1 /* Callgraph based interprocedural optimizations.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
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 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 Analyzing of all functions is deferred
81 to cgraph_finalize_compilation_unit and expansion into cgraph_optimize.
83 In cgraph_finalize_compilation_unit the reachable functions are
84 analyzed. During analysis the call-graph edges from reachable
85 functions are constructed and their destinations are marked as
86 reachable. References to functions and variables are discovered too
87 and variables found to be needed output to the assembly file. Via
88 mark_referenced call in assemble_variable functions referenced by
89 static variables are noticed too.
91 The intra-procedural information is produced and its existence
92 indicated by global_info_ready. Once this flag is set it is impossible
93 to change function from !reachable to reachable and thus
94 assemble_variable no longer call mark_referenced.
96 Finally the call-graph is topologically sorted and all reachable functions
97 that has not been completely inlined or are not external are output.
99 ??? It is possible that reference to function or variable is optimized
100 out. We can not deal with this nicely because topological order is not
101 suitable for it. For tree-ssa we may consider another pass doing
102 optimization and re-discovering reachable functions.
104 ??? Reorganize code so variables are output very last and only if they
105 really has been referenced by produced code, so we catch more cases
106 where reference has been optimized out. */
111 #include "coretypes.h"
115 #include "tree-flow.h"
116 #include "tree-inline.h"
117 #include "langhooks.h"
118 #include "pointer-set.h"
125 #include "diagnostic.h"
130 #include "function.h"
131 #include "ipa-prop.h"
133 #include "tree-iterator.h"
134 #include "tree-pass.h"
136 #include "coverage.h"
138 static void cgraph_expand_all_functions (void);
139 static void cgraph_mark_functions_to_output (void);
140 static void cgraph_expand_function (struct cgraph_node
*);
141 static void cgraph_output_pending_asms (void);
143 static FILE *cgraph_dump_file
;
145 /* A vector of FUNCTION_DECLs declared as static constructors. */
146 static GTY (()) VEC(tree
, gc
) *static_ctors
;
147 /* A vector of FUNCTION_DECLs declared as static destructors. */
148 static GTY (()) VEC(tree
, gc
) *static_dtors
;
150 /* When target does not have ctors and dtors, we call all constructor
151 and destructor by special initialization/destruction function
152 recognized by collect2.
154 When we are going to build this function, collect all constructors and
155 destructors and turn them into normal functions. */
158 record_cdtor_fn (tree fndecl
)
160 struct cgraph_node
*node
;
161 if (targetm
.have_ctors_dtors
162 || (!DECL_STATIC_CONSTRUCTOR (fndecl
)
163 && !DECL_STATIC_DESTRUCTOR (fndecl
)))
166 if (DECL_STATIC_CONSTRUCTOR (fndecl
))
168 VEC_safe_push (tree
, gc
, static_ctors
, fndecl
);
169 DECL_STATIC_CONSTRUCTOR (fndecl
) = 0;
171 if (DECL_STATIC_DESTRUCTOR (fndecl
))
173 VEC_safe_push (tree
, gc
, static_dtors
, fndecl
);
174 DECL_STATIC_DESTRUCTOR (fndecl
) = 0;
176 node
= cgraph_node (fndecl
);
177 node
->local
.disregard_inline_limits
= 1;
178 cgraph_mark_reachable_node (node
);
181 /* Define global constructors/destructor functions for the CDTORS, of
182 which they are LEN. The CDTORS are sorted by initialization
183 priority. If CTOR_P is true, these are constructors; otherwise,
184 they are destructors. */
187 build_cdtor (bool ctor_p
, tree
*cdtors
, size_t len
)
196 priority_type priority
;
200 /* Find the next batch of constructors/destructors with the same
201 initialization priority. */
206 p
= ctor_p
? DECL_INIT_PRIORITY (fn
) : DECL_FINI_PRIORITY (fn
);
209 else if (p
!= priority
)
211 append_to_statement_list (build_function_call_expr (fn
, 0),
216 gcc_assert (body
!= NULL_TREE
);
217 /* Generate a function to call all the function of like
219 cgraph_build_static_cdtor (ctor_p
? 'I' : 'D', body
, priority
);
223 /* Comparison function for qsort. P1 and P2 are actually of type
224 "tree *" and point to static constructors. DECL_INIT_PRIORITY is
225 used to determine the sort order. */
228 compare_ctor (const void *p1
, const void *p2
)
235 f1
= *(const tree
*)p1
;
236 f2
= *(const tree
*)p2
;
237 priority1
= DECL_INIT_PRIORITY (f1
);
238 priority2
= DECL_INIT_PRIORITY (f2
);
240 if (priority1
< priority2
)
242 else if (priority1
> priority2
)
245 /* Ensure a stable sort. */
246 return (const tree
*)p1
- (const tree
*)p2
;
249 /* Comparison function for qsort. P1 and P2 are actually of type
250 "tree *" and point to static destructors. DECL_FINI_PRIORITY is
251 used to determine the sort order. */
254 compare_dtor (const void *p1
, const void *p2
)
261 f1
= *(const tree
*)p1
;
262 f2
= *(const tree
*)p2
;
263 priority1
= DECL_FINI_PRIORITY (f1
);
264 priority2
= DECL_FINI_PRIORITY (f2
);
266 if (priority1
< priority2
)
268 else if (priority1
> priority2
)
271 /* Ensure a stable sort. */
272 return (const tree
*)p1
- (const tree
*)p2
;
275 /* Generate functions to call static constructors and destructors
276 for targets that do not support .ctors/.dtors sections. These
277 functions have magic names which are detected by collect2. */
280 cgraph_build_cdtor_fns (void)
282 if (!VEC_empty (tree
, static_ctors
))
284 gcc_assert (!targetm
.have_ctors_dtors
);
285 qsort (VEC_address (tree
, static_ctors
),
286 VEC_length (tree
, static_ctors
),
289 build_cdtor (/*ctor_p=*/true,
290 VEC_address (tree
, static_ctors
),
291 VEC_length (tree
, static_ctors
));
292 VEC_truncate (tree
, static_ctors
, 0);
295 if (!VEC_empty (tree
, static_dtors
))
297 gcc_assert (!targetm
.have_ctors_dtors
);
298 qsort (VEC_address (tree
, static_dtors
),
299 VEC_length (tree
, static_dtors
),
302 build_cdtor (/*ctor_p=*/false,
303 VEC_address (tree
, static_dtors
),
304 VEC_length (tree
, static_dtors
));
305 VEC_truncate (tree
, static_dtors
, 0);
309 /* Determine if function DECL is needed. That is, visible to something
310 either outside this translation unit, something magic in the system
314 decide_is_function_needed (struct cgraph_node
*node
, tree decl
)
316 if (MAIN_NAME_P (DECL_NAME (decl
))
317 && TREE_PUBLIC (decl
))
319 node
->local
.externally_visible
= true;
323 /* If the user told us it is used, then it must be so. */
324 if (node
->local
.externally_visible
)
327 /* ??? If the assembler name is set by hand, it is possible to assemble
328 the name later after finalizing the function and the fact is noticed
329 in assemble_name then. This is arguably a bug. */
330 if (DECL_ASSEMBLER_NAME_SET_P (decl
)
331 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)))
334 /* With -fkeep-inline-functions we are keeping all inline functions except
335 for extern inline ones. */
336 if (flag_keep_inline_functions
337 && DECL_DECLARED_INLINE_P (decl
)
338 && !DECL_EXTERNAL (decl
)
339 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (decl
)))
342 /* If we decided it was needed before, but at the time we didn't have
343 the body of the function available, then it's still needed. We have
344 to go back and re-check its dependencies now. */
348 /* Externally visible functions must be output. The exception is
349 COMDAT functions that must be output only when they are needed.
351 When not optimizing, also output the static functions. (see
352 PR24561), but don't do so for always_inline functions, functions
353 declared inline and nested functions. These was optimized out
354 in the original implementation and it is unclear whether we want
355 to change the behavior here. */
356 if (((TREE_PUBLIC (decl
)
357 || (!optimize
&& !node
->local
.disregard_inline_limits
358 && !DECL_DECLARED_INLINE_P (decl
)
360 && !flag_whole_program
)
361 && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
))
364 /* Constructors and destructors are reachable from the runtime by
366 if (DECL_STATIC_CONSTRUCTOR (decl
) || DECL_STATIC_DESTRUCTOR (decl
))
372 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
373 functions into callgraph in a way so they look like ordinary reachable
374 functions inserted into callgraph already at construction time. */
377 cgraph_process_new_functions (void)
381 struct cgraph_node
*node
;
383 /* Note that this queue may grow as its being processed, as the new
384 functions may generate new ones. */
385 while (cgraph_new_nodes
)
387 node
= cgraph_new_nodes
;
389 cgraph_new_nodes
= cgraph_new_nodes
->next_needed
;
390 switch (cgraph_state
)
392 case CGRAPH_STATE_CONSTRUCTION
:
393 /* At construction time we just need to finalize function and move
394 it into reachable functions list. */
396 node
->next_needed
= NULL
;
397 cgraph_finalize_function (fndecl
, false);
398 cgraph_mark_reachable_node (node
);
402 case CGRAPH_STATE_IPA
:
403 case CGRAPH_STATE_IPA_SSA
:
404 /* When IPA optimization already started, do all essential
405 transformations that has been already performed on the whole
406 cgraph but not on this function. */
408 gimple_register_cfg_hooks ();
410 cgraph_analyze_function (node
);
411 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
412 current_function_decl
= fndecl
;
413 compute_inline_parameters (node
);
414 if ((cgraph_state
== CGRAPH_STATE_IPA_SSA
415 && !gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
416 /* When not optimizing, be sure we run early local passes anyway
419 execute_pass_list (pass_early_local_passes
.pass
.sub
);
420 free_dominance_info (CDI_POST_DOMINATORS
);
421 free_dominance_info (CDI_DOMINATORS
);
423 current_function_decl
= NULL
;
426 case CGRAPH_STATE_EXPANSION
:
427 /* Functions created during expansion shall be compiled
430 cgraph_expand_function (node
);
437 cgraph_call_function_insertion_hooks (node
);
442 /* As an GCC extension we allow redefinition of the function. The
443 semantics when both copies of bodies differ is not well defined.
444 We replace the old body with new body so in unit at a time mode
445 we always use new body, while in normal mode we may end up with
446 old body inlined into some functions and new body expanded and
449 ??? It may make more sense to use one body for inlining and other
450 body for expanding the function but this is difficult to do. */
453 cgraph_reset_node (struct cgraph_node
*node
)
455 /* If node->process is set, then we have already begun whole-unit analysis.
456 This is *not* testing for whether we've already emitted the function.
457 That case can be sort-of legitimately seen with real function redefinition
458 errors. I would argue that the front end should never present us with
459 such a case, but don't enforce that for now. */
460 gcc_assert (!node
->process
);
462 /* Reset our data structures so we can analyze the function again. */
463 memset (&node
->local
, 0, sizeof (node
->local
));
464 memset (&node
->global
, 0, sizeof (node
->global
));
465 memset (&node
->rtl
, 0, sizeof (node
->rtl
));
466 node
->analyzed
= false;
467 node
->local
.redefined_extern_inline
= true;
468 node
->local
.finalized
= false;
470 cgraph_node_remove_callees (node
);
472 /* We may need to re-queue the node for assembling in case
473 we already proceeded it and ignored as not needed or got
474 a re-declaration in IMA mode. */
477 struct cgraph_node
*n
;
479 for (n
= cgraph_nodes_queue
; n
; n
= n
->next_needed
)
488 cgraph_lower_function (struct cgraph_node
*node
)
492 tree_lowering_passes (node
->decl
);
493 node
->lowered
= true;
496 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
497 logic in effect. If NESTED is true, then our caller cannot stand to have
498 the garbage collector run at the moment. We would need to either create
499 a new GC context, or just not compile right now. */
502 cgraph_finalize_function (tree decl
, bool nested
)
504 struct cgraph_node
*node
= cgraph_node (decl
);
506 if (node
->local
.finalized
)
507 cgraph_reset_node (node
);
509 node
->pid
= cgraph_max_pid
++;
510 notice_global_symbol (decl
);
511 node
->local
.finalized
= true;
512 node
->lowered
= DECL_STRUCT_FUNCTION (decl
)->cfg
!= NULL
;
513 node
->finalized_by_frontend
= true;
514 record_cdtor_fn (node
->decl
);
516 lower_nested_functions (decl
);
517 gcc_assert (!node
->nested
);
519 if (decide_is_function_needed (node
, decl
))
520 cgraph_mark_needed_node (node
);
522 /* Since we reclaim unreachable nodes at the end of every language
523 level unit, we need to be conservative about possible entry points
525 if ((TREE_PUBLIC (decl
) && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
)))
526 cgraph_mark_reachable_node (node
);
528 /* If we've not yet emitted decl, tell the debug info about it. */
529 if (!TREE_ASM_WRITTEN (decl
))
530 (*debug_hooks
->deferred_inline_function
) (decl
);
532 /* Possibly warn about unused parameters. */
533 if (warn_unused_parameter
)
534 do_warn_unused_parameter (decl
);
540 /* C99 extern inline keywords allow changing of declaration after function
541 has been finalized. We need to re-decide if we want to mark the function as
545 cgraph_mark_if_needed (tree decl
)
547 struct cgraph_node
*node
= cgraph_node (decl
);
548 if (node
->local
.finalized
&& decide_is_function_needed (node
, decl
))
549 cgraph_mark_needed_node (node
);
552 /* Return TRUE if NODE2 is equivalent to NODE or its clone. */
554 clone_of_p (struct cgraph_node
*node
, struct cgraph_node
*node2
)
556 while (node
!= node2
&& node2
)
557 node2
= node2
->clone_of
;
558 return node2
!= NULL
;
561 /* Verify cgraph nodes of given cgraph node. */
563 verify_cgraph_node (struct cgraph_node
*node
)
565 struct cgraph_edge
*e
;
566 struct function
*this_cfun
= DECL_STRUCT_FUNCTION (node
->decl
);
567 struct function
*saved_cfun
= cfun
;
568 basic_block this_block
;
569 gimple_stmt_iterator gsi
;
570 bool error_found
= false;
572 if (errorcount
|| sorrycount
)
575 timevar_push (TV_CGRAPH_VERIFY
);
576 /* debug_generic_stmt needs correct cfun */
577 set_cfun (this_cfun
);
578 for (e
= node
->callees
; e
; e
= e
->next_callee
)
581 error ("aux field set for edge %s->%s",
582 identifier_to_locale (cgraph_node_name (e
->caller
)),
583 identifier_to_locale (cgraph_node_name (e
->callee
)));
588 error ("Execution count is negative");
591 for (e
= node
->callers
; e
; e
= e
->next_caller
)
595 error ("caller edge count is negative");
598 if (e
->frequency
< 0)
600 error ("caller edge frequency is negative");
603 if (e
->frequency
> CGRAPH_FREQ_MAX
)
605 error ("caller edge frequency is too large");
608 if (!e
->inline_failed
)
610 if (node
->global
.inlined_to
611 != (e
->caller
->global
.inlined_to
612 ? e
->caller
->global
.inlined_to
: e
->caller
))
614 error ("inlined_to pointer is wrong");
617 if (node
->callers
->next_caller
)
619 error ("multiple inline callers");
624 if (node
->global
.inlined_to
)
626 error ("inlined_to pointer set for noninline callers");
630 if (!node
->callers
&& node
->global
.inlined_to
)
632 error ("inlined_to pointer is set but no predecessors found");
635 if (node
->global
.inlined_to
== node
)
637 error ("inlined_to pointer refers to itself");
641 if (!cgraph_node (node
->decl
))
643 error ("node not found in cgraph_hash");
649 struct cgraph_node
*n
;
650 for (n
= node
->clone_of
->clones
; n
; n
= n
->next_sibling_clone
)
655 error ("node has wrong clone_of");
661 struct cgraph_node
*n
;
662 for (n
= node
->clones
; n
; n
= n
->next_sibling_clone
)
663 if (n
->clone_of
!= node
)
667 error ("node has wrong clone list");
671 if ((node
->prev_sibling_clone
|| node
->next_sibling_clone
) && !node
->clone_of
)
673 error ("node is in clone list but it is not clone");
676 if (!node
->prev_sibling_clone
&& node
->clone_of
&& node
->clone_of
->clones
!= node
)
678 error ("node has wrong prev_clone pointer");
681 if (node
->prev_sibling_clone
&& node
->prev_sibling_clone
->next_sibling_clone
!= node
)
683 error ("double linked list of clones corrupted");
687 if (node
->analyzed
&& gimple_has_body_p (node
->decl
)
688 && !TREE_ASM_WRITTEN (node
->decl
)
689 && (!DECL_EXTERNAL (node
->decl
) || node
->global
.inlined_to
))
693 /* The nodes we're interested in are never shared, so walk
694 the tree ignoring duplicates. */
695 struct pointer_set_t
*visited_nodes
= pointer_set_create ();
696 /* Reach the trees by walking over the CFG, and note the
697 enclosing basic-blocks in the call edges. */
698 FOR_EACH_BB_FN (this_block
, this_cfun
)
699 for (gsi
= gsi_start_bb (this_block
);
703 gimple stmt
= gsi_stmt (gsi
);
705 if (is_gimple_call (stmt
) && (decl
= gimple_call_fndecl (stmt
)))
707 struct cgraph_edge
*e
= cgraph_edge (node
, stmt
);
712 error ("shared call_stmt:");
713 debug_gimple_stmt (stmt
);
716 if (!clone_of_p (cgraph_node (decl
), e
->callee
)
717 && !e
->callee
->global
.inlined_to
)
719 error ("edge points to wrong declaration:");
720 debug_tree (e
->callee
->decl
);
721 fprintf (stderr
," Instead of:");
728 error ("missing callgraph edge for call stmt:");
729 debug_gimple_stmt (stmt
);
734 pointer_set_destroy (visited_nodes
);
737 /* No CFG available?! */
740 for (e
= node
->callees
; e
; e
= e
->next_callee
)
742 if (!e
->aux
&& !e
->indirect_call
)
744 error ("edge %s->%s has no corresponding call_stmt",
745 identifier_to_locale (cgraph_node_name (e
->caller
)),
746 identifier_to_locale (cgraph_node_name (e
->callee
)));
747 debug_gimple_stmt (e
->call_stmt
);
755 dump_cgraph_node (stderr
, node
);
756 internal_error ("verify_cgraph_node failed");
758 set_cfun (saved_cfun
);
759 timevar_pop (TV_CGRAPH_VERIFY
);
762 /* Verify whole cgraph structure. */
766 struct cgraph_node
*node
;
768 if (sorrycount
|| errorcount
)
771 for (node
= cgraph_nodes
; node
; node
= node
->next
)
772 verify_cgraph_node (node
);
775 /* Output all asm statements we have stored up to be output. */
778 cgraph_output_pending_asms (void)
780 struct cgraph_asm_node
*can
;
782 if (errorcount
|| sorrycount
)
785 for (can
= cgraph_asm_nodes
; can
; can
= can
->next
)
786 assemble_asm (can
->asm_str
);
787 cgraph_asm_nodes
= NULL
;
790 /* Analyze the function scheduled to be output. */
792 cgraph_analyze_function (struct cgraph_node
*node
)
794 tree decl
= node
->decl
;
796 current_function_decl
= decl
;
797 push_cfun (DECL_STRUCT_FUNCTION (decl
));
798 cgraph_lower_function (node
);
799 node
->analyzed
= true;
802 current_function_decl
= NULL
;
805 /* Look for externally_visible and used attributes and mark cgraph nodes
808 We cannot mark the nodes at the point the attributes are processed (in
809 handle_*_attribute) because the copy of the declarations available at that
810 point may not be canonical. For example, in:
813 void f() __attribute__((used));
815 the declaration we see in handle_used_attribute will be the second
816 declaration -- but the front end will subsequently merge that declaration
817 with the original declaration and discard the second declaration.
819 Furthermore, we can't mark these nodes in cgraph_finalize_function because:
822 void f() __attribute__((externally_visible));
826 So, we walk the nodes at the end of the translation unit, applying the
827 attributes at that point. */
830 process_function_and_variable_attributes (struct cgraph_node
*first
,
831 struct varpool_node
*first_var
)
833 struct cgraph_node
*node
;
834 struct varpool_node
*vnode
;
836 for (node
= cgraph_nodes
; node
!= first
; node
= node
->next
)
838 tree decl
= node
->decl
;
839 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl
)))
841 mark_decl_referenced (decl
);
842 if (node
->local
.finalized
)
843 cgraph_mark_needed_node (node
);
845 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
847 if (! TREE_PUBLIC (node
->decl
))
848 warning (OPT_Wattributes
,
849 "%J%<externally_visible%> attribute have effect only on public objects",
853 if (node
->local
.finalized
)
854 cgraph_mark_needed_node (node
);
855 node
->local
.externally_visible
= true;
859 for (vnode
= varpool_nodes
; vnode
!= first_var
; vnode
= vnode
->next
)
861 tree decl
= vnode
->decl
;
862 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl
)))
864 mark_decl_referenced (decl
);
865 if (vnode
->finalized
)
866 varpool_mark_needed_node (vnode
);
868 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
870 if (! TREE_PUBLIC (vnode
->decl
))
871 warning (OPT_Wattributes
,
872 "%J%<externally_visible%> attribute have effect only on public objects",
876 if (vnode
->finalized
)
877 varpool_mark_needed_node (vnode
);
878 vnode
->externally_visible
= true;
884 /* Process CGRAPH_NODES_NEEDED queue, analyze each function (and transitively
885 each reachable functions) and build cgraph.
886 The function can be called multiple times after inserting new nodes
887 into beginning of queue. Just the new part of queue is re-scanned then. */
890 cgraph_analyze_functions (void)
892 /* Keep track of already processed nodes when called multiple times for
893 intermodule optimization. */
894 static struct cgraph_node
*first_analyzed
;
895 struct cgraph_node
*first_processed
= first_analyzed
;
896 static struct varpool_node
*first_analyzed_var
;
897 struct cgraph_node
*node
, *next
;
899 process_function_and_variable_attributes (first_processed
,
901 first_processed
= cgraph_nodes
;
902 first_analyzed_var
= varpool_nodes
;
903 varpool_analyze_pending_decls ();
904 if (cgraph_dump_file
)
906 fprintf (cgraph_dump_file
, "Initial entry points:");
907 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
909 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
910 fprintf (cgraph_dump_file
, "\n");
912 cgraph_process_new_functions ();
914 /* Propagate reachability flag and lower representation of all reachable
915 functions. In the future, lowering will introduce new functions and
916 new entry points on the way (by template instantiation and virtual
917 method table generation for instance). */
918 while (cgraph_nodes_queue
)
920 struct cgraph_edge
*edge
;
921 tree decl
= cgraph_nodes_queue
->decl
;
923 node
= cgraph_nodes_queue
;
924 cgraph_nodes_queue
= cgraph_nodes_queue
->next_needed
;
925 node
->next_needed
= NULL
;
927 /* ??? It is possible to create extern inline function and later using
928 weak alias attribute to kill its body. See
929 gcc.c-torture/compile/20011119-1.c */
930 if (!DECL_STRUCT_FUNCTION (decl
))
932 cgraph_reset_node (node
);
936 gcc_assert (!node
->analyzed
&& node
->reachable
);
937 gcc_assert (gimple_body (decl
));
939 cgraph_analyze_function (node
);
941 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
942 if (!edge
->callee
->reachable
)
943 cgraph_mark_reachable_node (edge
->callee
);
945 /* If decl is a clone of an abstract function, mark that abstract
946 function so that we don't release its body. The DECL_INITIAL() of that
947 abstract function declaration will be later needed to output debug info. */
948 if (DECL_ABSTRACT_ORIGIN (decl
))
950 struct cgraph_node
*origin_node
= cgraph_node (DECL_ABSTRACT_ORIGIN (decl
));
951 origin_node
->abstract_and_needed
= true;
954 /* We finalize local static variables during constructing callgraph
955 edges. Process their attributes too. */
956 process_function_and_variable_attributes (first_processed
,
958 first_processed
= cgraph_nodes
;
959 first_analyzed_var
= varpool_nodes
;
960 varpool_analyze_pending_decls ();
961 cgraph_process_new_functions ();
964 /* Collect entry points to the unit. */
965 if (cgraph_dump_file
)
967 fprintf (cgraph_dump_file
, "Unit entry points:");
968 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
970 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
971 fprintf (cgraph_dump_file
, "\n\nInitial ");
972 dump_cgraph (cgraph_dump_file
);
975 if (cgraph_dump_file
)
976 fprintf (cgraph_dump_file
, "\nReclaiming functions:");
978 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= next
)
980 tree decl
= node
->decl
;
983 if (node
->local
.finalized
&& !gimple_has_body_p (decl
))
984 cgraph_reset_node (node
);
986 if (!node
->reachable
&& gimple_has_body_p (decl
))
988 if (cgraph_dump_file
)
989 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
990 cgraph_remove_node (node
);
994 node
->next_needed
= NULL
;
995 gcc_assert (!node
->local
.finalized
|| gimple_has_body_p (decl
));
996 gcc_assert (node
->analyzed
== node
->local
.finalized
);
998 if (cgraph_dump_file
)
1000 fprintf (cgraph_dump_file
, "\n\nReclaimed ");
1001 dump_cgraph (cgraph_dump_file
);
1003 first_analyzed
= cgraph_nodes
;
1007 /* Analyze the whole compilation unit once it is parsed completely. */
1010 cgraph_finalize_compilation_unit (void)
1012 if (errorcount
|| sorrycount
)
1015 finish_aliases_1 ();
1019 fprintf (stderr
, "\nAnalyzing compilation unit\n");
1023 timevar_push (TV_CGRAPH
);
1024 cgraph_analyze_functions ();
1025 timevar_pop (TV_CGRAPH
);
1029 /* Figure out what functions we want to assemble. */
1032 cgraph_mark_functions_to_output (void)
1034 struct cgraph_node
*node
;
1036 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1038 tree decl
= node
->decl
;
1039 struct cgraph_edge
*e
;
1041 gcc_assert (!node
->process
);
1043 for (e
= node
->callers
; e
; e
= e
->next_caller
)
1044 if (e
->inline_failed
)
1047 /* We need to output all local functions that are used and not
1048 always inlined, as well as those that are reachable from
1049 outside the current compilation unit. */
1051 && !node
->global
.inlined_to
1053 || (e
&& node
->reachable
))
1054 && !TREE_ASM_WRITTEN (decl
)
1055 && !DECL_EXTERNAL (decl
))
1059 /* We should've reclaimed all functions that are not needed. */
1060 #ifdef ENABLE_CHECKING
1061 if (!node
->global
.inlined_to
1062 && gimple_has_body_p (decl
)
1063 && !DECL_EXTERNAL (decl
))
1065 dump_cgraph_node (stderr
, node
);
1066 internal_error ("failed to reclaim unneeded function");
1069 gcc_assert (node
->global
.inlined_to
1070 || !gimple_has_body_p (decl
)
1071 || DECL_EXTERNAL (decl
));
1078 /* Expand function specified by NODE. */
1081 cgraph_expand_function (struct cgraph_node
*node
)
1083 tree decl
= node
->decl
;
1085 /* We ought to not compile any inline clones. */
1086 gcc_assert (!node
->global
.inlined_to
);
1088 announce_function (decl
);
1091 gcc_assert (node
->lowered
);
1093 /* Generate RTL for the body of DECL. */
1094 if (lang_hooks
.callgraph
.emit_associated_thunks
1095 && node
->finalized_by_frontend
)
1096 lang_hooks
.callgraph
.emit_associated_thunks (decl
);
1097 tree_rest_of_compilation (decl
);
1099 /* Make sure that BE didn't give up on compiling. */
1100 gcc_assert (TREE_ASM_WRITTEN (decl
));
1101 current_function_decl
= NULL
;
1102 gcc_assert (!cgraph_preserve_function_body_p (decl
));
1103 cgraph_release_function_body (node
);
1104 /* Eliminate all call edges. This is important so the GIMPLE_CALL no longer
1105 points to the dead function body. */
1106 cgraph_node_remove_callees (node
);
1108 cgraph_function_flags_ready
= true;
1111 /* Return true when CALLER_DECL should be inlined into CALLEE_DECL. */
1114 cgraph_inline_p (struct cgraph_edge
*e
, cgraph_inline_failed_t
*reason
)
1116 *reason
= e
->inline_failed
;
1117 return !e
->inline_failed
;
1122 /* Expand all functions that must be output.
1124 Attempt to topologically sort the nodes so function is output when
1125 all called functions are already assembled to allow data to be
1126 propagated across the callgraph. Use a stack to get smaller distance
1127 between a function and its callees (later we may choose to use a more
1128 sophisticated algorithm for function reordering; we will likely want
1129 to use subsections to make the output functions appear in top-down
1133 cgraph_expand_all_functions (void)
1135 struct cgraph_node
*node
;
1136 struct cgraph_node
**order
= XCNEWVEC (struct cgraph_node
*, cgraph_n_nodes
);
1137 int order_pos
, new_order_pos
= 0;
1140 order_pos
= cgraph_postorder (order
);
1141 gcc_assert (order_pos
== cgraph_n_nodes
);
1143 /* Garbage collector may remove inline clones we eliminate during
1144 optimization. So we must be sure to not reference them. */
1145 for (i
= 0; i
< order_pos
; i
++)
1146 if (order
[i
]->process
)
1147 order
[new_order_pos
++] = order
[i
];
1149 for (i
= new_order_pos
- 1; i
>= 0; i
--)
1154 gcc_assert (node
->reachable
);
1156 cgraph_expand_function (node
);
1159 cgraph_process_new_functions ();
1165 /* This is used to sort the node types by the cgraph order number. */
1167 enum cgraph_order_sort_kind
1169 ORDER_UNDEFINED
= 0,
1175 struct cgraph_order_sort
1177 enum cgraph_order_sort_kind kind
;
1180 struct cgraph_node
*f
;
1181 struct varpool_node
*v
;
1182 struct cgraph_asm_node
*a
;
1186 /* Output all functions, variables, and asm statements in the order
1187 according to their order fields, which is the order in which they
1188 appeared in the file. This implements -fno-toplevel-reorder. In
1189 this mode we may output functions and variables which don't really
1190 need to be output. */
1193 cgraph_output_in_order (void)
1197 struct cgraph_order_sort
*nodes
;
1199 struct cgraph_node
*pf
;
1200 struct varpool_node
*pv
;
1201 struct cgraph_asm_node
*pa
;
1204 size
= max
* sizeof (struct cgraph_order_sort
);
1205 nodes
= (struct cgraph_order_sort
*) alloca (size
);
1206 memset (nodes
, 0, size
);
1208 varpool_analyze_pending_decls ();
1210 for (pf
= cgraph_nodes
; pf
; pf
= pf
->next
)
1215 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1216 nodes
[i
].kind
= ORDER_FUNCTION
;
1221 for (pv
= varpool_nodes_queue
; pv
; pv
= pv
->next_needed
)
1224 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1225 nodes
[i
].kind
= ORDER_VAR
;
1229 for (pa
= cgraph_asm_nodes
; pa
; pa
= pa
->next
)
1232 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1233 nodes
[i
].kind
= ORDER_ASM
;
1237 /* In toplevel reorder mode we output all statics; mark them as needed. */
1238 for (i
= 0; i
< max
; ++i
)
1240 if (nodes
[i
].kind
== ORDER_VAR
)
1242 varpool_mark_needed_node (nodes
[i
].u
.v
);
1245 varpool_empty_needed_queue ();
1247 for (i
= 0; i
< max
; ++i
)
1249 switch (nodes
[i
].kind
)
1251 case ORDER_FUNCTION
:
1252 nodes
[i
].u
.f
->process
= 0;
1253 cgraph_expand_function (nodes
[i
].u
.f
);
1257 varpool_assemble_decl (nodes
[i
].u
.v
);
1261 assemble_asm (nodes
[i
].u
.a
->asm_str
);
1264 case ORDER_UNDEFINED
:
1272 cgraph_asm_nodes
= NULL
;
1275 /* Return true when function body of DECL still needs to be kept around
1276 for later re-use. */
1278 cgraph_preserve_function_body_p (tree decl
)
1280 struct cgraph_node
*node
;
1282 gcc_assert (cgraph_global_info_ready
);
1283 /* Look if there is any clone around. */
1284 node
= cgraph_node (decl
);
1294 current_function_decl
= NULL
;
1295 gimple_register_cfg_hooks ();
1296 bitmap_obstack_initialize (NULL
);
1297 execute_ipa_pass_list (all_ipa_passes
);
1299 /* Generate coverage variables and constructors. */
1302 /* Process new functions added. */
1304 current_function_decl
= NULL
;
1305 cgraph_process_new_functions ();
1307 bitmap_obstack_release (NULL
);
1310 /* Perform simple optimizations based on callgraph. */
1313 cgraph_optimize (void)
1315 if (errorcount
|| sorrycount
)
1318 #ifdef ENABLE_CHECKING
1322 /* Call functions declared with the "constructor" or "destructor"
1324 cgraph_build_cdtor_fns ();
1326 /* Frontend may output common variables after the unit has been finalized.
1327 It is safe to deal with them here as they are always zero initialized. */
1328 varpool_analyze_pending_decls ();
1329 cgraph_analyze_functions ();
1331 timevar_push (TV_CGRAPHOPT
);
1332 if (pre_ipa_mem_report
)
1334 fprintf (stderr
, "Memory consumption before IPA\n");
1335 dump_memory_report (false);
1338 fprintf (stderr
, "Performing interprocedural optimizations\n");
1339 cgraph_state
= CGRAPH_STATE_IPA
;
1341 /* Don't run the IPA passes if there was any error or sorry messages. */
1342 if (errorcount
== 0 && sorrycount
== 0)
1345 /* This pass remove bodies of extern inline functions we never inlined.
1346 Do this later so other IPA passes see what is really going on. */
1347 cgraph_remove_unreachable_nodes (false, dump_file
);
1348 cgraph_global_info_ready
= true;
1349 if (cgraph_dump_file
)
1351 fprintf (cgraph_dump_file
, "Optimized ");
1352 dump_cgraph (cgraph_dump_file
);
1353 dump_varpool (cgraph_dump_file
);
1355 if (post_ipa_mem_report
)
1357 fprintf (stderr
, "Memory consumption after IPA\n");
1358 dump_memory_report (false);
1360 timevar_pop (TV_CGRAPHOPT
);
1362 /* Output everything. */
1364 fprintf (stderr
, "Assembling functions:\n");
1365 #ifdef ENABLE_CHECKING
1369 cgraph_materialize_all_clones ();
1370 cgraph_mark_functions_to_output ();
1372 cgraph_state
= CGRAPH_STATE_EXPANSION
;
1373 if (!flag_toplevel_reorder
)
1374 cgraph_output_in_order ();
1377 cgraph_output_pending_asms ();
1379 cgraph_expand_all_functions ();
1380 varpool_remove_unreferenced_decls ();
1382 varpool_assemble_pending_decls ();
1384 cgraph_process_new_functions ();
1385 cgraph_state
= CGRAPH_STATE_FINISHED
;
1387 if (cgraph_dump_file
)
1389 fprintf (cgraph_dump_file
, "\nFinal ");
1390 dump_cgraph (cgraph_dump_file
);
1392 #ifdef ENABLE_CHECKING
1394 /* Double check that all inline clones are gone and that all
1395 function bodies have been released from memory. */
1396 if (!(sorrycount
|| errorcount
))
1398 struct cgraph_node
*node
;
1399 bool error_found
= false;
1401 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1403 && (node
->global
.inlined_to
1404 || gimple_has_body_p (node
->decl
)))
1407 dump_cgraph_node (stderr
, node
);
1410 internal_error ("nodes with unreleased memory found");
1414 /* Generate and emit a static constructor or destructor. WHICH must
1415 be one of 'I' (for a constructor) or 'D' (for a destructor). BODY
1416 is a STATEMENT_LIST containing GENERIC statements. PRIORITY is the
1417 initialization priority for this constructor or destructor. */
1420 cgraph_build_static_cdtor (char which
, tree body
, int priority
)
1422 static int counter
= 0;
1424 tree decl
, name
, resdecl
;
1426 /* The priority is encoded in the constructor or destructor name.
1427 collect2 will sort the names and arrange that they are called at
1429 sprintf (which_buf
, "%c_%.5d_%d", which
, priority
, counter
++);
1430 name
= get_file_function_name (which_buf
);
1432 decl
= build_decl (FUNCTION_DECL
, name
,
1433 build_function_type (void_type_node
, void_list_node
));
1434 current_function_decl
= decl
;
1436 resdecl
= build_decl (RESULT_DECL
, NULL_TREE
, void_type_node
);
1437 DECL_ARTIFICIAL (resdecl
) = 1;
1438 DECL_RESULT (decl
) = resdecl
;
1439 DECL_CONTEXT (resdecl
) = decl
;
1441 allocate_struct_function (decl
, false);
1443 TREE_STATIC (decl
) = 1;
1444 TREE_USED (decl
) = 1;
1445 DECL_ARTIFICIAL (decl
) = 1;
1446 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
1447 DECL_SAVED_TREE (decl
) = body
;
1448 TREE_PUBLIC (decl
) = ! targetm
.have_ctors_dtors
;
1449 DECL_UNINLINABLE (decl
) = 1;
1451 DECL_INITIAL (decl
) = make_node (BLOCK
);
1452 TREE_USED (DECL_INITIAL (decl
)) = 1;
1454 DECL_SOURCE_LOCATION (decl
) = input_location
;
1455 cfun
->function_end_locus
= input_location
;
1460 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
1461 decl_init_priority_insert (decl
, priority
);
1464 DECL_STATIC_DESTRUCTOR (decl
) = 1;
1465 decl_fini_priority_insert (decl
, priority
);
1471 gimplify_function_tree (decl
);
1473 cgraph_add_new_function (decl
, false);
1474 cgraph_mark_needed_node (cgraph_node (decl
));
1481 cgraph_dump_file
= dump_begin (TDI_cgraph
, NULL
);
1484 /* The edges representing the callers of the NEW_VERSION node were
1485 fixed by cgraph_function_versioning (), now the call_expr in their
1486 respective tree code should be updated to call the NEW_VERSION. */
1489 update_call_expr (struct cgraph_node
*new_version
)
1491 struct cgraph_edge
*e
;
1493 gcc_assert (new_version
);
1495 /* Update the call expr on the edges to call the new version. */
1496 for (e
= new_version
->callers
; e
; e
= e
->next_caller
)
1498 struct function
*inner_function
= DECL_STRUCT_FUNCTION (e
->caller
->decl
);
1499 gimple_call_set_fndecl (e
->call_stmt
, new_version
->decl
);
1500 /* Update EH information too, just in case. */
1501 if (!stmt_could_throw_p (e
->call_stmt
)
1502 && lookup_stmt_eh_region_fn (inner_function
, e
->call_stmt
))
1503 remove_stmt_from_eh_region_fn (inner_function
, e
->call_stmt
);
1508 /* Create a new cgraph node which is the new version of
1509 OLD_VERSION node. REDIRECT_CALLERS holds the callers
1510 edges which should be redirected to point to
1511 NEW_VERSION. ALL the callees edges of OLD_VERSION
1512 are cloned to the new version node. Return the new
1515 static struct cgraph_node
*
1516 cgraph_copy_node_for_versioning (struct cgraph_node
*old_version
,
1518 VEC(cgraph_edge_p
,heap
) *redirect_callers
)
1520 struct cgraph_node
*new_version
;
1521 struct cgraph_edge
*e
, *new_e
;
1522 struct cgraph_edge
*next_callee
;
1525 gcc_assert (old_version
);
1527 new_version
= cgraph_node (new_decl
);
1529 new_version
->analyzed
= true;
1530 new_version
->local
= old_version
->local
;
1531 new_version
->global
= old_version
->global
;
1532 new_version
->rtl
= new_version
->rtl
;
1533 new_version
->reachable
= true;
1534 new_version
->count
= old_version
->count
;
1536 /* Clone the old node callees. Recursive calls are
1538 for (e
= old_version
->callees
;e
; e
=e
->next_callee
)
1540 new_e
= cgraph_clone_edge (e
, new_version
, e
->call_stmt
, 0, e
->frequency
,
1541 e
->loop_nest
, true);
1542 new_e
->count
= e
->count
;
1544 /* Fix recursive calls.
1545 If OLD_VERSION has a recursive call after the
1546 previous edge cloning, the new version will have an edge
1547 pointing to the old version, which is wrong;
1548 Redirect it to point to the new version. */
1549 for (e
= new_version
->callees
; e
; e
= next_callee
)
1551 next_callee
= e
->next_callee
;
1552 if (e
->callee
== old_version
)
1553 cgraph_redirect_edge_callee (e
, new_version
);
1558 for (i
= 0; VEC_iterate (cgraph_edge_p
, redirect_callers
, i
, e
); i
++)
1560 /* Redirect calls to the old version node to point to its new
1562 cgraph_redirect_edge_callee (e
, new_version
);
1568 /* Perform function versioning.
1569 Function versioning includes copying of the tree and
1570 a callgraph update (creating a new cgraph node and updating
1571 its callees and callers).
1573 REDIRECT_CALLERS varray includes the edges to be redirected
1576 TREE_MAP is a mapping of tree nodes we want to replace with
1577 new ones (according to results of prior analysis).
1578 OLD_VERSION_NODE is the node that is versioned.
1579 It returns the new version's cgraph node.
1580 ARGS_TO_SKIP lists arguments to be omitted from functions
1583 struct cgraph_node
*
1584 cgraph_function_versioning (struct cgraph_node
*old_version_node
,
1585 VEC(cgraph_edge_p
,heap
) *redirect_callers
,
1586 VEC (ipa_replace_map_p
,gc
)* tree_map
,
1587 bitmap args_to_skip
)
1589 tree old_decl
= old_version_node
->decl
;
1590 struct cgraph_node
*new_version_node
= NULL
;
1593 if (!tree_versionable_function_p (old_decl
))
1596 /* Make a new FUNCTION_DECL tree node for the
1599 new_decl
= copy_node (old_decl
);
1601 new_decl
= build_function_decl_skip_args (old_decl
, args_to_skip
);
1603 /* Create the new version's call-graph node.
1604 and update the edges of the new node. */
1606 cgraph_copy_node_for_versioning (old_version_node
, new_decl
,
1609 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1610 tree_function_versioning (old_decl
, new_decl
, tree_map
, false, args_to_skip
);
1612 /* Update the new version's properties.
1613 Make The new version visible only within this translation unit. Make sure
1614 that is not weak also.
1615 ??? We cannot use COMDAT linkage because there is no
1616 ABI support for this. */
1617 DECL_EXTERNAL (new_version_node
->decl
) = 0;
1618 DECL_ONE_ONLY (new_version_node
->decl
) = 0;
1619 TREE_PUBLIC (new_version_node
->decl
) = 0;
1620 DECL_COMDAT (new_version_node
->decl
) = 0;
1621 DECL_WEAK (new_version_node
->decl
) = 0;
1622 DECL_VIRTUAL_P (new_version_node
->decl
) = 0;
1623 new_version_node
->local
.externally_visible
= 0;
1624 new_version_node
->local
.local
= 1;
1625 new_version_node
->lowered
= true;
1627 /* Update the call_expr on the edges to call the new version node. */
1628 update_call_expr (new_version_node
);
1630 cgraph_call_function_insertion_hooks (new_version_node
);
1631 return new_version_node
;
1634 /* Produce separate function body for inline clones so the offline copy can be
1635 modified without affecting them. */
1636 struct cgraph_node
*
1637 save_inline_function_body (struct cgraph_node
*node
)
1639 struct cgraph_node
*first_clone
, *n
;
1641 gcc_assert (node
== cgraph_node (node
->decl
));
1643 cgraph_lower_function (node
);
1645 first_clone
= node
->clones
;
1647 first_clone
->decl
= copy_node (node
->decl
);
1648 cgraph_insert_node_to_hashtable (first_clone
);
1649 gcc_assert (first_clone
== cgraph_node (first_clone
->decl
));
1650 if (first_clone
->next_sibling_clone
)
1652 for (n
= first_clone
->next_sibling_clone
; n
->next_sibling_clone
; n
= n
->next_sibling_clone
)
1653 n
->clone_of
= first_clone
;
1654 n
->clone_of
= first_clone
;
1655 n
->next_sibling_clone
= first_clone
->clones
;
1656 if (first_clone
->clones
)
1657 first_clone
->clones
->prev_sibling_clone
= n
;
1658 first_clone
->clones
= first_clone
->next_sibling_clone
;
1659 first_clone
->next_sibling_clone
->prev_sibling_clone
= NULL
;
1660 first_clone
->next_sibling_clone
= NULL
;
1661 gcc_assert (!first_clone
->prev_sibling_clone
);
1663 first_clone
->clone_of
= NULL
;
1664 node
->clones
= NULL
;
1666 if (first_clone
->clones
)
1667 for (n
= first_clone
->clones
; n
!= first_clone
;)
1669 gcc_assert (n
->decl
== node
->decl
);
1670 n
->decl
= first_clone
->decl
;
1673 else if (n
->next_sibling_clone
)
1674 n
= n
->next_sibling_clone
;
1677 while (n
!= first_clone
&& !n
->next_sibling_clone
)
1679 if (n
!= first_clone
)
1680 n
= n
->next_sibling_clone
;
1684 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1685 tree_function_versioning (node
->decl
, first_clone
->decl
, NULL
, true, NULL
);
1687 DECL_EXTERNAL (first_clone
->decl
) = 0;
1688 DECL_ONE_ONLY (first_clone
->decl
) = 0;
1689 TREE_PUBLIC (first_clone
->decl
) = 0;
1690 DECL_COMDAT (first_clone
->decl
) = 0;
1691 VEC_free (ipa_opt_pass
, heap
,
1692 DECL_STRUCT_FUNCTION (first_clone
->decl
)->ipa_transforms_to_apply
);
1693 DECL_STRUCT_FUNCTION (first_clone
->decl
)->ipa_transforms_to_apply
= NULL
;
1695 #ifdef ENABLE_CHECKING
1696 verify_cgraph_node (first_clone
);
1701 /* Given virtual clone, turn it into actual clone. */
1703 cgraph_materialize_clone (struct cgraph_node
*node
)
1705 bitmap_obstack_initialize (NULL
);
1706 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1707 tree_function_versioning (node
->clone_of
->decl
, node
->decl
,
1708 node
->clone
.tree_map
, true,
1709 node
->clone
.args_to_skip
);
1711 /* Function is no longer clone. */
1712 if (node
->next_sibling_clone
)
1713 node
->next_sibling_clone
->prev_sibling_clone
= node
->prev_sibling_clone
;
1714 if (node
->prev_sibling_clone
)
1715 node
->prev_sibling_clone
->next_sibling_clone
= node
->next_sibling_clone
;
1717 node
->clone_of
->clones
= node
->next_sibling_clone
;
1718 node
->next_sibling_clone
= NULL
;
1719 node
->prev_sibling_clone
= NULL
;
1720 node
->clone_of
= NULL
;
1721 bitmap_obstack_release (NULL
);
1724 /* Once all functions from compilation unit are in memory, produce all clones
1725 and update all calls.
1726 We might also do this on demand if we don't want to bring all functions to
1727 memory prior compilation, but current WHOPR implementation does that and it is
1728 is bit easier to keep everything right in this order. */
1730 cgraph_materialize_all_clones (void)
1732 struct cgraph_node
*node
;
1733 bool stabilized
= false;
1735 if (cgraph_dump_file
)
1736 fprintf (cgraph_dump_file
, "Materializing clones\n");
1737 #ifdef ENABLE_CHECKING
1741 /* We can also do topological order, but number of iterations should be
1742 bounded by number of IPA passes since single IPA pass is probably not
1743 going to create clones of clones it created itself. */
1747 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1749 if (node
->clone_of
&& node
->decl
!= node
->clone_of
->decl
1750 && !gimple_has_body_p (node
->decl
))
1752 if (gimple_has_body_p (node
->clone_of
->decl
))
1754 if (cgraph_dump_file
)
1755 fprintf (cgraph_dump_file
, " clonning %s to %s",
1756 cgraph_node_name (node
->clone_of
),
1757 cgraph_node_name (node
));
1758 cgraph_materialize_clone (node
);
1765 if (cgraph_dump_file
)
1766 fprintf (cgraph_dump_file
, "Updating call sites\n");
1767 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1768 if (node
->analyzed
&& gimple_has_body_p (node
->decl
)
1769 && (!node
->clone_of
|| node
->clone_of
->decl
!= node
->decl
))
1771 struct cgraph_edge
*e
;
1773 current_function_decl
= node
->decl
;
1774 push_cfun (DECL_STRUCT_FUNCTION (node
->decl
));
1775 for (e
= node
->callees
; e
; e
= e
->next_callee
)
1777 tree decl
= gimple_call_fndecl (e
->call_stmt
);
1778 /* When function gets inlined, indirect inlining might've invented
1779 new edge for orginally indirect stmt. Since we are not
1780 preserving clones in the original form, we must not update here
1781 since other inline clones don't need to contain call to the same
1782 call. Inliner will do the substitution for us later. */
1783 if (decl
&& decl
!= e
->callee
->decl
)
1786 gimple_stmt_iterator gsi
;
1788 if (cgraph_dump_file
)
1790 fprintf (cgraph_dump_file
, "updating call of %s in %s:",
1791 cgraph_node_name (node
),
1792 cgraph_node_name (e
->callee
));
1793 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
1796 if (e
->callee
->clone
.args_to_skip
)
1797 new_stmt
= gimple_call_copy_skip_args (e
->call_stmt
,
1798 e
->callee
->clone
.args_to_skip
);
1800 new_stmt
= e
->call_stmt
;
1801 if (gimple_vdef (new_stmt
)
1802 && TREE_CODE (gimple_vdef (new_stmt
)) == SSA_NAME
)
1803 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt
)) = new_stmt
;
1804 gimple_call_set_fndecl (new_stmt
, e
->callee
->decl
);
1806 gsi
= gsi_for_stmt (e
->call_stmt
);
1807 gsi_replace (&gsi
, new_stmt
, true);
1809 /* Update EH information too, just in case. */
1810 if (!stmt_could_throw_p (new_stmt
)
1811 && lookup_stmt_eh_region (new_stmt
))
1812 remove_stmt_from_eh_region (new_stmt
);
1814 cgraph_set_call_stmt_including_clones (node
, e
->call_stmt
, new_stmt
);
1816 if (cgraph_dump_file
)
1818 fprintf (cgraph_dump_file
, " updated to:");
1819 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
1824 current_function_decl
= NULL
;
1825 #ifdef ENABLE_CHECKING
1826 verify_cgraph_node (node
);
1829 #ifdef ENABLE_CHECKING
1832 cgraph_remove_unreachable_nodes (false, cgraph_dump_file
);
1835 #include "gt-cgraphunit.h"