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
202 || lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
205 /* ??? If the assembler name is set by hand, it is possible to assemble
206 the name later after finalizing the function and the fact is noticed
207 in assemble_name then. This is arguably a bug. */
208 if (DECL_ASSEMBLER_NAME_SET_P (decl)
209 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
212 /* If we decided it was needed before, but at the time we didn't have
213 the body of the function available, then it's still needed. We have
214 to go back and re-check its dependencies now. */
218 /* Externally visible functions must be output. The exception is
219 COMDAT functions that must be output only when they are needed.
221 When not optimizing, also output the static functions. (see
222 PR24561), but don't do so for always_inline functions, functions
223 declared inline and nested functions. These was optimized out
224 in the original implementation and it is unclear whether we want
225 to change the behavior here. */
226 if (((TREE_PUBLIC (decl)
227 || (!optimize && !node->local.disregard_inline_limits
228 && !DECL_DECLARED_INLINE_P (decl)
230 && !flag_whole_program)
231 && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl))
234 /* Constructors and destructors are reachable from the runtime by
236 if (DECL_STATIC_CONSTRUCTOR (decl) || DECL_STATIC_DESTRUCTOR (decl))
239 if (flag_unit_at_a_time)
242 /* If not doing unit at a time, then we'll only defer this function
243 if its marked for inlining. Otherwise we want to emit it now. */
245 /* "extern inline" functions are never output locally. */
246 if (DECL_EXTERNAL (decl))
248 /* Nested functions of extern inline function shall not be emit unless
249 we inlined the origin. */
250 for (origin = decl_function_context (decl); origin;
251 origin = decl_function_context (origin))
252 if (DECL_EXTERNAL (origin))
254 /* We want to emit COMDAT functions only when absolutely necessary. */
255 if (DECL_COMDAT (decl))
257 if (!DECL_INLINE (decl)
258 || (!node->local.disregard_inline_limits
259 /* When declared inline, defer even the uninlinable functions.
260 This allows them to be eliminated when unused. */
261 && !DECL_DECLARED_INLINE_P (decl)
262 && (!node->local.inlinable || !cgraph_default_inline_p (node, NULL))))
268 /* Walk the decls we marked as necessary and see if they reference new
269 variables or functions and add them into the worklists. */
271 cgraph_varpool_analyze_pending_decls (void)
273 bool changed = false;
274 timevar_push (TV_CGRAPH);
276 while (cgraph_varpool_first_unanalyzed_node)
278 tree decl = cgraph_varpool_first_unanalyzed_node->decl;
280 cgraph_varpool_first_unanalyzed_node->analyzed = true;
282 cgraph_varpool_first_unanalyzed_node = cgraph_varpool_first_unanalyzed_node->next_needed;
284 /* Compute the alignment early so function body expanders are
285 already informed about increased alignment. */
286 align_variable (decl, 0);
288 if (DECL_INITIAL (decl))
290 visited_nodes = pointer_set_create ();
291 walk_tree (&DECL_INITIAL (decl), record_reference, NULL, visited_nodes);
292 pointer_set_destroy (visited_nodes);
293 visited_nodes = NULL;
297 timevar_pop (TV_CGRAPH);
301 /* Optimization of function bodies might've rendered some variables as
302 unnecessary so we want to avoid these from being compiled.
304 This is done by pruning the queue and keeping only the variables that
305 really appear needed (ie they are either externally visible or referenced
306 by compiled function). Re-doing the reachability analysis on variables
307 brings back the remaining variables referenced by these. */
309 cgraph_varpool_remove_unreferenced_decls (void)
311 struct cgraph_varpool_node *next, *node = cgraph_varpool_nodes_queue;
313 cgraph_varpool_reset_queue ();
315 if (errorcount || sorrycount)
320 tree decl = node->decl;
321 next = node->next_needed;
325 && ((DECL_ASSEMBLER_NAME_SET_P (decl)
326 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
327 || node->force_output
328 || decide_is_variable_needed (node, decl)
329 /* ??? Cgraph does not yet rule the world with an iron hand,
330 and does not control the emission of debug information.
331 After a variable has its DECL_RTL set, we must assume that
332 it may be referenced by the debug information, and we can
333 no longer elide it. */
334 || DECL_RTL_SET_P (decl)))
335 cgraph_varpool_mark_needed_node (node);
339 /* Make sure we mark alias targets as used targets. */
341 cgraph_varpool_analyze_pending_decls ();
345 /* When not doing unit-at-a-time, output all functions enqueued.
346 Return true when such a functions were found. */
349 cgraph_assemble_pending_functions (void)
353 if (flag_unit_at_a_time)
356 cgraph_output_pending_asms ();
358 while (cgraph_nodes_queue)
360 struct cgraph_node *n = cgraph_nodes_queue;
362 cgraph_nodes_queue = cgraph_nodes_queue->next_needed;
363 n->next_needed = NULL;
364 if (!n->global.inlined_to
366 && !DECL_EXTERNAL (n->decl))
368 cgraph_expand_function (n);
373 /* Process CGRAPH_EXPAND_QUEUE, these are functions created during
374 the expansion process. Note that this queue may grow as its
375 being processed, as the new functions may generate new ones. */
376 while (cgraph_expand_queue)
378 struct cgraph_node *n = cgraph_expand_queue;
379 cgraph_expand_queue = cgraph_expand_queue->next_needed;
380 n->next_needed = NULL;
381 cgraph_finalize_function (n->decl, false);
389 /* As an GCC extension we allow redefinition of the function. The
390 semantics when both copies of bodies differ is not well defined.
391 We replace the old body with new body so in unit at a time mode
392 we always use new body, while in normal mode we may end up with
393 old body inlined into some functions and new body expanded and
396 ??? It may make more sense to use one body for inlining and other
397 body for expanding the function but this is difficult to do. */
400 cgraph_reset_node (struct cgraph_node *node)
402 /* If node->output is set, then this is a unit-at-a-time compilation
403 and we have already begun whole-unit analysis. This is *not*
404 testing for whether we've already emitted the function. That
405 case can be sort-of legitimately seen with real function
406 redefinition errors. I would argue that the front end should
407 never present us with such a case, but don't enforce that for now. */
408 gcc_assert (!node->output);
410 /* Reset our data structures so we can analyze the function again. */
411 memset (&node->local, 0, sizeof (node->local));
412 memset (&node->global, 0, sizeof (node->global));
413 memset (&node->rtl, 0, sizeof (node->rtl));
414 node->analyzed = false;
415 node->local.redefined_extern_inline = true;
416 node->local.finalized = false;
418 if (!flag_unit_at_a_time)
420 struct cgraph_node *n;
422 for (n = cgraph_nodes; n; n = n->next)
423 if (n->global.inlined_to == node)
424 cgraph_remove_node (n);
427 cgraph_node_remove_callees (node);
429 /* We may need to re-queue the node for assembling in case
430 we already proceeded it and ignored as not needed. */
431 if (node->reachable && !flag_unit_at_a_time)
433 struct cgraph_node *n;
435 for (n = cgraph_nodes_queue; n; n = n->next_needed)
444 cgraph_lower_function (struct cgraph_node *node)
448 tree_lowering_passes (node->decl);
449 node->lowered = true;
452 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
453 logic in effect. If NESTED is true, then our caller cannot stand to have
454 the garbage collector run at the moment. We would need to either create
455 a new GC context, or just not compile right now. */
458 cgraph_finalize_function (tree decl, bool nested)
460 struct cgraph_node *node = cgraph_node (decl);
462 if (node->local.finalized)
463 cgraph_reset_node (node);
465 notice_global_symbol (decl);
467 node->local.finalized = true;
468 node->lowered = DECL_STRUCT_FUNCTION (decl)->cfg != NULL;
470 lower_nested_functions (decl);
471 gcc_assert (!node->nested);
473 /* If not unit at a time, then we need to create the call graph
474 now, so that called functions can be queued and emitted now. */
475 if (!flag_unit_at_a_time)
477 cgraph_analyze_function (node);
478 cgraph_decide_inlining_incrementally (node, false);
481 if (decide_is_function_needed (node, decl))
482 cgraph_mark_needed_node (node);
484 /* Since we reclaim unreachable nodes at the end of every language
485 level unit, we need to be conservative about possible entry points
487 if ((TREE_PUBLIC (decl) && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl)))
488 cgraph_mark_reachable_node (node);
490 /* If not unit at a time, go ahead and emit everything we've found
491 to be reachable at this time. */
494 if (!cgraph_assemble_pending_functions ())
498 /* If we've not yet emitted decl, tell the debug info about it. */
499 if (!TREE_ASM_WRITTEN (decl))
500 (*debug_hooks->deferred_inline_function) (decl);
502 /* Possibly warn about unused parameters. */
503 if (warn_unused_parameter)
504 do_warn_unused_parameter (decl);
507 /* Walk tree and record all calls. Called via walk_tree. */
509 record_reference (tree *tp, int *walk_subtrees, void *data)
513 switch (TREE_CODE (t))
516 /* ??? Really, we should mark this decl as *potentially* referenced
517 by this function and re-examine whether the decl is actually used
518 after rtl has been generated. */
519 if (TREE_STATIC (t) || DECL_EXTERNAL (t))
521 cgraph_varpool_mark_needed_node (cgraph_varpool_node (t));
522 if (lang_hooks.callgraph.analyze_expr)
523 return lang_hooks.callgraph.analyze_expr (tp, walk_subtrees,
530 if (flag_unit_at_a_time)
532 /* Record dereferences to the functions. This makes the
533 functions reachable unconditionally. */
534 tree decl = TREE_OPERAND (*tp, 0);
535 if (TREE_CODE (decl) == FUNCTION_DECL)
536 cgraph_mark_needed_node (cgraph_node (decl));
541 /* Save some cycles by not walking types and declaration as we
542 won't find anything useful there anyway. */
543 if (IS_TYPE_OR_DECL_P (*tp))
549 if ((unsigned int) TREE_CODE (t) >= LAST_AND_UNUSED_TREE_CODE)
550 return lang_hooks.callgraph.analyze_expr (tp, walk_subtrees, data);
557 /* Create cgraph edges for function calls inside BODY from NODE. */
560 cgraph_create_edges (struct cgraph_node *node, tree body)
564 struct function *this_cfun = DECL_STRUCT_FUNCTION (body);
565 block_stmt_iterator bsi;
567 visited_nodes = pointer_set_create ();
569 /* Reach the trees by walking over the CFG, and note the
570 enclosing basic-blocks in the call edges. */
571 FOR_EACH_BB_FN (bb, this_cfun)
572 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
574 tree stmt = bsi_stmt (bsi);
575 tree call = get_call_expr_in (stmt);
578 if (call && (decl = get_callee_fndecl (call)))
580 cgraph_create_edge (node, cgraph_node (decl), stmt,
583 walk_tree (&TREE_OPERAND (call, 1),
584 record_reference, node, visited_nodes);
585 if (TREE_CODE (stmt) == MODIFY_EXPR)
586 walk_tree (&TREE_OPERAND (stmt, 0),
587 record_reference, node, visited_nodes);
590 walk_tree (bsi_stmt_ptr (bsi), record_reference, node, visited_nodes);
593 /* Look for initializers of constant variables and private statics. */
594 for (step = DECL_STRUCT_FUNCTION (body)->unexpanded_var_list;
596 step = TREE_CHAIN (step))
598 tree decl = TREE_VALUE (step);
599 if (TREE_CODE (decl) == VAR_DECL
600 && (TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
601 && flag_unit_at_a_time)
602 cgraph_varpool_finalize_decl (decl);
603 else if (TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
604 walk_tree (&DECL_INITIAL (decl), record_reference, node, visited_nodes);
607 pointer_set_destroy (visited_nodes);
608 visited_nodes = NULL;
611 /* Give initial reasons why inlining would fail. Those gets
612 either NULLified or usually overwritten by more precise reason
615 initialize_inline_failed (struct cgraph_node *node)
617 struct cgraph_edge *e;
619 for (e = node->callers; e; e = e->next_caller)
621 gcc_assert (!e->callee->global.inlined_to);
622 gcc_assert (e->inline_failed);
623 if (node->local.redefined_extern_inline)
624 e->inline_failed = N_("redefined extern inline functions are not "
625 "considered for inlining");
626 else if (!node->local.inlinable)
627 e->inline_failed = N_("function not inlinable");
629 e->inline_failed = N_("function not considered for inlining");
633 /* Rebuild call edges from current function after a passes not aware
634 of cgraph updating. */
636 rebuild_cgraph_edges (void)
639 struct cgraph_node *node = cgraph_node (current_function_decl);
640 block_stmt_iterator bsi;
642 cgraph_node_remove_callees (node);
644 node->count = ENTRY_BLOCK_PTR->count;
647 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
649 tree stmt = bsi_stmt (bsi);
650 tree call = get_call_expr_in (stmt);
653 if (call && (decl = get_callee_fndecl (call)))
654 cgraph_create_edge (node, cgraph_node (decl), stmt,
658 initialize_inline_failed (node);
659 gcc_assert (!node->global.inlined_to);
663 struct tree_opt_pass pass_rebuild_cgraph_edges =
667 rebuild_cgraph_edges, /* execute */
670 0, /* static_pass_number */
672 PROP_cfg, /* properties_required */
673 0, /* properties_provided */
674 0, /* properties_destroyed */
675 0, /* todo_flags_start */
676 0, /* todo_flags_finish */
680 /* Verify cgraph nodes of given cgraph node. */
682 verify_cgraph_node (struct cgraph_node *node)
684 struct cgraph_edge *e;
685 struct cgraph_node *main_clone;
686 struct function *this_cfun = DECL_STRUCT_FUNCTION (node->decl);
687 basic_block this_block;
688 block_stmt_iterator bsi;
689 bool error_found = false;
691 timevar_push (TV_CGRAPH_VERIFY);
692 for (e = node->callees; e; e = e->next_callee)
695 error ("aux field set for edge %s->%s",
696 cgraph_node_name (e->caller), cgraph_node_name (e->callee));
701 error ("Execution count is negative");
704 for (e = node->callers; e; e = e->next_caller)
708 error ("caller edge count is negative");
711 if (!e->inline_failed)
713 if (node->global.inlined_to
714 != (e->caller->global.inlined_to
715 ? e->caller->global.inlined_to : e->caller))
717 error ("inlined_to pointer is wrong");
720 if (node->callers->next_caller)
722 error ("multiple inline callers");
727 if (node->global.inlined_to)
729 error ("inlined_to pointer set for noninline callers");
733 if (!node->callers && node->global.inlined_to)
735 error ("inlined_to pointer is set but no predecessors found");
738 if (node->global.inlined_to == node)
740 error ("inlined_to pointer refers to itself");
744 for (main_clone = cgraph_node (node->decl); main_clone;
745 main_clone = main_clone->next_clone)
746 if (main_clone == node)
748 if (!cgraph_node (node->decl))
750 error ("node not found in cgraph_hash");
755 && DECL_SAVED_TREE (node->decl) && !TREE_ASM_WRITTEN (node->decl)
756 && (!DECL_EXTERNAL (node->decl) || node->global.inlined_to))
760 /* The nodes we're interested in are never shared, so walk
761 the tree ignoring duplicates. */
762 visited_nodes = pointer_set_create ();
763 /* Reach the trees by walking over the CFG, and note the
764 enclosing basic-blocks in the call edges. */
765 FOR_EACH_BB_FN (this_block, this_cfun)
766 for (bsi = bsi_start (this_block); !bsi_end_p (bsi); bsi_next (&bsi))
768 tree stmt = bsi_stmt (bsi);
769 tree call = get_call_expr_in (stmt);
771 if (call && (decl = get_callee_fndecl (call)))
773 struct cgraph_edge *e = cgraph_edge (node, stmt);
778 error ("shared call_stmt:");
779 debug_generic_stmt (stmt);
782 if (e->callee->decl != cgraph_node (decl)->decl
785 error ("edge points to wrong declaration:");
786 debug_tree (e->callee->decl);
787 fprintf (stderr," Instead of:");
794 error ("missing callgraph edge for call stmt:");
795 debug_generic_stmt (stmt);
800 pointer_set_destroy (visited_nodes);
801 visited_nodes = NULL;
804 /* No CFG available?! */
807 for (e = node->callees; e; e = e->next_callee)
811 error ("edge %s->%s has no corresponding call_stmt",
812 cgraph_node_name (e->caller),
813 cgraph_node_name (e->callee));
814 debug_generic_stmt (e->call_stmt);
822 dump_cgraph_node (stderr, node);
823 internal_error ("verify_cgraph_node failed");
825 timevar_pop (TV_CGRAPH_VERIFY);
828 /* Verify whole cgraph structure. */
832 struct cgraph_node *node;
834 if (sorrycount || errorcount)
837 for (node = cgraph_nodes; node; node = node->next)
838 verify_cgraph_node (node);
841 /* Output one variable, if necessary. Return whether we output it. */
843 cgraph_varpool_assemble_decl (struct cgraph_varpool_node *node)
845 tree decl = node->decl;
847 if (!TREE_ASM_WRITTEN (decl)
849 && !DECL_EXTERNAL (decl)
850 && (TREE_CODE (decl) != VAR_DECL || !DECL_HAS_VALUE_EXPR_P (decl)))
852 assemble_variable (decl, 0, 1, 0);
853 /* Local static variables are never seen by check_global_declarations
854 so we need to output debug info by hand. */
855 if (DECL_CONTEXT (decl)
856 && (TREE_CODE (DECL_CONTEXT (decl)) == BLOCK
857 || TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)
858 && errorcount == 0 && sorrycount == 0)
860 timevar_push (TV_SYMOUT);
861 (*debug_hooks->global_decl) (decl);
862 timevar_pop (TV_SYMOUT);
870 /* Output all variables enqueued to be assembled. */
872 cgraph_varpool_assemble_pending_decls (void)
874 bool changed = false;
876 if (errorcount || sorrycount)
879 /* EH might mark decls as needed during expansion. This should be safe since
880 we don't create references to new function, but it should not be used
882 cgraph_varpool_analyze_pending_decls ();
884 while (cgraph_varpool_nodes_queue)
886 struct cgraph_varpool_node *node = cgraph_varpool_nodes_queue;
888 cgraph_varpool_nodes_queue = cgraph_varpool_nodes_queue->next_needed;
889 if (cgraph_varpool_assemble_decl (node))
891 node->next_needed = NULL;
896 /* Output all asm statements we have stored up to be output. */
899 cgraph_output_pending_asms (void)
901 struct cgraph_asm_node *can;
903 if (errorcount || sorrycount)
906 for (can = cgraph_asm_nodes; can; can = can->next)
907 assemble_asm (can->asm_str);
908 cgraph_asm_nodes = NULL;
911 /* Analyze the function scheduled to be output. */
913 cgraph_analyze_function (struct cgraph_node *node)
915 tree decl = node->decl;
917 current_function_decl = decl;
918 push_cfun (DECL_STRUCT_FUNCTION (decl));
919 cgraph_lower_function (node);
921 /* First kill forward declaration so reverse inlining works properly. */
922 cgraph_create_edges (node, decl);
924 node->local.inlinable = tree_inlinable_function_p (decl);
925 node->local.self_insns = estimate_num_insns (decl);
926 if (node->local.inlinable)
927 node->local.disregard_inline_limits
928 = lang_hooks.tree_inlining.disregard_inline_limits (decl);
929 initialize_inline_failed (node);
930 if (flag_really_no_inline && !node->local.disregard_inline_limits)
931 node->local.inlinable = 0;
932 /* Inlining characteristics are maintained by the cgraph_mark_inline. */
933 node->global.insns = node->local.self_insns;
935 node->analyzed = true;
937 current_function_decl = NULL;
940 /* Analyze the whole compilation unit once it is parsed completely. */
943 cgraph_finalize_compilation_unit (void)
945 struct cgraph_node *node;
946 /* Keep track of already processed nodes when called multiple times for
947 intermodule optimization. */
948 static struct cgraph_node *first_analyzed;
952 if (!flag_unit_at_a_time)
954 cgraph_output_pending_asms ();
955 cgraph_assemble_pending_functions ();
961 fprintf (stderr, "\nAnalyzing compilation unit");
965 timevar_push (TV_CGRAPH);
966 cgraph_varpool_analyze_pending_decls ();
967 if (cgraph_dump_file)
969 fprintf (cgraph_dump_file, "Initial entry points:");
970 for (node = cgraph_nodes; node != first_analyzed; node = node->next)
971 if (node->needed && DECL_SAVED_TREE (node->decl))
972 fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
973 fprintf (cgraph_dump_file, "\n");
976 /* Propagate reachability flag and lower representation of all reachable
977 functions. In the future, lowering will introduce new functions and
978 new entry points on the way (by template instantiation and virtual
979 method table generation for instance). */
980 while (cgraph_nodes_queue)
982 struct cgraph_edge *edge;
983 tree decl = cgraph_nodes_queue->decl;
985 node = cgraph_nodes_queue;
986 cgraph_nodes_queue = cgraph_nodes_queue->next_needed;
987 node->next_needed = NULL;
989 /* ??? It is possible to create extern inline function and later using
990 weak alias attribute to kill its body. See
991 gcc.c-torture/compile/20011119-1.c */
992 if (!DECL_SAVED_TREE (decl))
994 cgraph_reset_node (node);
998 gcc_assert (!node->analyzed && node->reachable);
999 gcc_assert (DECL_SAVED_TREE (decl));
1001 cgraph_analyze_function (node);
1003 for (edge = node->callees; edge; edge = edge->next_callee)
1004 if (!edge->callee->reachable)
1005 cgraph_mark_reachable_node (edge->callee);
1007 cgraph_varpool_analyze_pending_decls ();
1010 /* Collect entry points to the unit. */
1012 if (cgraph_dump_file)
1014 fprintf (cgraph_dump_file, "Unit entry points:");
1015 for (node = cgraph_nodes; node != first_analyzed; node = node->next)
1016 if (node->needed && DECL_SAVED_TREE (node->decl))
1017 fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
1018 fprintf (cgraph_dump_file, "\n\nInitial ");
1019 dump_cgraph (cgraph_dump_file);
1022 if (cgraph_dump_file)
1023 fprintf (cgraph_dump_file, "\nReclaiming functions:");
1025 for (node = cgraph_nodes; node != first_analyzed; node = node->next)
1027 tree decl = node->decl;
1029 if (node->local.finalized && !DECL_SAVED_TREE (decl))
1030 cgraph_reset_node (node);
1032 if (!node->reachable && DECL_SAVED_TREE (decl))
1034 if (cgraph_dump_file)
1035 fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
1036 cgraph_remove_node (node);
1040 node->next_needed = NULL;
1041 gcc_assert (!node->local.finalized || DECL_SAVED_TREE (decl));
1042 gcc_assert (node->analyzed == node->local.finalized);
1044 if (cgraph_dump_file)
1046 fprintf (cgraph_dump_file, "\n\nReclaimed ");
1047 dump_cgraph (cgraph_dump_file);
1049 first_analyzed = cgraph_nodes;
1051 timevar_pop (TV_CGRAPH);
1053 /* Figure out what functions we want to assemble. */
1056 cgraph_mark_functions_to_output (void)
1058 struct cgraph_node *node;
1060 for (node = cgraph_nodes; node; node = node->next)
1062 tree decl = node->decl;
1063 struct cgraph_edge *e;
1065 gcc_assert (!node->output);
1067 for (e = node->callers; e; e = e->next_caller)
1068 if (e->inline_failed)
1071 /* We need to output all local functions that are used and not
1072 always inlined, as well as those that are reachable from
1073 outside the current compilation unit. */
1074 if (DECL_SAVED_TREE (decl)
1075 && !node->global.inlined_to
1077 || (e && node->reachable))
1078 && !TREE_ASM_WRITTEN (decl)
1079 && !DECL_EXTERNAL (decl))
1083 /* We should've reclaimed all functions that are not needed. */
1084 #ifdef ENABLE_CHECKING
1085 if (!node->global.inlined_to && DECL_SAVED_TREE (decl)
1086 && !DECL_EXTERNAL (decl))
1088 dump_cgraph_node (stderr, node);
1089 internal_error ("failed to reclaim unneeded function");
1092 gcc_assert (node->global.inlined_to || !DECL_SAVED_TREE (decl)
1093 || DECL_EXTERNAL (decl));
1100 /* Expand function specified by NODE. */
1103 cgraph_expand_function (struct cgraph_node *node)
1105 tree decl = node->decl;
1107 /* We ought to not compile any inline clones. */
1108 gcc_assert (!node->global.inlined_to);
1110 if (flag_unit_at_a_time)
1111 announce_function (decl);
1113 cgraph_lower_function (node);
1115 /* Generate RTL for the body of DECL. */
1116 lang_hooks.callgraph.expand_function (decl);
1118 /* Make sure that BE didn't give up on compiling. */
1119 /* ??? Can happen with nested function of extern inline. */
1120 gcc_assert (TREE_ASM_WRITTEN (node->decl));
1122 current_function_decl = NULL;
1123 if (!cgraph_preserve_function_body_p (node->decl))
1125 DECL_SAVED_TREE (node->decl) = NULL;
1126 DECL_STRUCT_FUNCTION (node->decl) = NULL;
1127 DECL_INITIAL (node->decl) = error_mark_node;
1128 /* Eliminate all call edges. This is important so the call_expr no longer
1129 points to the dead function body. */
1130 cgraph_node_remove_callees (node);
1133 cgraph_function_flags_ready = true;
1136 /* Return true when CALLER_DECL should be inlined into CALLEE_DECL. */
1139 cgraph_inline_p (struct cgraph_edge *e, const char **reason)
1141 *reason = e->inline_failed;
1142 return !e->inline_failed;
1147 /* Expand all functions that must be output.
1149 Attempt to topologically sort the nodes so function is output when
1150 all called functions are already assembled to allow data to be
1151 propagated across the callgraph. Use a stack to get smaller distance
1152 between a function and its callees (later we may choose to use a more
1153 sophisticated algorithm for function reordering; we will likely want
1154 to use subsections to make the output functions appear in top-down
1158 cgraph_expand_all_functions (void)
1160 struct cgraph_node *node;
1161 struct cgraph_node **order = XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
1162 int order_pos = 0, new_order_pos = 0;
1165 order_pos = cgraph_postorder (order);
1166 gcc_assert (order_pos == cgraph_n_nodes);
1168 /* Garbage collector may remove inline clones we eliminate during
1169 optimization. So we must be sure to not reference them. */
1170 for (i = 0; i < order_pos; i++)
1171 if (order[i]->output)
1172 order[new_order_pos++] = order[i];
1174 for (i = new_order_pos - 1; i >= 0; i--)
1179 gcc_assert (node->reachable);
1181 cgraph_expand_function (node);
1187 /* Process CGRAPH_EXPAND_QUEUE, these are functions created during
1188 the expansion process. Note that this queue may grow as its
1189 being processed, as the new functions may generate new ones. */
1190 while (cgraph_expand_queue)
1192 node = cgraph_expand_queue;
1193 cgraph_expand_queue = cgraph_expand_queue->next_needed;
1194 node->next_needed = NULL;
1196 node->lowered = DECL_STRUCT_FUNCTION (node->decl)->cfg != NULL;
1197 cgraph_expand_function (node);
1201 /* This is used to sort the node types by the cgraph order number. */
1203 struct cgraph_order_sort
1205 enum { ORDER_UNDEFINED = 0, ORDER_FUNCTION, ORDER_VAR, ORDER_ASM } kind;
1208 struct cgraph_node *f;
1209 struct cgraph_varpool_node *v;
1210 struct cgraph_asm_node *a;
1214 /* Output all functions, variables, and asm statements in the order
1215 according to their order fields, which is the order in which they
1216 appeared in the file. This implements -fno-toplevel-reorder. In
1217 this mode we may output functions and variables which don't really
1218 need to be output. */
1221 cgraph_output_in_order (void)
1225 struct cgraph_order_sort *nodes;
1227 struct cgraph_node *pf;
1228 struct cgraph_varpool_node *pv;
1229 struct cgraph_asm_node *pa;
1232 size = max * sizeof (struct cgraph_order_sort);
1233 nodes = (struct cgraph_order_sort *) alloca (size);
1234 memset (nodes, 0, size);
1236 cgraph_varpool_analyze_pending_decls ();
1238 for (pf = cgraph_nodes; pf; pf = pf->next)
1243 gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
1244 nodes[i].kind = ORDER_FUNCTION;
1249 for (pv = cgraph_varpool_nodes_queue; pv; pv = pv->next_needed)
1252 gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
1253 nodes[i].kind = ORDER_VAR;
1257 for (pa = cgraph_asm_nodes; pa; pa = pa->next)
1260 gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
1261 nodes[i].kind = ORDER_ASM;
1265 for (i = 0; i < max; ++i)
1267 switch (nodes[i].kind)
1269 case ORDER_FUNCTION:
1270 nodes[i].u.f->output = 0;
1271 cgraph_expand_function (nodes[i].u.f);
1275 cgraph_varpool_assemble_decl (nodes[i].u.v);
1279 assemble_asm (nodes[i].u.a->asm_str);
1282 case ORDER_UNDEFINED:
1290 cgraph_asm_nodes = NULL;
1293 /* Mark visibility of all functions.
1295 A local function is one whose calls can occur only in the current
1296 compilation unit and all its calls are explicit, so we can change
1297 its calling convention. We simply mark all static functions whose
1298 address is not taken as local.
1300 We also change the TREE_PUBLIC flag of all declarations that are public
1301 in language point of view but we want to overwrite this default
1302 via visibilities for the backend point of view. */
1305 cgraph_function_and_variable_visibility (void)
1307 struct cgraph_node *node;
1308 struct cgraph_varpool_node *vnode;
1310 for (node = cgraph_nodes; node; node = node->next)
1313 && (DECL_COMDAT (node->decl)
1314 || (!flag_whole_program
1315 && TREE_PUBLIC (node->decl) && !DECL_EXTERNAL (node->decl))))
1316 node->local.externally_visible = true;
1317 if (!node->local.externally_visible && node->analyzed
1318 && !DECL_EXTERNAL (node->decl))
1320 gcc_assert (flag_whole_program || !TREE_PUBLIC (node->decl));
1321 TREE_PUBLIC (node->decl) = 0;
1323 node->local.local = (!node->needed
1325 && !DECL_EXTERNAL (node->decl)
1326 && !node->local.externally_visible);
1328 for (vnode = cgraph_varpool_nodes_queue; vnode; vnode = vnode->next_needed)
1331 && !flag_whole_program
1332 && (DECL_COMDAT (vnode->decl) || TREE_PUBLIC (vnode->decl)))
1333 vnode->externally_visible = 1;
1334 if (!vnode->externally_visible)
1336 gcc_assert (flag_whole_program || !TREE_PUBLIC (vnode->decl));
1337 TREE_PUBLIC (vnode->decl) = 0;
1339 gcc_assert (TREE_STATIC (vnode->decl));
1342 /* Because we have to be conservative on the boundaries of source
1343 level units, it is possible that we marked some functions in
1344 reachable just because they might be used later via external
1345 linkage, but after making them local they are really unreachable
1347 cgraph_remove_unreachable_nodes (true, cgraph_dump_file);
1349 if (cgraph_dump_file)
1351 fprintf (cgraph_dump_file, "\nMarking local functions:");
1352 for (node = cgraph_nodes; node; node = node->next)
1353 if (node->local.local)
1354 fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
1355 fprintf (cgraph_dump_file, "\n\n");
1356 fprintf (cgraph_dump_file, "\nMarking externally visible functions:");
1357 for (node = cgraph_nodes; node; node = node->next)
1358 if (node->local.externally_visible)
1359 fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
1360 fprintf (cgraph_dump_file, "\n\n");
1362 cgraph_function_flags_ready = true;
1365 /* Return true when function body of DECL still needs to be kept around
1366 for later re-use. */
1368 cgraph_preserve_function_body_p (tree decl)
1370 struct cgraph_node *node;
1371 if (!cgraph_global_info_ready)
1372 return (DECL_INLINE (decl) && !flag_really_no_inline);
1373 /* Look if there is any clone around. */
1374 for (node = cgraph_node (decl); node; node = node->next_clone)
1375 if (node->global.inlined_to)
1384 tree_register_cfg_hooks ();
1385 bitmap_obstack_initialize (NULL);
1386 execute_ipa_pass_list (all_ipa_passes);
1387 bitmap_obstack_release (NULL);
1390 /* Perform simple optimizations based on callgraph. */
1393 cgraph_optimize (void)
1395 #ifdef ENABLE_CHECKING
1398 if (!flag_unit_at_a_time)
1400 cgraph_output_pending_asms ();
1401 cgraph_varpool_assemble_pending_decls ();
1405 process_pending_assemble_externals ();
1407 /* Frontend may output common variables after the unit has been finalized.
1408 It is safe to deal with them here as they are always zero initialized. */
1409 cgraph_varpool_analyze_pending_decls ();
1411 timevar_push (TV_CGRAPHOPT);
1413 fprintf (stderr, "Performing intraprocedural optimizations\n");
1415 cgraph_function_and_variable_visibility ();
1416 if (cgraph_dump_file)
1418 fprintf (cgraph_dump_file, "Marked ");
1419 dump_cgraph (cgraph_dump_file);
1422 /* Don't run the IPA passes if there was any error or sorry messages. */
1423 if (errorcount == 0 && sorrycount == 0)
1426 /* This pass remove bodies of extern inline functions we never inlined.
1427 Do this later so other IPA passes see what is really going on. */
1428 cgraph_remove_unreachable_nodes (false, dump_file);
1429 cgraph_global_info_ready = true;
1430 if (cgraph_dump_file)
1432 fprintf (cgraph_dump_file, "Optimized ");
1433 dump_cgraph (cgraph_dump_file);
1434 dump_varpool (cgraph_dump_file);
1436 timevar_pop (TV_CGRAPHOPT);
1438 /* Output everything. */
1440 fprintf (stderr, "Assembling functions:\n");
1441 #ifdef ENABLE_CHECKING
1445 cgraph_mark_functions_to_output ();
1447 if (!flag_toplevel_reorder)
1448 cgraph_output_in_order ();
1451 cgraph_output_pending_asms ();
1453 cgraph_expand_all_functions ();
1454 cgraph_varpool_remove_unreferenced_decls ();
1456 cgraph_varpool_assemble_pending_decls ();
1459 if (cgraph_dump_file)
1461 fprintf (cgraph_dump_file, "\nFinal ");
1462 dump_cgraph (cgraph_dump_file);
1464 #ifdef ENABLE_CHECKING
1466 /* Double check that all inline clones are gone and that all
1467 function bodies have been released from memory. */
1468 if (flag_unit_at_a_time
1469 && !dump_enabled_p (TDI_tree_all)
1470 && !(sorrycount || errorcount))
1472 struct cgraph_node *node;
1473 bool error_found = false;
1475 for (node = cgraph_nodes; node; node = node->next)
1477 && (node->global.inlined_to
1478 || DECL_SAVED_TREE (node->decl)))
1481 dump_cgraph_node (stderr, node);
1484 internal_error ("nodes with no released memory found");
1489 /* Generate and emit a static constructor or destructor. WHICH must be
1490 one of 'I' or 'D'. BODY should be a STATEMENT_LIST containing
1491 GENERIC statements. */
1494 cgraph_build_static_cdtor (char which, tree body, int priority)
1496 static int counter = 0;
1498 tree decl, name, resdecl;
1500 sprintf (which_buf, "%c_%d", which, counter++);
1501 name = get_file_function_name_long (which_buf);
1503 decl = build_decl (FUNCTION_DECL, name,
1504 build_function_type (void_type_node, void_list_node));
1505 current_function_decl = decl;
1507 resdecl = build_decl (RESULT_DECL, NULL_TREE, void_type_node);
1508 DECL_ARTIFICIAL (resdecl) = 1;
1509 DECL_IGNORED_P (resdecl) = 1;
1510 DECL_RESULT (decl) = resdecl;
1512 allocate_struct_function (decl);
1514 TREE_STATIC (decl) = 1;
1515 TREE_USED (decl) = 1;
1516 DECL_ARTIFICIAL (decl) = 1;
1517 DECL_IGNORED_P (decl) = 1;
1518 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
1519 DECL_SAVED_TREE (decl) = body;
1520 TREE_PUBLIC (decl) = ! targetm.have_ctors_dtors;
1521 DECL_UNINLINABLE (decl) = 1;
1523 DECL_INITIAL (decl) = make_node (BLOCK);
1524 TREE_USED (DECL_INITIAL (decl)) = 1;
1526 DECL_SOURCE_LOCATION (decl) = input_location;
1527 cfun->function_end_locus = input_location;
1532 DECL_STATIC_CONSTRUCTOR (decl) = 1;
1535 DECL_STATIC_DESTRUCTOR (decl) = 1;
1541 gimplify_function_tree (decl);
1543 /* ??? We will get called LATE in the compilation process. */
1544 if (cgraph_global_info_ready)
1546 tree_lowering_passes (decl);
1547 tree_rest_of_compilation (decl);
1550 cgraph_finalize_function (decl, 0);
1552 if (targetm.have_ctors_dtors)
1554 void (*fn) (rtx, int);
1557 fn = targetm.asm_out.constructor;
1559 fn = targetm.asm_out.destructor;
1560 fn (XEXP (DECL_RTL (decl), 0), priority);
1567 cgraph_dump_file = dump_begin (TDI_cgraph, NULL);
1570 /* The edges representing the callers of the NEW_VERSION node were
1571 fixed by cgraph_function_versioning (), now the call_expr in their
1572 respective tree code should be updated to call the NEW_VERSION. */
1575 update_call_expr (struct cgraph_node *new_version)
1577 struct cgraph_edge *e;
1579 gcc_assert (new_version);
1580 for (e = new_version->callers; e; e = e->next_caller)
1581 /* Update the call expr on the edges
1582 to call the new version. */
1583 TREE_OPERAND (TREE_OPERAND (get_call_expr_in (e->call_stmt), 0), 0) = new_version->decl;
1587 /* Create a new cgraph node which is the new version of
1588 OLD_VERSION node. REDIRECT_CALLERS holds the callers
1589 edges which should be redirected to point to
1590 NEW_VERSION. ALL the callees edges of OLD_VERSION
1591 are cloned to the new version node. Return the new
1594 static struct cgraph_node *
1595 cgraph_copy_node_for_versioning (struct cgraph_node *old_version,
1597 VEC(cgraph_edge_p,heap) *redirect_callers)
1599 struct cgraph_node *new_version;
1600 struct cgraph_edge *e, *new_e;
1601 struct cgraph_edge *next_callee;
1604 gcc_assert (old_version);
1606 new_version = cgraph_node (new_decl);
1608 new_version->analyzed = true;
1609 new_version->local = old_version->local;
1610 new_version->global = old_version->global;
1611 new_version->rtl = new_version->rtl;
1612 new_version->reachable = true;
1613 new_version->count = old_version->count;
1615 /* Clone the old node callees. Recursive calls are
1617 for (e = old_version->callees;e; e=e->next_callee)
1619 new_e = cgraph_clone_edge (e, new_version, e->call_stmt, 0, e->loop_nest, true);
1620 new_e->count = e->count;
1622 /* Fix recursive calls.
1623 If OLD_VERSION has a recursive call after the
1624 previous edge cloning, the new version will have an edge
1625 pointing to the old version, which is wrong;
1626 Redirect it to point to the new version. */
1627 for (e = new_version->callees ; e; e = next_callee)
1629 next_callee = e->next_callee;
1630 if (e->callee == old_version)
1631 cgraph_redirect_edge_callee (e, new_version);
1636 for (i = 0; VEC_iterate (cgraph_edge_p, redirect_callers, i, e); i++)
1638 /* Redirect calls to the old version node to point to its new
1640 cgraph_redirect_edge_callee (e, new_version);
1646 /* Perform function versioning.
1647 Function versioning includes copying of the tree and
1648 a callgraph update (creating a new cgraph node and updating
1649 its callees and callers).
1651 REDIRECT_CALLERS varray includes the edges to be redirected
1654 TREE_MAP is a mapping of tree nodes we want to replace with
1655 new ones (according to results of prior analysis).
1656 OLD_VERSION_NODE is the node that is versioned.
1657 It returns the new version's cgraph node. */
1659 struct cgraph_node *
1660 cgraph_function_versioning (struct cgraph_node *old_version_node,
1661 VEC(cgraph_edge_p,heap) *redirect_callers,
1662 varray_type tree_map)
1664 tree old_decl = old_version_node->decl;
1665 struct cgraph_node *new_version_node = NULL;
1668 if (!tree_versionable_function_p (old_decl))
1671 /* Make a new FUNCTION_DECL tree node for the
1673 new_decl = copy_node (old_decl);
1675 /* Create the new version's call-graph node.
1676 and update the edges of the new node. */
1678 cgraph_copy_node_for_versioning (old_version_node, new_decl,
1681 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1682 tree_function_versioning (old_decl, new_decl, tree_map, false);
1683 /* Update the call_expr on the edges to call the new version node. */
1684 update_call_expr (new_version_node);
1686 /* Update the new version's properties.
1687 Make The new version visible only within this translation unit.
1688 ??? We cannot use COMDAT linkage because there is no
1689 ABI support for this. */
1690 DECL_EXTERNAL (new_version_node->decl) = 0;
1691 DECL_ONE_ONLY (new_version_node->decl) = 0;
1692 TREE_PUBLIC (new_version_node->decl) = 0;
1693 DECL_COMDAT (new_version_node->decl) = 0;
1694 new_version_node->local.externally_visible = 0;
1695 new_version_node->local.local = 1;
1696 new_version_node->lowered = true;
1697 return new_version_node;
1700 /* Produce separate function body for inline clones so the offline copy can be
1701 modified without affecting them. */
1702 struct cgraph_node *
1703 save_inline_function_body (struct cgraph_node *node)
1705 struct cgraph_node *first_clone;
1707 gcc_assert (node == cgraph_node (node->decl));
1709 cgraph_lower_function (node);
1711 /* In non-unit-at-a-time we construct full fledged clone we never output to
1712 assembly file. This clone is pointed out by inline_decl of original function
1713 and inlining infrastructure knows how to deal with this. */
1714 if (!flag_unit_at_a_time)
1716 struct cgraph_edge *e;
1718 first_clone = cgraph_clone_node (node, node->count, 0, false);
1719 first_clone->needed = 0;
1720 first_clone->reachable = 1;
1721 /* Recursively clone all bodies. */
1722 for (e = first_clone->callees; e; e = e->next_callee)
1723 if (!e->inline_failed)
1724 cgraph_clone_inlined_nodes (e, true, false);
1727 first_clone = node->next_clone;
1729 first_clone->decl = copy_node (node->decl);
1730 node->next_clone = NULL;
1731 if (!flag_unit_at_a_time)
1732 node->inline_decl = first_clone->decl;
1733 first_clone->prev_clone = NULL;
1734 cgraph_insert_node_to_hashtable (first_clone);
1735 gcc_assert (first_clone == cgraph_node (first_clone->decl));
1737 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1738 tree_function_versioning (node->decl, first_clone->decl, NULL, true);
1740 DECL_EXTERNAL (first_clone->decl) = 0;
1741 DECL_ONE_ONLY (first_clone->decl) = 0;
1742 TREE_PUBLIC (first_clone->decl) = 0;
1743 DECL_COMDAT (first_clone->decl) = 0;
1745 for (node = first_clone->next_clone; node; node = node->next_clone)
1746 node->decl = first_clone->decl;
1747 #ifdef ENABLE_CHECKING
1748 verify_cgraph_node (first_clone);