1 /* Callgraph based interprocedural optimizations.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
3 Free Software Foundation, Inc.
4 Contributed by Jan Hubicka
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* This module implements main driver of compilation process as well as
23 few basic interprocedural optimizers.
25 The main scope of this file is to act as an interface in between
26 tree based frontends and the backend (and middle end)
28 The front-end is supposed to use following functionality:
30 - cgraph_finalize_function
32 This function is called once front-end has parsed whole body of function
33 and it is certain that the function body nor the declaration will change.
35 (There is one exception needed for implementing GCC extern inline
38 - varpool_finalize_variable
40 This function has same behavior as the above but is used for static
43 - cgraph_finalize_compilation_unit
45 This function is called once (source level) compilation unit is finalized
46 and it will no longer change.
48 In the unit-at-a-time the call-graph construction and local function
49 analysis takes place here. Bodies of unreachable functions are released
50 to conserve memory usage.
52 The function can be called multiple times when multiple source level
53 compilation units are combined (such as in C frontend)
57 In this unit-at-a-time compilation the intra procedural analysis takes
58 place here. In particular the static functions whose address is never
59 taken are marked as local. Backend can then use this information to
60 modify calling conventions, do better inlining or similar optimizations.
62 - cgraph_mark_needed_node
63 - varpool_mark_needed_node
65 When function or variable is referenced by some hidden way the call-graph
66 data structure must be updated accordingly by this function.
67 There should be little need to call this function and all the references
68 should be made explicit to cgraph code. At present these functions are
69 used by C++ frontend to explicitly mark the keyed methods.
71 - analyze_expr callback
73 This function is responsible for lowering tree nodes not understood by
74 generic code into understandable ones or alternatively marking
75 callgraph and varpool nodes referenced by the as needed.
77 ??? On the tree-ssa genericizing should take place here and we will avoid
78 need for these hooks (replacing them by genericizing hook)
80 We implement two compilation modes.
82 - unit-at-a-time: In this mode analyzing of all functions is deferred
83 to cgraph_finalize_compilation_unit and expansion into cgraph_optimize.
85 In cgraph_finalize_compilation_unit the reachable functions are
86 analyzed. During analysis the call-graph edges from reachable
87 functions are constructed and their destinations are marked as
88 reachable. References to functions and variables are discovered too
89 and variables found to be needed output to the assembly file. Via
90 mark_referenced call in assemble_variable functions referenced by
91 static variables are noticed too.
93 The intra-procedural information is produced and its existence
94 indicated by global_info_ready. Once this flag is set it is impossible
95 to change function from !reachable to reachable and thus
96 assemble_variable no longer call mark_referenced.
98 Finally the call-graph is topologically sorted and all reachable functions
99 that has not been completely inlined or are not external are output.
101 ??? It is possible that reference to function or variable is optimized
102 out. We can not deal with this nicely because topological order is not
103 suitable for it. For tree-ssa we may consider another pass doing
104 optimization and re-discovering reachable functions.
106 ??? Reorganize code so variables are output very last and only if they
107 really has been referenced by produced code, so we catch more cases
108 where reference has been optimized out.
112 All functions are variables are output as early as possible to conserve
113 memory consumption. This may or may not result in less memory used but
114 it is still needed for some legacy code that rely on particular ordering
115 of things output from the compiler.
117 Varpool data structures are not used and variables are output directly.
119 Functions are output early using call of
120 cgraph_assemble_pending_function from cgraph_finalize_function. The
121 decision on whether function is needed is made more conservative so
122 uninlinable static functions are needed too. During the call-graph
123 construction the edge destinations are not marked as reachable and it
124 is completely relied upon assemble_variable to mark them. */
129 #include "coretypes.h"
133 #include "tree-flow.h"
134 #include "tree-inline.h"
135 #include "langhooks.h"
136 #include "pointer-set.h"
143 #include "diagnostic.h"
147 #include "c-common.h"
149 #include "function.h"
150 #include "ipa-prop.h"
151 #include "tree-gimple.h"
152 #include "tree-pass.h"
155 static void cgraph_expand_all_functions (void);
156 static void cgraph_mark_functions_to_output (void);
157 static void cgraph_expand_function (struct cgraph_node
*);
158 static void cgraph_output_pending_asms (void);
160 static FILE *cgraph_dump_file
;
162 /* A vector of FUNCTION_DECLs declared as static constructors. */
163 static GTY (()) VEC(tree
, gc
) *static_ctors
;
164 /* A vector of FUNCTION_DECLs declared as static destructors. */
165 static GTY (()) VEC(tree
, gc
) *static_dtors
;
167 /* When target does not have ctors and dtors, we call all constructor
168 and destructor by special initialization/destruction function
169 recognized by collect2.
171 When we are going to build this function, collect all constructors and
172 destructors and turn them into normal functions. */
175 record_cdtor_fn (tree fndecl
)
177 struct cgraph_node
*node
;
178 if (targetm
.have_ctors_dtors
179 || (!DECL_STATIC_CONSTRUCTOR (fndecl
)
180 && !DECL_STATIC_DESTRUCTOR (fndecl
)))
183 if (DECL_STATIC_CONSTRUCTOR (fndecl
))
185 VEC_safe_push (tree
, gc
, static_ctors
, fndecl
);
186 DECL_STATIC_CONSTRUCTOR (fndecl
) = 0;
188 if (DECL_STATIC_DESTRUCTOR (fndecl
))
190 VEC_safe_push (tree
, gc
, static_dtors
, fndecl
);
191 DECL_STATIC_DESTRUCTOR (fndecl
) = 0;
193 DECL_INLINE (fndecl
) = 1;
194 node
= cgraph_node (fndecl
);
195 node
->local
.disregard_inline_limits
= 1;
196 cgraph_mark_reachable_node (node
);
199 /* Define global constructors/destructor functions for the CDTORS, of
200 which they are LEN. The CDTORS are sorted by initialization
201 priority. If CTOR_P is true, these are constructors; otherwise,
202 they are destructors. */
205 build_cdtor (bool ctor_p
, tree
*cdtors
, size_t len
)
214 priority_type priority
;
218 /* Find the next batch of constructors/destructors with the same
219 initialization priority. */
224 p
= ctor_p
? DECL_INIT_PRIORITY (fn
) : DECL_FINI_PRIORITY (fn
);
227 else if (p
!= priority
)
229 append_to_statement_list (build_function_call_expr (fn
, 0),
234 gcc_assert (body
!= NULL_TREE
);
235 /* Generate a function to call all the function of like
237 cgraph_build_static_cdtor (ctor_p
? 'I' : 'D', body
, priority
);
241 /* Comparison function for qsort. P1 and P2 are actually of type
242 "tree *" and point to static constructors. DECL_INIT_PRIORITY is
243 used to determine the sort order. */
246 compare_ctor (const void *p1
, const void *p2
)
253 f1
= *(const tree
*)p1
;
254 f2
= *(const tree
*)p2
;
255 priority1
= DECL_INIT_PRIORITY (f1
);
256 priority2
= DECL_INIT_PRIORITY (f2
);
258 if (priority1
< priority2
)
260 else if (priority1
> priority2
)
263 /* Ensure a stable sort. */
264 return (const tree
*)p1
- (const tree
*)p2
;
267 /* Comparison function for qsort. P1 and P2 are actually of type
268 "tree *" and point to static destructors. DECL_FINI_PRIORITY is
269 used to determine the sort order. */
272 compare_dtor (const void *p1
, const void *p2
)
279 f1
= *(const tree
*)p1
;
280 f2
= *(const tree
*)p2
;
281 priority1
= DECL_FINI_PRIORITY (f1
);
282 priority2
= DECL_FINI_PRIORITY (f2
);
284 if (priority1
< priority2
)
286 else if (priority1
> priority2
)
289 /* Ensure a stable sort. */
290 return (const tree
*)p1
- (const tree
*)p2
;
293 /* Generate functions to call static constructors and destructors
294 for targets that do not support .ctors/.dtors sections. These
295 functions have magic names which are detected by collect2. */
298 cgraph_build_cdtor_fns (void)
300 if (!VEC_empty (tree
, static_ctors
))
302 gcc_assert (!targetm
.have_ctors_dtors
);
303 qsort (VEC_address (tree
, static_ctors
),
304 VEC_length (tree
, static_ctors
),
307 build_cdtor (/*ctor_p=*/true,
308 VEC_address (tree
, static_ctors
),
309 VEC_length (tree
, static_ctors
));
310 VEC_truncate (tree
, static_ctors
, 0);
313 if (!VEC_empty (tree
, static_dtors
))
315 gcc_assert (!targetm
.have_ctors_dtors
);
316 qsort (VEC_address (tree
, static_dtors
),
317 VEC_length (tree
, static_dtors
),
320 build_cdtor (/*ctor_p=*/false,
321 VEC_address (tree
, static_dtors
),
322 VEC_length (tree
, static_dtors
));
323 VEC_truncate (tree
, static_dtors
, 0);
327 /* Determine if function DECL is needed. That is, visible to something
328 either outside this translation unit, something magic in the system
329 configury, or (if not doing unit-at-a-time) to something we haven't
333 decide_is_function_needed (struct cgraph_node
*node
, tree decl
)
336 if (MAIN_NAME_P (DECL_NAME (decl
))
337 && TREE_PUBLIC (decl
))
339 node
->local
.externally_visible
= true;
343 /* If the user told us it is used, then it must be so. */
344 if (node
->local
.externally_visible
)
347 if (!flag_unit_at_a_time
&& lookup_attribute ("used", DECL_ATTRIBUTES (decl
)))
350 /* ??? If the assembler name is set by hand, it is possible to assemble
351 the name later after finalizing the function and the fact is noticed
352 in assemble_name then. This is arguably a bug. */
353 if (DECL_ASSEMBLER_NAME_SET_P (decl
)
354 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)))
357 /* With -fkeep-inline-functions we are keeping all inline functions except
358 for extern inline ones. */
359 if (flag_keep_inline_functions
360 && DECL_DECLARED_INLINE_P (decl
)
361 && !DECL_EXTERNAL (decl
)
362 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (decl
)))
365 /* If we decided it was needed before, but at the time we didn't have
366 the body of the function available, then it's still needed. We have
367 to go back and re-check its dependencies now. */
371 /* Externally visible functions must be output. The exception is
372 COMDAT functions that must be output only when they are needed.
374 When not optimizing, also output the static functions. (see
375 PR24561), but don't do so for always_inline functions, functions
376 declared inline and nested functions. These was optimized out
377 in the original implementation and it is unclear whether we want
378 to change the behavior here. */
379 if (((TREE_PUBLIC (decl
)
380 || (!optimize
&& !node
->local
.disregard_inline_limits
381 && !DECL_DECLARED_INLINE_P (decl
)
383 && !flag_whole_program
)
384 && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
))
387 /* Constructors and destructors are reachable from the runtime by
389 if (DECL_STATIC_CONSTRUCTOR (decl
) || DECL_STATIC_DESTRUCTOR (decl
))
392 if (flag_unit_at_a_time
)
395 /* If not doing unit at a time, then we'll only defer this function
396 if its marked for inlining. Otherwise we want to emit it now. */
398 /* "extern inline" functions are never output locally. */
399 if (DECL_EXTERNAL (decl
))
401 /* Nested functions of extern inline function shall not be emit unless
402 we inlined the origin. */
403 for (origin
= decl_function_context (decl
); origin
;
404 origin
= decl_function_context (origin
))
405 if (DECL_EXTERNAL (origin
))
407 /* We want to emit COMDAT functions only when absolutely necessary. */
408 if (DECL_COMDAT (decl
))
410 if (!DECL_INLINE (decl
)
411 || (!node
->local
.disregard_inline_limits
412 /* When declared inline, defer even the uninlinable functions.
413 This allows them to be eliminated when unused. */
414 && !DECL_DECLARED_INLINE_P (decl
)
415 && (!node
->local
.inlinable
|| !cgraph_default_inline_p (node
, NULL
))))
421 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
422 functions into callgraph in a way so they look like ordinary reachable
423 functions inserted into callgraph already at construction time. */
426 cgraph_process_new_functions (void)
430 struct cgraph_node
*node
;
432 /* Note that this queue may grow as its being processed, as the new
433 functions may generate new ones. */
434 while (cgraph_new_nodes
)
436 node
= cgraph_new_nodes
;
438 cgraph_new_nodes
= cgraph_new_nodes
->next_needed
;
439 switch (cgraph_state
)
441 case CGRAPH_STATE_CONSTRUCTION
:
442 /* At construction time we just need to finalize function and move
443 it into reachable functions list. */
445 node
->next_needed
= NULL
;
446 node
->needed
= node
->reachable
= false;
447 cgraph_finalize_function (fndecl
, false);
448 cgraph_mark_reachable_node (node
);
452 case CGRAPH_STATE_IPA
:
453 case CGRAPH_STATE_IPA_SSA
:
454 /* When IPA optimization already started, do all essential
455 transformations that has been already performed on the whole
456 cgraph but not on this function. */
458 tree_register_cfg_hooks ();
460 cgraph_analyze_function (node
);
461 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
462 current_function_decl
= fndecl
;
463 compute_inline_parameters (node
);
464 if ((cgraph_state
== CGRAPH_STATE_IPA_SSA
465 && !gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
466 /* When not optimizing, be sure we run early local passes anyway
469 execute_pass_list (pass_early_local_passes
.pass
.sub
);
470 free_dominance_info (CDI_POST_DOMINATORS
);
471 free_dominance_info (CDI_DOMINATORS
);
473 current_function_decl
= NULL
;
476 case CGRAPH_STATE_EXPANSION
:
477 /* Functions created during expansion shall be compiled
480 cgraph_expand_function (node
);
491 /* When not doing unit-at-a-time, output all functions enqueued.
492 Return true when such a functions were found. */
495 cgraph_assemble_pending_functions (void)
499 if (flag_unit_at_a_time
)
502 cgraph_output_pending_asms ();
504 while (cgraph_nodes_queue
)
506 struct cgraph_node
*n
= cgraph_nodes_queue
;
508 cgraph_nodes_queue
= cgraph_nodes_queue
->next_needed
;
509 n
->next_needed
= NULL
;
510 if (!n
->global
.inlined_to
512 && !DECL_EXTERNAL (n
->decl
))
514 cgraph_expand_function (n
);
517 output
|= cgraph_process_new_functions ();
524 /* As an GCC extension we allow redefinition of the function. The
525 semantics when both copies of bodies differ is not well defined.
526 We replace the old body with new body so in unit at a time mode
527 we always use new body, while in normal mode we may end up with
528 old body inlined into some functions and new body expanded and
531 ??? It may make more sense to use one body for inlining and other
532 body for expanding the function but this is difficult to do. */
535 cgraph_reset_node (struct cgraph_node
*node
)
537 /* If node->output is set, then this is a unit-at-a-time compilation
538 and we have already begun whole-unit analysis. This is *not*
539 testing for whether we've already emitted the function. That
540 case can be sort-of legitimately seen with real function
541 redefinition errors. I would argue that the front end should
542 never present us with such a case, but don't enforce that for now. */
543 gcc_assert (!node
->output
);
545 /* Reset our data structures so we can analyze the function again. */
546 memset (&node
->local
, 0, sizeof (node
->local
));
547 memset (&node
->global
, 0, sizeof (node
->global
));
548 memset (&node
->rtl
, 0, sizeof (node
->rtl
));
549 node
->analyzed
= false;
550 node
->local
.redefined_extern_inline
= true;
551 node
->local
.finalized
= false;
553 if (!flag_unit_at_a_time
)
555 struct cgraph_node
*n
, *next
;
557 for (n
= cgraph_nodes
; n
; n
= next
)
560 if (n
->global
.inlined_to
== node
)
561 cgraph_remove_node (n
);
565 cgraph_node_remove_callees (node
);
567 /* We may need to re-queue the node for assembling in case
568 we already proceeded it and ignored as not needed or got
569 a re-declaration in IMA mode. */
572 struct cgraph_node
*n
;
574 for (n
= cgraph_nodes_queue
; n
; n
= n
->next_needed
)
583 cgraph_lower_function (struct cgraph_node
*node
)
587 tree_lowering_passes (node
->decl
);
588 node
->lowered
= true;
591 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
592 logic in effect. If NESTED is true, then our caller cannot stand to have
593 the garbage collector run at the moment. We would need to either create
594 a new GC context, or just not compile right now. */
597 cgraph_finalize_function (tree decl
, bool nested
)
599 struct cgraph_node
*node
= cgraph_node (decl
);
601 if (node
->local
.finalized
)
602 cgraph_reset_node (node
);
604 node
->pid
= cgraph_max_pid
++;
605 notice_global_symbol (decl
);
607 node
->local
.finalized
= true;
608 node
->lowered
= DECL_STRUCT_FUNCTION (decl
)->cfg
!= NULL
;
609 record_cdtor_fn (node
->decl
);
611 lower_nested_functions (decl
);
612 gcc_assert (!node
->nested
);
614 /* If not unit at a time, then we need to create the call graph
615 now, so that called functions can be queued and emitted now. */
616 if (!flag_unit_at_a_time
)
617 cgraph_analyze_function (node
);
619 if (decide_is_function_needed (node
, decl
))
620 cgraph_mark_needed_node (node
);
622 /* Since we reclaim unreachable nodes at the end of every language
623 level unit, we need to be conservative about possible entry points
625 if ((TREE_PUBLIC (decl
) && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
)))
626 cgraph_mark_reachable_node (node
);
628 /* If not unit at a time, go ahead and emit everything we've found
629 to be reachable at this time. */
632 if (!cgraph_assemble_pending_functions ())
636 /* If we've not yet emitted decl, tell the debug info about it. */
637 if (!TREE_ASM_WRITTEN (decl
))
638 (*debug_hooks
->deferred_inline_function
) (decl
);
640 /* Possibly warn about unused parameters. */
641 if (warn_unused_parameter
)
642 do_warn_unused_parameter (decl
);
645 /* C99 extern inline keywords allow changing of declaration after function
646 has been finalized. We need to re-decide if we want to mark the function as
650 cgraph_mark_if_needed (tree decl
)
652 struct cgraph_node
*node
= cgraph_node (decl
);
653 if (node
->local
.finalized
&& decide_is_function_needed (node
, decl
))
654 cgraph_mark_needed_node (node
);
657 /* Verify cgraph nodes of given cgraph node. */
659 verify_cgraph_node (struct cgraph_node
*node
)
661 struct cgraph_edge
*e
;
662 struct cgraph_node
*main_clone
;
663 struct function
*this_cfun
= DECL_STRUCT_FUNCTION (node
->decl
);
664 struct function
*saved_cfun
= cfun
;
665 basic_block this_block
;
666 block_stmt_iterator bsi
;
667 bool error_found
= false;
669 if (errorcount
|| sorrycount
)
672 timevar_push (TV_CGRAPH_VERIFY
);
673 /* debug_generic_stmt needs correct cfun */
674 set_cfun (this_cfun
);
675 for (e
= node
->callees
; e
; e
= e
->next_callee
)
678 error ("aux field set for edge %s->%s",
679 cgraph_node_name (e
->caller
), cgraph_node_name (e
->callee
));
684 error ("Execution count is negative");
687 for (e
= node
->callers
; e
; e
= e
->next_caller
)
691 error ("caller edge count is negative");
694 if (e
->frequency
< 0)
696 error ("caller edge frequency is negative");
699 if (e
->frequency
> CGRAPH_FREQ_MAX
)
701 error ("caller edge frequency is too large");
704 if (!e
->inline_failed
)
706 if (node
->global
.inlined_to
707 != (e
->caller
->global
.inlined_to
708 ? e
->caller
->global
.inlined_to
: e
->caller
))
710 error ("inlined_to pointer is wrong");
713 if (node
->callers
->next_caller
)
715 error ("multiple inline callers");
720 if (node
->global
.inlined_to
)
722 error ("inlined_to pointer set for noninline callers");
726 if (!node
->callers
&& node
->global
.inlined_to
)
728 error ("inlined_to pointer is set but no predecessors found");
731 if (node
->global
.inlined_to
== node
)
733 error ("inlined_to pointer refers to itself");
737 for (main_clone
= cgraph_node (node
->decl
); main_clone
;
738 main_clone
= main_clone
->next_clone
)
739 if (main_clone
== node
)
741 if (!cgraph_node (node
->decl
))
743 error ("node not found in cgraph_hash");
748 && DECL_SAVED_TREE (node
->decl
) && !TREE_ASM_WRITTEN (node
->decl
)
749 && (!DECL_EXTERNAL (node
->decl
) || node
->global
.inlined_to
))
753 /* The nodes we're interested in are never shared, so walk
754 the tree ignoring duplicates. */
755 struct pointer_set_t
*visited_nodes
= pointer_set_create ();
756 /* Reach the trees by walking over the CFG, and note the
757 enclosing basic-blocks in the call edges. */
758 FOR_EACH_BB_FN (this_block
, this_cfun
)
759 for (bsi
= bsi_start (this_block
); !bsi_end_p (bsi
); bsi_next (&bsi
))
761 tree stmt
= bsi_stmt (bsi
);
762 tree call
= get_call_expr_in (stmt
);
764 if (call
&& (decl
= get_callee_fndecl (call
)))
766 struct cgraph_edge
*e
= cgraph_edge (node
, stmt
);
771 error ("shared call_stmt:");
772 debug_generic_stmt (stmt
);
775 if (e
->callee
->decl
!= cgraph_node (decl
)->decl
778 error ("edge points to wrong declaration:");
779 debug_tree (e
->callee
->decl
);
780 fprintf (stderr
," Instead of:");
787 error ("missing callgraph edge for call stmt:");
788 debug_generic_stmt (stmt
);
793 pointer_set_destroy (visited_nodes
);
796 /* No CFG available?! */
799 for (e
= node
->callees
; e
; e
= e
->next_callee
)
803 error ("edge %s->%s has no corresponding call_stmt",
804 cgraph_node_name (e
->caller
),
805 cgraph_node_name (e
->callee
));
806 debug_generic_stmt (e
->call_stmt
);
814 dump_cgraph_node (stderr
, node
);
815 internal_error ("verify_cgraph_node failed");
817 set_cfun (saved_cfun
);
818 timevar_pop (TV_CGRAPH_VERIFY
);
821 /* Verify whole cgraph structure. */
825 struct cgraph_node
*node
;
827 if (sorrycount
|| errorcount
)
830 for (node
= cgraph_nodes
; node
; node
= node
->next
)
831 verify_cgraph_node (node
);
834 /* Output all asm statements we have stored up to be output. */
837 cgraph_output_pending_asms (void)
839 struct cgraph_asm_node
*can
;
841 if (errorcount
|| sorrycount
)
844 for (can
= cgraph_asm_nodes
; can
; can
= can
->next
)
845 assemble_asm (can
->asm_str
);
846 cgraph_asm_nodes
= NULL
;
849 /* Analyze the function scheduled to be output. */
851 cgraph_analyze_function (struct cgraph_node
*node
)
853 tree decl
= node
->decl
;
855 current_function_decl
= decl
;
856 push_cfun (DECL_STRUCT_FUNCTION (decl
));
857 cgraph_lower_function (node
);
858 node
->analyzed
= true;
860 if (!flag_unit_at_a_time
)
862 bitmap_obstack_initialize (NULL
);
863 tree_register_cfg_hooks ();
864 execute_pass_list (pass_early_local_passes
.pass
.sub
);
865 free_dominance_info (CDI_POST_DOMINATORS
);
866 free_dominance_info (CDI_DOMINATORS
);
867 bitmap_obstack_release (NULL
);
871 current_function_decl
= NULL
;
874 /* Look for externally_visible and used attributes and mark cgraph nodes
877 We cannot mark the nodes at the point the attributes are processed (in
878 handle_*_attribute) because the copy of the declarations available at that
879 point may not be canonical. For example, in:
882 void f() __attribute__((used));
884 the declaration we see in handle_used_attribute will be the second
885 declaration -- but the front end will subsequently merge that declaration
886 with the original declaration and discard the second declaration.
888 Furthermore, we can't mark these nodes in cgraph_finalize_function because:
891 void f() __attribute__((externally_visible));
895 So, we walk the nodes at the end of the translation unit, applying the
896 attributes at that point. */
899 process_function_and_variable_attributes (struct cgraph_node
*first
,
900 struct varpool_node
*first_var
)
902 struct cgraph_node
*node
;
903 struct varpool_node
*vnode
;
905 for (node
= cgraph_nodes
; node
!= first
; node
= node
->next
)
907 tree decl
= node
->decl
;
908 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl
)))
910 mark_decl_referenced (decl
);
911 if (node
->local
.finalized
)
912 cgraph_mark_needed_node (node
);
914 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
916 if (! TREE_PUBLIC (node
->decl
))
917 warning (OPT_Wattributes
,
918 "%J%<externally_visible%> attribute have effect only on public objects",
922 if (node
->local
.finalized
)
923 cgraph_mark_needed_node (node
);
924 node
->local
.externally_visible
= true;
928 for (vnode
= varpool_nodes
; vnode
!= first_var
; vnode
= vnode
->next
)
930 tree decl
= vnode
->decl
;
931 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl
)))
933 mark_decl_referenced (decl
);
934 if (vnode
->finalized
)
935 varpool_mark_needed_node (vnode
);
937 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
939 if (! TREE_PUBLIC (vnode
->decl
))
940 warning (OPT_Wattributes
,
941 "%J%<externally_visible%> attribute have effect only on public objects",
945 if (vnode
->finalized
)
946 varpool_mark_needed_node (vnode
);
947 vnode
->externally_visible
= true;
953 /* Process CGRAPH_NODES_NEEDED queue, analyze each function (and transitively
954 each reachable functions) and build cgraph.
955 The function can be called multiple times after inserting new nodes
956 into beginning of queue. Just the new part of queue is re-scanned then. */
959 cgraph_analyze_functions (void)
961 /* Keep track of already processed nodes when called multiple times for
962 intermodule optimization. */
963 static struct cgraph_node
*first_analyzed
;
964 struct cgraph_node
*first_processed
= first_analyzed
;
965 static struct varpool_node
*first_analyzed_var
;
966 struct cgraph_node
*node
, *next
;
968 process_function_and_variable_attributes (first_processed
,
970 first_processed
= cgraph_nodes
;
971 first_analyzed_var
= varpool_nodes
;
972 varpool_analyze_pending_decls ();
973 if (cgraph_dump_file
)
975 fprintf (cgraph_dump_file
, "Initial entry points:");
976 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
977 if (node
->needed
&& DECL_SAVED_TREE (node
->decl
))
978 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
979 fprintf (cgraph_dump_file
, "\n");
981 cgraph_process_new_functions ();
983 /* Propagate reachability flag and lower representation of all reachable
984 functions. In the future, lowering will introduce new functions and
985 new entry points on the way (by template instantiation and virtual
986 method table generation for instance). */
987 while (cgraph_nodes_queue
)
989 struct cgraph_edge
*edge
;
990 tree decl
= cgraph_nodes_queue
->decl
;
992 node
= cgraph_nodes_queue
;
993 cgraph_nodes_queue
= cgraph_nodes_queue
->next_needed
;
994 node
->next_needed
= NULL
;
996 /* ??? It is possible to create extern inline function and later using
997 weak alias attribute to kill its body. See
998 gcc.c-torture/compile/20011119-1.c */
999 if (!DECL_SAVED_TREE (decl
))
1001 cgraph_reset_node (node
);
1005 gcc_assert (!node
->analyzed
&& node
->reachable
);
1006 gcc_assert (DECL_SAVED_TREE (decl
));
1008 cgraph_analyze_function (node
);
1010 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
1011 if (!edge
->callee
->reachable
)
1012 cgraph_mark_reachable_node (edge
->callee
);
1014 /* We finalize local static variables during constructing callgraph
1015 edges. Process their attributes too. */
1016 process_function_and_variable_attributes (first_processed
,
1017 first_analyzed_var
);
1018 first_processed
= cgraph_nodes
;
1019 first_analyzed_var
= varpool_nodes
;
1020 varpool_analyze_pending_decls ();
1021 cgraph_process_new_functions ();
1024 /* Collect entry points to the unit. */
1025 if (cgraph_dump_file
)
1027 fprintf (cgraph_dump_file
, "Unit entry points:");
1028 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
1029 if (node
->needed
&& DECL_SAVED_TREE (node
->decl
))
1030 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1031 fprintf (cgraph_dump_file
, "\n\nInitial ");
1032 dump_cgraph (cgraph_dump_file
);
1035 if (cgraph_dump_file
)
1036 fprintf (cgraph_dump_file
, "\nReclaiming functions:");
1038 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= next
)
1040 tree decl
= node
->decl
;
1043 if (node
->local
.finalized
&& !DECL_SAVED_TREE (decl
))
1044 cgraph_reset_node (node
);
1046 if (!node
->reachable
&& DECL_SAVED_TREE (decl
))
1048 if (cgraph_dump_file
)
1049 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1050 cgraph_remove_node (node
);
1054 node
->next_needed
= NULL
;
1055 gcc_assert (!node
->local
.finalized
|| DECL_SAVED_TREE (decl
));
1056 gcc_assert (node
->analyzed
== node
->local
.finalized
);
1058 if (cgraph_dump_file
)
1060 fprintf (cgraph_dump_file
, "\n\nReclaimed ");
1061 dump_cgraph (cgraph_dump_file
);
1063 first_analyzed
= cgraph_nodes
;
1067 /* Analyze the whole compilation unit once it is parsed completely. */
1070 cgraph_finalize_compilation_unit (void)
1072 if (errorcount
|| sorrycount
)
1075 finish_aliases_1 ();
1077 if (!flag_unit_at_a_time
)
1079 cgraph_output_pending_asms ();
1080 cgraph_assemble_pending_functions ();
1081 varpool_output_debug_info ();
1087 fprintf (stderr
, "\nAnalyzing compilation unit\n");
1091 timevar_push (TV_CGRAPH
);
1092 cgraph_analyze_functions ();
1093 timevar_pop (TV_CGRAPH
);
1095 /* Figure out what functions we want to assemble. */
1098 cgraph_mark_functions_to_output (void)
1100 struct cgraph_node
*node
;
1102 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1104 tree decl
= node
->decl
;
1105 struct cgraph_edge
*e
;
1107 gcc_assert (!node
->output
);
1109 for (e
= node
->callers
; e
; e
= e
->next_caller
)
1110 if (e
->inline_failed
)
1113 /* We need to output all local functions that are used and not
1114 always inlined, as well as those that are reachable from
1115 outside the current compilation unit. */
1116 if (DECL_SAVED_TREE (decl
)
1117 && !node
->global
.inlined_to
1119 || (e
&& node
->reachable
))
1120 && !TREE_ASM_WRITTEN (decl
)
1121 && !DECL_EXTERNAL (decl
))
1125 /* We should've reclaimed all functions that are not needed. */
1126 #ifdef ENABLE_CHECKING
1127 if (!node
->global
.inlined_to
&& DECL_SAVED_TREE (decl
)
1128 && !DECL_EXTERNAL (decl
))
1130 dump_cgraph_node (stderr
, node
);
1131 internal_error ("failed to reclaim unneeded function");
1134 gcc_assert (node
->global
.inlined_to
|| !DECL_SAVED_TREE (decl
)
1135 || DECL_EXTERNAL (decl
));
1142 /* Expand function specified by NODE. */
1145 cgraph_expand_function (struct cgraph_node
*node
)
1147 tree decl
= node
->decl
;
1149 /* We ought to not compile any inline clones. */
1150 gcc_assert (!node
->global
.inlined_to
);
1152 if (flag_unit_at_a_time
)
1153 announce_function (decl
);
1155 gcc_assert (node
->lowered
);
1157 /* Generate RTL for the body of DECL. */
1158 if (lang_hooks
.callgraph
.emit_associated_thunks
)
1159 lang_hooks
.callgraph
.emit_associated_thunks (decl
);
1160 tree_rest_of_compilation (decl
);
1162 /* Make sure that BE didn't give up on compiling. */
1163 /* ??? Can happen with nested function of extern inline. */
1164 gcc_assert (TREE_ASM_WRITTEN (node
->decl
));
1166 current_function_decl
= NULL
;
1167 if (!cgraph_preserve_function_body_p (node
->decl
))
1169 cgraph_release_function_body (node
);
1170 /* Eliminate all call edges. This is important so the call_expr no longer
1171 points to the dead function body. */
1172 cgraph_node_remove_callees (node
);
1175 cgraph_function_flags_ready
= true;
1178 /* Return true when CALLER_DECL should be inlined into CALLEE_DECL. */
1181 cgraph_inline_p (struct cgraph_edge
*e
, const char **reason
)
1183 *reason
= e
->inline_failed
;
1184 return !e
->inline_failed
;
1189 /* Expand all functions that must be output.
1191 Attempt to topologically sort the nodes so function is output when
1192 all called functions are already assembled to allow data to be
1193 propagated across the callgraph. Use a stack to get smaller distance
1194 between a function and its callees (later we may choose to use a more
1195 sophisticated algorithm for function reordering; we will likely want
1196 to use subsections to make the output functions appear in top-down
1200 cgraph_expand_all_functions (void)
1202 struct cgraph_node
*node
;
1203 struct cgraph_node
**order
= XCNEWVEC (struct cgraph_node
*, cgraph_n_nodes
);
1204 int order_pos
= 0, new_order_pos
= 0;
1207 order_pos
= cgraph_postorder (order
);
1208 gcc_assert (order_pos
== cgraph_n_nodes
);
1210 /* Garbage collector may remove inline clones we eliminate during
1211 optimization. So we must be sure to not reference them. */
1212 for (i
= 0; i
< order_pos
; i
++)
1213 if (order
[i
]->output
)
1214 order
[new_order_pos
++] = order
[i
];
1216 for (i
= new_order_pos
- 1; i
>= 0; i
--)
1221 gcc_assert (node
->reachable
);
1223 cgraph_expand_function (node
);
1226 cgraph_process_new_functions ();
1232 /* This is used to sort the node types by the cgraph order number. */
1234 struct cgraph_order_sort
1236 enum { ORDER_UNDEFINED
= 0, ORDER_FUNCTION
, ORDER_VAR
, ORDER_ASM
} kind
;
1239 struct cgraph_node
*f
;
1240 struct varpool_node
*v
;
1241 struct cgraph_asm_node
*a
;
1245 /* Output all functions, variables, and asm statements in the order
1246 according to their order fields, which is the order in which they
1247 appeared in the file. This implements -fno-toplevel-reorder. In
1248 this mode we may output functions and variables which don't really
1249 need to be output. */
1252 cgraph_output_in_order (void)
1256 struct cgraph_order_sort
*nodes
;
1258 struct cgraph_node
*pf
;
1259 struct varpool_node
*pv
;
1260 struct cgraph_asm_node
*pa
;
1263 size
= max
* sizeof (struct cgraph_order_sort
);
1264 nodes
= (struct cgraph_order_sort
*) alloca (size
);
1265 memset (nodes
, 0, size
);
1267 varpool_analyze_pending_decls ();
1269 for (pf
= cgraph_nodes
; pf
; pf
= pf
->next
)
1274 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1275 nodes
[i
].kind
= ORDER_FUNCTION
;
1280 for (pv
= varpool_nodes_queue
; pv
; pv
= pv
->next_needed
)
1283 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1284 nodes
[i
].kind
= ORDER_VAR
;
1288 for (pa
= cgraph_asm_nodes
; pa
; pa
= pa
->next
)
1291 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1292 nodes
[i
].kind
= ORDER_ASM
;
1296 for (i
= 0; i
< max
; ++i
)
1298 switch (nodes
[i
].kind
)
1300 case ORDER_FUNCTION
:
1301 nodes
[i
].u
.f
->output
= 0;
1302 cgraph_expand_function (nodes
[i
].u
.f
);
1306 varpool_assemble_decl (nodes
[i
].u
.v
);
1310 assemble_asm (nodes
[i
].u
.a
->asm_str
);
1313 case ORDER_UNDEFINED
:
1321 cgraph_asm_nodes
= NULL
;
1324 /* Return true when function body of DECL still needs to be kept around
1325 for later re-use. */
1327 cgraph_preserve_function_body_p (tree decl
)
1329 struct cgraph_node
*node
;
1330 if (!cgraph_global_info_ready
)
1331 return (flag_really_no_inline
1332 ? DECL_DISREGARD_INLINE_LIMITS (decl
)
1333 : DECL_INLINE (decl
));
1334 /* Look if there is any clone around. */
1335 for (node
= cgraph_node (decl
); node
; node
= node
->next_clone
)
1336 if (node
->global
.inlined_to
)
1345 current_function_decl
= NULL
;
1346 tree_register_cfg_hooks ();
1347 bitmap_obstack_initialize (NULL
);
1348 execute_ipa_pass_list (all_ipa_passes
);
1349 bitmap_obstack_release (NULL
);
1352 /* Perform simple optimizations based on callgraph. */
1355 cgraph_optimize (void)
1357 if (errorcount
|| sorrycount
)
1360 #ifdef ENABLE_CHECKING
1364 /* Call functions declared with the "constructor" or "destructor"
1366 cgraph_build_cdtor_fns ();
1367 if (!flag_unit_at_a_time
)
1369 cgraph_assemble_pending_functions ();
1370 cgraph_process_new_functions ();
1371 cgraph_state
= CGRAPH_STATE_FINISHED
;
1372 cgraph_output_pending_asms ();
1373 varpool_assemble_pending_decls ();
1374 varpool_output_debug_info ();
1378 /* Frontend may output common variables after the unit has been finalized.
1379 It is safe to deal with them here as they are always zero initialized. */
1380 varpool_analyze_pending_decls ();
1381 cgraph_analyze_functions ();
1383 timevar_push (TV_CGRAPHOPT
);
1384 if (pre_ipa_mem_report
)
1386 fprintf (stderr
, "Memory consumption before IPA\n");
1387 dump_memory_report (false);
1390 fprintf (stderr
, "Performing interprocedural optimizations\n");
1391 cgraph_state
= CGRAPH_STATE_IPA
;
1393 /* Don't run the IPA passes if there was any error or sorry messages. */
1394 if (errorcount
== 0 && sorrycount
== 0)
1397 /* This pass remove bodies of extern inline functions we never inlined.
1398 Do this later so other IPA passes see what is really going on. */
1399 cgraph_remove_unreachable_nodes (false, dump_file
);
1400 cgraph_global_info_ready
= true;
1401 if (cgraph_dump_file
)
1403 fprintf (cgraph_dump_file
, "Optimized ");
1404 dump_cgraph (cgraph_dump_file
);
1405 dump_varpool (cgraph_dump_file
);
1407 if (post_ipa_mem_report
)
1409 fprintf (stderr
, "Memory consumption after IPA\n");
1410 dump_memory_report (false);
1412 timevar_pop (TV_CGRAPHOPT
);
1414 /* Output everything. */
1416 fprintf (stderr
, "Assembling functions:\n");
1417 #ifdef ENABLE_CHECKING
1421 cgraph_mark_functions_to_output ();
1423 cgraph_state
= CGRAPH_STATE_EXPANSION
;
1424 if (!flag_toplevel_reorder
)
1425 cgraph_output_in_order ();
1428 cgraph_output_pending_asms ();
1430 cgraph_expand_all_functions ();
1431 varpool_remove_unreferenced_decls ();
1433 varpool_assemble_pending_decls ();
1434 varpool_output_debug_info ();
1436 cgraph_process_new_functions ();
1437 cgraph_state
= CGRAPH_STATE_FINISHED
;
1439 if (cgraph_dump_file
)
1441 fprintf (cgraph_dump_file
, "\nFinal ");
1442 dump_cgraph (cgraph_dump_file
);
1444 #ifdef ENABLE_CHECKING
1446 /* Double check that all inline clones are gone and that all
1447 function bodies have been released from memory. */
1448 if (flag_unit_at_a_time
1449 && !(sorrycount
|| errorcount
))
1451 struct cgraph_node
*node
;
1452 bool error_found
= false;
1454 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1456 && (node
->global
.inlined_to
1457 || DECL_SAVED_TREE (node
->decl
)))
1460 dump_cgraph_node (stderr
, node
);
1463 internal_error ("nodes with no released memory found");
1467 /* Generate and emit a static constructor or destructor. WHICH must
1468 be one of 'I' (for a constructor) or 'D' (for a destructor). BODY
1469 is a STATEMENT_LIST containing GENERIC statements. PRIORITY is the
1470 initialization priority for this constructor or destructor. */
1473 cgraph_build_static_cdtor (char which
, tree body
, int priority
)
1475 static int counter
= 0;
1477 tree decl
, name
, resdecl
;
1479 /* The priority is encoded in the constructor or destructor name.
1480 collect2 will sort the names and arrange that they are called at
1482 sprintf (which_buf
, "%c_%.5d_%d", which
, priority
, counter
++);
1483 name
= get_file_function_name (which_buf
);
1485 decl
= build_decl (FUNCTION_DECL
, name
,
1486 build_function_type (void_type_node
, void_list_node
));
1487 current_function_decl
= decl
;
1489 resdecl
= build_decl (RESULT_DECL
, NULL_TREE
, void_type_node
);
1490 DECL_ARTIFICIAL (resdecl
) = 1;
1491 DECL_RESULT (decl
) = resdecl
;
1493 allocate_struct_function (decl
, false);
1495 TREE_STATIC (decl
) = 1;
1496 TREE_USED (decl
) = 1;
1497 DECL_ARTIFICIAL (decl
) = 1;
1498 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
1499 DECL_SAVED_TREE (decl
) = body
;
1500 TREE_PUBLIC (decl
) = ! targetm
.have_ctors_dtors
;
1501 DECL_UNINLINABLE (decl
) = 1;
1503 DECL_INITIAL (decl
) = make_node (BLOCK
);
1504 TREE_USED (DECL_INITIAL (decl
)) = 1;
1506 DECL_SOURCE_LOCATION (decl
) = input_location
;
1507 cfun
->function_end_locus
= input_location
;
1512 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
1513 decl_init_priority_insert (decl
, priority
);
1516 DECL_STATIC_DESTRUCTOR (decl
) = 1;
1517 decl_fini_priority_insert (decl
, priority
);
1523 gimplify_function_tree (decl
);
1525 cgraph_add_new_function (decl
, false);
1526 cgraph_mark_needed_node (cgraph_node (decl
));
1533 cgraph_dump_file
= dump_begin (TDI_cgraph
, NULL
);
1536 /* The edges representing the callers of the NEW_VERSION node were
1537 fixed by cgraph_function_versioning (), now the call_expr in their
1538 respective tree code should be updated to call the NEW_VERSION. */
1541 update_call_expr (struct cgraph_node
*new_version
)
1543 struct cgraph_edge
*e
;
1545 gcc_assert (new_version
);
1546 for (e
= new_version
->callers
; e
; e
= e
->next_caller
)
1547 /* Update the call expr on the edges
1548 to call the new version. */
1549 TREE_OPERAND (CALL_EXPR_FN (get_call_expr_in (e
->call_stmt
)), 0) = new_version
->decl
;
1553 /* Create a new cgraph node which is the new version of
1554 OLD_VERSION node. REDIRECT_CALLERS holds the callers
1555 edges which should be redirected to point to
1556 NEW_VERSION. ALL the callees edges of OLD_VERSION
1557 are cloned to the new version node. Return the new
1560 static struct cgraph_node
*
1561 cgraph_copy_node_for_versioning (struct cgraph_node
*old_version
,
1563 VEC(cgraph_edge_p
,heap
) *redirect_callers
)
1565 struct cgraph_node
*new_version
;
1566 struct cgraph_edge
*e
, *new_e
;
1567 struct cgraph_edge
*next_callee
;
1570 gcc_assert (old_version
);
1572 new_version
= cgraph_node (new_decl
);
1574 new_version
->analyzed
= true;
1575 new_version
->local
= old_version
->local
;
1576 new_version
->global
= old_version
->global
;
1577 new_version
->rtl
= new_version
->rtl
;
1578 new_version
->reachable
= true;
1579 new_version
->count
= old_version
->count
;
1581 /* Clone the old node callees. Recursive calls are
1583 for (e
= old_version
->callees
;e
; e
=e
->next_callee
)
1585 new_e
= cgraph_clone_edge (e
, new_version
, e
->call_stmt
, 0, e
->frequency
,
1586 e
->loop_nest
, true);
1587 new_e
->count
= e
->count
;
1589 /* Fix recursive calls.
1590 If OLD_VERSION has a recursive call after the
1591 previous edge cloning, the new version will have an edge
1592 pointing to the old version, which is wrong;
1593 Redirect it to point to the new version. */
1594 for (e
= new_version
->callees
; e
; e
= next_callee
)
1596 next_callee
= e
->next_callee
;
1597 if (e
->callee
== old_version
)
1598 cgraph_redirect_edge_callee (e
, new_version
);
1603 for (i
= 0; VEC_iterate (cgraph_edge_p
, redirect_callers
, i
, e
); i
++)
1605 /* Redirect calls to the old version node to point to its new
1607 cgraph_redirect_edge_callee (e
, new_version
);
1613 /* Perform function versioning.
1614 Function versioning includes copying of the tree and
1615 a callgraph update (creating a new cgraph node and updating
1616 its callees and callers).
1618 REDIRECT_CALLERS varray includes the edges to be redirected
1621 TREE_MAP is a mapping of tree nodes we want to replace with
1622 new ones (according to results of prior analysis).
1623 OLD_VERSION_NODE is the node that is versioned.
1624 It returns the new version's cgraph node. */
1626 struct cgraph_node
*
1627 cgraph_function_versioning (struct cgraph_node
*old_version_node
,
1628 VEC(cgraph_edge_p
,heap
) *redirect_callers
,
1629 varray_type tree_map
)
1631 tree old_decl
= old_version_node
->decl
;
1632 struct cgraph_node
*new_version_node
= NULL
;
1635 if (!tree_versionable_function_p (old_decl
))
1638 /* Make a new FUNCTION_DECL tree node for the
1640 new_decl
= copy_node (old_decl
);
1642 /* Create the new version's call-graph node.
1643 and update the edges of the new node. */
1645 cgraph_copy_node_for_versioning (old_version_node
, new_decl
,
1648 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1649 tree_function_versioning (old_decl
, new_decl
, tree_map
, false);
1650 /* Update the call_expr on the edges to call the new version node. */
1651 update_call_expr (new_version_node
);
1653 /* Update the new version's properties.
1654 Make The new version visible only within this translation unit.
1655 ??? We cannot use COMDAT linkage because there is no
1656 ABI support for this. */
1657 DECL_EXTERNAL (new_version_node
->decl
) = 0;
1658 DECL_ONE_ONLY (new_version_node
->decl
) = 0;
1659 TREE_PUBLIC (new_version_node
->decl
) = 0;
1660 DECL_COMDAT (new_version_node
->decl
) = 0;
1661 new_version_node
->local
.externally_visible
= 0;
1662 new_version_node
->local
.local
= 1;
1663 new_version_node
->lowered
= true;
1664 return new_version_node
;
1667 /* Produce separate function body for inline clones so the offline copy can be
1668 modified without affecting them. */
1669 struct cgraph_node
*
1670 save_inline_function_body (struct cgraph_node
*node
)
1672 struct cgraph_node
*first_clone
;
1674 gcc_assert (node
== cgraph_node (node
->decl
));
1676 cgraph_lower_function (node
);
1678 /* In non-unit-at-a-time we construct full fledged clone we never output to
1679 assembly file. This clone is pointed out by inline_decl of original function
1680 and inlining infrastructure knows how to deal with this. */
1681 if (!flag_unit_at_a_time
)
1683 struct cgraph_edge
*e
;
1685 first_clone
= cgraph_clone_node (node
, node
->count
, 0, CGRAPH_FREQ_BASE
,
1687 first_clone
->needed
= 0;
1688 first_clone
->reachable
= 1;
1689 /* Recursively clone all bodies. */
1690 for (e
= first_clone
->callees
; e
; e
= e
->next_callee
)
1691 if (!e
->inline_failed
)
1692 cgraph_clone_inlined_nodes (e
, true, false);
1695 first_clone
= node
->next_clone
;
1697 first_clone
->decl
= copy_node (node
->decl
);
1698 node
->next_clone
= NULL
;
1699 if (!flag_unit_at_a_time
)
1700 node
->inline_decl
= first_clone
->decl
;
1701 first_clone
->prev_clone
= NULL
;
1702 cgraph_insert_node_to_hashtable (first_clone
);
1703 gcc_assert (first_clone
== cgraph_node (first_clone
->decl
));
1705 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1706 tree_function_versioning (node
->decl
, first_clone
->decl
, NULL
, true);
1708 DECL_EXTERNAL (first_clone
->decl
) = 0;
1709 DECL_ONE_ONLY (first_clone
->decl
) = 0;
1710 TREE_PUBLIC (first_clone
->decl
) = 0;
1711 DECL_COMDAT (first_clone
->decl
) = 0;
1713 for (node
= first_clone
->next_clone
; node
; node
= node
->next_clone
)
1714 node
->decl
= first_clone
->decl
;
1715 #ifdef ENABLE_CHECKING
1716 verify_cgraph_node (first_clone
);
1721 #include "gt-cgraphunit.h"