1 /* Callgraph based interprocedural optimizations.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
3 2011 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"
115 #include "tree-flow.h"
116 #include "tree-inline.h"
117 #include "langhooks.h"
118 #include "pointer-set.h"
125 #include "diagnostic.h"
126 #include "tree-pretty-print.h"
127 #include "gimple-pretty-print.h"
132 #include "function.h"
133 #include "ipa-prop.h"
135 #include "tree-iterator.h"
136 #include "tree-pass.h"
137 #include "tree-dump.h"
139 #include "coverage.h"
141 #include "ipa-inline.h"
142 #include "ipa-utils.h"
143 #include "lto-streamer.h"
145 static void cgraph_expand_all_functions (void);
146 static void cgraph_mark_functions_to_output (void);
147 static void cgraph_expand_function (struct cgraph_node
*);
148 static void cgraph_output_pending_asms (void);
150 FILE *cgraph_dump_file
;
152 /* Used for vtable lookup in thunk adjusting. */
153 static GTY (()) tree vtable_entry_type
;
155 /* Determine if function DECL is needed. That is, visible to something
156 either outside this translation unit, something magic in the system
160 cgraph_decide_is_function_needed (struct cgraph_node
*node
, tree decl
)
162 /* If the user told us it is used, then it must be so. */
163 if (node
->local
.externally_visible
)
166 /* ??? If the assembler name is set by hand, it is possible to assemble
167 the name later after finalizing the function and the fact is noticed
168 in assemble_name then. This is arguably a bug. */
169 if (DECL_ASSEMBLER_NAME_SET_P (decl
)
170 && (!node
->thunk
.thunk_p
&& !node
->same_body_alias
)
171 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)))
174 /* With -fkeep-inline-functions we are keeping all inline functions except
175 for extern inline ones. */
176 if (flag_keep_inline_functions
177 && DECL_DECLARED_INLINE_P (decl
)
178 && !DECL_EXTERNAL (decl
)
179 && !DECL_DISREGARD_INLINE_LIMITS (decl
))
182 /* If we decided it was needed before, but at the time we didn't have
183 the body of the function available, then it's still needed. We have
184 to go back and re-check its dependencies now. */
188 /* Externally visible functions must be output. The exception is
189 COMDAT functions that must be output only when they are needed.
191 When not optimizing, also output the static functions. (see
192 PR24561), but don't do so for always_inline functions, functions
193 declared inline and nested functions. These were optimized out
194 in the original implementation and it is unclear whether we want
195 to change the behavior here. */
196 if (((TREE_PUBLIC (decl
)
198 && !DECL_DISREGARD_INLINE_LIMITS (decl
)
199 && !DECL_DECLARED_INLINE_P (decl
)
200 && !(DECL_CONTEXT (decl
)
201 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
)))
202 && !flag_whole_program
204 && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
))
210 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
211 functions into callgraph in a way so they look like ordinary reachable
212 functions inserted into callgraph already at construction time. */
215 cgraph_process_new_functions (void)
219 struct cgraph_node
*node
;
221 varpool_analyze_pending_decls ();
222 /* Note that this queue may grow as its being processed, as the new
223 functions may generate new ones. */
224 while (cgraph_new_nodes
)
226 node
= cgraph_new_nodes
;
228 cgraph_new_nodes
= cgraph_new_nodes
->next_needed
;
229 switch (cgraph_state
)
231 case CGRAPH_STATE_CONSTRUCTION
:
232 /* At construction time we just need to finalize function and move
233 it into reachable functions list. */
235 node
->next_needed
= NULL
;
236 cgraph_finalize_function (fndecl
, false);
237 cgraph_mark_reachable_node (node
);
239 cgraph_call_function_insertion_hooks (node
);
242 case CGRAPH_STATE_IPA
:
243 case CGRAPH_STATE_IPA_SSA
:
244 /* When IPA optimization already started, do all essential
245 transformations that has been already performed on the whole
246 cgraph but not on this function. */
248 gimple_register_cfg_hooks ();
250 cgraph_analyze_function (node
);
251 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
252 current_function_decl
= fndecl
;
253 if ((cgraph_state
== CGRAPH_STATE_IPA_SSA
254 && !gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
255 /* When not optimizing, be sure we run early local passes anyway
258 execute_pass_list (pass_early_local_passes
.pass
.sub
);
260 compute_inline_parameters (node
, true);
261 free_dominance_info (CDI_POST_DOMINATORS
);
262 free_dominance_info (CDI_DOMINATORS
);
264 current_function_decl
= NULL
;
265 cgraph_call_function_insertion_hooks (node
);
268 case CGRAPH_STATE_EXPANSION
:
269 /* Functions created during expansion shall be compiled
272 cgraph_call_function_insertion_hooks (node
);
273 cgraph_expand_function (node
);
280 varpool_analyze_pending_decls ();
285 /* As an GCC extension we allow redefinition of the function. The
286 semantics when both copies of bodies differ is not well defined.
287 We replace the old body with new body so in unit at a time mode
288 we always use new body, while in normal mode we may end up with
289 old body inlined into some functions and new body expanded and
292 ??? It may make more sense to use one body for inlining and other
293 body for expanding the function but this is difficult to do. */
296 cgraph_reset_node (struct cgraph_node
*node
)
298 /* If node->process is set, then we have already begun whole-unit analysis.
299 This is *not* testing for whether we've already emitted the function.
300 That case can be sort-of legitimately seen with real function redefinition
301 errors. I would argue that the front end should never present us with
302 such a case, but don't enforce that for now. */
303 gcc_assert (!node
->process
);
305 /* Reset our data structures so we can analyze the function again. */
306 memset (&node
->local
, 0, sizeof (node
->local
));
307 memset (&node
->global
, 0, sizeof (node
->global
));
308 memset (&node
->rtl
, 0, sizeof (node
->rtl
));
309 node
->analyzed
= false;
310 node
->local
.finalized
= false;
312 cgraph_node_remove_callees (node
);
316 cgraph_lower_function (struct cgraph_node
*node
)
322 lower_nested_functions (node
->decl
);
323 gcc_assert (!node
->nested
);
325 tree_lowering_passes (node
->decl
);
326 node
->lowered
= true;
329 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
330 logic in effect. If NESTED is true, then our caller cannot stand to have
331 the garbage collector run at the moment. We would need to either create
332 a new GC context, or just not compile right now. */
335 cgraph_finalize_function (tree decl
, bool nested
)
337 struct cgraph_node
*node
= cgraph_get_create_node (decl
);
339 if (node
->local
.finalized
)
341 cgraph_reset_node (node
);
342 node
->local
.redefined_extern_inline
= true;
345 notice_global_symbol (decl
);
346 node
->local
.finalized
= true;
347 node
->lowered
= DECL_STRUCT_FUNCTION (decl
)->cfg
!= NULL
;
349 if (cgraph_decide_is_function_needed (node
, decl
))
350 cgraph_mark_needed_node (node
);
352 /* Since we reclaim unreachable nodes at the end of every language
353 level unit, we need to be conservative about possible entry points
355 if ((TREE_PUBLIC (decl
) && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
))
356 || DECL_STATIC_CONSTRUCTOR (decl
)
357 || DECL_STATIC_DESTRUCTOR (decl
)
358 /* COMDAT virtual functions may be referenced by vtable from
359 other compilation unit. Still we want to devirtualize calls
360 to those so we need to analyze them.
361 FIXME: We should introduce may edges for this purpose and update
362 their handling in unreachable function removal and inliner too. */
363 || (DECL_VIRTUAL_P (decl
)
364 && optimize
&& (DECL_COMDAT (decl
) || DECL_EXTERNAL (decl
))))
365 cgraph_mark_reachable_node (node
);
367 /* If we've not yet emitted decl, tell the debug info about it. */
368 if (!TREE_ASM_WRITTEN (decl
))
369 (*debug_hooks
->deferred_inline_function
) (decl
);
371 /* Possibly warn about unused parameters. */
372 if (warn_unused_parameter
)
373 do_warn_unused_parameter (decl
);
379 /* C99 extern inline keywords allow changing of declaration after function
380 has been finalized. We need to re-decide if we want to mark the function as
384 cgraph_mark_if_needed (tree decl
)
386 struct cgraph_node
*node
= cgraph_get_node (decl
);
387 if (node
->local
.finalized
&& cgraph_decide_is_function_needed (node
, decl
))
388 cgraph_mark_needed_node (node
);
391 /* Return TRUE if NODE2 is equivalent to NODE or its clone. */
393 clone_of_p (struct cgraph_node
*node
, struct cgraph_node
*node2
)
395 node
= cgraph_function_or_thunk_node (node
, NULL
);
396 node2
= cgraph_function_or_thunk_node (node2
, NULL
);
397 while (node
!= node2
&& node2
)
398 node2
= node2
->clone_of
;
399 return node2
!= NULL
;
402 /* Verify edge E count and frequency. */
405 verify_edge_count_and_frequency (struct cgraph_edge
*e
)
407 bool error_found
= false;
410 error ("caller edge count is negative");
413 if (e
->frequency
< 0)
415 error ("caller edge frequency is negative");
418 if (e
->frequency
> CGRAPH_FREQ_MAX
)
420 error ("caller edge frequency is too large");
423 if (gimple_has_body_p (e
->caller
->decl
)
424 && !e
->caller
->global
.inlined_to
425 /* FIXME: Inline-analysis sets frequency to 0 when edge is optimized out.
426 Remove this once edges are actualy removed from the function at that time. */
428 || (inline_edge_summary_vec
429 && !inline_edge_summary (e
)->predicate
))
431 != compute_call_stmt_bb_frequency (e
->caller
->decl
,
432 gimple_bb (e
->call_stmt
))))
434 error ("caller edge frequency %i does not match BB frequency %i",
436 compute_call_stmt_bb_frequency (e
->caller
->decl
,
437 gimple_bb (e
->call_stmt
)));
443 /* Switch to THIS_CFUN if needed and print STMT to stderr. */
445 cgraph_debug_gimple_stmt (struct function
*this_cfun
, gimple stmt
)
447 /* debug_gimple_stmt needs correct cfun */
448 if (cfun
!= this_cfun
)
449 set_cfun (this_cfun
);
450 debug_gimple_stmt (stmt
);
453 /* Verify that call graph edge E corresponds to DECL from the associated
454 statement. Return true if the verification should fail. */
457 verify_edge_corresponds_to_fndecl (struct cgraph_edge
*e
, tree decl
)
459 struct cgraph_node
*node
;
461 if (!decl
|| e
->callee
->global
.inlined_to
)
463 node
= cgraph_get_node (decl
);
465 /* We do not know if a node from a different partition is an alias or what it
466 aliases and therefore cannot do the former_clone_of check reliably. */
467 if (!node
|| node
->in_other_partition
)
469 node
= cgraph_function_or_thunk_node (node
, NULL
);
471 if ((e
->callee
->former_clone_of
!= node
->decl
)
472 /* IPA-CP sometimes redirect edge to clone and then back to the former
473 function. This ping-pong has to go, eventaully. */
474 && (node
!= cgraph_function_or_thunk_node (e
->callee
, NULL
))
475 && !clone_of_p (node
, e
->callee
))
481 /* Verify cgraph nodes of given cgraph node. */
483 verify_cgraph_node (struct cgraph_node
*node
)
485 struct cgraph_edge
*e
;
486 struct function
*this_cfun
= DECL_STRUCT_FUNCTION (node
->decl
);
487 basic_block this_block
;
488 gimple_stmt_iterator gsi
;
489 bool error_found
= false;
494 timevar_push (TV_CGRAPH_VERIFY
);
495 for (e
= node
->callees
; e
; e
= e
->next_callee
)
498 error ("aux field set for edge %s->%s",
499 identifier_to_locale (cgraph_node_name (e
->caller
)),
500 identifier_to_locale (cgraph_node_name (e
->callee
)));
505 error ("execution count is negative");
508 if (node
->global
.inlined_to
&& node
->local
.externally_visible
)
510 error ("externally visible inline clone");
513 if (node
->global
.inlined_to
&& node
->address_taken
)
515 error ("inline clone with address taken");
518 if (node
->global
.inlined_to
&& node
->needed
)
520 error ("inline clone is needed");
523 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
527 error ("aux field set for indirect edge from %s",
528 identifier_to_locale (cgraph_node_name (e
->caller
)));
531 if (!e
->indirect_unknown_callee
532 || !e
->indirect_info
)
534 error ("An indirect edge from %s is not marked as indirect or has "
535 "associated indirect_info, the corresponding statement is: ",
536 identifier_to_locale (cgraph_node_name (e
->caller
)));
537 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
541 for (e
= node
->callers
; e
; e
= e
->next_caller
)
543 if (verify_edge_count_and_frequency (e
))
545 if (!e
->inline_failed
)
547 if (node
->global
.inlined_to
548 != (e
->caller
->global
.inlined_to
549 ? e
->caller
->global
.inlined_to
: e
->caller
))
551 error ("inlined_to pointer is wrong");
554 if (node
->callers
->next_caller
)
556 error ("multiple inline callers");
561 if (node
->global
.inlined_to
)
563 error ("inlined_to pointer set for noninline callers");
567 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
568 if (verify_edge_count_and_frequency (e
))
570 if (!node
->callers
&& node
->global
.inlined_to
)
572 error ("inlined_to pointer is set but no predecessors found");
575 if (node
->global
.inlined_to
== node
)
577 error ("inlined_to pointer refers to itself");
581 if (!cgraph_get_node (node
->decl
))
583 error ("node not found in cgraph_hash");
589 struct cgraph_node
*n
;
590 for (n
= node
->clone_of
->clones
; n
; n
= n
->next_sibling_clone
)
595 error ("node has wrong clone_of");
601 struct cgraph_node
*n
;
602 for (n
= node
->clones
; n
; n
= n
->next_sibling_clone
)
603 if (n
->clone_of
!= node
)
607 error ("node has wrong clone list");
611 if ((node
->prev_sibling_clone
|| node
->next_sibling_clone
) && !node
->clone_of
)
613 error ("node is in clone list but it is not clone");
616 if (!node
->prev_sibling_clone
&& node
->clone_of
&& node
->clone_of
->clones
!= node
)
618 error ("node has wrong prev_clone pointer");
621 if (node
->prev_sibling_clone
&& node
->prev_sibling_clone
->next_sibling_clone
!= node
)
623 error ("double linked list of clones corrupted");
626 if (node
->same_comdat_group
)
628 struct cgraph_node
*n
= node
->same_comdat_group
;
630 if (!DECL_ONE_ONLY (node
->decl
))
632 error ("non-DECL_ONE_ONLY node in a same_comdat_group list");
637 error ("node is alone in a comdat group");
642 if (!n
->same_comdat_group
)
644 error ("same_comdat_group is not a circular list");
648 n
= n
->same_comdat_group
;
653 if (node
->analyzed
&& node
->alias
)
655 bool ref_found
= false;
661 error ("Alias has call edges");
664 for (i
= 0; ipa_ref_list_reference_iterate (&node
->ref_list
, i
, ref
); i
++)
665 if (ref
->use
!= IPA_REF_ALIAS
)
667 error ("Alias has non-alias refernece");
672 error ("Alias has more than one alias reference");
679 error ("Analyzed alias has no reference");
683 if (node
->analyzed
&& node
->thunk
.thunk_p
)
687 error ("No edge out of thunk node");
690 else if (node
->callees
->next_callee
)
692 error ("More than one edge out of thunk node");
695 if (gimple_has_body_p (node
->decl
))
697 error ("Thunk is not supposed to have body");
701 else if (node
->analyzed
&& gimple_has_body_p (node
->decl
)
702 && !TREE_ASM_WRITTEN (node
->decl
)
703 && (!DECL_EXTERNAL (node
->decl
) || node
->global
.inlined_to
)
708 /* The nodes we're interested in are never shared, so walk
709 the tree ignoring duplicates. */
710 struct pointer_set_t
*visited_nodes
= pointer_set_create ();
711 /* Reach the trees by walking over the CFG, and note the
712 enclosing basic-blocks in the call edges. */
713 FOR_EACH_BB_FN (this_block
, this_cfun
)
714 for (gsi
= gsi_start_bb (this_block
);
718 gimple stmt
= gsi_stmt (gsi
);
719 if (is_gimple_call (stmt
))
721 struct cgraph_edge
*e
= cgraph_edge (node
, stmt
);
722 tree decl
= gimple_call_fndecl (stmt
);
727 error ("shared call_stmt:");
728 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
731 if (!e
->indirect_unknown_callee
)
733 if (verify_edge_corresponds_to_fndecl (e
, decl
))
735 error ("edge points to wrong declaration:");
736 debug_tree (e
->callee
->decl
);
737 fprintf (stderr
," Instead of:");
744 error ("an indirect edge with unknown callee "
745 "corresponding to a call_stmt with "
746 "a known declaration:");
748 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
754 error ("missing callgraph edge for call stmt:");
755 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
760 pointer_set_destroy (visited_nodes
);
763 /* No CFG available?! */
766 for (e
= node
->callees
; e
; e
= e
->next_callee
)
770 error ("edge %s->%s has no corresponding call_stmt",
771 identifier_to_locale (cgraph_node_name (e
->caller
)),
772 identifier_to_locale (cgraph_node_name (e
->callee
)));
773 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
778 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
782 error ("an indirect edge from %s has no corresponding call_stmt",
783 identifier_to_locale (cgraph_node_name (e
->caller
)));
784 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
792 dump_cgraph_node (stderr
, node
);
793 internal_error ("verify_cgraph_node failed");
795 timevar_pop (TV_CGRAPH_VERIFY
);
798 /* Verify whole cgraph structure. */
802 struct cgraph_node
*node
;
807 for (node
= cgraph_nodes
; node
; node
= node
->next
)
808 verify_cgraph_node (node
);
811 /* Output all asm statements we have stored up to be output. */
814 cgraph_output_pending_asms (void)
816 struct cgraph_asm_node
*can
;
821 for (can
= cgraph_asm_nodes
; can
; can
= can
->next
)
822 assemble_asm (can
->asm_str
);
823 cgraph_asm_nodes
= NULL
;
826 /* Analyze the function scheduled to be output. */
828 cgraph_analyze_function (struct cgraph_node
*node
)
830 tree save
= current_function_decl
;
831 tree decl
= node
->decl
;
833 if (node
->alias
&& node
->thunk
.alias
)
835 struct cgraph_node
*tgt
= cgraph_get_node (node
->thunk
.alias
);
836 if (!VEC_length (ipa_ref_t
, node
->ref_list
.references
))
837 ipa_record_reference (node
, NULL
, tgt
, NULL
, IPA_REF_ALIAS
, NULL
);
838 if (node
->same_body_alias
)
840 DECL_VIRTUAL_P (node
->decl
) = DECL_VIRTUAL_P (node
->thunk
.alias
);
841 DECL_DECLARED_INLINE_P (node
->decl
)
842 = DECL_DECLARED_INLINE_P (node
->thunk
.alias
);
843 DECL_DISREGARD_INLINE_LIMITS (node
->decl
)
844 = DECL_DISREGARD_INLINE_LIMITS (node
->thunk
.alias
);
847 /* Fixup visibility nonsences C++ frontend produce on same body aliases. */
848 if (TREE_PUBLIC (node
->decl
) && node
->same_body_alias
)
850 DECL_EXTERNAL (node
->decl
) = DECL_EXTERNAL (node
->thunk
.alias
);
851 if (DECL_ONE_ONLY (node
->thunk
.alias
))
853 DECL_COMDAT (node
->decl
) = DECL_COMDAT (node
->thunk
.alias
);
854 DECL_COMDAT_GROUP (node
->decl
) = DECL_COMDAT_GROUP (node
->thunk
.alias
);
855 if (DECL_ONE_ONLY (node
->thunk
.alias
) && !node
->same_comdat_group
)
857 struct cgraph_node
*tgt
= cgraph_get_node (node
->thunk
.alias
);
858 node
->same_comdat_group
= tgt
;
859 if (!tgt
->same_comdat_group
)
860 tgt
->same_comdat_group
= node
;
863 struct cgraph_node
*n
;
864 for (n
= tgt
->same_comdat_group
;
865 n
->same_comdat_group
!= tgt
;
866 n
= n
->same_comdat_group
)
868 n
->same_comdat_group
= node
;
873 cgraph_mark_reachable_node (cgraph_alias_aliased_node (node
));
874 if (node
->address_taken
)
875 cgraph_mark_address_taken_node (cgraph_alias_aliased_node (node
));
876 if (cgraph_decide_is_function_needed (node
, node
->decl
))
877 cgraph_mark_needed_node (node
);
879 else if (node
->thunk
.thunk_p
)
881 cgraph_create_edge (node
, cgraph_get_node (node
->thunk
.alias
),
882 NULL
, 0, CGRAPH_FREQ_BASE
);
886 current_function_decl
= decl
;
887 push_cfun (DECL_STRUCT_FUNCTION (decl
));
889 assign_assembler_name_if_neeeded (node
->decl
);
891 /* Make sure to gimplify bodies only once. During analyzing a
892 function we lower it, which will require gimplified nested
893 functions, so we can end up here with an already gimplified
895 if (!gimple_body (decl
))
896 gimplify_function_tree (decl
);
897 dump_function (TDI_generic
, decl
);
899 cgraph_lower_function (node
);
902 node
->analyzed
= true;
904 current_function_decl
= save
;
907 /* C++ frontend produce same body aliases all over the place, even before PCH
908 gets streamed out. It relies on us linking the aliases with their function
909 in order to do the fixups, but ipa-ref is not PCH safe. Consequentely we
910 first produce aliases without links, but once C++ FE is sure he won't sream
911 PCH we build the links via this function. */
914 cgraph_process_same_body_aliases (void)
916 struct cgraph_node
*node
;
917 for (node
= cgraph_nodes
; node
; node
= node
->next
)
918 if (node
->same_body_alias
919 && !VEC_length (ipa_ref_t
, node
->ref_list
.references
))
921 struct cgraph_node
*tgt
= cgraph_get_node (node
->thunk
.alias
);
922 ipa_record_reference (node
, NULL
, tgt
, NULL
, IPA_REF_ALIAS
, NULL
);
924 same_body_aliases_done
= true;
927 /* Process attributes common for vars and functions. */
930 process_common_attributes (tree decl
)
932 tree weakref
= lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
));
934 if (weakref
&& !lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)))
936 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wattributes
,
937 "%<weakref%> attribute should be accompanied with"
938 " an %<alias%> attribute");
939 DECL_WEAK (decl
) = 0;
940 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
941 DECL_ATTRIBUTES (decl
));
945 /* Look for externally_visible and used attributes and mark cgraph nodes
948 We cannot mark the nodes at the point the attributes are processed (in
949 handle_*_attribute) because the copy of the declarations available at that
950 point may not be canonical. For example, in:
953 void f() __attribute__((used));
955 the declaration we see in handle_used_attribute will be the second
956 declaration -- but the front end will subsequently merge that declaration
957 with the original declaration and discard the second declaration.
959 Furthermore, we can't mark these nodes in cgraph_finalize_function because:
962 void f() __attribute__((externally_visible));
966 So, we walk the nodes at the end of the translation unit, applying the
967 attributes at that point. */
970 process_function_and_variable_attributes (struct cgraph_node
*first
,
971 struct varpool_node
*first_var
)
973 struct cgraph_node
*node
;
974 struct varpool_node
*vnode
;
976 for (node
= cgraph_nodes
; node
!= first
; node
= node
->next
)
978 tree decl
= node
->decl
;
979 if (DECL_PRESERVE_P (decl
))
980 cgraph_mark_needed_node (node
);
981 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
982 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl
))
983 && TREE_PUBLIC (node
->decl
))
985 if (node
->local
.finalized
)
986 cgraph_mark_needed_node (node
);
988 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
990 if (! TREE_PUBLIC (node
->decl
))
991 warning_at (DECL_SOURCE_LOCATION (node
->decl
), OPT_Wattributes
,
992 "%<externally_visible%>"
993 " attribute have effect only on public objects");
994 else if (node
->local
.finalized
)
995 cgraph_mark_needed_node (node
);
997 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
998 && (node
->local
.finalized
&& !node
->alias
))
1000 warning_at (DECL_SOURCE_LOCATION (node
->decl
), OPT_Wattributes
,
1001 "%<weakref%> attribute ignored"
1002 " because function is defined");
1003 DECL_WEAK (decl
) = 0;
1004 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
1005 DECL_ATTRIBUTES (decl
));
1008 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (decl
))
1009 && !DECL_DECLARED_INLINE_P (decl
)
1010 /* redefining extern inline function makes it DECL_UNINLINABLE. */
1011 && !DECL_UNINLINABLE (decl
))
1012 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wattributes
,
1013 "always_inline function might not be inlinable");
1015 process_common_attributes (decl
);
1017 for (vnode
= varpool_nodes
; vnode
!= first_var
; vnode
= vnode
->next
)
1019 tree decl
= vnode
->decl
;
1020 if (DECL_PRESERVE_P (decl
))
1022 vnode
->force_output
= true;
1023 if (vnode
->finalized
)
1024 varpool_mark_needed_node (vnode
);
1026 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
1027 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl
))
1028 && TREE_PUBLIC (vnode
->decl
))
1030 if (vnode
->finalized
)
1031 varpool_mark_needed_node (vnode
);
1033 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
1035 if (! TREE_PUBLIC (vnode
->decl
))
1036 warning_at (DECL_SOURCE_LOCATION (vnode
->decl
), OPT_Wattributes
,
1037 "%<externally_visible%>"
1038 " attribute have effect only on public objects");
1039 else if (vnode
->finalized
)
1040 varpool_mark_needed_node (vnode
);
1042 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
1044 && DECL_INITIAL (decl
))
1046 warning_at (DECL_SOURCE_LOCATION (vnode
->decl
), OPT_Wattributes
,
1047 "%<weakref%> attribute ignored"
1048 " because variable is initialized");
1049 DECL_WEAK (decl
) = 0;
1050 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
1051 DECL_ATTRIBUTES (decl
));
1053 process_common_attributes (decl
);
1057 /* Process CGRAPH_NODES_NEEDED queue, analyze each function (and transitively
1058 each reachable functions) and build cgraph.
1059 The function can be called multiple times after inserting new nodes
1060 into beginning of queue. Just the new part of queue is re-scanned then. */
1063 cgraph_analyze_functions (void)
1065 /* Keep track of already processed nodes when called multiple times for
1066 intermodule optimization. */
1067 static struct cgraph_node
*first_analyzed
;
1068 struct cgraph_node
*first_processed
= first_analyzed
;
1069 static struct varpool_node
*first_analyzed_var
;
1070 struct cgraph_node
*node
, *next
;
1072 bitmap_obstack_initialize (NULL
);
1073 process_function_and_variable_attributes (first_processed
,
1074 first_analyzed_var
);
1075 first_processed
= cgraph_nodes
;
1076 first_analyzed_var
= varpool_nodes
;
1077 varpool_analyze_pending_decls ();
1078 if (cgraph_dump_file
)
1080 fprintf (cgraph_dump_file
, "Initial entry points:");
1081 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
1083 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1084 fprintf (cgraph_dump_file
, "\n");
1086 cgraph_process_new_functions ();
1088 /* Propagate reachability flag and lower representation of all reachable
1089 functions. In the future, lowering will introduce new functions and
1090 new entry points on the way (by template instantiation and virtual
1091 method table generation for instance). */
1092 while (cgraph_nodes_queue
)
1094 struct cgraph_edge
*edge
;
1095 tree decl
= cgraph_nodes_queue
->decl
;
1097 node
= cgraph_nodes_queue
;
1098 cgraph_nodes_queue
= cgraph_nodes_queue
->next_needed
;
1099 node
->next_needed
= NULL
;
1101 /* ??? It is possible to create extern inline function and later using
1102 weak alias attribute to kill its body. See
1103 gcc.c-torture/compile/20011119-1.c */
1104 if (!DECL_STRUCT_FUNCTION (decl
)
1105 && (!node
->alias
|| !node
->thunk
.alias
)
1106 && !node
->thunk
.thunk_p
)
1108 cgraph_reset_node (node
);
1109 node
->local
.redefined_extern_inline
= true;
1113 if (!node
->analyzed
)
1114 cgraph_analyze_function (node
);
1116 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
1117 if (!edge
->callee
->reachable
)
1118 cgraph_mark_reachable_node (edge
->callee
);
1119 for (edge
= node
->callers
; edge
; edge
= edge
->next_caller
)
1120 if (!edge
->caller
->reachable
&& edge
->caller
->thunk
.thunk_p
)
1121 cgraph_mark_reachable_node (edge
->caller
);
1123 if (node
->same_comdat_group
)
1125 for (next
= node
->same_comdat_group
;
1127 next
= next
->same_comdat_group
)
1128 cgraph_mark_reachable_node (next
);
1131 /* If decl is a clone of an abstract function, mark that abstract
1132 function so that we don't release its body. The DECL_INITIAL() of that
1133 abstract function declaration will be later needed to output debug
1135 if (DECL_ABSTRACT_ORIGIN (decl
))
1137 struct cgraph_node
*origin_node
;
1138 origin_node
= cgraph_get_node (DECL_ABSTRACT_ORIGIN (decl
));
1139 origin_node
->abstract_and_needed
= true;
1142 /* We finalize local static variables during constructing callgraph
1143 edges. Process their attributes too. */
1144 process_function_and_variable_attributes (first_processed
,
1145 first_analyzed_var
);
1146 first_processed
= cgraph_nodes
;
1147 first_analyzed_var
= varpool_nodes
;
1148 varpool_analyze_pending_decls ();
1149 cgraph_process_new_functions ();
1152 /* Collect entry points to the unit. */
1153 if (cgraph_dump_file
)
1155 fprintf (cgraph_dump_file
, "Unit entry points:");
1156 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
1158 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1159 fprintf (cgraph_dump_file
, "\n\nInitial ");
1160 dump_cgraph (cgraph_dump_file
);
1161 dump_varpool (cgraph_dump_file
);
1164 if (cgraph_dump_file
)
1165 fprintf (cgraph_dump_file
, "\nReclaiming functions:");
1167 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= next
)
1169 tree decl
= node
->decl
;
1172 if (node
->local
.finalized
&& !gimple_has_body_p (decl
)
1173 && (!node
->alias
|| !node
->thunk
.alias
)
1174 && !node
->thunk
.thunk_p
)
1175 cgraph_reset_node (node
);
1177 if (!node
->reachable
1178 && (gimple_has_body_p (decl
) || node
->thunk
.thunk_p
1179 || (node
->alias
&& node
->thunk
.alias
)))
1181 if (cgraph_dump_file
)
1182 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1183 cgraph_remove_node (node
);
1187 node
->next_needed
= NULL
;
1188 gcc_assert (!node
->local
.finalized
|| node
->thunk
.thunk_p
1190 || gimple_has_body_p (decl
));
1191 gcc_assert (node
->analyzed
== node
->local
.finalized
);
1193 if (cgraph_dump_file
)
1195 fprintf (cgraph_dump_file
, "\n\nReclaimed ");
1196 dump_cgraph (cgraph_dump_file
);
1197 dump_varpool (cgraph_dump_file
);
1199 bitmap_obstack_release (NULL
);
1200 first_analyzed
= cgraph_nodes
;
1204 /* Translate the ugly representation of aliases as alias pairs into nice
1205 representation in callgraph. We don't handle all cases yet,
1209 handle_alias_pairs (void)
1213 struct cgraph_node
*target_node
;
1214 struct cgraph_node
*src_node
;
1215 struct varpool_node
*target_vnode
;
1217 for (i
= 0; VEC_iterate (alias_pair
, alias_pairs
, i
, p
);)
1219 if (TREE_CODE (p
->decl
) == FUNCTION_DECL
1220 && !lookup_attribute ("weakref", DECL_ATTRIBUTES (p
->decl
))
1221 && (target_node
= cgraph_node_for_asm (p
->target
)) != NULL
)
1223 src_node
= cgraph_get_node (p
->decl
);
1224 if (src_node
&& src_node
->local
.finalized
)
1225 cgraph_reset_node (src_node
);
1226 /* Normally EXTERNAL flag is used to mark external inlines,
1227 however for aliases it seems to be allowed to use it w/o
1228 any meaning. See gcc.dg/attr-alias-3.c
1229 However for weakref we insist on EXTERNAL flag being set.
1230 See gcc.dg/attr-alias-5.c */
1231 if (DECL_EXTERNAL (p
->decl
))
1232 DECL_EXTERNAL (p
->decl
) = 0;
1233 cgraph_create_function_alias (p
->decl
, target_node
->decl
);
1234 VEC_unordered_remove (alias_pair
, alias_pairs
, i
);
1236 else if (TREE_CODE (p
->decl
) == VAR_DECL
1237 && !lookup_attribute ("weakref", DECL_ATTRIBUTES (p
->decl
))
1238 && (target_vnode
= varpool_node_for_asm (p
->target
)) != NULL
)
1240 /* Normally EXTERNAL flag is used to mark external inlines,
1241 however for aliases it seems to be allowed to use it w/o
1242 any meaning. See gcc.dg/attr-alias-3.c
1243 However for weakref we insist on EXTERNAL flag being set.
1244 See gcc.dg/attr-alias-5.c */
1245 if (DECL_EXTERNAL (p
->decl
))
1246 DECL_EXTERNAL (p
->decl
) = 0;
1247 varpool_create_variable_alias (p
->decl
, target_vnode
->decl
);
1248 VEC_unordered_remove (alias_pair
, alias_pairs
, i
);
1253 fprintf (dump_file
, "Unhandled alias %s->%s\n",
1254 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (p
->decl
)),
1255 IDENTIFIER_POINTER (p
->target
));
1263 /* Analyze the whole compilation unit once it is parsed completely. */
1266 cgraph_finalize_compilation_unit (void)
1268 timevar_push (TV_CGRAPH
);
1270 /* If LTO is enabled, initialize the streamer hooks needed by GIMPLE. */
1272 lto_streamer_hooks_init ();
1274 /* If we're here there's no current function anymore. Some frontends
1275 are lazy in clearing these. */
1276 current_function_decl
= NULL
;
1279 /* Do not skip analyzing the functions if there were errors, we
1280 miss diagnostics for following functions otherwise. */
1282 /* Emit size functions we didn't inline. */
1283 finalize_size_functions ();
1285 /* Mark alias targets necessary and emit diagnostics. */
1286 finish_aliases_1 ();
1287 handle_alias_pairs ();
1291 fprintf (stderr
, "\nAnalyzing compilation unit\n");
1295 if (flag_dump_passes
)
1298 /* Gimplify and lower all functions, compute reachability and
1299 remove unreachable nodes. */
1300 cgraph_analyze_functions ();
1302 /* Mark alias targets necessary and emit diagnostics. */
1303 finish_aliases_1 ();
1304 handle_alias_pairs ();
1306 /* Gimplify and lower thunks. */
1307 cgraph_analyze_functions ();
1309 /* Finally drive the pass manager. */
1312 timevar_pop (TV_CGRAPH
);
1316 /* Figure out what functions we want to assemble. */
1319 cgraph_mark_functions_to_output (void)
1321 struct cgraph_node
*node
;
1322 #ifdef ENABLE_CHECKING
1323 bool check_same_comdat_groups
= false;
1325 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1326 gcc_assert (!node
->process
);
1329 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1331 tree decl
= node
->decl
;
1332 struct cgraph_edge
*e
;
1334 gcc_assert (!node
->process
|| node
->same_comdat_group
);
1338 for (e
= node
->callers
; e
; e
= e
->next_caller
)
1339 if (e
->inline_failed
)
1342 /* We need to output all local functions that are used and not
1343 always inlined, as well as those that are reachable from
1344 outside the current compilation unit. */
1346 && !node
->thunk
.thunk_p
1348 && !node
->global
.inlined_to
1349 && (!cgraph_only_called_directly_p (node
)
1350 || ((e
|| ipa_ref_has_aliases_p (&node
->ref_list
))
1351 && node
->reachable
))
1352 && !TREE_ASM_WRITTEN (decl
)
1353 && !DECL_EXTERNAL (decl
))
1356 if (node
->same_comdat_group
)
1358 struct cgraph_node
*next
;
1359 for (next
= node
->same_comdat_group
;
1361 next
= next
->same_comdat_group
)
1362 if (!next
->thunk
.thunk_p
&& !next
->alias
)
1366 else if (node
->same_comdat_group
)
1368 #ifdef ENABLE_CHECKING
1369 check_same_comdat_groups
= true;
1374 /* We should've reclaimed all functions that are not needed. */
1375 #ifdef ENABLE_CHECKING
1376 if (!node
->global
.inlined_to
1377 && gimple_has_body_p (decl
)
1378 /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
1379 are inside partition, we can end up not removing the body since we no longer
1380 have analyzed node pointing to it. */
1381 && !node
->in_other_partition
1383 && !DECL_EXTERNAL (decl
))
1385 dump_cgraph_node (stderr
, node
);
1386 internal_error ("failed to reclaim unneeded function");
1389 gcc_assert (node
->global
.inlined_to
1390 || !gimple_has_body_p (decl
)
1391 || node
->in_other_partition
1392 || DECL_EXTERNAL (decl
));
1397 #ifdef ENABLE_CHECKING
1398 if (check_same_comdat_groups
)
1399 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1400 if (node
->same_comdat_group
&& !node
->process
)
1402 tree decl
= node
->decl
;
1403 if (!node
->global
.inlined_to
1404 && gimple_has_body_p (decl
)
1405 /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
1406 are inside partition, we can end up not removing the body since we no longer
1407 have analyzed node pointing to it. */
1408 && !node
->in_other_partition
1409 && !DECL_EXTERNAL (decl
))
1411 dump_cgraph_node (stderr
, node
);
1412 internal_error ("failed to reclaim unneeded functionin same comdat group");
1418 /* DECL is FUNCTION_DECL. Initialize datastructures so DECL is a function
1419 in lowered gimple form.
1421 Set current_function_decl and cfun to newly constructed empty function body.
1422 return basic block in the function body. */
1425 init_lowered_empty_function (tree decl
)
1429 current_function_decl
= decl
;
1430 allocate_struct_function (decl
, false);
1431 gimple_register_cfg_hooks ();
1432 init_empty_tree_cfg ();
1433 init_tree_ssa (cfun
);
1434 init_ssa_operands ();
1435 cfun
->gimple_df
->in_ssa_p
= true;
1436 DECL_INITIAL (decl
) = make_node (BLOCK
);
1438 DECL_SAVED_TREE (decl
) = error_mark_node
;
1439 cfun
->curr_properties
|=
1440 (PROP_gimple_lcf
| PROP_gimple_leh
| PROP_cfg
| PROP_referenced_vars
|
1441 PROP_ssa
| PROP_gimple_any
);
1443 /* Create BB for body of the function and connect it properly. */
1444 bb
= create_basic_block (NULL
, (void *) 0, ENTRY_BLOCK_PTR
);
1445 make_edge (ENTRY_BLOCK_PTR
, bb
, 0);
1446 make_edge (bb
, EXIT_BLOCK_PTR
, 0);
1451 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
1452 offset indicated by VIRTUAL_OFFSET, if that is
1453 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
1454 zero for a result adjusting thunk. */
1457 thunk_adjust (gimple_stmt_iterator
* bsi
,
1458 tree ptr
, bool this_adjusting
,
1459 HOST_WIDE_INT fixed_offset
, tree virtual_offset
)
1465 && fixed_offset
!= 0)
1467 stmt
= gimple_build_assign
1468 (ptr
, fold_build_pointer_plus_hwi_loc (input_location
,
1471 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1474 /* If there's a virtual offset, look up that value in the vtable and
1475 adjust the pointer again. */
1483 if (!vtable_entry_type
)
1485 tree vfunc_type
= make_node (FUNCTION_TYPE
);
1486 TREE_TYPE (vfunc_type
) = integer_type_node
;
1487 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
1488 layout_type (vfunc_type
);
1490 vtable_entry_type
= build_pointer_type (vfunc_type
);
1494 create_tmp_var (build_pointer_type
1495 (build_pointer_type (vtable_entry_type
)), "vptr");
1497 /* The vptr is always at offset zero in the object. */
1498 stmt
= gimple_build_assign (vtabletmp
,
1499 build1 (NOP_EXPR
, TREE_TYPE (vtabletmp
),
1501 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1502 mark_symbols_for_renaming (stmt
);
1503 find_referenced_vars_in (stmt
);
1505 /* Form the vtable address. */
1506 vtabletmp2
= create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp
)),
1508 stmt
= gimple_build_assign (vtabletmp2
,
1509 build_simple_mem_ref (vtabletmp
));
1510 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1511 mark_symbols_for_renaming (stmt
);
1512 find_referenced_vars_in (stmt
);
1514 /* Find the entry with the vcall offset. */
1515 stmt
= gimple_build_assign (vtabletmp2
,
1516 fold_build_pointer_plus_loc (input_location
,
1519 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1521 /* Get the offset itself. */
1522 vtabletmp3
= create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp2
)),
1524 stmt
= gimple_build_assign (vtabletmp3
,
1525 build_simple_mem_ref (vtabletmp2
));
1526 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1527 mark_symbols_for_renaming (stmt
);
1528 find_referenced_vars_in (stmt
);
1530 /* Cast to sizetype. */
1531 offsettmp
= create_tmp_var (sizetype
, "offset");
1532 stmt
= gimple_build_assign (offsettmp
, fold_convert (sizetype
, vtabletmp3
));
1533 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1534 mark_symbols_for_renaming (stmt
);
1535 find_referenced_vars_in (stmt
);
1537 /* Adjust the `this' pointer. */
1538 ptr
= fold_build_pointer_plus_loc (input_location
, ptr
, offsettmp
);
1542 && fixed_offset
!= 0)
1543 /* Adjust the pointer by the constant. */
1547 if (TREE_CODE (ptr
) == VAR_DECL
)
1551 ptrtmp
= create_tmp_var (TREE_TYPE (ptr
), "ptr");
1552 stmt
= gimple_build_assign (ptrtmp
, ptr
);
1553 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1554 mark_symbols_for_renaming (stmt
);
1555 find_referenced_vars_in (stmt
);
1557 ptr
= fold_build_pointer_plus_hwi_loc (input_location
,
1558 ptrtmp
, fixed_offset
);
1561 /* Emit the statement and gimplify the adjustment expression. */
1562 ret
= create_tmp_var (TREE_TYPE (ptr
), "adjusted_this");
1563 stmt
= gimple_build_assign (ret
, ptr
);
1564 mark_symbols_for_renaming (stmt
);
1565 find_referenced_vars_in (stmt
);
1566 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1571 /* Produce assembler for thunk NODE. */
1574 assemble_thunk (struct cgraph_node
*node
)
1576 bool this_adjusting
= node
->thunk
.this_adjusting
;
1577 HOST_WIDE_INT fixed_offset
= node
->thunk
.fixed_offset
;
1578 HOST_WIDE_INT virtual_value
= node
->thunk
.virtual_value
;
1579 tree virtual_offset
= NULL
;
1580 tree alias
= node
->thunk
.alias
;
1581 tree thunk_fndecl
= node
->decl
;
1582 tree a
= DECL_ARGUMENTS (thunk_fndecl
);
1584 current_function_decl
= thunk_fndecl
;
1586 /* Ensure thunks are emitted in their correct sections. */
1587 resolve_unique_section (thunk_fndecl
, 0, flag_function_sections
);
1590 && targetm
.asm_out
.can_output_mi_thunk (thunk_fndecl
, fixed_offset
,
1591 virtual_value
, alias
))
1595 tree restype
= TREE_TYPE (TREE_TYPE (thunk_fndecl
));
1597 DECL_RESULT (thunk_fndecl
)
1598 = build_decl (DECL_SOURCE_LOCATION (thunk_fndecl
),
1599 RESULT_DECL
, 0, restype
);
1600 fnname
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk_fndecl
));
1602 /* The back end expects DECL_INITIAL to contain a BLOCK, so we
1604 fn_block
= make_node (BLOCK
);
1605 BLOCK_VARS (fn_block
) = a
;
1606 DECL_INITIAL (thunk_fndecl
) = fn_block
;
1607 init_function_start (thunk_fndecl
);
1609 assemble_start_function (thunk_fndecl
, fnname
);
1611 targetm
.asm_out
.output_mi_thunk (asm_out_file
, thunk_fndecl
,
1612 fixed_offset
, virtual_value
, alias
);
1614 assemble_end_function (thunk_fndecl
, fnname
);
1615 init_insn_lengths ();
1616 free_after_compilation (cfun
);
1618 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
1619 node
->thunk
.thunk_p
= false;
1620 node
->analyzed
= false;
1625 basic_block bb
, then_bb
, else_bb
, return_bb
;
1626 gimple_stmt_iterator bsi
;
1632 VEC(tree
, heap
) *vargs
;
1637 DECL_IGNORED_P (thunk_fndecl
) = 1;
1638 bitmap_obstack_initialize (NULL
);
1640 if (node
->thunk
.virtual_offset_p
)
1641 virtual_offset
= size_int (virtual_value
);
1643 /* Build the return declaration for the function. */
1644 restype
= TREE_TYPE (TREE_TYPE (thunk_fndecl
));
1645 if (DECL_RESULT (thunk_fndecl
) == NULL_TREE
)
1647 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
1648 DECL_ARTIFICIAL (resdecl
) = 1;
1649 DECL_IGNORED_P (resdecl
) = 1;
1650 DECL_RESULT (thunk_fndecl
) = resdecl
;
1653 resdecl
= DECL_RESULT (thunk_fndecl
);
1655 bb
= then_bb
= else_bb
= return_bb
= init_lowered_empty_function (thunk_fndecl
);
1657 bsi
= gsi_start_bb (bb
);
1659 /* Build call to the function being thunked. */
1660 if (!VOID_TYPE_P (restype
))
1662 if (!is_gimple_reg_type (restype
))
1665 add_local_decl (cfun
, restmp
);
1666 BLOCK_VARS (DECL_INITIAL (current_function_decl
)) = restmp
;
1669 restmp
= create_tmp_var_raw (restype
, "retval");
1672 for (arg
= a
; arg
; arg
= DECL_CHAIN (arg
))
1674 vargs
= VEC_alloc (tree
, heap
, nargs
);
1676 VEC_quick_push (tree
, vargs
,
1681 VEC_quick_push (tree
, vargs
, a
);
1682 for (i
= 1, arg
= DECL_CHAIN (a
); i
< nargs
; i
++, arg
= DECL_CHAIN (arg
))
1683 VEC_quick_push (tree
, vargs
, arg
);
1684 call
= gimple_build_call_vec (build_fold_addr_expr_loc (0, alias
), vargs
);
1685 VEC_free (tree
, heap
, vargs
);
1686 gimple_call_set_cannot_inline (call
, true);
1687 gimple_call_set_from_thunk (call
, true);
1689 gimple_call_set_lhs (call
, restmp
);
1690 gsi_insert_after (&bsi
, call
, GSI_NEW_STMT
);
1691 mark_symbols_for_renaming (call
);
1692 find_referenced_vars_in (call
);
1695 if (restmp
&& !this_adjusting
)
1697 tree true_label
= NULL_TREE
;
1699 if (TREE_CODE (TREE_TYPE (restmp
)) == POINTER_TYPE
)
1702 /* If the return type is a pointer, we need to
1703 protect against NULL. We know there will be an
1704 adjustment, because that's why we're emitting a
1706 then_bb
= create_basic_block (NULL
, (void *) 0, bb
);
1707 return_bb
= create_basic_block (NULL
, (void *) 0, then_bb
);
1708 else_bb
= create_basic_block (NULL
, (void *) 0, else_bb
);
1709 remove_edge (single_succ_edge (bb
));
1710 true_label
= gimple_block_label (then_bb
);
1711 stmt
= gimple_build_cond (NE_EXPR
, restmp
,
1712 build_zero_cst (TREE_TYPE (restmp
)),
1713 NULL_TREE
, NULL_TREE
);
1714 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1715 make_edge (bb
, then_bb
, EDGE_TRUE_VALUE
);
1716 make_edge (bb
, else_bb
, EDGE_FALSE_VALUE
);
1717 make_edge (return_bb
, EXIT_BLOCK_PTR
, 0);
1718 make_edge (then_bb
, return_bb
, EDGE_FALLTHRU
);
1719 make_edge (else_bb
, return_bb
, EDGE_FALLTHRU
);
1720 bsi
= gsi_last_bb (then_bb
);
1723 restmp
= thunk_adjust (&bsi
, restmp
, /*this_adjusting=*/0,
1724 fixed_offset
, virtual_offset
);
1728 bsi
= gsi_last_bb (else_bb
);
1729 stmt
= gimple_build_assign (restmp
,
1730 build_zero_cst (TREE_TYPE (restmp
)));
1731 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1732 bsi
= gsi_last_bb (return_bb
);
1736 gimple_call_set_tail (call
, true);
1738 /* Build return value. */
1739 ret
= gimple_build_return (restmp
);
1740 gsi_insert_after (&bsi
, ret
, GSI_NEW_STMT
);
1742 delete_unreachable_blocks ();
1743 update_ssa (TODO_update_ssa
);
1745 /* Since we want to emit the thunk, we explicitly mark its name as
1747 node
->thunk
.thunk_p
= false;
1748 cgraph_node_remove_callees (node
);
1749 cgraph_add_new_function (thunk_fndecl
, true);
1750 bitmap_obstack_release (NULL
);
1752 current_function_decl
= NULL
;
1757 /* Assemble thunks and aliases asociated to NODE. */
1760 assemble_thunks_and_aliases (struct cgraph_node
*node
)
1762 struct cgraph_edge
*e
;
1764 struct ipa_ref
*ref
;
1766 for (e
= node
->callers
; e
;)
1767 if (e
->caller
->thunk
.thunk_p
)
1769 struct cgraph_node
*thunk
= e
->caller
;
1772 assemble_thunks_and_aliases (thunk
);
1773 assemble_thunk (thunk
);
1777 for (i
= 0; ipa_ref_list_refering_iterate (&node
->ref_list
, i
, ref
); i
++)
1778 if (ref
->use
== IPA_REF_ALIAS
)
1780 struct cgraph_node
*alias
= ipa_ref_refering_node (ref
);
1781 assemble_alias (alias
->decl
,
1782 DECL_ASSEMBLER_NAME (alias
->thunk
.alias
));
1783 assemble_thunks_and_aliases (alias
);
1787 /* Expand function specified by NODE. */
1790 cgraph_expand_function (struct cgraph_node
*node
)
1792 tree decl
= node
->decl
;
1794 /* We ought to not compile any inline clones. */
1795 gcc_assert (!node
->global
.inlined_to
);
1797 announce_function (decl
);
1799 assemble_thunks_and_aliases (node
);
1800 gcc_assert (node
->lowered
);
1802 /* Generate RTL for the body of DECL. */
1803 tree_rest_of_compilation (decl
);
1805 /* Make sure that BE didn't give up on compiling. */
1806 gcc_assert (TREE_ASM_WRITTEN (decl
));
1807 current_function_decl
= NULL
;
1808 gcc_assert (!cgraph_preserve_function_body_p (node
));
1809 cgraph_release_function_body (node
);
1810 /* Eliminate all call edges. This is important so the GIMPLE_CALL no longer
1811 points to the dead function body. */
1812 cgraph_node_remove_callees (node
);
1814 cgraph_function_flags_ready
= true;
1817 /* Return true when CALLER_DECL should be inlined into CALLEE_DECL. */
1820 cgraph_inline_p (struct cgraph_edge
*e
, cgraph_inline_failed_t
*reason
)
1822 *reason
= e
->inline_failed
;
1823 return !e
->inline_failed
;
1828 /* Expand all functions that must be output.
1830 Attempt to topologically sort the nodes so function is output when
1831 all called functions are already assembled to allow data to be
1832 propagated across the callgraph. Use a stack to get smaller distance
1833 between a function and its callees (later we may choose to use a more
1834 sophisticated algorithm for function reordering; we will likely want
1835 to use subsections to make the output functions appear in top-down
1839 cgraph_expand_all_functions (void)
1841 struct cgraph_node
*node
;
1842 struct cgraph_node
**order
= XCNEWVEC (struct cgraph_node
*, cgraph_n_nodes
);
1843 int order_pos
, new_order_pos
= 0;
1846 order_pos
= ipa_reverse_postorder (order
);
1847 gcc_assert (order_pos
== cgraph_n_nodes
);
1849 /* Garbage collector may remove inline clones we eliminate during
1850 optimization. So we must be sure to not reference them. */
1851 for (i
= 0; i
< order_pos
; i
++)
1852 if (order
[i
]->process
)
1853 order
[new_order_pos
++] = order
[i
];
1855 for (i
= new_order_pos
- 1; i
>= 0; i
--)
1860 gcc_assert (node
->reachable
);
1862 cgraph_expand_function (node
);
1865 cgraph_process_new_functions ();
1871 /* This is used to sort the node types by the cgraph order number. */
1873 enum cgraph_order_sort_kind
1875 ORDER_UNDEFINED
= 0,
1881 struct cgraph_order_sort
1883 enum cgraph_order_sort_kind kind
;
1886 struct cgraph_node
*f
;
1887 struct varpool_node
*v
;
1888 struct cgraph_asm_node
*a
;
1892 /* Output all functions, variables, and asm statements in the order
1893 according to their order fields, which is the order in which they
1894 appeared in the file. This implements -fno-toplevel-reorder. In
1895 this mode we may output functions and variables which don't really
1896 need to be output. */
1899 cgraph_output_in_order (void)
1902 struct cgraph_order_sort
*nodes
;
1904 struct cgraph_node
*pf
;
1905 struct varpool_node
*pv
;
1906 struct cgraph_asm_node
*pa
;
1909 nodes
= XCNEWVEC (struct cgraph_order_sort
, max
);
1911 varpool_analyze_pending_decls ();
1913 for (pf
= cgraph_nodes
; pf
; pf
= pf
->next
)
1915 if (pf
->process
&& !pf
->thunk
.thunk_p
&& !pf
->alias
)
1918 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1919 nodes
[i
].kind
= ORDER_FUNCTION
;
1924 for (pv
= varpool_nodes_queue
; pv
; pv
= pv
->next_needed
)
1927 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1928 nodes
[i
].kind
= ORDER_VAR
;
1932 for (pa
= cgraph_asm_nodes
; pa
; pa
= pa
->next
)
1935 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1936 nodes
[i
].kind
= ORDER_ASM
;
1940 /* In toplevel reorder mode we output all statics; mark them as needed. */
1941 for (i
= 0; i
< max
; ++i
)
1943 if (nodes
[i
].kind
== ORDER_VAR
)
1945 varpool_mark_needed_node (nodes
[i
].u
.v
);
1948 varpool_empty_needed_queue ();
1950 for (i
= 0; i
< max
; ++i
)
1951 if (nodes
[i
].kind
== ORDER_VAR
)
1952 varpool_finalize_named_section_flags (nodes
[i
].u
.v
);
1954 for (i
= 0; i
< max
; ++i
)
1956 switch (nodes
[i
].kind
)
1958 case ORDER_FUNCTION
:
1959 nodes
[i
].u
.f
->process
= 0;
1960 cgraph_expand_function (nodes
[i
].u
.f
);
1964 varpool_assemble_decl (nodes
[i
].u
.v
);
1968 assemble_asm (nodes
[i
].u
.a
->asm_str
);
1971 case ORDER_UNDEFINED
:
1979 cgraph_asm_nodes
= NULL
;
1983 /* Return true when function body of DECL still needs to be kept around
1984 for later re-use. */
1986 cgraph_preserve_function_body_p (struct cgraph_node
*node
)
1988 gcc_assert (cgraph_global_info_ready
);
1989 gcc_assert (!node
->alias
&& !node
->thunk
.thunk_p
);
1991 /* Look if there is any clone around. */
2001 current_function_decl
= NULL
;
2002 gimple_register_cfg_hooks ();
2003 bitmap_obstack_initialize (NULL
);
2005 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_START
, NULL
);
2009 execute_ipa_pass_list (all_small_ipa_passes
);
2014 /* If pass_all_early_optimizations was not scheduled, the state of
2015 the cgraph will not be properly updated. Update it now. */
2016 if (cgraph_state
< CGRAPH_STATE_IPA_SSA
)
2017 cgraph_state
= CGRAPH_STATE_IPA_SSA
;
2021 /* Generate coverage variables and constructors. */
2024 /* Process new functions added. */
2026 current_function_decl
= NULL
;
2027 cgraph_process_new_functions ();
2029 execute_ipa_summary_passes
2030 ((struct ipa_opt_pass_d
*) all_regular_ipa_passes
);
2033 /* Some targets need to handle LTO assembler output specially. */
2034 if (flag_generate_lto
)
2035 targetm
.asm_out
.lto_start ();
2037 execute_ipa_summary_passes ((struct ipa_opt_pass_d
*) all_lto_gen_passes
);
2040 ipa_write_summaries ();
2042 if (flag_generate_lto
)
2043 targetm
.asm_out
.lto_end ();
2046 execute_ipa_pass_list (all_regular_ipa_passes
);
2047 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_END
, NULL
);
2049 bitmap_obstack_release (NULL
);
2053 /* Perform simple optimizations based on callgraph. */
2056 cgraph_optimize (void)
2061 #ifdef ENABLE_CHECKING
2065 /* Frontend may output common variables after the unit has been finalized.
2066 It is safe to deal with them here as they are always zero initialized. */
2067 varpool_analyze_pending_decls ();
2069 timevar_push (TV_CGRAPHOPT
);
2070 if (pre_ipa_mem_report
)
2072 fprintf (stderr
, "Memory consumption before IPA\n");
2073 dump_memory_report (false);
2076 fprintf (stderr
, "Performing interprocedural optimizations\n");
2077 cgraph_state
= CGRAPH_STATE_IPA
;
2079 /* Don't run the IPA passes if there was any error or sorry messages. */
2083 /* Do nothing else if any IPA pass found errors. */
2086 timevar_pop (TV_CGRAPHOPT
);
2090 /* This pass remove bodies of extern inline functions we never inlined.
2091 Do this later so other IPA passes see what is really going on. */
2092 cgraph_remove_unreachable_nodes (false, dump_file
);
2093 cgraph_global_info_ready
= true;
2094 if (cgraph_dump_file
)
2096 fprintf (cgraph_dump_file
, "Optimized ");
2097 dump_cgraph (cgraph_dump_file
);
2098 dump_varpool (cgraph_dump_file
);
2100 if (post_ipa_mem_report
)
2102 fprintf (stderr
, "Memory consumption after IPA\n");
2103 dump_memory_report (false);
2105 timevar_pop (TV_CGRAPHOPT
);
2107 /* Output everything. */
2108 (*debug_hooks
->assembly_start
) ();
2110 fprintf (stderr
, "Assembling functions:\n");
2111 #ifdef ENABLE_CHECKING
2115 cgraph_materialize_all_clones ();
2116 bitmap_obstack_initialize (NULL
);
2117 execute_ipa_pass_list (all_late_ipa_passes
);
2118 cgraph_remove_unreachable_nodes (true, dump_file
);
2119 #ifdef ENABLE_CHECKING
2122 bitmap_obstack_release (NULL
);
2123 cgraph_mark_functions_to_output ();
2125 cgraph_state
= CGRAPH_STATE_EXPANSION
;
2126 if (!flag_toplevel_reorder
)
2127 cgraph_output_in_order ();
2130 cgraph_output_pending_asms ();
2132 cgraph_expand_all_functions ();
2133 varpool_remove_unreferenced_decls ();
2135 varpool_assemble_pending_decls ();
2137 cgraph_process_new_functions ();
2138 cgraph_state
= CGRAPH_STATE_FINISHED
;
2140 if (cgraph_dump_file
)
2142 fprintf (cgraph_dump_file
, "\nFinal ");
2143 dump_cgraph (cgraph_dump_file
);
2144 dump_varpool (cgraph_dump_file
);
2146 #ifdef ENABLE_CHECKING
2148 /* Double check that all inline clones are gone and that all
2149 function bodies have been released from memory. */
2152 struct cgraph_node
*node
;
2153 bool error_found
= false;
2155 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2157 && (node
->global
.inlined_to
2158 || gimple_has_body_p (node
->decl
)))
2161 dump_cgraph_node (stderr
, node
);
2164 internal_error ("nodes with unreleased memory found");
2172 if (!cgraph_dump_file
)
2173 cgraph_dump_file
= dump_begin (TDI_cgraph
, NULL
);
2176 /* The edges representing the callers of the NEW_VERSION node were
2177 fixed by cgraph_function_versioning (), now the call_expr in their
2178 respective tree code should be updated to call the NEW_VERSION. */
2181 update_call_expr (struct cgraph_node
*new_version
)
2183 struct cgraph_edge
*e
;
2185 gcc_assert (new_version
);
2187 /* Update the call expr on the edges to call the new version. */
2188 for (e
= new_version
->callers
; e
; e
= e
->next_caller
)
2190 struct function
*inner_function
= DECL_STRUCT_FUNCTION (e
->caller
->decl
);
2191 gimple_call_set_fndecl (e
->call_stmt
, new_version
->decl
);
2192 maybe_clean_eh_stmt_fn (inner_function
, e
->call_stmt
);
2197 /* Create a new cgraph node which is the new version of
2198 OLD_VERSION node. REDIRECT_CALLERS holds the callers
2199 edges which should be redirected to point to
2200 NEW_VERSION. ALL the callees edges of OLD_VERSION
2201 are cloned to the new version node. Return the new
2204 If non-NULL BLOCK_TO_COPY determine what basic blocks
2205 was copied to prevent duplications of calls that are dead
2208 static struct cgraph_node
*
2209 cgraph_copy_node_for_versioning (struct cgraph_node
*old_version
,
2211 VEC(cgraph_edge_p
,heap
) *redirect_callers
,
2214 struct cgraph_node
*new_version
;
2215 struct cgraph_edge
*e
;
2218 gcc_assert (old_version
);
2220 new_version
= cgraph_create_node (new_decl
);
2222 new_version
->analyzed
= true;
2223 new_version
->local
= old_version
->local
;
2224 new_version
->local
.externally_visible
= false;
2225 new_version
->local
.local
= true;
2226 new_version
->global
= old_version
->global
;
2227 new_version
->rtl
= old_version
->rtl
;
2228 new_version
->reachable
= true;
2229 new_version
->count
= old_version
->count
;
2231 for (e
= old_version
->callees
; e
; e
=e
->next_callee
)
2233 || bitmap_bit_p (bbs_to_copy
, gimple_bb (e
->call_stmt
)->index
))
2234 cgraph_clone_edge (e
, new_version
, e
->call_stmt
,
2235 e
->lto_stmt_uid
, REG_BR_PROB_BASE
,
2238 for (e
= old_version
->indirect_calls
; e
; e
=e
->next_callee
)
2240 || bitmap_bit_p (bbs_to_copy
, gimple_bb (e
->call_stmt
)->index
))
2241 cgraph_clone_edge (e
, new_version
, e
->call_stmt
,
2242 e
->lto_stmt_uid
, REG_BR_PROB_BASE
,
2245 FOR_EACH_VEC_ELT (cgraph_edge_p
, redirect_callers
, i
, e
)
2247 /* Redirect calls to the old version node to point to its new
2249 cgraph_redirect_edge_callee (e
, new_version
);
2255 /* Perform function versioning.
2256 Function versioning includes copying of the tree and
2257 a callgraph update (creating a new cgraph node and updating
2258 its callees and callers).
2260 REDIRECT_CALLERS varray includes the edges to be redirected
2263 TREE_MAP is a mapping of tree nodes we want to replace with
2264 new ones (according to results of prior analysis).
2265 OLD_VERSION_NODE is the node that is versioned.
2266 It returns the new version's cgraph node.
2267 If non-NULL ARGS_TO_SKIP determine function parameters to remove
2269 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
2270 If non_NULL NEW_ENTRY determine new entry BB of the clone. */
2272 struct cgraph_node
*
2273 cgraph_function_versioning (struct cgraph_node
*old_version_node
,
2274 VEC(cgraph_edge_p
,heap
) *redirect_callers
,
2275 VEC (ipa_replace_map_p
,gc
)* tree_map
,
2276 bitmap args_to_skip
,
2278 basic_block new_entry_block
,
2279 const char *clone_name
)
2281 tree old_decl
= old_version_node
->decl
;
2282 struct cgraph_node
*new_version_node
= NULL
;
2285 if (!tree_versionable_function_p (old_decl
))
2288 gcc_assert (old_version_node
->local
.can_change_signature
|| !args_to_skip
);
2290 /* Make a new FUNCTION_DECL tree node for the
2293 new_decl
= copy_node (old_decl
);
2295 new_decl
= build_function_decl_skip_args (old_decl
, args_to_skip
);
2297 /* Generate a new name for the new version. */
2298 DECL_NAME (new_decl
) = clone_function_name (old_decl
, clone_name
);
2299 SET_DECL_ASSEMBLER_NAME (new_decl
, DECL_NAME (new_decl
));
2300 SET_DECL_RTL (new_decl
, NULL
);
2302 /* Create the new version's call-graph node.
2303 and update the edges of the new node. */
2305 cgraph_copy_node_for_versioning (old_version_node
, new_decl
,
2306 redirect_callers
, bbs_to_copy
);
2308 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2309 tree_function_versioning (old_decl
, new_decl
, tree_map
, false, args_to_skip
,
2310 bbs_to_copy
, new_entry_block
);
2312 /* Update the new version's properties.
2313 Make The new version visible only within this translation unit. Make sure
2314 that is not weak also.
2315 ??? We cannot use COMDAT linkage because there is no
2316 ABI support for this. */
2317 cgraph_make_decl_local (new_version_node
->decl
);
2318 DECL_VIRTUAL_P (new_version_node
->decl
) = 0;
2319 new_version_node
->local
.externally_visible
= 0;
2320 new_version_node
->local
.local
= 1;
2321 new_version_node
->lowered
= true;
2323 /* Update the call_expr on the edges to call the new version node. */
2324 update_call_expr (new_version_node
);
2326 cgraph_call_function_insertion_hooks (new_version_node
);
2327 return new_version_node
;
2330 /* Given virtual clone, turn it into actual clone. */
2332 cgraph_materialize_clone (struct cgraph_node
*node
)
2334 bitmap_obstack_initialize (NULL
);
2335 node
->former_clone_of
= node
->clone_of
->decl
;
2336 if (node
->clone_of
->former_clone_of
)
2337 node
->former_clone_of
= node
->clone_of
->former_clone_of
;
2338 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2339 tree_function_versioning (node
->clone_of
->decl
, node
->decl
,
2340 node
->clone
.tree_map
, true,
2341 node
->clone
.args_to_skip
, NULL
, NULL
);
2342 if (cgraph_dump_file
)
2344 dump_function_to_file (node
->clone_of
->decl
, cgraph_dump_file
, dump_flags
);
2345 dump_function_to_file (node
->decl
, cgraph_dump_file
, dump_flags
);
2348 /* Function is no longer clone. */
2349 if (node
->next_sibling_clone
)
2350 node
->next_sibling_clone
->prev_sibling_clone
= node
->prev_sibling_clone
;
2351 if (node
->prev_sibling_clone
)
2352 node
->prev_sibling_clone
->next_sibling_clone
= node
->next_sibling_clone
;
2354 node
->clone_of
->clones
= node
->next_sibling_clone
;
2355 node
->next_sibling_clone
= NULL
;
2356 node
->prev_sibling_clone
= NULL
;
2357 if (!node
->clone_of
->analyzed
&& !node
->clone_of
->clones
)
2359 cgraph_release_function_body (node
->clone_of
);
2360 cgraph_node_remove_callees (node
->clone_of
);
2361 ipa_remove_all_references (&node
->clone_of
->ref_list
);
2363 node
->clone_of
= NULL
;
2364 bitmap_obstack_release (NULL
);
2367 /* If necessary, change the function declaration in the call statement
2368 associated with E so that it corresponds to the edge callee. */
2371 cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge
*e
)
2373 tree decl
= gimple_call_fndecl (e
->call_stmt
);
2375 gimple_stmt_iterator gsi
;
2376 bool gsi_computed
= false;
2377 #ifdef ENABLE_CHECKING
2378 struct cgraph_node
*node
;
2381 if (e
->indirect_unknown_callee
2382 || decl
== e
->callee
->decl
2383 /* Don't update call from same body alias to the real function. */
2384 || (decl
&& cgraph_get_node (decl
) == cgraph_get_node (e
->callee
->decl
)))
2385 return e
->call_stmt
;
2387 #ifdef ENABLE_CHECKING
2390 node
= cgraph_get_node (decl
);
2391 gcc_assert (!node
|| !node
->clone
.combined_args_to_skip
);
2395 if (cgraph_dump_file
)
2397 fprintf (cgraph_dump_file
, "updating call of %s/%i -> %s/%i: ",
2398 cgraph_node_name (e
->caller
), e
->caller
->uid
,
2399 cgraph_node_name (e
->callee
), e
->callee
->uid
);
2400 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
2401 if (e
->callee
->clone
.combined_args_to_skip
)
2403 fprintf (cgraph_dump_file
, " combined args to skip: ");
2404 dump_bitmap (cgraph_dump_file
,
2405 e
->callee
->clone
.combined_args_to_skip
);
2409 if (e
->indirect_info
&&
2410 e
->indirect_info
->thunk_delta
!= 0
2411 && (!e
->callee
->clone
.combined_args_to_skip
2412 || !bitmap_bit_p (e
->callee
->clone
.combined_args_to_skip
, 0)))
2414 if (cgraph_dump_file
)
2415 fprintf (cgraph_dump_file
, " Thunk delta is "
2416 HOST_WIDE_INT_PRINT_DEC
"\n", e
->indirect_info
->thunk_delta
);
2417 gsi
= gsi_for_stmt (e
->call_stmt
);
2418 gsi_computed
= true;
2419 gimple_adjust_this_by_delta (&gsi
,
2420 build_int_cst (sizetype
,
2421 e
->indirect_info
->thunk_delta
));
2422 e
->indirect_info
->thunk_delta
= 0;
2425 if (e
->callee
->clone
.combined_args_to_skip
)
2430 = gimple_call_copy_skip_args (e
->call_stmt
,
2431 e
->callee
->clone
.combined_args_to_skip
);
2432 gimple_call_set_fndecl (new_stmt
, e
->callee
->decl
);
2434 if (gimple_vdef (new_stmt
)
2435 && TREE_CODE (gimple_vdef (new_stmt
)) == SSA_NAME
)
2436 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt
)) = new_stmt
;
2439 gsi
= gsi_for_stmt (e
->call_stmt
);
2440 gsi_replace (&gsi
, new_stmt
, false);
2441 /* We need to defer cleaning EH info on the new statement to
2442 fixup-cfg. We may not have dominator information at this point
2443 and thus would end up with unreachable blocks and have no way
2444 to communicate that we need to run CFG cleanup then. */
2445 lp_nr
= lookup_stmt_eh_lp (e
->call_stmt
);
2448 remove_stmt_from_eh_lp (e
->call_stmt
);
2449 add_stmt_to_eh_lp (new_stmt
, lp_nr
);
2454 new_stmt
= e
->call_stmt
;
2455 gimple_call_set_fndecl (new_stmt
, e
->callee
->decl
);
2456 update_stmt (new_stmt
);
2459 cgraph_set_call_stmt_including_clones (e
->caller
, e
->call_stmt
, new_stmt
);
2461 if (cgraph_dump_file
)
2463 fprintf (cgraph_dump_file
, " updated to:");
2464 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
2469 /* Once all functions from compilation unit are in memory, produce all clones
2470 and update all calls. We might also do this on demand if we don't want to
2471 bring all functions to memory prior compilation, but current WHOPR
2472 implementation does that and it is is bit easier to keep everything right in
2475 cgraph_materialize_all_clones (void)
2477 struct cgraph_node
*node
;
2478 bool stabilized
= false;
2480 if (cgraph_dump_file
)
2481 fprintf (cgraph_dump_file
, "Materializing clones\n");
2482 #ifdef ENABLE_CHECKING
2486 /* We can also do topological order, but number of iterations should be
2487 bounded by number of IPA passes since single IPA pass is probably not
2488 going to create clones of clones it created itself. */
2492 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2494 if (node
->clone_of
&& node
->decl
!= node
->clone_of
->decl
2495 && !gimple_has_body_p (node
->decl
))
2497 if (gimple_has_body_p (node
->clone_of
->decl
))
2499 if (cgraph_dump_file
)
2501 fprintf (cgraph_dump_file
, "cloning %s to %s\n",
2502 cgraph_node_name (node
->clone_of
),
2503 cgraph_node_name (node
));
2504 if (node
->clone
.tree_map
)
2507 fprintf (cgraph_dump_file
, " replace map: ");
2508 for (i
= 0; i
< VEC_length (ipa_replace_map_p
,
2509 node
->clone
.tree_map
);
2512 struct ipa_replace_map
*replace_info
;
2513 replace_info
= VEC_index (ipa_replace_map_p
,
2514 node
->clone
.tree_map
,
2516 print_generic_expr (cgraph_dump_file
, replace_info
->old_tree
, 0);
2517 fprintf (cgraph_dump_file
, " -> ");
2518 print_generic_expr (cgraph_dump_file
, replace_info
->new_tree
, 0);
2519 fprintf (cgraph_dump_file
, "%s%s;",
2520 replace_info
->replace_p
? "(replace)":"",
2521 replace_info
->ref_p
? "(ref)":"");
2523 fprintf (cgraph_dump_file
, "\n");
2525 if (node
->clone
.args_to_skip
)
2527 fprintf (cgraph_dump_file
, " args_to_skip: ");
2528 dump_bitmap (cgraph_dump_file
, node
->clone
.args_to_skip
);
2530 if (node
->clone
.args_to_skip
)
2532 fprintf (cgraph_dump_file
, " combined_args_to_skip:");
2533 dump_bitmap (cgraph_dump_file
, node
->clone
.combined_args_to_skip
);
2536 cgraph_materialize_clone (node
);
2542 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2543 if (!node
->analyzed
&& node
->callees
)
2544 cgraph_node_remove_callees (node
);
2545 if (cgraph_dump_file
)
2546 fprintf (cgraph_dump_file
, "Materialization Call site updates done.\n");
2547 #ifdef ENABLE_CHECKING
2550 cgraph_remove_unreachable_nodes (false, cgraph_dump_file
);
2553 #include "gt-cgraphunit.h"