1 /* Driver of optimization process
2 Copyright (C) 2003-2016 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"
168 #include "cfghooks.h"
169 #include "regset.h" /* FIXME: For reg_obstack. */
170 #include "alloc-pool.h"
171 #include "tree-pass.h"
172 #include "stringpool.h"
173 #include "gimple-ssa.h"
175 #include "coverage.h"
176 #include "lto-streamer.h"
177 #include "fold-const.h"
179 #include "stor-layout.h"
181 #include "cfgcleanup.h"
182 #include "gimple-fold.h"
183 #include "gimplify.h"
184 #include "gimple-iterator.h"
185 #include "gimplify-me.h"
186 #include "tree-cfg.h"
187 #include "tree-into-ssa.h"
188 #include "tree-ssa.h"
189 #include "langhooks.h"
192 #include "symbol-summary.h"
193 #include "ipa-prop.h"
194 #include "gimple-pretty-print.h"
196 #include "ipa-inline.h"
197 #include "ipa-utils.h"
201 #include "pass_manager.h"
202 #include "tree-nested.h"
204 #include "tree-chkp.h"
205 #include "lto-section-names.h"
207 /* Queue of cgraph nodes scheduled to be added into cgraph. This is a
208 secondary queue used during optimization to accommodate passes that
209 may generate new functions that need to be optimized and expanded. */
210 vec
<cgraph_node
*> cgraph_new_nodes
;
212 static void expand_all_functions (void);
213 static void mark_functions_to_output (void);
214 static void handle_alias_pairs (void);
216 /* Used for vtable lookup in thunk adjusting. */
217 static GTY (()) tree vtable_entry_type
;
219 /* Determine if symbol declaration is needed. That is, visible to something
220 either outside this translation unit, something magic in the system
223 symtab_node::needed_p (void)
225 /* Double check that no one output the function into assembly file
227 gcc_checking_assert (!DECL_ASSEMBLER_NAME_SET_P (decl
)
228 || !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)));
233 if (DECL_EXTERNAL (decl
))
236 /* If the user told us it is used, then it must be so. */
240 /* ABI forced symbols are needed when they are external. */
241 if (forced_by_abi
&& TREE_PUBLIC (decl
))
244 /* Keep constructors, destructors and virtual functions. */
245 if (TREE_CODE (decl
) == FUNCTION_DECL
246 && (DECL_STATIC_CONSTRUCTOR (decl
) || DECL_STATIC_DESTRUCTOR (decl
)))
249 /* Externally visible variables must be output. The exception is
250 COMDAT variables that must be output only when they are needed. */
251 if (TREE_PUBLIC (decl
) && !DECL_COMDAT (decl
))
257 /* Head and terminator of the queue of nodes to be processed while building
260 static symtab_node symtab_terminator
;
261 static symtab_node
*queued_nodes
= &symtab_terminator
;
263 /* Add NODE to queue starting at QUEUED_NODES.
264 The queue is linked via AUX pointers and terminated by pointer to 1. */
267 enqueue_node (symtab_node
*node
)
271 gcc_checking_assert (queued_nodes
);
272 node
->aux
= queued_nodes
;
276 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
277 functions into callgraph in a way so they look like ordinary reachable
278 functions inserted into callgraph already at construction time. */
281 symbol_table::process_new_functions (void)
285 if (!cgraph_new_nodes
.exists ())
288 handle_alias_pairs ();
289 /* Note that this queue may grow as its being processed, as the new
290 functions may generate new ones. */
291 for (unsigned i
= 0; i
< cgraph_new_nodes
.length (); i
++)
293 cgraph_node
*node
= cgraph_new_nodes
[i
];
298 /* At construction time we just need to finalize function and move
299 it into reachable functions list. */
301 cgraph_node::finalize_function (fndecl
, false);
302 call_cgraph_insertion_hooks (node
);
308 case IPA_SSA_AFTER_INLINING
:
309 /* When IPA optimization already started, do all essential
310 transformations that has been already performed on the whole
311 cgraph but not on this function. */
313 gimple_register_cfg_hooks ();
316 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
317 if ((state
== IPA_SSA
|| state
== IPA_SSA_AFTER_INLINING
)
318 && !gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
319 g
->get_passes ()->execute_early_local_passes ();
320 else if (inline_summaries
!= NULL
)
321 compute_inline_parameters (node
, true);
322 free_dominance_info (CDI_POST_DOMINATORS
);
323 free_dominance_info (CDI_DOMINATORS
);
325 call_cgraph_insertion_hooks (node
);
329 /* Functions created during expansion shall be compiled
332 call_cgraph_insertion_hooks (node
);
342 cgraph_new_nodes
.release ();
345 /* As an GCC extension we allow redefinition of the function. The
346 semantics when both copies of bodies differ is not well defined.
347 We replace the old body with new body so in unit at a time mode
348 we always use new body, while in normal mode we may end up with
349 old body inlined into some functions and new body expanded and
352 ??? It may make more sense to use one body for inlining and other
353 body for expanding the function but this is difficult to do. */
356 cgraph_node::reset (void)
358 /* If process is set, then we have already begun whole-unit analysis.
359 This is *not* testing for whether we've already emitted the function.
360 That case can be sort-of legitimately seen with real function redefinition
361 errors. I would argue that the front end should never present us with
362 such a case, but don't enforce that for now. */
363 gcc_assert (!process
);
365 /* Reset our data structures so we can analyze the function again. */
366 memset (&local
, 0, sizeof (local
));
367 memset (&global
, 0, sizeof (global
));
368 memset (&rtl
, 0, sizeof (rtl
));
372 transparent_alias
= false;
374 cpp_implicit_alias
= false;
377 remove_all_references ();
380 /* Return true when there are references to the node. INCLUDE_SELF is
381 true if a self reference counts as a reference. */
384 symtab_node::referred_to_p (bool include_self
)
388 /* See if there are any references at all. */
389 if (iterate_referring (0, ref
))
391 /* For functions check also calls. */
392 cgraph_node
*cn
= dyn_cast
<cgraph_node
*> (this);
393 if (cn
&& cn
->callers
)
397 for (cgraph_edge
*e
= cn
->callers
; e
; e
= e
->next_caller
)
398 if (e
->caller
!= this)
404 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
405 logic in effect. If NO_COLLECT is true, then our caller cannot stand to have
406 the garbage collector run at the moment. We would need to either create
407 a new GC context, or just not compile right now. */
410 cgraph_node::finalize_function (tree decl
, bool no_collect
)
412 cgraph_node
*node
= cgraph_node::get_create (decl
);
414 if (node
->definition
)
416 /* Nested functions should only be defined once. */
417 gcc_assert (!DECL_CONTEXT (decl
)
418 || TREE_CODE (DECL_CONTEXT (decl
)) != FUNCTION_DECL
);
420 node
->local
.redefined_extern_inline
= true;
423 /* Set definition first before calling notice_global_symbol so that
424 it is available to notice_global_symbol. */
425 node
->definition
= true;
426 notice_global_symbol (decl
);
427 node
->lowered
= DECL_STRUCT_FUNCTION (decl
)->cfg
!= NULL
;
429 /* With -fkeep-inline-functions we are keeping all inline functions except
430 for extern inline ones. */
431 if (flag_keep_inline_functions
432 && DECL_DECLARED_INLINE_P (decl
)
433 && !DECL_EXTERNAL (decl
)
434 && !DECL_DISREGARD_INLINE_LIMITS (decl
))
435 node
->force_output
= 1;
437 /* When not optimizing, also output the static functions. (see
438 PR24561), but don't do so for always_inline functions, functions
439 declared inline and nested functions. These were optimized out
440 in the original implementation and it is unclear whether we want
441 to change the behavior here. */
442 if (((!opt_for_fn (decl
, optimize
) || flag_keep_static_functions
)
443 && !node
->cpp_implicit_alias
444 && !DECL_DISREGARD_INLINE_LIMITS (decl
)
445 && !DECL_DECLARED_INLINE_P (decl
)
446 && !(DECL_CONTEXT (decl
)
447 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
))
448 && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
))
449 node
->force_output
= 1;
451 /* If we've not yet emitted decl, tell the debug info about it. */
452 if (!TREE_ASM_WRITTEN (decl
))
453 (*debug_hooks
->deferred_inline_function
) (decl
);
458 if (symtab
->state
== CONSTRUCTION
459 && (node
->needed_p () || node
->referred_to_p ()))
463 /* Add the function FNDECL to the call graph.
464 Unlike finalize_function, this function is intended to be used
465 by middle end and allows insertion of new function at arbitrary point
466 of compilation. The function can be either in high, low or SSA form
469 The function is assumed to be reachable and have address taken (so no
470 API breaking optimizations are performed on it).
472 Main work done by this function is to enqueue the function for later
473 processing to avoid need the passes to be re-entrant. */
476 cgraph_node::add_new_function (tree fndecl
, bool lowered
)
478 gcc::pass_manager
*passes
= g
->get_passes ();
483 struct function
*fn
= DECL_STRUCT_FUNCTION (fndecl
);
484 const char *function_type
= ((gimple_has_body_p (fndecl
))
486 ? (gimple_in_ssa_p (fn
)
490 : "to-be-gimplified");
492 "Added new %s function %s to callgraph\n",
494 fndecl_name (fndecl
));
497 switch (symtab
->state
)
500 cgraph_node::finalize_function (fndecl
, false);
503 /* Just enqueue function to be processed at nearest occurrence. */
504 node
= cgraph_node::get_create (fndecl
);
506 node
->lowered
= true;
507 cgraph_new_nodes
.safe_push (node
);
512 case IPA_SSA_AFTER_INLINING
:
514 /* Bring the function into finalized state and enqueue for later
515 analyzing and compilation. */
516 node
= cgraph_node::get_create (fndecl
);
517 node
->local
.local
= false;
518 node
->definition
= true;
519 node
->force_output
= true;
520 if (!lowered
&& symtab
->state
== EXPANSION
)
522 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
523 gimple_register_cfg_hooks ();
524 bitmap_obstack_initialize (NULL
);
525 execute_pass_list (cfun
, passes
->all_lowering_passes
);
526 passes
->execute_early_local_passes ();
527 bitmap_obstack_release (NULL
);
533 node
->lowered
= true;
534 cgraph_new_nodes
.safe_push (node
);
538 /* At the very end of compilation we have to do all the work up
540 node
= cgraph_node::create (fndecl
);
542 node
->lowered
= true;
543 node
->definition
= true;
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
);
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 /* Analyze the function scheduled to be output. */
568 cgraph_node::analyze (void)
570 tree decl
= this->decl
;
571 location_t saved_loc
= input_location
;
572 input_location
= DECL_SOURCE_LOCATION (decl
);
576 cgraph_node
*t
= cgraph_node::get (thunk
.alias
);
578 create_edge (t
, NULL
, 0, CGRAPH_FREQ_BASE
);
579 callees
->can_throw_external
= !TREE_NOTHROW (t
->decl
);
580 /* Target code in expand_thunk may need the thunk's target
581 to be analyzed, so recurse here. */
586 t
= t
->get_alias_target ();
590 if (!expand_thunk (false, false))
598 resolve_alias (cgraph_node::get (alias_target
), transparent_alias
);
599 else if (dispatcher_function
)
601 /* Generate the dispatcher body of multi-versioned functions. */
602 cgraph_function_version_info
*dispatcher_version_info
603 = function_version ();
604 if (dispatcher_version_info
!= NULL
605 && (dispatcher_version_info
->dispatcher_resolver
608 tree resolver
= NULL_TREE
;
609 gcc_assert (targetm
.generate_version_dispatcher_body
);
610 resolver
= targetm
.generate_version_dispatcher_body (this);
611 gcc_assert (resolver
!= NULL_TREE
);
616 push_cfun (DECL_STRUCT_FUNCTION (decl
));
618 assign_assembler_name_if_neeeded (decl
);
620 /* Make sure to gimplify bodies only once. During analyzing a
621 function we lower it, which will require gimplified nested
622 functions, so we can end up here with an already gimplified
624 if (!gimple_has_body_p (decl
))
625 gimplify_function_tree (decl
);
627 /* Lower the function. */
631 lower_nested_functions (decl
);
632 gcc_assert (!nested
);
634 gimple_register_cfg_hooks ();
635 bitmap_obstack_initialize (NULL
);
636 execute_pass_list (cfun
, g
->get_passes ()->all_lowering_passes
);
637 free_dominance_info (CDI_POST_DOMINATORS
);
638 free_dominance_info (CDI_DOMINATORS
);
640 bitmap_obstack_release (NULL
);
648 input_location
= saved_loc
;
651 /* C++ frontend produce same body aliases all over the place, even before PCH
652 gets streamed out. It relies on us linking the aliases with their function
653 in order to do the fixups, but ipa-ref is not PCH safe. Consequentely we
654 first produce aliases without links, but once C++ FE is sure he won't sream
655 PCH we build the links via this function. */
658 symbol_table::process_same_body_aliases (void)
661 FOR_EACH_SYMBOL (node
)
662 if (node
->cpp_implicit_alias
&& !node
->analyzed
)
664 (TREE_CODE (node
->alias_target
) == VAR_DECL
665 ? (symtab_node
*)varpool_node::get_create (node
->alias_target
)
666 : (symtab_node
*)cgraph_node::get_create (node
->alias_target
));
667 cpp_implicit_aliases_done
= true;
670 /* Process attributes common for vars and functions. */
673 process_common_attributes (symtab_node
*node
, tree decl
)
675 tree weakref
= lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
));
677 if (weakref
&& !lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)))
679 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wattributes
,
680 "%<weakref%> attribute should be accompanied with"
681 " an %<alias%> attribute");
682 DECL_WEAK (decl
) = 0;
683 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
684 DECL_ATTRIBUTES (decl
));
687 if (lookup_attribute ("no_reorder", DECL_ATTRIBUTES (decl
)))
688 node
->no_reorder
= 1;
691 /* Look for externally_visible and used attributes and mark cgraph nodes
694 We cannot mark the nodes at the point the attributes are processed (in
695 handle_*_attribute) because the copy of the declarations available at that
696 point may not be canonical. For example, in:
699 void f() __attribute__((used));
701 the declaration we see in handle_used_attribute will be the second
702 declaration -- but the front end will subsequently merge that declaration
703 with the original declaration and discard the second declaration.
705 Furthermore, we can't mark these nodes in finalize_function because:
708 void f() __attribute__((externally_visible));
712 So, we walk the nodes at the end of the translation unit, applying the
713 attributes at that point. */
716 process_function_and_variable_attributes (cgraph_node
*first
,
717 varpool_node
*first_var
)
722 for (node
= symtab
->first_function (); node
!= first
;
723 node
= symtab
->next_function (node
))
725 tree decl
= node
->decl
;
726 if (DECL_PRESERVE_P (decl
))
727 node
->mark_force_output ();
728 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
730 if (! TREE_PUBLIC (node
->decl
))
731 warning_at (DECL_SOURCE_LOCATION (node
->decl
), OPT_Wattributes
,
732 "%<externally_visible%>"
733 " attribute have effect only on public objects");
735 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
736 && (node
->definition
&& !node
->alias
))
738 warning_at (DECL_SOURCE_LOCATION (node
->decl
), OPT_Wattributes
,
739 "%<weakref%> attribute ignored"
740 " because function is defined");
741 DECL_WEAK (decl
) = 0;
742 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
743 DECL_ATTRIBUTES (decl
));
746 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (decl
))
747 && !DECL_DECLARED_INLINE_P (decl
)
748 /* redefining extern inline function makes it DECL_UNINLINABLE. */
749 && !DECL_UNINLINABLE (decl
))
750 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wattributes
,
751 "always_inline function might not be inlinable");
753 process_common_attributes (node
, decl
);
755 for (vnode
= symtab
->first_variable (); vnode
!= first_var
;
756 vnode
= symtab
->next_variable (vnode
))
758 tree decl
= vnode
->decl
;
759 if (DECL_EXTERNAL (decl
)
760 && DECL_INITIAL (decl
))
761 varpool_node::finalize_decl (decl
);
762 if (DECL_PRESERVE_P (decl
))
763 vnode
->force_output
= true;
764 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
766 if (! TREE_PUBLIC (vnode
->decl
))
767 warning_at (DECL_SOURCE_LOCATION (vnode
->decl
), OPT_Wattributes
,
768 "%<externally_visible%>"
769 " attribute have effect only on public objects");
771 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
773 && DECL_INITIAL (decl
))
775 warning_at (DECL_SOURCE_LOCATION (vnode
->decl
), OPT_Wattributes
,
776 "%<weakref%> attribute ignored"
777 " because variable is initialized");
778 DECL_WEAK (decl
) = 0;
779 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
780 DECL_ATTRIBUTES (decl
));
782 process_common_attributes (vnode
, decl
);
786 /* Mark DECL as finalized. By finalizing the declaration, frontend instruct the
787 middle end to output the variable to asm file, if needed or externally
791 varpool_node::finalize_decl (tree decl
)
793 varpool_node
*node
= varpool_node::get_create (decl
);
795 gcc_assert (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
));
797 if (node
->definition
)
799 /* Set definition first before calling notice_global_symbol so that
800 it is available to notice_global_symbol. */
801 node
->definition
= true;
802 notice_global_symbol (decl
);
803 if (TREE_THIS_VOLATILE (decl
) || DECL_PRESERVE_P (decl
)
804 /* Traditionally we do not eliminate static variables when not
805 optimizing and when not doing toplevel reoder. */
807 || ((!flag_toplevel_reorder
808 && !DECL_COMDAT (node
->decl
)
809 && !DECL_ARTIFICIAL (node
->decl
))))
810 node
->force_output
= true;
812 if (symtab
->state
== CONSTRUCTION
813 && (node
->needed_p () || node
->referred_to_p ()))
815 if (symtab
->state
>= IPA_SSA
)
817 /* Some frontends produce various interface variables after compilation
819 if (symtab
->state
== FINISHED
820 || (!flag_toplevel_reorder
821 && symtab
->state
== EXPANSION
))
822 node
->assemble_decl ();
824 if (DECL_INITIAL (decl
))
825 chkp_register_var_initializer (decl
);
828 /* EDGE is an polymorphic call. Mark all possible targets as reachable
829 and if there is only one target, perform trivial devirtualization.
830 REACHABLE_CALL_TARGETS collects target lists we already walked to
831 avoid udplicate work. */
834 walk_polymorphic_call_targets (hash_set
<void *> *reachable_call_targets
,
840 vec
<cgraph_node
*>targets
841 = possible_polymorphic_call_targets
842 (edge
, &final
, &cache_token
);
844 if (!reachable_call_targets
->add (cache_token
))
846 if (symtab
->dump_file
)
847 dump_possible_polymorphic_call_targets
848 (symtab
->dump_file
, edge
);
850 for (i
= 0; i
< targets
.length (); i
++)
852 /* Do not bother to mark virtual methods in anonymous namespace;
853 either we will find use of virtual table defining it, or it is
855 if (targets
[i
]->definition
857 (TREE_TYPE (targets
[i
]->decl
))
859 && !type_in_anonymous_namespace_p
860 (TYPE_METHOD_BASETYPE (TREE_TYPE (targets
[i
]->decl
))))
861 enqueue_node (targets
[i
]);
865 /* Very trivial devirtualization; when the type is
866 final or anonymous (so we know all its derivation)
867 and there is only one possible virtual call target,
868 make the edge direct. */
871 if (targets
.length () <= 1 && dbg_cnt (devirt
))
874 if (targets
.length () == 1)
877 target
= cgraph_node::create
878 (builtin_decl_implicit (BUILT_IN_UNREACHABLE
));
880 if (symtab
->dump_file
)
882 fprintf (symtab
->dump_file
,
883 "Devirtualizing call: ");
884 print_gimple_stmt (symtab
->dump_file
,
888 if (dump_enabled_p ())
890 location_t locus
= gimple_location_safe (edge
->call_stmt
);
891 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, locus
,
892 "devirtualizing call in %s to %s\n",
893 edge
->caller
->name (), target
->name ());
896 edge
->make_direct (target
);
897 edge
->redirect_call_stmt_to_callee ();
899 /* Call to __builtin_unreachable shouldn't be instrumented. */
900 if (!targets
.length ())
901 gimple_call_set_with_bounds (edge
->call_stmt
, false);
903 if (symtab
->dump_file
)
905 fprintf (symtab
->dump_file
,
906 "Devirtualized as: ");
907 print_gimple_stmt (symtab
->dump_file
,
915 /* Issue appropriate warnings for the global declaration DECL. */
918 check_global_declaration (symtab_node
*snode
)
920 const char *decl_file
;
921 tree decl
= snode
->decl
;
923 /* Warn about any function declared static but not defined. We don't
924 warn about variables, because many programs have static variables
925 that exist only to get some text into the object file. */
926 if (TREE_CODE (decl
) == FUNCTION_DECL
927 && DECL_INITIAL (decl
) == 0
928 && DECL_EXTERNAL (decl
)
929 && ! DECL_ARTIFICIAL (decl
)
930 && ! TREE_NO_WARNING (decl
)
931 && ! TREE_PUBLIC (decl
)
932 && (warn_unused_function
933 || snode
->referred_to_p (/*include_self=*/false)))
935 if (snode
->referred_to_p (/*include_self=*/false))
936 pedwarn (input_location
, 0, "%q+F used but never defined", decl
);
938 warning (OPT_Wunused_function
, "%q+F declared %<static%> but never defined", decl
);
939 /* This symbol is effectively an "extern" declaration now. */
940 TREE_PUBLIC (decl
) = 1;
943 /* Warn about static fns or vars defined but not used. */
944 if (((warn_unused_function
&& TREE_CODE (decl
) == FUNCTION_DECL
)
945 || (((warn_unused_variable
&& ! TREE_READONLY (decl
))
946 || (warn_unused_const_variable
> 0 && TREE_READONLY (decl
)
947 && (warn_unused_const_variable
== 2
948 || (main_input_filename
!= NULL
949 && (decl_file
= DECL_SOURCE_FILE (decl
)) != NULL
950 && filename_cmp (main_input_filename
,
952 && TREE_CODE (decl
) == VAR_DECL
))
953 && ! DECL_IN_SYSTEM_HEADER (decl
)
954 && ! snode
->referred_to_p (/*include_self=*/false)
955 /* This TREE_USED check is needed in addition to referred_to_p
956 above, because the `__unused__' attribute is not being
957 considered for referred_to_p. */
958 && ! TREE_USED (decl
)
959 /* The TREE_USED bit for file-scope decls is kept in the identifier,
960 to handle multiple external decls in different scopes. */
961 && ! (DECL_NAME (decl
) && TREE_USED (DECL_NAME (decl
)))
962 && ! DECL_EXTERNAL (decl
)
963 && ! DECL_ARTIFICIAL (decl
)
964 && ! DECL_ABSTRACT_ORIGIN (decl
)
965 && ! TREE_PUBLIC (decl
)
966 /* A volatile variable might be used in some non-obvious way. */
967 && (! VAR_P (decl
) || ! TREE_THIS_VOLATILE (decl
))
968 /* Global register variables must be declared to reserve them. */
969 && ! (TREE_CODE (decl
) == VAR_DECL
&& DECL_REGISTER (decl
))
970 /* Global ctors and dtors are called by the runtime. */
971 && (TREE_CODE (decl
) != FUNCTION_DECL
972 || (!DECL_STATIC_CONSTRUCTOR (decl
)
973 && !DECL_STATIC_DESTRUCTOR (decl
)))
974 /* Otherwise, ask the language. */
975 && lang_hooks
.decls
.warn_unused_global (decl
))
976 warning_at (DECL_SOURCE_LOCATION (decl
),
977 (TREE_CODE (decl
) == FUNCTION_DECL
)
978 ? OPT_Wunused_function
979 : (TREE_READONLY (decl
)
980 ? OPT_Wunused_const_variable_
981 : OPT_Wunused_variable
),
982 "%qD defined but not used", decl
);
985 /* Discover all functions and variables that are trivially needed, analyze
986 them as well as all functions and variables referred by them */
987 static cgraph_node
*first_analyzed
;
988 static varpool_node
*first_analyzed_var
;
990 /* FIRST_TIME is set to TRUE for the first time we are called for a
991 translation unit from finalize_compilation_unit() or false
995 analyze_functions (bool first_time
)
997 /* Keep track of already processed nodes when called multiple times for
998 intermodule optimization. */
999 cgraph_node
*first_handled
= first_analyzed
;
1000 varpool_node
*first_handled_var
= first_analyzed_var
;
1001 hash_set
<void *> reachable_call_targets
;
1007 bool changed
= true;
1008 location_t saved_loc
= input_location
;
1010 bitmap_obstack_initialize (NULL
);
1011 symtab
->state
= CONSTRUCTION
;
1012 input_location
= UNKNOWN_LOCATION
;
1014 /* Ugly, but the fixup can not happen at a time same body alias is created;
1015 C++ FE is confused about the COMDAT groups being right. */
1016 if (symtab
->cpp_implicit_aliases_done
)
1017 FOR_EACH_SYMBOL (node
)
1018 if (node
->cpp_implicit_alias
)
1019 node
->fixup_same_cpp_alias_visibility (node
->get_alias_target ());
1020 build_type_inheritance_graph ();
1022 /* Analysis adds static variables that in turn adds references to new functions.
1023 So we need to iterate the process until it stabilize. */
1027 process_function_and_variable_attributes (first_analyzed
,
1028 first_analyzed_var
);
1030 /* First identify the trivially needed symbols. */
1031 for (node
= symtab
->first_symbol ();
1032 node
!= first_analyzed
1033 && node
!= first_analyzed_var
; node
= node
->next
)
1035 /* Convert COMDAT group designators to IDENTIFIER_NODEs. */
1036 node
->get_comdat_group_id ();
1037 if (node
->needed_p ())
1039 enqueue_node (node
);
1040 if (!changed
&& symtab
->dump_file
)
1041 fprintf (symtab
->dump_file
, "Trivially needed symbols:");
1043 if (symtab
->dump_file
)
1044 fprintf (symtab
->dump_file
, " %s", node
->asm_name ());
1045 if (!changed
&& symtab
->dump_file
)
1046 fprintf (symtab
->dump_file
, "\n");
1048 if (node
== first_analyzed
1049 || node
== first_analyzed_var
)
1052 symtab
->process_new_functions ();
1053 first_analyzed_var
= symtab
->first_variable ();
1054 first_analyzed
= symtab
->first_function ();
1056 if (changed
&& symtab
->dump_file
)
1057 fprintf (symtab
->dump_file
, "\n");
1059 /* Lower representation, build callgraph edges and references for all trivially
1060 needed symbols and all symbols referred by them. */
1061 while (queued_nodes
!= &symtab_terminator
)
1064 node
= queued_nodes
;
1065 queued_nodes
= (symtab_node
*)queued_nodes
->aux
;
1066 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
);
1067 if (cnode
&& cnode
->definition
)
1070 tree decl
= cnode
->decl
;
1072 /* ??? It is possible to create extern inline function
1073 and later using weak alias attribute to kill its body.
1074 See gcc.c-torture/compile/20011119-1.c */
1075 if (!DECL_STRUCT_FUNCTION (decl
)
1077 && !cnode
->thunk
.thunk_p
1078 && !cnode
->dispatcher_function
)
1081 cnode
->local
.redefined_extern_inline
= true;
1085 if (!cnode
->analyzed
)
1088 for (edge
= cnode
->callees
; edge
; edge
= edge
->next_callee
)
1089 if (edge
->callee
->definition
1090 && (!DECL_EXTERNAL (edge
->callee
->decl
)
1091 /* When not optimizing, do not try to analyze extern
1092 inline functions. Doing so is pointless. */
1093 || opt_for_fn (edge
->callee
->decl
, optimize
)
1094 /* Weakrefs needs to be preserved. */
1095 || edge
->callee
->alias
1096 /* always_inline functions are inlined aven at -O0. */
1099 DECL_ATTRIBUTES (edge
->callee
->decl
))
1100 /* Multiversioned functions needs the dispatcher to
1101 be produced locally even for extern functions. */
1102 || edge
->callee
->function_version ()))
1103 enqueue_node (edge
->callee
);
1104 if (opt_for_fn (cnode
->decl
, optimize
)
1105 && opt_for_fn (cnode
->decl
, flag_devirtualize
))
1109 for (edge
= cnode
->indirect_calls
; edge
; edge
= next
)
1111 next
= edge
->next_callee
;
1112 if (edge
->indirect_info
->polymorphic
)
1113 walk_polymorphic_call_targets (&reachable_call_targets
,
1118 /* If decl is a clone of an abstract function,
1119 mark that abstract function so that we don't release its body.
1120 The DECL_INITIAL() of that abstract function declaration
1121 will be later needed to output debug info. */
1122 if (DECL_ABSTRACT_ORIGIN (decl
))
1124 cgraph_node
*origin_node
1125 = cgraph_node::get_create (DECL_ABSTRACT_ORIGIN (decl
));
1126 origin_node
->used_as_abstract_origin
= true;
1131 varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
);
1132 if (vnode
&& vnode
->definition
&& !vnode
->analyzed
)
1136 if (node
->same_comdat_group
)
1139 for (next
= node
->same_comdat_group
;
1141 next
= next
->same_comdat_group
)
1142 if (!next
->comdat_local_p ())
1143 enqueue_node (next
);
1145 for (i
= 0; node
->iterate_reference (i
, ref
); i
++)
1146 if (ref
->referred
->definition
1147 && (!DECL_EXTERNAL (ref
->referred
->decl
)
1148 || ((TREE_CODE (ref
->referred
->decl
) != FUNCTION_DECL
1150 || (TREE_CODE (ref
->referred
->decl
) == FUNCTION_DECL
1151 && opt_for_fn (ref
->referred
->decl
, optimize
))
1153 || ref
->referred
->alias
)))
1154 enqueue_node (ref
->referred
);
1155 symtab
->process_new_functions ();
1158 update_type_inheritance_graph ();
1160 /* Collect entry points to the unit. */
1161 if (symtab
->dump_file
)
1163 fprintf (symtab
->dump_file
, "\n\nInitial ");
1164 symtab_node::dump_table (symtab
->dump_file
);
1170 FOR_EACH_SYMBOL (snode
)
1171 check_global_declaration (snode
);
1174 if (symtab
->dump_file
)
1175 fprintf (symtab
->dump_file
, "\nRemoving unused symbols:");
1177 for (node
= symtab
->first_symbol ();
1178 node
!= first_handled
1179 && node
!= first_handled_var
; node
= next
)
1182 if (!node
->aux
&& !node
->referred_to_p ())
1184 if (symtab
->dump_file
)
1185 fprintf (symtab
->dump_file
, " %s", node
->name ());
1187 /* See if the debugger can use anything before the DECL
1188 passes away. Perhaps it can notice a DECL that is now a
1189 constant and can tag the early DIE with an appropriate
1192 Otherwise, this is the last chance the debug_hooks have
1193 at looking at optimized away DECLs, since
1194 late_global_decl will subsequently be called from the
1195 contents of the now pruned symbol table. */
1196 if (!decl_function_context (node
->decl
))
1197 (*debug_hooks
->late_global_decl
) (node
->decl
);
1202 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
))
1204 tree decl
= node
->decl
;
1206 if (cnode
->definition
&& !gimple_has_body_p (decl
)
1208 && !cnode
->thunk
.thunk_p
)
1211 gcc_assert (!cnode
->definition
|| cnode
->thunk
.thunk_p
1213 || gimple_has_body_p (decl
));
1214 gcc_assert (cnode
->analyzed
== cnode
->definition
);
1218 for (;node
; node
= node
->next
)
1220 first_analyzed
= symtab
->first_function ();
1221 first_analyzed_var
= symtab
->first_variable ();
1222 if (symtab
->dump_file
)
1224 fprintf (symtab
->dump_file
, "\n\nReclaimed ");
1225 symtab_node::dump_table (symtab
->dump_file
);
1227 bitmap_obstack_release (NULL
);
1229 /* Initialize assembler name hash, in particular we want to trigger C++
1230 mangling and same body alias creation before we free DECL_ARGUMENTS
1233 symtab
->symtab_initialize_asm_name_hash ();
1235 input_location
= saved_loc
;
1238 /* Translate the ugly representation of aliases as alias pairs into nice
1239 representation in callgraph. We don't handle all cases yet,
1243 handle_alias_pairs (void)
1248 for (i
= 0; alias_pairs
&& alias_pairs
->iterate (i
, &p
);)
1250 symtab_node
*target_node
= symtab_node::get_for_asmname (p
->target
);
1252 /* Weakrefs with target not defined in current unit are easy to handle:
1253 they behave just as external variables except we need to note the
1254 alias flag to later output the weakref pseudo op into asm file. */
1256 && lookup_attribute ("weakref", DECL_ATTRIBUTES (p
->decl
)) != NULL
)
1258 symtab_node
*node
= symtab_node::get (p
->decl
);
1261 node
->alias_target
= p
->target
;
1262 node
->weakref
= true;
1264 node
->transparent_alias
= true;
1266 alias_pairs
->unordered_remove (i
);
1269 else if (!target_node
)
1271 error ("%q+D aliased to undefined symbol %qE", p
->decl
, p
->target
);
1272 symtab_node
*node
= symtab_node::get (p
->decl
);
1274 node
->alias
= false;
1275 alias_pairs
->unordered_remove (i
);
1279 if (DECL_EXTERNAL (target_node
->decl
)
1280 /* We use local aliases for C++ thunks to force the tailcall
1281 to bind locally. This is a hack - to keep it working do
1282 the following (which is not strictly correct). */
1283 && (TREE_CODE (target_node
->decl
) != FUNCTION_DECL
1284 || ! DECL_VIRTUAL_P (target_node
->decl
))
1285 && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (p
->decl
)))
1287 error ("%q+D aliased to external symbol %qE",
1288 p
->decl
, p
->target
);
1291 if (TREE_CODE (p
->decl
) == FUNCTION_DECL
1292 && target_node
&& is_a
<cgraph_node
*> (target_node
))
1294 cgraph_node
*src_node
= cgraph_node::get (p
->decl
);
1295 if (src_node
&& src_node
->definition
)
1297 cgraph_node::create_alias (p
->decl
, target_node
->decl
);
1298 alias_pairs
->unordered_remove (i
);
1300 else if (TREE_CODE (p
->decl
) == VAR_DECL
1301 && target_node
&& is_a
<varpool_node
*> (target_node
))
1303 varpool_node::create_alias (p
->decl
, target_node
->decl
);
1304 alias_pairs
->unordered_remove (i
);
1308 error ("%q+D alias in between function and variable is not supported",
1310 warning (0, "%q+D aliased declaration",
1312 alias_pairs
->unordered_remove (i
);
1315 vec_free (alias_pairs
);
1319 /* Figure out what functions we want to assemble. */
1322 mark_functions_to_output (void)
1324 bool check_same_comdat_groups
= false;
1328 FOR_EACH_FUNCTION (node
)
1329 gcc_assert (!node
->process
);
1331 FOR_EACH_FUNCTION (node
)
1333 tree decl
= node
->decl
;
1335 gcc_assert (!node
->process
|| node
->same_comdat_group
);
1339 /* We need to output all local functions that are used and not
1340 always inlined, as well as those that are reachable from
1341 outside the current compilation unit. */
1343 && !node
->thunk
.thunk_p
1345 && !node
->global
.inlined_to
1346 && !TREE_ASM_WRITTEN (decl
)
1347 && !DECL_EXTERNAL (decl
))
1350 if (node
->same_comdat_group
)
1353 for (next
= dyn_cast
<cgraph_node
*> (node
->same_comdat_group
);
1355 next
= dyn_cast
<cgraph_node
*> (next
->same_comdat_group
))
1356 if (!next
->thunk
.thunk_p
&& !next
->alias
1357 && !next
->comdat_local_p ())
1361 else if (node
->same_comdat_group
)
1364 check_same_comdat_groups
= true;
1368 /* We should've reclaimed all functions that are not needed. */
1370 && !node
->global
.inlined_to
1371 && gimple_has_body_p (decl
)
1372 /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
1373 are inside partition, we can end up not removing the body since we no longer
1374 have analyzed node pointing to it. */
1375 && !node
->in_other_partition
1378 && !DECL_EXTERNAL (decl
))
1381 internal_error ("failed to reclaim unneeded function");
1383 gcc_assert (node
->global
.inlined_to
1384 || !gimple_has_body_p (decl
)
1385 || node
->in_other_partition
1387 || DECL_ARTIFICIAL (decl
)
1388 || DECL_EXTERNAL (decl
));
1393 if (flag_checking
&& check_same_comdat_groups
)
1394 FOR_EACH_FUNCTION (node
)
1395 if (node
->same_comdat_group
&& !node
->process
)
1397 tree decl
= node
->decl
;
1398 if (!node
->global
.inlined_to
1399 && gimple_has_body_p (decl
)
1400 /* FIXME: in an ltrans unit when the offline copy is outside a
1401 partition but inline copies are inside a partition, we can
1402 end up not removing the body since we no longer have an
1403 analyzed node pointing to it. */
1404 && !node
->in_other_partition
1406 && !DECL_EXTERNAL (decl
))
1409 internal_error ("failed to reclaim unneeded function in same "
1415 /* DECL is FUNCTION_DECL. Initialize datastructures so DECL is a function
1416 in lowered gimple form. IN_SSA is true if the gimple is in SSA.
1418 Set current_function_decl and cfun to newly constructed empty function body.
1419 return basic block in the function body. */
1422 init_lowered_empty_function (tree decl
, bool in_ssa
, gcov_type count
)
1427 current_function_decl
= decl
;
1428 allocate_struct_function (decl
, false);
1429 gimple_register_cfg_hooks ();
1430 init_empty_tree_cfg ();
1434 init_tree_ssa (cfun
);
1435 init_ssa_operands (cfun
);
1436 cfun
->gimple_df
->in_ssa_p
= true;
1437 cfun
->curr_properties
|= PROP_ssa
;
1440 DECL_INITIAL (decl
) = make_node (BLOCK
);
1442 DECL_SAVED_TREE (decl
) = error_mark_node
;
1443 cfun
->curr_properties
|= (PROP_gimple_lcf
| PROP_gimple_leh
| PROP_gimple_any
1444 | PROP_cfg
| PROP_loops
);
1446 set_loops_for_fn (cfun
, ggc_cleared_alloc
<loops
> ());
1447 init_loops_structure (cfun
, loops_for_fn (cfun
), 1);
1448 loops_for_fn (cfun
)->state
|= LOOPS_MAY_HAVE_MULTIPLE_LATCHES
;
1450 /* Create BB for body of the function and connect it properly. */
1451 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
= count
;
1452 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->frequency
= REG_BR_PROB_BASE
;
1453 EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
= count
;
1454 EXIT_BLOCK_PTR_FOR_FN (cfun
)->frequency
= REG_BR_PROB_BASE
;
1455 bb
= create_basic_block (NULL
, ENTRY_BLOCK_PTR_FOR_FN (cfun
));
1457 bb
->frequency
= BB_FREQ_MAX
;
1458 e
= make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
), bb
, EDGE_FALLTHRU
);
1460 e
->probability
= REG_BR_PROB_BASE
;
1461 e
= make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
1463 e
->probability
= REG_BR_PROB_BASE
;
1464 add_bb_to_loop (bb
, ENTRY_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
1469 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
1470 offset indicated by VIRTUAL_OFFSET, if that is
1471 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
1472 zero for a result adjusting thunk. */
1475 thunk_adjust (gimple_stmt_iterator
* bsi
,
1476 tree ptr
, bool this_adjusting
,
1477 HOST_WIDE_INT fixed_offset
, tree virtual_offset
)
1483 && fixed_offset
!= 0)
1485 stmt
= gimple_build_assign
1486 (ptr
, fold_build_pointer_plus_hwi_loc (input_location
,
1489 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1492 /* If there's a virtual offset, look up that value in the vtable and
1493 adjust the pointer again. */
1500 if (!vtable_entry_type
)
1502 tree vfunc_type
= make_node (FUNCTION_TYPE
);
1503 TREE_TYPE (vfunc_type
) = integer_type_node
;
1504 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
1505 layout_type (vfunc_type
);
1507 vtable_entry_type
= build_pointer_type (vfunc_type
);
1511 create_tmp_reg (build_pointer_type
1512 (build_pointer_type (vtable_entry_type
)), "vptr");
1514 /* The vptr is always at offset zero in the object. */
1515 stmt
= gimple_build_assign (vtabletmp
,
1516 build1 (NOP_EXPR
, TREE_TYPE (vtabletmp
),
1518 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1520 /* Form the vtable address. */
1521 vtabletmp2
= create_tmp_reg (TREE_TYPE (TREE_TYPE (vtabletmp
)),
1523 stmt
= gimple_build_assign (vtabletmp2
,
1524 build_simple_mem_ref (vtabletmp
));
1525 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1527 /* Find the entry with the vcall offset. */
1528 stmt
= gimple_build_assign (vtabletmp2
,
1529 fold_build_pointer_plus_loc (input_location
,
1532 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1534 /* Get the offset itself. */
1535 vtabletmp3
= create_tmp_reg (TREE_TYPE (TREE_TYPE (vtabletmp2
)),
1537 stmt
= gimple_build_assign (vtabletmp3
,
1538 build_simple_mem_ref (vtabletmp2
));
1539 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1541 /* Adjust the `this' pointer. */
1542 ptr
= fold_build_pointer_plus_loc (input_location
, ptr
, vtabletmp3
);
1543 ptr
= force_gimple_operand_gsi (bsi
, ptr
, true, NULL_TREE
, false,
1544 GSI_CONTINUE_LINKING
);
1548 && fixed_offset
!= 0)
1549 /* Adjust the pointer by the constant. */
1553 if (TREE_CODE (ptr
) == VAR_DECL
)
1557 ptrtmp
= create_tmp_reg (TREE_TYPE (ptr
), "ptr");
1558 stmt
= gimple_build_assign (ptrtmp
, ptr
);
1559 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1561 ptr
= fold_build_pointer_plus_hwi_loc (input_location
,
1562 ptrtmp
, fixed_offset
);
1565 /* Emit the statement and gimplify the adjustment expression. */
1566 ret
= create_tmp_reg (TREE_TYPE (ptr
), "adjusted_this");
1567 stmt
= gimple_build_assign (ret
, ptr
);
1568 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1573 /* Expand thunk NODE to gimple if possible.
1574 When FORCE_GIMPLE_THUNK is true, gimple thunk is created and
1575 no assembler is produced.
1576 When OUTPUT_ASM_THUNK is true, also produce assembler for
1577 thunks that are not lowered. */
1580 cgraph_node::expand_thunk (bool output_asm_thunks
, bool force_gimple_thunk
)
1582 bool this_adjusting
= thunk
.this_adjusting
;
1583 HOST_WIDE_INT fixed_offset
= thunk
.fixed_offset
;
1584 HOST_WIDE_INT virtual_value
= thunk
.virtual_value
;
1585 tree virtual_offset
= NULL
;
1586 tree alias
= callees
->callee
->decl
;
1587 tree thunk_fndecl
= decl
;
1590 /* Instrumentation thunk is the same function with
1591 a different signature. Never need to expand it. */
1592 if (thunk
.add_pointer_bounds_args
)
1595 if (!force_gimple_thunk
&& this_adjusting
1596 && targetm
.asm_out
.can_output_mi_thunk (thunk_fndecl
, fixed_offset
,
1597 virtual_value
, alias
))
1601 tree restype
= TREE_TYPE (TREE_TYPE (thunk_fndecl
));
1603 if (!output_asm_thunks
)
1610 get_untransformed_body ();
1611 a
= DECL_ARGUMENTS (thunk_fndecl
);
1613 current_function_decl
= thunk_fndecl
;
1615 /* Ensure thunks are emitted in their correct sections. */
1616 resolve_unique_section (thunk_fndecl
, 0,
1617 flag_function_sections
);
1619 DECL_RESULT (thunk_fndecl
)
1620 = build_decl (DECL_SOURCE_LOCATION (thunk_fndecl
),
1621 RESULT_DECL
, 0, restype
);
1622 DECL_CONTEXT (DECL_RESULT (thunk_fndecl
)) = thunk_fndecl
;
1623 fnname
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk_fndecl
));
1625 /* The back end expects DECL_INITIAL to contain a BLOCK, so we
1627 fn_block
= make_node (BLOCK
);
1628 BLOCK_VARS (fn_block
) = a
;
1629 DECL_INITIAL (thunk_fndecl
) = fn_block
;
1630 allocate_struct_function (thunk_fndecl
, false);
1631 init_function_start (thunk_fndecl
);
1633 insn_locations_init ();
1634 set_curr_insn_location (DECL_SOURCE_LOCATION (thunk_fndecl
));
1635 prologue_location
= curr_insn_location ();
1636 assemble_start_function (thunk_fndecl
, fnname
);
1638 targetm
.asm_out
.output_mi_thunk (asm_out_file
, thunk_fndecl
,
1639 fixed_offset
, virtual_value
, alias
);
1641 assemble_end_function (thunk_fndecl
, fnname
);
1642 insn_locations_finalize ();
1643 init_insn_lengths ();
1644 free_after_compilation (cfun
);
1645 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
1646 thunk
.thunk_p
= false;
1649 else if (stdarg_p (TREE_TYPE (thunk_fndecl
)))
1651 error ("generic thunk code fails for method %qD which uses %<...%>",
1653 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
1660 basic_block bb
, then_bb
, else_bb
, return_bb
;
1661 gimple_stmt_iterator bsi
;
1671 bool alias_is_noreturn
= TREE_THIS_VOLATILE (alias
);
1673 /* We may be called from expand_thunk that releses body except for
1674 DECL_ARGUMENTS. In this case force_gimple_thunk is true. */
1675 if (in_lto_p
&& !force_gimple_thunk
)
1676 get_untransformed_body ();
1677 a
= DECL_ARGUMENTS (thunk_fndecl
);
1679 current_function_decl
= thunk_fndecl
;
1681 /* Ensure thunks are emitted in their correct sections. */
1682 resolve_unique_section (thunk_fndecl
, 0,
1683 flag_function_sections
);
1685 DECL_IGNORED_P (thunk_fndecl
) = 1;
1686 bitmap_obstack_initialize (NULL
);
1688 if (thunk
.virtual_offset_p
)
1689 virtual_offset
= size_int (virtual_value
);
1691 /* Build the return declaration for the function. */
1692 restype
= TREE_TYPE (TREE_TYPE (thunk_fndecl
));
1693 if (DECL_RESULT (thunk_fndecl
) == NULL_TREE
)
1695 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
1696 DECL_ARTIFICIAL (resdecl
) = 1;
1697 DECL_IGNORED_P (resdecl
) = 1;
1698 DECL_RESULT (thunk_fndecl
) = resdecl
;
1699 DECL_CONTEXT (DECL_RESULT (thunk_fndecl
)) = thunk_fndecl
;
1702 resdecl
= DECL_RESULT (thunk_fndecl
);
1704 bb
= then_bb
= else_bb
= return_bb
1705 = init_lowered_empty_function (thunk_fndecl
, true, count
);
1707 bsi
= gsi_start_bb (bb
);
1709 /* Build call to the function being thunked. */
1710 if (!VOID_TYPE_P (restype
)
1711 && (!alias_is_noreturn
1712 || TREE_ADDRESSABLE (restype
)
1713 || TREE_CODE (TYPE_SIZE_UNIT (restype
)) != INTEGER_CST
))
1715 if (DECL_BY_REFERENCE (resdecl
))
1717 restmp
= gimple_fold_indirect_ref (resdecl
);
1719 restmp
= build2 (MEM_REF
,
1720 TREE_TYPE (TREE_TYPE (DECL_RESULT (alias
))),
1722 build_int_cst (TREE_TYPE
1723 (DECL_RESULT (alias
)), 0));
1725 else if (!is_gimple_reg_type (restype
))
1727 if (aggregate_value_p (resdecl
, TREE_TYPE (thunk_fndecl
)))
1731 if (TREE_CODE (restmp
) == VAR_DECL
)
1732 add_local_decl (cfun
, restmp
);
1733 BLOCK_VARS (DECL_INITIAL (current_function_decl
)) = restmp
;
1736 restmp
= create_tmp_var (restype
, "retval");
1739 restmp
= create_tmp_reg (restype
, "retval");
1742 for (arg
= a
; arg
; arg
= DECL_CHAIN (arg
))
1744 auto_vec
<tree
> vargs (nargs
);
1749 vargs
.quick_push (thunk_adjust (&bsi
, a
, 1, fixed_offset
,
1751 arg
= DECL_CHAIN (a
);
1756 for (; i
< nargs
; i
++, arg
= DECL_CHAIN (arg
))
1759 if (!is_gimple_val (arg
))
1761 tmp
= create_tmp_reg (TYPE_MAIN_VARIANT
1762 (TREE_TYPE (arg
)), "arg");
1763 gimple
*stmt
= gimple_build_assign (tmp
, arg
);
1764 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1766 vargs
.quick_push (tmp
);
1768 call
= gimple_build_call_vec (build_fold_addr_expr_loc (0, alias
), vargs
);
1769 callees
->call_stmt
= call
;
1770 gimple_call_set_from_thunk (call
, true);
1771 gimple_call_set_with_bounds (call
, instrumentation_clone
);
1773 /* Return slot optimization is always possible and in fact requred to
1774 return values with DECL_BY_REFERENCE. */
1775 if (aggregate_value_p (resdecl
, TREE_TYPE (thunk_fndecl
))
1776 && (!is_gimple_reg_type (TREE_TYPE (resdecl
))
1777 || DECL_BY_REFERENCE (resdecl
)))
1778 gimple_call_set_return_slot_opt (call
, true);
1782 gimple_call_set_lhs (call
, restmp
);
1783 gcc_assert (useless_type_conversion_p (TREE_TYPE (restmp
),
1784 TREE_TYPE (TREE_TYPE (alias
))));
1786 gsi_insert_after (&bsi
, call
, GSI_NEW_STMT
);
1787 if (!alias_is_noreturn
)
1789 if (instrumentation_clone
1790 && !DECL_BY_REFERENCE (resdecl
)
1792 && BOUNDED_P (restmp
))
1794 resbnd
= chkp_insert_retbnd_call (NULL
, restmp
, &bsi
);
1795 create_edge (get_create (gimple_call_fndecl (gsi_stmt (bsi
))),
1796 as_a
<gcall
*> (gsi_stmt (bsi
)),
1797 callees
->count
, callees
->frequency
);
1800 if (restmp
&& !this_adjusting
1801 && (fixed_offset
|| virtual_offset
))
1803 tree true_label
= NULL_TREE
;
1805 if (TREE_CODE (TREE_TYPE (restmp
)) == POINTER_TYPE
)
1809 /* If the return type is a pointer, we need to
1810 protect against NULL. We know there will be an
1811 adjustment, because that's why we're emitting a
1813 then_bb
= create_basic_block (NULL
, bb
);
1814 then_bb
->count
= count
- count
/ 16;
1815 then_bb
->frequency
= BB_FREQ_MAX
- BB_FREQ_MAX
/ 16;
1816 return_bb
= create_basic_block (NULL
, then_bb
);
1817 return_bb
->count
= count
;
1818 return_bb
->frequency
= BB_FREQ_MAX
;
1819 else_bb
= create_basic_block (NULL
, else_bb
);
1820 then_bb
->count
= count
/ 16;
1821 then_bb
->frequency
= BB_FREQ_MAX
/ 16;
1822 add_bb_to_loop (then_bb
, bb
->loop_father
);
1823 add_bb_to_loop (return_bb
, bb
->loop_father
);
1824 add_bb_to_loop (else_bb
, bb
->loop_father
);
1825 remove_edge (single_succ_edge (bb
));
1826 true_label
= gimple_block_label (then_bb
);
1827 stmt
= gimple_build_cond (NE_EXPR
, restmp
,
1828 build_zero_cst (TREE_TYPE (restmp
)),
1829 NULL_TREE
, NULL_TREE
);
1830 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1831 e
= make_edge (bb
, then_bb
, EDGE_TRUE_VALUE
);
1832 e
->probability
= REG_BR_PROB_BASE
- REG_BR_PROB_BASE
/ 16;
1833 e
->count
= count
- count
/ 16;
1834 e
= make_edge (bb
, else_bb
, EDGE_FALSE_VALUE
);
1835 e
->probability
= REG_BR_PROB_BASE
/ 16;
1836 e
->count
= count
/ 16;
1837 e
= make_edge (return_bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
1838 e
->probability
= REG_BR_PROB_BASE
;
1840 e
= make_edge (then_bb
, return_bb
, EDGE_FALLTHRU
);
1841 e
->probability
= REG_BR_PROB_BASE
;
1842 e
->count
= count
- count
/ 16;
1843 e
= make_edge (else_bb
, return_bb
, EDGE_FALLTHRU
);
1844 e
->probability
= REG_BR_PROB_BASE
;
1845 e
->count
= count
/ 16;
1846 bsi
= gsi_last_bb (then_bb
);
1849 restmp
= thunk_adjust (&bsi
, restmp
, /*this_adjusting=*/0,
1850 fixed_offset
, virtual_offset
);
1854 bsi
= gsi_last_bb (else_bb
);
1855 stmt
= gimple_build_assign (restmp
,
1856 build_zero_cst (TREE_TYPE (restmp
)));
1857 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1858 bsi
= gsi_last_bb (return_bb
);
1862 gimple_call_set_tail (call
, true);
1864 /* Build return value. */
1865 if (!DECL_BY_REFERENCE (resdecl
))
1866 ret
= gimple_build_return (restmp
);
1868 ret
= gimple_build_return (resdecl
);
1869 gimple_return_set_retbnd (ret
, resbnd
);
1871 gsi_insert_after (&bsi
, ret
, GSI_NEW_STMT
);
1875 gimple_call_set_tail (call
, true);
1876 remove_edge (single_succ_edge (bb
));
1879 cfun
->gimple_df
->in_ssa_p
= true;
1880 profile_status_for_fn (cfun
)
1881 = count
? PROFILE_READ
: PROFILE_GUESSED
;
1882 /* FIXME: C++ FE should stop setting TREE_ASM_WRITTEN on thunks. */
1883 TREE_ASM_WRITTEN (thunk_fndecl
) = false;
1884 delete_unreachable_blocks ();
1885 update_ssa (TODO_update_ssa
);
1886 checking_verify_flow_info ();
1887 free_dominance_info (CDI_DOMINATORS
);
1889 /* Since we want to emit the thunk, we explicitly mark its name as
1891 thunk
.thunk_p
= false;
1893 bitmap_obstack_release (NULL
);
1895 current_function_decl
= NULL
;
1900 /* Assemble thunks and aliases associated to node. */
1903 cgraph_node::assemble_thunks_and_aliases (void)
1908 for (e
= callers
; e
;)
1909 if (e
->caller
->thunk
.thunk_p
1910 && !e
->caller
->thunk
.add_pointer_bounds_args
)
1912 cgraph_node
*thunk
= e
->caller
;
1915 thunk
->expand_thunk (true, false);
1916 thunk
->assemble_thunks_and_aliases ();
1921 FOR_EACH_ALIAS (this, ref
)
1923 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
1924 if (!alias
->transparent_alias
)
1926 bool saved_written
= TREE_ASM_WRITTEN (decl
);
1928 /* Force assemble_alias to really output the alias this time instead
1929 of buffering it in same alias pairs. */
1930 TREE_ASM_WRITTEN (decl
) = 1;
1931 do_assemble_alias (alias
->decl
,
1932 DECL_ASSEMBLER_NAME (decl
));
1933 alias
->assemble_thunks_and_aliases ();
1934 TREE_ASM_WRITTEN (decl
) = saved_written
;
1939 /* Expand function specified by node. */
1942 cgraph_node::expand (void)
1944 location_t saved_loc
;
1946 /* We ought to not compile any inline clones. */
1947 gcc_assert (!global
.inlined_to
);
1949 announce_function (decl
);
1951 gcc_assert (lowered
);
1952 get_untransformed_body ();
1954 /* Generate RTL for the body of DECL. */
1956 timevar_push (TV_REST_OF_COMPILATION
);
1958 gcc_assert (symtab
->global_info_ready
);
1960 /* Initialize the default bitmap obstack. */
1961 bitmap_obstack_initialize (NULL
);
1963 /* Initialize the RTL code for the function. */
1964 saved_loc
= input_location
;
1965 input_location
= DECL_SOURCE_LOCATION (decl
);
1967 gcc_assert (DECL_STRUCT_FUNCTION (decl
));
1968 push_cfun (DECL_STRUCT_FUNCTION (decl
));
1969 init_function_start (decl
);
1971 gimple_register_cfg_hooks ();
1973 bitmap_obstack_initialize (®_obstack
); /* FIXME, only at RTL generation*/
1975 execute_all_ipa_transforms ();
1977 /* Perform all tree transforms and optimizations. */
1979 /* Signal the start of passes. */
1980 invoke_plugin_callbacks (PLUGIN_ALL_PASSES_START
, NULL
);
1982 execute_pass_list (cfun
, g
->get_passes ()->all_passes
);
1984 /* Signal the end of passes. */
1985 invoke_plugin_callbacks (PLUGIN_ALL_PASSES_END
, NULL
);
1987 bitmap_obstack_release (®_obstack
);
1989 /* Release the default bitmap obstack. */
1990 bitmap_obstack_release (NULL
);
1992 /* If requested, warn about function definitions where the function will
1993 return a value (usually of some struct or union type) which itself will
1994 take up a lot of stack space. */
1995 if (warn_larger_than
&& !DECL_EXTERNAL (decl
) && TREE_TYPE (decl
))
1997 tree ret_type
= TREE_TYPE (TREE_TYPE (decl
));
1999 if (ret_type
&& TYPE_SIZE_UNIT (ret_type
)
2000 && TREE_CODE (TYPE_SIZE_UNIT (ret_type
)) == INTEGER_CST
2001 && 0 < compare_tree_int (TYPE_SIZE_UNIT (ret_type
),
2004 unsigned int size_as_int
2005 = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (ret_type
));
2007 if (compare_tree_int (TYPE_SIZE_UNIT (ret_type
), size_as_int
) == 0)
2008 warning (OPT_Wlarger_than_
, "size of return value of %q+D is %u bytes",
2011 warning (OPT_Wlarger_than_
, "size of return value of %q+D is larger than %wd bytes",
2012 decl
, larger_than_size
);
2016 gimple_set_body (decl
, NULL
);
2017 if (DECL_STRUCT_FUNCTION (decl
) == 0
2018 && !cgraph_node::get (decl
)->origin
)
2020 /* Stop pointing to the local nodes about to be freed.
2021 But DECL_INITIAL must remain nonzero so we know this
2022 was an actual function definition.
2023 For a nested function, this is done in c_pop_function_context.
2024 If rest_of_compilation set this to 0, leave it 0. */
2025 if (DECL_INITIAL (decl
) != 0)
2026 DECL_INITIAL (decl
) = error_mark_node
;
2029 input_location
= saved_loc
;
2032 timevar_pop (TV_REST_OF_COMPILATION
);
2034 /* Make sure that BE didn't give up on compiling. */
2035 gcc_assert (TREE_ASM_WRITTEN (decl
));
2039 /* It would make a lot more sense to output thunks before function body to get more
2040 forward and lest backwarding jumps. This however would need solving problem
2041 with comdats. See PR48668. Also aliases must come after function itself to
2042 make one pass assemblers, like one on AIX, happy. See PR 50689.
2043 FIXME: Perhaps thunks should be move before function IFF they are not in comdat
2045 assemble_thunks_and_aliases ();
2047 /* Eliminate all call edges. This is important so the GIMPLE_CALL no longer
2048 points to the dead function body. */
2050 remove_all_references ();
2053 /* Node comparer that is responsible for the order that corresponds
2054 to time when a function was launched for the first time. */
2057 node_cmp (const void *pa
, const void *pb
)
2059 const cgraph_node
*a
= *(const cgraph_node
* const *) pa
;
2060 const cgraph_node
*b
= *(const cgraph_node
* const *) pb
;
2062 /* Functions with time profile must be before these without profile. */
2063 if (!a
->tp_first_run
|| !b
->tp_first_run
)
2064 return a
->tp_first_run
- b
->tp_first_run
;
2066 return a
->tp_first_run
!= b
->tp_first_run
2067 ? b
->tp_first_run
- a
->tp_first_run
2068 : b
->order
- a
->order
;
2071 /* Expand all functions that must be output.
2073 Attempt to topologically sort the nodes so function is output when
2074 all called functions are already assembled to allow data to be
2075 propagated across the callgraph. Use a stack to get smaller distance
2076 between a function and its callees (later we may choose to use a more
2077 sophisticated algorithm for function reordering; we will likely want
2078 to use subsections to make the output functions appear in top-down
2082 expand_all_functions (void)
2085 cgraph_node
**order
= XCNEWVEC (cgraph_node
*,
2086 symtab
->cgraph_count
);
2087 unsigned int expanded_func_count
= 0, profiled_func_count
= 0;
2088 int order_pos
, new_order_pos
= 0;
2091 order_pos
= ipa_reverse_postorder (order
);
2092 gcc_assert (order_pos
== symtab
->cgraph_count
);
2094 /* Garbage collector may remove inline clones we eliminate during
2095 optimization. So we must be sure to not reference them. */
2096 for (i
= 0; i
< order_pos
; i
++)
2097 if (order
[i
]->process
)
2098 order
[new_order_pos
++] = order
[i
];
2100 if (flag_profile_reorder_functions
)
2101 qsort (order
, new_order_pos
, sizeof (cgraph_node
*), node_cmp
);
2103 for (i
= new_order_pos
- 1; i
>= 0; i
--)
2109 expanded_func_count
++;
2110 if(node
->tp_first_run
)
2111 profiled_func_count
++;
2113 if (symtab
->dump_file
)
2114 fprintf (symtab
->dump_file
,
2115 "Time profile order in expand_all_functions:%s:%d\n",
2116 node
->asm_name (), node
->tp_first_run
);
2123 fprintf (dump_file
, "Expanded functions with time profile (%s):%u/%u\n",
2124 main_input_filename
, profiled_func_count
, expanded_func_count
);
2126 if (symtab
->dump_file
&& flag_profile_reorder_functions
)
2127 fprintf (symtab
->dump_file
, "Expanded functions with time profile:%u/%u\n",
2128 profiled_func_count
, expanded_func_count
);
2130 symtab
->process_new_functions ();
2131 free_gimplify_stack ();
2136 /* This is used to sort the node types by the cgraph order number. */
2138 enum cgraph_order_sort_kind
2140 ORDER_UNDEFINED
= 0,
2146 struct cgraph_order_sort
2148 enum cgraph_order_sort_kind kind
;
2157 /* Output all functions, variables, and asm statements in the order
2158 according to their order fields, which is the order in which they
2159 appeared in the file. This implements -fno-toplevel-reorder. In
2160 this mode we may output functions and variables which don't really
2162 When NO_REORDER is true only do this for symbols marked no reorder. */
2165 output_in_order (bool no_reorder
)
2168 cgraph_order_sort
*nodes
;
2173 max
= symtab
->order
;
2174 nodes
= XCNEWVEC (cgraph_order_sort
, max
);
2176 FOR_EACH_DEFINED_FUNCTION (pf
)
2178 if (pf
->process
&& !pf
->thunk
.thunk_p
&& !pf
->alias
)
2180 if (no_reorder
&& !pf
->no_reorder
)
2183 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
2184 nodes
[i
].kind
= ORDER_FUNCTION
;
2189 FOR_EACH_DEFINED_VARIABLE (pv
)
2190 if (!DECL_EXTERNAL (pv
->decl
))
2192 if (no_reorder
&& !pv
->no_reorder
)
2195 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
2196 nodes
[i
].kind
= ORDER_VAR
;
2200 for (pa
= symtab
->first_asm_symbol (); pa
; pa
= pa
->next
)
2203 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
2204 nodes
[i
].kind
= ORDER_ASM
;
2208 /* In toplevel reorder mode we output all statics; mark them as needed. */
2210 for (i
= 0; i
< max
; ++i
)
2211 if (nodes
[i
].kind
== ORDER_VAR
)
2212 nodes
[i
].u
.v
->finalize_named_section_flags ();
2214 for (i
= 0; i
< max
; ++i
)
2216 switch (nodes
[i
].kind
)
2218 case ORDER_FUNCTION
:
2219 nodes
[i
].u
.f
->process
= 0;
2220 nodes
[i
].u
.f
->expand ();
2224 #ifdef ACCEL_COMPILER
2225 /* Do not assemble "omp declare target link" vars. */
2226 if (DECL_HAS_VALUE_EXPR_P (nodes
[i
].u
.v
->decl
)
2227 && lookup_attribute ("omp declare target link",
2228 DECL_ATTRIBUTES (nodes
[i
].u
.v
->decl
)))
2231 nodes
[i
].u
.v
->assemble_decl ();
2235 assemble_asm (nodes
[i
].u
.a
->asm_str
);
2238 case ORDER_UNDEFINED
:
2246 symtab
->clear_asm_symbols ();
2254 gcc::pass_manager
*passes
= g
->get_passes ();
2257 current_function_decl
= NULL
;
2258 gimple_register_cfg_hooks ();
2259 bitmap_obstack_initialize (NULL
);
2261 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_START
, NULL
);
2265 execute_ipa_pass_list (passes
->all_small_ipa_passes
);
2270 /* This extra symtab_remove_unreachable_nodes pass tends to catch some
2271 devirtualization and other changes where removal iterate. */
2272 symtab
->remove_unreachable_nodes (symtab
->dump_file
);
2274 /* If pass_all_early_optimizations was not scheduled, the state of
2275 the cgraph will not be properly updated. Update it now. */
2276 if (symtab
->state
< IPA_SSA
)
2277 symtab
->state
= IPA_SSA
;
2281 /* Generate coverage variables and constructors. */
2284 /* Process new functions added. */
2286 current_function_decl
= NULL
;
2287 symtab
->process_new_functions ();
2289 execute_ipa_summary_passes
2290 ((ipa_opt_pass_d
*) passes
->all_regular_ipa_passes
);
2293 /* Some targets need to handle LTO assembler output specially. */
2294 if (flag_generate_lto
|| flag_generate_offload
)
2295 targetm
.asm_out
.lto_start ();
2299 if (g
->have_offload
)
2301 section_name_prefix
= OFFLOAD_SECTION_NAME_PREFIX
;
2302 lto_stream_offload_p
= true;
2303 ipa_write_summaries ();
2304 lto_stream_offload_p
= false;
2308 section_name_prefix
= LTO_SECTION_NAME_PREFIX
;
2309 lto_stream_offload_p
= false;
2310 ipa_write_summaries ();
2314 if (flag_generate_lto
|| flag_generate_offload
)
2315 targetm
.asm_out
.lto_end ();
2317 if (!flag_ltrans
&& (in_lto_p
|| !flag_lto
|| flag_fat_lto_objects
))
2318 execute_ipa_pass_list (passes
->all_regular_ipa_passes
);
2319 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_END
, NULL
);
2321 bitmap_obstack_release (NULL
);
2325 /* Return string alias is alias of. */
2328 get_alias_symbol (tree decl
)
2330 tree alias
= lookup_attribute ("alias", DECL_ATTRIBUTES (decl
));
2331 return get_identifier (TREE_STRING_POINTER
2332 (TREE_VALUE (TREE_VALUE (alias
))));
2336 /* Weakrefs may be associated to external decls and thus not output
2337 at expansion time. Emit all necessary aliases. */
2340 symbol_table::output_weakrefs (void)
2344 FOR_EACH_SYMBOL (node
)
2346 && !TREE_ASM_WRITTEN (node
->decl
)
2347 && (!(cnode
= dyn_cast
<cgraph_node
*> (node
))
2348 || !cnode
->instrumented_version
2349 || !TREE_ASM_WRITTEN (cnode
->instrumented_version
->decl
))
2354 /* Weakrefs are special by not requiring target definition in current
2355 compilation unit. It is thus bit hard to work out what we want to
2357 When alias target is defined, we need to fetch it from symtab reference,
2358 otherwise it is pointed to by alias_target. */
2359 if (node
->alias_target
)
2360 target
= (DECL_P (node
->alias_target
)
2361 ? DECL_ASSEMBLER_NAME (node
->alias_target
)
2362 : node
->alias_target
);
2363 else if (node
->analyzed
)
2364 target
= DECL_ASSEMBLER_NAME (node
->get_alias_target ()->decl
);
2368 target
= get_alias_symbol (node
->decl
);
2370 do_assemble_alias (node
->decl
, target
);
2374 /* Perform simple optimizations based on callgraph. */
2377 symbol_table::compile (void)
2382 symtab_node::checking_verify_symtab_nodes ();
2384 timevar_push (TV_CGRAPHOPT
);
2385 if (pre_ipa_mem_report
)
2387 fprintf (stderr
, "Memory consumption before IPA\n");
2388 dump_memory_report (false);
2391 fprintf (stderr
, "Performing interprocedural optimizations\n");
2394 /* Offloading requires LTO infrastructure. */
2395 if (!in_lto_p
&& g
->have_offload
)
2396 flag_generate_offload
= 1;
2398 /* If LTO is enabled, initialize the streamer hooks needed by GIMPLE. */
2399 if (flag_generate_lto
|| flag_generate_offload
)
2400 lto_streamer_hooks_init ();
2402 /* Don't run the IPA passes if there was any error or sorry messages. */
2406 /* Do nothing else if any IPA pass found errors or if we are just streaming LTO. */
2408 || (!in_lto_p
&& flag_lto
&& !flag_fat_lto_objects
))
2410 timevar_pop (TV_CGRAPHOPT
);
2414 global_info_ready
= true;
2417 fprintf (dump_file
, "Optimized ");
2418 symtab_node:: dump_table (dump_file
);
2420 if (post_ipa_mem_report
)
2422 fprintf (stderr
, "Memory consumption after IPA\n");
2423 dump_memory_report (false);
2425 timevar_pop (TV_CGRAPHOPT
);
2427 /* Output everything. */
2428 (*debug_hooks
->assembly_start
) ();
2430 fprintf (stderr
, "Assembling functions:\n");
2431 symtab_node::checking_verify_symtab_nodes ();
2433 materialize_all_clones ();
2434 bitmap_obstack_initialize (NULL
);
2435 execute_ipa_pass_list (g
->get_passes ()->all_late_ipa_passes
);
2436 bitmap_obstack_release (NULL
);
2437 mark_functions_to_output ();
2439 /* When weakref support is missing, we autmatically translate all
2440 references to NODE to references to its ultimate alias target.
2441 The renaming mechanizm uses flag IDENTIFIER_TRANSPARENT_ALIAS and
2444 Set up this mapping before we output any assembler but once we are sure
2445 that all symbol renaming is done.
2447 FIXME: All this uglyness can go away if we just do renaming at gimple
2448 level by physically rewritting the IL. At the moment we can only redirect
2449 calls, so we need infrastructure for renaming references as well. */
2450 #ifndef ASM_OUTPUT_WEAKREF
2453 FOR_EACH_SYMBOL (node
)
2455 && lookup_attribute ("weakref", DECL_ATTRIBUTES (node
->decl
)))
2457 IDENTIFIER_TRANSPARENT_ALIAS
2458 (DECL_ASSEMBLER_NAME (node
->decl
)) = 1;
2459 TREE_CHAIN (DECL_ASSEMBLER_NAME (node
->decl
))
2460 = (node
->alias_target
? node
->alias_target
2461 : DECL_ASSEMBLER_NAME (node
->get_alias_target ()->decl
));
2467 if (!flag_toplevel_reorder
)
2468 output_in_order (false);
2471 /* Output first asm statements and anything ordered. The process
2472 flag is cleared for these nodes, so we skip them later. */
2473 output_in_order (true);
2474 expand_all_functions ();
2475 output_variables ();
2478 process_new_functions ();
2484 fprintf (dump_file
, "\nFinal ");
2485 symtab_node::dump_table (dump_file
);
2489 symtab_node::verify_symtab_nodes ();
2490 /* Double check that all inline clones are gone and that all
2491 function bodies have been released from memory. */
2495 bool error_found
= false;
2497 FOR_EACH_DEFINED_FUNCTION (node
)
2498 if (node
->global
.inlined_to
2499 || gimple_has_body_p (node
->decl
))
2505 internal_error ("nodes with unreleased memory found");
2510 /* Analyze the whole compilation unit once it is parsed completely. */
2513 symbol_table::finalize_compilation_unit (void)
2515 timevar_push (TV_CGRAPH
);
2517 /* If we're here there's no current function anymore. Some frontends
2518 are lazy in clearing these. */
2519 current_function_decl
= NULL
;
2522 /* Do not skip analyzing the functions if there were errors, we
2523 miss diagnostics for following functions otherwise. */
2525 /* Emit size functions we didn't inline. */
2526 finalize_size_functions ();
2528 /* Mark alias targets necessary and emit diagnostics. */
2529 handle_alias_pairs ();
2533 fprintf (stderr
, "\nAnalyzing compilation unit\n");
2537 if (flag_dump_passes
)
2540 /* Gimplify and lower all functions, compute reachability and
2541 remove unreachable nodes. */
2542 analyze_functions (/*first_time=*/true);
2544 /* Mark alias targets necessary and emit diagnostics. */
2545 handle_alias_pairs ();
2547 /* Gimplify and lower thunks. */
2548 analyze_functions (/*first_time=*/false);
2552 /* Emit early debug for reachable functions, and by consequence,
2553 locally scoped symbols. */
2554 struct cgraph_node
*cnode
;
2555 FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (cnode
)
2556 (*debug_hooks
->early_global_decl
) (cnode
->decl
);
2558 /* Clean up anything that needs cleaning up after initial debug
2560 (*debug_hooks
->early_finish
) ();
2563 /* Finally drive the pass manager. */
2566 timevar_pop (TV_CGRAPH
);
2569 /* Reset all state within cgraphunit.c so that we can rerun the compiler
2570 within the same process. For use by toplev::finalize. */
2573 cgraphunit_c_finalize (void)
2575 gcc_assert (cgraph_new_nodes
.length () == 0);
2576 cgraph_new_nodes
.truncate (0);
2578 vtable_entry_type
= NULL
;
2579 queued_nodes
= &symtab_terminator
;
2581 first_analyzed
= NULL
;
2582 first_analyzed_var
= NULL
;
2585 /* Creates a wrapper from cgraph_node to TARGET node. Thunk is used for this
2586 kind of wrapper method. */
2589 cgraph_node::create_wrapper (cgraph_node
*target
)
2591 /* Preserve DECL_RESULT so we get right by reference flag. */
2592 tree decl_result
= DECL_RESULT (decl
);
2594 /* Remove the function's body but keep arguments to be reused
2596 release_body (true);
2599 DECL_UNINLINABLE (decl
) = false;
2600 DECL_RESULT (decl
) = decl_result
;
2601 DECL_INITIAL (decl
) = NULL
;
2602 allocate_struct_function (decl
, false);
2605 /* Turn alias into thunk and expand it into GIMPLE representation. */
2608 memset (&thunk
, 0, sizeof (cgraph_thunk_info
));
2609 thunk
.thunk_p
= true;
2610 create_edge (target
, NULL
, count
, CGRAPH_FREQ_BASE
);
2611 callees
->can_throw_external
= !TREE_NOTHROW (target
->decl
);
2613 tree arguments
= DECL_ARGUMENTS (decl
);
2617 TREE_ADDRESSABLE (arguments
) = false;
2618 arguments
= TREE_CHAIN (arguments
);
2621 expand_thunk (false, true);
2623 /* Inline summary set-up. */
2625 inline_analyze_function (this);
2628 #include "gt-cgraphunit.h"