1 /* Callgraph based interprocedural optimizations.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
3 2011 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"
126 #include "tree-pretty-print.h"
127 #include "gimple-pretty-print.h"
132 #include "function.h"
133 #include "ipa-prop.h"
135 #include "tree-iterator.h"
136 #include "tree-pass.h"
137 #include "tree-dump.h"
139 #include "coverage.h"
142 static void cgraph_expand_all_functions (void);
143 static void cgraph_mark_functions_to_output (void);
144 static void cgraph_expand_function (struct cgraph_node
*);
145 static void cgraph_output_pending_asms (void);
146 static void cgraph_analyze_function (struct cgraph_node
*);
148 FILE *cgraph_dump_file
;
150 /* Used for vtable lookup in thunk adjusting. */
151 static GTY (()) tree vtable_entry_type
;
153 /* Determine if function DECL is needed. That is, visible to something
154 either outside this translation unit, something magic in the system
158 cgraph_decide_is_function_needed (struct cgraph_node
*node
, tree decl
)
160 /* If the user told us it is used, then it must be so. */
161 if (node
->local
.externally_visible
)
164 /* ??? If the assembler name is set by hand, it is possible to assemble
165 the name later after finalizing the function and the fact is noticed
166 in assemble_name then. This is arguably a bug. */
167 if (DECL_ASSEMBLER_NAME_SET_P (decl
)
168 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)))
171 /* With -fkeep-inline-functions we are keeping all inline functions except
172 for extern inline ones. */
173 if (flag_keep_inline_functions
174 && DECL_DECLARED_INLINE_P (decl
)
175 && !DECL_EXTERNAL (decl
)
176 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (decl
)))
179 /* If we decided it was needed before, but at the time we didn't have
180 the body of the function available, then it's still needed. We have
181 to go back and re-check its dependencies now. */
185 /* Externally visible functions must be output. The exception is
186 COMDAT functions that must be output only when they are needed.
188 When not optimizing, also output the static functions. (see
189 PR24561), but don't do so for always_inline functions, functions
190 declared inline and nested functions. These were optimized out
191 in the original implementation and it is unclear whether we want
192 to change the behavior here. */
193 if (((TREE_PUBLIC (decl
)
195 && !node
->local
.disregard_inline_limits
196 && !DECL_DECLARED_INLINE_P (decl
)
197 && !(DECL_CONTEXT (decl
)
198 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
)))
199 && !flag_whole_program
201 && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
))
207 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
208 functions into callgraph in a way so they look like ordinary reachable
209 functions inserted into callgraph already at construction time. */
212 cgraph_process_new_functions (void)
216 struct cgraph_node
*node
;
218 varpool_analyze_pending_decls ();
219 /* Note that this queue may grow as its being processed, as the new
220 functions may generate new ones. */
221 while (cgraph_new_nodes
)
223 node
= cgraph_new_nodes
;
225 cgraph_new_nodes
= cgraph_new_nodes
->next_needed
;
226 switch (cgraph_state
)
228 case CGRAPH_STATE_CONSTRUCTION
:
229 /* At construction time we just need to finalize function and move
230 it into reachable functions list. */
232 node
->next_needed
= NULL
;
233 cgraph_finalize_function (fndecl
, false);
234 cgraph_mark_reachable_node (node
);
238 case CGRAPH_STATE_IPA
:
239 case CGRAPH_STATE_IPA_SSA
:
240 /* When IPA optimization already started, do all essential
241 transformations that has been already performed on the whole
242 cgraph but not on this function. */
244 gimple_register_cfg_hooks ();
246 cgraph_analyze_function (node
);
247 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
248 current_function_decl
= fndecl
;
249 compute_inline_parameters (node
);
250 if ((cgraph_state
== CGRAPH_STATE_IPA_SSA
251 && !gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
252 /* When not optimizing, be sure we run early local passes anyway
255 execute_pass_list (pass_early_local_passes
.pass
.sub
);
256 free_dominance_info (CDI_POST_DOMINATORS
);
257 free_dominance_info (CDI_DOMINATORS
);
259 current_function_decl
= NULL
;
262 case CGRAPH_STATE_EXPANSION
:
263 /* Functions created during expansion shall be compiled
266 cgraph_expand_function (node
);
273 cgraph_call_function_insertion_hooks (node
);
274 varpool_analyze_pending_decls ();
279 /* As an GCC extension we allow redefinition of the function. The
280 semantics when both copies of bodies differ is not well defined.
281 We replace the old body with new body so in unit at a time mode
282 we always use new body, while in normal mode we may end up with
283 old body inlined into some functions and new body expanded and
286 ??? It may make more sense to use one body for inlining and other
287 body for expanding the function but this is difficult to do. */
290 cgraph_reset_node (struct cgraph_node
*node
)
292 /* If node->process is set, then we have already begun whole-unit analysis.
293 This is *not* testing for whether we've already emitted the function.
294 That case can be sort-of legitimately seen with real function redefinition
295 errors. I would argue that the front end should never present us with
296 such a case, but don't enforce that for now. */
297 gcc_assert (!node
->process
);
299 /* Reset our data structures so we can analyze the function again. */
300 memset (&node
->local
, 0, sizeof (node
->local
));
301 memset (&node
->global
, 0, sizeof (node
->global
));
302 memset (&node
->rtl
, 0, sizeof (node
->rtl
));
303 node
->analyzed
= false;
304 node
->local
.redefined_extern_inline
= true;
305 node
->local
.finalized
= false;
307 cgraph_node_remove_callees (node
);
309 /* We may need to re-queue the node for assembling in case
310 we already proceeded it and ignored as not needed or got
311 a re-declaration in IMA mode. */
314 struct cgraph_node
*n
;
316 for (n
= cgraph_nodes_queue
; n
; n
= n
->next_needed
)
325 cgraph_lower_function (struct cgraph_node
*node
)
331 lower_nested_functions (node
->decl
);
332 gcc_assert (!node
->nested
);
334 tree_lowering_passes (node
->decl
);
335 node
->lowered
= true;
338 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
339 logic in effect. If NESTED is true, then our caller cannot stand to have
340 the garbage collector run at the moment. We would need to either create
341 a new GC context, or just not compile right now. */
344 cgraph_finalize_function (tree decl
, bool nested
)
346 struct cgraph_node
*node
= cgraph_node (decl
);
348 if (node
->local
.finalized
)
349 cgraph_reset_node (node
);
351 node
->pid
= cgraph_max_pid
++;
352 notice_global_symbol (decl
);
353 node
->local
.finalized
= true;
354 node
->lowered
= DECL_STRUCT_FUNCTION (decl
)->cfg
!= NULL
;
355 node
->finalized_by_frontend
= true;
357 if (cgraph_decide_is_function_needed (node
, decl
))
358 cgraph_mark_needed_node (node
);
360 /* Since we reclaim unreachable nodes at the end of every language
361 level unit, we need to be conservative about possible entry points
363 if ((TREE_PUBLIC (decl
) && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
))
364 || DECL_STATIC_CONSTRUCTOR (decl
)
365 || DECL_STATIC_DESTRUCTOR (decl
)
366 /* COMDAT virtual functions may be referenced by vtable from
367 other compilatoin unit. Still we want to devirtualize calls
368 to those so we need to analyze them.
369 FIXME: We should introduce may edges for this purpose and update
370 their handling in unreachable function removal and inliner too. */
371 || (DECL_VIRTUAL_P (decl
) && (DECL_COMDAT (decl
) || DECL_EXTERNAL (decl
))))
372 cgraph_mark_reachable_node (node
);
374 /* If we've not yet emitted decl, tell the debug info about it. */
375 if (!TREE_ASM_WRITTEN (decl
))
376 (*debug_hooks
->deferred_inline_function
) (decl
);
378 /* Possibly warn about unused parameters. */
379 if (warn_unused_parameter
)
380 do_warn_unused_parameter (decl
);
386 /* C99 extern inline keywords allow changing of declaration after function
387 has been finalized. We need to re-decide if we want to mark the function as
391 cgraph_mark_if_needed (tree decl
)
393 struct cgraph_node
*node
= cgraph_node (decl
);
394 if (node
->local
.finalized
&& cgraph_decide_is_function_needed (node
, decl
))
395 cgraph_mark_needed_node (node
);
398 /* Return TRUE if NODE2 is equivalent to NODE or its clone. */
400 clone_of_p (struct cgraph_node
*node
, struct cgraph_node
*node2
)
402 while (node
!= node2
&& node2
)
403 node2
= node2
->clone_of
;
404 return node2
!= NULL
;
407 /* Verify edge E count and frequency. */
410 verify_edge_count_and_frequency (struct cgraph_edge
*e
)
412 bool error_found
= false;
415 error ("caller edge count is negative");
418 if (e
->frequency
< 0)
420 error ("caller edge frequency is negative");
423 if (e
->frequency
> CGRAPH_FREQ_MAX
)
425 error ("caller edge frequency is too large");
428 if (gimple_has_body_p (e
->caller
->decl
)
429 && !e
->caller
->global
.inlined_to
431 != compute_call_stmt_bb_frequency (e
->caller
->decl
,
432 gimple_bb (e
->call_stmt
))))
434 error ("caller edge frequency %i does not match BB freqency %i",
436 compute_call_stmt_bb_frequency (e
->caller
->decl
,
437 gimple_bb (e
->call_stmt
)));
443 /* Verify cgraph nodes of given cgraph node. */
445 verify_cgraph_node (struct cgraph_node
*node
)
447 struct cgraph_edge
*e
;
448 struct function
*this_cfun
= DECL_STRUCT_FUNCTION (node
->decl
);
449 struct function
*saved_cfun
= cfun
;
450 basic_block this_block
;
451 gimple_stmt_iterator gsi
;
452 bool error_found
= false;
457 timevar_push (TV_CGRAPH_VERIFY
);
458 /* debug_generic_stmt needs correct cfun */
459 set_cfun (this_cfun
);
460 for (e
= node
->callees
; e
; e
= e
->next_callee
)
463 error ("aux field set for edge %s->%s",
464 identifier_to_locale (cgraph_node_name (e
->caller
)),
465 identifier_to_locale (cgraph_node_name (e
->callee
)));
470 error ("execution count is negative");
473 if (node
->global
.inlined_to
&& node
->local
.externally_visible
)
475 error ("externally visible inline clone");
478 if (node
->global
.inlined_to
&& node
->address_taken
)
480 error ("inline clone with address taken");
483 if (node
->global
.inlined_to
&& node
->needed
)
485 error ("inline clone is needed");
488 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
492 error ("aux field set for indirect edge from %s",
493 identifier_to_locale (cgraph_node_name (e
->caller
)));
496 if (!e
->indirect_unknown_callee
497 || !e
->indirect_info
)
499 error ("An indirect edge from %s is not marked as indirect or has "
500 "associated indirect_info, the corresponding statement is: ",
501 identifier_to_locale (cgraph_node_name (e
->caller
)));
502 debug_gimple_stmt (e
->call_stmt
);
506 for (e
= node
->callers
; e
; e
= e
->next_caller
)
508 if (verify_edge_count_and_frequency (e
))
510 if (!e
->inline_failed
)
512 if (node
->global
.inlined_to
513 != (e
->caller
->global
.inlined_to
514 ? e
->caller
->global
.inlined_to
: e
->caller
))
516 error ("inlined_to pointer is wrong");
519 if (node
->callers
->next_caller
)
521 error ("multiple inline callers");
526 if (node
->global
.inlined_to
)
528 error ("inlined_to pointer set for noninline callers");
532 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
533 if (verify_edge_count_and_frequency (e
))
535 if (!node
->callers
&& node
->global
.inlined_to
)
537 error ("inlined_to pointer is set but no predecessors found");
540 if (node
->global
.inlined_to
== node
)
542 error ("inlined_to pointer refers to itself");
546 if (!cgraph_node (node
->decl
))
548 error ("node not found in cgraph_hash");
554 struct cgraph_node
*n
;
555 for (n
= node
->clone_of
->clones
; n
; n
= n
->next_sibling_clone
)
560 error ("node has wrong clone_of");
566 struct cgraph_node
*n
;
567 for (n
= node
->clones
; n
; n
= n
->next_sibling_clone
)
568 if (n
->clone_of
!= node
)
572 error ("node has wrong clone list");
576 if ((node
->prev_sibling_clone
|| node
->next_sibling_clone
) && !node
->clone_of
)
578 error ("node is in clone list but it is not clone");
581 if (!node
->prev_sibling_clone
&& node
->clone_of
&& node
->clone_of
->clones
!= node
)
583 error ("node has wrong prev_clone pointer");
586 if (node
->prev_sibling_clone
&& node
->prev_sibling_clone
->next_sibling_clone
!= node
)
588 error ("double linked list of clones corrupted");
591 if (node
->same_comdat_group
)
593 struct cgraph_node
*n
= node
->same_comdat_group
;
595 if (!DECL_ONE_ONLY (node
->decl
))
597 error ("non-DECL_ONE_ONLY node in a same_comdat_group list");
602 error ("node is alone in a comdat group");
607 if (!n
->same_comdat_group
)
609 error ("same_comdat_group is not a circular list");
613 n
= n
->same_comdat_group
;
618 if (node
->analyzed
&& gimple_has_body_p (node
->decl
)
619 && !TREE_ASM_WRITTEN (node
->decl
)
620 && (!DECL_EXTERNAL (node
->decl
) || node
->global
.inlined_to
)
625 /* The nodes we're interested in are never shared, so walk
626 the tree ignoring duplicates. */
627 struct pointer_set_t
*visited_nodes
= pointer_set_create ();
628 /* Reach the trees by walking over the CFG, and note the
629 enclosing basic-blocks in the call edges. */
630 FOR_EACH_BB_FN (this_block
, this_cfun
)
631 for (gsi
= gsi_start_bb (this_block
);
635 gimple stmt
= gsi_stmt (gsi
);
636 if (is_gimple_call (stmt
))
638 struct cgraph_edge
*e
= cgraph_edge (node
, stmt
);
639 tree decl
= gimple_call_fndecl (stmt
);
644 error ("shared call_stmt:");
645 debug_gimple_stmt (stmt
);
648 if (!e
->indirect_unknown_callee
)
650 struct cgraph_node
*n
;
652 if (e
->callee
->same_body_alias
)
654 error ("edge points to same body alias:");
655 debug_tree (e
->callee
->decl
);
658 else if (!e
->callee
->global
.inlined_to
660 && cgraph_get_node (decl
)
661 && (e
->callee
->former_clone_of
662 != cgraph_get_node (decl
)->decl
)
663 && !clone_of_p (cgraph_node (decl
),
666 error ("edge points to wrong declaration:");
667 debug_tree (e
->callee
->decl
);
668 fprintf (stderr
," Instead of:");
673 && (n
= cgraph_get_node_or_alias (decl
))
674 && (n
->same_body_alias
675 && n
->thunk
.thunk_p
))
677 error ("a call to thunk improperly represented "
678 "in the call graph:");
679 debug_gimple_stmt (stmt
);
684 error ("an indirect edge with unknown callee "
685 "corresponding to a call_stmt with "
686 "a known declaration:");
688 debug_gimple_stmt (e
->call_stmt
);
694 error ("missing callgraph edge for call stmt:");
695 debug_gimple_stmt (stmt
);
700 pointer_set_destroy (visited_nodes
);
703 /* No CFG available?! */
706 for (e
= node
->callees
; e
; e
= e
->next_callee
)
710 error ("edge %s->%s has no corresponding call_stmt",
711 identifier_to_locale (cgraph_node_name (e
->caller
)),
712 identifier_to_locale (cgraph_node_name (e
->callee
)));
713 debug_gimple_stmt (e
->call_stmt
);
718 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
722 error ("an indirect edge from %s has no corresponding call_stmt",
723 identifier_to_locale (cgraph_node_name (e
->caller
)));
724 debug_gimple_stmt (e
->call_stmt
);
732 dump_cgraph_node (stderr
, node
);
733 internal_error ("verify_cgraph_node failed");
735 set_cfun (saved_cfun
);
736 timevar_pop (TV_CGRAPH_VERIFY
);
739 /* Verify whole cgraph structure. */
743 struct cgraph_node
*node
;
748 for (node
= cgraph_nodes
; node
; node
= node
->next
)
749 verify_cgraph_node (node
);
752 /* Output all asm statements we have stored up to be output. */
755 cgraph_output_pending_asms (void)
757 struct cgraph_asm_node
*can
;
762 for (can
= cgraph_asm_nodes
; can
; can
= can
->next
)
763 assemble_asm (can
->asm_str
);
764 cgraph_asm_nodes
= NULL
;
767 /* Analyze the function scheduled to be output. */
769 cgraph_analyze_function (struct cgraph_node
*node
)
771 tree save
= current_function_decl
;
772 tree decl
= node
->decl
;
774 current_function_decl
= decl
;
775 push_cfun (DECL_STRUCT_FUNCTION (decl
));
777 assign_assembler_name_if_neeeded (node
->decl
);
779 /* Make sure to gimplify bodies only once. During analyzing a
780 function we lower it, which will require gimplified nested
781 functions, so we can end up here with an already gimplified
783 if (!gimple_body (decl
))
784 gimplify_function_tree (decl
);
785 dump_function (TDI_generic
, decl
);
787 cgraph_lower_function (node
);
788 node
->analyzed
= true;
791 current_function_decl
= save
;
794 /* Process attributes common for vars and functions. */
797 process_common_attributes (tree decl
)
799 tree weakref
= lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
));
801 if (weakref
&& !lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)))
803 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wattributes
,
804 "%<weakref%> attribute should be accompanied with"
805 " an %<alias%> attribute");
806 DECL_WEAK (decl
) = 0;
807 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
808 DECL_ATTRIBUTES (decl
));
812 /* Look for externally_visible and used attributes and mark cgraph nodes
815 We cannot mark the nodes at the point the attributes are processed (in
816 handle_*_attribute) because the copy of the declarations available at that
817 point may not be canonical. For example, in:
820 void f() __attribute__((used));
822 the declaration we see in handle_used_attribute will be the second
823 declaration -- but the front end will subsequently merge that declaration
824 with the original declaration and discard the second declaration.
826 Furthermore, we can't mark these nodes in cgraph_finalize_function because:
829 void f() __attribute__((externally_visible));
833 So, we walk the nodes at the end of the translation unit, applying the
834 attributes at that point. */
837 process_function_and_variable_attributes (struct cgraph_node
*first
,
838 struct varpool_node
*first_var
)
840 struct cgraph_node
*node
;
841 struct varpool_node
*vnode
;
843 for (node
= cgraph_nodes
; node
!= first
; node
= node
->next
)
845 tree decl
= node
->decl
;
846 if (DECL_PRESERVE_P (decl
))
847 cgraph_mark_needed_node (node
);
848 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
849 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl
))
850 && TREE_PUBLIC (node
->decl
))
852 if (node
->local
.finalized
)
853 cgraph_mark_needed_node (node
);
855 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
857 if (! TREE_PUBLIC (node
->decl
))
858 warning_at (DECL_SOURCE_LOCATION (node
->decl
), OPT_Wattributes
,
859 "%<externally_visible%>"
860 " attribute have effect only on public objects");
861 else if (node
->local
.finalized
)
862 cgraph_mark_needed_node (node
);
864 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
865 && node
->local
.finalized
)
867 warning_at (DECL_SOURCE_LOCATION (node
->decl
), OPT_Wattributes
,
868 "%<weakref%> attribute ignored"
869 " because function is defined");
870 DECL_WEAK (decl
) = 0;
871 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
872 DECL_ATTRIBUTES (decl
));
874 process_common_attributes (decl
);
876 for (vnode
= varpool_nodes
; vnode
!= first_var
; vnode
= vnode
->next
)
878 tree decl
= vnode
->decl
;
879 if (DECL_PRESERVE_P (decl
))
881 vnode
->force_output
= true;
882 if (vnode
->finalized
)
883 varpool_mark_needed_node (vnode
);
885 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
886 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl
))
887 && TREE_PUBLIC (vnode
->decl
))
889 if (vnode
->finalized
)
890 varpool_mark_needed_node (vnode
);
892 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
894 if (! TREE_PUBLIC (vnode
->decl
))
895 warning_at (DECL_SOURCE_LOCATION (vnode
->decl
), OPT_Wattributes
,
896 "%<externally_visible%>"
897 " attribute have effect only on public objects");
898 else if (vnode
->finalized
)
899 varpool_mark_needed_node (vnode
);
901 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
903 && DECL_INITIAL (decl
))
905 warning_at (DECL_SOURCE_LOCATION (vnode
->decl
), OPT_Wattributes
,
906 "%<weakref%> attribute ignored"
907 " because variable is initialized");
908 DECL_WEAK (decl
) = 0;
909 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
910 DECL_ATTRIBUTES (decl
));
912 process_common_attributes (decl
);
916 /* Process CGRAPH_NODES_NEEDED queue, analyze each function (and transitively
917 each reachable functions) and build cgraph.
918 The function can be called multiple times after inserting new nodes
919 into beginning of queue. Just the new part of queue is re-scanned then. */
922 cgraph_analyze_functions (void)
924 /* Keep track of already processed nodes when called multiple times for
925 intermodule optimization. */
926 static struct cgraph_node
*first_analyzed
;
927 struct cgraph_node
*first_processed
= first_analyzed
;
928 static struct varpool_node
*first_analyzed_var
;
929 struct cgraph_node
*node
, *next
;
931 bitmap_obstack_initialize (NULL
);
932 process_function_and_variable_attributes (first_processed
,
934 first_processed
= cgraph_nodes
;
935 first_analyzed_var
= varpool_nodes
;
936 varpool_analyze_pending_decls ();
937 if (cgraph_dump_file
)
939 fprintf (cgraph_dump_file
, "Initial entry points:");
940 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
942 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
943 fprintf (cgraph_dump_file
, "\n");
945 cgraph_process_new_functions ();
947 /* Propagate reachability flag and lower representation of all reachable
948 functions. In the future, lowering will introduce new functions and
949 new entry points on the way (by template instantiation and virtual
950 method table generation for instance). */
951 while (cgraph_nodes_queue
)
953 struct cgraph_edge
*edge
;
954 tree decl
= cgraph_nodes_queue
->decl
;
956 node
= cgraph_nodes_queue
;
957 cgraph_nodes_queue
= cgraph_nodes_queue
->next_needed
;
958 node
->next_needed
= NULL
;
960 /* ??? It is possible to create extern inline function and later using
961 weak alias attribute to kill its body. See
962 gcc.c-torture/compile/20011119-1.c */
963 if (!DECL_STRUCT_FUNCTION (decl
))
965 cgraph_reset_node (node
);
970 cgraph_analyze_function (node
);
972 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
973 if (!edge
->callee
->reachable
)
974 cgraph_mark_reachable_node (edge
->callee
);
976 if (node
->same_comdat_group
)
978 for (next
= node
->same_comdat_group
;
980 next
= next
->same_comdat_group
)
981 cgraph_mark_reachable_node (next
);
984 /* If decl is a clone of an abstract function, mark that abstract
985 function so that we don't release its body. The DECL_INITIAL() of that
986 abstract function declaration will be later needed to output debug info. */
987 if (DECL_ABSTRACT_ORIGIN (decl
))
989 struct cgraph_node
*origin_node
= cgraph_node (DECL_ABSTRACT_ORIGIN (decl
));
990 origin_node
->abstract_and_needed
= true;
993 /* We finalize local static variables during constructing callgraph
994 edges. Process their attributes too. */
995 process_function_and_variable_attributes (first_processed
,
997 first_processed
= cgraph_nodes
;
998 first_analyzed_var
= varpool_nodes
;
999 varpool_analyze_pending_decls ();
1000 cgraph_process_new_functions ();
1003 /* Collect entry points to the unit. */
1004 if (cgraph_dump_file
)
1006 fprintf (cgraph_dump_file
, "Unit entry points:");
1007 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
1009 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1010 fprintf (cgraph_dump_file
, "\n\nInitial ");
1011 dump_cgraph (cgraph_dump_file
);
1012 dump_varpool (cgraph_dump_file
);
1015 if (cgraph_dump_file
)
1016 fprintf (cgraph_dump_file
, "\nReclaiming functions:");
1018 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= next
)
1020 tree decl
= node
->decl
;
1023 if (node
->local
.finalized
&& !gimple_has_body_p (decl
))
1024 cgraph_reset_node (node
);
1026 if (!node
->reachable
&& gimple_has_body_p (decl
))
1028 if (cgraph_dump_file
)
1029 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1030 cgraph_remove_node (node
);
1034 node
->next_needed
= NULL
;
1035 gcc_assert (!node
->local
.finalized
|| gimple_has_body_p (decl
));
1036 gcc_assert (node
->analyzed
== node
->local
.finalized
);
1038 if (cgraph_dump_file
)
1040 fprintf (cgraph_dump_file
, "\n\nReclaimed ");
1041 dump_cgraph (cgraph_dump_file
);
1042 dump_varpool (cgraph_dump_file
);
1044 bitmap_obstack_release (NULL
);
1045 first_analyzed
= cgraph_nodes
;
1050 /* Analyze the whole compilation unit once it is parsed completely. */
1053 cgraph_finalize_compilation_unit (void)
1055 timevar_push (TV_CGRAPH
);
1057 /* Do not skip analyzing the functions if there were errors, we
1058 miss diagnostics for following functions otherwise. */
1060 /* Emit size functions we didn't inline. */
1061 finalize_size_functions ();
1063 /* Mark alias targets necessary and emit diagnostics. */
1064 finish_aliases_1 ();
1068 fprintf (stderr
, "\nAnalyzing compilation unit\n");
1072 /* Gimplify and lower all functions, compute reachability and
1073 remove unreachable nodes. */
1074 cgraph_analyze_functions ();
1076 /* Mark alias targets necessary and emit diagnostics. */
1077 finish_aliases_1 ();
1079 /* Gimplify and lower thunks. */
1080 cgraph_analyze_functions ();
1082 /* Finally drive the pass manager. */
1085 timevar_pop (TV_CGRAPH
);
1089 /* Figure out what functions we want to assemble. */
1092 cgraph_mark_functions_to_output (void)
1094 struct cgraph_node
*node
;
1095 #ifdef ENABLE_CHECKING
1096 bool check_same_comdat_groups
= false;
1098 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1099 gcc_assert (!node
->process
);
1102 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1104 tree decl
= node
->decl
;
1105 struct cgraph_edge
*e
;
1107 gcc_assert (!node
->process
|| node
->same_comdat_group
);
1111 for (e
= node
->callers
; e
; e
= e
->next_caller
)
1112 if (e
->inline_failed
)
1115 /* We need to output all local functions that are used and not
1116 always inlined, as well as those that are reachable from
1117 outside the current compilation unit. */
1119 && !node
->global
.inlined_to
1120 && (!cgraph_only_called_directly_p (node
)
1121 || (e
&& node
->reachable
))
1122 && !TREE_ASM_WRITTEN (decl
)
1123 && !DECL_EXTERNAL (decl
))
1126 if (node
->same_comdat_group
)
1128 struct cgraph_node
*next
;
1129 for (next
= node
->same_comdat_group
;
1131 next
= next
->same_comdat_group
)
1135 else if (node
->same_comdat_group
)
1137 #ifdef ENABLE_CHECKING
1138 check_same_comdat_groups
= true;
1143 /* We should've reclaimed all functions that are not needed. */
1144 #ifdef ENABLE_CHECKING
1145 if (!node
->global
.inlined_to
1146 && gimple_has_body_p (decl
)
1147 /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
1148 are inside partition, we can end up not removing the body since we no longer
1149 have analyzed node pointing to it. */
1150 && !node
->in_other_partition
1151 && !DECL_EXTERNAL (decl
))
1153 dump_cgraph_node (stderr
, node
);
1154 internal_error ("failed to reclaim unneeded function");
1157 gcc_assert (node
->global
.inlined_to
1158 || !gimple_has_body_p (decl
)
1159 || node
->in_other_partition
1160 || DECL_EXTERNAL (decl
));
1165 #ifdef ENABLE_CHECKING
1166 if (check_same_comdat_groups
)
1167 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1168 if (node
->same_comdat_group
&& !node
->process
)
1170 tree decl
= node
->decl
;
1171 if (!node
->global
.inlined_to
1172 && gimple_has_body_p (decl
)
1173 /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
1174 are inside partition, we can end up not removing the body since we no longer
1175 have analyzed node pointing to it. */
1176 && !node
->in_other_partition
1177 && !DECL_EXTERNAL (decl
))
1179 dump_cgraph_node (stderr
, node
);
1180 internal_error ("failed to reclaim unneeded function");
1186 /* DECL is FUNCTION_DECL. Initialize datastructures so DECL is a function
1187 in lowered gimple form.
1189 Set current_function_decl and cfun to newly constructed empty function body.
1190 return basic block in the function body. */
1193 init_lowered_empty_function (tree decl
)
1197 current_function_decl
= decl
;
1198 allocate_struct_function (decl
, false);
1199 gimple_register_cfg_hooks ();
1200 init_empty_tree_cfg ();
1201 init_tree_ssa (cfun
);
1202 init_ssa_operands ();
1203 cfun
->gimple_df
->in_ssa_p
= true;
1204 DECL_INITIAL (decl
) = make_node (BLOCK
);
1206 DECL_SAVED_TREE (decl
) = error_mark_node
;
1207 cfun
->curr_properties
|=
1208 (PROP_gimple_lcf
| PROP_gimple_leh
| PROP_cfg
| PROP_referenced_vars
|
1211 /* Create BB for body of the function and connect it properly. */
1212 bb
= create_basic_block (NULL
, (void *) 0, ENTRY_BLOCK_PTR
);
1213 make_edge (ENTRY_BLOCK_PTR
, bb
, 0);
1214 make_edge (bb
, EXIT_BLOCK_PTR
, 0);
1219 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
1220 offset indicated by VIRTUAL_OFFSET, if that is
1221 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
1222 zero for a result adjusting thunk. */
1225 thunk_adjust (gimple_stmt_iterator
* bsi
,
1226 tree ptr
, bool this_adjusting
,
1227 HOST_WIDE_INT fixed_offset
, tree virtual_offset
)
1233 && fixed_offset
!= 0)
1235 stmt
= gimple_build_assign (ptr
,
1236 fold_build2_loc (input_location
,
1238 TREE_TYPE (ptr
), ptr
,
1239 size_int (fixed_offset
)));
1240 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1243 /* If there's a virtual offset, look up that value in the vtable and
1244 adjust the pointer again. */
1252 if (!vtable_entry_type
)
1254 tree vfunc_type
= make_node (FUNCTION_TYPE
);
1255 TREE_TYPE (vfunc_type
) = integer_type_node
;
1256 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
1257 layout_type (vfunc_type
);
1259 vtable_entry_type
= build_pointer_type (vfunc_type
);
1263 create_tmp_var (build_pointer_type
1264 (build_pointer_type (vtable_entry_type
)), "vptr");
1266 /* The vptr is always at offset zero in the object. */
1267 stmt
= gimple_build_assign (vtabletmp
,
1268 build1 (NOP_EXPR
, TREE_TYPE (vtabletmp
),
1270 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1271 mark_symbols_for_renaming (stmt
);
1272 find_referenced_vars_in (stmt
);
1274 /* Form the vtable address. */
1275 vtabletmp2
= create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp
)),
1277 stmt
= gimple_build_assign (vtabletmp2
,
1278 build_simple_mem_ref (vtabletmp
));
1279 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1280 mark_symbols_for_renaming (stmt
);
1281 find_referenced_vars_in (stmt
);
1283 /* Find the entry with the vcall offset. */
1284 stmt
= gimple_build_assign (vtabletmp2
,
1285 fold_build2_loc (input_location
,
1287 TREE_TYPE (vtabletmp2
),
1289 fold_convert (sizetype
,
1291 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1293 /* Get the offset itself. */
1294 vtabletmp3
= create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp2
)),
1296 stmt
= gimple_build_assign (vtabletmp3
,
1297 build_simple_mem_ref (vtabletmp2
));
1298 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1299 mark_symbols_for_renaming (stmt
);
1300 find_referenced_vars_in (stmt
);
1302 /* Cast to sizetype. */
1303 offsettmp
= create_tmp_var (sizetype
, "offset");
1304 stmt
= gimple_build_assign (offsettmp
, fold_convert (sizetype
, vtabletmp3
));
1305 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1306 mark_symbols_for_renaming (stmt
);
1307 find_referenced_vars_in (stmt
);
1309 /* Adjust the `this' pointer. */
1310 ptr
= fold_build2_loc (input_location
,
1311 POINTER_PLUS_EXPR
, TREE_TYPE (ptr
), ptr
,
1316 && fixed_offset
!= 0)
1317 /* Adjust the pointer by the constant. */
1321 if (TREE_CODE (ptr
) == VAR_DECL
)
1325 ptrtmp
= create_tmp_var (TREE_TYPE (ptr
), "ptr");
1326 stmt
= gimple_build_assign (ptrtmp
, ptr
);
1327 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1328 mark_symbols_for_renaming (stmt
);
1329 find_referenced_vars_in (stmt
);
1331 ptr
= fold_build2_loc (input_location
,
1332 POINTER_PLUS_EXPR
, TREE_TYPE (ptrtmp
), ptrtmp
,
1333 size_int (fixed_offset
));
1336 /* Emit the statement and gimplify the adjustment expression. */
1337 ret
= create_tmp_var (TREE_TYPE (ptr
), "adjusted_this");
1338 stmt
= gimple_build_assign (ret
, ptr
);
1339 mark_symbols_for_renaming (stmt
);
1340 find_referenced_vars_in (stmt
);
1341 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1346 /* Produce assembler for thunk NODE. */
1349 assemble_thunk (struct cgraph_node
*node
)
1351 bool this_adjusting
= node
->thunk
.this_adjusting
;
1352 HOST_WIDE_INT fixed_offset
= node
->thunk
.fixed_offset
;
1353 HOST_WIDE_INT virtual_value
= node
->thunk
.virtual_value
;
1354 tree virtual_offset
= NULL
;
1355 tree alias
= node
->thunk
.alias
;
1356 tree thunk_fndecl
= node
->decl
;
1357 tree a
= DECL_ARGUMENTS (thunk_fndecl
);
1359 current_function_decl
= thunk_fndecl
;
1361 /* Ensure thunks are emitted in their correct sections. */
1362 resolve_unique_section (thunk_fndecl
, 0, flag_function_sections
);
1365 && targetm
.asm_out
.can_output_mi_thunk (thunk_fndecl
, fixed_offset
,
1366 virtual_value
, alias
))
1371 DECL_RESULT (thunk_fndecl
)
1372 = build_decl (DECL_SOURCE_LOCATION (thunk_fndecl
),
1373 RESULT_DECL
, 0, integer_type_node
);
1374 fnname
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk_fndecl
));
1376 /* The back end expects DECL_INITIAL to contain a BLOCK, so we
1378 fn_block
= make_node (BLOCK
);
1379 BLOCK_VARS (fn_block
) = a
;
1380 DECL_INITIAL (thunk_fndecl
) = fn_block
;
1381 init_function_start (thunk_fndecl
);
1383 assemble_start_function (thunk_fndecl
, fnname
);
1385 targetm
.asm_out
.output_mi_thunk (asm_out_file
, thunk_fndecl
,
1386 fixed_offset
, virtual_value
, alias
);
1388 assemble_end_function (thunk_fndecl
, fnname
);
1389 init_insn_lengths ();
1390 free_after_compilation (cfun
);
1392 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
1397 basic_block bb
, then_bb
, else_bb
, return_bb
;
1398 gimple_stmt_iterator bsi
;
1404 VEC(tree
, heap
) *vargs
;
1409 DECL_IGNORED_P (thunk_fndecl
) = 1;
1410 bitmap_obstack_initialize (NULL
);
1412 if (node
->thunk
.virtual_offset_p
)
1413 virtual_offset
= size_int (virtual_value
);
1415 /* Build the return declaration for the function. */
1416 restype
= TREE_TYPE (TREE_TYPE (thunk_fndecl
));
1417 if (DECL_RESULT (thunk_fndecl
) == NULL_TREE
)
1419 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
1420 DECL_ARTIFICIAL (resdecl
) = 1;
1421 DECL_IGNORED_P (resdecl
) = 1;
1422 DECL_RESULT (thunk_fndecl
) = resdecl
;
1425 resdecl
= DECL_RESULT (thunk_fndecl
);
1427 bb
= then_bb
= else_bb
= return_bb
= init_lowered_empty_function (thunk_fndecl
);
1429 bsi
= gsi_start_bb (bb
);
1431 /* Build call to the function being thunked. */
1432 if (!VOID_TYPE_P (restype
))
1434 if (!is_gimple_reg_type (restype
))
1437 add_local_decl (cfun
, restmp
);
1438 BLOCK_VARS (DECL_INITIAL (current_function_decl
)) = restmp
;
1441 restmp
= create_tmp_var_raw (restype
, "retval");
1444 for (arg
= a
; arg
; arg
= DECL_CHAIN (arg
))
1446 vargs
= VEC_alloc (tree
, heap
, nargs
);
1448 VEC_quick_push (tree
, vargs
,
1453 VEC_quick_push (tree
, vargs
, a
);
1454 for (i
= 1, arg
= DECL_CHAIN (a
); i
< nargs
; i
++, arg
= DECL_CHAIN (arg
))
1455 VEC_quick_push (tree
, vargs
, arg
);
1456 call
= gimple_build_call_vec (build_fold_addr_expr_loc (0, alias
), vargs
);
1457 VEC_free (tree
, heap
, vargs
);
1458 gimple_call_set_cannot_inline (call
, true);
1459 gimple_call_set_from_thunk (call
, true);
1461 gimple_call_set_lhs (call
, restmp
);
1462 gsi_insert_after (&bsi
, call
, GSI_NEW_STMT
);
1463 mark_symbols_for_renaming (call
);
1464 find_referenced_vars_in (call
);
1467 if (restmp
&& !this_adjusting
)
1469 tree true_label
= NULL_TREE
;
1471 if (TREE_CODE (TREE_TYPE (restmp
)) == POINTER_TYPE
)
1474 /* If the return type is a pointer, we need to
1475 protect against NULL. We know there will be an
1476 adjustment, because that's why we're emitting a
1478 then_bb
= create_basic_block (NULL
, (void *) 0, bb
);
1479 return_bb
= create_basic_block (NULL
, (void *) 0, then_bb
);
1480 else_bb
= create_basic_block (NULL
, (void *) 0, else_bb
);
1481 remove_edge (single_succ_edge (bb
));
1482 true_label
= gimple_block_label (then_bb
);
1483 stmt
= gimple_build_cond (NE_EXPR
, restmp
,
1484 build_zero_cst (TREE_TYPE (restmp
)),
1485 NULL_TREE
, NULL_TREE
);
1486 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1487 make_edge (bb
, then_bb
, EDGE_TRUE_VALUE
);
1488 make_edge (bb
, else_bb
, EDGE_FALSE_VALUE
);
1489 make_edge (return_bb
, EXIT_BLOCK_PTR
, 0);
1490 make_edge (then_bb
, return_bb
, EDGE_FALLTHRU
);
1491 make_edge (else_bb
, return_bb
, EDGE_FALLTHRU
);
1492 bsi
= gsi_last_bb (then_bb
);
1495 restmp
= thunk_adjust (&bsi
, restmp
, /*this_adjusting=*/0,
1496 fixed_offset
, virtual_offset
);
1500 bsi
= gsi_last_bb (else_bb
);
1501 stmt
= gimple_build_assign (restmp
,
1502 build_zero_cst (TREE_TYPE (restmp
)));
1503 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1504 bsi
= gsi_last_bb (return_bb
);
1508 gimple_call_set_tail (call
, true);
1510 /* Build return value. */
1511 ret
= gimple_build_return (restmp
);
1512 gsi_insert_after (&bsi
, ret
, GSI_NEW_STMT
);
1514 delete_unreachable_blocks ();
1515 update_ssa (TODO_update_ssa
);
1517 cgraph_remove_same_body_alias (node
);
1518 /* Since we want to emit the thunk, we explicitly mark its name as
1520 cgraph_add_new_function (thunk_fndecl
, true);
1521 bitmap_obstack_release (NULL
);
1523 current_function_decl
= NULL
;
1526 /* Expand function specified by NODE. */
1529 cgraph_expand_function (struct cgraph_node
*node
)
1531 tree decl
= node
->decl
;
1533 /* We ought to not compile any inline clones. */
1534 gcc_assert (!node
->global
.inlined_to
);
1536 announce_function (decl
);
1538 if (node
->same_body
)
1540 struct cgraph_node
*alias
, *next
;
1541 bool saved_alias
= node
->alias
;
1542 for (alias
= node
->same_body
;
1543 alias
&& alias
->next
; alias
= alias
->next
)
1545 /* Walk aliases in the order they were created; it is possible that
1546 thunks reffers to the aliases made earlier. */
1547 for (; alias
; alias
= next
)
1549 next
= alias
->previous
;
1550 if (!alias
->thunk
.thunk_p
)
1551 assemble_alias (alias
->decl
,
1552 DECL_ASSEMBLER_NAME (alias
->thunk
.alias
));
1554 assemble_thunk (alias
);
1556 node
->alias
= saved_alias
;
1557 cgraph_process_new_functions ();
1560 gcc_assert (node
->lowered
);
1562 /* Generate RTL for the body of DECL. */
1563 tree_rest_of_compilation (decl
);
1565 /* Make sure that BE didn't give up on compiling. */
1566 gcc_assert (TREE_ASM_WRITTEN (decl
));
1567 current_function_decl
= NULL
;
1568 gcc_assert (!cgraph_preserve_function_body_p (decl
));
1569 cgraph_release_function_body (node
);
1570 /* Eliminate all call edges. This is important so the GIMPLE_CALL no longer
1571 points to the dead function body. */
1572 cgraph_node_remove_callees (node
);
1574 cgraph_function_flags_ready
= true;
1577 /* Return true when CALLER_DECL should be inlined into CALLEE_DECL. */
1580 cgraph_inline_p (struct cgraph_edge
*e
, cgraph_inline_failed_t
*reason
)
1582 *reason
= e
->inline_failed
;
1583 return !e
->inline_failed
;
1588 /* Expand all functions that must be output.
1590 Attempt to topologically sort the nodes so function is output when
1591 all called functions are already assembled to allow data to be
1592 propagated across the callgraph. Use a stack to get smaller distance
1593 between a function and its callees (later we may choose to use a more
1594 sophisticated algorithm for function reordering; we will likely want
1595 to use subsections to make the output functions appear in top-down
1599 cgraph_expand_all_functions (void)
1601 struct cgraph_node
*node
;
1602 struct cgraph_node
**order
= XCNEWVEC (struct cgraph_node
*, cgraph_n_nodes
);
1603 int order_pos
, new_order_pos
= 0;
1606 order_pos
= cgraph_postorder (order
);
1607 gcc_assert (order_pos
== cgraph_n_nodes
);
1609 /* Garbage collector may remove inline clones we eliminate during
1610 optimization. So we must be sure to not reference them. */
1611 for (i
= 0; i
< order_pos
; i
++)
1612 if (order
[i
]->process
)
1613 order
[new_order_pos
++] = order
[i
];
1615 for (i
= new_order_pos
- 1; i
>= 0; i
--)
1620 gcc_assert (node
->reachable
);
1622 cgraph_expand_function (node
);
1625 cgraph_process_new_functions ();
1631 /* This is used to sort the node types by the cgraph order number. */
1633 enum cgraph_order_sort_kind
1635 ORDER_UNDEFINED
= 0,
1641 struct cgraph_order_sort
1643 enum cgraph_order_sort_kind kind
;
1646 struct cgraph_node
*f
;
1647 struct varpool_node
*v
;
1648 struct cgraph_asm_node
*a
;
1652 /* Output all functions, variables, and asm statements in the order
1653 according to their order fields, which is the order in which they
1654 appeared in the file. This implements -fno-toplevel-reorder. In
1655 this mode we may output functions and variables which don't really
1656 need to be output. */
1659 cgraph_output_in_order (void)
1662 struct cgraph_order_sort
*nodes
;
1664 struct cgraph_node
*pf
;
1665 struct varpool_node
*pv
;
1666 struct cgraph_asm_node
*pa
;
1669 nodes
= XCNEWVEC (struct cgraph_order_sort
, max
);
1671 varpool_analyze_pending_decls ();
1673 for (pf
= cgraph_nodes
; pf
; pf
= pf
->next
)
1678 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1679 nodes
[i
].kind
= ORDER_FUNCTION
;
1684 for (pv
= varpool_nodes_queue
; pv
; pv
= pv
->next_needed
)
1687 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1688 nodes
[i
].kind
= ORDER_VAR
;
1692 for (pa
= cgraph_asm_nodes
; pa
; pa
= pa
->next
)
1695 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1696 nodes
[i
].kind
= ORDER_ASM
;
1700 /* In toplevel reorder mode we output all statics; mark them as needed. */
1701 for (i
= 0; i
< max
; ++i
)
1703 if (nodes
[i
].kind
== ORDER_VAR
)
1705 varpool_mark_needed_node (nodes
[i
].u
.v
);
1708 varpool_empty_needed_queue ();
1710 for (i
= 0; i
< max
; ++i
)
1712 switch (nodes
[i
].kind
)
1714 case ORDER_FUNCTION
:
1715 nodes
[i
].u
.f
->process
= 0;
1716 cgraph_expand_function (nodes
[i
].u
.f
);
1720 varpool_assemble_decl (nodes
[i
].u
.v
);
1724 assemble_asm (nodes
[i
].u
.a
->asm_str
);
1727 case ORDER_UNDEFINED
:
1735 cgraph_asm_nodes
= NULL
;
1739 /* Return true when function body of DECL still needs to be kept around
1740 for later re-use. */
1742 cgraph_preserve_function_body_p (tree decl
)
1744 struct cgraph_node
*node
;
1746 gcc_assert (cgraph_global_info_ready
);
1747 /* Look if there is any clone around. */
1748 node
= cgraph_node (decl
);
1758 current_function_decl
= NULL
;
1759 gimple_register_cfg_hooks ();
1760 bitmap_obstack_initialize (NULL
);
1762 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_START
, NULL
);
1766 execute_ipa_pass_list (all_small_ipa_passes
);
1771 /* If pass_all_early_optimizations was not scheduled, the state of
1772 the cgraph will not be properly updated. Update it now. */
1773 if (cgraph_state
< CGRAPH_STATE_IPA_SSA
)
1774 cgraph_state
= CGRAPH_STATE_IPA_SSA
;
1778 /* Generate coverage variables and constructors. */
1781 /* Process new functions added. */
1783 current_function_decl
= NULL
;
1784 cgraph_process_new_functions ();
1786 execute_ipa_summary_passes
1787 ((struct ipa_opt_pass_d
*) all_regular_ipa_passes
);
1790 /* Some targets need to handle LTO assembler output specially. */
1791 if (flag_generate_lto
)
1792 targetm
.asm_out
.lto_start ();
1794 execute_ipa_summary_passes ((struct ipa_opt_pass_d
*) all_lto_gen_passes
);
1797 ipa_write_summaries ();
1799 if (flag_generate_lto
)
1800 targetm
.asm_out
.lto_end ();
1803 execute_ipa_pass_list (all_regular_ipa_passes
);
1804 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_END
, NULL
);
1806 bitmap_obstack_release (NULL
);
1810 /* Perform simple optimizations based on callgraph. */
1813 cgraph_optimize (void)
1818 #ifdef ENABLE_CHECKING
1822 /* Frontend may output common variables after the unit has been finalized.
1823 It is safe to deal with them here as they are always zero initialized. */
1824 varpool_analyze_pending_decls ();
1826 timevar_push (TV_CGRAPHOPT
);
1827 if (pre_ipa_mem_report
)
1829 fprintf (stderr
, "Memory consumption before IPA\n");
1830 dump_memory_report (false);
1833 fprintf (stderr
, "Performing interprocedural optimizations\n");
1834 cgraph_state
= CGRAPH_STATE_IPA
;
1836 /* Don't run the IPA passes if there was any error or sorry messages. */
1840 /* Do nothing else if any IPA pass found errors. */
1843 timevar_pop (TV_CGRAPHOPT
);
1847 /* This pass remove bodies of extern inline functions we never inlined.
1848 Do this later so other IPA passes see what is really going on. */
1849 cgraph_remove_unreachable_nodes (false, dump_file
);
1850 cgraph_global_info_ready
= true;
1851 if (cgraph_dump_file
)
1853 fprintf (cgraph_dump_file
, "Optimized ");
1854 dump_cgraph (cgraph_dump_file
);
1855 dump_varpool (cgraph_dump_file
);
1857 if (post_ipa_mem_report
)
1859 fprintf (stderr
, "Memory consumption after IPA\n");
1860 dump_memory_report (false);
1862 timevar_pop (TV_CGRAPHOPT
);
1864 /* Output everything. */
1865 (*debug_hooks
->assembly_start
) ();
1867 fprintf (stderr
, "Assembling functions:\n");
1868 #ifdef ENABLE_CHECKING
1872 cgraph_materialize_all_clones ();
1873 cgraph_mark_functions_to_output ();
1875 cgraph_state
= CGRAPH_STATE_EXPANSION
;
1876 if (!flag_toplevel_reorder
)
1877 cgraph_output_in_order ();
1880 cgraph_output_pending_asms ();
1882 cgraph_expand_all_functions ();
1883 varpool_remove_unreferenced_decls ();
1885 varpool_assemble_pending_decls ();
1887 cgraph_process_new_functions ();
1888 cgraph_state
= CGRAPH_STATE_FINISHED
;
1890 if (cgraph_dump_file
)
1892 fprintf (cgraph_dump_file
, "\nFinal ");
1893 dump_cgraph (cgraph_dump_file
);
1894 dump_varpool (cgraph_dump_file
);
1896 #ifdef ENABLE_CHECKING
1898 /* Double check that all inline clones are gone and that all
1899 function bodies have been released from memory. */
1902 struct cgraph_node
*node
;
1903 bool error_found
= false;
1905 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1907 && (node
->global
.inlined_to
1908 || gimple_has_body_p (node
->decl
)))
1911 dump_cgraph_node (stderr
, node
);
1914 internal_error ("nodes with unreleased memory found");
1922 if (!cgraph_dump_file
)
1923 cgraph_dump_file
= dump_begin (TDI_cgraph
, NULL
);
1926 /* The edges representing the callers of the NEW_VERSION node were
1927 fixed by cgraph_function_versioning (), now the call_expr in their
1928 respective tree code should be updated to call the NEW_VERSION. */
1931 update_call_expr (struct cgraph_node
*new_version
)
1933 struct cgraph_edge
*e
;
1935 gcc_assert (new_version
);
1937 /* Update the call expr on the edges to call the new version. */
1938 for (e
= new_version
->callers
; e
; e
= e
->next_caller
)
1940 struct function
*inner_function
= DECL_STRUCT_FUNCTION (e
->caller
->decl
);
1941 gimple_call_set_fndecl (e
->call_stmt
, new_version
->decl
);
1942 maybe_clean_eh_stmt_fn (inner_function
, e
->call_stmt
);
1947 /* Create a new cgraph node which is the new version of
1948 OLD_VERSION node. REDIRECT_CALLERS holds the callers
1949 edges which should be redirected to point to
1950 NEW_VERSION. ALL the callees edges of OLD_VERSION
1951 are cloned to the new version node. Return the new
1954 If non-NULL BLOCK_TO_COPY determine what basic blocks
1955 was copied to prevent duplications of calls that are dead
1958 static struct cgraph_node
*
1959 cgraph_copy_node_for_versioning (struct cgraph_node
*old_version
,
1961 VEC(cgraph_edge_p
,heap
) *redirect_callers
,
1964 struct cgraph_node
*new_version
;
1965 struct cgraph_edge
*e
;
1968 gcc_assert (old_version
);
1970 new_version
= cgraph_node (new_decl
);
1972 new_version
->analyzed
= true;
1973 new_version
->local
= old_version
->local
;
1974 new_version
->local
.externally_visible
= false;
1975 new_version
->local
.local
= true;
1976 new_version
->local
.vtable_method
= false;
1977 new_version
->global
= old_version
->global
;
1978 new_version
->rtl
= old_version
->rtl
;
1979 new_version
->reachable
= true;
1980 new_version
->count
= old_version
->count
;
1982 for (e
= old_version
->callees
; e
; e
=e
->next_callee
)
1984 || bitmap_bit_p (bbs_to_copy
, gimple_bb (e
->call_stmt
)->index
))
1985 cgraph_clone_edge (e
, new_version
, e
->call_stmt
,
1986 e
->lto_stmt_uid
, REG_BR_PROB_BASE
,
1988 e
->loop_nest
, true);
1989 for (e
= old_version
->indirect_calls
; e
; e
=e
->next_callee
)
1991 || bitmap_bit_p (bbs_to_copy
, gimple_bb (e
->call_stmt
)->index
))
1992 cgraph_clone_edge (e
, new_version
, e
->call_stmt
,
1993 e
->lto_stmt_uid
, REG_BR_PROB_BASE
,
1995 e
->loop_nest
, true);
1996 FOR_EACH_VEC_ELT (cgraph_edge_p
, redirect_callers
, i
, e
)
1998 /* Redirect calls to the old version node to point to its new
2000 cgraph_redirect_edge_callee (e
, new_version
);
2006 /* Perform function versioning.
2007 Function versioning includes copying of the tree and
2008 a callgraph update (creating a new cgraph node and updating
2009 its callees and callers).
2011 REDIRECT_CALLERS varray includes the edges to be redirected
2014 TREE_MAP is a mapping of tree nodes we want to replace with
2015 new ones (according to results of prior analysis).
2016 OLD_VERSION_NODE is the node that is versioned.
2017 It returns the new version's cgraph node.
2018 If non-NULL ARGS_TO_SKIP determine function parameters to remove
2020 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
2021 If non_NULL NEW_ENTRY determine new entry BB of the clone. */
2023 struct cgraph_node
*
2024 cgraph_function_versioning (struct cgraph_node
*old_version_node
,
2025 VEC(cgraph_edge_p
,heap
) *redirect_callers
,
2026 VEC (ipa_replace_map_p
,gc
)* tree_map
,
2027 bitmap args_to_skip
,
2029 basic_block new_entry_block
,
2030 const char *clone_name
)
2032 tree old_decl
= old_version_node
->decl
;
2033 struct cgraph_node
*new_version_node
= NULL
;
2036 if (!tree_versionable_function_p (old_decl
))
2039 gcc_assert (old_version_node
->local
.can_change_signature
|| !args_to_skip
);
2041 /* Make a new FUNCTION_DECL tree node for the
2044 new_decl
= copy_node (old_decl
);
2046 new_decl
= build_function_decl_skip_args (old_decl
, args_to_skip
);
2048 /* Generate a new name for the new version. */
2049 DECL_NAME (new_decl
) = clone_function_name (old_decl
, clone_name
);
2050 SET_DECL_ASSEMBLER_NAME (new_decl
, DECL_NAME (new_decl
));
2051 SET_DECL_RTL (new_decl
, NULL
);
2053 /* Create the new version's call-graph node.
2054 and update the edges of the new node. */
2056 cgraph_copy_node_for_versioning (old_version_node
, new_decl
,
2057 redirect_callers
, bbs_to_copy
);
2059 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2060 tree_function_versioning (old_decl
, new_decl
, tree_map
, false, args_to_skip
,
2061 bbs_to_copy
, new_entry_block
);
2063 /* Update the new version's properties.
2064 Make The new version visible only within this translation unit. Make sure
2065 that is not weak also.
2066 ??? We cannot use COMDAT linkage because there is no
2067 ABI support for this. */
2068 cgraph_make_decl_local (new_version_node
->decl
);
2069 DECL_VIRTUAL_P (new_version_node
->decl
) = 0;
2070 new_version_node
->local
.externally_visible
= 0;
2071 new_version_node
->local
.local
= 1;
2072 new_version_node
->lowered
= true;
2074 /* Update the call_expr on the edges to call the new version node. */
2075 update_call_expr (new_version_node
);
2077 cgraph_call_function_insertion_hooks (new_version_node
);
2078 return new_version_node
;
2081 /* Produce separate function body for inline clones so the offline copy can be
2082 modified without affecting them. */
2083 struct cgraph_node
*
2084 save_inline_function_body (struct cgraph_node
*node
)
2086 struct cgraph_node
*first_clone
, *n
;
2088 gcc_assert (node
== cgraph_node (node
->decl
));
2090 cgraph_lower_function (node
);
2092 first_clone
= node
->clones
;
2094 first_clone
->decl
= copy_node (node
->decl
);
2095 cgraph_insert_node_to_hashtable (first_clone
);
2096 gcc_assert (first_clone
== cgraph_node (first_clone
->decl
));
2097 if (first_clone
->next_sibling_clone
)
2099 for (n
= first_clone
->next_sibling_clone
; n
->next_sibling_clone
; n
= n
->next_sibling_clone
)
2100 n
->clone_of
= first_clone
;
2101 n
->clone_of
= first_clone
;
2102 n
->next_sibling_clone
= first_clone
->clones
;
2103 if (first_clone
->clones
)
2104 first_clone
->clones
->prev_sibling_clone
= n
;
2105 first_clone
->clones
= first_clone
->next_sibling_clone
;
2106 first_clone
->next_sibling_clone
->prev_sibling_clone
= NULL
;
2107 first_clone
->next_sibling_clone
= NULL
;
2108 gcc_assert (!first_clone
->prev_sibling_clone
);
2110 first_clone
->clone_of
= NULL
;
2111 node
->clones
= NULL
;
2113 if (first_clone
->clones
)
2114 for (n
= first_clone
->clones
; n
!= first_clone
;)
2116 gcc_assert (n
->decl
== node
->decl
);
2117 n
->decl
= first_clone
->decl
;
2120 else if (n
->next_sibling_clone
)
2121 n
= n
->next_sibling_clone
;
2124 while (n
!= first_clone
&& !n
->next_sibling_clone
)
2126 if (n
!= first_clone
)
2127 n
= n
->next_sibling_clone
;
2131 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2132 tree_function_versioning (node
->decl
, first_clone
->decl
, NULL
, true, NULL
,
2135 DECL_EXTERNAL (first_clone
->decl
) = 0;
2136 DECL_COMDAT_GROUP (first_clone
->decl
) = NULL_TREE
;
2137 TREE_PUBLIC (first_clone
->decl
) = 0;
2138 DECL_COMDAT (first_clone
->decl
) = 0;
2139 VEC_free (ipa_opt_pass
, heap
,
2140 first_clone
->ipa_transforms_to_apply
);
2141 first_clone
->ipa_transforms_to_apply
= NULL
;
2143 #ifdef ENABLE_CHECKING
2144 verify_cgraph_node (first_clone
);
2149 /* Given virtual clone, turn it into actual clone. */
2151 cgraph_materialize_clone (struct cgraph_node
*node
)
2153 bitmap_obstack_initialize (NULL
);
2154 node
->former_clone_of
= node
->clone_of
->decl
;
2155 if (node
->clone_of
->former_clone_of
)
2156 node
->former_clone_of
= node
->clone_of
->former_clone_of
;
2157 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2158 tree_function_versioning (node
->clone_of
->decl
, node
->decl
,
2159 node
->clone
.tree_map
, true,
2160 node
->clone
.args_to_skip
, NULL
, NULL
);
2161 if (cgraph_dump_file
)
2163 dump_function_to_file (node
->clone_of
->decl
, cgraph_dump_file
, dump_flags
);
2164 dump_function_to_file (node
->decl
, cgraph_dump_file
, dump_flags
);
2167 /* Function is no longer clone. */
2168 if (node
->next_sibling_clone
)
2169 node
->next_sibling_clone
->prev_sibling_clone
= node
->prev_sibling_clone
;
2170 if (node
->prev_sibling_clone
)
2171 node
->prev_sibling_clone
->next_sibling_clone
= node
->next_sibling_clone
;
2173 node
->clone_of
->clones
= node
->next_sibling_clone
;
2174 node
->next_sibling_clone
= NULL
;
2175 node
->prev_sibling_clone
= NULL
;
2176 if (!node
->clone_of
->analyzed
&& !node
->clone_of
->clones
)
2178 cgraph_release_function_body (node
->clone_of
);
2179 cgraph_node_remove_callees (node
->clone_of
);
2180 ipa_remove_all_references (&node
->clone_of
->ref_list
);
2182 node
->clone_of
= NULL
;
2183 bitmap_obstack_release (NULL
);
2186 /* If necessary, change the function declaration in the call statement
2187 associated with E so that it corresponds to the edge callee. */
2190 cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge
*e
)
2192 tree decl
= gimple_call_fndecl (e
->call_stmt
);
2194 gimple_stmt_iterator gsi
;
2195 bool gsi_computed
= false;
2196 #ifdef ENABLE_CHECKING
2197 struct cgraph_node
*node
;
2200 if (e
->indirect_unknown_callee
2201 || decl
== e
->callee
->decl
2202 /* Don't update call from same body alias to the real function. */
2203 || (decl
&& cgraph_get_node (decl
) == cgraph_get_node (e
->callee
->decl
)))
2204 return e
->call_stmt
;
2206 #ifdef ENABLE_CHECKING
2209 node
= cgraph_get_node (decl
);
2210 gcc_assert (!node
|| !node
->clone
.combined_args_to_skip
);
2214 if (cgraph_dump_file
)
2216 fprintf (cgraph_dump_file
, "updating call of %s/%i -> %s/%i: ",
2217 cgraph_node_name (e
->caller
), e
->caller
->uid
,
2218 cgraph_node_name (e
->callee
), e
->callee
->uid
);
2219 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
2220 if (e
->callee
->clone
.combined_args_to_skip
)
2222 fprintf (cgraph_dump_file
, " combined args to skip: ");
2223 dump_bitmap (cgraph_dump_file
,
2224 e
->callee
->clone
.combined_args_to_skip
);
2228 if (e
->indirect_info
&&
2229 e
->indirect_info
->thunk_delta
!= 0
2230 && (!e
->callee
->clone
.combined_args_to_skip
2231 || !bitmap_bit_p (e
->callee
->clone
.combined_args_to_skip
, 0)))
2233 if (cgraph_dump_file
)
2234 fprintf (cgraph_dump_file
, " Thunk delta is "
2235 HOST_WIDE_INT_PRINT_DEC
"\n", e
->indirect_info
->thunk_delta
);
2236 gsi
= gsi_for_stmt (e
->call_stmt
);
2237 gsi_computed
= true;
2238 gimple_adjust_this_by_delta (&gsi
,
2239 build_int_cst (sizetype
,
2240 e
->indirect_info
->thunk_delta
));
2241 e
->indirect_info
->thunk_delta
= 0;
2244 if (e
->callee
->clone
.combined_args_to_skip
)
2249 = gimple_call_copy_skip_args (e
->call_stmt
,
2250 e
->callee
->clone
.combined_args_to_skip
);
2251 gimple_call_set_fndecl (new_stmt
, e
->callee
->decl
);
2253 if (gimple_vdef (new_stmt
)
2254 && TREE_CODE (gimple_vdef (new_stmt
)) == SSA_NAME
)
2255 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt
)) = new_stmt
;
2258 gsi
= gsi_for_stmt (e
->call_stmt
);
2259 gsi_replace (&gsi
, new_stmt
, false);
2260 /* We need to defer cleaning EH info on the new statement to
2261 fixup-cfg. We may not have dominator information at this point
2262 and thus would end up with unreachable blocks and have no way
2263 to communicate that we need to run CFG cleanup then. */
2264 lp_nr
= lookup_stmt_eh_lp (e
->call_stmt
);
2267 remove_stmt_from_eh_lp (e
->call_stmt
);
2268 add_stmt_to_eh_lp (new_stmt
, lp_nr
);
2273 new_stmt
= e
->call_stmt
;
2274 gimple_call_set_fndecl (new_stmt
, e
->callee
->decl
);
2275 update_stmt (new_stmt
);
2278 cgraph_set_call_stmt_including_clones (e
->caller
, e
->call_stmt
, new_stmt
);
2280 if (cgraph_dump_file
)
2282 fprintf (cgraph_dump_file
, " updated to:");
2283 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
2288 /* Once all functions from compilation unit are in memory, produce all clones
2289 and update all calls. We might also do this on demand if we don't want to
2290 bring all functions to memory prior compilation, but current WHOPR
2291 implementation does that and it is is bit easier to keep everything right in
2294 cgraph_materialize_all_clones (void)
2296 struct cgraph_node
*node
;
2297 bool stabilized
= false;
2299 if (cgraph_dump_file
)
2300 fprintf (cgraph_dump_file
, "Materializing clones\n");
2301 #ifdef ENABLE_CHECKING
2305 /* We can also do topological order, but number of iterations should be
2306 bounded by number of IPA passes since single IPA pass is probably not
2307 going to create clones of clones it created itself. */
2311 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2313 if (node
->clone_of
&& node
->decl
!= node
->clone_of
->decl
2314 && !gimple_has_body_p (node
->decl
))
2316 if (gimple_has_body_p (node
->clone_of
->decl
))
2318 if (cgraph_dump_file
)
2320 fprintf (cgraph_dump_file
, "clonning %s to %s\n",
2321 cgraph_node_name (node
->clone_of
),
2322 cgraph_node_name (node
));
2323 if (node
->clone
.tree_map
)
2326 fprintf (cgraph_dump_file
, " replace map: ");
2327 for (i
= 0; i
< VEC_length (ipa_replace_map_p
,
2328 node
->clone
.tree_map
);
2331 struct ipa_replace_map
*replace_info
;
2332 replace_info
= VEC_index (ipa_replace_map_p
,
2333 node
->clone
.tree_map
,
2335 print_generic_expr (cgraph_dump_file
, replace_info
->old_tree
, 0);
2336 fprintf (cgraph_dump_file
, " -> ");
2337 print_generic_expr (cgraph_dump_file
, replace_info
->new_tree
, 0);
2338 fprintf (cgraph_dump_file
, "%s%s;",
2339 replace_info
->replace_p
? "(replace)":"",
2340 replace_info
->ref_p
? "(ref)":"");
2342 fprintf (cgraph_dump_file
, "\n");
2344 if (node
->clone
.args_to_skip
)
2346 fprintf (cgraph_dump_file
, " args_to_skip: ");
2347 dump_bitmap (cgraph_dump_file
, node
->clone
.args_to_skip
);
2349 if (node
->clone
.args_to_skip
)
2351 fprintf (cgraph_dump_file
, " combined_args_to_skip:");
2352 dump_bitmap (cgraph_dump_file
, node
->clone
.combined_args_to_skip
);
2355 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
, "Materialization Call site updates done.\n");
2366 #ifdef ENABLE_CHECKING
2369 cgraph_remove_unreachable_nodes (false, cgraph_dump_file
);
2372 #include "gt-cgraphunit.h"