1 /* Callgraph based interprocedural optimizations.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
4 Contributed by Jan Hubicka
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* This module implements main driver of compilation process as well as
23 few basic interprocedural optimizers.
25 The main scope of this file is to act as an interface in between
26 tree based frontends and the backend (and middle end)
28 The front-end is supposed to use following functionality:
30 - cgraph_finalize_function
32 This function is called once front-end has parsed whole body of function
33 and it is certain that the function body nor the declaration will change.
35 (There is one exception needed for implementing GCC extern inline
38 - varpool_finalize_variable
40 This function has same behavior as the above but is used for static
43 - cgraph_finalize_compilation_unit
45 This function is called once (source level) compilation unit is finalized
46 and it will no longer change.
48 In the the call-graph construction and local function
49 analysis takes place here. Bodies of unreachable functions are released
50 to conserve memory usage.
52 The function can be called multiple times when multiple source level
53 compilation units are combined (such as in C frontend)
57 In this unit-at-a-time compilation the intra procedural analysis takes
58 place here. In particular the static functions whose address is never
59 taken are marked as local. Backend can then use this information to
60 modify calling conventions, do better inlining or similar optimizations.
62 - cgraph_mark_needed_node
63 - varpool_mark_needed_node
65 When function or variable is referenced by some hidden way the call-graph
66 data structure must be updated accordingly by this function.
67 There should be little need to call this function and all the references
68 should be made explicit to cgraph code. At present these functions are
69 used by C++ frontend to explicitly mark the keyed methods.
71 - analyze_expr callback
73 This function is responsible for lowering tree nodes not understood by
74 generic code into understandable ones or alternatively marking
75 callgraph and varpool nodes referenced by the as needed.
77 ??? On the tree-ssa genericizing should take place here and we will avoid
78 need for these hooks (replacing them by genericizing hook)
80 Analyzing of all functions is deferred
81 to cgraph_finalize_compilation_unit and expansion into cgraph_optimize.
83 In cgraph_finalize_compilation_unit the reachable functions are
84 analyzed. During analysis the call-graph edges from reachable
85 functions are constructed and their destinations are marked as
86 reachable. References to functions and variables are discovered too
87 and variables found to be needed output to the assembly file. Via
88 mark_referenced call in assemble_variable functions referenced by
89 static variables are noticed too.
91 The intra-procedural information is produced and its existence
92 indicated by global_info_ready. Once this flag is set it is impossible
93 to change function from !reachable to reachable and thus
94 assemble_variable no longer call mark_referenced.
96 Finally the call-graph is topologically sorted and all reachable functions
97 that has not been completely inlined or are not external are output.
99 ??? It is possible that reference to function or variable is optimized
100 out. We can not deal with this nicely because topological order is not
101 suitable for it. For tree-ssa we may consider another pass doing
102 optimization and re-discovering reachable functions.
104 ??? Reorganize code so variables are output very last and only if they
105 really has been referenced by produced code, so we catch more cases
106 where reference has been optimized out. */
111 #include "coretypes.h"
115 #include "tree-flow.h"
116 #include "tree-inline.h"
117 #include "langhooks.h"
118 #include "pointer-set.h"
125 #include "diagnostic.h"
130 #include "function.h"
131 #include "ipa-prop.h"
133 #include "tree-iterator.h"
134 #include "tree-pass.h"
135 #include "tree-dump.h"
137 #include "coverage.h"
140 static void cgraph_expand_all_functions (void);
141 static void cgraph_mark_functions_to_output (void);
142 static void cgraph_expand_function (struct cgraph_node
*);
143 static void cgraph_output_pending_asms (void);
144 static void cgraph_analyze_function (struct cgraph_node
*);
146 static FILE *cgraph_dump_file
;
148 /* A vector of FUNCTION_DECLs declared as static constructors. */
149 static GTY (()) VEC(tree
, gc
) *static_ctors
;
150 /* A vector of FUNCTION_DECLs declared as static destructors. */
151 static GTY (()) VEC(tree
, gc
) *static_dtors
;
153 /* Used for vtable lookup in thunk adjusting. */
154 static GTY (()) tree vtable_entry_type
;
156 /* When target does not have ctors and dtors, we call all constructor
157 and destructor by special initialization/destruction function
158 recognized by collect2.
160 When we are going to build this function, collect all constructors and
161 destructors and turn them into normal functions. */
164 record_cdtor_fn (tree fndecl
)
166 struct cgraph_node
*node
;
167 if (targetm
.have_ctors_dtors
168 || (!DECL_STATIC_CONSTRUCTOR (fndecl
)
169 && !DECL_STATIC_DESTRUCTOR (fndecl
)))
172 if (DECL_STATIC_CONSTRUCTOR (fndecl
))
174 VEC_safe_push (tree
, gc
, static_ctors
, fndecl
);
175 DECL_STATIC_CONSTRUCTOR (fndecl
) = 0;
177 if (DECL_STATIC_DESTRUCTOR (fndecl
))
179 VEC_safe_push (tree
, gc
, static_dtors
, fndecl
);
180 DECL_STATIC_DESTRUCTOR (fndecl
) = 0;
182 node
= cgraph_node (fndecl
);
183 node
->local
.disregard_inline_limits
= 1;
184 cgraph_mark_reachable_node (node
);
187 /* Define global constructors/destructor functions for the CDTORS, of
188 which they are LEN. The CDTORS are sorted by initialization
189 priority. If CTOR_P is true, these are constructors; otherwise,
190 they are destructors. */
193 build_cdtor (bool ctor_p
, tree
*cdtors
, size_t len
)
202 priority_type priority
;
206 /* Find the next batch of constructors/destructors with the same
207 initialization priority. */
212 p
= ctor_p
? DECL_INIT_PRIORITY (fn
) : DECL_FINI_PRIORITY (fn
);
215 else if (p
!= priority
)
217 append_to_statement_list (build_function_call_expr (UNKNOWN_LOCATION
,
223 gcc_assert (body
!= NULL_TREE
);
224 /* Generate a function to call all the function of like
226 cgraph_build_static_cdtor (ctor_p
? 'I' : 'D', body
, priority
);
230 /* Comparison function for qsort. P1 and P2 are actually of type
231 "tree *" and point to static constructors. DECL_INIT_PRIORITY is
232 used to determine the sort order. */
235 compare_ctor (const void *p1
, const void *p2
)
242 f1
= *(const tree
*)p1
;
243 f2
= *(const tree
*)p2
;
244 priority1
= DECL_INIT_PRIORITY (f1
);
245 priority2
= DECL_INIT_PRIORITY (f2
);
247 if (priority1
< priority2
)
249 else if (priority1
> priority2
)
252 /* Ensure a stable sort. */
253 return (const tree
*)p1
- (const tree
*)p2
;
256 /* Comparison function for qsort. P1 and P2 are actually of type
257 "tree *" and point to static destructors. DECL_FINI_PRIORITY is
258 used to determine the sort order. */
261 compare_dtor (const void *p1
, const void *p2
)
268 f1
= *(const tree
*)p1
;
269 f2
= *(const tree
*)p2
;
270 priority1
= DECL_FINI_PRIORITY (f1
);
271 priority2
= DECL_FINI_PRIORITY (f2
);
273 if (priority1
< priority2
)
275 else if (priority1
> priority2
)
278 /* Ensure a stable sort. */
279 return (const tree
*)p1
- (const tree
*)p2
;
282 /* Generate functions to call static constructors and destructors
283 for targets that do not support .ctors/.dtors sections. These
284 functions have magic names which are detected by collect2. */
287 cgraph_build_cdtor_fns (void)
289 if (!VEC_empty (tree
, static_ctors
))
291 gcc_assert (!targetm
.have_ctors_dtors
);
292 qsort (VEC_address (tree
, static_ctors
),
293 VEC_length (tree
, static_ctors
),
296 build_cdtor (/*ctor_p=*/true,
297 VEC_address (tree
, static_ctors
),
298 VEC_length (tree
, static_ctors
));
299 VEC_truncate (tree
, static_ctors
, 0);
302 if (!VEC_empty (tree
, static_dtors
))
304 gcc_assert (!targetm
.have_ctors_dtors
);
305 qsort (VEC_address (tree
, static_dtors
),
306 VEC_length (tree
, static_dtors
),
309 build_cdtor (/*ctor_p=*/false,
310 VEC_address (tree
, static_dtors
),
311 VEC_length (tree
, static_dtors
));
312 VEC_truncate (tree
, static_dtors
, 0);
316 /* Determine if function DECL is needed. That is, visible to something
317 either outside this translation unit, something magic in the system
321 cgraph_decide_is_function_needed (struct cgraph_node
*node
, tree decl
)
323 /* If the user told us it is used, then it must be so. */
324 if (node
->local
.externally_visible
)
327 /* ??? If the assembler name is set by hand, it is possible to assemble
328 the name later after finalizing the function and the fact is noticed
329 in assemble_name then. This is arguably a bug. */
330 if (DECL_ASSEMBLER_NAME_SET_P (decl
)
331 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)))
334 /* With -fkeep-inline-functions we are keeping all inline functions except
335 for extern inline ones. */
336 if (flag_keep_inline_functions
337 && DECL_DECLARED_INLINE_P (decl
)
338 && !DECL_EXTERNAL (decl
)
339 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (decl
)))
342 /* If we decided it was needed before, but at the time we didn't have
343 the body of the function available, then it's still needed. We have
344 to go back and re-check its dependencies now. */
348 /* Externally visible functions must be output. The exception is
349 COMDAT functions that must be output only when they are needed.
351 When not optimizing, also output the static functions. (see
352 PR24561), but don't do so for always_inline functions, functions
353 declared inline and nested functions. These was optimized out
354 in the original implementation and it is unclear whether we want
355 to change the behavior here. */
356 if (((TREE_PUBLIC (decl
)
357 || (!optimize
&& !node
->local
.disregard_inline_limits
358 && !DECL_DECLARED_INLINE_P (decl
)
360 && !flag_whole_program
363 && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
))
366 /* Constructors and destructors are reachable from the runtime by
368 if (DECL_STATIC_CONSTRUCTOR (decl
) || DECL_STATIC_DESTRUCTOR (decl
))
374 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
375 functions into callgraph in a way so they look like ordinary reachable
376 functions inserted into callgraph already at construction time. */
379 cgraph_process_new_functions (void)
383 struct cgraph_node
*node
;
385 /* Note that this queue may grow as its being processed, as the new
386 functions may generate new ones. */
387 while (cgraph_new_nodes
)
389 node
= cgraph_new_nodes
;
391 cgraph_new_nodes
= cgraph_new_nodes
->next_needed
;
392 switch (cgraph_state
)
394 case CGRAPH_STATE_CONSTRUCTION
:
395 /* At construction time we just need to finalize function and move
396 it into reachable functions list. */
398 node
->next_needed
= NULL
;
399 cgraph_finalize_function (fndecl
, false);
400 cgraph_mark_reachable_node (node
);
404 case CGRAPH_STATE_IPA
:
405 case CGRAPH_STATE_IPA_SSA
:
406 /* When IPA optimization already started, do all essential
407 transformations that has been already performed on the whole
408 cgraph but not on this function. */
410 gimple_register_cfg_hooks ();
412 cgraph_analyze_function (node
);
413 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
414 current_function_decl
= fndecl
;
415 compute_inline_parameters (node
);
416 if ((cgraph_state
== CGRAPH_STATE_IPA_SSA
417 && !gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
418 /* When not optimizing, be sure we run early local passes anyway
421 execute_pass_list (pass_early_local_passes
.pass
.sub
);
422 free_dominance_info (CDI_POST_DOMINATORS
);
423 free_dominance_info (CDI_DOMINATORS
);
425 current_function_decl
= NULL
;
428 case CGRAPH_STATE_EXPANSION
:
429 /* Functions created during expansion shall be compiled
432 cgraph_expand_function (node
);
439 cgraph_call_function_insertion_hooks (node
);
444 /* As an GCC extension we allow redefinition of the function. The
445 semantics when both copies of bodies differ is not well defined.
446 We replace the old body with new body so in unit at a time mode
447 we always use new body, while in normal mode we may end up with
448 old body inlined into some functions and new body expanded and
451 ??? It may make more sense to use one body for inlining and other
452 body for expanding the function but this is difficult to do. */
455 cgraph_reset_node (struct cgraph_node
*node
)
457 /* If node->process is set, then we have already begun whole-unit analysis.
458 This is *not* testing for whether we've already emitted the function.
459 That case can be sort-of legitimately seen with real function redefinition
460 errors. I would argue that the front end should never present us with
461 such a case, but don't enforce that for now. */
462 gcc_assert (!node
->process
);
464 /* Reset our data structures so we can analyze the function again. */
465 memset (&node
->local
, 0, sizeof (node
->local
));
466 memset (&node
->global
, 0, sizeof (node
->global
));
467 memset (&node
->rtl
, 0, sizeof (node
->rtl
));
468 node
->analyzed
= false;
469 node
->local
.redefined_extern_inline
= true;
470 node
->local
.finalized
= false;
472 cgraph_node_remove_callees (node
);
474 /* We may need to re-queue the node for assembling in case
475 we already proceeded it and ignored as not needed or got
476 a re-declaration in IMA mode. */
479 struct cgraph_node
*n
;
481 for (n
= cgraph_nodes_queue
; n
; n
= n
->next_needed
)
490 cgraph_lower_function (struct cgraph_node
*node
)
496 lower_nested_functions (node
->decl
);
497 gcc_assert (!node
->nested
);
499 tree_lowering_passes (node
->decl
);
500 node
->lowered
= true;
503 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
504 logic in effect. If NESTED is true, then our caller cannot stand to have
505 the garbage collector run at the moment. We would need to either create
506 a new GC context, or just not compile right now. */
509 cgraph_finalize_function (tree decl
, bool nested
)
511 struct cgraph_node
*node
= cgraph_node (decl
);
513 if (node
->local
.finalized
)
514 cgraph_reset_node (node
);
516 node
->pid
= cgraph_max_pid
++;
517 notice_global_symbol (decl
);
518 node
->local
.finalized
= true;
519 node
->lowered
= DECL_STRUCT_FUNCTION (decl
)->cfg
!= NULL
;
520 node
->finalized_by_frontend
= true;
521 record_cdtor_fn (node
->decl
);
523 if (cgraph_decide_is_function_needed (node
, decl
))
524 cgraph_mark_needed_node (node
);
526 /* Since we reclaim unreachable nodes at the end of every language
527 level unit, we need to be conservative about possible entry points
529 if ((TREE_PUBLIC (decl
) && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
)))
530 cgraph_mark_reachable_node (node
);
532 /* If we've not yet emitted decl, tell the debug info about it. */
533 if (!TREE_ASM_WRITTEN (decl
))
534 (*debug_hooks
->deferred_inline_function
) (decl
);
536 /* Possibly warn about unused parameters. */
537 if (warn_unused_parameter
)
538 do_warn_unused_parameter (decl
);
544 /* C99 extern inline keywords allow changing of declaration after function
545 has been finalized. We need to re-decide if we want to mark the function as
549 cgraph_mark_if_needed (tree decl
)
551 struct cgraph_node
*node
= cgraph_node (decl
);
552 if (node
->local
.finalized
&& cgraph_decide_is_function_needed (node
, decl
))
553 cgraph_mark_needed_node (node
);
556 /* Return TRUE if NODE2 is equivalent to NODE or its clone. */
558 clone_of_p (struct cgraph_node
*node
, struct cgraph_node
*node2
)
560 while (node
!= node2
&& node2
)
561 node2
= node2
->clone_of
;
562 return node2
!= NULL
;
565 /* Verify cgraph nodes of given cgraph node. */
567 verify_cgraph_node (struct cgraph_node
*node
)
569 struct cgraph_edge
*e
;
570 struct function
*this_cfun
= DECL_STRUCT_FUNCTION (node
->decl
);
571 struct function
*saved_cfun
= cfun
;
572 basic_block this_block
;
573 gimple_stmt_iterator gsi
;
574 bool error_found
= false;
576 if (errorcount
|| sorrycount
)
579 timevar_push (TV_CGRAPH_VERIFY
);
580 /* debug_generic_stmt needs correct cfun */
581 set_cfun (this_cfun
);
582 for (e
= node
->callees
; e
; e
= e
->next_callee
)
585 error ("aux field set for edge %s->%s",
586 identifier_to_locale (cgraph_node_name (e
->caller
)),
587 identifier_to_locale (cgraph_node_name (e
->callee
)));
592 error ("Execution count is negative");
595 if (node
->global
.inlined_to
&& node
->local
.externally_visible
)
597 error ("Externally visible inline clone");
600 if (node
->global
.inlined_to
&& node
->address_taken
)
602 error ("Inline clone with address taken");
605 if (node
->global
.inlined_to
&& node
->needed
)
607 error ("Inline clone is needed");
610 for (e
= node
->callers
; e
; e
= e
->next_caller
)
614 error ("caller edge count is negative");
617 if (e
->frequency
< 0)
619 error ("caller edge frequency is negative");
622 if (e
->frequency
> CGRAPH_FREQ_MAX
)
624 error ("caller edge frequency is too large");
627 if (gimple_has_body_p (e
->caller
->decl
)
628 && !e
->caller
->global
.inlined_to
630 != compute_call_stmt_bb_frequency (e
->caller
->decl
,
631 gimple_bb (e
->call_stmt
))))
633 error ("caller edge frequency %i does not match BB freqency %i",
635 compute_call_stmt_bb_frequency (e
->caller
->decl
,
636 gimple_bb (e
->call_stmt
)));
639 if (!e
->inline_failed
)
641 if (node
->global
.inlined_to
642 != (e
->caller
->global
.inlined_to
643 ? e
->caller
->global
.inlined_to
: e
->caller
))
645 error ("inlined_to pointer is wrong");
648 if (node
->callers
->next_caller
)
650 error ("multiple inline callers");
655 if (node
->global
.inlined_to
)
657 error ("inlined_to pointer set for noninline callers");
661 if (!node
->callers
&& node
->global
.inlined_to
)
663 error ("inlined_to pointer is set but no predecessors found");
666 if (node
->global
.inlined_to
== node
)
668 error ("inlined_to pointer refers to itself");
672 if (!cgraph_node (node
->decl
))
674 error ("node not found in cgraph_hash");
680 struct cgraph_node
*n
;
681 for (n
= node
->clone_of
->clones
; n
; n
= n
->next_sibling_clone
)
686 error ("node has wrong clone_of");
692 struct cgraph_node
*n
;
693 for (n
= node
->clones
; n
; n
= n
->next_sibling_clone
)
694 if (n
->clone_of
!= node
)
698 error ("node has wrong clone list");
702 if ((node
->prev_sibling_clone
|| node
->next_sibling_clone
) && !node
->clone_of
)
704 error ("node is in clone list but it is not clone");
707 if (!node
->prev_sibling_clone
&& node
->clone_of
&& node
->clone_of
->clones
!= node
)
709 error ("node has wrong prev_clone pointer");
712 if (node
->prev_sibling_clone
&& node
->prev_sibling_clone
->next_sibling_clone
!= node
)
714 error ("double linked list of clones corrupted");
718 if (node
->analyzed
&& gimple_has_body_p (node
->decl
)
719 && !TREE_ASM_WRITTEN (node
->decl
)
720 && (!DECL_EXTERNAL (node
->decl
) || node
->global
.inlined_to
)
725 /* The nodes we're interested in are never shared, so walk
726 the tree ignoring duplicates. */
727 struct pointer_set_t
*visited_nodes
= pointer_set_create ();
728 /* Reach the trees by walking over the CFG, and note the
729 enclosing basic-blocks in the call edges. */
730 FOR_EACH_BB_FN (this_block
, this_cfun
)
731 for (gsi
= gsi_start_bb (this_block
);
735 gimple stmt
= gsi_stmt (gsi
);
737 if (is_gimple_call (stmt
) && (decl
= gimple_call_fndecl (stmt
)))
739 struct cgraph_edge
*e
= cgraph_edge (node
, stmt
);
744 error ("shared call_stmt:");
745 debug_gimple_stmt (stmt
);
748 if (e
->callee
->same_body_alias
)
750 error ("edge points to same body alias:");
751 debug_tree (e
->callee
->decl
);
754 else if (!clone_of_p (cgraph_node (decl
), e
->callee
)
755 && !e
->callee
->global
.inlined_to
)
757 error ("edge points to wrong declaration:");
758 debug_tree (e
->callee
->decl
);
759 fprintf (stderr
," Instead of:");
767 error ("missing callgraph edge for call stmt:");
768 debug_gimple_stmt (stmt
);
773 pointer_set_destroy (visited_nodes
);
776 /* No CFG available?! */
779 for (e
= node
->callees
; e
; e
= e
->next_callee
)
781 if (!e
->aux
&& !e
->indirect_call
)
783 error ("edge %s->%s has no corresponding call_stmt",
784 identifier_to_locale (cgraph_node_name (e
->caller
)),
785 identifier_to_locale (cgraph_node_name (e
->callee
)));
786 debug_gimple_stmt (e
->call_stmt
);
794 dump_cgraph_node (stderr
, node
);
795 internal_error ("verify_cgraph_node failed");
797 set_cfun (saved_cfun
);
798 timevar_pop (TV_CGRAPH_VERIFY
);
801 /* Verify whole cgraph structure. */
805 struct cgraph_node
*node
;
807 if (sorrycount
|| errorcount
)
810 for (node
= cgraph_nodes
; node
; node
= node
->next
)
811 verify_cgraph_node (node
);
814 /* Output all asm statements we have stored up to be output. */
817 cgraph_output_pending_asms (void)
819 struct cgraph_asm_node
*can
;
821 if (errorcount
|| sorrycount
)
824 for (can
= cgraph_asm_nodes
; can
; can
= can
->next
)
825 assemble_asm (can
->asm_str
);
826 cgraph_asm_nodes
= NULL
;
829 /* Analyze the function scheduled to be output. */
831 cgraph_analyze_function (struct cgraph_node
*node
)
833 tree save
= current_function_decl
;
834 tree decl
= node
->decl
;
836 current_function_decl
= decl
;
837 push_cfun (DECL_STRUCT_FUNCTION (decl
));
839 /* Make sure to gimplify bodies only once. During analyzing a
840 function we lower it, which will require gimplified nested
841 functions, so we can end up here with an already gimplified
843 if (!gimple_body (decl
))
844 gimplify_function_tree (decl
);
845 dump_function (TDI_generic
, decl
);
847 cgraph_lower_function (node
);
848 node
->analyzed
= true;
851 current_function_decl
= save
;
854 /* Look for externally_visible and used attributes and mark cgraph nodes
857 We cannot mark the nodes at the point the attributes are processed (in
858 handle_*_attribute) because the copy of the declarations available at that
859 point may not be canonical. For example, in:
862 void f() __attribute__((used));
864 the declaration we see in handle_used_attribute will be the second
865 declaration -- but the front end will subsequently merge that declaration
866 with the original declaration and discard the second declaration.
868 Furthermore, we can't mark these nodes in cgraph_finalize_function because:
871 void f() __attribute__((externally_visible));
875 So, we walk the nodes at the end of the translation unit, applying the
876 attributes at that point. */
879 process_function_and_variable_attributes (struct cgraph_node
*first
,
880 struct varpool_node
*first_var
)
882 struct cgraph_node
*node
;
883 struct varpool_node
*vnode
;
885 for (node
= cgraph_nodes
; node
!= first
; node
= node
->next
)
887 tree decl
= node
->decl
;
888 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl
)))
890 mark_decl_referenced (decl
);
891 if (node
->local
.finalized
)
892 cgraph_mark_needed_node (node
);
894 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
896 if (! TREE_PUBLIC (node
->decl
))
897 warning_at (DECL_SOURCE_LOCATION (node
->decl
), OPT_Wattributes
,
898 "%<externally_visible%>"
899 " attribute have effect only on public objects");
900 else if (node
->local
.finalized
)
901 cgraph_mark_needed_node (node
);
904 for (vnode
= varpool_nodes
; vnode
!= first_var
; vnode
= vnode
->next
)
906 tree decl
= vnode
->decl
;
907 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl
)))
909 mark_decl_referenced (decl
);
910 vnode
->force_output
= true;
911 if (vnode
->finalized
)
912 varpool_mark_needed_node (vnode
);
914 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
916 if (! TREE_PUBLIC (vnode
->decl
))
917 warning_at (DECL_SOURCE_LOCATION (vnode
->decl
), OPT_Wattributes
,
918 "%<externally_visible%>"
919 " attribute have effect only on public objects");
920 else if (vnode
->finalized
)
921 varpool_mark_needed_node (vnode
);
926 /* Process CGRAPH_NODES_NEEDED queue, analyze each function (and transitively
927 each reachable functions) and build cgraph.
928 The function can be called multiple times after inserting new nodes
929 into beginning of queue. Just the new part of queue is re-scanned then. */
932 cgraph_analyze_functions (void)
934 /* Keep track of already processed nodes when called multiple times for
935 intermodule optimization. */
936 static struct cgraph_node
*first_analyzed
;
937 struct cgraph_node
*first_processed
= first_analyzed
;
938 static struct varpool_node
*first_analyzed_var
;
939 struct cgraph_node
*node
, *next
;
941 process_function_and_variable_attributes (first_processed
,
943 first_processed
= cgraph_nodes
;
944 first_analyzed_var
= varpool_nodes
;
945 varpool_analyze_pending_decls ();
946 if (cgraph_dump_file
)
948 fprintf (cgraph_dump_file
, "Initial entry points:");
949 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
951 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
952 fprintf (cgraph_dump_file
, "\n");
954 cgraph_process_new_functions ();
956 /* Propagate reachability flag and lower representation of all reachable
957 functions. In the future, lowering will introduce new functions and
958 new entry points on the way (by template instantiation and virtual
959 method table generation for instance). */
960 while (cgraph_nodes_queue
)
962 struct cgraph_edge
*edge
;
963 tree decl
= cgraph_nodes_queue
->decl
;
965 node
= cgraph_nodes_queue
;
966 cgraph_nodes_queue
= cgraph_nodes_queue
->next_needed
;
967 node
->next_needed
= NULL
;
969 /* ??? It is possible to create extern inline function and later using
970 weak alias attribute to kill its body. See
971 gcc.c-torture/compile/20011119-1.c */
972 if (!DECL_STRUCT_FUNCTION (decl
))
974 cgraph_reset_node (node
);
979 cgraph_analyze_function (node
);
981 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
982 if (!edge
->callee
->reachable
)
983 cgraph_mark_reachable_node (edge
->callee
);
985 if (node
->same_comdat_group
)
987 for (next
= node
->same_comdat_group
;
989 next
= next
->same_comdat_group
)
990 cgraph_mark_reachable_node (next
);
993 /* If decl is a clone of an abstract function, mark that abstract
994 function so that we don't release its body. The DECL_INITIAL() of that
995 abstract function declaration will be later needed to output debug info. */
996 if (DECL_ABSTRACT_ORIGIN (decl
))
998 struct cgraph_node
*origin_node
= cgraph_node (DECL_ABSTRACT_ORIGIN (decl
));
999 origin_node
->abstract_and_needed
= true;
1002 /* We finalize local static variables during constructing callgraph
1003 edges. Process their attributes too. */
1004 process_function_and_variable_attributes (first_processed
,
1005 first_analyzed_var
);
1006 first_processed
= cgraph_nodes
;
1007 first_analyzed_var
= varpool_nodes
;
1008 varpool_analyze_pending_decls ();
1009 cgraph_process_new_functions ();
1012 /* Collect entry points to the unit. */
1013 if (cgraph_dump_file
)
1015 fprintf (cgraph_dump_file
, "Unit entry points:");
1016 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
1018 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1019 fprintf (cgraph_dump_file
, "\n\nInitial ");
1020 dump_cgraph (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
);
1051 first_analyzed
= cgraph_nodes
;
1056 /* Analyze the whole compilation unit once it is parsed completely. */
1059 cgraph_finalize_compilation_unit (void)
1061 timevar_push (TV_CGRAPH
);
1063 /* Do not skip analyzing the functions if there were errors, we
1064 miss diagnostics for following functions otherwise. */
1066 /* Emit size functions we didn't inline. */
1067 finalize_size_functions ();
1069 /* Call functions declared with the "constructor" or "destructor"
1071 cgraph_build_cdtor_fns ();
1073 /* Mark alias targets necessary and emit diagnostics. */
1074 finish_aliases_1 ();
1078 fprintf (stderr
, "\nAnalyzing compilation unit\n");
1082 /* Gimplify and lower all functions, compute reachability and
1083 remove unreachable nodes. */
1084 cgraph_analyze_functions ();
1086 /* Mark alias targets necessary and emit diagnostics. */
1087 finish_aliases_1 ();
1089 /* Gimplify and lower thunks. */
1090 cgraph_analyze_functions ();
1092 /* Finally drive the pass manager. */
1095 timevar_pop (TV_CGRAPH
);
1099 /* Figure out what functions we want to assemble. */
1102 cgraph_mark_functions_to_output (void)
1104 struct cgraph_node
*node
;
1105 #ifdef ENABLE_CHECKING
1106 bool check_same_comdat_groups
= false;
1108 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1109 gcc_assert (!node
->process
);
1112 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1114 tree decl
= node
->decl
;
1115 struct cgraph_edge
*e
;
1117 gcc_assert (!node
->process
|| node
->same_comdat_group
);
1121 for (e
= node
->callers
; e
; e
= e
->next_caller
)
1122 if (e
->inline_failed
)
1125 /* We need to output all local functions that are used and not
1126 always inlined, as well as those that are reachable from
1127 outside the current compilation unit. */
1129 && !node
->global
.inlined_to
1131 || (e
&& node
->reachable
))
1132 && !TREE_ASM_WRITTEN (decl
)
1133 && !DECL_EXTERNAL (decl
))
1136 if (node
->same_comdat_group
)
1138 struct cgraph_node
*next
;
1139 for (next
= node
->same_comdat_group
;
1141 next
= next
->same_comdat_group
)
1145 else if (node
->same_comdat_group
)
1147 #ifdef ENABLE_CHECKING
1148 check_same_comdat_groups
= true;
1153 /* We should've reclaimed all functions that are not needed. */
1154 #ifdef ENABLE_CHECKING
1155 if (!node
->global
.inlined_to
1156 && gimple_has_body_p (decl
)
1157 && !DECL_EXTERNAL (decl
))
1159 dump_cgraph_node (stderr
, node
);
1160 internal_error ("failed to reclaim unneeded function");
1163 gcc_assert (node
->global
.inlined_to
1164 || !gimple_has_body_p (decl
)
1165 || DECL_EXTERNAL (decl
));
1170 #ifdef ENABLE_CHECKING
1171 if (check_same_comdat_groups
)
1172 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1173 if (node
->same_comdat_group
&& !node
->process
)
1175 tree decl
= node
->decl
;
1176 if (!node
->global
.inlined_to
1177 && gimple_has_body_p (decl
)
1178 && !DECL_EXTERNAL (decl
))
1180 dump_cgraph_node (stderr
, node
);
1181 internal_error ("failed to reclaim unneeded function");
1187 /* DECL is FUNCTION_DECL. Initialize datastructures so DECL is a function
1188 in lowered gimple form.
1190 Set current_function_decl and cfun to newly constructed empty function body.
1191 return basic block in the function body. */
1194 init_lowered_empty_function (tree decl
)
1198 current_function_decl
= decl
;
1199 allocate_struct_function (decl
, false);
1200 gimple_register_cfg_hooks ();
1201 init_empty_tree_cfg ();
1202 init_tree_ssa (cfun
);
1203 init_ssa_operands ();
1204 cfun
->gimple_df
->in_ssa_p
= true;
1205 DECL_INITIAL (decl
) = make_node (BLOCK
);
1207 DECL_SAVED_TREE (decl
) = error_mark_node
;
1208 cfun
->curr_properties
|=
1209 (PROP_gimple_lcf
| PROP_gimple_leh
| PROP_cfg
| PROP_referenced_vars
|
1212 /* Create BB for body of the function and connect it properly. */
1213 bb
= create_basic_block (NULL
, (void *) 0, ENTRY_BLOCK_PTR
);
1214 make_edge (ENTRY_BLOCK_PTR
, bb
, 0);
1215 make_edge (bb
, EXIT_BLOCK_PTR
, 0);
1220 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
1221 offset indicated by VIRTUAL_OFFSET, if that is
1222 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
1223 zero for a result adjusting thunk. */
1226 thunk_adjust (gimple_stmt_iterator
* bsi
,
1227 tree ptr
, bool this_adjusting
,
1228 HOST_WIDE_INT fixed_offset
, tree virtual_offset
)
1235 stmt
= gimple_build_assign (ptr
,
1236 fold_build2_loc (input_location
,
1238 TREE_TYPE (ptr
), ptr
,
1239 size_int (fixed_offset
)));
1240 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1243 /* If there's a virtual offset, look up that value in the vtable and
1244 adjust the pointer again. */
1252 if (!vtable_entry_type
)
1254 tree vfunc_type
= make_node (FUNCTION_TYPE
);
1255 TREE_TYPE (vfunc_type
) = integer_type_node
;
1256 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
1257 layout_type (vfunc_type
);
1259 vtable_entry_type
= build_pointer_type (vfunc_type
);
1263 create_tmp_var (build_pointer_type
1264 (build_pointer_type (vtable_entry_type
)), "vptr");
1266 /* The vptr is always at offset zero in the object. */
1267 stmt
= gimple_build_assign (vtabletmp
,
1268 build1 (NOP_EXPR
, TREE_TYPE (vtabletmp
),
1270 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1271 mark_symbols_for_renaming (stmt
);
1272 find_referenced_vars_in (stmt
);
1274 /* Form the vtable address. */
1275 vtabletmp2
= create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp
)),
1277 stmt
= gimple_build_assign (vtabletmp2
,
1278 build1 (INDIRECT_REF
,
1279 TREE_TYPE (vtabletmp2
), vtabletmp
));
1280 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1281 mark_symbols_for_renaming (stmt
);
1282 find_referenced_vars_in (stmt
);
1284 /* Find the entry with the vcall offset. */
1285 stmt
= gimple_build_assign (vtabletmp2
,
1286 fold_build2_loc (input_location
,
1288 TREE_TYPE (vtabletmp2
),
1290 fold_convert (sizetype
,
1292 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1294 /* Get the offset itself. */
1295 vtabletmp3
= create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp2
)),
1297 stmt
= gimple_build_assign (vtabletmp3
,
1298 build1 (INDIRECT_REF
,
1299 TREE_TYPE (vtabletmp3
),
1301 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1302 mark_symbols_for_renaming (stmt
);
1303 find_referenced_vars_in (stmt
);
1305 /* Cast to sizetype. */
1306 offsettmp
= create_tmp_var (sizetype
, "offset");
1307 stmt
= gimple_build_assign (offsettmp
, fold_convert (sizetype
, vtabletmp3
));
1308 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1309 mark_symbols_for_renaming (stmt
);
1310 find_referenced_vars_in (stmt
);
1312 /* Adjust the `this' pointer. */
1313 ptr
= fold_build2_loc (input_location
,
1314 POINTER_PLUS_EXPR
, TREE_TYPE (ptr
), ptr
,
1318 if (!this_adjusting
)
1319 /* Adjust the pointer by the constant. */
1323 if (TREE_CODE (ptr
) == VAR_DECL
)
1327 ptrtmp
= create_tmp_var (TREE_TYPE (ptr
), "ptr");
1328 stmt
= gimple_build_assign (ptrtmp
, ptr
);
1329 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1330 mark_symbols_for_renaming (stmt
);
1331 find_referenced_vars_in (stmt
);
1333 ptr
= fold_build2_loc (input_location
,
1334 POINTER_PLUS_EXPR
, TREE_TYPE (ptrtmp
), ptrtmp
,
1335 size_int (fixed_offset
));
1338 /* Emit the statement and gimplify the adjustment expression. */
1339 ret
= create_tmp_var (TREE_TYPE (ptr
), "adjusted_this");
1340 stmt
= gimple_build_assign (ret
, ptr
);
1341 mark_symbols_for_renaming (stmt
);
1342 find_referenced_vars_in (stmt
);
1343 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1348 /* Produce assembler for thunk NODE. */
1351 assemble_thunk (struct cgraph_node
*node
)
1353 bool this_adjusting
= node
->thunk
.this_adjusting
;
1354 HOST_WIDE_INT fixed_offset
= node
->thunk
.fixed_offset
;
1355 HOST_WIDE_INT virtual_value
= node
->thunk
.virtual_value
;
1356 tree virtual_offset
= NULL
;
1357 tree alias
= node
->thunk
.alias
;
1358 tree thunk_fndecl
= node
->decl
;
1359 tree a
= DECL_ARGUMENTS (thunk_fndecl
);
1361 current_function_decl
= thunk_fndecl
;
1364 && targetm
.asm_out
.can_output_mi_thunk (thunk_fndecl
, fixed_offset
,
1365 virtual_value
, alias
))
1370 DECL_RESULT (thunk_fndecl
)
1371 = build_decl (DECL_SOURCE_LOCATION (thunk_fndecl
),
1372 RESULT_DECL
, 0, integer_type_node
);
1373 fnname
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk_fndecl
));
1375 /* The back end expects DECL_INITIAL to contain a BLOCK, so we
1377 fn_block
= make_node (BLOCK
);
1378 BLOCK_VARS (fn_block
) = a
;
1379 DECL_INITIAL (thunk_fndecl
) = fn_block
;
1380 init_function_start (thunk_fndecl
);
1382 assemble_start_function (thunk_fndecl
, fnname
);
1384 targetm
.asm_out
.output_mi_thunk (asm_out_file
, thunk_fndecl
,
1385 fixed_offset
, virtual_value
, alias
);
1387 assemble_end_function (thunk_fndecl
, fnname
);
1388 init_insn_lengths ();
1389 free_after_compilation (cfun
);
1391 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
1396 basic_block bb
, then_bb
, else_bb
, return_bb
;
1397 gimple_stmt_iterator bsi
;
1403 VEC(tree
, heap
) *vargs
;
1408 DECL_IGNORED_P (thunk_fndecl
) = 1;
1409 bitmap_obstack_initialize (NULL
);
1411 if (node
->thunk
.virtual_offset_p
)
1412 virtual_offset
= size_int (virtual_value
);
1414 /* Build the return declaration for the function. */
1415 restype
= TREE_TYPE (TREE_TYPE (thunk_fndecl
));
1416 if (DECL_RESULT (thunk_fndecl
) == NULL_TREE
)
1418 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
1419 DECL_ARTIFICIAL (resdecl
) = 1;
1420 DECL_IGNORED_P (resdecl
) = 1;
1421 DECL_RESULT (thunk_fndecl
) = resdecl
;
1424 resdecl
= DECL_RESULT (thunk_fndecl
);
1426 bb
= then_bb
= else_bb
= return_bb
= init_lowered_empty_function (thunk_fndecl
);
1428 bsi
= gsi_start_bb (bb
);
1430 /* Build call to the function being thunked. */
1431 if (!VOID_TYPE_P (restype
))
1433 if (!is_gimple_reg_type (restype
))
1436 cfun
->local_decls
= tree_cons (NULL_TREE
, restmp
, cfun
->local_decls
);
1437 BLOCK_VARS (DECL_INITIAL (current_function_decl
)) = restmp
;
1440 restmp
= create_tmp_var_raw (restype
, "retval");
1443 for (arg
= a
; arg
; arg
= TREE_CHAIN (arg
))
1445 vargs
= VEC_alloc (tree
, heap
, nargs
);
1447 VEC_quick_push (tree
, vargs
,
1452 VEC_quick_push (tree
, vargs
, a
);
1453 for (i
= 1, arg
= TREE_CHAIN (a
); i
< nargs
; i
++, arg
= TREE_CHAIN (arg
))
1454 VEC_quick_push (tree
, vargs
, arg
);
1455 call
= gimple_build_call_vec (build_fold_addr_expr_loc (0, alias
), vargs
);
1456 VEC_free (tree
, heap
, vargs
);
1457 gimple_call_set_cannot_inline (call
, true);
1458 gimple_call_set_from_thunk (call
, true);
1460 gimple_call_set_lhs (call
, restmp
);
1461 gsi_insert_after (&bsi
, call
, GSI_NEW_STMT
);
1462 mark_symbols_for_renaming (call
);
1463 find_referenced_vars_in (call
);
1466 if (restmp
&& !this_adjusting
)
1468 tree true_label
= NULL_TREE
, false_label
= NULL_TREE
;
1470 if (TREE_CODE (TREE_TYPE (restmp
)) == POINTER_TYPE
)
1473 /* If the return type is a pointer, we need to
1474 protect against NULL. We know there will be an
1475 adjustment, because that's why we're emitting a
1477 then_bb
= create_basic_block (NULL
, (void *) 0, bb
);
1478 return_bb
= create_basic_block (NULL
, (void *) 0, then_bb
);
1479 else_bb
= create_basic_block (NULL
, (void *) 0, else_bb
);
1480 remove_edge (single_succ_edge (bb
));
1481 true_label
= gimple_block_label (then_bb
);
1482 false_label
= gimple_block_label (else_bb
);
1483 stmt
= gimple_build_cond (NE_EXPR
, restmp
,
1484 fold_convert (TREE_TYPE (restmp
),
1486 NULL_TREE
, NULL_TREE
);
1487 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1488 make_edge (bb
, then_bb
, EDGE_TRUE_VALUE
);
1489 make_edge (bb
, else_bb
, EDGE_FALSE_VALUE
);
1490 make_edge (return_bb
, EXIT_BLOCK_PTR
, 0);
1491 make_edge (then_bb
, return_bb
, EDGE_FALLTHRU
);
1492 make_edge (else_bb
, return_bb
, EDGE_FALLTHRU
);
1493 bsi
= gsi_last_bb (then_bb
);
1496 restmp
= thunk_adjust (&bsi
, restmp
, /*this_adjusting=*/0,
1497 fixed_offset
, virtual_offset
);
1501 bsi
= gsi_last_bb (else_bb
);
1502 stmt
= gimple_build_assign (restmp
, fold_convert (TREE_TYPE (restmp
),
1503 integer_zero_node
));
1504 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1505 bsi
= gsi_last_bb (return_bb
);
1509 gimple_call_set_tail (call
, true);
1511 /* Build return value. */
1512 ret
= gimple_build_return (restmp
);
1513 gsi_insert_after (&bsi
, ret
, GSI_NEW_STMT
);
1515 delete_unreachable_blocks ();
1516 update_ssa (TODO_update_ssa
);
1518 cgraph_remove_same_body_alias (node
);
1519 /* Since we want to emit the thunk, we explicitly mark its name as
1521 mark_decl_referenced (thunk_fndecl
);
1522 cgraph_add_new_function (thunk_fndecl
, true);
1523 bitmap_obstack_release (NULL
);
1525 current_function_decl
= NULL
;
1528 /* Expand function specified by NODE. */
1531 cgraph_expand_function (struct cgraph_node
*node
)
1533 tree decl
= node
->decl
;
1535 /* We ought to not compile any inline clones. */
1536 gcc_assert (!node
->global
.inlined_to
);
1538 announce_function (decl
);
1541 gcc_assert (node
->lowered
);
1543 /* Generate RTL for the body of DECL. */
1544 tree_rest_of_compilation (decl
);
1546 /* Make sure that BE didn't give up on compiling. */
1547 gcc_assert (TREE_ASM_WRITTEN (decl
));
1548 current_function_decl
= NULL
;
1549 if (node
->same_body
)
1551 struct cgraph_node
*alias
, *next
;
1552 bool saved_alias
= node
->alias
;
1553 for (alias
= node
->same_body
;
1554 alias
&& alias
->next
; alias
= alias
->next
)
1556 /* Walk aliases in the order they were created; it is possible that
1557 thunks reffers to the aliases made earlier. */
1558 for (; alias
; alias
= next
)
1560 next
= alias
->previous
;
1561 if (!alias
->thunk
.thunk_p
)
1562 assemble_alias (alias
->decl
,
1563 DECL_ASSEMBLER_NAME (alias
->thunk
.alias
));
1565 assemble_thunk (alias
);
1567 node
->alias
= saved_alias
;
1569 gcc_assert (!cgraph_preserve_function_body_p (decl
));
1570 cgraph_release_function_body (node
);
1571 /* Eliminate all call edges. This is important so the GIMPLE_CALL no longer
1572 points to the dead function body. */
1573 cgraph_node_remove_callees (node
);
1575 cgraph_function_flags_ready
= true;
1578 /* Return true when CALLER_DECL should be inlined into CALLEE_DECL. */
1581 cgraph_inline_p (struct cgraph_edge
*e
, cgraph_inline_failed_t
*reason
)
1583 *reason
= e
->inline_failed
;
1584 return !e
->inline_failed
;
1589 /* Expand all functions that must be output.
1591 Attempt to topologically sort the nodes so function is output when
1592 all called functions are already assembled to allow data to be
1593 propagated across the callgraph. Use a stack to get smaller distance
1594 between a function and its callees (later we may choose to use a more
1595 sophisticated algorithm for function reordering; we will likely want
1596 to use subsections to make the output functions appear in top-down
1600 cgraph_expand_all_functions (void)
1602 struct cgraph_node
*node
;
1603 struct cgraph_node
**order
= XCNEWVEC (struct cgraph_node
*, cgraph_n_nodes
);
1604 int order_pos
, new_order_pos
= 0;
1607 order_pos
= cgraph_postorder (order
);
1608 gcc_assert (order_pos
== cgraph_n_nodes
);
1610 /* Garbage collector may remove inline clones we eliminate during
1611 optimization. So we must be sure to not reference them. */
1612 for (i
= 0; i
< order_pos
; i
++)
1613 if (order
[i
]->process
)
1614 order
[new_order_pos
++] = order
[i
];
1616 for (i
= new_order_pos
- 1; i
>= 0; i
--)
1621 gcc_assert (node
->reachable
);
1623 cgraph_expand_function (node
);
1626 cgraph_process_new_functions ();
1632 /* This is used to sort the node types by the cgraph order number. */
1634 enum cgraph_order_sort_kind
1636 ORDER_UNDEFINED
= 0,
1642 struct cgraph_order_sort
1644 enum cgraph_order_sort_kind kind
;
1647 struct cgraph_node
*f
;
1648 struct varpool_node
*v
;
1649 struct cgraph_asm_node
*a
;
1653 /* Output all functions, variables, and asm statements in the order
1654 according to their order fields, which is the order in which they
1655 appeared in the file. This implements -fno-toplevel-reorder. In
1656 this mode we may output functions and variables which don't really
1657 need to be output. */
1660 cgraph_output_in_order (void)
1664 struct cgraph_order_sort
*nodes
;
1666 struct cgraph_node
*pf
;
1667 struct varpool_node
*pv
;
1668 struct cgraph_asm_node
*pa
;
1671 size
= max
* sizeof (struct cgraph_order_sort
);
1672 nodes
= (struct cgraph_order_sort
*) alloca (size
);
1673 memset (nodes
, 0, size
);
1675 varpool_analyze_pending_decls ();
1677 for (pf
= cgraph_nodes
; pf
; pf
= pf
->next
)
1682 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1683 nodes
[i
].kind
= ORDER_FUNCTION
;
1688 for (pv
= varpool_nodes_queue
; pv
; pv
= pv
->next_needed
)
1691 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1692 nodes
[i
].kind
= ORDER_VAR
;
1696 for (pa
= cgraph_asm_nodes
; pa
; pa
= pa
->next
)
1699 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1700 nodes
[i
].kind
= ORDER_ASM
;
1704 /* In toplevel reorder mode we output all statics; mark them as needed. */
1705 for (i
= 0; i
< max
; ++i
)
1707 if (nodes
[i
].kind
== ORDER_VAR
)
1709 varpool_mark_needed_node (nodes
[i
].u
.v
);
1712 varpool_empty_needed_queue ();
1714 for (i
= 0; i
< max
; ++i
)
1716 switch (nodes
[i
].kind
)
1718 case ORDER_FUNCTION
:
1719 nodes
[i
].u
.f
->process
= 0;
1720 cgraph_expand_function (nodes
[i
].u
.f
);
1724 varpool_assemble_decl (nodes
[i
].u
.v
);
1728 assemble_asm (nodes
[i
].u
.a
->asm_str
);
1731 case ORDER_UNDEFINED
:
1739 cgraph_asm_nodes
= NULL
;
1742 /* Return true when function body of DECL still needs to be kept around
1743 for later re-use. */
1745 cgraph_preserve_function_body_p (tree decl
)
1747 struct cgraph_node
*node
;
1749 gcc_assert (cgraph_global_info_ready
);
1750 /* Look if there is any clone around. */
1751 node
= cgraph_node (decl
);
1761 current_function_decl
= NULL
;
1762 gimple_register_cfg_hooks ();
1763 bitmap_obstack_initialize (NULL
);
1765 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_START
, NULL
);
1768 execute_ipa_pass_list (all_small_ipa_passes
);
1770 /* If pass_all_early_optimizations was not scheduled, the state of
1771 the cgraph will not be properly updated. Update it now. */
1772 if (cgraph_state
< CGRAPH_STATE_IPA_SSA
)
1773 cgraph_state
= CGRAPH_STATE_IPA_SSA
;
1777 /* Generate coverage variables and constructors. */
1780 /* Process new functions added. */
1782 current_function_decl
= NULL
;
1783 cgraph_process_new_functions ();
1785 execute_ipa_summary_passes
1786 ((struct ipa_opt_pass_d
*) all_regular_ipa_passes
);
1788 execute_ipa_summary_passes ((struct ipa_opt_pass_d
*) all_lto_gen_passes
);
1791 ipa_write_summaries ();
1794 execute_ipa_pass_list (all_regular_ipa_passes
);
1795 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_END
, NULL
);
1797 bitmap_obstack_release (NULL
);
1801 /* Perform simple optimizations based on callgraph. */
1804 cgraph_optimize (void)
1806 if (errorcount
|| sorrycount
)
1809 #ifdef ENABLE_CHECKING
1813 /* Frontend may output common variables after the unit has been finalized.
1814 It is safe to deal with them here as they are always zero initialized. */
1815 varpool_analyze_pending_decls ();
1817 timevar_push (TV_CGRAPHOPT
);
1818 if (pre_ipa_mem_report
)
1820 fprintf (stderr
, "Memory consumption before IPA\n");
1821 dump_memory_report (false);
1824 fprintf (stderr
, "Performing interprocedural optimizations\n");
1825 cgraph_state
= CGRAPH_STATE_IPA
;
1827 /* Don't run the IPA passes if there was any error or sorry messages. */
1828 if (errorcount
== 0 && sorrycount
== 0)
1831 /* Do nothing else if any IPA pass found errors. */
1832 if (errorcount
|| sorrycount
)
1834 timevar_pop (TV_CGRAPHOPT
);
1838 /* This pass remove bodies of extern inline functions we never inlined.
1839 Do this later so other IPA passes see what is really going on. */
1840 cgraph_remove_unreachable_nodes (false, dump_file
);
1841 cgraph_global_info_ready
= true;
1842 if (cgraph_dump_file
)
1844 fprintf (cgraph_dump_file
, "Optimized ");
1845 dump_cgraph (cgraph_dump_file
);
1846 dump_varpool (cgraph_dump_file
);
1848 if (post_ipa_mem_report
)
1850 fprintf (stderr
, "Memory consumption after IPA\n");
1851 dump_memory_report (false);
1853 timevar_pop (TV_CGRAPHOPT
);
1855 /* Output everything. */
1856 (*debug_hooks
->assembly_start
) ();
1858 fprintf (stderr
, "Assembling functions:\n");
1859 #ifdef ENABLE_CHECKING
1863 cgraph_materialize_all_clones ();
1864 cgraph_mark_functions_to_output ();
1866 cgraph_state
= CGRAPH_STATE_EXPANSION
;
1867 if (!flag_toplevel_reorder
)
1868 cgraph_output_in_order ();
1871 cgraph_output_pending_asms ();
1873 cgraph_expand_all_functions ();
1874 varpool_remove_unreferenced_decls ();
1876 varpool_assemble_pending_decls ();
1878 cgraph_process_new_functions ();
1879 cgraph_state
= CGRAPH_STATE_FINISHED
;
1881 if (cgraph_dump_file
)
1883 fprintf (cgraph_dump_file
, "\nFinal ");
1884 dump_cgraph (cgraph_dump_file
);
1886 #ifdef ENABLE_CHECKING
1888 /* Double check that all inline clones are gone and that all
1889 function bodies have been released from memory. */
1890 if (!(sorrycount
|| errorcount
))
1892 struct cgraph_node
*node
;
1893 bool error_found
= false;
1895 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1897 && (node
->global
.inlined_to
1898 || gimple_has_body_p (node
->decl
)))
1901 dump_cgraph_node (stderr
, node
);
1904 internal_error ("nodes with unreleased memory found");
1910 /* Generate and emit a static constructor or destructor. WHICH must
1911 be one of 'I' (for a constructor) or 'D' (for a destructor). BODY
1912 is a STATEMENT_LIST containing GENERIC statements. PRIORITY is the
1913 initialization priority for this constructor or destructor. */
1916 cgraph_build_static_cdtor (char which
, tree body
, int priority
)
1918 static int counter
= 0;
1920 tree decl
, name
, resdecl
;
1922 /* The priority is encoded in the constructor or destructor name.
1923 collect2 will sort the names and arrange that they are called at
1925 sprintf (which_buf
, "%c_%.5d_%d", which
, priority
, counter
++);
1926 name
= get_file_function_name (which_buf
);
1928 decl
= build_decl (input_location
, FUNCTION_DECL
, name
,
1929 build_function_type (void_type_node
, void_list_node
));
1930 current_function_decl
= decl
;
1932 resdecl
= build_decl (input_location
,
1933 RESULT_DECL
, NULL_TREE
, void_type_node
);
1934 DECL_ARTIFICIAL (resdecl
) = 1;
1935 DECL_RESULT (decl
) = resdecl
;
1936 DECL_CONTEXT (resdecl
) = decl
;
1938 allocate_struct_function (decl
, false);
1940 TREE_STATIC (decl
) = 1;
1941 TREE_USED (decl
) = 1;
1942 DECL_ARTIFICIAL (decl
) = 1;
1943 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
1944 DECL_SAVED_TREE (decl
) = body
;
1945 TREE_PUBLIC (decl
) = ! targetm
.have_ctors_dtors
;
1946 DECL_UNINLINABLE (decl
) = 1;
1948 DECL_INITIAL (decl
) = make_node (BLOCK
);
1949 TREE_USED (DECL_INITIAL (decl
)) = 1;
1951 DECL_SOURCE_LOCATION (decl
) = input_location
;
1952 cfun
->function_end_locus
= input_location
;
1957 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
1958 decl_init_priority_insert (decl
, priority
);
1961 DECL_STATIC_DESTRUCTOR (decl
) = 1;
1962 decl_fini_priority_insert (decl
, priority
);
1968 gimplify_function_tree (decl
);
1970 cgraph_add_new_function (decl
, false);
1971 cgraph_mark_needed_node (cgraph_node (decl
));
1978 cgraph_dump_file
= dump_begin (TDI_cgraph
, NULL
);
1981 /* The edges representing the callers of the NEW_VERSION node were
1982 fixed by cgraph_function_versioning (), now the call_expr in their
1983 respective tree code should be updated to call the NEW_VERSION. */
1986 update_call_expr (struct cgraph_node
*new_version
)
1988 struct cgraph_edge
*e
;
1990 gcc_assert (new_version
);
1992 /* Update the call expr on the edges to call the new version. */
1993 for (e
= new_version
->callers
; e
; e
= e
->next_caller
)
1995 struct function
*inner_function
= DECL_STRUCT_FUNCTION (e
->caller
->decl
);
1996 gimple_call_set_fndecl (e
->call_stmt
, new_version
->decl
);
1997 maybe_clean_eh_stmt_fn (inner_function
, e
->call_stmt
);
2002 /* Create a new cgraph node which is the new version of
2003 OLD_VERSION node. REDIRECT_CALLERS holds the callers
2004 edges which should be redirected to point to
2005 NEW_VERSION. ALL the callees edges of OLD_VERSION
2006 are cloned to the new version node. Return the new
2009 static struct cgraph_node
*
2010 cgraph_copy_node_for_versioning (struct cgraph_node
*old_version
,
2012 VEC(cgraph_edge_p
,heap
) *redirect_callers
)
2014 struct cgraph_node
*new_version
;
2015 struct cgraph_edge
*e
, *new_e
;
2016 struct cgraph_edge
*next_callee
;
2019 gcc_assert (old_version
);
2021 new_version
= cgraph_node (new_decl
);
2023 new_version
->analyzed
= true;
2024 new_version
->local
= old_version
->local
;
2025 new_version
->global
= old_version
->global
;
2026 new_version
->rtl
= new_version
->rtl
;
2027 new_version
->reachable
= true;
2028 new_version
->count
= old_version
->count
;
2030 /* Clone the old node callees. Recursive calls are
2032 for (e
= old_version
->callees
;e
; e
=e
->next_callee
)
2034 new_e
= cgraph_clone_edge (e
, new_version
, e
->call_stmt
,
2035 e
->lto_stmt_uid
, 0, e
->frequency
,
2036 e
->loop_nest
, true);
2037 new_e
->count
= e
->count
;
2039 /* Fix recursive calls.
2040 If OLD_VERSION has a recursive call after the
2041 previous edge cloning, the new version will have an edge
2042 pointing to the old version, which is wrong;
2043 Redirect it to point to the new version. */
2044 for (e
= new_version
->callees
; e
; e
= next_callee
)
2046 next_callee
= e
->next_callee
;
2047 if (e
->callee
== old_version
)
2048 cgraph_redirect_edge_callee (e
, new_version
);
2053 for (i
= 0; VEC_iterate (cgraph_edge_p
, redirect_callers
, i
, e
); i
++)
2055 /* Redirect calls to the old version node to point to its new
2057 cgraph_redirect_edge_callee (e
, new_version
);
2063 /* Perform function versioning.
2064 Function versioning includes copying of the tree and
2065 a callgraph update (creating a new cgraph node and updating
2066 its callees and callers).
2068 REDIRECT_CALLERS varray includes the edges to be redirected
2071 TREE_MAP is a mapping of tree nodes we want to replace with
2072 new ones (according to results of prior analysis).
2073 OLD_VERSION_NODE is the node that is versioned.
2074 It returns the new version's cgraph node.
2075 ARGS_TO_SKIP lists arguments to be omitted from functions
2078 struct cgraph_node
*
2079 cgraph_function_versioning (struct cgraph_node
*old_version_node
,
2080 VEC(cgraph_edge_p
,heap
) *redirect_callers
,
2081 VEC (ipa_replace_map_p
,gc
)* tree_map
,
2082 bitmap args_to_skip
)
2084 tree old_decl
= old_version_node
->decl
;
2085 struct cgraph_node
*new_version_node
= NULL
;
2088 if (!tree_versionable_function_p (old_decl
))
2091 /* Make a new FUNCTION_DECL tree node for the
2094 new_decl
= copy_node (old_decl
);
2096 new_decl
= build_function_decl_skip_args (old_decl
, args_to_skip
);
2098 /* Create the new version's call-graph node.
2099 and update the edges of the new node. */
2101 cgraph_copy_node_for_versioning (old_version_node
, new_decl
,
2104 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2105 tree_function_versioning (old_decl
, new_decl
, tree_map
, false, args_to_skip
);
2107 /* Update the new version's properties.
2108 Make The new version visible only within this translation unit. Make sure
2109 that is not weak also.
2110 ??? We cannot use COMDAT linkage because there is no
2111 ABI support for this. */
2112 DECL_EXTERNAL (new_version_node
->decl
) = 0;
2113 DECL_COMDAT_GROUP (new_version_node
->decl
) = NULL_TREE
;
2114 TREE_PUBLIC (new_version_node
->decl
) = 0;
2115 DECL_COMDAT (new_version_node
->decl
) = 0;
2116 DECL_WEAK (new_version_node
->decl
) = 0;
2117 DECL_VIRTUAL_P (new_version_node
->decl
) = 0;
2118 new_version_node
->local
.externally_visible
= 0;
2119 new_version_node
->local
.local
= 1;
2120 new_version_node
->lowered
= true;
2122 /* Update the call_expr on the edges to call the new version node. */
2123 update_call_expr (new_version_node
);
2125 cgraph_call_function_insertion_hooks (new_version_node
);
2126 return new_version_node
;
2129 /* Produce separate function body for inline clones so the offline copy can be
2130 modified without affecting them. */
2131 struct cgraph_node
*
2132 save_inline_function_body (struct cgraph_node
*node
)
2134 struct cgraph_node
*first_clone
, *n
;
2136 gcc_assert (node
== cgraph_node (node
->decl
));
2138 cgraph_lower_function (node
);
2140 first_clone
= node
->clones
;
2142 first_clone
->decl
= copy_node (node
->decl
);
2143 cgraph_insert_node_to_hashtable (first_clone
);
2144 gcc_assert (first_clone
== cgraph_node (first_clone
->decl
));
2145 if (first_clone
->next_sibling_clone
)
2147 for (n
= first_clone
->next_sibling_clone
; n
->next_sibling_clone
; n
= n
->next_sibling_clone
)
2148 n
->clone_of
= first_clone
;
2149 n
->clone_of
= first_clone
;
2150 n
->next_sibling_clone
= first_clone
->clones
;
2151 if (first_clone
->clones
)
2152 first_clone
->clones
->prev_sibling_clone
= n
;
2153 first_clone
->clones
= first_clone
->next_sibling_clone
;
2154 first_clone
->next_sibling_clone
->prev_sibling_clone
= NULL
;
2155 first_clone
->next_sibling_clone
= NULL
;
2156 gcc_assert (!first_clone
->prev_sibling_clone
);
2158 first_clone
->clone_of
= NULL
;
2159 node
->clones
= NULL
;
2161 if (first_clone
->clones
)
2162 for (n
= first_clone
->clones
; n
!= first_clone
;)
2164 gcc_assert (n
->decl
== node
->decl
);
2165 n
->decl
= first_clone
->decl
;
2168 else if (n
->next_sibling_clone
)
2169 n
= n
->next_sibling_clone
;
2172 while (n
!= first_clone
&& !n
->next_sibling_clone
)
2174 if (n
!= first_clone
)
2175 n
= n
->next_sibling_clone
;
2179 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2180 tree_function_versioning (node
->decl
, first_clone
->decl
, NULL
, true, NULL
);
2182 DECL_EXTERNAL (first_clone
->decl
) = 0;
2183 DECL_COMDAT_GROUP (first_clone
->decl
) = NULL_TREE
;
2184 TREE_PUBLIC (first_clone
->decl
) = 0;
2185 DECL_COMDAT (first_clone
->decl
) = 0;
2186 VEC_free (ipa_opt_pass
, heap
,
2187 first_clone
->ipa_transforms_to_apply
);
2188 first_clone
->ipa_transforms_to_apply
= NULL
;
2190 #ifdef ENABLE_CHECKING
2191 verify_cgraph_node (first_clone
);
2196 /* Given virtual clone, turn it into actual clone. */
2198 cgraph_materialize_clone (struct cgraph_node
*node
)
2200 bitmap_obstack_initialize (NULL
);
2201 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2202 tree_function_versioning (node
->clone_of
->decl
, node
->decl
,
2203 node
->clone
.tree_map
, true,
2204 node
->clone
.args_to_skip
);
2205 if (cgraph_dump_file
)
2207 dump_function_to_file (node
->clone_of
->decl
, cgraph_dump_file
, dump_flags
);
2208 dump_function_to_file (node
->decl
, cgraph_dump_file
, dump_flags
);
2211 /* Function is no longer clone. */
2212 if (node
->next_sibling_clone
)
2213 node
->next_sibling_clone
->prev_sibling_clone
= node
->prev_sibling_clone
;
2214 if (node
->prev_sibling_clone
)
2215 node
->prev_sibling_clone
->next_sibling_clone
= node
->next_sibling_clone
;
2217 node
->clone_of
->clones
= node
->next_sibling_clone
;
2218 node
->next_sibling_clone
= NULL
;
2219 node
->prev_sibling_clone
= NULL
;
2220 if (!node
->clone_of
->analyzed
&& !node
->clone_of
->clones
)
2221 cgraph_remove_node (node
->clone_of
);
2222 node
->clone_of
= NULL
;
2223 bitmap_obstack_release (NULL
);
2226 /* Once all functions from compilation unit are in memory, produce all clones
2227 and update all calls.
2228 We might also do this on demand if we don't want to bring all functions to
2229 memory prior compilation, but current WHOPR implementation does that and it is
2230 is bit easier to keep everything right in this order. */
2232 cgraph_materialize_all_clones (void)
2234 struct cgraph_node
*node
;
2235 bool stabilized
= false;
2237 if (cgraph_dump_file
)
2238 fprintf (cgraph_dump_file
, "Materializing clones\n");
2239 #ifdef ENABLE_CHECKING
2243 /* We can also do topological order, but number of iterations should be
2244 bounded by number of IPA passes since single IPA pass is probably not
2245 going to create clones of clones it created itself. */
2249 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2251 if (node
->clone_of
&& node
->decl
!= node
->clone_of
->decl
2252 && !gimple_has_body_p (node
->decl
))
2254 if (gimple_has_body_p (node
->clone_of
->decl
))
2256 if (cgraph_dump_file
)
2258 fprintf (cgraph_dump_file
, "clonning %s to %s\n",
2259 cgraph_node_name (node
->clone_of
),
2260 cgraph_node_name (node
));
2261 if (node
->clone
.tree_map
)
2264 fprintf (cgraph_dump_file
, " replace map: ");
2265 for (i
= 0; i
< VEC_length (ipa_replace_map_p
,
2266 node
->clone
.tree_map
);
2269 struct ipa_replace_map
*replace_info
;
2270 replace_info
= VEC_index (ipa_replace_map_p
,
2271 node
->clone
.tree_map
,
2273 print_generic_expr (cgraph_dump_file
, replace_info
->old_tree
, 0);
2274 fprintf (cgraph_dump_file
, " -> ");
2275 print_generic_expr (cgraph_dump_file
, replace_info
->new_tree
, 0);
2276 fprintf (cgraph_dump_file
, "%s%s;",
2277 replace_info
->replace_p
? "(replace)":"",
2278 replace_info
->ref_p
? "(ref)":"");
2280 fprintf (cgraph_dump_file
, "\n");
2282 if (node
->clone
.args_to_skip
)
2284 fprintf (cgraph_dump_file
, " args_to_skip: ");
2285 dump_bitmap (cgraph_dump_file
, node
->clone
.args_to_skip
);
2287 if (node
->clone
.args_to_skip
)
2289 fprintf (cgraph_dump_file
, " combined_args_to_skip:");
2290 dump_bitmap (cgraph_dump_file
, node
->clone
.combined_args_to_skip
);
2293 cgraph_materialize_clone (node
);
2300 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2301 if (!node
->analyzed
&& node
->callees
)
2302 cgraph_node_remove_callees (node
);
2303 if (cgraph_dump_file
)
2304 fprintf (cgraph_dump_file
, "Updating call sites\n");
2305 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2306 if (node
->analyzed
&& gimple_has_body_p (node
->decl
)
2307 && (!node
->clone_of
|| node
->clone_of
->decl
!= node
->decl
))
2309 struct cgraph_edge
*e
;
2311 current_function_decl
= node
->decl
;
2312 push_cfun (DECL_STRUCT_FUNCTION (node
->decl
));
2313 for (e
= node
->callees
; e
; e
= e
->next_callee
)
2315 tree decl
= gimple_call_fndecl (e
->call_stmt
);
2316 /* When function gets inlined, indirect inlining might've invented
2317 new edge for orginally indirect stmt. Since we are not
2318 preserving clones in the original form, we must not update here
2319 since other inline clones don't need to contain call to the same
2320 call. Inliner will do the substitution for us later. */
2321 if (decl
&& decl
!= e
->callee
->decl
)
2324 gimple_stmt_iterator gsi
;
2326 if (cgraph_get_node (decl
) == cgraph_get_node (e
->callee
->decl
))
2327 /* Don't update call from same body alias to the real function. */
2330 if (cgraph_dump_file
)
2332 fprintf (cgraph_dump_file
, "updating call of %s in %s:",
2333 cgraph_node_name (node
),
2334 cgraph_node_name (e
->callee
));
2335 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
2338 if (e
->callee
->clone
.combined_args_to_skip
)
2339 new_stmt
= gimple_call_copy_skip_args (e
->call_stmt
,
2340 e
->callee
->clone
.combined_args_to_skip
);
2342 new_stmt
= e
->call_stmt
;
2343 if (gimple_vdef (new_stmt
)
2344 && TREE_CODE (gimple_vdef (new_stmt
)) == SSA_NAME
)
2345 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt
)) = new_stmt
;
2346 gimple_call_set_fndecl (new_stmt
, e
->callee
->decl
);
2348 gsi
= gsi_for_stmt (e
->call_stmt
);
2349 gsi_replace (&gsi
, new_stmt
, true);
2351 /* Update EH information too, just in case. */
2352 maybe_clean_or_replace_eh_stmt (e
->call_stmt
, new_stmt
);
2354 cgraph_set_call_stmt_including_clones (node
, e
->call_stmt
, new_stmt
);
2356 if (cgraph_dump_file
)
2358 fprintf (cgraph_dump_file
, " updated to:");
2359 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
2364 current_function_decl
= NULL
;
2365 #ifdef ENABLE_CHECKING
2366 verify_cgraph_node (node
);
2369 #ifdef ENABLE_CHECKING
2372 cgraph_remove_unreachable_nodes (false, cgraph_dump_file
);
2375 #include "gt-cgraphunit.h"