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 assemble_alias (alias->decl,
1776 DECL_ASSEMBLER_NAME (alias->thunk.alias));
1777 assemble_thunks_and_aliases (alias);
1781 /* Expand function specified by NODE. */
1784 cgraph_expand_function (struct cgraph_node *node)
1786 tree decl = node->decl;
1788 /* We ought to not compile any inline clones. */
1789 gcc_assert (!node->global.inlined_to);
1791 announce_function (decl);
1793 assemble_thunks_and_aliases (node);
1794 gcc_assert (node->lowered);
1796 /* Generate RTL for the body of DECL. */
1797 tree_rest_of_compilation (decl);
1799 /* Make sure that BE didn't give up on compiling. */
1800 gcc_assert (TREE_ASM_WRITTEN (decl));
1801 current_function_decl = NULL;
1802 gcc_assert (!cgraph_preserve_function_body_p (node));
1803 cgraph_release_function_body (node);
1804 /* Eliminate all call edges. This is important so the GIMPLE_CALL no longer
1805 points to the dead function body. */
1806 cgraph_node_remove_callees (node);
1808 cgraph_function_flags_ready = true;
1811 /* Return true when CALLER_DECL should be inlined into CALLEE_DECL. */
1814 cgraph_inline_p (struct cgraph_edge *e, cgraph_inline_failed_t *reason)
1816 *reason = e->inline_failed;
1817 return !e->inline_failed;
1822 /* Expand all functions that must be output.
1824 Attempt to topologically sort the nodes so function is output when
1825 all called functions are already assembled to allow data to be
1826 propagated across the callgraph. Use a stack to get smaller distance
1827 between a function and its callees (later we may choose to use a more
1828 sophisticated algorithm for function reordering; we will likely want
1829 to use subsections to make the output functions appear in top-down
1833 cgraph_expand_all_functions (void)
1835 struct cgraph_node *node;
1836 struct cgraph_node **order = XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
1837 int order_pos, new_order_pos = 0;
1840 order_pos = ipa_reverse_postorder (order);
1841 gcc_assert (order_pos == cgraph_n_nodes);
1843 /* Garbage collector may remove inline clones we eliminate during
1844 optimization. So we must be sure to not reference them. */
1845 for (i = 0; i < order_pos; i++)
1846 if (order[i]->process)
1847 order[new_order_pos++] = order[i];
1849 for (i = new_order_pos - 1; i >= 0; i--)
1854 gcc_assert (node->reachable);
1856 cgraph_expand_function (node);
1859 cgraph_process_new_functions ();
1865 /* This is used to sort the node types by the cgraph order number. */
1867 enum cgraph_order_sort_kind
1869 ORDER_UNDEFINED = 0,
1875 struct cgraph_order_sort
1877 enum cgraph_order_sort_kind kind;
1880 struct cgraph_node *f;
1881 struct varpool_node *v;
1882 struct cgraph_asm_node *a;
1886 /* Output all functions, variables, and asm statements in the order
1887 according to their order fields, which is the order in which they
1888 appeared in the file. This implements -fno-toplevel-reorder. In
1889 this mode we may output functions and variables which don't really
1890 need to be output. */
1893 cgraph_output_in_order (void)
1896 struct cgraph_order_sort *nodes;
1898 struct cgraph_node *pf;
1899 struct varpool_node *pv;
1900 struct cgraph_asm_node *pa;
1903 nodes = XCNEWVEC (struct cgraph_order_sort, max);
1905 varpool_analyze_pending_decls ();
1907 for (pf = cgraph_nodes; pf; pf = pf->next)
1909 if (pf->process && !pf->thunk.thunk_p && !pf->alias)
1912 gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
1913 nodes[i].kind = ORDER_FUNCTION;
1918 for (pv = varpool_nodes_queue; pv; pv = pv->next_needed)
1921 gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
1922 nodes[i].kind = ORDER_VAR;
1926 for (pa = cgraph_asm_nodes; pa; pa = pa->next)
1929 gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
1930 nodes[i].kind = ORDER_ASM;
1934 /* In toplevel reorder mode we output all statics; mark them as needed. */
1935 for (i = 0; i < max; ++i)
1937 if (nodes[i].kind == ORDER_VAR)
1939 varpool_mark_needed_node (nodes[i].u.v);
1942 varpool_empty_needed_queue ();
1944 for (i = 0; i < max; ++i)
1945 if (nodes[i].kind == ORDER_VAR)
1946 varpool_finalize_named_section_flags (nodes[i].u.v);
1948 for (i = 0; i < max; ++i)
1950 switch (nodes[i].kind)
1952 case ORDER_FUNCTION:
1953 nodes[i].u.f->process = 0;
1954 cgraph_expand_function (nodes[i].u.f);
1958 varpool_assemble_decl (nodes[i].u.v);
1962 assemble_asm (nodes[i].u.a->asm_str);
1965 case ORDER_UNDEFINED:
1973 cgraph_asm_nodes = NULL;
1977 /* Return true when function body of DECL still needs to be kept around
1978 for later re-use. */
1980 cgraph_preserve_function_body_p (struct cgraph_node *node)
1982 gcc_assert (cgraph_global_info_ready);
1983 gcc_assert (!node->alias && !node->thunk.thunk_p);
1985 /* Look if there is any clone around. */
1995 current_function_decl = NULL;
1996 gimple_register_cfg_hooks ();
1997 bitmap_obstack_initialize (NULL);
1999 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_START, NULL);
2003 execute_ipa_pass_list (all_small_ipa_passes);
2008 /* If pass_all_early_optimizations was not scheduled, the state of
2009 the cgraph will not be properly updated. Update it now. */
2010 if (cgraph_state < CGRAPH_STATE_IPA_SSA)
2011 cgraph_state = CGRAPH_STATE_IPA_SSA;
2015 /* Generate coverage variables and constructors. */
2018 /* Process new functions added. */
2020 current_function_decl = NULL;
2021 cgraph_process_new_functions ();
2023 execute_ipa_summary_passes
2024 ((struct ipa_opt_pass_d *) all_regular_ipa_passes);
2027 /* Some targets need to handle LTO assembler output specially. */
2028 if (flag_generate_lto)
2029 targetm.asm_out.lto_start ();
2031 execute_ipa_summary_passes ((struct ipa_opt_pass_d *) all_lto_gen_passes);
2034 ipa_write_summaries ();
2036 if (flag_generate_lto)
2037 targetm.asm_out.lto_end ();
2040 execute_ipa_pass_list (all_regular_ipa_passes);
2041 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_END, NULL);
2043 bitmap_obstack_release (NULL);
2047 /* Perform simple optimizations based on callgraph. */
2050 cgraph_optimize (void)
2055 #ifdef ENABLE_CHECKING
2059 /* Frontend may output common variables after the unit has been finalized.
2060 It is safe to deal with them here as they are always zero initialized. */
2061 varpool_analyze_pending_decls ();
2063 timevar_push (TV_CGRAPHOPT);
2064 if (pre_ipa_mem_report)
2066 fprintf (stderr, "Memory consumption before IPA\n");
2067 dump_memory_report (false);
2070 fprintf (stderr, "Performing interprocedural optimizations\n");
2071 cgraph_state = CGRAPH_STATE_IPA;
2073 /* Don't run the IPA passes if there was any error or sorry messages. */
2077 /* Do nothing else if any IPA pass found errors. */
2080 timevar_pop (TV_CGRAPHOPT);
2084 /* This pass remove bodies of extern inline functions we never inlined.
2085 Do this later so other IPA passes see what is really going on. */
2086 cgraph_remove_unreachable_nodes (false, dump_file);
2087 cgraph_global_info_ready = true;
2088 if (cgraph_dump_file)
2090 fprintf (cgraph_dump_file, "Optimized ");
2091 dump_cgraph (cgraph_dump_file);
2092 dump_varpool (cgraph_dump_file);
2094 if (post_ipa_mem_report)
2096 fprintf (stderr, "Memory consumption after IPA\n");
2097 dump_memory_report (false);
2099 timevar_pop (TV_CGRAPHOPT);
2101 /* Output everything. */
2102 (*debug_hooks->assembly_start) ();
2104 fprintf (stderr, "Assembling functions:\n");
2105 #ifdef ENABLE_CHECKING
2109 cgraph_materialize_all_clones ();
2110 bitmap_obstack_initialize (NULL);
2111 execute_ipa_pass_list (all_late_ipa_passes);
2112 cgraph_remove_unreachable_nodes (true, dump_file);
2113 #ifdef ENABLE_CHECKING
2116 bitmap_obstack_release (NULL);
2117 cgraph_mark_functions_to_output ();
2119 cgraph_state = CGRAPH_STATE_EXPANSION;
2120 if (!flag_toplevel_reorder)
2121 cgraph_output_in_order ();
2124 cgraph_output_pending_asms ();
2126 cgraph_expand_all_functions ();
2127 varpool_remove_unreferenced_decls ();
2129 varpool_assemble_pending_decls ();
2131 cgraph_process_new_functions ();
2132 cgraph_state = CGRAPH_STATE_FINISHED;
2134 if (cgraph_dump_file)
2136 fprintf (cgraph_dump_file, "\nFinal ");
2137 dump_cgraph (cgraph_dump_file);
2138 dump_varpool (cgraph_dump_file);
2140 #ifdef ENABLE_CHECKING
2142 /* Double check that all inline clones are gone and that all
2143 function bodies have been released from memory. */
2146 struct cgraph_node *node;
2147 bool error_found = false;
2149 for (node = cgraph_nodes; node; node = node->next)
2151 && (node->global.inlined_to
2152 || gimple_has_body_p (node->decl)))
2155 dump_cgraph_node (stderr, node);
2158 internal_error ("nodes with unreleased memory found");
2166 if (!cgraph_dump_file)
2167 cgraph_dump_file = dump_begin (TDI_cgraph, NULL);
2170 /* The edges representing the callers of the NEW_VERSION node were
2171 fixed by cgraph_function_versioning (), now the call_expr in their
2172 respective tree code should be updated to call the NEW_VERSION. */
2175 update_call_expr (struct cgraph_node *new_version)
2177 struct cgraph_edge *e;
2179 gcc_assert (new_version);
2181 /* Update the call expr on the edges to call the new version. */
2182 for (e = new_version->callers; e; e = e->next_caller)
2184 struct function *inner_function = DECL_STRUCT_FUNCTION (e->caller->decl);
2185 gimple_call_set_fndecl (e->call_stmt, new_version->decl);
2186 maybe_clean_eh_stmt_fn (inner_function, e->call_stmt);
2191 /* Create a new cgraph node which is the new version of
2192 OLD_VERSION node. REDIRECT_CALLERS holds the callers
2193 edges which should be redirected to point to
2194 NEW_VERSION. ALL the callees edges of OLD_VERSION
2195 are cloned to the new version node. Return the new
2198 If non-NULL BLOCK_TO_COPY determine what basic blocks
2199 was copied to prevent duplications of calls that are dead
2202 static struct cgraph_node *
2203 cgraph_copy_node_for_versioning (struct cgraph_node *old_version,
2205 VEC(cgraph_edge_p,heap) *redirect_callers,
2208 struct cgraph_node *new_version;
2209 struct cgraph_edge *e;
2212 gcc_assert (old_version);
2214 new_version = cgraph_create_node (new_decl);
2216 new_version->analyzed = true;
2217 new_version->local = old_version->local;
2218 new_version->local.externally_visible = false;
2219 new_version->local.local = true;
2220 new_version->global = old_version->global;
2221 new_version->rtl = old_version->rtl;
2222 new_version->reachable = true;
2223 new_version->count = old_version->count;
2225 for (e = old_version->callees; e; e=e->next_callee)
2227 || bitmap_bit_p (bbs_to_copy, gimple_bb (e->call_stmt)->index))
2228 cgraph_clone_edge (e, new_version, e->call_stmt,
2229 e->lto_stmt_uid, REG_BR_PROB_BASE,
2232 for (e = old_version->indirect_calls; 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_EACH_VEC_ELT (cgraph_edge_p, redirect_callers, i, e)
2241 /* Redirect calls to the old version node to point to its new
2243 cgraph_redirect_edge_callee (e, new_version);
2249 /* Perform function versioning.
2250 Function versioning includes copying of the tree and
2251 a callgraph update (creating a new cgraph node and updating
2252 its callees and callers).
2254 REDIRECT_CALLERS varray includes the edges to be redirected
2257 TREE_MAP is a mapping of tree nodes we want to replace with
2258 new ones (according to results of prior analysis).
2259 OLD_VERSION_NODE is the node that is versioned.
2260 It returns the new version's cgraph node.
2261 If non-NULL ARGS_TO_SKIP determine function parameters to remove
2263 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
2264 If non_NULL NEW_ENTRY determine new entry BB of the clone. */
2266 struct cgraph_node *
2267 cgraph_function_versioning (struct cgraph_node *old_version_node,
2268 VEC(cgraph_edge_p,heap) *redirect_callers,
2269 VEC (ipa_replace_map_p,gc)* tree_map,
2270 bitmap args_to_skip,
2272 basic_block new_entry_block,
2273 const char *clone_name)
2275 tree old_decl = old_version_node->decl;
2276 struct cgraph_node *new_version_node = NULL;
2279 if (!tree_versionable_function_p (old_decl))
2282 gcc_assert (old_version_node->local.can_change_signature || !args_to_skip);
2284 /* Make a new FUNCTION_DECL tree node for the
2287 new_decl = copy_node (old_decl);
2289 new_decl = build_function_decl_skip_args (old_decl, args_to_skip);
2291 /* Generate a new name for the new version. */
2292 DECL_NAME (new_decl) = clone_function_name (old_decl, clone_name);
2293 SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
2294 SET_DECL_RTL (new_decl, NULL);
2296 /* Create the new version's call-graph node.
2297 and update the edges of the new node. */
2299 cgraph_copy_node_for_versioning (old_version_node, new_decl,
2300 redirect_callers, bbs_to_copy);
2302 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2303 tree_function_versioning (old_decl, new_decl, tree_map, false, args_to_skip,
2304 bbs_to_copy, new_entry_block);
2306 /* Update the new version's properties.
2307 Make The new version visible only within this translation unit. Make sure
2308 that is not weak also.
2309 ??? We cannot use COMDAT linkage because there is no
2310 ABI support for this. */
2311 cgraph_make_decl_local (new_version_node->decl);
2312 DECL_VIRTUAL_P (new_version_node->decl) = 0;
2313 new_version_node->local.externally_visible = 0;
2314 new_version_node->local.local = 1;
2315 new_version_node->lowered = true;
2317 /* Update the call_expr on the edges to call the new version node. */
2318 update_call_expr (new_version_node);
2320 cgraph_call_function_insertion_hooks (new_version_node);
2321 return new_version_node;
2324 /* Given virtual clone, turn it into actual clone. */
2326 cgraph_materialize_clone (struct cgraph_node *node)
2328 bitmap_obstack_initialize (NULL);
2329 node->former_clone_of = node->clone_of->decl;
2330 if (node->clone_of->former_clone_of)
2331 node->former_clone_of = node->clone_of->former_clone_of;
2332 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2333 tree_function_versioning (node->clone_of->decl, node->decl,
2334 node->clone.tree_map, true,
2335 node->clone.args_to_skip, NULL, NULL);
2336 if (cgraph_dump_file)
2338 dump_function_to_file (node->clone_of->decl, cgraph_dump_file, dump_flags);
2339 dump_function_to_file (node->decl, cgraph_dump_file, dump_flags);
2342 /* Function is no longer clone. */
2343 if (node->next_sibling_clone)
2344 node->next_sibling_clone->prev_sibling_clone = node->prev_sibling_clone;
2345 if (node->prev_sibling_clone)
2346 node->prev_sibling_clone->next_sibling_clone = node->next_sibling_clone;
2348 node->clone_of->clones = node->next_sibling_clone;
2349 node->next_sibling_clone = NULL;
2350 node->prev_sibling_clone = NULL;
2351 if (!node->clone_of->analyzed && !node->clone_of->clones)
2353 cgraph_release_function_body (node->clone_of);
2354 cgraph_node_remove_callees (node->clone_of);
2355 ipa_remove_all_references (&node->clone_of->ref_list);
2357 node->clone_of = NULL;
2358 bitmap_obstack_release (NULL);
2361 /* If necessary, change the function declaration in the call statement
2362 associated with E so that it corresponds to the edge callee. */
2365 cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge *e)
2367 tree decl = gimple_call_fndecl (e->call_stmt);
2369 gimple_stmt_iterator gsi;
2370 bool gsi_computed = false;
2371 #ifdef ENABLE_CHECKING
2372 struct cgraph_node *node;
2375 if (e->indirect_unknown_callee
2376 || decl == e->callee->decl
2377 /* Don't update call from same body alias to the real function. */
2378 || (decl && cgraph_get_node (decl) == cgraph_get_node (e->callee->decl)))
2379 return e->call_stmt;
2381 #ifdef ENABLE_CHECKING
2384 node = cgraph_get_node (decl);
2385 gcc_assert (!node || !node->clone.combined_args_to_skip);
2389 if (cgraph_dump_file)
2391 fprintf (cgraph_dump_file, "updating call of %s/%i -> %s/%i: ",
2392 cgraph_node_name (e->caller), e->caller->uid,
2393 cgraph_node_name (e->callee), e->callee->uid);
2394 print_gimple_stmt (cgraph_dump_file, e->call_stmt, 0, dump_flags);
2395 if (e->callee->clone.combined_args_to_skip)
2397 fprintf (cgraph_dump_file, " combined args to skip: ");
2398 dump_bitmap (cgraph_dump_file,
2399 e->callee->clone.combined_args_to_skip);
2403 if (e->indirect_info &&
2404 e->indirect_info->thunk_delta != 0
2405 && (!e->callee->clone.combined_args_to_skip
2406 || !bitmap_bit_p (e->callee->clone.combined_args_to_skip, 0)))
2408 if (cgraph_dump_file)
2409 fprintf (cgraph_dump_file, " Thunk delta is "
2410 HOST_WIDE_INT_PRINT_DEC "\n", e->indirect_info->thunk_delta);
2411 gsi = gsi_for_stmt (e->call_stmt);
2412 gsi_computed = true;
2413 gimple_adjust_this_by_delta (&gsi,
2414 size_int (e->indirect_info->thunk_delta));
2415 e->indirect_info->thunk_delta = 0;
2418 if (e->callee->clone.combined_args_to_skip)
2423 = gimple_call_copy_skip_args (e->call_stmt,
2424 e->callee->clone.combined_args_to_skip);
2425 gimple_call_set_fndecl (new_stmt, e->callee->decl);
2427 if (gimple_vdef (new_stmt)
2428 && TREE_CODE (gimple_vdef (new_stmt)) == SSA_NAME)
2429 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt)) = new_stmt;
2432 gsi = gsi_for_stmt (e->call_stmt);
2433 gsi_replace (&gsi, new_stmt, false);
2434 /* We need to defer cleaning EH info on the new statement to
2435 fixup-cfg. We may not have dominator information at this point
2436 and thus would end up with unreachable blocks and have no way
2437 to communicate that we need to run CFG cleanup then. */
2438 lp_nr = lookup_stmt_eh_lp (e->call_stmt);
2441 remove_stmt_from_eh_lp (e->call_stmt);
2442 add_stmt_to_eh_lp (new_stmt, lp_nr);
2447 new_stmt = e->call_stmt;
2448 gimple_call_set_fndecl (new_stmt, e->callee->decl);
2449 update_stmt (new_stmt);
2452 cgraph_set_call_stmt_including_clones (e->caller, e->call_stmt, new_stmt);
2454 if (cgraph_dump_file)
2456 fprintf (cgraph_dump_file, " updated to:");
2457 print_gimple_stmt (cgraph_dump_file, e->call_stmt, 0, dump_flags);
2462 /* Once all functions from compilation unit are in memory, produce all clones
2463 and update all calls. We might also do this on demand if we don't want to
2464 bring all functions to memory prior compilation, but current WHOPR
2465 implementation does that and it is is bit easier to keep everything right in
2468 cgraph_materialize_all_clones (void)
2470 struct cgraph_node *node;
2471 bool stabilized = false;
2473 if (cgraph_dump_file)
2474 fprintf (cgraph_dump_file, "Materializing clones\n");
2475 #ifdef ENABLE_CHECKING
2479 /* We can also do topological order, but number of iterations should be
2480 bounded by number of IPA passes since single IPA pass is probably not
2481 going to create clones of clones it created itself. */
2485 for (node = cgraph_nodes; node; node = node->next)
2487 if (node->clone_of && node->decl != node->clone_of->decl
2488 && !gimple_has_body_p (node->decl))
2490 if (gimple_has_body_p (node->clone_of->decl))
2492 if (cgraph_dump_file)
2494 fprintf (cgraph_dump_file, "cloning %s to %s\n",
2495 cgraph_node_name (node->clone_of),
2496 cgraph_node_name (node));
2497 if (node->clone.tree_map)
2500 fprintf (cgraph_dump_file, " replace map: ");
2501 for (i = 0; i < VEC_length (ipa_replace_map_p,
2502 node->clone.tree_map);
2505 struct ipa_replace_map *replace_info;
2506 replace_info = VEC_index (ipa_replace_map_p,
2507 node->clone.tree_map,
2509 print_generic_expr (cgraph_dump_file, replace_info->old_tree, 0);
2510 fprintf (cgraph_dump_file, " -> ");
2511 print_generic_expr (cgraph_dump_file, replace_info->new_tree, 0);
2512 fprintf (cgraph_dump_file, "%s%s;",
2513 replace_info->replace_p ? "(replace)":"",
2514 replace_info->ref_p ? "(ref)":"");
2516 fprintf (cgraph_dump_file, "\n");
2518 if (node->clone.args_to_skip)
2520 fprintf (cgraph_dump_file, " args_to_skip: ");
2521 dump_bitmap (cgraph_dump_file, node->clone.args_to_skip);
2523 if (node->clone.args_to_skip)
2525 fprintf (cgraph_dump_file, " combined_args_to_skip:");
2526 dump_bitmap (cgraph_dump_file, node->clone.combined_args_to_skip);
2529 cgraph_materialize_clone (node);
2535 for (node = cgraph_nodes; node; node = node->next)
2536 if (!node->analyzed && node->callees)
2537 cgraph_node_remove_callees (node);
2538 if (cgraph_dump_file)
2539 fprintf (cgraph_dump_file, "Materialization Call site updates done.\n");
2540 #ifdef ENABLE_CHECKING
2543 cgraph_remove_unreachable_nodes (false, cgraph_dump_file);
2546 #include "gt-cgraphunit.h"