1 /* Driver of optimization process
2 Copyright (C) 2003-2015 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:
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"
164 #include "hash-set.h"
165 #include "machmode.h"
167 #include "double-int.h"
171 #include "wide-int.h"
174 #include "fold-const.h"
176 #include "stor-layout.h"
177 #include "stringpool.h"
181 #include "hard-reg-set.h"
183 #include "function.h"
184 #include "basic-block.h"
185 #include "tree-ssa-alias.h"
186 #include "internal-fn.h"
187 #include "gimple-fold.h"
188 #include "gimple-expr.h"
191 #include "gimplify.h"
192 #include "gimple-iterator.h"
193 #include "gimplify-me.h"
194 #include "gimple-ssa.h"
195 #include "tree-cfg.h"
196 #include "tree-into-ssa.h"
197 #include "tree-ssa.h"
198 #include "tree-inline.h"
199 #include "langhooks.h"
204 #include "diagnostic.h"
207 #include "hash-map.h"
208 #include "plugin-api.h"
211 #include "alloc-pool.h"
212 #include "symbol-summary.h"
213 #include "ipa-prop.h"
214 #include "tree-iterator.h"
215 #include "tree-pass.h"
216 #include "tree-dump.h"
217 #include "gimple-pretty-print.h"
219 #include "coverage.h"
221 #include "ipa-inline.h"
222 #include "ipa-utils.h"
223 #include "lto-streamer.h"
226 #include "regset.h" /* FIXME: For reg_obstack. */
228 #include "pass_manager.h"
229 #include "tree-nested.h"
230 #include "gimplify.h"
232 #include "tree-chkp.h"
233 #include "lto-section-names.h"
235 #include "print-tree.h"
237 /* Queue of cgraph nodes scheduled to be added into cgraph. This is a
238 secondary queue used during optimization to accommodate passes that
239 may generate new functions that need to be optimized and expanded. */
240 vec
<cgraph_node
*> cgraph_new_nodes
;
242 static void expand_all_functions (void);
243 static void mark_functions_to_output (void);
244 static void handle_alias_pairs (void);
246 /* Used for vtable lookup in thunk adjusting. */
247 static GTY (()) tree vtable_entry_type
;
249 /* Determine if symbol declaration is needed. That is, visible to something
250 either outside this translation unit, something magic in the system
253 symtab_node::needed_p (void)
255 /* Double check that no one output the function into assembly file
257 gcc_checking_assert (!DECL_ASSEMBLER_NAME_SET_P (decl
)
258 || !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)));
263 if (DECL_EXTERNAL (decl
))
266 /* If the user told us it is used, then it must be so. */
270 /* ABI forced symbols are needed when they are external. */
271 if (forced_by_abi
&& TREE_PUBLIC (decl
))
274 /* Keep constructors, destructors and virtual functions. */
275 if (TREE_CODE (decl
) == FUNCTION_DECL
276 && (DECL_STATIC_CONSTRUCTOR (decl
) || DECL_STATIC_DESTRUCTOR (decl
)))
279 /* Externally visible variables must be output. The exception is
280 COMDAT variables that must be output only when they are needed. */
281 if (TREE_PUBLIC (decl
) && !DECL_COMDAT (decl
))
287 /* Head and terminator of the queue of nodes to be processed while building
290 static symtab_node symtab_terminator
;
291 static symtab_node
*queued_nodes
= &symtab_terminator
;
293 /* Add NODE to queue starting at QUEUED_NODES.
294 The queue is linked via AUX pointers and terminated by pointer to 1. */
297 enqueue_node (symtab_node
*node
)
301 gcc_checking_assert (queued_nodes
);
302 node
->aux
= queued_nodes
;
306 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
307 functions into callgraph in a way so they look like ordinary reachable
308 functions inserted into callgraph already at construction time. */
311 symbol_table::process_new_functions (void)
315 if (!cgraph_new_nodes
.exists ())
318 handle_alias_pairs ();
319 /* Note that this queue may grow as its being processed, as the new
320 functions may generate new ones. */
321 for (unsigned i
= 0; i
< cgraph_new_nodes
.length (); i
++)
323 cgraph_node
*node
= cgraph_new_nodes
[i
];
328 /* At construction time we just need to finalize function and move
329 it into reachable functions list. */
331 cgraph_node::finalize_function (fndecl
, false);
332 call_cgraph_insertion_hooks (node
);
338 case IPA_SSA_AFTER_INLINING
:
339 /* When IPA optimization already started, do all essential
340 transformations that has been already performed on the whole
341 cgraph but not on this function. */
343 gimple_register_cfg_hooks ();
346 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
347 if ((state
== IPA_SSA
|| state
== IPA_SSA_AFTER_INLINING
)
348 && !gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
349 g
->get_passes ()->execute_early_local_passes ();
350 else if (inline_summaries
!= NULL
)
351 compute_inline_parameters (node
, true);
352 free_dominance_info (CDI_POST_DOMINATORS
);
353 free_dominance_info (CDI_DOMINATORS
);
355 call_cgraph_insertion_hooks (node
);
359 /* Functions created during expansion shall be compiled
362 call_cgraph_insertion_hooks (node
);
372 cgraph_new_nodes
.release ();
375 /* As an GCC extension we allow redefinition of the function. The
376 semantics when both copies of bodies differ is not well defined.
377 We replace the old body with new body so in unit at a time mode
378 we always use new body, while in normal mode we may end up with
379 old body inlined into some functions and new body expanded and
382 ??? It may make more sense to use one body for inlining and other
383 body for expanding the function but this is difficult to do. */
386 cgraph_node::reset (void)
388 /* If process is set, then we have already begun whole-unit analysis.
389 This is *not* testing for whether we've already emitted the function.
390 That case can be sort-of legitimately seen with real function redefinition
391 errors. I would argue that the front end should never present us with
392 such a case, but don't enforce that for now. */
393 gcc_assert (!process
);
395 /* Reset our data structures so we can analyze the function again. */
396 memset (&local
, 0, sizeof (local
));
397 memset (&global
, 0, sizeof (global
));
398 memset (&rtl
, 0, sizeof (rtl
));
403 cpp_implicit_alias
= false;
406 remove_all_references ();
409 /* Return true when there are references to the node. */
412 symtab_node::referred_to_p (void)
416 /* See if there are any references at all. */
417 if (iterate_referring (0, ref
))
419 /* For functions check also calls. */
420 cgraph_node
*cn
= dyn_cast
<cgraph_node
*> (this);
421 if (cn
&& cn
->callers
)
426 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
427 logic in effect. If NO_COLLECT is true, then our caller cannot stand to have
428 the garbage collector run at the moment. We would need to either create
429 a new GC context, or just not compile right now. */
432 cgraph_node::finalize_function (tree decl
, bool no_collect
)
434 cgraph_node
*node
= cgraph_node::get_create (decl
);
436 if (node
->definition
)
438 /* Nested functions should only be defined once. */
439 gcc_assert (!DECL_CONTEXT (decl
)
440 || TREE_CODE (DECL_CONTEXT (decl
)) != FUNCTION_DECL
);
442 node
->local
.redefined_extern_inline
= true;
445 notice_global_symbol (decl
);
446 node
->definition
= true;
447 node
->lowered
= DECL_STRUCT_FUNCTION (decl
)->cfg
!= NULL
;
449 /* With -fkeep-inline-functions we are keeping all inline functions except
450 for extern inline ones. */
451 if (flag_keep_inline_functions
452 && DECL_DECLARED_INLINE_P (decl
)
453 && !DECL_EXTERNAL (decl
)
454 && !DECL_DISREGARD_INLINE_LIMITS (decl
))
455 node
->force_output
= 1;
457 /* When not optimizing, also output the static functions. (see
458 PR24561), but don't do so for always_inline functions, functions
459 declared inline and nested functions. These were optimized out
460 in the original implementation and it is unclear whether we want
461 to change the behavior here. */
462 if ((!opt_for_fn (decl
, optimize
)
463 && !node
->cpp_implicit_alias
464 && !DECL_DISREGARD_INLINE_LIMITS (decl
)
465 && !DECL_DECLARED_INLINE_P (decl
)
466 && !(DECL_CONTEXT (decl
)
467 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
))
468 && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
))
469 node
->force_output
= 1;
471 /* If we've not yet emitted decl, tell the debug info about it. */
472 if (!TREE_ASM_WRITTEN (decl
))
473 (*debug_hooks
->deferred_inline_function
) (decl
);
475 /* Possibly warn about unused parameters. */
476 if (warn_unused_parameter
)
477 do_warn_unused_parameter (decl
);
482 if (symtab
->state
== CONSTRUCTION
483 && (node
->needed_p () || node
->referred_to_p ()))
487 /* Add the function FNDECL to the call graph.
488 Unlike finalize_function, this function is intended to be used
489 by middle end and allows insertion of new function at arbitrary point
490 of compilation. The function can be either in high, low or SSA form
493 The function is assumed to be reachable and have address taken (so no
494 API breaking optimizations are performed on it).
496 Main work done by this function is to enqueue the function for later
497 processing to avoid need the passes to be re-entrant. */
500 cgraph_node::add_new_function (tree fndecl
, bool lowered
)
502 gcc::pass_manager
*passes
= g
->get_passes ();
504 switch (symtab
->state
)
507 cgraph_node::finalize_function (fndecl
, false);
510 /* Just enqueue function to be processed at nearest occurrence. */
511 node
= cgraph_node::get_create (fndecl
);
513 node
->lowered
= true;
514 cgraph_new_nodes
.safe_push (node
);
519 case IPA_SSA_AFTER_INLINING
:
521 /* Bring the function into finalized state and enqueue for later
522 analyzing and compilation. */
523 node
= cgraph_node::get_create (fndecl
);
524 node
->local
.local
= false;
525 node
->definition
= true;
526 node
->force_output
= true;
527 if (!lowered
&& symtab
->state
== EXPANSION
)
529 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
530 gimple_register_cfg_hooks ();
531 bitmap_obstack_initialize (NULL
);
532 execute_pass_list (cfun
, passes
->all_lowering_passes
);
533 passes
->execute_early_local_passes ();
534 bitmap_obstack_release (NULL
);
540 node
->lowered
= true;
541 cgraph_new_nodes
.safe_push (node
);
545 /* At the very end of compilation we have to do all the work up
547 node
= cgraph_node::create (fndecl
);
549 node
->lowered
= true;
550 node
->definition
= true;
552 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
553 gimple_register_cfg_hooks ();
554 bitmap_obstack_initialize (NULL
);
555 if (!gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
556 g
->get_passes ()->execute_early_local_passes ();
557 bitmap_obstack_release (NULL
);
566 /* Set a personality if required and we already passed EH lowering. */
568 && (function_needs_eh_personality (DECL_STRUCT_FUNCTION (fndecl
))
569 == eh_personality_lang
))
570 DECL_FUNCTION_PERSONALITY (fndecl
) = lang_hooks
.eh_personality ();
573 /* Analyze the function scheduled to be output. */
575 cgraph_node::analyze (void)
577 tree decl
= this->decl
;
578 location_t saved_loc
= input_location
;
579 input_location
= DECL_SOURCE_LOCATION (decl
);
583 create_edge (cgraph_node::get (thunk
.alias
),
584 NULL
, 0, CGRAPH_FREQ_BASE
);
585 if (!expand_thunk (false, false))
593 resolve_alias (cgraph_node::get (alias_target
));
594 else if (dispatcher_function
)
596 /* Generate the dispatcher body of multi-versioned functions. */
597 cgraph_function_version_info
*dispatcher_version_info
598 = function_version ();
599 if (dispatcher_version_info
!= NULL
600 && (dispatcher_version_info
->dispatcher_resolver
603 tree resolver
= NULL_TREE
;
604 gcc_assert (targetm
.generate_version_dispatcher_body
);
605 resolver
= targetm
.generate_version_dispatcher_body (this);
606 gcc_assert (resolver
!= NULL_TREE
);
611 push_cfun (DECL_STRUCT_FUNCTION (decl
));
613 assign_assembler_name_if_neeeded (decl
);
615 /* Make sure to gimplify bodies only once. During analyzing a
616 function we lower it, which will require gimplified nested
617 functions, so we can end up here with an already gimplified
619 if (!gimple_has_body_p (decl
))
620 gimplify_function_tree (decl
);
621 dump_function (TDI_generic
, decl
);
623 /* Lower the function. */
627 lower_nested_functions (decl
);
628 gcc_assert (!nested
);
630 gimple_register_cfg_hooks ();
631 bitmap_obstack_initialize (NULL
);
632 execute_pass_list (cfun
, g
->get_passes ()->all_lowering_passes
);
633 free_dominance_info (CDI_POST_DOMINATORS
);
634 free_dominance_info (CDI_DOMINATORS
);
636 bitmap_obstack_release (NULL
);
644 input_location
= saved_loc
;
647 /* C++ frontend produce same body aliases all over the place, even before PCH
648 gets streamed out. It relies on us linking the aliases with their function
649 in order to do the fixups, but ipa-ref is not PCH safe. Consequentely we
650 first produce aliases without links, but once C++ FE is sure he won't sream
651 PCH we build the links via this function. */
654 symbol_table::process_same_body_aliases (void)
657 FOR_EACH_SYMBOL (node
)
658 if (node
->cpp_implicit_alias
&& !node
->analyzed
)
660 (TREE_CODE (node
->alias_target
) == VAR_DECL
661 ? (symtab_node
*)varpool_node::get_create (node
->alias_target
)
662 : (symtab_node
*)cgraph_node::get_create (node
->alias_target
));
663 cpp_implicit_aliases_done
= true;
666 /* Process attributes common for vars and functions. */
669 process_common_attributes (symtab_node
*node
, tree decl
)
671 tree weakref
= lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
));
673 if (weakref
&& !lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)))
675 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wattributes
,
676 "%<weakref%> attribute should be accompanied with"
677 " an %<alias%> attribute");
678 DECL_WEAK (decl
) = 0;
679 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
680 DECL_ATTRIBUTES (decl
));
683 if (lookup_attribute ("no_reorder", DECL_ATTRIBUTES (decl
)))
684 node
->no_reorder
= 1;
687 /* Look for externally_visible and used attributes and mark cgraph nodes
690 We cannot mark the nodes at the point the attributes are processed (in
691 handle_*_attribute) because the copy of the declarations available at that
692 point may not be canonical. For example, in:
695 void f() __attribute__((used));
697 the declaration we see in handle_used_attribute will be the second
698 declaration -- but the front end will subsequently merge that declaration
699 with the original declaration and discard the second declaration.
701 Furthermore, we can't mark these nodes in finalize_function because:
704 void f() __attribute__((externally_visible));
708 So, we walk the nodes at the end of the translation unit, applying the
709 attributes at that point. */
712 process_function_and_variable_attributes (cgraph_node
*first
,
713 varpool_node
*first_var
)
718 for (node
= symtab
->first_function (); node
!= first
;
719 node
= symtab
->next_function (node
))
721 tree decl
= node
->decl
;
722 if (DECL_PRESERVE_P (decl
))
723 node
->mark_force_output ();
724 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
726 if (! TREE_PUBLIC (node
->decl
))
727 warning_at (DECL_SOURCE_LOCATION (node
->decl
), OPT_Wattributes
,
728 "%<externally_visible%>"
729 " attribute have effect only on public objects");
731 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
732 && (node
->definition
&& !node
->alias
))
734 warning_at (DECL_SOURCE_LOCATION (node
->decl
), OPT_Wattributes
,
735 "%<weakref%> attribute ignored"
736 " because function is defined");
737 DECL_WEAK (decl
) = 0;
738 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
739 DECL_ATTRIBUTES (decl
));
742 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (decl
))
743 && !DECL_DECLARED_INLINE_P (decl
)
744 /* redefining extern inline function makes it DECL_UNINLINABLE. */
745 && !DECL_UNINLINABLE (decl
))
746 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wattributes
,
747 "always_inline function might not be inlinable");
749 process_common_attributes (node
, decl
);
751 for (vnode
= symtab
->first_variable (); vnode
!= first_var
;
752 vnode
= symtab
->next_variable (vnode
))
754 tree decl
= vnode
->decl
;
755 if (DECL_EXTERNAL (decl
)
756 && DECL_INITIAL (decl
))
757 varpool_node::finalize_decl (decl
);
758 if (DECL_PRESERVE_P (decl
))
759 vnode
->force_output
= true;
760 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
762 if (! TREE_PUBLIC (vnode
->decl
))
763 warning_at (DECL_SOURCE_LOCATION (vnode
->decl
), OPT_Wattributes
,
764 "%<externally_visible%>"
765 " attribute have effect only on public objects");
767 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
769 && DECL_INITIAL (decl
))
771 warning_at (DECL_SOURCE_LOCATION (vnode
->decl
), OPT_Wattributes
,
772 "%<weakref%> attribute ignored"
773 " because variable is initialized");
774 DECL_WEAK (decl
) = 0;
775 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
776 DECL_ATTRIBUTES (decl
));
778 process_common_attributes (vnode
, decl
);
782 /* Mark DECL as finalized. By finalizing the declaration, frontend instruct the
783 middle end to output the variable to asm file, if needed or externally
787 varpool_node::finalize_decl (tree decl
)
789 varpool_node
*node
= varpool_node::get_create (decl
);
791 gcc_assert (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
));
793 if (node
->definition
)
795 notice_global_symbol (decl
);
796 node
->definition
= true;
797 if (TREE_THIS_VOLATILE (decl
) || DECL_PRESERVE_P (decl
)
798 /* Traditionally we do not eliminate static variables when not
799 optimizing and when not doing toplevel reoder. */
801 || ((!flag_toplevel_reorder
802 && !DECL_COMDAT (node
->decl
)
803 && !DECL_ARTIFICIAL (node
->decl
))))
804 node
->force_output
= true;
806 if (symtab
->state
== CONSTRUCTION
807 && (node
->needed_p () || node
->referred_to_p ()))
809 if (symtab
->state
>= IPA_SSA
)
811 /* Some frontends produce various interface variables after compilation
813 if (symtab
->state
== FINISHED
814 || (!flag_toplevel_reorder
815 && symtab
->state
== EXPANSION
))
816 node
->assemble_decl ();
818 if (DECL_INITIAL (decl
))
819 chkp_register_var_initializer (decl
);
822 /* EDGE is an polymorphic call. Mark all possible targets as reachable
823 and if there is only one target, perform trivial devirtualization.
824 REACHABLE_CALL_TARGETS collects target lists we already walked to
825 avoid udplicate work. */
828 walk_polymorphic_call_targets (hash_set
<void *> *reachable_call_targets
,
834 vec
<cgraph_node
*>targets
835 = possible_polymorphic_call_targets
836 (edge
, &final
, &cache_token
);
838 if (!reachable_call_targets
->add (cache_token
))
840 if (symtab
->dump_file
)
841 dump_possible_polymorphic_call_targets
842 (symtab
->dump_file
, edge
);
844 for (i
= 0; i
< targets
.length (); i
++)
846 /* Do not bother to mark virtual methods in anonymous namespace;
847 either we will find use of virtual table defining it, or it is
849 if (targets
[i
]->definition
851 (TREE_TYPE (targets
[i
]->decl
))
853 && !type_in_anonymous_namespace_p
855 (TREE_TYPE (targets
[i
]->decl
))))
856 enqueue_node (targets
[i
]);
860 /* Very trivial devirtualization; when the type is
861 final or anonymous (so we know all its derivation)
862 and there is only one possible virtual call target,
863 make the edge direct. */
866 if (targets
.length () <= 1 && dbg_cnt (devirt
))
869 if (targets
.length () == 1)
872 target
= cgraph_node::create
873 (builtin_decl_implicit (BUILT_IN_UNREACHABLE
));
875 if (symtab
->dump_file
)
877 fprintf (symtab
->dump_file
,
878 "Devirtualizing call: ");
879 print_gimple_stmt (symtab
->dump_file
,
883 if (dump_enabled_p ())
885 location_t locus
= gimple_location_safe (edge
->call_stmt
);
886 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, locus
,
887 "devirtualizing call in %s to %s\n",
888 edge
->caller
->name (), target
->name ());
891 edge
->make_direct (target
);
892 edge
->redirect_call_stmt_to_callee ();
894 /* Call to __builtin_unreachable shouldn't be instrumented. */
895 if (!targets
.length ())
896 gimple_call_set_with_bounds (edge
->call_stmt
, false);
898 if (symtab
->dump_file
)
900 fprintf (symtab
->dump_file
,
901 "Devirtualized as: ");
902 print_gimple_stmt (symtab
->dump_file
,
911 /* Discover all functions and variables that are trivially needed, analyze
912 them as well as all functions and variables referred by them */
913 static cgraph_node
*first_analyzed
;
914 static varpool_node
*first_analyzed_var
;
917 analyze_functions (void)
919 /* Keep track of already processed nodes when called multiple times for
920 intermodule optimization. */
921 cgraph_node
*first_handled
= first_analyzed
;
922 varpool_node
*first_handled_var
= first_analyzed_var
;
923 hash_set
<void *> reachable_call_targets
;
930 location_t saved_loc
= input_location
;
932 bitmap_obstack_initialize (NULL
);
933 symtab
->state
= CONSTRUCTION
;
934 input_location
= UNKNOWN_LOCATION
;
936 /* Ugly, but the fixup can not happen at a time same body alias is created;
937 C++ FE is confused about the COMDAT groups being right. */
938 if (symtab
->cpp_implicit_aliases_done
)
939 FOR_EACH_SYMBOL (node
)
940 if (node
->cpp_implicit_alias
)
941 node
->fixup_same_cpp_alias_visibility (node
->get_alias_target ());
942 build_type_inheritance_graph ();
944 /* Analysis adds static variables that in turn adds references to new functions.
945 So we need to iterate the process until it stabilize. */
949 process_function_and_variable_attributes (first_analyzed
,
952 /* First identify the trivially needed symbols. */
953 for (node
= symtab
->first_symbol ();
954 node
!= first_analyzed
955 && node
!= first_analyzed_var
; node
= node
->next
)
957 /* Convert COMDAT group designators to IDENTIFIER_NODEs. */
958 node
->get_comdat_group_id ();
959 if (node
->needed_p ())
962 if (!changed
&& symtab
->dump_file
)
963 fprintf (symtab
->dump_file
, "Trivially needed symbols:");
965 if (symtab
->dump_file
)
966 fprintf (symtab
->dump_file
, " %s", node
->asm_name ());
967 if (!changed
&& symtab
->dump_file
)
968 fprintf (symtab
->dump_file
, "\n");
970 if (node
== first_analyzed
971 || node
== first_analyzed_var
)
974 symtab
->process_new_functions ();
975 first_analyzed_var
= symtab
->first_variable ();
976 first_analyzed
= symtab
->first_function ();
978 if (changed
&& symtab
->dump_file
)
979 fprintf (symtab
->dump_file
, "\n");
981 /* Lower representation, build callgraph edges and references for all trivially
982 needed symbols and all symbols referred by them. */
983 while (queued_nodes
!= &symtab_terminator
)
987 queued_nodes
= (symtab_node
*)queued_nodes
->aux
;
988 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
);
989 if (cnode
&& cnode
->definition
)
992 tree decl
= cnode
->decl
;
994 /* ??? It is possible to create extern inline function
995 and later using weak alias attribute to kill its body.
996 See gcc.c-torture/compile/20011119-1.c */
997 if (!DECL_STRUCT_FUNCTION (decl
)
999 && !cnode
->thunk
.thunk_p
1000 && !cnode
->dispatcher_function
)
1003 cnode
->local
.redefined_extern_inline
= true;
1007 if (!cnode
->analyzed
)
1010 for (edge
= cnode
->callees
; edge
; edge
= edge
->next_callee
)
1011 if (edge
->callee
->definition
1012 && (!DECL_EXTERNAL (edge
->callee
->decl
)
1013 /* When not optimizing, do not try to analyze extern
1014 inline functions. Doing so is pointless. */
1015 || opt_for_fn (edge
->callee
->decl
, optimize
)
1016 /* Weakrefs needs to be preserved. */
1017 || edge
->callee
->alias
1018 /* always_inline functions are inlined aven at -O0. */
1021 DECL_ATTRIBUTES (edge
->callee
->decl
))
1022 /* Multiversioned functions needs the dispatcher to
1023 be produced locally even for extern functions. */
1024 || edge
->callee
->function_version ()))
1025 enqueue_node (edge
->callee
);
1026 if (opt_for_fn (cnode
->decl
, optimize
)
1027 && opt_for_fn (cnode
->decl
, flag_devirtualize
))
1031 for (edge
= cnode
->indirect_calls
; edge
; edge
= next
)
1033 next
= edge
->next_callee
;
1034 if (edge
->indirect_info
->polymorphic
)
1035 walk_polymorphic_call_targets (&reachable_call_targets
,
1040 /* If decl is a clone of an abstract function,
1041 mark that abstract function so that we don't release its body.
1042 The DECL_INITIAL() of that abstract function declaration
1043 will be later needed to output debug info. */
1044 if (DECL_ABSTRACT_ORIGIN (decl
))
1046 cgraph_node
*origin_node
1047 = cgraph_node::get_create (DECL_ABSTRACT_ORIGIN (decl
));
1048 origin_node
->used_as_abstract_origin
= true;
1053 varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
);
1054 if (vnode
&& vnode
->definition
&& !vnode
->analyzed
)
1058 if (node
->same_comdat_group
)
1061 for (next
= node
->same_comdat_group
;
1063 next
= next
->same_comdat_group
)
1064 if (!next
->comdat_local_p ())
1065 enqueue_node (next
);
1067 for (i
= 0; node
->iterate_reference (i
, ref
); i
++)
1068 if (ref
->referred
->definition
1069 && (!DECL_EXTERNAL (ref
->referred
->decl
)
1070 || ((TREE_CODE (ref
->referred
->decl
) != FUNCTION_DECL
1072 || (TREE_CODE (ref
->referred
->decl
) == FUNCTION_DECL
1073 && opt_for_fn (ref
->referred
->decl
, optimize
))
1075 || ref
->referred
->alias
)))
1076 enqueue_node (ref
->referred
);
1077 symtab
->process_new_functions ();
1080 update_type_inheritance_graph ();
1082 /* Collect entry points to the unit. */
1083 if (symtab
->dump_file
)
1085 fprintf (symtab
->dump_file
, "\n\nInitial ");
1086 symtab_node::dump_table (symtab
->dump_file
);
1089 if (symtab
->dump_file
)
1090 fprintf (symtab
->dump_file
, "\nRemoving unused symbols:");
1092 for (node
= symtab
->first_symbol ();
1093 node
!= first_handled
1094 && node
!= first_handled_var
; node
= next
)
1097 if (!node
->aux
&& !node
->referred_to_p ())
1099 if (symtab
->dump_file
)
1100 fprintf (symtab
->dump_file
, " %s", node
->name ());
1104 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
))
1106 tree decl
= node
->decl
;
1108 if (cnode
->definition
&& !gimple_has_body_p (decl
)
1110 && !cnode
->thunk
.thunk_p
)
1113 gcc_assert (!cnode
->definition
|| cnode
->thunk
.thunk_p
1115 || gimple_has_body_p (decl
));
1116 gcc_assert (cnode
->analyzed
== cnode
->definition
);
1120 for (;node
; node
= node
->next
)
1122 first_analyzed
= symtab
->first_function ();
1123 first_analyzed_var
= symtab
->first_variable ();
1124 if (symtab
->dump_file
)
1126 fprintf (symtab
->dump_file
, "\n\nReclaimed ");
1127 symtab_node::dump_table (symtab
->dump_file
);
1129 bitmap_obstack_release (NULL
);
1131 /* Initialize assembler name hash, in particular we want to trigger C++
1132 mangling and same body alias creation before we free DECL_ARGUMENTS
1135 symtab
->symtab_initialize_asm_name_hash ();
1137 input_location
= saved_loc
;
1140 /* Translate the ugly representation of aliases as alias pairs into nice
1141 representation in callgraph. We don't handle all cases yet,
1145 handle_alias_pairs (void)
1150 for (i
= 0; alias_pairs
&& alias_pairs
->iterate (i
, &p
);)
1152 symtab_node
*target_node
= symtab_node::get_for_asmname (p
->target
);
1154 /* Weakrefs with target not defined in current unit are easy to handle:
1155 they behave just as external variables except we need to note the
1156 alias flag to later output the weakref pseudo op into asm file. */
1158 && lookup_attribute ("weakref", DECL_ATTRIBUTES (p
->decl
)) != NULL
)
1160 symtab_node
*node
= symtab_node::get (p
->decl
);
1163 node
->alias_target
= p
->target
;
1164 node
->weakref
= true;
1167 alias_pairs
->unordered_remove (i
);
1170 else if (!target_node
)
1172 error ("%q+D aliased to undefined symbol %qE", p
->decl
, p
->target
);
1173 symtab_node
*node
= symtab_node::get (p
->decl
);
1175 node
->alias
= false;
1176 alias_pairs
->unordered_remove (i
);
1180 if (DECL_EXTERNAL (target_node
->decl
)
1181 /* We use local aliases for C++ thunks to force the tailcall
1182 to bind locally. This is a hack - to keep it working do
1183 the following (which is not strictly correct). */
1184 && (TREE_CODE (target_node
->decl
) != FUNCTION_DECL
1185 || ! DECL_VIRTUAL_P (target_node
->decl
))
1186 && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (p
->decl
)))
1188 error ("%q+D aliased to external symbol %qE",
1189 p
->decl
, p
->target
);
1192 if (TREE_CODE (p
->decl
) == FUNCTION_DECL
1193 && target_node
&& is_a
<cgraph_node
*> (target_node
))
1195 cgraph_node
*src_node
= cgraph_node::get (p
->decl
);
1196 if (src_node
&& src_node
->definition
)
1198 cgraph_node::create_alias (p
->decl
, target_node
->decl
);
1199 alias_pairs
->unordered_remove (i
);
1201 else if (TREE_CODE (p
->decl
) == VAR_DECL
1202 && target_node
&& is_a
<varpool_node
*> (target_node
))
1204 varpool_node::create_alias (p
->decl
, target_node
->decl
);
1205 alias_pairs
->unordered_remove (i
);
1209 error ("%q+D alias in between function and variable is not supported",
1211 warning (0, "%q+D aliased declaration",
1213 alias_pairs
->unordered_remove (i
);
1216 vec_free (alias_pairs
);
1220 /* Figure out what functions we want to assemble. */
1223 mark_functions_to_output (void)
1226 #ifdef ENABLE_CHECKING
1227 bool check_same_comdat_groups
= false;
1229 FOR_EACH_FUNCTION (node
)
1230 gcc_assert (!node
->process
);
1233 FOR_EACH_FUNCTION (node
)
1235 tree decl
= node
->decl
;
1237 gcc_assert (!node
->process
|| node
->same_comdat_group
);
1241 /* We need to output all local functions that are used and not
1242 always inlined, as well as those that are reachable from
1243 outside the current compilation unit. */
1245 && !node
->thunk
.thunk_p
1247 && !node
->global
.inlined_to
1248 && !TREE_ASM_WRITTEN (decl
)
1249 && !DECL_EXTERNAL (decl
))
1252 if (node
->same_comdat_group
)
1255 for (next
= dyn_cast
<cgraph_node
*> (node
->same_comdat_group
);
1257 next
= dyn_cast
<cgraph_node
*> (next
->same_comdat_group
))
1258 if (!next
->thunk
.thunk_p
&& !next
->alias
1259 && !next
->comdat_local_p ())
1263 else if (node
->same_comdat_group
)
1265 #ifdef ENABLE_CHECKING
1266 check_same_comdat_groups
= true;
1271 /* We should've reclaimed all functions that are not needed. */
1272 #ifdef ENABLE_CHECKING
1273 if (!node
->global
.inlined_to
1274 && gimple_has_body_p (decl
)
1275 /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
1276 are inside partition, we can end up not removing the body since we no longer
1277 have analyzed node pointing to it. */
1278 && !node
->in_other_partition
1281 && !DECL_EXTERNAL (decl
))
1284 internal_error ("failed to reclaim unneeded function");
1287 gcc_assert (node
->global
.inlined_to
1288 || !gimple_has_body_p (decl
)
1289 || node
->in_other_partition
1291 || DECL_ARTIFICIAL (decl
)
1292 || DECL_EXTERNAL (decl
));
1297 #ifdef ENABLE_CHECKING
1298 if (check_same_comdat_groups
)
1299 FOR_EACH_FUNCTION (node
)
1300 if (node
->same_comdat_group
&& !node
->process
)
1302 tree decl
= node
->decl
;
1303 if (!node
->global
.inlined_to
1304 && gimple_has_body_p (decl
)
1305 /* FIXME: in an ltrans unit when the offline copy is outside a
1306 partition but inline copies are inside a partition, we can
1307 end up not removing the body since we no longer have an
1308 analyzed node pointing to it. */
1309 && !node
->in_other_partition
1311 && !DECL_EXTERNAL (decl
))
1314 internal_error ("failed to reclaim unneeded function in same "
1321 /* DECL is FUNCTION_DECL. Initialize datastructures so DECL is a function
1322 in lowered gimple form. IN_SSA is true if the gimple is in SSA.
1324 Set current_function_decl and cfun to newly constructed empty function body.
1325 return basic block in the function body. */
1328 init_lowered_empty_function (tree decl
, bool in_ssa
, gcov_type count
)
1333 current_function_decl
= decl
;
1334 allocate_struct_function (decl
, false);
1335 gimple_register_cfg_hooks ();
1336 init_empty_tree_cfg ();
1340 init_tree_ssa (cfun
);
1341 init_ssa_operands (cfun
);
1342 cfun
->gimple_df
->in_ssa_p
= true;
1343 cfun
->curr_properties
|= PROP_ssa
;
1346 DECL_INITIAL (decl
) = make_node (BLOCK
);
1348 DECL_SAVED_TREE (decl
) = error_mark_node
;
1349 cfun
->curr_properties
|= (PROP_gimple_lcf
| PROP_gimple_leh
| PROP_gimple_any
1350 | PROP_cfg
| PROP_loops
);
1352 set_loops_for_fn (cfun
, ggc_cleared_alloc
<loops
> ());
1353 init_loops_structure (cfun
, loops_for_fn (cfun
), 1);
1354 loops_for_fn (cfun
)->state
|= LOOPS_MAY_HAVE_MULTIPLE_LATCHES
;
1356 /* Create BB for body of the function and connect it properly. */
1357 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
= count
;
1358 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
= REG_BR_PROB_BASE
;
1359 EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
= count
;
1360 EXIT_BLOCK_PTR_FOR_FN (cfun
)->frequency
= REG_BR_PROB_BASE
;
1361 bb
= create_basic_block (NULL
, (void *) 0, ENTRY_BLOCK_PTR_FOR_FN (cfun
));
1363 bb
->frequency
= BB_FREQ_MAX
;
1364 e
= make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
), bb
, EDGE_FALLTHRU
);
1366 e
->probability
= REG_BR_PROB_BASE
;
1367 e
= make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
1369 e
->probability
= REG_BR_PROB_BASE
;
1370 add_bb_to_loop (bb
, ENTRY_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
1375 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
1376 offset indicated by VIRTUAL_OFFSET, if that is
1377 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
1378 zero for a result adjusting thunk. */
1381 thunk_adjust (gimple_stmt_iterator
* bsi
,
1382 tree ptr
, bool this_adjusting
,
1383 HOST_WIDE_INT fixed_offset
, tree virtual_offset
)
1389 && fixed_offset
!= 0)
1391 stmt
= gimple_build_assign
1392 (ptr
, fold_build_pointer_plus_hwi_loc (input_location
,
1395 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1398 /* If there's a virtual offset, look up that value in the vtable and
1399 adjust the pointer again. */
1406 if (!vtable_entry_type
)
1408 tree vfunc_type
= make_node (FUNCTION_TYPE
);
1409 TREE_TYPE (vfunc_type
) = integer_type_node
;
1410 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
1411 layout_type (vfunc_type
);
1413 vtable_entry_type
= build_pointer_type (vfunc_type
);
1417 create_tmp_reg (build_pointer_type
1418 (build_pointer_type (vtable_entry_type
)), "vptr");
1420 /* The vptr is always at offset zero in the object. */
1421 stmt
= gimple_build_assign (vtabletmp
,
1422 build1 (NOP_EXPR
, TREE_TYPE (vtabletmp
),
1424 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1426 /* Form the vtable address. */
1427 vtabletmp2
= create_tmp_reg (TREE_TYPE (TREE_TYPE (vtabletmp
)),
1429 stmt
= gimple_build_assign (vtabletmp2
,
1430 build_simple_mem_ref (vtabletmp
));
1431 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1433 /* Find the entry with the vcall offset. */
1434 stmt
= gimple_build_assign (vtabletmp2
,
1435 fold_build_pointer_plus_loc (input_location
,
1438 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1440 /* Get the offset itself. */
1441 vtabletmp3
= create_tmp_reg (TREE_TYPE (TREE_TYPE (vtabletmp2
)),
1443 stmt
= gimple_build_assign (vtabletmp3
,
1444 build_simple_mem_ref (vtabletmp2
));
1445 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1447 /* Adjust the `this' pointer. */
1448 ptr
= fold_build_pointer_plus_loc (input_location
, ptr
, vtabletmp3
);
1449 ptr
= force_gimple_operand_gsi (bsi
, ptr
, true, NULL_TREE
, false,
1450 GSI_CONTINUE_LINKING
);
1454 && fixed_offset
!= 0)
1455 /* Adjust the pointer by the constant. */
1459 if (TREE_CODE (ptr
) == VAR_DECL
)
1463 ptrtmp
= create_tmp_reg (TREE_TYPE (ptr
), "ptr");
1464 stmt
= gimple_build_assign (ptrtmp
, ptr
);
1465 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1467 ptr
= fold_build_pointer_plus_hwi_loc (input_location
,
1468 ptrtmp
, fixed_offset
);
1471 /* Emit the statement and gimplify the adjustment expression. */
1472 ret
= create_tmp_reg (TREE_TYPE (ptr
), "adjusted_this");
1473 stmt
= gimple_build_assign (ret
, ptr
);
1474 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1479 /* Expand thunk NODE to gimple if possible.
1480 When FORCE_GIMPLE_THUNK is true, gimple thunk is created and
1481 no assembler is produced.
1482 When OUTPUT_ASM_THUNK is true, also produce assembler for
1483 thunks that are not lowered. */
1486 cgraph_node::expand_thunk (bool output_asm_thunks
, bool force_gimple_thunk
)
1488 bool this_adjusting
= thunk
.this_adjusting
;
1489 HOST_WIDE_INT fixed_offset
= thunk
.fixed_offset
;
1490 HOST_WIDE_INT virtual_value
= thunk
.virtual_value
;
1491 tree virtual_offset
= NULL
;
1492 tree alias
= callees
->callee
->decl
;
1493 tree thunk_fndecl
= decl
;
1497 if (!force_gimple_thunk
&& this_adjusting
1498 && targetm
.asm_out
.can_output_mi_thunk (thunk_fndecl
, fixed_offset
,
1499 virtual_value
, alias
))
1503 tree restype
= TREE_TYPE (TREE_TYPE (thunk_fndecl
));
1505 if (!output_asm_thunks
)
1512 get_untransformed_body ();
1513 a
= DECL_ARGUMENTS (thunk_fndecl
);
1515 current_function_decl
= thunk_fndecl
;
1517 /* Ensure thunks are emitted in their correct sections. */
1518 resolve_unique_section (thunk_fndecl
, 0, flag_function_sections
);
1520 DECL_RESULT (thunk_fndecl
)
1521 = build_decl (DECL_SOURCE_LOCATION (thunk_fndecl
),
1522 RESULT_DECL
, 0, restype
);
1523 DECL_CONTEXT (DECL_RESULT (thunk_fndecl
)) = thunk_fndecl
;
1524 fnname
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk_fndecl
));
1526 /* The back end expects DECL_INITIAL to contain a BLOCK, so we
1528 fn_block
= make_node (BLOCK
);
1529 BLOCK_VARS (fn_block
) = a
;
1530 DECL_INITIAL (thunk_fndecl
) = fn_block
;
1531 init_function_start (thunk_fndecl
);
1533 insn_locations_init ();
1534 set_curr_insn_location (DECL_SOURCE_LOCATION (thunk_fndecl
));
1535 prologue_location
= curr_insn_location ();
1536 assemble_start_function (thunk_fndecl
, fnname
);
1538 targetm
.asm_out
.output_mi_thunk (asm_out_file
, thunk_fndecl
,
1539 fixed_offset
, virtual_value
, alias
);
1541 assemble_end_function (thunk_fndecl
, fnname
);
1542 insn_locations_finalize ();
1543 init_insn_lengths ();
1544 free_after_compilation (cfun
);
1546 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
1547 thunk
.thunk_p
= false;
1553 basic_block bb
, then_bb
, else_bb
, return_bb
;
1554 gimple_stmt_iterator bsi
;
1565 get_untransformed_body ();
1566 a
= DECL_ARGUMENTS (thunk_fndecl
);
1568 current_function_decl
= thunk_fndecl
;
1570 /* Ensure thunks are emitted in their correct sections. */
1571 resolve_unique_section (thunk_fndecl
, 0, flag_function_sections
);
1573 DECL_IGNORED_P (thunk_fndecl
) = 1;
1574 bitmap_obstack_initialize (NULL
);
1576 if (thunk
.virtual_offset_p
)
1577 virtual_offset
= size_int (virtual_value
);
1579 /* Build the return declaration for the function. */
1580 restype
= TREE_TYPE (TREE_TYPE (thunk_fndecl
));
1581 if (DECL_RESULT (thunk_fndecl
) == NULL_TREE
)
1583 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
1584 DECL_ARTIFICIAL (resdecl
) = 1;
1585 DECL_IGNORED_P (resdecl
) = 1;
1586 DECL_RESULT (thunk_fndecl
) = resdecl
;
1587 DECL_CONTEXT (DECL_RESULT (thunk_fndecl
)) = thunk_fndecl
;
1590 resdecl
= DECL_RESULT (thunk_fndecl
);
1592 bb
= then_bb
= else_bb
= return_bb
1593 = init_lowered_empty_function (thunk_fndecl
, true, count
);
1595 bsi
= gsi_start_bb (bb
);
1597 /* Build call to the function being thunked. */
1598 if (!VOID_TYPE_P (restype
))
1600 if (DECL_BY_REFERENCE (resdecl
))
1602 restmp
= gimple_fold_indirect_ref (resdecl
);
1604 restmp
= build2 (MEM_REF
,
1605 TREE_TYPE (TREE_TYPE (DECL_RESULT (alias
))),
1607 build_int_cst (TREE_TYPE
1608 (DECL_RESULT (alias
)), 0));
1610 else if (!is_gimple_reg_type (restype
))
1612 if (aggregate_value_p (resdecl
, TREE_TYPE (thunk_fndecl
)))
1616 if (TREE_CODE (restmp
) == VAR_DECL
)
1617 add_local_decl (cfun
, restmp
);
1618 BLOCK_VARS (DECL_INITIAL (current_function_decl
)) = restmp
;
1621 restmp
= create_tmp_var (restype
, "retval");
1624 restmp
= create_tmp_reg (restype
, "retval");
1627 for (arg
= a
; arg
; arg
= DECL_CHAIN (arg
))
1629 auto_vec
<tree
> vargs (nargs
);
1634 vargs
.quick_push (thunk_adjust (&bsi
, a
, 1, fixed_offset
,
1636 arg
= DECL_CHAIN (a
);
1641 for (; i
< nargs
; i
++, arg
= DECL_CHAIN (arg
))
1644 if (!is_gimple_val (arg
))
1646 tmp
= create_tmp_reg (TYPE_MAIN_VARIANT
1647 (TREE_TYPE (arg
)), "arg");
1648 gimple stmt
= gimple_build_assign (tmp
, arg
);
1649 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1651 vargs
.quick_push (tmp
);
1653 call
= gimple_build_call_vec (build_fold_addr_expr_loc (0, alias
), vargs
);
1654 callees
->call_stmt
= call
;
1655 gimple_call_set_from_thunk (call
, true);
1656 gimple_call_set_with_bounds (call
, instrumentation_clone
);
1659 gimple_call_set_lhs (call
, restmp
);
1660 gcc_assert (useless_type_conversion_p (TREE_TYPE (restmp
),
1661 TREE_TYPE (TREE_TYPE (alias
))));
1663 gsi_insert_after (&bsi
, call
, GSI_NEW_STMT
);
1664 if (!(gimple_call_flags (call
) & ECF_NORETURN
))
1666 if (restmp
&& !this_adjusting
1667 && (fixed_offset
|| virtual_offset
))
1669 tree true_label
= NULL_TREE
;
1671 if (TREE_CODE (TREE_TYPE (restmp
)) == POINTER_TYPE
)
1675 /* If the return type is a pointer, we need to
1676 protect against NULL. We know there will be an
1677 adjustment, because that's why we're emitting a
1679 then_bb
= create_basic_block (NULL
, (void *) 0, bb
);
1680 then_bb
->count
= count
- count
/ 16;
1681 then_bb
->frequency
= BB_FREQ_MAX
- BB_FREQ_MAX
/ 16;
1682 return_bb
= create_basic_block (NULL
, (void *) 0, then_bb
);
1683 return_bb
->count
= count
;
1684 return_bb
->frequency
= BB_FREQ_MAX
;
1685 else_bb
= create_basic_block (NULL
, (void *) 0, else_bb
);
1686 then_bb
->count
= count
/ 16;
1687 then_bb
->frequency
= BB_FREQ_MAX
/ 16;
1688 add_bb_to_loop (then_bb
, bb
->loop_father
);
1689 add_bb_to_loop (return_bb
, bb
->loop_father
);
1690 add_bb_to_loop (else_bb
, bb
->loop_father
);
1691 remove_edge (single_succ_edge (bb
));
1692 true_label
= gimple_block_label (then_bb
);
1693 stmt
= gimple_build_cond (NE_EXPR
, restmp
,
1694 build_zero_cst (TREE_TYPE (restmp
)),
1695 NULL_TREE
, NULL_TREE
);
1696 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1697 e
= make_edge (bb
, then_bb
, EDGE_TRUE_VALUE
);
1698 e
->probability
= REG_BR_PROB_BASE
- REG_BR_PROB_BASE
/ 16;
1699 e
->count
= count
- count
/ 16;
1700 e
= make_edge (bb
, else_bb
, EDGE_FALSE_VALUE
);
1701 e
->probability
= REG_BR_PROB_BASE
/ 16;
1702 e
->count
= count
/ 16;
1703 e
= make_edge (return_bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
1704 e
->probability
= REG_BR_PROB_BASE
;
1706 e
= make_edge (then_bb
, return_bb
, EDGE_FALLTHRU
);
1707 e
->probability
= REG_BR_PROB_BASE
;
1708 e
->count
= count
- count
/ 16;
1709 e
= make_edge (else_bb
, return_bb
, EDGE_FALLTHRU
);
1710 e
->probability
= REG_BR_PROB_BASE
;
1711 e
->count
= count
/ 16;
1712 bsi
= gsi_last_bb (then_bb
);
1715 restmp
= thunk_adjust (&bsi
, restmp
, /*this_adjusting=*/0,
1716 fixed_offset
, virtual_offset
);
1720 bsi
= gsi_last_bb (else_bb
);
1721 stmt
= gimple_build_assign (restmp
,
1722 build_zero_cst (TREE_TYPE (restmp
)));
1723 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1724 bsi
= gsi_last_bb (return_bb
);
1728 gimple_call_set_tail (call
, true);
1730 /* Build return value. */
1731 if (!DECL_BY_REFERENCE (resdecl
))
1732 ret
= gimple_build_return (restmp
);
1734 ret
= gimple_build_return (resdecl
);
1736 gsi_insert_after (&bsi
, ret
, GSI_NEW_STMT
);
1740 gimple_call_set_tail (call
, true);
1741 remove_edge (single_succ_edge (bb
));
1744 cfun
->gimple_df
->in_ssa_p
= true;
1745 profile_status_for_fn (cfun
)
1746 = count
? PROFILE_READ
: PROFILE_GUESSED
;
1747 /* FIXME: C++ FE should stop setting TREE_ASM_WRITTEN on thunks. */
1748 TREE_ASM_WRITTEN (thunk_fndecl
) = false;
1749 delete_unreachable_blocks ();
1750 update_ssa (TODO_update_ssa
);
1751 #ifdef ENABLE_CHECKING
1752 verify_flow_info ();
1754 free_dominance_info (CDI_DOMINATORS
);
1756 /* Since we want to emit the thunk, we explicitly mark its name as
1758 thunk
.thunk_p
= false;
1760 bitmap_obstack_release (NULL
);
1762 current_function_decl
= NULL
;
1767 /* Assemble thunks and aliases associated to node. */
1770 cgraph_node::assemble_thunks_and_aliases (void)
1775 for (e
= callers
; e
;)
1776 if (e
->caller
->thunk
.thunk_p
1777 && !e
->caller
->thunk
.add_pointer_bounds_args
)
1779 cgraph_node
*thunk
= e
->caller
;
1782 thunk
->expand_thunk (true, false);
1783 thunk
->assemble_thunks_and_aliases ();
1788 FOR_EACH_ALIAS (this, ref
)
1790 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
1791 bool saved_written
= TREE_ASM_WRITTEN (decl
);
1793 /* Force assemble_alias to really output the alias this time instead
1794 of buffering it in same alias pairs. */
1795 TREE_ASM_WRITTEN (decl
) = 1;
1796 do_assemble_alias (alias
->decl
,
1797 DECL_ASSEMBLER_NAME (decl
));
1798 alias
->assemble_thunks_and_aliases ();
1799 TREE_ASM_WRITTEN (decl
) = saved_written
;
1803 /* Expand function specified by node. */
1806 cgraph_node::expand (void)
1808 location_t saved_loc
;
1810 /* We ought to not compile any inline clones. */
1811 gcc_assert (!global
.inlined_to
);
1813 announce_function (decl
);
1815 gcc_assert (lowered
);
1816 get_untransformed_body ();
1818 /* Generate RTL for the body of DECL. */
1820 timevar_push (TV_REST_OF_COMPILATION
);
1822 gcc_assert (symtab
->global_info_ready
);
1824 /* Initialize the default bitmap obstack. */
1825 bitmap_obstack_initialize (NULL
);
1827 /* Initialize the RTL code for the function. */
1828 current_function_decl
= decl
;
1829 saved_loc
= input_location
;
1830 input_location
= DECL_SOURCE_LOCATION (decl
);
1831 init_function_start (decl
);
1833 gimple_register_cfg_hooks ();
1835 bitmap_obstack_initialize (®_obstack
); /* FIXME, only at RTL generation*/
1837 execute_all_ipa_transforms ();
1839 /* Perform all tree transforms and optimizations. */
1841 /* Signal the start of passes. */
1842 invoke_plugin_callbacks (PLUGIN_ALL_PASSES_START
, NULL
);
1844 execute_pass_list (cfun
, g
->get_passes ()->all_passes
);
1846 /* Signal the end of passes. */
1847 invoke_plugin_callbacks (PLUGIN_ALL_PASSES_END
, NULL
);
1849 bitmap_obstack_release (®_obstack
);
1851 /* Release the default bitmap obstack. */
1852 bitmap_obstack_release (NULL
);
1854 /* If requested, warn about function definitions where the function will
1855 return a value (usually of some struct or union type) which itself will
1856 take up a lot of stack space. */
1857 if (warn_larger_than
&& !DECL_EXTERNAL (decl
) && TREE_TYPE (decl
))
1859 tree ret_type
= TREE_TYPE (TREE_TYPE (decl
));
1861 if (ret_type
&& TYPE_SIZE_UNIT (ret_type
)
1862 && TREE_CODE (TYPE_SIZE_UNIT (ret_type
)) == INTEGER_CST
1863 && 0 < compare_tree_int (TYPE_SIZE_UNIT (ret_type
),
1866 unsigned int size_as_int
1867 = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (ret_type
));
1869 if (compare_tree_int (TYPE_SIZE_UNIT (ret_type
), size_as_int
) == 0)
1870 warning (OPT_Wlarger_than_
, "size of return value of %q+D is %u bytes",
1873 warning (OPT_Wlarger_than_
, "size of return value of %q+D is larger than %wd bytes",
1874 decl
, larger_than_size
);
1878 gimple_set_body (decl
, NULL
);
1879 if (DECL_STRUCT_FUNCTION (decl
) == 0
1880 && !cgraph_node::get (decl
)->origin
)
1882 /* Stop pointing to the local nodes about to be freed.
1883 But DECL_INITIAL must remain nonzero so we know this
1884 was an actual function definition.
1885 For a nested function, this is done in c_pop_function_context.
1886 If rest_of_compilation set this to 0, leave it 0. */
1887 if (DECL_INITIAL (decl
) != 0)
1888 DECL_INITIAL (decl
) = error_mark_node
;
1891 input_location
= saved_loc
;
1894 timevar_pop (TV_REST_OF_COMPILATION
);
1896 /* Make sure that BE didn't give up on compiling. */
1897 gcc_assert (TREE_ASM_WRITTEN (decl
));
1899 current_function_decl
= NULL
;
1901 /* It would make a lot more sense to output thunks before function body to get more
1902 forward and lest backwarding jumps. This however would need solving problem
1903 with comdats. See PR48668. Also aliases must come after function itself to
1904 make one pass assemblers, like one on AIX, happy. See PR 50689.
1905 FIXME: Perhaps thunks should be move before function IFF they are not in comdat
1907 assemble_thunks_and_aliases ();
1909 /* Eliminate all call edges. This is important so the GIMPLE_CALL no longer
1910 points to the dead function body. */
1912 remove_all_references ();
1915 /* Node comparer that is responsible for the order that corresponds
1916 to time when a function was launched for the first time. */
1919 node_cmp (const void *pa
, const void *pb
)
1921 const cgraph_node
*a
= *(const cgraph_node
* const *) pa
;
1922 const cgraph_node
*b
= *(const cgraph_node
* const *) pb
;
1924 /* Functions with time profile must be before these without profile. */
1925 if (!a
->tp_first_run
|| !b
->tp_first_run
)
1926 return a
->tp_first_run
- b
->tp_first_run
;
1928 return a
->tp_first_run
!= b
->tp_first_run
1929 ? b
->tp_first_run
- a
->tp_first_run
1930 : b
->order
- a
->order
;
1933 /* Expand all functions that must be output.
1935 Attempt to topologically sort the nodes so function is output when
1936 all called functions are already assembled to allow data to be
1937 propagated across the callgraph. Use a stack to get smaller distance
1938 between a function and its callees (later we may choose to use a more
1939 sophisticated algorithm for function reordering; we will likely want
1940 to use subsections to make the output functions appear in top-down
1944 expand_all_functions (void)
1947 cgraph_node
**order
= XCNEWVEC (cgraph_node
*,
1948 symtab
->cgraph_count
);
1949 unsigned int expanded_func_count
= 0, profiled_func_count
= 0;
1950 int order_pos
, new_order_pos
= 0;
1953 order_pos
= ipa_reverse_postorder (order
);
1954 gcc_assert (order_pos
== symtab
->cgraph_count
);
1956 /* Garbage collector may remove inline clones we eliminate during
1957 optimization. So we must be sure to not reference them. */
1958 for (i
= 0; i
< order_pos
; i
++)
1959 if (order
[i
]->process
)
1960 order
[new_order_pos
++] = order
[i
];
1962 if (flag_profile_reorder_functions
)
1963 qsort (order
, new_order_pos
, sizeof (cgraph_node
*), node_cmp
);
1965 for (i
= new_order_pos
- 1; i
>= 0; i
--)
1971 expanded_func_count
++;
1972 if(node
->tp_first_run
)
1973 profiled_func_count
++;
1975 if (symtab
->dump_file
)
1976 fprintf (symtab
->dump_file
,
1977 "Time profile order in expand_all_functions:%s:%d\n",
1978 node
->asm_name (), node
->tp_first_run
);
1985 fprintf (dump_file
, "Expanded functions with time profile (%s):%u/%u\n",
1986 main_input_filename
, profiled_func_count
, expanded_func_count
);
1988 if (symtab
->dump_file
&& flag_profile_reorder_functions
)
1989 fprintf (symtab
->dump_file
, "Expanded functions with time profile:%u/%u\n",
1990 profiled_func_count
, expanded_func_count
);
1992 symtab
->process_new_functions ();
1993 free_gimplify_stack ();
1998 /* This is used to sort the node types by the cgraph order number. */
2000 enum cgraph_order_sort_kind
2002 ORDER_UNDEFINED
= 0,
2008 struct cgraph_order_sort
2010 enum cgraph_order_sort_kind kind
;
2019 /* Output all functions, variables, and asm statements in the order
2020 according to their order fields, which is the order in which they
2021 appeared in the file. This implements -fno-toplevel-reorder. In
2022 this mode we may output functions and variables which don't really
2024 When NO_REORDER is true only do this for symbols marked no reorder. */
2027 output_in_order (bool no_reorder
)
2030 cgraph_order_sort
*nodes
;
2035 max
= symtab
->order
;
2036 nodes
= XCNEWVEC (cgraph_order_sort
, max
);
2038 FOR_EACH_DEFINED_FUNCTION (pf
)
2040 if (pf
->process
&& !pf
->thunk
.thunk_p
&& !pf
->alias
)
2042 if (no_reorder
&& !pf
->no_reorder
)
2045 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
2046 nodes
[i
].kind
= ORDER_FUNCTION
;
2051 FOR_EACH_DEFINED_VARIABLE (pv
)
2052 if (!DECL_EXTERNAL (pv
->decl
))
2054 if (no_reorder
&& !pv
->no_reorder
)
2057 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
2058 nodes
[i
].kind
= ORDER_VAR
;
2062 for (pa
= symtab
->first_asm_symbol (); pa
; pa
= pa
->next
)
2065 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
2066 nodes
[i
].kind
= ORDER_ASM
;
2070 /* In toplevel reorder mode we output all statics; mark them as needed. */
2072 for (i
= 0; i
< max
; ++i
)
2073 if (nodes
[i
].kind
== ORDER_VAR
)
2074 nodes
[i
].u
.v
->finalize_named_section_flags ();
2076 for (i
= 0; i
< max
; ++i
)
2078 switch (nodes
[i
].kind
)
2080 case ORDER_FUNCTION
:
2081 nodes
[i
].u
.f
->process
= 0;
2082 nodes
[i
].u
.f
->expand ();
2086 nodes
[i
].u
.v
->assemble_decl ();
2090 assemble_asm (nodes
[i
].u
.a
->asm_str
);
2093 case ORDER_UNDEFINED
:
2101 symtab
->clear_asm_symbols ();
2109 gcc::pass_manager
*passes
= g
->get_passes ();
2112 current_function_decl
= NULL
;
2113 gimple_register_cfg_hooks ();
2114 bitmap_obstack_initialize (NULL
);
2116 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_START
, NULL
);
2120 execute_ipa_pass_list (passes
->all_small_ipa_passes
);
2125 /* This extra symtab_remove_unreachable_nodes pass tends to catch some
2126 devirtualization and other changes where removal iterate. */
2127 symtab
->remove_unreachable_nodes (symtab
->dump_file
);
2129 /* If pass_all_early_optimizations was not scheduled, the state of
2130 the cgraph will not be properly updated. Update it now. */
2131 if (symtab
->state
< IPA_SSA
)
2132 symtab
->state
= IPA_SSA
;
2136 /* Generate coverage variables and constructors. */
2139 /* Process new functions added. */
2141 current_function_decl
= NULL
;
2142 symtab
->process_new_functions ();
2144 execute_ipa_summary_passes
2145 ((ipa_opt_pass_d
*) passes
->all_regular_ipa_passes
);
2148 /* Some targets need to handle LTO assembler output specially. */
2149 if (flag_generate_lto
|| flag_generate_offload
)
2150 targetm
.asm_out
.lto_start ();
2154 if (g
->have_offload
)
2156 section_name_prefix
= OFFLOAD_SECTION_NAME_PREFIX
;
2157 lto_stream_offload_p
= true;
2158 ipa_write_summaries ();
2159 lto_stream_offload_p
= false;
2163 section_name_prefix
= LTO_SECTION_NAME_PREFIX
;
2164 lto_stream_offload_p
= false;
2165 ipa_write_summaries ();
2169 if (flag_generate_lto
|| flag_generate_offload
)
2170 targetm
.asm_out
.lto_end ();
2172 if (!flag_ltrans
&& (in_lto_p
|| !flag_lto
|| flag_fat_lto_objects
))
2173 execute_ipa_pass_list (passes
->all_regular_ipa_passes
);
2174 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_END
, NULL
);
2176 bitmap_obstack_release (NULL
);
2180 /* Return string alias is alias of. */
2183 get_alias_symbol (tree decl
)
2185 tree alias
= lookup_attribute ("alias", DECL_ATTRIBUTES (decl
));
2186 return get_identifier (TREE_STRING_POINTER
2187 (TREE_VALUE (TREE_VALUE (alias
))));
2191 /* Weakrefs may be associated to external decls and thus not output
2192 at expansion time. Emit all necessary aliases. */
2195 symbol_table::output_weakrefs (void)
2199 FOR_EACH_SYMBOL (node
)
2201 && !TREE_ASM_WRITTEN (node
->decl
)
2202 && (!(cnode
= dyn_cast
<cgraph_node
*> (node
))
2203 || !cnode
->instrumented_version
2204 || !TREE_ASM_WRITTEN (cnode
->instrumented_version
->decl
))
2209 /* Weakrefs are special by not requiring target definition in current
2210 compilation unit. It is thus bit hard to work out what we want to
2212 When alias target is defined, we need to fetch it from symtab reference,
2213 otherwise it is pointed to by alias_target. */
2214 if (node
->alias_target
)
2215 target
= (DECL_P (node
->alias_target
)
2216 ? DECL_ASSEMBLER_NAME (node
->alias_target
)
2217 : node
->alias_target
);
2218 else if (node
->analyzed
)
2219 target
= DECL_ASSEMBLER_NAME (node
->get_alias_target ()->decl
);
2223 target
= get_alias_symbol (node
->decl
);
2225 do_assemble_alias (node
->decl
, target
);
2229 /* Perform simple optimizations based on callgraph. */
2232 symbol_table::compile (void)
2237 #ifdef ENABLE_CHECKING
2238 symtab_node::verify_symtab_nodes ();
2241 timevar_push (TV_CGRAPHOPT
);
2242 if (pre_ipa_mem_report
)
2244 fprintf (stderr
, "Memory consumption before IPA\n");
2245 dump_memory_report (false);
2248 fprintf (stderr
, "Performing interprocedural optimizations\n");
2251 /* Offloading requires LTO infrastructure. */
2252 if (!in_lto_p
&& g
->have_offload
)
2253 flag_generate_offload
= 1;
2255 /* If LTO is enabled, initialize the streamer hooks needed by GIMPLE. */
2256 if (flag_generate_lto
|| flag_generate_offload
)
2257 lto_streamer_hooks_init ();
2259 /* Don't run the IPA passes if there was any error or sorry messages. */
2263 /* Do nothing else if any IPA pass found errors or if we are just streaming LTO. */
2265 || (!in_lto_p
&& flag_lto
&& !flag_fat_lto_objects
))
2267 timevar_pop (TV_CGRAPHOPT
);
2271 global_info_ready
= true;
2274 fprintf (dump_file
, "Optimized ");
2275 symtab_node:: dump_table (dump_file
);
2277 if (post_ipa_mem_report
)
2279 fprintf (stderr
, "Memory consumption after IPA\n");
2280 dump_memory_report (false);
2282 timevar_pop (TV_CGRAPHOPT
);
2284 /* Output everything. */
2285 (*debug_hooks
->assembly_start
) ();
2287 fprintf (stderr
, "Assembling functions:\n");
2288 #ifdef ENABLE_CHECKING
2289 symtab_node::verify_symtab_nodes ();
2292 materialize_all_clones ();
2293 bitmap_obstack_initialize (NULL
);
2294 execute_ipa_pass_list (g
->get_passes ()->all_late_ipa_passes
);
2295 bitmap_obstack_release (NULL
);
2296 mark_functions_to_output ();
2298 /* When weakref support is missing, we autmatically translate all
2299 references to NODE to references to its ultimate alias target.
2300 The renaming mechanizm uses flag IDENTIFIER_TRANSPARENT_ALIAS and
2303 Set up this mapping before we output any assembler but once we are sure
2304 that all symbol renaming is done.
2306 FIXME: All this uglyness can go away if we just do renaming at gimple
2307 level by physically rewritting the IL. At the moment we can only redirect
2308 calls, so we need infrastructure for renaming references as well. */
2309 #ifndef ASM_OUTPUT_WEAKREF
2312 FOR_EACH_SYMBOL (node
)
2314 && lookup_attribute ("weakref", DECL_ATTRIBUTES (node
->decl
)))
2316 IDENTIFIER_TRANSPARENT_ALIAS
2317 (DECL_ASSEMBLER_NAME (node
->decl
)) = 1;
2318 TREE_CHAIN (DECL_ASSEMBLER_NAME (node
->decl
))
2319 = (node
->alias_target
? node
->alias_target
2320 : DECL_ASSEMBLER_NAME (node
->get_alias_target ()->decl
));
2326 if (!flag_toplevel_reorder
)
2327 output_in_order (false);
2330 /* Output first asm statements and anything ordered. The process
2331 flag is cleared for these nodes, so we skip them later. */
2332 output_in_order (true);
2333 expand_all_functions ();
2334 output_variables ();
2337 process_new_functions ();
2343 fprintf (dump_file
, "\nFinal ");
2344 symtab_node::dump_table (dump_file
);
2346 #ifdef ENABLE_CHECKING
2347 symtab_node::verify_symtab_nodes ();
2348 /* Double check that all inline clones are gone and that all
2349 function bodies have been released from memory. */
2353 bool error_found
= false;
2355 FOR_EACH_DEFINED_FUNCTION (node
)
2356 if (node
->global
.inlined_to
2357 || gimple_has_body_p (node
->decl
))
2363 internal_error ("nodes with unreleased memory found");
2369 /* Analyze the whole compilation unit once it is parsed completely. */
2372 symbol_table::finalize_compilation_unit (void)
2374 timevar_push (TV_CGRAPH
);
2376 /* If we're here there's no current function anymore. Some frontends
2377 are lazy in clearing these. */
2378 current_function_decl
= NULL
;
2381 /* Do not skip analyzing the functions if there were errors, we
2382 miss diagnostics for following functions otherwise. */
2384 /* Emit size functions we didn't inline. */
2385 finalize_size_functions ();
2387 /* Mark alias targets necessary and emit diagnostics. */
2388 handle_alias_pairs ();
2392 fprintf (stderr
, "\nAnalyzing compilation unit\n");
2396 if (flag_dump_passes
)
2399 /* Gimplify and lower all functions, compute reachability and
2400 remove unreachable nodes. */
2401 analyze_functions ();
2403 /* Mark alias targets necessary and emit diagnostics. */
2404 handle_alias_pairs ();
2406 /* Gimplify and lower thunks. */
2407 analyze_functions ();
2409 /* Finally drive the pass manager. */
2412 timevar_pop (TV_CGRAPH
);
2415 /* Reset all state within cgraphunit.c so that we can rerun the compiler
2416 within the same process. For use by toplev::finalize. */
2419 cgraphunit_c_finalize (void)
2421 gcc_assert (cgraph_new_nodes
.length () == 0);
2422 cgraph_new_nodes
.truncate (0);
2424 vtable_entry_type
= NULL
;
2425 queued_nodes
= &symtab_terminator
;
2427 first_analyzed
= NULL
;
2428 first_analyzed_var
= NULL
;
2431 /* Creates a wrapper from cgraph_node to TARGET node. Thunk is used for this
2432 kind of wrapper method. */
2435 cgraph_node::create_wrapper (cgraph_node
*target
)
2437 /* Preserve DECL_RESULT so we get right by reference flag. */
2438 tree decl_result
= DECL_RESULT (decl
);
2440 /* Remove the function's body but keep arguments to be reused
2442 release_body (true);
2445 DECL_RESULT (decl
) = decl_result
;
2446 DECL_INITIAL (decl
) = NULL
;
2447 allocate_struct_function (decl
, false);
2450 /* Turn alias into thunk and expand it into GIMPLE representation. */
2452 thunk
.thunk_p
= true;
2453 thunk
.this_adjusting
= false;
2454 create_edge (target
, NULL
, count
, CGRAPH_FREQ_BASE
);
2456 tree arguments
= DECL_ARGUMENTS (decl
);
2460 TREE_ADDRESSABLE (arguments
) = false;
2461 arguments
= TREE_CHAIN (arguments
);
2464 expand_thunk (false, true);
2466 /* Inline summary set-up. */
2468 inline_analyze_function (this);
2471 #include "gt-cgraphunit.h"