1 /* Callgraph based intraprocedural optimizations.
2 Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
22 /* This module implements main driver of compilation process as well as
23 few basic intraprocedural 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 function.)
37 - cgraph_varpool_finalize_variable
39 This function has same behavior as the above but is used for static
42 - cgraph_finalize_compilation_unit
44 This function is called once compilation unit is finalized and it will
47 In the unit-at-a-time the call-graph construction and local function
48 analysis takes place here. Bodies of unreachable functions are released
49 to conserve memory usage.
51 ??? The compilation unit in this point of view should be compilation
52 unit as defined by the language - for instance C frontend allows multiple
53 compilation units to be parsed at once and it should call function each
54 time parsing is done so we save memory.
58 In this unit-at-a-time compilation the intra procedural analysis takes
59 place here. In particular the static functions whose address is never
60 taken are marked as local. Backend can then use this information to
61 modify calling conventions, do better inlining or similar optimizations.
63 - cgraph_assemble_pending_functions
64 - cgraph_varpool_assemble_pending_variables
66 In non-unit-at-a-time mode these functions can be used to force compilation
67 of functions or variables that are known to be needed at given stage
70 - cgraph_mark_needed_node
71 - cgraph_varpool_mark_needed_node
73 When function or variable is referenced by some hidden way (for instance
74 via assembly code and marked by attribute "used"), the call-graph data structure
75 must be updated accordingly by this function.
77 - analyze_expr callback
79 This function is responsible for lowering tree nodes not understood by
80 generic code into understandable ones or alternatively marking
81 callgraph and varpool nodes referenced by the as needed.
83 ??? On the tree-ssa genericizing should take place here and we will avoid
84 need for these hooks (replacing them by genericizing hook)
86 - expand_function callback
88 This function is used to expand function and pass it into RTL back-end.
89 Front-end should not make any assumptions about when this function can be
90 called. In particular cgraph_assemble_pending_functions,
91 cgraph_varpool_assemble_pending_variables, cgraph_finalize_function,
92 cgraph_varpool_finalize_function, cgraph_optimize can cause arbitrarily
93 previously finalized functions to be expanded.
95 We implement two compilation modes.
97 - unit-at-a-time: In this mode analyzing of all functions is deferred
98 to cgraph_finalize_compilation_unit and expansion into cgraph_optimize.
100 In cgraph_finalize_compilation_unit the reachable functions are
101 analyzed. During analysis the call-graph edges from reachable
102 functions are constructed and their destinations are marked as
103 reachable. References to functions and variables are discovered too
104 and variables found to be needed output to the assembly file. Via
105 mark_referenced call in assemble_variable functions referenced by
106 static variables are noticed too.
108 The intra-procedural information is produced and its existence
109 indicated by global_info_ready. Once this flag is set it is impossible
110 to change function from !reachable to reachable and thus
111 assemble_variable no longer call mark_referenced.
113 Finally the call-graph is topologically sorted and all reachable functions
114 that has not been completely inlined or are not external are output.
116 ??? It is possible that reference to function or variable is optimized
117 out. We can not deal with this nicely because topological order is not
118 suitable for it. For tree-ssa we may consider another pass doing
119 optimization and re-discovering reachable functions.
121 ??? Reorganize code so variables are output very last and only if they
122 really has been referenced by produced code, so we catch more cases
123 where reference has been optimized out.
127 All functions are variables are output as early as possible to conserve
128 memory consumption. This may or may not result in less memory used but
129 it is still needed for some legacy code that rely on particular ordering
130 of things output from the compiler.
132 Varpool data structures are not used and variables are output directly.
134 Functions are output early using call of
135 cgraph_assemble_pending_function from cgraph_finalize_function. The
136 decision on whether function is needed is made more conservative so
137 uninlininable static functions are needed too. During the call-graph
138 construction the edge destinations are not marked as reachable and it
139 is completely relied upn assemble_variable to mark them. */
144 #include "coretypes.h"
148 #include "tree-flow.h"
149 #include "tree-inline.h"
150 #include "langhooks.h"
151 #include "pointer-set.h"
158 #include "diagnostic.h"
162 #include "c-common.h"
164 #include "function.h"
165 #include "ipa-prop.h"
166 #include "tree-gimple.h"
167 #include "tree-pass.h"
170 static void cgraph_expand_all_functions (void);
171 static void cgraph_mark_functions_to_output (void);
172 static void cgraph_expand_function (struct cgraph_node *);
173 static tree record_reference (tree *, int *, void *);
174 static void cgraph_output_pending_asms (void);
176 /* Records tree nodes seen in record_reference. Simply using
177 walk_tree_without_duplicates doesn't guarantee each node is visited
178 once because it gets a new htab upon each recursive call from
179 record_reference itself. */
180 static struct pointer_set_t *visited_nodes;
182 static FILE *cgraph_dump_file;
184 /* Determine if function DECL is needed. That is, visible to something
185 either outside this translation unit, something magic in the system
186 configury, or (if not doing unit-at-a-time) to something we havn't
190 decide_is_function_needed (struct cgraph_node *node, tree decl)
193 if (MAIN_NAME_P (DECL_NAME (decl))
194 && TREE_PUBLIC (decl))
196 node->local.externally_visible = true;
200 /* If the user told us it is used, then it must be so. */
201 if (node->local.externally_visible)
204 if (!flag_unit_at_a_time && lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
207 /* ??? If the assembler name is set by hand, it is possible to assemble
208 the name later after finalizing the function and the fact is noticed
209 in assemble_name then. This is arguably a bug. */
210 if (DECL_ASSEMBLER_NAME_SET_P (decl)
211 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
214 /* If we decided it was needed before, but at the time we didn't have
215 the body of the function available, then it's still needed. We have
216 to go back and re-check its dependencies now. */
220 /* Externally visible functions must be output. The exception is
221 COMDAT functions that must be output only when they are needed.
223 When not optimizing, also output the static functions. (see
224 PR24561), but don't do so for always_inline functions, functions
225 declared inline and nested functions. These was optimized out
226 in the original implementation and it is unclear whether we want
227 to change the behavior here. */
228 if (((TREE_PUBLIC (decl)
229 || (!optimize && !node->local.disregard_inline_limits
230 && !DECL_DECLARED_INLINE_P (decl)
232 && !flag_whole_program)
233 && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl))
236 /* Constructors and destructors are reachable from the runtime by
238 if (DECL_STATIC_CONSTRUCTOR (decl) || DECL_STATIC_DESTRUCTOR (decl))
241 if (flag_unit_at_a_time)
244 /* If not doing unit at a time, then we'll only defer this function
245 if its marked for inlining. Otherwise we want to emit it now. */
247 /* "extern inline" functions are never output locally. */
248 if (DECL_EXTERNAL (decl))
250 /* Nested functions of extern inline function shall not be emit unless
251 we inlined the origin. */
252 for (origin = decl_function_context (decl); origin;
253 origin = decl_function_context (origin))
254 if (DECL_EXTERNAL (origin))
256 /* We want to emit COMDAT functions only when absolutely necessary. */
257 if (DECL_COMDAT (decl))
259 if (!DECL_INLINE (decl)
260 || (!node->local.disregard_inline_limits
261 /* When declared inline, defer even the uninlinable functions.
262 This allows them to be eliminated when unused. */
263 && !DECL_DECLARED_INLINE_P (decl)
264 && (!node->local.inlinable || !cgraph_default_inline_p (node, NULL))))
270 /* Walk the decls we marked as necessary and see if they reference new
271 variables or functions and add them into the worklists. */
273 cgraph_varpool_analyze_pending_decls (void)
275 bool changed = false;
276 timevar_push (TV_CGRAPH);
278 while (cgraph_varpool_first_unanalyzed_node)
280 tree decl = cgraph_varpool_first_unanalyzed_node->decl;
282 cgraph_varpool_first_unanalyzed_node->analyzed = true;
284 cgraph_varpool_first_unanalyzed_node = cgraph_varpool_first_unanalyzed_node->next_needed;
286 /* Compute the alignment early so function body expanders are
287 already informed about increased alignment. */
288 align_variable (decl, 0);
290 if (DECL_INITIAL (decl))
292 visited_nodes = pointer_set_create ();
293 walk_tree (&DECL_INITIAL (decl), record_reference, NULL, visited_nodes);
294 pointer_set_destroy (visited_nodes);
295 visited_nodes = NULL;
299 timevar_pop (TV_CGRAPH);
303 /* Optimization of function bodies might've rendered some variables as
304 unnecessary so we want to avoid these from being compiled.
306 This is done by pruning the queue and keeping only the variables that
307 really appear needed (ie they are either externally visible or referenced
308 by compiled function). Re-doing the reachability analysis on variables
309 brings back the remaining variables referenced by these. */
311 cgraph_varpool_remove_unreferenced_decls (void)
313 struct cgraph_varpool_node *next, *node = cgraph_varpool_nodes_queue;
315 cgraph_varpool_reset_queue ();
317 if (errorcount || sorrycount)
322 tree decl = node->decl;
323 next = node->next_needed;
327 && ((DECL_ASSEMBLER_NAME_SET_P (decl)
328 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
329 || node->force_output
330 || decide_is_variable_needed (node, decl)
331 /* ??? Cgraph does not yet rule the world with an iron hand,
332 and does not control the emission of debug information.
333 After a variable has its DECL_RTL set, we must assume that
334 it may be referenced by the debug information, and we can
335 no longer elide it. */
336 || DECL_RTL_SET_P (decl)))
337 cgraph_varpool_mark_needed_node (node);
341 /* Make sure we mark alias targets as used targets. */
343 cgraph_varpool_analyze_pending_decls ();
347 /* When not doing unit-at-a-time, output all functions enqueued.
348 Return true when such a functions were found. */
351 cgraph_assemble_pending_functions (void)
355 if (flag_unit_at_a_time)
358 cgraph_output_pending_asms ();
360 while (cgraph_nodes_queue)
362 struct cgraph_node *n = cgraph_nodes_queue;
364 cgraph_nodes_queue = cgraph_nodes_queue->next_needed;
365 n->next_needed = NULL;
366 if (!n->global.inlined_to
368 && !DECL_EXTERNAL (n->decl))
370 cgraph_expand_function (n);
375 /* Process CGRAPH_EXPAND_QUEUE, these are functions created during
376 the expansion process. Note that this queue may grow as its
377 being processed, as the new functions may generate new ones. */
378 while (cgraph_expand_queue)
380 struct cgraph_node *n = cgraph_expand_queue;
381 cgraph_expand_queue = cgraph_expand_queue->next_needed;
382 n->next_needed = NULL;
383 cgraph_finalize_function (n->decl, false);
391 /* As an GCC extension we allow redefinition of the function. The
392 semantics when both copies of bodies differ is not well defined.
393 We replace the old body with new body so in unit at a time mode
394 we always use new body, while in normal mode we may end up with
395 old body inlined into some functions and new body expanded and
398 ??? It may make more sense to use one body for inlining and other
399 body for expanding the function but this is difficult to do. */
402 cgraph_reset_node (struct cgraph_node *node)
404 /* If node->output is set, then this is a unit-at-a-time compilation
405 and we have already begun whole-unit analysis. This is *not*
406 testing for whether we've already emitted the function. That
407 case can be sort-of legitimately seen with real function
408 redefinition errors. I would argue that the front end should
409 never present us with such a case, but don't enforce that for now. */
410 gcc_assert (!node->output);
412 /* Reset our data structures so we can analyze the function again. */
413 memset (&node->local, 0, sizeof (node->local));
414 memset (&node->global, 0, sizeof (node->global));
415 memset (&node->rtl, 0, sizeof (node->rtl));
416 node->analyzed = false;
417 node->local.redefined_extern_inline = true;
418 node->local.finalized = false;
420 if (!flag_unit_at_a_time)
422 struct cgraph_node *n;
424 for (n = cgraph_nodes; n; n = n->next)
425 if (n->global.inlined_to == node)
426 cgraph_remove_node (n);
429 cgraph_node_remove_callees (node);
431 /* We may need to re-queue the node for assembling in case
432 we already proceeded it and ignored as not needed. */
433 if (node->reachable && !flag_unit_at_a_time)
435 struct cgraph_node *n;
437 for (n = cgraph_nodes_queue; n; n = n->next_needed)
446 cgraph_lower_function (struct cgraph_node *node)
450 tree_lowering_passes (node->decl);
451 node->lowered = true;
454 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
455 logic in effect. If NESTED is true, then our caller cannot stand to have
456 the garbage collector run at the moment. We would need to either create
457 a new GC context, or just not compile right now. */
460 cgraph_finalize_function (tree decl, bool nested)
462 struct cgraph_node *node = cgraph_node (decl);
464 if (node->local.finalized)
465 cgraph_reset_node (node);
467 notice_global_symbol (decl);
469 node->local.finalized = true;
470 node->lowered = DECL_STRUCT_FUNCTION (decl)->cfg != NULL;
472 lower_nested_functions (decl);
473 gcc_assert (!node->nested);
475 /* If not unit at a time, then we need to create the call graph
476 now, so that called functions can be queued and emitted now. */
477 if (!flag_unit_at_a_time)
479 cgraph_analyze_function (node);
480 cgraph_decide_inlining_incrementally (node, false);
483 if (decide_is_function_needed (node, decl))
484 cgraph_mark_needed_node (node);
486 /* Since we reclaim unreachable nodes at the end of every language
487 level unit, we need to be conservative about possible entry points
489 if ((TREE_PUBLIC (decl) && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl)))
490 cgraph_mark_reachable_node (node);
492 /* If not unit at a time, go ahead and emit everything we've found
493 to be reachable at this time. */
496 if (!cgraph_assemble_pending_functions ())
500 /* If we've not yet emitted decl, tell the debug info about it. */
501 if (!TREE_ASM_WRITTEN (decl))
502 (*debug_hooks->deferred_inline_function) (decl);
504 /* Possibly warn about unused parameters. */
505 if (warn_unused_parameter)
506 do_warn_unused_parameter (decl);
509 /* Walk tree and record all calls. Called via walk_tree. */
511 record_reference (tree *tp, int *walk_subtrees, void *data)
515 switch (TREE_CODE (t))
518 /* ??? Really, we should mark this decl as *potentially* referenced
519 by this function and re-examine whether the decl is actually used
520 after rtl has been generated. */
521 if (TREE_STATIC (t) || DECL_EXTERNAL (t))
523 cgraph_varpool_mark_needed_node (cgraph_varpool_node (t));
524 if (lang_hooks.callgraph.analyze_expr)
525 return lang_hooks.callgraph.analyze_expr (tp, walk_subtrees,
532 if (flag_unit_at_a_time)
534 /* Record dereferences to the functions. This makes the
535 functions reachable unconditionally. */
536 tree decl = TREE_OPERAND (*tp, 0);
537 if (TREE_CODE (decl) == FUNCTION_DECL)
538 cgraph_mark_needed_node (cgraph_node (decl));
543 /* Save some cycles by not walking types and declaration as we
544 won't find anything useful there anyway. */
545 if (IS_TYPE_OR_DECL_P (*tp))
551 if ((unsigned int) TREE_CODE (t) >= LAST_AND_UNUSED_TREE_CODE)
552 return lang_hooks.callgraph.analyze_expr (tp, walk_subtrees, data);
559 /* Create cgraph edges for function calls inside BODY from NODE. */
562 cgraph_create_edges (struct cgraph_node *node, tree body)
566 struct function *this_cfun = DECL_STRUCT_FUNCTION (body);
567 block_stmt_iterator bsi;
569 visited_nodes = pointer_set_create ();
571 /* Reach the trees by walking over the CFG, and note the
572 enclosing basic-blocks in the call edges. */
573 FOR_EACH_BB_FN (bb, this_cfun)
574 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
576 tree stmt = bsi_stmt (bsi);
577 tree call = get_call_expr_in (stmt);
580 if (call && (decl = get_callee_fndecl (call)))
582 cgraph_create_edge (node, cgraph_node (decl), stmt,
585 walk_tree (&TREE_OPERAND (call, 1),
586 record_reference, node, visited_nodes);
587 if (TREE_CODE (stmt) == MODIFY_EXPR)
588 walk_tree (&TREE_OPERAND (stmt, 0),
589 record_reference, node, visited_nodes);
592 walk_tree (bsi_stmt_ptr (bsi), record_reference, node, visited_nodes);
595 /* Look for initializers of constant variables and private statics. */
596 for (step = DECL_STRUCT_FUNCTION (body)->unexpanded_var_list;
598 step = TREE_CHAIN (step))
600 tree decl = TREE_VALUE (step);
601 if (TREE_CODE (decl) == VAR_DECL
602 && (TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
603 && flag_unit_at_a_time)
604 cgraph_varpool_finalize_decl (decl);
605 else if (TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
606 walk_tree (&DECL_INITIAL (decl), record_reference, node, visited_nodes);
609 pointer_set_destroy (visited_nodes);
610 visited_nodes = NULL;
613 /* Give initial reasons why inlining would fail. Those gets
614 either NULLified or usually overwritten by more precise reason
617 initialize_inline_failed (struct cgraph_node *node)
619 struct cgraph_edge *e;
621 for (e = node->callers; e; e = e->next_caller)
623 gcc_assert (!e->callee->global.inlined_to);
624 gcc_assert (e->inline_failed);
625 if (node->local.redefined_extern_inline)
626 e->inline_failed = N_("redefined extern inline functions are not "
627 "considered for inlining");
628 else if (!node->local.inlinable)
629 e->inline_failed = N_("function not inlinable");
631 e->inline_failed = N_("function not considered for inlining");
635 /* Rebuild call edges from current function after a passes not aware
636 of cgraph updating. */
638 rebuild_cgraph_edges (void)
641 struct cgraph_node *node = cgraph_node (current_function_decl);
642 block_stmt_iterator bsi;
644 cgraph_node_remove_callees (node);
646 node->count = ENTRY_BLOCK_PTR->count;
649 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
651 tree stmt = bsi_stmt (bsi);
652 tree call = get_call_expr_in (stmt);
655 if (call && (decl = get_callee_fndecl (call)))
656 cgraph_create_edge (node, cgraph_node (decl), stmt,
660 initialize_inline_failed (node);
661 gcc_assert (!node->global.inlined_to);
665 struct tree_opt_pass pass_rebuild_cgraph_edges =
669 rebuild_cgraph_edges, /* execute */
672 0, /* static_pass_number */
674 PROP_cfg, /* properties_required */
675 0, /* properties_provided */
676 0, /* properties_destroyed */
677 0, /* todo_flags_start */
678 0, /* todo_flags_finish */
682 /* Verify cgraph nodes of given cgraph node. */
684 verify_cgraph_node (struct cgraph_node *node)
686 struct cgraph_edge *e;
687 struct cgraph_node *main_clone;
688 struct function *this_cfun = DECL_STRUCT_FUNCTION (node->decl);
689 basic_block this_block;
690 block_stmt_iterator bsi;
691 bool error_found = false;
693 timevar_push (TV_CGRAPH_VERIFY);
694 for (e = node->callees; e; e = e->next_callee)
697 error ("aux field set for edge %s->%s",
698 cgraph_node_name (e->caller), cgraph_node_name (e->callee));
703 error ("Execution count is negative");
706 for (e = node->callers; e; e = e->next_caller)
710 error ("caller edge count is negative");
713 if (!e->inline_failed)
715 if (node->global.inlined_to
716 != (e->caller->global.inlined_to
717 ? e->caller->global.inlined_to : e->caller))
719 error ("inlined_to pointer is wrong");
722 if (node->callers->next_caller)
724 error ("multiple inline callers");
729 if (node->global.inlined_to)
731 error ("inlined_to pointer set for noninline callers");
735 if (!node->callers && node->global.inlined_to)
737 error ("inlined_to pointer is set but no predecessors found");
740 if (node->global.inlined_to == node)
742 error ("inlined_to pointer refers to itself");
746 for (main_clone = cgraph_node (node->decl); main_clone;
747 main_clone = main_clone->next_clone)
748 if (main_clone == node)
750 if (!cgraph_node (node->decl))
752 error ("node not found in cgraph_hash");
757 && DECL_SAVED_TREE (node->decl) && !TREE_ASM_WRITTEN (node->decl)
758 && (!DECL_EXTERNAL (node->decl) || node->global.inlined_to))
762 /* The nodes we're interested in are never shared, so walk
763 the tree ignoring duplicates. */
764 visited_nodes = pointer_set_create ();
765 /* Reach the trees by walking over the CFG, and note the
766 enclosing basic-blocks in the call edges. */
767 FOR_EACH_BB_FN (this_block, this_cfun)
768 for (bsi = bsi_start (this_block); !bsi_end_p (bsi); bsi_next (&bsi))
770 tree stmt = bsi_stmt (bsi);
771 tree call = get_call_expr_in (stmt);
773 if (call && (decl = get_callee_fndecl (call)))
775 struct cgraph_edge *e = cgraph_edge (node, stmt);
780 error ("shared call_stmt:");
781 debug_generic_stmt (stmt);
784 if (e->callee->decl != cgraph_node (decl)->decl
787 error ("edge points to wrong declaration:");
788 debug_tree (e->callee->decl);
789 fprintf (stderr," Instead of:");
796 error ("missing callgraph edge for call stmt:");
797 debug_generic_stmt (stmt);
802 pointer_set_destroy (visited_nodes);
803 visited_nodes = NULL;
806 /* No CFG available?! */
809 for (e = node->callees; e; e = e->next_callee)
813 error ("edge %s->%s has no corresponding call_stmt",
814 cgraph_node_name (e->caller),
815 cgraph_node_name (e->callee));
816 debug_generic_stmt (e->call_stmt);
824 dump_cgraph_node (stderr, node);
825 internal_error ("verify_cgraph_node failed");
827 timevar_pop (TV_CGRAPH_VERIFY);
830 /* Verify whole cgraph structure. */
834 struct cgraph_node *node;
836 if (sorrycount || errorcount)
839 for (node = cgraph_nodes; node; node = node->next)
840 verify_cgraph_node (node);
843 /* Output one variable, if necessary. Return whether we output it. */
845 cgraph_varpool_assemble_decl (struct cgraph_varpool_node *node)
847 tree decl = node->decl;
849 if (!TREE_ASM_WRITTEN (decl)
851 && !DECL_EXTERNAL (decl)
852 && (TREE_CODE (decl) != VAR_DECL || !DECL_HAS_VALUE_EXPR_P (decl)))
854 assemble_variable (decl, 0, 1, 0);
855 /* Local static variables are never seen by check_global_declarations
856 so we need to output debug info by hand. */
857 if (DECL_CONTEXT (decl)
858 && (TREE_CODE (DECL_CONTEXT (decl)) == BLOCK
859 || TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)
860 && errorcount == 0 && sorrycount == 0)
862 timevar_push (TV_SYMOUT);
863 (*debug_hooks->global_decl) (decl);
864 timevar_pop (TV_SYMOUT);
872 /* Output all variables enqueued to be assembled. */
874 cgraph_varpool_assemble_pending_decls (void)
876 bool changed = false;
878 if (errorcount || sorrycount)
881 /* EH might mark decls as needed during expansion. This should be safe since
882 we don't create references to new function, but it should not be used
884 cgraph_varpool_analyze_pending_decls ();
886 while (cgraph_varpool_nodes_queue)
888 struct cgraph_varpool_node *node = cgraph_varpool_nodes_queue;
890 cgraph_varpool_nodes_queue = cgraph_varpool_nodes_queue->next_needed;
891 if (cgraph_varpool_assemble_decl (node))
893 node->next_needed = NULL;
898 /* Output all asm statements we have stored up to be output. */
901 cgraph_output_pending_asms (void)
903 struct cgraph_asm_node *can;
905 if (errorcount || sorrycount)
908 for (can = cgraph_asm_nodes; can; can = can->next)
909 assemble_asm (can->asm_str);
910 cgraph_asm_nodes = NULL;
913 /* Analyze the function scheduled to be output. */
915 cgraph_analyze_function (struct cgraph_node *node)
917 tree decl = node->decl;
919 current_function_decl = decl;
920 push_cfun (DECL_STRUCT_FUNCTION (decl));
921 cgraph_lower_function (node);
923 /* First kill forward declaration so reverse inlining works properly. */
924 cgraph_create_edges (node, decl);
926 node->local.inlinable = tree_inlinable_function_p (decl);
927 node->local.self_insns = estimate_num_insns (decl);
928 if (node->local.inlinable)
929 node->local.disregard_inline_limits
930 = lang_hooks.tree_inlining.disregard_inline_limits (decl);
931 initialize_inline_failed (node);
932 if (flag_really_no_inline && !node->local.disregard_inline_limits)
933 node->local.inlinable = 0;
934 /* Inlining characteristics are maintained by the cgraph_mark_inline. */
935 node->global.insns = node->local.self_insns;
937 node->analyzed = true;
939 current_function_decl = NULL;
942 /* Look for externally_visible and used attributes and mark cgraph nodes
945 We cannot mark the nodes at the point the attributes are processed (in
946 handle_*_attribute) because the copy of the declarations available at that
947 point may not be canonical. For example, in:
950 void f() __attribute__((used));
952 the declaration we see in handle_used_attribute will be the second
953 declaration -- but the front end will subsequently merge that declaration
954 with the original declaration and discard the second declaration.
956 Furthermore, we can't mark these nodes in cgraph_finalize_function because:
959 void f() __attribute__((externally_visible));
963 So, we walk the nodes at the end of the translation unit, applying the
964 attributes at that point. */
967 process_function_and_variable_attributes (struct cgraph_node *first,
968 struct cgraph_varpool_node *first_var)
970 struct cgraph_node *node;
971 struct cgraph_varpool_node *vnode;
973 for (node = cgraph_nodes; node != first; node = node->next)
975 tree decl = node->decl;
976 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
978 mark_decl_referenced (decl);
979 if (node->local.finalized)
980 cgraph_mark_needed_node (node);
982 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl)))
984 if (node->local.finalized)
985 cgraph_mark_needed_node (node);
986 node->externally_visible = true;
989 for (vnode = cgraph_varpool_nodes; vnode != first_var; vnode = vnode->next)
991 tree decl = vnode->decl;
992 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
994 mark_decl_referenced (decl);
995 if (vnode->finalized)
996 cgraph_varpool_mark_needed_node (vnode);
998 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl)))
1000 if (vnode->finalized)
1001 cgraph_varpool_mark_needed_node (vnode);
1002 vnode->externally_visible = true;
1007 /* Analyze the whole compilation unit once it is parsed completely. */
1010 cgraph_finalize_compilation_unit (void)
1012 struct cgraph_node *node;
1013 /* Keep track of already processed nodes when called multiple times for
1014 intermodule optimization. */
1015 static struct cgraph_node *first_analyzed;
1016 static struct cgraph_varpool_node *first_analyzed_var;
1018 finish_aliases_1 ();
1020 if (!flag_unit_at_a_time)
1022 cgraph_output_pending_asms ();
1023 cgraph_assemble_pending_functions ();
1029 fprintf (stderr, "\nAnalyzing compilation unit");
1033 timevar_push (TV_CGRAPH);
1034 process_function_and_variable_attributes (first_analyzed, first_analyzed_var);
1035 cgraph_varpool_analyze_pending_decls ();
1036 if (cgraph_dump_file)
1038 fprintf (cgraph_dump_file, "Initial entry points:");
1039 for (node = cgraph_nodes; node != first_analyzed; node = node->next)
1040 if (node->needed && DECL_SAVED_TREE (node->decl))
1041 fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
1042 fprintf (cgraph_dump_file, "\n");
1045 /* Propagate reachability flag and lower representation of all reachable
1046 functions. In the future, lowering will introduce new functions and
1047 new entry points on the way (by template instantiation and virtual
1048 method table generation for instance). */
1049 while (cgraph_nodes_queue)
1051 struct cgraph_edge *edge;
1052 tree decl = cgraph_nodes_queue->decl;
1054 node = cgraph_nodes_queue;
1055 cgraph_nodes_queue = cgraph_nodes_queue->next_needed;
1056 node->next_needed = NULL;
1058 /* ??? It is possible to create extern inline function and later using
1059 weak alias attribute to kill its body. See
1060 gcc.c-torture/compile/20011119-1.c */
1061 if (!DECL_SAVED_TREE (decl))
1063 cgraph_reset_node (node);
1067 gcc_assert (!node->analyzed && node->reachable);
1068 gcc_assert (DECL_SAVED_TREE (decl));
1070 cgraph_analyze_function (node);
1072 for (edge = node->callees; edge; edge = edge->next_callee)
1073 if (!edge->callee->reachable)
1074 cgraph_mark_reachable_node (edge->callee);
1076 cgraph_varpool_analyze_pending_decls ();
1079 /* Collect entry points to the unit. */
1081 if (cgraph_dump_file)
1083 fprintf (cgraph_dump_file, "Unit entry points:");
1084 for (node = cgraph_nodes; node != first_analyzed; node = node->next)
1085 if (node->needed && DECL_SAVED_TREE (node->decl))
1086 fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
1087 fprintf (cgraph_dump_file, "\n\nInitial ");
1088 dump_cgraph (cgraph_dump_file);
1091 if (cgraph_dump_file)
1092 fprintf (cgraph_dump_file, "\nReclaiming functions:");
1094 for (node = cgraph_nodes; node != first_analyzed; node = node->next)
1096 tree decl = node->decl;
1098 if (node->local.finalized && !DECL_SAVED_TREE (decl))
1099 cgraph_reset_node (node);
1101 if (!node->reachable && DECL_SAVED_TREE (decl))
1103 if (cgraph_dump_file)
1104 fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
1105 cgraph_remove_node (node);
1109 node->next_needed = NULL;
1110 gcc_assert (!node->local.finalized || DECL_SAVED_TREE (decl));
1111 gcc_assert (node->analyzed == node->local.finalized);
1113 if (cgraph_dump_file)
1115 fprintf (cgraph_dump_file, "\n\nReclaimed ");
1116 dump_cgraph (cgraph_dump_file);
1118 first_analyzed = cgraph_nodes;
1119 first_analyzed_var = cgraph_varpool_nodes;
1121 timevar_pop (TV_CGRAPH);
1123 /* Figure out what functions we want to assemble. */
1126 cgraph_mark_functions_to_output (void)
1128 struct cgraph_node *node;
1130 for (node = cgraph_nodes; node; node = node->next)
1132 tree decl = node->decl;
1133 struct cgraph_edge *e;
1135 gcc_assert (!node->output);
1137 for (e = node->callers; e; e = e->next_caller)
1138 if (e->inline_failed)
1141 /* We need to output all local functions that are used and not
1142 always inlined, as well as those that are reachable from
1143 outside the current compilation unit. */
1144 if (DECL_SAVED_TREE (decl)
1145 && !node->global.inlined_to
1147 || (e && node->reachable))
1148 && !TREE_ASM_WRITTEN (decl)
1149 && !DECL_EXTERNAL (decl))
1153 /* We should've reclaimed all functions that are not needed. */
1154 #ifdef ENABLE_CHECKING
1155 if (!node->global.inlined_to && DECL_SAVED_TREE (decl)
1156 && !DECL_EXTERNAL (decl))
1158 dump_cgraph_node (stderr, node);
1159 internal_error ("failed to reclaim unneeded function");
1162 gcc_assert (node->global.inlined_to || !DECL_SAVED_TREE (decl)
1163 || DECL_EXTERNAL (decl));
1170 /* Expand function specified by NODE. */
1173 cgraph_expand_function (struct cgraph_node *node)
1175 tree decl = node->decl;
1177 /* We ought to not compile any inline clones. */
1178 gcc_assert (!node->global.inlined_to);
1180 if (flag_unit_at_a_time)
1181 announce_function (decl);
1183 cgraph_lower_function (node);
1185 /* Generate RTL for the body of DECL. */
1186 lang_hooks.callgraph.expand_function (decl);
1188 /* Make sure that BE didn't give up on compiling. */
1189 /* ??? Can happen with nested function of extern inline. */
1190 gcc_assert (TREE_ASM_WRITTEN (node->decl));
1192 current_function_decl = NULL;
1193 if (!cgraph_preserve_function_body_p (node->decl))
1195 DECL_SAVED_TREE (node->decl) = NULL;
1196 DECL_STRUCT_FUNCTION (node->decl) = NULL;
1197 DECL_INITIAL (node->decl) = error_mark_node;
1198 /* Eliminate all call edges. This is important so the call_expr no longer
1199 points to the dead function body. */
1200 cgraph_node_remove_callees (node);
1203 cgraph_function_flags_ready = true;
1206 /* Return true when CALLER_DECL should be inlined into CALLEE_DECL. */
1209 cgraph_inline_p (struct cgraph_edge *e, const char **reason)
1211 *reason = e->inline_failed;
1212 return !e->inline_failed;
1217 /* Expand all functions that must be output.
1219 Attempt to topologically sort the nodes so function is output when
1220 all called functions are already assembled to allow data to be
1221 propagated across the callgraph. Use a stack to get smaller distance
1222 between a function and its callees (later we may choose to use a more
1223 sophisticated algorithm for function reordering; we will likely want
1224 to use subsections to make the output functions appear in top-down
1228 cgraph_expand_all_functions (void)
1230 struct cgraph_node *node;
1231 struct cgraph_node **order = XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
1232 int order_pos = 0, new_order_pos = 0;
1235 order_pos = cgraph_postorder (order);
1236 gcc_assert (order_pos == cgraph_n_nodes);
1238 /* Garbage collector may remove inline clones we eliminate during
1239 optimization. So we must be sure to not reference them. */
1240 for (i = 0; i < order_pos; i++)
1241 if (order[i]->output)
1242 order[new_order_pos++] = order[i];
1244 for (i = new_order_pos - 1; i >= 0; i--)
1249 gcc_assert (node->reachable);
1251 cgraph_expand_function (node);
1257 /* Process CGRAPH_EXPAND_QUEUE, these are functions created during
1258 the expansion process. Note that this queue may grow as its
1259 being processed, as the new functions may generate new ones. */
1260 while (cgraph_expand_queue)
1262 node = cgraph_expand_queue;
1263 cgraph_expand_queue = cgraph_expand_queue->next_needed;
1264 node->next_needed = NULL;
1266 node->lowered = DECL_STRUCT_FUNCTION (node->decl)->cfg != NULL;
1267 cgraph_expand_function (node);
1271 /* This is used to sort the node types by the cgraph order number. */
1273 struct cgraph_order_sort
1275 enum { ORDER_UNDEFINED = 0, ORDER_FUNCTION, ORDER_VAR, ORDER_ASM } kind;
1278 struct cgraph_node *f;
1279 struct cgraph_varpool_node *v;
1280 struct cgraph_asm_node *a;
1284 /* Output all functions, variables, and asm statements in the order
1285 according to their order fields, which is the order in which they
1286 appeared in the file. This implements -fno-toplevel-reorder. In
1287 this mode we may output functions and variables which don't really
1288 need to be output. */
1291 cgraph_output_in_order (void)
1295 struct cgraph_order_sort *nodes;
1297 struct cgraph_node *pf;
1298 struct cgraph_varpool_node *pv;
1299 struct cgraph_asm_node *pa;
1302 size = max * sizeof (struct cgraph_order_sort);
1303 nodes = (struct cgraph_order_sort *) alloca (size);
1304 memset (nodes, 0, size);
1306 cgraph_varpool_analyze_pending_decls ();
1308 for (pf = cgraph_nodes; pf; pf = pf->next)
1313 gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
1314 nodes[i].kind = ORDER_FUNCTION;
1319 for (pv = cgraph_varpool_nodes_queue; pv; pv = pv->next_needed)
1322 gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
1323 nodes[i].kind = ORDER_VAR;
1327 for (pa = cgraph_asm_nodes; pa; pa = pa->next)
1330 gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
1331 nodes[i].kind = ORDER_ASM;
1335 for (i = 0; i < max; ++i)
1337 switch (nodes[i].kind)
1339 case ORDER_FUNCTION:
1340 nodes[i].u.f->output = 0;
1341 cgraph_expand_function (nodes[i].u.f);
1345 cgraph_varpool_assemble_decl (nodes[i].u.v);
1349 assemble_asm (nodes[i].u.a->asm_str);
1352 case ORDER_UNDEFINED:
1360 cgraph_asm_nodes = NULL;
1363 /* Mark visibility of all functions.
1365 A local function is one whose calls can occur only in the current
1366 compilation unit and all its calls are explicit, so we can change
1367 its calling convention. We simply mark all static functions whose
1368 address is not taken as local.
1370 We also change the TREE_PUBLIC flag of all declarations that are public
1371 in language point of view but we want to overwrite this default
1372 via visibilities for the backend point of view. */
1375 cgraph_function_and_variable_visibility (void)
1377 struct cgraph_node *node;
1378 struct cgraph_varpool_node *vnode;
1380 for (node = cgraph_nodes; node; node = node->next)
1383 && (DECL_COMDAT (node->decl)
1384 || (!flag_whole_program
1385 && TREE_PUBLIC (node->decl) && !DECL_EXTERNAL (node->decl))))
1386 node->local.externally_visible = true;
1387 if (!node->local.externally_visible && node->analyzed
1388 && !DECL_EXTERNAL (node->decl))
1390 gcc_assert (flag_whole_program || !TREE_PUBLIC (node->decl));
1391 TREE_PUBLIC (node->decl) = 0;
1393 node->local.local = (!node->needed
1395 && !DECL_EXTERNAL (node->decl)
1396 && !node->local.externally_visible);
1398 for (vnode = cgraph_varpool_nodes_queue; vnode; vnode = vnode->next_needed)
1401 && !flag_whole_program
1402 && (DECL_COMDAT (vnode->decl) || TREE_PUBLIC (vnode->decl)))
1403 vnode->externally_visible = 1;
1404 if (!vnode->externally_visible)
1406 gcc_assert (flag_whole_program || !TREE_PUBLIC (vnode->decl));
1407 TREE_PUBLIC (vnode->decl) = 0;
1409 gcc_assert (TREE_STATIC (vnode->decl));
1412 /* Because we have to be conservative on the boundaries of source
1413 level units, it is possible that we marked some functions in
1414 reachable just because they might be used later via external
1415 linkage, but after making them local they are really unreachable
1417 cgraph_remove_unreachable_nodes (true, cgraph_dump_file);
1419 if (cgraph_dump_file)
1421 fprintf (cgraph_dump_file, "\nMarking local functions:");
1422 for (node = cgraph_nodes; node; node = node->next)
1423 if (node->local.local)
1424 fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
1425 fprintf (cgraph_dump_file, "\n\n");
1426 fprintf (cgraph_dump_file, "\nMarking externally visible functions:");
1427 for (node = cgraph_nodes; node; node = node->next)
1428 if (node->local.externally_visible)
1429 fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
1430 fprintf (cgraph_dump_file, "\n\n");
1432 cgraph_function_flags_ready = true;
1435 /* Return true when function body of DECL still needs to be kept around
1436 for later re-use. */
1438 cgraph_preserve_function_body_p (tree decl)
1440 struct cgraph_node *node;
1441 if (!cgraph_global_info_ready)
1442 return (DECL_INLINE (decl) && !flag_really_no_inline);
1443 /* Look if there is any clone around. */
1444 for (node = cgraph_node (decl); node; node = node->next_clone)
1445 if (node->global.inlined_to)
1454 tree_register_cfg_hooks ();
1455 bitmap_obstack_initialize (NULL);
1456 execute_ipa_pass_list (all_ipa_passes);
1457 bitmap_obstack_release (NULL);
1460 /* Perform simple optimizations based on callgraph. */
1463 cgraph_optimize (void)
1465 #ifdef ENABLE_CHECKING
1468 if (!flag_unit_at_a_time)
1470 cgraph_output_pending_asms ();
1471 cgraph_varpool_assemble_pending_decls ();
1475 process_pending_assemble_externals ();
1477 /* Frontend may output common variables after the unit has been finalized.
1478 It is safe to deal with them here as they are always zero initialized. */
1479 cgraph_varpool_analyze_pending_decls ();
1481 timevar_push (TV_CGRAPHOPT);
1483 fprintf (stderr, "Performing intraprocedural optimizations\n");
1485 cgraph_function_and_variable_visibility ();
1486 if (cgraph_dump_file)
1488 fprintf (cgraph_dump_file, "Marked ");
1489 dump_cgraph (cgraph_dump_file);
1492 /* Don't run the IPA passes if there was any error or sorry messages. */
1493 if (errorcount == 0 && sorrycount == 0)
1496 /* This pass remove bodies of extern inline functions we never inlined.
1497 Do this later so other IPA passes see what is really going on. */
1498 cgraph_remove_unreachable_nodes (false, dump_file);
1499 cgraph_global_info_ready = true;
1500 if (cgraph_dump_file)
1502 fprintf (cgraph_dump_file, "Optimized ");
1503 dump_cgraph (cgraph_dump_file);
1504 dump_varpool (cgraph_dump_file);
1506 timevar_pop (TV_CGRAPHOPT);
1508 /* Output everything. */
1510 fprintf (stderr, "Assembling functions:\n");
1511 #ifdef ENABLE_CHECKING
1515 cgraph_mark_functions_to_output ();
1517 if (!flag_toplevel_reorder)
1518 cgraph_output_in_order ();
1521 cgraph_output_pending_asms ();
1523 cgraph_expand_all_functions ();
1524 cgraph_varpool_remove_unreferenced_decls ();
1526 cgraph_varpool_assemble_pending_decls ();
1529 if (cgraph_dump_file)
1531 fprintf (cgraph_dump_file, "\nFinal ");
1532 dump_cgraph (cgraph_dump_file);
1534 #ifdef ENABLE_CHECKING
1536 /* Double check that all inline clones are gone and that all
1537 function bodies have been released from memory. */
1538 if (flag_unit_at_a_time
1539 && !(sorrycount || errorcount))
1541 struct cgraph_node *node;
1542 bool error_found = false;
1544 for (node = cgraph_nodes; node; node = node->next)
1546 && (node->global.inlined_to
1547 || DECL_SAVED_TREE (node->decl)))
1550 dump_cgraph_node (stderr, node);
1553 internal_error ("nodes with no released memory found");
1558 /* Generate and emit a static constructor or destructor. WHICH must be
1559 one of 'I' or 'D'. BODY should be a STATEMENT_LIST containing
1560 GENERIC statements. */
1563 cgraph_build_static_cdtor (char which, tree body, int priority)
1565 static int counter = 0;
1567 tree decl, name, resdecl;
1569 sprintf (which_buf, "%c_%d", which, counter++);
1570 name = get_file_function_name_long (which_buf);
1572 decl = build_decl (FUNCTION_DECL, name,
1573 build_function_type (void_type_node, void_list_node));
1574 current_function_decl = decl;
1576 resdecl = build_decl (RESULT_DECL, NULL_TREE, void_type_node);
1577 DECL_ARTIFICIAL (resdecl) = 1;
1578 DECL_IGNORED_P (resdecl) = 1;
1579 DECL_RESULT (decl) = resdecl;
1581 allocate_struct_function (decl);
1583 TREE_STATIC (decl) = 1;
1584 TREE_USED (decl) = 1;
1585 DECL_ARTIFICIAL (decl) = 1;
1586 DECL_IGNORED_P (decl) = 1;
1587 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
1588 DECL_SAVED_TREE (decl) = body;
1589 TREE_PUBLIC (decl) = ! targetm.have_ctors_dtors;
1590 DECL_UNINLINABLE (decl) = 1;
1592 DECL_INITIAL (decl) = make_node (BLOCK);
1593 TREE_USED (DECL_INITIAL (decl)) = 1;
1595 DECL_SOURCE_LOCATION (decl) = input_location;
1596 cfun->function_end_locus = input_location;
1601 DECL_STATIC_CONSTRUCTOR (decl) = 1;
1604 DECL_STATIC_DESTRUCTOR (decl) = 1;
1610 gimplify_function_tree (decl);
1612 /* ??? We will get called LATE in the compilation process. */
1613 if (cgraph_global_info_ready)
1615 tree_lowering_passes (decl);
1616 tree_rest_of_compilation (decl);
1619 cgraph_finalize_function (decl, 0);
1621 if (targetm.have_ctors_dtors)
1623 void (*fn) (rtx, int);
1626 fn = targetm.asm_out.constructor;
1628 fn = targetm.asm_out.destructor;
1629 fn (XEXP (DECL_RTL (decl), 0), priority);
1636 cgraph_dump_file = dump_begin (TDI_cgraph, NULL);
1639 /* The edges representing the callers of the NEW_VERSION node were
1640 fixed by cgraph_function_versioning (), now the call_expr in their
1641 respective tree code should be updated to call the NEW_VERSION. */
1644 update_call_expr (struct cgraph_node *new_version)
1646 struct cgraph_edge *e;
1648 gcc_assert (new_version);
1649 for (e = new_version->callers; e; e = e->next_caller)
1650 /* Update the call expr on the edges
1651 to call the new version. */
1652 TREE_OPERAND (TREE_OPERAND (get_call_expr_in (e->call_stmt), 0), 0) = new_version->decl;
1656 /* Create a new cgraph node which is the new version of
1657 OLD_VERSION node. REDIRECT_CALLERS holds the callers
1658 edges which should be redirected to point to
1659 NEW_VERSION. ALL the callees edges of OLD_VERSION
1660 are cloned to the new version node. Return the new
1663 static struct cgraph_node *
1664 cgraph_copy_node_for_versioning (struct cgraph_node *old_version,
1666 VEC(cgraph_edge_p,heap) *redirect_callers)
1668 struct cgraph_node *new_version;
1669 struct cgraph_edge *e, *new_e;
1670 struct cgraph_edge *next_callee;
1673 gcc_assert (old_version);
1675 new_version = cgraph_node (new_decl);
1677 new_version->analyzed = true;
1678 new_version->local = old_version->local;
1679 new_version->global = old_version->global;
1680 new_version->rtl = new_version->rtl;
1681 new_version->reachable = true;
1682 new_version->count = old_version->count;
1684 /* Clone the old node callees. Recursive calls are
1686 for (e = old_version->callees;e; e=e->next_callee)
1688 new_e = cgraph_clone_edge (e, new_version, e->call_stmt, 0, e->loop_nest, true);
1689 new_e->count = e->count;
1691 /* Fix recursive calls.
1692 If OLD_VERSION has a recursive call after the
1693 previous edge cloning, the new version will have an edge
1694 pointing to the old version, which is wrong;
1695 Redirect it to point to the new version. */
1696 for (e = new_version->callees ; e; e = next_callee)
1698 next_callee = e->next_callee;
1699 if (e->callee == old_version)
1700 cgraph_redirect_edge_callee (e, new_version);
1705 for (i = 0; VEC_iterate (cgraph_edge_p, redirect_callers, i, e); i++)
1707 /* Redirect calls to the old version node to point to its new
1709 cgraph_redirect_edge_callee (e, new_version);
1715 /* Perform function versioning.
1716 Function versioning includes copying of the tree and
1717 a callgraph update (creating a new cgraph node and updating
1718 its callees and callers).
1720 REDIRECT_CALLERS varray includes the edges to be redirected
1723 TREE_MAP is a mapping of tree nodes we want to replace with
1724 new ones (according to results of prior analysis).
1725 OLD_VERSION_NODE is the node that is versioned.
1726 It returns the new version's cgraph node. */
1728 struct cgraph_node *
1729 cgraph_function_versioning (struct cgraph_node *old_version_node,
1730 VEC(cgraph_edge_p,heap) *redirect_callers,
1731 varray_type tree_map)
1733 tree old_decl = old_version_node->decl;
1734 struct cgraph_node *new_version_node = NULL;
1737 if (!tree_versionable_function_p (old_decl))
1740 /* Make a new FUNCTION_DECL tree node for the
1742 new_decl = copy_node (old_decl);
1744 /* Create the new version's call-graph node.
1745 and update the edges of the new node. */
1747 cgraph_copy_node_for_versioning (old_version_node, new_decl,
1750 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1751 tree_function_versioning (old_decl, new_decl, tree_map, false);
1752 /* Update the call_expr on the edges to call the new version node. */
1753 update_call_expr (new_version_node);
1755 /* Update the new version's properties.
1756 Make The new version visible only within this translation unit.
1757 ??? We cannot use COMDAT linkage because there is no
1758 ABI support for this. */
1759 DECL_EXTERNAL (new_version_node->decl) = 0;
1760 DECL_ONE_ONLY (new_version_node->decl) = 0;
1761 TREE_PUBLIC (new_version_node->decl) = 0;
1762 DECL_COMDAT (new_version_node->decl) = 0;
1763 new_version_node->local.externally_visible = 0;
1764 new_version_node->local.local = 1;
1765 new_version_node->lowered = true;
1766 return new_version_node;
1769 /* Produce separate function body for inline clones so the offline copy can be
1770 modified without affecting them. */
1771 struct cgraph_node *
1772 save_inline_function_body (struct cgraph_node *node)
1774 struct cgraph_node *first_clone;
1776 gcc_assert (node == cgraph_node (node->decl));
1778 cgraph_lower_function (node);
1780 /* In non-unit-at-a-time we construct full fledged clone we never output to
1781 assembly file. This clone is pointed out by inline_decl of original function
1782 and inlining infrastructure knows how to deal with this. */
1783 if (!flag_unit_at_a_time)
1785 struct cgraph_edge *e;
1787 first_clone = cgraph_clone_node (node, node->count, 0, false);
1788 first_clone->needed = 0;
1789 first_clone->reachable = 1;
1790 /* Recursively clone all bodies. */
1791 for (e = first_clone->callees; e; e = e->next_callee)
1792 if (!e->inline_failed)
1793 cgraph_clone_inlined_nodes (e, true, false);
1796 first_clone = node->next_clone;
1798 first_clone->decl = copy_node (node->decl);
1799 node->next_clone = NULL;
1800 if (!flag_unit_at_a_time)
1801 node->inline_decl = first_clone->decl;
1802 first_clone->prev_clone = NULL;
1803 cgraph_insert_node_to_hashtable (first_clone);
1804 gcc_assert (first_clone == cgraph_node (first_clone->decl));
1806 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1807 tree_function_versioning (node->decl, first_clone->decl, NULL, true);
1809 DECL_EXTERNAL (first_clone->decl) = 0;
1810 DECL_ONE_ONLY (first_clone->decl) = 0;
1811 TREE_PUBLIC (first_clone->decl) = 0;
1812 DECL_COMDAT (first_clone->decl) = 0;
1814 for (node = first_clone->next_clone; node; node = node->next_clone)
1815 node->decl = first_clone->decl;
1816 #ifdef ENABLE_CHECKING
1817 verify_cgraph_node (first_clone);