1 /* Callgraph handling code.
2 Copyright (C) 2003-2013 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 /* This file contains basic routines manipulating call graph
23 The call-graph is a data structure designed for intra-procedural optimization.
24 It represents a multi-graph where nodes are functions and edges are call sites. */
28 #include "coretypes.h"
31 #include "tree-inline.h"
32 #include "langhooks.h"
39 #include "basic-block.h"
46 #include "value-prof.h"
48 #include "diagnostic-core.h"
50 #include "ipa-utils.h"
51 #include "lto-streamer.h"
52 #include "ipa-inline.h"
54 #include "gimple-pretty-print.h"
56 /* FIXME: Only for PROP_loops, but cgraph shouldn't have to know about this. */
57 #include "tree-pass.h"
59 static void cgraph_node_remove_callers (struct cgraph_node
*node
);
60 static inline void cgraph_edge_remove_caller (struct cgraph_edge
*e
);
61 static inline void cgraph_edge_remove_callee (struct cgraph_edge
*e
);
63 /* Queue of cgraph nodes scheduled to be lowered. */
64 symtab_node x_cgraph_nodes_queue
;
65 #define cgraph_nodes_queue ((struct cgraph_node *)x_cgraph_nodes_queue)
67 /* Number of nodes in existence. */
70 /* Maximal uid used in cgraph nodes. */
73 /* Maximal uid used in cgraph edges. */
74 int cgraph_edge_max_uid
;
76 /* Set when whole unit has been analyzed so we can access global info. */
77 bool cgraph_global_info_ready
= false;
79 /* What state callgraph is in right now. */
80 enum cgraph_state cgraph_state
= CGRAPH_STATE_PARSING
;
82 /* Set when the cgraph is fully build and the basic flags are computed. */
83 bool cgraph_function_flags_ready
= false;
85 /* List of hooks triggered on cgraph_edge events. */
86 struct cgraph_edge_hook_list
{
87 cgraph_edge_hook hook
;
89 struct cgraph_edge_hook_list
*next
;
92 /* List of hooks triggered on cgraph_node events. */
93 struct cgraph_node_hook_list
{
94 cgraph_node_hook hook
;
96 struct cgraph_node_hook_list
*next
;
99 /* List of hooks triggered on events involving two cgraph_edges. */
100 struct cgraph_2edge_hook_list
{
101 cgraph_2edge_hook hook
;
103 struct cgraph_2edge_hook_list
*next
;
106 /* List of hooks triggered on events involving two cgraph_nodes. */
107 struct cgraph_2node_hook_list
{
108 cgraph_2node_hook hook
;
110 struct cgraph_2node_hook_list
*next
;
113 /* List of hooks triggered when an edge is removed. */
114 struct cgraph_edge_hook_list
*first_cgraph_edge_removal_hook
;
115 /* List of hooks triggered when a node is removed. */
116 struct cgraph_node_hook_list
*first_cgraph_node_removal_hook
;
117 /* List of hooks triggered when an edge is duplicated. */
118 struct cgraph_2edge_hook_list
*first_cgraph_edge_duplicated_hook
;
119 /* List of hooks triggered when a node is duplicated. */
120 struct cgraph_2node_hook_list
*first_cgraph_node_duplicated_hook
;
121 /* List of hooks triggered when an function is inserted. */
122 struct cgraph_node_hook_list
*first_cgraph_function_insertion_hook
;
124 /* Head of a linked list of unused (freed) call graph nodes.
125 Do not GTY((delete)) this list so UIDs gets reliably recycled. */
126 static GTY(()) struct cgraph_node
*free_nodes
;
127 /* Head of a linked list of unused (freed) call graph edges.
128 Do not GTY((delete)) this list so UIDs gets reliably recycled. */
129 static GTY(()) struct cgraph_edge
*free_edges
;
131 /* Did procss_same_body_aliases run? */
132 bool cpp_implicit_aliases_done
;
134 /* Map a cgraph_node to cgraph_function_version_info using this htab.
135 The cgraph_function_version_info has a THIS_NODE field that is the
136 corresponding cgraph_node.. */
138 static htab_t
GTY((param_is (struct cgraph_function_version_info
*)))
139 cgraph_fnver_htab
= NULL
;
141 /* Hash function for cgraph_fnver_htab. */
143 cgraph_fnver_htab_hash (const void *ptr
)
145 int uid
= ((const struct cgraph_function_version_info
*)ptr
)->this_node
->uid
;
146 return (hashval_t
)(uid
);
149 /* eq function for cgraph_fnver_htab. */
151 cgraph_fnver_htab_eq (const void *p1
, const void *p2
)
153 const struct cgraph_function_version_info
*n1
154 = (const struct cgraph_function_version_info
*)p1
;
155 const struct cgraph_function_version_info
*n2
156 = (const struct cgraph_function_version_info
*)p2
;
158 return n1
->this_node
->uid
== n2
->this_node
->uid
;
161 /* Mark as GC root all allocated nodes. */
162 static GTY(()) struct cgraph_function_version_info
*
163 version_info_node
= NULL
;
165 /* Get the cgraph_function_version_info node corresponding to node. */
166 struct cgraph_function_version_info
*
167 get_cgraph_node_version (struct cgraph_node
*node
)
169 struct cgraph_function_version_info
*ret
;
170 struct cgraph_function_version_info key
;
171 key
.this_node
= node
;
173 if (cgraph_fnver_htab
== NULL
)
176 ret
= (struct cgraph_function_version_info
*)
177 htab_find (cgraph_fnver_htab
, &key
);
182 /* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
183 corresponding to cgraph_node NODE. */
184 struct cgraph_function_version_info
*
185 insert_new_cgraph_node_version (struct cgraph_node
*node
)
189 version_info_node
= NULL
;
190 version_info_node
= ggc_alloc_cleared_cgraph_function_version_info ();
191 version_info_node
->this_node
= node
;
193 if (cgraph_fnver_htab
== NULL
)
194 cgraph_fnver_htab
= htab_create_ggc (2, cgraph_fnver_htab_hash
,
195 cgraph_fnver_htab_eq
, NULL
);
197 slot
= htab_find_slot (cgraph_fnver_htab
, version_info_node
, INSERT
);
198 gcc_assert (slot
!= NULL
);
199 *slot
= version_info_node
;
200 return version_info_node
;
203 /* Remove the cgraph_function_version_info and cgraph_node for DECL. This
204 DECL is a duplicate declaration. */
206 delete_function_version (tree decl
)
208 struct cgraph_node
*decl_node
= cgraph_get_node (decl
);
209 struct cgraph_function_version_info
*decl_v
= NULL
;
211 if (decl_node
== NULL
)
214 decl_v
= get_cgraph_node_version (decl_node
);
219 if (decl_v
->prev
!= NULL
)
220 decl_v
->prev
->next
= decl_v
->next
;
222 if (decl_v
->next
!= NULL
)
223 decl_v
->next
->prev
= decl_v
->prev
;
225 if (cgraph_fnver_htab
!= NULL
)
226 htab_remove_elt (cgraph_fnver_htab
, decl_v
);
228 cgraph_remove_node (decl_node
);
231 /* Record that DECL1 and DECL2 are semantically identical function
234 record_function_versions (tree decl1
, tree decl2
)
236 struct cgraph_node
*decl1_node
= cgraph_get_create_node (decl1
);
237 struct cgraph_node
*decl2_node
= cgraph_get_create_node (decl2
);
238 struct cgraph_function_version_info
*decl1_v
= NULL
;
239 struct cgraph_function_version_info
*decl2_v
= NULL
;
240 struct cgraph_function_version_info
*before
;
241 struct cgraph_function_version_info
*after
;
243 gcc_assert (decl1_node
!= NULL
&& decl2_node
!= NULL
);
244 decl1_v
= get_cgraph_node_version (decl1_node
);
245 decl2_v
= get_cgraph_node_version (decl2_node
);
247 if (decl1_v
!= NULL
&& decl2_v
!= NULL
)
251 decl1_v
= insert_new_cgraph_node_version (decl1_node
);
254 decl2_v
= insert_new_cgraph_node_version (decl2_node
);
256 /* Chain decl2_v and decl1_v. All semantically identical versions
257 will be chained together. */
262 while (before
->next
!= NULL
)
263 before
= before
->next
;
265 while (after
->prev
!= NULL
)
268 before
->next
= after
;
269 after
->prev
= before
;
272 /* Macros to access the next item in the list of free cgraph nodes and
274 #define NEXT_FREE_NODE(NODE) cgraph ((NODE)->symbol.next)
275 #define SET_NEXT_FREE_NODE(NODE,NODE2) ((NODE))->symbol.next = (symtab_node)NODE2
276 #define NEXT_FREE_EDGE(EDGE) (EDGE)->prev_caller
278 /* Register HOOK to be called with DATA on each removed edge. */
279 struct cgraph_edge_hook_list
*
280 cgraph_add_edge_removal_hook (cgraph_edge_hook hook
, void *data
)
282 struct cgraph_edge_hook_list
*entry
;
283 struct cgraph_edge_hook_list
**ptr
= &first_cgraph_edge_removal_hook
;
285 entry
= (struct cgraph_edge_hook_list
*) xmalloc (sizeof (*entry
));
295 /* Remove ENTRY from the list of hooks called on removing edges. */
297 cgraph_remove_edge_removal_hook (struct cgraph_edge_hook_list
*entry
)
299 struct cgraph_edge_hook_list
**ptr
= &first_cgraph_edge_removal_hook
;
301 while (*ptr
!= entry
)
307 /* Call all edge removal hooks. */
309 cgraph_call_edge_removal_hooks (struct cgraph_edge
*e
)
311 struct cgraph_edge_hook_list
*entry
= first_cgraph_edge_removal_hook
;
314 entry
->hook (e
, entry
->data
);
319 /* Register HOOK to be called with DATA on each removed node. */
320 struct cgraph_node_hook_list
*
321 cgraph_add_node_removal_hook (cgraph_node_hook hook
, void *data
)
323 struct cgraph_node_hook_list
*entry
;
324 struct cgraph_node_hook_list
**ptr
= &first_cgraph_node_removal_hook
;
326 entry
= (struct cgraph_node_hook_list
*) xmalloc (sizeof (*entry
));
336 /* Remove ENTRY from the list of hooks called on removing nodes. */
338 cgraph_remove_node_removal_hook (struct cgraph_node_hook_list
*entry
)
340 struct cgraph_node_hook_list
**ptr
= &first_cgraph_node_removal_hook
;
342 while (*ptr
!= entry
)
348 /* Call all node removal hooks. */
350 cgraph_call_node_removal_hooks (struct cgraph_node
*node
)
352 struct cgraph_node_hook_list
*entry
= first_cgraph_node_removal_hook
;
355 entry
->hook (node
, entry
->data
);
360 /* Register HOOK to be called with DATA on each inserted node. */
361 struct cgraph_node_hook_list
*
362 cgraph_add_function_insertion_hook (cgraph_node_hook hook
, void *data
)
364 struct cgraph_node_hook_list
*entry
;
365 struct cgraph_node_hook_list
**ptr
= &first_cgraph_function_insertion_hook
;
367 entry
= (struct cgraph_node_hook_list
*) xmalloc (sizeof (*entry
));
377 /* Remove ENTRY from the list of hooks called on inserted nodes. */
379 cgraph_remove_function_insertion_hook (struct cgraph_node_hook_list
*entry
)
381 struct cgraph_node_hook_list
**ptr
= &first_cgraph_function_insertion_hook
;
383 while (*ptr
!= entry
)
389 /* Call all node insertion hooks. */
391 cgraph_call_function_insertion_hooks (struct cgraph_node
*node
)
393 struct cgraph_node_hook_list
*entry
= first_cgraph_function_insertion_hook
;
396 entry
->hook (node
, entry
->data
);
401 /* Register HOOK to be called with DATA on each duplicated edge. */
402 struct cgraph_2edge_hook_list
*
403 cgraph_add_edge_duplication_hook (cgraph_2edge_hook hook
, void *data
)
405 struct cgraph_2edge_hook_list
*entry
;
406 struct cgraph_2edge_hook_list
**ptr
= &first_cgraph_edge_duplicated_hook
;
408 entry
= (struct cgraph_2edge_hook_list
*) xmalloc (sizeof (*entry
));
418 /* Remove ENTRY from the list of hooks called on duplicating edges. */
420 cgraph_remove_edge_duplication_hook (struct cgraph_2edge_hook_list
*entry
)
422 struct cgraph_2edge_hook_list
**ptr
= &first_cgraph_edge_duplicated_hook
;
424 while (*ptr
!= entry
)
430 /* Call all edge duplication hooks. */
432 cgraph_call_edge_duplication_hooks (struct cgraph_edge
*cs1
,
433 struct cgraph_edge
*cs2
)
435 struct cgraph_2edge_hook_list
*entry
= first_cgraph_edge_duplicated_hook
;
438 entry
->hook (cs1
, cs2
, entry
->data
);
443 /* Register HOOK to be called with DATA on each duplicated node. */
444 struct cgraph_2node_hook_list
*
445 cgraph_add_node_duplication_hook (cgraph_2node_hook hook
, void *data
)
447 struct cgraph_2node_hook_list
*entry
;
448 struct cgraph_2node_hook_list
**ptr
= &first_cgraph_node_duplicated_hook
;
450 entry
= (struct cgraph_2node_hook_list
*) xmalloc (sizeof (*entry
));
460 /* Remove ENTRY from the list of hooks called on duplicating nodes. */
462 cgraph_remove_node_duplication_hook (struct cgraph_2node_hook_list
*entry
)
464 struct cgraph_2node_hook_list
**ptr
= &first_cgraph_node_duplicated_hook
;
466 while (*ptr
!= entry
)
472 /* Call all node duplication hooks. */
474 cgraph_call_node_duplication_hooks (struct cgraph_node
*node1
,
475 struct cgraph_node
*node2
)
477 struct cgraph_2node_hook_list
*entry
= first_cgraph_node_duplicated_hook
;
480 entry
->hook (node1
, node2
, entry
->data
);
485 /* Allocate new callgraph node. */
487 static inline struct cgraph_node
*
488 cgraph_allocate_node (void)
490 struct cgraph_node
*node
;
495 free_nodes
= NEXT_FREE_NODE (node
);
499 node
= ggc_alloc_cleared_cgraph_node ();
500 node
->uid
= cgraph_max_uid
++;
506 /* Allocate new callgraph node and insert it into basic data structures. */
509 cgraph_create_empty_node (void)
511 struct cgraph_node
*node
= cgraph_allocate_node ();
513 node
->symbol
.type
= SYMTAB_FUNCTION
;
514 node
->frequency
= NODE_FREQUENCY_NORMAL
;
515 node
->count_materialization_scale
= REG_BR_PROB_BASE
;
520 /* Return cgraph node assigned to DECL. Create new one when needed. */
523 cgraph_create_node (tree decl
)
525 struct cgraph_node
*node
= cgraph_create_empty_node ();
526 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
528 node
->symbol
.decl
= decl
;
529 symtab_register_node ((symtab_node
) node
);
531 if (DECL_CONTEXT (decl
) && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
533 node
->origin
= cgraph_get_create_node (DECL_CONTEXT (decl
));
534 node
->next_nested
= node
->origin
->nested
;
535 node
->origin
->nested
= node
;
540 /* Try to find a call graph node for declaration DECL and if it does not exist,
544 cgraph_get_create_node (tree decl
)
546 struct cgraph_node
*node
;
548 node
= cgraph_get_node (decl
);
552 return cgraph_create_node (decl
);
555 /* Mark ALIAS as an alias to DECL. DECL_NODE is cgraph node representing
556 the function body is associated with (not necessarily cgraph_node (DECL). */
559 cgraph_create_function_alias (tree alias
, tree target
)
561 struct cgraph_node
*alias_node
;
563 gcc_assert (TREE_CODE (target
) == FUNCTION_DECL
564 || TREE_CODE (target
) == IDENTIFIER_NODE
);
565 gcc_assert (TREE_CODE (alias
) == FUNCTION_DECL
);
566 alias_node
= cgraph_get_create_node (alias
);
567 gcc_assert (!alias_node
->symbol
.definition
);
568 alias_node
->symbol
.alias_target
= target
;
569 alias_node
->symbol
.definition
= true;
570 alias_node
->symbol
.alias
= true;
571 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (alias
)) != NULL
)
572 alias_node
->symbol
.weakref
= true;
576 /* Attempt to mark ALIAS as an alias to DECL. Return alias node if successful
578 Same body aliases are output whenever the body of DECL is output,
579 and cgraph_get_node (ALIAS) transparently returns cgraph_get_node (DECL). */
582 cgraph_same_body_alias (struct cgraph_node
*decl_node ATTRIBUTE_UNUSED
, tree alias
, tree decl
)
584 struct cgraph_node
*n
;
585 #ifndef ASM_OUTPUT_DEF
586 /* If aliases aren't supported by the assembler, fail. */
589 /* Langhooks can create same body aliases of symbols not defined.
590 Those are useless. Drop them on the floor. */
591 if (cgraph_global_info_ready
)
594 n
= cgraph_create_function_alias (alias
, decl
);
595 n
->symbol
.cpp_implicit_alias
= true;
596 if (cpp_implicit_aliases_done
)
597 symtab_resolve_alias ((symtab_node
)n
,
598 (symtab_node
)cgraph_get_node (decl
));
602 /* Add thunk alias into callgraph. The alias declaration is ALIAS and it
603 aliases DECL with an adjustments made into the first parameter.
604 See comments in thunk_adjust for detail on the parameters. */
607 cgraph_add_thunk (struct cgraph_node
*decl_node ATTRIBUTE_UNUSED
,
608 tree alias
, tree decl ATTRIBUTE_UNUSED
,
610 HOST_WIDE_INT fixed_offset
, HOST_WIDE_INT virtual_value
,
614 struct cgraph_node
*node
;
616 node
= cgraph_get_node (alias
);
619 gcc_assert (node
->symbol
.definition
);
620 gcc_assert (!node
->symbol
.alias
);
621 gcc_assert (!node
->thunk
.thunk_p
);
622 cgraph_remove_node (node
);
625 node
= cgraph_create_node (alias
);
626 gcc_checking_assert (!virtual_offset
627 || tree_to_double_int (virtual_offset
) ==
628 double_int::from_shwi (virtual_value
));
629 node
->thunk
.fixed_offset
= fixed_offset
;
630 node
->thunk
.this_adjusting
= this_adjusting
;
631 node
->thunk
.virtual_value
= virtual_value
;
632 node
->thunk
.virtual_offset_p
= virtual_offset
!= NULL
;
633 node
->thunk
.alias
= real_alias
;
634 node
->thunk
.thunk_p
= true;
635 node
->symbol
.definition
= true;
640 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
641 Return NULL if there's no such node. */
644 cgraph_node_for_asm (tree asmname
)
646 /* We do not want to look at inline clones. */
647 for (symtab_node node
= symtab_node_for_asm (asmname
);
649 node
= node
->symbol
.next_sharing_asm_name
)
651 cgraph_node
*cn
= dyn_cast
<cgraph_node
> (node
);
652 if (cn
&& !cn
->global
.inlined_to
)
658 /* Returns a hash value for X (which really is a cgraph_edge). */
661 edge_hash (const void *x
)
663 return htab_hash_pointer (((const struct cgraph_edge
*) x
)->call_stmt
);
666 /* Return nonzero if the call_stmt of of cgraph_edge X is stmt *Y. */
669 edge_eq (const void *x
, const void *y
)
671 return ((const struct cgraph_edge
*) x
)->call_stmt
== y
;
674 /* Add call graph edge E to call site hash of its caller. */
677 cgraph_update_edge_in_call_site_hash (struct cgraph_edge
*e
)
680 slot
= htab_find_slot_with_hash (e
->caller
->call_site_hash
,
682 htab_hash_pointer (e
->call_stmt
),
687 /* Add call graph edge E to call site hash of its caller. */
690 cgraph_add_edge_to_call_site_hash (struct cgraph_edge
*e
)
693 /* There are two speculative edges for every statement (one direct,
694 one indirect); always hash the direct one. */
695 if (e
->speculative
&& e
->indirect_unknown_callee
)
697 slot
= htab_find_slot_with_hash (e
->caller
->call_site_hash
,
699 htab_hash_pointer (e
->call_stmt
),
703 gcc_assert (((struct cgraph_edge
*)*slot
)->speculative
);
708 gcc_assert (!*slot
|| e
->speculative
);
712 /* Return the callgraph edge representing the GIMPLE_CALL statement
716 cgraph_edge (struct cgraph_node
*node
, gimple call_stmt
)
718 struct cgraph_edge
*e
, *e2
;
721 if (node
->call_site_hash
)
722 return (struct cgraph_edge
*)
723 htab_find_with_hash (node
->call_site_hash
, call_stmt
,
724 htab_hash_pointer (call_stmt
));
726 /* This loop may turn out to be performance problem. In such case adding
727 hashtables into call nodes with very many edges is probably best
728 solution. It is not good idea to add pointer into CALL_EXPR itself
729 because we want to make possible having multiple cgraph nodes representing
730 different clones of the same body before the body is actually cloned. */
731 for (e
= node
->callees
; e
; e
= e
->next_callee
)
733 if (e
->call_stmt
== call_stmt
)
739 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
741 if (e
->call_stmt
== call_stmt
)
748 node
->call_site_hash
= htab_create_ggc (120, edge_hash
, edge_eq
, NULL
);
749 for (e2
= node
->callees
; e2
; e2
= e2
->next_callee
)
750 cgraph_add_edge_to_call_site_hash (e2
);
751 for (e2
= node
->indirect_calls
; e2
; e2
= e2
->next_callee
)
752 cgraph_add_edge_to_call_site_hash (e2
);
759 /* Change field call_stmt of edge E to NEW_STMT.
760 If UPDATE_SPECULATIVE and E is any component of speculative
761 edge, then update all components. */
764 cgraph_set_call_stmt (struct cgraph_edge
*e
, gimple new_stmt
,
765 bool update_speculative
)
769 /* Speculative edges has three component, update all of them
771 if (update_speculative
&& e
->speculative
)
773 struct cgraph_edge
*direct
, *indirect
;
776 cgraph_speculative_call_info (e
, direct
, indirect
, ref
);
777 cgraph_set_call_stmt (direct
, new_stmt
, false);
778 cgraph_set_call_stmt (indirect
, new_stmt
, false);
779 ref
->stmt
= new_stmt
;
783 /* Only direct speculative edges go to call_site_hash. */
784 if (e
->caller
->call_site_hash
785 && (!e
->speculative
|| !e
->indirect_unknown_callee
))
787 htab_remove_elt_with_hash (e
->caller
->call_site_hash
,
789 htab_hash_pointer (e
->call_stmt
));
792 e
->call_stmt
= new_stmt
;
793 if (e
->indirect_unknown_callee
794 && (decl
= gimple_call_fndecl (new_stmt
)))
796 /* Constant propagation (and possibly also inlining?) can turn an
797 indirect call into a direct one. */
798 struct cgraph_node
*new_callee
= cgraph_get_node (decl
);
800 gcc_checking_assert (new_callee
);
801 e
= cgraph_make_edge_direct (e
, new_callee
);
804 push_cfun (DECL_STRUCT_FUNCTION (e
->caller
->symbol
.decl
));
805 e
->can_throw_external
= stmt_can_throw_external (new_stmt
);
807 if (e
->caller
->call_site_hash
)
808 cgraph_add_edge_to_call_site_hash (e
);
811 /* Allocate a cgraph_edge structure and fill it with data according to the
812 parameters of which only CALLEE can be NULL (when creating an indirect call
815 static struct cgraph_edge
*
816 cgraph_create_edge_1 (struct cgraph_node
*caller
, struct cgraph_node
*callee
,
817 gimple call_stmt
, gcov_type count
, int freq
)
819 struct cgraph_edge
*edge
;
821 /* LTO does not actually have access to the call_stmt since these
822 have not been loaded yet. */
825 /* This is a rather expensive check possibly triggering
826 construction of call stmt hashtable. */
827 #ifdef ENABLE_CHECKING
828 struct cgraph_edge
*e
;
829 gcc_checking_assert (!(e
=cgraph_edge (caller
, call_stmt
)) || e
->speculative
);
832 gcc_assert (is_gimple_call (call_stmt
));
838 free_edges
= NEXT_FREE_EDGE (edge
);
842 edge
= ggc_alloc_cgraph_edge ();
843 edge
->uid
= cgraph_edge_max_uid
++;
847 edge
->caller
= caller
;
848 edge
->callee
= callee
;
849 edge
->prev_caller
= NULL
;
850 edge
->next_caller
= NULL
;
851 edge
->prev_callee
= NULL
;
852 edge
->next_callee
= NULL
;
853 edge
->lto_stmt_uid
= 0;
856 gcc_assert (count
>= 0);
857 edge
->frequency
= freq
;
858 gcc_assert (freq
>= 0);
859 gcc_assert (freq
<= CGRAPH_FREQ_MAX
);
861 edge
->call_stmt
= call_stmt
;
862 push_cfun (DECL_STRUCT_FUNCTION (caller
->symbol
.decl
));
863 edge
->can_throw_external
864 = call_stmt
? stmt_can_throw_external (call_stmt
) : false;
867 && callee
&& callee
->symbol
.decl
868 && !gimple_check_call_matching_types (call_stmt
, callee
->symbol
.decl
,
870 edge
->call_stmt_cannot_inline_p
= true;
872 edge
->call_stmt_cannot_inline_p
= false;
874 edge
->indirect_info
= NULL
;
875 edge
->indirect_inlining_edge
= 0;
876 edge
->speculative
= false;
877 if (call_stmt
&& caller
->call_site_hash
)
878 cgraph_add_edge_to_call_site_hash (edge
);
883 /* Create edge from CALLER to CALLEE in the cgraph. */
886 cgraph_create_edge (struct cgraph_node
*caller
, struct cgraph_node
*callee
,
887 gimple call_stmt
, gcov_type count
, int freq
)
889 struct cgraph_edge
*edge
= cgraph_create_edge_1 (caller
, callee
, call_stmt
,
892 edge
->indirect_unknown_callee
= 0;
893 initialize_inline_failed (edge
);
895 edge
->next_caller
= callee
->callers
;
897 callee
->callers
->prev_caller
= edge
;
898 edge
->next_callee
= caller
->callees
;
900 caller
->callees
->prev_callee
= edge
;
901 caller
->callees
= edge
;
902 callee
->callers
= edge
;
907 /* Allocate cgraph_indirect_call_info and set its fields to default values. */
909 struct cgraph_indirect_call_info
*
910 cgraph_allocate_init_indirect_info (void)
912 struct cgraph_indirect_call_info
*ii
;
914 ii
= ggc_alloc_cleared_cgraph_indirect_call_info ();
915 ii
->param_index
= -1;
919 /* Create an indirect edge with a yet-undetermined callee where the call
920 statement destination is a formal parameter of the caller with index
924 cgraph_create_indirect_edge (struct cgraph_node
*caller
, gimple call_stmt
,
926 gcov_type count
, int freq
)
928 struct cgraph_edge
*edge
= cgraph_create_edge_1 (caller
, NULL
, call_stmt
,
932 edge
->indirect_unknown_callee
= 1;
933 initialize_inline_failed (edge
);
935 edge
->indirect_info
= cgraph_allocate_init_indirect_info ();
936 edge
->indirect_info
->ecf_flags
= ecf_flags
;
938 /* Record polymorphic call info. */
940 && (target
= gimple_call_fn (call_stmt
))
941 && virtual_method_call_p (target
))
943 tree type
= obj_type_ref_class (target
);
946 /* Only record types can have virtual calls. */
947 gcc_assert (TREE_CODE (type
) == RECORD_TYPE
);
948 edge
->indirect_info
->param_index
= -1;
949 edge
->indirect_info
->otr_token
950 = tree_low_cst (OBJ_TYPE_REF_TOKEN (target
), 1);
951 edge
->indirect_info
->otr_type
= type
;
952 edge
->indirect_info
->polymorphic
= 1;
955 edge
->next_callee
= caller
->indirect_calls
;
956 if (caller
->indirect_calls
)
957 caller
->indirect_calls
->prev_callee
= edge
;
958 caller
->indirect_calls
= edge
;
963 /* Remove the edge E from the list of the callers of the callee. */
966 cgraph_edge_remove_callee (struct cgraph_edge
*e
)
968 gcc_assert (!e
->indirect_unknown_callee
);
970 e
->prev_caller
->next_caller
= e
->next_caller
;
972 e
->next_caller
->prev_caller
= e
->prev_caller
;
974 e
->callee
->callers
= e
->next_caller
;
977 /* Remove the edge E from the list of the callees of the caller. */
980 cgraph_edge_remove_caller (struct cgraph_edge
*e
)
983 e
->prev_callee
->next_callee
= e
->next_callee
;
985 e
->next_callee
->prev_callee
= e
->prev_callee
;
988 if (e
->indirect_unknown_callee
)
989 e
->caller
->indirect_calls
= e
->next_callee
;
991 e
->caller
->callees
= e
->next_callee
;
993 if (e
->caller
->call_site_hash
)
994 htab_remove_elt_with_hash (e
->caller
->call_site_hash
,
996 htab_hash_pointer (e
->call_stmt
));
999 /* Put the edge onto the free list. */
1002 cgraph_free_edge (struct cgraph_edge
*e
)
1006 if (e
->indirect_info
)
1007 ggc_free (e
->indirect_info
);
1009 /* Clear out the edge so we do not dangle pointers. */
1010 memset (e
, 0, sizeof (*e
));
1012 NEXT_FREE_EDGE (e
) = free_edges
;
1016 /* Remove the edge E in the cgraph. */
1019 cgraph_remove_edge (struct cgraph_edge
*e
)
1021 /* Call all edge removal hooks. */
1022 cgraph_call_edge_removal_hooks (e
);
1024 if (!e
->indirect_unknown_callee
)
1025 /* Remove from callers list of the callee. */
1026 cgraph_edge_remove_callee (e
);
1028 /* Remove from callees list of the callers. */
1029 cgraph_edge_remove_caller (e
);
1031 /* Put the edge onto the free list. */
1032 cgraph_free_edge (e
);
1035 /* Set callee of call graph edge E and add it to the corresponding set of
1039 cgraph_set_edge_callee (struct cgraph_edge
*e
, struct cgraph_node
*n
)
1041 e
->prev_caller
= NULL
;
1043 n
->callers
->prev_caller
= e
;
1044 e
->next_caller
= n
->callers
;
1049 /* Turn edge E into speculative call calling N2. Update
1050 the profile so the direct call is taken COUNT times
1053 At clone materialization time, the indirect call E will
1056 if (call_dest == N2)
1061 At this time the function just creates the direct call,
1062 the referencd representing the if conditional and attaches
1063 them all to the orginal indirect call statement.
1065 Return direct edge created. */
1067 struct cgraph_edge
*
1068 cgraph_turn_edge_to_speculative (struct cgraph_edge
*e
,
1069 struct cgraph_node
*n2
,
1070 gcov_type direct_count
,
1071 int direct_frequency
)
1073 struct cgraph_node
*n
= e
->caller
;
1074 struct ipa_ref
*ref
;
1075 struct cgraph_edge
*e2
;
1079 fprintf (dump_file
, "Indirect call -> speculative call"
1080 " %s/%i => %s/%i\n",
1081 xstrdup (cgraph_node_name (n
)), n
->symbol
.order
,
1082 xstrdup (cgraph_node_name (n2
)), n2
->symbol
.order
);
1084 e
->speculative
= true;
1085 e2
= cgraph_create_edge (n
, n2
, e
->call_stmt
, direct_count
, direct_frequency
);
1086 initialize_inline_failed (e2
);
1087 e2
->speculative
= true;
1088 if (TREE_NOTHROW (n2
->symbol
.decl
))
1089 e2
->can_throw_external
= false;
1091 e2
->can_throw_external
= e
->can_throw_external
;
1092 e2
->lto_stmt_uid
= e
->lto_stmt_uid
;
1093 e
->count
-= e2
->count
;
1094 e
->frequency
-= e2
->frequency
;
1095 cgraph_call_edge_duplication_hooks (e
, e2
);
1096 ref
= ipa_record_reference ((symtab_node
)n
, (symtab_node
)n2
,
1097 IPA_REF_ADDR
, e
->call_stmt
);
1098 ref
->lto_stmt_uid
= e
->lto_stmt_uid
;
1099 ref
->speculative
= e
->speculative
;
1100 cgraph_mark_address_taken_node (n2
);
1104 /* Speculative call consist of three components:
1105 1) an indirect edge representing the original call
1106 2) an direct edge representing the new call
1107 3) ADDR_EXPR reference representing the speculative check.
1108 All three components are attached to single statement (the indirect
1109 call) and if one of them exists, all of them must exist.
1111 Given speculative call edge E, return all three components.
1115 cgraph_speculative_call_info (struct cgraph_edge
*e
,
1116 struct cgraph_edge
*&direct
,
1117 struct cgraph_edge
*&indirect
,
1118 struct ipa_ref
*&reference
)
1120 struct ipa_ref
*ref
;
1122 struct cgraph_edge
*e2
;
1124 if (!e
->indirect_unknown_callee
)
1125 for (e2
= e
->caller
->indirect_calls
;
1126 e2
->call_stmt
!= e
->call_stmt
|| e2
->lto_stmt_uid
!= e
->lto_stmt_uid
;
1127 e2
= e2
->next_callee
)
1132 /* We can take advantage of the call stmt hash. */
1135 e
= cgraph_edge (e
->caller
, e2
->call_stmt
);
1136 gcc_assert (e
->speculative
&& !e
->indirect_unknown_callee
);
1139 for (e
= e
->caller
->callees
;
1140 e2
->call_stmt
!= e
->call_stmt
1141 || e2
->lto_stmt_uid
!= e
->lto_stmt_uid
;
1145 gcc_assert (e
->speculative
&& e2
->speculative
);
1150 for (i
= 0; ipa_ref_list_reference_iterate (&e
->caller
->symbol
.ref_list
,
1152 if (ref
->speculative
1153 && ((ref
->stmt
&& ref
->stmt
== e
->call_stmt
)
1154 || (!ref
->stmt
&& ref
->lto_stmt_uid
== e
->lto_stmt_uid
)))
1160 /* Speculative edge always consist of all three components - direct edge,
1161 indirect and reference. */
1163 gcc_assert (e
&& e2
&& ref
);
1166 /* Redirect callee of E to N. The function does not update underlying
1170 cgraph_redirect_edge_callee (struct cgraph_edge
*e
, struct cgraph_node
*n
)
1172 /* Remove from callers list of the current callee. */
1173 cgraph_edge_remove_callee (e
);
1175 /* Insert to callers list of the new callee. */
1176 cgraph_set_edge_callee (e
, n
);
1179 /* Speculative call EDGE turned out to be direct call to CALLE_DECL.
1180 Remove the speculative call sequence and return edge representing the call.
1181 It is up to caller to redirect the call as appropriate. */
1183 struct cgraph_edge
*
1184 cgraph_resolve_speculation (struct cgraph_edge
*edge
, tree callee_decl
)
1186 struct cgraph_edge
*e2
;
1187 struct ipa_ref
*ref
;
1189 gcc_assert (edge
->speculative
);
1190 cgraph_speculative_call_info (edge
, e2
, edge
, ref
);
1191 if (ref
->referred
->symbol
.decl
!= callee_decl
)
1197 fprintf (dump_file
, "Speculative indirect call %s/%i => %s/%i has "
1198 "turned out to have contradicting known target ",
1199 xstrdup (cgraph_node_name (edge
->caller
)), edge
->caller
->symbol
.order
,
1200 xstrdup (cgraph_node_name (e2
->callee
)), e2
->callee
->symbol
.order
);
1201 print_generic_expr (dump_file
, callee_decl
, 0);
1202 fprintf (dump_file
, "\n");
1206 fprintf (dump_file
, "Removing speculative call %s/%i => %s/%i\n",
1207 xstrdup (cgraph_node_name (edge
->caller
)), edge
->caller
->symbol
.order
,
1208 xstrdup (cgraph_node_name (e2
->callee
)), e2
->callee
->symbol
.order
);
1214 struct cgraph_edge
*tmp
= edge
;
1216 fprintf (dump_file
, "Speculative call turned into direct call.\n");
1219 /* FIXME: If EDGE is inlined, we should scale up the frequencies and counts
1220 in the functions inlined through it. */
1222 edge
->count
+= e2
->count
;
1223 edge
->frequency
+= e2
->frequency
;
1224 if (edge
->frequency
> CGRAPH_FREQ_MAX
)
1225 edge
->frequency
= CGRAPH_FREQ_MAX
;
1226 edge
->speculative
= false;
1227 e2
->speculative
= false;
1228 ipa_remove_reference (ref
);
1229 if (e2
->indirect_unknown_callee
|| e2
->inline_failed
)
1230 cgraph_remove_edge (e2
);
1232 cgraph_remove_node_and_inline_clones (e2
->callee
, NULL
);
1233 if (edge
->caller
->call_site_hash
)
1234 cgraph_update_edge_in_call_site_hash (edge
);
1238 /* Make an indirect EDGE with an unknown callee an ordinary edge leading to
1239 CALLEE. DELTA is an integer constant that is to be added to the this
1240 pointer (first parameter) to compensate for skipping a thunk adjustment. */
1242 struct cgraph_edge
*
1243 cgraph_make_edge_direct (struct cgraph_edge
*edge
, struct cgraph_node
*callee
)
1245 gcc_assert (edge
->indirect_unknown_callee
);
1247 /* If we are redirecting speculative call, make it non-speculative. */
1248 if (edge
->indirect_unknown_callee
&& edge
->speculative
)
1250 edge
= cgraph_resolve_speculation (edge
, callee
->symbol
.decl
);
1252 /* On successful speculation just return the pre existing direct edge. */
1253 if (!edge
->indirect_unknown_callee
)
1257 edge
->indirect_unknown_callee
= 0;
1258 ggc_free (edge
->indirect_info
);
1259 edge
->indirect_info
= NULL
;
1261 /* Get the edge out of the indirect edge list. */
1262 if (edge
->prev_callee
)
1263 edge
->prev_callee
->next_callee
= edge
->next_callee
;
1264 if (edge
->next_callee
)
1265 edge
->next_callee
->prev_callee
= edge
->prev_callee
;
1266 if (!edge
->prev_callee
)
1267 edge
->caller
->indirect_calls
= edge
->next_callee
;
1269 /* Put it into the normal callee list */
1270 edge
->prev_callee
= NULL
;
1271 edge
->next_callee
= edge
->caller
->callees
;
1272 if (edge
->caller
->callees
)
1273 edge
->caller
->callees
->prev_callee
= edge
;
1274 edge
->caller
->callees
= edge
;
1276 /* Insert to callers list of the new callee. */
1277 cgraph_set_edge_callee (edge
, callee
);
1279 if (edge
->call_stmt
)
1280 edge
->call_stmt_cannot_inline_p
1281 = !gimple_check_call_matching_types (edge
->call_stmt
, callee
->symbol
.decl
,
1284 /* We need to re-determine the inlining status of the edge. */
1285 initialize_inline_failed (edge
);
1289 /* If necessary, change the function declaration in the call statement
1290 associated with E so that it corresponds to the edge callee. */
1293 cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge
*e
)
1295 tree decl
= gimple_call_fndecl (e
->call_stmt
);
1297 gimple_stmt_iterator gsi
;
1298 #ifdef ENABLE_CHECKING
1299 struct cgraph_node
*node
;
1304 struct cgraph_edge
*e2
;
1306 struct ipa_ref
*ref
;
1308 cgraph_speculative_call_info (e
, e
, e2
, ref
);
1309 /* If there already is an direct call (i.e. as a result of inliner's
1310 substitution), forget about speculating. */
1312 e
= cgraph_resolve_speculation (e
, decl
);
1313 /* If types do not match, speculation was likely wrong.
1314 The direct edge was posisbly redirected to the clone with a different
1315 signature. We did not update the call statement yet, so compare it
1316 with the reference that still points to the proper type. */
1317 else if (!gimple_check_call_matching_types (e
->call_stmt
,
1318 ref
->referred
->symbol
.decl
,
1322 fprintf (dump_file
, "Not expanding speculative call of %s/%i -> %s/%i\n"
1324 xstrdup (cgraph_node_name (e
->caller
)),
1325 e
->caller
->symbol
.order
,
1326 xstrdup (cgraph_node_name (e
->callee
)),
1327 e
->callee
->symbol
.order
);
1328 e
= cgraph_resolve_speculation (e
, NULL
);
1329 /* We are producing the final function body and will throw away the
1330 callgraph edges really soon. Reset the counts/frequencies to
1331 keep verifier happy in the case of roundoff errors. */
1332 e
->count
= gimple_bb (e
->call_stmt
)->count
;
1333 e
->frequency
= compute_call_stmt_bb_frequency
1334 (e
->caller
->symbol
.decl
, gimple_bb (e
->call_stmt
));
1336 /* Expand speculation into GIMPLE code. */
1341 "Expanding speculative call of %s/%i -> %s/%i count:"
1342 HOST_WIDEST_INT_PRINT_DEC
"\n",
1343 xstrdup (cgraph_node_name (e
->caller
)),
1344 e
->caller
->symbol
.order
,
1345 xstrdup (cgraph_node_name (e
->callee
)),
1346 e
->callee
->symbol
.order
,
1347 (HOST_WIDEST_INT
)e
->count
);
1348 gcc_assert (e2
->speculative
);
1349 push_cfun (DECL_STRUCT_FUNCTION (e
->caller
->symbol
.decl
));
1350 new_stmt
= gimple_ic (e
->call_stmt
, cgraph (ref
->referred
),
1351 e
->count
|| e2
->count
1352 ? RDIV (e
->count
* REG_BR_PROB_BASE
,
1353 e
->count
+ e2
->count
)
1354 : e
->frequency
|| e2
->frequency
1355 ? RDIV (e
->frequency
* REG_BR_PROB_BASE
,
1356 e
->frequency
+ e2
->frequency
)
1357 : REG_BR_PROB_BASE
/ 2,
1358 e
->count
, e
->count
+ e2
->count
);
1359 e
->speculative
= false;
1360 cgraph_set_call_stmt_including_clones (e
->caller
, e
->call_stmt
,
1362 e
->frequency
= compute_call_stmt_bb_frequency
1363 (e
->caller
->symbol
.decl
, gimple_bb (e
->call_stmt
));
1364 e2
->frequency
= compute_call_stmt_bb_frequency
1365 (e2
->caller
->symbol
.decl
, gimple_bb (e2
->call_stmt
));
1366 e2
->speculative
= false;
1367 ref
->speculative
= false;
1369 /* Indirect edges are not both in the call site hash.
1371 if (e
->caller
->call_site_hash
)
1372 cgraph_update_edge_in_call_site_hash (e2
);
1374 /* Continue redirecting E to proper target. */
1378 if (e
->indirect_unknown_callee
1379 || decl
== e
->callee
->symbol
.decl
)
1380 return e
->call_stmt
;
1382 #ifdef ENABLE_CHECKING
1385 node
= cgraph_get_node (decl
);
1386 gcc_assert (!node
|| !node
->clone
.combined_args_to_skip
);
1390 if (cgraph_dump_file
)
1392 fprintf (cgraph_dump_file
, "updating call of %s/%i -> %s/%i: ",
1393 xstrdup (cgraph_node_name (e
->caller
)), e
->caller
->symbol
.order
,
1394 xstrdup (cgraph_node_name (e
->callee
)), e
->callee
->symbol
.order
);
1395 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
1396 if (e
->callee
->clone
.combined_args_to_skip
)
1398 fprintf (cgraph_dump_file
, " combined args to skip: ");
1399 dump_bitmap (cgraph_dump_file
,
1400 e
->callee
->clone
.combined_args_to_skip
);
1404 if (e
->callee
->clone
.combined_args_to_skip
)
1409 = gimple_call_copy_skip_args (e
->call_stmt
,
1410 e
->callee
->clone
.combined_args_to_skip
);
1411 gimple_call_set_fndecl (new_stmt
, e
->callee
->symbol
.decl
);
1412 gimple_call_set_fntype (new_stmt
, gimple_call_fntype (e
->call_stmt
));
1414 if (gimple_vdef (new_stmt
)
1415 && TREE_CODE (gimple_vdef (new_stmt
)) == SSA_NAME
)
1416 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt
)) = new_stmt
;
1418 gsi
= gsi_for_stmt (e
->call_stmt
);
1419 gsi_replace (&gsi
, new_stmt
, false);
1420 /* We need to defer cleaning EH info on the new statement to
1421 fixup-cfg. We may not have dominator information at this point
1422 and thus would end up with unreachable blocks and have no way
1423 to communicate that we need to run CFG cleanup then. */
1424 lp_nr
= lookup_stmt_eh_lp (e
->call_stmt
);
1427 remove_stmt_from_eh_lp (e
->call_stmt
);
1428 add_stmt_to_eh_lp (new_stmt
, lp_nr
);
1433 new_stmt
= e
->call_stmt
;
1434 gimple_call_set_fndecl (new_stmt
, e
->callee
->symbol
.decl
);
1435 update_stmt (new_stmt
);
1438 cgraph_set_call_stmt_including_clones (e
->caller
, e
->call_stmt
, new_stmt
, false);
1440 if (cgraph_dump_file
)
1442 fprintf (cgraph_dump_file
, " updated to:");
1443 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
1448 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1449 OLD_STMT changed into NEW_STMT. OLD_CALL is gimple_call_fndecl
1450 of OLD_STMT if it was previously call statement.
1451 If NEW_STMT is NULL, the call has been dropped without any
1455 cgraph_update_edges_for_call_stmt_node (struct cgraph_node
*node
,
1456 gimple old_stmt
, tree old_call
,
1459 tree new_call
= (new_stmt
&& is_gimple_call (new_stmt
))
1460 ? gimple_call_fndecl (new_stmt
) : 0;
1462 /* We are seeing indirect calls, then there is nothing to update. */
1463 if (!new_call
&& !old_call
)
1465 /* See if we turned indirect call into direct call or folded call to one builtin
1466 into different builtin. */
1467 if (old_call
!= new_call
)
1469 struct cgraph_edge
*e
= cgraph_edge (node
, old_stmt
);
1470 struct cgraph_edge
*ne
= NULL
;
1476 /* See if the edge is already there and has the correct callee. It
1477 might be so because of indirect inlining has already updated
1478 it. We also might've cloned and redirected the edge. */
1479 if (new_call
&& e
->callee
)
1481 struct cgraph_node
*callee
= e
->callee
;
1484 if (callee
->symbol
.decl
== new_call
1485 || callee
->former_clone_of
== new_call
)
1487 callee
= callee
->clone_of
;
1491 /* Otherwise remove edge and create new one; we can't simply redirect
1492 since function has changed, so inline plan and other information
1493 attached to edge is invalid. */
1495 frequency
= e
->frequency
;
1496 cgraph_remove_edge (e
);
1500 /* We are seeing new direct call; compute profile info based on BB. */
1501 basic_block bb
= gimple_bb (new_stmt
);
1503 frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
1509 ne
= cgraph_create_edge (node
, cgraph_get_create_node (new_call
),
1510 new_stmt
, count
, frequency
);
1511 gcc_assert (ne
->inline_failed
);
1514 /* We only updated the call stmt; update pointer in cgraph edge.. */
1515 else if (old_stmt
!= new_stmt
)
1516 cgraph_set_call_stmt (cgraph_edge (node
, old_stmt
), new_stmt
);
1519 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1520 OLD_STMT changed into NEW_STMT. OLD_DECL is gimple_call_fndecl
1521 of OLD_STMT before it was updated (updating can happen inplace). */
1524 cgraph_update_edges_for_call_stmt (gimple old_stmt
, tree old_decl
, gimple new_stmt
)
1526 struct cgraph_node
*orig
= cgraph_get_node (cfun
->decl
);
1527 struct cgraph_node
*node
;
1529 gcc_checking_assert (orig
);
1530 cgraph_update_edges_for_call_stmt_node (orig
, old_stmt
, old_decl
, new_stmt
);
1532 for (node
= orig
->clones
; node
!= orig
;)
1534 cgraph_update_edges_for_call_stmt_node (node
, old_stmt
, old_decl
, new_stmt
);
1536 node
= node
->clones
;
1537 else if (node
->next_sibling_clone
)
1538 node
= node
->next_sibling_clone
;
1541 while (node
!= orig
&& !node
->next_sibling_clone
)
1542 node
= node
->clone_of
;
1544 node
= node
->next_sibling_clone
;
1550 /* Remove all callees from the node. */
1553 cgraph_node_remove_callees (struct cgraph_node
*node
)
1555 struct cgraph_edge
*e
, *f
;
1557 /* It is sufficient to remove the edges from the lists of callers of
1558 the callees. The callee list of the node can be zapped with one
1560 for (e
= node
->callees
; e
; e
= f
)
1563 cgraph_call_edge_removal_hooks (e
);
1564 if (!e
->indirect_unknown_callee
)
1565 cgraph_edge_remove_callee (e
);
1566 cgraph_free_edge (e
);
1568 for (e
= node
->indirect_calls
; e
; e
= f
)
1571 cgraph_call_edge_removal_hooks (e
);
1572 if (!e
->indirect_unknown_callee
)
1573 cgraph_edge_remove_callee (e
);
1574 cgraph_free_edge (e
);
1576 node
->indirect_calls
= NULL
;
1577 node
->callees
= NULL
;
1578 if (node
->call_site_hash
)
1580 htab_delete (node
->call_site_hash
);
1581 node
->call_site_hash
= NULL
;
1585 /* Remove all callers from the node. */
1588 cgraph_node_remove_callers (struct cgraph_node
*node
)
1590 struct cgraph_edge
*e
, *f
;
1592 /* It is sufficient to remove the edges from the lists of callees of
1593 the callers. The caller list of the node can be zapped with one
1595 for (e
= node
->callers
; e
; e
= f
)
1598 cgraph_call_edge_removal_hooks (e
);
1599 cgraph_edge_remove_caller (e
);
1600 cgraph_free_edge (e
);
1602 node
->callers
= NULL
;
1605 /* Helper function for cgraph_release_function_body and free_lang_data.
1606 It releases body from function DECL without having to inspect its
1607 possibly non-existent symtab node. */
1610 release_function_body (tree decl
)
1612 if (DECL_STRUCT_FUNCTION (decl
))
1614 push_cfun (DECL_STRUCT_FUNCTION (decl
));
1618 cfun
->curr_properties
&= ~PROP_loops
;
1619 loop_optimizer_finalize ();
1621 if (cfun
->gimple_df
)
1624 delete_tree_cfg_annotations ();
1629 gcc_assert (dom_computed
[0] == DOM_NONE
);
1630 gcc_assert (dom_computed
[1] == DOM_NONE
);
1634 if (cfun
->value_histograms
)
1637 gimple_set_body (decl
, NULL
);
1638 /* Struct function hangs a lot of data that would leak if we didn't
1639 removed all pointers to it. */
1640 ggc_free (DECL_STRUCT_FUNCTION (decl
));
1641 DECL_STRUCT_FUNCTION (decl
) = NULL
;
1643 DECL_SAVED_TREE (decl
) = NULL
;
1646 /* Release memory used to represent body of function NODE.
1647 Use this only for functions that are released before being translated to
1648 target code (i.e. RTL). Functions that are compiled to RTL and beyond
1649 are free'd in final.c via free_after_compilation(). */
1652 cgraph_release_function_body (struct cgraph_node
*node
)
1654 node
->ipa_transforms_to_apply
.release ();
1655 if (!node
->used_as_abstract_origin
&& cgraph_state
!= CGRAPH_STATE_PARSING
)
1657 DECL_RESULT (node
->symbol
.decl
) = NULL
;
1658 DECL_ARGUMENTS (node
->symbol
.decl
) = NULL
;
1660 /* If the node is abstract and needed, then do not clear DECL_INITIAL
1661 of its associated function function declaration because it's
1662 needed to emit debug info later. */
1663 if (!node
->used_as_abstract_origin
&& DECL_INITIAL (node
->symbol
.decl
))
1664 DECL_INITIAL (node
->symbol
.decl
) = error_mark_node
;
1665 release_function_body (node
->symbol
.decl
);
1666 if (node
->symbol
.lto_file_data
)
1667 lto_free_function_in_decl_state_for_node ((symtab_node
) node
);
1670 /* Remove the node from cgraph. */
1673 cgraph_remove_node (struct cgraph_node
*node
)
1675 struct cgraph_node
*n
;
1676 int uid
= node
->uid
;
1678 cgraph_call_node_removal_hooks (node
);
1679 cgraph_node_remove_callers (node
);
1680 cgraph_node_remove_callees (node
);
1681 node
->ipa_transforms_to_apply
.release ();
1683 /* Incremental inlining access removed nodes stored in the postorder list.
1685 node
->symbol
.force_output
= false;
1686 node
->symbol
.forced_by_abi
= false;
1687 for (n
= node
->nested
; n
; n
= n
->next_nested
)
1689 node
->nested
= NULL
;
1692 struct cgraph_node
**node2
= &node
->origin
->nested
;
1694 while (*node2
!= node
)
1695 node2
= &(*node2
)->next_nested
;
1696 *node2
= node
->next_nested
;
1698 symtab_unregister_node ((symtab_node
)node
);
1699 if (node
->prev_sibling_clone
)
1700 node
->prev_sibling_clone
->next_sibling_clone
= node
->next_sibling_clone
;
1701 else if (node
->clone_of
)
1702 node
->clone_of
->clones
= node
->next_sibling_clone
;
1703 if (node
->next_sibling_clone
)
1704 node
->next_sibling_clone
->prev_sibling_clone
= node
->prev_sibling_clone
;
1707 struct cgraph_node
*n
, *next
;
1711 for (n
= node
->clones
; n
->next_sibling_clone
; n
= n
->next_sibling_clone
)
1712 n
->clone_of
= node
->clone_of
;
1713 n
->clone_of
= node
->clone_of
;
1714 n
->next_sibling_clone
= node
->clone_of
->clones
;
1715 if (node
->clone_of
->clones
)
1716 node
->clone_of
->clones
->prev_sibling_clone
= n
;
1717 node
->clone_of
->clones
= node
->clones
;
1721 /* We are removing node with clones. This makes clones inconsistent,
1722 but assume they will be removed subsequently and just keep clone
1723 tree intact. This can happen in unreachable function removal since
1724 we remove unreachable functions in random order, not by bottom-up
1725 walk of clone trees. */
1726 for (n
= node
->clones
; n
; n
= next
)
1728 next
= n
->next_sibling_clone
;
1729 n
->next_sibling_clone
= NULL
;
1730 n
->prev_sibling_clone
= NULL
;
1736 /* While all the clones are removed after being proceeded, the function
1737 itself is kept in the cgraph even after it is compiled. Check whether
1738 we are done with this body and reclaim it proactively if this is the case.
1740 if (cgraph_state
!= CGRAPH_LTO_STREAMING
)
1742 n
= cgraph_get_node (node
->symbol
.decl
);
1744 || (!n
->clones
&& !n
->clone_of
&& !n
->global
.inlined_to
1745 && (cgraph_global_info_ready
1746 && (TREE_ASM_WRITTEN (n
->symbol
.decl
)
1747 || DECL_EXTERNAL (n
->symbol
.decl
)
1748 || !n
->symbol
.analyzed
1749 || (!flag_wpa
&& n
->symbol
.in_other_partition
)))))
1750 cgraph_release_function_body (node
);
1753 node
->symbol
.decl
= NULL
;
1754 if (node
->call_site_hash
)
1756 htab_delete (node
->call_site_hash
);
1757 node
->call_site_hash
= NULL
;
1761 /* Clear out the node to NULL all pointers and add the node to the free
1763 memset (node
, 0, sizeof(*node
));
1764 node
->symbol
.type
= SYMTAB_FUNCTION
;
1766 SET_NEXT_FREE_NODE (node
, free_nodes
);
1770 /* Likewise indicate that a node is having address taken. */
1773 cgraph_mark_address_taken_node (struct cgraph_node
*node
)
1775 /* Indirect inlining can figure out that all uses of the address are
1777 if (node
->global
.inlined_to
)
1779 gcc_assert (cfun
->after_inlining
);
1780 gcc_assert (node
->callers
->indirect_inlining_edge
);
1783 /* FIXME: address_taken flag is used both as a shortcut for testing whether
1784 IPA_REF_ADDR reference exists (and thus it should be set on node
1785 representing alias we take address of) and as a test whether address
1786 of the object was taken (and thus it should be set on node alias is
1787 referring to). We should remove the first use and the remove the
1789 node
->symbol
.address_taken
= 1;
1790 node
= cgraph_function_or_thunk_node (node
, NULL
);
1791 node
->symbol
.address_taken
= 1;
1794 /* Return local info for the compiled function. */
1796 struct cgraph_local_info
*
1797 cgraph_local_info (tree decl
)
1799 struct cgraph_node
*node
;
1801 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1802 node
= cgraph_get_node (decl
);
1805 return &node
->local
;
1808 /* Return local info for the compiled function. */
1810 struct cgraph_global_info
*
1811 cgraph_global_info (tree decl
)
1813 struct cgraph_node
*node
;
1815 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
&& cgraph_global_info_ready
);
1816 node
= cgraph_get_node (decl
);
1819 return &node
->global
;
1822 /* Return local info for the compiled function. */
1824 struct cgraph_rtl_info
*
1825 cgraph_rtl_info (tree decl
)
1827 struct cgraph_node
*node
;
1829 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1830 node
= cgraph_get_node (decl
);
1832 || (decl
!= current_function_decl
1833 && !TREE_ASM_WRITTEN (node
->symbol
.decl
)))
1838 /* Return a string describing the failure REASON. */
1841 cgraph_inline_failed_string (cgraph_inline_failed_t reason
)
1844 #define DEFCIFCODE(code, string) string,
1846 static const char *cif_string_table
[CIF_N_REASONS
] = {
1847 #include "cif-code.def"
1850 /* Signedness of an enum type is implementation defined, so cast it
1851 to unsigned before testing. */
1852 gcc_assert ((unsigned) reason
< CIF_N_REASONS
);
1853 return cif_string_table
[reason
];
1856 /* Names used to print out the availability enum. */
1857 const char * const cgraph_availability_names
[] =
1858 {"unset", "not_available", "overwritable", "available", "local"};
1861 /* Dump call graph node NODE to file F. */
1864 dump_cgraph_node (FILE *f
, struct cgraph_node
*node
)
1866 struct cgraph_edge
*edge
;
1867 int indirect_calls_count
= 0;
1869 dump_symtab_base (f
, (symtab_node
) node
);
1871 if (node
->global
.inlined_to
)
1872 fprintf (f
, " Function %s/%i is inline copy in %s/%i\n",
1873 xstrdup (cgraph_node_name (node
)),
1875 xstrdup (cgraph_node_name (node
->global
.inlined_to
)),
1876 node
->global
.inlined_to
->symbol
.order
);
1878 fprintf (f
, " Clone of %s/%i\n",
1879 cgraph_node_asm_name (node
->clone_of
),
1880 node
->clone_of
->symbol
.order
);
1881 if (cgraph_function_flags_ready
)
1882 fprintf (f
, " Availability: %s\n",
1883 cgraph_availability_names
[cgraph_function_body_availability (node
)]);
1885 if (node
->profile_id
)
1886 fprintf (f
, " Profile id: %i\n",
1888 fprintf (f
, " Function flags:");
1890 fprintf (f
, " executed "HOST_WIDEST_INT_PRINT_DEC
"x",
1891 (HOST_WIDEST_INT
)node
->count
);
1893 fprintf (f
, " nested in: %s", cgraph_node_asm_name (node
->origin
));
1894 if (gimple_has_body_p (node
->symbol
.decl
))
1895 fprintf (f
, " body");
1897 fprintf (f
, " process");
1898 if (node
->local
.local
)
1899 fprintf (f
, " local");
1900 if (node
->local
.redefined_extern_inline
)
1901 fprintf (f
, " redefined_extern_inline");
1902 if (node
->only_called_at_startup
)
1903 fprintf (f
, " only_called_at_startup");
1904 if (node
->only_called_at_exit
)
1905 fprintf (f
, " only_called_at_exit");
1907 fprintf (f
, " tm_clone");
1911 if (node
->thunk
.thunk_p
)
1913 fprintf (f
, " Thunk");
1914 if (node
->thunk
.alias
)
1915 fprintf (f
, " of %s (asm: %s)",
1916 lang_hooks
.decl_printable_name (node
->thunk
.alias
, 2),
1917 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (node
->thunk
.alias
)));
1918 fprintf (f
, " fixed offset %i virtual value %i has "
1919 "virtual offset %i)\n",
1920 (int)node
->thunk
.fixed_offset
,
1921 (int)node
->thunk
.virtual_value
,
1922 (int)node
->thunk
.virtual_offset_p
);
1924 if (node
->symbol
.alias
&& node
->thunk
.alias
1925 && DECL_P (node
->thunk
.alias
))
1927 fprintf (f
, " Alias of %s",
1928 lang_hooks
.decl_printable_name (node
->thunk
.alias
, 2));
1929 if (DECL_ASSEMBLER_NAME_SET_P (node
->thunk
.alias
))
1930 fprintf (f
, " (asm: %s)",
1931 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (node
->thunk
.alias
)));
1935 fprintf (f
, " Called by: ");
1937 for (edge
= node
->callers
; edge
; edge
= edge
->next_caller
)
1939 fprintf (f
, "%s/%i ", cgraph_node_asm_name (edge
->caller
),
1940 edge
->caller
->symbol
.order
);
1942 fprintf (f
, "("HOST_WIDEST_INT_PRINT_DEC
"x) ",
1943 (HOST_WIDEST_INT
)edge
->count
);
1944 if (edge
->frequency
)
1945 fprintf (f
, "(%.2f per call) ",
1946 edge
->frequency
/ (double)CGRAPH_FREQ_BASE
);
1947 if (edge
->speculative
)
1948 fprintf(f
, "(speculative) ");
1949 if (!edge
->inline_failed
)
1950 fprintf(f
, "(inlined) ");
1951 if (edge
->indirect_inlining_edge
)
1952 fprintf(f
, "(indirect_inlining) ");
1953 if (edge
->can_throw_external
)
1954 fprintf(f
, "(can throw external) ");
1957 fprintf (f
, "\n Calls: ");
1958 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
1960 fprintf (f
, "%s/%i ", cgraph_node_asm_name (edge
->callee
),
1961 edge
->callee
->symbol
.order
);
1962 if (edge
->speculative
)
1963 fprintf(f
, "(speculative) ");
1964 if (!edge
->inline_failed
)
1965 fprintf(f
, "(inlined) ");
1966 if (edge
->indirect_inlining_edge
)
1967 fprintf(f
, "(indirect_inlining) ");
1969 fprintf (f
, "("HOST_WIDEST_INT_PRINT_DEC
"x) ",
1970 (HOST_WIDEST_INT
)edge
->count
);
1971 if (edge
->frequency
)
1972 fprintf (f
, "(%.2f per call) ",
1973 edge
->frequency
/ (double)CGRAPH_FREQ_BASE
);
1974 if (edge
->can_throw_external
)
1975 fprintf(f
, "(can throw external) ");
1979 for (edge
= node
->indirect_calls
; edge
; edge
= edge
->next_callee
)
1980 indirect_calls_count
++;
1981 if (indirect_calls_count
)
1982 fprintf (f
, " Has %i outgoing edges for indirect calls.\n",
1983 indirect_calls_count
);
1987 /* Dump call graph node NODE to stderr. */
1990 debug_cgraph_node (struct cgraph_node
*node
)
1992 dump_cgraph_node (stderr
, node
);
1996 /* Dump the callgraph to file F. */
1999 dump_cgraph (FILE *f
)
2001 struct cgraph_node
*node
;
2003 fprintf (f
, "callgraph:\n\n");
2004 FOR_EACH_FUNCTION (node
)
2005 dump_cgraph_node (f
, node
);
2009 /* Dump the call graph to stderr. */
2014 dump_cgraph (stderr
);
2017 /* Return true when the DECL can possibly be inlined. */
2019 cgraph_function_possibly_inlined_p (tree decl
)
2021 if (!cgraph_global_info_ready
)
2022 return !DECL_UNINLINABLE (decl
);
2023 return DECL_POSSIBLY_INLINED (decl
);
2026 /* NODE is no longer nested function; update cgraph accordingly. */
2028 cgraph_unnest_node (struct cgraph_node
*node
)
2030 struct cgraph_node
**node2
= &node
->origin
->nested
;
2031 gcc_assert (node
->origin
);
2033 while (*node2
!= node
)
2034 node2
= &(*node2
)->next_nested
;
2035 *node2
= node
->next_nested
;
2036 node
->origin
= NULL
;
2039 /* Return function availability. See cgraph.h for description of individual
2042 cgraph_function_body_availability (struct cgraph_node
*node
)
2044 enum availability avail
;
2045 if (!node
->symbol
.analyzed
)
2046 avail
= AVAIL_NOT_AVAILABLE
;
2047 else if (node
->local
.local
)
2048 avail
= AVAIL_LOCAL
;
2049 else if (node
->symbol
.alias
&& node
->symbol
.weakref
)
2050 cgraph_function_or_thunk_node (node
, &avail
);
2051 else if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (node
->symbol
.decl
)))
2052 avail
= AVAIL_OVERWRITABLE
;
2053 else if (!node
->symbol
.externally_visible
)
2054 avail
= AVAIL_AVAILABLE
;
2055 /* Inline functions are safe to be analyzed even if their symbol can
2056 be overwritten at runtime. It is not meaningful to enforce any sane
2057 behaviour on replacing inline function by different body. */
2058 else if (DECL_DECLARED_INLINE_P (node
->symbol
.decl
))
2059 avail
= AVAIL_AVAILABLE
;
2061 /* If the function can be overwritten, return OVERWRITABLE. Take
2062 care at least of two notable extensions - the COMDAT functions
2063 used to share template instantiations in C++ (this is symmetric
2064 to code cp_cannot_inline_tree_fn and probably shall be shared and
2065 the inlinability hooks completely eliminated).
2067 ??? Does the C++ one definition rule allow us to always return
2068 AVAIL_AVAILABLE here? That would be good reason to preserve this
2071 else if (decl_replaceable_p (node
->symbol
.decl
)
2072 && !DECL_EXTERNAL (node
->symbol
.decl
))
2073 avail
= AVAIL_OVERWRITABLE
;
2074 else avail
= AVAIL_AVAILABLE
;
2079 /* Worker for cgraph_node_can_be_local_p. */
2081 cgraph_node_cannot_be_local_p_1 (struct cgraph_node
*node
,
2082 void *data ATTRIBUTE_UNUSED
)
2084 return !(!node
->symbol
.force_output
2085 && ((DECL_COMDAT (node
->symbol
.decl
)
2086 && !node
->symbol
.forced_by_abi
2087 && !symtab_used_from_object_file_p ((symtab_node
) node
)
2088 && !node
->symbol
.same_comdat_group
)
2089 || !node
->symbol
.externally_visible
));
2092 /* Return true if NODE can be made local for API change.
2093 Extern inline functions and C++ COMDAT functions can be made local
2094 at the expense of possible code size growth if function is used in multiple
2095 compilation units. */
2097 cgraph_node_can_be_local_p (struct cgraph_node
*node
)
2099 return (!node
->symbol
.address_taken
2100 && !cgraph_for_node_and_aliases (node
,
2101 cgraph_node_cannot_be_local_p_1
,
2105 /* Call calback on NODE, thunks and aliases associated to NODE.
2106 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
2110 cgraph_for_node_thunks_and_aliases (struct cgraph_node
*node
,
2111 bool (*callback
) (struct cgraph_node
*, void *),
2113 bool include_overwritable
)
2115 struct cgraph_edge
*e
;
2117 struct ipa_ref
*ref
;
2119 if (callback (node
, data
))
2121 for (e
= node
->callers
; e
; e
= e
->next_caller
)
2122 if (e
->caller
->thunk
.thunk_p
2123 && (include_overwritable
2124 || cgraph_function_body_availability (e
->caller
) > AVAIL_OVERWRITABLE
))
2125 if (cgraph_for_node_thunks_and_aliases (e
->caller
, callback
, data
,
2126 include_overwritable
))
2128 for (i
= 0; ipa_ref_list_referring_iterate (&node
->symbol
.ref_list
, i
, ref
); i
++)
2129 if (ref
->use
== IPA_REF_ALIAS
)
2131 struct cgraph_node
*alias
= ipa_ref_referring_node (ref
);
2132 if (include_overwritable
2133 || cgraph_function_body_availability (alias
) > AVAIL_OVERWRITABLE
)
2134 if (cgraph_for_node_thunks_and_aliases (alias
, callback
, data
,
2135 include_overwritable
))
2141 /* Call calback on NODE and aliases associated to NODE.
2142 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
2146 cgraph_for_node_and_aliases (struct cgraph_node
*node
,
2147 bool (*callback
) (struct cgraph_node
*, void *),
2149 bool include_overwritable
)
2152 struct ipa_ref
*ref
;
2154 if (callback (node
, data
))
2156 for (i
= 0; ipa_ref_list_referring_iterate (&node
->symbol
.ref_list
, i
, ref
); i
++)
2157 if (ref
->use
== IPA_REF_ALIAS
)
2159 struct cgraph_node
*alias
= ipa_ref_referring_node (ref
);
2160 if (include_overwritable
2161 || cgraph_function_body_availability (alias
) > AVAIL_OVERWRITABLE
)
2162 if (cgraph_for_node_and_aliases (alias
, callback
, data
,
2163 include_overwritable
))
2169 /* Worker to bring NODE local. */
2172 cgraph_make_node_local_1 (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
2174 gcc_checking_assert (cgraph_node_can_be_local_p (node
));
2175 if (DECL_COMDAT (node
->symbol
.decl
) || DECL_EXTERNAL (node
->symbol
.decl
))
2177 symtab_make_decl_local (node
->symbol
.decl
);
2179 node
->symbol
.externally_visible
= false;
2180 node
->symbol
.forced_by_abi
= false;
2181 node
->local
.local
= true;
2182 node
->symbol
.unique_name
= (node
->symbol
.resolution
== LDPR_PREVAILING_DEF_IRONLY
2183 || node
->symbol
.resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
);
2184 node
->symbol
.resolution
= LDPR_PREVAILING_DEF_IRONLY
;
2185 gcc_assert (cgraph_function_body_availability (node
) == AVAIL_LOCAL
);
2190 /* Bring NODE local. */
2193 cgraph_make_node_local (struct cgraph_node
*node
)
2195 cgraph_for_node_thunks_and_aliases (node
, cgraph_make_node_local_1
,
2199 /* Worker to set nothrow flag. */
2202 cgraph_set_nothrow_flag_1 (struct cgraph_node
*node
, void *data
)
2204 struct cgraph_edge
*e
;
2206 TREE_NOTHROW (node
->symbol
.decl
) = data
!= NULL
;
2209 for (e
= node
->callers
; e
; e
= e
->next_caller
)
2210 e
->can_throw_external
= false;
2214 /* Set TREE_NOTHROW on NODE's decl and on aliases of NODE
2215 if any to NOTHROW. */
2218 cgraph_set_nothrow_flag (struct cgraph_node
*node
, bool nothrow
)
2220 cgraph_for_node_thunks_and_aliases (node
, cgraph_set_nothrow_flag_1
,
2221 (void *)(size_t)nothrow
, false);
2224 /* Worker to set const flag. */
2227 cgraph_set_const_flag_1 (struct cgraph_node
*node
, void *data
)
2229 /* Static constructors and destructors without a side effect can be
2231 if (data
&& !((size_t)data
& 2))
2233 if (DECL_STATIC_CONSTRUCTOR (node
->symbol
.decl
))
2234 DECL_STATIC_CONSTRUCTOR (node
->symbol
.decl
) = 0;
2235 if (DECL_STATIC_DESTRUCTOR (node
->symbol
.decl
))
2236 DECL_STATIC_DESTRUCTOR (node
->symbol
.decl
) = 0;
2238 TREE_READONLY (node
->symbol
.decl
) = data
!= NULL
;
2239 DECL_LOOPING_CONST_OR_PURE_P (node
->symbol
.decl
) = ((size_t)data
& 2) != 0;
2243 /* Set TREE_READONLY on NODE's decl and on aliases of NODE
2244 if any to READONLY. */
2247 cgraph_set_const_flag (struct cgraph_node
*node
, bool readonly
, bool looping
)
2249 cgraph_for_node_thunks_and_aliases (node
, cgraph_set_const_flag_1
,
2250 (void *)(size_t)(readonly
+ (int)looping
* 2),
2254 /* Worker to set pure flag. */
2257 cgraph_set_pure_flag_1 (struct cgraph_node
*node
, void *data
)
2259 /* Static constructors and destructors without a side effect can be
2261 if (data
&& !((size_t)data
& 2))
2263 if (DECL_STATIC_CONSTRUCTOR (node
->symbol
.decl
))
2264 DECL_STATIC_CONSTRUCTOR (node
->symbol
.decl
) = 0;
2265 if (DECL_STATIC_DESTRUCTOR (node
->symbol
.decl
))
2266 DECL_STATIC_DESTRUCTOR (node
->symbol
.decl
) = 0;
2268 DECL_PURE_P (node
->symbol
.decl
) = data
!= NULL
;
2269 DECL_LOOPING_CONST_OR_PURE_P (node
->symbol
.decl
) = ((size_t)data
& 2) != 0;
2273 /* Set DECL_PURE_P on NODE's decl and on aliases of NODE
2277 cgraph_set_pure_flag (struct cgraph_node
*node
, bool pure
, bool looping
)
2279 cgraph_for_node_thunks_and_aliases (node
, cgraph_set_pure_flag_1
,
2280 (void *)(size_t)(pure
+ (int)looping
* 2),
2284 /* Return true when NODE can not return or throw and thus
2285 it is safe to ignore its side effects for IPA analysis. */
2288 cgraph_node_cannot_return (struct cgraph_node
*node
)
2290 int flags
= flags_from_decl_or_type (node
->symbol
.decl
);
2291 if (!flag_exceptions
)
2292 return (flags
& ECF_NORETURN
) != 0;
2294 return ((flags
& (ECF_NORETURN
| ECF_NOTHROW
))
2295 == (ECF_NORETURN
| ECF_NOTHROW
));
2298 /* Return true when call of E can not lead to return from caller
2299 and thus it is safe to ignore its side effects for IPA analysis
2300 when computing side effects of the caller.
2301 FIXME: We could actually mark all edges that have no reaching
2302 patch to EXIT_BLOCK_PTR or throw to get better results. */
2304 cgraph_edge_cannot_lead_to_return (struct cgraph_edge
*e
)
2306 if (cgraph_node_cannot_return (e
->caller
))
2308 if (e
->indirect_unknown_callee
)
2310 int flags
= e
->indirect_info
->ecf_flags
;
2311 if (!flag_exceptions
)
2312 return (flags
& ECF_NORETURN
) != 0;
2314 return ((flags
& (ECF_NORETURN
| ECF_NOTHROW
))
2315 == (ECF_NORETURN
| ECF_NOTHROW
));
2318 return cgraph_node_cannot_return (e
->callee
);
2321 /* Return true when function NODE can be removed from callgraph
2322 if all direct calls are eliminated. */
2325 cgraph_can_remove_if_no_direct_calls_and_refs_p (struct cgraph_node
*node
)
2327 gcc_assert (!node
->global
.inlined_to
);
2328 /* Extern inlines can always go, we will use the external definition. */
2329 if (DECL_EXTERNAL (node
->symbol
.decl
))
2331 /* When function is needed, we can not remove it. */
2332 if (node
->symbol
.force_output
|| node
->symbol
.used_from_other_partition
)
2334 if (DECL_STATIC_CONSTRUCTOR (node
->symbol
.decl
)
2335 || DECL_STATIC_DESTRUCTOR (node
->symbol
.decl
))
2337 /* Only COMDAT functions can be removed if externally visible. */
2338 if (node
->symbol
.externally_visible
2339 && (!DECL_COMDAT (node
->symbol
.decl
)
2340 || node
->symbol
.forced_by_abi
2341 || symtab_used_from_object_file_p ((symtab_node
) node
)))
2346 /* Worker for cgraph_can_remove_if_no_direct_calls_p. */
2349 nonremovable_p (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
2351 return !cgraph_can_remove_if_no_direct_calls_and_refs_p (node
);
2354 /* Return true when function NODE and its aliases can be removed from callgraph
2355 if all direct calls are eliminated. */
2358 cgraph_can_remove_if_no_direct_calls_p (struct cgraph_node
*node
)
2360 /* Extern inlines can always go, we will use the external definition. */
2361 if (DECL_EXTERNAL (node
->symbol
.decl
))
2363 if (node
->symbol
.address_taken
)
2365 return !cgraph_for_node_and_aliases (node
, nonremovable_p
, NULL
, true);
2368 /* Worker for cgraph_can_remove_if_no_direct_calls_p. */
2371 used_from_object_file_p (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
2373 return symtab_used_from_object_file_p ((symtab_node
) node
);
2376 /* Return true when function NODE can be expected to be removed
2377 from program when direct calls in this compilation unit are removed.
2379 As a special case COMDAT functions are
2380 cgraph_can_remove_if_no_direct_calls_p while the are not
2381 cgraph_only_called_directly_p (it is possible they are called from other
2384 This function behaves as cgraph_only_called_directly_p because eliminating
2385 all uses of COMDAT function does not make it necessarily disappear from
2386 the program unless we are compiling whole program or we do LTO. In this
2387 case we know we win since dynamic linking will not really discard the
2388 linkonce section. */
2391 cgraph_will_be_removed_from_program_if_no_direct_calls (struct cgraph_node
*node
)
2393 gcc_assert (!node
->global
.inlined_to
);
2394 if (cgraph_for_node_and_aliases (node
, used_from_object_file_p
, NULL
, true))
2396 if (!in_lto_p
&& !flag_whole_program
)
2397 return cgraph_only_called_directly_p (node
);
2400 if (DECL_EXTERNAL (node
->symbol
.decl
))
2402 return cgraph_can_remove_if_no_direct_calls_p (node
);
2407 /* Worker for cgraph_only_called_directly_p. */
2410 cgraph_not_only_called_directly_p_1 (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
2412 return !cgraph_only_called_directly_or_aliased_p (node
);
2415 /* Return true when function NODE and all its aliases are only called
2417 i.e. it is not externally visible, address was not taken and
2418 it is not used in any other non-standard way. */
2421 cgraph_only_called_directly_p (struct cgraph_node
*node
)
2423 gcc_assert (cgraph_function_or_thunk_node (node
, NULL
) == node
);
2424 return !cgraph_for_node_and_aliases (node
, cgraph_not_only_called_directly_p_1
,
2429 /* Collect all callers of NODE. Worker for collect_callers_of_node. */
2432 collect_callers_of_node_1 (struct cgraph_node
*node
, void *data
)
2434 vec
<cgraph_edge_p
> *redirect_callers
= (vec
<cgraph_edge_p
> *)data
;
2435 struct cgraph_edge
*cs
;
2436 enum availability avail
;
2437 cgraph_function_or_thunk_node (node
, &avail
);
2439 if (avail
> AVAIL_OVERWRITABLE
)
2440 for (cs
= node
->callers
; cs
!= NULL
; cs
= cs
->next_caller
)
2441 if (!cs
->indirect_inlining_edge
)
2442 redirect_callers
->safe_push (cs
);
2446 /* Collect all callers of NODE and its aliases that are known to lead to NODE
2447 (i.e. are not overwritable). */
2450 collect_callers_of_node (struct cgraph_node
*node
)
2452 vec
<cgraph_edge_p
> redirect_callers
= vNULL
;
2453 cgraph_for_node_and_aliases (node
, collect_callers_of_node_1
,
2454 &redirect_callers
, false);
2455 return redirect_callers
;
2458 /* Return TRUE if NODE2 is equivalent to NODE or its clone. */
2460 clone_of_p (struct cgraph_node
*node
, struct cgraph_node
*node2
)
2462 node
= cgraph_function_or_thunk_node (node
, NULL
);
2463 node2
= cgraph_function_or_thunk_node (node2
, NULL
);
2464 while (node
!= node2
&& node2
)
2465 node2
= node2
->clone_of
;
2466 return node2
!= NULL
;
2469 /* Verify edge E count and frequency. */
2472 verify_edge_count_and_frequency (struct cgraph_edge
*e
)
2474 bool error_found
= false;
2477 error ("caller edge count is negative");
2480 if (e
->frequency
< 0)
2482 error ("caller edge frequency is negative");
2485 if (e
->frequency
> CGRAPH_FREQ_MAX
)
2487 error ("caller edge frequency is too large");
2490 if (gimple_has_body_p (e
->caller
->symbol
.decl
)
2491 && !e
->caller
->global
.inlined_to
2493 /* FIXME: Inline-analysis sets frequency to 0 when edge is optimized out.
2494 Remove this once edges are actually removed from the function at that time. */
2496 || (inline_edge_summary_vec
.exists ()
2497 && ((inline_edge_summary_vec
.length () <= (unsigned) e
->uid
)
2498 || !inline_edge_summary (e
)->predicate
)))
2500 != compute_call_stmt_bb_frequency (e
->caller
->symbol
.decl
,
2501 gimple_bb (e
->call_stmt
))))
2503 error ("caller edge frequency %i does not match BB frequency %i",
2505 compute_call_stmt_bb_frequency (e
->caller
->symbol
.decl
,
2506 gimple_bb (e
->call_stmt
)));
2512 /* Switch to THIS_CFUN if needed and print STMT to stderr. */
2514 cgraph_debug_gimple_stmt (struct function
*this_cfun
, gimple stmt
)
2516 bool fndecl_was_null
= false;
2517 /* debug_gimple_stmt needs correct cfun */
2518 if (cfun
!= this_cfun
)
2519 set_cfun (this_cfun
);
2520 /* ...and an actual current_function_decl */
2521 if (!current_function_decl
)
2523 current_function_decl
= this_cfun
->decl
;
2524 fndecl_was_null
= true;
2526 debug_gimple_stmt (stmt
);
2527 if (fndecl_was_null
)
2528 current_function_decl
= NULL
;
2531 /* Verify that call graph edge E corresponds to DECL from the associated
2532 statement. Return true if the verification should fail. */
2535 verify_edge_corresponds_to_fndecl (struct cgraph_edge
*e
, tree decl
)
2537 struct cgraph_node
*node
;
2539 if (!decl
|| e
->callee
->global
.inlined_to
)
2541 if (cgraph_state
== CGRAPH_LTO_STREAMING
)
2543 node
= cgraph_get_node (decl
);
2545 /* We do not know if a node from a different partition is an alias or what it
2546 aliases and therefore cannot do the former_clone_of check reliably. */
2547 if (!node
|| node
->symbol
.in_other_partition
|| e
->callee
->symbol
.in_other_partition
)
2549 node
= cgraph_function_or_thunk_node (node
, NULL
);
2551 if (e
->callee
->former_clone_of
!= node
->symbol
.decl
2552 /* IPA-CP sometimes redirect edge to clone and then back to the former
2553 function. This ping-pong has to go, eventually. */
2554 && (node
!= cgraph_function_or_thunk_node (e
->callee
, NULL
))
2555 && !clone_of_p (cgraph_function_or_thunk_node (node
, NULL
), e
->callee
))
2561 /* Verify cgraph nodes of given cgraph node. */
2563 verify_cgraph_node (struct cgraph_node
*node
)
2565 struct cgraph_edge
*e
;
2566 struct function
*this_cfun
= DECL_STRUCT_FUNCTION (node
->symbol
.decl
);
2567 basic_block this_block
;
2568 gimple_stmt_iterator gsi
;
2569 bool error_found
= false;
2574 timevar_push (TV_CGRAPH_VERIFY
);
2575 error_found
|= verify_symtab_base ((symtab_node
) node
);
2576 for (e
= node
->callees
; e
; e
= e
->next_callee
)
2579 error ("aux field set for edge %s->%s",
2580 identifier_to_locale (cgraph_node_name (e
->caller
)),
2581 identifier_to_locale (cgraph_node_name (e
->callee
)));
2584 if (node
->count
< 0)
2586 error ("execution count is negative");
2589 if (node
->global
.inlined_to
&& node
->symbol
.same_comdat_group
)
2591 error ("inline clone in same comdat group list");
2594 if (!node
->symbol
.definition
&& !node
->symbol
.in_other_partition
&& node
->local
.local
)
2596 error ("local symbols must be defined");
2599 if (node
->global
.inlined_to
&& node
->symbol
.externally_visible
)
2601 error ("externally visible inline clone");
2604 if (node
->global
.inlined_to
&& node
->symbol
.address_taken
)
2606 error ("inline clone with address taken");
2609 if (node
->global
.inlined_to
&& node
->symbol
.force_output
)
2611 error ("inline clone is forced to output");
2614 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
2618 error ("aux field set for indirect edge from %s",
2619 identifier_to_locale (cgraph_node_name (e
->caller
)));
2622 if (!e
->indirect_unknown_callee
2623 || !e
->indirect_info
)
2625 error ("An indirect edge from %s is not marked as indirect or has "
2626 "associated indirect_info, the corresponding statement is: ",
2627 identifier_to_locale (cgraph_node_name (e
->caller
)));
2628 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
2632 for (e
= node
->callers
; e
; e
= e
->next_caller
)
2634 if (verify_edge_count_and_frequency (e
))
2636 if (!e
->inline_failed
)
2638 if (node
->global
.inlined_to
2639 != (e
->caller
->global
.inlined_to
2640 ? e
->caller
->global
.inlined_to
: e
->caller
))
2642 error ("inlined_to pointer is wrong");
2645 if (node
->callers
->next_caller
)
2647 error ("multiple inline callers");
2652 if (node
->global
.inlined_to
)
2654 error ("inlined_to pointer set for noninline callers");
2658 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
2659 if (verify_edge_count_and_frequency (e
))
2661 if (!node
->callers
&& node
->global
.inlined_to
)
2663 error ("inlined_to pointer is set but no predecessors found");
2666 if (node
->global
.inlined_to
== node
)
2668 error ("inlined_to pointer refers to itself");
2674 struct cgraph_node
*n
;
2675 for (n
= node
->clone_of
->clones
; n
; n
= n
->next_sibling_clone
)
2680 error ("node has wrong clone_of");
2686 struct cgraph_node
*n
;
2687 for (n
= node
->clones
; n
; n
= n
->next_sibling_clone
)
2688 if (n
->clone_of
!= node
)
2692 error ("node has wrong clone list");
2696 if ((node
->prev_sibling_clone
|| node
->next_sibling_clone
) && !node
->clone_of
)
2698 error ("node is in clone list but it is not clone");
2701 if (!node
->prev_sibling_clone
&& node
->clone_of
&& node
->clone_of
->clones
!= node
)
2703 error ("node has wrong prev_clone pointer");
2706 if (node
->prev_sibling_clone
&& node
->prev_sibling_clone
->next_sibling_clone
!= node
)
2708 error ("double linked list of clones corrupted");
2712 if (node
->symbol
.analyzed
&& node
->symbol
.alias
)
2714 bool ref_found
= false;
2716 struct ipa_ref
*ref
;
2720 error ("Alias has call edges");
2723 for (i
= 0; ipa_ref_list_reference_iterate (&node
->symbol
.ref_list
,
2725 if (ref
->use
!= IPA_REF_ALIAS
)
2727 error ("Alias has non-alias reference");
2732 error ("Alias has more than one alias reference");
2739 error ("Analyzed alias has no reference");
2743 if (node
->symbol
.analyzed
&& node
->thunk
.thunk_p
)
2747 error ("No edge out of thunk node");
2750 else if (node
->callees
->next_callee
)
2752 error ("More than one edge out of thunk node");
2755 if (gimple_has_body_p (node
->symbol
.decl
))
2757 error ("Thunk is not supposed to have body");
2761 else if (node
->symbol
.analyzed
&& gimple_has_body_p (node
->symbol
.decl
)
2762 && !TREE_ASM_WRITTEN (node
->symbol
.decl
)
2763 && (!DECL_EXTERNAL (node
->symbol
.decl
) || node
->global
.inlined_to
)
2768 pointer_set_t
*stmts
= pointer_set_create ();
2770 struct ipa_ref
*ref
;
2772 /* Reach the trees by walking over the CFG, and note the
2773 enclosing basic-blocks in the call edges. */
2774 FOR_EACH_BB_FN (this_block
, this_cfun
)
2776 for (gsi
= gsi_start_phis (this_block
);
2777 !gsi_end_p (gsi
); gsi_next (&gsi
))
2778 pointer_set_insert (stmts
, gsi_stmt (gsi
));
2779 for (gsi
= gsi_start_bb (this_block
);
2783 gimple stmt
= gsi_stmt (gsi
);
2784 pointer_set_insert (stmts
, stmt
);
2785 if (is_gimple_call (stmt
))
2787 struct cgraph_edge
*e
= cgraph_edge (node
, stmt
);
2788 tree decl
= gimple_call_fndecl (stmt
);
2793 error ("shared call_stmt:");
2794 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
2797 if (!e
->indirect_unknown_callee
)
2799 if (verify_edge_corresponds_to_fndecl (e
, decl
))
2801 error ("edge points to wrong declaration:");
2802 debug_tree (e
->callee
->symbol
.decl
);
2803 fprintf (stderr
," Instead of:");
2810 error ("an indirect edge with unknown callee "
2811 "corresponding to a call_stmt with "
2812 "a known declaration:");
2814 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
2820 error ("missing callgraph edge for call stmt:");
2821 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
2828 ipa_ref_list_reference_iterate (&node
->symbol
.ref_list
, i
, ref
);
2830 if (ref
->stmt
&& !pointer_set_contains (stmts
, ref
->stmt
))
2832 error ("reference to dead statement");
2833 cgraph_debug_gimple_stmt (this_cfun
, ref
->stmt
);
2836 pointer_set_destroy (stmts
);
2839 /* No CFG available?! */
2842 for (e
= node
->callees
; e
; e
= e
->next_callee
)
2846 error ("edge %s->%s has no corresponding call_stmt",
2847 identifier_to_locale (cgraph_node_name (e
->caller
)),
2848 identifier_to_locale (cgraph_node_name (e
->callee
)));
2849 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
2854 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
2856 if (!e
->aux
&& !e
->speculative
)
2858 error ("an indirect edge from %s has no corresponding call_stmt",
2859 identifier_to_locale (cgraph_node_name (e
->caller
)));
2860 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
2868 dump_cgraph_node (stderr
, node
);
2869 internal_error ("verify_cgraph_node failed");
2871 timevar_pop (TV_CGRAPH_VERIFY
);
2874 /* Verify whole cgraph structure. */
2876 verify_cgraph (void)
2878 struct cgraph_node
*node
;
2883 FOR_EACH_FUNCTION (node
)
2884 verify_cgraph_node (node
);
2887 /* Create external decl node for DECL.
2888 The difference i nbetween cgraph_get_create_node and
2889 cgraph_get_create_real_symbol_node is that cgraph_get_create_node
2890 may return inline clone, while cgraph_get_create_real_symbol_node
2891 will create a new node in this case.
2892 FIXME: This function should be removed once clones are put out of decl
2895 struct cgraph_node
*
2896 cgraph_get_create_real_symbol_node (tree decl
)
2898 struct cgraph_node
*first_clone
= cgraph_get_node (decl
);
2899 struct cgraph_node
*node
;
2900 /* create symbol table node. even if inline clone exists, we can not take
2901 it as a target of non-inlined call. */
2902 node
= cgraph_get_node (decl
);
2903 if (node
&& !node
->global
.inlined_to
)
2906 node
= cgraph_create_node (decl
);
2908 /* ok, we previously inlined the function, then removed the offline copy and
2909 now we want it back for external call. this can happen when devirtualizing
2910 while inlining function called once that happens after extern inlined and
2911 virtuals are already removed. in this case introduce the external node
2912 and make it available for call. */
2915 first_clone
->clone_of
= node
;
2916 node
->clones
= first_clone
;
2917 symtab_prevail_in_asm_name_hash ((symtab_node
) node
);
2918 symtab_insert_node_to_hashtable ((symtab_node
) node
);
2920 fprintf (dump_file
, "Introduced new external node "
2921 "(%s/%i) and turned into root of the clone tree.\n",
2922 xstrdup (cgraph_node_name (node
)), node
->symbol
.order
);
2925 fprintf (dump_file
, "Introduced new external node "
2926 "(%s/%i).\n", xstrdup (cgraph_node_name (node
)),
2927 node
->symbol
.order
);
2932 /* Given NODE, walk the alias chain to return the function NODE is alias of.
2933 Walk through thunk, too.
2934 When AVAILABILITY is non-NULL, get minimal availability in the chain. */
2936 struct cgraph_node
*
2937 cgraph_function_node (struct cgraph_node
*node
, enum availability
*availability
)
2941 node
= cgraph_function_or_thunk_node (node
, availability
);
2942 if (node
->thunk
.thunk_p
)
2944 node
= node
->callees
->callee
;
2947 enum availability a
;
2948 a
= cgraph_function_body_availability (node
);
2949 if (a
< *availability
)
2952 node
= cgraph_function_or_thunk_node (node
, availability
);
2954 } while (node
&& node
->thunk
.thunk_p
);
2958 /* When doing LTO, read NODE's body from disk if it is not already present. */
2961 cgraph_get_body (struct cgraph_node
*node
)
2963 struct lto_file_decl_data
*file_data
;
2964 const char *data
, *name
;
2966 tree decl
= node
->symbol
.decl
;
2968 if (DECL_RESULT (decl
))
2971 gcc_assert (in_lto_p
);
2973 file_data
= node
->symbol
.lto_file_data
;
2974 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
2976 /* We may have renamed the declaration, e.g., a static function. */
2977 name
= lto_get_decl_name_mapping (file_data
, name
);
2979 data
= lto_get_section_data (file_data
, LTO_section_function_body
,
2983 dump_cgraph_node (stderr
, node
);
2984 fatal_error ("%s: section %s is missing",
2985 file_data
->file_name
,
2989 gcc_assert (DECL_STRUCT_FUNCTION (decl
) == NULL
);
2991 lto_input_function_body (file_data
, node
, data
);
2992 lto_stats
.num_function_bodies
++;
2993 lto_free_section_data (file_data
, LTO_section_function_body
, name
,
2995 lto_free_function_in_decl_state_for_node ((symtab_node
) node
);
2999 #include "gt-cgraph.h"