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 call-graph construction and local function analysis takes
49 place here. Bodies of unreachable functions are released to
50 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);
147 FILE *cgraph_dump_file
;
149 /* Used for vtable lookup in thunk adjusting. */
150 static GTY (()) tree vtable_entry_type
;
152 /* Determine if function DECL is needed. That is, visible to something
153 either outside this translation unit, something magic in the system
157 cgraph_decide_is_function_needed (struct cgraph_node
*node
, tree decl
)
159 /* If the user told us it is used, then it must be so. */
160 if (node
->local
.externally_visible
)
163 /* ??? If the assembler name is set by hand, it is possible to assemble
164 the name later after finalizing the function and the fact is noticed
165 in assemble_name then. This is arguably a bug. */
166 if (DECL_ASSEMBLER_NAME_SET_P (decl
)
167 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)))
170 /* With -fkeep-inline-functions we are keeping all inline functions except
171 for extern inline ones. */
172 if (flag_keep_inline_functions
173 && DECL_DECLARED_INLINE_P (decl
)
174 && !DECL_EXTERNAL (decl
)
175 && !DECL_DISREGARD_INLINE_LIMITS (decl
))
178 /* If we decided it was needed before, but at the time we didn't have
179 the body of the function available, then it's still needed. We have
180 to go back and re-check its dependencies now. */
184 /* Externally visible functions must be output. The exception is
185 COMDAT functions that must be output only when they are needed.
187 When not optimizing, also output the static functions. (see
188 PR24561), but don't do so for always_inline functions, functions
189 declared inline and nested functions. These were optimized out
190 in the original implementation and it is unclear whether we want
191 to change the behavior here. */
192 if (((TREE_PUBLIC (decl
)
194 && !DECL_DISREGARD_INLINE_LIMITS (decl
)
195 && !DECL_DECLARED_INLINE_P (decl
)
196 && !(DECL_CONTEXT (decl
)
197 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
)))
198 && !flag_whole_program
200 && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
))
206 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
207 functions into callgraph in a way so they look like ordinary reachable
208 functions inserted into callgraph already at construction time. */
211 cgraph_process_new_functions (void)
215 struct cgraph_node
*node
;
217 varpool_analyze_pending_decls ();
218 /* Note that this queue may grow as its being processed, as the new
219 functions may generate new ones. */
220 while (cgraph_new_nodes
)
222 node
= cgraph_new_nodes
;
224 cgraph_new_nodes
= cgraph_new_nodes
->next_needed
;
225 switch (cgraph_state
)
227 case CGRAPH_STATE_CONSTRUCTION
:
228 /* At construction time we just need to finalize function and move
229 it into reachable functions list. */
231 node
->next_needed
= NULL
;
232 cgraph_finalize_function (fndecl
, false);
233 cgraph_mark_reachable_node (node
);
237 case CGRAPH_STATE_IPA
:
238 case CGRAPH_STATE_IPA_SSA
:
239 /* When IPA optimization already started, do all essential
240 transformations that has been already performed on the whole
241 cgraph but not on this function. */
243 gimple_register_cfg_hooks ();
245 cgraph_analyze_function (node
);
246 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
247 current_function_decl
= fndecl
;
248 if ((cgraph_state
== CGRAPH_STATE_IPA_SSA
249 && !gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
250 /* When not optimizing, be sure we run early local passes anyway
253 execute_pass_list (pass_early_local_passes
.pass
.sub
);
255 compute_inline_parameters (node
);
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_get_create_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
;
356 if (cgraph_decide_is_function_needed (node
, decl
))
357 cgraph_mark_needed_node (node
);
359 /* Since we reclaim unreachable nodes at the end of every language
360 level unit, we need to be conservative about possible entry points
362 if ((TREE_PUBLIC (decl
) && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
))
363 || DECL_STATIC_CONSTRUCTOR (decl
)
364 || DECL_STATIC_DESTRUCTOR (decl
)
365 /* COMDAT virtual functions may be referenced by vtable from
366 other compilation unit. Still we want to devirtualize calls
367 to those so we need to analyze them.
368 FIXME: We should introduce may edges for this purpose and update
369 their handling in unreachable function removal and inliner too. */
370 || (DECL_VIRTUAL_P (decl
) && (DECL_COMDAT (decl
) || DECL_EXTERNAL (decl
))))
371 cgraph_mark_reachable_node (node
);
373 /* If we've not yet emitted decl, tell the debug info about it. */
374 if (!TREE_ASM_WRITTEN (decl
))
375 (*debug_hooks
->deferred_inline_function
) (decl
);
377 /* Possibly warn about unused parameters. */
378 if (warn_unused_parameter
)
379 do_warn_unused_parameter (decl
);
385 /* C99 extern inline keywords allow changing of declaration after function
386 has been finalized. We need to re-decide if we want to mark the function as
390 cgraph_mark_if_needed (tree decl
)
392 struct cgraph_node
*node
= cgraph_get_node (decl
);
393 if (node
->local
.finalized
&& cgraph_decide_is_function_needed (node
, decl
))
394 cgraph_mark_needed_node (node
);
397 /* Return TRUE if NODE2 is equivalent to NODE or its clone. */
399 clone_of_p (struct cgraph_node
*node
, struct cgraph_node
*node2
)
401 while (node
!= node2
&& node2
)
402 node2
= node2
->clone_of
;
403 return node2
!= NULL
;
406 /* Verify edge E count and frequency. */
409 verify_edge_count_and_frequency (struct cgraph_edge
*e
)
411 bool error_found
= false;
414 error ("caller edge count is negative");
417 if (e
->frequency
< 0)
419 error ("caller edge frequency is negative");
422 if (e
->frequency
> CGRAPH_FREQ_MAX
)
424 error ("caller edge frequency is too large");
427 if (gimple_has_body_p (e
->caller
->decl
)
428 && !e
->caller
->global
.inlined_to
430 != compute_call_stmt_bb_frequency (e
->caller
->decl
,
431 gimple_bb (e
->call_stmt
))))
433 error ("caller edge frequency %i does not match BB frequency %i",
435 compute_call_stmt_bb_frequency (e
->caller
->decl
,
436 gimple_bb (e
->call_stmt
)));
442 /* Switch to THIS_CFUN if needed and print STMT to stderr. */
444 cgraph_debug_gimple_stmt (struct function
*this_cfun
, gimple stmt
)
446 /* debug_gimple_stmt needs correct cfun */
447 if (cfun
!= this_cfun
)
448 set_cfun (this_cfun
);
449 debug_gimple_stmt (stmt
);
452 /* Verify cgraph nodes of given cgraph node. */
454 verify_cgraph_node (struct cgraph_node
*node
)
456 struct cgraph_edge
*e
;
457 struct function
*this_cfun
= DECL_STRUCT_FUNCTION (node
->decl
);
458 basic_block this_block
;
459 gimple_stmt_iterator gsi
;
460 bool error_found
= false;
465 timevar_push (TV_CGRAPH_VERIFY
);
466 for (e
= node
->callees
; e
; e
= e
->next_callee
)
469 error ("aux field set for edge %s->%s",
470 identifier_to_locale (cgraph_node_name (e
->caller
)),
471 identifier_to_locale (cgraph_node_name (e
->callee
)));
476 error ("execution count is negative");
479 if (node
->global
.inlined_to
&& node
->local
.externally_visible
)
481 error ("externally visible inline clone");
484 if (node
->global
.inlined_to
&& node
->address_taken
)
486 error ("inline clone with address taken");
489 if (node
->global
.inlined_to
&& node
->needed
)
491 error ("inline clone is needed");
494 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
498 error ("aux field set for indirect edge from %s",
499 identifier_to_locale (cgraph_node_name (e
->caller
)));
502 if (!e
->indirect_unknown_callee
503 || !e
->indirect_info
)
505 error ("An indirect edge from %s is not marked as indirect or has "
506 "associated indirect_info, the corresponding statement is: ",
507 identifier_to_locale (cgraph_node_name (e
->caller
)));
508 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
512 for (e
= node
->callers
; e
; e
= e
->next_caller
)
514 if (verify_edge_count_and_frequency (e
))
516 if (!e
->inline_failed
)
518 if (node
->global
.inlined_to
519 != (e
->caller
->global
.inlined_to
520 ? e
->caller
->global
.inlined_to
: e
->caller
))
522 error ("inlined_to pointer is wrong");
525 if (node
->callers
->next_caller
)
527 error ("multiple inline callers");
532 if (node
->global
.inlined_to
)
534 error ("inlined_to pointer set for noninline callers");
538 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
539 if (verify_edge_count_and_frequency (e
))
541 if (!node
->callers
&& node
->global
.inlined_to
)
543 error ("inlined_to pointer is set but no predecessors found");
546 if (node
->global
.inlined_to
== node
)
548 error ("inlined_to pointer refers to itself");
552 if (!cgraph_get_node (node
->decl
))
554 error ("node not found in cgraph_hash");
560 struct cgraph_node
*n
;
561 for (n
= node
->clone_of
->clones
; n
; n
= n
->next_sibling_clone
)
566 error ("node has wrong clone_of");
572 struct cgraph_node
*n
;
573 for (n
= node
->clones
; n
; n
= n
->next_sibling_clone
)
574 if (n
->clone_of
!= node
)
578 error ("node has wrong clone list");
582 if ((node
->prev_sibling_clone
|| node
->next_sibling_clone
) && !node
->clone_of
)
584 error ("node is in clone list but it is not clone");
587 if (!node
->prev_sibling_clone
&& node
->clone_of
&& node
->clone_of
->clones
!= node
)
589 error ("node has wrong prev_clone pointer");
592 if (node
->prev_sibling_clone
&& node
->prev_sibling_clone
->next_sibling_clone
!= node
)
594 error ("double linked list of clones corrupted");
597 if (node
->same_comdat_group
)
599 struct cgraph_node
*n
= node
->same_comdat_group
;
601 if (!DECL_ONE_ONLY (node
->decl
))
603 error ("non-DECL_ONE_ONLY node in a same_comdat_group list");
608 error ("node is alone in a comdat group");
613 if (!n
->same_comdat_group
)
615 error ("same_comdat_group is not a circular list");
619 n
= n
->same_comdat_group
;
624 if (node
->analyzed
&& gimple_has_body_p (node
->decl
)
625 && !TREE_ASM_WRITTEN (node
->decl
)
626 && (!DECL_EXTERNAL (node
->decl
) || node
->global
.inlined_to
)
631 /* The nodes we're interested in are never shared, so walk
632 the tree ignoring duplicates. */
633 struct pointer_set_t
*visited_nodes
= pointer_set_create ();
634 /* Reach the trees by walking over the CFG, and note the
635 enclosing basic-blocks in the call edges. */
636 FOR_EACH_BB_FN (this_block
, this_cfun
)
637 for (gsi
= gsi_start_bb (this_block
);
641 gimple stmt
= gsi_stmt (gsi
);
642 if (is_gimple_call (stmt
))
644 struct cgraph_edge
*e
= cgraph_edge (node
, stmt
);
645 tree decl
= gimple_call_fndecl (stmt
);
650 error ("shared call_stmt:");
651 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
654 if (!e
->indirect_unknown_callee
)
656 struct cgraph_node
*n
;
658 if (e
->callee
->same_body_alias
)
660 error ("edge points to same body alias:");
661 debug_tree (e
->callee
->decl
);
664 else if (!e
->callee
->global
.inlined_to
666 && cgraph_get_node (decl
)
667 && (e
->callee
->former_clone_of
668 != cgraph_get_node (decl
)->decl
)
669 && !clone_of_p (cgraph_get_node (decl
),
672 error ("edge points to wrong declaration:");
673 debug_tree (e
->callee
->decl
);
674 fprintf (stderr
," Instead of:");
679 && (n
= cgraph_get_node_or_alias (decl
))
680 && (n
->same_body_alias
681 && n
->thunk
.thunk_p
))
683 error ("a call to thunk improperly represented "
684 "in the call graph:");
685 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
691 error ("an indirect edge with unknown callee "
692 "corresponding to a call_stmt with "
693 "a known declaration:");
695 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
701 error ("missing callgraph edge for call stmt:");
702 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
707 pointer_set_destroy (visited_nodes
);
710 /* No CFG available?! */
713 for (e
= node
->callees
; e
; e
= e
->next_callee
)
717 error ("edge %s->%s has no corresponding call_stmt",
718 identifier_to_locale (cgraph_node_name (e
->caller
)),
719 identifier_to_locale (cgraph_node_name (e
->callee
)));
720 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
725 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
729 error ("an indirect edge from %s has no corresponding call_stmt",
730 identifier_to_locale (cgraph_node_name (e
->caller
)));
731 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
739 dump_cgraph_node (stderr
, node
);
740 internal_error ("verify_cgraph_node failed");
742 timevar_pop (TV_CGRAPH_VERIFY
);
745 /* Verify whole cgraph structure. */
749 struct cgraph_node
*node
;
754 for (node
= cgraph_nodes
; node
; node
= node
->next
)
755 verify_cgraph_node (node
);
758 /* Output all asm statements we have stored up to be output. */
761 cgraph_output_pending_asms (void)
763 struct cgraph_asm_node
*can
;
768 for (can
= cgraph_asm_nodes
; can
; can
= can
->next
)
769 assemble_asm (can
->asm_str
);
770 cgraph_asm_nodes
= NULL
;
773 /* Analyze the function scheduled to be output. */
775 cgraph_analyze_function (struct cgraph_node
*node
)
777 tree save
= current_function_decl
;
778 tree decl
= node
->decl
;
780 current_function_decl
= decl
;
781 push_cfun (DECL_STRUCT_FUNCTION (decl
));
783 assign_assembler_name_if_neeeded (node
->decl
);
785 /* Make sure to gimplify bodies only once. During analyzing a
786 function we lower it, which will require gimplified nested
787 functions, so we can end up here with an already gimplified
789 if (!gimple_body (decl
))
790 gimplify_function_tree (decl
);
791 dump_function (TDI_generic
, decl
);
793 cgraph_lower_function (node
);
794 node
->analyzed
= true;
797 current_function_decl
= save
;
800 /* Process attributes common for vars and functions. */
803 process_common_attributes (tree decl
)
805 tree weakref
= lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
));
807 if (weakref
&& !lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)))
809 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wattributes
,
810 "%<weakref%> attribute should be accompanied with"
811 " an %<alias%> attribute");
812 DECL_WEAK (decl
) = 0;
813 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
814 DECL_ATTRIBUTES (decl
));
818 /* Look for externally_visible and used attributes and mark cgraph nodes
821 We cannot mark the nodes at the point the attributes are processed (in
822 handle_*_attribute) because the copy of the declarations available at that
823 point may not be canonical. For example, in:
826 void f() __attribute__((used));
828 the declaration we see in handle_used_attribute will be the second
829 declaration -- but the front end will subsequently merge that declaration
830 with the original declaration and discard the second declaration.
832 Furthermore, we can't mark these nodes in cgraph_finalize_function because:
835 void f() __attribute__((externally_visible));
839 So, we walk the nodes at the end of the translation unit, applying the
840 attributes at that point. */
843 process_function_and_variable_attributes (struct cgraph_node
*first
,
844 struct varpool_node
*first_var
)
846 struct cgraph_node
*node
;
847 struct varpool_node
*vnode
;
849 for (node
= cgraph_nodes
; node
!= first
; node
= node
->next
)
851 tree decl
= node
->decl
;
852 if (DECL_PRESERVE_P (decl
))
853 cgraph_mark_needed_node (node
);
854 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
855 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl
))
856 && TREE_PUBLIC (node
->decl
))
858 if (node
->local
.finalized
)
859 cgraph_mark_needed_node (node
);
861 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
863 if (! TREE_PUBLIC (node
->decl
))
864 warning_at (DECL_SOURCE_LOCATION (node
->decl
), OPT_Wattributes
,
865 "%<externally_visible%>"
866 " attribute have effect only on public objects");
867 else if (node
->local
.finalized
)
868 cgraph_mark_needed_node (node
);
870 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
871 && node
->local
.finalized
)
873 warning_at (DECL_SOURCE_LOCATION (node
->decl
), OPT_Wattributes
,
874 "%<weakref%> attribute ignored"
875 " because function is defined");
876 DECL_WEAK (decl
) = 0;
877 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
878 DECL_ATTRIBUTES (decl
));
880 process_common_attributes (decl
);
882 for (vnode
= varpool_nodes
; vnode
!= first_var
; vnode
= vnode
->next
)
884 tree decl
= vnode
->decl
;
885 if (DECL_PRESERVE_P (decl
))
887 vnode
->force_output
= true;
888 if (vnode
->finalized
)
889 varpool_mark_needed_node (vnode
);
891 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
892 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl
))
893 && TREE_PUBLIC (vnode
->decl
))
895 if (vnode
->finalized
)
896 varpool_mark_needed_node (vnode
);
898 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
900 if (! TREE_PUBLIC (vnode
->decl
))
901 warning_at (DECL_SOURCE_LOCATION (vnode
->decl
), OPT_Wattributes
,
902 "%<externally_visible%>"
903 " attribute have effect only on public objects");
904 else if (vnode
->finalized
)
905 varpool_mark_needed_node (vnode
);
907 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
909 && DECL_INITIAL (decl
))
911 warning_at (DECL_SOURCE_LOCATION (vnode
->decl
), OPT_Wattributes
,
912 "%<weakref%> attribute ignored"
913 " because variable is initialized");
914 DECL_WEAK (decl
) = 0;
915 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
916 DECL_ATTRIBUTES (decl
));
918 process_common_attributes (decl
);
922 /* Process CGRAPH_NODES_NEEDED queue, analyze each function (and transitively
923 each reachable functions) and build cgraph.
924 The function can be called multiple times after inserting new nodes
925 into beginning of queue. Just the new part of queue is re-scanned then. */
928 cgraph_analyze_functions (void)
930 /* Keep track of already processed nodes when called multiple times for
931 intermodule optimization. */
932 static struct cgraph_node
*first_analyzed
;
933 struct cgraph_node
*first_processed
= first_analyzed
;
934 static struct varpool_node
*first_analyzed_var
;
935 struct cgraph_node
*node
, *next
;
937 bitmap_obstack_initialize (NULL
);
938 process_function_and_variable_attributes (first_processed
,
940 first_processed
= cgraph_nodes
;
941 first_analyzed_var
= varpool_nodes
;
942 varpool_analyze_pending_decls ();
943 if (cgraph_dump_file
)
945 fprintf (cgraph_dump_file
, "Initial entry points:");
946 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
948 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
949 fprintf (cgraph_dump_file
, "\n");
951 cgraph_process_new_functions ();
953 /* Propagate reachability flag and lower representation of all reachable
954 functions. In the future, lowering will introduce new functions and
955 new entry points on the way (by template instantiation and virtual
956 method table generation for instance). */
957 while (cgraph_nodes_queue
)
959 struct cgraph_edge
*edge
;
960 tree decl
= cgraph_nodes_queue
->decl
;
962 node
= cgraph_nodes_queue
;
963 cgraph_nodes_queue
= cgraph_nodes_queue
->next_needed
;
964 node
->next_needed
= NULL
;
966 /* ??? It is possible to create extern inline function and later using
967 weak alias attribute to kill its body. See
968 gcc.c-torture/compile/20011119-1.c */
969 if (!DECL_STRUCT_FUNCTION (decl
))
971 cgraph_reset_node (node
);
976 cgraph_analyze_function (node
);
978 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
979 if (!edge
->callee
->reachable
)
980 cgraph_mark_reachable_node (edge
->callee
);
982 if (node
->same_comdat_group
)
984 for (next
= node
->same_comdat_group
;
986 next
= next
->same_comdat_group
)
987 cgraph_mark_reachable_node (next
);
990 /* If decl is a clone of an abstract function, mark that abstract
991 function so that we don't release its body. The DECL_INITIAL() of that
992 abstract function declaration will be later needed to output debug
994 if (DECL_ABSTRACT_ORIGIN (decl
))
996 struct cgraph_node
*origin_node
;
997 origin_node
= cgraph_get_node (DECL_ABSTRACT_ORIGIN (decl
));
998 origin_node
->abstract_and_needed
= true;
1001 /* We finalize local static variables during constructing callgraph
1002 edges. Process their attributes too. */
1003 process_function_and_variable_attributes (first_processed
,
1004 first_analyzed_var
);
1005 first_processed
= cgraph_nodes
;
1006 first_analyzed_var
= varpool_nodes
;
1007 varpool_analyze_pending_decls ();
1008 cgraph_process_new_functions ();
1011 /* Collect entry points to the unit. */
1012 if (cgraph_dump_file
)
1014 fprintf (cgraph_dump_file
, "Unit entry points:");
1015 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
1017 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1018 fprintf (cgraph_dump_file
, "\n\nInitial ");
1019 dump_cgraph (cgraph_dump_file
);
1020 dump_varpool (cgraph_dump_file
);
1023 if (cgraph_dump_file
)
1024 fprintf (cgraph_dump_file
, "\nReclaiming functions:");
1026 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= next
)
1028 tree decl
= node
->decl
;
1031 if (node
->local
.finalized
&& !gimple_has_body_p (decl
))
1032 cgraph_reset_node (node
);
1034 if (!node
->reachable
&& gimple_has_body_p (decl
))
1036 if (cgraph_dump_file
)
1037 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1038 cgraph_remove_node (node
);
1042 node
->next_needed
= NULL
;
1043 gcc_assert (!node
->local
.finalized
|| gimple_has_body_p (decl
));
1044 gcc_assert (node
->analyzed
== node
->local
.finalized
);
1046 if (cgraph_dump_file
)
1048 fprintf (cgraph_dump_file
, "\n\nReclaimed ");
1049 dump_cgraph (cgraph_dump_file
);
1050 dump_varpool (cgraph_dump_file
);
1052 bitmap_obstack_release (NULL
);
1053 first_analyzed
= cgraph_nodes
;
1058 /* Analyze the whole compilation unit once it is parsed completely. */
1061 cgraph_finalize_compilation_unit (void)
1063 timevar_push (TV_CGRAPH
);
1065 /* If we're here there's no current function anymore. Some frontends
1066 are lazy in clearing these. */
1067 current_function_decl
= NULL
;
1070 /* Do not skip analyzing the functions if there were errors, we
1071 miss diagnostics for following functions otherwise. */
1073 /* Emit size functions we didn't inline. */
1074 finalize_size_functions ();
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 && (!cgraph_only_called_directly_p (node
)
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 build_simple_mem_ref (vtabletmp
));
1292 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1293 mark_symbols_for_renaming (stmt
);
1294 find_referenced_vars_in (stmt
);
1296 /* Find the entry with the vcall offset. */
1297 stmt
= gimple_build_assign (vtabletmp2
,
1298 fold_build2_loc (input_location
,
1300 TREE_TYPE (vtabletmp2
),
1302 fold_convert (sizetype
,
1304 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1306 /* Get the offset itself. */
1307 vtabletmp3
= create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp2
)),
1309 stmt
= gimple_build_assign (vtabletmp3
,
1310 build_simple_mem_ref (vtabletmp2
));
1311 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1312 mark_symbols_for_renaming (stmt
);
1313 find_referenced_vars_in (stmt
);
1315 /* Cast to sizetype. */
1316 offsettmp
= create_tmp_var (sizetype
, "offset");
1317 stmt
= gimple_build_assign (offsettmp
, fold_convert (sizetype
, vtabletmp3
));
1318 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1319 mark_symbols_for_renaming (stmt
);
1320 find_referenced_vars_in (stmt
);
1322 /* Adjust the `this' pointer. */
1323 ptr
= fold_build2_loc (input_location
,
1324 POINTER_PLUS_EXPR
, TREE_TYPE (ptr
), ptr
,
1329 && fixed_offset
!= 0)
1330 /* Adjust the pointer by the constant. */
1334 if (TREE_CODE (ptr
) == VAR_DECL
)
1338 ptrtmp
= create_tmp_var (TREE_TYPE (ptr
), "ptr");
1339 stmt
= gimple_build_assign (ptrtmp
, ptr
);
1340 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1341 mark_symbols_for_renaming (stmt
);
1342 find_referenced_vars_in (stmt
);
1344 ptr
= fold_build2_loc (input_location
,
1345 POINTER_PLUS_EXPR
, TREE_TYPE (ptrtmp
), ptrtmp
,
1346 size_int (fixed_offset
));
1349 /* Emit the statement and gimplify the adjustment expression. */
1350 ret
= create_tmp_var (TREE_TYPE (ptr
), "adjusted_this");
1351 stmt
= gimple_build_assign (ret
, ptr
);
1352 mark_symbols_for_renaming (stmt
);
1353 find_referenced_vars_in (stmt
);
1354 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1359 /* Produce assembler for thunk NODE. */
1362 assemble_thunk (struct cgraph_node
*node
)
1364 bool this_adjusting
= node
->thunk
.this_adjusting
;
1365 HOST_WIDE_INT fixed_offset
= node
->thunk
.fixed_offset
;
1366 HOST_WIDE_INT virtual_value
= node
->thunk
.virtual_value
;
1367 tree virtual_offset
= NULL
;
1368 tree alias
= node
->thunk
.alias
;
1369 tree thunk_fndecl
= node
->decl
;
1370 tree a
= DECL_ARGUMENTS (thunk_fndecl
);
1372 current_function_decl
= thunk_fndecl
;
1374 /* Ensure thunks are emitted in their correct sections. */
1375 resolve_unique_section (thunk_fndecl
, 0, flag_function_sections
);
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 add_local_decl (cfun
, restmp
);
1451 BLOCK_VARS (DECL_INITIAL (current_function_decl
)) = restmp
;
1454 restmp
= create_tmp_var_raw (restype
, "retval");
1457 for (arg
= a
; arg
; arg
= DECL_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
= DECL_CHAIN (a
); i
< nargs
; i
++, arg
= DECL_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 build_zero_cst (TREE_TYPE (restmp
)),
1498 NULL_TREE
, NULL_TREE
);
1499 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1500 make_edge (bb
, then_bb
, EDGE_TRUE_VALUE
);
1501 make_edge (bb
, else_bb
, EDGE_FALSE_VALUE
);
1502 make_edge (return_bb
, EXIT_BLOCK_PTR
, 0);
1503 make_edge (then_bb
, return_bb
, EDGE_FALLTHRU
);
1504 make_edge (else_bb
, return_bb
, EDGE_FALLTHRU
);
1505 bsi
= gsi_last_bb (then_bb
);
1508 restmp
= thunk_adjust (&bsi
, restmp
, /*this_adjusting=*/0,
1509 fixed_offset
, virtual_offset
);
1513 bsi
= gsi_last_bb (else_bb
);
1514 stmt
= gimple_build_assign (restmp
,
1515 build_zero_cst (TREE_TYPE (restmp
)));
1516 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1517 bsi
= gsi_last_bb (return_bb
);
1521 gimple_call_set_tail (call
, true);
1523 /* Build return value. */
1524 ret
= gimple_build_return (restmp
);
1525 gsi_insert_after (&bsi
, ret
, GSI_NEW_STMT
);
1527 delete_unreachable_blocks ();
1528 update_ssa (TODO_update_ssa
);
1530 cgraph_remove_same_body_alias (node
);
1531 /* Since we want to emit the thunk, we explicitly mark its name as
1533 cgraph_add_new_function (thunk_fndecl
, true);
1534 bitmap_obstack_release (NULL
);
1536 current_function_decl
= NULL
;
1539 /* Expand function specified by NODE. */
1542 cgraph_expand_function (struct cgraph_node
*node
)
1544 tree decl
= node
->decl
;
1546 /* We ought to not compile any inline clones. */
1547 gcc_assert (!node
->global
.inlined_to
);
1549 announce_function (decl
);
1551 if (node
->same_body
)
1553 struct cgraph_node
*alias
, *next
;
1554 bool saved_alias
= node
->alias
;
1555 for (alias
= node
->same_body
;
1556 alias
&& alias
->next
; alias
= alias
->next
)
1558 /* Walk aliases in the order they were created; it is possible that
1559 thunks refers to the aliases made earlier. */
1560 for (; alias
; alias
= next
)
1562 next
= alias
->previous
;
1563 if (!alias
->thunk
.thunk_p
)
1564 assemble_alias (alias
->decl
,
1565 DECL_ASSEMBLER_NAME (alias
->thunk
.alias
));
1567 assemble_thunk (alias
);
1569 node
->alias
= saved_alias
;
1570 cgraph_process_new_functions ();
1573 gcc_assert (node
->lowered
);
1575 /* Generate RTL for the body of DECL. */
1576 tree_rest_of_compilation (decl
);
1578 /* Make sure that BE didn't give up on compiling. */
1579 gcc_assert (TREE_ASM_WRITTEN (decl
));
1580 current_function_decl
= NULL
;
1581 gcc_assert (!cgraph_preserve_function_body_p (decl
));
1582 cgraph_release_function_body (node
);
1583 /* Eliminate all call edges. This is important so the GIMPLE_CALL no longer
1584 points to the dead function body. */
1585 cgraph_node_remove_callees (node
);
1587 cgraph_function_flags_ready
= true;
1590 /* Return true when CALLER_DECL should be inlined into CALLEE_DECL. */
1593 cgraph_inline_p (struct cgraph_edge
*e
, cgraph_inline_failed_t
*reason
)
1595 *reason
= e
->inline_failed
;
1596 return !e
->inline_failed
;
1601 /* Expand all functions that must be output.
1603 Attempt to topologically sort the nodes so function is output when
1604 all called functions are already assembled to allow data to be
1605 propagated across the callgraph. Use a stack to get smaller distance
1606 between a function and its callees (later we may choose to use a more
1607 sophisticated algorithm for function reordering; we will likely want
1608 to use subsections to make the output functions appear in top-down
1612 cgraph_expand_all_functions (void)
1614 struct cgraph_node
*node
;
1615 struct cgraph_node
**order
= XCNEWVEC (struct cgraph_node
*, cgraph_n_nodes
);
1616 int order_pos
, new_order_pos
= 0;
1619 order_pos
= cgraph_postorder (order
);
1620 gcc_assert (order_pos
== cgraph_n_nodes
);
1622 /* Garbage collector may remove inline clones we eliminate during
1623 optimization. So we must be sure to not reference them. */
1624 for (i
= 0; i
< order_pos
; i
++)
1625 if (order
[i
]->process
)
1626 order
[new_order_pos
++] = order
[i
];
1628 for (i
= new_order_pos
- 1; i
>= 0; i
--)
1633 gcc_assert (node
->reachable
);
1635 cgraph_expand_function (node
);
1638 cgraph_process_new_functions ();
1644 /* This is used to sort the node types by the cgraph order number. */
1646 enum cgraph_order_sort_kind
1648 ORDER_UNDEFINED
= 0,
1654 struct cgraph_order_sort
1656 enum cgraph_order_sort_kind kind
;
1659 struct cgraph_node
*f
;
1660 struct varpool_node
*v
;
1661 struct cgraph_asm_node
*a
;
1665 /* Output all functions, variables, and asm statements in the order
1666 according to their order fields, which is the order in which they
1667 appeared in the file. This implements -fno-toplevel-reorder. In
1668 this mode we may output functions and variables which don't really
1669 need to be output. */
1672 cgraph_output_in_order (void)
1675 struct cgraph_order_sort
*nodes
;
1677 struct cgraph_node
*pf
;
1678 struct varpool_node
*pv
;
1679 struct cgraph_asm_node
*pa
;
1682 nodes
= XCNEWVEC (struct cgraph_order_sort
, max
);
1684 varpool_analyze_pending_decls ();
1686 for (pf
= cgraph_nodes
; pf
; pf
= pf
->next
)
1691 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1692 nodes
[i
].kind
= ORDER_FUNCTION
;
1697 for (pv
= varpool_nodes_queue
; pv
; pv
= pv
->next_needed
)
1700 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1701 nodes
[i
].kind
= ORDER_VAR
;
1705 for (pa
= cgraph_asm_nodes
; pa
; pa
= pa
->next
)
1708 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1709 nodes
[i
].kind
= ORDER_ASM
;
1713 /* In toplevel reorder mode we output all statics; mark them as needed. */
1714 for (i
= 0; i
< max
; ++i
)
1716 if (nodes
[i
].kind
== ORDER_VAR
)
1718 varpool_mark_needed_node (nodes
[i
].u
.v
);
1721 varpool_empty_needed_queue ();
1723 for (i
= 0; i
< max
; ++i
)
1724 if (nodes
[i
].kind
== ORDER_VAR
)
1725 varpool_finalize_named_section_flags (nodes
[i
].u
.v
);
1727 for (i
= 0; i
< max
; ++i
)
1729 switch (nodes
[i
].kind
)
1731 case ORDER_FUNCTION
:
1732 nodes
[i
].u
.f
->process
= 0;
1733 cgraph_expand_function (nodes
[i
].u
.f
);
1737 varpool_assemble_decl (nodes
[i
].u
.v
);
1741 assemble_asm (nodes
[i
].u
.a
->asm_str
);
1744 case ORDER_UNDEFINED
:
1752 cgraph_asm_nodes
= NULL
;
1756 /* Return true when function body of DECL still needs to be kept around
1757 for later re-use. */
1759 cgraph_preserve_function_body_p (tree decl
)
1761 struct cgraph_node
*node
;
1763 gcc_assert (cgraph_global_info_ready
);
1764 /* Look if there is any clone around. */
1765 node
= cgraph_get_node (decl
);
1775 current_function_decl
= NULL
;
1776 gimple_register_cfg_hooks ();
1777 bitmap_obstack_initialize (NULL
);
1779 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_START
, NULL
);
1783 execute_ipa_pass_list (all_small_ipa_passes
);
1788 /* If pass_all_early_optimizations was not scheduled, the state of
1789 the cgraph will not be properly updated. Update it now. */
1790 if (cgraph_state
< CGRAPH_STATE_IPA_SSA
)
1791 cgraph_state
= CGRAPH_STATE_IPA_SSA
;
1795 /* Generate coverage variables and constructors. */
1798 /* Process new functions added. */
1800 current_function_decl
= NULL
;
1801 cgraph_process_new_functions ();
1803 execute_ipa_summary_passes
1804 ((struct ipa_opt_pass_d
*) all_regular_ipa_passes
);
1807 /* Some targets need to handle LTO assembler output specially. */
1808 if (flag_generate_lto
)
1809 targetm
.asm_out
.lto_start ();
1811 execute_ipa_summary_passes ((struct ipa_opt_pass_d
*) all_lto_gen_passes
);
1814 ipa_write_summaries ();
1816 if (flag_generate_lto
)
1817 targetm
.asm_out
.lto_end ();
1820 execute_ipa_pass_list (all_regular_ipa_passes
);
1821 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_END
, NULL
);
1823 bitmap_obstack_release (NULL
);
1827 /* Perform simple optimizations based on callgraph. */
1830 cgraph_optimize (void)
1835 #ifdef ENABLE_CHECKING
1839 /* Frontend may output common variables after the unit has been finalized.
1840 It is safe to deal with them here as they are always zero initialized. */
1841 varpool_analyze_pending_decls ();
1843 timevar_push (TV_CGRAPHOPT
);
1844 if (pre_ipa_mem_report
)
1846 fprintf (stderr
, "Memory consumption before IPA\n");
1847 dump_memory_report (false);
1850 fprintf (stderr
, "Performing interprocedural optimizations\n");
1851 cgraph_state
= CGRAPH_STATE_IPA
;
1853 /* Don't run the IPA passes if there was any error or sorry messages. */
1857 /* Do nothing else if any IPA pass found errors. */
1860 timevar_pop (TV_CGRAPHOPT
);
1864 /* This pass remove bodies of extern inline functions we never inlined.
1865 Do this later so other IPA passes see what is really going on. */
1866 cgraph_remove_unreachable_nodes (false, dump_file
);
1867 cgraph_global_info_ready
= true;
1868 if (cgraph_dump_file
)
1870 fprintf (cgraph_dump_file
, "Optimized ");
1871 dump_cgraph (cgraph_dump_file
);
1872 dump_varpool (cgraph_dump_file
);
1874 if (post_ipa_mem_report
)
1876 fprintf (stderr
, "Memory consumption after IPA\n");
1877 dump_memory_report (false);
1879 timevar_pop (TV_CGRAPHOPT
);
1881 /* Output everything. */
1882 (*debug_hooks
->assembly_start
) ();
1884 fprintf (stderr
, "Assembling functions:\n");
1885 #ifdef ENABLE_CHECKING
1889 cgraph_materialize_all_clones ();
1890 cgraph_mark_functions_to_output ();
1892 cgraph_state
= CGRAPH_STATE_EXPANSION
;
1893 if (!flag_toplevel_reorder
)
1894 cgraph_output_in_order ();
1897 cgraph_output_pending_asms ();
1899 cgraph_expand_all_functions ();
1900 varpool_remove_unreferenced_decls ();
1902 varpool_assemble_pending_decls ();
1904 cgraph_process_new_functions ();
1905 cgraph_state
= CGRAPH_STATE_FINISHED
;
1907 if (cgraph_dump_file
)
1909 fprintf (cgraph_dump_file
, "\nFinal ");
1910 dump_cgraph (cgraph_dump_file
);
1911 dump_varpool (cgraph_dump_file
);
1913 #ifdef ENABLE_CHECKING
1915 /* Double check that all inline clones are gone and that all
1916 function bodies have been released from memory. */
1919 struct cgraph_node
*node
;
1920 bool error_found
= false;
1922 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1924 && (node
->global
.inlined_to
1925 || gimple_has_body_p (node
->decl
)))
1928 dump_cgraph_node (stderr
, node
);
1931 internal_error ("nodes with unreleased memory found");
1939 if (!cgraph_dump_file
)
1940 cgraph_dump_file
= dump_begin (TDI_cgraph
, NULL
);
1943 /* The edges representing the callers of the NEW_VERSION node were
1944 fixed by cgraph_function_versioning (), now the call_expr in their
1945 respective tree code should be updated to call the NEW_VERSION. */
1948 update_call_expr (struct cgraph_node
*new_version
)
1950 struct cgraph_edge
*e
;
1952 gcc_assert (new_version
);
1954 /* Update the call expr on the edges to call the new version. */
1955 for (e
= new_version
->callers
; e
; e
= e
->next_caller
)
1957 struct function
*inner_function
= DECL_STRUCT_FUNCTION (e
->caller
->decl
);
1958 gimple_call_set_fndecl (e
->call_stmt
, new_version
->decl
);
1959 maybe_clean_eh_stmt_fn (inner_function
, e
->call_stmt
);
1964 /* Create a new cgraph node which is the new version of
1965 OLD_VERSION node. REDIRECT_CALLERS holds the callers
1966 edges which should be redirected to point to
1967 NEW_VERSION. ALL the callees edges of OLD_VERSION
1968 are cloned to the new version node. Return the new
1971 If non-NULL BLOCK_TO_COPY determine what basic blocks
1972 was copied to prevent duplications of calls that are dead
1975 static struct cgraph_node
*
1976 cgraph_copy_node_for_versioning (struct cgraph_node
*old_version
,
1978 VEC(cgraph_edge_p
,heap
) *redirect_callers
,
1981 struct cgraph_node
*new_version
;
1982 struct cgraph_edge
*e
;
1985 gcc_assert (old_version
);
1987 new_version
= cgraph_create_node (new_decl
);
1989 new_version
->analyzed
= true;
1990 new_version
->local
= old_version
->local
;
1991 new_version
->local
.externally_visible
= false;
1992 new_version
->local
.local
= true;
1993 new_version
->global
= old_version
->global
;
1994 new_version
->rtl
= old_version
->rtl
;
1995 new_version
->reachable
= true;
1996 new_version
->count
= old_version
->count
;
1998 for (e
= old_version
->callees
; e
; e
=e
->next_callee
)
2000 || bitmap_bit_p (bbs_to_copy
, gimple_bb (e
->call_stmt
)->index
))
2001 cgraph_clone_edge (e
, new_version
, e
->call_stmt
,
2002 e
->lto_stmt_uid
, REG_BR_PROB_BASE
,
2004 e
->loop_nest
, true);
2005 for (e
= old_version
->indirect_calls
; e
; e
=e
->next_callee
)
2007 || bitmap_bit_p (bbs_to_copy
, gimple_bb (e
->call_stmt
)->index
))
2008 cgraph_clone_edge (e
, new_version
, e
->call_stmt
,
2009 e
->lto_stmt_uid
, REG_BR_PROB_BASE
,
2011 e
->loop_nest
, true);
2012 FOR_EACH_VEC_ELT (cgraph_edge_p
, redirect_callers
, i
, e
)
2014 /* Redirect calls to the old version node to point to its new
2016 cgraph_redirect_edge_callee (e
, new_version
);
2022 /* Perform function versioning.
2023 Function versioning includes copying of the tree and
2024 a callgraph update (creating a new cgraph node and updating
2025 its callees and callers).
2027 REDIRECT_CALLERS varray includes the edges to be redirected
2030 TREE_MAP is a mapping of tree nodes we want to replace with
2031 new ones (according to results of prior analysis).
2032 OLD_VERSION_NODE is the node that is versioned.
2033 It returns the new version's cgraph node.
2034 If non-NULL ARGS_TO_SKIP determine function parameters to remove
2036 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
2037 If non_NULL NEW_ENTRY determine new entry BB of the clone. */
2039 struct cgraph_node
*
2040 cgraph_function_versioning (struct cgraph_node
*old_version_node
,
2041 VEC(cgraph_edge_p
,heap
) *redirect_callers
,
2042 VEC (ipa_replace_map_p
,gc
)* tree_map
,
2043 bitmap args_to_skip
,
2045 basic_block new_entry_block
,
2046 const char *clone_name
)
2048 tree old_decl
= old_version_node
->decl
;
2049 struct cgraph_node
*new_version_node
= NULL
;
2052 if (!tree_versionable_function_p (old_decl
))
2055 gcc_assert (old_version_node
->local
.can_change_signature
|| !args_to_skip
);
2057 /* Make a new FUNCTION_DECL tree node for the
2060 new_decl
= copy_node (old_decl
);
2062 new_decl
= build_function_decl_skip_args (old_decl
, args_to_skip
);
2064 /* Generate a new name for the new version. */
2065 DECL_NAME (new_decl
) = clone_function_name (old_decl
, clone_name
);
2066 SET_DECL_ASSEMBLER_NAME (new_decl
, DECL_NAME (new_decl
));
2067 SET_DECL_RTL (new_decl
, NULL
);
2069 /* Create the new version's call-graph node.
2070 and update the edges of the new node. */
2072 cgraph_copy_node_for_versioning (old_version_node
, new_decl
,
2073 redirect_callers
, bbs_to_copy
);
2075 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2076 tree_function_versioning (old_decl
, new_decl
, tree_map
, false, args_to_skip
,
2077 bbs_to_copy
, new_entry_block
);
2079 /* Update the new version's properties.
2080 Make The new version visible only within this translation unit. Make sure
2081 that is not weak also.
2082 ??? We cannot use COMDAT linkage because there is no
2083 ABI support for this. */
2084 cgraph_make_decl_local (new_version_node
->decl
);
2085 DECL_VIRTUAL_P (new_version_node
->decl
) = 0;
2086 new_version_node
->local
.externally_visible
= 0;
2087 new_version_node
->local
.local
= 1;
2088 new_version_node
->lowered
= true;
2090 /* Update the call_expr on the edges to call the new version node. */
2091 update_call_expr (new_version_node
);
2093 cgraph_call_function_insertion_hooks (new_version_node
);
2094 return new_version_node
;
2097 /* Produce separate function body for inline clones so the offline copy can be
2098 modified without affecting them. */
2099 struct cgraph_node
*
2100 save_inline_function_body (struct cgraph_node
*node
)
2102 struct cgraph_node
*first_clone
, *n
;
2104 gcc_assert (node
== cgraph_get_node (node
->decl
));
2106 cgraph_lower_function (node
);
2108 first_clone
= node
->clones
;
2110 first_clone
->decl
= copy_node (node
->decl
);
2111 cgraph_insert_node_to_hashtable (first_clone
);
2112 gcc_assert (first_clone
== cgraph_get_node (first_clone
->decl
));
2113 if (first_clone
->next_sibling_clone
)
2115 for (n
= first_clone
->next_sibling_clone
; n
->next_sibling_clone
; n
= n
->next_sibling_clone
)
2116 n
->clone_of
= first_clone
;
2117 n
->clone_of
= first_clone
;
2118 n
->next_sibling_clone
= first_clone
->clones
;
2119 if (first_clone
->clones
)
2120 first_clone
->clones
->prev_sibling_clone
= n
;
2121 first_clone
->clones
= first_clone
->next_sibling_clone
;
2122 first_clone
->next_sibling_clone
->prev_sibling_clone
= NULL
;
2123 first_clone
->next_sibling_clone
= NULL
;
2124 gcc_assert (!first_clone
->prev_sibling_clone
);
2126 first_clone
->clone_of
= NULL
;
2127 node
->clones
= NULL
;
2129 if (first_clone
->clones
)
2130 for (n
= first_clone
->clones
; n
!= first_clone
;)
2132 gcc_assert (n
->decl
== node
->decl
);
2133 n
->decl
= first_clone
->decl
;
2136 else if (n
->next_sibling_clone
)
2137 n
= n
->next_sibling_clone
;
2140 while (n
!= first_clone
&& !n
->next_sibling_clone
)
2142 if (n
!= first_clone
)
2143 n
= n
->next_sibling_clone
;
2147 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2148 tree_function_versioning (node
->decl
, first_clone
->decl
, NULL
, true, NULL
,
2151 DECL_EXTERNAL (first_clone
->decl
) = 0;
2152 DECL_COMDAT_GROUP (first_clone
->decl
) = NULL_TREE
;
2153 TREE_PUBLIC (first_clone
->decl
) = 0;
2154 DECL_COMDAT (first_clone
->decl
) = 0;
2155 VEC_free (ipa_opt_pass
, heap
,
2156 first_clone
->ipa_transforms_to_apply
);
2157 first_clone
->ipa_transforms_to_apply
= NULL
;
2159 #ifdef ENABLE_CHECKING
2160 verify_cgraph_node (first_clone
);
2165 /* Given virtual clone, turn it into actual clone. */
2167 cgraph_materialize_clone (struct cgraph_node
*node
)
2169 bitmap_obstack_initialize (NULL
);
2170 node
->former_clone_of
= node
->clone_of
->decl
;
2171 if (node
->clone_of
->former_clone_of
)
2172 node
->former_clone_of
= node
->clone_of
->former_clone_of
;
2173 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2174 tree_function_versioning (node
->clone_of
->decl
, node
->decl
,
2175 node
->clone
.tree_map
, true,
2176 node
->clone
.args_to_skip
, NULL
, NULL
);
2177 if (cgraph_dump_file
)
2179 dump_function_to_file (node
->clone_of
->decl
, cgraph_dump_file
, dump_flags
);
2180 dump_function_to_file (node
->decl
, cgraph_dump_file
, dump_flags
);
2183 /* Function is no longer clone. */
2184 if (node
->next_sibling_clone
)
2185 node
->next_sibling_clone
->prev_sibling_clone
= node
->prev_sibling_clone
;
2186 if (node
->prev_sibling_clone
)
2187 node
->prev_sibling_clone
->next_sibling_clone
= node
->next_sibling_clone
;
2189 node
->clone_of
->clones
= node
->next_sibling_clone
;
2190 node
->next_sibling_clone
= NULL
;
2191 node
->prev_sibling_clone
= NULL
;
2192 if (!node
->clone_of
->analyzed
&& !node
->clone_of
->clones
)
2194 cgraph_release_function_body (node
->clone_of
);
2195 cgraph_node_remove_callees (node
->clone_of
);
2196 ipa_remove_all_references (&node
->clone_of
->ref_list
);
2198 node
->clone_of
= NULL
;
2199 bitmap_obstack_release (NULL
);
2202 /* If necessary, change the function declaration in the call statement
2203 associated with E so that it corresponds to the edge callee. */
2206 cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge
*e
)
2208 tree decl
= gimple_call_fndecl (e
->call_stmt
);
2210 gimple_stmt_iterator gsi
;
2211 bool gsi_computed
= false;
2212 #ifdef ENABLE_CHECKING
2213 struct cgraph_node
*node
;
2216 if (e
->indirect_unknown_callee
2217 || decl
== e
->callee
->decl
2218 /* Don't update call from same body alias to the real function. */
2219 || (decl
&& cgraph_get_node (decl
) == cgraph_get_node (e
->callee
->decl
)))
2220 return e
->call_stmt
;
2222 #ifdef ENABLE_CHECKING
2225 node
= cgraph_get_node (decl
);
2226 gcc_assert (!node
|| !node
->clone
.combined_args_to_skip
);
2230 if (cgraph_dump_file
)
2232 fprintf (cgraph_dump_file
, "updating call of %s/%i -> %s/%i: ",
2233 cgraph_node_name (e
->caller
), e
->caller
->uid
,
2234 cgraph_node_name (e
->callee
), e
->callee
->uid
);
2235 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
2236 if (e
->callee
->clone
.combined_args_to_skip
)
2238 fprintf (cgraph_dump_file
, " combined args to skip: ");
2239 dump_bitmap (cgraph_dump_file
,
2240 e
->callee
->clone
.combined_args_to_skip
);
2244 if (e
->indirect_info
&&
2245 e
->indirect_info
->thunk_delta
!= 0
2246 && (!e
->callee
->clone
.combined_args_to_skip
2247 || !bitmap_bit_p (e
->callee
->clone
.combined_args_to_skip
, 0)))
2249 if (cgraph_dump_file
)
2250 fprintf (cgraph_dump_file
, " Thunk delta is "
2251 HOST_WIDE_INT_PRINT_DEC
"\n", e
->indirect_info
->thunk_delta
);
2252 gsi
= gsi_for_stmt (e
->call_stmt
);
2253 gsi_computed
= true;
2254 gimple_adjust_this_by_delta (&gsi
,
2255 build_int_cst (sizetype
,
2256 e
->indirect_info
->thunk_delta
));
2257 e
->indirect_info
->thunk_delta
= 0;
2260 if (e
->callee
->clone
.combined_args_to_skip
)
2265 = gimple_call_copy_skip_args (e
->call_stmt
,
2266 e
->callee
->clone
.combined_args_to_skip
);
2267 gimple_call_set_fndecl (new_stmt
, e
->callee
->decl
);
2269 if (gimple_vdef (new_stmt
)
2270 && TREE_CODE (gimple_vdef (new_stmt
)) == SSA_NAME
)
2271 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt
)) = new_stmt
;
2274 gsi
= gsi_for_stmt (e
->call_stmt
);
2275 gsi_replace (&gsi
, new_stmt
, false);
2276 /* We need to defer cleaning EH info on the new statement to
2277 fixup-cfg. We may not have dominator information at this point
2278 and thus would end up with unreachable blocks and have no way
2279 to communicate that we need to run CFG cleanup then. */
2280 lp_nr
= lookup_stmt_eh_lp (e
->call_stmt
);
2283 remove_stmt_from_eh_lp (e
->call_stmt
);
2284 add_stmt_to_eh_lp (new_stmt
, lp_nr
);
2289 new_stmt
= e
->call_stmt
;
2290 gimple_call_set_fndecl (new_stmt
, e
->callee
->decl
);
2291 update_stmt (new_stmt
);
2294 cgraph_set_call_stmt_including_clones (e
->caller
, e
->call_stmt
, new_stmt
);
2296 if (cgraph_dump_file
)
2298 fprintf (cgraph_dump_file
, " updated to:");
2299 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
2304 /* Once all functions from compilation unit are in memory, produce all clones
2305 and update all calls. We might also do this on demand if we don't want to
2306 bring all functions to memory prior compilation, but current WHOPR
2307 implementation does that and it is is bit easier to keep everything right in
2310 cgraph_materialize_all_clones (void)
2312 struct cgraph_node
*node
;
2313 bool stabilized
= false;
2315 if (cgraph_dump_file
)
2316 fprintf (cgraph_dump_file
, "Materializing clones\n");
2317 #ifdef ENABLE_CHECKING
2321 /* We can also do topological order, but number of iterations should be
2322 bounded by number of IPA passes since single IPA pass is probably not
2323 going to create clones of clones it created itself. */
2327 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2329 if (node
->clone_of
&& node
->decl
!= node
->clone_of
->decl
2330 && !gimple_has_body_p (node
->decl
))
2332 if (gimple_has_body_p (node
->clone_of
->decl
))
2334 if (cgraph_dump_file
)
2336 fprintf (cgraph_dump_file
, "cloning %s to %s\n",
2337 cgraph_node_name (node
->clone_of
),
2338 cgraph_node_name (node
));
2339 if (node
->clone
.tree_map
)
2342 fprintf (cgraph_dump_file
, " replace map: ");
2343 for (i
= 0; i
< VEC_length (ipa_replace_map_p
,
2344 node
->clone
.tree_map
);
2347 struct ipa_replace_map
*replace_info
;
2348 replace_info
= VEC_index (ipa_replace_map_p
,
2349 node
->clone
.tree_map
,
2351 print_generic_expr (cgraph_dump_file
, replace_info
->old_tree
, 0);
2352 fprintf (cgraph_dump_file
, " -> ");
2353 print_generic_expr (cgraph_dump_file
, replace_info
->new_tree
, 0);
2354 fprintf (cgraph_dump_file
, "%s%s;",
2355 replace_info
->replace_p
? "(replace)":"",
2356 replace_info
->ref_p
? "(ref)":"");
2358 fprintf (cgraph_dump_file
, "\n");
2360 if (node
->clone
.args_to_skip
)
2362 fprintf (cgraph_dump_file
, " args_to_skip: ");
2363 dump_bitmap (cgraph_dump_file
, node
->clone
.args_to_skip
);
2365 if (node
->clone
.args_to_skip
)
2367 fprintf (cgraph_dump_file
, " combined_args_to_skip:");
2368 dump_bitmap (cgraph_dump_file
, node
->clone
.combined_args_to_skip
);
2371 cgraph_materialize_clone (node
);
2377 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2378 if (!node
->analyzed
&& node
->callees
)
2379 cgraph_node_remove_callees (node
);
2380 if (cgraph_dump_file
)
2381 fprintf (cgraph_dump_file
, "Materialization Call site updates done.\n");
2382 #ifdef ENABLE_CHECKING
2385 cgraph_remove_unreachable_nodes (false, cgraph_dump_file
);
2388 #include "gt-cgraphunit.h"