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. */
1482 if (!vtable_entry_type)
1484 tree vfunc_type = make_node (FUNCTION_TYPE);
1485 TREE_TYPE (vfunc_type) = integer_type_node;
1486 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
1487 layout_type (vfunc_type);
1489 vtable_entry_type = build_pointer_type (vfunc_type);
1493 create_tmp_var (build_pointer_type
1494 (build_pointer_type (vtable_entry_type)), "vptr");
1496 /* The vptr is always at offset zero in the object. */
1497 stmt = gimple_build_assign (vtabletmp,
1498 build1 (NOP_EXPR, TREE_TYPE (vtabletmp),
1500 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1501 mark_symbols_for_renaming (stmt);
1502 find_referenced_vars_in (stmt);
1504 /* Form the vtable address. */
1505 vtabletmp2 = create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp)),
1507 stmt = gimple_build_assign (vtabletmp2,
1508 build_simple_mem_ref (vtabletmp));
1509 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1510 mark_symbols_for_renaming (stmt);
1511 find_referenced_vars_in (stmt);
1513 /* Find the entry with the vcall offset. */
1514 stmt = gimple_build_assign (vtabletmp2,
1515 fold_build_pointer_plus_loc (input_location,
1518 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1520 /* Get the offset itself. */
1521 vtabletmp3 = create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp2)),
1523 stmt = gimple_build_assign (vtabletmp3,
1524 build_simple_mem_ref (vtabletmp2));
1525 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1526 mark_symbols_for_renaming (stmt);
1527 find_referenced_vars_in (stmt);
1529 /* Adjust the `this' pointer. */
1530 ptr = fold_build_pointer_plus_loc (input_location, ptr, vtabletmp3);
1531 ptr = force_gimple_operand_gsi (bsi, ptr, true, NULL_TREE, false,
1532 GSI_CONTINUE_LINKING);
1536 && fixed_offset != 0)
1537 /* Adjust the pointer by the constant. */
1541 if (TREE_CODE (ptr) == VAR_DECL)
1545 ptrtmp = create_tmp_var (TREE_TYPE (ptr), "ptr");
1546 stmt = gimple_build_assign (ptrtmp, ptr);
1547 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1548 mark_symbols_for_renaming (stmt);
1549 find_referenced_vars_in (stmt);
1551 ptr = fold_build_pointer_plus_hwi_loc (input_location,
1552 ptrtmp, fixed_offset);
1555 /* Emit the statement and gimplify the adjustment expression. */
1556 ret = create_tmp_var (TREE_TYPE (ptr), "adjusted_this");
1557 stmt = gimple_build_assign (ret, ptr);
1558 mark_symbols_for_renaming (stmt);
1559 find_referenced_vars_in (stmt);
1560 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1565 /* Produce assembler for thunk NODE. */
1568 assemble_thunk (struct cgraph_node *node)
1570 bool this_adjusting = node->thunk.this_adjusting;
1571 HOST_WIDE_INT fixed_offset = node->thunk.fixed_offset;
1572 HOST_WIDE_INT virtual_value = node->thunk.virtual_value;
1573 tree virtual_offset = NULL;
1574 tree alias = node->thunk.alias;
1575 tree thunk_fndecl = node->decl;
1576 tree a = DECL_ARGUMENTS (thunk_fndecl);
1578 current_function_decl = thunk_fndecl;
1580 /* Ensure thunks are emitted in their correct sections. */
1581 resolve_unique_section (thunk_fndecl, 0, flag_function_sections);
1584 && targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
1585 virtual_value, alias))
1589 tree restype = TREE_TYPE (TREE_TYPE (thunk_fndecl));
1591 DECL_RESULT (thunk_fndecl)
1592 = build_decl (DECL_SOURCE_LOCATION (thunk_fndecl),
1593 RESULT_DECL, 0, restype);
1594 fnname = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk_fndecl));
1596 /* The back end expects DECL_INITIAL to contain a BLOCK, so we
1598 fn_block = make_node (BLOCK);
1599 BLOCK_VARS (fn_block) = a;
1600 DECL_INITIAL (thunk_fndecl) = fn_block;
1601 init_function_start (thunk_fndecl);
1603 assemble_start_function (thunk_fndecl, fnname);
1605 targetm.asm_out.output_mi_thunk (asm_out_file, thunk_fndecl,
1606 fixed_offset, virtual_value, alias);
1608 assemble_end_function (thunk_fndecl, fnname);
1609 init_insn_lengths ();
1610 free_after_compilation (cfun);
1612 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
1613 node->thunk.thunk_p = false;
1614 node->analyzed = false;
1619 basic_block bb, then_bb, else_bb, return_bb;
1620 gimple_stmt_iterator bsi;
1626 VEC(tree, heap) *vargs;
1631 DECL_IGNORED_P (thunk_fndecl) = 1;
1632 bitmap_obstack_initialize (NULL);
1634 if (node->thunk.virtual_offset_p)
1635 virtual_offset = size_int (virtual_value);
1637 /* Build the return declaration for the function. */
1638 restype = TREE_TYPE (TREE_TYPE (thunk_fndecl));
1639 if (DECL_RESULT (thunk_fndecl) == NULL_TREE)
1641 resdecl = build_decl (input_location, RESULT_DECL, 0, restype);
1642 DECL_ARTIFICIAL (resdecl) = 1;
1643 DECL_IGNORED_P (resdecl) = 1;
1644 DECL_RESULT (thunk_fndecl) = resdecl;
1647 resdecl = DECL_RESULT (thunk_fndecl);
1649 bb = then_bb = else_bb = return_bb = init_lowered_empty_function (thunk_fndecl);
1651 bsi = gsi_start_bb (bb);
1653 /* Build call to the function being thunked. */
1654 if (!VOID_TYPE_P (restype))
1656 if (!is_gimple_reg_type (restype))
1659 add_local_decl (cfun, restmp);
1660 BLOCK_VARS (DECL_INITIAL (current_function_decl)) = restmp;
1663 restmp = create_tmp_var_raw (restype, "retval");
1666 for (arg = a; arg; arg = DECL_CHAIN (arg))
1668 vargs = VEC_alloc (tree, heap, nargs);
1670 VEC_quick_push (tree, vargs,
1675 VEC_quick_push (tree, vargs, a);
1676 for (i = 1, arg = DECL_CHAIN (a); i < nargs; i++, arg = DECL_CHAIN (arg))
1677 VEC_quick_push (tree, vargs, arg);
1678 call = gimple_build_call_vec (build_fold_addr_expr_loc (0, alias), vargs);
1679 VEC_free (tree, heap, vargs);
1680 gimple_call_set_cannot_inline (call, true);
1681 gimple_call_set_from_thunk (call, true);
1683 gimple_call_set_lhs (call, restmp);
1684 gsi_insert_after (&bsi, call, GSI_NEW_STMT);
1685 mark_symbols_for_renaming (call);
1686 find_referenced_vars_in (call);
1689 if (restmp && !this_adjusting)
1691 tree true_label = NULL_TREE;
1693 if (TREE_CODE (TREE_TYPE (restmp)) == POINTER_TYPE)
1696 /* If the return type is a pointer, we need to
1697 protect against NULL. We know there will be an
1698 adjustment, because that's why we're emitting a
1700 then_bb = create_basic_block (NULL, (void *) 0, bb);
1701 return_bb = create_basic_block (NULL, (void *) 0, then_bb);
1702 else_bb = create_basic_block (NULL, (void *) 0, else_bb);
1703 remove_edge (single_succ_edge (bb));
1704 true_label = gimple_block_label (then_bb);
1705 stmt = gimple_build_cond (NE_EXPR, restmp,
1706 build_zero_cst (TREE_TYPE (restmp)),
1707 NULL_TREE, NULL_TREE);
1708 gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
1709 make_edge (bb, then_bb, EDGE_TRUE_VALUE);
1710 make_edge (bb, else_bb, EDGE_FALSE_VALUE);
1711 make_edge (return_bb, EXIT_BLOCK_PTR, 0);
1712 make_edge (then_bb, return_bb, EDGE_FALLTHRU);
1713 make_edge (else_bb, return_bb, EDGE_FALLTHRU);
1714 bsi = gsi_last_bb (then_bb);
1717 restmp = thunk_adjust (&bsi, restmp, /*this_adjusting=*/0,
1718 fixed_offset, virtual_offset);
1722 bsi = gsi_last_bb (else_bb);
1723 stmt = gimple_build_assign (restmp,
1724 build_zero_cst (TREE_TYPE (restmp)));
1725 gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
1726 bsi = gsi_last_bb (return_bb);
1730 gimple_call_set_tail (call, true);
1732 /* Build return value. */
1733 ret = gimple_build_return (restmp);
1734 gsi_insert_after (&bsi, ret, GSI_NEW_STMT);
1736 delete_unreachable_blocks ();
1737 update_ssa (TODO_update_ssa);
1739 /* Since we want to emit the thunk, we explicitly mark its name as
1741 node->thunk.thunk_p = false;
1742 cgraph_node_remove_callees (node);
1743 cgraph_add_new_function (thunk_fndecl, true);
1744 bitmap_obstack_release (NULL);
1746 current_function_decl = NULL;
1751 /* Assemble thunks and aliases asociated to NODE. */
1754 assemble_thunks_and_aliases (struct cgraph_node *node)
1756 struct cgraph_edge *e;
1758 struct ipa_ref *ref;
1760 for (e = node->callers; e;)
1761 if (e->caller->thunk.thunk_p)
1763 struct cgraph_node *thunk = e->caller;
1766 assemble_thunks_and_aliases (thunk);
1767 assemble_thunk (thunk);
1771 for (i = 0; ipa_ref_list_refering_iterate (&node->ref_list, i, ref); i++)
1772 if (ref->use == IPA_REF_ALIAS)
1774 struct cgraph_node *alias = ipa_ref_refering_node (ref);
1775 bool saved_written = TREE_ASM_WRITTEN (alias->thunk.alias);
1777 /* Force assemble_alias to really output the alias this time instead
1778 of buffering it in same alias pairs. */
1779 TREE_ASM_WRITTEN (alias->thunk.alias) = 1;
1780 assemble_alias (alias->decl,
1781 DECL_ASSEMBLER_NAME (alias->thunk.alias));
1782 assemble_thunks_and_aliases (alias);
1783 TREE_ASM_WRITTEN (alias->thunk.alias) = saved_written;
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 ();
2045 if (!flag_ltrans && (in_lto_p || !flag_lto || flag_fat_lto_objects))
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 or if we are just streaming LTO. */
2085 || (!in_lto_p && flag_lto && !flag_fat_lto_objects))
2087 timevar_pop (TV_CGRAPHOPT);
2091 /* This pass remove bodies of extern inline functions we never inlined.
2092 Do this later so other IPA passes see what is really going on. */
2093 cgraph_remove_unreachable_nodes (false, dump_file);
2094 cgraph_global_info_ready = true;
2095 if (cgraph_dump_file)
2097 fprintf (cgraph_dump_file, "Optimized ");
2098 dump_cgraph (cgraph_dump_file);
2099 dump_varpool (cgraph_dump_file);
2101 if (post_ipa_mem_report)
2103 fprintf (stderr, "Memory consumption after IPA\n");
2104 dump_memory_report (false);
2106 timevar_pop (TV_CGRAPHOPT);
2108 /* Output everything. */
2109 (*debug_hooks->assembly_start) ();
2111 fprintf (stderr, "Assembling functions:\n");
2112 #ifdef ENABLE_CHECKING
2116 cgraph_materialize_all_clones ();
2117 bitmap_obstack_initialize (NULL);
2118 execute_ipa_pass_list (all_late_ipa_passes);
2119 cgraph_remove_unreachable_nodes (true, dump_file);
2120 #ifdef ENABLE_CHECKING
2123 bitmap_obstack_release (NULL);
2124 cgraph_mark_functions_to_output ();
2126 cgraph_state = CGRAPH_STATE_EXPANSION;
2127 if (!flag_toplevel_reorder)
2128 cgraph_output_in_order ();
2131 cgraph_output_pending_asms ();
2133 cgraph_expand_all_functions ();
2134 varpool_remove_unreferenced_decls ();
2136 varpool_assemble_pending_decls ();
2138 cgraph_process_new_functions ();
2139 cgraph_state = CGRAPH_STATE_FINISHED;
2141 if (cgraph_dump_file)
2143 fprintf (cgraph_dump_file, "\nFinal ");
2144 dump_cgraph (cgraph_dump_file);
2145 dump_varpool (cgraph_dump_file);
2147 #ifdef ENABLE_CHECKING
2149 /* Double check that all inline clones are gone and that all
2150 function bodies have been released from memory. */
2153 struct cgraph_node *node;
2154 bool error_found = false;
2156 for (node = cgraph_nodes; node; node = node->next)
2158 && (node->global.inlined_to
2159 || gimple_has_body_p (node->decl)))
2162 dump_cgraph_node (stderr, node);
2165 internal_error ("nodes with unreleased memory found");
2173 if (!cgraph_dump_file)
2174 cgraph_dump_file = dump_begin (TDI_cgraph, NULL);
2177 /* The edges representing the callers of the NEW_VERSION node were
2178 fixed by cgraph_function_versioning (), now the call_expr in their
2179 respective tree code should be updated to call the NEW_VERSION. */
2182 update_call_expr (struct cgraph_node *new_version)
2184 struct cgraph_edge *e;
2186 gcc_assert (new_version);
2188 /* Update the call expr on the edges to call the new version. */
2189 for (e = new_version->callers; e; e = e->next_caller)
2191 struct function *inner_function = DECL_STRUCT_FUNCTION (e->caller->decl);
2192 gimple_call_set_fndecl (e->call_stmt, new_version->decl);
2193 maybe_clean_eh_stmt_fn (inner_function, e->call_stmt);
2198 /* Create a new cgraph node which is the new version of
2199 OLD_VERSION node. REDIRECT_CALLERS holds the callers
2200 edges which should be redirected to point to
2201 NEW_VERSION. ALL the callees edges of OLD_VERSION
2202 are cloned to the new version node. Return the new
2205 If non-NULL BLOCK_TO_COPY determine what basic blocks
2206 was copied to prevent duplications of calls that are dead
2209 static struct cgraph_node *
2210 cgraph_copy_node_for_versioning (struct cgraph_node *old_version,
2212 VEC(cgraph_edge_p,heap) *redirect_callers,
2215 struct cgraph_node *new_version;
2216 struct cgraph_edge *e;
2219 gcc_assert (old_version);
2221 new_version = cgraph_create_node (new_decl);
2223 new_version->analyzed = true;
2224 new_version->local = old_version->local;
2225 new_version->local.externally_visible = false;
2226 new_version->local.local = true;
2227 new_version->global = old_version->global;
2228 new_version->rtl = old_version->rtl;
2229 new_version->reachable = true;
2230 new_version->count = old_version->count;
2232 for (e = old_version->callees; e; e=e->next_callee)
2234 || bitmap_bit_p (bbs_to_copy, gimple_bb (e->call_stmt)->index))
2235 cgraph_clone_edge (e, new_version, e->call_stmt,
2236 e->lto_stmt_uid, REG_BR_PROB_BASE,
2239 for (e = old_version->indirect_calls; e; e=e->next_callee)
2241 || bitmap_bit_p (bbs_to_copy, gimple_bb (e->call_stmt)->index))
2242 cgraph_clone_edge (e, new_version, e->call_stmt,
2243 e->lto_stmt_uid, REG_BR_PROB_BASE,
2246 FOR_EACH_VEC_ELT (cgraph_edge_p, redirect_callers, i, e)
2248 /* Redirect calls to the old version node to point to its new
2250 cgraph_redirect_edge_callee (e, new_version);
2256 /* Perform function versioning.
2257 Function versioning includes copying of the tree and
2258 a callgraph update (creating a new cgraph node and updating
2259 its callees and callers).
2261 REDIRECT_CALLERS varray includes the edges to be redirected
2264 TREE_MAP is a mapping of tree nodes we want to replace with
2265 new ones (according to results of prior analysis).
2266 OLD_VERSION_NODE is the node that is versioned.
2267 It returns the new version's cgraph node.
2268 If non-NULL ARGS_TO_SKIP determine function parameters to remove
2270 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
2271 If non_NULL NEW_ENTRY determine new entry BB of the clone. */
2273 struct cgraph_node *
2274 cgraph_function_versioning (struct cgraph_node *old_version_node,
2275 VEC(cgraph_edge_p,heap) *redirect_callers,
2276 VEC (ipa_replace_map_p,gc)* tree_map,
2277 bitmap args_to_skip,
2279 basic_block new_entry_block,
2280 const char *clone_name)
2282 tree old_decl = old_version_node->decl;
2283 struct cgraph_node *new_version_node = NULL;
2286 if (!tree_versionable_function_p (old_decl))
2289 gcc_assert (old_version_node->local.can_change_signature || !args_to_skip);
2291 /* Make a new FUNCTION_DECL tree node for the
2294 new_decl = copy_node (old_decl);
2296 new_decl = build_function_decl_skip_args (old_decl, args_to_skip);
2298 /* Generate a new name for the new version. */
2299 DECL_NAME (new_decl) = clone_function_name (old_decl, clone_name);
2300 SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
2301 SET_DECL_RTL (new_decl, NULL);
2303 /* Create the new version's call-graph node.
2304 and update the edges of the new node. */
2306 cgraph_copy_node_for_versioning (old_version_node, new_decl,
2307 redirect_callers, bbs_to_copy);
2309 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2310 tree_function_versioning (old_decl, new_decl, tree_map, false, args_to_skip,
2311 bbs_to_copy, new_entry_block);
2313 /* Update the new version's properties.
2314 Make The new version visible only within this translation unit. Make sure
2315 that is not weak also.
2316 ??? We cannot use COMDAT linkage because there is no
2317 ABI support for this. */
2318 cgraph_make_decl_local (new_version_node->decl);
2319 DECL_VIRTUAL_P (new_version_node->decl) = 0;
2320 new_version_node->local.externally_visible = 0;
2321 new_version_node->local.local = 1;
2322 new_version_node->lowered = true;
2324 /* Update the call_expr on the edges to call the new version node. */
2325 update_call_expr (new_version_node);
2327 cgraph_call_function_insertion_hooks (new_version_node);
2328 return new_version_node;
2331 /* Given virtual clone, turn it into actual clone. */
2333 cgraph_materialize_clone (struct cgraph_node *node)
2335 bitmap_obstack_initialize (NULL);
2336 node->former_clone_of = node->clone_of->decl;
2337 if (node->clone_of->former_clone_of)
2338 node->former_clone_of = node->clone_of->former_clone_of;
2339 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2340 tree_function_versioning (node->clone_of->decl, node->decl,
2341 node->clone.tree_map, true,
2342 node->clone.args_to_skip, NULL, NULL);
2343 if (cgraph_dump_file)
2345 dump_function_to_file (node->clone_of->decl, cgraph_dump_file, dump_flags);
2346 dump_function_to_file (node->decl, cgraph_dump_file, dump_flags);
2349 /* Function is no longer clone. */
2350 if (node->next_sibling_clone)
2351 node->next_sibling_clone->prev_sibling_clone = node->prev_sibling_clone;
2352 if (node->prev_sibling_clone)
2353 node->prev_sibling_clone->next_sibling_clone = node->next_sibling_clone;
2355 node->clone_of->clones = node->next_sibling_clone;
2356 node->next_sibling_clone = NULL;
2357 node->prev_sibling_clone = NULL;
2358 if (!node->clone_of->analyzed && !node->clone_of->clones)
2360 cgraph_release_function_body (node->clone_of);
2361 cgraph_node_remove_callees (node->clone_of);
2362 ipa_remove_all_references (&node->clone_of->ref_list);
2364 node->clone_of = NULL;
2365 bitmap_obstack_release (NULL);
2368 /* If necessary, change the function declaration in the call statement
2369 associated with E so that it corresponds to the edge callee. */
2372 cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge *e)
2374 tree decl = gimple_call_fndecl (e->call_stmt);
2376 gimple_stmt_iterator gsi;
2377 #ifdef ENABLE_CHECKING
2378 struct cgraph_node *node;
2381 if (e->indirect_unknown_callee
2382 || decl == e->callee->decl)
2383 return e->call_stmt;
2385 #ifdef ENABLE_CHECKING
2388 node = cgraph_get_node (decl);
2389 gcc_assert (!node || !node->clone.combined_args_to_skip);
2393 if (cgraph_dump_file)
2395 fprintf (cgraph_dump_file, "updating call of %s/%i -> %s/%i: ",
2396 cgraph_node_name (e->caller), e->caller->uid,
2397 cgraph_node_name (e->callee), e->callee->uid);
2398 print_gimple_stmt (cgraph_dump_file, e->call_stmt, 0, dump_flags);
2399 if (e->callee->clone.combined_args_to_skip)
2401 fprintf (cgraph_dump_file, " combined args to skip: ");
2402 dump_bitmap (cgraph_dump_file,
2403 e->callee->clone.combined_args_to_skip);
2407 if (e->callee->clone.combined_args_to_skip)
2412 = gimple_call_copy_skip_args (e->call_stmt,
2413 e->callee->clone.combined_args_to_skip);
2414 gimple_call_set_fndecl (new_stmt, e->callee->decl);
2416 if (gimple_vdef (new_stmt)
2417 && TREE_CODE (gimple_vdef (new_stmt)) == SSA_NAME)
2418 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt)) = new_stmt;
2420 gsi = gsi_for_stmt (e->call_stmt);
2421 gsi_replace (&gsi, new_stmt, false);
2422 /* We need to defer cleaning EH info on the new statement to
2423 fixup-cfg. We may not have dominator information at this point
2424 and thus would end up with unreachable blocks and have no way
2425 to communicate that we need to run CFG cleanup then. */
2426 lp_nr = lookup_stmt_eh_lp (e->call_stmt);
2429 remove_stmt_from_eh_lp (e->call_stmt);
2430 add_stmt_to_eh_lp (new_stmt, lp_nr);
2435 new_stmt = e->call_stmt;
2436 gimple_call_set_fndecl (new_stmt, e->callee->decl);
2437 update_stmt (new_stmt);
2440 cgraph_set_call_stmt_including_clones (e->caller, e->call_stmt, new_stmt);
2442 if (cgraph_dump_file)
2444 fprintf (cgraph_dump_file, " updated to:");
2445 print_gimple_stmt (cgraph_dump_file, e->call_stmt, 0, dump_flags);
2450 /* Once all functions from compilation unit are in memory, produce all clones
2451 and update all calls. We might also do this on demand if we don't want to
2452 bring all functions to memory prior compilation, but current WHOPR
2453 implementation does that and it is is bit easier to keep everything right in
2456 cgraph_materialize_all_clones (void)
2458 struct cgraph_node *node;
2459 bool stabilized = false;
2461 if (cgraph_dump_file)
2462 fprintf (cgraph_dump_file, "Materializing clones\n");
2463 #ifdef ENABLE_CHECKING
2467 /* We can also do topological order, but number of iterations should be
2468 bounded by number of IPA passes since single IPA pass is probably not
2469 going to create clones of clones it created itself. */
2473 for (node = cgraph_nodes; node; node = node->next)
2475 if (node->clone_of && node->decl != node->clone_of->decl
2476 && !gimple_has_body_p (node->decl))
2478 if (gimple_has_body_p (node->clone_of->decl))
2480 if (cgraph_dump_file)
2482 fprintf (cgraph_dump_file, "cloning %s to %s\n",
2483 cgraph_node_name (node->clone_of),
2484 cgraph_node_name (node));
2485 if (node->clone.tree_map)
2488 fprintf (cgraph_dump_file, " replace map: ");
2489 for (i = 0; i < VEC_length (ipa_replace_map_p,
2490 node->clone.tree_map);
2493 struct ipa_replace_map *replace_info;
2494 replace_info = VEC_index (ipa_replace_map_p,
2495 node->clone.tree_map,
2497 print_generic_expr (cgraph_dump_file, replace_info->old_tree, 0);
2498 fprintf (cgraph_dump_file, " -> ");
2499 print_generic_expr (cgraph_dump_file, replace_info->new_tree, 0);
2500 fprintf (cgraph_dump_file, "%s%s;",
2501 replace_info->replace_p ? "(replace)":"",
2502 replace_info->ref_p ? "(ref)":"");
2504 fprintf (cgraph_dump_file, "\n");
2506 if (node->clone.args_to_skip)
2508 fprintf (cgraph_dump_file, " args_to_skip: ");
2509 dump_bitmap (cgraph_dump_file, node->clone.args_to_skip);
2511 if (node->clone.args_to_skip)
2513 fprintf (cgraph_dump_file, " combined_args_to_skip:");
2514 dump_bitmap (cgraph_dump_file, node->clone.combined_args_to_skip);
2517 cgraph_materialize_clone (node);
2523 for (node = cgraph_nodes; node; node = node->next)
2524 if (!node->analyzed && node->callees)
2525 cgraph_node_remove_callees (node);
2526 if (cgraph_dump_file)
2527 fprintf (cgraph_dump_file, "Materialization Call site updates done.\n");
2528 #ifdef ENABLE_CHECKING
2531 cgraph_remove_unreachable_nodes (false, cgraph_dump_file);
2534 #include "gt-cgraphunit.h"