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"
141 #include "ipa-inline.h"
142 #include "ipa-utils.h"
143 #include "lto-streamer.h"
145 static void cgraph_expand_all_functions (void);
146 static void cgraph_mark_functions_to_output (void);
147 static void cgraph_expand_function (struct cgraph_node
*);
148 static void cgraph_output_pending_asms (void);
150 FILE *cgraph_dump_file
;
152 /* Used for vtable lookup in thunk adjusting. */
153 static GTY (()) tree vtable_entry_type
;
155 /* Determine if function DECL is needed. That is, visible to something
156 either outside this translation unit, something magic in the system
160 cgraph_decide_is_function_needed (struct cgraph_node
*node
, tree decl
)
162 /* If the user told us it is used, then it must be so. */
163 if (node
->local
.externally_visible
)
166 /* ??? If the assembler name is set by hand, it is possible to assemble
167 the name later after finalizing the function and the fact is noticed
168 in assemble_name then. This is arguably a bug. */
169 if (DECL_ASSEMBLER_NAME_SET_P (decl
)
170 && (!node
->thunk
.thunk_p
&& !node
->same_body_alias
)
171 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)))
174 /* With -fkeep-inline-functions we are keeping all inline functions except
175 for extern inline ones. */
176 if (flag_keep_inline_functions
177 && DECL_DECLARED_INLINE_P (decl
)
178 && !DECL_EXTERNAL (decl
)
179 && !DECL_DISREGARD_INLINE_LIMITS (decl
))
182 /* If we decided it was needed before, but at the time we didn't have
183 the body of the function available, then it's still needed. We have
184 to go back and re-check its dependencies now. */
188 /* Externally visible functions must be output. The exception is
189 COMDAT functions that must be output only when they are needed.
191 When not optimizing, also output the static functions. (see
192 PR24561), but don't do so for always_inline functions, functions
193 declared inline and nested functions. These were optimized out
194 in the original implementation and it is unclear whether we want
195 to change the behavior here. */
196 if (((TREE_PUBLIC (decl
)
198 && !DECL_DISREGARD_INLINE_LIMITS (decl
)
199 && !DECL_DECLARED_INLINE_P (decl
)
200 && !(DECL_CONTEXT (decl
)
201 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
)))
202 && !flag_whole_program
204 && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
))
210 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
211 functions into callgraph in a way so they look like ordinary reachable
212 functions inserted into callgraph already at construction time. */
215 cgraph_process_new_functions (void)
219 struct cgraph_node
*node
;
221 varpool_analyze_pending_decls ();
222 /* Note that this queue may grow as its being processed, as the new
223 functions may generate new ones. */
224 while (cgraph_new_nodes
)
226 node
= cgraph_new_nodes
;
228 cgraph_new_nodes
= cgraph_new_nodes
->next_needed
;
229 switch (cgraph_state
)
231 case CGRAPH_STATE_CONSTRUCTION
:
232 /* At construction time we just need to finalize function and move
233 it into reachable functions list. */
235 node
->next_needed
= NULL
;
236 cgraph_finalize_function (fndecl
, false);
237 cgraph_mark_reachable_node (node
);
239 cgraph_call_function_insertion_hooks (node
);
242 case CGRAPH_STATE_IPA
:
243 case CGRAPH_STATE_IPA_SSA
:
244 /* When IPA optimization already started, do all essential
245 transformations that has been already performed on the whole
246 cgraph but not on this function. */
248 gimple_register_cfg_hooks ();
250 cgraph_analyze_function (node
);
251 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
252 current_function_decl
= fndecl
;
253 if ((cgraph_state
== CGRAPH_STATE_IPA_SSA
254 && !gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
255 /* When not optimizing, be sure we run early local passes anyway
258 execute_pass_list (pass_early_local_passes
.pass
.sub
);
260 compute_inline_parameters (node
, true);
261 free_dominance_info (CDI_POST_DOMINATORS
);
262 free_dominance_info (CDI_DOMINATORS
);
264 current_function_decl
= NULL
;
265 cgraph_call_function_insertion_hooks (node
);
268 case CGRAPH_STATE_EXPANSION
:
269 /* Functions created during expansion shall be compiled
272 cgraph_call_function_insertion_hooks (node
);
273 cgraph_expand_function (node
);
280 varpool_analyze_pending_decls ();
285 /* As an GCC extension we allow redefinition of the function. The
286 semantics when both copies of bodies differ is not well defined.
287 We replace the old body with new body so in unit at a time mode
288 we always use new body, while in normal mode we may end up with
289 old body inlined into some functions and new body expanded and
292 ??? It may make more sense to use one body for inlining and other
293 body for expanding the function but this is difficult to do. */
296 cgraph_reset_node (struct cgraph_node
*node
)
298 /* If node->process is set, then we have already begun whole-unit analysis.
299 This is *not* testing for whether we've already emitted the function.
300 That case can be sort-of legitimately seen with real function redefinition
301 errors. I would argue that the front end should never present us with
302 such a case, but don't enforce that for now. */
303 gcc_assert (!node
->process
);
305 /* Reset our data structures so we can analyze the function again. */
306 memset (&node
->local
, 0, sizeof (node
->local
));
307 memset (&node
->global
, 0, sizeof (node
->global
));
308 memset (&node
->rtl
, 0, sizeof (node
->rtl
));
309 node
->analyzed
= false;
310 node
->local
.finalized
= false;
312 cgraph_node_remove_callees (node
);
316 cgraph_lower_function (struct cgraph_node
*node
)
322 lower_nested_functions (node
->decl
);
323 gcc_assert (!node
->nested
);
325 tree_lowering_passes (node
->decl
);
326 node
->lowered
= true;
329 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
330 logic in effect. If NESTED is true, then our caller cannot stand to have
331 the garbage collector run at the moment. We would need to either create
332 a new GC context, or just not compile right now. */
335 cgraph_finalize_function (tree decl
, bool nested
)
337 struct cgraph_node
*node
= cgraph_get_create_node (decl
);
339 if (node
->local
.finalized
)
341 cgraph_reset_node (node
);
342 node
->local
.redefined_extern_inline
= true;
345 notice_global_symbol (decl
);
346 node
->local
.finalized
= true;
347 node
->lowered
= DECL_STRUCT_FUNCTION (decl
)->cfg
!= NULL
;
349 if (cgraph_decide_is_function_needed (node
, decl
))
350 cgraph_mark_needed_node (node
);
352 /* Since we reclaim unreachable nodes at the end of every language
353 level unit, we need to be conservative about possible entry points
355 if ((TREE_PUBLIC (decl
) && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
))
356 || DECL_STATIC_CONSTRUCTOR (decl
)
357 || DECL_STATIC_DESTRUCTOR (decl
)
358 /* COMDAT virtual functions may be referenced by vtable from
359 other compilation unit. Still we want to devirtualize calls
360 to those so we need to analyze them.
361 FIXME: We should introduce may edges for this purpose and update
362 their handling in unreachable function removal and inliner too. */
363 || (DECL_VIRTUAL_P (decl
)
364 && optimize
&& (DECL_COMDAT (decl
) || DECL_EXTERNAL (decl
))))
365 cgraph_mark_reachable_node (node
);
367 /* If we've not yet emitted decl, tell the debug info about it. */
368 if (!TREE_ASM_WRITTEN (decl
))
369 (*debug_hooks
->deferred_inline_function
) (decl
);
371 /* Possibly warn about unused parameters. */
372 if (warn_unused_parameter
)
373 do_warn_unused_parameter (decl
);
379 /* C99 extern inline keywords allow changing of declaration after function
380 has been finalized. We need to re-decide if we want to mark the function as
384 cgraph_mark_if_needed (tree decl
)
386 struct cgraph_node
*node
= cgraph_get_node (decl
);
387 if (node
->local
.finalized
&& cgraph_decide_is_function_needed (node
, decl
))
388 cgraph_mark_needed_node (node
);
391 /* Return TRUE if NODE2 is equivalent to NODE or its clone. */
393 clone_of_p (struct cgraph_node
*node
, struct cgraph_node
*node2
)
395 node
= cgraph_function_or_thunk_node (node
, NULL
);
396 node2
= cgraph_function_or_thunk_node (node2
, NULL
);
397 while (node
!= node2
&& node2
)
398 node2
= node2
->clone_of
;
399 return node2
!= NULL
;
402 /* Verify edge E count and frequency. */
405 verify_edge_count_and_frequency (struct cgraph_edge
*e
)
407 bool error_found
= false;
410 error ("caller edge count is negative");
413 if (e
->frequency
< 0)
415 error ("caller edge frequency is negative");
418 if (e
->frequency
> CGRAPH_FREQ_MAX
)
420 error ("caller edge frequency is too large");
423 if (gimple_has_body_p (e
->caller
->decl
)
424 && !e
->caller
->global
.inlined_to
425 /* FIXME: Inline-analysis sets frequency to 0 when edge is optimized out.
426 Remove this once edges are actualy removed from the function at that time. */
428 || (inline_edge_summary_vec
429 && !inline_edge_summary (e
)->predicate
))
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 frequency %i",
436 compute_call_stmt_bb_frequency (e
->caller
->decl
,
437 gimple_bb (e
->call_stmt
)));
443 /* Switch to THIS_CFUN if needed and print STMT to stderr. */
445 cgraph_debug_gimple_stmt (struct function
*this_cfun
, gimple stmt
)
447 /* debug_gimple_stmt needs correct cfun */
448 if (cfun
!= this_cfun
)
449 set_cfun (this_cfun
);
450 debug_gimple_stmt (stmt
);
453 /* Verify cgraph nodes of given cgraph node. */
455 verify_cgraph_node (struct cgraph_node
*node
)
457 struct cgraph_edge
*e
;
458 struct function
*this_cfun
= DECL_STRUCT_FUNCTION (node
->decl
);
459 basic_block this_block
;
460 gimple_stmt_iterator gsi
;
461 bool error_found
= false;
466 timevar_push (TV_CGRAPH_VERIFY
);
467 for (e
= node
->callees
; e
; e
= e
->next_callee
)
470 error ("aux field set for edge %s->%s",
471 identifier_to_locale (cgraph_node_name (e
->caller
)),
472 identifier_to_locale (cgraph_node_name (e
->callee
)));
477 error ("execution count is negative");
480 if (node
->global
.inlined_to
&& node
->local
.externally_visible
)
482 error ("externally visible inline clone");
485 if (node
->global
.inlined_to
&& node
->address_taken
)
487 error ("inline clone with address taken");
490 if (node
->global
.inlined_to
&& node
->needed
)
492 error ("inline clone is needed");
495 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
499 error ("aux field set for indirect edge from %s",
500 identifier_to_locale (cgraph_node_name (e
->caller
)));
503 if (!e
->indirect_unknown_callee
504 || !e
->indirect_info
)
506 error ("An indirect edge from %s is not marked as indirect or has "
507 "associated indirect_info, the corresponding statement is: ",
508 identifier_to_locale (cgraph_node_name (e
->caller
)));
509 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
513 for (e
= node
->callers
; e
; e
= e
->next_caller
)
515 if (verify_edge_count_and_frequency (e
))
517 if (!e
->inline_failed
)
519 if (node
->global
.inlined_to
520 != (e
->caller
->global
.inlined_to
521 ? e
->caller
->global
.inlined_to
: e
->caller
))
523 error ("inlined_to pointer is wrong");
526 if (node
->callers
->next_caller
)
528 error ("multiple inline callers");
533 if (node
->global
.inlined_to
)
535 error ("inlined_to pointer set for noninline callers");
539 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
540 if (verify_edge_count_and_frequency (e
))
542 if (!node
->callers
&& node
->global
.inlined_to
)
544 error ("inlined_to pointer is set but no predecessors found");
547 if (node
->global
.inlined_to
== node
)
549 error ("inlined_to pointer refers to itself");
553 if (!cgraph_get_node (node
->decl
))
555 error ("node not found in cgraph_hash");
561 struct cgraph_node
*n
;
562 for (n
= node
->clone_of
->clones
; n
; n
= n
->next_sibling_clone
)
567 error ("node has wrong clone_of");
573 struct cgraph_node
*n
;
574 for (n
= node
->clones
; n
; n
= n
->next_sibling_clone
)
575 if (n
->clone_of
!= node
)
579 error ("node has wrong clone list");
583 if ((node
->prev_sibling_clone
|| node
->next_sibling_clone
) && !node
->clone_of
)
585 error ("node is in clone list but it is not clone");
588 if (!node
->prev_sibling_clone
&& node
->clone_of
&& node
->clone_of
->clones
!= node
)
590 error ("node has wrong prev_clone pointer");
593 if (node
->prev_sibling_clone
&& node
->prev_sibling_clone
->next_sibling_clone
!= node
)
595 error ("double linked list of clones corrupted");
598 if (node
->same_comdat_group
)
600 struct cgraph_node
*n
= node
->same_comdat_group
;
602 if (!DECL_ONE_ONLY (node
->decl
))
604 error ("non-DECL_ONE_ONLY node in a same_comdat_group list");
609 error ("node is alone in a comdat group");
614 if (!n
->same_comdat_group
)
616 error ("same_comdat_group is not a circular list");
620 n
= n
->same_comdat_group
;
625 if (node
->analyzed
&& node
->alias
)
627 bool ref_found
= false;
633 error ("Alias has call edges");
636 for (i
= 0; ipa_ref_list_reference_iterate (&node
->ref_list
, i
, ref
); i
++)
637 if (ref
->use
!= IPA_REF_ALIAS
)
639 error ("Alias has non-alias refernece");
644 error ("Alias has more than one alias reference");
651 error ("Analyzed alias has no reference");
655 if (node
->analyzed
&& node
->thunk
.thunk_p
)
659 error ("No edge out of thunk node");
662 else if (node
->callees
->next_callee
)
664 error ("More than one edge out of thunk node");
667 if (gimple_has_body_p (node
->decl
))
669 error ("Thunk is not supposed to have body");
673 else if (node
->analyzed
&& gimple_has_body_p (node
->decl
)
674 && !TREE_ASM_WRITTEN (node
->decl
)
675 && (!DECL_EXTERNAL (node
->decl
) || node
->global
.inlined_to
)
680 /* The nodes we're interested in are never shared, so walk
681 the tree ignoring duplicates. */
682 struct pointer_set_t
*visited_nodes
= pointer_set_create ();
683 /* Reach the trees by walking over the CFG, and note the
684 enclosing basic-blocks in the call edges. */
685 FOR_EACH_BB_FN (this_block
, this_cfun
)
686 for (gsi
= gsi_start_bb (this_block
);
690 gimple stmt
= gsi_stmt (gsi
);
691 if (is_gimple_call (stmt
))
693 struct cgraph_edge
*e
= cgraph_edge (node
, stmt
);
694 tree decl
= gimple_call_fndecl (stmt
);
699 error ("shared call_stmt:");
700 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
703 if (!e
->indirect_unknown_callee
)
705 if (!e
->callee
->global
.inlined_to
707 && cgraph_get_node (decl
)
708 && (e
->callee
->former_clone_of
709 != cgraph_get_node (decl
)->decl
)
710 /* IPA-CP sometimes redirect edge to clone and then back to the former
711 function. This ping-pong has to go, eventaully. */
712 && (cgraph_function_or_thunk_node (cgraph_get_node (decl
), NULL
)
713 != cgraph_function_or_thunk_node (e
->callee
, NULL
))
714 && !clone_of_p (cgraph_get_node (decl
),
717 error ("edge points to wrong declaration:");
718 debug_tree (e
->callee
->decl
);
719 fprintf (stderr
," Instead of:");
726 error ("an indirect edge with unknown callee "
727 "corresponding to a call_stmt with "
728 "a known declaration:");
730 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
736 error ("missing callgraph edge for call stmt:");
737 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
742 pointer_set_destroy (visited_nodes
);
745 /* No CFG available?! */
748 for (e
= node
->callees
; e
; e
= e
->next_callee
)
752 error ("edge %s->%s has no corresponding call_stmt",
753 identifier_to_locale (cgraph_node_name (e
->caller
)),
754 identifier_to_locale (cgraph_node_name (e
->callee
)));
755 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
760 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
764 error ("an indirect edge from %s has no corresponding call_stmt",
765 identifier_to_locale (cgraph_node_name (e
->caller
)));
766 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
774 dump_cgraph_node (stderr
, node
);
775 internal_error ("verify_cgraph_node failed");
777 timevar_pop (TV_CGRAPH_VERIFY
);
780 /* Verify whole cgraph structure. */
784 struct cgraph_node
*node
;
789 for (node
= cgraph_nodes
; node
; node
= node
->next
)
790 verify_cgraph_node (node
);
793 /* Output all asm statements we have stored up to be output. */
796 cgraph_output_pending_asms (void)
798 struct cgraph_asm_node
*can
;
803 for (can
= cgraph_asm_nodes
; can
; can
= can
->next
)
804 assemble_asm (can
->asm_str
);
805 cgraph_asm_nodes
= NULL
;
808 /* Analyze the function scheduled to be output. */
810 cgraph_analyze_function (struct cgraph_node
*node
)
812 tree save
= current_function_decl
;
813 tree decl
= node
->decl
;
815 if (node
->alias
&& node
->thunk
.alias
)
817 struct cgraph_node
*tgt
= cgraph_get_node (node
->thunk
.alias
);
818 if (!VEC_length (ipa_ref_t
, node
->ref_list
.references
))
819 ipa_record_reference (node
, NULL
, tgt
, NULL
, IPA_REF_ALIAS
, NULL
);
820 if (node
->same_body_alias
)
822 DECL_VIRTUAL_P (node
->decl
) = DECL_VIRTUAL_P (node
->thunk
.alias
);
823 DECL_DECLARED_INLINE_P (node
->decl
)
824 = DECL_DECLARED_INLINE_P (node
->thunk
.alias
);
825 DECL_DISREGARD_INLINE_LIMITS (node
->decl
)
826 = DECL_DISREGARD_INLINE_LIMITS (node
->thunk
.alias
);
829 /* Fixup visibility nonsences C++ frontend produce on same body aliases. */
830 if (TREE_PUBLIC (node
->decl
) && node
->same_body_alias
)
832 DECL_EXTERNAL (node
->decl
) = DECL_EXTERNAL (node
->thunk
.alias
);
833 if (DECL_ONE_ONLY (node
->thunk
.alias
))
835 DECL_COMDAT (node
->decl
) = DECL_COMDAT (node
->thunk
.alias
);
836 DECL_COMDAT_GROUP (node
->decl
) = DECL_COMDAT_GROUP (node
->thunk
.alias
);
837 if (DECL_ONE_ONLY (node
->thunk
.alias
) && !node
->same_comdat_group
)
839 struct cgraph_node
*tgt
= cgraph_get_node (node
->thunk
.alias
);
840 node
->same_comdat_group
= tgt
;
841 if (!tgt
->same_comdat_group
)
842 tgt
->same_comdat_group
= node
;
845 struct cgraph_node
*n
;
846 for (n
= tgt
->same_comdat_group
;
847 n
->same_comdat_group
!= tgt
;
848 n
= n
->same_comdat_group
)
850 n
->same_comdat_group
= node
;
855 cgraph_mark_reachable_node (cgraph_alias_aliased_node (node
));
856 if (node
->address_taken
)
857 cgraph_mark_address_taken_node (cgraph_alias_aliased_node (node
));
858 if (cgraph_decide_is_function_needed (node
, node
->decl
))
859 cgraph_mark_needed_node (node
);
861 else if (node
->thunk
.thunk_p
)
863 cgraph_create_edge (node
, cgraph_get_node (node
->thunk
.alias
),
864 NULL
, 0, CGRAPH_FREQ_BASE
);
868 current_function_decl
= decl
;
869 push_cfun (DECL_STRUCT_FUNCTION (decl
));
871 assign_assembler_name_if_neeeded (node
->decl
);
873 /* Make sure to gimplify bodies only once. During analyzing a
874 function we lower it, which will require gimplified nested
875 functions, so we can end up here with an already gimplified
877 if (!gimple_body (decl
))
878 gimplify_function_tree (decl
);
879 dump_function (TDI_generic
, decl
);
881 cgraph_lower_function (node
);
884 node
->analyzed
= true;
886 current_function_decl
= save
;
889 /* C++ frontend produce same body aliases all over the place, even before PCH
890 gets streamed out. It relies on us linking the aliases with their function
891 in order to do the fixups, but ipa-ref is not PCH safe. Consequentely we
892 first produce aliases without links, but once C++ FE is sure he won't sream
893 PCH we build the links via this function. */
896 cgraph_process_same_body_aliases (void)
898 struct cgraph_node
*node
;
899 for (node
= cgraph_nodes
; node
; node
= node
->next
)
900 if (node
->same_body_alias
901 && !VEC_length (ipa_ref_t
, node
->ref_list
.references
))
903 struct cgraph_node
*tgt
= cgraph_get_node (node
->thunk
.alias
);
904 ipa_record_reference (node
, NULL
, tgt
, NULL
, IPA_REF_ALIAS
, NULL
);
906 same_body_aliases_done
= true;
909 /* Process attributes common for vars and functions. */
912 process_common_attributes (tree decl
)
914 tree weakref
= lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
));
916 if (weakref
&& !lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)))
918 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wattributes
,
919 "%<weakref%> attribute should be accompanied with"
920 " an %<alias%> attribute");
921 DECL_WEAK (decl
) = 0;
922 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
923 DECL_ATTRIBUTES (decl
));
927 /* Look for externally_visible and used attributes and mark cgraph nodes
930 We cannot mark the nodes at the point the attributes are processed (in
931 handle_*_attribute) because the copy of the declarations available at that
932 point may not be canonical. For example, in:
935 void f() __attribute__((used));
937 the declaration we see in handle_used_attribute will be the second
938 declaration -- but the front end will subsequently merge that declaration
939 with the original declaration and discard the second declaration.
941 Furthermore, we can't mark these nodes in cgraph_finalize_function because:
944 void f() __attribute__((externally_visible));
948 So, we walk the nodes at the end of the translation unit, applying the
949 attributes at that point. */
952 process_function_and_variable_attributes (struct cgraph_node
*first
,
953 struct varpool_node
*first_var
)
955 struct cgraph_node
*node
;
956 struct varpool_node
*vnode
;
958 for (node
= cgraph_nodes
; node
!= first
; node
= node
->next
)
960 tree decl
= node
->decl
;
961 if (DECL_PRESERVE_P (decl
))
962 cgraph_mark_needed_node (node
);
963 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
964 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl
))
965 && TREE_PUBLIC (node
->decl
))
967 if (node
->local
.finalized
)
968 cgraph_mark_needed_node (node
);
970 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
972 if (! TREE_PUBLIC (node
->decl
))
973 warning_at (DECL_SOURCE_LOCATION (node
->decl
), OPT_Wattributes
,
974 "%<externally_visible%>"
975 " attribute have effect only on public objects");
976 else if (node
->local
.finalized
)
977 cgraph_mark_needed_node (node
);
979 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
980 && (node
->local
.finalized
&& !node
->alias
))
982 warning_at (DECL_SOURCE_LOCATION (node
->decl
), OPT_Wattributes
,
983 "%<weakref%> attribute ignored"
984 " because function is defined");
985 DECL_WEAK (decl
) = 0;
986 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
987 DECL_ATTRIBUTES (decl
));
989 process_common_attributes (decl
);
991 for (vnode
= varpool_nodes
; vnode
!= first_var
; vnode
= vnode
->next
)
993 tree decl
= vnode
->decl
;
994 if (DECL_PRESERVE_P (decl
))
996 vnode
->force_output
= true;
997 if (vnode
->finalized
)
998 varpool_mark_needed_node (vnode
);
1000 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
1001 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl
))
1002 && TREE_PUBLIC (vnode
->decl
))
1004 if (vnode
->finalized
)
1005 varpool_mark_needed_node (vnode
);
1007 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
1009 if (! TREE_PUBLIC (vnode
->decl
))
1010 warning_at (DECL_SOURCE_LOCATION (vnode
->decl
), OPT_Wattributes
,
1011 "%<externally_visible%>"
1012 " attribute have effect only on public objects");
1013 else if (vnode
->finalized
)
1014 varpool_mark_needed_node (vnode
);
1016 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
1018 && DECL_INITIAL (decl
))
1020 warning_at (DECL_SOURCE_LOCATION (vnode
->decl
), OPT_Wattributes
,
1021 "%<weakref%> attribute ignored"
1022 " because variable is initialized");
1023 DECL_WEAK (decl
) = 0;
1024 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
1025 DECL_ATTRIBUTES (decl
));
1027 process_common_attributes (decl
);
1031 /* Process CGRAPH_NODES_NEEDED queue, analyze each function (and transitively
1032 each reachable functions) and build cgraph.
1033 The function can be called multiple times after inserting new nodes
1034 into beginning of queue. Just the new part of queue is re-scanned then. */
1037 cgraph_analyze_functions (void)
1039 /* Keep track of already processed nodes when called multiple times for
1040 intermodule optimization. */
1041 static struct cgraph_node
*first_analyzed
;
1042 struct cgraph_node
*first_processed
= first_analyzed
;
1043 static struct varpool_node
*first_analyzed_var
;
1044 struct cgraph_node
*node
, *next
;
1046 bitmap_obstack_initialize (NULL
);
1047 process_function_and_variable_attributes (first_processed
,
1048 first_analyzed_var
);
1049 first_processed
= cgraph_nodes
;
1050 first_analyzed_var
= varpool_nodes
;
1051 varpool_analyze_pending_decls ();
1052 if (cgraph_dump_file
)
1054 fprintf (cgraph_dump_file
, "Initial entry points:");
1055 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
1057 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1058 fprintf (cgraph_dump_file
, "\n");
1060 cgraph_process_new_functions ();
1062 /* Propagate reachability flag and lower representation of all reachable
1063 functions. In the future, lowering will introduce new functions and
1064 new entry points on the way (by template instantiation and virtual
1065 method table generation for instance). */
1066 while (cgraph_nodes_queue
)
1068 struct cgraph_edge
*edge
;
1069 tree decl
= cgraph_nodes_queue
->decl
;
1071 node
= cgraph_nodes_queue
;
1072 cgraph_nodes_queue
= cgraph_nodes_queue
->next_needed
;
1073 node
->next_needed
= NULL
;
1075 /* ??? It is possible to create extern inline function and later using
1076 weak alias attribute to kill its body. See
1077 gcc.c-torture/compile/20011119-1.c */
1078 if (!DECL_STRUCT_FUNCTION (decl
)
1079 && (!node
->alias
|| !node
->thunk
.alias
)
1080 && !node
->thunk
.thunk_p
)
1082 cgraph_reset_node (node
);
1083 node
->local
.redefined_extern_inline
= true;
1087 if (!node
->analyzed
)
1088 cgraph_analyze_function (node
);
1090 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
1091 if (!edge
->callee
->reachable
)
1092 cgraph_mark_reachable_node (edge
->callee
);
1093 for (edge
= node
->callers
; edge
; edge
= edge
->next_caller
)
1094 if (!edge
->caller
->reachable
&& edge
->caller
->thunk
.thunk_p
)
1095 cgraph_mark_reachable_node (edge
->caller
);
1097 if (node
->same_comdat_group
)
1099 for (next
= node
->same_comdat_group
;
1101 next
= next
->same_comdat_group
)
1102 cgraph_mark_reachable_node (next
);
1105 /* If decl is a clone of an abstract function, mark that abstract
1106 function so that we don't release its body. The DECL_INITIAL() of that
1107 abstract function declaration will be later needed to output debug
1109 if (DECL_ABSTRACT_ORIGIN (decl
))
1111 struct cgraph_node
*origin_node
;
1112 origin_node
= cgraph_get_node (DECL_ABSTRACT_ORIGIN (decl
));
1113 origin_node
->abstract_and_needed
= true;
1116 /* We finalize local static variables during constructing callgraph
1117 edges. Process their attributes too. */
1118 process_function_and_variable_attributes (first_processed
,
1119 first_analyzed_var
);
1120 first_processed
= cgraph_nodes
;
1121 first_analyzed_var
= varpool_nodes
;
1122 varpool_analyze_pending_decls ();
1123 cgraph_process_new_functions ();
1126 /* Collect entry points to the unit. */
1127 if (cgraph_dump_file
)
1129 fprintf (cgraph_dump_file
, "Unit entry points:");
1130 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
1132 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1133 fprintf (cgraph_dump_file
, "\n\nInitial ");
1134 dump_cgraph (cgraph_dump_file
);
1135 dump_varpool (cgraph_dump_file
);
1138 if (cgraph_dump_file
)
1139 fprintf (cgraph_dump_file
, "\nReclaiming functions:");
1141 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= next
)
1143 tree decl
= node
->decl
;
1146 if (node
->local
.finalized
&& !gimple_has_body_p (decl
)
1147 && (!node
->alias
|| !node
->thunk
.alias
)
1148 && !node
->thunk
.thunk_p
)
1149 cgraph_reset_node (node
);
1151 if (!node
->reachable
1152 && (gimple_has_body_p (decl
) || node
->thunk
.thunk_p
1153 || (node
->alias
&& node
->thunk
.alias
)))
1155 if (cgraph_dump_file
)
1156 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1157 cgraph_remove_node (node
);
1161 node
->next_needed
= NULL
;
1162 gcc_assert (!node
->local
.finalized
|| node
->thunk
.thunk_p
1164 || gimple_has_body_p (decl
));
1165 gcc_assert (node
->analyzed
== node
->local
.finalized
);
1167 if (cgraph_dump_file
)
1169 fprintf (cgraph_dump_file
, "\n\nReclaimed ");
1170 dump_cgraph (cgraph_dump_file
);
1171 dump_varpool (cgraph_dump_file
);
1173 bitmap_obstack_release (NULL
);
1174 first_analyzed
= cgraph_nodes
;
1179 /* Analyze the whole compilation unit once it is parsed completely. */
1182 cgraph_finalize_compilation_unit (void)
1184 timevar_push (TV_CGRAPH
);
1186 /* If LTO is enabled, initialize the streamer hooks needed by GIMPLE. */
1188 lto_streamer_hooks_init ();
1190 /* If we're here there's no current function anymore. Some frontends
1191 are lazy in clearing these. */
1192 current_function_decl
= NULL
;
1195 /* Do not skip analyzing the functions if there were errors, we
1196 miss diagnostics for following functions otherwise. */
1198 /* Emit size functions we didn't inline. */
1199 finalize_size_functions ();
1201 /* Mark alias targets necessary and emit diagnostics. */
1202 finish_aliases_1 ();
1206 fprintf (stderr
, "\nAnalyzing compilation unit\n");
1210 if (flag_dump_passes
)
1213 /* Gimplify and lower all functions, compute reachability and
1214 remove unreachable nodes. */
1215 cgraph_analyze_functions ();
1217 /* Mark alias targets necessary and emit diagnostics. */
1218 finish_aliases_1 ();
1220 /* Gimplify and lower thunks. */
1221 cgraph_analyze_functions ();
1223 /* Finally drive the pass manager. */
1226 timevar_pop (TV_CGRAPH
);
1230 /* Figure out what functions we want to assemble. */
1233 cgraph_mark_functions_to_output (void)
1235 struct cgraph_node
*node
;
1236 #ifdef ENABLE_CHECKING
1237 bool check_same_comdat_groups
= false;
1239 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1240 gcc_assert (!node
->process
);
1243 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1245 tree decl
= node
->decl
;
1246 struct cgraph_edge
*e
;
1248 gcc_assert (!node
->process
|| node
->same_comdat_group
);
1252 for (e
= node
->callers
; e
; e
= e
->next_caller
)
1253 if (e
->inline_failed
)
1256 /* We need to output all local functions that are used and not
1257 always inlined, as well as those that are reachable from
1258 outside the current compilation unit. */
1260 && !node
->thunk
.thunk_p
1262 && !node
->global
.inlined_to
1263 && (!cgraph_only_called_directly_p (node
)
1264 || ((e
|| ipa_ref_has_aliases_p (&node
->ref_list
))
1265 && node
->reachable
))
1266 && !TREE_ASM_WRITTEN (decl
)
1267 && !DECL_EXTERNAL (decl
))
1270 if (node
->same_comdat_group
)
1272 struct cgraph_node
*next
;
1273 for (next
= node
->same_comdat_group
;
1275 next
= next
->same_comdat_group
)
1276 if (!next
->thunk
.thunk_p
&& !next
->alias
)
1280 else if (node
->same_comdat_group
)
1282 #ifdef ENABLE_CHECKING
1283 check_same_comdat_groups
= true;
1288 /* We should've reclaimed all functions that are not needed. */
1289 #ifdef ENABLE_CHECKING
1290 if (!node
->global
.inlined_to
1291 && gimple_has_body_p (decl
)
1292 /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
1293 are inside partition, we can end up not removing the body since we no longer
1294 have analyzed node pointing to it. */
1295 && !node
->in_other_partition
1297 && !DECL_EXTERNAL (decl
))
1299 dump_cgraph_node (stderr
, node
);
1300 internal_error ("failed to reclaim unneeded function");
1303 gcc_assert (node
->global
.inlined_to
1304 || !gimple_has_body_p (decl
)
1305 || node
->in_other_partition
1306 || DECL_EXTERNAL (decl
));
1311 #ifdef ENABLE_CHECKING
1312 if (check_same_comdat_groups
)
1313 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1314 if (node
->same_comdat_group
&& !node
->process
)
1316 tree decl
= node
->decl
;
1317 if (!node
->global
.inlined_to
1318 && gimple_has_body_p (decl
)
1319 /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
1320 are inside partition, we can end up not removing the body since we no longer
1321 have analyzed node pointing to it. */
1322 && !node
->in_other_partition
1323 && !DECL_EXTERNAL (decl
))
1325 dump_cgraph_node (stderr
, node
);
1326 internal_error ("failed to reclaim unneeded functionin same comdat group");
1332 /* DECL is FUNCTION_DECL. Initialize datastructures so DECL is a function
1333 in lowered gimple form.
1335 Set current_function_decl and cfun to newly constructed empty function body.
1336 return basic block in the function body. */
1339 init_lowered_empty_function (tree decl
)
1343 current_function_decl
= decl
;
1344 allocate_struct_function (decl
, false);
1345 gimple_register_cfg_hooks ();
1346 init_empty_tree_cfg ();
1347 init_tree_ssa (cfun
);
1348 init_ssa_operands ();
1349 cfun
->gimple_df
->in_ssa_p
= true;
1350 DECL_INITIAL (decl
) = make_node (BLOCK
);
1352 DECL_SAVED_TREE (decl
) = error_mark_node
;
1353 cfun
->curr_properties
|=
1354 (PROP_gimple_lcf
| PROP_gimple_leh
| PROP_cfg
| PROP_referenced_vars
|
1357 /* Create BB for body of the function and connect it properly. */
1358 bb
= create_basic_block (NULL
, (void *) 0, ENTRY_BLOCK_PTR
);
1359 make_edge (ENTRY_BLOCK_PTR
, bb
, 0);
1360 make_edge (bb
, EXIT_BLOCK_PTR
, 0);
1365 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
1366 offset indicated by VIRTUAL_OFFSET, if that is
1367 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
1368 zero for a result adjusting thunk. */
1371 thunk_adjust (gimple_stmt_iterator
* bsi
,
1372 tree ptr
, bool this_adjusting
,
1373 HOST_WIDE_INT fixed_offset
, tree virtual_offset
)
1379 && fixed_offset
!= 0)
1381 stmt
= gimple_build_assign (ptr
,
1382 fold_build2_loc (input_location
,
1384 TREE_TYPE (ptr
), ptr
,
1385 size_int (fixed_offset
)));
1386 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1389 /* If there's a virtual offset, look up that value in the vtable and
1390 adjust the pointer again. */
1398 if (!vtable_entry_type
)
1400 tree vfunc_type
= make_node (FUNCTION_TYPE
);
1401 TREE_TYPE (vfunc_type
) = integer_type_node
;
1402 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
1403 layout_type (vfunc_type
);
1405 vtable_entry_type
= build_pointer_type (vfunc_type
);
1409 create_tmp_var (build_pointer_type
1410 (build_pointer_type (vtable_entry_type
)), "vptr");
1412 /* The vptr is always at offset zero in the object. */
1413 stmt
= gimple_build_assign (vtabletmp
,
1414 build1 (NOP_EXPR
, TREE_TYPE (vtabletmp
),
1416 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1417 mark_symbols_for_renaming (stmt
);
1418 find_referenced_vars_in (stmt
);
1420 /* Form the vtable address. */
1421 vtabletmp2
= create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp
)),
1423 stmt
= gimple_build_assign (vtabletmp2
,
1424 build_simple_mem_ref (vtabletmp
));
1425 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1426 mark_symbols_for_renaming (stmt
);
1427 find_referenced_vars_in (stmt
);
1429 /* Find the entry with the vcall offset. */
1430 stmt
= gimple_build_assign (vtabletmp2
,
1431 fold_build2_loc (input_location
,
1433 TREE_TYPE (vtabletmp2
),
1435 fold_convert (sizetype
,
1437 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1439 /* Get the offset itself. */
1440 vtabletmp3
= create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp2
)),
1442 stmt
= gimple_build_assign (vtabletmp3
,
1443 build_simple_mem_ref (vtabletmp2
));
1444 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1445 mark_symbols_for_renaming (stmt
);
1446 find_referenced_vars_in (stmt
);
1448 /* Cast to sizetype. */
1449 offsettmp
= create_tmp_var (sizetype
, "offset");
1450 stmt
= gimple_build_assign (offsettmp
, fold_convert (sizetype
, vtabletmp3
));
1451 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1452 mark_symbols_for_renaming (stmt
);
1453 find_referenced_vars_in (stmt
);
1455 /* Adjust the `this' pointer. */
1456 ptr
= fold_build2_loc (input_location
,
1457 POINTER_PLUS_EXPR
, TREE_TYPE (ptr
), ptr
,
1462 && fixed_offset
!= 0)
1463 /* Adjust the pointer by the constant. */
1467 if (TREE_CODE (ptr
) == VAR_DECL
)
1471 ptrtmp
= create_tmp_var (TREE_TYPE (ptr
), "ptr");
1472 stmt
= gimple_build_assign (ptrtmp
, ptr
);
1473 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1474 mark_symbols_for_renaming (stmt
);
1475 find_referenced_vars_in (stmt
);
1477 ptr
= fold_build2_loc (input_location
,
1478 POINTER_PLUS_EXPR
, TREE_TYPE (ptrtmp
), ptrtmp
,
1479 size_int (fixed_offset
));
1482 /* Emit the statement and gimplify the adjustment expression. */
1483 ret
= create_tmp_var (TREE_TYPE (ptr
), "adjusted_this");
1484 stmt
= gimple_build_assign (ret
, ptr
);
1485 mark_symbols_for_renaming (stmt
);
1486 find_referenced_vars_in (stmt
);
1487 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1492 /* Produce assembler for thunk NODE. */
1495 assemble_thunk (struct cgraph_node
*node
)
1497 bool this_adjusting
= node
->thunk
.this_adjusting
;
1498 HOST_WIDE_INT fixed_offset
= node
->thunk
.fixed_offset
;
1499 HOST_WIDE_INT virtual_value
= node
->thunk
.virtual_value
;
1500 tree virtual_offset
= NULL
;
1501 tree alias
= node
->thunk
.alias
;
1502 tree thunk_fndecl
= node
->decl
;
1503 tree a
= DECL_ARGUMENTS (thunk_fndecl
);
1505 current_function_decl
= thunk_fndecl
;
1507 /* Ensure thunks are emitted in their correct sections. */
1508 resolve_unique_section (thunk_fndecl
, 0, flag_function_sections
);
1511 && targetm
.asm_out
.can_output_mi_thunk (thunk_fndecl
, fixed_offset
,
1512 virtual_value
, alias
))
1517 DECL_RESULT (thunk_fndecl
)
1518 = build_decl (DECL_SOURCE_LOCATION (thunk_fndecl
),
1519 RESULT_DECL
, 0, integer_type_node
);
1520 fnname
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk_fndecl
));
1522 /* The back end expects DECL_INITIAL to contain a BLOCK, so we
1524 fn_block
= make_node (BLOCK
);
1525 BLOCK_VARS (fn_block
) = a
;
1526 DECL_INITIAL (thunk_fndecl
) = fn_block
;
1527 init_function_start (thunk_fndecl
);
1529 assemble_start_function (thunk_fndecl
, fnname
);
1531 targetm
.asm_out
.output_mi_thunk (asm_out_file
, thunk_fndecl
,
1532 fixed_offset
, virtual_value
, alias
);
1534 assemble_end_function (thunk_fndecl
, fnname
);
1535 init_insn_lengths ();
1536 free_after_compilation (cfun
);
1538 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
1539 node
->thunk
.thunk_p
= false;
1540 node
->analyzed
= false;
1545 basic_block bb
, then_bb
, else_bb
, return_bb
;
1546 gimple_stmt_iterator bsi
;
1552 VEC(tree
, heap
) *vargs
;
1557 DECL_IGNORED_P (thunk_fndecl
) = 1;
1558 bitmap_obstack_initialize (NULL
);
1560 if (node
->thunk
.virtual_offset_p
)
1561 virtual_offset
= size_int (virtual_value
);
1563 /* Build the return declaration for the function. */
1564 restype
= TREE_TYPE (TREE_TYPE (thunk_fndecl
));
1565 if (DECL_RESULT (thunk_fndecl
) == NULL_TREE
)
1567 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
1568 DECL_ARTIFICIAL (resdecl
) = 1;
1569 DECL_IGNORED_P (resdecl
) = 1;
1570 DECL_RESULT (thunk_fndecl
) = resdecl
;
1573 resdecl
= DECL_RESULT (thunk_fndecl
);
1575 bb
= then_bb
= else_bb
= return_bb
= init_lowered_empty_function (thunk_fndecl
);
1577 bsi
= gsi_start_bb (bb
);
1579 /* Build call to the function being thunked. */
1580 if (!VOID_TYPE_P (restype
))
1582 if (!is_gimple_reg_type (restype
))
1585 add_local_decl (cfun
, restmp
);
1586 BLOCK_VARS (DECL_INITIAL (current_function_decl
)) = restmp
;
1589 restmp
= create_tmp_var_raw (restype
, "retval");
1592 for (arg
= a
; arg
; arg
= DECL_CHAIN (arg
))
1594 vargs
= VEC_alloc (tree
, heap
, nargs
);
1596 VEC_quick_push (tree
, vargs
,
1601 VEC_quick_push (tree
, vargs
, a
);
1602 for (i
= 1, arg
= DECL_CHAIN (a
); i
< nargs
; i
++, arg
= DECL_CHAIN (arg
))
1603 VEC_quick_push (tree
, vargs
, arg
);
1604 call
= gimple_build_call_vec (build_fold_addr_expr_loc (0, alias
), vargs
);
1605 VEC_free (tree
, heap
, vargs
);
1606 gimple_call_set_cannot_inline (call
, true);
1607 gimple_call_set_from_thunk (call
, true);
1609 gimple_call_set_lhs (call
, restmp
);
1610 gsi_insert_after (&bsi
, call
, GSI_NEW_STMT
);
1611 mark_symbols_for_renaming (call
);
1612 find_referenced_vars_in (call
);
1615 if (restmp
&& !this_adjusting
)
1617 tree true_label
= NULL_TREE
;
1619 if (TREE_CODE (TREE_TYPE (restmp
)) == POINTER_TYPE
)
1622 /* If the return type is a pointer, we need to
1623 protect against NULL. We know there will be an
1624 adjustment, because that's why we're emitting a
1626 then_bb
= create_basic_block (NULL
, (void *) 0, bb
);
1627 return_bb
= create_basic_block (NULL
, (void *) 0, then_bb
);
1628 else_bb
= create_basic_block (NULL
, (void *) 0, else_bb
);
1629 remove_edge (single_succ_edge (bb
));
1630 true_label
= gimple_block_label (then_bb
);
1631 stmt
= gimple_build_cond (NE_EXPR
, restmp
,
1632 build_zero_cst (TREE_TYPE (restmp
)),
1633 NULL_TREE
, NULL_TREE
);
1634 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1635 make_edge (bb
, then_bb
, EDGE_TRUE_VALUE
);
1636 make_edge (bb
, else_bb
, EDGE_FALSE_VALUE
);
1637 make_edge (return_bb
, EXIT_BLOCK_PTR
, 0);
1638 make_edge (then_bb
, return_bb
, EDGE_FALLTHRU
);
1639 make_edge (else_bb
, return_bb
, EDGE_FALLTHRU
);
1640 bsi
= gsi_last_bb (then_bb
);
1643 restmp
= thunk_adjust (&bsi
, restmp
, /*this_adjusting=*/0,
1644 fixed_offset
, virtual_offset
);
1648 bsi
= gsi_last_bb (else_bb
);
1649 stmt
= gimple_build_assign (restmp
,
1650 build_zero_cst (TREE_TYPE (restmp
)));
1651 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1652 bsi
= gsi_last_bb (return_bb
);
1656 gimple_call_set_tail (call
, true);
1658 /* Build return value. */
1659 ret
= gimple_build_return (restmp
);
1660 gsi_insert_after (&bsi
, ret
, GSI_NEW_STMT
);
1662 delete_unreachable_blocks ();
1663 update_ssa (TODO_update_ssa
);
1665 /* Since we want to emit the thunk, we explicitly mark its name as
1667 node
->thunk
.thunk_p
= false;
1668 cgraph_node_remove_callees (node
);
1669 cgraph_add_new_function (thunk_fndecl
, true);
1670 bitmap_obstack_release (NULL
);
1672 current_function_decl
= NULL
;
1677 /* Assemble thunks and aliases asociated to NODE. */
1680 assemble_thunks_and_aliases (struct cgraph_node
*node
)
1682 struct cgraph_edge
*e
;
1684 struct ipa_ref
*ref
;
1686 for (e
= node
->callers
; e
;)
1687 if (e
->caller
->thunk
.thunk_p
)
1689 struct cgraph_node
*thunk
= e
->caller
;
1692 assemble_thunks_and_aliases (thunk
);
1693 assemble_thunk (thunk
);
1697 for (i
= 0; ipa_ref_list_refering_iterate (&node
->ref_list
, i
, ref
); i
++)
1698 if (ref
->use
== IPA_REF_ALIAS
)
1700 struct cgraph_node
*alias
= ipa_ref_refering_node (ref
);
1701 assemble_alias (alias
->decl
,
1702 DECL_ASSEMBLER_NAME (alias
->thunk
.alias
));
1703 assemble_thunks_and_aliases (alias
);
1707 /* Expand function specified by NODE. */
1710 cgraph_expand_function (struct cgraph_node
*node
)
1712 tree decl
= node
->decl
;
1714 /* We ought to not compile any inline clones. */
1715 gcc_assert (!node
->global
.inlined_to
);
1717 announce_function (decl
);
1719 assemble_thunks_and_aliases (node
);
1720 gcc_assert (node
->lowered
);
1722 /* Generate RTL for the body of DECL. */
1723 tree_rest_of_compilation (decl
);
1725 /* Make sure that BE didn't give up on compiling. */
1726 gcc_assert (TREE_ASM_WRITTEN (decl
));
1727 current_function_decl
= NULL
;
1728 gcc_assert (!cgraph_preserve_function_body_p (node
));
1729 cgraph_release_function_body (node
);
1730 /* Eliminate all call edges. This is important so the GIMPLE_CALL no longer
1731 points to the dead function body. */
1732 cgraph_node_remove_callees (node
);
1734 cgraph_function_flags_ready
= true;
1737 /* Return true when CALLER_DECL should be inlined into CALLEE_DECL. */
1740 cgraph_inline_p (struct cgraph_edge
*e
, cgraph_inline_failed_t
*reason
)
1742 *reason
= e
->inline_failed
;
1743 return !e
->inline_failed
;
1748 /* Expand all functions that must be output.
1750 Attempt to topologically sort the nodes so function is output when
1751 all called functions are already assembled to allow data to be
1752 propagated across the callgraph. Use a stack to get smaller distance
1753 between a function and its callees (later we may choose to use a more
1754 sophisticated algorithm for function reordering; we will likely want
1755 to use subsections to make the output functions appear in top-down
1759 cgraph_expand_all_functions (void)
1761 struct cgraph_node
*node
;
1762 struct cgraph_node
**order
= XCNEWVEC (struct cgraph_node
*, cgraph_n_nodes
);
1763 int order_pos
, new_order_pos
= 0;
1766 order_pos
= ipa_reverse_postorder (order
);
1767 gcc_assert (order_pos
== cgraph_n_nodes
);
1769 /* Garbage collector may remove inline clones we eliminate during
1770 optimization. So we must be sure to not reference them. */
1771 for (i
= 0; i
< order_pos
; i
++)
1772 if (order
[i
]->process
)
1773 order
[new_order_pos
++] = order
[i
];
1775 for (i
= new_order_pos
- 1; i
>= 0; i
--)
1780 gcc_assert (node
->reachable
);
1782 cgraph_expand_function (node
);
1785 cgraph_process_new_functions ();
1791 /* This is used to sort the node types by the cgraph order number. */
1793 enum cgraph_order_sort_kind
1795 ORDER_UNDEFINED
= 0,
1801 struct cgraph_order_sort
1803 enum cgraph_order_sort_kind kind
;
1806 struct cgraph_node
*f
;
1807 struct varpool_node
*v
;
1808 struct cgraph_asm_node
*a
;
1812 /* Output all functions, variables, and asm statements in the order
1813 according to their order fields, which is the order in which they
1814 appeared in the file. This implements -fno-toplevel-reorder. In
1815 this mode we may output functions and variables which don't really
1816 need to be output. */
1819 cgraph_output_in_order (void)
1822 struct cgraph_order_sort
*nodes
;
1824 struct cgraph_node
*pf
;
1825 struct varpool_node
*pv
;
1826 struct cgraph_asm_node
*pa
;
1829 nodes
= XCNEWVEC (struct cgraph_order_sort
, max
);
1831 varpool_analyze_pending_decls ();
1833 for (pf
= cgraph_nodes
; pf
; pf
= pf
->next
)
1835 if (pf
->process
&& !pf
->thunk
.thunk_p
&& !pf
->alias
)
1838 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1839 nodes
[i
].kind
= ORDER_FUNCTION
;
1844 for (pv
= varpool_nodes_queue
; pv
; pv
= pv
->next_needed
)
1847 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1848 nodes
[i
].kind
= ORDER_VAR
;
1852 for (pa
= cgraph_asm_nodes
; pa
; pa
= pa
->next
)
1855 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1856 nodes
[i
].kind
= ORDER_ASM
;
1860 /* In toplevel reorder mode we output all statics; mark them as needed. */
1861 for (i
= 0; i
< max
; ++i
)
1863 if (nodes
[i
].kind
== ORDER_VAR
)
1865 varpool_mark_needed_node (nodes
[i
].u
.v
);
1868 varpool_empty_needed_queue ();
1870 for (i
= 0; i
< max
; ++i
)
1871 if (nodes
[i
].kind
== ORDER_VAR
)
1872 varpool_finalize_named_section_flags (nodes
[i
].u
.v
);
1874 for (i
= 0; i
< max
; ++i
)
1876 switch (nodes
[i
].kind
)
1878 case ORDER_FUNCTION
:
1879 nodes
[i
].u
.f
->process
= 0;
1880 cgraph_expand_function (nodes
[i
].u
.f
);
1884 varpool_assemble_decl (nodes
[i
].u
.v
);
1888 assemble_asm (nodes
[i
].u
.a
->asm_str
);
1891 case ORDER_UNDEFINED
:
1899 cgraph_asm_nodes
= NULL
;
1903 /* Return true when function body of DECL still needs to be kept around
1904 for later re-use. */
1906 cgraph_preserve_function_body_p (struct cgraph_node
*node
)
1908 gcc_assert (cgraph_global_info_ready
);
1909 gcc_assert (!node
->alias
&& !node
->thunk
.thunk_p
);
1911 /* Look if there is any clone around. */
1921 current_function_decl
= NULL
;
1922 gimple_register_cfg_hooks ();
1923 bitmap_obstack_initialize (NULL
);
1925 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_START
, NULL
);
1929 execute_ipa_pass_list (all_small_ipa_passes
);
1934 /* If pass_all_early_optimizations was not scheduled, the state of
1935 the cgraph will not be properly updated. Update it now. */
1936 if (cgraph_state
< CGRAPH_STATE_IPA_SSA
)
1937 cgraph_state
= CGRAPH_STATE_IPA_SSA
;
1941 /* Generate coverage variables and constructors. */
1944 /* Process new functions added. */
1946 current_function_decl
= NULL
;
1947 cgraph_process_new_functions ();
1949 execute_ipa_summary_passes
1950 ((struct ipa_opt_pass_d
*) all_regular_ipa_passes
);
1953 /* Some targets need to handle LTO assembler output specially. */
1954 if (flag_generate_lto
)
1955 targetm
.asm_out
.lto_start ();
1957 execute_ipa_summary_passes ((struct ipa_opt_pass_d
*) all_lto_gen_passes
);
1960 ipa_write_summaries ();
1962 if (flag_generate_lto
)
1963 targetm
.asm_out
.lto_end ();
1966 execute_ipa_pass_list (all_regular_ipa_passes
);
1967 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_END
, NULL
);
1969 bitmap_obstack_release (NULL
);
1973 /* Perform simple optimizations based on callgraph. */
1976 cgraph_optimize (void)
1981 #ifdef ENABLE_CHECKING
1985 /* Frontend may output common variables after the unit has been finalized.
1986 It is safe to deal with them here as they are always zero initialized. */
1987 varpool_analyze_pending_decls ();
1989 timevar_push (TV_CGRAPHOPT
);
1990 if (pre_ipa_mem_report
)
1992 fprintf (stderr
, "Memory consumption before IPA\n");
1993 dump_memory_report (false);
1996 fprintf (stderr
, "Performing interprocedural optimizations\n");
1997 cgraph_state
= CGRAPH_STATE_IPA
;
1999 /* Don't run the IPA passes if there was any error or sorry messages. */
2003 /* Do nothing else if any IPA pass found errors. */
2006 timevar_pop (TV_CGRAPHOPT
);
2010 /* This pass remove bodies of extern inline functions we never inlined.
2011 Do this later so other IPA passes see what is really going on. */
2012 cgraph_remove_unreachable_nodes (false, dump_file
);
2013 cgraph_global_info_ready
= true;
2014 if (cgraph_dump_file
)
2016 fprintf (cgraph_dump_file
, "Optimized ");
2017 dump_cgraph (cgraph_dump_file
);
2018 dump_varpool (cgraph_dump_file
);
2020 if (post_ipa_mem_report
)
2022 fprintf (stderr
, "Memory consumption after IPA\n");
2023 dump_memory_report (false);
2025 timevar_pop (TV_CGRAPHOPT
);
2027 /* Output everything. */
2028 (*debug_hooks
->assembly_start
) ();
2030 fprintf (stderr
, "Assembling functions:\n");
2031 #ifdef ENABLE_CHECKING
2035 cgraph_materialize_all_clones ();
2036 cgraph_mark_functions_to_output ();
2038 cgraph_state
= CGRAPH_STATE_EXPANSION
;
2039 if (!flag_toplevel_reorder
)
2040 cgraph_output_in_order ();
2043 cgraph_output_pending_asms ();
2045 cgraph_expand_all_functions ();
2046 varpool_remove_unreferenced_decls ();
2048 varpool_assemble_pending_decls ();
2050 cgraph_process_new_functions ();
2051 cgraph_state
= CGRAPH_STATE_FINISHED
;
2053 if (cgraph_dump_file
)
2055 fprintf (cgraph_dump_file
, "\nFinal ");
2056 dump_cgraph (cgraph_dump_file
);
2057 dump_varpool (cgraph_dump_file
);
2059 #ifdef ENABLE_CHECKING
2061 /* Double check that all inline clones are gone and that all
2062 function bodies have been released from memory. */
2065 struct cgraph_node
*node
;
2066 bool error_found
= false;
2068 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2070 && (node
->global
.inlined_to
2071 || gimple_has_body_p (node
->decl
)))
2074 dump_cgraph_node (stderr
, node
);
2077 internal_error ("nodes with unreleased memory found");
2085 if (!cgraph_dump_file
)
2086 cgraph_dump_file
= dump_begin (TDI_cgraph
, NULL
);
2089 /* The edges representing the callers of the NEW_VERSION node were
2090 fixed by cgraph_function_versioning (), now the call_expr in their
2091 respective tree code should be updated to call the NEW_VERSION. */
2094 update_call_expr (struct cgraph_node
*new_version
)
2096 struct cgraph_edge
*e
;
2098 gcc_assert (new_version
);
2100 /* Update the call expr on the edges to call the new version. */
2101 for (e
= new_version
->callers
; e
; e
= e
->next_caller
)
2103 struct function
*inner_function
= DECL_STRUCT_FUNCTION (e
->caller
->decl
);
2104 gimple_call_set_fndecl (e
->call_stmt
, new_version
->decl
);
2105 maybe_clean_eh_stmt_fn (inner_function
, e
->call_stmt
);
2110 /* Create a new cgraph node which is the new version of
2111 OLD_VERSION node. REDIRECT_CALLERS holds the callers
2112 edges which should be redirected to point to
2113 NEW_VERSION. ALL the callees edges of OLD_VERSION
2114 are cloned to the new version node. Return the new
2117 If non-NULL BLOCK_TO_COPY determine what basic blocks
2118 was copied to prevent duplications of calls that are dead
2121 static struct cgraph_node
*
2122 cgraph_copy_node_for_versioning (struct cgraph_node
*old_version
,
2124 VEC(cgraph_edge_p
,heap
) *redirect_callers
,
2127 struct cgraph_node
*new_version
;
2128 struct cgraph_edge
*e
;
2131 gcc_assert (old_version
);
2133 new_version
= cgraph_create_node (new_decl
);
2135 new_version
->analyzed
= true;
2136 new_version
->local
= old_version
->local
;
2137 new_version
->local
.externally_visible
= false;
2138 new_version
->local
.local
= true;
2139 new_version
->global
= old_version
->global
;
2140 new_version
->rtl
= old_version
->rtl
;
2141 new_version
->reachable
= true;
2142 new_version
->count
= old_version
->count
;
2144 for (e
= old_version
->callees
; e
; e
=e
->next_callee
)
2146 || bitmap_bit_p (bbs_to_copy
, gimple_bb (e
->call_stmt
)->index
))
2147 cgraph_clone_edge (e
, new_version
, e
->call_stmt
,
2148 e
->lto_stmt_uid
, REG_BR_PROB_BASE
,
2151 for (e
= old_version
->indirect_calls
; e
; e
=e
->next_callee
)
2153 || bitmap_bit_p (bbs_to_copy
, gimple_bb (e
->call_stmt
)->index
))
2154 cgraph_clone_edge (e
, new_version
, e
->call_stmt
,
2155 e
->lto_stmt_uid
, REG_BR_PROB_BASE
,
2158 FOR_EACH_VEC_ELT (cgraph_edge_p
, redirect_callers
, i
, e
)
2160 /* Redirect calls to the old version node to point to its new
2162 cgraph_redirect_edge_callee (e
, new_version
);
2168 /* Perform function versioning.
2169 Function versioning includes copying of the tree and
2170 a callgraph update (creating a new cgraph node and updating
2171 its callees and callers).
2173 REDIRECT_CALLERS varray includes the edges to be redirected
2176 TREE_MAP is a mapping of tree nodes we want to replace with
2177 new ones (according to results of prior analysis).
2178 OLD_VERSION_NODE is the node that is versioned.
2179 It returns the new version's cgraph node.
2180 If non-NULL ARGS_TO_SKIP determine function parameters to remove
2182 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
2183 If non_NULL NEW_ENTRY determine new entry BB of the clone. */
2185 struct cgraph_node
*
2186 cgraph_function_versioning (struct cgraph_node
*old_version_node
,
2187 VEC(cgraph_edge_p
,heap
) *redirect_callers
,
2188 VEC (ipa_replace_map_p
,gc
)* tree_map
,
2189 bitmap args_to_skip
,
2191 basic_block new_entry_block
,
2192 const char *clone_name
)
2194 tree old_decl
= old_version_node
->decl
;
2195 struct cgraph_node
*new_version_node
= NULL
;
2198 if (!tree_versionable_function_p (old_decl
))
2201 gcc_assert (old_version_node
->local
.can_change_signature
|| !args_to_skip
);
2203 /* Make a new FUNCTION_DECL tree node for the
2206 new_decl
= copy_node (old_decl
);
2208 new_decl
= build_function_decl_skip_args (old_decl
, args_to_skip
);
2210 /* Generate a new name for the new version. */
2211 DECL_NAME (new_decl
) = clone_function_name (old_decl
, clone_name
);
2212 SET_DECL_ASSEMBLER_NAME (new_decl
, DECL_NAME (new_decl
));
2213 SET_DECL_RTL (new_decl
, NULL
);
2215 /* Create the new version's call-graph node.
2216 and update the edges of the new node. */
2218 cgraph_copy_node_for_versioning (old_version_node
, new_decl
,
2219 redirect_callers
, bbs_to_copy
);
2221 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2222 tree_function_versioning (old_decl
, new_decl
, tree_map
, false, args_to_skip
,
2223 bbs_to_copy
, new_entry_block
);
2225 /* Update the new version's properties.
2226 Make The new version visible only within this translation unit. Make sure
2227 that is not weak also.
2228 ??? We cannot use COMDAT linkage because there is no
2229 ABI support for this. */
2230 cgraph_make_decl_local (new_version_node
->decl
);
2231 DECL_VIRTUAL_P (new_version_node
->decl
) = 0;
2232 new_version_node
->local
.externally_visible
= 0;
2233 new_version_node
->local
.local
= 1;
2234 new_version_node
->lowered
= true;
2236 /* Update the call_expr on the edges to call the new version node. */
2237 update_call_expr (new_version_node
);
2239 cgraph_call_function_insertion_hooks (new_version_node
);
2240 return new_version_node
;
2243 /* Given virtual clone, turn it into actual clone. */
2245 cgraph_materialize_clone (struct cgraph_node
*node
)
2247 bitmap_obstack_initialize (NULL
);
2248 node
->former_clone_of
= node
->clone_of
->decl
;
2249 if (node
->clone_of
->former_clone_of
)
2250 node
->former_clone_of
= node
->clone_of
->former_clone_of
;
2251 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2252 tree_function_versioning (node
->clone_of
->decl
, node
->decl
,
2253 node
->clone
.tree_map
, true,
2254 node
->clone
.args_to_skip
, NULL
, NULL
);
2255 if (cgraph_dump_file
)
2257 dump_function_to_file (node
->clone_of
->decl
, cgraph_dump_file
, dump_flags
);
2258 dump_function_to_file (node
->decl
, cgraph_dump_file
, dump_flags
);
2261 /* Function is no longer clone. */
2262 if (node
->next_sibling_clone
)
2263 node
->next_sibling_clone
->prev_sibling_clone
= node
->prev_sibling_clone
;
2264 if (node
->prev_sibling_clone
)
2265 node
->prev_sibling_clone
->next_sibling_clone
= node
->next_sibling_clone
;
2267 node
->clone_of
->clones
= node
->next_sibling_clone
;
2268 node
->next_sibling_clone
= NULL
;
2269 node
->prev_sibling_clone
= NULL
;
2270 if (!node
->clone_of
->analyzed
&& !node
->clone_of
->clones
)
2272 cgraph_release_function_body (node
->clone_of
);
2273 cgraph_node_remove_callees (node
->clone_of
);
2274 ipa_remove_all_references (&node
->clone_of
->ref_list
);
2276 node
->clone_of
= NULL
;
2277 bitmap_obstack_release (NULL
);
2280 /* If necessary, change the function declaration in the call statement
2281 associated with E so that it corresponds to the edge callee. */
2284 cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge
*e
)
2286 tree decl
= gimple_call_fndecl (e
->call_stmt
);
2288 gimple_stmt_iterator gsi
;
2289 bool gsi_computed
= false;
2290 #ifdef ENABLE_CHECKING
2291 struct cgraph_node
*node
;
2294 if (e
->indirect_unknown_callee
2295 || decl
== e
->callee
->decl
2296 /* Don't update call from same body alias to the real function. */
2297 || (decl
&& cgraph_get_node (decl
) == cgraph_get_node (e
->callee
->decl
)))
2298 return e
->call_stmt
;
2300 #ifdef ENABLE_CHECKING
2303 node
= cgraph_get_node (decl
);
2304 gcc_assert (!node
|| !node
->clone
.combined_args_to_skip
);
2308 if (cgraph_dump_file
)
2310 fprintf (cgraph_dump_file
, "updating call of %s/%i -> %s/%i: ",
2311 cgraph_node_name (e
->caller
), e
->caller
->uid
,
2312 cgraph_node_name (e
->callee
), e
->callee
->uid
);
2313 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
2314 if (e
->callee
->clone
.combined_args_to_skip
)
2316 fprintf (cgraph_dump_file
, " combined args to skip: ");
2317 dump_bitmap (cgraph_dump_file
,
2318 e
->callee
->clone
.combined_args_to_skip
);
2322 if (e
->indirect_info
&&
2323 e
->indirect_info
->thunk_delta
!= 0
2324 && (!e
->callee
->clone
.combined_args_to_skip
2325 || !bitmap_bit_p (e
->callee
->clone
.combined_args_to_skip
, 0)))
2327 if (cgraph_dump_file
)
2328 fprintf (cgraph_dump_file
, " Thunk delta is "
2329 HOST_WIDE_INT_PRINT_DEC
"\n", e
->indirect_info
->thunk_delta
);
2330 gsi
= gsi_for_stmt (e
->call_stmt
);
2331 gsi_computed
= true;
2332 gimple_adjust_this_by_delta (&gsi
,
2333 build_int_cst (sizetype
,
2334 e
->indirect_info
->thunk_delta
));
2335 e
->indirect_info
->thunk_delta
= 0;
2338 if (e
->callee
->clone
.combined_args_to_skip
)
2343 = gimple_call_copy_skip_args (e
->call_stmt
,
2344 e
->callee
->clone
.combined_args_to_skip
);
2345 gimple_call_set_fndecl (new_stmt
, e
->callee
->decl
);
2347 if (gimple_vdef (new_stmt
)
2348 && TREE_CODE (gimple_vdef (new_stmt
)) == SSA_NAME
)
2349 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt
)) = new_stmt
;
2352 gsi
= gsi_for_stmt (e
->call_stmt
);
2353 gsi_replace (&gsi
, new_stmt
, false);
2354 /* We need to defer cleaning EH info on the new statement to
2355 fixup-cfg. We may not have dominator information at this point
2356 and thus would end up with unreachable blocks and have no way
2357 to communicate that we need to run CFG cleanup then. */
2358 lp_nr
= lookup_stmt_eh_lp (e
->call_stmt
);
2361 remove_stmt_from_eh_lp (e
->call_stmt
);
2362 add_stmt_to_eh_lp (new_stmt
, lp_nr
);
2367 new_stmt
= e
->call_stmt
;
2368 gimple_call_set_fndecl (new_stmt
, e
->callee
->decl
);
2369 update_stmt (new_stmt
);
2372 cgraph_set_call_stmt_including_clones (e
->caller
, e
->call_stmt
, new_stmt
);
2374 if (cgraph_dump_file
)
2376 fprintf (cgraph_dump_file
, " updated to:");
2377 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
2382 /* Once all functions from compilation unit are in memory, produce all clones
2383 and update all calls. We might also do this on demand if we don't want to
2384 bring all functions to memory prior compilation, but current WHOPR
2385 implementation does that and it is is bit easier to keep everything right in
2388 cgraph_materialize_all_clones (void)
2390 struct cgraph_node
*node
;
2391 bool stabilized
= false;
2393 if (cgraph_dump_file
)
2394 fprintf (cgraph_dump_file
, "Materializing clones\n");
2395 #ifdef ENABLE_CHECKING
2399 /* We can also do topological order, but number of iterations should be
2400 bounded by number of IPA passes since single IPA pass is probably not
2401 going to create clones of clones it created itself. */
2405 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2407 if (node
->clone_of
&& node
->decl
!= node
->clone_of
->decl
2408 && !gimple_has_body_p (node
->decl
))
2410 if (gimple_has_body_p (node
->clone_of
->decl
))
2412 if (cgraph_dump_file
)
2414 fprintf (cgraph_dump_file
, "cloning %s to %s\n",
2415 cgraph_node_name (node
->clone_of
),
2416 cgraph_node_name (node
));
2417 if (node
->clone
.tree_map
)
2420 fprintf (cgraph_dump_file
, " replace map: ");
2421 for (i
= 0; i
< VEC_length (ipa_replace_map_p
,
2422 node
->clone
.tree_map
);
2425 struct ipa_replace_map
*replace_info
;
2426 replace_info
= VEC_index (ipa_replace_map_p
,
2427 node
->clone
.tree_map
,
2429 print_generic_expr (cgraph_dump_file
, replace_info
->old_tree
, 0);
2430 fprintf (cgraph_dump_file
, " -> ");
2431 print_generic_expr (cgraph_dump_file
, replace_info
->new_tree
, 0);
2432 fprintf (cgraph_dump_file
, "%s%s;",
2433 replace_info
->replace_p
? "(replace)":"",
2434 replace_info
->ref_p
? "(ref)":"");
2436 fprintf (cgraph_dump_file
, "\n");
2438 if (node
->clone
.args_to_skip
)
2440 fprintf (cgraph_dump_file
, " args_to_skip: ");
2441 dump_bitmap (cgraph_dump_file
, node
->clone
.args_to_skip
);
2443 if (node
->clone
.args_to_skip
)
2445 fprintf (cgraph_dump_file
, " combined_args_to_skip:");
2446 dump_bitmap (cgraph_dump_file
, node
->clone
.combined_args_to_skip
);
2449 cgraph_materialize_clone (node
);
2455 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2456 if (!node
->analyzed
&& node
->callees
)
2457 cgraph_node_remove_callees (node
);
2458 if (cgraph_dump_file
)
2459 fprintf (cgraph_dump_file
, "Materialization Call site updates done.\n");
2460 #ifdef ENABLE_CHECKING
2463 cgraph_remove_unreachable_nodes (false, cgraph_dump_file
);
2466 #include "gt-cgraphunit.h"