1 /* Callgraph based interprocedural optimizations.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
3 2011, 2012 Free Software Foundation, Inc.
4 Contributed by Jan Hubicka
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* This module implements main driver of compilation process as well as
23 few basic interprocedural optimizers.
25 The main scope of this file is to act as an interface in between
26 tree based frontends and the backend (and middle end)
28 The front-end is supposed to use following functionality:
30 - cgraph_finalize_function
32 This function is called once front-end has parsed whole body of function
33 and it is certain that the function body nor the declaration will change.
35 (There is one exception needed for implementing GCC extern inline
38 - varpool_finalize_variable
40 This function has same behavior as the above but is used for static
43 - cgraph_finalize_compilation_unit
45 This function is called once (source level) compilation unit is finalized
46 and it will no longer change.
48 In the call-graph construction and local function analysis takes
49 place here. Bodies of unreachable functions are released to
50 conserve memory usage.
52 The function can be called multiple times when multiple source level
53 compilation units are combined (such as in C frontend)
57 In this unit-at-a-time compilation the intra procedural analysis takes
58 place here. In particular the static functions whose address is never
59 taken are marked as local. Backend can then use this information to
60 modify calling conventions, do better inlining or similar optimizations.
62 - cgraph_mark_needed_node
63 - varpool_mark_needed_node
65 When function or variable is referenced by some hidden way the call-graph
66 data structure must be updated accordingly by this function.
67 There should be little need to call this function and all the references
68 should be made explicit to cgraph code. At present these functions are
69 used by C++ frontend to explicitly mark the keyed methods.
71 - analyze_expr callback
73 This function is responsible for lowering tree nodes not understood by
74 generic code into understandable ones or alternatively marking
75 callgraph and varpool nodes referenced by the as needed.
77 ??? On the tree-ssa genericizing should take place here and we will avoid
78 need for these hooks (replacing them by genericizing hook)
80 Analyzing of all functions is deferred
81 to cgraph_finalize_compilation_unit and expansion into cgraph_optimize.
83 In cgraph_finalize_compilation_unit the reachable functions are
84 analyzed. During analysis the call-graph edges from reachable
85 functions are constructed and their destinations are marked as
86 reachable. References to functions and variables are discovered too
87 and variables found to be needed output to the assembly file. Via
88 mark_referenced call in assemble_variable functions referenced by
89 static variables are noticed too.
91 The intra-procedural information is produced and its existence
92 indicated by global_info_ready. Once this flag is set it is impossible
93 to change function from !reachable to reachable and thus
94 assemble_variable no longer call mark_referenced.
96 Finally the call-graph is topologically sorted and all reachable functions
97 that has not been completely inlined or are not external are output.
99 ??? It is possible that reference to function or variable is optimized
100 out. We can not deal with this nicely because topological order is not
101 suitable for it. For tree-ssa we may consider another pass doing
102 optimization and re-discovering reachable functions.
104 ??? Reorganize code so variables are output very last and only if they
105 really has been referenced by produced code, so we catch more cases
106 where reference has been optimized out. */
111 #include "coretypes.h"
116 #include "tree-flow.h"
117 #include "tree-inline.h"
118 #include "langhooks.h"
119 #include "pointer-set.h"
126 #include "diagnostic.h"
127 #include "tree-pretty-print.h"
128 #include "gimple-pretty-print.h"
133 #include "function.h"
134 #include "ipa-prop.h"
136 #include "tree-iterator.h"
137 #include "tree-pass.h"
138 #include "tree-dump.h"
140 #include "coverage.h"
142 #include "ipa-inline.h"
143 #include "ipa-utils.h"
144 #include "lto-streamer.h"
146 #include "regset.h" /* FIXME: For reg_obstack. */
148 static void cgraph_expand_all_functions (void);
149 static void cgraph_mark_functions_to_output (void);
150 static void cgraph_expand_function (struct cgraph_node
*);
151 static void cgraph_output_pending_asms (void);
152 static void tree_rest_of_compilation (struct cgraph_node
*);
154 FILE *cgraph_dump_file
;
156 /* Used for vtable lookup in thunk adjusting. */
157 static GTY (()) tree vtable_entry_type
;
159 /* Determine if function DECL is needed. That is, visible to something
160 either outside this translation unit, something magic in the system
164 cgraph_decide_is_function_needed (struct cgraph_node
*node
, tree decl
)
166 /* If the user told us it is used, then it must be so. */
167 if (node
->symbol
.externally_visible
)
170 /* ??? If the assembler name is set by hand, it is possible to assemble
171 the name later after finalizing the function and the fact is noticed
172 in assemble_name then. This is arguably a bug. */
173 if (DECL_ASSEMBLER_NAME_SET_P (decl
)
174 && (!node
->thunk
.thunk_p
&& !node
->same_body_alias
)
175 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)))
178 /* With -fkeep-inline-functions we are keeping all inline functions except
179 for extern inline ones. */
180 if (flag_keep_inline_functions
181 && DECL_DECLARED_INLINE_P (decl
)
182 && !DECL_EXTERNAL (decl
)
183 && !DECL_DISREGARD_INLINE_LIMITS (decl
))
186 /* If we decided it was needed before, but at the time we didn't have
187 the body of the function available, then it's still needed. We have
188 to go back and re-check its dependencies now. */
192 /* Externally visible functions must be output. The exception is
193 COMDAT functions that must be output only when they are needed.
195 When not optimizing, also output the static functions. (see
196 PR24561), but don't do so for always_inline functions, functions
197 declared inline and nested functions. These were optimized out
198 in the original implementation and it is unclear whether we want
199 to change the behavior here. */
200 if (((TREE_PUBLIC (decl
)
202 && !node
->same_body_alias
203 && !DECL_DISREGARD_INLINE_LIMITS (decl
)
204 && !DECL_DECLARED_INLINE_P (decl
)
205 && !(DECL_CONTEXT (decl
)
206 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
)))
207 && !flag_whole_program
209 && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
))
215 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
216 functions into callgraph in a way so they look like ordinary reachable
217 functions inserted into callgraph already at construction time. */
220 cgraph_process_new_functions (void)
224 struct cgraph_node
*node
;
226 varpool_analyze_pending_decls ();
227 /* Note that this queue may grow as its being processed, as the new
228 functions may generate new ones. */
229 while (cgraph_new_nodes
)
231 node
= cgraph_new_nodes
;
232 fndecl
= node
->symbol
.decl
;
233 cgraph_new_nodes
= cgraph_new_nodes
->next_needed
;
234 switch (cgraph_state
)
236 case CGRAPH_STATE_CONSTRUCTION
:
237 /* At construction time we just need to finalize function and move
238 it into reachable functions list. */
240 node
->next_needed
= NULL
;
241 cgraph_finalize_function (fndecl
, false);
242 cgraph_mark_reachable_node (node
);
244 cgraph_call_function_insertion_hooks (node
);
247 case CGRAPH_STATE_IPA
:
248 case CGRAPH_STATE_IPA_SSA
:
249 /* When IPA optimization already started, do all essential
250 transformations that has been already performed on the whole
251 cgraph but not on this function. */
253 gimple_register_cfg_hooks ();
255 cgraph_analyze_function (node
);
256 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
257 current_function_decl
= fndecl
;
258 if ((cgraph_state
== CGRAPH_STATE_IPA_SSA
259 && !gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
260 /* When not optimizing, be sure we run early local passes anyway
263 execute_pass_list (pass_early_local_passes
.pass
.sub
);
265 compute_inline_parameters (node
, true);
266 free_dominance_info (CDI_POST_DOMINATORS
);
267 free_dominance_info (CDI_DOMINATORS
);
269 current_function_decl
= NULL
;
270 cgraph_call_function_insertion_hooks (node
);
273 case CGRAPH_STATE_EXPANSION
:
274 /* Functions created during expansion shall be compiled
277 cgraph_call_function_insertion_hooks (node
);
278 cgraph_expand_function (node
);
285 varpool_analyze_pending_decls ();
290 /* As an GCC extension we allow redefinition of the function. The
291 semantics when both copies of bodies differ is not well defined.
292 We replace the old body with new body so in unit at a time mode
293 we always use new body, while in normal mode we may end up with
294 old body inlined into some functions and new body expanded and
297 ??? It may make more sense to use one body for inlining and other
298 body for expanding the function but this is difficult to do. */
301 cgraph_reset_node (struct cgraph_node
*node
)
303 /* If node->process is set, then we have already begun whole-unit analysis.
304 This is *not* testing for whether we've already emitted the function.
305 That case can be sort-of legitimately seen with real function redefinition
306 errors. I would argue that the front end should never present us with
307 such a case, but don't enforce that for now. */
308 gcc_assert (!node
->process
);
310 /* Reset our data structures so we can analyze the function again. */
311 memset (&node
->local
, 0, sizeof (node
->local
));
312 memset (&node
->global
, 0, sizeof (node
->global
));
313 memset (&node
->rtl
, 0, sizeof (node
->rtl
));
314 node
->analyzed
= false;
315 node
->local
.finalized
= false;
317 cgraph_node_remove_callees (node
);
320 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
321 logic in effect. If NESTED is true, then our caller cannot stand to have
322 the garbage collector run at the moment. We would need to either create
323 a new GC context, or just not compile right now. */
326 cgraph_finalize_function (tree decl
, bool nested
)
328 struct cgraph_node
*node
= cgraph_get_create_node (decl
);
330 if (node
->local
.finalized
)
332 cgraph_reset_node (node
);
333 node
->local
.redefined_extern_inline
= true;
336 notice_global_symbol (decl
);
337 node
->local
.finalized
= true;
338 node
->lowered
= DECL_STRUCT_FUNCTION (decl
)->cfg
!= NULL
;
340 if (cgraph_decide_is_function_needed (node
, decl
))
341 cgraph_mark_needed_node (node
);
343 /* Since we reclaim unreachable nodes at the end of every language
344 level unit, we need to be conservative about possible entry points
346 if ((TREE_PUBLIC (decl
) && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
))
347 || DECL_STATIC_CONSTRUCTOR (decl
)
348 || DECL_STATIC_DESTRUCTOR (decl
)
349 /* COMDAT virtual functions may be referenced by vtable from
350 other compilation unit. Still we want to devirtualize calls
351 to those so we need to analyze them.
352 FIXME: We should introduce may edges for this purpose and update
353 their handling in unreachable function removal and inliner too. */
354 || (DECL_VIRTUAL_P (decl
)
355 && optimize
&& (DECL_COMDAT (decl
) || DECL_EXTERNAL (decl
))))
356 cgraph_mark_reachable_node (node
);
358 /* If we've not yet emitted decl, tell the debug info about it. */
359 if (!TREE_ASM_WRITTEN (decl
))
360 (*debug_hooks
->deferred_inline_function
) (decl
);
362 /* Possibly warn about unused parameters. */
363 if (warn_unused_parameter
)
364 do_warn_unused_parameter (decl
);
370 /* Add the function FNDECL to the call graph.
371 Unlike cgraph_finalize_function, this function is intended to be used
372 by middle end and allows insertion of new function at arbitrary point
373 of compilation. The function can be either in high, low or SSA form
376 The function is assumed to be reachable and have address taken (so no
377 API breaking optimizations are performed on it).
379 Main work done by this function is to enqueue the function for later
380 processing to avoid need the passes to be re-entrant. */
383 cgraph_add_new_function (tree fndecl
, bool lowered
)
385 struct cgraph_node
*node
;
386 switch (cgraph_state
)
388 case CGRAPH_STATE_CONSTRUCTION
:
389 /* Just enqueue function to be processed at nearest occurrence. */
390 node
= cgraph_create_node (fndecl
);
391 node
->next_needed
= cgraph_new_nodes
;
393 node
->lowered
= true;
394 cgraph_new_nodes
= node
;
397 case CGRAPH_STATE_IPA
:
398 case CGRAPH_STATE_IPA_SSA
:
399 case CGRAPH_STATE_EXPANSION
:
400 /* Bring the function into finalized state and enqueue for later
401 analyzing and compilation. */
402 node
= cgraph_get_create_node (fndecl
);
403 node
->local
.local
= false;
404 node
->local
.finalized
= true;
405 node
->reachable
= node
->needed
= true;
406 if (!lowered
&& cgraph_state
== CGRAPH_STATE_EXPANSION
)
408 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
409 current_function_decl
= fndecl
;
410 gimple_register_cfg_hooks ();
411 bitmap_obstack_initialize (NULL
);
412 execute_pass_list (all_lowering_passes
);
413 execute_pass_list (pass_early_local_passes
.pass
.sub
);
414 bitmap_obstack_release (NULL
);
416 current_function_decl
= NULL
;
421 node
->lowered
= true;
422 node
->next_needed
= cgraph_new_nodes
;
423 cgraph_new_nodes
= node
;
426 case CGRAPH_STATE_FINISHED
:
427 /* At the very end of compilation we have to do all the work up
429 node
= cgraph_create_node (fndecl
);
431 node
->lowered
= true;
432 cgraph_analyze_function (node
);
433 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
434 current_function_decl
= fndecl
;
435 gimple_register_cfg_hooks ();
436 bitmap_obstack_initialize (NULL
);
437 if (!gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
438 execute_pass_list (pass_early_local_passes
.pass
.sub
);
439 bitmap_obstack_release (NULL
);
440 tree_rest_of_compilation (node
);
442 current_function_decl
= NULL
;
449 /* Set a personality if required and we already passed EH lowering. */
451 && (function_needs_eh_personality (DECL_STRUCT_FUNCTION (fndecl
))
452 == eh_personality_lang
))
453 DECL_FUNCTION_PERSONALITY (fndecl
) = lang_hooks
.eh_personality ();
456 /* C99 extern inline keywords allow changing of declaration after function
457 has been finalized. We need to re-decide if we want to mark the function as
461 cgraph_mark_if_needed (tree decl
)
463 struct cgraph_node
*node
= cgraph_get_node (decl
);
464 if (node
->local
.finalized
&& cgraph_decide_is_function_needed (node
, decl
))
465 cgraph_mark_needed_node (node
);
468 /* Return TRUE if NODE2 is equivalent to NODE or its clone. */
470 clone_of_p (struct cgraph_node
*node
, struct cgraph_node
*node2
)
472 node
= cgraph_function_or_thunk_node (node
, NULL
);
473 node2
= cgraph_function_or_thunk_node (node2
, NULL
);
474 while (node
!= node2
&& node2
)
475 node2
= node2
->clone_of
;
476 return node2
!= NULL
;
479 /* Verify edge E count and frequency. */
482 verify_edge_count_and_frequency (struct cgraph_edge
*e
)
484 bool error_found
= false;
487 error ("caller edge count is negative");
490 if (e
->frequency
< 0)
492 error ("caller edge frequency is negative");
495 if (e
->frequency
> CGRAPH_FREQ_MAX
)
497 error ("caller edge frequency is too large");
500 if (gimple_has_body_p (e
->caller
->symbol
.decl
)
501 && !e
->caller
->global
.inlined_to
502 /* FIXME: Inline-analysis sets frequency to 0 when edge is optimized out.
503 Remove this once edges are actualy removed from the function at that time. */
505 || (inline_edge_summary_vec
506 && ((VEC_length(inline_edge_summary_t
, inline_edge_summary_vec
)
507 <= (unsigned) e
->uid
)
508 || !inline_edge_summary (e
)->predicate
)))
510 != compute_call_stmt_bb_frequency (e
->caller
->symbol
.decl
,
511 gimple_bb (e
->call_stmt
))))
513 error ("caller edge frequency %i does not match BB frequency %i",
515 compute_call_stmt_bb_frequency (e
->caller
->symbol
.decl
,
516 gimple_bb (e
->call_stmt
)));
522 /* Switch to THIS_CFUN if needed and print STMT to stderr. */
524 cgraph_debug_gimple_stmt (struct function
*this_cfun
, gimple stmt
)
526 /* debug_gimple_stmt needs correct cfun */
527 if (cfun
!= this_cfun
)
528 set_cfun (this_cfun
);
529 debug_gimple_stmt (stmt
);
532 /* Verify that call graph edge E corresponds to DECL from the associated
533 statement. Return true if the verification should fail. */
536 verify_edge_corresponds_to_fndecl (struct cgraph_edge
*e
, tree decl
)
538 struct cgraph_node
*node
;
540 if (!decl
|| e
->callee
->global
.inlined_to
)
542 node
= cgraph_get_node (decl
);
544 /* We do not know if a node from a different partition is an alias or what it
545 aliases and therefore cannot do the former_clone_of check reliably. */
546 if (!node
|| node
->symbol
.in_other_partition
)
548 node
= cgraph_function_or_thunk_node (node
, NULL
);
550 if ((e
->callee
->former_clone_of
!= node
->symbol
.decl
551 && (!node
->same_body_alias
552 || e
->callee
->former_clone_of
!= node
->thunk
.alias
))
553 /* IPA-CP sometimes redirect edge to clone and then back to the former
554 function. This ping-pong has to go, eventually. */
555 && (node
!= cgraph_function_or_thunk_node (e
->callee
, NULL
))
556 && !clone_of_p (node
, e
->callee
)
557 /* If decl is a same body alias of some other decl, allow e->callee to be
558 a clone of a clone of that other decl too. */
559 && (!node
->same_body_alias
560 || !clone_of_p (cgraph_get_node (node
->thunk
.alias
), e
->callee
)))
566 /* Verify cgraph nodes of given cgraph node. */
568 verify_cgraph_node (struct cgraph_node
*node
)
570 struct cgraph_edge
*e
;
571 struct function
*this_cfun
= DECL_STRUCT_FUNCTION (node
->symbol
.decl
);
572 basic_block this_block
;
573 gimple_stmt_iterator gsi
;
574 bool error_found
= false;
579 timevar_push (TV_CGRAPH_VERIFY
);
580 for (e
= node
->callees
; e
; e
= e
->next_callee
)
583 error ("aux field set for edge %s->%s",
584 identifier_to_locale (cgraph_node_name (e
->caller
)),
585 identifier_to_locale (cgraph_node_name (e
->callee
)));
590 error ("execution count is negative");
593 if (node
->global
.inlined_to
&& node
->symbol
.externally_visible
)
595 error ("externally visible inline clone");
598 if (node
->global
.inlined_to
&& node
->symbol
.address_taken
)
600 error ("inline clone with address taken");
603 if (node
->global
.inlined_to
&& node
->needed
)
605 error ("inline clone is needed");
608 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
612 error ("aux field set for indirect edge from %s",
613 identifier_to_locale (cgraph_node_name (e
->caller
)));
616 if (!e
->indirect_unknown_callee
617 || !e
->indirect_info
)
619 error ("An indirect edge from %s is not marked as indirect or has "
620 "associated indirect_info, the corresponding statement is: ",
621 identifier_to_locale (cgraph_node_name (e
->caller
)));
622 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
626 for (e
= node
->callers
; e
; e
= e
->next_caller
)
628 if (verify_edge_count_and_frequency (e
))
630 if (!e
->inline_failed
)
632 if (node
->global
.inlined_to
633 != (e
->caller
->global
.inlined_to
634 ? e
->caller
->global
.inlined_to
: e
->caller
))
636 error ("inlined_to pointer is wrong");
639 if (node
->callers
->next_caller
)
641 error ("multiple inline callers");
646 if (node
->global
.inlined_to
)
648 error ("inlined_to pointer set for noninline callers");
652 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
653 if (verify_edge_count_and_frequency (e
))
655 if (!node
->callers
&& node
->global
.inlined_to
)
657 error ("inlined_to pointer is set but no predecessors found");
660 if (node
->global
.inlined_to
== node
)
662 error ("inlined_to pointer refers to itself");
666 if (!cgraph_get_node (node
->symbol
.decl
))
668 error ("node not found in cgraph_hash");
674 struct cgraph_node
*n
;
675 for (n
= node
->clone_of
->clones
; n
; n
= n
->next_sibling_clone
)
680 error ("node has wrong clone_of");
686 struct cgraph_node
*n
;
687 for (n
= node
->clones
; n
; n
= n
->next_sibling_clone
)
688 if (n
->clone_of
!= node
)
692 error ("node has wrong clone list");
696 if ((node
->prev_sibling_clone
|| node
->next_sibling_clone
) && !node
->clone_of
)
698 error ("node is in clone list but it is not clone");
701 if (!node
->prev_sibling_clone
&& node
->clone_of
&& node
->clone_of
->clones
!= node
)
703 error ("node has wrong prev_clone pointer");
706 if (node
->prev_sibling_clone
&& node
->prev_sibling_clone
->next_sibling_clone
!= node
)
708 error ("double linked list of clones corrupted");
711 if (node
->symbol
.same_comdat_group
)
713 symtab_node n
= node
->symbol
.same_comdat_group
;
715 if (!DECL_ONE_ONLY (n
->symbol
.decl
))
717 error ("non-DECL_ONE_ONLY node in a same_comdat_group list");
720 if (n
== (symtab_node
)node
)
722 error ("node is alone in a comdat group");
727 if (!n
->symbol
.same_comdat_group
)
729 error ("same_comdat_group is not a circular list");
733 n
= n
->symbol
.same_comdat_group
;
735 while (n
!= (symtab_node
)node
);
738 if (node
->analyzed
&& node
->alias
)
740 bool ref_found
= false;
746 error ("Alias has call edges");
749 for (i
= 0; ipa_ref_list_reference_iterate (&node
->symbol
.ref_list
,
751 if (ref
->use
!= IPA_REF_ALIAS
)
753 error ("Alias has non-alias reference");
758 error ("Alias has more than one alias reference");
765 error ("Analyzed alias has no reference");
769 if (node
->analyzed
&& node
->thunk
.thunk_p
)
773 error ("No edge out of thunk node");
776 else if (node
->callees
->next_callee
)
778 error ("More than one edge out of thunk node");
781 if (gimple_has_body_p (node
->symbol
.decl
))
783 error ("Thunk is not supposed to have body");
787 else if (node
->analyzed
&& gimple_has_body_p (node
->symbol
.decl
)
788 && !TREE_ASM_WRITTEN (node
->symbol
.decl
)
789 && (!DECL_EXTERNAL (node
->symbol
.decl
) || node
->global
.inlined_to
)
794 /* The nodes we're interested in are never shared, so walk
795 the tree ignoring duplicates. */
796 struct pointer_set_t
*visited_nodes
= pointer_set_create ();
797 /* Reach the trees by walking over the CFG, and note the
798 enclosing basic-blocks in the call edges. */
799 FOR_EACH_BB_FN (this_block
, this_cfun
)
800 for (gsi
= gsi_start_bb (this_block
);
804 gimple stmt
= gsi_stmt (gsi
);
805 if (is_gimple_call (stmt
))
807 struct cgraph_edge
*e
= cgraph_edge (node
, stmt
);
808 tree decl
= gimple_call_fndecl (stmt
);
813 error ("shared call_stmt:");
814 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
817 if (!e
->indirect_unknown_callee
)
819 if (verify_edge_corresponds_to_fndecl (e
, decl
))
821 error ("edge points to wrong declaration:");
822 debug_tree (e
->callee
->symbol
.decl
);
823 fprintf (stderr
," Instead of:");
830 error ("an indirect edge with unknown callee "
831 "corresponding to a call_stmt with "
832 "a known declaration:");
834 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
840 error ("missing callgraph edge for call stmt:");
841 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
846 pointer_set_destroy (visited_nodes
);
849 /* No CFG available?! */
852 for (e
= node
->callees
; e
; e
= e
->next_callee
)
856 error ("edge %s->%s has no corresponding call_stmt",
857 identifier_to_locale (cgraph_node_name (e
->caller
)),
858 identifier_to_locale (cgraph_node_name (e
->callee
)));
859 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
864 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
868 error ("an indirect edge from %s has no corresponding call_stmt",
869 identifier_to_locale (cgraph_node_name (e
->caller
)));
870 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
878 dump_cgraph_node (stderr
, node
);
879 internal_error ("verify_cgraph_node failed");
881 timevar_pop (TV_CGRAPH_VERIFY
);
884 /* Verify whole cgraph structure. */
888 struct cgraph_node
*node
;
893 for (node
= cgraph_nodes
; node
; node
= node
->next
)
894 verify_cgraph_node (node
);
897 /* Output all asm statements we have stored up to be output. */
900 cgraph_output_pending_asms (void)
902 struct cgraph_asm_node
*can
;
907 for (can
= cgraph_asm_nodes
; can
; can
= can
->next
)
908 assemble_asm (can
->asm_str
);
909 cgraph_asm_nodes
= NULL
;
912 /* Analyze the function scheduled to be output. */
914 cgraph_analyze_function (struct cgraph_node
*node
)
916 tree save
= current_function_decl
;
917 tree decl
= node
->symbol
.decl
;
919 if (node
->alias
&& node
->thunk
.alias
)
921 struct cgraph_node
*tgt
= cgraph_get_node (node
->thunk
.alias
);
922 struct cgraph_node
*n
;
924 for (n
= tgt
; n
&& n
->alias
;
925 n
= n
->analyzed
? cgraph_alias_aliased_node (n
) : NULL
)
928 error ("function %q+D part of alias cycle", node
->symbol
.decl
);
932 if (!VEC_length (ipa_ref_t
, node
->symbol
.ref_list
.references
))
933 ipa_record_reference (node
, NULL
, tgt
, NULL
, IPA_REF_ALIAS
, NULL
);
934 if (node
->same_body_alias
)
936 DECL_VIRTUAL_P (node
->symbol
.decl
) = DECL_VIRTUAL_P (node
->thunk
.alias
);
937 DECL_DECLARED_INLINE_P (node
->symbol
.decl
)
938 = DECL_DECLARED_INLINE_P (node
->thunk
.alias
);
939 DECL_DISREGARD_INLINE_LIMITS (node
->symbol
.decl
)
940 = DECL_DISREGARD_INLINE_LIMITS (node
->thunk
.alias
);
943 /* Fixup visibility nonsences C++ frontend produce on same body aliases. */
944 if (TREE_PUBLIC (node
->symbol
.decl
) && node
->same_body_alias
)
946 DECL_EXTERNAL (node
->symbol
.decl
) = DECL_EXTERNAL (node
->thunk
.alias
);
947 if (DECL_ONE_ONLY (node
->thunk
.alias
))
949 DECL_COMDAT (node
->symbol
.decl
) = DECL_COMDAT (node
->thunk
.alias
);
950 DECL_COMDAT_GROUP (node
->symbol
.decl
) = DECL_COMDAT_GROUP (node
->thunk
.alias
);
951 if (DECL_ONE_ONLY (node
->thunk
.alias
) && !node
->symbol
.same_comdat_group
)
953 struct cgraph_node
*tgt
= cgraph_get_node (node
->thunk
.alias
);
954 node
->symbol
.same_comdat_group
= (symtab_node
)tgt
;
955 if (!tgt
->symbol
.same_comdat_group
)
956 tgt
->symbol
.same_comdat_group
= (symtab_node
)node
;
960 for (n
= tgt
->symbol
.same_comdat_group
;
961 n
->symbol
.same_comdat_group
!= (symtab_node
)tgt
;
962 n
= n
->symbol
.same_comdat_group
)
964 n
->symbol
.same_comdat_group
= (symtab_node
)node
;
969 cgraph_mark_reachable_node (cgraph_alias_aliased_node (node
));
970 if (node
->symbol
.address_taken
)
971 cgraph_mark_address_taken_node (cgraph_alias_aliased_node (node
));
972 if (cgraph_decide_is_function_needed (node
, node
->symbol
.decl
))
973 cgraph_mark_needed_node (node
);
975 else if (node
->thunk
.thunk_p
)
977 cgraph_create_edge (node
, cgraph_get_node (node
->thunk
.alias
),
978 NULL
, 0, CGRAPH_FREQ_BASE
);
982 current_function_decl
= decl
;
983 push_cfun (DECL_STRUCT_FUNCTION (decl
));
985 assign_assembler_name_if_neeeded (node
->symbol
.decl
);
987 /* Make sure to gimplify bodies only once. During analyzing a
988 function we lower it, which will require gimplified nested
989 functions, so we can end up here with an already gimplified
991 if (!gimple_body (decl
))
992 gimplify_function_tree (decl
);
993 dump_function (TDI_generic
, decl
);
995 /* Lower the function. */
999 lower_nested_functions (node
->symbol
.decl
);
1000 gcc_assert (!node
->nested
);
1002 gimple_register_cfg_hooks ();
1003 bitmap_obstack_initialize (NULL
);
1004 execute_pass_list (all_lowering_passes
);
1005 free_dominance_info (CDI_POST_DOMINATORS
);
1006 free_dominance_info (CDI_DOMINATORS
);
1008 bitmap_obstack_release (NULL
);
1009 node
->lowered
= true;
1014 node
->analyzed
= true;
1016 current_function_decl
= save
;
1019 /* C++ frontend produce same body aliases all over the place, even before PCH
1020 gets streamed out. It relies on us linking the aliases with their function
1021 in order to do the fixups, but ipa-ref is not PCH safe. Consequentely we
1022 first produce aliases without links, but once C++ FE is sure he won't sream
1023 PCH we build the links via this function. */
1026 cgraph_process_same_body_aliases (void)
1028 struct cgraph_node
*node
;
1029 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1030 if (node
->same_body_alias
1031 && !VEC_length (ipa_ref_t
, node
->symbol
.ref_list
.references
))
1033 struct cgraph_node
*tgt
= cgraph_get_node (node
->thunk
.alias
);
1034 ipa_record_reference (node
, NULL
, tgt
, NULL
, IPA_REF_ALIAS
, NULL
);
1036 same_body_aliases_done
= true;
1039 /* Process attributes common for vars and functions. */
1042 process_common_attributes (tree decl
)
1044 tree weakref
= lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
));
1046 if (weakref
&& !lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)))
1048 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wattributes
,
1049 "%<weakref%> attribute should be accompanied with"
1050 " an %<alias%> attribute");
1051 DECL_WEAK (decl
) = 0;
1052 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
1053 DECL_ATTRIBUTES (decl
));
1057 /* Look for externally_visible and used attributes and mark cgraph nodes
1060 We cannot mark the nodes at the point the attributes are processed (in
1061 handle_*_attribute) because the copy of the declarations available at that
1062 point may not be canonical. For example, in:
1065 void f() __attribute__((used));
1067 the declaration we see in handle_used_attribute will be the second
1068 declaration -- but the front end will subsequently merge that declaration
1069 with the original declaration and discard the second declaration.
1071 Furthermore, we can't mark these nodes in cgraph_finalize_function because:
1074 void f() __attribute__((externally_visible));
1078 So, we walk the nodes at the end of the translation unit, applying the
1079 attributes at that point. */
1082 process_function_and_variable_attributes (struct cgraph_node
*first
,
1083 struct varpool_node
*first_var
)
1085 struct cgraph_node
*node
;
1086 struct varpool_node
*vnode
;
1088 for (node
= cgraph_nodes
; node
!= first
; node
= node
->next
)
1090 tree decl
= node
->symbol
.decl
;
1091 if (DECL_PRESERVE_P (decl
))
1092 cgraph_mark_needed_node (node
);
1093 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
1094 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl
))
1095 && TREE_PUBLIC (node
->symbol
.decl
))
1097 if (node
->local
.finalized
)
1098 cgraph_mark_needed_node (node
);
1100 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
1102 if (! TREE_PUBLIC (node
->symbol
.decl
))
1103 warning_at (DECL_SOURCE_LOCATION (node
->symbol
.decl
), OPT_Wattributes
,
1104 "%<externally_visible%>"
1105 " attribute have effect only on public objects");
1106 else if (node
->local
.finalized
)
1107 cgraph_mark_needed_node (node
);
1109 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
1110 && (node
->local
.finalized
&& !node
->alias
))
1112 warning_at (DECL_SOURCE_LOCATION (node
->symbol
.decl
), OPT_Wattributes
,
1113 "%<weakref%> attribute ignored"
1114 " because function is defined");
1115 DECL_WEAK (decl
) = 0;
1116 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
1117 DECL_ATTRIBUTES (decl
));
1120 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (decl
))
1121 && !DECL_DECLARED_INLINE_P (decl
)
1122 /* redefining extern inline function makes it DECL_UNINLINABLE. */
1123 && !DECL_UNINLINABLE (decl
))
1124 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wattributes
,
1125 "always_inline function might not be inlinable");
1127 process_common_attributes (decl
);
1129 for (vnode
= varpool_nodes
; vnode
!= first_var
; vnode
= vnode
->next
)
1131 tree decl
= vnode
->symbol
.decl
;
1132 if (DECL_PRESERVE_P (decl
))
1134 vnode
->force_output
= true;
1135 if (vnode
->finalized
)
1136 varpool_mark_needed_node (vnode
);
1138 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
1139 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl
))
1140 && TREE_PUBLIC (vnode
->symbol
.decl
))
1142 if (vnode
->finalized
)
1143 varpool_mark_needed_node (vnode
);
1145 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
1147 if (! TREE_PUBLIC (vnode
->symbol
.decl
))
1148 warning_at (DECL_SOURCE_LOCATION (vnode
->symbol
.decl
), OPT_Wattributes
,
1149 "%<externally_visible%>"
1150 " attribute have effect only on public objects");
1151 else if (vnode
->finalized
)
1152 varpool_mark_needed_node (vnode
);
1154 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
1156 && DECL_INITIAL (decl
))
1158 warning_at (DECL_SOURCE_LOCATION (vnode
->symbol
.decl
), OPT_Wattributes
,
1159 "%<weakref%> attribute ignored"
1160 " because variable is initialized");
1161 DECL_WEAK (decl
) = 0;
1162 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
1163 DECL_ATTRIBUTES (decl
));
1165 process_common_attributes (decl
);
1169 /* Process CGRAPH_NODES_NEEDED queue, analyze each function (and transitively
1170 each reachable functions) and build cgraph.
1171 The function can be called multiple times after inserting new nodes
1172 into beginning of queue. Just the new part of queue is re-scanned then. */
1175 cgraph_analyze_functions (void)
1177 /* Keep track of already processed nodes when called multiple times for
1178 intermodule optimization. */
1179 static struct cgraph_node
*first_analyzed
;
1180 struct cgraph_node
*first_processed
= first_analyzed
;
1181 static struct varpool_node
*first_analyzed_var
;
1182 struct cgraph_node
*node
, *next
;
1184 bitmap_obstack_initialize (NULL
);
1185 process_function_and_variable_attributes (first_processed
,
1186 first_analyzed_var
);
1187 first_processed
= cgraph_nodes
;
1188 first_analyzed_var
= varpool_nodes
;
1189 varpool_analyze_pending_decls ();
1190 if (cgraph_dump_file
)
1192 fprintf (cgraph_dump_file
, "Initial entry points:");
1193 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
1195 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1196 fprintf (cgraph_dump_file
, "\n");
1198 cgraph_process_new_functions ();
1200 /* Propagate reachability flag and lower representation of all reachable
1201 functions. In the future, lowering will introduce new functions and
1202 new entry points on the way (by template instantiation and virtual
1203 method table generation for instance). */
1204 while (cgraph_nodes_queue
)
1206 struct cgraph_edge
*edge
;
1207 tree decl
= cgraph_nodes_queue
->symbol
.decl
;
1209 node
= cgraph_nodes_queue
;
1210 x_cgraph_nodes_queue
= (symtab_node
)cgraph_nodes_queue
->next_needed
;
1211 node
->next_needed
= NULL
;
1213 /* ??? It is possible to create extern inline function and later using
1214 weak alias attribute to kill its body. See
1215 gcc.c-torture/compile/20011119-1.c */
1216 if (!DECL_STRUCT_FUNCTION (decl
)
1217 && (!node
->alias
|| !node
->thunk
.alias
)
1218 && !node
->thunk
.thunk_p
)
1220 cgraph_reset_node (node
);
1221 node
->local
.redefined_extern_inline
= true;
1225 if (!node
->analyzed
)
1226 cgraph_analyze_function (node
);
1228 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
1229 if (!edge
->callee
->reachable
)
1230 cgraph_mark_reachable_node (edge
->callee
);
1231 for (edge
= node
->callers
; edge
; edge
= edge
->next_caller
)
1232 if (!edge
->caller
->reachable
&& edge
->caller
->thunk
.thunk_p
)
1233 cgraph_mark_reachable_node (edge
->caller
);
1235 if (node
->symbol
.same_comdat_group
)
1237 for (next
= cgraph (node
->symbol
.same_comdat_group
);
1239 next
= cgraph (next
->symbol
.same_comdat_group
))
1240 cgraph_mark_reachable_node (next
);
1243 /* If decl is a clone of an abstract function, mark that abstract
1244 function so that we don't release its body. The DECL_INITIAL() of that
1245 abstract function declaration will be later needed to output debug
1247 if (DECL_ABSTRACT_ORIGIN (decl
))
1249 struct cgraph_node
*origin_node
;
1250 origin_node
= cgraph_get_node (DECL_ABSTRACT_ORIGIN (decl
));
1251 origin_node
->abstract_and_needed
= true;
1254 /* We finalize local static variables during constructing callgraph
1255 edges. Process their attributes too. */
1256 process_function_and_variable_attributes (first_processed
,
1257 first_analyzed_var
);
1258 first_processed
= cgraph_nodes
;
1259 first_analyzed_var
= varpool_nodes
;
1260 varpool_analyze_pending_decls ();
1261 cgraph_process_new_functions ();
1264 /* Collect entry points to the unit. */
1265 if (cgraph_dump_file
)
1267 fprintf (cgraph_dump_file
, "Unit entry points:");
1268 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
1270 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1271 fprintf (cgraph_dump_file
, "\n\nInitial ");
1272 dump_cgraph (cgraph_dump_file
);
1273 dump_varpool (cgraph_dump_file
);
1276 if (cgraph_dump_file
)
1277 fprintf (cgraph_dump_file
, "\nReclaiming functions:");
1279 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= next
)
1281 tree decl
= node
->symbol
.decl
;
1284 if (node
->local
.finalized
&& !gimple_has_body_p (decl
)
1285 && (!node
->alias
|| !node
->thunk
.alias
)
1286 && !node
->thunk
.thunk_p
)
1287 cgraph_reset_node (node
);
1289 if (!node
->reachable
1290 && (gimple_has_body_p (decl
) || node
->thunk
.thunk_p
1291 || (node
->alias
&& node
->thunk
.alias
)))
1293 if (cgraph_dump_file
)
1294 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1295 cgraph_remove_node (node
);
1299 node
->next_needed
= NULL
;
1300 gcc_assert (!node
->local
.finalized
|| node
->thunk
.thunk_p
1302 || gimple_has_body_p (decl
));
1303 gcc_assert (node
->analyzed
== node
->local
.finalized
);
1305 if (cgraph_dump_file
)
1307 fprintf (cgraph_dump_file
, "\n\nReclaimed ");
1308 dump_cgraph (cgraph_dump_file
);
1309 dump_varpool (cgraph_dump_file
);
1311 bitmap_obstack_release (NULL
);
1312 first_analyzed
= cgraph_nodes
;
1316 /* Translate the ugly representation of aliases as alias pairs into nice
1317 representation in callgraph. We don't handle all cases yet,
1321 handle_alias_pairs (void)
1325 struct cgraph_node
*target_node
;
1326 struct cgraph_node
*src_node
;
1327 struct varpool_node
*target_vnode
;
1329 for (i
= 0; VEC_iterate (alias_pair
, alias_pairs
, i
, p
);)
1331 if (TREE_CODE (p
->decl
) == FUNCTION_DECL
1332 && (target_node
= cgraph_node_for_asm (p
->target
)) != NULL
)
1334 src_node
= cgraph_get_node (p
->decl
);
1335 if (src_node
&& src_node
->local
.finalized
)
1336 cgraph_reset_node (src_node
);
1337 /* Normally EXTERNAL flag is used to mark external inlines,
1338 however for aliases it seems to be allowed to use it w/o
1339 any meaning. See gcc.dg/attr-alias-3.c
1340 However for weakref we insist on EXTERNAL flag being set.
1341 See gcc.dg/attr-alias-5.c */
1342 if (DECL_EXTERNAL (p
->decl
))
1343 DECL_EXTERNAL (p
->decl
)
1344 = lookup_attribute ("weakref",
1345 DECL_ATTRIBUTES (p
->decl
)) != NULL
;
1346 cgraph_create_function_alias (p
->decl
, target_node
->symbol
.decl
);
1347 VEC_unordered_remove (alias_pair
, alias_pairs
, i
);
1349 else if (TREE_CODE (p
->decl
) == VAR_DECL
1350 && (target_vnode
= varpool_node_for_asm (p
->target
)) != NULL
)
1352 /* Normally EXTERNAL flag is used to mark external inlines,
1353 however for aliases it seems to be allowed to use it w/o
1354 any meaning. See gcc.dg/attr-alias-3.c
1355 However for weakref we insist on EXTERNAL flag being set.
1356 See gcc.dg/attr-alias-5.c */
1357 if (DECL_EXTERNAL (p
->decl
))
1358 DECL_EXTERNAL (p
->decl
)
1359 = lookup_attribute ("weakref",
1360 DECL_ATTRIBUTES (p
->decl
)) != NULL
;
1361 varpool_create_variable_alias (p
->decl
, target_vnode
->symbol
.decl
);
1362 VEC_unordered_remove (alias_pair
, alias_pairs
, i
);
1364 /* Weakrefs with target not defined in current unit are easy to handle; they
1365 behave just as external variables except we need to note the alias flag
1366 to later output the weakref pseudo op into asm file. */
1367 else if (lookup_attribute ("weakref", DECL_ATTRIBUTES (p
->decl
)) != NULL
1368 && (TREE_CODE (p
->decl
) == FUNCTION_DECL
1369 ? (varpool_node_for_asm (p
->target
) == NULL
)
1370 : (cgraph_node_for_asm (p
->target
) == NULL
)))
1372 if (TREE_CODE (p
->decl
) == FUNCTION_DECL
)
1373 cgraph_get_create_node (p
->decl
)->alias
= true;
1375 varpool_get_node (p
->decl
)->alias
= true;
1376 DECL_EXTERNAL (p
->decl
) = 1;
1377 VEC_unordered_remove (alias_pair
, alias_pairs
, i
);
1382 fprintf (dump_file
, "Unhandled alias %s->%s\n",
1383 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (p
->decl
)),
1384 IDENTIFIER_POINTER (p
->target
));
1392 /* Figure out what functions we want to assemble. */
1395 cgraph_mark_functions_to_output (void)
1397 struct cgraph_node
*node
;
1398 #ifdef ENABLE_CHECKING
1399 bool check_same_comdat_groups
= false;
1401 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1402 gcc_assert (!node
->process
);
1405 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1407 tree decl
= node
->symbol
.decl
;
1408 struct cgraph_edge
*e
;
1410 gcc_assert (!node
->process
|| node
->symbol
.same_comdat_group
);
1414 for (e
= node
->callers
; e
; e
= e
->next_caller
)
1415 if (e
->inline_failed
)
1418 /* We need to output all local functions that are used and not
1419 always inlined, as well as those that are reachable from
1420 outside the current compilation unit. */
1422 && !node
->thunk
.thunk_p
1424 && !node
->global
.inlined_to
1425 && (!cgraph_only_called_directly_p (node
)
1426 || ((e
|| ipa_ref_has_aliases_p (&node
->symbol
.ref_list
))
1427 && node
->reachable
))
1428 && !TREE_ASM_WRITTEN (decl
)
1429 && !DECL_EXTERNAL (decl
))
1432 if (node
->symbol
.same_comdat_group
)
1434 struct cgraph_node
*next
;
1435 for (next
= cgraph (node
->symbol
.same_comdat_group
);
1437 next
= cgraph (next
->symbol
.same_comdat_group
))
1438 if (!next
->thunk
.thunk_p
&& !next
->alias
)
1442 else if (node
->symbol
.same_comdat_group
)
1444 #ifdef ENABLE_CHECKING
1445 check_same_comdat_groups
= true;
1450 /* We should've reclaimed all functions that are not needed. */
1451 #ifdef ENABLE_CHECKING
1452 if (!node
->global
.inlined_to
1453 && gimple_has_body_p (decl
)
1454 /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
1455 are inside partition, we can end up not removing the body since we no longer
1456 have analyzed node pointing to it. */
1457 && !node
->symbol
.in_other_partition
1459 && !DECL_EXTERNAL (decl
))
1461 dump_cgraph_node (stderr
, node
);
1462 internal_error ("failed to reclaim unneeded function");
1465 gcc_assert (node
->global
.inlined_to
1466 || !gimple_has_body_p (decl
)
1467 || node
->symbol
.in_other_partition
1468 || DECL_EXTERNAL (decl
));
1473 #ifdef ENABLE_CHECKING
1474 if (check_same_comdat_groups
)
1475 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1476 if (node
->symbol
.same_comdat_group
&& !node
->process
)
1478 tree decl
= node
->symbol
.decl
;
1479 if (!node
->global
.inlined_to
1480 && gimple_has_body_p (decl
)
1481 /* FIXME: in an ltrans unit when the offline copy is outside a
1482 partition but inline copies are inside a partition, we can
1483 end up not removing the body since we no longer have an
1484 analyzed node pointing to it. */
1485 && !node
->symbol
.in_other_partition
1486 && !DECL_EXTERNAL (decl
))
1488 dump_cgraph_node (stderr
, node
);
1489 internal_error ("failed to reclaim unneeded function in same "
1496 /* DECL is FUNCTION_DECL. Initialize datastructures so DECL is a function
1497 in lowered gimple form.
1499 Set current_function_decl and cfun to newly constructed empty function body.
1500 return basic block in the function body. */
1503 init_lowered_empty_function (tree decl
)
1507 current_function_decl
= decl
;
1508 allocate_struct_function (decl
, false);
1509 gimple_register_cfg_hooks ();
1510 init_empty_tree_cfg ();
1511 init_tree_ssa (cfun
);
1512 init_ssa_operands ();
1513 cfun
->gimple_df
->in_ssa_p
= true;
1514 DECL_INITIAL (decl
) = make_node (BLOCK
);
1516 DECL_SAVED_TREE (decl
) = error_mark_node
;
1517 cfun
->curr_properties
|=
1518 (PROP_gimple_lcf
| PROP_gimple_leh
| PROP_cfg
| PROP_referenced_vars
|
1519 PROP_ssa
| PROP_gimple_any
);
1521 /* Create BB for body of the function and connect it properly. */
1522 bb
= create_basic_block (NULL
, (void *) 0, ENTRY_BLOCK_PTR
);
1523 make_edge (ENTRY_BLOCK_PTR
, bb
, 0);
1524 make_edge (bb
, EXIT_BLOCK_PTR
, 0);
1529 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
1530 offset indicated by VIRTUAL_OFFSET, if that is
1531 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
1532 zero for a result adjusting thunk. */
1535 thunk_adjust (gimple_stmt_iterator
* bsi
,
1536 tree ptr
, bool this_adjusting
,
1537 HOST_WIDE_INT fixed_offset
, tree virtual_offset
)
1543 && fixed_offset
!= 0)
1545 stmt
= gimple_build_assign
1546 (ptr
, fold_build_pointer_plus_hwi_loc (input_location
,
1549 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1552 /* If there's a virtual offset, look up that value in the vtable and
1553 adjust the pointer again. */
1560 if (!vtable_entry_type
)
1562 tree vfunc_type
= make_node (FUNCTION_TYPE
);
1563 TREE_TYPE (vfunc_type
) = integer_type_node
;
1564 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
1565 layout_type (vfunc_type
);
1567 vtable_entry_type
= build_pointer_type (vfunc_type
);
1571 create_tmp_var (build_pointer_type
1572 (build_pointer_type (vtable_entry_type
)), "vptr");
1574 /* The vptr is always at offset zero in the object. */
1575 stmt
= gimple_build_assign (vtabletmp
,
1576 build1 (NOP_EXPR
, TREE_TYPE (vtabletmp
),
1578 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1579 mark_symbols_for_renaming (stmt
);
1580 find_referenced_vars_in (stmt
);
1582 /* Form the vtable address. */
1583 vtabletmp2
= create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp
)),
1585 stmt
= gimple_build_assign (vtabletmp2
,
1586 build_simple_mem_ref (vtabletmp
));
1587 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1588 mark_symbols_for_renaming (stmt
);
1589 find_referenced_vars_in (stmt
);
1591 /* Find the entry with the vcall offset. */
1592 stmt
= gimple_build_assign (vtabletmp2
,
1593 fold_build_pointer_plus_loc (input_location
,
1596 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1598 /* Get the offset itself. */
1599 vtabletmp3
= create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp2
)),
1601 stmt
= gimple_build_assign (vtabletmp3
,
1602 build_simple_mem_ref (vtabletmp2
));
1603 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1604 mark_symbols_for_renaming (stmt
);
1605 find_referenced_vars_in (stmt
);
1607 /* Adjust the `this' pointer. */
1608 ptr
= fold_build_pointer_plus_loc (input_location
, ptr
, vtabletmp3
);
1609 ptr
= force_gimple_operand_gsi (bsi
, ptr
, true, NULL_TREE
, false,
1610 GSI_CONTINUE_LINKING
);
1614 && fixed_offset
!= 0)
1615 /* Adjust the pointer by the constant. */
1619 if (TREE_CODE (ptr
) == VAR_DECL
)
1623 ptrtmp
= create_tmp_var (TREE_TYPE (ptr
), "ptr");
1624 stmt
= gimple_build_assign (ptrtmp
, ptr
);
1625 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1626 mark_symbols_for_renaming (stmt
);
1627 find_referenced_vars_in (stmt
);
1629 ptr
= fold_build_pointer_plus_hwi_loc (input_location
,
1630 ptrtmp
, fixed_offset
);
1633 /* Emit the statement and gimplify the adjustment expression. */
1634 ret
= create_tmp_var (TREE_TYPE (ptr
), "adjusted_this");
1635 stmt
= gimple_build_assign (ret
, ptr
);
1636 mark_symbols_for_renaming (stmt
);
1637 find_referenced_vars_in (stmt
);
1638 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1643 /* Produce assembler for thunk NODE. */
1646 assemble_thunk (struct cgraph_node
*node
)
1648 bool this_adjusting
= node
->thunk
.this_adjusting
;
1649 HOST_WIDE_INT fixed_offset
= node
->thunk
.fixed_offset
;
1650 HOST_WIDE_INT virtual_value
= node
->thunk
.virtual_value
;
1651 tree virtual_offset
= NULL
;
1652 tree alias
= node
->thunk
.alias
;
1653 tree thunk_fndecl
= node
->symbol
.decl
;
1654 tree a
= DECL_ARGUMENTS (thunk_fndecl
);
1656 current_function_decl
= thunk_fndecl
;
1658 /* Ensure thunks are emitted in their correct sections. */
1659 resolve_unique_section (thunk_fndecl
, 0, flag_function_sections
);
1662 && targetm
.asm_out
.can_output_mi_thunk (thunk_fndecl
, fixed_offset
,
1663 virtual_value
, alias
))
1667 tree restype
= TREE_TYPE (TREE_TYPE (thunk_fndecl
));
1669 DECL_RESULT (thunk_fndecl
)
1670 = build_decl (DECL_SOURCE_LOCATION (thunk_fndecl
),
1671 RESULT_DECL
, 0, restype
);
1672 fnname
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk_fndecl
));
1674 /* The back end expects DECL_INITIAL to contain a BLOCK, so we
1676 fn_block
= make_node (BLOCK
);
1677 BLOCK_VARS (fn_block
) = a
;
1678 DECL_INITIAL (thunk_fndecl
) = fn_block
;
1679 init_function_start (thunk_fndecl
);
1681 assemble_start_function (thunk_fndecl
, fnname
);
1683 targetm
.asm_out
.output_mi_thunk (asm_out_file
, thunk_fndecl
,
1684 fixed_offset
, virtual_value
, alias
);
1686 assemble_end_function (thunk_fndecl
, fnname
);
1687 init_insn_lengths ();
1688 free_after_compilation (cfun
);
1690 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
1691 node
->thunk
.thunk_p
= false;
1692 node
->analyzed
= false;
1697 basic_block bb
, then_bb
, else_bb
, return_bb
;
1698 gimple_stmt_iterator bsi
;
1704 VEC(tree
, heap
) *vargs
;
1709 DECL_IGNORED_P (thunk_fndecl
) = 1;
1710 bitmap_obstack_initialize (NULL
);
1712 if (node
->thunk
.virtual_offset_p
)
1713 virtual_offset
= size_int (virtual_value
);
1715 /* Build the return declaration for the function. */
1716 restype
= TREE_TYPE (TREE_TYPE (thunk_fndecl
));
1717 if (DECL_RESULT (thunk_fndecl
) == NULL_TREE
)
1719 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
1720 DECL_ARTIFICIAL (resdecl
) = 1;
1721 DECL_IGNORED_P (resdecl
) = 1;
1722 DECL_RESULT (thunk_fndecl
) = resdecl
;
1725 resdecl
= DECL_RESULT (thunk_fndecl
);
1727 bb
= then_bb
= else_bb
= return_bb
= init_lowered_empty_function (thunk_fndecl
);
1729 bsi
= gsi_start_bb (bb
);
1731 /* Build call to the function being thunked. */
1732 if (!VOID_TYPE_P (restype
))
1734 if (!is_gimple_reg_type (restype
))
1737 add_local_decl (cfun
, restmp
);
1738 BLOCK_VARS (DECL_INITIAL (current_function_decl
)) = restmp
;
1741 restmp
= create_tmp_var_raw (restype
, "retval");
1744 for (arg
= a
; arg
; arg
= DECL_CHAIN (arg
))
1746 vargs
= VEC_alloc (tree
, heap
, nargs
);
1748 VEC_quick_push (tree
, vargs
,
1753 VEC_quick_push (tree
, vargs
, a
);
1754 for (i
= 1, arg
= DECL_CHAIN (a
); i
< nargs
; i
++, arg
= DECL_CHAIN (arg
))
1755 VEC_quick_push (tree
, vargs
, arg
);
1756 call
= gimple_build_call_vec (build_fold_addr_expr_loc (0, alias
), vargs
);
1757 VEC_free (tree
, heap
, vargs
);
1758 gimple_call_set_from_thunk (call
, true);
1760 gimple_call_set_lhs (call
, restmp
);
1761 gsi_insert_after (&bsi
, call
, GSI_NEW_STMT
);
1762 mark_symbols_for_renaming (call
);
1763 find_referenced_vars_in (call
);
1766 if (restmp
&& !this_adjusting
)
1768 tree true_label
= NULL_TREE
;
1770 if (TREE_CODE (TREE_TYPE (restmp
)) == POINTER_TYPE
)
1773 /* If the return type is a pointer, we need to
1774 protect against NULL. We know there will be an
1775 adjustment, because that's why we're emitting a
1777 then_bb
= create_basic_block (NULL
, (void *) 0, bb
);
1778 return_bb
= create_basic_block (NULL
, (void *) 0, then_bb
);
1779 else_bb
= create_basic_block (NULL
, (void *) 0, else_bb
);
1780 remove_edge (single_succ_edge (bb
));
1781 true_label
= gimple_block_label (then_bb
);
1782 stmt
= gimple_build_cond (NE_EXPR
, restmp
,
1783 build_zero_cst (TREE_TYPE (restmp
)),
1784 NULL_TREE
, NULL_TREE
);
1785 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1786 make_edge (bb
, then_bb
, EDGE_TRUE_VALUE
);
1787 make_edge (bb
, else_bb
, EDGE_FALSE_VALUE
);
1788 make_edge (return_bb
, EXIT_BLOCK_PTR
, 0);
1789 make_edge (then_bb
, return_bb
, EDGE_FALLTHRU
);
1790 make_edge (else_bb
, return_bb
, EDGE_FALLTHRU
);
1791 bsi
= gsi_last_bb (then_bb
);
1794 restmp
= thunk_adjust (&bsi
, restmp
, /*this_adjusting=*/0,
1795 fixed_offset
, virtual_offset
);
1799 bsi
= gsi_last_bb (else_bb
);
1800 stmt
= gimple_build_assign (restmp
,
1801 build_zero_cst (TREE_TYPE (restmp
)));
1802 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1803 bsi
= gsi_last_bb (return_bb
);
1807 gimple_call_set_tail (call
, true);
1809 /* Build return value. */
1810 ret
= gimple_build_return (restmp
);
1811 gsi_insert_after (&bsi
, ret
, GSI_NEW_STMT
);
1813 delete_unreachable_blocks ();
1814 update_ssa (TODO_update_ssa
);
1816 /* Since we want to emit the thunk, we explicitly mark its name as
1818 node
->thunk
.thunk_p
= false;
1819 cgraph_node_remove_callees (node
);
1820 cgraph_add_new_function (thunk_fndecl
, true);
1821 bitmap_obstack_release (NULL
);
1823 current_function_decl
= NULL
;
1828 /* Assemble thunks and aliases asociated to NODE. */
1831 assemble_thunks_and_aliases (struct cgraph_node
*node
)
1833 struct cgraph_edge
*e
;
1835 struct ipa_ref
*ref
;
1837 for (e
= node
->callers
; e
;)
1838 if (e
->caller
->thunk
.thunk_p
)
1840 struct cgraph_node
*thunk
= e
->caller
;
1843 assemble_thunks_and_aliases (thunk
);
1844 assemble_thunk (thunk
);
1848 for (i
= 0; ipa_ref_list_refering_iterate (&node
->symbol
.ref_list
,
1850 if (ref
->use
== IPA_REF_ALIAS
)
1852 struct cgraph_node
*alias
= ipa_ref_refering_node (ref
);
1853 bool saved_written
= TREE_ASM_WRITTEN (alias
->thunk
.alias
);
1855 /* Force assemble_alias to really output the alias this time instead
1856 of buffering it in same alias pairs. */
1857 TREE_ASM_WRITTEN (alias
->thunk
.alias
) = 1;
1858 assemble_alias (alias
->symbol
.decl
,
1859 DECL_ASSEMBLER_NAME (alias
->thunk
.alias
));
1860 assemble_thunks_and_aliases (alias
);
1861 TREE_ASM_WRITTEN (alias
->thunk
.alias
) = saved_written
;
1865 /* Perform IPA transforms and all further optimizations and compilation
1869 tree_rest_of_compilation (struct cgraph_node
*node
)
1871 tree fndecl
= node
->symbol
.decl
;
1872 location_t saved_loc
;
1874 timevar_push (TV_REST_OF_COMPILATION
);
1876 gcc_assert (cgraph_global_info_ready
);
1878 /* Initialize the default bitmap obstack. */
1879 bitmap_obstack_initialize (NULL
);
1881 /* Initialize the RTL code for the function. */
1882 current_function_decl
= fndecl
;
1883 saved_loc
= input_location
;
1884 input_location
= DECL_SOURCE_LOCATION (fndecl
);
1885 init_function_start (fndecl
);
1887 gimple_register_cfg_hooks ();
1889 bitmap_obstack_initialize (®_obstack
); /* FIXME, only at RTL generation*/
1891 execute_all_ipa_transforms ();
1893 /* Perform all tree transforms and optimizations. */
1895 /* Signal the start of passes. */
1896 invoke_plugin_callbacks (PLUGIN_ALL_PASSES_START
, NULL
);
1898 execute_pass_list (all_passes
);
1900 /* Signal the end of passes. */
1901 invoke_plugin_callbacks (PLUGIN_ALL_PASSES_END
, NULL
);
1903 bitmap_obstack_release (®_obstack
);
1905 /* Release the default bitmap obstack. */
1906 bitmap_obstack_release (NULL
);
1910 /* If requested, warn about function definitions where the function will
1911 return a value (usually of some struct or union type) which itself will
1912 take up a lot of stack space. */
1913 if (warn_larger_than
&& !DECL_EXTERNAL (fndecl
) && TREE_TYPE (fndecl
))
1915 tree ret_type
= TREE_TYPE (TREE_TYPE (fndecl
));
1917 if (ret_type
&& TYPE_SIZE_UNIT (ret_type
)
1918 && TREE_CODE (TYPE_SIZE_UNIT (ret_type
)) == INTEGER_CST
1919 && 0 < compare_tree_int (TYPE_SIZE_UNIT (ret_type
),
1922 unsigned int size_as_int
1923 = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (ret_type
));
1925 if (compare_tree_int (TYPE_SIZE_UNIT (ret_type
), size_as_int
) == 0)
1926 warning (OPT_Wlarger_than_
, "size of return value of %q+D is %u bytes",
1927 fndecl
, size_as_int
);
1929 warning (OPT_Wlarger_than_
, "size of return value of %q+D is larger than %wd bytes",
1930 fndecl
, larger_than_size
);
1934 gimple_set_body (fndecl
, NULL
);
1935 if (DECL_STRUCT_FUNCTION (fndecl
) == 0
1936 && !cgraph_get_node (fndecl
)->origin
)
1938 /* Stop pointing to the local nodes about to be freed.
1939 But DECL_INITIAL must remain nonzero so we know this
1940 was an actual function definition.
1941 For a nested function, this is done in c_pop_function_context.
1942 If rest_of_compilation set this to 0, leave it 0. */
1943 if (DECL_INITIAL (fndecl
) != 0)
1944 DECL_INITIAL (fndecl
) = error_mark_node
;
1947 input_location
= saved_loc
;
1950 timevar_pop (TV_REST_OF_COMPILATION
);
1953 /* Expand function specified by NODE. */
1956 cgraph_expand_function (struct cgraph_node
*node
)
1958 tree decl
= node
->symbol
.decl
;
1960 /* We ought to not compile any inline clones. */
1961 gcc_assert (!node
->global
.inlined_to
);
1963 announce_function (decl
);
1965 gcc_assert (node
->lowered
);
1967 /* Generate RTL for the body of DECL. */
1968 tree_rest_of_compilation (node
);
1970 /* Make sure that BE didn't give up on compiling. */
1971 gcc_assert (TREE_ASM_WRITTEN (decl
));
1972 current_function_decl
= NULL
;
1973 gcc_assert (!cgraph_preserve_function_body_p (node
));
1975 /* It would make a lot more sense to output thunks before function body to get more
1976 forward and lest backwarding jumps. This is however would need solving problem
1977 with comdats. See PR48668. Also aliases must come after function itself to
1978 make one pass assemblers, like one on AIX happy. See PR 50689.
1979 FIXME: Perhaps thunks should be move before function IFF they are not in comdat
1981 assemble_thunks_and_aliases (node
);
1982 cgraph_release_function_body (node
);
1983 /* Eliminate all call edges. This is important so the GIMPLE_CALL no longer
1984 points to the dead function body. */
1985 cgraph_node_remove_callees (node
);
1988 /* Return true when CALLER_DECL should be inlined into CALLEE_DECL. */
1991 cgraph_inline_p (struct cgraph_edge
*e
, cgraph_inline_failed_t
*reason
)
1993 *reason
= e
->inline_failed
;
1994 return !e
->inline_failed
;
1999 /* Expand all functions that must be output.
2001 Attempt to topologically sort the nodes so function is output when
2002 all called functions are already assembled to allow data to be
2003 propagated across the callgraph. Use a stack to get smaller distance
2004 between a function and its callees (later we may choose to use a more
2005 sophisticated algorithm for function reordering; we will likely want
2006 to use subsections to make the output functions appear in top-down
2010 cgraph_expand_all_functions (void)
2012 struct cgraph_node
*node
;
2013 struct cgraph_node
**order
= XCNEWVEC (struct cgraph_node
*, cgraph_n_nodes
);
2014 int order_pos
, new_order_pos
= 0;
2017 order_pos
= ipa_reverse_postorder (order
);
2018 gcc_assert (order_pos
== cgraph_n_nodes
);
2020 /* Garbage collector may remove inline clones we eliminate during
2021 optimization. So we must be sure to not reference them. */
2022 for (i
= 0; i
< order_pos
; i
++)
2023 if (order
[i
]->process
)
2024 order
[new_order_pos
++] = order
[i
];
2026 for (i
= new_order_pos
- 1; i
>= 0; i
--)
2031 gcc_assert (node
->reachable
);
2033 cgraph_expand_function (node
);
2036 cgraph_process_new_functions ();
2042 /* This is used to sort the node types by the cgraph order number. */
2044 enum cgraph_order_sort_kind
2046 ORDER_UNDEFINED
= 0,
2052 struct cgraph_order_sort
2054 enum cgraph_order_sort_kind kind
;
2057 struct cgraph_node
*f
;
2058 struct varpool_node
*v
;
2059 struct cgraph_asm_node
*a
;
2063 /* Output all functions, variables, and asm statements in the order
2064 according to their order fields, which is the order in which they
2065 appeared in the file. This implements -fno-toplevel-reorder. In
2066 this mode we may output functions and variables which don't really
2067 need to be output. */
2070 cgraph_output_in_order (void)
2073 struct cgraph_order_sort
*nodes
;
2075 struct cgraph_node
*pf
;
2076 struct varpool_node
*pv
;
2077 struct cgraph_asm_node
*pa
;
2080 nodes
= XCNEWVEC (struct cgraph_order_sort
, max
);
2082 varpool_analyze_pending_decls ();
2084 for (pf
= cgraph_nodes
; pf
; pf
= pf
->next
)
2086 if (pf
->process
&& !pf
->thunk
.thunk_p
&& !pf
->alias
)
2088 i
= pf
->symbol
.order
;
2089 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
2090 nodes
[i
].kind
= ORDER_FUNCTION
;
2095 for (pv
= varpool_nodes_queue
; pv
; pv
= pv
->next_needed
)
2097 i
= pv
->symbol
.order
;
2098 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
2099 nodes
[i
].kind
= ORDER_VAR
;
2103 for (pa
= cgraph_asm_nodes
; pa
; pa
= pa
->next
)
2106 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
2107 nodes
[i
].kind
= ORDER_ASM
;
2111 /* In toplevel reorder mode we output all statics; mark them as needed. */
2112 for (i
= 0; i
< max
; ++i
)
2114 if (nodes
[i
].kind
== ORDER_VAR
)
2116 varpool_mark_needed_node (nodes
[i
].u
.v
);
2119 varpool_empty_needed_queue ();
2121 for (i
= 0; i
< max
; ++i
)
2122 if (nodes
[i
].kind
== ORDER_VAR
)
2123 varpool_finalize_named_section_flags (nodes
[i
].u
.v
);
2125 for (i
= 0; i
< max
; ++i
)
2127 switch (nodes
[i
].kind
)
2129 case ORDER_FUNCTION
:
2130 nodes
[i
].u
.f
->process
= 0;
2131 cgraph_expand_function (nodes
[i
].u
.f
);
2135 varpool_assemble_decl (nodes
[i
].u
.v
);
2139 assemble_asm (nodes
[i
].u
.a
->asm_str
);
2142 case ORDER_UNDEFINED
:
2150 cgraph_asm_nodes
= NULL
;
2154 /* Return true when function body of DECL still needs to be kept around
2155 for later re-use. */
2157 cgraph_preserve_function_body_p (struct cgraph_node
*node
)
2159 gcc_assert (cgraph_global_info_ready
);
2160 gcc_assert (!node
->alias
&& !node
->thunk
.thunk_p
);
2162 /* Look if there is any clone around. */
2172 current_function_decl
= NULL
;
2173 gimple_register_cfg_hooks ();
2174 bitmap_obstack_initialize (NULL
);
2176 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_START
, NULL
);
2180 execute_ipa_pass_list (all_small_ipa_passes
);
2185 /* We never run removal of unreachable nodes after early passes. This is
2186 because TODO is run before the subpasses. It is important to remove
2187 the unreachable functions to save works at IPA level and to get LTO
2188 symbol tables right. */
2189 cgraph_remove_unreachable_nodes (true, cgraph_dump_file
);
2191 /* If pass_all_early_optimizations was not scheduled, the state of
2192 the cgraph will not be properly updated. Update it now. */
2193 if (cgraph_state
< CGRAPH_STATE_IPA_SSA
)
2194 cgraph_state
= CGRAPH_STATE_IPA_SSA
;
2198 /* Generate coverage variables and constructors. */
2201 /* Process new functions added. */
2203 current_function_decl
= NULL
;
2204 cgraph_process_new_functions ();
2206 execute_ipa_summary_passes
2207 ((struct ipa_opt_pass_d
*) all_regular_ipa_passes
);
2210 /* Some targets need to handle LTO assembler output specially. */
2211 if (flag_generate_lto
)
2212 targetm
.asm_out
.lto_start ();
2214 execute_ipa_summary_passes ((struct ipa_opt_pass_d
*) all_lto_gen_passes
);
2217 ipa_write_summaries ();
2219 if (flag_generate_lto
)
2220 targetm
.asm_out
.lto_end ();
2222 if (!flag_ltrans
&& (in_lto_p
|| !flag_lto
|| flag_fat_lto_objects
))
2223 execute_ipa_pass_list (all_regular_ipa_passes
);
2224 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_END
, NULL
);
2226 bitmap_obstack_release (NULL
);
2230 /* Return string alias is alias of. */
2233 get_alias_symbol (tree decl
)
2235 tree alias
= lookup_attribute ("alias", DECL_ATTRIBUTES (decl
));
2236 return get_identifier (TREE_STRING_POINTER
2237 (TREE_VALUE (TREE_VALUE (alias
))));
2241 /* Weakrefs may be associated to external decls and thus not output
2242 at expansion time. Emit all neccesary aliases. */
2245 output_weakrefs (void)
2247 struct cgraph_node
*node
;
2248 struct varpool_node
*vnode
;
2249 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2250 if (node
->alias
&& DECL_EXTERNAL (node
->symbol
.decl
)
2251 && !TREE_ASM_WRITTEN (node
->symbol
.decl
)
2252 && lookup_attribute ("weakref", DECL_ATTRIBUTES (node
->symbol
.decl
)))
2253 assemble_alias (node
->symbol
.decl
,
2254 node
->thunk
.alias
? DECL_ASSEMBLER_NAME (node
->thunk
.alias
)
2255 : get_alias_symbol (node
->symbol
.decl
));
2256 for (vnode
= varpool_nodes
; vnode
; vnode
= vnode
->next
)
2257 if (vnode
->alias
&& DECL_EXTERNAL (vnode
->symbol
.decl
)
2258 && !TREE_ASM_WRITTEN (vnode
->symbol
.decl
)
2259 && lookup_attribute ("weakref", DECL_ATTRIBUTES (vnode
->symbol
.decl
)))
2260 assemble_alias (vnode
->symbol
.decl
,
2261 vnode
->alias_of
? DECL_ASSEMBLER_NAME (vnode
->alias_of
)
2262 : get_alias_symbol (vnode
->symbol
.decl
));
2270 if (!cgraph_dump_file
)
2271 cgraph_dump_file
= dump_begin (TDI_cgraph
, NULL
);
2274 /* The edges representing the callers of the NEW_VERSION node were
2275 fixed by cgraph_function_versioning (), now the call_expr in their
2276 respective tree code should be updated to call the NEW_VERSION. */
2279 update_call_expr (struct cgraph_node
*new_version
)
2281 struct cgraph_edge
*e
;
2283 gcc_assert (new_version
);
2285 /* Update the call expr on the edges to call the new version. */
2286 for (e
= new_version
->callers
; e
; e
= e
->next_caller
)
2288 struct function
*inner_function
= DECL_STRUCT_FUNCTION (e
->caller
->symbol
.decl
);
2289 gimple_call_set_fndecl (e
->call_stmt
, new_version
->symbol
.decl
);
2290 maybe_clean_eh_stmt_fn (inner_function
, e
->call_stmt
);
2295 /* Create a new cgraph node which is the new version of
2296 OLD_VERSION node. REDIRECT_CALLERS holds the callers
2297 edges which should be redirected to point to
2298 NEW_VERSION. ALL the callees edges of OLD_VERSION
2299 are cloned to the new version node. Return the new
2302 If non-NULL BLOCK_TO_COPY determine what basic blocks
2303 was copied to prevent duplications of calls that are dead
2306 struct cgraph_node
*
2307 cgraph_copy_node_for_versioning (struct cgraph_node
*old_version
,
2309 VEC(cgraph_edge_p
,heap
) *redirect_callers
,
2312 struct cgraph_node
*new_version
;
2313 struct cgraph_edge
*e
;
2316 gcc_assert (old_version
);
2318 new_version
= cgraph_create_node (new_decl
);
2320 new_version
->analyzed
= old_version
->analyzed
;
2321 new_version
->local
= old_version
->local
;
2322 new_version
->symbol
.externally_visible
= false;
2323 new_version
->local
.local
= true;
2324 new_version
->global
= old_version
->global
;
2325 new_version
->rtl
= old_version
->rtl
;
2326 new_version
->reachable
= true;
2327 new_version
->count
= old_version
->count
;
2329 for (e
= old_version
->callees
; e
; e
=e
->next_callee
)
2331 || bitmap_bit_p (bbs_to_copy
, gimple_bb (e
->call_stmt
)->index
))
2332 cgraph_clone_edge (e
, new_version
, e
->call_stmt
,
2333 e
->lto_stmt_uid
, REG_BR_PROB_BASE
,
2336 for (e
= old_version
->indirect_calls
; e
; e
=e
->next_callee
)
2338 || bitmap_bit_p (bbs_to_copy
, gimple_bb (e
->call_stmt
)->index
))
2339 cgraph_clone_edge (e
, new_version
, e
->call_stmt
,
2340 e
->lto_stmt_uid
, REG_BR_PROB_BASE
,
2343 FOR_EACH_VEC_ELT (cgraph_edge_p
, redirect_callers
, i
, e
)
2345 /* Redirect calls to the old version node to point to its new
2347 cgraph_redirect_edge_callee (e
, new_version
);
2350 cgraph_call_node_duplication_hooks (old_version
, new_version
);
2355 /* Perform function versioning.
2356 Function versioning includes copying of the tree and
2357 a callgraph update (creating a new cgraph node and updating
2358 its callees and callers).
2360 REDIRECT_CALLERS varray includes the edges to be redirected
2363 TREE_MAP is a mapping of tree nodes we want to replace with
2364 new ones (according to results of prior analysis).
2365 OLD_VERSION_NODE is the node that is versioned.
2367 If non-NULL ARGS_TO_SKIP determine function parameters to remove
2369 If SKIP_RETURN is true, the new version will return void.
2370 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
2371 If non_NULL NEW_ENTRY determine new entry BB of the clone.
2373 Return the new version's cgraph node. */
2375 struct cgraph_node
*
2376 cgraph_function_versioning (struct cgraph_node
*old_version_node
,
2377 VEC(cgraph_edge_p
,heap
) *redirect_callers
,
2378 VEC (ipa_replace_map_p
,gc
)* tree_map
,
2379 bitmap args_to_skip
,
2382 basic_block new_entry_block
,
2383 const char *clone_name
)
2385 tree old_decl
= old_version_node
->symbol
.decl
;
2386 struct cgraph_node
*new_version_node
= NULL
;
2389 if (!tree_versionable_function_p (old_decl
))
2392 gcc_assert (old_version_node
->local
.can_change_signature
|| !args_to_skip
);
2394 /* Make a new FUNCTION_DECL tree node for the new version. */
2395 if (!args_to_skip
&& !skip_return
)
2396 new_decl
= copy_node (old_decl
);
2399 = build_function_decl_skip_args (old_decl
, args_to_skip
, skip_return
);
2401 /* Generate a new name for the new version. */
2402 DECL_NAME (new_decl
) = clone_function_name (old_decl
, clone_name
);
2403 SET_DECL_ASSEMBLER_NAME (new_decl
, DECL_NAME (new_decl
));
2404 SET_DECL_RTL (new_decl
, NULL
);
2406 /* When the old decl was a con-/destructor make sure the clone isn't. */
2407 DECL_STATIC_CONSTRUCTOR(new_decl
) = 0;
2408 DECL_STATIC_DESTRUCTOR(new_decl
) = 0;
2410 /* Create the new version's call-graph node.
2411 and update the edges of the new node. */
2413 cgraph_copy_node_for_versioning (old_version_node
, new_decl
,
2414 redirect_callers
, bbs_to_copy
);
2416 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2417 tree_function_versioning (old_decl
, new_decl
, tree_map
, false, args_to_skip
,
2418 skip_return
, bbs_to_copy
, new_entry_block
);
2420 /* Update the new version's properties.
2421 Make The new version visible only within this translation unit. Make sure
2422 that is not weak also.
2423 ??? We cannot use COMDAT linkage because there is no
2424 ABI support for this. */
2425 cgraph_make_decl_local (new_version_node
->symbol
.decl
);
2426 DECL_VIRTUAL_P (new_version_node
->symbol
.decl
) = 0;
2427 new_version_node
->symbol
.externally_visible
= 0;
2428 new_version_node
->local
.local
= 1;
2429 new_version_node
->lowered
= true;
2431 /* Update the call_expr on the edges to call the new version node. */
2432 update_call_expr (new_version_node
);
2434 cgraph_call_function_insertion_hooks (new_version_node
);
2435 return new_version_node
;
2438 /* Given virtual clone, turn it into actual clone. */
2440 cgraph_materialize_clone (struct cgraph_node
*node
)
2442 bitmap_obstack_initialize (NULL
);
2443 node
->former_clone_of
= node
->clone_of
->symbol
.decl
;
2444 if (node
->clone_of
->former_clone_of
)
2445 node
->former_clone_of
= node
->clone_of
->former_clone_of
;
2446 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2447 tree_function_versioning (node
->clone_of
->symbol
.decl
, node
->symbol
.decl
,
2448 node
->clone
.tree_map
, true,
2449 node
->clone
.args_to_skip
, false,
2451 if (cgraph_dump_file
)
2453 dump_function_to_file (node
->clone_of
->symbol
.decl
, cgraph_dump_file
, dump_flags
);
2454 dump_function_to_file (node
->symbol
.decl
, cgraph_dump_file
, dump_flags
);
2457 /* Function is no longer clone. */
2458 if (node
->next_sibling_clone
)
2459 node
->next_sibling_clone
->prev_sibling_clone
= node
->prev_sibling_clone
;
2460 if (node
->prev_sibling_clone
)
2461 node
->prev_sibling_clone
->next_sibling_clone
= node
->next_sibling_clone
;
2463 node
->clone_of
->clones
= node
->next_sibling_clone
;
2464 node
->next_sibling_clone
= NULL
;
2465 node
->prev_sibling_clone
= NULL
;
2466 if (!node
->clone_of
->analyzed
&& !node
->clone_of
->clones
)
2468 cgraph_release_function_body (node
->clone_of
);
2469 cgraph_node_remove_callees (node
->clone_of
);
2470 ipa_remove_all_references (&node
->clone_of
->symbol
.ref_list
);
2472 node
->clone_of
= NULL
;
2473 bitmap_obstack_release (NULL
);
2476 /* If necessary, change the function declaration in the call statement
2477 associated with E so that it corresponds to the edge callee. */
2480 cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge
*e
)
2482 tree decl
= gimple_call_fndecl (e
->call_stmt
);
2484 gimple_stmt_iterator gsi
;
2485 #ifdef ENABLE_CHECKING
2486 struct cgraph_node
*node
;
2489 if (e
->indirect_unknown_callee
2490 || decl
== e
->callee
->symbol
.decl
)
2491 return e
->call_stmt
;
2493 #ifdef ENABLE_CHECKING
2496 node
= cgraph_get_node (decl
);
2497 gcc_assert (!node
|| !node
->clone
.combined_args_to_skip
);
2501 if (cgraph_dump_file
)
2503 fprintf (cgraph_dump_file
, "updating call of %s/%i -> %s/%i: ",
2504 cgraph_node_name (e
->caller
), e
->caller
->uid
,
2505 cgraph_node_name (e
->callee
), e
->callee
->uid
);
2506 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
2507 if (e
->callee
->clone
.combined_args_to_skip
)
2509 fprintf (cgraph_dump_file
, " combined args to skip: ");
2510 dump_bitmap (cgraph_dump_file
,
2511 e
->callee
->clone
.combined_args_to_skip
);
2515 if (e
->callee
->clone
.combined_args_to_skip
)
2520 = gimple_call_copy_skip_args (e
->call_stmt
,
2521 e
->callee
->clone
.combined_args_to_skip
);
2522 gimple_call_set_fndecl (new_stmt
, e
->callee
->symbol
.decl
);
2524 if (gimple_vdef (new_stmt
)
2525 && TREE_CODE (gimple_vdef (new_stmt
)) == SSA_NAME
)
2526 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt
)) = new_stmt
;
2528 gsi
= gsi_for_stmt (e
->call_stmt
);
2529 gsi_replace (&gsi
, new_stmt
, false);
2530 /* We need to defer cleaning EH info on the new statement to
2531 fixup-cfg. We may not have dominator information at this point
2532 and thus would end up with unreachable blocks and have no way
2533 to communicate that we need to run CFG cleanup then. */
2534 lp_nr
= lookup_stmt_eh_lp (e
->call_stmt
);
2537 remove_stmt_from_eh_lp (e
->call_stmt
);
2538 add_stmt_to_eh_lp (new_stmt
, lp_nr
);
2543 new_stmt
= e
->call_stmt
;
2544 gimple_call_set_fndecl (new_stmt
, e
->callee
->symbol
.decl
);
2545 update_stmt (new_stmt
);
2548 cgraph_set_call_stmt_including_clones (e
->caller
, e
->call_stmt
, new_stmt
);
2550 if (cgraph_dump_file
)
2552 fprintf (cgraph_dump_file
, " updated to:");
2553 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
2558 /* Once all functions from compilation unit are in memory, produce all clones
2559 and update all calls. We might also do this on demand if we don't want to
2560 bring all functions to memory prior compilation, but current WHOPR
2561 implementation does that and it is is bit easier to keep everything right in
2564 cgraph_materialize_all_clones (void)
2566 struct cgraph_node
*node
;
2567 bool stabilized
= false;
2569 if (cgraph_dump_file
)
2570 fprintf (cgraph_dump_file
, "Materializing clones\n");
2571 #ifdef ENABLE_CHECKING
2575 /* We can also do topological order, but number of iterations should be
2576 bounded by number of IPA passes since single IPA pass is probably not
2577 going to create clones of clones it created itself. */
2581 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2583 if (node
->clone_of
&& node
->symbol
.decl
!= node
->clone_of
->symbol
.decl
2584 && !gimple_has_body_p (node
->symbol
.decl
))
2586 if (gimple_has_body_p (node
->clone_of
->symbol
.decl
))
2588 if (cgraph_dump_file
)
2590 fprintf (cgraph_dump_file
, "cloning %s to %s\n",
2591 cgraph_node_name (node
->clone_of
),
2592 cgraph_node_name (node
));
2593 if (node
->clone
.tree_map
)
2596 fprintf (cgraph_dump_file
, " replace map: ");
2597 for (i
= 0; i
< VEC_length (ipa_replace_map_p
,
2598 node
->clone
.tree_map
);
2601 struct ipa_replace_map
*replace_info
;
2602 replace_info
= VEC_index (ipa_replace_map_p
,
2603 node
->clone
.tree_map
,
2605 print_generic_expr (cgraph_dump_file
, replace_info
->old_tree
, 0);
2606 fprintf (cgraph_dump_file
, " -> ");
2607 print_generic_expr (cgraph_dump_file
, replace_info
->new_tree
, 0);
2608 fprintf (cgraph_dump_file
, "%s%s;",
2609 replace_info
->replace_p
? "(replace)":"",
2610 replace_info
->ref_p
? "(ref)":"");
2612 fprintf (cgraph_dump_file
, "\n");
2614 if (node
->clone
.args_to_skip
)
2616 fprintf (cgraph_dump_file
, " args_to_skip: ");
2617 dump_bitmap (cgraph_dump_file
, node
->clone
.args_to_skip
);
2619 if (node
->clone
.args_to_skip
)
2621 fprintf (cgraph_dump_file
, " combined_args_to_skip:");
2622 dump_bitmap (cgraph_dump_file
, node
->clone
.combined_args_to_skip
);
2625 cgraph_materialize_clone (node
);
2631 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2632 if (!node
->analyzed
&& node
->callees
)
2633 cgraph_node_remove_callees (node
);
2634 if (cgraph_dump_file
)
2635 fprintf (cgraph_dump_file
, "Materialization Call site updates done.\n");
2636 #ifdef ENABLE_CHECKING
2639 cgraph_remove_unreachable_nodes (false, cgraph_dump_file
);
2643 /* Perform simple optimizations based on callgraph. */
2646 cgraph_optimize (void)
2651 #ifdef ENABLE_CHECKING
2655 /* Frontend may output common variables after the unit has been finalized.
2656 It is safe to deal with them here as they are always zero initialized. */
2657 varpool_analyze_pending_decls ();
2659 timevar_push (TV_CGRAPHOPT
);
2660 if (pre_ipa_mem_report
)
2662 fprintf (stderr
, "Memory consumption before IPA\n");
2663 dump_memory_report (false);
2666 fprintf (stderr
, "Performing interprocedural optimizations\n");
2667 cgraph_state
= CGRAPH_STATE_IPA
;
2669 /* Don't run the IPA passes if there was any error or sorry messages. */
2673 /* Do nothing else if any IPA pass found errors or if we are just streaming LTO. */
2675 || (!in_lto_p
&& flag_lto
&& !flag_fat_lto_objects
))
2677 timevar_pop (TV_CGRAPHOPT
);
2681 /* This pass remove bodies of extern inline functions we never inlined.
2682 Do this later so other IPA passes see what is really going on. */
2683 cgraph_remove_unreachable_nodes (false, dump_file
);
2684 cgraph_global_info_ready
= true;
2685 if (cgraph_dump_file
)
2687 fprintf (cgraph_dump_file
, "Optimized ");
2688 dump_cgraph (cgraph_dump_file
);
2689 dump_varpool (cgraph_dump_file
);
2691 if (post_ipa_mem_report
)
2693 fprintf (stderr
, "Memory consumption after IPA\n");
2694 dump_memory_report (false);
2696 timevar_pop (TV_CGRAPHOPT
);
2698 /* Output everything. */
2699 (*debug_hooks
->assembly_start
) ();
2701 fprintf (stderr
, "Assembling functions:\n");
2702 #ifdef ENABLE_CHECKING
2706 cgraph_materialize_all_clones ();
2707 bitmap_obstack_initialize (NULL
);
2708 execute_ipa_pass_list (all_late_ipa_passes
);
2709 cgraph_remove_unreachable_nodes (true, dump_file
);
2710 #ifdef ENABLE_CHECKING
2713 bitmap_obstack_release (NULL
);
2714 cgraph_mark_functions_to_output ();
2717 cgraph_state
= CGRAPH_STATE_EXPANSION
;
2718 if (!flag_toplevel_reorder
)
2719 cgraph_output_in_order ();
2722 cgraph_output_pending_asms ();
2724 cgraph_expand_all_functions ();
2725 varpool_remove_unreferenced_decls ();
2727 varpool_assemble_pending_decls ();
2730 cgraph_process_new_functions ();
2731 cgraph_state
= CGRAPH_STATE_FINISHED
;
2733 if (cgraph_dump_file
)
2735 fprintf (cgraph_dump_file
, "\nFinal ");
2736 dump_cgraph (cgraph_dump_file
);
2737 dump_varpool (cgraph_dump_file
);
2739 #ifdef ENABLE_CHECKING
2741 /* Double check that all inline clones are gone and that all
2742 function bodies have been released from memory. */
2745 struct cgraph_node
*node
;
2746 bool error_found
= false;
2748 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2750 && (node
->global
.inlined_to
2751 || gimple_has_body_p (node
->symbol
.decl
)))
2754 dump_cgraph_node (stderr
, node
);
2757 internal_error ("nodes with unreleased memory found");
2763 /* Analyze the whole compilation unit once it is parsed completely. */
2766 cgraph_finalize_compilation_unit (void)
2768 timevar_push (TV_CGRAPH
);
2770 /* If LTO is enabled, initialize the streamer hooks needed by GIMPLE. */
2772 lto_streamer_hooks_init ();
2774 /* If we're here there's no current function anymore. Some frontends
2775 are lazy in clearing these. */
2776 current_function_decl
= NULL
;
2779 /* Do not skip analyzing the functions if there were errors, we
2780 miss diagnostics for following functions otherwise. */
2782 /* Emit size functions we didn't inline. */
2783 finalize_size_functions ();
2785 /* Mark alias targets necessary and emit diagnostics. */
2786 finish_aliases_1 ();
2787 handle_alias_pairs ();
2791 fprintf (stderr
, "\nAnalyzing compilation unit\n");
2795 if (flag_dump_passes
)
2798 /* Gimplify and lower all functions, compute reachability and
2799 remove unreachable nodes. */
2800 cgraph_analyze_functions ();
2802 /* Mark alias targets necessary and emit diagnostics. */
2803 finish_aliases_1 ();
2804 handle_alias_pairs ();
2806 /* Gimplify and lower thunks. */
2807 cgraph_analyze_functions ();
2809 /* Finally drive the pass manager. */
2812 timevar_pop (TV_CGRAPH
);
2816 #include "gt-cgraphunit.h"