1 /* Driver of optimization process
2 Copyright (C) 2003-2019 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 optimizations 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, transactional 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 streaming. 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 multiple 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 functions (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 "tree-vrp.h"
194 #include "ipa-prop.h"
195 #include "gimple-pretty-print.h"
197 #include "ipa-fnsummary.h"
198 #include "ipa-utils.h"
202 #include "pass_manager.h"
203 #include "tree-nested.h"
205 #include "lto-section-names.h"
206 #include "stringpool.h"
209 /* Queue of cgraph nodes scheduled to be added into cgraph. This is a
210 secondary queue used during optimization to accommodate passes that
211 may generate new functions that need to be optimized and expanded. */
212 vec
<cgraph_node
*> cgraph_new_nodes
;
214 static void expand_all_functions (void);
215 static void mark_functions_to_output (void);
216 static void handle_alias_pairs (void);
218 /* Used for vtable lookup in thunk adjusting. */
219 static GTY (()) tree vtable_entry_type
;
221 /* Return true if this symbol is a function from the C frontend specified
222 directly in RTL form (with "__RTL"). */
225 symtab_node::native_rtl_p () const
227 if (TREE_CODE (decl
) != FUNCTION_DECL
)
229 if (!DECL_STRUCT_FUNCTION (decl
))
231 return DECL_STRUCT_FUNCTION (decl
)->curr_properties
& PROP_rtl
;
234 /* Determine if symbol declaration is needed. That is, visible to something
235 either outside this translation unit, something magic in the system
238 symtab_node::needed_p (void)
240 /* Double check that no one output the function into assembly file
242 if (!native_rtl_p ())
244 (!DECL_ASSEMBLER_NAME_SET_P (decl
)
245 || !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)));
250 if (DECL_EXTERNAL (decl
))
253 /* If the user told us it is used, then it must be so. */
257 /* ABI forced symbols are needed when they are external. */
258 if (forced_by_abi
&& TREE_PUBLIC (decl
))
261 /* Keep constructors, destructors and virtual functions. */
262 if (TREE_CODE (decl
) == FUNCTION_DECL
263 && (DECL_STATIC_CONSTRUCTOR (decl
) || DECL_STATIC_DESTRUCTOR (decl
)))
266 /* Externally visible variables must be output. The exception is
267 COMDAT variables that must be output only when they are needed. */
268 if (TREE_PUBLIC (decl
) && !DECL_COMDAT (decl
))
274 /* Head and terminator of the queue of nodes to be processed while building
277 static symtab_node symtab_terminator
;
278 static symtab_node
*queued_nodes
= &symtab_terminator
;
280 /* Add NODE to queue starting at QUEUED_NODES.
281 The queue is linked via AUX pointers and terminated by pointer to 1. */
284 enqueue_node (symtab_node
*node
)
288 gcc_checking_assert (queued_nodes
);
289 node
->aux
= queued_nodes
;
293 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
294 functions into callgraph in a way so they look like ordinary reachable
295 functions inserted into callgraph already at construction time. */
298 symbol_table::process_new_functions (void)
302 if (!cgraph_new_nodes
.exists ())
305 handle_alias_pairs ();
306 /* Note that this queue may grow as its being processed, as the new
307 functions may generate new ones. */
308 for (unsigned i
= 0; i
< cgraph_new_nodes
.length (); i
++)
310 cgraph_node
*node
= cgraph_new_nodes
[i
];
315 /* At construction time we just need to finalize function and move
316 it into reachable functions list. */
318 cgraph_node::finalize_function (fndecl
, false);
319 call_cgraph_insertion_hooks (node
);
325 case IPA_SSA_AFTER_INLINING
:
326 /* When IPA optimization already started, do all essential
327 transformations that has been already performed on the whole
328 cgraph but not on this function. */
330 gimple_register_cfg_hooks ();
333 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
334 if ((state
== IPA_SSA
|| state
== IPA_SSA_AFTER_INLINING
)
335 && !gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
337 bool summaried_computed
= ipa_fn_summaries
!= NULL
;
338 g
->get_passes ()->execute_early_local_passes ();
339 /* Early passes compute inline parameters to do inlining
340 and splitting. This is redundant for functions added late.
341 Just throw away whatever it did. */
342 if (!summaried_computed
)
344 ipa_free_fn_summary ();
345 ipa_free_size_summary ();
348 else if (ipa_fn_summaries
!= NULL
)
349 compute_fn_summary (node
, true);
350 free_dominance_info (CDI_POST_DOMINATORS
);
351 free_dominance_info (CDI_DOMINATORS
);
353 call_cgraph_insertion_hooks (node
);
357 /* Functions created during expansion shall be compiled
360 call_cgraph_insertion_hooks (node
);
370 cgraph_new_nodes
.release ();
373 /* As an GCC extension we allow redefinition of the function. The
374 semantics when both copies of bodies differ is not well defined.
375 We replace the old body with new body so in unit at a time mode
376 we always use new body, while in normal mode we may end up with
377 old body inlined into some functions and new body expanded and
380 ??? It may make more sense to use one body for inlining and other
381 body for expanding the function but this is difficult to do. */
384 cgraph_node::reset (void)
386 /* If process is set, then we have already begun whole-unit analysis.
387 This is *not* testing for whether we've already emitted the function.
388 That case can be sort-of legitimately seen with real function redefinition
389 errors. I would argue that the front end should never present us with
390 such a case, but don't enforce that for now. */
391 gcc_assert (!process
);
393 /* Reset our data structures so we can analyze the function again. */
395 memset (&rtl
, 0, sizeof (rtl
));
399 transparent_alias
= false;
401 cpp_implicit_alias
= false;
404 remove_all_references ();
407 /* Return true when there are references to the node. INCLUDE_SELF is
408 true if a self reference counts as a reference. */
411 symtab_node::referred_to_p (bool include_self
)
415 /* See if there are any references at all. */
416 if (iterate_referring (0, ref
))
418 /* For functions check also calls. */
419 cgraph_node
*cn
= dyn_cast
<cgraph_node
*> (this);
420 if (cn
&& cn
->callers
)
424 for (cgraph_edge
*e
= cn
->callers
; e
; e
= e
->next_caller
)
425 if (e
->caller
!= this)
431 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
432 logic in effect. If NO_COLLECT is true, then our caller cannot stand to have
433 the garbage collector run at the moment. We would need to either create
434 a new GC context, or just not compile right now. */
437 cgraph_node::finalize_function (tree decl
, bool no_collect
)
439 cgraph_node
*node
= cgraph_node::get_create (decl
);
441 if (node
->definition
)
443 /* Nested functions should only be defined once. */
444 gcc_assert (!DECL_CONTEXT (decl
)
445 || TREE_CODE (DECL_CONTEXT (decl
)) != FUNCTION_DECL
);
447 node
->redefined_extern_inline
= true;
450 /* Set definition first before calling notice_global_symbol so that
451 it is available to notice_global_symbol. */
452 node
->definition
= true;
453 notice_global_symbol (decl
);
454 node
->lowered
= DECL_STRUCT_FUNCTION (decl
)->cfg
!= NULL
;
455 if (!flag_toplevel_reorder
)
456 node
->no_reorder
= true;
458 /* With -fkeep-inline-functions we are keeping all inline functions except
459 for extern inline ones. */
460 if (flag_keep_inline_functions
461 && DECL_DECLARED_INLINE_P (decl
)
462 && !DECL_EXTERNAL (decl
)
463 && !DECL_DISREGARD_INLINE_LIMITS (decl
))
464 node
->force_output
= 1;
466 /* __RTL functions were already output as soon as they were parsed (due
467 to the large amount of global state in the backend).
468 Mark such functions as "force_output" to reflect the fact that they
469 will be in the asm file when considering the symbols they reference.
470 The attempt to output them later on will bail out immediately. */
471 if (node
->native_rtl_p ())
472 node
->force_output
= 1;
474 /* When not optimizing, also output the static functions. (see
475 PR24561), but don't do so for always_inline functions, functions
476 declared inline and nested functions. These were optimized out
477 in the original implementation and it is unclear whether we want
478 to change the behavior here. */
479 if (((!opt_for_fn (decl
, optimize
) || flag_keep_static_functions
481 && !node
->cpp_implicit_alias
482 && !DECL_DISREGARD_INLINE_LIMITS (decl
)
483 && !DECL_DECLARED_INLINE_P (decl
)
484 && !(DECL_CONTEXT (decl
)
485 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
))
486 && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
))
487 node
->force_output
= 1;
489 /* If we've not yet emitted decl, tell the debug info about it. */
490 if (!TREE_ASM_WRITTEN (decl
))
491 (*debug_hooks
->deferred_inline_function
) (decl
);
496 if (symtab
->state
== CONSTRUCTION
497 && (node
->needed_p () || node
->referred_to_p ()))
501 /* Add the function FNDECL to the call graph.
502 Unlike finalize_function, this function is intended to be used
503 by middle end and allows insertion of new function at arbitrary point
504 of compilation. The function can be either in high, low or SSA form
507 The function is assumed to be reachable and have address taken (so no
508 API breaking optimizations are performed on it).
510 Main work done by this function is to enqueue the function for later
511 processing to avoid need the passes to be re-entrant. */
514 cgraph_node::add_new_function (tree fndecl
, bool lowered
)
516 gcc::pass_manager
*passes
= g
->get_passes ();
521 struct function
*fn
= DECL_STRUCT_FUNCTION (fndecl
);
522 const char *function_type
= ((gimple_has_body_p (fndecl
))
524 ? (gimple_in_ssa_p (fn
)
528 : "to-be-gimplified");
530 "Added new %s function %s to callgraph\n",
532 fndecl_name (fndecl
));
535 switch (symtab
->state
)
538 cgraph_node::finalize_function (fndecl
, false);
541 /* Just enqueue function to be processed at nearest occurrence. */
542 node
= cgraph_node::get_create (fndecl
);
544 node
->lowered
= true;
545 cgraph_new_nodes
.safe_push (node
);
550 case IPA_SSA_AFTER_INLINING
:
552 /* Bring the function into finalized state and enqueue for later
553 analyzing and compilation. */
554 node
= cgraph_node::get_create (fndecl
);
556 node
->definition
= true;
557 node
->force_output
= true;
558 if (TREE_PUBLIC (fndecl
))
559 node
->externally_visible
= true;
560 if (!lowered
&& symtab
->state
== EXPANSION
)
562 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
563 gimple_register_cfg_hooks ();
564 bitmap_obstack_initialize (NULL
);
565 execute_pass_list (cfun
, passes
->all_lowering_passes
);
566 passes
->execute_early_local_passes ();
567 bitmap_obstack_release (NULL
);
573 node
->lowered
= true;
574 cgraph_new_nodes
.safe_push (node
);
578 /* At the very end of compilation we have to do all the work up
580 node
= cgraph_node::create (fndecl
);
582 node
->lowered
= true;
583 node
->definition
= true;
585 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
586 gimple_register_cfg_hooks ();
587 bitmap_obstack_initialize (NULL
);
588 if (!gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
589 g
->get_passes ()->execute_early_local_passes ();
590 bitmap_obstack_release (NULL
);
599 /* Set a personality if required and we already passed EH lowering. */
601 && (function_needs_eh_personality (DECL_STRUCT_FUNCTION (fndecl
))
602 == eh_personality_lang
))
603 DECL_FUNCTION_PERSONALITY (fndecl
) = lang_hooks
.eh_personality ();
606 /* Analyze the function scheduled to be output. */
608 cgraph_node::analyze (void)
616 tree decl
= this->decl
;
617 location_t saved_loc
= input_location
;
618 input_location
= DECL_SOURCE_LOCATION (decl
);
622 cgraph_node
*t
= cgraph_node::get (thunk
.alias
);
624 create_edge (t
, NULL
, t
->count
);
625 callees
->can_throw_external
= !TREE_NOTHROW (t
->decl
);
626 /* Target code in expand_thunk may need the thunk's target
627 to be analyzed, so recurse here. */
628 if (!t
->analyzed
&& t
->definition
)
632 t
= t
->get_alias_target ();
633 if (!t
->analyzed
&& t
->definition
)
636 bool ret
= expand_thunk (false, false);
642 resolve_alias (cgraph_node::get (alias_target
), transparent_alias
);
643 else if (dispatcher_function
)
645 /* Generate the dispatcher body of multi-versioned functions. */
646 cgraph_function_version_info
*dispatcher_version_info
647 = function_version ();
648 if (dispatcher_version_info
!= NULL
649 && (dispatcher_version_info
->dispatcher_resolver
652 tree resolver
= NULL_TREE
;
653 gcc_assert (targetm
.generate_version_dispatcher_body
);
654 resolver
= targetm
.generate_version_dispatcher_body (this);
655 gcc_assert (resolver
!= NULL_TREE
);
660 push_cfun (DECL_STRUCT_FUNCTION (decl
));
662 assign_assembler_name_if_needed (decl
);
664 /* Make sure to gimplify bodies only once. During analyzing a
665 function we lower it, which will require gimplified nested
666 functions, so we can end up here with an already gimplified
668 if (!gimple_has_body_p (decl
))
669 gimplify_function_tree (decl
);
671 /* Lower the function. */
675 lower_nested_functions (decl
);
676 gcc_assert (!nested
);
678 gimple_register_cfg_hooks ();
679 bitmap_obstack_initialize (NULL
);
680 execute_pass_list (cfun
, g
->get_passes ()->all_lowering_passes
);
681 free_dominance_info (CDI_POST_DOMINATORS
);
682 free_dominance_info (CDI_DOMINATORS
);
684 bitmap_obstack_release (NULL
);
692 input_location
= saved_loc
;
695 /* C++ frontend produce same body aliases all over the place, even before PCH
696 gets streamed out. It relies on us linking the aliases with their function
697 in order to do the fixups, but ipa-ref is not PCH safe. Consequently we
698 first produce aliases without links, but once C++ FE is sure he won't stream
699 PCH we build the links via this function. */
702 symbol_table::process_same_body_aliases (void)
705 FOR_EACH_SYMBOL (node
)
706 if (node
->cpp_implicit_alias
&& !node
->analyzed
)
708 (VAR_P (node
->alias_target
)
709 ? (symtab_node
*)varpool_node::get_create (node
->alias_target
)
710 : (symtab_node
*)cgraph_node::get_create (node
->alias_target
));
711 cpp_implicit_aliases_done
= true;
714 /* Process a symver attribute. */
717 process_symver_attribute (symtab_node
*n
)
719 tree value
= lookup_attribute ("symver", DECL_ATTRIBUTES (n
->decl
));
723 if (lookup_attribute ("symver", TREE_CHAIN (value
)))
725 error_at (DECL_SOURCE_LOCATION (n
->decl
),
726 "multiple versions for one symbol");
729 tree symver
= get_identifier_with_length
730 (TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (value
))),
731 TREE_STRING_LENGTH (TREE_VALUE (TREE_VALUE (value
))));
732 symtab_node
*def
= symtab_node::get_for_asmname (symver
);
736 error_at (DECL_SOURCE_LOCATION (n
->decl
),
737 "duplicate definition of a symbol version");
738 inform (DECL_SOURCE_LOCATION (def
->decl
),
739 "same version was previously defined here");
744 error_at (DECL_SOURCE_LOCATION (n
->decl
),
745 "symbol needs to be defined to have a version");
748 if (DECL_COMMON (n
->decl
))
750 error_at (DECL_SOURCE_LOCATION (n
->decl
),
751 "common symbol cannot be versioned");
754 if (DECL_COMDAT (n
->decl
))
756 error_at (DECL_SOURCE_LOCATION (n
->decl
),
757 "comdat symbol cannot be versioned");
762 error_at (DECL_SOURCE_LOCATION (n
->decl
),
763 "weakref cannot be versioned");
766 if (!TREE_PUBLIC (n
->decl
))
768 error_at (DECL_SOURCE_LOCATION (n
->decl
),
769 "versioned symbol must be public");
772 if (DECL_VISIBILITY (n
->decl
) != VISIBILITY_DEFAULT
)
774 error_at (DECL_SOURCE_LOCATION (n
->decl
),
775 "versioned symbol must have default visibility");
779 /* Create new symbol table entry representing the version. */
780 tree new_decl
= copy_node (n
->decl
);
782 DECL_INITIAL (new_decl
) = NULL_TREE
;
783 if (TREE_CODE (new_decl
) == FUNCTION_DECL
)
784 DECL_STRUCT_FUNCTION (new_decl
) = NULL
;
785 SET_DECL_ASSEMBLER_NAME (new_decl
, symver
);
786 TREE_PUBLIC (new_decl
) = 1;
787 DECL_ATTRIBUTES (new_decl
) = NULL
;
789 symtab_node
*symver_node
= symtab_node::get_create (new_decl
);
790 symver_node
->alias
= true;
791 symver_node
->definition
= true;
792 symver_node
->symver
= true;
793 symver_node
->create_reference (n
, IPA_REF_ALIAS
, NULL
);
794 symver_node
->analyzed
= true;
797 /* Process attributes common for vars and functions. */
800 process_common_attributes (symtab_node
*node
, tree decl
)
802 tree weakref
= lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
));
804 if (weakref
&& !lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)))
806 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wattributes
,
807 "%<weakref%> attribute should be accompanied with"
808 " an %<alias%> attribute");
809 DECL_WEAK (decl
) = 0;
810 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
811 DECL_ATTRIBUTES (decl
));
814 if (lookup_attribute ("no_reorder", DECL_ATTRIBUTES (decl
)))
815 node
->no_reorder
= 1;
816 process_symver_attribute (node
);
819 /* Look for externally_visible and used attributes and mark cgraph nodes
822 We cannot mark the nodes at the point the attributes are processed (in
823 handle_*_attribute) because the copy of the declarations available at that
824 point may not be canonical. For example, in:
827 void f() __attribute__((used));
829 the declaration we see in handle_used_attribute will be the second
830 declaration -- but the front end will subsequently merge that declaration
831 with the original declaration and discard the second declaration.
833 Furthermore, we can't mark these nodes in finalize_function because:
836 void f() __attribute__((externally_visible));
840 So, we walk the nodes at the end of the translation unit, applying the
841 attributes at that point. */
844 process_function_and_variable_attributes (cgraph_node
*first
,
845 varpool_node
*first_var
)
850 for (node
= symtab
->first_function (); node
!= first
;
851 node
= symtab
->next_function (node
))
853 tree decl
= node
->decl
;
854 if (DECL_PRESERVE_P (decl
))
855 node
->mark_force_output ();
856 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
858 if (! TREE_PUBLIC (node
->decl
))
859 warning_at (DECL_SOURCE_LOCATION (node
->decl
), OPT_Wattributes
,
860 "%<externally_visible%>"
861 " attribute have effect only on public objects");
863 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
864 && (node
->definition
&& !node
->alias
))
866 warning_at (DECL_SOURCE_LOCATION (node
->decl
), OPT_Wattributes
,
867 "%<weakref%> attribute ignored"
868 " because function is defined");
869 DECL_WEAK (decl
) = 0;
870 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
871 DECL_ATTRIBUTES (decl
));
873 else if (lookup_attribute ("alias", DECL_ATTRIBUTES (decl
))
876 warning_at (DECL_SOURCE_LOCATION (node
->decl
), OPT_Wattributes
,
877 "%<alias%> attribute ignored"
878 " because function is defined");
880 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (decl
))
881 && !DECL_DECLARED_INLINE_P (decl
)
882 /* redefining extern inline function makes it DECL_UNINLINABLE. */
883 && !DECL_UNINLINABLE (decl
))
884 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wattributes
,
885 "%<always_inline%> function might not be inlinable");
887 process_common_attributes (node
, decl
);
889 for (vnode
= symtab
->first_variable (); vnode
!= first_var
;
890 vnode
= symtab
->next_variable (vnode
))
892 tree decl
= vnode
->decl
;
893 if (DECL_EXTERNAL (decl
)
894 && DECL_INITIAL (decl
))
895 varpool_node::finalize_decl (decl
);
896 if (DECL_PRESERVE_P (decl
))
897 vnode
->force_output
= true;
898 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
900 if (! TREE_PUBLIC (vnode
->decl
))
901 warning_at (DECL_SOURCE_LOCATION (vnode
->decl
), OPT_Wattributes
,
902 "%<externally_visible%>"
903 " attribute have effect only on public objects");
905 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
907 && DECL_INITIAL (decl
))
909 warning_at (DECL_SOURCE_LOCATION (vnode
->decl
), OPT_Wattributes
,
910 "%<weakref%> attribute ignored"
911 " because variable is initialized");
912 DECL_WEAK (decl
) = 0;
913 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
914 DECL_ATTRIBUTES (decl
));
916 process_common_attributes (vnode
, decl
);
920 /* Mark DECL as finalized. By finalizing the declaration, frontend instruct the
921 middle end to output the variable to asm file, if needed or externally
925 varpool_node::finalize_decl (tree decl
)
927 varpool_node
*node
= varpool_node::get_create (decl
);
929 gcc_assert (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
));
931 if (node
->definition
)
933 /* Set definition first before calling notice_global_symbol so that
934 it is available to notice_global_symbol. */
935 node
->definition
= true;
936 notice_global_symbol (decl
);
937 if (!flag_toplevel_reorder
)
938 node
->no_reorder
= true;
939 if (TREE_THIS_VOLATILE (decl
) || DECL_PRESERVE_P (decl
)
940 /* Traditionally we do not eliminate static variables when not
941 optimizing and when not doing toplevel reorder. */
942 || (node
->no_reorder
&& !DECL_COMDAT (node
->decl
)
943 && !DECL_ARTIFICIAL (node
->decl
)))
944 node
->force_output
= true;
946 if (symtab
->state
== CONSTRUCTION
947 && (node
->needed_p () || node
->referred_to_p ()))
949 if (symtab
->state
>= IPA_SSA
)
951 /* Some frontends produce various interface variables after compilation
953 if (symtab
->state
== FINISHED
955 && symtab
->state
== EXPANSION
))
956 node
->assemble_decl ();
959 /* EDGE is an polymorphic call. Mark all possible targets as reachable
960 and if there is only one target, perform trivial devirtualization.
961 REACHABLE_CALL_TARGETS collects target lists we already walked to
962 avoid duplicate work. */
965 walk_polymorphic_call_targets (hash_set
<void *> *reachable_call_targets
,
971 vec
<cgraph_node
*>targets
972 = possible_polymorphic_call_targets
973 (edge
, &final
, &cache_token
);
975 if (!reachable_call_targets
->add (cache_token
))
977 if (symtab
->dump_file
)
978 dump_possible_polymorphic_call_targets
979 (symtab
->dump_file
, edge
);
981 for (i
= 0; i
< targets
.length (); i
++)
983 /* Do not bother to mark virtual methods in anonymous namespace;
984 either we will find use of virtual table defining it, or it is
986 if (targets
[i
]->definition
988 (TREE_TYPE (targets
[i
]->decl
))
990 && !type_in_anonymous_namespace_p
991 (TYPE_METHOD_BASETYPE (TREE_TYPE (targets
[i
]->decl
))))
992 enqueue_node (targets
[i
]);
996 /* Very trivial devirtualization; when the type is
997 final or anonymous (so we know all its derivation)
998 and there is only one possible virtual call target,
999 make the edge direct. */
1002 if (targets
.length () <= 1 && dbg_cnt (devirt
))
1004 cgraph_node
*target
;
1005 if (targets
.length () == 1)
1006 target
= targets
[0];
1008 target
= cgraph_node::create
1009 (builtin_decl_implicit (BUILT_IN_UNREACHABLE
));
1011 if (symtab
->dump_file
)
1013 fprintf (symtab
->dump_file
,
1014 "Devirtualizing call: ");
1015 print_gimple_stmt (symtab
->dump_file
,
1019 if (dump_enabled_p ())
1021 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, edge
->call_stmt
,
1022 "devirtualizing call in %s to %s\n",
1023 edge
->caller
->name (), target
->name ());
1026 edge
->make_direct (target
);
1027 edge
->redirect_call_stmt_to_callee ();
1029 if (symtab
->dump_file
)
1031 fprintf (symtab
->dump_file
,
1032 "Devirtualized as: ");
1033 print_gimple_stmt (symtab
->dump_file
,
1041 /* Issue appropriate warnings for the global declaration DECL. */
1044 check_global_declaration (symtab_node
*snode
)
1046 const char *decl_file
;
1047 tree decl
= snode
->decl
;
1049 /* Warn about any function declared static but not defined. We don't
1050 warn about variables, because many programs have static variables
1051 that exist only to get some text into the object file. */
1052 if (TREE_CODE (decl
) == FUNCTION_DECL
1053 && DECL_INITIAL (decl
) == 0
1054 && DECL_EXTERNAL (decl
)
1055 && ! DECL_ARTIFICIAL (decl
)
1056 && ! TREE_NO_WARNING (decl
)
1057 && ! TREE_PUBLIC (decl
)
1058 && (warn_unused_function
1059 || snode
->referred_to_p (/*include_self=*/false)))
1061 if (snode
->referred_to_p (/*include_self=*/false))
1062 pedwarn (input_location
, 0, "%q+F used but never defined", decl
);
1064 warning (OPT_Wunused_function
, "%q+F declared %<static%> but never defined", decl
);
1065 /* This symbol is effectively an "extern" declaration now. */
1066 TREE_PUBLIC (decl
) = 1;
1069 /* Warn about static fns or vars defined but not used. */
1070 if (((warn_unused_function
&& TREE_CODE (decl
) == FUNCTION_DECL
)
1071 || (((warn_unused_variable
&& ! TREE_READONLY (decl
))
1072 || (warn_unused_const_variable
> 0 && TREE_READONLY (decl
)
1073 && (warn_unused_const_variable
== 2
1074 || (main_input_filename
!= NULL
1075 && (decl_file
= DECL_SOURCE_FILE (decl
)) != NULL
1076 && filename_cmp (main_input_filename
,
1079 && ! DECL_IN_SYSTEM_HEADER (decl
)
1080 && ! snode
->referred_to_p (/*include_self=*/false)
1081 /* This TREE_USED check is needed in addition to referred_to_p
1082 above, because the `__unused__' attribute is not being
1083 considered for referred_to_p. */
1084 && ! TREE_USED (decl
)
1085 /* The TREE_USED bit for file-scope decls is kept in the identifier,
1086 to handle multiple external decls in different scopes. */
1087 && ! (DECL_NAME (decl
) && TREE_USED (DECL_NAME (decl
)))
1088 && ! DECL_EXTERNAL (decl
)
1089 && ! DECL_ARTIFICIAL (decl
)
1090 && ! DECL_ABSTRACT_ORIGIN (decl
)
1091 && ! TREE_PUBLIC (decl
)
1092 /* A volatile variable might be used in some non-obvious way. */
1093 && (! VAR_P (decl
) || ! TREE_THIS_VOLATILE (decl
))
1094 /* Global register variables must be declared to reserve them. */
1095 && ! (VAR_P (decl
) && DECL_REGISTER (decl
))
1096 /* Global ctors and dtors are called by the runtime. */
1097 && (TREE_CODE (decl
) != FUNCTION_DECL
1098 || (!DECL_STATIC_CONSTRUCTOR (decl
)
1099 && !DECL_STATIC_DESTRUCTOR (decl
)))
1100 /* Otherwise, ask the language. */
1101 && lang_hooks
.decls
.warn_unused_global (decl
))
1102 warning_at (DECL_SOURCE_LOCATION (decl
),
1103 (TREE_CODE (decl
) == FUNCTION_DECL
)
1104 ? OPT_Wunused_function
1105 : (TREE_READONLY (decl
)
1106 ? OPT_Wunused_const_variable_
1107 : OPT_Wunused_variable
),
1108 "%qD defined but not used", decl
);
1111 /* Discover all functions and variables that are trivially needed, analyze
1112 them as well as all functions and variables referred by them */
1113 static cgraph_node
*first_analyzed
;
1114 static varpool_node
*first_analyzed_var
;
1116 /* FIRST_TIME is set to TRUE for the first time we are called for a
1117 translation unit from finalize_compilation_unit() or false
1121 analyze_functions (bool first_time
)
1123 /* Keep track of already processed nodes when called multiple times for
1124 intermodule optimization. */
1125 cgraph_node
*first_handled
= first_analyzed
;
1126 varpool_node
*first_handled_var
= first_analyzed_var
;
1127 hash_set
<void *> reachable_call_targets
;
1133 bool changed
= true;
1134 location_t saved_loc
= input_location
;
1136 bitmap_obstack_initialize (NULL
);
1137 symtab
->state
= CONSTRUCTION
;
1138 input_location
= UNKNOWN_LOCATION
;
1140 /* Ugly, but the fixup cannot happen at a time same body alias is created;
1141 C++ FE is confused about the COMDAT groups being right. */
1142 if (symtab
->cpp_implicit_aliases_done
)
1143 FOR_EACH_SYMBOL (node
)
1144 if (node
->cpp_implicit_alias
)
1145 node
->fixup_same_cpp_alias_visibility (node
->get_alias_target ());
1146 build_type_inheritance_graph ();
1148 /* Analysis adds static variables that in turn adds references to new functions.
1149 So we need to iterate the process until it stabilize. */
1153 process_function_and_variable_attributes (first_analyzed
,
1154 first_analyzed_var
);
1156 /* First identify the trivially needed symbols. */
1157 for (node
= symtab
->first_symbol ();
1158 node
!= first_analyzed
1159 && node
!= first_analyzed_var
; node
= node
->next
)
1161 /* Convert COMDAT group designators to IDENTIFIER_NODEs. */
1162 node
->get_comdat_group_id ();
1163 if (node
->needed_p ())
1165 enqueue_node (node
);
1166 if (!changed
&& symtab
->dump_file
)
1167 fprintf (symtab
->dump_file
, "Trivially needed symbols:");
1169 if (symtab
->dump_file
)
1170 fprintf (symtab
->dump_file
, " %s", node
->asm_name ());
1171 if (!changed
&& symtab
->dump_file
)
1172 fprintf (symtab
->dump_file
, "\n");
1174 if (node
== first_analyzed
1175 || node
== first_analyzed_var
)
1178 symtab
->process_new_functions ();
1179 first_analyzed_var
= symtab
->first_variable ();
1180 first_analyzed
= symtab
->first_function ();
1182 if (changed
&& symtab
->dump_file
)
1183 fprintf (symtab
->dump_file
, "\n");
1185 /* Lower representation, build callgraph edges and references for all trivially
1186 needed symbols and all symbols referred by them. */
1187 while (queued_nodes
!= &symtab_terminator
)
1190 node
= queued_nodes
;
1191 queued_nodes
= (symtab_node
*)queued_nodes
->aux
;
1192 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
);
1193 if (cnode
&& cnode
->definition
)
1196 tree decl
= cnode
->decl
;
1198 /* ??? It is possible to create extern inline function
1199 and later using weak alias attribute to kill its body.
1200 See gcc.c-torture/compile/20011119-1.c */
1201 if (!DECL_STRUCT_FUNCTION (decl
)
1203 && !cnode
->thunk
.thunk_p
1204 && !cnode
->dispatcher_function
)
1207 cnode
->redefined_extern_inline
= true;
1211 if (!cnode
->analyzed
)
1214 for (edge
= cnode
->callees
; edge
; edge
= edge
->next_callee
)
1215 if (edge
->callee
->definition
1216 && (!DECL_EXTERNAL (edge
->callee
->decl
)
1217 /* When not optimizing, do not try to analyze extern
1218 inline functions. Doing so is pointless. */
1219 || opt_for_fn (edge
->callee
->decl
, optimize
)
1220 /* Weakrefs needs to be preserved. */
1221 || edge
->callee
->alias
1222 /* always_inline functions are inlined even at -O0. */
1225 DECL_ATTRIBUTES (edge
->callee
->decl
))
1226 /* Multiversioned functions needs the dispatcher to
1227 be produced locally even for extern functions. */
1228 || edge
->callee
->function_version ()))
1229 enqueue_node (edge
->callee
);
1230 if (opt_for_fn (cnode
->decl
, optimize
)
1231 && opt_for_fn (cnode
->decl
, flag_devirtualize
))
1235 for (edge
= cnode
->indirect_calls
; edge
; edge
= next
)
1237 next
= edge
->next_callee
;
1238 if (edge
->indirect_info
->polymorphic
)
1239 walk_polymorphic_call_targets (&reachable_call_targets
,
1244 /* If decl is a clone of an abstract function,
1245 mark that abstract function so that we don't release its body.
1246 The DECL_INITIAL() of that abstract function declaration
1247 will be later needed to output debug info. */
1248 if (DECL_ABSTRACT_ORIGIN (decl
))
1250 cgraph_node
*origin_node
1251 = cgraph_node::get_create (DECL_ABSTRACT_ORIGIN (decl
));
1252 origin_node
->used_as_abstract_origin
= true;
1254 /* Preserve a functions function context node. It will
1255 later be needed to output debug info. */
1256 if (tree fn
= decl_function_context (decl
))
1258 cgraph_node
*origin_node
= cgraph_node::get_create (fn
);
1259 enqueue_node (origin_node
);
1264 varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
);
1265 if (vnode
&& vnode
->definition
&& !vnode
->analyzed
)
1269 if (node
->same_comdat_group
)
1272 for (next
= node
->same_comdat_group
;
1274 next
= next
->same_comdat_group
)
1275 if (!next
->comdat_local_p ())
1276 enqueue_node (next
);
1278 for (i
= 0; node
->iterate_reference (i
, ref
); i
++)
1279 if (ref
->referred
->definition
1280 && (!DECL_EXTERNAL (ref
->referred
->decl
)
1281 || ((TREE_CODE (ref
->referred
->decl
) != FUNCTION_DECL
1283 || (TREE_CODE (ref
->referred
->decl
) == FUNCTION_DECL
1284 && opt_for_fn (ref
->referred
->decl
, optimize
))
1286 || ref
->referred
->alias
)))
1287 enqueue_node (ref
->referred
);
1288 symtab
->process_new_functions ();
1291 update_type_inheritance_graph ();
1293 /* Collect entry points to the unit. */
1294 if (symtab
->dump_file
)
1296 fprintf (symtab
->dump_file
, "\n\nInitial ");
1297 symtab
->dump (symtab
->dump_file
);
1303 FOR_EACH_SYMBOL (snode
)
1304 check_global_declaration (snode
);
1307 if (symtab
->dump_file
)
1308 fprintf (symtab
->dump_file
, "\nRemoving unused symbols:");
1310 for (node
= symtab
->first_symbol ();
1311 node
!= first_handled
1312 && node
!= first_handled_var
; node
= next
)
1315 /* For symbols declared locally we clear TREE_READONLY when emitting
1316 the constructor (if one is needed). For external declarations we can
1317 not safely assume that the type is readonly because we may be called
1318 during its construction. */
1319 if (TREE_CODE (node
->decl
) == VAR_DECL
1320 && TYPE_P (TREE_TYPE (node
->decl
))
1321 && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (node
->decl
))
1322 && DECL_EXTERNAL (node
->decl
))
1323 TREE_READONLY (node
->decl
) = 0;
1324 if (!node
->aux
&& !node
->referred_to_p ())
1326 if (symtab
->dump_file
)
1327 fprintf (symtab
->dump_file
, " %s", node
->name ());
1329 /* See if the debugger can use anything before the DECL
1330 passes away. Perhaps it can notice a DECL that is now a
1331 constant and can tag the early DIE with an appropriate
1334 Otherwise, this is the last chance the debug_hooks have
1335 at looking at optimized away DECLs, since
1336 late_global_decl will subsequently be called from the
1337 contents of the now pruned symbol table. */
1338 if (VAR_P (node
->decl
)
1339 && !decl_function_context (node
->decl
))
1341 /* We are reclaiming totally unreachable code and variables
1342 so they effectively appear as readonly. Show that to
1343 the debug machinery. */
1344 TREE_READONLY (node
->decl
) = 1;
1345 node
->definition
= false;
1346 (*debug_hooks
->late_global_decl
) (node
->decl
);
1352 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
))
1354 tree decl
= node
->decl
;
1356 if (cnode
->definition
&& !gimple_has_body_p (decl
)
1358 && !cnode
->thunk
.thunk_p
)
1361 gcc_assert (!cnode
->definition
|| cnode
->thunk
.thunk_p
1363 || gimple_has_body_p (decl
)
1364 || cnode
->native_rtl_p ());
1365 gcc_assert (cnode
->analyzed
== cnode
->definition
);
1369 for (;node
; node
= node
->next
)
1371 first_analyzed
= symtab
->first_function ();
1372 first_analyzed_var
= symtab
->first_variable ();
1373 if (symtab
->dump_file
)
1375 fprintf (symtab
->dump_file
, "\n\nReclaimed ");
1376 symtab
->dump (symtab
->dump_file
);
1378 bitmap_obstack_release (NULL
);
1380 /* Initialize assembler name hash, in particular we want to trigger C++
1381 mangling and same body alias creation before we free DECL_ARGUMENTS
1384 symtab
->symtab_initialize_asm_name_hash ();
1386 input_location
= saved_loc
;
1389 /* Check declaration of the type of ALIAS for compatibility with its TARGET
1390 (which may be an ifunc resolver) and issue a diagnostic when they are
1391 not compatible according to language rules (plus a C++ extension for
1392 non-static member functions). */
1395 maybe_diag_incompatible_alias (tree alias
, tree target
)
1397 tree altype
= TREE_TYPE (alias
);
1398 tree targtype
= TREE_TYPE (target
);
1400 bool ifunc
= cgraph_node::get (alias
)->ifunc_resolver
;
1401 tree funcptr
= altype
;
1405 /* Handle attribute ifunc first. */
1406 if (TREE_CODE (altype
) == METHOD_TYPE
)
1408 /* Set FUNCPTR to the type of the alias target. If the type
1409 is a non-static member function of class C, construct a type
1410 of an ordinary function taking C* as the first argument,
1411 followed by the member function argument list, and use it
1412 instead to check for incompatibility. This conversion is
1413 not defined by the language but an extension provided by
1416 tree rettype
= TREE_TYPE (altype
);
1417 tree args
= TYPE_ARG_TYPES (altype
);
1418 altype
= build_function_type (rettype
, args
);
1422 targtype
= TREE_TYPE (targtype
);
1424 if (POINTER_TYPE_P (targtype
))
1426 targtype
= TREE_TYPE (targtype
);
1428 /* Only issue Wattribute-alias for conversions to void* with
1430 if (VOID_TYPE_P (targtype
) && !extra_warnings
)
1433 /* Proceed to handle incompatible ifunc resolvers below. */
1437 funcptr
= build_pointer_type (funcptr
);
1439 error_at (DECL_SOURCE_LOCATION (target
),
1440 "%<ifunc%> resolver for %qD must return %qT",
1442 inform (DECL_SOURCE_LOCATION (alias
),
1443 "resolver indirect function declared here");
1448 if ((!FUNC_OR_METHOD_TYPE_P (targtype
)
1449 || (prototype_p (altype
)
1450 && prototype_p (targtype
)
1451 && !types_compatible_p (altype
, targtype
))))
1453 /* Warn for incompatibilities. Avoid warning for functions
1454 without a prototype to make it possible to declare aliases
1455 without knowing the exact type, as libstdc++ does. */
1458 funcptr
= build_pointer_type (funcptr
);
1460 auto_diagnostic_group d
;
1461 if (warning_at (DECL_SOURCE_LOCATION (target
),
1462 OPT_Wattribute_alias_
,
1463 "%<ifunc%> resolver for %qD should return %qT",
1465 inform (DECL_SOURCE_LOCATION (alias
),
1466 "resolver indirect function declared here");
1470 auto_diagnostic_group d
;
1471 if (warning_at (DECL_SOURCE_LOCATION (alias
),
1472 OPT_Wattribute_alias_
,
1473 "%qD alias between functions of incompatible "
1474 "types %qT and %qT", alias
, altype
, targtype
))
1475 inform (DECL_SOURCE_LOCATION (target
),
1476 "aliased declaration here");
1481 /* Translate the ugly representation of aliases as alias pairs into nice
1482 representation in callgraph. We don't handle all cases yet,
1486 handle_alias_pairs (void)
1491 for (i
= 0; alias_pairs
&& alias_pairs
->iterate (i
, &p
);)
1493 symtab_node
*target_node
= symtab_node::get_for_asmname (p
->target
);
1495 /* Weakrefs with target not defined in current unit are easy to handle:
1496 they behave just as external variables except we need to note the
1497 alias flag to later output the weakref pseudo op into asm file. */
1499 && lookup_attribute ("weakref", DECL_ATTRIBUTES (p
->decl
)) != NULL
)
1501 symtab_node
*node
= symtab_node::get (p
->decl
);
1504 node
->alias_target
= p
->target
;
1505 node
->weakref
= true;
1507 node
->transparent_alias
= true;
1509 alias_pairs
->unordered_remove (i
);
1512 else if (!target_node
)
1514 error ("%q+D aliased to undefined symbol %qE", p
->decl
, p
->target
);
1515 symtab_node
*node
= symtab_node::get (p
->decl
);
1517 node
->alias
= false;
1518 alias_pairs
->unordered_remove (i
);
1522 if (DECL_EXTERNAL (target_node
->decl
)
1523 /* We use local aliases for C++ thunks to force the tailcall
1524 to bind locally. This is a hack - to keep it working do
1525 the following (which is not strictly correct). */
1526 && (TREE_CODE (target_node
->decl
) != FUNCTION_DECL
1527 || ! DECL_VIRTUAL_P (target_node
->decl
))
1528 && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (p
->decl
)))
1530 error ("%q+D aliased to external symbol %qE",
1531 p
->decl
, p
->target
);
1534 if (TREE_CODE (p
->decl
) == FUNCTION_DECL
1535 && target_node
&& is_a
<cgraph_node
*> (target_node
))
1537 maybe_diag_incompatible_alias (p
->decl
, target_node
->decl
);
1539 maybe_diag_alias_attributes (p
->decl
, target_node
->decl
);
1541 cgraph_node
*src_node
= cgraph_node::get (p
->decl
);
1542 if (src_node
&& src_node
->definition
)
1544 cgraph_node::create_alias (p
->decl
, target_node
->decl
);
1545 alias_pairs
->unordered_remove (i
);
1547 else if (VAR_P (p
->decl
)
1548 && target_node
&& is_a
<varpool_node
*> (target_node
))
1550 varpool_node::create_alias (p
->decl
, target_node
->decl
);
1551 alias_pairs
->unordered_remove (i
);
1555 error ("%q+D alias between function and variable is not supported",
1557 inform (DECL_SOURCE_LOCATION (target_node
->decl
),
1558 "aliased declaration here");
1560 alias_pairs
->unordered_remove (i
);
1563 vec_free (alias_pairs
);
1567 /* Figure out what functions we want to assemble. */
1570 mark_functions_to_output (void)
1572 bool check_same_comdat_groups
= false;
1576 FOR_EACH_FUNCTION (node
)
1577 gcc_assert (!node
->process
);
1579 FOR_EACH_FUNCTION (node
)
1581 tree decl
= node
->decl
;
1583 gcc_assert (!node
->process
|| node
->same_comdat_group
);
1587 /* We need to output all local functions that are used and not
1588 always inlined, as well as those that are reachable from
1589 outside the current compilation unit. */
1591 && !node
->thunk
.thunk_p
1593 && !node
->inlined_to
1594 && !TREE_ASM_WRITTEN (decl
)
1595 && !DECL_EXTERNAL (decl
))
1598 if (node
->same_comdat_group
)
1601 for (next
= dyn_cast
<cgraph_node
*> (node
->same_comdat_group
);
1603 next
= dyn_cast
<cgraph_node
*> (next
->same_comdat_group
))
1604 if (!next
->thunk
.thunk_p
&& !next
->alias
1605 && !next
->comdat_local_p ())
1609 else if (node
->same_comdat_group
)
1612 check_same_comdat_groups
= true;
1616 /* We should've reclaimed all functions that are not needed. */
1618 && !node
->inlined_to
1619 && gimple_has_body_p (decl
)
1620 /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
1621 are inside partition, we can end up not removing the body since we no longer
1622 have analyzed node pointing to it. */
1623 && !node
->in_other_partition
1626 && !DECL_EXTERNAL (decl
))
1629 internal_error ("failed to reclaim unneeded function");
1631 gcc_assert (node
->inlined_to
1632 || !gimple_has_body_p (decl
)
1633 || node
->in_other_partition
1635 || DECL_ARTIFICIAL (decl
)
1636 || DECL_EXTERNAL (decl
));
1641 if (flag_checking
&& check_same_comdat_groups
)
1642 FOR_EACH_FUNCTION (node
)
1643 if (node
->same_comdat_group
&& !node
->process
)
1645 tree decl
= node
->decl
;
1646 if (!node
->inlined_to
1647 && gimple_has_body_p (decl
)
1648 /* FIXME: in an ltrans unit when the offline copy is outside a
1649 partition but inline copies are inside a partition, we can
1650 end up not removing the body since we no longer have an
1651 analyzed node pointing to it. */
1652 && !node
->in_other_partition
1654 && !DECL_EXTERNAL (decl
))
1657 internal_error ("failed to reclaim unneeded function in same "
1663 /* DECL is FUNCTION_DECL. Initialize datastructures so DECL is a function
1664 in lowered gimple form. IN_SSA is true if the gimple is in SSA.
1666 Set current_function_decl and cfun to newly constructed empty function body.
1667 return basic block in the function body. */
1670 init_lowered_empty_function (tree decl
, bool in_ssa
, profile_count count
)
1675 current_function_decl
= decl
;
1676 allocate_struct_function (decl
, false);
1677 gimple_register_cfg_hooks ();
1678 init_empty_tree_cfg ();
1679 init_tree_ssa (cfun
);
1683 init_ssa_operands (cfun
);
1684 cfun
->gimple_df
->in_ssa_p
= true;
1685 cfun
->curr_properties
|= PROP_ssa
;
1688 DECL_INITIAL (decl
) = make_node (BLOCK
);
1689 BLOCK_SUPERCONTEXT (DECL_INITIAL (decl
)) = decl
;
1691 DECL_SAVED_TREE (decl
) = error_mark_node
;
1692 cfun
->curr_properties
|= (PROP_gimple_lcf
| PROP_gimple_leh
| PROP_gimple_any
1693 | PROP_cfg
| PROP_loops
);
1695 set_loops_for_fn (cfun
, ggc_cleared_alloc
<loops
> ());
1696 init_loops_structure (cfun
, loops_for_fn (cfun
), 1);
1697 loops_for_fn (cfun
)->state
|= LOOPS_MAY_HAVE_MULTIPLE_LATCHES
;
1699 /* Create BB for body of the function and connect it properly. */
1700 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
= count
;
1701 EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
= count
;
1702 bb
= create_basic_block (NULL
, ENTRY_BLOCK_PTR_FOR_FN (cfun
));
1704 e
= make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
), bb
, EDGE_FALLTHRU
);
1705 e
->probability
= profile_probability::always ();
1706 e
= make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
1707 e
->probability
= profile_probability::always ();
1708 add_bb_to_loop (bb
, ENTRY_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
1713 /* Adjust PTR by the constant FIXED_OFFSET, by the vtable offset indicated by
1714 VIRTUAL_OFFSET, and by the indirect offset indicated by INDIRECT_OFFSET, if
1715 it is non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and zero
1716 for a result adjusting thunk. */
1719 thunk_adjust (gimple_stmt_iterator
* bsi
,
1720 tree ptr
, bool this_adjusting
,
1721 HOST_WIDE_INT fixed_offset
, tree virtual_offset
,
1722 HOST_WIDE_INT indirect_offset
)
1728 && fixed_offset
!= 0)
1730 stmt
= gimple_build_assign
1731 (ptr
, fold_build_pointer_plus_hwi_loc (input_location
,
1734 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1737 if (!vtable_entry_type
&& (virtual_offset
|| indirect_offset
!= 0))
1739 tree vfunc_type
= make_node (FUNCTION_TYPE
);
1740 TREE_TYPE (vfunc_type
) = integer_type_node
;
1741 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
1742 layout_type (vfunc_type
);
1744 vtable_entry_type
= build_pointer_type (vfunc_type
);
1747 /* If there's a virtual offset, look up that value in the vtable and
1748 adjust the pointer again. */
1756 create_tmp_reg (build_pointer_type
1757 (build_pointer_type (vtable_entry_type
)), "vptr");
1759 /* The vptr is always at offset zero in the object. */
1760 stmt
= gimple_build_assign (vtabletmp
,
1761 build1 (NOP_EXPR
, TREE_TYPE (vtabletmp
),
1763 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1765 /* Form the vtable address. */
1766 vtabletmp2
= create_tmp_reg (TREE_TYPE (TREE_TYPE (vtabletmp
)),
1768 stmt
= gimple_build_assign (vtabletmp2
,
1769 build_simple_mem_ref (vtabletmp
));
1770 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1772 /* Find the entry with the vcall offset. */
1773 stmt
= gimple_build_assign (vtabletmp2
,
1774 fold_build_pointer_plus_loc (input_location
,
1777 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1779 /* Get the offset itself. */
1780 vtabletmp3
= create_tmp_reg (TREE_TYPE (TREE_TYPE (vtabletmp2
)),
1782 stmt
= gimple_build_assign (vtabletmp3
,
1783 build_simple_mem_ref (vtabletmp2
));
1784 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1786 /* Adjust the `this' pointer. */
1787 ptr
= fold_build_pointer_plus_loc (input_location
, ptr
, vtabletmp3
);
1788 ptr
= force_gimple_operand_gsi (bsi
, ptr
, true, NULL_TREE
, false,
1789 GSI_CONTINUE_LINKING
);
1792 /* Likewise for an offset that is stored in the object that contains the
1794 if (indirect_offset
!= 0)
1796 tree offset_ptr
, offset_tree
;
1798 /* Get the address of the offset. */
1800 = create_tmp_reg (build_pointer_type
1801 (build_pointer_type (vtable_entry_type
)),
1803 stmt
= gimple_build_assign (offset_ptr
,
1804 build1 (NOP_EXPR
, TREE_TYPE (offset_ptr
),
1806 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1808 stmt
= gimple_build_assign
1810 fold_build_pointer_plus_hwi_loc (input_location
, offset_ptr
,
1812 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1814 /* Get the offset itself. */
1815 offset_tree
= create_tmp_reg (TREE_TYPE (TREE_TYPE (offset_ptr
)),
1817 stmt
= gimple_build_assign (offset_tree
,
1818 build_simple_mem_ref (offset_ptr
));
1819 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1821 /* Adjust the `this' pointer. */
1822 ptr
= fold_build_pointer_plus_loc (input_location
, ptr
, offset_tree
);
1823 ptr
= force_gimple_operand_gsi (bsi
, ptr
, true, NULL_TREE
, false,
1824 GSI_CONTINUE_LINKING
);
1828 && fixed_offset
!= 0)
1829 /* Adjust the pointer by the constant. */
1837 ptrtmp
= create_tmp_reg (TREE_TYPE (ptr
), "ptr");
1838 stmt
= gimple_build_assign (ptrtmp
, ptr
);
1839 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1841 ptr
= fold_build_pointer_plus_hwi_loc (input_location
,
1842 ptrtmp
, fixed_offset
);
1845 /* Emit the statement and gimplify the adjustment expression. */
1846 ret
= create_tmp_reg (TREE_TYPE (ptr
), "adjusted_this");
1847 stmt
= gimple_build_assign (ret
, ptr
);
1848 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1853 /* Expand thunk NODE to gimple if possible.
1854 When FORCE_GIMPLE_THUNK is true, gimple thunk is created and
1855 no assembler is produced.
1856 When OUTPUT_ASM_THUNK is true, also produce assembler for
1857 thunks that are not lowered. */
1860 cgraph_node::expand_thunk (bool output_asm_thunks
, bool force_gimple_thunk
)
1862 bool this_adjusting
= thunk
.this_adjusting
;
1863 HOST_WIDE_INT fixed_offset
= thunk
.fixed_offset
;
1864 HOST_WIDE_INT virtual_value
= thunk
.virtual_value
;
1865 HOST_WIDE_INT indirect_offset
= thunk
.indirect_offset
;
1866 tree virtual_offset
= NULL
;
1867 tree alias
= callees
->callee
->decl
;
1868 tree thunk_fndecl
= decl
;
1871 if (!force_gimple_thunk
1873 && indirect_offset
== 0
1874 && !DECL_EXTERNAL (alias
)
1875 && !DECL_STATIC_CHAIN (alias
)
1876 && targetm
.asm_out
.can_output_mi_thunk (thunk_fndecl
, fixed_offset
,
1877 virtual_value
, alias
))
1880 tree restype
= TREE_TYPE (TREE_TYPE (thunk_fndecl
));
1882 if (!output_asm_thunks
)
1889 get_untransformed_body ();
1890 a
= DECL_ARGUMENTS (thunk_fndecl
);
1892 current_function_decl
= thunk_fndecl
;
1894 /* Ensure thunks are emitted in their correct sections. */
1895 resolve_unique_section (thunk_fndecl
, 0,
1896 flag_function_sections
);
1898 DECL_RESULT (thunk_fndecl
)
1899 = build_decl (DECL_SOURCE_LOCATION (thunk_fndecl
),
1900 RESULT_DECL
, 0, restype
);
1901 DECL_CONTEXT (DECL_RESULT (thunk_fndecl
)) = thunk_fndecl
;
1903 /* The back end expects DECL_INITIAL to contain a BLOCK, so we
1905 fn_block
= make_node (BLOCK
);
1906 BLOCK_VARS (fn_block
) = a
;
1907 DECL_INITIAL (thunk_fndecl
) = fn_block
;
1908 BLOCK_SUPERCONTEXT (fn_block
) = thunk_fndecl
;
1909 allocate_struct_function (thunk_fndecl
, false);
1910 init_function_start (thunk_fndecl
);
1912 insn_locations_init ();
1913 set_curr_insn_location (DECL_SOURCE_LOCATION (thunk_fndecl
));
1914 prologue_location
= curr_insn_location ();
1916 targetm
.asm_out
.output_mi_thunk (asm_out_file
, thunk_fndecl
,
1917 fixed_offset
, virtual_value
, alias
);
1919 insn_locations_finalize ();
1920 init_insn_lengths ();
1921 free_after_compilation (cfun
);
1922 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
1923 thunk
.thunk_p
= false;
1926 else if (stdarg_p (TREE_TYPE (thunk_fndecl
)))
1928 error ("generic thunk code fails for method %qD which uses %<...%>",
1930 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
1937 basic_block bb
, then_bb
, else_bb
, return_bb
;
1938 gimple_stmt_iterator bsi
;
1947 bool alias_is_noreturn
= TREE_THIS_VOLATILE (alias
);
1949 /* We may be called from expand_thunk that releases body except for
1950 DECL_ARGUMENTS. In this case force_gimple_thunk is true. */
1951 if (in_lto_p
&& !force_gimple_thunk
)
1952 get_untransformed_body ();
1954 /* We need to force DECL_IGNORED_P when the thunk is created
1955 after early debug was run. */
1956 if (force_gimple_thunk
)
1957 DECL_IGNORED_P (thunk_fndecl
) = 1;
1959 a
= DECL_ARGUMENTS (thunk_fndecl
);
1961 current_function_decl
= thunk_fndecl
;
1963 /* Ensure thunks are emitted in their correct sections. */
1964 resolve_unique_section (thunk_fndecl
, 0,
1965 flag_function_sections
);
1967 bitmap_obstack_initialize (NULL
);
1969 if (thunk
.virtual_offset_p
)
1970 virtual_offset
= size_int (virtual_value
);
1972 /* Build the return declaration for the function. */
1973 restype
= TREE_TYPE (TREE_TYPE (thunk_fndecl
));
1974 if (DECL_RESULT (thunk_fndecl
) == NULL_TREE
)
1976 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
1977 DECL_ARTIFICIAL (resdecl
) = 1;
1978 DECL_IGNORED_P (resdecl
) = 1;
1979 DECL_CONTEXT (resdecl
) = thunk_fndecl
;
1980 DECL_RESULT (thunk_fndecl
) = resdecl
;
1983 resdecl
= DECL_RESULT (thunk_fndecl
);
1985 profile_count cfg_count
= count
;
1986 if (!cfg_count
.initialized_p ())
1987 cfg_count
= profile_count::from_gcov_type (BB_FREQ_MAX
).guessed_local ();
1989 bb
= then_bb
= else_bb
= return_bb
1990 = init_lowered_empty_function (thunk_fndecl
, true, cfg_count
);
1992 bsi
= gsi_start_bb (bb
);
1994 /* Build call to the function being thunked. */
1995 if (!VOID_TYPE_P (restype
)
1996 && (!alias_is_noreturn
1997 || TREE_ADDRESSABLE (restype
)
1998 || TREE_CODE (TYPE_SIZE_UNIT (restype
)) != INTEGER_CST
))
2000 if (DECL_BY_REFERENCE (resdecl
))
2002 restmp
= gimple_fold_indirect_ref (resdecl
);
2004 restmp
= build2 (MEM_REF
,
2005 TREE_TYPE (TREE_TYPE (resdecl
)),
2007 build_int_cst (TREE_TYPE (resdecl
), 0));
2009 else if (!is_gimple_reg_type (restype
))
2011 if (aggregate_value_p (resdecl
, TREE_TYPE (thunk_fndecl
)))
2017 add_local_decl (cfun
, restmp
);
2018 BLOCK_VARS (DECL_INITIAL (current_function_decl
))
2023 restmp
= create_tmp_var (restype
, "retval");
2026 restmp
= create_tmp_reg (restype
, "retval");
2029 for (arg
= a
; arg
; arg
= DECL_CHAIN (arg
))
2031 auto_vec
<tree
> vargs (nargs
);
2036 vargs
.quick_push (thunk_adjust (&bsi
, a
, 1, fixed_offset
,
2037 virtual_offset
, indirect_offset
));
2038 arg
= DECL_CHAIN (a
);
2043 for (; i
< nargs
; i
++, arg
= DECL_CHAIN (arg
))
2046 if (VECTOR_TYPE_P (TREE_TYPE (arg
))
2047 || TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
2048 DECL_GIMPLE_REG_P (arg
) = 1;
2050 if (!is_gimple_val (arg
))
2052 tmp
= create_tmp_reg (TYPE_MAIN_VARIANT
2053 (TREE_TYPE (arg
)), "arg");
2054 gimple
*stmt
= gimple_build_assign (tmp
, arg
);
2055 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
2057 vargs
.quick_push (tmp
);
2059 call
= gimple_build_call_vec (build_fold_addr_expr_loc (0, alias
), vargs
);
2060 callees
->call_stmt
= call
;
2061 gimple_call_set_from_thunk (call
, true);
2062 if (DECL_STATIC_CHAIN (alias
))
2064 tree p
= DECL_STRUCT_FUNCTION (alias
)->static_chain_decl
;
2065 tree type
= TREE_TYPE (p
);
2066 tree decl
= build_decl (DECL_SOURCE_LOCATION (thunk_fndecl
),
2067 PARM_DECL
, create_tmp_var_name ("CHAIN"),
2069 DECL_ARTIFICIAL (decl
) = 1;
2070 DECL_IGNORED_P (decl
) = 1;
2071 TREE_USED (decl
) = 1;
2072 DECL_CONTEXT (decl
) = thunk_fndecl
;
2073 DECL_ARG_TYPE (decl
) = type
;
2074 TREE_READONLY (decl
) = 1;
2076 struct function
*sf
= DECL_STRUCT_FUNCTION (thunk_fndecl
);
2077 sf
->static_chain_decl
= decl
;
2079 gimple_call_set_chain (call
, decl
);
2082 /* Return slot optimization is always possible and in fact required to
2083 return values with DECL_BY_REFERENCE. */
2084 if (aggregate_value_p (resdecl
, TREE_TYPE (thunk_fndecl
))
2085 && (!is_gimple_reg_type (TREE_TYPE (resdecl
))
2086 || DECL_BY_REFERENCE (resdecl
)))
2087 gimple_call_set_return_slot_opt (call
, true);
2091 gimple_call_set_lhs (call
, restmp
);
2092 gcc_assert (useless_type_conversion_p (TREE_TYPE (restmp
),
2093 TREE_TYPE (TREE_TYPE (alias
))));
2095 gsi_insert_after (&bsi
, call
, GSI_NEW_STMT
);
2096 if (!alias_is_noreturn
)
2098 if (restmp
&& !this_adjusting
2099 && (fixed_offset
|| virtual_offset
))
2101 tree true_label
= NULL_TREE
;
2103 if (TREE_CODE (TREE_TYPE (restmp
)) == POINTER_TYPE
)
2107 /* If the return type is a pointer, we need to
2108 protect against NULL. We know there will be an
2109 adjustment, because that's why we're emitting a
2111 then_bb
= create_basic_block (NULL
, bb
);
2112 then_bb
->count
= cfg_count
- cfg_count
.apply_scale (1, 16);
2113 return_bb
= create_basic_block (NULL
, then_bb
);
2114 return_bb
->count
= cfg_count
;
2115 else_bb
= create_basic_block (NULL
, else_bb
);
2116 else_bb
->count
= cfg_count
.apply_scale (1, 16);
2117 add_bb_to_loop (then_bb
, bb
->loop_father
);
2118 add_bb_to_loop (return_bb
, bb
->loop_father
);
2119 add_bb_to_loop (else_bb
, bb
->loop_father
);
2120 remove_edge (single_succ_edge (bb
));
2121 true_label
= gimple_block_label (then_bb
);
2122 stmt
= gimple_build_cond (NE_EXPR
, restmp
,
2123 build_zero_cst (TREE_TYPE (restmp
)),
2124 NULL_TREE
, NULL_TREE
);
2125 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
2126 e
= make_edge (bb
, then_bb
, EDGE_TRUE_VALUE
);
2127 e
->probability
= profile_probability::guessed_always ()
2128 .apply_scale (1, 16);
2129 e
= make_edge (bb
, else_bb
, EDGE_FALSE_VALUE
);
2130 e
->probability
= profile_probability::guessed_always ()
2131 .apply_scale (1, 16);
2132 make_single_succ_edge (return_bb
,
2133 EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
2134 make_single_succ_edge (then_bb
, return_bb
, EDGE_FALLTHRU
);
2135 e
= make_edge (else_bb
, return_bb
, EDGE_FALLTHRU
);
2136 e
->probability
= profile_probability::always ();
2137 bsi
= gsi_last_bb (then_bb
);
2140 restmp
= thunk_adjust (&bsi
, restmp
, /*this_adjusting=*/0,
2141 fixed_offset
, virtual_offset
,
2146 bsi
= gsi_last_bb (else_bb
);
2147 stmt
= gimple_build_assign (restmp
,
2148 build_zero_cst (TREE_TYPE (restmp
)));
2149 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
2150 bsi
= gsi_last_bb (return_bb
);
2154 gimple_call_set_tail (call
, true);
2156 /* Build return value. */
2157 if (!DECL_BY_REFERENCE (resdecl
))
2158 ret
= gimple_build_return (restmp
);
2160 ret
= gimple_build_return (resdecl
);
2162 gsi_insert_after (&bsi
, ret
, GSI_NEW_STMT
);
2166 gimple_call_set_tail (call
, true);
2167 remove_edge (single_succ_edge (bb
));
2170 cfun
->gimple_df
->in_ssa_p
= true;
2171 update_max_bb_count ();
2172 profile_status_for_fn (cfun
)
2173 = cfg_count
.initialized_p () && cfg_count
.ipa_p ()
2174 ? PROFILE_READ
: PROFILE_GUESSED
;
2175 /* FIXME: C++ FE should stop setting TREE_ASM_WRITTEN on thunks. */
2176 TREE_ASM_WRITTEN (thunk_fndecl
) = false;
2177 delete_unreachable_blocks ();
2178 update_ssa (TODO_update_ssa
);
2179 checking_verify_flow_info ();
2180 free_dominance_info (CDI_DOMINATORS
);
2182 /* Since we want to emit the thunk, we explicitly mark its name as
2184 thunk
.thunk_p
= false;
2186 bitmap_obstack_release (NULL
);
2188 current_function_decl
= NULL
;
2193 /* Assemble thunks and aliases associated to node. */
2196 cgraph_node::assemble_thunks_and_aliases (void)
2201 for (e
= callers
; e
;)
2202 if (e
->caller
->thunk
.thunk_p
2203 && !e
->caller
->inlined_to
)
2205 cgraph_node
*thunk
= e
->caller
;
2208 thunk
->expand_thunk (true, false);
2209 thunk
->assemble_thunks_and_aliases ();
2214 FOR_EACH_ALIAS (this, ref
)
2216 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2217 if (!alias
->transparent_alias
)
2219 bool saved_written
= TREE_ASM_WRITTEN (decl
);
2221 /* Force assemble_alias to really output the alias this time instead
2222 of buffering it in same alias pairs. */
2223 TREE_ASM_WRITTEN (decl
) = 1;
2225 do_assemble_symver (alias
->decl
,
2226 DECL_ASSEMBLER_NAME (decl
));
2228 do_assemble_alias (alias
->decl
,
2229 DECL_ASSEMBLER_NAME (decl
));
2230 alias
->assemble_thunks_and_aliases ();
2231 TREE_ASM_WRITTEN (decl
) = saved_written
;
2236 /* Expand function specified by node. */
2239 cgraph_node::expand (void)
2241 location_t saved_loc
;
2243 /* We ought to not compile any inline clones. */
2244 gcc_assert (!inlined_to
);
2246 /* __RTL functions are compiled as soon as they are parsed, so don't
2248 if (native_rtl_p ())
2251 announce_function (decl
);
2253 gcc_assert (lowered
);
2254 get_untransformed_body ();
2256 /* Generate RTL for the body of DECL. */
2258 timevar_push (TV_REST_OF_COMPILATION
);
2260 gcc_assert (symtab
->global_info_ready
);
2262 /* Initialize the default bitmap obstack. */
2263 bitmap_obstack_initialize (NULL
);
2265 /* Initialize the RTL code for the function. */
2266 saved_loc
= input_location
;
2267 input_location
= DECL_SOURCE_LOCATION (decl
);
2269 gcc_assert (DECL_STRUCT_FUNCTION (decl
));
2270 push_cfun (DECL_STRUCT_FUNCTION (decl
));
2271 init_function_start (decl
);
2273 gimple_register_cfg_hooks ();
2275 bitmap_obstack_initialize (®_obstack
); /* FIXME, only at RTL generation*/
2277 execute_all_ipa_transforms (false);
2279 /* Perform all tree transforms and optimizations. */
2281 /* Signal the start of passes. */
2282 invoke_plugin_callbacks (PLUGIN_ALL_PASSES_START
, NULL
);
2284 execute_pass_list (cfun
, g
->get_passes ()->all_passes
);
2286 /* Signal the end of passes. */
2287 invoke_plugin_callbacks (PLUGIN_ALL_PASSES_END
, NULL
);
2289 bitmap_obstack_release (®_obstack
);
2291 /* Release the default bitmap obstack. */
2292 bitmap_obstack_release (NULL
);
2294 /* If requested, warn about function definitions where the function will
2295 return a value (usually of some struct or union type) which itself will
2296 take up a lot of stack space. */
2297 if (!DECL_EXTERNAL (decl
) && TREE_TYPE (decl
))
2299 tree ret_type
= TREE_TYPE (TREE_TYPE (decl
));
2301 if (ret_type
&& TYPE_SIZE_UNIT (ret_type
)
2302 && TREE_CODE (TYPE_SIZE_UNIT (ret_type
)) == INTEGER_CST
2303 && compare_tree_int (TYPE_SIZE_UNIT (ret_type
),
2304 warn_larger_than_size
) > 0)
2306 unsigned int size_as_int
2307 = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (ret_type
));
2309 if (compare_tree_int (TYPE_SIZE_UNIT (ret_type
), size_as_int
) == 0)
2310 warning (OPT_Wlarger_than_
,
2311 "size of return value of %q+D is %u bytes",
2314 warning (OPT_Wlarger_than_
,
2315 "size of return value of %q+D is larger than %wu bytes",
2316 decl
, warn_larger_than_size
);
2320 gimple_set_body (decl
, NULL
);
2321 if (DECL_STRUCT_FUNCTION (decl
) == 0
2322 && !cgraph_node::get (decl
)->origin
)
2324 /* Stop pointing to the local nodes about to be freed.
2325 But DECL_INITIAL must remain nonzero so we know this
2326 was an actual function definition.
2327 For a nested function, this is done in c_pop_function_context.
2328 If rest_of_compilation set this to 0, leave it 0. */
2329 if (DECL_INITIAL (decl
) != 0)
2330 DECL_INITIAL (decl
) = error_mark_node
;
2333 input_location
= saved_loc
;
2336 timevar_pop (TV_REST_OF_COMPILATION
);
2338 /* Make sure that BE didn't give up on compiling. */
2339 gcc_assert (TREE_ASM_WRITTEN (decl
));
2343 /* It would make a lot more sense to output thunks before function body to
2344 get more forward and fewer backward jumps. This however would need
2345 solving problem with comdats. See PR48668. Also aliases must come after
2346 function itself to make one pass assemblers, like one on AIX, happy.
2348 FIXME: Perhaps thunks should be move before function IFF they are not in
2350 assemble_thunks_and_aliases ();
2352 /* Eliminate all call edges. This is important so the GIMPLE_CALL no longer
2353 points to the dead function body. */
2355 remove_all_references ();
2358 /* Node comparator that is responsible for the order that corresponds
2359 to time when a function was launched for the first time. */
2362 node_cmp (const void *pa
, const void *pb
)
2364 const cgraph_node
*a
= *(const cgraph_node
* const *) pa
;
2365 const cgraph_node
*b
= *(const cgraph_node
* const *) pb
;
2367 /* Functions with time profile must be before these without profile. */
2368 if (!a
->tp_first_run
|| !b
->tp_first_run
)
2369 return a
->tp_first_run
- b
->tp_first_run
;
2371 return a
->tp_first_run
!= b
->tp_first_run
2372 ? b
->tp_first_run
- a
->tp_first_run
2373 : b
->order
- a
->order
;
2376 /* Expand all functions that must be output.
2378 Attempt to topologically sort the nodes so function is output when
2379 all called functions are already assembled to allow data to be
2380 propagated across the callgraph. Use a stack to get smaller distance
2381 between a function and its callees (later we may choose to use a more
2382 sophisticated algorithm for function reordering; we will likely want
2383 to use subsections to make the output functions appear in top-down
2387 expand_all_functions (void)
2390 cgraph_node
**order
= XCNEWVEC (cgraph_node
*,
2391 symtab
->cgraph_count
);
2392 unsigned int expanded_func_count
= 0, profiled_func_count
= 0;
2393 int order_pos
, new_order_pos
= 0;
2396 order_pos
= ipa_reverse_postorder (order
);
2397 gcc_assert (order_pos
== symtab
->cgraph_count
);
2399 /* Garbage collector may remove inline clones we eliminate during
2400 optimization. So we must be sure to not reference them. */
2401 for (i
= 0; i
< order_pos
; i
++)
2402 if (order
[i
]->process
)
2403 order
[new_order_pos
++] = order
[i
];
2405 if (flag_profile_reorder_functions
)
2406 qsort (order
, new_order_pos
, sizeof (cgraph_node
*), node_cmp
);
2408 for (i
= new_order_pos
- 1; i
>= 0; i
--)
2414 expanded_func_count
++;
2415 if(node
->tp_first_run
)
2416 profiled_func_count
++;
2418 if (symtab
->dump_file
)
2419 fprintf (symtab
->dump_file
,
2420 "Time profile order in expand_all_functions:%s:%d\n",
2421 node
->asm_name (), node
->tp_first_run
);
2428 fprintf (dump_file
, "Expanded functions with time profile (%s):%u/%u\n",
2429 main_input_filename
, profiled_func_count
, expanded_func_count
);
2431 if (symtab
->dump_file
&& flag_profile_reorder_functions
)
2432 fprintf (symtab
->dump_file
, "Expanded functions with time profile:%u/%u\n",
2433 profiled_func_count
, expanded_func_count
);
2435 symtab
->process_new_functions ();
2436 free_gimplify_stack ();
2441 /* This is used to sort the node types by the cgraph order number. */
2443 enum cgraph_order_sort_kind
2445 ORDER_UNDEFINED
= 0,
2452 struct cgraph_order_sort
2454 enum cgraph_order_sort_kind kind
;
2463 /* Output all functions, variables, and asm statements in the order
2464 according to their order fields, which is the order in which they
2465 appeared in the file. This implements -fno-toplevel-reorder. In
2466 this mode we may output functions and variables which don't really
2467 need to be output. */
2470 output_in_order (void)
2473 cgraph_order_sort
*nodes
;
2478 max
= symtab
->order
;
2479 nodes
= XCNEWVEC (cgraph_order_sort
, max
);
2481 FOR_EACH_DEFINED_FUNCTION (pf
)
2483 if (pf
->process
&& !pf
->thunk
.thunk_p
&& !pf
->alias
)
2485 if (!pf
->no_reorder
)
2488 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
2489 nodes
[i
].kind
= ORDER_FUNCTION
;
2494 /* There is a similar loop in symbol_table::output_variables.
2495 Please keep them in sync. */
2496 FOR_EACH_VARIABLE (pv
)
2498 if (!pv
->no_reorder
)
2500 if (DECL_HARD_REGISTER (pv
->decl
)
2501 || DECL_HAS_VALUE_EXPR_P (pv
->decl
))
2504 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
2505 nodes
[i
].kind
= pv
->definition
? ORDER_VAR
: ORDER_VAR_UNDEF
;
2509 for (pa
= symtab
->first_asm_symbol (); pa
; pa
= pa
->next
)
2512 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
2513 nodes
[i
].kind
= ORDER_ASM
;
2517 /* In toplevel reorder mode we output all statics; mark them as needed. */
2519 for (i
= 0; i
< max
; ++i
)
2520 if (nodes
[i
].kind
== ORDER_VAR
)
2521 nodes
[i
].u
.v
->finalize_named_section_flags ();
2523 for (i
= 0; i
< max
; ++i
)
2525 switch (nodes
[i
].kind
)
2527 case ORDER_FUNCTION
:
2528 nodes
[i
].u
.f
->process
= 0;
2529 nodes
[i
].u
.f
->expand ();
2533 nodes
[i
].u
.v
->assemble_decl ();
2536 case ORDER_VAR_UNDEF
:
2537 assemble_undefined_decl (nodes
[i
].u
.v
->decl
);
2541 assemble_asm (nodes
[i
].u
.a
->asm_str
);
2544 case ORDER_UNDEFINED
:
2552 symtab
->clear_asm_symbols ();
2560 gcc::pass_manager
*passes
= g
->get_passes ();
2563 current_function_decl
= NULL
;
2564 gimple_register_cfg_hooks ();
2565 bitmap_obstack_initialize (NULL
);
2567 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_START
, NULL
);
2571 execute_ipa_pass_list (passes
->all_small_ipa_passes
);
2576 /* This extra symtab_remove_unreachable_nodes pass tends to catch some
2577 devirtualization and other changes where removal iterate. */
2578 symtab
->remove_unreachable_nodes (symtab
->dump_file
);
2580 /* If pass_all_early_optimizations was not scheduled, the state of
2581 the cgraph will not be properly updated. Update it now. */
2582 if (symtab
->state
< IPA_SSA
)
2583 symtab
->state
= IPA_SSA
;
2587 /* Generate coverage variables and constructors. */
2590 /* Process new functions added. */
2592 current_function_decl
= NULL
;
2593 symtab
->process_new_functions ();
2595 execute_ipa_summary_passes
2596 ((ipa_opt_pass_d
*) passes
->all_regular_ipa_passes
);
2599 /* Some targets need to handle LTO assembler output specially. */
2600 if (flag_generate_lto
|| flag_generate_offload
)
2601 targetm
.asm_out
.lto_start ();
2604 || flag_incremental_link
== INCREMENTAL_LINK_LTO
)
2607 fprintf (stderr
, "Streaming LTO\n");
2608 if (g
->have_offload
)
2610 section_name_prefix
= OFFLOAD_SECTION_NAME_PREFIX
;
2611 lto_stream_offload_p
= true;
2612 ipa_write_summaries ();
2613 lto_stream_offload_p
= false;
2617 section_name_prefix
= LTO_SECTION_NAME_PREFIX
;
2618 lto_stream_offload_p
= false;
2619 ipa_write_summaries ();
2623 if (flag_generate_lto
|| flag_generate_offload
)
2624 targetm
.asm_out
.lto_end ();
2627 && ((in_lto_p
&& flag_incremental_link
!= INCREMENTAL_LINK_LTO
)
2628 || !flag_lto
|| flag_fat_lto_objects
))
2629 execute_ipa_pass_list (passes
->all_regular_ipa_passes
);
2630 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_END
, NULL
);
2632 bitmap_obstack_release (NULL
);
2636 /* Return string alias is alias of. */
2639 get_alias_symbol (tree decl
)
2641 tree alias
= lookup_attribute ("alias", DECL_ATTRIBUTES (decl
));
2642 return get_identifier (TREE_STRING_POINTER
2643 (TREE_VALUE (TREE_VALUE (alias
))));
2647 /* Weakrefs may be associated to external decls and thus not output
2648 at expansion time. Emit all necessary aliases. */
2651 symbol_table::output_weakrefs (void)
2654 FOR_EACH_SYMBOL (node
)
2656 && !TREE_ASM_WRITTEN (node
->decl
)
2661 /* Weakrefs are special by not requiring target definition in current
2662 compilation unit. It is thus bit hard to work out what we want to
2664 When alias target is defined, we need to fetch it from symtab reference,
2665 otherwise it is pointed to by alias_target. */
2666 if (node
->alias_target
)
2667 target
= (DECL_P (node
->alias_target
)
2668 ? DECL_ASSEMBLER_NAME (node
->alias_target
)
2669 : node
->alias_target
);
2670 else if (node
->analyzed
)
2671 target
= DECL_ASSEMBLER_NAME (node
->get_alias_target ()->decl
);
2675 target
= get_alias_symbol (node
->decl
);
2677 do_assemble_alias (node
->decl
, target
);
2681 /* Perform simple optimizations based on callgraph. */
2684 symbol_table::compile (void)
2689 symtab_node::checking_verify_symtab_nodes ();
2691 timevar_push (TV_CGRAPHOPT
);
2692 if (pre_ipa_mem_report
)
2693 dump_memory_report ("Memory consumption before IPA");
2695 fprintf (stderr
, "Performing interprocedural optimizations\n");
2698 /* If LTO is enabled, initialize the streamer hooks needed by GIMPLE. */
2699 if (flag_generate_lto
|| flag_generate_offload
)
2700 lto_streamer_hooks_init ();
2702 /* Don't run the IPA passes if there was any error or sorry messages. */
2705 timevar_start (TV_CGRAPH_IPA_PASSES
);
2707 timevar_stop (TV_CGRAPH_IPA_PASSES
);
2709 /* Do nothing else if any IPA pass found errors or if we are just streaming LTO. */
2711 || ((!in_lto_p
|| flag_incremental_link
== INCREMENTAL_LINK_LTO
)
2712 && flag_lto
&& !flag_fat_lto_objects
))
2714 timevar_pop (TV_CGRAPHOPT
);
2718 global_info_ready
= true;
2721 fprintf (dump_file
, "Optimized ");
2722 symtab
->dump (dump_file
);
2724 if (post_ipa_mem_report
)
2725 dump_memory_report ("Memory consumption after IPA");
2726 timevar_pop (TV_CGRAPHOPT
);
2728 /* Output everything. */
2729 switch_to_section (text_section
);
2730 (*debug_hooks
->assembly_start
) ();
2732 fprintf (stderr
, "Assembling functions:\n");
2733 symtab_node::checking_verify_symtab_nodes ();
2735 bitmap_obstack_initialize (NULL
);
2736 execute_ipa_pass_list (g
->get_passes ()->all_late_ipa_passes
);
2737 bitmap_obstack_release (NULL
);
2738 mark_functions_to_output ();
2740 /* When weakref support is missing, we automatically translate all
2741 references to NODE to references to its ultimate alias target.
2742 The renaming mechanism uses flag IDENTIFIER_TRANSPARENT_ALIAS and
2745 Set up this mapping before we output any assembler but once we are sure
2746 that all symbol renaming is done.
2748 FIXME: All this ugliness can go away if we just do renaming at gimple
2749 level by physically rewriting the IL. At the moment we can only redirect
2750 calls, so we need infrastructure for renaming references as well. */
2751 #ifndef ASM_OUTPUT_WEAKREF
2754 FOR_EACH_SYMBOL (node
)
2756 && lookup_attribute ("weakref", DECL_ATTRIBUTES (node
->decl
)))
2758 IDENTIFIER_TRANSPARENT_ALIAS
2759 (DECL_ASSEMBLER_NAME (node
->decl
)) = 1;
2760 TREE_CHAIN (DECL_ASSEMBLER_NAME (node
->decl
))
2761 = (node
->alias_target
? node
->alias_target
2762 : DECL_ASSEMBLER_NAME (node
->get_alias_target ()->decl
));
2768 /* Output first asm statements and anything ordered. The process
2769 flag is cleared for these nodes, so we skip them later. */
2772 timevar_start (TV_CGRAPH_FUNC_EXPANSION
);
2773 expand_all_functions ();
2774 timevar_stop (TV_CGRAPH_FUNC_EXPANSION
);
2776 output_variables ();
2778 process_new_functions ();
2784 fprintf (dump_file
, "\nFinal ");
2785 symtab
->dump (dump_file
);
2789 symtab_node::verify_symtab_nodes ();
2790 /* Double check that all inline clones are gone and that all
2791 function bodies have been released from memory. */
2795 bool error_found
= false;
2797 FOR_EACH_DEFINED_FUNCTION (node
)
2798 if (node
->inlined_to
2799 || gimple_has_body_p (node
->decl
))
2805 internal_error ("nodes with unreleased memory found");
2809 /* Earlydebug dump file, flags, and number. */
2811 static int debuginfo_early_dump_nr
;
2812 static FILE *debuginfo_early_dump_file
;
2813 static dump_flags_t debuginfo_early_dump_flags
;
2815 /* Debug dump file, flags, and number. */
2817 static int debuginfo_dump_nr
;
2818 static FILE *debuginfo_dump_file
;
2819 static dump_flags_t debuginfo_dump_flags
;
2821 /* Register the debug and earlydebug dump files. */
2824 debuginfo_early_init (void)
2826 gcc::dump_manager
*dumps
= g
->get_dumps ();
2827 debuginfo_early_dump_nr
= dumps
->dump_register (".earlydebug", "earlydebug",
2828 "earlydebug", DK_tree
,
2831 debuginfo_dump_nr
= dumps
->dump_register (".debug", "debug",
2837 /* Initialize the debug and earlydebug dump files. */
2840 debuginfo_init (void)
2842 gcc::dump_manager
*dumps
= g
->get_dumps ();
2843 debuginfo_dump_file
= dump_begin (debuginfo_dump_nr
, NULL
);
2844 debuginfo_dump_flags
= dumps
->get_dump_file_info (debuginfo_dump_nr
)->pflags
;
2845 debuginfo_early_dump_file
= dump_begin (debuginfo_early_dump_nr
, NULL
);
2846 debuginfo_early_dump_flags
2847 = dumps
->get_dump_file_info (debuginfo_early_dump_nr
)->pflags
;
2850 /* Finalize the debug and earlydebug dump files. */
2853 debuginfo_fini (void)
2855 if (debuginfo_dump_file
)
2856 dump_end (debuginfo_dump_nr
, debuginfo_dump_file
);
2857 if (debuginfo_early_dump_file
)
2858 dump_end (debuginfo_early_dump_nr
, debuginfo_early_dump_file
);
2861 /* Set dump_file to the debug dump file. */
2864 debuginfo_start (void)
2866 set_dump_file (debuginfo_dump_file
);
2869 /* Undo setting dump_file to the debug dump file. */
2872 debuginfo_stop (void)
2874 set_dump_file (NULL
);
2877 /* Set dump_file to the earlydebug dump file. */
2880 debuginfo_early_start (void)
2882 set_dump_file (debuginfo_early_dump_file
);
2885 /* Undo setting dump_file to the earlydebug dump file. */
2888 debuginfo_early_stop (void)
2890 set_dump_file (NULL
);
2893 /* Analyze the whole compilation unit once it is parsed completely. */
2896 symbol_table::finalize_compilation_unit (void)
2898 timevar_push (TV_CGRAPH
);
2900 /* If we're here there's no current function anymore. Some frontends
2901 are lazy in clearing these. */
2902 current_function_decl
= NULL
;
2905 /* Do not skip analyzing the functions if there were errors, we
2906 miss diagnostics for following functions otherwise. */
2908 /* Emit size functions we didn't inline. */
2909 finalize_size_functions ();
2911 /* Mark alias targets necessary and emit diagnostics. */
2912 handle_alias_pairs ();
2916 fprintf (stderr
, "\nAnalyzing compilation unit\n");
2920 if (flag_dump_passes
)
2923 /* Gimplify and lower all functions, compute reachability and
2924 remove unreachable nodes. */
2925 analyze_functions (/*first_time=*/true);
2927 /* Mark alias targets necessary and emit diagnostics. */
2928 handle_alias_pairs ();
2930 /* Gimplify and lower thunks. */
2931 analyze_functions (/*first_time=*/false);
2933 /* Offloading requires LTO infrastructure. */
2934 if (!in_lto_p
&& g
->have_offload
)
2935 flag_generate_offload
= 1;
2939 /* Emit early debug for reachable functions, and by consequence,
2940 locally scoped symbols. */
2941 struct cgraph_node
*cnode
;
2942 FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (cnode
)
2943 (*debug_hooks
->early_global_decl
) (cnode
->decl
);
2945 /* Clean up anything that needs cleaning up after initial debug
2947 debuginfo_early_start ();
2948 (*debug_hooks
->early_finish
) (main_input_filename
);
2949 debuginfo_early_stop ();
2952 /* Finally drive the pass manager. */
2955 timevar_pop (TV_CGRAPH
);
2958 /* Reset all state within cgraphunit.c so that we can rerun the compiler
2959 within the same process. For use by toplev::finalize. */
2962 cgraphunit_c_finalize (void)
2964 gcc_assert (cgraph_new_nodes
.length () == 0);
2965 cgraph_new_nodes
.truncate (0);
2967 vtable_entry_type
= NULL
;
2968 queued_nodes
= &symtab_terminator
;
2970 first_analyzed
= NULL
;
2971 first_analyzed_var
= NULL
;
2974 /* Creates a wrapper from cgraph_node to TARGET node. Thunk is used for this
2975 kind of wrapper method. */
2978 cgraph_node::create_wrapper (cgraph_node
*target
)
2980 /* Preserve DECL_RESULT so we get right by reference flag. */
2981 tree decl_result
= DECL_RESULT (decl
);
2983 /* Remove the function's body but keep arguments to be reused
2985 release_body (true);
2988 DECL_UNINLINABLE (decl
) = false;
2989 DECL_RESULT (decl
) = decl_result
;
2990 DECL_INITIAL (decl
) = NULL
;
2991 allocate_struct_function (decl
, false);
2994 /* Turn alias into thunk and expand it into GIMPLE representation. */
2997 memset (&thunk
, 0, sizeof (cgraph_thunk_info
));
2998 thunk
.thunk_p
= true;
2999 create_edge (target
, NULL
, count
);
3000 callees
->can_throw_external
= !TREE_NOTHROW (target
->decl
);
3002 tree arguments
= DECL_ARGUMENTS (decl
);
3006 TREE_ADDRESSABLE (arguments
) = false;
3007 arguments
= TREE_CHAIN (arguments
);
3010 expand_thunk (false, true);
3012 /* Inline summary set-up. */
3014 inline_analyze_function (this);
3017 #include "gt-cgraphunit.h"