1 /* Driver of optimization process
2 Copyright (C) 2003-2023 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-iterator.h"
183 #include "gimple-fold.h"
184 #include "gimplify.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"
208 #include "ipa-inline.h"
209 #include "omp-offload.h"
210 #include "symtab-thunks.h"
212 /* Queue of cgraph nodes scheduled to be added into cgraph. This is a
213 secondary queue used during optimization to accommodate passes that
214 may generate new functions that need to be optimized and expanded. */
215 vec
<cgraph_node
*> cgraph_new_nodes
;
217 static void expand_all_functions (void);
218 static void mark_functions_to_output (void);
219 static void handle_alias_pairs (void);
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 (SYMTAB_SYMBOL
);
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 node
->semantic_interposition
= opt_for_fn (decl
, flag_semantic_interposition
);
456 if (!flag_toplevel_reorder
)
457 node
->no_reorder
= true;
459 /* With -fkeep-inline-functions we are keeping all inline functions except
460 for extern inline ones. */
461 if (flag_keep_inline_functions
462 && DECL_DECLARED_INLINE_P (decl
)
463 && !DECL_EXTERNAL (decl
)
464 && !DECL_DISREGARD_INLINE_LIMITS (decl
))
465 node
->force_output
= 1;
467 /* __RTL functions were already output as soon as they were parsed (due
468 to the large amount of global state in the backend).
469 Mark such functions as "force_output" to reflect the fact that they
470 will be in the asm file when considering the symbols they reference.
471 The attempt to output them later on will bail out immediately. */
472 if (node
->native_rtl_p ())
473 node
->force_output
= 1;
475 /* When not optimizing, also output the static functions. (see
476 PR24561), but don't do so for always_inline functions, functions
477 declared inline and nested functions. These were optimized out
478 in the original implementation and it is unclear whether we want
479 to change the behavior here. */
480 if (((!opt_for_fn (decl
, optimize
) || flag_keep_static_functions
482 && !node
->cpp_implicit_alias
483 && !DECL_DISREGARD_INLINE_LIMITS (decl
)
484 && !DECL_DECLARED_INLINE_P (decl
)
485 && !(DECL_CONTEXT (decl
)
486 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
))
487 && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
))
488 node
->force_output
= 1;
490 /* If we've not yet emitted decl, tell the debug info about it. */
491 if (!TREE_ASM_WRITTEN (decl
))
492 (*debug_hooks
->deferred_inline_function
) (decl
);
497 if (symtab
->state
== CONSTRUCTION
498 && (node
->needed_p () || node
->referred_to_p ()))
502 /* Add the function FNDECL to the call graph.
503 Unlike finalize_function, this function is intended to be used
504 by middle end and allows insertion of new function at arbitrary point
505 of compilation. The function can be either in high, low or SSA form
508 The function is assumed to be reachable and have address taken (so no
509 API breaking optimizations are performed on it).
511 Main work done by this function is to enqueue the function for later
512 processing to avoid need the passes to be re-entrant. */
515 cgraph_node::add_new_function (tree fndecl
, bool lowered
)
517 gcc::pass_manager
*passes
= g
->get_passes ();
522 struct function
*fn
= DECL_STRUCT_FUNCTION (fndecl
);
523 const char *function_type
= ((gimple_has_body_p (fndecl
))
525 ? (gimple_in_ssa_p (fn
)
529 : "to-be-gimplified");
531 "Added new %s function %s to callgraph\n",
533 fndecl_name (fndecl
));
536 switch (symtab
->state
)
539 cgraph_node::finalize_function (fndecl
, false);
542 /* Just enqueue function to be processed at nearest occurrence. */
543 node
= cgraph_node::get_create (fndecl
);
545 node
->lowered
= true;
546 cgraph_new_nodes
.safe_push (node
);
551 case IPA_SSA_AFTER_INLINING
:
553 /* Bring the function into finalized state and enqueue for later
554 analyzing and compilation. */
555 node
= cgraph_node::get_create (fndecl
);
557 node
->definition
= true;
558 node
->semantic_interposition
= opt_for_fn (fndecl
,
559 flag_semantic_interposition
);
560 node
->force_output
= true;
561 if (TREE_PUBLIC (fndecl
))
562 node
->externally_visible
= true;
563 if (!lowered
&& symtab
->state
== EXPANSION
)
565 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
566 gimple_register_cfg_hooks ();
567 bitmap_obstack_initialize (NULL
);
568 execute_pass_list (cfun
, passes
->all_lowering_passes
);
569 passes
->execute_early_local_passes ();
570 bitmap_obstack_release (NULL
);
576 node
->lowered
= true;
577 cgraph_new_nodes
.safe_push (node
);
581 /* At the very end of compilation we have to do all the work up
583 node
= cgraph_node::create (fndecl
);
585 node
->lowered
= true;
586 node
->definition
= true;
587 node
->semantic_interposition
= opt_for_fn (fndecl
,
588 flag_semantic_interposition
);
590 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
591 gimple_register_cfg_hooks ();
592 bitmap_obstack_initialize (NULL
);
593 if (!gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
594 g
->get_passes ()->execute_early_local_passes ();
595 bitmap_obstack_release (NULL
);
604 /* Set a personality if required and we already passed EH lowering. */
606 && (function_needs_eh_personality (DECL_STRUCT_FUNCTION (fndecl
))
607 == eh_personality_lang
))
608 DECL_FUNCTION_PERSONALITY (fndecl
) = lang_hooks
.eh_personality ();
611 /* Analyze the function scheduled to be output. */
613 cgraph_node::analyze (void)
621 tree decl
= this->decl
;
622 location_t saved_loc
= input_location
;
623 input_location
= DECL_SOURCE_LOCATION (decl
);
624 semantic_interposition
= opt_for_fn (decl
, flag_semantic_interposition
);
628 thunk_info
*info
= thunk_info::get (this);
629 cgraph_node
*t
= cgraph_node::get (info
->alias
);
631 create_edge (t
, NULL
, t
->count
);
632 callees
->can_throw_external
= !TREE_NOTHROW (t
->decl
);
633 /* Target code in expand_thunk may need the thunk's target
634 to be analyzed, so recurse here. */
635 if (!t
->analyzed
&& t
->definition
)
639 t
= t
->get_alias_target ();
640 if (!t
->analyzed
&& t
->definition
)
643 bool ret
= expand_thunk (this, false, false);
644 thunk_info::get (this)->alias
= NULL
;
649 resolve_alias (cgraph_node::get (alias_target
), transparent_alias
);
650 else if (dispatcher_function
)
652 /* Generate the dispatcher body of multi-versioned functions. */
653 cgraph_function_version_info
*dispatcher_version_info
654 = function_version ();
655 if (dispatcher_version_info
!= NULL
656 && (dispatcher_version_info
->dispatcher_resolver
659 tree resolver
= NULL_TREE
;
660 gcc_assert (targetm
.generate_version_dispatcher_body
);
661 resolver
= targetm
.generate_version_dispatcher_body (this);
662 gcc_assert (resolver
!= NULL_TREE
);
667 push_cfun (DECL_STRUCT_FUNCTION (decl
));
669 assign_assembler_name_if_needed (decl
);
671 /* Make sure to gimplify bodies only once. During analyzing a
672 function we lower it, which will require gimplified nested
673 functions, so we can end up here with an already gimplified
675 if (!gimple_has_body_p (decl
))
676 gimplify_function_tree (decl
);
678 /* Lower the function. */
681 if (first_nested_function (this))
682 lower_nested_functions (decl
);
684 gimple_register_cfg_hooks ();
685 bitmap_obstack_initialize (NULL
);
686 execute_pass_list (cfun
, g
->get_passes ()->all_lowering_passes
);
688 bitmap_obstack_release (NULL
);
696 input_location
= saved_loc
;
699 /* C++ frontend produce same body aliases all over the place, even before PCH
700 gets streamed out. It relies on us linking the aliases with their function
701 in order to do the fixups, but ipa-ref is not PCH safe. Consequently we
702 first produce aliases without links, but once C++ FE is sure he won't stream
703 PCH we build the links via this function. */
706 symbol_table::process_same_body_aliases (void)
709 FOR_EACH_SYMBOL (node
)
710 if (node
->cpp_implicit_alias
&& !node
->analyzed
)
712 (VAR_P (node
->alias_target
)
713 ? (symtab_node
*)varpool_node::get_create (node
->alias_target
)
714 : (symtab_node
*)cgraph_node::get_create (node
->alias_target
));
715 cpp_implicit_aliases_done
= true;
718 /* Process a symver attribute. */
721 process_symver_attribute (symtab_node
*n
)
723 tree value
= lookup_attribute ("symver", DECL_ATTRIBUTES (n
->decl
));
725 for (; value
!= NULL
; value
= TREE_CHAIN (value
))
727 /* Starting from bintuils 2.35 gas supports:
728 # Assign foo to bar@V1 and baz@V2.
732 const char *purpose
= IDENTIFIER_POINTER (TREE_PURPOSE (value
));
733 if (strcmp (purpose
, "symver") != 0)
736 tree symver
= get_identifier_with_length
737 (TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (value
))),
738 TREE_STRING_LENGTH (TREE_VALUE (TREE_VALUE (value
))));
739 symtab_node
*def
= symtab_node::get_for_asmname (symver
);
743 error_at (DECL_SOURCE_LOCATION (n
->decl
),
744 "duplicate definition of a symbol version");
745 inform (DECL_SOURCE_LOCATION (def
->decl
),
746 "same version was previously defined here");
751 error_at (DECL_SOURCE_LOCATION (n
->decl
),
752 "symbol needs to be defined to have a version");
755 if (DECL_COMMON (n
->decl
))
757 error_at (DECL_SOURCE_LOCATION (n
->decl
),
758 "common symbol cannot be versioned");
761 if (DECL_COMDAT (n
->decl
))
763 error_at (DECL_SOURCE_LOCATION (n
->decl
),
764 "comdat symbol cannot be versioned");
769 error_at (DECL_SOURCE_LOCATION (n
->decl
),
770 "%<weakref%> cannot be versioned");
773 if (!TREE_PUBLIC (n
->decl
))
775 error_at (DECL_SOURCE_LOCATION (n
->decl
),
776 "versioned symbol must be public");
779 if (DECL_VISIBILITY (n
->decl
) != VISIBILITY_DEFAULT
)
781 error_at (DECL_SOURCE_LOCATION (n
->decl
),
782 "versioned symbol must have default visibility");
786 /* Create new symbol table entry representing the version. */
787 tree new_decl
= copy_node (n
->decl
);
789 DECL_INITIAL (new_decl
) = NULL_TREE
;
790 if (TREE_CODE (new_decl
) == FUNCTION_DECL
)
791 DECL_STRUCT_FUNCTION (new_decl
) = NULL
;
792 SET_DECL_ASSEMBLER_NAME (new_decl
, symver
);
793 TREE_PUBLIC (new_decl
) = 1;
794 DECL_ATTRIBUTES (new_decl
) = NULL
;
796 symtab_node
*symver_node
= symtab_node::get_create (new_decl
);
797 symver_node
->alias
= true;
798 symver_node
->definition
= true;
799 symver_node
->symver
= true;
800 symver_node
->create_reference (n
, IPA_REF_ALIAS
, NULL
);
801 symver_node
->analyzed
= true;
805 /* Process attributes common for vars and functions. */
808 process_common_attributes (symtab_node
*node
, tree decl
)
810 tree weakref
= lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
));
812 if (weakref
&& !lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)))
814 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wattributes
,
815 "%<weakref%> attribute should be accompanied with"
816 " an %<alias%> attribute");
817 DECL_WEAK (decl
) = 0;
818 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
819 DECL_ATTRIBUTES (decl
));
822 if (lookup_attribute ("no_reorder", DECL_ATTRIBUTES (decl
)))
823 node
->no_reorder
= 1;
824 process_symver_attribute (node
);
827 /* Look for externally_visible and used attributes and mark cgraph nodes
830 We cannot mark the nodes at the point the attributes are processed (in
831 handle_*_attribute) because the copy of the declarations available at that
832 point may not be canonical. For example, in:
835 void f() __attribute__((used));
837 the declaration we see in handle_used_attribute will be the second
838 declaration -- but the front end will subsequently merge that declaration
839 with the original declaration and discard the second declaration.
841 Furthermore, we can't mark these nodes in finalize_function because:
844 void f() __attribute__((externally_visible));
848 So, we walk the nodes at the end of the translation unit, applying the
849 attributes at that point. */
852 process_function_and_variable_attributes (cgraph_node
*first
,
853 varpool_node
*first_var
)
858 for (node
= symtab
->first_function (); node
!= first
;
859 node
= symtab
->next_function (node
))
861 tree decl
= node
->decl
;
864 && lookup_attribute ("flatten", DECL_ATTRIBUTES (decl
)))
866 tree tdecl
= node
->get_alias_target_tree ();
867 if (!tdecl
|| !DECL_P (tdecl
)
868 || !lookup_attribute ("flatten", DECL_ATTRIBUTES (tdecl
)))
869 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wattributes
,
870 "%<flatten%> attribute is ignored on aliases");
872 if (DECL_PRESERVE_P (decl
))
873 node
->mark_force_output ();
874 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
876 if (! TREE_PUBLIC (node
->decl
))
877 warning_at (DECL_SOURCE_LOCATION (node
->decl
), OPT_Wattributes
,
878 "%<externally_visible%>"
879 " attribute have effect only on public objects");
881 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
883 && (!node
->alias
|| DECL_INITIAL (decl
) != error_mark_node
))
885 /* NODE->DEFINITION && NODE->ALIAS is nonzero for valid weakref
886 function declarations; DECL_INITIAL is non-null for invalid
887 weakref functions that are also defined. */
888 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wattributes
,
889 "%<weakref%> attribute ignored"
890 " because function is defined");
891 DECL_WEAK (decl
) = 0;
892 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
893 DECL_ATTRIBUTES (decl
));
894 DECL_ATTRIBUTES (decl
) = remove_attribute ("alias",
895 DECL_ATTRIBUTES (decl
));
897 node
->weakref
= false;
898 node
->transparent_alias
= false;
900 else if (lookup_attribute ("alias", DECL_ATTRIBUTES (decl
))
903 warning_at (DECL_SOURCE_LOCATION (node
->decl
), OPT_Wattributes
,
904 "%<alias%> attribute ignored"
905 " because function is defined");
907 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (decl
))
908 && !DECL_DECLARED_INLINE_P (decl
)
909 /* redefining extern inline function makes it DECL_UNINLINABLE. */
910 && !DECL_UNINLINABLE (decl
))
911 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wattributes
,
912 "%<always_inline%> function might not be inlinable");
914 process_common_attributes (node
, decl
);
916 for (vnode
= symtab
->first_variable (); vnode
!= first_var
;
917 vnode
= symtab
->next_variable (vnode
))
919 tree decl
= vnode
->decl
;
920 if (DECL_EXTERNAL (decl
)
921 && DECL_INITIAL (decl
))
922 varpool_node::finalize_decl (decl
);
923 if (DECL_PRESERVE_P (decl
))
924 vnode
->force_output
= true;
925 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
927 if (! TREE_PUBLIC (vnode
->decl
))
928 warning_at (DECL_SOURCE_LOCATION (vnode
->decl
), OPT_Wattributes
,
929 "%<externally_visible%>"
930 " attribute have effect only on public objects");
932 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
934 && DECL_INITIAL (decl
))
936 warning_at (DECL_SOURCE_LOCATION (vnode
->decl
), OPT_Wattributes
,
937 "%<weakref%> attribute ignored"
938 " because variable is initialized");
939 DECL_WEAK (decl
) = 0;
940 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
941 DECL_ATTRIBUTES (decl
));
943 process_common_attributes (vnode
, decl
);
947 /* Mark DECL as finalized. By finalizing the declaration, frontend instruct the
948 middle end to output the variable to asm file, if needed or externally
952 varpool_node::finalize_decl (tree decl
)
954 varpool_node
*node
= varpool_node::get_create (decl
);
956 gcc_assert (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
));
958 if (node
->definition
)
960 /* Set definition first before calling notice_global_symbol so that
961 it is available to notice_global_symbol. */
962 node
->definition
= true;
963 node
->semantic_interposition
= flag_semantic_interposition
;
964 notice_global_symbol (decl
);
965 if (!flag_toplevel_reorder
)
966 node
->no_reorder
= true;
967 if (TREE_THIS_VOLATILE (decl
) || DECL_PRESERVE_P (decl
)
968 /* Traditionally we do not eliminate static variables when not
969 optimizing and when not doing toplevel reorder. */
970 || (node
->no_reorder
&& !DECL_COMDAT (node
->decl
)
971 && !DECL_ARTIFICIAL (node
->decl
)))
972 node
->force_output
= true;
974 if (symtab
->state
== CONSTRUCTION
975 && (node
->needed_p () || node
->referred_to_p ()))
977 if (symtab
->state
>= IPA_SSA
)
979 /* Some frontends produce various interface variables after compilation
981 if (symtab
->state
== FINISHED
983 && symtab
->state
== EXPANSION
))
984 node
->assemble_decl ();
987 /* EDGE is an polymorphic call. Mark all possible targets as reachable
988 and if there is only one target, perform trivial devirtualization.
989 REACHABLE_CALL_TARGETS collects target lists we already walked to
990 avoid duplicate work. */
993 walk_polymorphic_call_targets (hash_set
<void *> *reachable_call_targets
,
999 vec
<cgraph_node
*>targets
1000 = possible_polymorphic_call_targets
1001 (edge
, &final
, &cache_token
);
1003 if (cache_token
!= NULL
&& !reachable_call_targets
->add (cache_token
))
1005 if (symtab
->dump_file
)
1006 dump_possible_polymorphic_call_targets
1007 (symtab
->dump_file
, edge
);
1009 for (i
= 0; i
< targets
.length (); i
++)
1011 /* Do not bother to mark virtual methods in anonymous namespace;
1012 either we will find use of virtual table defining it, or it is
1014 if (targets
[i
]->definition
1016 (TREE_TYPE (targets
[i
]->decl
))
1018 && !type_in_anonymous_namespace_p
1019 (TYPE_METHOD_BASETYPE (TREE_TYPE (targets
[i
]->decl
))))
1020 enqueue_node (targets
[i
]);
1024 /* Very trivial devirtualization; when the type is
1025 final or anonymous (so we know all its derivation)
1026 and there is only one possible virtual call target,
1027 make the edge direct. */
1030 if (targets
.length () <= 1 && dbg_cnt (devirt
))
1032 cgraph_node
*target
;
1033 if (targets
.length () == 1)
1034 target
= targets
[0];
1036 target
= cgraph_node::create (builtin_decl_unreachable ());
1038 if (symtab
->dump_file
)
1040 fprintf (symtab
->dump_file
,
1041 "Devirtualizing call: ");
1042 print_gimple_stmt (symtab
->dump_file
,
1046 if (dump_enabled_p ())
1048 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, edge
->call_stmt
,
1049 "devirtualizing call in %s to %s\n",
1050 edge
->caller
->dump_name (),
1051 target
->dump_name ());
1054 edge
= cgraph_edge::make_direct (edge
, target
);
1055 gimple
*new_call
= cgraph_edge::redirect_call_stmt_to_callee (edge
);
1057 if (symtab
->dump_file
)
1059 fprintf (symtab
->dump_file
, "Devirtualized as: ");
1060 print_gimple_stmt (symtab
->dump_file
, new_call
, 0, TDF_SLIM
);
1066 /* Issue appropriate warnings for the global declaration DECL. */
1069 check_global_declaration (symtab_node
*snode
)
1071 const char *decl_file
;
1072 tree decl
= snode
->decl
;
1074 /* Warn about any function declared static but not defined. We don't
1075 warn about variables, because many programs have static variables
1076 that exist only to get some text into the object file. */
1077 if (TREE_CODE (decl
) == FUNCTION_DECL
1078 && DECL_INITIAL (decl
) == 0
1079 && DECL_EXTERNAL (decl
)
1080 && ! DECL_ARTIFICIAL (decl
)
1081 && ! TREE_PUBLIC (decl
))
1083 if (warning_suppressed_p (decl
, OPT_Wunused
))
1085 else if (snode
->referred_to_p (/*include_self=*/false))
1086 pedwarn (input_location
, 0, "%q+F used but never defined", decl
);
1088 warning (OPT_Wunused_function
, "%q+F declared %<static%> but never "
1092 /* Warn about static fns or vars defined but not used. */
1093 if (((warn_unused_function
&& TREE_CODE (decl
) == FUNCTION_DECL
)
1094 || (((warn_unused_variable
&& ! TREE_READONLY (decl
))
1095 || (warn_unused_const_variable
> 0 && TREE_READONLY (decl
)
1096 && (warn_unused_const_variable
== 2
1097 || (main_input_filename
!= NULL
1098 && (decl_file
= DECL_SOURCE_FILE (decl
)) != NULL
1099 && filename_cmp (main_input_filename
,
1102 && ! DECL_IN_SYSTEM_HEADER (decl
)
1103 && ! snode
->referred_to_p (/*include_self=*/false)
1104 /* This TREE_USED check is needed in addition to referred_to_p
1105 above, because the `__unused__' attribute is not being
1106 considered for referred_to_p. */
1107 && ! TREE_USED (decl
)
1108 /* The TREE_USED bit for file-scope decls is kept in the identifier,
1109 to handle multiple external decls in different scopes. */
1110 && ! (DECL_NAME (decl
) && TREE_USED (DECL_NAME (decl
)))
1111 && ! DECL_EXTERNAL (decl
)
1112 && ! DECL_ARTIFICIAL (decl
)
1113 && ! DECL_ABSTRACT_ORIGIN (decl
)
1114 && ! TREE_PUBLIC (decl
)
1115 /* A volatile variable might be used in some non-obvious way. */
1116 && (! VAR_P (decl
) || ! TREE_THIS_VOLATILE (decl
))
1117 /* Global register variables must be declared to reserve them. */
1118 && ! (VAR_P (decl
) && DECL_REGISTER (decl
))
1119 /* Global ctors and dtors are called by the runtime. */
1120 && (TREE_CODE (decl
) != FUNCTION_DECL
1121 || (!DECL_STATIC_CONSTRUCTOR (decl
)
1122 && !DECL_STATIC_DESTRUCTOR (decl
)))
1123 /* Otherwise, ask the language. */
1124 && lang_hooks
.decls
.warn_unused_global (decl
))
1125 warning_at (DECL_SOURCE_LOCATION (decl
),
1126 (TREE_CODE (decl
) == FUNCTION_DECL
)
1127 ? OPT_Wunused_function
1128 : (TREE_READONLY (decl
)
1129 ? OPT_Wunused_const_variable_
1130 : OPT_Wunused_variable
),
1131 "%qD defined but not used", decl
);
1134 /* Discover all functions and variables that are trivially needed, analyze
1135 them as well as all functions and variables referred by them */
1136 static cgraph_node
*first_analyzed
;
1137 static varpool_node
*first_analyzed_var
;
1139 /* FIRST_TIME is set to TRUE for the first time we are called for a
1140 translation unit from finalize_compilation_unit() or false
1144 analyze_functions (bool first_time
)
1146 /* Keep track of already processed nodes when called multiple times for
1147 intermodule optimization. */
1148 cgraph_node
*first_handled
= first_analyzed
;
1149 varpool_node
*first_handled_var
= first_analyzed_var
;
1150 hash_set
<void *> reachable_call_targets
;
1156 bool changed
= true;
1157 location_t saved_loc
= input_location
;
1159 bitmap_obstack_initialize (NULL
);
1160 symtab
->state
= CONSTRUCTION
;
1161 input_location
= UNKNOWN_LOCATION
;
1163 thunk_info::process_early_thunks ();
1165 /* Ugly, but the fixup cannot happen at a time same body alias is created;
1166 C++ FE is confused about the COMDAT groups being right. */
1167 if (symtab
->cpp_implicit_aliases_done
)
1168 FOR_EACH_SYMBOL (node
)
1169 if (node
->cpp_implicit_alias
)
1170 node
->fixup_same_cpp_alias_visibility (node
->get_alias_target ());
1171 build_type_inheritance_graph ();
1173 if (flag_openmp
&& first_time
)
1174 omp_discover_implicit_declare_target ();
1176 /* Analysis adds static variables that in turn adds references to new functions.
1177 So we need to iterate the process until it stabilize. */
1181 process_function_and_variable_attributes (first_analyzed
,
1182 first_analyzed_var
);
1184 /* First identify the trivially needed symbols. */
1185 for (node
= symtab
->first_symbol ();
1186 node
!= first_analyzed
1187 && node
!= first_analyzed_var
; node
= node
->next
)
1189 /* Convert COMDAT group designators to IDENTIFIER_NODEs. */
1190 node
->get_comdat_group_id ();
1191 if (node
->needed_p ())
1193 enqueue_node (node
);
1194 if (!changed
&& symtab
->dump_file
)
1195 fprintf (symtab
->dump_file
, "Trivially needed symbols:");
1197 if (symtab
->dump_file
)
1198 fprintf (symtab
->dump_file
, " %s", node
->dump_asm_name ());
1200 if (node
== first_analyzed
1201 || node
== first_analyzed_var
)
1204 symtab
->process_new_functions ();
1205 first_analyzed_var
= symtab
->first_variable ();
1206 first_analyzed
= symtab
->first_function ();
1208 if (changed
&& symtab
->dump_file
)
1209 fprintf (symtab
->dump_file
, "\n");
1211 /* Lower representation, build callgraph edges and references for all trivially
1212 needed symbols and all symbols referred by them. */
1213 while (queued_nodes
!= &symtab_terminator
)
1216 node
= queued_nodes
;
1217 queued_nodes
= (symtab_node
*)queued_nodes
->aux
;
1218 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
);
1219 if (cnode
&& cnode
->definition
)
1222 tree decl
= cnode
->decl
;
1224 /* ??? It is possible to create extern inline function
1225 and later using weak alias attribute to kill its body.
1226 See gcc.c-torture/compile/20011119-1.c */
1227 if (!DECL_STRUCT_FUNCTION (decl
)
1230 && !cnode
->dispatcher_function
)
1233 cnode
->redefined_extern_inline
= true;
1237 if (!cnode
->analyzed
)
1240 for (edge
= cnode
->callees
; edge
; edge
= edge
->next_callee
)
1241 if (edge
->callee
->definition
1242 && (!DECL_EXTERNAL (edge
->callee
->decl
)
1243 /* When not optimizing, do not try to analyze extern
1244 inline functions. Doing so is pointless. */
1245 || opt_for_fn (edge
->callee
->decl
, optimize
)
1246 /* Weakrefs needs to be preserved. */
1247 || edge
->callee
->alias
1248 /* always_inline functions are inlined even at -O0. */
1251 DECL_ATTRIBUTES (edge
->callee
->decl
))
1252 /* Multiversioned functions needs the dispatcher to
1253 be produced locally even for extern functions. */
1254 || edge
->callee
->function_version ()))
1255 enqueue_node (edge
->callee
);
1256 if (opt_for_fn (cnode
->decl
, optimize
)
1257 && opt_for_fn (cnode
->decl
, flag_devirtualize
))
1261 for (edge
= cnode
->indirect_calls
; edge
; edge
= next
)
1263 next
= edge
->next_callee
;
1264 if (edge
->indirect_info
->polymorphic
)
1265 walk_polymorphic_call_targets (&reachable_call_targets
,
1270 /* If decl is a clone of an abstract function,
1271 mark that abstract function so that we don't release its body.
1272 The DECL_INITIAL() of that abstract function declaration
1273 will be later needed to output debug info. */
1274 if (DECL_ABSTRACT_ORIGIN (decl
))
1276 cgraph_node
*origin_node
1277 = cgraph_node::get_create (DECL_ABSTRACT_ORIGIN (decl
));
1278 origin_node
->used_as_abstract_origin
= true;
1280 /* Preserve a functions function context node. It will
1281 later be needed to output debug info. */
1282 if (tree fn
= decl_function_context (decl
))
1284 cgraph_node
*origin_node
= cgraph_node::get_create (fn
);
1285 enqueue_node (origin_node
);
1290 varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
);
1291 if (vnode
&& vnode
->definition
&& !vnode
->analyzed
)
1295 if (node
->same_comdat_group
)
1298 for (next
= node
->same_comdat_group
;
1300 next
= next
->same_comdat_group
)
1301 if (!next
->comdat_local_p ())
1302 enqueue_node (next
);
1304 for (i
= 0; node
->iterate_reference (i
, ref
); i
++)
1305 if (ref
->referred
->definition
1306 && (!DECL_EXTERNAL (ref
->referred
->decl
)
1307 || ((TREE_CODE (ref
->referred
->decl
) != FUNCTION_DECL
1309 || (TREE_CODE (ref
->referred
->decl
) == FUNCTION_DECL
1310 && opt_for_fn (ref
->referred
->decl
, optimize
))
1312 || ref
->referred
->alias
)))
1313 enqueue_node (ref
->referred
);
1314 symtab
->process_new_functions ();
1317 update_type_inheritance_graph ();
1319 /* Collect entry points to the unit. */
1320 if (symtab
->dump_file
)
1322 fprintf (symtab
->dump_file
, "\n\nInitial ");
1323 symtab
->dump (symtab
->dump_file
);
1329 FOR_EACH_SYMBOL (snode
)
1330 check_global_declaration (snode
);
1333 if (symtab
->dump_file
)
1334 fprintf (symtab
->dump_file
, "\nRemoving unused symbols:");
1336 for (node
= symtab
->first_symbol ();
1337 node
!= first_handled
1338 && node
!= first_handled_var
; node
= next
)
1341 /* For symbols declared locally we clear TREE_READONLY when emitting
1342 the constructor (if one is needed). For external declarations we can
1343 not safely assume that the type is readonly because we may be called
1344 during its construction. */
1345 if (TREE_CODE (node
->decl
) == VAR_DECL
1346 && TYPE_P (TREE_TYPE (node
->decl
))
1347 && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (node
->decl
))
1348 && DECL_EXTERNAL (node
->decl
))
1349 TREE_READONLY (node
->decl
) = 0;
1350 if (!node
->aux
&& !node
->referred_to_p ())
1352 if (symtab
->dump_file
)
1353 fprintf (symtab
->dump_file
, " %s", node
->dump_name ());
1355 /* See if the debugger can use anything before the DECL
1356 passes away. Perhaps it can notice a DECL that is now a
1357 constant and can tag the early DIE with an appropriate
1360 Otherwise, this is the last chance the debug_hooks have
1361 at looking at optimized away DECLs, since
1362 late_global_decl will subsequently be called from the
1363 contents of the now pruned symbol table. */
1364 if (VAR_P (node
->decl
)
1365 && !decl_function_context (node
->decl
))
1367 /* We are reclaiming totally unreachable code and variables
1368 so they effectively appear as readonly. Show that to
1369 the debug machinery. */
1370 TREE_READONLY (node
->decl
) = 1;
1371 node
->definition
= false;
1372 (*debug_hooks
->late_global_decl
) (node
->decl
);
1378 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
))
1380 tree decl
= node
->decl
;
1382 if (cnode
->definition
&& !gimple_has_body_p (decl
)
1387 gcc_assert (!cnode
->definition
|| cnode
->thunk
1389 || gimple_has_body_p (decl
)
1390 || cnode
->native_rtl_p ());
1391 gcc_assert (cnode
->analyzed
== cnode
->definition
);
1395 for (;node
; node
= node
->next
)
1397 first_analyzed
= symtab
->first_function ();
1398 first_analyzed_var
= symtab
->first_variable ();
1399 if (symtab
->dump_file
)
1401 fprintf (symtab
->dump_file
, "\n\nReclaimed ");
1402 symtab
->dump (symtab
->dump_file
);
1404 bitmap_obstack_release (NULL
);
1406 /* Initialize assembler name hash, in particular we want to trigger C++
1407 mangling and same body alias creation before we free DECL_ARGUMENTS
1410 symtab
->symtab_initialize_asm_name_hash ();
1412 input_location
= saved_loc
;
1415 /* Check declaration of the type of ALIAS for compatibility with its TARGET
1416 (which may be an ifunc resolver) and issue a diagnostic when they are
1417 not compatible according to language rules (plus a C++ extension for
1418 non-static member functions). */
1421 maybe_diag_incompatible_alias (tree alias
, tree target
)
1423 tree altype
= TREE_TYPE (alias
);
1424 tree targtype
= TREE_TYPE (target
);
1426 bool ifunc
= cgraph_node::get (alias
)->ifunc_resolver
;
1427 tree funcptr
= altype
;
1431 /* Handle attribute ifunc first. */
1432 if (TREE_CODE (altype
) == METHOD_TYPE
)
1434 /* Set FUNCPTR to the type of the alias target. If the type
1435 is a non-static member function of class C, construct a type
1436 of an ordinary function taking C* as the first argument,
1437 followed by the member function argument list, and use it
1438 instead to check for incompatibility. This conversion is
1439 not defined by the language but an extension provided by
1442 tree rettype
= TREE_TYPE (altype
);
1443 tree args
= TYPE_ARG_TYPES (altype
);
1444 altype
= build_function_type (rettype
, args
);
1448 targtype
= TREE_TYPE (targtype
);
1450 if (POINTER_TYPE_P (targtype
))
1452 targtype
= TREE_TYPE (targtype
);
1454 /* Only issue Wattribute-alias for conversions to void* with
1456 if (VOID_TYPE_P (targtype
) && !extra_warnings
)
1459 /* Proceed to handle incompatible ifunc resolvers below. */
1463 funcptr
= build_pointer_type (funcptr
);
1465 error_at (DECL_SOURCE_LOCATION (target
),
1466 "%<ifunc%> resolver for %qD must return %qT",
1468 inform (DECL_SOURCE_LOCATION (alias
),
1469 "resolver indirect function declared here");
1474 if ((!FUNC_OR_METHOD_TYPE_P (targtype
)
1475 || (prototype_p (altype
)
1476 && prototype_p (targtype
)
1477 && !types_compatible_p (altype
, targtype
))))
1479 /* Warn for incompatibilities. Avoid warning for functions
1480 without a prototype to make it possible to declare aliases
1481 without knowing the exact type, as libstdc++ does. */
1484 funcptr
= build_pointer_type (funcptr
);
1486 auto_diagnostic_group d
;
1487 if (warning_at (DECL_SOURCE_LOCATION (target
),
1488 OPT_Wattribute_alias_
,
1489 "%<ifunc%> resolver for %qD should return %qT",
1491 inform (DECL_SOURCE_LOCATION (alias
),
1492 "resolver indirect function declared here");
1496 auto_diagnostic_group d
;
1497 if (warning_at (DECL_SOURCE_LOCATION (alias
),
1498 OPT_Wattribute_alias_
,
1499 "%qD alias between functions of incompatible "
1500 "types %qT and %qT", alias
, altype
, targtype
))
1501 inform (DECL_SOURCE_LOCATION (target
),
1502 "aliased declaration here");
1507 /* Translate the ugly representation of aliases as alias pairs into nice
1508 representation in callgraph. We don't handle all cases yet,
1512 handle_alias_pairs (void)
1517 for (i
= 0; alias_pairs
&& alias_pairs
->iterate (i
, &p
);)
1519 symtab_node
*target_node
= symtab_node::get_for_asmname (p
->target
);
1521 /* Weakrefs with target not defined in current unit are easy to handle:
1522 they behave just as external variables except we need to note the
1523 alias flag to later output the weakref pseudo op into asm file. */
1525 && lookup_attribute ("weakref", DECL_ATTRIBUTES (p
->decl
)) != NULL
)
1527 symtab_node
*node
= symtab_node::get (p
->decl
);
1530 node
->alias_target
= p
->target
;
1531 node
->weakref
= true;
1533 node
->transparent_alias
= true;
1535 alias_pairs
->unordered_remove (i
);
1538 else if (!target_node
)
1540 error ("%q+D aliased to undefined symbol %qE", p
->decl
, p
->target
);
1541 symtab_node
*node
= symtab_node::get (p
->decl
);
1543 node
->alias
= false;
1544 alias_pairs
->unordered_remove (i
);
1548 if (DECL_EXTERNAL (target_node
->decl
)
1549 /* We use local aliases for C++ thunks to force the tailcall
1550 to bind locally. This is a hack - to keep it working do
1551 the following (which is not strictly correct). */
1552 && (TREE_CODE (target_node
->decl
) != FUNCTION_DECL
1553 || ! DECL_VIRTUAL_P (target_node
->decl
))
1554 && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (p
->decl
)))
1556 error ("%q+D aliased to external symbol %qE",
1557 p
->decl
, p
->target
);
1560 if (TREE_CODE (p
->decl
) == FUNCTION_DECL
1561 && target_node
&& is_a
<cgraph_node
*> (target_node
))
1563 maybe_diag_incompatible_alias (p
->decl
, target_node
->decl
);
1565 maybe_diag_alias_attributes (p
->decl
, target_node
->decl
);
1567 cgraph_node
*src_node
= cgraph_node::get (p
->decl
);
1568 if (src_node
&& src_node
->definition
)
1570 cgraph_node::create_alias (p
->decl
, target_node
->decl
);
1571 alias_pairs
->unordered_remove (i
);
1573 else if (VAR_P (p
->decl
)
1574 && target_node
&& is_a
<varpool_node
*> (target_node
))
1576 varpool_node::create_alias (p
->decl
, target_node
->decl
);
1577 alias_pairs
->unordered_remove (i
);
1581 error ("%q+D alias between function and variable is not supported",
1583 inform (DECL_SOURCE_LOCATION (target_node
->decl
),
1584 "aliased declaration here");
1586 alias_pairs
->unordered_remove (i
);
1589 vec_free (alias_pairs
);
1593 /* Figure out what functions we want to assemble. */
1596 mark_functions_to_output (void)
1598 bool check_same_comdat_groups
= false;
1602 FOR_EACH_FUNCTION (node
)
1603 gcc_assert (!node
->process
);
1605 FOR_EACH_FUNCTION (node
)
1607 tree decl
= node
->decl
;
1609 gcc_assert (!node
->process
|| node
->same_comdat_group
);
1613 /* We need to output all local functions that are used and not
1614 always inlined, as well as those that are reachable from
1615 outside the current compilation unit. */
1619 && !node
->inlined_to
1620 && !TREE_ASM_WRITTEN (decl
)
1621 && !DECL_EXTERNAL (decl
))
1624 if (node
->same_comdat_group
)
1627 for (next
= dyn_cast
<cgraph_node
*> (node
->same_comdat_group
);
1629 next
= dyn_cast
<cgraph_node
*> (next
->same_comdat_group
))
1630 if (!next
->thunk
&& !next
->alias
1631 && !next
->comdat_local_p ())
1635 else if (node
->same_comdat_group
)
1638 check_same_comdat_groups
= true;
1642 /* We should've reclaimed all functions that are not needed. */
1644 && !node
->inlined_to
1645 && gimple_has_body_p (decl
)
1646 /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
1647 are inside partition, we can end up not removing the body since we no longer
1648 have analyzed node pointing to it. */
1649 && !node
->in_other_partition
1652 && !DECL_EXTERNAL (decl
))
1655 internal_error ("failed to reclaim unneeded function");
1657 gcc_assert (node
->inlined_to
1658 || !gimple_has_body_p (decl
)
1659 || node
->in_other_partition
1661 || DECL_ARTIFICIAL (decl
)
1662 || DECL_EXTERNAL (decl
));
1667 if (flag_checking
&& check_same_comdat_groups
)
1668 FOR_EACH_FUNCTION (node
)
1669 if (node
->same_comdat_group
&& !node
->process
)
1671 tree decl
= node
->decl
;
1672 if (!node
->inlined_to
1673 && gimple_has_body_p (decl
)
1674 /* FIXME: in an ltrans unit when the offline copy is outside a
1675 partition but inline copies are inside a partition, we can
1676 end up not removing the body since we no longer have an
1677 analyzed node pointing to it. */
1678 && !node
->in_other_partition
1680 && !DECL_EXTERNAL (decl
))
1683 internal_error ("failed to reclaim unneeded function in same "
1689 /* DECL is FUNCTION_DECL. Initialize datastructures so DECL is a function
1690 in lowered gimple form. IN_SSA is true if the gimple is in SSA.
1692 Set current_function_decl and cfun to newly constructed empty function body.
1693 return basic block in the function body. */
1696 init_lowered_empty_function (tree decl
, bool in_ssa
, profile_count count
)
1701 current_function_decl
= decl
;
1702 allocate_struct_function (decl
, false);
1703 gimple_register_cfg_hooks ();
1704 init_empty_tree_cfg ();
1705 init_tree_ssa (cfun
);
1709 init_ssa_operands (cfun
);
1710 cfun
->gimple_df
->in_ssa_p
= true;
1711 cfun
->curr_properties
|= PROP_ssa
;
1714 DECL_INITIAL (decl
) = make_node (BLOCK
);
1715 BLOCK_SUPERCONTEXT (DECL_INITIAL (decl
)) = decl
;
1717 DECL_SAVED_TREE (decl
) = error_mark_node
;
1718 cfun
->curr_properties
|= (PROP_gimple_lcf
| PROP_gimple_leh
| PROP_gimple_any
1719 | PROP_cfg
| PROP_loops
);
1721 set_loops_for_fn (cfun
, ggc_cleared_alloc
<loops
> ());
1722 init_loops_structure (cfun
, loops_for_fn (cfun
), 1);
1723 loops_for_fn (cfun
)->state
|= LOOPS_MAY_HAVE_MULTIPLE_LATCHES
;
1725 /* Create BB for body of the function and connect it properly. */
1726 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
= count
;
1727 EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
= count
;
1728 bb
= create_basic_block (NULL
, ENTRY_BLOCK_PTR_FOR_FN (cfun
));
1730 e
= make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
), bb
, EDGE_FALLTHRU
);
1731 e
->probability
= profile_probability::always ();
1732 e
= make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
1733 e
->probability
= profile_probability::always ();
1734 add_bb_to_loop (bb
, ENTRY_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
1739 /* Assemble thunks and aliases associated to node. */
1742 cgraph_node::assemble_thunks_and_aliases (void)
1747 for (e
= callers
; e
;)
1748 if (e
->caller
->thunk
1749 && !e
->caller
->inlined_to
)
1751 cgraph_node
*thunk
= e
->caller
;
1754 expand_thunk (thunk
, !rtl_dump_and_exit
, false);
1755 thunk
->assemble_thunks_and_aliases ();
1760 FOR_EACH_ALIAS (this, ref
)
1762 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
1763 if (!alias
->transparent_alias
)
1765 bool saved_written
= TREE_ASM_WRITTEN (decl
);
1767 /* Force assemble_alias to really output the alias this time instead
1768 of buffering it in same alias pairs. */
1769 TREE_ASM_WRITTEN (decl
) = 1;
1771 do_assemble_symver (alias
->decl
,
1772 DECL_ASSEMBLER_NAME (decl
));
1774 do_assemble_alias (alias
->decl
,
1775 DECL_ASSEMBLER_NAME (decl
));
1776 alias
->assemble_thunks_and_aliases ();
1777 TREE_ASM_WRITTEN (decl
) = saved_written
;
1782 /* Expand function specified by node. */
1785 cgraph_node::expand (void)
1787 location_t saved_loc
;
1789 /* We ought to not compile any inline clones. */
1790 gcc_assert (!inlined_to
);
1792 /* __RTL functions are compiled as soon as they are parsed, so don't
1794 if (native_rtl_p ())
1797 announce_function (decl
);
1799 gcc_assert (lowered
);
1801 /* Initialize the default bitmap obstack. */
1802 bitmap_obstack_initialize (NULL
);
1803 get_untransformed_body ();
1805 /* Generate RTL for the body of DECL. */
1807 timevar_push (TV_REST_OF_COMPILATION
);
1809 gcc_assert (symtab
->global_info_ready
);
1811 /* Initialize the RTL code for the function. */
1812 saved_loc
= input_location
;
1813 input_location
= DECL_SOURCE_LOCATION (decl
);
1815 gcc_assert (DECL_STRUCT_FUNCTION (decl
));
1816 push_cfun (DECL_STRUCT_FUNCTION (decl
));
1817 init_function_start (decl
);
1819 gimple_register_cfg_hooks ();
1821 bitmap_obstack_initialize (®_obstack
); /* FIXME, only at RTL generation*/
1823 update_ssa (TODO_update_ssa_only_virtuals
);
1824 if (ipa_transforms_to_apply
.exists ())
1825 execute_all_ipa_transforms (false);
1827 /* Perform all tree transforms and optimizations. */
1829 /* Signal the start of passes. */
1830 invoke_plugin_callbacks (PLUGIN_ALL_PASSES_START
, NULL
);
1832 execute_pass_list (cfun
, g
->get_passes ()->all_passes
);
1834 /* Signal the end of passes. */
1835 invoke_plugin_callbacks (PLUGIN_ALL_PASSES_END
, NULL
);
1837 bitmap_obstack_release (®_obstack
);
1839 /* Release the default bitmap obstack. */
1840 bitmap_obstack_release (NULL
);
1842 /* If requested, warn about function definitions where the function will
1843 return a value (usually of some struct or union type) which itself will
1844 take up a lot of stack space. */
1845 if (!DECL_EXTERNAL (decl
) && TREE_TYPE (decl
))
1847 tree ret_type
= TREE_TYPE (TREE_TYPE (decl
));
1849 if (ret_type
&& TYPE_SIZE_UNIT (ret_type
)
1850 && TREE_CODE (TYPE_SIZE_UNIT (ret_type
)) == INTEGER_CST
1851 && compare_tree_int (TYPE_SIZE_UNIT (ret_type
),
1852 warn_larger_than_size
) > 0)
1854 unsigned int size_as_int
1855 = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (ret_type
));
1857 if (compare_tree_int (TYPE_SIZE_UNIT (ret_type
), size_as_int
) == 0)
1858 warning (OPT_Wlarger_than_
,
1859 "size of return value of %q+D is %u bytes",
1862 warning (OPT_Wlarger_than_
,
1863 "size of return value of %q+D is larger than %wu bytes",
1864 decl
, warn_larger_than_size
);
1868 gimple_set_body (decl
, NULL
);
1869 if (DECL_STRUCT_FUNCTION (decl
) == 0)
1871 /* Stop pointing to the local nodes about to be freed.
1872 But DECL_INITIAL must remain nonzero so we know this
1873 was an actual function definition. */
1874 if (DECL_INITIAL (decl
) != 0)
1875 DECL_INITIAL (decl
) = error_mark_node
;
1878 input_location
= saved_loc
;
1881 timevar_pop (TV_REST_OF_COMPILATION
);
1883 if (DECL_STRUCT_FUNCTION (decl
)
1884 && DECL_STRUCT_FUNCTION (decl
)->assume_function
)
1886 /* Assume functions aren't expanded into RTL, on the other side
1887 we don't want to release their body. */
1893 /* Make sure that BE didn't give up on compiling. */
1894 gcc_assert (TREE_ASM_WRITTEN (decl
));
1898 /* It would make a lot more sense to output thunks before function body to
1899 get more forward and fewer backward jumps. This however would need
1900 solving problem with comdats. See PR48668. Also aliases must come after
1901 function itself to make one pass assemblers, like one on AIX, happy.
1903 FIXME: Perhaps thunks should be move before function IFF they are not in
1905 assemble_thunks_and_aliases ();
1909 /* Node comparator that is responsible for the order that corresponds
1910 to time when a function was launched for the first time. */
1913 tp_first_run_node_cmp (const void *pa
, const void *pb
)
1915 const cgraph_node
*a
= *(const cgraph_node
* const *) pa
;
1916 const cgraph_node
*b
= *(const cgraph_node
* const *) pb
;
1917 unsigned int tp_first_run_a
= a
->tp_first_run
;
1918 unsigned int tp_first_run_b
= b
->tp_first_run
;
1920 if (!opt_for_fn (a
->decl
, flag_profile_reorder_functions
)
1923 if (!opt_for_fn (b
->decl
, flag_profile_reorder_functions
)
1927 if (tp_first_run_a
== tp_first_run_b
)
1928 return a
->order
- b
->order
;
1930 /* Functions with time profile must be before these without profile. */
1931 tp_first_run_a
= (tp_first_run_a
- 1) & INT_MAX
;
1932 tp_first_run_b
= (tp_first_run_b
- 1) & INT_MAX
;
1934 return tp_first_run_a
- tp_first_run_b
;
1937 /* Expand all functions that must be output.
1939 Attempt to topologically sort the nodes so function is output when
1940 all called functions are already assembled to allow data to be
1941 propagated across the callgraph. Use a stack to get smaller distance
1942 between a function and its callees (later we may choose to use a more
1943 sophisticated algorithm for function reordering; we will likely want
1944 to use subsections to make the output functions appear in top-down
1948 expand_all_functions (void)
1951 cgraph_node
**order
= XCNEWVEC (cgraph_node
*,
1952 symtab
->cgraph_count
);
1953 cgraph_node
**tp_first_run_order
= XCNEWVEC (cgraph_node
*,
1954 symtab
->cgraph_count
);
1955 unsigned int expanded_func_count
= 0, profiled_func_count
= 0;
1956 int order_pos
, tp_first_run_order_pos
= 0, new_order_pos
= 0;
1959 order_pos
= ipa_reverse_postorder (order
);
1960 gcc_assert (order_pos
== symtab
->cgraph_count
);
1962 /* Garbage collector may remove inline clones we eliminate during
1963 optimization. So we must be sure to not reference them. */
1964 for (i
= 0; i
< order_pos
; i
++)
1965 if (order
[i
]->process
)
1967 if (order
[i
]->tp_first_run
1968 && opt_for_fn (order
[i
]->decl
, flag_profile_reorder_functions
))
1969 tp_first_run_order
[tp_first_run_order_pos
++] = order
[i
];
1971 order
[new_order_pos
++] = order
[i
];
1974 /* First output functions with time profile in specified order. */
1975 qsort (tp_first_run_order
, tp_first_run_order_pos
,
1976 sizeof (cgraph_node
*), tp_first_run_node_cmp
);
1977 for (i
= 0; i
< tp_first_run_order_pos
; i
++)
1979 node
= tp_first_run_order
[i
];
1983 expanded_func_count
++;
1984 profiled_func_count
++;
1986 if (symtab
->dump_file
)
1987 fprintf (symtab
->dump_file
,
1988 "Time profile order in expand_all_functions:%s:%d\n",
1989 node
->dump_asm_name (), node
->tp_first_run
);
1995 /* Output functions in RPO so callees get optimized before callers. This
1996 makes ipa-ra and other propagators to work.
1997 FIXME: This is far from optimal code layout.
1998 Make multiple passes over the list to defer processing of gc
1999 candidates until all potential uses are seen. */
2000 int gc_candidates
= 0;
2001 int prev_gc_candidates
= 0;
2005 for (i
= new_order_pos
- 1; i
>= 0; i
--)
2009 if (node
->gc_candidate
)
2011 else if (node
->process
)
2013 expanded_func_count
++;
2018 if (!gc_candidates
|| gc_candidates
== prev_gc_candidates
)
2020 prev_gc_candidates
= gc_candidates
;
2024 /* Free any unused gc_candidate functions. */
2026 for (i
= new_order_pos
- 1; i
>= 0; i
--)
2029 if (node
->gc_candidate
)
2031 struct function
*fn
= DECL_STRUCT_FUNCTION (node
->decl
);
2032 if (symtab
->dump_file
)
2033 fprintf (symtab
->dump_file
,
2034 "Deleting unused function %s\n",
2035 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (node
->decl
)));
2036 node
->process
= false;
2037 free_dominance_info (fn
, CDI_DOMINATORS
);
2038 free_dominance_info (fn
, CDI_POST_DOMINATORS
);
2039 node
->release_body (false);
2044 fprintf (dump_file
, "Expanded functions with time profile (%s):%u/%u\n",
2045 main_input_filename
, profiled_func_count
, expanded_func_count
);
2047 if (symtab
->dump_file
&& tp_first_run_order_pos
)
2048 fprintf (symtab
->dump_file
, "Expanded functions with time profile:%u/%u\n",
2049 profiled_func_count
, expanded_func_count
);
2051 symtab
->process_new_functions ();
2052 free_gimplify_stack ();
2053 delete ipa_saved_clone_sources
;
2054 ipa_saved_clone_sources
= NULL
;
2056 free (tp_first_run_order
);
2059 /* This is used to sort the node types by the cgraph order number. */
2061 enum cgraph_order_sort_kind
2069 struct cgraph_order_sort
2071 /* Construct from a cgraph_node. */
2072 cgraph_order_sort (cgraph_node
*node
)
2073 : kind (ORDER_FUNCTION
), order (node
->order
)
2078 /* Construct from a varpool_node. */
2079 cgraph_order_sort (varpool_node
*node
)
2080 : kind (node
->definition
? ORDER_VAR
: ORDER_VAR_UNDEF
), order (node
->order
)
2085 /* Construct from a asm_node. */
2086 cgraph_order_sort (asm_node
*node
)
2087 : kind (ORDER_ASM
), order (node
->order
)
2092 /* Assembly cgraph_order_sort based on its type. */
2095 enum cgraph_order_sort_kind kind
;
2105 /* Assembly cgraph_order_sort based on its type. */
2108 cgraph_order_sort::process ()
2112 case ORDER_FUNCTION
:
2117 u
.v
->assemble_decl ();
2119 case ORDER_VAR_UNDEF
:
2120 assemble_undefined_decl (u
.v
->decl
);
2123 assemble_asm (u
.a
->asm_str
);
2130 /* Compare cgraph_order_sort by order. */
2133 cgraph_order_cmp (const void *a_p
, const void *b_p
)
2135 const cgraph_order_sort
*nodea
= (const cgraph_order_sort
*)a_p
;
2136 const cgraph_order_sort
*nodeb
= (const cgraph_order_sort
*)b_p
;
2138 return nodea
->order
- nodeb
->order
;
2141 /* Output all functions, variables, and asm statements in the order
2142 according to their order fields, which is the order in which they
2143 appeared in the file. This implements -fno-toplevel-reorder. In
2144 this mode we may output functions and variables which don't really
2145 need to be output. */
2148 output_in_order (void)
2152 varpool_node
*vnode
;
2154 auto_vec
<cgraph_order_sort
> nodes
;
2155 cgraph_order_sort
*node
;
2157 FOR_EACH_DEFINED_FUNCTION (cnode
)
2158 if (cnode
->process
&& !cnode
->thunk
2159 && !cnode
->alias
&& cnode
->no_reorder
)
2160 nodes
.safe_push (cgraph_order_sort (cnode
));
2162 /* There is a similar loop in symbol_table::output_variables.
2163 Please keep them in sync. */
2164 FOR_EACH_VARIABLE (vnode
)
2165 if (vnode
->no_reorder
2166 && !DECL_HARD_REGISTER (vnode
->decl
)
2167 && !DECL_HAS_VALUE_EXPR_P (vnode
->decl
))
2168 nodes
.safe_push (cgraph_order_sort (vnode
));
2170 for (anode
= symtab
->first_asm_symbol (); anode
; anode
= anode
->next
)
2171 nodes
.safe_push (cgraph_order_sort (anode
));
2173 /* Sort nodes by order. */
2174 nodes
.qsort (cgraph_order_cmp
);
2176 /* In toplevel reorder mode we output all statics; mark them as needed. */
2177 FOR_EACH_VEC_ELT (nodes
, i
, node
)
2178 if (node
->kind
== ORDER_VAR
)
2179 node
->u
.v
->finalize_named_section_flags ();
2181 FOR_EACH_VEC_ELT (nodes
, i
, node
)
2184 symtab
->clear_asm_symbols ();
2190 gcc::pass_manager
*passes
= g
->get_passes ();
2193 current_function_decl
= NULL
;
2194 gimple_register_cfg_hooks ();
2195 bitmap_obstack_initialize (NULL
);
2197 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_START
, NULL
);
2201 execute_ipa_pass_list (passes
->all_small_ipa_passes
);
2206 /* This extra symtab_remove_unreachable_nodes pass tends to catch some
2207 devirtualization and other changes where removal iterate. */
2208 symtab
->remove_unreachable_nodes (symtab
->dump_file
);
2210 /* If pass_all_early_optimizations was not scheduled, the state of
2211 the cgraph will not be properly updated. Update it now. */
2212 if (symtab
->state
< IPA_SSA
)
2213 symtab
->state
= IPA_SSA
;
2217 /* Generate coverage variables and constructors. */
2220 /* Process new functions added. */
2222 current_function_decl
= NULL
;
2223 symtab
->process_new_functions ();
2225 execute_ipa_summary_passes
2226 ((ipa_opt_pass_d
*) passes
->all_regular_ipa_passes
);
2229 /* Some targets need to handle LTO assembler output specially. */
2230 if (flag_generate_lto
|| flag_generate_offload
)
2231 targetm
.asm_out
.lto_start ();
2234 || flag_incremental_link
== INCREMENTAL_LINK_LTO
)
2237 fprintf (stderr
, "Streaming LTO\n");
2238 if (g
->have_offload
)
2240 section_name_prefix
= OFFLOAD_SECTION_NAME_PREFIX
;
2241 lto_stream_offload_p
= true;
2242 ipa_write_summaries ();
2243 lto_stream_offload_p
= false;
2247 section_name_prefix
= LTO_SECTION_NAME_PREFIX
;
2248 lto_stream_offload_p
= false;
2249 ipa_write_summaries ();
2253 if (flag_generate_lto
|| flag_generate_offload
)
2254 targetm
.asm_out
.lto_end ();
2257 && ((in_lto_p
&& flag_incremental_link
!= INCREMENTAL_LINK_LTO
)
2258 || !flag_lto
|| flag_fat_lto_objects
))
2259 execute_ipa_pass_list (passes
->all_regular_ipa_passes
);
2260 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_END
, NULL
);
2262 bitmap_obstack_release (NULL
);
2266 /* Weakrefs may be associated to external decls and thus not output
2267 at expansion time. Emit all necessary aliases. */
2270 symbol_table::output_weakrefs (void)
2273 FOR_EACH_SYMBOL (node
)
2275 && !TREE_ASM_WRITTEN (node
->decl
)
2280 /* Weakrefs are special by not requiring target definition in current
2281 compilation unit. It is thus bit hard to work out what we want to
2283 When alias target is defined, we need to fetch it from symtab reference,
2284 otherwise it is pointed to by alias_target. */
2285 if (node
->alias_target
)
2286 target
= (DECL_P (node
->alias_target
)
2287 ? DECL_ASSEMBLER_NAME (node
->alias_target
)
2288 : node
->alias_target
);
2289 else if (node
->analyzed
)
2290 target
= DECL_ASSEMBLER_NAME (node
->get_alias_target ()->decl
);
2293 do_assemble_alias (node
->decl
, target
);
2297 /* Perform simple optimizations based on callgraph. */
2300 symbol_table::compile (void)
2305 symtab_node::checking_verify_symtab_nodes ();
2307 timevar_push (TV_CGRAPHOPT
);
2308 if (pre_ipa_mem_report
)
2309 dump_memory_report ("Memory consumption before IPA");
2311 fprintf (stderr
, "Performing interprocedural optimizations\n");
2314 /* If LTO is enabled, initialize the streamer hooks needed by GIMPLE. */
2315 if (flag_generate_lto
|| flag_generate_offload
)
2316 lto_streamer_hooks_init ();
2318 /* Don't run the IPA passes if there was any error or sorry messages. */
2321 timevar_start (TV_CGRAPH_IPA_PASSES
);
2323 timevar_stop (TV_CGRAPH_IPA_PASSES
);
2325 /* Do nothing else if any IPA pass found errors or if we are just streaming LTO. */
2327 || ((!in_lto_p
|| flag_incremental_link
== INCREMENTAL_LINK_LTO
)
2328 && flag_lto
&& !flag_fat_lto_objects
))
2330 timevar_pop (TV_CGRAPHOPT
);
2334 global_info_ready
= true;
2337 fprintf (dump_file
, "Optimized ");
2338 symtab
->dump (dump_file
);
2340 if (post_ipa_mem_report
)
2341 dump_memory_report ("Memory consumption after IPA");
2342 timevar_pop (TV_CGRAPHOPT
);
2344 /* Output everything. */
2345 switch_to_section (text_section
);
2346 (*debug_hooks
->assembly_start
) ();
2348 fprintf (stderr
, "Assembling functions:\n");
2349 symtab_node::checking_verify_symtab_nodes ();
2351 bitmap_obstack_initialize (NULL
);
2352 execute_ipa_pass_list (g
->get_passes ()->all_late_ipa_passes
);
2353 bitmap_obstack_release (NULL
);
2354 mark_functions_to_output ();
2356 /* When weakref support is missing, we automatically translate all
2357 references to NODE to references to its ultimate alias target.
2358 The renaming mechanism uses flag IDENTIFIER_TRANSPARENT_ALIAS and
2361 Set up this mapping before we output any assembler but once we are sure
2362 that all symbol renaming is done.
2364 FIXME: All this ugliness can go away if we just do renaming at gimple
2365 level by physically rewriting the IL. At the moment we can only redirect
2366 calls, so we need infrastructure for renaming references as well. */
2367 #ifndef ASM_OUTPUT_WEAKREF
2370 FOR_EACH_SYMBOL (node
)
2372 && lookup_attribute ("weakref", DECL_ATTRIBUTES (node
->decl
)))
2374 IDENTIFIER_TRANSPARENT_ALIAS
2375 (DECL_ASSEMBLER_NAME (node
->decl
)) = 1;
2376 TREE_CHAIN (DECL_ASSEMBLER_NAME (node
->decl
))
2377 = (node
->alias_target
? node
->alias_target
2378 : DECL_ASSEMBLER_NAME (node
->get_alias_target ()->decl
));
2384 /* Output first asm statements and anything ordered. The process
2385 flag is cleared for these nodes, so we skip them later. */
2388 timevar_start (TV_CGRAPH_FUNC_EXPANSION
);
2389 expand_all_functions ();
2390 timevar_stop (TV_CGRAPH_FUNC_EXPANSION
);
2392 output_variables ();
2394 process_new_functions ();
2400 fprintf (dump_file
, "\nFinal ");
2401 symtab
->dump (dump_file
);
2405 symtab_node::verify_symtab_nodes ();
2406 /* Double check that all inline clones are gone and that all
2407 function bodies have been released from memory. */
2411 bool error_found
= false;
2413 FOR_EACH_DEFINED_FUNCTION (node
)
2414 if (node
->inlined_to
2415 || gimple_has_body_p (node
->decl
))
2417 if (DECL_STRUCT_FUNCTION (node
->decl
)
2418 && (DECL_STRUCT_FUNCTION (node
->decl
)->curr_properties
2419 & PROP_assumptions_done
) != 0)
2425 internal_error ("nodes with unreleased memory found");
2429 /* Earlydebug dump file, flags, and number. */
2431 static int debuginfo_early_dump_nr
;
2432 static FILE *debuginfo_early_dump_file
;
2433 static dump_flags_t debuginfo_early_dump_flags
;
2435 /* Debug dump file, flags, and number. */
2437 static int debuginfo_dump_nr
;
2438 static FILE *debuginfo_dump_file
;
2439 static dump_flags_t debuginfo_dump_flags
;
2441 /* Register the debug and earlydebug dump files. */
2444 debuginfo_early_init (void)
2446 gcc::dump_manager
*dumps
= g
->get_dumps ();
2447 debuginfo_early_dump_nr
= dumps
->dump_register (".earlydebug", "earlydebug",
2448 "earlydebug", DK_tree
,
2451 debuginfo_dump_nr
= dumps
->dump_register (".debug", "debug",
2457 /* Initialize the debug and earlydebug dump files. */
2460 debuginfo_init (void)
2462 gcc::dump_manager
*dumps
= g
->get_dumps ();
2463 debuginfo_dump_file
= dump_begin (debuginfo_dump_nr
, NULL
);
2464 debuginfo_dump_flags
= dumps
->get_dump_file_info (debuginfo_dump_nr
)->pflags
;
2465 debuginfo_early_dump_file
= dump_begin (debuginfo_early_dump_nr
, NULL
);
2466 debuginfo_early_dump_flags
2467 = dumps
->get_dump_file_info (debuginfo_early_dump_nr
)->pflags
;
2470 /* Finalize the debug and earlydebug dump files. */
2473 debuginfo_fini (void)
2475 if (debuginfo_dump_file
)
2476 dump_end (debuginfo_dump_nr
, debuginfo_dump_file
);
2477 if (debuginfo_early_dump_file
)
2478 dump_end (debuginfo_early_dump_nr
, debuginfo_early_dump_file
);
2481 /* Set dump_file to the debug dump file. */
2484 debuginfo_start (void)
2486 set_dump_file (debuginfo_dump_file
);
2489 /* Undo setting dump_file to the debug dump file. */
2492 debuginfo_stop (void)
2494 set_dump_file (NULL
);
2497 /* Set dump_file to the earlydebug dump file. */
2500 debuginfo_early_start (void)
2502 set_dump_file (debuginfo_early_dump_file
);
2505 /* Undo setting dump_file to the earlydebug dump file. */
2508 debuginfo_early_stop (void)
2510 set_dump_file (NULL
);
2513 /* Analyze the whole compilation unit once it is parsed completely. */
2516 symbol_table::finalize_compilation_unit (void)
2518 timevar_push (TV_CGRAPH
);
2520 /* If we're here there's no current function anymore. Some frontends
2521 are lazy in clearing these. */
2522 current_function_decl
= NULL
;
2525 /* Do not skip analyzing the functions if there were errors, we
2526 miss diagnostics for following functions otherwise. */
2528 /* Emit size functions we didn't inline. */
2529 finalize_size_functions ();
2531 /* Mark alias targets necessary and emit diagnostics. */
2532 handle_alias_pairs ();
2536 fprintf (stderr
, "\nAnalyzing compilation unit\n");
2540 if (flag_dump_passes
)
2543 /* Gimplify and lower all functions, compute reachability and
2544 remove unreachable nodes. */
2545 analyze_functions (/*first_time=*/true);
2547 /* Mark alias targets necessary and emit diagnostics. */
2548 handle_alias_pairs ();
2550 /* Gimplify and lower thunks. */
2551 analyze_functions (/*first_time=*/false);
2553 /* All nested functions should be lowered now. */
2554 nested_function_info::release ();
2556 /* Offloading requires LTO infrastructure. */
2557 if (!in_lto_p
&& g
->have_offload
)
2558 flag_generate_offload
= 1;
2562 /* Give the frontends the chance to emit early debug based on
2563 what is still reachable in the TU. */
2564 (*lang_hooks
.finalize_early_debug
) ();
2566 /* Clean up anything that needs cleaning up after initial debug
2568 debuginfo_early_start ();
2569 (*debug_hooks
->early_finish
) (main_input_filename
);
2570 debuginfo_early_stop ();
2573 /* Finally drive the pass manager. */
2576 timevar_pop (TV_CGRAPH
);
2579 /* Reset all state within cgraphunit.cc so that we can rerun the compiler
2580 within the same process. For use by toplev::finalize. */
2583 cgraphunit_cc_finalize (void)
2585 gcc_assert (cgraph_new_nodes
.length () == 0);
2586 cgraph_new_nodes
.truncate (0);
2588 queued_nodes
= &symtab_terminator
;
2590 first_analyzed
= NULL
;
2591 first_analyzed_var
= NULL
;
2594 /* Creates a wrapper from cgraph_node to TARGET node. Thunk is used for this
2595 kind of wrapper method. */
2598 cgraph_node::create_wrapper (cgraph_node
*target
)
2600 /* Preserve DECL_RESULT so we get right by reference flag. */
2601 tree decl_result
= DECL_RESULT (decl
);
2603 /* Remove the function's body but keep arguments to be reused
2605 release_body (true);
2608 DECL_UNINLINABLE (decl
) = false;
2609 DECL_RESULT (decl
) = decl_result
;
2610 DECL_INITIAL (decl
) = NULL
;
2611 allocate_struct_function (decl
, false);
2614 /* Turn alias into thunk and expand it into GIMPLE representation. */
2616 semantic_interposition
= opt_for_fn (decl
, flag_semantic_interposition
);
2618 /* Create empty thunk, but be sure we did not keep former thunk around.
2619 In that case we would need to preserve the info. */
2620 gcc_checking_assert (!thunk_info::get (this));
2621 thunk_info::get_create (this);
2623 create_edge (target
, NULL
, count
);
2624 callees
->can_throw_external
= !TREE_NOTHROW (target
->decl
);
2626 tree arguments
= DECL_ARGUMENTS (decl
);
2630 TREE_ADDRESSABLE (arguments
) = false;
2631 arguments
= TREE_CHAIN (arguments
);
2634 expand_thunk (this, false, true);
2635 thunk_info::remove (this);
2637 /* Inline summary set-up. */
2639 inline_analyze_function (this);