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"
135 #include "tree-dump.h"
137 #include "coverage.h"
139 static void cgraph_expand_all_functions (void);
140 static void cgraph_mark_functions_to_output (void);
141 static void cgraph_expand_function (struct cgraph_node
*);
142 static void cgraph_output_pending_asms (void);
143 static void cgraph_optimize (void);
144 static void cgraph_analyze_function (struct cgraph_node
*);
146 static FILE *cgraph_dump_file
;
148 /* A vector of FUNCTION_DECLs declared as static constructors. */
149 static GTY (()) VEC(tree
, gc
) *static_ctors
;
150 /* A vector of FUNCTION_DECLs declared as static destructors. */
151 static GTY (()) VEC(tree
, gc
) *static_dtors
;
153 /* When target does not have ctors and dtors, we call all constructor
154 and destructor by special initialization/destruction function
155 recognized by collect2.
157 When we are going to build this function, collect all constructors and
158 destructors and turn them into normal functions. */
161 record_cdtor_fn (tree fndecl
)
163 struct cgraph_node
*node
;
164 if (targetm
.have_ctors_dtors
165 || (!DECL_STATIC_CONSTRUCTOR (fndecl
)
166 && !DECL_STATIC_DESTRUCTOR (fndecl
)))
169 if (DECL_STATIC_CONSTRUCTOR (fndecl
))
171 VEC_safe_push (tree
, gc
, static_ctors
, fndecl
);
172 DECL_STATIC_CONSTRUCTOR (fndecl
) = 0;
174 if (DECL_STATIC_DESTRUCTOR (fndecl
))
176 VEC_safe_push (tree
, gc
, static_dtors
, fndecl
);
177 DECL_STATIC_DESTRUCTOR (fndecl
) = 0;
179 node
= cgraph_node (fndecl
);
180 node
->local
.disregard_inline_limits
= 1;
181 cgraph_mark_reachable_node (node
);
184 /* Define global constructors/destructor functions for the CDTORS, of
185 which they are LEN. The CDTORS are sorted by initialization
186 priority. If CTOR_P is true, these are constructors; otherwise,
187 they are destructors. */
190 build_cdtor (bool ctor_p
, tree
*cdtors
, size_t len
)
199 priority_type priority
;
203 /* Find the next batch of constructors/destructors with the same
204 initialization priority. */
209 p
= ctor_p
? DECL_INIT_PRIORITY (fn
) : DECL_FINI_PRIORITY (fn
);
212 else if (p
!= priority
)
214 append_to_statement_list (build_function_call_expr (UNKNOWN_LOCATION
,
220 gcc_assert (body
!= NULL_TREE
);
221 /* Generate a function to call all the function of like
223 cgraph_build_static_cdtor (ctor_p
? 'I' : 'D', body
, priority
);
227 /* Comparison function for qsort. P1 and P2 are actually of type
228 "tree *" and point to static constructors. DECL_INIT_PRIORITY is
229 used to determine the sort order. */
232 compare_ctor (const void *p1
, const void *p2
)
239 f1
= *(const tree
*)p1
;
240 f2
= *(const tree
*)p2
;
241 priority1
= DECL_INIT_PRIORITY (f1
);
242 priority2
= DECL_INIT_PRIORITY (f2
);
244 if (priority1
< priority2
)
246 else if (priority1
> priority2
)
249 /* Ensure a stable sort. */
250 return (const tree
*)p1
- (const tree
*)p2
;
253 /* Comparison function for qsort. P1 and P2 are actually of type
254 "tree *" and point to static destructors. DECL_FINI_PRIORITY is
255 used to determine the sort order. */
258 compare_dtor (const void *p1
, const void *p2
)
265 f1
= *(const tree
*)p1
;
266 f2
= *(const tree
*)p2
;
267 priority1
= DECL_FINI_PRIORITY (f1
);
268 priority2
= DECL_FINI_PRIORITY (f2
);
270 if (priority1
< priority2
)
272 else if (priority1
> priority2
)
275 /* Ensure a stable sort. */
276 return (const tree
*)p1
- (const tree
*)p2
;
279 /* Generate functions to call static constructors and destructors
280 for targets that do not support .ctors/.dtors sections. These
281 functions have magic names which are detected by collect2. */
284 cgraph_build_cdtor_fns (void)
286 if (!VEC_empty (tree
, static_ctors
))
288 gcc_assert (!targetm
.have_ctors_dtors
);
289 qsort (VEC_address (tree
, static_ctors
),
290 VEC_length (tree
, static_ctors
),
293 build_cdtor (/*ctor_p=*/true,
294 VEC_address (tree
, static_ctors
),
295 VEC_length (tree
, static_ctors
));
296 VEC_truncate (tree
, static_ctors
, 0);
299 if (!VEC_empty (tree
, static_dtors
))
301 gcc_assert (!targetm
.have_ctors_dtors
);
302 qsort (VEC_address (tree
, static_dtors
),
303 VEC_length (tree
, static_dtors
),
306 build_cdtor (/*ctor_p=*/false,
307 VEC_address (tree
, static_dtors
),
308 VEC_length (tree
, static_dtors
));
309 VEC_truncate (tree
, static_dtors
, 0);
313 /* Determine if function DECL is needed. That is, visible to something
314 either outside this translation unit, something magic in the system
318 decide_is_function_needed (struct cgraph_node
*node
, tree decl
)
320 if (MAIN_NAME_P (DECL_NAME (decl
))
321 && TREE_PUBLIC (decl
))
323 node
->local
.externally_visible
= true;
327 /* If the user told us it is used, then it must be so. */
328 if (node
->local
.externally_visible
)
331 /* ??? If the assembler name is set by hand, it is possible to assemble
332 the name later after finalizing the function and the fact is noticed
333 in assemble_name then. This is arguably a bug. */
334 if (DECL_ASSEMBLER_NAME_SET_P (decl
)
335 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)))
338 /* With -fkeep-inline-functions we are keeping all inline functions except
339 for extern inline ones. */
340 if (flag_keep_inline_functions
341 && DECL_DECLARED_INLINE_P (decl
)
342 && !DECL_EXTERNAL (decl
)
343 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (decl
)))
346 /* If we decided it was needed before, but at the time we didn't have
347 the body of the function available, then it's still needed. We have
348 to go back and re-check its dependencies now. */
352 /* Externally visible functions must be output. The exception is
353 COMDAT functions that must be output only when they are needed.
355 When not optimizing, also output the static functions. (see
356 PR24561), but don't do so for always_inline functions, functions
357 declared inline and nested functions. These was optimized out
358 in the original implementation and it is unclear whether we want
359 to change the behavior here. */
360 if (((TREE_PUBLIC (decl
)
361 || (!optimize
&& !node
->local
.disregard_inline_limits
362 && !DECL_DECLARED_INLINE_P (decl
)
364 && !flag_whole_program
)
365 && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
))
368 /* Constructors and destructors are reachable from the runtime by
370 if (DECL_STATIC_CONSTRUCTOR (decl
) || DECL_STATIC_DESTRUCTOR (decl
))
376 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
377 functions into callgraph in a way so they look like ordinary reachable
378 functions inserted into callgraph already at construction time. */
381 cgraph_process_new_functions (void)
385 struct cgraph_node
*node
;
387 /* Note that this queue may grow as its being processed, as the new
388 functions may generate new ones. */
389 while (cgraph_new_nodes
)
391 node
= cgraph_new_nodes
;
393 cgraph_new_nodes
= cgraph_new_nodes
->next_needed
;
394 switch (cgraph_state
)
396 case CGRAPH_STATE_CONSTRUCTION
:
397 /* At construction time we just need to finalize function and move
398 it into reachable functions list. */
400 node
->next_needed
= NULL
;
401 cgraph_finalize_function (fndecl
, false);
402 cgraph_mark_reachable_node (node
);
406 case CGRAPH_STATE_IPA
:
407 case CGRAPH_STATE_IPA_SSA
:
408 /* When IPA optimization already started, do all essential
409 transformations that has been already performed on the whole
410 cgraph but not on this function. */
412 gimple_register_cfg_hooks ();
414 cgraph_analyze_function (node
);
415 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
416 current_function_decl
= fndecl
;
417 compute_inline_parameters (node
);
418 if ((cgraph_state
== CGRAPH_STATE_IPA_SSA
419 && !gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
420 /* When not optimizing, be sure we run early local passes anyway
423 execute_pass_list (pass_early_local_passes
.pass
.sub
);
424 free_dominance_info (CDI_POST_DOMINATORS
);
425 free_dominance_info (CDI_DOMINATORS
);
427 current_function_decl
= NULL
;
430 case CGRAPH_STATE_EXPANSION
:
431 /* Functions created during expansion shall be compiled
434 cgraph_expand_function (node
);
441 cgraph_call_function_insertion_hooks (node
);
446 /* As an GCC extension we allow redefinition of the function. The
447 semantics when both copies of bodies differ is not well defined.
448 We replace the old body with new body so in unit at a time mode
449 we always use new body, while in normal mode we may end up with
450 old body inlined into some functions and new body expanded and
453 ??? It may make more sense to use one body for inlining and other
454 body for expanding the function but this is difficult to do. */
457 cgraph_reset_node (struct cgraph_node
*node
)
459 /* If node->process is set, then we have already begun whole-unit analysis.
460 This is *not* testing for whether we've already emitted the function.
461 That case can be sort-of legitimately seen with real function redefinition
462 errors. I would argue that the front end should never present us with
463 such a case, but don't enforce that for now. */
464 gcc_assert (!node
->process
);
466 /* Reset our data structures so we can analyze the function again. */
467 memset (&node
->local
, 0, sizeof (node
->local
));
468 memset (&node
->global
, 0, sizeof (node
->global
));
469 memset (&node
->rtl
, 0, sizeof (node
->rtl
));
470 node
->analyzed
= false;
471 node
->local
.redefined_extern_inline
= true;
472 node
->local
.finalized
= false;
474 cgraph_node_remove_callees (node
);
476 /* We may need to re-queue the node for assembling in case
477 we already proceeded it and ignored as not needed or got
478 a re-declaration in IMA mode. */
481 struct cgraph_node
*n
;
483 for (n
= cgraph_nodes_queue
; n
; n
= n
->next_needed
)
492 cgraph_lower_function (struct cgraph_node
*node
)
498 lower_nested_functions (node
->decl
);
499 gcc_assert (!node
->nested
);
501 tree_lowering_passes (node
->decl
);
502 node
->lowered
= true;
505 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
506 logic in effect. If NESTED is true, then our caller cannot stand to have
507 the garbage collector run at the moment. We would need to either create
508 a new GC context, or just not compile right now. */
511 cgraph_finalize_function (tree decl
, bool nested
)
513 struct cgraph_node
*node
= cgraph_node (decl
);
515 if (node
->local
.finalized
)
516 cgraph_reset_node (node
);
518 node
->pid
= cgraph_max_pid
++;
519 notice_global_symbol (decl
);
520 node
->local
.finalized
= true;
521 node
->lowered
= DECL_STRUCT_FUNCTION (decl
)->cfg
!= NULL
;
522 node
->finalized_by_frontend
= true;
523 record_cdtor_fn (node
->decl
);
525 if (decide_is_function_needed (node
, decl
))
526 cgraph_mark_needed_node (node
);
528 /* Since we reclaim unreachable nodes at the end of every language
529 level unit, we need to be conservative about possible entry points
531 if ((TREE_PUBLIC (decl
) && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
)))
532 cgraph_mark_reachable_node (node
);
534 /* If we've not yet emitted decl, tell the debug info about it. */
535 if (!TREE_ASM_WRITTEN (decl
))
536 (*debug_hooks
->deferred_inline_function
) (decl
);
538 /* Possibly warn about unused parameters. */
539 if (warn_unused_parameter
)
540 do_warn_unused_parameter (decl
);
546 /* C99 extern inline keywords allow changing of declaration after function
547 has been finalized. We need to re-decide if we want to mark the function as
551 cgraph_mark_if_needed (tree decl
)
553 struct cgraph_node
*node
= cgraph_node (decl
);
554 if (node
->local
.finalized
&& decide_is_function_needed (node
, decl
))
555 cgraph_mark_needed_node (node
);
558 /* Return TRUE if NODE2 is equivalent to NODE or its clone. */
560 clone_of_p (struct cgraph_node
*node
, struct cgraph_node
*node2
)
562 while (node
!= node2
&& node2
)
563 node2
= node2
->clone_of
;
564 return node2
!= NULL
;
567 /* Verify cgraph nodes of given cgraph node. */
569 verify_cgraph_node (struct cgraph_node
*node
)
571 struct cgraph_edge
*e
;
572 struct function
*this_cfun
= DECL_STRUCT_FUNCTION (node
->decl
);
573 struct function
*saved_cfun
= cfun
;
574 basic_block this_block
;
575 gimple_stmt_iterator gsi
;
576 bool error_found
= false;
578 if (errorcount
|| sorrycount
)
581 timevar_push (TV_CGRAPH_VERIFY
);
582 /* debug_generic_stmt needs correct cfun */
583 set_cfun (this_cfun
);
584 for (e
= node
->callees
; e
; e
= e
->next_callee
)
587 error ("aux field set for edge %s->%s",
588 identifier_to_locale (cgraph_node_name (e
->caller
)),
589 identifier_to_locale (cgraph_node_name (e
->callee
)));
594 error ("Execution count is negative");
597 for (e
= node
->callers
; e
; e
= e
->next_caller
)
601 error ("caller edge count is negative");
604 if (e
->frequency
< 0)
606 error ("caller edge frequency is negative");
609 if (e
->frequency
> CGRAPH_FREQ_MAX
)
611 error ("caller edge frequency is too large");
614 if (!e
->inline_failed
)
616 if (node
->global
.inlined_to
617 != (e
->caller
->global
.inlined_to
618 ? e
->caller
->global
.inlined_to
: e
->caller
))
620 error ("inlined_to pointer is wrong");
623 if (node
->callers
->next_caller
)
625 error ("multiple inline callers");
630 if (node
->global
.inlined_to
)
632 error ("inlined_to pointer set for noninline callers");
636 if (!node
->callers
&& node
->global
.inlined_to
)
638 error ("inlined_to pointer is set but no predecessors found");
641 if (node
->global
.inlined_to
== node
)
643 error ("inlined_to pointer refers to itself");
647 if (!cgraph_node (node
->decl
))
649 error ("node not found in cgraph_hash");
655 struct cgraph_node
*n
;
656 for (n
= node
->clone_of
->clones
; n
; n
= n
->next_sibling_clone
)
661 error ("node has wrong clone_of");
667 struct cgraph_node
*n
;
668 for (n
= node
->clones
; n
; n
= n
->next_sibling_clone
)
669 if (n
->clone_of
!= node
)
673 error ("node has wrong clone list");
677 if ((node
->prev_sibling_clone
|| node
->next_sibling_clone
) && !node
->clone_of
)
679 error ("node is in clone list but it is not clone");
682 if (!node
->prev_sibling_clone
&& node
->clone_of
&& node
->clone_of
->clones
!= node
)
684 error ("node has wrong prev_clone pointer");
687 if (node
->prev_sibling_clone
&& node
->prev_sibling_clone
->next_sibling_clone
!= node
)
689 error ("double linked list of clones corrupted");
693 if (node
->analyzed
&& gimple_has_body_p (node
->decl
)
694 && !TREE_ASM_WRITTEN (node
->decl
)
695 && (!DECL_EXTERNAL (node
->decl
) || node
->global
.inlined_to
))
699 /* The nodes we're interested in are never shared, so walk
700 the tree ignoring duplicates. */
701 struct pointer_set_t
*visited_nodes
= pointer_set_create ();
702 /* Reach the trees by walking over the CFG, and note the
703 enclosing basic-blocks in the call edges. */
704 FOR_EACH_BB_FN (this_block
, this_cfun
)
705 for (gsi
= gsi_start_bb (this_block
);
709 gimple stmt
= gsi_stmt (gsi
);
711 if (is_gimple_call (stmt
) && (decl
= gimple_call_fndecl (stmt
)))
713 struct cgraph_edge
*e
= cgraph_edge (node
, stmt
);
718 error ("shared call_stmt:");
719 debug_gimple_stmt (stmt
);
722 if (!clone_of_p (cgraph_node (decl
), e
->callee
)
723 && !e
->callee
->global
.inlined_to
)
725 error ("edge points to wrong declaration:");
726 debug_tree (e
->callee
->decl
);
727 fprintf (stderr
," Instead of:");
734 error ("missing callgraph edge for call stmt:");
735 debug_gimple_stmt (stmt
);
740 pointer_set_destroy (visited_nodes
);
743 /* No CFG available?! */
746 for (e
= node
->callees
; e
; e
= e
->next_callee
)
748 if (!e
->aux
&& !e
->indirect_call
)
750 error ("edge %s->%s has no corresponding call_stmt",
751 identifier_to_locale (cgraph_node_name (e
->caller
)),
752 identifier_to_locale (cgraph_node_name (e
->callee
)));
753 debug_gimple_stmt (e
->call_stmt
);
761 dump_cgraph_node (stderr
, node
);
762 internal_error ("verify_cgraph_node failed");
764 set_cfun (saved_cfun
);
765 timevar_pop (TV_CGRAPH_VERIFY
);
768 /* Verify whole cgraph structure. */
772 struct cgraph_node
*node
;
774 if (sorrycount
|| errorcount
)
777 for (node
= cgraph_nodes
; node
; node
= node
->next
)
778 verify_cgraph_node (node
);
781 /* Output all asm statements we have stored up to be output. */
784 cgraph_output_pending_asms (void)
786 struct cgraph_asm_node
*can
;
788 if (errorcount
|| sorrycount
)
791 for (can
= cgraph_asm_nodes
; can
; can
= can
->next
)
792 assemble_asm (can
->asm_str
);
793 cgraph_asm_nodes
= NULL
;
796 /* Analyze the function scheduled to be output. */
798 cgraph_analyze_function (struct cgraph_node
*node
)
800 tree save
= current_function_decl
;
801 tree decl
= node
->decl
;
803 current_function_decl
= decl
;
804 push_cfun (DECL_STRUCT_FUNCTION (decl
));
806 /* Make sure to gimplify bodies only once. During analyzing a
807 function we lower it, which will require gimplified nested
808 functions, so we can end up here with an already gimplified
810 if (!gimple_body (decl
))
811 gimplify_function_tree (decl
);
812 dump_function (TDI_generic
, decl
);
814 cgraph_lower_function (node
);
815 node
->analyzed
= true;
818 current_function_decl
= save
;
821 /* Look for externally_visible and used attributes and mark cgraph nodes
824 We cannot mark the nodes at the point the attributes are processed (in
825 handle_*_attribute) because the copy of the declarations available at that
826 point may not be canonical. For example, in:
829 void f() __attribute__((used));
831 the declaration we see in handle_used_attribute will be the second
832 declaration -- but the front end will subsequently merge that declaration
833 with the original declaration and discard the second declaration.
835 Furthermore, we can't mark these nodes in cgraph_finalize_function because:
838 void f() __attribute__((externally_visible));
842 So, we walk the nodes at the end of the translation unit, applying the
843 attributes at that point. */
846 process_function_and_variable_attributes (struct cgraph_node
*first
,
847 struct varpool_node
*first_var
)
849 struct cgraph_node
*node
;
850 struct varpool_node
*vnode
;
852 for (node
= cgraph_nodes
; node
!= first
; node
= node
->next
)
854 tree decl
= node
->decl
;
855 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl
)))
857 mark_decl_referenced (decl
);
858 if (node
->local
.finalized
)
859 cgraph_mark_needed_node (node
);
861 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
863 if (! TREE_PUBLIC (node
->decl
))
864 warning_at (DECL_SOURCE_LOCATION (node
->decl
), OPT_Wattributes
,
865 "%<externally_visible%>"
866 " attribute have effect only on public objects");
869 if (node
->local
.finalized
)
870 cgraph_mark_needed_node (node
);
871 node
->local
.externally_visible
= true;
875 for (vnode
= varpool_nodes
; vnode
!= first_var
; vnode
= vnode
->next
)
877 tree decl
= vnode
->decl
;
878 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl
)))
880 mark_decl_referenced (decl
);
881 if (vnode
->finalized
)
882 varpool_mark_needed_node (vnode
);
884 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
886 if (! TREE_PUBLIC (vnode
->decl
))
887 warning_at (DECL_SOURCE_LOCATION (vnode
->decl
), OPT_Wattributes
,
888 "%<externally_visible%>"
889 " attribute have effect only on public objects");
892 if (vnode
->finalized
)
893 varpool_mark_needed_node (vnode
);
894 vnode
->externally_visible
= true;
900 /* Process CGRAPH_NODES_NEEDED queue, analyze each function (and transitively
901 each reachable functions) and build cgraph.
902 The function can be called multiple times after inserting new nodes
903 into beginning of queue. Just the new part of queue is re-scanned then. */
906 cgraph_analyze_functions (void)
908 /* Keep track of already processed nodes when called multiple times for
909 intermodule optimization. */
910 static struct cgraph_node
*first_analyzed
;
911 struct cgraph_node
*first_processed
= first_analyzed
;
912 static struct varpool_node
*first_analyzed_var
;
913 struct cgraph_node
*node
, *next
;
915 process_function_and_variable_attributes (first_processed
,
917 first_processed
= cgraph_nodes
;
918 first_analyzed_var
= varpool_nodes
;
919 varpool_analyze_pending_decls ();
920 if (cgraph_dump_file
)
922 fprintf (cgraph_dump_file
, "Initial entry points:");
923 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
925 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
926 fprintf (cgraph_dump_file
, "\n");
928 cgraph_process_new_functions ();
930 /* Propagate reachability flag and lower representation of all reachable
931 functions. In the future, lowering will introduce new functions and
932 new entry points on the way (by template instantiation and virtual
933 method table generation for instance). */
934 while (cgraph_nodes_queue
)
936 struct cgraph_edge
*edge
;
937 tree decl
= cgraph_nodes_queue
->decl
;
939 node
= cgraph_nodes_queue
;
940 cgraph_nodes_queue
= cgraph_nodes_queue
->next_needed
;
941 node
->next_needed
= NULL
;
943 /* ??? It is possible to create extern inline function and later using
944 weak alias attribute to kill its body. See
945 gcc.c-torture/compile/20011119-1.c */
946 if (!DECL_STRUCT_FUNCTION (decl
))
948 cgraph_reset_node (node
);
952 gcc_assert (!node
->analyzed
&& node
->reachable
);
953 cgraph_analyze_function (node
);
955 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
956 if (!edge
->callee
->reachable
)
957 cgraph_mark_reachable_node (edge
->callee
);
959 /* If decl is a clone of an abstract function, mark that abstract
960 function so that we don't release its body. The DECL_INITIAL() of that
961 abstract function declaration will be later needed to output debug info. */
962 if (DECL_ABSTRACT_ORIGIN (decl
))
964 struct cgraph_node
*origin_node
= cgraph_node (DECL_ABSTRACT_ORIGIN (decl
));
965 origin_node
->abstract_and_needed
= true;
968 /* We finalize local static variables during constructing callgraph
969 edges. Process their attributes too. */
970 process_function_and_variable_attributes (first_processed
,
972 first_processed
= cgraph_nodes
;
973 first_analyzed_var
= varpool_nodes
;
974 varpool_analyze_pending_decls ();
975 cgraph_process_new_functions ();
978 /* Collect entry points to the unit. */
979 if (cgraph_dump_file
)
981 fprintf (cgraph_dump_file
, "Unit entry points:");
982 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
984 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
985 fprintf (cgraph_dump_file
, "\n\nInitial ");
986 dump_cgraph (cgraph_dump_file
);
989 if (cgraph_dump_file
)
990 fprintf (cgraph_dump_file
, "\nReclaiming functions:");
992 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= next
)
994 tree decl
= node
->decl
;
997 if (node
->local
.finalized
&& !gimple_has_body_p (decl
))
998 cgraph_reset_node (node
);
1000 if (!node
->reachable
&& gimple_has_body_p (decl
))
1002 if (cgraph_dump_file
)
1003 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1004 cgraph_remove_node (node
);
1008 node
->next_needed
= NULL
;
1009 gcc_assert (!node
->local
.finalized
|| gimple_has_body_p (decl
));
1010 gcc_assert (node
->analyzed
== node
->local
.finalized
);
1012 if (cgraph_dump_file
)
1014 fprintf (cgraph_dump_file
, "\n\nReclaimed ");
1015 dump_cgraph (cgraph_dump_file
);
1017 first_analyzed
= cgraph_nodes
;
1022 /* Emit thunks for every node in the cgraph.
1023 FIXME: We really ought to emit thunks only for functions that are needed. */
1026 cgraph_emit_thunks (void)
1028 struct cgraph_node
*n
;
1030 for (n
= cgraph_nodes
; n
; n
= n
->next
)
1032 /* Only emit thunks on functions defined in this TU.
1033 Note that this may emit more thunks than strictly necessary.
1034 During optimization some nodes may disappear. It would be
1035 nice to only emit thunks only for the functions that will be
1036 emitted, but we cannot know that until the inliner and other
1037 IPA passes have run (see the sequencing of the call to
1038 cgraph_mark_functions_to_output in cgraph_optimize). */
1040 && !DECL_EXTERNAL (n
->decl
))
1041 lang_hooks
.callgraph
.emit_associated_thunks (n
->decl
);
1046 /* Analyze the whole compilation unit once it is parsed completely. */
1049 cgraph_finalize_compilation_unit (void)
1051 timevar_push (TV_CGRAPH
);
1053 /* Do not skip analyzing the functions if there were errors, we
1054 miss diagnostics for following functions otherwise. */
1056 /* Emit size functions we didn't inline. */
1057 finalize_size_functions ();
1059 /* Call functions declared with the "constructor" or "destructor"
1061 cgraph_build_cdtor_fns ();
1063 /* Mark alias targets necessary and emit diagnostics. */
1064 finish_aliases_1 ();
1068 fprintf (stderr
, "\nAnalyzing compilation unit\n");
1072 /* Gimplify and lower all functions, compute reachability and
1073 remove unreachable nodes. */
1074 cgraph_analyze_functions ();
1076 /* Emit thunks for reachable nodes, if needed. */
1077 if (lang_hooks
.callgraph
.emit_associated_thunks
)
1078 cgraph_emit_thunks ();
1080 /* Mark alias targets necessary and emit diagnostics. */
1081 finish_aliases_1 ();
1083 /* Gimplify and lower thunks. */
1084 cgraph_analyze_functions ();
1086 /* Finally drive the pass manager. */
1089 timevar_pop (TV_CGRAPH
);
1093 /* Figure out what functions we want to assemble. */
1096 cgraph_mark_functions_to_output (void)
1098 struct cgraph_node
*node
;
1100 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1102 tree decl
= node
->decl
;
1103 struct cgraph_edge
*e
;
1105 gcc_assert (!node
->process
);
1107 for (e
= node
->callers
; e
; e
= e
->next_caller
)
1108 if (e
->inline_failed
)
1111 /* We need to output all local functions that are used and not
1112 always inlined, as well as those that are reachable from
1113 outside the current compilation unit. */
1115 && !node
->global
.inlined_to
1117 || (e
&& node
->reachable
))
1118 && !TREE_ASM_WRITTEN (decl
)
1119 && !DECL_EXTERNAL (decl
))
1123 /* We should've reclaimed all functions that are not needed. */
1124 #ifdef ENABLE_CHECKING
1125 if (!node
->global
.inlined_to
1126 && gimple_has_body_p (decl
)
1127 && !DECL_EXTERNAL (decl
))
1129 dump_cgraph_node (stderr
, node
);
1130 internal_error ("failed to reclaim unneeded function");
1133 gcc_assert (node
->global
.inlined_to
1134 || !gimple_has_body_p (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 announce_function (decl
);
1155 gcc_assert (node
->lowered
);
1157 /* Generate RTL for the body of DECL. */
1158 tree_rest_of_compilation (decl
);
1160 /* Make sure that BE didn't give up on compiling. */
1161 gcc_assert (TREE_ASM_WRITTEN (decl
));
1162 current_function_decl
= NULL
;
1163 gcc_assert (!cgraph_preserve_function_body_p (decl
));
1164 cgraph_release_function_body (node
);
1165 /* Eliminate all call edges. This is important so the GIMPLE_CALL no longer
1166 points to the dead function body. */
1167 cgraph_node_remove_callees (node
);
1169 cgraph_function_flags_ready
= true;
1172 /* Return true when CALLER_DECL should be inlined into CALLEE_DECL. */
1175 cgraph_inline_p (struct cgraph_edge
*e
, cgraph_inline_failed_t
*reason
)
1177 *reason
= e
->inline_failed
;
1178 return !e
->inline_failed
;
1183 /* Expand all functions that must be output.
1185 Attempt to topologically sort the nodes so function is output when
1186 all called functions are already assembled to allow data to be
1187 propagated across the callgraph. Use a stack to get smaller distance
1188 between a function and its callees (later we may choose to use a more
1189 sophisticated algorithm for function reordering; we will likely want
1190 to use subsections to make the output functions appear in top-down
1194 cgraph_expand_all_functions (void)
1196 struct cgraph_node
*node
;
1197 struct cgraph_node
**order
= XCNEWVEC (struct cgraph_node
*, cgraph_n_nodes
);
1198 int order_pos
, new_order_pos
= 0;
1201 order_pos
= cgraph_postorder (order
);
1202 gcc_assert (order_pos
== cgraph_n_nodes
);
1204 /* Garbage collector may remove inline clones we eliminate during
1205 optimization. So we must be sure to not reference them. */
1206 for (i
= 0; i
< order_pos
; i
++)
1207 if (order
[i
]->process
)
1208 order
[new_order_pos
++] = order
[i
];
1210 for (i
= new_order_pos
- 1; i
>= 0; i
--)
1215 gcc_assert (node
->reachable
);
1217 cgraph_expand_function (node
);
1220 cgraph_process_new_functions ();
1226 /* This is used to sort the node types by the cgraph order number. */
1228 enum cgraph_order_sort_kind
1230 ORDER_UNDEFINED
= 0,
1236 struct cgraph_order_sort
1238 enum cgraph_order_sort_kind kind
;
1241 struct cgraph_node
*f
;
1242 struct varpool_node
*v
;
1243 struct cgraph_asm_node
*a
;
1247 /* Output all functions, variables, and asm statements in the order
1248 according to their order fields, which is the order in which they
1249 appeared in the file. This implements -fno-toplevel-reorder. In
1250 this mode we may output functions and variables which don't really
1251 need to be output. */
1254 cgraph_output_in_order (void)
1258 struct cgraph_order_sort
*nodes
;
1260 struct cgraph_node
*pf
;
1261 struct varpool_node
*pv
;
1262 struct cgraph_asm_node
*pa
;
1265 size
= max
* sizeof (struct cgraph_order_sort
);
1266 nodes
= (struct cgraph_order_sort
*) alloca (size
);
1267 memset (nodes
, 0, size
);
1269 varpool_analyze_pending_decls ();
1271 for (pf
= cgraph_nodes
; pf
; pf
= pf
->next
)
1276 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1277 nodes
[i
].kind
= ORDER_FUNCTION
;
1282 for (pv
= varpool_nodes_queue
; pv
; pv
= pv
->next_needed
)
1285 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1286 nodes
[i
].kind
= ORDER_VAR
;
1290 for (pa
= cgraph_asm_nodes
; pa
; pa
= pa
->next
)
1293 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1294 nodes
[i
].kind
= ORDER_ASM
;
1298 /* In toplevel reorder mode we output all statics; mark them as needed. */
1299 for (i
= 0; i
< max
; ++i
)
1301 if (nodes
[i
].kind
== ORDER_VAR
)
1303 varpool_mark_needed_node (nodes
[i
].u
.v
);
1306 varpool_empty_needed_queue ();
1308 for (i
= 0; i
< max
; ++i
)
1310 switch (nodes
[i
].kind
)
1312 case ORDER_FUNCTION
:
1313 nodes
[i
].u
.f
->process
= 0;
1314 cgraph_expand_function (nodes
[i
].u
.f
);
1318 varpool_assemble_decl (nodes
[i
].u
.v
);
1322 assemble_asm (nodes
[i
].u
.a
->asm_str
);
1325 case ORDER_UNDEFINED
:
1333 cgraph_asm_nodes
= NULL
;
1336 /* Return true when function body of DECL still needs to be kept around
1337 for later re-use. */
1339 cgraph_preserve_function_body_p (tree decl
)
1341 struct cgraph_node
*node
;
1343 gcc_assert (cgraph_global_info_ready
);
1344 /* Look if there is any clone around. */
1345 node
= cgraph_node (decl
);
1355 current_function_decl
= NULL
;
1356 gimple_register_cfg_hooks ();
1357 bitmap_obstack_initialize (NULL
);
1358 execute_ipa_pass_list (all_ipa_passes
);
1360 /* Generate coverage variables and constructors. */
1363 /* Process new functions added. */
1365 current_function_decl
= NULL
;
1366 cgraph_process_new_functions ();
1368 bitmap_obstack_release (NULL
);
1372 /* Perform simple optimizations based on callgraph. */
1375 cgraph_optimize (void)
1377 if (errorcount
|| sorrycount
)
1380 #ifdef ENABLE_CHECKING
1384 /* Frontend may output common variables after the unit has been finalized.
1385 It is safe to deal with them here as they are always zero initialized. */
1386 varpool_analyze_pending_decls ();
1388 timevar_push (TV_CGRAPHOPT
);
1389 if (pre_ipa_mem_report
)
1391 fprintf (stderr
, "Memory consumption before IPA\n");
1392 dump_memory_report (false);
1395 fprintf (stderr
, "Performing interprocedural optimizations\n");
1396 cgraph_state
= CGRAPH_STATE_IPA
;
1398 /* Don't run the IPA passes if there was any error or sorry messages. */
1399 if (errorcount
== 0 && sorrycount
== 0)
1402 /* Do nothing else if any IPA pass found errors. */
1403 if (errorcount
|| sorrycount
)
1406 /* This pass remove bodies of extern inline functions we never inlined.
1407 Do this later so other IPA passes see what is really going on. */
1408 cgraph_remove_unreachable_nodes (false, dump_file
);
1409 cgraph_global_info_ready
= true;
1410 if (cgraph_dump_file
)
1412 fprintf (cgraph_dump_file
, "Optimized ");
1413 dump_cgraph (cgraph_dump_file
);
1414 dump_varpool (cgraph_dump_file
);
1416 if (post_ipa_mem_report
)
1418 fprintf (stderr
, "Memory consumption after IPA\n");
1419 dump_memory_report (false);
1421 timevar_pop (TV_CGRAPHOPT
);
1423 /* Output everything. */
1425 fprintf (stderr
, "Assembling functions:\n");
1426 #ifdef ENABLE_CHECKING
1430 cgraph_materialize_all_clones ();
1431 cgraph_mark_functions_to_output ();
1433 cgraph_state
= CGRAPH_STATE_EXPANSION
;
1434 if (!flag_toplevel_reorder
)
1435 cgraph_output_in_order ();
1438 cgraph_output_pending_asms ();
1440 cgraph_expand_all_functions ();
1441 varpool_remove_unreferenced_decls ();
1443 varpool_assemble_pending_decls ();
1445 cgraph_process_new_functions ();
1446 cgraph_state
= CGRAPH_STATE_FINISHED
;
1448 if (cgraph_dump_file
)
1450 fprintf (cgraph_dump_file
, "\nFinal ");
1451 dump_cgraph (cgraph_dump_file
);
1453 #ifdef ENABLE_CHECKING
1455 /* Double check that all inline clones are gone and that all
1456 function bodies have been released from memory. */
1457 if (!(sorrycount
|| errorcount
))
1459 struct cgraph_node
*node
;
1460 bool error_found
= false;
1462 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1464 && (node
->global
.inlined_to
1465 || gimple_has_body_p (node
->decl
)))
1468 dump_cgraph_node (stderr
, node
);
1471 internal_error ("nodes with unreleased memory found");
1477 /* Generate and emit a static constructor or destructor. WHICH must
1478 be one of 'I' (for a constructor) or 'D' (for a destructor). BODY
1479 is a STATEMENT_LIST containing GENERIC statements. PRIORITY is the
1480 initialization priority for this constructor or destructor. */
1483 cgraph_build_static_cdtor (char which
, tree body
, int priority
)
1485 static int counter
= 0;
1487 tree decl
, name
, resdecl
;
1489 /* The priority is encoded in the constructor or destructor name.
1490 collect2 will sort the names and arrange that they are called at
1492 sprintf (which_buf
, "%c_%.5d_%d", which
, priority
, counter
++);
1493 name
= get_file_function_name (which_buf
);
1495 decl
= build_decl (input_location
, FUNCTION_DECL
, name
,
1496 build_function_type (void_type_node
, void_list_node
));
1497 current_function_decl
= decl
;
1499 resdecl
= build_decl (input_location
,
1500 RESULT_DECL
, NULL_TREE
, void_type_node
);
1501 DECL_ARTIFICIAL (resdecl
) = 1;
1502 DECL_RESULT (decl
) = resdecl
;
1503 DECL_CONTEXT (resdecl
) = decl
;
1505 allocate_struct_function (decl
, false);
1507 TREE_STATIC (decl
) = 1;
1508 TREE_USED (decl
) = 1;
1509 DECL_ARTIFICIAL (decl
) = 1;
1510 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
1511 DECL_SAVED_TREE (decl
) = body
;
1512 TREE_PUBLIC (decl
) = ! targetm
.have_ctors_dtors
;
1513 DECL_UNINLINABLE (decl
) = 1;
1515 DECL_INITIAL (decl
) = make_node (BLOCK
);
1516 TREE_USED (DECL_INITIAL (decl
)) = 1;
1518 DECL_SOURCE_LOCATION (decl
) = input_location
;
1519 cfun
->function_end_locus
= input_location
;
1524 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
1525 decl_init_priority_insert (decl
, priority
);
1528 DECL_STATIC_DESTRUCTOR (decl
) = 1;
1529 decl_fini_priority_insert (decl
, priority
);
1535 gimplify_function_tree (decl
);
1537 cgraph_add_new_function (decl
, false);
1538 cgraph_mark_needed_node (cgraph_node (decl
));
1545 cgraph_dump_file
= dump_begin (TDI_cgraph
, NULL
);
1548 /* The edges representing the callers of the NEW_VERSION node were
1549 fixed by cgraph_function_versioning (), now the call_expr in their
1550 respective tree code should be updated to call the NEW_VERSION. */
1553 update_call_expr (struct cgraph_node
*new_version
)
1555 struct cgraph_edge
*e
;
1557 gcc_assert (new_version
);
1559 /* Update the call expr on the edges to call the new version. */
1560 for (e
= new_version
->callers
; e
; e
= e
->next_caller
)
1562 struct function
*inner_function
= DECL_STRUCT_FUNCTION (e
->caller
->decl
);
1563 gimple_call_set_fndecl (e
->call_stmt
, new_version
->decl
);
1564 maybe_clean_eh_stmt_fn (inner_function
, e
->call_stmt
);
1569 /* Create a new cgraph node which is the new version of
1570 OLD_VERSION node. REDIRECT_CALLERS holds the callers
1571 edges which should be redirected to point to
1572 NEW_VERSION. ALL the callees edges of OLD_VERSION
1573 are cloned to the new version node. Return the new
1576 static struct cgraph_node
*
1577 cgraph_copy_node_for_versioning (struct cgraph_node
*old_version
,
1579 VEC(cgraph_edge_p
,heap
) *redirect_callers
)
1581 struct cgraph_node
*new_version
;
1582 struct cgraph_edge
*e
, *new_e
;
1583 struct cgraph_edge
*next_callee
;
1586 gcc_assert (old_version
);
1588 new_version
= cgraph_node (new_decl
);
1590 new_version
->analyzed
= true;
1591 new_version
->local
= old_version
->local
;
1592 new_version
->global
= old_version
->global
;
1593 new_version
->rtl
= new_version
->rtl
;
1594 new_version
->reachable
= true;
1595 new_version
->count
= old_version
->count
;
1597 /* Clone the old node callees. Recursive calls are
1599 for (e
= old_version
->callees
;e
; e
=e
->next_callee
)
1601 new_e
= cgraph_clone_edge (e
, new_version
, e
->call_stmt
, 0, e
->frequency
,
1602 e
->loop_nest
, true);
1603 new_e
->count
= e
->count
;
1605 /* Fix recursive calls.
1606 If OLD_VERSION has a recursive call after the
1607 previous edge cloning, the new version will have an edge
1608 pointing to the old version, which is wrong;
1609 Redirect it to point to the new version. */
1610 for (e
= new_version
->callees
; e
; e
= next_callee
)
1612 next_callee
= e
->next_callee
;
1613 if (e
->callee
== old_version
)
1614 cgraph_redirect_edge_callee (e
, new_version
);
1619 for (i
= 0; VEC_iterate (cgraph_edge_p
, redirect_callers
, i
, e
); i
++)
1621 /* Redirect calls to the old version node to point to its new
1623 cgraph_redirect_edge_callee (e
, new_version
);
1629 /* Perform function versioning.
1630 Function versioning includes copying of the tree and
1631 a callgraph update (creating a new cgraph node and updating
1632 its callees and callers).
1634 REDIRECT_CALLERS varray includes the edges to be redirected
1637 TREE_MAP is a mapping of tree nodes we want to replace with
1638 new ones (according to results of prior analysis).
1639 OLD_VERSION_NODE is the node that is versioned.
1640 It returns the new version's cgraph node.
1641 ARGS_TO_SKIP lists arguments to be omitted from functions
1644 struct cgraph_node
*
1645 cgraph_function_versioning (struct cgraph_node
*old_version_node
,
1646 VEC(cgraph_edge_p
,heap
) *redirect_callers
,
1647 VEC (ipa_replace_map_p
,gc
)* tree_map
,
1648 bitmap args_to_skip
)
1650 tree old_decl
= old_version_node
->decl
;
1651 struct cgraph_node
*new_version_node
= NULL
;
1654 if (!tree_versionable_function_p (old_decl
))
1657 /* Make a new FUNCTION_DECL tree node for the
1660 new_decl
= copy_node (old_decl
);
1662 new_decl
= build_function_decl_skip_args (old_decl
, args_to_skip
);
1664 /* Create the new version's call-graph node.
1665 and update the edges of the new node. */
1667 cgraph_copy_node_for_versioning (old_version_node
, new_decl
,
1670 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1671 tree_function_versioning (old_decl
, new_decl
, tree_map
, false, args_to_skip
);
1673 /* Update the new version's properties.
1674 Make The new version visible only within this translation unit. Make sure
1675 that is not weak also.
1676 ??? We cannot use COMDAT linkage because there is no
1677 ABI support for this. */
1678 DECL_EXTERNAL (new_version_node
->decl
) = 0;
1679 DECL_COMDAT_GROUP (new_version_node
->decl
) = NULL_TREE
;
1680 TREE_PUBLIC (new_version_node
->decl
) = 0;
1681 DECL_COMDAT (new_version_node
->decl
) = 0;
1682 DECL_WEAK (new_version_node
->decl
) = 0;
1683 DECL_VIRTUAL_P (new_version_node
->decl
) = 0;
1684 new_version_node
->local
.externally_visible
= 0;
1685 new_version_node
->local
.local
= 1;
1686 new_version_node
->lowered
= true;
1688 /* Update the call_expr on the edges to call the new version node. */
1689 update_call_expr (new_version_node
);
1691 cgraph_call_function_insertion_hooks (new_version_node
);
1692 return new_version_node
;
1695 /* Produce separate function body for inline clones so the offline copy can be
1696 modified without affecting them. */
1697 struct cgraph_node
*
1698 save_inline_function_body (struct cgraph_node
*node
)
1700 struct cgraph_node
*first_clone
, *n
;
1702 gcc_assert (node
== cgraph_node (node
->decl
));
1704 cgraph_lower_function (node
);
1706 first_clone
= node
->clones
;
1708 first_clone
->decl
= copy_node (node
->decl
);
1709 cgraph_insert_node_to_hashtable (first_clone
);
1710 gcc_assert (first_clone
== cgraph_node (first_clone
->decl
));
1711 if (first_clone
->next_sibling_clone
)
1713 for (n
= first_clone
->next_sibling_clone
; n
->next_sibling_clone
; n
= n
->next_sibling_clone
)
1714 n
->clone_of
= first_clone
;
1715 n
->clone_of
= first_clone
;
1716 n
->next_sibling_clone
= first_clone
->clones
;
1717 if (first_clone
->clones
)
1718 first_clone
->clones
->prev_sibling_clone
= n
;
1719 first_clone
->clones
= first_clone
->next_sibling_clone
;
1720 first_clone
->next_sibling_clone
->prev_sibling_clone
= NULL
;
1721 first_clone
->next_sibling_clone
= NULL
;
1722 gcc_assert (!first_clone
->prev_sibling_clone
);
1724 first_clone
->clone_of
= NULL
;
1725 node
->clones
= NULL
;
1727 if (first_clone
->clones
)
1728 for (n
= first_clone
->clones
; n
!= first_clone
;)
1730 gcc_assert (n
->decl
== node
->decl
);
1731 n
->decl
= first_clone
->decl
;
1734 else if (n
->next_sibling_clone
)
1735 n
= n
->next_sibling_clone
;
1738 while (n
!= first_clone
&& !n
->next_sibling_clone
)
1740 if (n
!= first_clone
)
1741 n
= n
->next_sibling_clone
;
1745 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1746 tree_function_versioning (node
->decl
, first_clone
->decl
, NULL
, true, NULL
);
1748 DECL_EXTERNAL (first_clone
->decl
) = 0;
1749 DECL_COMDAT_GROUP (first_clone
->decl
) = NULL_TREE
;
1750 TREE_PUBLIC (first_clone
->decl
) = 0;
1751 DECL_COMDAT (first_clone
->decl
) = 0;
1752 VEC_free (ipa_opt_pass
, heap
,
1753 DECL_STRUCT_FUNCTION (first_clone
->decl
)->ipa_transforms_to_apply
);
1754 DECL_STRUCT_FUNCTION (first_clone
->decl
)->ipa_transforms_to_apply
= NULL
;
1756 #ifdef ENABLE_CHECKING
1757 verify_cgraph_node (first_clone
);
1762 /* Given virtual clone, turn it into actual clone. */
1764 cgraph_materialize_clone (struct cgraph_node
*node
)
1766 bitmap_obstack_initialize (NULL
);
1767 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1768 tree_function_versioning (node
->clone_of
->decl
, node
->decl
,
1769 node
->clone
.tree_map
, true,
1770 node
->clone
.args_to_skip
);
1771 if (cgraph_dump_file
)
1773 dump_function_to_file (node
->clone_of
->decl
, cgraph_dump_file
, dump_flags
);
1774 dump_function_to_file (node
->decl
, cgraph_dump_file
, dump_flags
);
1777 /* Function is no longer clone. */
1778 if (node
->next_sibling_clone
)
1779 node
->next_sibling_clone
->prev_sibling_clone
= node
->prev_sibling_clone
;
1780 if (node
->prev_sibling_clone
)
1781 node
->prev_sibling_clone
->next_sibling_clone
= node
->next_sibling_clone
;
1783 node
->clone_of
->clones
= node
->next_sibling_clone
;
1784 node
->next_sibling_clone
= NULL
;
1785 node
->prev_sibling_clone
= NULL
;
1786 node
->clone_of
= NULL
;
1787 bitmap_obstack_release (NULL
);
1790 /* Once all functions from compilation unit are in memory, produce all clones
1791 and update all calls.
1792 We might also do this on demand if we don't want to bring all functions to
1793 memory prior compilation, but current WHOPR implementation does that and it is
1794 is bit easier to keep everything right in this order. */
1796 cgraph_materialize_all_clones (void)
1798 struct cgraph_node
*node
;
1799 bool stabilized
= false;
1801 if (cgraph_dump_file
)
1802 fprintf (cgraph_dump_file
, "Materializing clones\n");
1803 #ifdef ENABLE_CHECKING
1807 /* We can also do topological order, but number of iterations should be
1808 bounded by number of IPA passes since single IPA pass is probably not
1809 going to create clones of clones it created itself. */
1813 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1815 if (node
->clone_of
&& node
->decl
!= node
->clone_of
->decl
1816 && !gimple_has_body_p (node
->decl
))
1818 if (gimple_has_body_p (node
->clone_of
->decl
))
1820 if (cgraph_dump_file
)
1822 fprintf (cgraph_dump_file
, "clonning %s to %s\n",
1823 cgraph_node_name (node
->clone_of
),
1824 cgraph_node_name (node
));
1825 if (node
->clone
.tree_map
)
1828 fprintf (cgraph_dump_file
, " replace map: ");
1829 for (i
= 0; i
< VEC_length (ipa_replace_map_p
,
1830 node
->clone
.tree_map
);
1833 struct ipa_replace_map
*replace_info
;
1834 replace_info
= VEC_index (ipa_replace_map_p
,
1835 node
->clone
.tree_map
,
1837 print_generic_expr (cgraph_dump_file
, replace_info
->old_tree
, 0);
1838 fprintf (cgraph_dump_file
, " -> ");
1839 print_generic_expr (cgraph_dump_file
, replace_info
->new_tree
, 0);
1840 fprintf (cgraph_dump_file
, "%s%s;",
1841 replace_info
->replace_p
? "(replace)":"",
1842 replace_info
->ref_p
? "(ref)":"");
1844 fprintf (cgraph_dump_file
, "\n");
1846 if (node
->clone
.args_to_skip
)
1848 fprintf (cgraph_dump_file
, " args_to_skip: ");
1849 dump_bitmap (cgraph_dump_file
, node
->clone
.args_to_skip
);
1851 if (node
->clone
.args_to_skip
)
1853 fprintf (cgraph_dump_file
, " combined_args_to_skip:");
1854 dump_bitmap (cgraph_dump_file
, node
->clone
.combined_args_to_skip
);
1857 cgraph_materialize_clone (node
);
1864 if (cgraph_dump_file
)
1865 fprintf (cgraph_dump_file
, "Updating call sites\n");
1866 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1867 if (node
->analyzed
&& gimple_has_body_p (node
->decl
)
1868 && (!node
->clone_of
|| node
->clone_of
->decl
!= node
->decl
))
1870 struct cgraph_edge
*e
;
1872 current_function_decl
= node
->decl
;
1873 push_cfun (DECL_STRUCT_FUNCTION (node
->decl
));
1874 for (e
= node
->callees
; e
; e
= e
->next_callee
)
1876 tree decl
= gimple_call_fndecl (e
->call_stmt
);
1877 /* When function gets inlined, indirect inlining might've invented
1878 new edge for orginally indirect stmt. Since we are not
1879 preserving clones in the original form, we must not update here
1880 since other inline clones don't need to contain call to the same
1881 call. Inliner will do the substitution for us later. */
1882 if (decl
&& decl
!= e
->callee
->decl
)
1885 gimple_stmt_iterator gsi
;
1887 if (cgraph_dump_file
)
1889 fprintf (cgraph_dump_file
, "updating call of %s in %s:",
1890 cgraph_node_name (node
),
1891 cgraph_node_name (e
->callee
));
1892 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
1895 if (e
->callee
->clone
.combined_args_to_skip
)
1896 new_stmt
= gimple_call_copy_skip_args (e
->call_stmt
,
1897 e
->callee
->clone
.combined_args_to_skip
);
1899 new_stmt
= e
->call_stmt
;
1900 if (gimple_vdef (new_stmt
)
1901 && TREE_CODE (gimple_vdef (new_stmt
)) == SSA_NAME
)
1902 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt
)) = new_stmt
;
1903 gimple_call_set_fndecl (new_stmt
, e
->callee
->decl
);
1905 gsi
= gsi_for_stmt (e
->call_stmt
);
1906 gsi_replace (&gsi
, new_stmt
, true);
1908 /* Update EH information too, just in case. */
1909 maybe_clean_or_replace_eh_stmt (e
->call_stmt
, new_stmt
);
1911 cgraph_set_call_stmt_including_clones (node
, e
->call_stmt
, new_stmt
);
1913 if (cgraph_dump_file
)
1915 fprintf (cgraph_dump_file
, " updated to:");
1916 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
1921 current_function_decl
= NULL
;
1922 #ifdef ENABLE_CHECKING
1923 verify_cgraph_node (node
);
1926 #ifdef ENABLE_CHECKING
1929 cgraph_remove_unreachable_nodes (false, cgraph_dump_file
);
1932 #include "gt-cgraphunit.h"