1 /* Callgraph based interprocedural optimizations.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
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"
140 static void cgraph_expand_all_functions (void);
141 static void cgraph_mark_functions_to_output (void);
142 static void cgraph_expand_function (struct cgraph_node
*);
143 static void cgraph_output_pending_asms (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 /* Used for vtable lookup in thunk adjusting. */
154 static GTY (()) tree vtable_entry_type
;
156 /* When target does not have ctors and dtors, we call all constructor
157 and destructor by special initialization/destruction function
158 recognized by collect2.
160 When we are going to build this function, collect all constructors and
161 destructors and turn them into normal functions. */
164 record_cdtor_fn (tree fndecl
)
166 struct cgraph_node
*node
;
167 if (targetm
.have_ctors_dtors
168 || (!DECL_STATIC_CONSTRUCTOR (fndecl
)
169 && !DECL_STATIC_DESTRUCTOR (fndecl
)))
172 if (DECL_STATIC_CONSTRUCTOR (fndecl
))
174 VEC_safe_push (tree
, gc
, static_ctors
, fndecl
);
175 DECL_STATIC_CONSTRUCTOR (fndecl
) = 0;
177 if (DECL_STATIC_DESTRUCTOR (fndecl
))
179 VEC_safe_push (tree
, gc
, static_dtors
, fndecl
);
180 DECL_STATIC_DESTRUCTOR (fndecl
) = 0;
182 node
= cgraph_node (fndecl
);
183 node
->local
.disregard_inline_limits
= 1;
184 cgraph_mark_reachable_node (node
);
187 /* Define global constructors/destructor functions for the CDTORS, of
188 which they are LEN. The CDTORS are sorted by initialization
189 priority. If CTOR_P is true, these are constructors; otherwise,
190 they are destructors. */
193 build_cdtor (bool ctor_p
, tree
*cdtors
, size_t len
)
202 priority_type priority
;
206 /* Find the next batch of constructors/destructors with the same
207 initialization priority. */
212 p
= ctor_p
? DECL_INIT_PRIORITY (fn
) : DECL_FINI_PRIORITY (fn
);
215 else if (p
!= priority
)
217 append_to_statement_list (build_function_call_expr (UNKNOWN_LOCATION
,
223 gcc_assert (body
!= NULL_TREE
);
224 /* Generate a function to call all the function of like
226 cgraph_build_static_cdtor (ctor_p
? 'I' : 'D', body
, priority
);
230 /* Comparison function for qsort. P1 and P2 are actually of type
231 "tree *" and point to static constructors. DECL_INIT_PRIORITY is
232 used to determine the sort order. */
235 compare_ctor (const void *p1
, const void *p2
)
242 f1
= *(const tree
*)p1
;
243 f2
= *(const tree
*)p2
;
244 priority1
= DECL_INIT_PRIORITY (f1
);
245 priority2
= DECL_INIT_PRIORITY (f2
);
247 if (priority1
< priority2
)
249 else if (priority1
> priority2
)
252 /* Ensure a stable sort. */
253 return (const tree
*)p1
- (const tree
*)p2
;
256 /* Comparison function for qsort. P1 and P2 are actually of type
257 "tree *" and point to static destructors. DECL_FINI_PRIORITY is
258 used to determine the sort order. */
261 compare_dtor (const void *p1
, const void *p2
)
268 f1
= *(const tree
*)p1
;
269 f2
= *(const tree
*)p2
;
270 priority1
= DECL_FINI_PRIORITY (f1
);
271 priority2
= DECL_FINI_PRIORITY (f2
);
273 if (priority1
< priority2
)
275 else if (priority1
> priority2
)
278 /* Ensure a stable sort. */
279 return (const tree
*)p1
- (const tree
*)p2
;
282 /* Generate functions to call static constructors and destructors
283 for targets that do not support .ctors/.dtors sections. These
284 functions have magic names which are detected by collect2. */
287 cgraph_build_cdtor_fns (void)
289 if (!VEC_empty (tree
, static_ctors
))
291 gcc_assert (!targetm
.have_ctors_dtors
);
292 qsort (VEC_address (tree
, static_ctors
),
293 VEC_length (tree
, static_ctors
),
296 build_cdtor (/*ctor_p=*/true,
297 VEC_address (tree
, static_ctors
),
298 VEC_length (tree
, static_ctors
));
299 VEC_truncate (tree
, static_ctors
, 0);
302 if (!VEC_empty (tree
, static_dtors
))
304 gcc_assert (!targetm
.have_ctors_dtors
);
305 qsort (VEC_address (tree
, static_dtors
),
306 VEC_length (tree
, static_dtors
),
309 build_cdtor (/*ctor_p=*/false,
310 VEC_address (tree
, static_dtors
),
311 VEC_length (tree
, static_dtors
));
312 VEC_truncate (tree
, static_dtors
, 0);
316 /* Determine if function DECL is needed. That is, visible to something
317 either outside this translation unit, something magic in the system
321 cgraph_decide_is_function_needed (struct cgraph_node
*node
, tree decl
)
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
363 && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
))
366 /* Constructors and destructors are reachable from the runtime by
368 if (DECL_STATIC_CONSTRUCTOR (decl
) || DECL_STATIC_DESTRUCTOR (decl
))
374 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
375 functions into callgraph in a way so they look like ordinary reachable
376 functions inserted into callgraph already at construction time. */
379 cgraph_process_new_functions (void)
383 struct cgraph_node
*node
;
385 /* Note that this queue may grow as its being processed, as the new
386 functions may generate new ones. */
387 while (cgraph_new_nodes
)
389 node
= cgraph_new_nodes
;
391 cgraph_new_nodes
= cgraph_new_nodes
->next_needed
;
392 switch (cgraph_state
)
394 case CGRAPH_STATE_CONSTRUCTION
:
395 /* At construction time we just need to finalize function and move
396 it into reachable functions list. */
398 node
->next_needed
= NULL
;
399 cgraph_finalize_function (fndecl
, false);
400 cgraph_mark_reachable_node (node
);
404 case CGRAPH_STATE_IPA
:
405 case CGRAPH_STATE_IPA_SSA
:
406 /* When IPA optimization already started, do all essential
407 transformations that has been already performed on the whole
408 cgraph but not on this function. */
410 gimple_register_cfg_hooks ();
412 cgraph_analyze_function (node
);
413 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
414 current_function_decl
= fndecl
;
415 compute_inline_parameters (node
);
416 if ((cgraph_state
== CGRAPH_STATE_IPA_SSA
417 && !gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
418 /* When not optimizing, be sure we run early local passes anyway
421 execute_pass_list (pass_early_local_passes
.pass
.sub
);
422 free_dominance_info (CDI_POST_DOMINATORS
);
423 free_dominance_info (CDI_DOMINATORS
);
425 current_function_decl
= NULL
;
428 case CGRAPH_STATE_EXPANSION
:
429 /* Functions created during expansion shall be compiled
432 cgraph_expand_function (node
);
439 cgraph_call_function_insertion_hooks (node
);
444 /* As an GCC extension we allow redefinition of the function. The
445 semantics when both copies of bodies differ is not well defined.
446 We replace the old body with new body so in unit at a time mode
447 we always use new body, while in normal mode we may end up with
448 old body inlined into some functions and new body expanded and
451 ??? It may make more sense to use one body for inlining and other
452 body for expanding the function but this is difficult to do. */
455 cgraph_reset_node (struct cgraph_node
*node
)
457 /* If node->process is set, then we have already begun whole-unit analysis.
458 This is *not* testing for whether we've already emitted the function.
459 That case can be sort-of legitimately seen with real function redefinition
460 errors. I would argue that the front end should never present us with
461 such a case, but don't enforce that for now. */
462 gcc_assert (!node
->process
);
464 /* Reset our data structures so we can analyze the function again. */
465 memset (&node
->local
, 0, sizeof (node
->local
));
466 memset (&node
->global
, 0, sizeof (node
->global
));
467 memset (&node
->rtl
, 0, sizeof (node
->rtl
));
468 node
->analyzed
= false;
469 node
->local
.redefined_extern_inline
= true;
470 node
->local
.finalized
= false;
472 cgraph_node_remove_callees (node
);
474 /* We may need to re-queue the node for assembling in case
475 we already proceeded it and ignored as not needed or got
476 a re-declaration in IMA mode. */
479 struct cgraph_node
*n
;
481 for (n
= cgraph_nodes_queue
; n
; n
= n
->next_needed
)
490 cgraph_lower_function (struct cgraph_node
*node
)
496 lower_nested_functions (node
->decl
);
497 gcc_assert (!node
->nested
);
499 tree_lowering_passes (node
->decl
);
500 node
->lowered
= true;
503 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
504 logic in effect. If NESTED is true, then our caller cannot stand to have
505 the garbage collector run at the moment. We would need to either create
506 a new GC context, or just not compile right now. */
509 cgraph_finalize_function (tree decl
, bool nested
)
511 struct cgraph_node
*node
= cgraph_node (decl
);
513 if (node
->local
.finalized
)
514 cgraph_reset_node (node
);
516 node
->pid
= cgraph_max_pid
++;
517 notice_global_symbol (decl
);
518 node
->local
.finalized
= true;
519 node
->lowered
= DECL_STRUCT_FUNCTION (decl
)->cfg
!= NULL
;
520 node
->finalized_by_frontend
= true;
521 record_cdtor_fn (node
->decl
);
523 if (cgraph_decide_is_function_needed (node
, decl
))
524 cgraph_mark_needed_node (node
);
526 /* Since we reclaim unreachable nodes at the end of every language
527 level unit, we need to be conservative about possible entry points
529 if ((TREE_PUBLIC (decl
) && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
)))
530 cgraph_mark_reachable_node (node
);
532 /* If we've not yet emitted decl, tell the debug info about it. */
533 if (!TREE_ASM_WRITTEN (decl
))
534 (*debug_hooks
->deferred_inline_function
) (decl
);
536 /* Possibly warn about unused parameters. */
537 if (warn_unused_parameter
)
538 do_warn_unused_parameter (decl
);
544 /* C99 extern inline keywords allow changing of declaration after function
545 has been finalized. We need to re-decide if we want to mark the function as
549 cgraph_mark_if_needed (tree decl
)
551 struct cgraph_node
*node
= cgraph_node (decl
);
552 if (node
->local
.finalized
&& cgraph_decide_is_function_needed (node
, decl
))
553 cgraph_mark_needed_node (node
);
556 /* Return TRUE if NODE2 is equivalent to NODE or its clone. */
558 clone_of_p (struct cgraph_node
*node
, struct cgraph_node
*node2
)
560 while (node
!= node2
&& node2
)
561 node2
= node2
->clone_of
;
562 return node2
!= NULL
;
565 /* Verify cgraph nodes of given cgraph node. */
567 verify_cgraph_node (struct cgraph_node
*node
)
569 struct cgraph_edge
*e
;
570 struct function
*this_cfun
= DECL_STRUCT_FUNCTION (node
->decl
);
571 struct function
*saved_cfun
= cfun
;
572 basic_block this_block
;
573 gimple_stmt_iterator gsi
;
574 bool error_found
= false;
576 if (errorcount
|| sorrycount
)
579 timevar_push (TV_CGRAPH_VERIFY
);
580 /* debug_generic_stmt needs correct cfun */
581 set_cfun (this_cfun
);
582 for (e
= node
->callees
; e
; e
= e
->next_callee
)
585 error ("aux field set for edge %s->%s",
586 identifier_to_locale (cgraph_node_name (e
->caller
)),
587 identifier_to_locale (cgraph_node_name (e
->callee
)));
592 error ("Execution count is negative");
595 if (node
->global
.inlined_to
&& node
->local
.externally_visible
)
597 error ("Externally visible inline clone");
600 if (node
->global
.inlined_to
&& node
->address_taken
)
602 error ("Inline clone with address taken");
605 if (node
->global
.inlined_to
&& node
->needed
)
607 error ("Inline clone is needed");
610 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
614 error ("aux field set for indirect edge from %s",
615 identifier_to_locale (cgraph_node_name (e
->caller
)));
618 if (!e
->indirect_unknown_callee
619 || !e
->indirect_info
)
621 error ("An indirect edge from %s is not marked as indirect or has "
622 "associated indirect_info, the corresponding statement is: ",
623 identifier_to_locale (cgraph_node_name (e
->caller
)));
624 debug_gimple_stmt (e
->call_stmt
);
628 for (e
= node
->callers
; e
; e
= e
->next_caller
)
632 error ("caller edge count is negative");
635 if (e
->frequency
< 0)
637 error ("caller edge frequency is negative");
640 if (e
->frequency
> CGRAPH_FREQ_MAX
)
642 error ("caller edge frequency is too large");
645 if (gimple_has_body_p (e
->caller
->decl
)
646 && !e
->caller
->global
.inlined_to
648 != compute_call_stmt_bb_frequency (e
->caller
->decl
,
649 gimple_bb (e
->call_stmt
))))
651 error ("caller edge frequency %i does not match BB freqency %i",
653 compute_call_stmt_bb_frequency (e
->caller
->decl
,
654 gimple_bb (e
->call_stmt
)));
657 if (!e
->inline_failed
)
659 if (node
->global
.inlined_to
660 != (e
->caller
->global
.inlined_to
661 ? e
->caller
->global
.inlined_to
: e
->caller
))
663 error ("inlined_to pointer is wrong");
666 if (node
->callers
->next_caller
)
668 error ("multiple inline callers");
673 if (node
->global
.inlined_to
)
675 error ("inlined_to pointer set for noninline callers");
679 if (!node
->callers
&& node
->global
.inlined_to
)
681 error ("inlined_to pointer is set but no predecessors found");
684 if (node
->global
.inlined_to
== node
)
686 error ("inlined_to pointer refers to itself");
690 if (!cgraph_node (node
->decl
))
692 error ("node not found in cgraph_hash");
698 struct cgraph_node
*n
;
699 for (n
= node
->clone_of
->clones
; n
; n
= n
->next_sibling_clone
)
704 error ("node has wrong clone_of");
710 struct cgraph_node
*n
;
711 for (n
= node
->clones
; n
; n
= n
->next_sibling_clone
)
712 if (n
->clone_of
!= node
)
716 error ("node has wrong clone list");
720 if ((node
->prev_sibling_clone
|| node
->next_sibling_clone
) && !node
->clone_of
)
722 error ("node is in clone list but it is not clone");
725 if (!node
->prev_sibling_clone
&& node
->clone_of
&& node
->clone_of
->clones
!= node
)
727 error ("node has wrong prev_clone pointer");
730 if (node
->prev_sibling_clone
&& node
->prev_sibling_clone
->next_sibling_clone
!= node
)
732 error ("double linked list of clones corrupted");
735 if (node
->same_comdat_group
)
737 struct cgraph_node
*n
= node
->same_comdat_group
;
739 if (!DECL_ONE_ONLY (node
->decl
))
741 error ("non-DECL_ONE_ONLY node in a same_comdat_group list");
746 error ("node is alone in a comdat group");
751 if (!n
->same_comdat_group
)
753 error ("same_comdat_group is not a circular list");
757 n
= n
->same_comdat_group
;
762 if (node
->analyzed
&& gimple_has_body_p (node
->decl
)
763 && !TREE_ASM_WRITTEN (node
->decl
)
764 && (!DECL_EXTERNAL (node
->decl
) || node
->global
.inlined_to
)
769 /* The nodes we're interested in are never shared, so walk
770 the tree ignoring duplicates. */
771 struct pointer_set_t
*visited_nodes
= pointer_set_create ();
772 /* Reach the trees by walking over the CFG, and note the
773 enclosing basic-blocks in the call edges. */
774 FOR_EACH_BB_FN (this_block
, this_cfun
)
775 for (gsi
= gsi_start_bb (this_block
);
779 gimple stmt
= gsi_stmt (gsi
);
780 if (is_gimple_call (stmt
))
782 struct cgraph_edge
*e
= cgraph_edge (node
, stmt
);
783 tree decl
= gimple_call_fndecl (stmt
);
788 error ("shared call_stmt:");
789 debug_gimple_stmt (stmt
);
792 if (!e
->indirect_unknown_callee
)
794 if (e
->callee
->same_body_alias
)
796 error ("edge points to same body alias:");
797 debug_tree (e
->callee
->decl
);
800 else if (!node
->global
.inlined_to
801 && !e
->callee
->global
.inlined_to
803 && !clone_of_p (cgraph_node (decl
),
806 error ("edge points to wrong declaration:");
807 debug_tree (e
->callee
->decl
);
808 fprintf (stderr
," Instead of:");
815 error ("an indirect edge with unknown callee "
816 "corresponding to a call_stmt with "
817 "a known declaration:");
819 debug_gimple_stmt (e
->call_stmt
);
825 error ("missing callgraph edge for call stmt:");
826 debug_gimple_stmt (stmt
);
831 pointer_set_destroy (visited_nodes
);
834 /* No CFG available?! */
837 for (e
= node
->callees
; e
; e
= e
->next_callee
)
841 error ("edge %s->%s has no corresponding call_stmt",
842 identifier_to_locale (cgraph_node_name (e
->caller
)),
843 identifier_to_locale (cgraph_node_name (e
->callee
)));
844 debug_gimple_stmt (e
->call_stmt
);
849 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
853 error ("an indirect edge from %s has no corresponding call_stmt",
854 identifier_to_locale (cgraph_node_name (e
->caller
)));
855 debug_gimple_stmt (e
->call_stmt
);
863 dump_cgraph_node (stderr
, node
);
864 internal_error ("verify_cgraph_node failed");
866 set_cfun (saved_cfun
);
867 timevar_pop (TV_CGRAPH_VERIFY
);
870 /* Verify whole cgraph structure. */
874 struct cgraph_node
*node
;
876 if (sorrycount
|| errorcount
)
879 for (node
= cgraph_nodes
; node
; node
= node
->next
)
880 verify_cgraph_node (node
);
883 /* Output all asm statements we have stored up to be output. */
886 cgraph_output_pending_asms (void)
888 struct cgraph_asm_node
*can
;
890 if (errorcount
|| sorrycount
)
893 for (can
= cgraph_asm_nodes
; can
; can
= can
->next
)
894 assemble_asm (can
->asm_str
);
895 cgraph_asm_nodes
= NULL
;
898 /* Analyze the function scheduled to be output. */
900 cgraph_analyze_function (struct cgraph_node
*node
)
902 tree save
= current_function_decl
;
903 tree decl
= node
->decl
;
905 current_function_decl
= decl
;
906 push_cfun (DECL_STRUCT_FUNCTION (decl
));
908 assign_assembler_name_if_neeeded (node
->decl
);
910 /* Make sure to gimplify bodies only once. During analyzing a
911 function we lower it, which will require gimplified nested
912 functions, so we can end up here with an already gimplified
914 if (!gimple_body (decl
))
915 gimplify_function_tree (decl
);
916 dump_function (TDI_generic
, decl
);
918 cgraph_lower_function (node
);
919 node
->analyzed
= true;
922 current_function_decl
= save
;
925 /* Look for externally_visible and used attributes and mark cgraph nodes
928 We cannot mark the nodes at the point the attributes are processed (in
929 handle_*_attribute) because the copy of the declarations available at that
930 point may not be canonical. For example, in:
933 void f() __attribute__((used));
935 the declaration we see in handle_used_attribute will be the second
936 declaration -- but the front end will subsequently merge that declaration
937 with the original declaration and discard the second declaration.
939 Furthermore, we can't mark these nodes in cgraph_finalize_function because:
942 void f() __attribute__((externally_visible));
946 So, we walk the nodes at the end of the translation unit, applying the
947 attributes at that point. */
950 process_function_and_variable_attributes (struct cgraph_node
*first
,
951 struct varpool_node
*first_var
)
953 struct cgraph_node
*node
;
954 struct varpool_node
*vnode
;
956 for (node
= cgraph_nodes
; node
!= first
; node
= node
->next
)
958 tree decl
= node
->decl
;
959 if (DECL_PRESERVE_P (decl
))
961 mark_decl_referenced (decl
);
962 if (node
->local
.finalized
)
963 cgraph_mark_needed_node (node
);
965 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
967 if (! TREE_PUBLIC (node
->decl
))
968 warning_at (DECL_SOURCE_LOCATION (node
->decl
), OPT_Wattributes
,
969 "%<externally_visible%>"
970 " attribute have effect only on public objects");
971 else if (node
->local
.finalized
)
972 cgraph_mark_needed_node (node
);
975 for (vnode
= varpool_nodes
; vnode
!= first_var
; vnode
= vnode
->next
)
977 tree decl
= vnode
->decl
;
978 if (DECL_PRESERVE_P (decl
))
980 mark_decl_referenced (decl
);
981 vnode
->force_output
= true;
982 if (vnode
->finalized
)
983 varpool_mark_needed_node (vnode
);
985 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
987 if (! TREE_PUBLIC (vnode
->decl
))
988 warning_at (DECL_SOURCE_LOCATION (vnode
->decl
), OPT_Wattributes
,
989 "%<externally_visible%>"
990 " attribute have effect only on public objects");
991 else if (vnode
->finalized
)
992 varpool_mark_needed_node (vnode
);
997 /* Process CGRAPH_NODES_NEEDED queue, analyze each function (and transitively
998 each reachable functions) and build cgraph.
999 The function can be called multiple times after inserting new nodes
1000 into beginning of queue. Just the new part of queue is re-scanned then. */
1003 cgraph_analyze_functions (void)
1005 /* Keep track of already processed nodes when called multiple times for
1006 intermodule optimization. */
1007 static struct cgraph_node
*first_analyzed
;
1008 struct cgraph_node
*first_processed
= first_analyzed
;
1009 static struct varpool_node
*first_analyzed_var
;
1010 struct cgraph_node
*node
, *next
;
1012 process_function_and_variable_attributes (first_processed
,
1013 first_analyzed_var
);
1014 first_processed
= cgraph_nodes
;
1015 first_analyzed_var
= varpool_nodes
;
1016 varpool_analyze_pending_decls ();
1017 if (cgraph_dump_file
)
1019 fprintf (cgraph_dump_file
, "Initial entry points:");
1020 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
1022 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1023 fprintf (cgraph_dump_file
, "\n");
1025 cgraph_process_new_functions ();
1027 /* Propagate reachability flag and lower representation of all reachable
1028 functions. In the future, lowering will introduce new functions and
1029 new entry points on the way (by template instantiation and virtual
1030 method table generation for instance). */
1031 while (cgraph_nodes_queue
)
1033 struct cgraph_edge
*edge
;
1034 tree decl
= cgraph_nodes_queue
->decl
;
1036 node
= cgraph_nodes_queue
;
1037 cgraph_nodes_queue
= cgraph_nodes_queue
->next_needed
;
1038 node
->next_needed
= NULL
;
1040 /* ??? It is possible to create extern inline function and later using
1041 weak alias attribute to kill its body. See
1042 gcc.c-torture/compile/20011119-1.c */
1043 if (!DECL_STRUCT_FUNCTION (decl
))
1045 cgraph_reset_node (node
);
1049 if (!node
->analyzed
)
1050 cgraph_analyze_function (node
);
1052 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
1053 if (!edge
->callee
->reachable
)
1054 cgraph_mark_reachable_node (edge
->callee
);
1056 if (node
->same_comdat_group
)
1058 for (next
= node
->same_comdat_group
;
1060 next
= next
->same_comdat_group
)
1061 cgraph_mark_reachable_node (next
);
1064 /* If decl is a clone of an abstract function, mark that abstract
1065 function so that we don't release its body. The DECL_INITIAL() of that
1066 abstract function declaration will be later needed to output debug info. */
1067 if (DECL_ABSTRACT_ORIGIN (decl
))
1069 struct cgraph_node
*origin_node
= cgraph_node (DECL_ABSTRACT_ORIGIN (decl
));
1070 origin_node
->abstract_and_needed
= true;
1073 /* We finalize local static variables during constructing callgraph
1074 edges. Process their attributes too. */
1075 process_function_and_variable_attributes (first_processed
,
1076 first_analyzed_var
);
1077 first_processed
= cgraph_nodes
;
1078 first_analyzed_var
= varpool_nodes
;
1079 varpool_analyze_pending_decls ();
1080 cgraph_process_new_functions ();
1083 /* Collect entry points to the unit. */
1084 if (cgraph_dump_file
)
1086 fprintf (cgraph_dump_file
, "Unit entry points:");
1087 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
1089 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1090 fprintf (cgraph_dump_file
, "\n\nInitial ");
1091 dump_cgraph (cgraph_dump_file
);
1094 if (cgraph_dump_file
)
1095 fprintf (cgraph_dump_file
, "\nReclaiming functions:");
1097 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= next
)
1099 tree decl
= node
->decl
;
1102 if (node
->local
.finalized
&& !gimple_has_body_p (decl
))
1103 cgraph_reset_node (node
);
1105 if (!node
->reachable
&& gimple_has_body_p (decl
))
1107 if (cgraph_dump_file
)
1108 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1109 cgraph_remove_node (node
);
1113 node
->next_needed
= NULL
;
1114 gcc_assert (!node
->local
.finalized
|| gimple_has_body_p (decl
));
1115 gcc_assert (node
->analyzed
== node
->local
.finalized
);
1117 if (cgraph_dump_file
)
1119 fprintf (cgraph_dump_file
, "\n\nReclaimed ");
1120 dump_cgraph (cgraph_dump_file
);
1122 first_analyzed
= cgraph_nodes
;
1127 /* Analyze the whole compilation unit once it is parsed completely. */
1130 cgraph_finalize_compilation_unit (void)
1132 timevar_push (TV_CGRAPH
);
1134 /* Do not skip analyzing the functions if there were errors, we
1135 miss diagnostics for following functions otherwise. */
1137 /* Emit size functions we didn't inline. */
1138 finalize_size_functions ();
1140 /* Call functions declared with the "constructor" or "destructor"
1142 cgraph_build_cdtor_fns ();
1144 /* Mark alias targets necessary and emit diagnostics. */
1145 finish_aliases_1 ();
1149 fprintf (stderr
, "\nAnalyzing compilation unit\n");
1153 /* Gimplify and lower all functions, compute reachability and
1154 remove unreachable nodes. */
1155 cgraph_analyze_functions ();
1157 /* Mark alias targets necessary and emit diagnostics. */
1158 finish_aliases_1 ();
1160 /* Gimplify and lower thunks. */
1161 cgraph_analyze_functions ();
1163 /* Finally drive the pass manager. */
1166 timevar_pop (TV_CGRAPH
);
1170 /* Figure out what functions we want to assemble. */
1173 cgraph_mark_functions_to_output (void)
1175 struct cgraph_node
*node
;
1176 #ifdef ENABLE_CHECKING
1177 bool check_same_comdat_groups
= false;
1179 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1180 gcc_assert (!node
->process
);
1183 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1185 tree decl
= node
->decl
;
1186 struct cgraph_edge
*e
;
1188 gcc_assert (!node
->process
|| node
->same_comdat_group
);
1192 for (e
= node
->callers
; e
; e
= e
->next_caller
)
1193 if (e
->inline_failed
)
1196 /* We need to output all local functions that are used and not
1197 always inlined, as well as those that are reachable from
1198 outside the current compilation unit. */
1200 && !node
->global
.inlined_to
1201 && (node
->needed
|| node
->reachable_from_other_partition
1202 || (e
&& node
->reachable
))
1203 && !TREE_ASM_WRITTEN (decl
)
1204 && !DECL_EXTERNAL (decl
))
1207 if (node
->same_comdat_group
)
1209 struct cgraph_node
*next
;
1210 for (next
= node
->same_comdat_group
;
1212 next
= next
->same_comdat_group
)
1216 else if (node
->same_comdat_group
)
1218 #ifdef ENABLE_CHECKING
1219 check_same_comdat_groups
= true;
1224 /* We should've reclaimed all functions that are not needed. */
1225 #ifdef ENABLE_CHECKING
1226 if (!node
->global
.inlined_to
1227 && gimple_has_body_p (decl
)
1228 /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
1229 are inside partition, we can end up not removing the body since we no longer
1230 have analyzed node pointing to it. */
1231 && !node
->in_other_partition
1232 && !DECL_EXTERNAL (decl
))
1234 dump_cgraph_node (stderr
, node
);
1235 internal_error ("failed to reclaim unneeded function");
1238 gcc_assert (node
->global
.inlined_to
1239 || !gimple_has_body_p (decl
)
1240 || node
->in_other_partition
1241 || DECL_EXTERNAL (decl
));
1246 #ifdef ENABLE_CHECKING
1247 if (check_same_comdat_groups
)
1248 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1249 if (node
->same_comdat_group
&& !node
->process
)
1251 tree decl
= node
->decl
;
1252 if (!node
->global
.inlined_to
1253 && gimple_has_body_p (decl
)
1254 /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
1255 are inside partition, we can end up not removing the body since we no longer
1256 have analyzed node pointing to it. */
1257 && !node
->in_other_partition
1258 && !DECL_EXTERNAL (decl
))
1260 dump_cgraph_node (stderr
, node
);
1261 internal_error ("failed to reclaim unneeded function");
1267 /* DECL is FUNCTION_DECL. Initialize datastructures so DECL is a function
1268 in lowered gimple form.
1270 Set current_function_decl and cfun to newly constructed empty function body.
1271 return basic block in the function body. */
1274 init_lowered_empty_function (tree decl
)
1278 current_function_decl
= decl
;
1279 allocate_struct_function (decl
, false);
1280 gimple_register_cfg_hooks ();
1281 init_empty_tree_cfg ();
1282 init_tree_ssa (cfun
);
1283 init_ssa_operands ();
1284 cfun
->gimple_df
->in_ssa_p
= true;
1285 DECL_INITIAL (decl
) = make_node (BLOCK
);
1287 DECL_SAVED_TREE (decl
) = error_mark_node
;
1288 cfun
->curr_properties
|=
1289 (PROP_gimple_lcf
| PROP_gimple_leh
| PROP_cfg
| PROP_referenced_vars
|
1292 /* Create BB for body of the function and connect it properly. */
1293 bb
= create_basic_block (NULL
, (void *) 0, ENTRY_BLOCK_PTR
);
1294 make_edge (ENTRY_BLOCK_PTR
, bb
, 0);
1295 make_edge (bb
, EXIT_BLOCK_PTR
, 0);
1300 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
1301 offset indicated by VIRTUAL_OFFSET, if that is
1302 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
1303 zero for a result adjusting thunk. */
1306 thunk_adjust (gimple_stmt_iterator
* bsi
,
1307 tree ptr
, bool this_adjusting
,
1308 HOST_WIDE_INT fixed_offset
, tree virtual_offset
)
1314 && fixed_offset
!= 0)
1316 stmt
= gimple_build_assign (ptr
,
1317 fold_build2_loc (input_location
,
1319 TREE_TYPE (ptr
), ptr
,
1320 size_int (fixed_offset
)));
1321 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1324 /* If there's a virtual offset, look up that value in the vtable and
1325 adjust the pointer again. */
1333 if (!vtable_entry_type
)
1335 tree vfunc_type
= make_node (FUNCTION_TYPE
);
1336 TREE_TYPE (vfunc_type
) = integer_type_node
;
1337 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
1338 layout_type (vfunc_type
);
1340 vtable_entry_type
= build_pointer_type (vfunc_type
);
1344 create_tmp_var (build_pointer_type
1345 (build_pointer_type (vtable_entry_type
)), "vptr");
1347 /* The vptr is always at offset zero in the object. */
1348 stmt
= gimple_build_assign (vtabletmp
,
1349 build1 (NOP_EXPR
, TREE_TYPE (vtabletmp
),
1351 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1352 mark_symbols_for_renaming (stmt
);
1353 find_referenced_vars_in (stmt
);
1355 /* Form the vtable address. */
1356 vtabletmp2
= create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp
)),
1358 stmt
= gimple_build_assign (vtabletmp2
,
1359 build1 (INDIRECT_REF
,
1360 TREE_TYPE (vtabletmp2
), vtabletmp
));
1361 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1362 mark_symbols_for_renaming (stmt
);
1363 find_referenced_vars_in (stmt
);
1365 /* Find the entry with the vcall offset. */
1366 stmt
= gimple_build_assign (vtabletmp2
,
1367 fold_build2_loc (input_location
,
1369 TREE_TYPE (vtabletmp2
),
1371 fold_convert (sizetype
,
1373 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1375 /* Get the offset itself. */
1376 vtabletmp3
= create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp2
)),
1378 stmt
= gimple_build_assign (vtabletmp3
,
1379 build1 (INDIRECT_REF
,
1380 TREE_TYPE (vtabletmp3
),
1382 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1383 mark_symbols_for_renaming (stmt
);
1384 find_referenced_vars_in (stmt
);
1386 /* Cast to sizetype. */
1387 offsettmp
= create_tmp_var (sizetype
, "offset");
1388 stmt
= gimple_build_assign (offsettmp
, fold_convert (sizetype
, vtabletmp3
));
1389 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1390 mark_symbols_for_renaming (stmt
);
1391 find_referenced_vars_in (stmt
);
1393 /* Adjust the `this' pointer. */
1394 ptr
= fold_build2_loc (input_location
,
1395 POINTER_PLUS_EXPR
, TREE_TYPE (ptr
), ptr
,
1400 && fixed_offset
!= 0)
1401 /* Adjust the pointer by the constant. */
1405 if (TREE_CODE (ptr
) == VAR_DECL
)
1409 ptrtmp
= create_tmp_var (TREE_TYPE (ptr
), "ptr");
1410 stmt
= gimple_build_assign (ptrtmp
, ptr
);
1411 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1412 mark_symbols_for_renaming (stmt
);
1413 find_referenced_vars_in (stmt
);
1415 ptr
= fold_build2_loc (input_location
,
1416 POINTER_PLUS_EXPR
, TREE_TYPE (ptrtmp
), ptrtmp
,
1417 size_int (fixed_offset
));
1420 /* Emit the statement and gimplify the adjustment expression. */
1421 ret
= create_tmp_var (TREE_TYPE (ptr
), "adjusted_this");
1422 stmt
= gimple_build_assign (ret
, ptr
);
1423 mark_symbols_for_renaming (stmt
);
1424 find_referenced_vars_in (stmt
);
1425 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1430 /* Produce assembler for thunk NODE. */
1433 assemble_thunk (struct cgraph_node
*node
)
1435 bool this_adjusting
= node
->thunk
.this_adjusting
;
1436 HOST_WIDE_INT fixed_offset
= node
->thunk
.fixed_offset
;
1437 HOST_WIDE_INT virtual_value
= node
->thunk
.virtual_value
;
1438 tree virtual_offset
= NULL
;
1439 tree alias
= node
->thunk
.alias
;
1440 tree thunk_fndecl
= node
->decl
;
1441 tree a
= DECL_ARGUMENTS (thunk_fndecl
);
1443 current_function_decl
= thunk_fndecl
;
1446 && targetm
.asm_out
.can_output_mi_thunk (thunk_fndecl
, fixed_offset
,
1447 virtual_value
, alias
))
1452 DECL_RESULT (thunk_fndecl
)
1453 = build_decl (DECL_SOURCE_LOCATION (thunk_fndecl
),
1454 RESULT_DECL
, 0, integer_type_node
);
1455 fnname
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk_fndecl
));
1457 /* The back end expects DECL_INITIAL to contain a BLOCK, so we
1459 fn_block
= make_node (BLOCK
);
1460 BLOCK_VARS (fn_block
) = a
;
1461 DECL_INITIAL (thunk_fndecl
) = fn_block
;
1462 init_function_start (thunk_fndecl
);
1464 assemble_start_function (thunk_fndecl
, fnname
);
1466 targetm
.asm_out
.output_mi_thunk (asm_out_file
, thunk_fndecl
,
1467 fixed_offset
, virtual_value
, alias
);
1469 assemble_end_function (thunk_fndecl
, fnname
);
1470 init_insn_lengths ();
1471 free_after_compilation (cfun
);
1473 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
1478 basic_block bb
, then_bb
, else_bb
, return_bb
;
1479 gimple_stmt_iterator bsi
;
1485 VEC(tree
, heap
) *vargs
;
1490 DECL_IGNORED_P (thunk_fndecl
) = 1;
1491 bitmap_obstack_initialize (NULL
);
1493 if (node
->thunk
.virtual_offset_p
)
1494 virtual_offset
= size_int (virtual_value
);
1496 /* Build the return declaration for the function. */
1497 restype
= TREE_TYPE (TREE_TYPE (thunk_fndecl
));
1498 if (DECL_RESULT (thunk_fndecl
) == NULL_TREE
)
1500 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
1501 DECL_ARTIFICIAL (resdecl
) = 1;
1502 DECL_IGNORED_P (resdecl
) = 1;
1503 DECL_RESULT (thunk_fndecl
) = resdecl
;
1506 resdecl
= DECL_RESULT (thunk_fndecl
);
1508 bb
= then_bb
= else_bb
= return_bb
= init_lowered_empty_function (thunk_fndecl
);
1510 bsi
= gsi_start_bb (bb
);
1512 /* Build call to the function being thunked. */
1513 if (!VOID_TYPE_P (restype
))
1515 if (!is_gimple_reg_type (restype
))
1518 cfun
->local_decls
= tree_cons (NULL_TREE
, restmp
, cfun
->local_decls
);
1519 BLOCK_VARS (DECL_INITIAL (current_function_decl
)) = restmp
;
1522 restmp
= create_tmp_var_raw (restype
, "retval");
1525 for (arg
= a
; arg
; arg
= TREE_CHAIN (arg
))
1527 vargs
= VEC_alloc (tree
, heap
, nargs
);
1529 VEC_quick_push (tree
, vargs
,
1534 VEC_quick_push (tree
, vargs
, a
);
1535 for (i
= 1, arg
= TREE_CHAIN (a
); i
< nargs
; i
++, arg
= TREE_CHAIN (arg
))
1536 VEC_quick_push (tree
, vargs
, arg
);
1537 call
= gimple_build_call_vec (build_fold_addr_expr_loc (0, alias
), vargs
);
1538 VEC_free (tree
, heap
, vargs
);
1539 gimple_call_set_cannot_inline (call
, true);
1540 gimple_call_set_from_thunk (call
, true);
1542 gimple_call_set_lhs (call
, restmp
);
1543 gsi_insert_after (&bsi
, call
, GSI_NEW_STMT
);
1544 mark_symbols_for_renaming (call
);
1545 find_referenced_vars_in (call
);
1548 if (restmp
&& !this_adjusting
)
1550 tree true_label
= NULL_TREE
;
1552 if (TREE_CODE (TREE_TYPE (restmp
)) == POINTER_TYPE
)
1555 /* If the return type is a pointer, we need to
1556 protect against NULL. We know there will be an
1557 adjustment, because that's why we're emitting a
1559 then_bb
= create_basic_block (NULL
, (void *) 0, bb
);
1560 return_bb
= create_basic_block (NULL
, (void *) 0, then_bb
);
1561 else_bb
= create_basic_block (NULL
, (void *) 0, else_bb
);
1562 remove_edge (single_succ_edge (bb
));
1563 true_label
= gimple_block_label (then_bb
);
1564 stmt
= gimple_build_cond (NE_EXPR
, restmp
,
1565 fold_convert (TREE_TYPE (restmp
),
1567 NULL_TREE
, NULL_TREE
);
1568 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1569 make_edge (bb
, then_bb
, EDGE_TRUE_VALUE
);
1570 make_edge (bb
, else_bb
, EDGE_FALSE_VALUE
);
1571 make_edge (return_bb
, EXIT_BLOCK_PTR
, 0);
1572 make_edge (then_bb
, return_bb
, EDGE_FALLTHRU
);
1573 make_edge (else_bb
, return_bb
, EDGE_FALLTHRU
);
1574 bsi
= gsi_last_bb (then_bb
);
1577 restmp
= thunk_adjust (&bsi
, restmp
, /*this_adjusting=*/0,
1578 fixed_offset
, virtual_offset
);
1582 bsi
= gsi_last_bb (else_bb
);
1583 stmt
= gimple_build_assign (restmp
, fold_convert (TREE_TYPE (restmp
),
1584 integer_zero_node
));
1585 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1586 bsi
= gsi_last_bb (return_bb
);
1590 gimple_call_set_tail (call
, true);
1592 /* Build return value. */
1593 ret
= gimple_build_return (restmp
);
1594 gsi_insert_after (&bsi
, ret
, GSI_NEW_STMT
);
1596 delete_unreachable_blocks ();
1597 update_ssa (TODO_update_ssa
);
1599 cgraph_remove_same_body_alias (node
);
1600 /* Since we want to emit the thunk, we explicitly mark its name as
1602 mark_decl_referenced (thunk_fndecl
);
1603 cgraph_add_new_function (thunk_fndecl
, true);
1604 bitmap_obstack_release (NULL
);
1606 current_function_decl
= NULL
;
1609 /* Expand function specified by NODE. */
1612 cgraph_expand_function (struct cgraph_node
*node
)
1614 tree decl
= node
->decl
;
1616 /* We ought to not compile any inline clones. */
1617 gcc_assert (!node
->global
.inlined_to
);
1619 announce_function (decl
);
1622 gcc_assert (node
->lowered
);
1624 /* Generate RTL for the body of DECL. */
1625 tree_rest_of_compilation (decl
);
1627 /* Make sure that BE didn't give up on compiling. */
1628 gcc_assert (TREE_ASM_WRITTEN (decl
));
1629 current_function_decl
= NULL
;
1630 if (node
->same_body
)
1632 struct cgraph_node
*alias
, *next
;
1633 bool saved_alias
= node
->alias
;
1634 for (alias
= node
->same_body
;
1635 alias
&& alias
->next
; alias
= alias
->next
)
1637 /* Walk aliases in the order they were created; it is possible that
1638 thunks reffers to the aliases made earlier. */
1639 for (; alias
; alias
= next
)
1641 next
= alias
->previous
;
1642 if (!alias
->thunk
.thunk_p
)
1643 assemble_alias (alias
->decl
,
1644 DECL_ASSEMBLER_NAME (alias
->thunk
.alias
));
1646 assemble_thunk (alias
);
1648 node
->alias
= saved_alias
;
1650 gcc_assert (!cgraph_preserve_function_body_p (decl
));
1651 cgraph_release_function_body (node
);
1652 /* Eliminate all call edges. This is important so the GIMPLE_CALL no longer
1653 points to the dead function body. */
1654 cgraph_node_remove_callees (node
);
1656 cgraph_function_flags_ready
= true;
1659 /* Return true when CALLER_DECL should be inlined into CALLEE_DECL. */
1662 cgraph_inline_p (struct cgraph_edge
*e
, cgraph_inline_failed_t
*reason
)
1664 *reason
= e
->inline_failed
;
1665 return !e
->inline_failed
;
1670 /* Expand all functions that must be output.
1672 Attempt to topologically sort the nodes so function is output when
1673 all called functions are already assembled to allow data to be
1674 propagated across the callgraph. Use a stack to get smaller distance
1675 between a function and its callees (later we may choose to use a more
1676 sophisticated algorithm for function reordering; we will likely want
1677 to use subsections to make the output functions appear in top-down
1681 cgraph_expand_all_functions (void)
1683 struct cgraph_node
*node
;
1684 struct cgraph_node
**order
= XCNEWVEC (struct cgraph_node
*, cgraph_n_nodes
);
1685 int order_pos
, new_order_pos
= 0;
1688 order_pos
= cgraph_postorder (order
);
1689 gcc_assert (order_pos
== cgraph_n_nodes
);
1691 /* Garbage collector may remove inline clones we eliminate during
1692 optimization. So we must be sure to not reference them. */
1693 for (i
= 0; i
< order_pos
; i
++)
1694 if (order
[i
]->process
)
1695 order
[new_order_pos
++] = order
[i
];
1697 for (i
= new_order_pos
- 1; i
>= 0; i
--)
1702 gcc_assert (node
->reachable
);
1704 cgraph_expand_function (node
);
1707 cgraph_process_new_functions ();
1713 /* This is used to sort the node types by the cgraph order number. */
1715 enum cgraph_order_sort_kind
1717 ORDER_UNDEFINED
= 0,
1723 struct cgraph_order_sort
1725 enum cgraph_order_sort_kind kind
;
1728 struct cgraph_node
*f
;
1729 struct varpool_node
*v
;
1730 struct cgraph_asm_node
*a
;
1734 /* Output all functions, variables, and asm statements in the order
1735 according to their order fields, which is the order in which they
1736 appeared in the file. This implements -fno-toplevel-reorder. In
1737 this mode we may output functions and variables which don't really
1738 need to be output. */
1741 cgraph_output_in_order (void)
1744 struct cgraph_order_sort
*nodes
;
1746 struct cgraph_node
*pf
;
1747 struct varpool_node
*pv
;
1748 struct cgraph_asm_node
*pa
;
1751 nodes
= XCNEWVEC (struct cgraph_order_sort
, max
);
1753 varpool_analyze_pending_decls ();
1755 for (pf
= cgraph_nodes
; pf
; pf
= pf
->next
)
1760 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1761 nodes
[i
].kind
= ORDER_FUNCTION
;
1766 for (pv
= varpool_nodes_queue
; pv
; pv
= pv
->next_needed
)
1769 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1770 nodes
[i
].kind
= ORDER_VAR
;
1774 for (pa
= cgraph_asm_nodes
; pa
; pa
= pa
->next
)
1777 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1778 nodes
[i
].kind
= ORDER_ASM
;
1782 /* In toplevel reorder mode we output all statics; mark them as needed. */
1783 for (i
= 0; i
< max
; ++i
)
1785 if (nodes
[i
].kind
== ORDER_VAR
)
1787 varpool_mark_needed_node (nodes
[i
].u
.v
);
1790 varpool_empty_needed_queue ();
1792 for (i
= 0; i
< max
; ++i
)
1794 switch (nodes
[i
].kind
)
1796 case ORDER_FUNCTION
:
1797 nodes
[i
].u
.f
->process
= 0;
1798 cgraph_expand_function (nodes
[i
].u
.f
);
1802 varpool_assemble_decl (nodes
[i
].u
.v
);
1806 assemble_asm (nodes
[i
].u
.a
->asm_str
);
1809 case ORDER_UNDEFINED
:
1817 cgraph_asm_nodes
= NULL
;
1821 /* Return true when function body of DECL still needs to be kept around
1822 for later re-use. */
1824 cgraph_preserve_function_body_p (tree decl
)
1826 struct cgraph_node
*node
;
1828 gcc_assert (cgraph_global_info_ready
);
1829 /* Look if there is any clone around. */
1830 node
= cgraph_node (decl
);
1840 current_function_decl
= NULL
;
1841 gimple_register_cfg_hooks ();
1842 bitmap_obstack_initialize (NULL
);
1844 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_START
, NULL
);
1847 execute_ipa_pass_list (all_small_ipa_passes
);
1849 /* If pass_all_early_optimizations was not scheduled, the state of
1850 the cgraph will not be properly updated. Update it now. */
1851 if (cgraph_state
< CGRAPH_STATE_IPA_SSA
)
1852 cgraph_state
= CGRAPH_STATE_IPA_SSA
;
1856 /* Generate coverage variables and constructors. */
1859 /* Process new functions added. */
1861 current_function_decl
= NULL
;
1862 cgraph_process_new_functions ();
1864 execute_ipa_summary_passes
1865 ((struct ipa_opt_pass_d
*) all_regular_ipa_passes
);
1867 execute_ipa_summary_passes ((struct ipa_opt_pass_d
*) all_lto_gen_passes
);
1870 ipa_write_summaries ();
1873 execute_ipa_pass_list (all_regular_ipa_passes
);
1874 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_END
, NULL
);
1876 bitmap_obstack_release (NULL
);
1880 /* Perform simple optimizations based on callgraph. */
1883 cgraph_optimize (void)
1885 if (errorcount
|| sorrycount
)
1888 #ifdef ENABLE_CHECKING
1892 /* Frontend may output common variables after the unit has been finalized.
1893 It is safe to deal with them here as they are always zero initialized. */
1894 varpool_analyze_pending_decls ();
1896 timevar_push (TV_CGRAPHOPT
);
1897 if (pre_ipa_mem_report
)
1899 fprintf (stderr
, "Memory consumption before IPA\n");
1900 dump_memory_report (false);
1903 fprintf (stderr
, "Performing interprocedural optimizations\n");
1904 cgraph_state
= CGRAPH_STATE_IPA
;
1906 /* Don't run the IPA passes if there was any error or sorry messages. */
1907 if (errorcount
== 0 && sorrycount
== 0)
1910 /* Do nothing else if any IPA pass found errors. */
1911 if (errorcount
|| sorrycount
)
1913 timevar_pop (TV_CGRAPHOPT
);
1917 /* This pass remove bodies of extern inline functions we never inlined.
1918 Do this later so other IPA passes see what is really going on. */
1919 cgraph_remove_unreachable_nodes (false, dump_file
);
1920 cgraph_global_info_ready
= true;
1921 if (cgraph_dump_file
)
1923 fprintf (cgraph_dump_file
, "Optimized ");
1924 dump_cgraph (cgraph_dump_file
);
1925 dump_varpool (cgraph_dump_file
);
1927 if (post_ipa_mem_report
)
1929 fprintf (stderr
, "Memory consumption after IPA\n");
1930 dump_memory_report (false);
1932 timevar_pop (TV_CGRAPHOPT
);
1934 /* Output everything. */
1935 (*debug_hooks
->assembly_start
) ();
1937 fprintf (stderr
, "Assembling functions:\n");
1938 #ifdef ENABLE_CHECKING
1942 cgraph_materialize_all_clones ();
1943 cgraph_mark_functions_to_output ();
1945 cgraph_state
= CGRAPH_STATE_EXPANSION
;
1946 if (!flag_toplevel_reorder
)
1947 cgraph_output_in_order ();
1950 cgraph_output_pending_asms ();
1952 cgraph_expand_all_functions ();
1953 varpool_remove_unreferenced_decls ();
1955 varpool_assemble_pending_decls ();
1957 cgraph_process_new_functions ();
1958 cgraph_state
= CGRAPH_STATE_FINISHED
;
1960 if (cgraph_dump_file
)
1962 fprintf (cgraph_dump_file
, "\nFinal ");
1963 dump_cgraph (cgraph_dump_file
);
1965 #ifdef ENABLE_CHECKING
1967 /* Double check that all inline clones are gone and that all
1968 function bodies have been released from memory. */
1969 if (!(sorrycount
|| errorcount
))
1971 struct cgraph_node
*node
;
1972 bool error_found
= false;
1974 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1976 && (node
->global
.inlined_to
1977 || gimple_has_body_p (node
->decl
)))
1980 dump_cgraph_node (stderr
, node
);
1983 internal_error ("nodes with unreleased memory found");
1989 /* Generate and emit a static constructor or destructor. WHICH must
1990 be one of 'I' (for a constructor) or 'D' (for a destructor). BODY
1991 is a STATEMENT_LIST containing GENERIC statements. PRIORITY is the
1992 initialization priority for this constructor or destructor. */
1995 cgraph_build_static_cdtor (char which
, tree body
, int priority
)
1997 static int counter
= 0;
1999 tree decl
, name
, resdecl
;
2001 /* The priority is encoded in the constructor or destructor name.
2002 collect2 will sort the names and arrange that they are called at
2004 sprintf (which_buf
, "%c_%.5d_%d", which
, priority
, counter
++);
2005 name
= get_file_function_name (which_buf
);
2007 decl
= build_decl (input_location
, FUNCTION_DECL
, name
,
2008 build_function_type (void_type_node
, void_list_node
));
2009 current_function_decl
= decl
;
2011 resdecl
= build_decl (input_location
,
2012 RESULT_DECL
, NULL_TREE
, void_type_node
);
2013 DECL_ARTIFICIAL (resdecl
) = 1;
2014 DECL_RESULT (decl
) = resdecl
;
2015 DECL_CONTEXT (resdecl
) = decl
;
2017 allocate_struct_function (decl
, false);
2019 TREE_STATIC (decl
) = 1;
2020 TREE_USED (decl
) = 1;
2021 DECL_ARTIFICIAL (decl
) = 1;
2022 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
2023 DECL_SAVED_TREE (decl
) = body
;
2024 if (!targetm
.have_ctors_dtors
)
2026 TREE_PUBLIC (decl
) = 1;
2027 DECL_PRESERVE_P (decl
) = 1;
2029 DECL_UNINLINABLE (decl
) = 1;
2031 DECL_INITIAL (decl
) = make_node (BLOCK
);
2032 TREE_USED (DECL_INITIAL (decl
)) = 1;
2034 DECL_SOURCE_LOCATION (decl
) = input_location
;
2035 cfun
->function_end_locus
= input_location
;
2040 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
2041 decl_init_priority_insert (decl
, priority
);
2044 DECL_STATIC_DESTRUCTOR (decl
) = 1;
2045 decl_fini_priority_insert (decl
, priority
);
2051 gimplify_function_tree (decl
);
2053 cgraph_add_new_function (decl
, false);
2054 cgraph_mark_needed_node (cgraph_node (decl
));
2061 cgraph_dump_file
= dump_begin (TDI_cgraph
, NULL
);
2064 /* The edges representing the callers of the NEW_VERSION node were
2065 fixed by cgraph_function_versioning (), now the call_expr in their
2066 respective tree code should be updated to call the NEW_VERSION. */
2069 update_call_expr (struct cgraph_node
*new_version
)
2071 struct cgraph_edge
*e
;
2073 gcc_assert (new_version
);
2075 /* Update the call expr on the edges to call the new version. */
2076 for (e
= new_version
->callers
; e
; e
= e
->next_caller
)
2078 struct function
*inner_function
= DECL_STRUCT_FUNCTION (e
->caller
->decl
);
2079 gimple_call_set_fndecl (e
->call_stmt
, new_version
->decl
);
2080 maybe_clean_eh_stmt_fn (inner_function
, e
->call_stmt
);
2085 /* Create a new cgraph node which is the new version of
2086 OLD_VERSION node. REDIRECT_CALLERS holds the callers
2087 edges which should be redirected to point to
2088 NEW_VERSION. ALL the callees edges of OLD_VERSION
2089 are cloned to the new version node. Return the new
2092 static struct cgraph_node
*
2093 cgraph_copy_node_for_versioning (struct cgraph_node
*old_version
,
2095 VEC(cgraph_edge_p
,heap
) *redirect_callers
)
2097 struct cgraph_node
*new_version
;
2098 struct cgraph_edge
*e
;
2099 struct cgraph_edge
*next_callee
;
2102 gcc_assert (old_version
);
2104 new_version
= cgraph_node (new_decl
);
2106 new_version
->analyzed
= true;
2107 new_version
->local
= old_version
->local
;
2108 new_version
->global
= old_version
->global
;
2109 new_version
->rtl
= new_version
->rtl
;
2110 new_version
->reachable
= true;
2111 new_version
->count
= old_version
->count
;
2113 /* Clone the old node callees. Recursive calls are
2115 for (e
= old_version
->callees
;e
; e
=e
->next_callee
)
2117 cgraph_clone_edge (e
, new_version
, e
->call_stmt
,
2118 e
->lto_stmt_uid
, REG_BR_PROB_BASE
,
2120 e
->loop_nest
, true);
2122 /* Fix recursive calls.
2123 If OLD_VERSION has a recursive call after the
2124 previous edge cloning, the new version will have an edge
2125 pointing to the old version, which is wrong;
2126 Redirect it to point to the new version. */
2127 for (e
= new_version
->callees
; e
; e
= next_callee
)
2129 next_callee
= e
->next_callee
;
2130 if (e
->callee
== old_version
)
2131 cgraph_redirect_edge_callee (e
, new_version
);
2136 for (i
= 0; VEC_iterate (cgraph_edge_p
, redirect_callers
, i
, e
); i
++)
2138 /* Redirect calls to the old version node to point to its new
2140 cgraph_redirect_edge_callee (e
, new_version
);
2146 /* Perform function versioning.
2147 Function versioning includes copying of the tree and
2148 a callgraph update (creating a new cgraph node and updating
2149 its callees and callers).
2151 REDIRECT_CALLERS varray includes the edges to be redirected
2154 TREE_MAP is a mapping of tree nodes we want to replace with
2155 new ones (according to results of prior analysis).
2156 OLD_VERSION_NODE is the node that is versioned.
2157 It returns the new version's cgraph node.
2158 ARGS_TO_SKIP lists arguments to be omitted from functions
2161 struct cgraph_node
*
2162 cgraph_function_versioning (struct cgraph_node
*old_version_node
,
2163 VEC(cgraph_edge_p
,heap
) *redirect_callers
,
2164 VEC (ipa_replace_map_p
,gc
)* tree_map
,
2165 bitmap args_to_skip
)
2167 tree old_decl
= old_version_node
->decl
;
2168 struct cgraph_node
*new_version_node
= NULL
;
2171 if (!tree_versionable_function_p (old_decl
))
2174 /* Make a new FUNCTION_DECL tree node for the
2177 new_decl
= copy_node (old_decl
);
2179 new_decl
= build_function_decl_skip_args (old_decl
, args_to_skip
);
2181 /* Create the new version's call-graph node.
2182 and update the edges of the new node. */
2184 cgraph_copy_node_for_versioning (old_version_node
, new_decl
,
2187 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2188 tree_function_versioning (old_decl
, new_decl
, tree_map
, false, args_to_skip
);
2190 /* Update the new version's properties.
2191 Make The new version visible only within this translation unit. Make sure
2192 that is not weak also.
2193 ??? We cannot use COMDAT linkage because there is no
2194 ABI support for this. */
2195 cgraph_make_decl_local (new_version_node
->decl
);
2196 DECL_VIRTUAL_P (new_version_node
->decl
) = 0;
2197 new_version_node
->local
.externally_visible
= 0;
2198 new_version_node
->local
.local
= 1;
2199 new_version_node
->lowered
= true;
2201 /* Update the call_expr on the edges to call the new version node. */
2202 update_call_expr (new_version_node
);
2204 cgraph_call_function_insertion_hooks (new_version_node
);
2205 return new_version_node
;
2208 /* Produce separate function body for inline clones so the offline copy can be
2209 modified without affecting them. */
2210 struct cgraph_node
*
2211 save_inline_function_body (struct cgraph_node
*node
)
2213 struct cgraph_node
*first_clone
, *n
;
2215 gcc_assert (node
== cgraph_node (node
->decl
));
2217 cgraph_lower_function (node
);
2219 first_clone
= node
->clones
;
2221 first_clone
->decl
= copy_node (node
->decl
);
2222 cgraph_insert_node_to_hashtable (first_clone
);
2223 gcc_assert (first_clone
== cgraph_node (first_clone
->decl
));
2224 if (first_clone
->next_sibling_clone
)
2226 for (n
= first_clone
->next_sibling_clone
; n
->next_sibling_clone
; n
= n
->next_sibling_clone
)
2227 n
->clone_of
= first_clone
;
2228 n
->clone_of
= first_clone
;
2229 n
->next_sibling_clone
= first_clone
->clones
;
2230 if (first_clone
->clones
)
2231 first_clone
->clones
->prev_sibling_clone
= n
;
2232 first_clone
->clones
= first_clone
->next_sibling_clone
;
2233 first_clone
->next_sibling_clone
->prev_sibling_clone
= NULL
;
2234 first_clone
->next_sibling_clone
= NULL
;
2235 gcc_assert (!first_clone
->prev_sibling_clone
);
2237 first_clone
->clone_of
= NULL
;
2238 node
->clones
= NULL
;
2240 if (first_clone
->clones
)
2241 for (n
= first_clone
->clones
; n
!= first_clone
;)
2243 gcc_assert (n
->decl
== node
->decl
);
2244 n
->decl
= first_clone
->decl
;
2247 else if (n
->next_sibling_clone
)
2248 n
= n
->next_sibling_clone
;
2251 while (n
!= first_clone
&& !n
->next_sibling_clone
)
2253 if (n
!= first_clone
)
2254 n
= n
->next_sibling_clone
;
2258 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2259 tree_function_versioning (node
->decl
, first_clone
->decl
, NULL
, true, NULL
);
2261 DECL_EXTERNAL (first_clone
->decl
) = 0;
2262 DECL_COMDAT_GROUP (first_clone
->decl
) = NULL_TREE
;
2263 TREE_PUBLIC (first_clone
->decl
) = 0;
2264 DECL_COMDAT (first_clone
->decl
) = 0;
2265 VEC_free (ipa_opt_pass
, heap
,
2266 first_clone
->ipa_transforms_to_apply
);
2267 first_clone
->ipa_transforms_to_apply
= NULL
;
2269 #ifdef ENABLE_CHECKING
2270 verify_cgraph_node (first_clone
);
2275 /* Given virtual clone, turn it into actual clone. */
2277 cgraph_materialize_clone (struct cgraph_node
*node
)
2279 bitmap_obstack_initialize (NULL
);
2280 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2281 tree_function_versioning (node
->clone_of
->decl
, node
->decl
,
2282 node
->clone
.tree_map
, true,
2283 node
->clone
.args_to_skip
);
2284 if (cgraph_dump_file
)
2286 dump_function_to_file (node
->clone_of
->decl
, cgraph_dump_file
, dump_flags
);
2287 dump_function_to_file (node
->decl
, cgraph_dump_file
, dump_flags
);
2290 /* Function is no longer clone. */
2291 if (node
->next_sibling_clone
)
2292 node
->next_sibling_clone
->prev_sibling_clone
= node
->prev_sibling_clone
;
2293 if (node
->prev_sibling_clone
)
2294 node
->prev_sibling_clone
->next_sibling_clone
= node
->next_sibling_clone
;
2296 node
->clone_of
->clones
= node
->next_sibling_clone
;
2297 node
->next_sibling_clone
= NULL
;
2298 node
->prev_sibling_clone
= NULL
;
2299 if (!node
->clone_of
->analyzed
&& !node
->clone_of
->clones
)
2300 cgraph_remove_node (node
->clone_of
);
2301 node
->clone_of
= NULL
;
2302 bitmap_obstack_release (NULL
);
2305 /* If necessary, change the function declaration in the call statement
2306 associated with E so that it corresponds to the edge callee. */
2309 cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge
*e
)
2311 tree decl
= gimple_call_fndecl (e
->call_stmt
);
2313 gimple_stmt_iterator gsi
;
2315 if (!decl
|| decl
== e
->callee
->decl
2316 /* Don't update call from same body alias to the real function. */
2317 || cgraph_get_node (decl
) == cgraph_get_node (e
->callee
->decl
))
2318 return e
->call_stmt
;
2320 if (cgraph_dump_file
)
2322 fprintf (cgraph_dump_file
, "updating call of %s/%i -> %s/%i: ",
2323 cgraph_node_name (e
->caller
), e
->caller
->uid
,
2324 cgraph_node_name (e
->callee
), e
->callee
->uid
);
2325 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
2328 if (e
->callee
->clone
.combined_args_to_skip
)
2329 new_stmt
= gimple_call_copy_skip_args (e
->call_stmt
,
2330 e
->callee
->clone
.combined_args_to_skip
);
2332 new_stmt
= e
->call_stmt
;
2333 if (gimple_vdef (new_stmt
)
2334 && TREE_CODE (gimple_vdef (new_stmt
)) == SSA_NAME
)
2335 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt
)) = new_stmt
;
2336 gimple_call_set_fndecl (new_stmt
, e
->callee
->decl
);
2338 gsi
= gsi_for_stmt (e
->call_stmt
);
2339 gsi_replace (&gsi
, new_stmt
, true);
2340 update_stmt (new_stmt
);
2342 /* Update EH information too, just in case. */
2343 maybe_clean_or_replace_eh_stmt (e
->call_stmt
, new_stmt
);
2345 cgraph_set_call_stmt_including_clones (e
->caller
, e
->call_stmt
, new_stmt
);
2347 if (cgraph_dump_file
)
2349 fprintf (cgraph_dump_file
, " updated to:");
2350 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
2355 /* Once all functions from compilation unit are in memory, produce all clones
2356 and update all calls. We might also do this on demand if we don't want to
2357 bring all functions to memory prior compilation, but current WHOPR
2358 implementation does that and it is is bit easier to keep everything right in
2361 cgraph_materialize_all_clones (void)
2363 struct cgraph_node
*node
;
2364 bool stabilized
= false;
2366 if (cgraph_dump_file
)
2367 fprintf (cgraph_dump_file
, "Materializing clones\n");
2368 #ifdef ENABLE_CHECKING
2372 /* We can also do topological order, but number of iterations should be
2373 bounded by number of IPA passes since single IPA pass is probably not
2374 going to create clones of clones it created itself. */
2378 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2380 if (node
->clone_of
&& node
->decl
!= node
->clone_of
->decl
2381 && !gimple_has_body_p (node
->decl
))
2383 if (gimple_has_body_p (node
->clone_of
->decl
))
2385 if (cgraph_dump_file
)
2387 fprintf (cgraph_dump_file
, "clonning %s to %s\n",
2388 cgraph_node_name (node
->clone_of
),
2389 cgraph_node_name (node
));
2390 if (node
->clone
.tree_map
)
2393 fprintf (cgraph_dump_file
, " replace map: ");
2394 for (i
= 0; i
< VEC_length (ipa_replace_map_p
,
2395 node
->clone
.tree_map
);
2398 struct ipa_replace_map
*replace_info
;
2399 replace_info
= VEC_index (ipa_replace_map_p
,
2400 node
->clone
.tree_map
,
2402 print_generic_expr (cgraph_dump_file
, replace_info
->old_tree
, 0);
2403 fprintf (cgraph_dump_file
, " -> ");
2404 print_generic_expr (cgraph_dump_file
, replace_info
->new_tree
, 0);
2405 fprintf (cgraph_dump_file
, "%s%s;",
2406 replace_info
->replace_p
? "(replace)":"",
2407 replace_info
->ref_p
? "(ref)":"");
2409 fprintf (cgraph_dump_file
, "\n");
2411 if (node
->clone
.args_to_skip
)
2413 fprintf (cgraph_dump_file
, " args_to_skip: ");
2414 dump_bitmap (cgraph_dump_file
, node
->clone
.args_to_skip
);
2416 if (node
->clone
.args_to_skip
)
2418 fprintf (cgraph_dump_file
, " combined_args_to_skip:");
2419 dump_bitmap (cgraph_dump_file
, node
->clone
.combined_args_to_skip
);
2422 cgraph_materialize_clone (node
);
2429 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2430 if (!node
->analyzed
&& node
->callees
)
2431 cgraph_node_remove_callees (node
);
2432 if (cgraph_dump_file
)
2433 fprintf (cgraph_dump_file
, "Updating call sites\n");
2434 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2435 if (node
->analyzed
&& !node
->clone_of
2436 && gimple_has_body_p (node
->decl
))
2438 struct cgraph_edge
*e
;
2440 current_function_decl
= node
->decl
;
2441 push_cfun (DECL_STRUCT_FUNCTION (node
->decl
));
2442 for (e
= node
->callees
; e
; e
= e
->next_callee
)
2443 cgraph_redirect_edge_call_stmt_to_callee (e
);
2444 gcc_assert (!need_ssa_update_p (cfun
));
2446 current_function_decl
= NULL
;
2447 #ifdef ENABLE_CHECKING
2448 verify_cgraph_node (node
);
2451 if (cgraph_dump_file
)
2452 fprintf (cgraph_dump_file
, "Materialization Call site updates done.\n");
2453 /* All changes to parameters have been performed. In order not to
2454 incorrectly repeat them, we simply dispose of the bitmaps that drive the
2456 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2457 node
->clone
.combined_args_to_skip
= NULL
;
2458 #ifdef ENABLE_CHECKING
2461 cgraph_remove_unreachable_nodes (false, cgraph_dump_file
);
2464 #include "gt-cgraphunit.h"