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
->callers
; e
; e
= e
->next_caller
)
614 error ("caller edge count is negative");
617 if (e
->frequency
< 0)
619 error ("caller edge frequency is negative");
622 if (e
->frequency
> CGRAPH_FREQ_MAX
)
624 error ("caller edge frequency is too large");
627 if (gimple_has_body_p (e
->caller
->decl
)
628 && !e
->caller
->global
.inlined_to
630 != compute_call_stmt_bb_frequency (e
->caller
->decl
,
631 gimple_bb (e
->call_stmt
))))
633 error ("caller edge frequency %i does not match BB freqency %i",
635 compute_call_stmt_bb_frequency (e
->caller
->decl
,
636 gimple_bb (e
->call_stmt
)));
639 if (!e
->inline_failed
)
641 if (node
->global
.inlined_to
642 != (e
->caller
->global
.inlined_to
643 ? e
->caller
->global
.inlined_to
: e
->caller
))
645 error ("inlined_to pointer is wrong");
648 if (node
->callers
->next_caller
)
650 error ("multiple inline callers");
655 if (node
->global
.inlined_to
)
657 error ("inlined_to pointer set for noninline callers");
661 if (!node
->callers
&& node
->global
.inlined_to
)
663 error ("inlined_to pointer is set but no predecessors found");
666 if (node
->global
.inlined_to
== node
)
668 error ("inlined_to pointer refers to itself");
672 if (!cgraph_node (node
->decl
))
674 error ("node not found in cgraph_hash");
680 struct cgraph_node
*n
;
681 for (n
= node
->clone_of
->clones
; n
; n
= n
->next_sibling_clone
)
686 error ("node has wrong clone_of");
692 struct cgraph_node
*n
;
693 for (n
= node
->clones
; n
; n
= n
->next_sibling_clone
)
694 if (n
->clone_of
!= node
)
698 error ("node has wrong clone list");
702 if ((node
->prev_sibling_clone
|| node
->next_sibling_clone
) && !node
->clone_of
)
704 error ("node is in clone list but it is not clone");
707 if (!node
->prev_sibling_clone
&& node
->clone_of
&& node
->clone_of
->clones
!= node
)
709 error ("node has wrong prev_clone pointer");
712 if (node
->prev_sibling_clone
&& node
->prev_sibling_clone
->next_sibling_clone
!= node
)
714 error ("double linked list of clones corrupted");
718 if (node
->analyzed
&& gimple_has_body_p (node
->decl
)
719 && !TREE_ASM_WRITTEN (node
->decl
)
720 && (!DECL_EXTERNAL (node
->decl
) || node
->global
.inlined_to
)
725 /* The nodes we're interested in are never shared, so walk
726 the tree ignoring duplicates. */
727 struct pointer_set_t
*visited_nodes
= pointer_set_create ();
728 /* Reach the trees by walking over the CFG, and note the
729 enclosing basic-blocks in the call edges. */
730 FOR_EACH_BB_FN (this_block
, this_cfun
)
731 for (gsi
= gsi_start_bb (this_block
);
735 gimple stmt
= gsi_stmt (gsi
);
737 if (is_gimple_call (stmt
) && (decl
= gimple_call_fndecl (stmt
)))
739 struct cgraph_edge
*e
= cgraph_edge (node
, stmt
);
744 error ("shared call_stmt:");
745 debug_gimple_stmt (stmt
);
748 if (e
->callee
->same_body_alias
)
750 error ("edge points to same body alias:");
751 debug_tree (e
->callee
->decl
);
754 else if (!node
->global
.inlined_to
755 && !e
->callee
->global
.inlined_to
756 && !clone_of_p (cgraph_node (decl
), e
->callee
))
758 error ("edge points to wrong declaration:");
759 debug_tree (e
->callee
->decl
);
760 fprintf (stderr
," Instead of:");
768 error ("missing callgraph edge for call stmt:");
769 debug_gimple_stmt (stmt
);
774 pointer_set_destroy (visited_nodes
);
777 /* No CFG available?! */
780 for (e
= node
->callees
; e
; e
= e
->next_callee
)
782 if (!e
->aux
&& !e
->indirect_call
)
784 error ("edge %s->%s has no corresponding call_stmt",
785 identifier_to_locale (cgraph_node_name (e
->caller
)),
786 identifier_to_locale (cgraph_node_name (e
->callee
)));
787 debug_gimple_stmt (e
->call_stmt
);
795 dump_cgraph_node (stderr
, node
);
796 internal_error ("verify_cgraph_node failed");
798 set_cfun (saved_cfun
);
799 timevar_pop (TV_CGRAPH_VERIFY
);
802 /* Verify whole cgraph structure. */
806 struct cgraph_node
*node
;
808 if (sorrycount
|| errorcount
)
811 for (node
= cgraph_nodes
; node
; node
= node
->next
)
812 verify_cgraph_node (node
);
815 /* Output all asm statements we have stored up to be output. */
818 cgraph_output_pending_asms (void)
820 struct cgraph_asm_node
*can
;
822 if (errorcount
|| sorrycount
)
825 for (can
= cgraph_asm_nodes
; can
; can
= can
->next
)
826 assemble_asm (can
->asm_str
);
827 cgraph_asm_nodes
= NULL
;
830 /* Analyze the function scheduled to be output. */
832 cgraph_analyze_function (struct cgraph_node
*node
)
834 tree save
= current_function_decl
;
835 tree decl
= node
->decl
;
837 current_function_decl
= decl
;
838 push_cfun (DECL_STRUCT_FUNCTION (decl
));
840 assign_assembler_name_if_neeeded (node
->decl
);
842 /* Make sure to gimplify bodies only once. During analyzing a
843 function we lower it, which will require gimplified nested
844 functions, so we can end up here with an already gimplified
846 if (!gimple_body (decl
))
847 gimplify_function_tree (decl
);
848 dump_function (TDI_generic
, decl
);
850 cgraph_lower_function (node
);
851 node
->analyzed
= true;
854 current_function_decl
= save
;
857 /* Look for externally_visible and used attributes and mark cgraph nodes
860 We cannot mark the nodes at the point the attributes are processed (in
861 handle_*_attribute) because the copy of the declarations available at that
862 point may not be canonical. For example, in:
865 void f() __attribute__((used));
867 the declaration we see in handle_used_attribute will be the second
868 declaration -- but the front end will subsequently merge that declaration
869 with the original declaration and discard the second declaration.
871 Furthermore, we can't mark these nodes in cgraph_finalize_function because:
874 void f() __attribute__((externally_visible));
878 So, we walk the nodes at the end of the translation unit, applying the
879 attributes at that point. */
882 process_function_and_variable_attributes (struct cgraph_node
*first
,
883 struct varpool_node
*first_var
)
885 struct cgraph_node
*node
;
886 struct varpool_node
*vnode
;
888 for (node
= cgraph_nodes
; node
!= first
; node
= node
->next
)
890 tree decl
= node
->decl
;
891 if (DECL_PRESERVE_P (decl
))
893 mark_decl_referenced (decl
);
894 if (node
->local
.finalized
)
895 cgraph_mark_needed_node (node
);
897 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
899 if (! TREE_PUBLIC (node
->decl
))
900 warning_at (DECL_SOURCE_LOCATION (node
->decl
), OPT_Wattributes
,
901 "%<externally_visible%>"
902 " attribute have effect only on public objects");
903 else if (node
->local
.finalized
)
904 cgraph_mark_needed_node (node
);
907 for (vnode
= varpool_nodes
; vnode
!= first_var
; vnode
= vnode
->next
)
909 tree decl
= vnode
->decl
;
910 if (DECL_PRESERVE_P (decl
))
912 mark_decl_referenced (decl
);
913 vnode
->force_output
= true;
914 if (vnode
->finalized
)
915 varpool_mark_needed_node (vnode
);
917 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
919 if (! TREE_PUBLIC (vnode
->decl
))
920 warning_at (DECL_SOURCE_LOCATION (vnode
->decl
), OPT_Wattributes
,
921 "%<externally_visible%>"
922 " attribute have effect only on public objects");
923 else if (vnode
->finalized
)
924 varpool_mark_needed_node (vnode
);
929 /* Process CGRAPH_NODES_NEEDED queue, analyze each function (and transitively
930 each reachable functions) and build cgraph.
931 The function can be called multiple times after inserting new nodes
932 into beginning of queue. Just the new part of queue is re-scanned then. */
935 cgraph_analyze_functions (void)
937 /* Keep track of already processed nodes when called multiple times for
938 intermodule optimization. */
939 static struct cgraph_node
*first_analyzed
;
940 struct cgraph_node
*first_processed
= first_analyzed
;
941 static struct varpool_node
*first_analyzed_var
;
942 struct cgraph_node
*node
, *next
;
944 process_function_and_variable_attributes (first_processed
,
946 first_processed
= cgraph_nodes
;
947 first_analyzed_var
= varpool_nodes
;
948 varpool_analyze_pending_decls ();
949 if (cgraph_dump_file
)
951 fprintf (cgraph_dump_file
, "Initial entry points:");
952 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
954 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
955 fprintf (cgraph_dump_file
, "\n");
957 cgraph_process_new_functions ();
959 /* Propagate reachability flag and lower representation of all reachable
960 functions. In the future, lowering will introduce new functions and
961 new entry points on the way (by template instantiation and virtual
962 method table generation for instance). */
963 while (cgraph_nodes_queue
)
965 struct cgraph_edge
*edge
;
966 tree decl
= cgraph_nodes_queue
->decl
;
968 node
= cgraph_nodes_queue
;
969 cgraph_nodes_queue
= cgraph_nodes_queue
->next_needed
;
970 node
->next_needed
= NULL
;
972 /* ??? It is possible to create extern inline function and later using
973 weak alias attribute to kill its body. See
974 gcc.c-torture/compile/20011119-1.c */
975 if (!DECL_STRUCT_FUNCTION (decl
))
977 cgraph_reset_node (node
);
982 cgraph_analyze_function (node
);
984 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
985 if (!edge
->callee
->reachable
)
986 cgraph_mark_reachable_node (edge
->callee
);
988 if (node
->same_comdat_group
)
990 for (next
= node
->same_comdat_group
;
992 next
= next
->same_comdat_group
)
993 cgraph_mark_reachable_node (next
);
996 /* If decl is a clone of an abstract function, mark that abstract
997 function so that we don't release its body. The DECL_INITIAL() of that
998 abstract function declaration will be later needed to output debug info. */
999 if (DECL_ABSTRACT_ORIGIN (decl
))
1001 struct cgraph_node
*origin_node
= cgraph_node (DECL_ABSTRACT_ORIGIN (decl
));
1002 origin_node
->abstract_and_needed
= true;
1005 /* We finalize local static variables during constructing callgraph
1006 edges. Process their attributes too. */
1007 process_function_and_variable_attributes (first_processed
,
1008 first_analyzed_var
);
1009 first_processed
= cgraph_nodes
;
1010 first_analyzed_var
= varpool_nodes
;
1011 varpool_analyze_pending_decls ();
1012 cgraph_process_new_functions ();
1015 /* Collect entry points to the unit. */
1016 if (cgraph_dump_file
)
1018 fprintf (cgraph_dump_file
, "Unit entry points:");
1019 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
1021 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1022 fprintf (cgraph_dump_file
, "\n\nInitial ");
1023 dump_cgraph (cgraph_dump_file
);
1026 if (cgraph_dump_file
)
1027 fprintf (cgraph_dump_file
, "\nReclaiming functions:");
1029 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= next
)
1031 tree decl
= node
->decl
;
1034 if (node
->local
.finalized
&& !gimple_has_body_p (decl
))
1035 cgraph_reset_node (node
);
1037 if (!node
->reachable
&& gimple_has_body_p (decl
))
1039 if (cgraph_dump_file
)
1040 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1041 cgraph_remove_node (node
);
1045 node
->next_needed
= NULL
;
1046 gcc_assert (!node
->local
.finalized
|| gimple_has_body_p (decl
));
1047 gcc_assert (node
->analyzed
== node
->local
.finalized
);
1049 if (cgraph_dump_file
)
1051 fprintf (cgraph_dump_file
, "\n\nReclaimed ");
1052 dump_cgraph (cgraph_dump_file
);
1054 first_analyzed
= cgraph_nodes
;
1059 /* Analyze the whole compilation unit once it is parsed completely. */
1062 cgraph_finalize_compilation_unit (void)
1064 timevar_push (TV_CGRAPH
);
1066 /* Do not skip analyzing the functions if there were errors, we
1067 miss diagnostics for following functions otherwise. */
1069 /* Emit size functions we didn't inline. */
1070 finalize_size_functions ();
1072 /* Call functions declared with the "constructor" or "destructor"
1074 cgraph_build_cdtor_fns ();
1076 /* Mark alias targets necessary and emit diagnostics. */
1077 finish_aliases_1 ();
1081 fprintf (stderr
, "\nAnalyzing compilation unit\n");
1085 /* Gimplify and lower all functions, compute reachability and
1086 remove unreachable nodes. */
1087 cgraph_analyze_functions ();
1089 /* Mark alias targets necessary and emit diagnostics. */
1090 finish_aliases_1 ();
1092 /* Gimplify and lower thunks. */
1093 cgraph_analyze_functions ();
1095 /* Finally drive the pass manager. */
1098 timevar_pop (TV_CGRAPH
);
1102 /* Figure out what functions we want to assemble. */
1105 cgraph_mark_functions_to_output (void)
1107 struct cgraph_node
*node
;
1108 #ifdef ENABLE_CHECKING
1109 bool check_same_comdat_groups
= false;
1111 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1112 gcc_assert (!node
->process
);
1115 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1117 tree decl
= node
->decl
;
1118 struct cgraph_edge
*e
;
1120 gcc_assert (!node
->process
|| node
->same_comdat_group
);
1124 for (e
= node
->callers
; e
; e
= e
->next_caller
)
1125 if (e
->inline_failed
)
1128 /* We need to output all local functions that are used and not
1129 always inlined, as well as those that are reachable from
1130 outside the current compilation unit. */
1132 && !node
->global
.inlined_to
1133 && (node
->needed
|| node
->reachable_from_other_partition
1134 || (e
&& node
->reachable
))
1135 && !TREE_ASM_WRITTEN (decl
)
1136 && !DECL_EXTERNAL (decl
))
1139 if (node
->same_comdat_group
)
1141 struct cgraph_node
*next
;
1142 for (next
= node
->same_comdat_group
;
1144 next
= next
->same_comdat_group
)
1148 else if (node
->same_comdat_group
)
1150 #ifdef ENABLE_CHECKING
1151 check_same_comdat_groups
= true;
1156 /* We should've reclaimed all functions that are not needed. */
1157 #ifdef ENABLE_CHECKING
1158 if (!node
->global
.inlined_to
1159 && gimple_has_body_p (decl
)
1160 /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
1161 are inside partition, we can end up not removing the body since we no longer
1162 have analyzed node pointing to it. */
1163 && !node
->in_other_partition
1164 && !DECL_EXTERNAL (decl
))
1166 dump_cgraph_node (stderr
, node
);
1167 internal_error ("failed to reclaim unneeded function");
1170 gcc_assert (node
->global
.inlined_to
1171 || !gimple_has_body_p (decl
)
1172 || node
->in_other_partition
1173 || DECL_EXTERNAL (decl
));
1178 #ifdef ENABLE_CHECKING
1179 if (check_same_comdat_groups
)
1180 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1181 if (node
->same_comdat_group
&& !node
->process
)
1183 tree decl
= node
->decl
;
1184 if (!node
->global
.inlined_to
1185 && gimple_has_body_p (decl
)
1186 /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
1187 are inside partition, we can end up not removing the body since we no longer
1188 have analyzed node pointing to it. */
1189 && !node
->in_other_partition
1190 && !DECL_EXTERNAL (decl
))
1192 dump_cgraph_node (stderr
, node
);
1193 internal_error ("failed to reclaim unneeded function");
1199 /* DECL is FUNCTION_DECL. Initialize datastructures so DECL is a function
1200 in lowered gimple form.
1202 Set current_function_decl and cfun to newly constructed empty function body.
1203 return basic block in the function body. */
1206 init_lowered_empty_function (tree decl
)
1210 current_function_decl
= decl
;
1211 allocate_struct_function (decl
, false);
1212 gimple_register_cfg_hooks ();
1213 init_empty_tree_cfg ();
1214 init_tree_ssa (cfun
);
1215 init_ssa_operands ();
1216 cfun
->gimple_df
->in_ssa_p
= true;
1217 DECL_INITIAL (decl
) = make_node (BLOCK
);
1219 DECL_SAVED_TREE (decl
) = error_mark_node
;
1220 cfun
->curr_properties
|=
1221 (PROP_gimple_lcf
| PROP_gimple_leh
| PROP_cfg
| PROP_referenced_vars
|
1224 /* Create BB for body of the function and connect it properly. */
1225 bb
= create_basic_block (NULL
, (void *) 0, ENTRY_BLOCK_PTR
);
1226 make_edge (ENTRY_BLOCK_PTR
, bb
, 0);
1227 make_edge (bb
, EXIT_BLOCK_PTR
, 0);
1232 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
1233 offset indicated by VIRTUAL_OFFSET, if that is
1234 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
1235 zero for a result adjusting thunk. */
1238 thunk_adjust (gimple_stmt_iterator
* bsi
,
1239 tree ptr
, bool this_adjusting
,
1240 HOST_WIDE_INT fixed_offset
, tree virtual_offset
)
1246 && fixed_offset
!= 0)
1248 stmt
= gimple_build_assign (ptr
,
1249 fold_build2_loc (input_location
,
1251 TREE_TYPE (ptr
), ptr
,
1252 size_int (fixed_offset
)));
1253 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1256 /* If there's a virtual offset, look up that value in the vtable and
1257 adjust the pointer again. */
1265 if (!vtable_entry_type
)
1267 tree vfunc_type
= make_node (FUNCTION_TYPE
);
1268 TREE_TYPE (vfunc_type
) = integer_type_node
;
1269 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
1270 layout_type (vfunc_type
);
1272 vtable_entry_type
= build_pointer_type (vfunc_type
);
1276 create_tmp_var (build_pointer_type
1277 (build_pointer_type (vtable_entry_type
)), "vptr");
1279 /* The vptr is always at offset zero in the object. */
1280 stmt
= gimple_build_assign (vtabletmp
,
1281 build1 (NOP_EXPR
, TREE_TYPE (vtabletmp
),
1283 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1284 mark_symbols_for_renaming (stmt
);
1285 find_referenced_vars_in (stmt
);
1287 /* Form the vtable address. */
1288 vtabletmp2
= create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp
)),
1290 stmt
= gimple_build_assign (vtabletmp2
,
1291 build1 (INDIRECT_REF
,
1292 TREE_TYPE (vtabletmp2
), vtabletmp
));
1293 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1294 mark_symbols_for_renaming (stmt
);
1295 find_referenced_vars_in (stmt
);
1297 /* Find the entry with the vcall offset. */
1298 stmt
= gimple_build_assign (vtabletmp2
,
1299 fold_build2_loc (input_location
,
1301 TREE_TYPE (vtabletmp2
),
1303 fold_convert (sizetype
,
1305 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1307 /* Get the offset itself. */
1308 vtabletmp3
= create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp2
)),
1310 stmt
= gimple_build_assign (vtabletmp3
,
1311 build1 (INDIRECT_REF
,
1312 TREE_TYPE (vtabletmp3
),
1314 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1315 mark_symbols_for_renaming (stmt
);
1316 find_referenced_vars_in (stmt
);
1318 /* Cast to sizetype. */
1319 offsettmp
= create_tmp_var (sizetype
, "offset");
1320 stmt
= gimple_build_assign (offsettmp
, fold_convert (sizetype
, vtabletmp3
));
1321 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1322 mark_symbols_for_renaming (stmt
);
1323 find_referenced_vars_in (stmt
);
1325 /* Adjust the `this' pointer. */
1326 ptr
= fold_build2_loc (input_location
,
1327 POINTER_PLUS_EXPR
, TREE_TYPE (ptr
), ptr
,
1332 && fixed_offset
!= 0)
1333 /* Adjust the pointer by the constant. */
1337 if (TREE_CODE (ptr
) == VAR_DECL
)
1341 ptrtmp
= create_tmp_var (TREE_TYPE (ptr
), "ptr");
1342 stmt
= gimple_build_assign (ptrtmp
, ptr
);
1343 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1344 mark_symbols_for_renaming (stmt
);
1345 find_referenced_vars_in (stmt
);
1347 ptr
= fold_build2_loc (input_location
,
1348 POINTER_PLUS_EXPR
, TREE_TYPE (ptrtmp
), ptrtmp
,
1349 size_int (fixed_offset
));
1352 /* Emit the statement and gimplify the adjustment expression. */
1353 ret
= create_tmp_var (TREE_TYPE (ptr
), "adjusted_this");
1354 stmt
= gimple_build_assign (ret
, ptr
);
1355 mark_symbols_for_renaming (stmt
);
1356 find_referenced_vars_in (stmt
);
1357 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1362 /* Produce assembler for thunk NODE. */
1365 assemble_thunk (struct cgraph_node
*node
)
1367 bool this_adjusting
= node
->thunk
.this_adjusting
;
1368 HOST_WIDE_INT fixed_offset
= node
->thunk
.fixed_offset
;
1369 HOST_WIDE_INT virtual_value
= node
->thunk
.virtual_value
;
1370 tree virtual_offset
= NULL
;
1371 tree alias
= node
->thunk
.alias
;
1372 tree thunk_fndecl
= node
->decl
;
1373 tree a
= DECL_ARGUMENTS (thunk_fndecl
);
1375 current_function_decl
= thunk_fndecl
;
1378 && targetm
.asm_out
.can_output_mi_thunk (thunk_fndecl
, fixed_offset
,
1379 virtual_value
, alias
))
1384 DECL_RESULT (thunk_fndecl
)
1385 = build_decl (DECL_SOURCE_LOCATION (thunk_fndecl
),
1386 RESULT_DECL
, 0, integer_type_node
);
1387 fnname
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk_fndecl
));
1389 /* The back end expects DECL_INITIAL to contain a BLOCK, so we
1391 fn_block
= make_node (BLOCK
);
1392 BLOCK_VARS (fn_block
) = a
;
1393 DECL_INITIAL (thunk_fndecl
) = fn_block
;
1394 init_function_start (thunk_fndecl
);
1396 assemble_start_function (thunk_fndecl
, fnname
);
1398 targetm
.asm_out
.output_mi_thunk (asm_out_file
, thunk_fndecl
,
1399 fixed_offset
, virtual_value
, alias
);
1401 assemble_end_function (thunk_fndecl
, fnname
);
1402 init_insn_lengths ();
1403 free_after_compilation (cfun
);
1405 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
1410 basic_block bb
, then_bb
, else_bb
, return_bb
;
1411 gimple_stmt_iterator bsi
;
1417 VEC(tree
, heap
) *vargs
;
1422 DECL_IGNORED_P (thunk_fndecl
) = 1;
1423 bitmap_obstack_initialize (NULL
);
1425 if (node
->thunk
.virtual_offset_p
)
1426 virtual_offset
= size_int (virtual_value
);
1428 /* Build the return declaration for the function. */
1429 restype
= TREE_TYPE (TREE_TYPE (thunk_fndecl
));
1430 if (DECL_RESULT (thunk_fndecl
) == NULL_TREE
)
1432 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
1433 DECL_ARTIFICIAL (resdecl
) = 1;
1434 DECL_IGNORED_P (resdecl
) = 1;
1435 DECL_RESULT (thunk_fndecl
) = resdecl
;
1438 resdecl
= DECL_RESULT (thunk_fndecl
);
1440 bb
= then_bb
= else_bb
= return_bb
= init_lowered_empty_function (thunk_fndecl
);
1442 bsi
= gsi_start_bb (bb
);
1444 /* Build call to the function being thunked. */
1445 if (!VOID_TYPE_P (restype
))
1447 if (!is_gimple_reg_type (restype
))
1450 cfun
->local_decls
= tree_cons (NULL_TREE
, restmp
, cfun
->local_decls
);
1451 BLOCK_VARS (DECL_INITIAL (current_function_decl
)) = restmp
;
1454 restmp
= create_tmp_var_raw (restype
, "retval");
1457 for (arg
= a
; arg
; arg
= TREE_CHAIN (arg
))
1459 vargs
= VEC_alloc (tree
, heap
, nargs
);
1461 VEC_quick_push (tree
, vargs
,
1466 VEC_quick_push (tree
, vargs
, a
);
1467 for (i
= 1, arg
= TREE_CHAIN (a
); i
< nargs
; i
++, arg
= TREE_CHAIN (arg
))
1468 VEC_quick_push (tree
, vargs
, arg
);
1469 call
= gimple_build_call_vec (build_fold_addr_expr_loc (0, alias
), vargs
);
1470 VEC_free (tree
, heap
, vargs
);
1471 gimple_call_set_cannot_inline (call
, true);
1472 gimple_call_set_from_thunk (call
, true);
1474 gimple_call_set_lhs (call
, restmp
);
1475 gsi_insert_after (&bsi
, call
, GSI_NEW_STMT
);
1476 mark_symbols_for_renaming (call
);
1477 find_referenced_vars_in (call
);
1480 if (restmp
&& !this_adjusting
)
1482 tree true_label
= NULL_TREE
;
1484 if (TREE_CODE (TREE_TYPE (restmp
)) == POINTER_TYPE
)
1487 /* If the return type is a pointer, we need to
1488 protect against NULL. We know there will be an
1489 adjustment, because that's why we're emitting a
1491 then_bb
= create_basic_block (NULL
, (void *) 0, bb
);
1492 return_bb
= create_basic_block (NULL
, (void *) 0, then_bb
);
1493 else_bb
= create_basic_block (NULL
, (void *) 0, else_bb
);
1494 remove_edge (single_succ_edge (bb
));
1495 true_label
= gimple_block_label (then_bb
);
1496 stmt
= gimple_build_cond (NE_EXPR
, restmp
,
1497 fold_convert (TREE_TYPE (restmp
),
1499 NULL_TREE
, NULL_TREE
);
1500 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1501 make_edge (bb
, then_bb
, EDGE_TRUE_VALUE
);
1502 make_edge (bb
, else_bb
, EDGE_FALSE_VALUE
);
1503 make_edge (return_bb
, EXIT_BLOCK_PTR
, 0);
1504 make_edge (then_bb
, return_bb
, EDGE_FALLTHRU
);
1505 make_edge (else_bb
, return_bb
, EDGE_FALLTHRU
);
1506 bsi
= gsi_last_bb (then_bb
);
1509 restmp
= thunk_adjust (&bsi
, restmp
, /*this_adjusting=*/0,
1510 fixed_offset
, virtual_offset
);
1514 bsi
= gsi_last_bb (else_bb
);
1515 stmt
= gimple_build_assign (restmp
, fold_convert (TREE_TYPE (restmp
),
1516 integer_zero_node
));
1517 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1518 bsi
= gsi_last_bb (return_bb
);
1522 gimple_call_set_tail (call
, true);
1524 /* Build return value. */
1525 ret
= gimple_build_return (restmp
);
1526 gsi_insert_after (&bsi
, ret
, GSI_NEW_STMT
);
1528 delete_unreachable_blocks ();
1529 update_ssa (TODO_update_ssa
);
1531 cgraph_remove_same_body_alias (node
);
1532 /* Since we want to emit the thunk, we explicitly mark its name as
1534 mark_decl_referenced (thunk_fndecl
);
1535 cgraph_add_new_function (thunk_fndecl
, true);
1536 bitmap_obstack_release (NULL
);
1538 current_function_decl
= NULL
;
1541 /* Expand function specified by NODE. */
1544 cgraph_expand_function (struct cgraph_node
*node
)
1546 tree decl
= node
->decl
;
1548 /* We ought to not compile any inline clones. */
1549 gcc_assert (!node
->global
.inlined_to
);
1551 announce_function (decl
);
1554 gcc_assert (node
->lowered
);
1556 /* Generate RTL for the body of DECL. */
1557 tree_rest_of_compilation (decl
);
1559 /* Make sure that BE didn't give up on compiling. */
1560 gcc_assert (TREE_ASM_WRITTEN (decl
));
1561 current_function_decl
= NULL
;
1562 if (node
->same_body
)
1564 struct cgraph_node
*alias
, *next
;
1565 bool saved_alias
= node
->alias
;
1566 for (alias
= node
->same_body
;
1567 alias
&& alias
->next
; alias
= alias
->next
)
1569 /* Walk aliases in the order they were created; it is possible that
1570 thunks reffers to the aliases made earlier. */
1571 for (; alias
; alias
= next
)
1573 next
= alias
->previous
;
1574 if (!alias
->thunk
.thunk_p
)
1575 assemble_alias (alias
->decl
,
1576 DECL_ASSEMBLER_NAME (alias
->thunk
.alias
));
1578 assemble_thunk (alias
);
1580 node
->alias
= saved_alias
;
1582 gcc_assert (!cgraph_preserve_function_body_p (decl
));
1583 cgraph_release_function_body (node
);
1584 /* Eliminate all call edges. This is important so the GIMPLE_CALL no longer
1585 points to the dead function body. */
1586 cgraph_node_remove_callees (node
);
1588 cgraph_function_flags_ready
= true;
1591 /* Return true when CALLER_DECL should be inlined into CALLEE_DECL. */
1594 cgraph_inline_p (struct cgraph_edge
*e
, cgraph_inline_failed_t
*reason
)
1596 *reason
= e
->inline_failed
;
1597 return !e
->inline_failed
;
1602 /* Expand all functions that must be output.
1604 Attempt to topologically sort the nodes so function is output when
1605 all called functions are already assembled to allow data to be
1606 propagated across the callgraph. Use a stack to get smaller distance
1607 between a function and its callees (later we may choose to use a more
1608 sophisticated algorithm for function reordering; we will likely want
1609 to use subsections to make the output functions appear in top-down
1613 cgraph_expand_all_functions (void)
1615 struct cgraph_node
*node
;
1616 struct cgraph_node
**order
= XCNEWVEC (struct cgraph_node
*, cgraph_n_nodes
);
1617 int order_pos
, new_order_pos
= 0;
1620 order_pos
= cgraph_postorder (order
);
1621 gcc_assert (order_pos
== cgraph_n_nodes
);
1623 /* Garbage collector may remove inline clones we eliminate during
1624 optimization. So we must be sure to not reference them. */
1625 for (i
= 0; i
< order_pos
; i
++)
1626 if (order
[i
]->process
)
1627 order
[new_order_pos
++] = order
[i
];
1629 for (i
= new_order_pos
- 1; i
>= 0; i
--)
1634 gcc_assert (node
->reachable
);
1636 cgraph_expand_function (node
);
1639 cgraph_process_new_functions ();
1645 /* This is used to sort the node types by the cgraph order number. */
1647 enum cgraph_order_sort_kind
1649 ORDER_UNDEFINED
= 0,
1655 struct cgraph_order_sort
1657 enum cgraph_order_sort_kind kind
;
1660 struct cgraph_node
*f
;
1661 struct varpool_node
*v
;
1662 struct cgraph_asm_node
*a
;
1666 /* Output all functions, variables, and asm statements in the order
1667 according to their order fields, which is the order in which they
1668 appeared in the file. This implements -fno-toplevel-reorder. In
1669 this mode we may output functions and variables which don't really
1670 need to be output. */
1673 cgraph_output_in_order (void)
1676 struct cgraph_order_sort
*nodes
;
1678 struct cgraph_node
*pf
;
1679 struct varpool_node
*pv
;
1680 struct cgraph_asm_node
*pa
;
1683 nodes
= XCNEWVEC (struct cgraph_order_sort
, max
);
1685 varpool_analyze_pending_decls ();
1687 for (pf
= cgraph_nodes
; pf
; pf
= pf
->next
)
1692 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1693 nodes
[i
].kind
= ORDER_FUNCTION
;
1698 for (pv
= varpool_nodes_queue
; pv
; pv
= pv
->next_needed
)
1701 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1702 nodes
[i
].kind
= ORDER_VAR
;
1706 for (pa
= cgraph_asm_nodes
; pa
; pa
= pa
->next
)
1709 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1710 nodes
[i
].kind
= ORDER_ASM
;
1714 /* In toplevel reorder mode we output all statics; mark them as needed. */
1715 for (i
= 0; i
< max
; ++i
)
1717 if (nodes
[i
].kind
== ORDER_VAR
)
1719 varpool_mark_needed_node (nodes
[i
].u
.v
);
1722 varpool_empty_needed_queue ();
1724 for (i
= 0; i
< max
; ++i
)
1726 switch (nodes
[i
].kind
)
1728 case ORDER_FUNCTION
:
1729 nodes
[i
].u
.f
->process
= 0;
1730 cgraph_expand_function (nodes
[i
].u
.f
);
1734 varpool_assemble_decl (nodes
[i
].u
.v
);
1738 assemble_asm (nodes
[i
].u
.a
->asm_str
);
1741 case ORDER_UNDEFINED
:
1749 cgraph_asm_nodes
= NULL
;
1753 /* Return true when function body of DECL still needs to be kept around
1754 for later re-use. */
1756 cgraph_preserve_function_body_p (tree decl
)
1758 struct cgraph_node
*node
;
1760 gcc_assert (cgraph_global_info_ready
);
1761 /* Look if there is any clone around. */
1762 node
= cgraph_node (decl
);
1772 current_function_decl
= NULL
;
1773 gimple_register_cfg_hooks ();
1774 bitmap_obstack_initialize (NULL
);
1776 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_START
, NULL
);
1779 execute_ipa_pass_list (all_small_ipa_passes
);
1781 /* If pass_all_early_optimizations was not scheduled, the state of
1782 the cgraph will not be properly updated. Update it now. */
1783 if (cgraph_state
< CGRAPH_STATE_IPA_SSA
)
1784 cgraph_state
= CGRAPH_STATE_IPA_SSA
;
1788 /* Generate coverage variables and constructors. */
1791 /* Process new functions added. */
1793 current_function_decl
= NULL
;
1794 cgraph_process_new_functions ();
1796 execute_ipa_summary_passes
1797 ((struct ipa_opt_pass_d
*) all_regular_ipa_passes
);
1799 execute_ipa_summary_passes ((struct ipa_opt_pass_d
*) all_lto_gen_passes
);
1802 ipa_write_summaries ();
1805 execute_ipa_pass_list (all_regular_ipa_passes
);
1806 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_END
, NULL
);
1808 bitmap_obstack_release (NULL
);
1812 /* Perform simple optimizations based on callgraph. */
1815 cgraph_optimize (void)
1817 if (errorcount
|| sorrycount
)
1820 #ifdef ENABLE_CHECKING
1824 /* Frontend may output common variables after the unit has been finalized.
1825 It is safe to deal with them here as they are always zero initialized. */
1826 varpool_analyze_pending_decls ();
1828 timevar_push (TV_CGRAPHOPT
);
1829 if (pre_ipa_mem_report
)
1831 fprintf (stderr
, "Memory consumption before IPA\n");
1832 dump_memory_report (false);
1835 fprintf (stderr
, "Performing interprocedural optimizations\n");
1836 cgraph_state
= CGRAPH_STATE_IPA
;
1838 /* Don't run the IPA passes if there was any error or sorry messages. */
1839 if (errorcount
== 0 && sorrycount
== 0)
1842 /* Do nothing else if any IPA pass found errors. */
1843 if (errorcount
|| sorrycount
)
1845 timevar_pop (TV_CGRAPHOPT
);
1849 /* This pass remove bodies of extern inline functions we never inlined.
1850 Do this later so other IPA passes see what is really going on. */
1851 cgraph_remove_unreachable_nodes (false, dump_file
);
1852 cgraph_global_info_ready
= true;
1853 if (cgraph_dump_file
)
1855 fprintf (cgraph_dump_file
, "Optimized ");
1856 dump_cgraph (cgraph_dump_file
);
1857 dump_varpool (cgraph_dump_file
);
1859 if (post_ipa_mem_report
)
1861 fprintf (stderr
, "Memory consumption after IPA\n");
1862 dump_memory_report (false);
1864 timevar_pop (TV_CGRAPHOPT
);
1866 /* Output everything. */
1867 (*debug_hooks
->assembly_start
) ();
1869 fprintf (stderr
, "Assembling functions:\n");
1870 #ifdef ENABLE_CHECKING
1874 cgraph_materialize_all_clones ();
1875 cgraph_mark_functions_to_output ();
1877 cgraph_state
= CGRAPH_STATE_EXPANSION
;
1878 if (!flag_toplevel_reorder
)
1879 cgraph_output_in_order ();
1882 cgraph_output_pending_asms ();
1884 cgraph_expand_all_functions ();
1885 varpool_remove_unreferenced_decls ();
1887 varpool_assemble_pending_decls ();
1889 cgraph_process_new_functions ();
1890 cgraph_state
= CGRAPH_STATE_FINISHED
;
1892 if (cgraph_dump_file
)
1894 fprintf (cgraph_dump_file
, "\nFinal ");
1895 dump_cgraph (cgraph_dump_file
);
1897 #ifdef ENABLE_CHECKING
1899 /* Double check that all inline clones are gone and that all
1900 function bodies have been released from memory. */
1901 if (!(sorrycount
|| errorcount
))
1903 struct cgraph_node
*node
;
1904 bool error_found
= false;
1906 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1908 && (node
->global
.inlined_to
1909 || gimple_has_body_p (node
->decl
)))
1912 dump_cgraph_node (stderr
, node
);
1915 internal_error ("nodes with unreleased memory found");
1921 /* Generate and emit a static constructor or destructor. WHICH must
1922 be one of 'I' (for a constructor) or 'D' (for a destructor). BODY
1923 is a STATEMENT_LIST containing GENERIC statements. PRIORITY is the
1924 initialization priority for this constructor or destructor. */
1927 cgraph_build_static_cdtor (char which
, tree body
, int priority
)
1929 static int counter
= 0;
1931 tree decl
, name
, resdecl
;
1933 /* The priority is encoded in the constructor or destructor name.
1934 collect2 will sort the names and arrange that they are called at
1936 sprintf (which_buf
, "%c_%.5d_%d", which
, priority
, counter
++);
1937 name
= get_file_function_name (which_buf
);
1939 decl
= build_decl (input_location
, FUNCTION_DECL
, name
,
1940 build_function_type (void_type_node
, void_list_node
));
1941 current_function_decl
= decl
;
1943 resdecl
= build_decl (input_location
,
1944 RESULT_DECL
, NULL_TREE
, void_type_node
);
1945 DECL_ARTIFICIAL (resdecl
) = 1;
1946 DECL_RESULT (decl
) = resdecl
;
1947 DECL_CONTEXT (resdecl
) = decl
;
1949 allocate_struct_function (decl
, false);
1951 TREE_STATIC (decl
) = 1;
1952 TREE_USED (decl
) = 1;
1953 DECL_ARTIFICIAL (decl
) = 1;
1954 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
1955 DECL_SAVED_TREE (decl
) = body
;
1956 if (!targetm
.have_ctors_dtors
)
1958 TREE_PUBLIC (decl
) = 1;
1959 DECL_PRESERVE_P (decl
) = 1;
1961 DECL_UNINLINABLE (decl
) = 1;
1963 DECL_INITIAL (decl
) = make_node (BLOCK
);
1964 TREE_USED (DECL_INITIAL (decl
)) = 1;
1966 DECL_SOURCE_LOCATION (decl
) = input_location
;
1967 cfun
->function_end_locus
= input_location
;
1972 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
1973 decl_init_priority_insert (decl
, priority
);
1976 DECL_STATIC_DESTRUCTOR (decl
) = 1;
1977 decl_fini_priority_insert (decl
, priority
);
1983 gimplify_function_tree (decl
);
1985 cgraph_add_new_function (decl
, false);
1986 cgraph_mark_needed_node (cgraph_node (decl
));
1993 cgraph_dump_file
= dump_begin (TDI_cgraph
, NULL
);
1996 /* The edges representing the callers of the NEW_VERSION node were
1997 fixed by cgraph_function_versioning (), now the call_expr in their
1998 respective tree code should be updated to call the NEW_VERSION. */
2001 update_call_expr (struct cgraph_node
*new_version
)
2003 struct cgraph_edge
*e
;
2005 gcc_assert (new_version
);
2007 /* Update the call expr on the edges to call the new version. */
2008 for (e
= new_version
->callers
; e
; e
= e
->next_caller
)
2010 struct function
*inner_function
= DECL_STRUCT_FUNCTION (e
->caller
->decl
);
2011 gimple_call_set_fndecl (e
->call_stmt
, new_version
->decl
);
2012 maybe_clean_eh_stmt_fn (inner_function
, e
->call_stmt
);
2017 /* Create a new cgraph node which is the new version of
2018 OLD_VERSION node. REDIRECT_CALLERS holds the callers
2019 edges which should be redirected to point to
2020 NEW_VERSION. ALL the callees edges of OLD_VERSION
2021 are cloned to the new version node. Return the new
2024 static struct cgraph_node
*
2025 cgraph_copy_node_for_versioning (struct cgraph_node
*old_version
,
2027 VEC(cgraph_edge_p
,heap
) *redirect_callers
)
2029 struct cgraph_node
*new_version
;
2030 struct cgraph_edge
*e
, *new_e
;
2031 struct cgraph_edge
*next_callee
;
2034 gcc_assert (old_version
);
2036 new_version
= cgraph_node (new_decl
);
2038 new_version
->analyzed
= true;
2039 new_version
->local
= old_version
->local
;
2040 new_version
->global
= old_version
->global
;
2041 new_version
->rtl
= new_version
->rtl
;
2042 new_version
->reachable
= true;
2043 new_version
->count
= old_version
->count
;
2045 /* Clone the old node callees. Recursive calls are
2047 for (e
= old_version
->callees
;e
; e
=e
->next_callee
)
2049 new_e
= cgraph_clone_edge (e
, new_version
, e
->call_stmt
,
2050 e
->lto_stmt_uid
, 0, e
->frequency
,
2051 e
->loop_nest
, true);
2052 new_e
->count
= e
->count
;
2054 /* Fix recursive calls.
2055 If OLD_VERSION has a recursive call after the
2056 previous edge cloning, the new version will have an edge
2057 pointing to the old version, which is wrong;
2058 Redirect it to point to the new version. */
2059 for (e
= new_version
->callees
; e
; e
= next_callee
)
2061 next_callee
= e
->next_callee
;
2062 if (e
->callee
== old_version
)
2063 cgraph_redirect_edge_callee (e
, new_version
);
2068 for (i
= 0; VEC_iterate (cgraph_edge_p
, redirect_callers
, i
, e
); i
++)
2070 /* Redirect calls to the old version node to point to its new
2072 cgraph_redirect_edge_callee (e
, new_version
);
2078 /* Perform function versioning.
2079 Function versioning includes copying of the tree and
2080 a callgraph update (creating a new cgraph node and updating
2081 its callees and callers).
2083 REDIRECT_CALLERS varray includes the edges to be redirected
2086 TREE_MAP is a mapping of tree nodes we want to replace with
2087 new ones (according to results of prior analysis).
2088 OLD_VERSION_NODE is the node that is versioned.
2089 It returns the new version's cgraph node.
2090 ARGS_TO_SKIP lists arguments to be omitted from functions
2093 struct cgraph_node
*
2094 cgraph_function_versioning (struct cgraph_node
*old_version_node
,
2095 VEC(cgraph_edge_p
,heap
) *redirect_callers
,
2096 VEC (ipa_replace_map_p
,gc
)* tree_map
,
2097 bitmap args_to_skip
)
2099 tree old_decl
= old_version_node
->decl
;
2100 struct cgraph_node
*new_version_node
= NULL
;
2103 if (!tree_versionable_function_p (old_decl
))
2106 /* Make a new FUNCTION_DECL tree node for the
2109 new_decl
= copy_node (old_decl
);
2111 new_decl
= build_function_decl_skip_args (old_decl
, args_to_skip
);
2113 /* Create the new version's call-graph node.
2114 and update the edges of the new node. */
2116 cgraph_copy_node_for_versioning (old_version_node
, new_decl
,
2119 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2120 tree_function_versioning (old_decl
, new_decl
, tree_map
, false, args_to_skip
);
2122 /* Update the new version's properties.
2123 Make The new version visible only within this translation unit. Make sure
2124 that is not weak also.
2125 ??? We cannot use COMDAT linkage because there is no
2126 ABI support for this. */
2127 cgraph_make_decl_local (new_version_node
->decl
);
2128 DECL_VIRTUAL_P (new_version_node
->decl
) = 0;
2129 new_version_node
->local
.externally_visible
= 0;
2130 new_version_node
->local
.local
= 1;
2131 new_version_node
->lowered
= true;
2133 /* Update the call_expr on the edges to call the new version node. */
2134 update_call_expr (new_version_node
);
2136 cgraph_call_function_insertion_hooks (new_version_node
);
2137 return new_version_node
;
2140 /* Produce separate function body for inline clones so the offline copy can be
2141 modified without affecting them. */
2142 struct cgraph_node
*
2143 save_inline_function_body (struct cgraph_node
*node
)
2145 struct cgraph_node
*first_clone
, *n
;
2147 gcc_assert (node
== cgraph_node (node
->decl
));
2149 cgraph_lower_function (node
);
2151 first_clone
= node
->clones
;
2153 first_clone
->decl
= copy_node (node
->decl
);
2154 cgraph_insert_node_to_hashtable (first_clone
);
2155 gcc_assert (first_clone
== cgraph_node (first_clone
->decl
));
2156 if (first_clone
->next_sibling_clone
)
2158 for (n
= first_clone
->next_sibling_clone
; n
->next_sibling_clone
; n
= n
->next_sibling_clone
)
2159 n
->clone_of
= first_clone
;
2160 n
->clone_of
= first_clone
;
2161 n
->next_sibling_clone
= first_clone
->clones
;
2162 if (first_clone
->clones
)
2163 first_clone
->clones
->prev_sibling_clone
= n
;
2164 first_clone
->clones
= first_clone
->next_sibling_clone
;
2165 first_clone
->next_sibling_clone
->prev_sibling_clone
= NULL
;
2166 first_clone
->next_sibling_clone
= NULL
;
2167 gcc_assert (!first_clone
->prev_sibling_clone
);
2169 first_clone
->clone_of
= NULL
;
2170 node
->clones
= NULL
;
2172 if (first_clone
->clones
)
2173 for (n
= first_clone
->clones
; n
!= first_clone
;)
2175 gcc_assert (n
->decl
== node
->decl
);
2176 n
->decl
= first_clone
->decl
;
2179 else if (n
->next_sibling_clone
)
2180 n
= n
->next_sibling_clone
;
2183 while (n
!= first_clone
&& !n
->next_sibling_clone
)
2185 if (n
!= first_clone
)
2186 n
= n
->next_sibling_clone
;
2190 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2191 tree_function_versioning (node
->decl
, first_clone
->decl
, NULL
, true, NULL
);
2193 DECL_EXTERNAL (first_clone
->decl
) = 0;
2194 DECL_COMDAT_GROUP (first_clone
->decl
) = NULL_TREE
;
2195 TREE_PUBLIC (first_clone
->decl
) = 0;
2196 DECL_COMDAT (first_clone
->decl
) = 0;
2197 VEC_free (ipa_opt_pass
, heap
,
2198 first_clone
->ipa_transforms_to_apply
);
2199 first_clone
->ipa_transforms_to_apply
= NULL
;
2201 #ifdef ENABLE_CHECKING
2202 verify_cgraph_node (first_clone
);
2207 /* Given virtual clone, turn it into actual clone. */
2209 cgraph_materialize_clone (struct cgraph_node
*node
)
2211 bitmap_obstack_initialize (NULL
);
2212 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2213 tree_function_versioning (node
->clone_of
->decl
, node
->decl
,
2214 node
->clone
.tree_map
, true,
2215 node
->clone
.args_to_skip
);
2216 if (cgraph_dump_file
)
2218 dump_function_to_file (node
->clone_of
->decl
, cgraph_dump_file
, dump_flags
);
2219 dump_function_to_file (node
->decl
, cgraph_dump_file
, dump_flags
);
2222 /* Function is no longer clone. */
2223 if (node
->next_sibling_clone
)
2224 node
->next_sibling_clone
->prev_sibling_clone
= node
->prev_sibling_clone
;
2225 if (node
->prev_sibling_clone
)
2226 node
->prev_sibling_clone
->next_sibling_clone
= node
->next_sibling_clone
;
2228 node
->clone_of
->clones
= node
->next_sibling_clone
;
2229 node
->next_sibling_clone
= NULL
;
2230 node
->prev_sibling_clone
= NULL
;
2231 if (!node
->clone_of
->analyzed
&& !node
->clone_of
->clones
)
2232 cgraph_remove_node (node
->clone_of
);
2233 node
->clone_of
= NULL
;
2234 bitmap_obstack_release (NULL
);
2237 /* If necessary, change the function declaration in the call statement
2238 associated with E so that it corresponds to the edge callee. */
2241 cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge
*e
)
2243 tree decl
= gimple_call_fndecl (e
->call_stmt
);
2245 gimple_stmt_iterator gsi
;
2247 if (!decl
|| decl
== e
->callee
->decl
2248 /* Don't update call from same body alias to the real function. */
2249 || cgraph_get_node (decl
) == cgraph_get_node (e
->callee
->decl
))
2250 return e
->call_stmt
;
2252 if (cgraph_dump_file
)
2254 fprintf (cgraph_dump_file
, "updating call of %s/%i -> %s/%i: ",
2255 cgraph_node_name (e
->caller
), e
->caller
->uid
,
2256 cgraph_node_name (e
->callee
), e
->callee
->uid
);
2257 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
2260 if (e
->callee
->clone
.combined_args_to_skip
)
2261 new_stmt
= gimple_call_copy_skip_args (e
->call_stmt
,
2262 e
->callee
->clone
.combined_args_to_skip
);
2264 new_stmt
= e
->call_stmt
;
2265 if (gimple_vdef (new_stmt
)
2266 && TREE_CODE (gimple_vdef (new_stmt
)) == SSA_NAME
)
2267 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt
)) = new_stmt
;
2268 gimple_call_set_fndecl (new_stmt
, e
->callee
->decl
);
2270 gsi
= gsi_for_stmt (e
->call_stmt
);
2271 gsi_replace (&gsi
, new_stmt
, true);
2272 update_stmt (new_stmt
);
2274 /* Update EH information too, just in case. */
2275 maybe_clean_or_replace_eh_stmt (e
->call_stmt
, new_stmt
);
2277 cgraph_set_call_stmt_including_clones (e
->caller
, e
->call_stmt
, new_stmt
);
2279 if (cgraph_dump_file
)
2281 fprintf (cgraph_dump_file
, " updated to:");
2282 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
2287 /* Once all functions from compilation unit are in memory, produce all clones
2288 and update all calls. We might also do this on demand if we don't want to
2289 bring all functions to memory prior compilation, but current WHOPR
2290 implementation does that and it is is bit easier to keep everything right in
2293 cgraph_materialize_all_clones (void)
2295 struct cgraph_node
*node
;
2296 bool stabilized
= false;
2298 if (cgraph_dump_file
)
2299 fprintf (cgraph_dump_file
, "Materializing clones\n");
2300 #ifdef ENABLE_CHECKING
2304 /* We can also do topological order, but number of iterations should be
2305 bounded by number of IPA passes since single IPA pass is probably not
2306 going to create clones of clones it created itself. */
2310 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2312 if (node
->clone_of
&& node
->decl
!= node
->clone_of
->decl
2313 && !gimple_has_body_p (node
->decl
))
2315 if (gimple_has_body_p (node
->clone_of
->decl
))
2317 if (cgraph_dump_file
)
2319 fprintf (cgraph_dump_file
, "clonning %s to %s\n",
2320 cgraph_node_name (node
->clone_of
),
2321 cgraph_node_name (node
));
2322 if (node
->clone
.tree_map
)
2325 fprintf (cgraph_dump_file
, " replace map: ");
2326 for (i
= 0; i
< VEC_length (ipa_replace_map_p
,
2327 node
->clone
.tree_map
);
2330 struct ipa_replace_map
*replace_info
;
2331 replace_info
= VEC_index (ipa_replace_map_p
,
2332 node
->clone
.tree_map
,
2334 print_generic_expr (cgraph_dump_file
, replace_info
->old_tree
, 0);
2335 fprintf (cgraph_dump_file
, " -> ");
2336 print_generic_expr (cgraph_dump_file
, replace_info
->new_tree
, 0);
2337 fprintf (cgraph_dump_file
, "%s%s;",
2338 replace_info
->replace_p
? "(replace)":"",
2339 replace_info
->ref_p
? "(ref)":"");
2341 fprintf (cgraph_dump_file
, "\n");
2343 if (node
->clone
.args_to_skip
)
2345 fprintf (cgraph_dump_file
, " args_to_skip: ");
2346 dump_bitmap (cgraph_dump_file
, node
->clone
.args_to_skip
);
2348 if (node
->clone
.args_to_skip
)
2350 fprintf (cgraph_dump_file
, " combined_args_to_skip:");
2351 dump_bitmap (cgraph_dump_file
, node
->clone
.combined_args_to_skip
);
2354 cgraph_materialize_clone (node
);
2361 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2362 if (!node
->analyzed
&& node
->callees
)
2363 cgraph_node_remove_callees (node
);
2364 if (cgraph_dump_file
)
2365 fprintf (cgraph_dump_file
, "Updating call sites\n");
2366 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2367 if (node
->analyzed
&& !node
->clone_of
2368 && gimple_has_body_p (node
->decl
))
2370 struct cgraph_edge
*e
;
2372 current_function_decl
= node
->decl
;
2373 push_cfun (DECL_STRUCT_FUNCTION (node
->decl
));
2374 for (e
= node
->callees
; e
; e
= e
->next_callee
)
2375 cgraph_redirect_edge_call_stmt_to_callee (e
);
2376 gcc_assert (!need_ssa_update_p (cfun
));
2378 current_function_decl
= NULL
;
2379 #ifdef ENABLE_CHECKING
2380 verify_cgraph_node (node
);
2383 if (cgraph_dump_file
)
2384 fprintf (cgraph_dump_file
, "Materialization Call site updates done.\n");
2385 /* All changes to parameters have been performed. In order not to
2386 incorrectly repeat them, we simply dispose of the bitmaps that drive the
2388 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2389 node
->clone
.combined_args_to_skip
= NULL
;
2390 #ifdef ENABLE_CHECKING
2393 cgraph_remove_unreachable_nodes (false, cgraph_dump_file
);
2396 #include "gt-cgraphunit.h"