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 /* Parameters in IFUNC function should never be used. */
537 if (DECL_IS_IFUNC (decl
))
541 for (parm
= DECL_ARGUMENTS (decl
);
542 parm
; parm
= TREE_CHAIN (parm
))
545 && TREE_CODE (parm
) == PARM_DECL
547 error ("parameter %q+D used in indirect function %q+F",
552 /* Possibly warn about unused parameters. */
553 else if (warn_unused_parameter
)
554 do_warn_unused_parameter (decl
);
560 /* C99 extern inline keywords allow changing of declaration after function
561 has been finalized. We need to re-decide if we want to mark the function as
565 cgraph_mark_if_needed (tree decl
)
567 struct cgraph_node
*node
= cgraph_node (decl
);
568 if (node
->local
.finalized
&& cgraph_decide_is_function_needed (node
, decl
))
569 cgraph_mark_needed_node (node
);
572 /* Return TRUE if NODE2 is equivalent to NODE or its clone. */
574 clone_of_p (struct cgraph_node
*node
, struct cgraph_node
*node2
)
576 while (node
!= node2
&& node2
)
577 node2
= node2
->clone_of
;
578 return node2
!= NULL
;
581 /* Verify cgraph nodes of given cgraph node. */
583 verify_cgraph_node (struct cgraph_node
*node
)
585 struct cgraph_edge
*e
;
586 struct function
*this_cfun
= DECL_STRUCT_FUNCTION (node
->decl
);
587 struct function
*saved_cfun
= cfun
;
588 basic_block this_block
;
589 gimple_stmt_iterator gsi
;
590 bool error_found
= false;
592 if (errorcount
|| sorrycount
)
595 timevar_push (TV_CGRAPH_VERIFY
);
596 /* debug_generic_stmt needs correct cfun */
597 set_cfun (this_cfun
);
598 for (e
= node
->callees
; e
; e
= e
->next_callee
)
601 error ("aux field set for edge %s->%s",
602 identifier_to_locale (cgraph_node_name (e
->caller
)),
603 identifier_to_locale (cgraph_node_name (e
->callee
)));
608 error ("Execution count is negative");
611 if (node
->global
.inlined_to
&& node
->local
.externally_visible
)
613 error ("Externally visible inline clone");
616 if (node
->global
.inlined_to
&& node
->address_taken
)
618 error ("Inline clone with address taken");
621 if (node
->global
.inlined_to
&& node
->needed
)
623 error ("Inline clone is needed");
626 for (e
= node
->callers
; e
; e
= e
->next_caller
)
630 error ("caller edge count is negative");
633 if (e
->frequency
< 0)
635 error ("caller edge frequency is negative");
638 if (e
->frequency
> CGRAPH_FREQ_MAX
)
640 error ("caller edge frequency is too large");
643 if (gimple_has_body_p (e
->caller
->decl
)
644 && !e
->caller
->global
.inlined_to
646 != compute_call_stmt_bb_frequency (e
->caller
->decl
,
647 gimple_bb (e
->call_stmt
))))
649 error ("caller edge frequency %i does not match BB freqency %i",
651 compute_call_stmt_bb_frequency (e
->caller
->decl
,
652 gimple_bb (e
->call_stmt
)));
655 if (!e
->inline_failed
)
657 if (node
->global
.inlined_to
658 != (e
->caller
->global
.inlined_to
659 ? e
->caller
->global
.inlined_to
: e
->caller
))
661 error ("inlined_to pointer is wrong");
664 if (node
->callers
->next_caller
)
666 error ("multiple inline callers");
671 if (node
->global
.inlined_to
)
673 error ("inlined_to pointer set for noninline callers");
677 if (!node
->callers
&& node
->global
.inlined_to
)
679 error ("inlined_to pointer is set but no predecessors found");
682 if (node
->global
.inlined_to
== node
)
684 error ("inlined_to pointer refers to itself");
688 if (!cgraph_node (node
->decl
))
690 error ("node not found in cgraph_hash");
696 struct cgraph_node
*n
;
697 for (n
= node
->clone_of
->clones
; n
; n
= n
->next_sibling_clone
)
702 error ("node has wrong clone_of");
708 struct cgraph_node
*n
;
709 for (n
= node
->clones
; n
; n
= n
->next_sibling_clone
)
710 if (n
->clone_of
!= node
)
714 error ("node has wrong clone list");
718 if ((node
->prev_sibling_clone
|| node
->next_sibling_clone
) && !node
->clone_of
)
720 error ("node is in clone list but it is not clone");
723 if (!node
->prev_sibling_clone
&& node
->clone_of
&& node
->clone_of
->clones
!= node
)
725 error ("node has wrong prev_clone pointer");
728 if (node
->prev_sibling_clone
&& node
->prev_sibling_clone
->next_sibling_clone
!= node
)
730 error ("double linked list of clones corrupted");
734 if (node
->analyzed
&& gimple_has_body_p (node
->decl
)
735 && !TREE_ASM_WRITTEN (node
->decl
)
736 && (!DECL_EXTERNAL (node
->decl
) || node
->global
.inlined_to
)
741 /* The nodes we're interested in are never shared, so walk
742 the tree ignoring duplicates. */
743 struct pointer_set_t
*visited_nodes
= pointer_set_create ();
744 /* Reach the trees by walking over the CFG, and note the
745 enclosing basic-blocks in the call edges. */
746 FOR_EACH_BB_FN (this_block
, this_cfun
)
747 for (gsi
= gsi_start_bb (this_block
);
751 gimple stmt
= gsi_stmt (gsi
);
753 if (is_gimple_call (stmt
) && (decl
= gimple_call_fndecl (stmt
)))
755 struct cgraph_edge
*e
= cgraph_edge (node
, stmt
);
760 error ("shared call_stmt:");
761 debug_gimple_stmt (stmt
);
764 if (e
->callee
->same_body_alias
)
766 error ("edge points to same body alias:");
767 debug_tree (e
->callee
->decl
);
770 else if (!node
->global
.inlined_to
771 && !e
->callee
->global
.inlined_to
772 && !clone_of_p (cgraph_node (decl
), e
->callee
))
774 error ("edge points to wrong declaration:");
775 debug_tree (e
->callee
->decl
);
776 fprintf (stderr
," Instead of:");
784 error ("missing callgraph edge for call stmt:");
785 debug_gimple_stmt (stmt
);
790 pointer_set_destroy (visited_nodes
);
793 /* No CFG available?! */
796 for (e
= node
->callees
; e
; e
= e
->next_callee
)
798 if (!e
->aux
&& !e
->indirect_call
)
800 error ("edge %s->%s has no corresponding call_stmt",
801 identifier_to_locale (cgraph_node_name (e
->caller
)),
802 identifier_to_locale (cgraph_node_name (e
->callee
)));
803 debug_gimple_stmt (e
->call_stmt
);
811 dump_cgraph_node (stderr
, node
);
812 internal_error ("verify_cgraph_node failed");
814 set_cfun (saved_cfun
);
815 timevar_pop (TV_CGRAPH_VERIFY
);
818 /* Verify whole cgraph structure. */
822 struct cgraph_node
*node
;
824 if (sorrycount
|| errorcount
)
827 for (node
= cgraph_nodes
; node
; node
= node
->next
)
828 verify_cgraph_node (node
);
831 /* Output all asm statements we have stored up to be output. */
834 cgraph_output_pending_asms (void)
836 struct cgraph_asm_node
*can
;
838 if (errorcount
|| sorrycount
)
841 for (can
= cgraph_asm_nodes
; can
; can
= can
->next
)
842 assemble_asm (can
->asm_str
);
843 cgraph_asm_nodes
= NULL
;
846 /* Analyze the function scheduled to be output. */
848 cgraph_analyze_function (struct cgraph_node
*node
)
850 tree save
= current_function_decl
;
851 tree decl
= node
->decl
;
853 current_function_decl
= decl
;
854 push_cfun (DECL_STRUCT_FUNCTION (decl
));
856 assign_assembler_name_if_neeeded (node
->decl
);
858 /* Make sure to gimplify bodies only once. During analyzing a
859 function we lower it, which will require gimplified nested
860 functions, so we can end up here with an already gimplified
862 if (!gimple_body (decl
))
863 gimplify_function_tree (decl
);
864 dump_function (TDI_generic
, decl
);
866 cgraph_lower_function (node
);
867 node
->analyzed
= true;
870 current_function_decl
= save
;
873 /* Look for externally_visible and used attributes and mark cgraph nodes
876 We cannot mark the nodes at the point the attributes are processed (in
877 handle_*_attribute) because the copy of the declarations available at that
878 point may not be canonical. For example, in:
881 void f() __attribute__((used));
883 the declaration we see in handle_used_attribute will be the second
884 declaration -- but the front end will subsequently merge that declaration
885 with the original declaration and discard the second declaration.
887 Furthermore, we can't mark these nodes in cgraph_finalize_function because:
890 void f() __attribute__((externally_visible));
894 So, we walk the nodes at the end of the translation unit, applying the
895 attributes at that point. */
898 process_function_and_variable_attributes (struct cgraph_node
*first
,
899 struct varpool_node
*first_var
)
901 struct cgraph_node
*node
;
902 struct varpool_node
*vnode
;
904 for (node
= cgraph_nodes
; node
!= first
; node
= node
->next
)
906 tree decl
= node
->decl
;
907 if (DECL_PRESERVE_P (decl
))
909 mark_decl_referenced (decl
);
910 if (node
->local
.finalized
)
911 cgraph_mark_needed_node (node
);
913 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
915 if (! TREE_PUBLIC (node
->decl
))
916 warning_at (DECL_SOURCE_LOCATION (node
->decl
), OPT_Wattributes
,
917 "%<externally_visible%>"
918 " attribute have effect only on public objects");
919 else if (node
->local
.finalized
)
920 cgraph_mark_needed_node (node
);
923 for (vnode
= varpool_nodes
; vnode
!= first_var
; vnode
= vnode
->next
)
925 tree decl
= vnode
->decl
;
926 if (DECL_PRESERVE_P (decl
))
928 mark_decl_referenced (decl
);
929 vnode
->force_output
= true;
930 if (vnode
->finalized
)
931 varpool_mark_needed_node (vnode
);
933 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
935 if (! TREE_PUBLIC (vnode
->decl
))
936 warning_at (DECL_SOURCE_LOCATION (vnode
->decl
), OPT_Wattributes
,
937 "%<externally_visible%>"
938 " attribute have effect only on public objects");
939 else if (vnode
->finalized
)
940 varpool_mark_needed_node (vnode
);
945 /* Process CGRAPH_NODES_NEEDED queue, analyze each function (and transitively
946 each reachable functions) and build cgraph.
947 The function can be called multiple times after inserting new nodes
948 into beginning of queue. Just the new part of queue is re-scanned then. */
951 cgraph_analyze_functions (void)
953 /* Keep track of already processed nodes when called multiple times for
954 intermodule optimization. */
955 static struct cgraph_node
*first_analyzed
;
956 struct cgraph_node
*first_processed
= first_analyzed
;
957 static struct varpool_node
*first_analyzed_var
;
958 struct cgraph_node
*node
, *next
;
960 process_function_and_variable_attributes (first_processed
,
962 first_processed
= cgraph_nodes
;
963 first_analyzed_var
= varpool_nodes
;
964 varpool_analyze_pending_decls ();
965 if (cgraph_dump_file
)
967 fprintf (cgraph_dump_file
, "Initial entry points:");
968 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
970 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
971 fprintf (cgraph_dump_file
, "\n");
973 cgraph_process_new_functions ();
975 /* Propagate reachability flag and lower representation of all reachable
976 functions. In the future, lowering will introduce new functions and
977 new entry points on the way (by template instantiation and virtual
978 method table generation for instance). */
979 while (cgraph_nodes_queue
)
981 struct cgraph_edge
*edge
;
982 tree decl
= cgraph_nodes_queue
->decl
;
984 node
= cgraph_nodes_queue
;
985 cgraph_nodes_queue
= cgraph_nodes_queue
->next_needed
;
986 node
->next_needed
= NULL
;
988 /* ??? It is possible to create extern inline function and later using
989 weak alias attribute to kill its body. See
990 gcc.c-torture/compile/20011119-1.c */
991 if (!DECL_STRUCT_FUNCTION (decl
))
993 cgraph_reset_node (node
);
998 cgraph_analyze_function (node
);
1000 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
1001 if (!edge
->callee
->reachable
)
1002 cgraph_mark_reachable_node (edge
->callee
);
1004 if (node
->same_comdat_group
)
1006 for (next
= node
->same_comdat_group
;
1008 next
= next
->same_comdat_group
)
1009 cgraph_mark_reachable_node (next
);
1012 /* If decl is a clone of an abstract function, mark that abstract
1013 function so that we don't release its body. The DECL_INITIAL() of that
1014 abstract function declaration will be later needed to output debug info. */
1015 if (DECL_ABSTRACT_ORIGIN (decl
))
1017 struct cgraph_node
*origin_node
= cgraph_node (DECL_ABSTRACT_ORIGIN (decl
));
1018 origin_node
->abstract_and_needed
= true;
1021 /* We finalize local static variables during constructing callgraph
1022 edges. Process their attributes too. */
1023 process_function_and_variable_attributes (first_processed
,
1024 first_analyzed_var
);
1025 first_processed
= cgraph_nodes
;
1026 first_analyzed_var
= varpool_nodes
;
1027 varpool_analyze_pending_decls ();
1028 cgraph_process_new_functions ();
1031 /* Collect entry points to the unit. */
1032 if (cgraph_dump_file
)
1034 fprintf (cgraph_dump_file
, "Unit entry points:");
1035 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= node
->next
)
1037 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1038 fprintf (cgraph_dump_file
, "\n\nInitial ");
1039 dump_cgraph (cgraph_dump_file
);
1042 if (cgraph_dump_file
)
1043 fprintf (cgraph_dump_file
, "\nReclaiming functions:");
1045 for (node
= cgraph_nodes
; node
!= first_analyzed
; node
= next
)
1047 tree decl
= node
->decl
;
1050 if (node
->local
.finalized
&& !gimple_has_body_p (decl
))
1051 cgraph_reset_node (node
);
1053 if (!node
->reachable
&& gimple_has_body_p (decl
))
1055 if (cgraph_dump_file
)
1056 fprintf (cgraph_dump_file
, " %s", cgraph_node_name (node
));
1057 cgraph_remove_node (node
);
1061 node
->next_needed
= NULL
;
1062 gcc_assert (!node
->local
.finalized
|| gimple_has_body_p (decl
));
1063 gcc_assert (node
->analyzed
== node
->local
.finalized
);
1065 if (cgraph_dump_file
)
1067 fprintf (cgraph_dump_file
, "\n\nReclaimed ");
1068 dump_cgraph (cgraph_dump_file
);
1070 first_analyzed
= cgraph_nodes
;
1075 /* Analyze the whole compilation unit once it is parsed completely. */
1078 cgraph_finalize_compilation_unit (void)
1080 timevar_push (TV_CGRAPH
);
1082 /* Do not skip analyzing the functions if there were errors, we
1083 miss diagnostics for following functions otherwise. */
1085 /* Emit size functions we didn't inline. */
1086 finalize_size_functions ();
1088 /* Call functions declared with the "constructor" or "destructor"
1090 cgraph_build_cdtor_fns ();
1092 /* Mark alias targets necessary and emit diagnostics. */
1093 finish_aliases_1 ();
1097 fprintf (stderr
, "\nAnalyzing compilation unit\n");
1101 /* Gimplify and lower all functions, compute reachability and
1102 remove unreachable nodes. */
1103 cgraph_analyze_functions ();
1105 /* Mark alias targets necessary and emit diagnostics. */
1106 finish_aliases_1 ();
1108 /* Gimplify and lower thunks. */
1109 cgraph_analyze_functions ();
1111 /* Finally drive the pass manager. */
1114 timevar_pop (TV_CGRAPH
);
1118 /* Figure out what functions we want to assemble. */
1121 cgraph_mark_functions_to_output (void)
1123 struct cgraph_node
*node
;
1124 #ifdef ENABLE_CHECKING
1125 bool check_same_comdat_groups
= false;
1127 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1128 gcc_assert (!node
->process
);
1131 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1133 tree decl
= node
->decl
;
1134 struct cgraph_edge
*e
;
1136 gcc_assert (!node
->process
|| node
->same_comdat_group
);
1140 for (e
= node
->callers
; e
; e
= e
->next_caller
)
1141 if (e
->inline_failed
)
1144 /* We need to output all local functions that are used and not
1145 always inlined, as well as those that are reachable from
1146 outside the current compilation unit. */
1148 && !node
->global
.inlined_to
1150 || (e
&& node
->reachable
))
1151 && !TREE_ASM_WRITTEN (decl
)
1152 && !DECL_EXTERNAL (decl
))
1155 if (node
->same_comdat_group
)
1157 struct cgraph_node
*next
;
1158 for (next
= node
->same_comdat_group
;
1160 next
= next
->same_comdat_group
)
1164 else if (node
->same_comdat_group
)
1166 #ifdef ENABLE_CHECKING
1167 check_same_comdat_groups
= true;
1172 /* We should've reclaimed all functions that are not needed. */
1173 #ifdef ENABLE_CHECKING
1174 if (!node
->global
.inlined_to
1175 && gimple_has_body_p (decl
)
1176 && !DECL_EXTERNAL (decl
))
1178 dump_cgraph_node (stderr
, node
);
1179 internal_error ("failed to reclaim unneeded function");
1182 gcc_assert (node
->global
.inlined_to
1183 || !gimple_has_body_p (decl
)
1184 || DECL_EXTERNAL (decl
));
1189 #ifdef ENABLE_CHECKING
1190 if (check_same_comdat_groups
)
1191 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1192 if (node
->same_comdat_group
&& !node
->process
)
1194 tree decl
= node
->decl
;
1195 if (!node
->global
.inlined_to
1196 && gimple_has_body_p (decl
)
1197 && !DECL_EXTERNAL (decl
))
1199 dump_cgraph_node (stderr
, node
);
1200 internal_error ("failed to reclaim unneeded function");
1206 /* DECL is FUNCTION_DECL. Initialize datastructures so DECL is a function
1207 in lowered gimple form.
1209 Set current_function_decl and cfun to newly constructed empty function body.
1210 return basic block in the function body. */
1213 init_lowered_empty_function (tree decl
)
1217 current_function_decl
= decl
;
1218 allocate_struct_function (decl
, false);
1219 gimple_register_cfg_hooks ();
1220 init_empty_tree_cfg ();
1221 init_tree_ssa (cfun
);
1222 init_ssa_operands ();
1223 cfun
->gimple_df
->in_ssa_p
= true;
1224 DECL_INITIAL (decl
) = make_node (BLOCK
);
1226 DECL_SAVED_TREE (decl
) = error_mark_node
;
1227 cfun
->curr_properties
|=
1228 (PROP_gimple_lcf
| PROP_gimple_leh
| PROP_cfg
| PROP_referenced_vars
|
1231 /* Create BB for body of the function and connect it properly. */
1232 bb
= create_basic_block (NULL
, (void *) 0, ENTRY_BLOCK_PTR
);
1233 make_edge (ENTRY_BLOCK_PTR
, bb
, 0);
1234 make_edge (bb
, EXIT_BLOCK_PTR
, 0);
1239 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
1240 offset indicated by VIRTUAL_OFFSET, if that is
1241 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
1242 zero for a result adjusting thunk. */
1245 thunk_adjust (gimple_stmt_iterator
* bsi
,
1246 tree ptr
, bool this_adjusting
,
1247 HOST_WIDE_INT fixed_offset
, tree virtual_offset
)
1253 && fixed_offset
!= 0)
1255 stmt
= gimple_build_assign (ptr
,
1256 fold_build2_loc (input_location
,
1258 TREE_TYPE (ptr
), ptr
,
1259 size_int (fixed_offset
)));
1260 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1263 /* If there's a virtual offset, look up that value in the vtable and
1264 adjust the pointer again. */
1272 if (!vtable_entry_type
)
1274 tree vfunc_type
= make_node (FUNCTION_TYPE
);
1275 TREE_TYPE (vfunc_type
) = integer_type_node
;
1276 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
1277 layout_type (vfunc_type
);
1279 vtable_entry_type
= build_pointer_type (vfunc_type
);
1283 create_tmp_var (build_pointer_type
1284 (build_pointer_type (vtable_entry_type
)), "vptr");
1286 /* The vptr is always at offset zero in the object. */
1287 stmt
= gimple_build_assign (vtabletmp
,
1288 build1 (NOP_EXPR
, TREE_TYPE (vtabletmp
),
1290 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1291 mark_symbols_for_renaming (stmt
);
1292 find_referenced_vars_in (stmt
);
1294 /* Form the vtable address. */
1295 vtabletmp2
= create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp
)),
1297 stmt
= gimple_build_assign (vtabletmp2
,
1298 build1 (INDIRECT_REF
,
1299 TREE_TYPE (vtabletmp2
), vtabletmp
));
1300 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1301 mark_symbols_for_renaming (stmt
);
1302 find_referenced_vars_in (stmt
);
1304 /* Find the entry with the vcall offset. */
1305 stmt
= gimple_build_assign (vtabletmp2
,
1306 fold_build2_loc (input_location
,
1308 TREE_TYPE (vtabletmp2
),
1310 fold_convert (sizetype
,
1312 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1314 /* Get the offset itself. */
1315 vtabletmp3
= create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp2
)),
1317 stmt
= gimple_build_assign (vtabletmp3
,
1318 build1 (INDIRECT_REF
,
1319 TREE_TYPE (vtabletmp3
),
1321 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1322 mark_symbols_for_renaming (stmt
);
1323 find_referenced_vars_in (stmt
);
1325 /* Cast to sizetype. */
1326 offsettmp
= create_tmp_var (sizetype
, "offset");
1327 stmt
= gimple_build_assign (offsettmp
, fold_convert (sizetype
, vtabletmp3
));
1328 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1329 mark_symbols_for_renaming (stmt
);
1330 find_referenced_vars_in (stmt
);
1332 /* Adjust the `this' pointer. */
1333 ptr
= fold_build2_loc (input_location
,
1334 POINTER_PLUS_EXPR
, TREE_TYPE (ptr
), ptr
,
1339 && fixed_offset
!= 0)
1340 /* Adjust the pointer by the constant. */
1344 if (TREE_CODE (ptr
) == VAR_DECL
)
1348 ptrtmp
= create_tmp_var (TREE_TYPE (ptr
), "ptr");
1349 stmt
= gimple_build_assign (ptrtmp
, ptr
);
1350 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1351 mark_symbols_for_renaming (stmt
);
1352 find_referenced_vars_in (stmt
);
1354 ptr
= fold_build2_loc (input_location
,
1355 POINTER_PLUS_EXPR
, TREE_TYPE (ptrtmp
), ptrtmp
,
1356 size_int (fixed_offset
));
1359 /* Emit the statement and gimplify the adjustment expression. */
1360 ret
= create_tmp_var (TREE_TYPE (ptr
), "adjusted_this");
1361 stmt
= gimple_build_assign (ret
, ptr
);
1362 mark_symbols_for_renaming (stmt
);
1363 find_referenced_vars_in (stmt
);
1364 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1369 /* Produce assembler for thunk NODE. */
1372 assemble_thunk (struct cgraph_node
*node
)
1374 bool this_adjusting
= node
->thunk
.this_adjusting
;
1375 HOST_WIDE_INT fixed_offset
= node
->thunk
.fixed_offset
;
1376 HOST_WIDE_INT virtual_value
= node
->thunk
.virtual_value
;
1377 tree virtual_offset
= NULL
;
1378 tree alias
= node
->thunk
.alias
;
1379 tree thunk_fndecl
= node
->decl
;
1380 tree a
= DECL_ARGUMENTS (thunk_fndecl
);
1382 current_function_decl
= thunk_fndecl
;
1385 && targetm
.asm_out
.can_output_mi_thunk (thunk_fndecl
, fixed_offset
,
1386 virtual_value
, alias
))
1391 DECL_RESULT (thunk_fndecl
)
1392 = build_decl (DECL_SOURCE_LOCATION (thunk_fndecl
),
1393 RESULT_DECL
, 0, integer_type_node
);
1394 fnname
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk_fndecl
));
1396 /* The back end expects DECL_INITIAL to contain a BLOCK, so we
1398 fn_block
= make_node (BLOCK
);
1399 BLOCK_VARS (fn_block
) = a
;
1400 DECL_INITIAL (thunk_fndecl
) = fn_block
;
1401 init_function_start (thunk_fndecl
);
1403 assemble_start_function (thunk_fndecl
, fnname
);
1405 targetm
.asm_out
.output_mi_thunk (asm_out_file
, thunk_fndecl
,
1406 fixed_offset
, virtual_value
, alias
);
1408 assemble_end_function (thunk_fndecl
, fnname
);
1409 init_insn_lengths ();
1410 free_after_compilation (cfun
);
1412 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
1417 basic_block bb
, then_bb
, else_bb
, return_bb
;
1418 gimple_stmt_iterator bsi
;
1424 VEC(tree
, heap
) *vargs
;
1429 DECL_IGNORED_P (thunk_fndecl
) = 1;
1430 bitmap_obstack_initialize (NULL
);
1432 if (node
->thunk
.virtual_offset_p
)
1433 virtual_offset
= size_int (virtual_value
);
1435 /* Build the return declaration for the function. */
1436 restype
= TREE_TYPE (TREE_TYPE (thunk_fndecl
));
1437 if (DECL_RESULT (thunk_fndecl
) == NULL_TREE
)
1439 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
1440 DECL_ARTIFICIAL (resdecl
) = 1;
1441 DECL_IGNORED_P (resdecl
) = 1;
1442 DECL_RESULT (thunk_fndecl
) = resdecl
;
1445 resdecl
= DECL_RESULT (thunk_fndecl
);
1447 bb
= then_bb
= else_bb
= return_bb
= init_lowered_empty_function (thunk_fndecl
);
1449 bsi
= gsi_start_bb (bb
);
1451 /* Build call to the function being thunked. */
1452 if (!VOID_TYPE_P (restype
))
1454 if (!is_gimple_reg_type (restype
))
1457 cfun
->local_decls
= tree_cons (NULL_TREE
, restmp
, cfun
->local_decls
);
1458 BLOCK_VARS (DECL_INITIAL (current_function_decl
)) = restmp
;
1461 restmp
= create_tmp_var_raw (restype
, "retval");
1464 for (arg
= a
; arg
; arg
= TREE_CHAIN (arg
))
1466 vargs
= VEC_alloc (tree
, heap
, nargs
);
1468 VEC_quick_push (tree
, vargs
,
1473 VEC_quick_push (tree
, vargs
, a
);
1474 for (i
= 1, arg
= TREE_CHAIN (a
); i
< nargs
; i
++, arg
= TREE_CHAIN (arg
))
1475 VEC_quick_push (tree
, vargs
, arg
);
1476 call
= gimple_build_call_vec (build_fold_addr_expr_loc (0, alias
), vargs
);
1477 VEC_free (tree
, heap
, vargs
);
1478 gimple_call_set_cannot_inline (call
, true);
1479 gimple_call_set_from_thunk (call
, true);
1481 gimple_call_set_lhs (call
, restmp
);
1482 gsi_insert_after (&bsi
, call
, GSI_NEW_STMT
);
1483 mark_symbols_for_renaming (call
);
1484 find_referenced_vars_in (call
);
1487 if (restmp
&& !this_adjusting
)
1489 tree true_label
= NULL_TREE
;
1491 if (TREE_CODE (TREE_TYPE (restmp
)) == POINTER_TYPE
)
1494 /* If the return type is a pointer, we need to
1495 protect against NULL. We know there will be an
1496 adjustment, because that's why we're emitting a
1498 then_bb
= create_basic_block (NULL
, (void *) 0, bb
);
1499 return_bb
= create_basic_block (NULL
, (void *) 0, then_bb
);
1500 else_bb
= create_basic_block (NULL
, (void *) 0, else_bb
);
1501 remove_edge (single_succ_edge (bb
));
1502 true_label
= gimple_block_label (then_bb
);
1503 stmt
= gimple_build_cond (NE_EXPR
, restmp
,
1504 fold_convert (TREE_TYPE (restmp
),
1506 NULL_TREE
, NULL_TREE
);
1507 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1508 make_edge (bb
, then_bb
, EDGE_TRUE_VALUE
);
1509 make_edge (bb
, else_bb
, EDGE_FALSE_VALUE
);
1510 make_edge (return_bb
, EXIT_BLOCK_PTR
, 0);
1511 make_edge (then_bb
, return_bb
, EDGE_FALLTHRU
);
1512 make_edge (else_bb
, return_bb
, EDGE_FALLTHRU
);
1513 bsi
= gsi_last_bb (then_bb
);
1516 restmp
= thunk_adjust (&bsi
, restmp
, /*this_adjusting=*/0,
1517 fixed_offset
, virtual_offset
);
1521 bsi
= gsi_last_bb (else_bb
);
1522 stmt
= gimple_build_assign (restmp
, fold_convert (TREE_TYPE (restmp
),
1523 integer_zero_node
));
1524 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1525 bsi
= gsi_last_bb (return_bb
);
1529 gimple_call_set_tail (call
, true);
1531 /* Build return value. */
1532 ret
= gimple_build_return (restmp
);
1533 gsi_insert_after (&bsi
, ret
, GSI_NEW_STMT
);
1535 delete_unreachable_blocks ();
1536 update_ssa (TODO_update_ssa
);
1538 cgraph_remove_same_body_alias (node
);
1539 /* Since we want to emit the thunk, we explicitly mark its name as
1541 mark_decl_referenced (thunk_fndecl
);
1542 cgraph_add_new_function (thunk_fndecl
, true);
1543 bitmap_obstack_release (NULL
);
1545 current_function_decl
= NULL
;
1548 /* Expand function specified by NODE. */
1551 cgraph_expand_function (struct cgraph_node
*node
)
1553 tree decl
= node
->decl
;
1555 /* We ought to not compile any inline clones. */
1556 gcc_assert (!node
->global
.inlined_to
);
1558 announce_function (decl
);
1561 gcc_assert (node
->lowered
);
1563 /* Generate RTL for the body of DECL. */
1564 tree_rest_of_compilation (decl
);
1566 /* Make sure that BE didn't give up on compiling. */
1567 gcc_assert (TREE_ASM_WRITTEN (decl
));
1568 current_function_decl
= NULL
;
1569 if (node
->same_body
)
1571 struct cgraph_node
*alias
, *next
;
1572 bool saved_alias
= node
->alias
;
1573 for (alias
= node
->same_body
;
1574 alias
&& alias
->next
; alias
= alias
->next
)
1576 /* Walk aliases in the order they were created; it is possible that
1577 thunks reffers to the aliases made earlier. */
1578 for (; alias
; alias
= next
)
1580 next
= alias
->previous
;
1581 if (!alias
->thunk
.thunk_p
)
1582 assemble_alias (alias
->decl
,
1583 DECL_ASSEMBLER_NAME (alias
->thunk
.alias
));
1585 assemble_thunk (alias
);
1587 node
->alias
= saved_alias
;
1589 gcc_assert (!cgraph_preserve_function_body_p (decl
));
1590 cgraph_release_function_body (node
);
1591 /* Eliminate all call edges. This is important so the GIMPLE_CALL no longer
1592 points to the dead function body. */
1593 cgraph_node_remove_callees (node
);
1595 cgraph_function_flags_ready
= true;
1598 /* Return true when CALLER_DECL should be inlined into CALLEE_DECL. */
1601 cgraph_inline_p (struct cgraph_edge
*e
, cgraph_inline_failed_t
*reason
)
1603 *reason
= e
->inline_failed
;
1604 return !e
->inline_failed
;
1609 /* Expand all functions that must be output.
1611 Attempt to topologically sort the nodes so function is output when
1612 all called functions are already assembled to allow data to be
1613 propagated across the callgraph. Use a stack to get smaller distance
1614 between a function and its callees (later we may choose to use a more
1615 sophisticated algorithm for function reordering; we will likely want
1616 to use subsections to make the output functions appear in top-down
1620 cgraph_expand_all_functions (void)
1622 struct cgraph_node
*node
;
1623 struct cgraph_node
**order
= XCNEWVEC (struct cgraph_node
*, cgraph_n_nodes
);
1624 int order_pos
, new_order_pos
= 0;
1627 order_pos
= cgraph_postorder (order
);
1628 gcc_assert (order_pos
== cgraph_n_nodes
);
1630 /* Garbage collector may remove inline clones we eliminate during
1631 optimization. So we must be sure to not reference them. */
1632 for (i
= 0; i
< order_pos
; i
++)
1633 if (order
[i
]->process
)
1634 order
[new_order_pos
++] = order
[i
];
1636 for (i
= new_order_pos
- 1; i
>= 0; i
--)
1641 gcc_assert (node
->reachable
);
1643 cgraph_expand_function (node
);
1646 cgraph_process_new_functions ();
1652 /* This is used to sort the node types by the cgraph order number. */
1654 enum cgraph_order_sort_kind
1656 ORDER_UNDEFINED
= 0,
1662 struct cgraph_order_sort
1664 enum cgraph_order_sort_kind kind
;
1667 struct cgraph_node
*f
;
1668 struct varpool_node
*v
;
1669 struct cgraph_asm_node
*a
;
1673 /* Output all functions, variables, and asm statements in the order
1674 according to their order fields, which is the order in which they
1675 appeared in the file. This implements -fno-toplevel-reorder. In
1676 this mode we may output functions and variables which don't really
1677 need to be output. */
1680 cgraph_output_in_order (void)
1683 struct cgraph_order_sort
*nodes
;
1685 struct cgraph_node
*pf
;
1686 struct varpool_node
*pv
;
1687 struct cgraph_asm_node
*pa
;
1690 nodes
= XCNEWVEC (struct cgraph_order_sort
, max
);
1692 varpool_analyze_pending_decls ();
1694 for (pf
= cgraph_nodes
; pf
; pf
= pf
->next
)
1699 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1700 nodes
[i
].kind
= ORDER_FUNCTION
;
1705 for (pv
= varpool_nodes_queue
; pv
; pv
= pv
->next_needed
)
1708 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1709 nodes
[i
].kind
= ORDER_VAR
;
1713 for (pa
= cgraph_asm_nodes
; pa
; pa
= pa
->next
)
1716 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1717 nodes
[i
].kind
= ORDER_ASM
;
1721 /* In toplevel reorder mode we output all statics; mark them as needed. */
1722 for (i
= 0; i
< max
; ++i
)
1724 if (nodes
[i
].kind
== ORDER_VAR
)
1726 varpool_mark_needed_node (nodes
[i
].u
.v
);
1729 varpool_empty_needed_queue ();
1731 for (i
= 0; i
< max
; ++i
)
1733 switch (nodes
[i
].kind
)
1735 case ORDER_FUNCTION
:
1736 nodes
[i
].u
.f
->process
= 0;
1737 cgraph_expand_function (nodes
[i
].u
.f
);
1741 varpool_assemble_decl (nodes
[i
].u
.v
);
1745 assemble_asm (nodes
[i
].u
.a
->asm_str
);
1748 case ORDER_UNDEFINED
:
1756 cgraph_asm_nodes
= NULL
;
1760 /* Return true when function body of DECL still needs to be kept around
1761 for later re-use. */
1763 cgraph_preserve_function_body_p (tree decl
)
1765 struct cgraph_node
*node
;
1767 gcc_assert (cgraph_global_info_ready
);
1768 /* Look if there is any clone around. */
1769 node
= cgraph_node (decl
);
1779 current_function_decl
= NULL
;
1780 gimple_register_cfg_hooks ();
1781 bitmap_obstack_initialize (NULL
);
1783 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_START
, NULL
);
1786 execute_ipa_pass_list (all_small_ipa_passes
);
1788 /* If pass_all_early_optimizations was not scheduled, the state of
1789 the cgraph will not be properly updated. Update it now. */
1790 if (cgraph_state
< CGRAPH_STATE_IPA_SSA
)
1791 cgraph_state
= CGRAPH_STATE_IPA_SSA
;
1795 /* Generate coverage variables and constructors. */
1798 /* Process new functions added. */
1800 current_function_decl
= NULL
;
1801 cgraph_process_new_functions ();
1803 execute_ipa_summary_passes
1804 ((struct ipa_opt_pass_d
*) all_regular_ipa_passes
);
1806 execute_ipa_summary_passes ((struct ipa_opt_pass_d
*) all_lto_gen_passes
);
1809 ipa_write_summaries ();
1812 execute_ipa_pass_list (all_regular_ipa_passes
);
1813 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_END
, NULL
);
1815 bitmap_obstack_release (NULL
);
1819 /* Perform simple optimizations based on callgraph. */
1822 cgraph_optimize (void)
1824 if (errorcount
|| sorrycount
)
1827 #ifdef ENABLE_CHECKING
1831 /* Frontend may output common variables after the unit has been finalized.
1832 It is safe to deal with them here as they are always zero initialized. */
1833 varpool_analyze_pending_decls ();
1835 timevar_push (TV_CGRAPHOPT
);
1836 if (pre_ipa_mem_report
)
1838 fprintf (stderr
, "Memory consumption before IPA\n");
1839 dump_memory_report (false);
1842 fprintf (stderr
, "Performing interprocedural optimizations\n");
1843 cgraph_state
= CGRAPH_STATE_IPA
;
1845 /* Don't run the IPA passes if there was any error or sorry messages. */
1846 if (errorcount
== 0 && sorrycount
== 0)
1849 /* Do nothing else if any IPA pass found errors. */
1850 if (errorcount
|| sorrycount
)
1852 timevar_pop (TV_CGRAPHOPT
);
1856 /* This pass remove bodies of extern inline functions we never inlined.
1857 Do this later so other IPA passes see what is really going on. */
1858 cgraph_remove_unreachable_nodes (false, dump_file
);
1859 cgraph_global_info_ready
= true;
1860 if (cgraph_dump_file
)
1862 fprintf (cgraph_dump_file
, "Optimized ");
1863 dump_cgraph (cgraph_dump_file
);
1864 dump_varpool (cgraph_dump_file
);
1866 if (post_ipa_mem_report
)
1868 fprintf (stderr
, "Memory consumption after IPA\n");
1869 dump_memory_report (false);
1871 timevar_pop (TV_CGRAPHOPT
);
1873 /* Output everything. */
1874 (*debug_hooks
->assembly_start
) ();
1876 fprintf (stderr
, "Assembling functions:\n");
1877 #ifdef ENABLE_CHECKING
1881 cgraph_materialize_all_clones ();
1882 cgraph_mark_functions_to_output ();
1884 cgraph_state
= CGRAPH_STATE_EXPANSION
;
1885 if (!flag_toplevel_reorder
)
1886 cgraph_output_in_order ();
1889 cgraph_output_pending_asms ();
1891 cgraph_expand_all_functions ();
1892 varpool_remove_unreferenced_decls ();
1894 varpool_assemble_pending_decls ();
1896 cgraph_process_new_functions ();
1897 cgraph_state
= CGRAPH_STATE_FINISHED
;
1899 if (cgraph_dump_file
)
1901 fprintf (cgraph_dump_file
, "\nFinal ");
1902 dump_cgraph (cgraph_dump_file
);
1904 #ifdef ENABLE_CHECKING
1906 /* Double check that all inline clones are gone and that all
1907 function bodies have been released from memory. */
1908 if (!(sorrycount
|| errorcount
))
1910 struct cgraph_node
*node
;
1911 bool error_found
= false;
1913 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1915 && (node
->global
.inlined_to
1916 || gimple_has_body_p (node
->decl
)))
1919 dump_cgraph_node (stderr
, node
);
1922 internal_error ("nodes with unreleased memory found");
1928 /* Generate and emit a static constructor or destructor. WHICH must
1929 be one of 'I' (for a constructor) or 'D' (for a destructor). BODY
1930 is a STATEMENT_LIST containing GENERIC statements. PRIORITY is the
1931 initialization priority for this constructor or destructor. */
1934 cgraph_build_static_cdtor (char which
, tree body
, int priority
)
1936 static int counter
= 0;
1938 tree decl
, name
, resdecl
;
1940 /* The priority is encoded in the constructor or destructor name.
1941 collect2 will sort the names and arrange that they are called at
1943 sprintf (which_buf
, "%c_%.5d_%d", which
, priority
, counter
++);
1944 name
= get_file_function_name (which_buf
);
1946 decl
= build_decl (input_location
, FUNCTION_DECL
, name
,
1947 build_function_type (void_type_node
, void_list_node
));
1948 current_function_decl
= decl
;
1950 resdecl
= build_decl (input_location
,
1951 RESULT_DECL
, NULL_TREE
, void_type_node
);
1952 DECL_ARTIFICIAL (resdecl
) = 1;
1953 DECL_RESULT (decl
) = resdecl
;
1954 DECL_CONTEXT (resdecl
) = decl
;
1956 allocate_struct_function (decl
, false);
1958 TREE_STATIC (decl
) = 1;
1959 TREE_USED (decl
) = 1;
1960 DECL_ARTIFICIAL (decl
) = 1;
1961 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
1962 DECL_SAVED_TREE (decl
) = body
;
1963 if (!targetm
.have_ctors_dtors
)
1965 TREE_PUBLIC (decl
) = 1;
1966 DECL_PRESERVE_P (decl
) = 1;
1968 DECL_UNINLINABLE (decl
) = 1;
1970 DECL_INITIAL (decl
) = make_node (BLOCK
);
1971 TREE_USED (DECL_INITIAL (decl
)) = 1;
1973 DECL_SOURCE_LOCATION (decl
) = input_location
;
1974 cfun
->function_end_locus
= input_location
;
1979 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
1980 decl_init_priority_insert (decl
, priority
);
1983 DECL_STATIC_DESTRUCTOR (decl
) = 1;
1984 decl_fini_priority_insert (decl
, priority
);
1990 gimplify_function_tree (decl
);
1992 cgraph_add_new_function (decl
, false);
1993 cgraph_mark_needed_node (cgraph_node (decl
));
2000 cgraph_dump_file
= dump_begin (TDI_cgraph
, NULL
);
2003 /* The edges representing the callers of the NEW_VERSION node were
2004 fixed by cgraph_function_versioning (), now the call_expr in their
2005 respective tree code should be updated to call the NEW_VERSION. */
2008 update_call_expr (struct cgraph_node
*new_version
)
2010 struct cgraph_edge
*e
;
2012 gcc_assert (new_version
);
2014 /* Update the call expr on the edges to call the new version. */
2015 for (e
= new_version
->callers
; e
; e
= e
->next_caller
)
2017 struct function
*inner_function
= DECL_STRUCT_FUNCTION (e
->caller
->decl
);
2018 gimple_call_set_fndecl (e
->call_stmt
, new_version
->decl
);
2019 maybe_clean_eh_stmt_fn (inner_function
, e
->call_stmt
);
2024 /* Create a new cgraph node which is the new version of
2025 OLD_VERSION node. REDIRECT_CALLERS holds the callers
2026 edges which should be redirected to point to
2027 NEW_VERSION. ALL the callees edges of OLD_VERSION
2028 are cloned to the new version node. Return the new
2031 static struct cgraph_node
*
2032 cgraph_copy_node_for_versioning (struct cgraph_node
*old_version
,
2034 VEC(cgraph_edge_p
,heap
) *redirect_callers
)
2036 struct cgraph_node
*new_version
;
2037 struct cgraph_edge
*e
, *new_e
;
2038 struct cgraph_edge
*next_callee
;
2041 gcc_assert (old_version
);
2043 new_version
= cgraph_node (new_decl
);
2045 new_version
->analyzed
= true;
2046 new_version
->local
= old_version
->local
;
2047 new_version
->global
= old_version
->global
;
2048 new_version
->rtl
= new_version
->rtl
;
2049 new_version
->reachable
= true;
2050 new_version
->count
= old_version
->count
;
2052 /* Clone the old node callees. Recursive calls are
2054 for (e
= old_version
->callees
;e
; e
=e
->next_callee
)
2056 new_e
= cgraph_clone_edge (e
, new_version
, e
->call_stmt
,
2057 e
->lto_stmt_uid
, 0, e
->frequency
,
2058 e
->loop_nest
, true);
2059 new_e
->count
= e
->count
;
2061 /* Fix recursive calls.
2062 If OLD_VERSION has a recursive call after the
2063 previous edge cloning, the new version will have an edge
2064 pointing to the old version, which is wrong;
2065 Redirect it to point to the new version. */
2066 for (e
= new_version
->callees
; e
; e
= next_callee
)
2068 next_callee
= e
->next_callee
;
2069 if (e
->callee
== old_version
)
2070 cgraph_redirect_edge_callee (e
, new_version
);
2075 for (i
= 0; VEC_iterate (cgraph_edge_p
, redirect_callers
, i
, e
); i
++)
2077 /* Redirect calls to the old version node to point to its new
2079 cgraph_redirect_edge_callee (e
, new_version
);
2085 /* Perform function versioning.
2086 Function versioning includes copying of the tree and
2087 a callgraph update (creating a new cgraph node and updating
2088 its callees and callers).
2090 REDIRECT_CALLERS varray includes the edges to be redirected
2093 TREE_MAP is a mapping of tree nodes we want to replace with
2094 new ones (according to results of prior analysis).
2095 OLD_VERSION_NODE is the node that is versioned.
2096 It returns the new version's cgraph node.
2097 ARGS_TO_SKIP lists arguments to be omitted from functions
2100 struct cgraph_node
*
2101 cgraph_function_versioning (struct cgraph_node
*old_version_node
,
2102 VEC(cgraph_edge_p
,heap
) *redirect_callers
,
2103 VEC (ipa_replace_map_p
,gc
)* tree_map
,
2104 bitmap args_to_skip
)
2106 tree old_decl
= old_version_node
->decl
;
2107 struct cgraph_node
*new_version_node
= NULL
;
2110 if (!tree_versionable_function_p (old_decl
))
2113 /* Make a new FUNCTION_DECL tree node for the
2116 new_decl
= copy_node (old_decl
);
2118 new_decl
= build_function_decl_skip_args (old_decl
, args_to_skip
);
2120 /* Create the new version's call-graph node.
2121 and update the edges of the new node. */
2123 cgraph_copy_node_for_versioning (old_version_node
, new_decl
,
2126 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2127 tree_function_versioning (old_decl
, new_decl
, tree_map
, false, args_to_skip
);
2129 /* Update the new version's properties.
2130 Make The new version visible only within this translation unit. Make sure
2131 that is not weak also.
2132 ??? We cannot use COMDAT linkage because there is no
2133 ABI support for this. */
2134 cgraph_make_decl_local (new_version_node
->decl
);
2135 DECL_VIRTUAL_P (new_version_node
->decl
) = 0;
2136 new_version_node
->local
.externally_visible
= 0;
2137 new_version_node
->local
.local
= 1;
2138 new_version_node
->lowered
= true;
2140 /* Update the call_expr on the edges to call the new version node. */
2141 update_call_expr (new_version_node
);
2143 cgraph_call_function_insertion_hooks (new_version_node
);
2144 return new_version_node
;
2147 /* Produce separate function body for inline clones so the offline copy can be
2148 modified without affecting them. */
2149 struct cgraph_node
*
2150 save_inline_function_body (struct cgraph_node
*node
)
2152 struct cgraph_node
*first_clone
, *n
;
2154 gcc_assert (node
== cgraph_node (node
->decl
));
2156 cgraph_lower_function (node
);
2158 first_clone
= node
->clones
;
2160 first_clone
->decl
= copy_node (node
->decl
);
2161 cgraph_insert_node_to_hashtable (first_clone
);
2162 gcc_assert (first_clone
== cgraph_node (first_clone
->decl
));
2163 if (first_clone
->next_sibling_clone
)
2165 for (n
= first_clone
->next_sibling_clone
; n
->next_sibling_clone
; n
= n
->next_sibling_clone
)
2166 n
->clone_of
= first_clone
;
2167 n
->clone_of
= first_clone
;
2168 n
->next_sibling_clone
= first_clone
->clones
;
2169 if (first_clone
->clones
)
2170 first_clone
->clones
->prev_sibling_clone
= n
;
2171 first_clone
->clones
= first_clone
->next_sibling_clone
;
2172 first_clone
->next_sibling_clone
->prev_sibling_clone
= NULL
;
2173 first_clone
->next_sibling_clone
= NULL
;
2174 gcc_assert (!first_clone
->prev_sibling_clone
);
2176 first_clone
->clone_of
= NULL
;
2177 node
->clones
= NULL
;
2179 if (first_clone
->clones
)
2180 for (n
= first_clone
->clones
; n
!= first_clone
;)
2182 gcc_assert (n
->decl
== node
->decl
);
2183 n
->decl
= first_clone
->decl
;
2186 else if (n
->next_sibling_clone
)
2187 n
= n
->next_sibling_clone
;
2190 while (n
!= first_clone
&& !n
->next_sibling_clone
)
2192 if (n
!= first_clone
)
2193 n
= n
->next_sibling_clone
;
2197 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2198 tree_function_versioning (node
->decl
, first_clone
->decl
, NULL
, true, NULL
);
2200 DECL_EXTERNAL (first_clone
->decl
) = 0;
2201 DECL_COMDAT_GROUP (first_clone
->decl
) = NULL_TREE
;
2202 TREE_PUBLIC (first_clone
->decl
) = 0;
2203 DECL_COMDAT (first_clone
->decl
) = 0;
2204 VEC_free (ipa_opt_pass
, heap
,
2205 first_clone
->ipa_transforms_to_apply
);
2206 first_clone
->ipa_transforms_to_apply
= NULL
;
2208 #ifdef ENABLE_CHECKING
2209 verify_cgraph_node (first_clone
);
2214 /* Given virtual clone, turn it into actual clone. */
2216 cgraph_materialize_clone (struct cgraph_node
*node
)
2218 bitmap_obstack_initialize (NULL
);
2219 /* Copy the OLD_VERSION_NODE function tree to the new version. */
2220 tree_function_versioning (node
->clone_of
->decl
, node
->decl
,
2221 node
->clone
.tree_map
, true,
2222 node
->clone
.args_to_skip
);
2223 if (cgraph_dump_file
)
2225 dump_function_to_file (node
->clone_of
->decl
, cgraph_dump_file
, dump_flags
);
2226 dump_function_to_file (node
->decl
, cgraph_dump_file
, dump_flags
);
2229 /* Function is no longer clone. */
2230 if (node
->next_sibling_clone
)
2231 node
->next_sibling_clone
->prev_sibling_clone
= node
->prev_sibling_clone
;
2232 if (node
->prev_sibling_clone
)
2233 node
->prev_sibling_clone
->next_sibling_clone
= node
->next_sibling_clone
;
2235 node
->clone_of
->clones
= node
->next_sibling_clone
;
2236 node
->next_sibling_clone
= NULL
;
2237 node
->prev_sibling_clone
= NULL
;
2238 if (!node
->clone_of
->analyzed
&& !node
->clone_of
->clones
)
2239 cgraph_remove_node (node
->clone_of
);
2240 node
->clone_of
= NULL
;
2241 bitmap_obstack_release (NULL
);
2244 /* If necessary, change the function declaration in the call statement
2245 associated with E so that it corresponds to the edge callee. */
2248 cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge
*e
)
2250 tree decl
= gimple_call_fndecl (e
->call_stmt
);
2252 gimple_stmt_iterator gsi
;
2254 if (!decl
|| decl
== e
->callee
->decl
2255 /* Don't update call from same body alias to the real function. */
2256 || cgraph_get_node (decl
) == cgraph_get_node (e
->callee
->decl
))
2257 return e
->call_stmt
;
2259 if (cgraph_dump_file
)
2261 fprintf (cgraph_dump_file
, "updating call of %s/%i -> %s/%i: ",
2262 cgraph_node_name (e
->caller
), e
->caller
->uid
,
2263 cgraph_node_name (e
->callee
), e
->callee
->uid
);
2264 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
2267 if (e
->callee
->clone
.combined_args_to_skip
)
2268 new_stmt
= gimple_call_copy_skip_args (e
->call_stmt
,
2269 e
->callee
->clone
.combined_args_to_skip
);
2271 new_stmt
= e
->call_stmt
;
2272 if (gimple_vdef (new_stmt
)
2273 && TREE_CODE (gimple_vdef (new_stmt
)) == SSA_NAME
)
2274 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt
)) = new_stmt
;
2275 gimple_call_set_fndecl (new_stmt
, e
->callee
->decl
);
2277 gsi
= gsi_for_stmt (e
->call_stmt
);
2278 gsi_replace (&gsi
, new_stmt
, true);
2280 /* Update EH information too, just in case. */
2281 maybe_clean_or_replace_eh_stmt (e
->call_stmt
, new_stmt
);
2283 cgraph_set_call_stmt_including_clones (e
->caller
, e
->call_stmt
, new_stmt
);
2285 if (cgraph_dump_file
)
2287 fprintf (cgraph_dump_file
, " updated to:");
2288 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
2293 /* Once all functions from compilation unit are in memory, produce all clones
2294 and update all calls. We might also do this on demand if we don't want to
2295 bring all functions to memory prior compilation, but current WHOPR
2296 implementation does that and it is is bit easier to keep everything right in
2299 cgraph_materialize_all_clones (void)
2301 struct cgraph_node
*node
;
2302 bool stabilized
= false;
2304 if (cgraph_dump_file
)
2305 fprintf (cgraph_dump_file
, "Materializing clones\n");
2306 #ifdef ENABLE_CHECKING
2310 /* We can also do topological order, but number of iterations should be
2311 bounded by number of IPA passes since single IPA pass is probably not
2312 going to create clones of clones it created itself. */
2316 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2318 if (node
->clone_of
&& node
->decl
!= node
->clone_of
->decl
2319 && !gimple_has_body_p (node
->decl
))
2321 if (gimple_has_body_p (node
->clone_of
->decl
))
2323 if (cgraph_dump_file
)
2325 fprintf (cgraph_dump_file
, "clonning %s to %s\n",
2326 cgraph_node_name (node
->clone_of
),
2327 cgraph_node_name (node
));
2328 if (node
->clone
.tree_map
)
2331 fprintf (cgraph_dump_file
, " replace map: ");
2332 for (i
= 0; i
< VEC_length (ipa_replace_map_p
,
2333 node
->clone
.tree_map
);
2336 struct ipa_replace_map
*replace_info
;
2337 replace_info
= VEC_index (ipa_replace_map_p
,
2338 node
->clone
.tree_map
,
2340 print_generic_expr (cgraph_dump_file
, replace_info
->old_tree
, 0);
2341 fprintf (cgraph_dump_file
, " -> ");
2342 print_generic_expr (cgraph_dump_file
, replace_info
->new_tree
, 0);
2343 fprintf (cgraph_dump_file
, "%s%s;",
2344 replace_info
->replace_p
? "(replace)":"",
2345 replace_info
->ref_p
? "(ref)":"");
2347 fprintf (cgraph_dump_file
, "\n");
2349 if (node
->clone
.args_to_skip
)
2351 fprintf (cgraph_dump_file
, " args_to_skip: ");
2352 dump_bitmap (cgraph_dump_file
, node
->clone
.args_to_skip
);
2354 if (node
->clone
.args_to_skip
)
2356 fprintf (cgraph_dump_file
, " combined_args_to_skip:");
2357 dump_bitmap (cgraph_dump_file
, node
->clone
.combined_args_to_skip
);
2360 cgraph_materialize_clone (node
);
2367 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2368 if (!node
->analyzed
&& node
->callees
)
2369 cgraph_node_remove_callees (node
);
2370 if (cgraph_dump_file
)
2371 fprintf (cgraph_dump_file
, "Updating call sites\n");
2372 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2373 if (node
->analyzed
&& !node
->clone_of
2374 && gimple_has_body_p (node
->decl
))
2376 struct cgraph_edge
*e
;
2378 current_function_decl
= node
->decl
;
2379 push_cfun (DECL_STRUCT_FUNCTION (node
->decl
));
2380 for (e
= node
->callees
; e
; e
= e
->next_callee
)
2381 cgraph_redirect_edge_call_stmt_to_callee (e
);
2383 current_function_decl
= NULL
;
2384 #ifdef ENABLE_CHECKING
2385 verify_cgraph_node (node
);
2388 if (cgraph_dump_file
)
2389 fprintf (cgraph_dump_file
, "Materialization Call site updates done.\n");
2390 /* All changes to parameters have been performed. In order not to
2391 incorrectly repeat them, we simply dispose of the bitmaps that drive the
2393 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2394 node
->clone
.combined_args_to_skip
= NULL
;
2395 #ifdef ENABLE_CHECKING
2398 cgraph_remove_unreachable_nodes (false, cgraph_dump_file
);
2401 #include "gt-cgraphunit.h"