1 /* Driver of optimization process
2 Copyright (C) 2003-2013 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 /* This module implements main driver of compilation process.
23 The main scope of this file is to act as an interface in between
24 tree based frontends and the backend.
26 The front-end is supposed to use following functionality:
28 - cgraph_finalize_function
30 This function is called once front-end has parsed whole body of function
31 and it is certain that the function body nor the declaration will change.
33 (There is one exception needed for implementing GCC extern inline
36 - varpool_finalize_decl
38 This function has same behavior as the above but is used for static
43 Insert new toplevel ASM statement
45 - finalize_compilation_unit
47 This function is called once (source level) compilation unit is finalized
48 and it will no longer change.
50 The symbol table is constructed starting from the trivially needed
51 symbols finalized by the frontend. Functions are lowered into
52 GIMPLE representation and callgraph/reference lists are constructed.
53 Those are used to discover other necessary functions and variables.
55 At the end the bodies of unreachable functions are removed.
57 The function can be called multiple times when multiple source level
58 compilation units are combined.
62 This passes control to the back-end. Optimizations are performed and
63 final assembler is generated. This is done in the following way. Note
64 that with link time optimization the process is split into three
65 stages (compile time, linktime analysis and parallel linktime as
70 1) Inter-procedural optimization.
73 This part is further split into:
75 a) early optimizations. These are local passes executed in
76 the topological order on the callgraph.
78 The purpose of early optimiations is to optimize away simple
79 things that may otherwise confuse IP analysis. Very simple
80 propagation across the callgraph is done i.e. to discover
81 functions without side effects and simple inlining is performed.
83 b) early small interprocedural passes.
85 Those are interprocedural passes executed only at compilation
86 time. These include, for example, transational memory lowering,
87 unreachable code removal and other simple transformations.
89 c) IP analysis stage. All interprocedural passes do their
92 Interprocedural passes differ from small interprocedural
93 passes by their ability to operate across whole program
94 at linktime. Their analysis stage is performed early to
95 both reduce linking times and linktime memory usage by
96 not having to represent whole program in memory.
98 d) LTO sreaming. When doing LTO, everything important gets
99 streamed into the object file.
101 Compile time and or linktime analysis stage (WPA):
103 At linktime units gets streamed back and symbol table is
104 merged. Function bodies are not streamed in and not
106 e) IP propagation stage. All IP passes execute their
107 IP propagation. This is done based on the earlier analysis
108 without having function bodies at hand.
109 f) Ltrans streaming. When doing WHOPR LTO, the program
110 is partitioned and streamed into multple object files.
112 Compile time and/or parallel linktime stage (ltrans)
114 Each of the object files is streamed back and compiled
115 separately. Now the function bodies becomes available
118 2) Virtual clone materialization
119 (cgraph_materialize_clone)
121 IP passes can produce copies of existing functoins (such
122 as versioned clones or inline clones) without actually
123 manipulating their bodies by creating virtual clones in
124 the callgraph. At this time the virtual clones are
125 turned into real functions
128 All IP passes transform function bodies based on earlier
129 decision of the IP propagation.
131 4) late small IP passes
133 Simple IP passes working within single program partition.
136 (expand_all_functions)
138 At this stage functions that needs to be output into
139 assembler are identified and compiled in topological order
140 6) Output of variables and aliases
141 Now it is known what variable references was not optimized
142 out and thus all variables are output to the file.
144 Note that with -fno-toplevel-reorder passes 5 and 6
145 are combined together in cgraph_output_in_order.
147 Finally there are functions to manipulate the callgraph from
149 - cgraph_add_new_function is used to add backend produced
150 functions introduced after the unit is finalized.
151 The functions are enqueue for later processing and inserted
152 into callgraph with cgraph_process_new_functions.
154 - cgraph_function_versioning
156 produces a copy of function into new one (a version)
157 and apply simple transformations
162 #include "coretypes.h"
167 #include "tree-flow.h"
168 #include "tree-inline.h"
169 #include "langhooks.h"
170 #include "pointer-set.h"
177 #include "diagnostic.h"
181 #include "function.h"
182 #include "ipa-prop.h"
184 #include "tree-iterator.h"
185 #include "tree-pass.h"
186 #include "tree-dump.h"
187 #include "gimple-pretty-print.h"
189 #include "coverage.h"
191 #include "ipa-inline.h"
192 #include "ipa-utils.h"
193 #include "lto-streamer.h"
196 #include "regset.h" /* FIXME: For reg_obstack. */
198 #include "pass_manager.h"
200 /* Queue of cgraph nodes scheduled to be added into cgraph. This is a
201 secondary queue used during optimization to accommodate passes that
202 may generate new functions that need to be optimized and expanded. */
203 cgraph_node_set cgraph_new_nodes
;
205 static void expand_all_functions (void);
206 static void mark_functions_to_output (void);
207 static void expand_function (struct cgraph_node
*);
208 static void analyze_function (struct cgraph_node
*);
209 static void handle_alias_pairs (void);
211 FILE *cgraph_dump_file
;
213 /* Linked list of cgraph asm nodes. */
214 struct asm_node
*asm_nodes
;
216 /* Last node in cgraph_asm_nodes. */
217 static GTY(()) struct asm_node
*asm_last_node
;
219 /* Used for vtable lookup in thunk adjusting. */
220 static GTY (()) tree vtable_entry_type
;
222 /* Determine if symbol DECL is needed. That is, visible to something
223 either outside this translation unit, something magic in the system
226 decide_is_symbol_needed (symtab_node node
)
228 tree decl
= node
->symbol
.decl
;
230 /* Double check that no one output the function into assembly file
232 gcc_checking_assert (!DECL_ASSEMBLER_NAME_SET_P (decl
)
233 || !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)));
235 if (!node
->symbol
.definition
)
238 /* Devirtualization may access these. */
239 if (DECL_VIRTUAL_P (decl
) && optimize
)
242 if (DECL_EXTERNAL (decl
))
245 /* If the user told us it is used, then it must be so. */
246 if (node
->symbol
.force_output
)
249 /* ABI forced symbols are needed when they are external. */
250 if (node
->symbol
.forced_by_abi
&& TREE_PUBLIC (decl
))
253 /* Keep constructors, destructors and virtual functions. */
254 if (TREE_CODE (decl
) == FUNCTION_DECL
255 && (DECL_STATIC_CONSTRUCTOR (decl
) || DECL_STATIC_DESTRUCTOR (decl
)))
258 /* Externally visible variables must be output. The exception is
259 COMDAT variables that must be output only when they are needed. */
260 if (TREE_PUBLIC (decl
) && !DECL_COMDAT (decl
))
266 /* Head of the queue of nodes to be processed while building callgraph */
268 static symtab_node first
= (symtab_node
)(void *)1;
270 /* Add NODE to queue starting at FIRST.
271 The queue is linked via AUX pointers and terminated by pointer to 1. */
274 enqueue_node (symtab_node node
)
276 if (node
->symbol
.aux
)
278 gcc_checking_assert (first
);
279 node
->symbol
.aux
= first
;
283 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
284 functions into callgraph in a way so they look like ordinary reachable
285 functions inserted into callgraph already at construction time. */
288 cgraph_process_new_functions (void)
292 struct cgraph_node
*node
;
293 cgraph_node_set_iterator csi
;
295 if (!cgraph_new_nodes
)
297 handle_alias_pairs ();
298 /* Note that this queue may grow as its being processed, as the new
299 functions may generate new ones. */
300 for (csi
= csi_start (cgraph_new_nodes
); !csi_end_p (csi
); csi_next (&csi
))
302 node
= csi_node (csi
);
303 fndecl
= node
->symbol
.decl
;
304 switch (cgraph_state
)
306 case CGRAPH_STATE_CONSTRUCTION
:
307 /* At construction time we just need to finalize function and move
308 it into reachable functions list. */
310 cgraph_finalize_function (fndecl
, false);
312 cgraph_call_function_insertion_hooks (node
);
313 enqueue_node ((symtab_node
) node
);
316 case CGRAPH_STATE_IPA
:
317 case CGRAPH_STATE_IPA_SSA
:
318 /* When IPA optimization already started, do all essential
319 transformations that has been already performed on the whole
320 cgraph but not on this function. */
322 gimple_register_cfg_hooks ();
323 if (!node
->symbol
.analyzed
)
324 analyze_function (node
);
325 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
326 if (cgraph_state
== CGRAPH_STATE_IPA_SSA
327 && !gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
328 execute_pass_list (pass_early_local_passes
.pass
.sub
);
329 else if (inline_summary_vec
!= NULL
)
330 compute_inline_parameters (node
, true);
331 free_dominance_info (CDI_POST_DOMINATORS
);
332 free_dominance_info (CDI_DOMINATORS
);
334 cgraph_call_function_insertion_hooks (node
);
337 case CGRAPH_STATE_EXPANSION
:
338 /* Functions created during expansion shall be compiled
341 cgraph_call_function_insertion_hooks (node
);
342 expand_function (node
);
350 free_cgraph_node_set (cgraph_new_nodes
);
351 cgraph_new_nodes
= NULL
;
355 /* As an GCC extension we allow redefinition of the function. The
356 semantics when both copies of bodies differ is not well defined.
357 We replace the old body with new body so in unit at a time mode
358 we always use new body, while in normal mode we may end up with
359 old body inlined into some functions and new body expanded and
362 ??? It may make more sense to use one body for inlining and other
363 body for expanding the function but this is difficult to do. */
366 cgraph_reset_node (struct cgraph_node
*node
)
368 /* If node->process is set, then we have already begun whole-unit analysis.
369 This is *not* testing for whether we've already emitted the function.
370 That case can be sort-of legitimately seen with real function redefinition
371 errors. I would argue that the front end should never present us with
372 such a case, but don't enforce that for now. */
373 gcc_assert (!node
->process
);
375 /* Reset our data structures so we can analyze the function again. */
376 memset (&node
->local
, 0, sizeof (node
->local
));
377 memset (&node
->global
, 0, sizeof (node
->global
));
378 memset (&node
->rtl
, 0, sizeof (node
->rtl
));
379 node
->symbol
.analyzed
= false;
380 node
->symbol
.definition
= false;
381 node
->symbol
.alias
= false;
382 node
->symbol
.weakref
= false;
383 node
->symbol
.cpp_implicit_alias
= false;
385 cgraph_node_remove_callees (node
);
386 ipa_remove_all_references (&node
->symbol
.ref_list
);
389 /* Return true when there are references to NODE. */
392 referred_to_p (symtab_node node
)
396 /* See if there are any references at all. */
397 if (ipa_ref_list_referring_iterate (&node
->symbol
.ref_list
, 0, ref
))
399 /* For functions check also calls. */
400 cgraph_node
*cn
= dyn_cast
<cgraph_node
> (node
);
401 if (cn
&& cn
->callers
)
406 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
407 logic in effect. If NESTED is true, then our caller cannot stand to have
408 the garbage collector run at the moment. We would need to either create
409 a new GC context, or just not compile right now. */
412 cgraph_finalize_function (tree decl
, bool nested
)
414 struct cgraph_node
*node
= cgraph_get_create_node (decl
);
416 if (node
->symbol
.definition
)
418 cgraph_reset_node (node
);
419 node
->local
.redefined_extern_inline
= true;
422 notice_global_symbol (decl
);
423 node
->symbol
.definition
= true;
424 node
->lowered
= DECL_STRUCT_FUNCTION (decl
)->cfg
!= NULL
;
426 /* With -fkeep-inline-functions we are keeping all inline functions except
427 for extern inline ones. */
428 if (flag_keep_inline_functions
429 && DECL_DECLARED_INLINE_P (decl
)
430 && !DECL_EXTERNAL (decl
)
431 && !DECL_DISREGARD_INLINE_LIMITS (decl
))
432 node
->symbol
.force_output
= 1;
434 /* When not optimizing, also output the static functions. (see
435 PR24561), but don't do so for always_inline functions, functions
436 declared inline and nested functions. These were optimized out
437 in the original implementation and it is unclear whether we want
438 to change the behavior here. */
440 && !node
->symbol
.cpp_implicit_alias
441 && !DECL_DISREGARD_INLINE_LIMITS (decl
)
442 && !DECL_DECLARED_INLINE_P (decl
)
443 && !(DECL_CONTEXT (decl
)
444 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
))
445 && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
))
446 node
->symbol
.force_output
= 1;
448 /* If we've not yet emitted decl, tell the debug info about it. */
449 if (!TREE_ASM_WRITTEN (decl
))
450 (*debug_hooks
->deferred_inline_function
) (decl
);
452 /* Possibly warn about unused parameters. */
453 if (warn_unused_parameter
)
454 do_warn_unused_parameter (decl
);
459 if (cgraph_state
== CGRAPH_STATE_CONSTRUCTION
460 && (decide_is_symbol_needed ((symtab_node
) node
)
461 || referred_to_p ((symtab_node
)node
)))
462 enqueue_node ((symtab_node
)node
);
465 /* Add the function FNDECL to the call graph.
466 Unlike cgraph_finalize_function, this function is intended to be used
467 by middle end and allows insertion of new function at arbitrary point
468 of compilation. The function can be either in high, low or SSA form
471 The function is assumed to be reachable and have address taken (so no
472 API breaking optimizations are performed on it).
474 Main work done by this function is to enqueue the function for later
475 processing to avoid need the passes to be re-entrant. */
478 cgraph_add_new_function (tree fndecl
, bool lowered
)
480 gcc::pass_manager
*passes
= g
->get_passes ();
481 struct cgraph_node
*node
;
482 switch (cgraph_state
)
484 case CGRAPH_STATE_PARSING
:
485 cgraph_finalize_function (fndecl
, false);
487 case CGRAPH_STATE_CONSTRUCTION
:
488 /* Just enqueue function to be processed at nearest occurrence. */
489 node
= cgraph_create_node (fndecl
);
491 node
->lowered
= true;
492 if (!cgraph_new_nodes
)
493 cgraph_new_nodes
= cgraph_node_set_new ();
494 cgraph_node_set_add (cgraph_new_nodes
, node
);
497 case CGRAPH_STATE_IPA
:
498 case CGRAPH_STATE_IPA_SSA
:
499 case CGRAPH_STATE_EXPANSION
:
500 /* Bring the function into finalized state and enqueue for later
501 analyzing and compilation. */
502 node
= cgraph_get_create_node (fndecl
);
503 node
->local
.local
= false;
504 node
->symbol
.definition
= true;
505 node
->symbol
.force_output
= true;
506 if (!lowered
&& cgraph_state
== CGRAPH_STATE_EXPANSION
)
508 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
509 gimple_register_cfg_hooks ();
510 bitmap_obstack_initialize (NULL
);
511 execute_pass_list (passes
->all_lowering_passes
);
512 execute_pass_list (pass_early_local_passes
.pass
.sub
);
513 bitmap_obstack_release (NULL
);
519 node
->lowered
= true;
520 if (!cgraph_new_nodes
)
521 cgraph_new_nodes
= cgraph_node_set_new ();
522 cgraph_node_set_add (cgraph_new_nodes
, node
);
525 case CGRAPH_STATE_FINISHED
:
526 /* At the very end of compilation we have to do all the work up
528 node
= cgraph_create_node (fndecl
);
530 node
->lowered
= true;
531 node
->symbol
.definition
= true;
532 analyze_function (node
);
533 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
534 gimple_register_cfg_hooks ();
535 bitmap_obstack_initialize (NULL
);
536 if (!gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
537 execute_pass_list (pass_early_local_passes
.pass
.sub
);
538 bitmap_obstack_release (NULL
);
540 expand_function (node
);
547 /* Set a personality if required and we already passed EH lowering. */
549 && (function_needs_eh_personality (DECL_STRUCT_FUNCTION (fndecl
))
550 == eh_personality_lang
))
551 DECL_FUNCTION_PERSONALITY (fndecl
) = lang_hooks
.eh_personality ();
554 /* Add a top-level asm statement to the list. */
557 add_asm_node (tree asm_str
)
559 struct asm_node
*node
;
561 node
= ggc_alloc_cleared_asm_node ();
562 node
->asm_str
= asm_str
;
563 node
->order
= symtab_order
++;
565 if (asm_nodes
== NULL
)
568 asm_last_node
->next
= node
;
569 asm_last_node
= node
;
573 /* Output all asm statements we have stored up to be output. */
576 output_asm_statements (void)
578 struct asm_node
*can
;
583 for (can
= asm_nodes
; can
; can
= can
->next
)
584 assemble_asm (can
->asm_str
);
588 /* Analyze the function scheduled to be output. */
590 analyze_function (struct cgraph_node
*node
)
592 tree decl
= node
->symbol
.decl
;
593 location_t saved_loc
= input_location
;
594 input_location
= DECL_SOURCE_LOCATION (decl
);
596 if (node
->symbol
.alias
)
598 ((symtab_node
) node
, (symtab_node
) cgraph_get_node (node
->symbol
.alias_target
));
599 else if (node
->thunk
.thunk_p
)
601 cgraph_create_edge (node
, cgraph_get_node (node
->thunk
.alias
),
602 NULL
, 0, CGRAPH_FREQ_BASE
);
603 node
->thunk
.alias
= NULL
;
605 else if (node
->dispatcher_function
)
607 /* Generate the dispatcher body of multi-versioned functions. */
608 struct cgraph_function_version_info
*dispatcher_version_info
609 = get_cgraph_node_version (node
);
610 if (dispatcher_version_info
!= NULL
611 && (dispatcher_version_info
->dispatcher_resolver
614 tree resolver
= NULL_TREE
;
615 gcc_assert (targetm
.generate_version_dispatcher_body
);
616 resolver
= targetm
.generate_version_dispatcher_body (node
);
617 gcc_assert (resolver
!= NULL_TREE
);
622 push_cfun (DECL_STRUCT_FUNCTION (decl
));
624 assign_assembler_name_if_neeeded (node
->symbol
.decl
);
626 /* Make sure to gimplify bodies only once. During analyzing a
627 function we lower it, which will require gimplified nested
628 functions, so we can end up here with an already gimplified
630 if (!gimple_has_body_p (decl
))
631 gimplify_function_tree (decl
);
632 dump_function (TDI_generic
, decl
);
634 /* Lower the function. */
638 lower_nested_functions (node
->symbol
.decl
);
639 gcc_assert (!node
->nested
);
641 gimple_register_cfg_hooks ();
642 bitmap_obstack_initialize (NULL
);
643 execute_pass_list (g
->get_passes ()->all_lowering_passes
);
644 free_dominance_info (CDI_POST_DOMINATORS
);
645 free_dominance_info (CDI_DOMINATORS
);
647 bitmap_obstack_release (NULL
);
648 node
->lowered
= true;
653 node
->symbol
.analyzed
= true;
655 input_location
= saved_loc
;
658 /* C++ frontend produce same body aliases all over the place, even before PCH
659 gets streamed out. It relies on us linking the aliases with their function
660 in order to do the fixups, but ipa-ref is not PCH safe. Consequentely we
661 first produce aliases without links, but once C++ FE is sure he won't sream
662 PCH we build the links via this function. */
665 cgraph_process_same_body_aliases (void)
668 FOR_EACH_SYMBOL (node
)
669 if (node
->symbol
.cpp_implicit_alias
&& !node
->symbol
.analyzed
)
672 TREE_CODE (node
->symbol
.alias_target
) == VAR_DECL
673 ? (symtab_node
)varpool_node_for_decl (node
->symbol
.alias_target
)
674 : (symtab_node
)cgraph_get_create_node (node
->symbol
.alias_target
));
675 cpp_implicit_aliases_done
= true;
678 /* Process attributes common for vars and functions. */
681 process_common_attributes (tree decl
)
683 tree weakref
= lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
));
685 if (weakref
&& !lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)))
687 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wattributes
,
688 "%<weakref%> attribute should be accompanied with"
689 " an %<alias%> attribute");
690 DECL_WEAK (decl
) = 0;
691 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
692 DECL_ATTRIBUTES (decl
));
696 /* Look for externally_visible and used attributes and mark cgraph nodes
699 We cannot mark the nodes at the point the attributes are processed (in
700 handle_*_attribute) because the copy of the declarations available at that
701 point may not be canonical. For example, in:
704 void f() __attribute__((used));
706 the declaration we see in handle_used_attribute will be the second
707 declaration -- but the front end will subsequently merge that declaration
708 with the original declaration and discard the second declaration.
710 Furthermore, we can't mark these nodes in cgraph_finalize_function because:
713 void f() __attribute__((externally_visible));
717 So, we walk the nodes at the end of the translation unit, applying the
718 attributes at that point. */
721 process_function_and_variable_attributes (struct cgraph_node
*first
,
722 struct varpool_node
*first_var
)
724 struct cgraph_node
*node
;
725 struct varpool_node
*vnode
;
727 for (node
= cgraph_first_function (); node
!= first
;
728 node
= cgraph_next_function (node
))
730 tree decl
= node
->symbol
.decl
;
731 if (DECL_PRESERVE_P (decl
))
732 cgraph_mark_force_output_node (node
);
733 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
735 if (! TREE_PUBLIC (node
->symbol
.decl
))
736 warning_at (DECL_SOURCE_LOCATION (node
->symbol
.decl
), OPT_Wattributes
,
737 "%<externally_visible%>"
738 " attribute have effect only on public objects");
740 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
741 && (node
->symbol
.definition
&& !node
->symbol
.alias
))
743 warning_at (DECL_SOURCE_LOCATION (node
->symbol
.decl
), OPT_Wattributes
,
744 "%<weakref%> attribute ignored"
745 " because function is defined");
746 DECL_WEAK (decl
) = 0;
747 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
748 DECL_ATTRIBUTES (decl
));
751 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (decl
))
752 && !DECL_DECLARED_INLINE_P (decl
)
753 /* redefining extern inline function makes it DECL_UNINLINABLE. */
754 && !DECL_UNINLINABLE (decl
))
755 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wattributes
,
756 "always_inline function might not be inlinable");
758 process_common_attributes (decl
);
760 for (vnode
= varpool_first_variable (); vnode
!= first_var
;
761 vnode
= varpool_next_variable (vnode
))
763 tree decl
= vnode
->symbol
.decl
;
764 if (DECL_EXTERNAL (decl
)
765 && DECL_INITIAL (decl
))
766 varpool_finalize_decl (decl
);
767 if (DECL_PRESERVE_P (decl
))
768 vnode
->symbol
.force_output
= true;
769 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
771 if (! TREE_PUBLIC (vnode
->symbol
.decl
))
772 warning_at (DECL_SOURCE_LOCATION (vnode
->symbol
.decl
), OPT_Wattributes
,
773 "%<externally_visible%>"
774 " attribute have effect only on public objects");
776 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
777 && vnode
->symbol
.definition
778 && DECL_INITIAL (decl
))
780 warning_at (DECL_SOURCE_LOCATION (vnode
->symbol
.decl
), OPT_Wattributes
,
781 "%<weakref%> attribute ignored"
782 " because variable is initialized");
783 DECL_WEAK (decl
) = 0;
784 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
785 DECL_ATTRIBUTES (decl
));
787 process_common_attributes (decl
);
791 /* Mark DECL as finalized. By finalizing the declaration, frontend instruct the
792 middle end to output the variable to asm file, if needed or externally
796 varpool_finalize_decl (tree decl
)
798 struct varpool_node
*node
= varpool_node_for_decl (decl
);
800 gcc_assert (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
));
802 if (node
->symbol
.definition
)
804 notice_global_symbol (decl
);
805 node
->symbol
.definition
= true;
806 if (TREE_THIS_VOLATILE (decl
) || DECL_PRESERVE_P (decl
)
807 /* Traditionally we do not eliminate static variables when not
808 optimizing and when not doing toplevel reoder. */
809 || (!flag_toplevel_reorder
&& !DECL_COMDAT (node
->symbol
.decl
)
810 && !DECL_ARTIFICIAL (node
->symbol
.decl
)))
811 node
->symbol
.force_output
= true;
813 if (cgraph_state
== CGRAPH_STATE_CONSTRUCTION
814 && (decide_is_symbol_needed ((symtab_node
) node
)
815 || referred_to_p ((symtab_node
)node
)))
816 enqueue_node ((symtab_node
)node
);
817 if (cgraph_state
>= CGRAPH_STATE_IPA_SSA
)
818 varpool_analyze_node (node
);
819 /* Some frontends produce various interface variables after compilation
821 if (cgraph_state
== CGRAPH_STATE_FINISHED
)
822 varpool_assemble_decl (node
);
826 /* Discover all functions and variables that are trivially needed, analyze
827 them as well as all functions and variables referred by them */
830 analyze_functions (void)
832 /* Keep track of already processed nodes when called multiple times for
833 intermodule optimization. */
834 static struct cgraph_node
*first_analyzed
;
835 struct cgraph_node
*first_handled
= first_analyzed
;
836 static struct varpool_node
*first_analyzed_var
;
837 struct varpool_node
*first_handled_var
= first_analyzed_var
;
839 symtab_node node
, next
;
844 bitmap_obstack_initialize (NULL
);
845 cgraph_state
= CGRAPH_STATE_CONSTRUCTION
;
847 /* Ugly, but the fixup can not happen at a time same body alias is created;
848 C++ FE is confused about the COMDAT groups being right. */
849 if (cpp_implicit_aliases_done
)
850 FOR_EACH_SYMBOL (node
)
851 if (node
->symbol
.cpp_implicit_alias
)
852 fixup_same_cpp_alias_visibility (node
, symtab_alias_target (node
));
854 /* Analysis adds static variables that in turn adds references to new functions.
855 So we need to iterate the process until it stabilize. */
859 process_function_and_variable_attributes (first_analyzed
,
862 /* First identify the trivially needed symbols. */
863 for (node
= symtab_nodes
;
864 node
!= (symtab_node
)first_analyzed
865 && node
!= (symtab_node
)first_analyzed_var
; node
= node
->symbol
.next
)
867 if (decide_is_symbol_needed (node
))
870 if (!changed
&& cgraph_dump_file
)
871 fprintf (cgraph_dump_file
, "Trivially needed symbols:");
873 if (cgraph_dump_file
)
874 fprintf (cgraph_dump_file
, " %s", symtab_node_asm_name (node
));
876 if (node
== (symtab_node
)first_analyzed
877 || node
== (symtab_node
)first_analyzed_var
)
880 cgraph_process_new_functions ();
881 first_analyzed_var
= varpool_first_variable ();
882 first_analyzed
= cgraph_first_function ();
884 if (changed
&& dump_file
)
885 fprintf (cgraph_dump_file
, "\n");
887 /* Lower representation, build callgraph edges and references for all trivially
888 needed symbols and all symbols referred by them. */
889 while (first
!= (symtab_node
)(void *)1)
893 first
= (symtab_node
)first
->symbol
.aux
;
894 cgraph_node
*cnode
= dyn_cast
<cgraph_node
> (node
);
895 if (cnode
&& cnode
->symbol
.definition
)
897 struct cgraph_edge
*edge
;
898 tree decl
= cnode
->symbol
.decl
;
900 /* ??? It is possible to create extern inline function
901 and later using weak alias attribute to kill its body.
902 See gcc.c-torture/compile/20011119-1.c */
903 if (!DECL_STRUCT_FUNCTION (decl
)
904 && !cnode
->symbol
.alias
905 && !cnode
->thunk
.thunk_p
906 && !cnode
->dispatcher_function
)
908 cgraph_reset_node (cnode
);
909 cnode
->local
.redefined_extern_inline
= true;
913 if (!cnode
->symbol
.analyzed
)
914 analyze_function (cnode
);
916 for (edge
= cnode
->callees
; edge
; edge
= edge
->next_callee
)
917 if (edge
->callee
->symbol
.definition
)
918 enqueue_node ((symtab_node
)edge
->callee
);
920 /* If decl is a clone of an abstract function,
921 mark that abstract function so that we don't release its body.
922 The DECL_INITIAL() of that abstract function declaration
923 will be later needed to output debug info. */
924 if (DECL_ABSTRACT_ORIGIN (decl
))
926 struct cgraph_node
*origin_node
927 = cgraph_get_node (DECL_ABSTRACT_ORIGIN (decl
));
928 origin_node
->used_as_abstract_origin
= true;
933 varpool_node
*vnode
= dyn_cast
<varpool_node
> (node
);
934 if (vnode
&& vnode
->symbol
.definition
&& !vnode
->symbol
.analyzed
)
935 varpool_analyze_node (vnode
);
938 if (node
->symbol
.same_comdat_group
)
941 for (next
= node
->symbol
.same_comdat_group
;
943 next
= next
->symbol
.same_comdat_group
)
946 for (i
= 0; ipa_ref_list_reference_iterate (&node
->symbol
.ref_list
, i
, ref
); i
++)
947 if (ref
->referred
->symbol
.definition
)
948 enqueue_node (ref
->referred
);
949 cgraph_process_new_functions ();
953 /* Collect entry points to the unit. */
954 if (cgraph_dump_file
)
956 fprintf (cgraph_dump_file
, "\n\nInitial ");
957 dump_symtab (cgraph_dump_file
);
960 if (cgraph_dump_file
)
961 fprintf (cgraph_dump_file
, "\nRemoving unused symbols:");
963 for (node
= symtab_nodes
;
964 node
!= (symtab_node
)first_handled
965 && node
!= (symtab_node
)first_handled_var
; node
= next
)
967 next
= node
->symbol
.next
;
968 if (!node
->symbol
.aux
&& !referred_to_p (node
))
970 if (cgraph_dump_file
)
971 fprintf (cgraph_dump_file
, " %s", symtab_node_name (node
));
972 symtab_remove_node (node
);
975 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
> (node
))
977 tree decl
= node
->symbol
.decl
;
979 if (cnode
->symbol
.definition
&& !gimple_has_body_p (decl
)
980 && !cnode
->symbol
.alias
981 && !cnode
->thunk
.thunk_p
)
982 cgraph_reset_node (cnode
);
984 gcc_assert (!cnode
->symbol
.definition
|| cnode
->thunk
.thunk_p
985 || cnode
->symbol
.alias
986 || gimple_has_body_p (decl
));
987 gcc_assert (cnode
->symbol
.analyzed
== cnode
->symbol
.definition
);
989 node
->symbol
.aux
= NULL
;
991 first_analyzed
= cgraph_first_function ();
992 first_analyzed_var
= varpool_first_variable ();
993 if (cgraph_dump_file
)
995 fprintf (cgraph_dump_file
, "\n\nReclaimed ");
996 dump_symtab (cgraph_dump_file
);
998 bitmap_obstack_release (NULL
);
1002 /* Translate the ugly representation of aliases as alias pairs into nice
1003 representation in callgraph. We don't handle all cases yet,
1007 handle_alias_pairs (void)
1012 for (i
= 0; alias_pairs
&& alias_pairs
->iterate (i
, &p
);)
1014 symtab_node target_node
= symtab_node_for_asm (p
->target
);
1016 /* Weakrefs with target not defined in current unit are easy to handle; they
1017 behave just as external variables except we need to note the alias flag
1018 to later output the weakref pseudo op into asm file. */
1019 if (!target_node
&& lookup_attribute ("weakref", DECL_ATTRIBUTES (p
->decl
)) != NULL
)
1021 symtab_node node
= symtab_get_node (p
->decl
);
1024 node
->symbol
.alias_target
= p
->target
;
1025 node
->symbol
.weakref
= true;
1026 node
->symbol
.alias
= true;
1028 alias_pairs
->unordered_remove (i
);
1031 else if (!target_node
)
1033 error ("%q+D aliased to undefined symbol %qE", p
->decl
, p
->target
);
1034 alias_pairs
->unordered_remove (i
);
1038 if (DECL_EXTERNAL (target_node
->symbol
.decl
)
1039 /* We use local aliases for C++ thunks to force the tailcall
1040 to bind locally. This is a hack - to keep it working do
1041 the following (which is not strictly correct). */
1042 && (! TREE_CODE (target_node
->symbol
.decl
) == FUNCTION_DECL
1043 || ! DECL_VIRTUAL_P (target_node
->symbol
.decl
))
1044 && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (p
->decl
)))
1046 error ("%q+D aliased to external symbol %qE",
1047 p
->decl
, p
->target
);
1050 if (TREE_CODE (p
->decl
) == FUNCTION_DECL
1051 && target_node
&& is_a
<cgraph_node
> (target_node
))
1053 struct cgraph_node
*src_node
= cgraph_get_node (p
->decl
);
1054 if (src_node
&& src_node
->symbol
.definition
)
1055 cgraph_reset_node (src_node
);
1056 cgraph_create_function_alias (p
->decl
, target_node
->symbol
.decl
);
1057 alias_pairs
->unordered_remove (i
);
1059 else if (TREE_CODE (p
->decl
) == VAR_DECL
1060 && target_node
&& is_a
<varpool_node
> (target_node
))
1062 varpool_create_variable_alias (p
->decl
, target_node
->symbol
.decl
);
1063 alias_pairs
->unordered_remove (i
);
1067 error ("%q+D alias in between function and variable is not supported",
1069 warning (0, "%q+D aliased declaration",
1070 target_node
->symbol
.decl
);
1071 alias_pairs
->unordered_remove (i
);
1074 vec_free (alias_pairs
);
1078 /* Figure out what functions we want to assemble. */
1081 mark_functions_to_output (void)
1083 struct cgraph_node
*node
;
1084 #ifdef ENABLE_CHECKING
1085 bool check_same_comdat_groups
= false;
1087 FOR_EACH_FUNCTION (node
)
1088 gcc_assert (!node
->process
);
1091 FOR_EACH_FUNCTION (node
)
1093 tree decl
= node
->symbol
.decl
;
1095 gcc_assert (!node
->process
|| node
->symbol
.same_comdat_group
);
1099 /* We need to output all local functions that are used and not
1100 always inlined, as well as those that are reachable from
1101 outside the current compilation unit. */
1102 if (node
->symbol
.analyzed
1103 && !node
->thunk
.thunk_p
1104 && !node
->symbol
.alias
1105 && !node
->global
.inlined_to
1106 && !TREE_ASM_WRITTEN (decl
)
1107 && !DECL_EXTERNAL (decl
))
1110 if (node
->symbol
.same_comdat_group
)
1112 struct cgraph_node
*next
;
1113 for (next
= cgraph (node
->symbol
.same_comdat_group
);
1115 next
= cgraph (next
->symbol
.same_comdat_group
))
1116 if (!next
->thunk
.thunk_p
&& !next
->symbol
.alias
)
1120 else if (node
->symbol
.same_comdat_group
)
1122 #ifdef ENABLE_CHECKING
1123 check_same_comdat_groups
= true;
1128 /* We should've reclaimed all functions that are not needed. */
1129 #ifdef ENABLE_CHECKING
1130 if (!node
->global
.inlined_to
1131 && gimple_has_body_p (decl
)
1132 /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
1133 are inside partition, we can end up not removing the body since we no longer
1134 have analyzed node pointing to it. */
1135 && !node
->symbol
.in_other_partition
1136 && !node
->symbol
.alias
1138 && !DECL_EXTERNAL (decl
))
1140 dump_cgraph_node (stderr
, node
);
1141 internal_error ("failed to reclaim unneeded function");
1144 gcc_assert (node
->global
.inlined_to
1145 || !gimple_has_body_p (decl
)
1146 || node
->symbol
.in_other_partition
1148 || DECL_ARTIFICIAL (decl
)
1149 || DECL_EXTERNAL (decl
));
1154 #ifdef ENABLE_CHECKING
1155 if (check_same_comdat_groups
)
1156 FOR_EACH_FUNCTION (node
)
1157 if (node
->symbol
.same_comdat_group
&& !node
->process
)
1159 tree decl
= node
->symbol
.decl
;
1160 if (!node
->global
.inlined_to
1161 && gimple_has_body_p (decl
)
1162 /* FIXME: in an ltrans unit when the offline copy is outside a
1163 partition but inline copies are inside a partition, we can
1164 end up not removing the body since we no longer have an
1165 analyzed node pointing to it. */
1166 && !node
->symbol
.in_other_partition
1168 && !DECL_EXTERNAL (decl
))
1170 dump_cgraph_node (stderr
, node
);
1171 internal_error ("failed to reclaim unneeded function in same "
1178 /* DECL is FUNCTION_DECL. Initialize datastructures so DECL is a function
1179 in lowered gimple form. IN_SSA is true if the gimple is in SSA.
1181 Set current_function_decl and cfun to newly constructed empty function body.
1182 return basic block in the function body. */
1185 init_lowered_empty_function (tree decl
, bool in_ssa
)
1189 current_function_decl
= decl
;
1190 allocate_struct_function (decl
, false);
1191 gimple_register_cfg_hooks ();
1192 init_empty_tree_cfg ();
1196 init_tree_ssa (cfun
);
1197 init_ssa_operands (cfun
);
1198 cfun
->gimple_df
->in_ssa_p
= true;
1199 cfun
->curr_properties
|= PROP_ssa
;
1202 DECL_INITIAL (decl
) = make_node (BLOCK
);
1204 DECL_SAVED_TREE (decl
) = error_mark_node
;
1205 cfun
->curr_properties
|= (PROP_gimple_lcf
| PROP_gimple_leh
| PROP_gimple_any
1206 | PROP_cfg
| PROP_loops
);
1208 set_loops_for_fn (cfun
, ggc_alloc_cleared_loops ());
1209 init_loops_structure (cfun
, loops_for_fn (cfun
), 1);
1210 loops_for_fn (cfun
)->state
|= LOOPS_MAY_HAVE_MULTIPLE_LATCHES
;
1212 /* Create BB for body of the function and connect it properly. */
1213 bb
= create_basic_block (NULL
, (void *) 0, ENTRY_BLOCK_PTR
);
1214 make_edge (ENTRY_BLOCK_PTR
, bb
, EDGE_FALLTHRU
);
1215 make_edge (bb
, EXIT_BLOCK_PTR
, 0);
1216 add_bb_to_loop (bb
, ENTRY_BLOCK_PTR
->loop_father
);
1221 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
1222 offset indicated by VIRTUAL_OFFSET, if that is
1223 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
1224 zero for a result adjusting thunk. */
1227 thunk_adjust (gimple_stmt_iterator
* bsi
,
1228 tree ptr
, bool this_adjusting
,
1229 HOST_WIDE_INT fixed_offset
, tree virtual_offset
)
1235 && fixed_offset
!= 0)
1237 stmt
= gimple_build_assign
1238 (ptr
, fold_build_pointer_plus_hwi_loc (input_location
,
1241 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1244 /* If there's a virtual offset, look up that value in the vtable and
1245 adjust the pointer again. */
1252 if (!vtable_entry_type
)
1254 tree vfunc_type
= make_node (FUNCTION_TYPE
);
1255 TREE_TYPE (vfunc_type
) = integer_type_node
;
1256 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
1257 layout_type (vfunc_type
);
1259 vtable_entry_type
= build_pointer_type (vfunc_type
);
1263 create_tmp_reg (build_pointer_type
1264 (build_pointer_type (vtable_entry_type
)), "vptr");
1266 /* The vptr is always at offset zero in the object. */
1267 stmt
= gimple_build_assign (vtabletmp
,
1268 build1 (NOP_EXPR
, TREE_TYPE (vtabletmp
),
1270 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1272 /* Form the vtable address. */
1273 vtabletmp2
= create_tmp_reg (TREE_TYPE (TREE_TYPE (vtabletmp
)),
1275 stmt
= gimple_build_assign (vtabletmp2
,
1276 build_simple_mem_ref (vtabletmp
));
1277 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1279 /* Find the entry with the vcall offset. */
1280 stmt
= gimple_build_assign (vtabletmp2
,
1281 fold_build_pointer_plus_loc (input_location
,
1284 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1286 /* Get the offset itself. */
1287 vtabletmp3
= create_tmp_reg (TREE_TYPE (TREE_TYPE (vtabletmp2
)),
1289 stmt
= gimple_build_assign (vtabletmp3
,
1290 build_simple_mem_ref (vtabletmp2
));
1291 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1293 /* Adjust the `this' pointer. */
1294 ptr
= fold_build_pointer_plus_loc (input_location
, ptr
, vtabletmp3
);
1295 ptr
= force_gimple_operand_gsi (bsi
, ptr
, true, NULL_TREE
, false,
1296 GSI_CONTINUE_LINKING
);
1300 && fixed_offset
!= 0)
1301 /* Adjust the pointer by the constant. */
1305 if (TREE_CODE (ptr
) == VAR_DECL
)
1309 ptrtmp
= create_tmp_reg (TREE_TYPE (ptr
), "ptr");
1310 stmt
= gimple_build_assign (ptrtmp
, ptr
);
1311 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1313 ptr
= fold_build_pointer_plus_hwi_loc (input_location
,
1314 ptrtmp
, fixed_offset
);
1317 /* Emit the statement and gimplify the adjustment expression. */
1318 ret
= create_tmp_reg (TREE_TYPE (ptr
), "adjusted_this");
1319 stmt
= gimple_build_assign (ret
, ptr
);
1320 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1325 /* Produce assembler for thunk NODE. */
1328 expand_thunk (struct cgraph_node
*node
)
1330 bool this_adjusting
= node
->thunk
.this_adjusting
;
1331 HOST_WIDE_INT fixed_offset
= node
->thunk
.fixed_offset
;
1332 HOST_WIDE_INT virtual_value
= node
->thunk
.virtual_value
;
1333 tree virtual_offset
= NULL
;
1334 tree alias
= node
->callees
->callee
->symbol
.decl
;
1335 tree thunk_fndecl
= node
->symbol
.decl
;
1336 tree a
= DECL_ARGUMENTS (thunk_fndecl
);
1338 current_function_decl
= thunk_fndecl
;
1340 /* Ensure thunks are emitted in their correct sections. */
1341 resolve_unique_section (thunk_fndecl
, 0, flag_function_sections
);
1344 && targetm
.asm_out
.can_output_mi_thunk (thunk_fndecl
, fixed_offset
,
1345 virtual_value
, alias
))
1349 tree restype
= TREE_TYPE (TREE_TYPE (thunk_fndecl
));
1351 DECL_RESULT (thunk_fndecl
)
1352 = build_decl (DECL_SOURCE_LOCATION (thunk_fndecl
),
1353 RESULT_DECL
, 0, restype
);
1354 fnname
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk_fndecl
));
1356 /* The back end expects DECL_INITIAL to contain a BLOCK, so we
1358 fn_block
= make_node (BLOCK
);
1359 BLOCK_VARS (fn_block
) = a
;
1360 DECL_INITIAL (thunk_fndecl
) = fn_block
;
1361 init_function_start (thunk_fndecl
);
1363 insn_locations_init ();
1364 set_curr_insn_location (DECL_SOURCE_LOCATION (thunk_fndecl
));
1365 prologue_location
= curr_insn_location ();
1366 assemble_start_function (thunk_fndecl
, fnname
);
1368 targetm
.asm_out
.output_mi_thunk (asm_out_file
, thunk_fndecl
,
1369 fixed_offset
, virtual_value
, alias
);
1371 assemble_end_function (thunk_fndecl
, fnname
);
1372 insn_locations_finalize ();
1373 init_insn_lengths ();
1374 free_after_compilation (cfun
);
1376 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
1377 node
->thunk
.thunk_p
= false;
1378 node
->symbol
.analyzed
= false;
1383 basic_block bb
, then_bb
, else_bb
, return_bb
;
1384 gimple_stmt_iterator bsi
;
1395 DECL_IGNORED_P (thunk_fndecl
) = 1;
1396 bitmap_obstack_initialize (NULL
);
1398 if (node
->thunk
.virtual_offset_p
)
1399 virtual_offset
= size_int (virtual_value
);
1401 /* Build the return declaration for the function. */
1402 restype
= TREE_TYPE (TREE_TYPE (thunk_fndecl
));
1403 if (DECL_RESULT (thunk_fndecl
) == NULL_TREE
)
1405 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
1406 DECL_ARTIFICIAL (resdecl
) = 1;
1407 DECL_IGNORED_P (resdecl
) = 1;
1408 DECL_RESULT (thunk_fndecl
) = resdecl
;
1411 resdecl
= DECL_RESULT (thunk_fndecl
);
1413 bb
= then_bb
= else_bb
= return_bb
= init_lowered_empty_function (thunk_fndecl
, true);
1415 bsi
= gsi_start_bb (bb
);
1417 /* Build call to the function being thunked. */
1418 if (!VOID_TYPE_P (restype
))
1420 if (DECL_BY_REFERENCE (resdecl
))
1421 restmp
= gimple_fold_indirect_ref (resdecl
);
1422 else if (!is_gimple_reg_type (restype
))
1425 add_local_decl (cfun
, restmp
);
1426 BLOCK_VARS (DECL_INITIAL (current_function_decl
)) = restmp
;
1429 restmp
= create_tmp_reg (restype
, "retval");
1432 for (arg
= a
; arg
; arg
= DECL_CHAIN (arg
))
1434 vargs
.create (nargs
);
1436 vargs
.quick_push (thunk_adjust (&bsi
, a
, 1, fixed_offset
,
1439 vargs
.quick_push (a
);
1442 for (i
= 1, arg
= DECL_CHAIN (a
); i
< nargs
; i
++, arg
= DECL_CHAIN (arg
))
1443 vargs
.quick_push (arg
);
1444 call
= gimple_build_call_vec (build_fold_addr_expr_loc (0, alias
), vargs
);
1446 gimple_call_set_from_thunk (call
, true);
1449 gimple_call_set_lhs (call
, restmp
);
1450 gcc_assert (useless_type_conversion_p (TREE_TYPE (restmp
),
1451 TREE_TYPE (TREE_TYPE (alias
))));
1453 gsi_insert_after (&bsi
, call
, GSI_NEW_STMT
);
1454 if (!(gimple_call_flags (call
) & ECF_NORETURN
))
1456 if (restmp
&& !this_adjusting
1457 && (fixed_offset
|| virtual_offset
))
1459 tree true_label
= NULL_TREE
;
1461 if (TREE_CODE (TREE_TYPE (restmp
)) == POINTER_TYPE
)
1464 /* If the return type is a pointer, we need to
1465 protect against NULL. We know there will be an
1466 adjustment, because that's why we're emitting a
1468 then_bb
= create_basic_block (NULL
, (void *) 0, bb
);
1469 return_bb
= create_basic_block (NULL
, (void *) 0, then_bb
);
1470 else_bb
= create_basic_block (NULL
, (void *) 0, else_bb
);
1471 add_bb_to_loop (then_bb
, bb
->loop_father
);
1472 add_bb_to_loop (return_bb
, bb
->loop_father
);
1473 add_bb_to_loop (else_bb
, bb
->loop_father
);
1474 remove_edge (single_succ_edge (bb
));
1475 true_label
= gimple_block_label (then_bb
);
1476 stmt
= gimple_build_cond (NE_EXPR
, restmp
,
1477 build_zero_cst (TREE_TYPE (restmp
)),
1478 NULL_TREE
, NULL_TREE
);
1479 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1480 make_edge (bb
, then_bb
, EDGE_TRUE_VALUE
);
1481 make_edge (bb
, else_bb
, EDGE_FALSE_VALUE
);
1482 make_edge (return_bb
, EXIT_BLOCK_PTR
, 0);
1483 make_edge (then_bb
, return_bb
, EDGE_FALLTHRU
);
1484 make_edge (else_bb
, return_bb
, EDGE_FALLTHRU
);
1485 bsi
= gsi_last_bb (then_bb
);
1488 restmp
= thunk_adjust (&bsi
, restmp
, /*this_adjusting=*/0,
1489 fixed_offset
, virtual_offset
);
1493 bsi
= gsi_last_bb (else_bb
);
1494 stmt
= gimple_build_assign (restmp
,
1495 build_zero_cst (TREE_TYPE (restmp
)));
1496 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1497 bsi
= gsi_last_bb (return_bb
);
1501 gimple_call_set_tail (call
, true);
1503 /* Build return value. */
1504 ret
= gimple_build_return (restmp
);
1505 gsi_insert_after (&bsi
, ret
, GSI_NEW_STMT
);
1509 gimple_call_set_tail (call
, true);
1510 remove_edge (single_succ_edge (bb
));
1513 delete_unreachable_blocks ();
1514 update_ssa (TODO_update_ssa
);
1515 #ifdef ENABLE_CHECKING
1516 verify_flow_info ();
1519 /* Since we want to emit the thunk, we explicitly mark its name as
1521 node
->thunk
.thunk_p
= false;
1522 rebuild_cgraph_edges ();
1523 cgraph_add_new_function (thunk_fndecl
, true);
1524 bitmap_obstack_release (NULL
);
1526 current_function_decl
= NULL
;
1530 /* Assemble thunks and aliases associated to NODE. */
1533 assemble_thunks_and_aliases (struct cgraph_node
*node
)
1535 struct cgraph_edge
*e
;
1537 struct ipa_ref
*ref
;
1539 for (e
= node
->callers
; e
;)
1540 if (e
->caller
->thunk
.thunk_p
)
1542 struct cgraph_node
*thunk
= e
->caller
;
1545 assemble_thunks_and_aliases (thunk
);
1546 expand_thunk (thunk
);
1550 for (i
= 0; ipa_ref_list_referring_iterate (&node
->symbol
.ref_list
,
1552 if (ref
->use
== IPA_REF_ALIAS
)
1554 struct cgraph_node
*alias
= ipa_ref_referring_node (ref
);
1555 bool saved_written
= TREE_ASM_WRITTEN (node
->symbol
.decl
);
1557 /* Force assemble_alias to really output the alias this time instead
1558 of buffering it in same alias pairs. */
1559 TREE_ASM_WRITTEN (node
->symbol
.decl
) = 1;
1560 do_assemble_alias (alias
->symbol
.decl
,
1561 DECL_ASSEMBLER_NAME (node
->symbol
.decl
));
1562 assemble_thunks_and_aliases (alias
);
1563 TREE_ASM_WRITTEN (node
->symbol
.decl
) = saved_written
;
1567 /* Expand function specified by NODE. */
1570 expand_function (struct cgraph_node
*node
)
1572 tree decl
= node
->symbol
.decl
;
1573 location_t saved_loc
;
1575 /* We ought to not compile any inline clones. */
1576 gcc_assert (!node
->global
.inlined_to
);
1578 announce_function (decl
);
1580 gcc_assert (node
->lowered
);
1582 /* Generate RTL for the body of DECL. */
1584 timevar_push (TV_REST_OF_COMPILATION
);
1586 gcc_assert (cgraph_global_info_ready
);
1588 /* Initialize the default bitmap obstack. */
1589 bitmap_obstack_initialize (NULL
);
1591 /* Initialize the RTL code for the function. */
1592 current_function_decl
= decl
;
1593 saved_loc
= input_location
;
1594 input_location
= DECL_SOURCE_LOCATION (decl
);
1595 init_function_start (decl
);
1597 gimple_register_cfg_hooks ();
1599 bitmap_obstack_initialize (®_obstack
); /* FIXME, only at RTL generation*/
1601 execute_all_ipa_transforms ();
1603 /* Perform all tree transforms and optimizations. */
1605 /* Signal the start of passes. */
1606 invoke_plugin_callbacks (PLUGIN_ALL_PASSES_START
, NULL
);
1608 execute_pass_list (g
->get_passes ()->all_passes
);
1610 /* Signal the end of passes. */
1611 invoke_plugin_callbacks (PLUGIN_ALL_PASSES_END
, NULL
);
1613 bitmap_obstack_release (®_obstack
);
1615 /* Release the default bitmap obstack. */
1616 bitmap_obstack_release (NULL
);
1618 /* If requested, warn about function definitions where the function will
1619 return a value (usually of some struct or union type) which itself will
1620 take up a lot of stack space. */
1621 if (warn_larger_than
&& !DECL_EXTERNAL (decl
) && TREE_TYPE (decl
))
1623 tree ret_type
= TREE_TYPE (TREE_TYPE (decl
));
1625 if (ret_type
&& TYPE_SIZE_UNIT (ret_type
)
1626 && TREE_CODE (TYPE_SIZE_UNIT (ret_type
)) == INTEGER_CST
1627 && 0 < compare_tree_int (TYPE_SIZE_UNIT (ret_type
),
1630 unsigned int size_as_int
1631 = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (ret_type
));
1633 if (compare_tree_int (TYPE_SIZE_UNIT (ret_type
), size_as_int
) == 0)
1634 warning (OPT_Wlarger_than_
, "size of return value of %q+D is %u bytes",
1637 warning (OPT_Wlarger_than_
, "size of return value of %q+D is larger than %wd bytes",
1638 decl
, larger_than_size
);
1642 gimple_set_body (decl
, NULL
);
1643 if (DECL_STRUCT_FUNCTION (decl
) == 0
1644 && !cgraph_get_node (decl
)->origin
)
1646 /* Stop pointing to the local nodes about to be freed.
1647 But DECL_INITIAL must remain nonzero so we know this
1648 was an actual function definition.
1649 For a nested function, this is done in c_pop_function_context.
1650 If rest_of_compilation set this to 0, leave it 0. */
1651 if (DECL_INITIAL (decl
) != 0)
1652 DECL_INITIAL (decl
) = error_mark_node
;
1655 input_location
= saved_loc
;
1658 timevar_pop (TV_REST_OF_COMPILATION
);
1660 /* Make sure that BE didn't give up on compiling. */
1661 gcc_assert (TREE_ASM_WRITTEN (decl
));
1663 current_function_decl
= NULL
;
1665 /* It would make a lot more sense to output thunks before function body to get more
1666 forward and lest backwarding jumps. This however would need solving problem
1667 with comdats. See PR48668. Also aliases must come after function itself to
1668 make one pass assemblers, like one on AIX, happy. See PR 50689.
1669 FIXME: Perhaps thunks should be move before function IFF they are not in comdat
1671 assemble_thunks_and_aliases (node
);
1672 cgraph_release_function_body (node
);
1673 /* Eliminate all call edges. This is important so the GIMPLE_CALL no longer
1674 points to the dead function body. */
1675 cgraph_node_remove_callees (node
);
1679 /* Expand all functions that must be output.
1681 Attempt to topologically sort the nodes so function is output when
1682 all called functions are already assembled to allow data to be
1683 propagated across the callgraph. Use a stack to get smaller distance
1684 between a function and its callees (later we may choose to use a more
1685 sophisticated algorithm for function reordering; we will likely want
1686 to use subsections to make the output functions appear in top-down
1690 expand_all_functions (void)
1692 struct cgraph_node
*node
;
1693 struct cgraph_node
**order
= XCNEWVEC (struct cgraph_node
*, cgraph_n_nodes
);
1694 int order_pos
, new_order_pos
= 0;
1697 order_pos
= ipa_reverse_postorder (order
);
1698 gcc_assert (order_pos
== cgraph_n_nodes
);
1700 /* Garbage collector may remove inline clones we eliminate during
1701 optimization. So we must be sure to not reference them. */
1702 for (i
= 0; i
< order_pos
; i
++)
1703 if (order
[i
]->process
)
1704 order
[new_order_pos
++] = order
[i
];
1706 for (i
= new_order_pos
- 1; i
>= 0; i
--)
1712 expand_function (node
);
1715 cgraph_process_new_functions ();
1721 /* This is used to sort the node types by the cgraph order number. */
1723 enum cgraph_order_sort_kind
1725 ORDER_UNDEFINED
= 0,
1731 struct cgraph_order_sort
1733 enum cgraph_order_sort_kind kind
;
1736 struct cgraph_node
*f
;
1737 struct varpool_node
*v
;
1742 /* Output all functions, variables, and asm statements in the order
1743 according to their order fields, which is the order in which they
1744 appeared in the file. This implements -fno-toplevel-reorder. In
1745 this mode we may output functions and variables which don't really
1746 need to be output. */
1749 output_in_order (void)
1752 struct cgraph_order_sort
*nodes
;
1754 struct cgraph_node
*pf
;
1755 struct varpool_node
*pv
;
1756 struct asm_node
*pa
;
1759 nodes
= XCNEWVEC (struct cgraph_order_sort
, max
);
1761 FOR_EACH_DEFINED_FUNCTION (pf
)
1763 if (pf
->process
&& !pf
->thunk
.thunk_p
&& !pf
->symbol
.alias
)
1765 i
= pf
->symbol
.order
;
1766 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1767 nodes
[i
].kind
= ORDER_FUNCTION
;
1772 FOR_EACH_DEFINED_VARIABLE (pv
)
1773 if (!DECL_EXTERNAL (pv
->symbol
.decl
))
1775 i
= pv
->symbol
.order
;
1776 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1777 nodes
[i
].kind
= ORDER_VAR
;
1781 for (pa
= asm_nodes
; pa
; pa
= pa
->next
)
1784 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1785 nodes
[i
].kind
= ORDER_ASM
;
1789 /* In toplevel reorder mode we output all statics; mark them as needed. */
1791 for (i
= 0; i
< max
; ++i
)
1792 if (nodes
[i
].kind
== ORDER_VAR
)
1793 varpool_finalize_named_section_flags (nodes
[i
].u
.v
);
1795 for (i
= 0; i
< max
; ++i
)
1797 switch (nodes
[i
].kind
)
1799 case ORDER_FUNCTION
:
1800 nodes
[i
].u
.f
->process
= 0;
1801 expand_function (nodes
[i
].u
.f
);
1805 varpool_assemble_decl (nodes
[i
].u
.v
);
1809 assemble_asm (nodes
[i
].u
.a
->asm_str
);
1812 case ORDER_UNDEFINED
:
1827 gcc::pass_manager
*passes
= g
->get_passes ();
1830 current_function_decl
= NULL
;
1831 gimple_register_cfg_hooks ();
1832 bitmap_obstack_initialize (NULL
);
1834 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_START
, NULL
);
1838 execute_ipa_pass_list (passes
->all_small_ipa_passes
);
1843 /* We never run removal of unreachable nodes after early passes. This is
1844 because TODO is run before the subpasses. It is important to remove
1845 the unreachable functions to save works at IPA level and to get LTO
1846 symbol tables right. */
1847 symtab_remove_unreachable_nodes (true, cgraph_dump_file
);
1849 /* If pass_all_early_optimizations was not scheduled, the state of
1850 the cgraph will not be properly updated. Update it now. */
1851 if (cgraph_state
< CGRAPH_STATE_IPA_SSA
)
1852 cgraph_state
= CGRAPH_STATE_IPA_SSA
;
1856 /* Generate coverage variables and constructors. */
1859 /* Process new functions added. */
1861 current_function_decl
= NULL
;
1862 cgraph_process_new_functions ();
1864 execute_ipa_summary_passes
1865 ((struct ipa_opt_pass_d
*) passes
->all_regular_ipa_passes
);
1868 /* Some targets need to handle LTO assembler output specially. */
1869 if (flag_generate_lto
)
1870 targetm
.asm_out
.lto_start ();
1872 execute_ipa_summary_passes ((struct ipa_opt_pass_d
*)
1873 passes
->all_lto_gen_passes
);
1876 ipa_write_summaries ();
1878 if (flag_generate_lto
)
1879 targetm
.asm_out
.lto_end ();
1881 if (!flag_ltrans
&& (in_lto_p
|| !flag_lto
|| flag_fat_lto_objects
))
1882 execute_ipa_pass_list (passes
->all_regular_ipa_passes
);
1883 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_END
, NULL
);
1885 bitmap_obstack_release (NULL
);
1889 /* Return string alias is alias of. */
1892 get_alias_symbol (tree decl
)
1894 tree alias
= lookup_attribute ("alias", DECL_ATTRIBUTES (decl
));
1895 return get_identifier (TREE_STRING_POINTER
1896 (TREE_VALUE (TREE_VALUE (alias
))));
1900 /* Weakrefs may be associated to external decls and thus not output
1901 at expansion time. Emit all necessary aliases. */
1904 output_weakrefs (void)
1907 FOR_EACH_SYMBOL (node
)
1908 if (node
->symbol
.alias
1909 && !TREE_ASM_WRITTEN (node
->symbol
.decl
)
1910 && node
->symbol
.weakref
)
1914 /* Weakrefs are special by not requiring target definition in current
1915 compilation unit. It is thus bit hard to work out what we want to
1917 When alias target is defined, we need to fetch it from symtab reference,
1918 otherwise it is pointed to by alias_target. */
1919 if (node
->symbol
.alias_target
)
1920 target
= (DECL_P (node
->symbol
.alias_target
)
1921 ? DECL_ASSEMBLER_NAME (node
->symbol
.alias_target
)
1922 : node
->symbol
.alias_target
);
1923 else if (node
->symbol
.analyzed
)
1924 target
= DECL_ASSEMBLER_NAME (symtab_alias_target (node
)->symbol
.decl
);
1928 target
= get_alias_symbol (node
->symbol
.decl
);
1930 do_assemble_alias (node
->symbol
.decl
, target
);
1934 /* Initialize callgraph dump file. */
1939 if (!cgraph_dump_file
)
1940 cgraph_dump_file
= dump_begin (TDI_cgraph
, NULL
);
1944 /* Perform simple optimizations based on callgraph. */
1952 #ifdef ENABLE_CHECKING
1956 timevar_push (TV_CGRAPHOPT
);
1957 if (pre_ipa_mem_report
)
1959 fprintf (stderr
, "Memory consumption before IPA\n");
1960 dump_memory_report (false);
1963 fprintf (stderr
, "Performing interprocedural optimizations\n");
1964 cgraph_state
= CGRAPH_STATE_IPA
;
1966 /* If LTO is enabled, initialize the streamer hooks needed by GIMPLE. */
1968 lto_streamer_hooks_init ();
1970 /* Don't run the IPA passes if there was any error or sorry messages. */
1974 /* Do nothing else if any IPA pass found errors or if we are just streaming LTO. */
1976 || (!in_lto_p
&& flag_lto
&& !flag_fat_lto_objects
))
1978 timevar_pop (TV_CGRAPHOPT
);
1982 /* This pass remove bodies of extern inline functions we never inlined.
1983 Do this later so other IPA passes see what is really going on. */
1984 symtab_remove_unreachable_nodes (false, dump_file
);
1985 cgraph_global_info_ready
= true;
1986 if (cgraph_dump_file
)
1988 fprintf (cgraph_dump_file
, "Optimized ");
1989 dump_symtab (cgraph_dump_file
);
1991 if (post_ipa_mem_report
)
1993 fprintf (stderr
, "Memory consumption after IPA\n");
1994 dump_memory_report (false);
1996 timevar_pop (TV_CGRAPHOPT
);
1998 /* Output everything. */
1999 (*debug_hooks
->assembly_start
) ();
2001 fprintf (stderr
, "Assembling functions:\n");
2002 #ifdef ENABLE_CHECKING
2006 cgraph_materialize_all_clones ();
2007 bitmap_obstack_initialize (NULL
);
2008 execute_ipa_pass_list (g
->get_passes ()->all_late_ipa_passes
);
2009 symtab_remove_unreachable_nodes (true, dump_file
);
2010 #ifdef ENABLE_CHECKING
2013 bitmap_obstack_release (NULL
);
2014 mark_functions_to_output ();
2016 /* When weakref support is missing, we autmatically translate all
2017 references to NODE to references to its ultimate alias target.
2018 The renaming mechanizm uses flag IDENTIFIER_TRANSPARENT_ALIAS and
2021 Set up this mapping before we output any assembler but once we are sure
2022 that all symbol renaming is done.
2024 FIXME: All this uglyness can go away if we just do renaming at gimple
2025 level by physically rewritting the IL. At the moment we can only redirect
2026 calls, so we need infrastructure for renaming references as well. */
2027 #ifndef ASM_OUTPUT_WEAKREF
2030 FOR_EACH_SYMBOL (node
)
2031 if (node
->symbol
.alias
2032 && lookup_attribute ("weakref", DECL_ATTRIBUTES (node
->symbol
.decl
)))
2034 IDENTIFIER_TRANSPARENT_ALIAS
2035 (DECL_ASSEMBLER_NAME (node
->symbol
.decl
)) = 1;
2036 TREE_CHAIN (DECL_ASSEMBLER_NAME (node
->symbol
.decl
))
2037 = (node
->symbol
.alias_target
? node
->symbol
.alias_target
2038 : DECL_ASSEMBLER_NAME (symtab_alias_target (node
)->symbol
.decl
));
2042 cgraph_state
= CGRAPH_STATE_EXPANSION
;
2043 if (!flag_toplevel_reorder
)
2047 output_asm_statements ();
2049 expand_all_functions ();
2050 varpool_output_variables ();
2053 cgraph_process_new_functions ();
2054 cgraph_state
= CGRAPH_STATE_FINISHED
;
2057 if (cgraph_dump_file
)
2059 fprintf (cgraph_dump_file
, "\nFinal ");
2060 dump_symtab (cgraph_dump_file
);
2062 #ifdef ENABLE_CHECKING
2064 /* Double check that all inline clones are gone and that all
2065 function bodies have been released from memory. */
2068 struct cgraph_node
*node
;
2069 bool error_found
= false;
2071 FOR_EACH_DEFINED_FUNCTION (node
)
2072 if (node
->global
.inlined_to
2073 || gimple_has_body_p (node
->symbol
.decl
))
2076 dump_cgraph_node (stderr
, node
);
2079 internal_error ("nodes with unreleased memory found");
2085 /* Analyze the whole compilation unit once it is parsed completely. */
2088 finalize_compilation_unit (void)
2090 timevar_push (TV_CGRAPH
);
2092 /* If we're here there's no current function anymore. Some frontends
2093 are lazy in clearing these. */
2094 current_function_decl
= NULL
;
2097 /* Do not skip analyzing the functions if there were errors, we
2098 miss diagnostics for following functions otherwise. */
2100 /* Emit size functions we didn't inline. */
2101 finalize_size_functions ();
2103 /* Mark alias targets necessary and emit diagnostics. */
2104 handle_alias_pairs ();
2108 fprintf (stderr
, "\nAnalyzing compilation unit\n");
2112 if (flag_dump_passes
)
2115 /* Gimplify and lower all functions, compute reachability and
2116 remove unreachable nodes. */
2117 analyze_functions ();
2119 /* Mark alias targets necessary and emit diagnostics. */
2120 handle_alias_pairs ();
2122 /* Gimplify and lower thunks. */
2123 analyze_functions ();
2125 /* Finally drive the pass manager. */
2128 timevar_pop (TV_CGRAPH
);
2132 #include "gt-cgraphunit.h"