1 /* Callgraph handling code.
2 Copyright (C) 2003-2014 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"
33 #include "print-tree.h"
34 #include "tree-inline.h"
35 #include "langhooks.h"
43 #include "tree-ssa-alias.h"
44 #include "internal-fn.h"
46 #include "gimple-expr.h"
48 #include "gimple-iterator.h"
51 #include "gimple-ssa.h"
55 #include "value-prof.h"
57 #include "diagnostic-core.h"
59 #include "ipa-utils.h"
60 #include "lto-streamer.h"
61 #include "ipa-inline.h"
63 #include "gimple-pretty-print.h"
65 /* FIXME: Only for PROP_loops, but cgraph shouldn't have to know about this. */
66 #include "tree-pass.h"
68 static void cgraph_node_remove_callers (struct cgraph_node
*node
);
69 static inline void cgraph_edge_remove_caller (struct cgraph_edge
*e
);
70 static inline void cgraph_edge_remove_callee (struct cgraph_edge
*e
);
72 /* Queue of cgraph nodes scheduled to be lowered. */
73 symtab_node
*x_cgraph_nodes_queue
;
74 #define cgraph_nodes_queue ((struct cgraph_node *)x_cgraph_nodes_queue)
76 /* Number of nodes in existence. */
79 /* Maximal uid used in cgraph nodes. */
82 /* Maximal uid used in cgraph edges. */
83 int cgraph_edge_max_uid
;
85 /* Set when whole unit has been analyzed so we can access global info. */
86 bool cgraph_global_info_ready
= false;
88 /* What state callgraph is in right now. */
89 enum cgraph_state cgraph_state
= CGRAPH_STATE_PARSING
;
91 /* Set when the cgraph is fully build and the basic flags are computed. */
92 bool cgraph_function_flags_ready
= false;
94 /* List of hooks triggered on cgraph_edge events. */
95 struct cgraph_edge_hook_list
{
96 cgraph_edge_hook hook
;
98 struct cgraph_edge_hook_list
*next
;
101 /* List of hooks triggered on cgraph_node events. */
102 struct cgraph_node_hook_list
{
103 cgraph_node_hook hook
;
105 struct cgraph_node_hook_list
*next
;
108 /* List of hooks triggered on events involving two cgraph_edges. */
109 struct cgraph_2edge_hook_list
{
110 cgraph_2edge_hook hook
;
112 struct cgraph_2edge_hook_list
*next
;
115 /* List of hooks triggered on events involving two cgraph_nodes. */
116 struct cgraph_2node_hook_list
{
117 cgraph_2node_hook hook
;
119 struct cgraph_2node_hook_list
*next
;
122 /* List of hooks triggered when an edge is removed. */
123 struct cgraph_edge_hook_list
*first_cgraph_edge_removal_hook
;
124 /* List of hooks triggered when a node is removed. */
125 struct cgraph_node_hook_list
*first_cgraph_node_removal_hook
;
126 /* List of hooks triggered when an edge is duplicated. */
127 struct cgraph_2edge_hook_list
*first_cgraph_edge_duplicated_hook
;
128 /* List of hooks triggered when a node is duplicated. */
129 struct cgraph_2node_hook_list
*first_cgraph_node_duplicated_hook
;
130 /* List of hooks triggered when an function is inserted. */
131 struct cgraph_node_hook_list
*first_cgraph_function_insertion_hook
;
133 /* Head of a linked list of unused (freed) call graph nodes.
134 Do not GTY((delete)) this list so UIDs gets reliably recycled. */
135 static GTY(()) struct cgraph_node
*free_nodes
;
136 /* Head of a linked list of unused (freed) call graph edges.
137 Do not GTY((delete)) this list so UIDs gets reliably recycled. */
138 static GTY(()) struct cgraph_edge
*free_edges
;
140 /* Did procss_same_body_aliases run? */
141 bool cpp_implicit_aliases_done
;
143 /* Map a cgraph_node to cgraph_function_version_info using this htab.
144 The cgraph_function_version_info has a THIS_NODE field that is the
145 corresponding cgraph_node.. */
147 static GTY((param_is (struct cgraph_function_version_info
))) htab_t
148 cgraph_fnver_htab
= NULL
;
150 /* Hash function for cgraph_fnver_htab. */
152 cgraph_fnver_htab_hash (const void *ptr
)
154 int uid
= ((const struct cgraph_function_version_info
*)ptr
)->this_node
->uid
;
155 return (hashval_t
)(uid
);
158 /* eq function for cgraph_fnver_htab. */
160 cgraph_fnver_htab_eq (const void *p1
, const void *p2
)
162 const struct cgraph_function_version_info
*n1
163 = (const struct cgraph_function_version_info
*)p1
;
164 const struct cgraph_function_version_info
*n2
165 = (const struct cgraph_function_version_info
*)p2
;
167 return n1
->this_node
->uid
== n2
->this_node
->uid
;
170 /* Mark as GC root all allocated nodes. */
171 static GTY(()) struct cgraph_function_version_info
*
172 version_info_node
= NULL
;
174 /* Get the cgraph_function_version_info node corresponding to node. */
175 struct cgraph_function_version_info
*
176 get_cgraph_node_version (struct cgraph_node
*node
)
178 struct cgraph_function_version_info
*ret
;
179 struct cgraph_function_version_info key
;
180 key
.this_node
= node
;
182 if (cgraph_fnver_htab
== NULL
)
185 ret
= (struct cgraph_function_version_info
*)
186 htab_find (cgraph_fnver_htab
, &key
);
191 /* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
192 corresponding to cgraph_node NODE. */
193 struct cgraph_function_version_info
*
194 insert_new_cgraph_node_version (struct cgraph_node
*node
)
198 version_info_node
= NULL
;
199 version_info_node
= ggc_alloc_cleared_cgraph_function_version_info ();
200 version_info_node
->this_node
= node
;
202 if (cgraph_fnver_htab
== NULL
)
203 cgraph_fnver_htab
= htab_create_ggc (2, cgraph_fnver_htab_hash
,
204 cgraph_fnver_htab_eq
, NULL
);
206 slot
= htab_find_slot (cgraph_fnver_htab
, version_info_node
, INSERT
);
207 gcc_assert (slot
!= NULL
);
208 *slot
= version_info_node
;
209 return version_info_node
;
212 /* Remove the cgraph_function_version_info and cgraph_node for DECL. This
213 DECL is a duplicate declaration. */
215 delete_function_version (tree decl
)
217 struct cgraph_node
*decl_node
= cgraph_get_node (decl
);
218 struct cgraph_function_version_info
*decl_v
= NULL
;
220 if (decl_node
== NULL
)
223 decl_v
= get_cgraph_node_version (decl_node
);
228 if (decl_v
->prev
!= NULL
)
229 decl_v
->prev
->next
= decl_v
->next
;
231 if (decl_v
->next
!= NULL
)
232 decl_v
->next
->prev
= decl_v
->prev
;
234 if (cgraph_fnver_htab
!= NULL
)
235 htab_remove_elt (cgraph_fnver_htab
, decl_v
);
237 cgraph_remove_node (decl_node
);
240 /* Record that DECL1 and DECL2 are semantically identical function
243 record_function_versions (tree decl1
, tree decl2
)
245 struct cgraph_node
*decl1_node
= cgraph_get_create_node (decl1
);
246 struct cgraph_node
*decl2_node
= cgraph_get_create_node (decl2
);
247 struct cgraph_function_version_info
*decl1_v
= NULL
;
248 struct cgraph_function_version_info
*decl2_v
= NULL
;
249 struct cgraph_function_version_info
*before
;
250 struct cgraph_function_version_info
*after
;
252 gcc_assert (decl1_node
!= NULL
&& decl2_node
!= NULL
);
253 decl1_v
= get_cgraph_node_version (decl1_node
);
254 decl2_v
= get_cgraph_node_version (decl2_node
);
256 if (decl1_v
!= NULL
&& decl2_v
!= NULL
)
260 decl1_v
= insert_new_cgraph_node_version (decl1_node
);
263 decl2_v
= insert_new_cgraph_node_version (decl2_node
);
265 /* Chain decl2_v and decl1_v. All semantically identical versions
266 will be chained together. */
271 while (before
->next
!= NULL
)
272 before
= before
->next
;
274 while (after
->prev
!= NULL
)
277 before
->next
= after
;
278 after
->prev
= before
;
281 /* Macros to access the next item in the list of free cgraph nodes and
283 #define NEXT_FREE_NODE(NODE) cgraph ((NODE)->next)
284 #define SET_NEXT_FREE_NODE(NODE,NODE2) ((NODE))->next = NODE2
285 #define NEXT_FREE_EDGE(EDGE) (EDGE)->prev_caller
287 /* Register HOOK to be called with DATA on each removed edge. */
288 struct cgraph_edge_hook_list
*
289 cgraph_add_edge_removal_hook (cgraph_edge_hook hook
, void *data
)
291 struct cgraph_edge_hook_list
*entry
;
292 struct cgraph_edge_hook_list
**ptr
= &first_cgraph_edge_removal_hook
;
294 entry
= (struct cgraph_edge_hook_list
*) xmalloc (sizeof (*entry
));
304 /* Remove ENTRY from the list of hooks called on removing edges. */
306 cgraph_remove_edge_removal_hook (struct cgraph_edge_hook_list
*entry
)
308 struct cgraph_edge_hook_list
**ptr
= &first_cgraph_edge_removal_hook
;
310 while (*ptr
!= entry
)
316 /* Call all edge removal hooks. */
318 cgraph_call_edge_removal_hooks (struct cgraph_edge
*e
)
320 struct cgraph_edge_hook_list
*entry
= first_cgraph_edge_removal_hook
;
323 entry
->hook (e
, entry
->data
);
328 /* Register HOOK to be called with DATA on each removed node. */
329 struct cgraph_node_hook_list
*
330 cgraph_add_node_removal_hook (cgraph_node_hook hook
, void *data
)
332 struct cgraph_node_hook_list
*entry
;
333 struct cgraph_node_hook_list
**ptr
= &first_cgraph_node_removal_hook
;
335 entry
= (struct cgraph_node_hook_list
*) xmalloc (sizeof (*entry
));
345 /* Remove ENTRY from the list of hooks called on removing nodes. */
347 cgraph_remove_node_removal_hook (struct cgraph_node_hook_list
*entry
)
349 struct cgraph_node_hook_list
**ptr
= &first_cgraph_node_removal_hook
;
351 while (*ptr
!= entry
)
357 /* Call all node removal hooks. */
359 cgraph_call_node_removal_hooks (struct cgraph_node
*node
)
361 struct cgraph_node_hook_list
*entry
= first_cgraph_node_removal_hook
;
364 entry
->hook (node
, entry
->data
);
369 /* Register HOOK to be called with DATA on each inserted node. */
370 struct cgraph_node_hook_list
*
371 cgraph_add_function_insertion_hook (cgraph_node_hook hook
, void *data
)
373 struct cgraph_node_hook_list
*entry
;
374 struct cgraph_node_hook_list
**ptr
= &first_cgraph_function_insertion_hook
;
376 entry
= (struct cgraph_node_hook_list
*) xmalloc (sizeof (*entry
));
386 /* Remove ENTRY from the list of hooks called on inserted nodes. */
388 cgraph_remove_function_insertion_hook (struct cgraph_node_hook_list
*entry
)
390 struct cgraph_node_hook_list
**ptr
= &first_cgraph_function_insertion_hook
;
392 while (*ptr
!= entry
)
398 /* Call all node insertion hooks. */
400 cgraph_call_function_insertion_hooks (struct cgraph_node
*node
)
402 struct cgraph_node_hook_list
*entry
= first_cgraph_function_insertion_hook
;
405 entry
->hook (node
, entry
->data
);
410 /* Register HOOK to be called with DATA on each duplicated edge. */
411 struct cgraph_2edge_hook_list
*
412 cgraph_add_edge_duplication_hook (cgraph_2edge_hook hook
, void *data
)
414 struct cgraph_2edge_hook_list
*entry
;
415 struct cgraph_2edge_hook_list
**ptr
= &first_cgraph_edge_duplicated_hook
;
417 entry
= (struct cgraph_2edge_hook_list
*) xmalloc (sizeof (*entry
));
427 /* Remove ENTRY from the list of hooks called on duplicating edges. */
429 cgraph_remove_edge_duplication_hook (struct cgraph_2edge_hook_list
*entry
)
431 struct cgraph_2edge_hook_list
**ptr
= &first_cgraph_edge_duplicated_hook
;
433 while (*ptr
!= entry
)
439 /* Call all edge duplication hooks. */
441 cgraph_call_edge_duplication_hooks (struct cgraph_edge
*cs1
,
442 struct cgraph_edge
*cs2
)
444 struct cgraph_2edge_hook_list
*entry
= first_cgraph_edge_duplicated_hook
;
447 entry
->hook (cs1
, cs2
, entry
->data
);
452 /* Register HOOK to be called with DATA on each duplicated node. */
453 struct cgraph_2node_hook_list
*
454 cgraph_add_node_duplication_hook (cgraph_2node_hook hook
, void *data
)
456 struct cgraph_2node_hook_list
*entry
;
457 struct cgraph_2node_hook_list
**ptr
= &first_cgraph_node_duplicated_hook
;
459 entry
= (struct cgraph_2node_hook_list
*) xmalloc (sizeof (*entry
));
469 /* Remove ENTRY from the list of hooks called on duplicating nodes. */
471 cgraph_remove_node_duplication_hook (struct cgraph_2node_hook_list
*entry
)
473 struct cgraph_2node_hook_list
**ptr
= &first_cgraph_node_duplicated_hook
;
475 while (*ptr
!= entry
)
481 /* Call all node duplication hooks. */
483 cgraph_call_node_duplication_hooks (struct cgraph_node
*node1
,
484 struct cgraph_node
*node2
)
486 struct cgraph_2node_hook_list
*entry
= first_cgraph_node_duplicated_hook
;
489 entry
->hook (node1
, node2
, entry
->data
);
494 /* Allocate new callgraph node. */
496 static inline struct cgraph_node
*
497 cgraph_allocate_node (void)
499 struct cgraph_node
*node
;
504 free_nodes
= NEXT_FREE_NODE (node
);
508 node
= ggc_alloc_cleared_cgraph_node ();
509 node
->uid
= cgraph_max_uid
++;
515 /* Allocate new callgraph node and insert it into basic data structures. */
518 cgraph_create_empty_node (void)
520 struct cgraph_node
*node
= cgraph_allocate_node ();
522 node
->type
= SYMTAB_FUNCTION
;
523 node
->frequency
= NODE_FREQUENCY_NORMAL
;
524 node
->count_materialization_scale
= REG_BR_PROB_BASE
;
529 /* Return cgraph node assigned to DECL. Create new one when needed. */
532 cgraph_create_node (tree decl
)
534 struct cgraph_node
*node
= cgraph_create_empty_node ();
535 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
538 symtab_register_node (node
);
540 if (DECL_CONTEXT (decl
) && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
542 node
->origin
= cgraph_get_create_node (DECL_CONTEXT (decl
));
543 node
->next_nested
= node
->origin
->nested
;
544 node
->origin
->nested
= node
;
549 /* Try to find a call graph node for declaration DECL and if it does not exist
550 or if it corresponds to an inline clone, create a new one. */
553 cgraph_get_create_node (tree decl
)
555 struct cgraph_node
*first_clone
= cgraph_get_node (decl
);
557 if (first_clone
&& !first_clone
->global
.inlined_to
)
560 struct cgraph_node
*node
= cgraph_create_node (decl
);
563 first_clone
->clone_of
= node
;
564 node
->clones
= first_clone
;
565 symtab_prevail_in_asm_name_hash (node
);
566 symtab_insert_node_to_hashtable (node
);
568 fprintf (dump_file
, "Introduced new external node "
569 "(%s/%i) and turned into root of the clone tree.\n",
570 xstrdup (node
->name ()), node
->order
);
573 fprintf (dump_file
, "Introduced new external node "
574 "(%s/%i).\n", xstrdup (node
->name ()),
579 /* Mark ALIAS as an alias to DECL. DECL_NODE is cgraph node representing
580 the function body is associated with (not necessarily cgraph_node (DECL). */
583 cgraph_create_function_alias (tree alias
, tree target
)
585 struct cgraph_node
*alias_node
;
587 gcc_assert (TREE_CODE (target
) == FUNCTION_DECL
588 || TREE_CODE (target
) == IDENTIFIER_NODE
);
589 gcc_assert (TREE_CODE (alias
) == FUNCTION_DECL
);
590 alias_node
= cgraph_get_create_node (alias
);
591 gcc_assert (!alias_node
->definition
);
592 alias_node
->alias_target
= target
;
593 alias_node
->definition
= true;
594 alias_node
->alias
= true;
595 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (alias
)) != NULL
)
596 alias_node
->weakref
= true;
600 /* Attempt to mark ALIAS as an alias to DECL. Return alias node if successful
602 Same body aliases are output whenever the body of DECL is output,
603 and cgraph_get_node (ALIAS) transparently returns cgraph_get_node (DECL). */
606 cgraph_same_body_alias (struct cgraph_node
*decl_node ATTRIBUTE_UNUSED
, tree alias
, tree decl
)
608 struct cgraph_node
*n
;
609 #ifndef ASM_OUTPUT_DEF
610 /* If aliases aren't supported by the assembler, fail. */
613 /* Langhooks can create same body aliases of symbols not defined.
614 Those are useless. Drop them on the floor. */
615 if (cgraph_global_info_ready
)
618 n
= cgraph_create_function_alias (alias
, decl
);
619 n
->cpp_implicit_alias
= true;
620 if (cpp_implicit_aliases_done
)
621 symtab_resolve_alias (n
,
622 cgraph_get_node (decl
));
626 /* Add thunk alias into callgraph. The alias declaration is ALIAS and it
627 aliases DECL with an adjustments made into the first parameter.
628 See comments in thunk_adjust for detail on the parameters. */
631 cgraph_add_thunk (struct cgraph_node
*decl_node ATTRIBUTE_UNUSED
,
632 tree alias
, tree decl ATTRIBUTE_UNUSED
,
634 HOST_WIDE_INT fixed_offset
, HOST_WIDE_INT virtual_value
,
638 struct cgraph_node
*node
;
640 node
= cgraph_get_node (alias
);
643 gcc_assert (node
->definition
);
644 gcc_assert (!node
->alias
);
645 gcc_assert (!node
->thunk
.thunk_p
);
646 cgraph_remove_node (node
);
649 node
= cgraph_create_node (alias
);
650 gcc_checking_assert (!virtual_offset
651 || tree_to_double_int (virtual_offset
) ==
652 double_int::from_shwi (virtual_value
));
653 node
->thunk
.fixed_offset
= fixed_offset
;
654 node
->thunk
.this_adjusting
= this_adjusting
;
655 node
->thunk
.virtual_value
= virtual_value
;
656 node
->thunk
.virtual_offset_p
= virtual_offset
!= NULL
;
657 node
->thunk
.alias
= real_alias
;
658 node
->thunk
.thunk_p
= true;
659 node
->definition
= true;
664 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
665 Return NULL if there's no such node. */
668 cgraph_node_for_asm (tree asmname
)
670 /* We do not want to look at inline clones. */
671 for (symtab_node
*node
= symtab_node_for_asm (asmname
);
673 node
= node
->next_sharing_asm_name
)
675 cgraph_node
*cn
= dyn_cast
<cgraph_node
> (node
);
676 if (cn
&& !cn
->global
.inlined_to
)
682 /* Returns a hash value for X (which really is a cgraph_edge). */
685 edge_hash (const void *x
)
687 return htab_hash_pointer (((const struct cgraph_edge
*) x
)->call_stmt
);
690 /* Return nonzero if the call_stmt of of cgraph_edge X is stmt *Y. */
693 edge_eq (const void *x
, const void *y
)
695 return ((const struct cgraph_edge
*) x
)->call_stmt
== y
;
698 /* Add call graph edge E to call site hash of its caller. */
701 cgraph_update_edge_in_call_site_hash (struct cgraph_edge
*e
)
704 slot
= htab_find_slot_with_hash (e
->caller
->call_site_hash
,
706 htab_hash_pointer (e
->call_stmt
),
711 /* Add call graph edge E to call site hash of its caller. */
714 cgraph_add_edge_to_call_site_hash (struct cgraph_edge
*e
)
717 /* There are two speculative edges for every statement (one direct,
718 one indirect); always hash the direct one. */
719 if (e
->speculative
&& e
->indirect_unknown_callee
)
721 slot
= htab_find_slot_with_hash (e
->caller
->call_site_hash
,
723 htab_hash_pointer (e
->call_stmt
),
727 gcc_assert (((struct cgraph_edge
*)*slot
)->speculative
);
732 gcc_assert (!*slot
|| e
->speculative
);
736 /* Return the callgraph edge representing the GIMPLE_CALL statement
740 cgraph_edge (struct cgraph_node
*node
, gimple call_stmt
)
742 struct cgraph_edge
*e
, *e2
;
745 if (node
->call_site_hash
)
746 return (struct cgraph_edge
*)
747 htab_find_with_hash (node
->call_site_hash
, call_stmt
,
748 htab_hash_pointer (call_stmt
));
750 /* This loop may turn out to be performance problem. In such case adding
751 hashtables into call nodes with very many edges is probably best
752 solution. It is not good idea to add pointer into CALL_EXPR itself
753 because we want to make possible having multiple cgraph nodes representing
754 different clones of the same body before the body is actually cloned. */
755 for (e
= node
->callees
; e
; e
= e
->next_callee
)
757 if (e
->call_stmt
== call_stmt
)
763 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
765 if (e
->call_stmt
== call_stmt
)
772 node
->call_site_hash
= htab_create_ggc (120, edge_hash
, edge_eq
, NULL
);
773 for (e2
= node
->callees
; e2
; e2
= e2
->next_callee
)
774 cgraph_add_edge_to_call_site_hash (e2
);
775 for (e2
= node
->indirect_calls
; e2
; e2
= e2
->next_callee
)
776 cgraph_add_edge_to_call_site_hash (e2
);
783 /* Change field call_stmt of edge E to NEW_STMT.
784 If UPDATE_SPECULATIVE and E is any component of speculative
785 edge, then update all components. */
788 cgraph_set_call_stmt (struct cgraph_edge
*e
, gimple new_stmt
,
789 bool update_speculative
)
793 /* Speculative edges has three component, update all of them
795 if (update_speculative
&& e
->speculative
)
797 struct cgraph_edge
*direct
, *indirect
;
800 cgraph_speculative_call_info (e
, direct
, indirect
, ref
);
801 cgraph_set_call_stmt (direct
, new_stmt
, false);
802 cgraph_set_call_stmt (indirect
, new_stmt
, false);
803 ref
->stmt
= new_stmt
;
807 /* Only direct speculative edges go to call_site_hash. */
808 if (e
->caller
->call_site_hash
809 && (!e
->speculative
|| !e
->indirect_unknown_callee
))
811 htab_remove_elt_with_hash (e
->caller
->call_site_hash
,
813 htab_hash_pointer (e
->call_stmt
));
816 e
->call_stmt
= new_stmt
;
817 if (e
->indirect_unknown_callee
818 && (decl
= gimple_call_fndecl (new_stmt
)))
820 /* Constant propagation (and possibly also inlining?) can turn an
821 indirect call into a direct one. */
822 struct cgraph_node
*new_callee
= cgraph_get_node (decl
);
824 gcc_checking_assert (new_callee
);
825 e
= cgraph_make_edge_direct (e
, new_callee
);
828 push_cfun (DECL_STRUCT_FUNCTION (e
->caller
->decl
));
829 e
->can_throw_external
= stmt_can_throw_external (new_stmt
);
831 if (e
->caller
->call_site_hash
)
832 cgraph_add_edge_to_call_site_hash (e
);
835 /* Allocate a cgraph_edge structure and fill it with data according to the
836 parameters of which only CALLEE can be NULL (when creating an indirect call
839 static struct cgraph_edge
*
840 cgraph_create_edge_1 (struct cgraph_node
*caller
, struct cgraph_node
*callee
,
841 gimple call_stmt
, gcov_type count
, int freq
,
842 bool indir_unknown_callee
)
844 struct cgraph_edge
*edge
;
846 /* LTO does not actually have access to the call_stmt since these
847 have not been loaded yet. */
850 /* This is a rather expensive check possibly triggering
851 construction of call stmt hashtable. */
852 #ifdef ENABLE_CHECKING
853 struct cgraph_edge
*e
;
854 gcc_checking_assert (!(e
=cgraph_edge (caller
, call_stmt
)) || e
->speculative
);
857 gcc_assert (is_gimple_call (call_stmt
));
863 free_edges
= NEXT_FREE_EDGE (edge
);
867 edge
= ggc_alloc_cgraph_edge ();
868 edge
->uid
= cgraph_edge_max_uid
++;
872 edge
->caller
= caller
;
873 edge
->callee
= callee
;
874 edge
->prev_caller
= NULL
;
875 edge
->next_caller
= NULL
;
876 edge
->prev_callee
= NULL
;
877 edge
->next_callee
= NULL
;
878 edge
->lto_stmt_uid
= 0;
881 gcc_assert (count
>= 0);
882 edge
->frequency
= freq
;
883 gcc_assert (freq
>= 0);
884 gcc_assert (freq
<= CGRAPH_FREQ_MAX
);
886 edge
->call_stmt
= call_stmt
;
887 push_cfun (DECL_STRUCT_FUNCTION (caller
->decl
));
888 edge
->can_throw_external
889 = call_stmt
? stmt_can_throw_external (call_stmt
) : false;
892 && callee
&& callee
->decl
893 && !gimple_check_call_matching_types (call_stmt
, callee
->decl
,
895 edge
->call_stmt_cannot_inline_p
= true;
897 edge
->call_stmt_cannot_inline_p
= false;
899 edge
->indirect_info
= NULL
;
900 edge
->indirect_inlining_edge
= 0;
901 edge
->speculative
= false;
902 edge
->indirect_unknown_callee
= indir_unknown_callee
;
903 if (call_stmt
&& caller
->call_site_hash
)
904 cgraph_add_edge_to_call_site_hash (edge
);
909 /* Create edge from CALLER to CALLEE in the cgraph. */
912 cgraph_create_edge (struct cgraph_node
*caller
, struct cgraph_node
*callee
,
913 gimple call_stmt
, gcov_type count
, int freq
)
915 struct cgraph_edge
*edge
= cgraph_create_edge_1 (caller
, callee
, call_stmt
,
918 initialize_inline_failed (edge
);
920 edge
->next_caller
= callee
->callers
;
922 callee
->callers
->prev_caller
= edge
;
923 edge
->next_callee
= caller
->callees
;
925 caller
->callees
->prev_callee
= edge
;
926 caller
->callees
= edge
;
927 callee
->callers
= edge
;
932 /* Allocate cgraph_indirect_call_info and set its fields to default values. */
934 struct cgraph_indirect_call_info
*
935 cgraph_allocate_init_indirect_info (void)
937 struct cgraph_indirect_call_info
*ii
;
939 ii
= ggc_alloc_cleared_cgraph_indirect_call_info ();
940 ii
->param_index
= -1;
944 /* Create an indirect edge with a yet-undetermined callee where the call
945 statement destination is a formal parameter of the caller with index
949 cgraph_create_indirect_edge (struct cgraph_node
*caller
, gimple call_stmt
,
951 gcov_type count
, int freq
)
953 struct cgraph_edge
*edge
= cgraph_create_edge_1 (caller
, NULL
, call_stmt
,
957 initialize_inline_failed (edge
);
959 edge
->indirect_info
= cgraph_allocate_init_indirect_info ();
960 edge
->indirect_info
->ecf_flags
= ecf_flags
;
962 /* Record polymorphic call info. */
964 && (target
= gimple_call_fn (call_stmt
))
965 && virtual_method_call_p (target
))
968 HOST_WIDE_INT otr_token
;
969 ipa_polymorphic_call_context context
;
971 get_polymorphic_call_info (caller
->decl
,
973 &otr_type
, &otr_token
,
976 /* Only record types can have virtual calls. */
977 gcc_assert (TREE_CODE (otr_type
) == RECORD_TYPE
);
978 edge
->indirect_info
->polymorphic
= true;
979 edge
->indirect_info
->param_index
= -1;
980 edge
->indirect_info
->otr_token
= otr_token
;
981 edge
->indirect_info
->otr_type
= otr_type
;
982 edge
->indirect_info
->outer_type
= context
.outer_type
;
983 edge
->indirect_info
->offset
= context
.offset
;
984 edge
->indirect_info
->maybe_in_construction
985 = context
.maybe_in_construction
;
986 edge
->indirect_info
->maybe_derived_type
= context
.maybe_derived_type
;
989 edge
->next_callee
= caller
->indirect_calls
;
990 if (caller
->indirect_calls
)
991 caller
->indirect_calls
->prev_callee
= edge
;
992 caller
->indirect_calls
= edge
;
997 /* Remove the edge E from the list of the callers of the callee. */
1000 cgraph_edge_remove_callee (struct cgraph_edge
*e
)
1002 gcc_assert (!e
->indirect_unknown_callee
);
1004 e
->prev_caller
->next_caller
= e
->next_caller
;
1006 e
->next_caller
->prev_caller
= e
->prev_caller
;
1007 if (!e
->prev_caller
)
1008 e
->callee
->callers
= e
->next_caller
;
1011 /* Remove the edge E from the list of the callees of the caller. */
1014 cgraph_edge_remove_caller (struct cgraph_edge
*e
)
1017 e
->prev_callee
->next_callee
= e
->next_callee
;
1019 e
->next_callee
->prev_callee
= e
->prev_callee
;
1020 if (!e
->prev_callee
)
1022 if (e
->indirect_unknown_callee
)
1023 e
->caller
->indirect_calls
= e
->next_callee
;
1025 e
->caller
->callees
= e
->next_callee
;
1027 if (e
->caller
->call_site_hash
)
1028 htab_remove_elt_with_hash (e
->caller
->call_site_hash
,
1030 htab_hash_pointer (e
->call_stmt
));
1033 /* Put the edge onto the free list. */
1036 cgraph_free_edge (struct cgraph_edge
*e
)
1040 if (e
->indirect_info
)
1041 ggc_free (e
->indirect_info
);
1043 /* Clear out the edge so we do not dangle pointers. */
1044 memset (e
, 0, sizeof (*e
));
1046 NEXT_FREE_EDGE (e
) = free_edges
;
1050 /* Remove the edge E in the cgraph. */
1053 cgraph_remove_edge (struct cgraph_edge
*e
)
1055 /* Call all edge removal hooks. */
1056 cgraph_call_edge_removal_hooks (e
);
1058 if (!e
->indirect_unknown_callee
)
1059 /* Remove from callers list of the callee. */
1060 cgraph_edge_remove_callee (e
);
1062 /* Remove from callees list of the callers. */
1063 cgraph_edge_remove_caller (e
);
1065 /* Put the edge onto the free list. */
1066 cgraph_free_edge (e
);
1069 /* Set callee of call graph edge E and add it to the corresponding set of
1073 cgraph_set_edge_callee (struct cgraph_edge
*e
, struct cgraph_node
*n
)
1075 e
->prev_caller
= NULL
;
1077 n
->callers
->prev_caller
= e
;
1078 e
->next_caller
= n
->callers
;
1083 /* Turn edge E into speculative call calling N2. Update
1084 the profile so the direct call is taken COUNT times
1087 At clone materialization time, the indirect call E will
1090 if (call_dest == N2)
1095 At this time the function just creates the direct call,
1096 the referencd representing the if conditional and attaches
1097 them all to the orginal indirect call statement.
1099 Return direct edge created. */
1101 struct cgraph_edge
*
1102 cgraph_turn_edge_to_speculative (struct cgraph_edge
*e
,
1103 struct cgraph_node
*n2
,
1104 gcov_type direct_count
,
1105 int direct_frequency
)
1107 struct cgraph_node
*n
= e
->caller
;
1108 struct ipa_ref
*ref
;
1109 struct cgraph_edge
*e2
;
1113 fprintf (dump_file
, "Indirect call -> speculative call"
1114 " %s/%i => %s/%i\n",
1115 xstrdup (n
->name ()), n
->order
,
1116 xstrdup (n2
->name ()), n2
->order
);
1118 e
->speculative
= true;
1119 e2
= cgraph_create_edge (n
, n2
, e
->call_stmt
, direct_count
, direct_frequency
);
1120 initialize_inline_failed (e2
);
1121 e2
->speculative
= true;
1122 if (TREE_NOTHROW (n2
->decl
))
1123 e2
->can_throw_external
= false;
1125 e2
->can_throw_external
= e
->can_throw_external
;
1126 e2
->lto_stmt_uid
= e
->lto_stmt_uid
;
1127 e
->count
-= e2
->count
;
1128 e
->frequency
-= e2
->frequency
;
1129 cgraph_call_edge_duplication_hooks (e
, e2
);
1130 ref
= ipa_record_reference (n
, n2
,
1131 IPA_REF_ADDR
, e
->call_stmt
);
1132 ref
->lto_stmt_uid
= e
->lto_stmt_uid
;
1133 ref
->speculative
= e
->speculative
;
1134 cgraph_mark_address_taken_node (n2
);
1138 /* Speculative call consist of three components:
1139 1) an indirect edge representing the original call
1140 2) an direct edge representing the new call
1141 3) ADDR_EXPR reference representing the speculative check.
1142 All three components are attached to single statement (the indirect
1143 call) and if one of them exists, all of them must exist.
1145 Given speculative call edge E, return all three components.
1149 cgraph_speculative_call_info (struct cgraph_edge
*e
,
1150 struct cgraph_edge
*&direct
,
1151 struct cgraph_edge
*&indirect
,
1152 struct ipa_ref
*&reference
)
1154 struct ipa_ref
*ref
;
1156 struct cgraph_edge
*e2
;
1158 if (!e
->indirect_unknown_callee
)
1159 for (e2
= e
->caller
->indirect_calls
;
1160 e2
->call_stmt
!= e
->call_stmt
|| e2
->lto_stmt_uid
!= e
->lto_stmt_uid
;
1161 e2
= e2
->next_callee
)
1166 /* We can take advantage of the call stmt hash. */
1169 e
= cgraph_edge (e
->caller
, e2
->call_stmt
);
1170 gcc_assert (e
->speculative
&& !e
->indirect_unknown_callee
);
1173 for (e
= e
->caller
->callees
;
1174 e2
->call_stmt
!= e
->call_stmt
1175 || e2
->lto_stmt_uid
!= e
->lto_stmt_uid
;
1179 gcc_assert (e
->speculative
&& e2
->speculative
);
1184 for (i
= 0; ipa_ref_list_reference_iterate (&e
->caller
->ref_list
,
1186 if (ref
->speculative
1187 && ((ref
->stmt
&& ref
->stmt
== e
->call_stmt
)
1188 || (!ref
->stmt
&& ref
->lto_stmt_uid
== e
->lto_stmt_uid
)))
1194 /* Speculative edge always consist of all three components - direct edge,
1195 indirect and reference. */
1197 gcc_assert (e
&& e2
&& ref
);
1200 /* Redirect callee of E to N. The function does not update underlying
1204 cgraph_redirect_edge_callee (struct cgraph_edge
*e
, struct cgraph_node
*n
)
1206 /* Remove from callers list of the current callee. */
1207 cgraph_edge_remove_callee (e
);
1209 /* Insert to callers list of the new callee. */
1210 cgraph_set_edge_callee (e
, n
);
1213 /* Speculative call EDGE turned out to be direct call to CALLE_DECL.
1214 Remove the speculative call sequence and return edge representing the call.
1215 It is up to caller to redirect the call as appropriate. */
1217 struct cgraph_edge
*
1218 cgraph_resolve_speculation (struct cgraph_edge
*edge
, tree callee_decl
)
1220 struct cgraph_edge
*e2
;
1221 struct ipa_ref
*ref
;
1223 gcc_assert (edge
->speculative
);
1224 cgraph_speculative_call_info (edge
, e2
, edge
, ref
);
1226 || !symtab_semantically_equivalent_p (ref
->referred
,
1227 symtab_get_node (callee_decl
)))
1233 fprintf (dump_file
, "Speculative indirect call %s/%i => %s/%i has "
1234 "turned out to have contradicting known target ",
1235 xstrdup (edge
->caller
->name ()), edge
->caller
->order
,
1236 xstrdup (e2
->callee
->name ()), e2
->callee
->order
);
1237 print_generic_expr (dump_file
, callee_decl
, 0);
1238 fprintf (dump_file
, "\n");
1242 fprintf (dump_file
, "Removing speculative call %s/%i => %s/%i\n",
1243 xstrdup (edge
->caller
->name ()), edge
->caller
->order
,
1244 xstrdup (e2
->callee
->name ()), e2
->callee
->order
);
1250 struct cgraph_edge
*tmp
= edge
;
1252 fprintf (dump_file
, "Speculative call turned into direct call.\n");
1255 /* FIXME: If EDGE is inlined, we should scale up the frequencies and counts
1256 in the functions inlined through it. */
1258 edge
->count
+= e2
->count
;
1259 edge
->frequency
+= e2
->frequency
;
1260 if (edge
->frequency
> CGRAPH_FREQ_MAX
)
1261 edge
->frequency
= CGRAPH_FREQ_MAX
;
1262 edge
->speculative
= false;
1263 e2
->speculative
= false;
1264 ipa_remove_reference (ref
);
1265 if (e2
->indirect_unknown_callee
|| e2
->inline_failed
)
1266 cgraph_remove_edge (e2
);
1268 cgraph_remove_node_and_inline_clones (e2
->callee
, NULL
);
1269 if (edge
->caller
->call_site_hash
)
1270 cgraph_update_edge_in_call_site_hash (edge
);
1274 /* Make an indirect EDGE with an unknown callee an ordinary edge leading to
1275 CALLEE. DELTA is an integer constant that is to be added to the this
1276 pointer (first parameter) to compensate for skipping a thunk adjustment. */
1278 struct cgraph_edge
*
1279 cgraph_make_edge_direct (struct cgraph_edge
*edge
, struct cgraph_node
*callee
)
1281 gcc_assert (edge
->indirect_unknown_callee
);
1283 /* If we are redirecting speculative call, make it non-speculative. */
1284 if (edge
->indirect_unknown_callee
&& edge
->speculative
)
1286 edge
= cgraph_resolve_speculation (edge
, callee
->decl
);
1288 /* On successful speculation just return the pre existing direct edge. */
1289 if (!edge
->indirect_unknown_callee
)
1293 edge
->indirect_unknown_callee
= 0;
1294 ggc_free (edge
->indirect_info
);
1295 edge
->indirect_info
= NULL
;
1297 /* Get the edge out of the indirect edge list. */
1298 if (edge
->prev_callee
)
1299 edge
->prev_callee
->next_callee
= edge
->next_callee
;
1300 if (edge
->next_callee
)
1301 edge
->next_callee
->prev_callee
= edge
->prev_callee
;
1302 if (!edge
->prev_callee
)
1303 edge
->caller
->indirect_calls
= edge
->next_callee
;
1305 /* Put it into the normal callee list */
1306 edge
->prev_callee
= NULL
;
1307 edge
->next_callee
= edge
->caller
->callees
;
1308 if (edge
->caller
->callees
)
1309 edge
->caller
->callees
->prev_callee
= edge
;
1310 edge
->caller
->callees
= edge
;
1312 /* Insert to callers list of the new callee. */
1313 cgraph_set_edge_callee (edge
, callee
);
1315 if (edge
->call_stmt
)
1316 edge
->call_stmt_cannot_inline_p
1317 = !gimple_check_call_matching_types (edge
->call_stmt
, callee
->decl
,
1320 /* We need to re-determine the inlining status of the edge. */
1321 initialize_inline_failed (edge
);
1325 /* If necessary, change the function declaration in the call statement
1326 associated with E so that it corresponds to the edge callee. */
1329 cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge
*e
)
1331 tree decl
= gimple_call_fndecl (e
->call_stmt
);
1333 gimple_stmt_iterator gsi
;
1334 #ifdef ENABLE_CHECKING
1335 struct cgraph_node
*node
;
1340 struct cgraph_edge
*e2
;
1342 struct ipa_ref
*ref
;
1344 cgraph_speculative_call_info (e
, e
, e2
, ref
);
1345 /* If there already is an direct call (i.e. as a result of inliner's
1346 substitution), forget about speculating. */
1348 e
= cgraph_resolve_speculation (e
, decl
);
1349 /* If types do not match, speculation was likely wrong.
1350 The direct edge was posisbly redirected to the clone with a different
1351 signature. We did not update the call statement yet, so compare it
1352 with the reference that still points to the proper type. */
1353 else if (!gimple_check_call_matching_types (e
->call_stmt
,
1354 ref
->referred
->decl
,
1358 fprintf (dump_file
, "Not expanding speculative call of %s/%i -> %s/%i\n"
1360 xstrdup (e
->caller
->name ()),
1362 xstrdup (e
->callee
->name ()),
1364 e
= cgraph_resolve_speculation (e
, NULL
);
1365 /* We are producing the final function body and will throw away the
1366 callgraph edges really soon. Reset the counts/frequencies to
1367 keep verifier happy in the case of roundoff errors. */
1368 e
->count
= gimple_bb (e
->call_stmt
)->count
;
1369 e
->frequency
= compute_call_stmt_bb_frequency
1370 (e
->caller
->decl
, gimple_bb (e
->call_stmt
));
1372 /* Expand speculation into GIMPLE code. */
1377 "Expanding speculative call of %s/%i -> %s/%i count:"
1378 HOST_WIDEST_INT_PRINT_DEC
"\n",
1379 xstrdup (e
->caller
->name ()),
1381 xstrdup (e
->callee
->name ()),
1383 (HOST_WIDEST_INT
)e
->count
);
1384 gcc_assert (e2
->speculative
);
1385 push_cfun (DECL_STRUCT_FUNCTION (e
->caller
->decl
));
1386 new_stmt
= gimple_ic (e
->call_stmt
, cgraph (ref
->referred
),
1387 e
->count
|| e2
->count
1388 ? RDIV (e
->count
* REG_BR_PROB_BASE
,
1389 e
->count
+ e2
->count
)
1390 : e
->frequency
|| e2
->frequency
1391 ? RDIV (e
->frequency
* REG_BR_PROB_BASE
,
1392 e
->frequency
+ e2
->frequency
)
1393 : REG_BR_PROB_BASE
/ 2,
1394 e
->count
, e
->count
+ e2
->count
);
1395 e
->speculative
= false;
1396 cgraph_set_call_stmt_including_clones (e
->caller
, e
->call_stmt
,
1398 e
->frequency
= compute_call_stmt_bb_frequency
1399 (e
->caller
->decl
, gimple_bb (e
->call_stmt
));
1400 e2
->frequency
= compute_call_stmt_bb_frequency
1401 (e2
->caller
->decl
, gimple_bb (e2
->call_stmt
));
1402 e2
->speculative
= false;
1403 ref
->speculative
= false;
1405 /* Indirect edges are not both in the call site hash.
1407 if (e
->caller
->call_site_hash
)
1408 cgraph_update_edge_in_call_site_hash (e2
);
1410 /* Continue redirecting E to proper target. */
1414 if (e
->indirect_unknown_callee
1415 || decl
== e
->callee
->decl
)
1416 return e
->call_stmt
;
1418 #ifdef ENABLE_CHECKING
1421 node
= cgraph_get_node (decl
);
1422 gcc_assert (!node
|| !node
->clone
.combined_args_to_skip
);
1426 if (cgraph_dump_file
)
1428 fprintf (cgraph_dump_file
, "updating call of %s/%i -> %s/%i: ",
1429 xstrdup (e
->caller
->name ()), e
->caller
->order
,
1430 xstrdup (e
->callee
->name ()), e
->callee
->order
);
1431 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
1432 if (e
->callee
->clone
.combined_args_to_skip
)
1434 fprintf (cgraph_dump_file
, " combined args to skip: ");
1435 dump_bitmap (cgraph_dump_file
,
1436 e
->callee
->clone
.combined_args_to_skip
);
1440 if (e
->callee
->clone
.combined_args_to_skip
)
1445 = gimple_call_copy_skip_args (e
->call_stmt
,
1446 e
->callee
->clone
.combined_args_to_skip
);
1447 gimple_call_set_fndecl (new_stmt
, e
->callee
->decl
);
1448 gimple_call_set_fntype (new_stmt
, gimple_call_fntype (e
->call_stmt
));
1450 if (gimple_vdef (new_stmt
)
1451 && TREE_CODE (gimple_vdef (new_stmt
)) == SSA_NAME
)
1452 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt
)) = new_stmt
;
1454 gsi
= gsi_for_stmt (e
->call_stmt
);
1455 gsi_replace (&gsi
, new_stmt
, false);
1456 /* We need to defer cleaning EH info on the new statement to
1457 fixup-cfg. We may not have dominator information at this point
1458 and thus would end up with unreachable blocks and have no way
1459 to communicate that we need to run CFG cleanup then. */
1460 lp_nr
= lookup_stmt_eh_lp (e
->call_stmt
);
1463 remove_stmt_from_eh_lp (e
->call_stmt
);
1464 add_stmt_to_eh_lp (new_stmt
, lp_nr
);
1469 new_stmt
= e
->call_stmt
;
1470 gimple_call_set_fndecl (new_stmt
, e
->callee
->decl
);
1471 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), new_stmt
);
1474 cgraph_set_call_stmt_including_clones (e
->caller
, e
->call_stmt
, new_stmt
, false);
1476 if (cgraph_dump_file
)
1478 fprintf (cgraph_dump_file
, " updated to:");
1479 print_gimple_stmt (cgraph_dump_file
, e
->call_stmt
, 0, dump_flags
);
1484 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1485 OLD_STMT changed into NEW_STMT. OLD_CALL is gimple_call_fndecl
1486 of OLD_STMT if it was previously call statement.
1487 If NEW_STMT is NULL, the call has been dropped without any
1491 cgraph_update_edges_for_call_stmt_node (struct cgraph_node
*node
,
1492 gimple old_stmt
, tree old_call
,
1495 tree new_call
= (new_stmt
&& is_gimple_call (new_stmt
))
1496 ? gimple_call_fndecl (new_stmt
) : 0;
1498 /* We are seeing indirect calls, then there is nothing to update. */
1499 if (!new_call
&& !old_call
)
1501 /* See if we turned indirect call into direct call or folded call to one builtin
1502 into different builtin. */
1503 if (old_call
!= new_call
)
1505 struct cgraph_edge
*e
= cgraph_edge (node
, old_stmt
);
1506 struct cgraph_edge
*ne
= NULL
;
1512 /* See if the edge is already there and has the correct callee. It
1513 might be so because of indirect inlining has already updated
1514 it. We also might've cloned and redirected the edge. */
1515 if (new_call
&& e
->callee
)
1517 struct cgraph_node
*callee
= e
->callee
;
1520 if (callee
->decl
== new_call
1521 || callee
->former_clone_of
== new_call
)
1523 cgraph_set_call_stmt (e
, new_stmt
);
1526 callee
= callee
->clone_of
;
1530 /* Otherwise remove edge and create new one; we can't simply redirect
1531 since function has changed, so inline plan and other information
1532 attached to edge is invalid. */
1534 frequency
= e
->frequency
;
1535 if (e
->indirect_unknown_callee
|| e
->inline_failed
)
1536 cgraph_remove_edge (e
);
1538 cgraph_remove_node_and_inline_clones (e
->callee
, NULL
);
1542 /* We are seeing new direct call; compute profile info based on BB. */
1543 basic_block bb
= gimple_bb (new_stmt
);
1545 frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
1551 ne
= cgraph_create_edge (node
, cgraph_get_create_node (new_call
),
1552 new_stmt
, count
, frequency
);
1553 gcc_assert (ne
->inline_failed
);
1556 /* We only updated the call stmt; update pointer in cgraph edge.. */
1557 else if (old_stmt
!= new_stmt
)
1558 cgraph_set_call_stmt (cgraph_edge (node
, old_stmt
), new_stmt
);
1561 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1562 OLD_STMT changed into NEW_STMT. OLD_DECL is gimple_call_fndecl
1563 of OLD_STMT before it was updated (updating can happen inplace). */
1566 cgraph_update_edges_for_call_stmt (gimple old_stmt
, tree old_decl
, gimple new_stmt
)
1568 struct cgraph_node
*orig
= cgraph_get_node (cfun
->decl
);
1569 struct cgraph_node
*node
;
1571 gcc_checking_assert (orig
);
1572 cgraph_update_edges_for_call_stmt_node (orig
, old_stmt
, old_decl
, new_stmt
);
1574 for (node
= orig
->clones
; node
!= orig
;)
1576 cgraph_update_edges_for_call_stmt_node (node
, old_stmt
, old_decl
, new_stmt
);
1578 node
= node
->clones
;
1579 else if (node
->next_sibling_clone
)
1580 node
= node
->next_sibling_clone
;
1583 while (node
!= orig
&& !node
->next_sibling_clone
)
1584 node
= node
->clone_of
;
1586 node
= node
->next_sibling_clone
;
1592 /* Remove all callees from the node. */
1595 cgraph_node_remove_callees (struct cgraph_node
*node
)
1597 struct cgraph_edge
*e
, *f
;
1599 /* It is sufficient to remove the edges from the lists of callers of
1600 the callees. The callee list of the node can be zapped with one
1602 for (e
= node
->callees
; e
; e
= f
)
1605 cgraph_call_edge_removal_hooks (e
);
1606 if (!e
->indirect_unknown_callee
)
1607 cgraph_edge_remove_callee (e
);
1608 cgraph_free_edge (e
);
1610 for (e
= node
->indirect_calls
; e
; e
= f
)
1613 cgraph_call_edge_removal_hooks (e
);
1614 if (!e
->indirect_unknown_callee
)
1615 cgraph_edge_remove_callee (e
);
1616 cgraph_free_edge (e
);
1618 node
->indirect_calls
= NULL
;
1619 node
->callees
= NULL
;
1620 if (node
->call_site_hash
)
1622 htab_delete (node
->call_site_hash
);
1623 node
->call_site_hash
= NULL
;
1627 /* Remove all callers from the node. */
1630 cgraph_node_remove_callers (struct cgraph_node
*node
)
1632 struct cgraph_edge
*e
, *f
;
1634 /* It is sufficient to remove the edges from the lists of callees of
1635 the callers. The caller list of the node can be zapped with one
1637 for (e
= node
->callers
; e
; e
= f
)
1640 cgraph_call_edge_removal_hooks (e
);
1641 cgraph_edge_remove_caller (e
);
1642 cgraph_free_edge (e
);
1644 node
->callers
= NULL
;
1647 /* Helper function for cgraph_release_function_body and free_lang_data.
1648 It releases body from function DECL without having to inspect its
1649 possibly non-existent symtab node. */
1652 release_function_body (tree decl
)
1654 if (DECL_STRUCT_FUNCTION (decl
))
1656 push_cfun (DECL_STRUCT_FUNCTION (decl
));
1660 cfun
->curr_properties
&= ~PROP_loops
;
1661 loop_optimizer_finalize ();
1663 if (cfun
->gimple_df
)
1666 delete_tree_cfg_annotations ();
1671 gcc_assert (dom_computed
[0] == DOM_NONE
);
1672 gcc_assert (dom_computed
[1] == DOM_NONE
);
1676 if (cfun
->value_histograms
)
1679 gimple_set_body (decl
, NULL
);
1680 /* Struct function hangs a lot of data that would leak if we didn't
1681 removed all pointers to it. */
1682 ggc_free (DECL_STRUCT_FUNCTION (decl
));
1683 DECL_STRUCT_FUNCTION (decl
) = NULL
;
1685 DECL_SAVED_TREE (decl
) = NULL
;
1688 /* Release memory used to represent body of function NODE.
1689 Use this only for functions that are released before being translated to
1690 target code (i.e. RTL). Functions that are compiled to RTL and beyond
1691 are free'd in final.c via free_after_compilation(). */
1694 cgraph_release_function_body (struct cgraph_node
*node
)
1696 node
->ipa_transforms_to_apply
.release ();
1697 if (!node
->used_as_abstract_origin
&& cgraph_state
!= CGRAPH_STATE_PARSING
)
1699 DECL_RESULT (node
->decl
) = NULL
;
1700 DECL_ARGUMENTS (node
->decl
) = NULL
;
1702 /* If the node is abstract and needed, then do not clear DECL_INITIAL
1703 of its associated function function declaration because it's
1704 needed to emit debug info later. */
1705 if (!node
->used_as_abstract_origin
&& DECL_INITIAL (node
->decl
))
1706 DECL_INITIAL (node
->decl
) = error_mark_node
;
1707 release_function_body (node
->decl
);
1708 if (node
->lto_file_data
)
1709 lto_free_function_in_decl_state_for_node (node
);
1712 /* Remove the node from cgraph. */
1715 cgraph_remove_node (struct cgraph_node
*node
)
1717 struct cgraph_node
*n
;
1718 int uid
= node
->uid
;
1720 cgraph_call_node_removal_hooks (node
);
1721 cgraph_node_remove_callers (node
);
1722 cgraph_node_remove_callees (node
);
1723 node
->ipa_transforms_to_apply
.release ();
1725 /* Incremental inlining access removed nodes stored in the postorder list.
1727 node
->force_output
= false;
1728 node
->forced_by_abi
= false;
1729 for (n
= node
->nested
; n
; n
= n
->next_nested
)
1731 node
->nested
= NULL
;
1734 struct cgraph_node
**node2
= &node
->origin
->nested
;
1736 while (*node2
!= node
)
1737 node2
= &(*node2
)->next_nested
;
1738 *node2
= node
->next_nested
;
1740 symtab_unregister_node (node
);
1741 if (node
->prev_sibling_clone
)
1742 node
->prev_sibling_clone
->next_sibling_clone
= node
->next_sibling_clone
;
1743 else if (node
->clone_of
)
1744 node
->clone_of
->clones
= node
->next_sibling_clone
;
1745 if (node
->next_sibling_clone
)
1746 node
->next_sibling_clone
->prev_sibling_clone
= node
->prev_sibling_clone
;
1749 struct cgraph_node
*n
, *next
;
1753 for (n
= node
->clones
; n
->next_sibling_clone
; n
= n
->next_sibling_clone
)
1754 n
->clone_of
= node
->clone_of
;
1755 n
->clone_of
= node
->clone_of
;
1756 n
->next_sibling_clone
= node
->clone_of
->clones
;
1757 if (node
->clone_of
->clones
)
1758 node
->clone_of
->clones
->prev_sibling_clone
= n
;
1759 node
->clone_of
->clones
= node
->clones
;
1763 /* We are removing node with clones. This makes clones inconsistent,
1764 but assume they will be removed subsequently and just keep clone
1765 tree intact. This can happen in unreachable function removal since
1766 we remove unreachable functions in random order, not by bottom-up
1767 walk of clone trees. */
1768 for (n
= node
->clones
; n
; n
= next
)
1770 next
= n
->next_sibling_clone
;
1771 n
->next_sibling_clone
= NULL
;
1772 n
->prev_sibling_clone
= NULL
;
1778 /* While all the clones are removed after being proceeded, the function
1779 itself is kept in the cgraph even after it is compiled. Check whether
1780 we are done with this body and reclaim it proactively if this is the case.
1782 if (cgraph_state
!= CGRAPH_LTO_STREAMING
)
1784 n
= cgraph_get_node (node
->decl
);
1786 || (!n
->clones
&& !n
->clone_of
&& !n
->global
.inlined_to
1787 && (cgraph_global_info_ready
1788 && (TREE_ASM_WRITTEN (n
->decl
)
1789 || DECL_EXTERNAL (n
->decl
)
1791 || (!flag_wpa
&& n
->in_other_partition
)))))
1792 cgraph_release_function_body (node
);
1796 if (node
->call_site_hash
)
1798 htab_delete (node
->call_site_hash
);
1799 node
->call_site_hash
= NULL
;
1803 /* Clear out the node to NULL all pointers and add the node to the free
1805 memset (node
, 0, sizeof (*node
));
1806 node
->type
= SYMTAB_FUNCTION
;
1808 SET_NEXT_FREE_NODE (node
, free_nodes
);
1812 /* Likewise indicate that a node is having address taken. */
1815 cgraph_mark_address_taken_node (struct cgraph_node
*node
)
1817 /* Indirect inlining can figure out that all uses of the address are
1819 if (node
->global
.inlined_to
)
1821 gcc_assert (cfun
->after_inlining
);
1822 gcc_assert (node
->callers
->indirect_inlining_edge
);
1825 /* FIXME: address_taken flag is used both as a shortcut for testing whether
1826 IPA_REF_ADDR reference exists (and thus it should be set on node
1827 representing alias we take address of) and as a test whether address
1828 of the object was taken (and thus it should be set on node alias is
1829 referring to). We should remove the first use and the remove the
1831 node
->address_taken
= 1;
1832 node
= cgraph_function_or_thunk_node (node
, NULL
);
1833 node
->address_taken
= 1;
1836 /* Return local info for the compiled function. */
1838 struct cgraph_local_info
*
1839 cgraph_local_info (tree decl
)
1841 struct cgraph_node
*node
;
1843 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1844 node
= cgraph_get_node (decl
);
1847 return &node
->local
;
1850 /* Return local info for the compiled function. */
1852 struct cgraph_global_info
*
1853 cgraph_global_info (tree decl
)
1855 struct cgraph_node
*node
;
1857 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
&& cgraph_global_info_ready
);
1858 node
= cgraph_get_node (decl
);
1861 return &node
->global
;
1864 /* Return local info for the compiled function. */
1866 struct cgraph_rtl_info
*
1867 cgraph_rtl_info (tree decl
)
1869 struct cgraph_node
*node
;
1871 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1872 node
= cgraph_get_node (decl
);
1874 || (decl
!= current_function_decl
1875 && !TREE_ASM_WRITTEN (node
->decl
)))
1880 /* Return a string describing the failure REASON. */
1883 cgraph_inline_failed_string (cgraph_inline_failed_t reason
)
1886 #define DEFCIFCODE(code, type, string) string,
1888 static const char *cif_string_table
[CIF_N_REASONS
] = {
1889 #include "cif-code.def"
1892 /* Signedness of an enum type is implementation defined, so cast it
1893 to unsigned before testing. */
1894 gcc_assert ((unsigned) reason
< CIF_N_REASONS
);
1895 return cif_string_table
[reason
];
1898 /* Return a type describing the failure REASON. */
1900 cgraph_inline_failed_type_t
1901 cgraph_inline_failed_type (cgraph_inline_failed_t reason
)
1904 #define DEFCIFCODE(code, type, string) type,
1906 static cgraph_inline_failed_type_t cif_type_table
[CIF_N_REASONS
] = {
1907 #include "cif-code.def"
1910 /* Signedness of an enum type is implementation defined, so cast it
1911 to unsigned before testing. */
1912 gcc_assert ((unsigned) reason
< CIF_N_REASONS
);
1913 return cif_type_table
[reason
];
1916 /* Names used to print out the availability enum. */
1917 const char * const cgraph_availability_names
[] =
1918 {"unset", "not_available", "overwritable", "available", "local"};
1921 /* Dump call graph node NODE to file F. */
1924 dump_cgraph_node (FILE *f
, struct cgraph_node
*node
)
1926 struct cgraph_edge
*edge
;
1927 int indirect_calls_count
= 0;
1929 dump_symtab_base (f
, node
);
1931 if (node
->global
.inlined_to
)
1932 fprintf (f
, " Function %s/%i is inline copy in %s/%i\n",
1933 xstrdup (node
->name ()),
1935 xstrdup (node
->global
.inlined_to
->name ()),
1936 node
->global
.inlined_to
->order
);
1938 fprintf (f
, " Clone of %s/%i\n",
1939 node
->clone_of
->asm_name (),
1940 node
->clone_of
->order
);
1941 if (cgraph_function_flags_ready
)
1942 fprintf (f
, " Availability: %s\n",
1943 cgraph_availability_names
[cgraph_function_body_availability (node
)]);
1945 if (node
->profile_id
)
1946 fprintf (f
, " Profile id: %i\n",
1948 fprintf (f
, " First run: %i\n", node
->tp_first_run
);
1949 fprintf (f
, " Function flags:");
1951 fprintf (f
, " executed "HOST_WIDEST_INT_PRINT_DEC
"x",
1952 (HOST_WIDEST_INT
)node
->count
);
1954 fprintf (f
, " nested in: %s", node
->origin
->asm_name ());
1955 if (gimple_has_body_p (node
->decl
))
1956 fprintf (f
, " body");
1958 fprintf (f
, " process");
1959 if (node
->local
.local
)
1960 fprintf (f
, " local");
1961 if (node
->local
.redefined_extern_inline
)
1962 fprintf (f
, " redefined_extern_inline");
1963 if (node
->only_called_at_startup
)
1964 fprintf (f
, " only_called_at_startup");
1965 if (node
->only_called_at_exit
)
1966 fprintf (f
, " only_called_at_exit");
1968 fprintf (f
, " tm_clone");
1972 if (node
->thunk
.thunk_p
)
1974 fprintf (f
, " Thunk");
1975 if (node
->thunk
.alias
)
1976 fprintf (f
, " of %s (asm: %s)",
1977 lang_hooks
.decl_printable_name (node
->thunk
.alias
, 2),
1978 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (node
->thunk
.alias
)));
1979 fprintf (f
, " fixed offset %i virtual value %i has "
1980 "virtual offset %i)\n",
1981 (int)node
->thunk
.fixed_offset
,
1982 (int)node
->thunk
.virtual_value
,
1983 (int)node
->thunk
.virtual_offset_p
);
1985 if (node
->alias
&& node
->thunk
.alias
1986 && DECL_P (node
->thunk
.alias
))
1988 fprintf (f
, " Alias of %s",
1989 lang_hooks
.decl_printable_name (node
->thunk
.alias
, 2));
1990 if (DECL_ASSEMBLER_NAME_SET_P (node
->thunk
.alias
))
1991 fprintf (f
, " (asm: %s)",
1992 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (node
->thunk
.alias
)));
1996 fprintf (f
, " Called by: ");
1998 for (edge
= node
->callers
; edge
; edge
= edge
->next_caller
)
2000 fprintf (f
, "%s/%i ", edge
->caller
->asm_name (),
2001 edge
->caller
->order
);
2003 fprintf (f
, "("HOST_WIDEST_INT_PRINT_DEC
"x) ",
2004 (HOST_WIDEST_INT
)edge
->count
);
2005 if (edge
->frequency
)
2006 fprintf (f
, "(%.2f per call) ",
2007 edge
->frequency
/ (double)CGRAPH_FREQ_BASE
);
2008 if (edge
->speculative
)
2009 fprintf (f
, "(speculative) ");
2010 if (!edge
->inline_failed
)
2011 fprintf (f
, "(inlined) ");
2012 if (edge
->indirect_inlining_edge
)
2013 fprintf (f
, "(indirect_inlining) ");
2014 if (edge
->can_throw_external
)
2015 fprintf (f
, "(can throw external) ");
2018 fprintf (f
, "\n Calls: ");
2019 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
2021 fprintf (f
, "%s/%i ", edge
->callee
->asm_name (),
2022 edge
->callee
->order
);
2023 if (edge
->speculative
)
2024 fprintf (f
, "(speculative) ");
2025 if (!edge
->inline_failed
)
2026 fprintf (f
, "(inlined) ");
2027 if (edge
->indirect_inlining_edge
)
2028 fprintf (f
, "(indirect_inlining) ");
2030 fprintf (f
, "("HOST_WIDEST_INT_PRINT_DEC
"x) ",
2031 (HOST_WIDEST_INT
)edge
->count
);
2032 if (edge
->frequency
)
2033 fprintf (f
, "(%.2f per call) ",
2034 edge
->frequency
/ (double)CGRAPH_FREQ_BASE
);
2035 if (edge
->can_throw_external
)
2036 fprintf (f
, "(can throw external) ");
2040 for (edge
= node
->indirect_calls
; edge
; edge
= edge
->next_callee
)
2041 indirect_calls_count
++;
2042 if (indirect_calls_count
)
2043 fprintf (f
, " Has %i outgoing edges for indirect calls.\n",
2044 indirect_calls_count
);
2048 /* Dump call graph node NODE to stderr. */
2051 debug_cgraph_node (struct cgraph_node
*node
)
2053 dump_cgraph_node (stderr
, node
);
2057 /* Dump the callgraph to file F. */
2060 dump_cgraph (FILE *f
)
2062 struct cgraph_node
*node
;
2064 fprintf (f
, "callgraph:\n\n");
2065 FOR_EACH_FUNCTION (node
)
2066 dump_cgraph_node (f
, node
);
2070 /* Dump the call graph to stderr. */
2075 dump_cgraph (stderr
);
2078 /* Return true when the DECL can possibly be inlined. */
2080 cgraph_function_possibly_inlined_p (tree decl
)
2082 if (!cgraph_global_info_ready
)
2083 return !DECL_UNINLINABLE (decl
);
2084 return DECL_POSSIBLY_INLINED (decl
);
2087 /* NODE is no longer nested function; update cgraph accordingly. */
2089 cgraph_unnest_node (struct cgraph_node
*node
)
2091 struct cgraph_node
**node2
= &node
->origin
->nested
;
2092 gcc_assert (node
->origin
);
2094 while (*node2
!= node
)
2095 node2
= &(*node2
)->next_nested
;
2096 *node2
= node
->next_nested
;
2097 node
->origin
= NULL
;
2100 /* Return function availability. See cgraph.h for description of individual
2103 cgraph_function_body_availability (struct cgraph_node
*node
)
2105 enum availability avail
;
2106 if (!node
->analyzed
)
2107 avail
= AVAIL_NOT_AVAILABLE
;
2108 else if (node
->local
.local
)
2109 avail
= AVAIL_LOCAL
;
2110 else if (node
->alias
&& node
->weakref
)
2111 cgraph_function_or_thunk_node (node
, &avail
);
2112 else if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (node
->decl
)))
2113 avail
= AVAIL_OVERWRITABLE
;
2114 else if (!node
->externally_visible
)
2115 avail
= AVAIL_AVAILABLE
;
2116 /* Inline functions are safe to be analyzed even if their symbol can
2117 be overwritten at runtime. It is not meaningful to enforce any sane
2118 behaviour on replacing inline function by different body. */
2119 else if (DECL_DECLARED_INLINE_P (node
->decl
))
2120 avail
= AVAIL_AVAILABLE
;
2122 /* If the function can be overwritten, return OVERWRITABLE. Take
2123 care at least of two notable extensions - the COMDAT functions
2124 used to share template instantiations in C++ (this is symmetric
2125 to code cp_cannot_inline_tree_fn and probably shall be shared and
2126 the inlinability hooks completely eliminated).
2128 ??? Does the C++ one definition rule allow us to always return
2129 AVAIL_AVAILABLE here? That would be good reason to preserve this
2132 else if (decl_replaceable_p (node
->decl
)
2133 && !DECL_EXTERNAL (node
->decl
))
2134 avail
= AVAIL_OVERWRITABLE
;
2135 else avail
= AVAIL_AVAILABLE
;
2140 /* Worker for cgraph_node_can_be_local_p. */
2142 cgraph_node_cannot_be_local_p_1 (struct cgraph_node
*node
,
2143 void *data ATTRIBUTE_UNUSED
)
2145 return !(!node
->force_output
2146 && ((DECL_COMDAT (node
->decl
)
2147 && !node
->forced_by_abi
2148 && !symtab_used_from_object_file_p (node
)
2149 && !node
->same_comdat_group
)
2150 || !node
->externally_visible
));
2153 /* Return true if NODE can be made local for API change.
2154 Extern inline functions and C++ COMDAT functions can be made local
2155 at the expense of possible code size growth if function is used in multiple
2156 compilation units. */
2158 cgraph_node_can_be_local_p (struct cgraph_node
*node
)
2160 return (!node
->address_taken
2161 && !cgraph_for_node_and_aliases (node
,
2162 cgraph_node_cannot_be_local_p_1
,
2166 /* Call calback on NODE, thunks and aliases associated to NODE.
2167 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
2171 cgraph_for_node_thunks_and_aliases (struct cgraph_node
*node
,
2172 bool (*callback
) (struct cgraph_node
*, void *),
2174 bool include_overwritable
)
2176 struct cgraph_edge
*e
;
2178 struct ipa_ref
*ref
;
2180 if (callback (node
, data
))
2182 for (e
= node
->callers
; e
; e
= e
->next_caller
)
2183 if (e
->caller
->thunk
.thunk_p
2184 && (include_overwritable
2185 || cgraph_function_body_availability (e
->caller
) > AVAIL_OVERWRITABLE
))
2186 if (cgraph_for_node_thunks_and_aliases (e
->caller
, callback
, data
,
2187 include_overwritable
))
2189 for (i
= 0; ipa_ref_list_referring_iterate (&node
->ref_list
, i
, ref
); i
++)
2190 if (ref
->use
== IPA_REF_ALIAS
)
2192 struct cgraph_node
*alias
= ipa_ref_referring_node (ref
);
2193 if (include_overwritable
2194 || cgraph_function_body_availability (alias
) > AVAIL_OVERWRITABLE
)
2195 if (cgraph_for_node_thunks_and_aliases (alias
, callback
, data
,
2196 include_overwritable
))
2202 /* Call calback on NODE and aliases associated to NODE.
2203 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
2207 cgraph_for_node_and_aliases (struct cgraph_node
*node
,
2208 bool (*callback
) (struct cgraph_node
*, void *),
2210 bool include_overwritable
)
2213 struct ipa_ref
*ref
;
2215 if (callback (node
, data
))
2217 for (i
= 0; ipa_ref_list_referring_iterate (&node
->ref_list
, i
, ref
); i
++)
2218 if (ref
->use
== IPA_REF_ALIAS
)
2220 struct cgraph_node
*alias
= ipa_ref_referring_node (ref
);
2221 if (include_overwritable
2222 || cgraph_function_body_availability (alias
) > AVAIL_OVERWRITABLE
)
2223 if (cgraph_for_node_and_aliases (alias
, callback
, data
,
2224 include_overwritable
))
2230 /* Worker to bring NODE local. */
2233 cgraph_make_node_local_1 (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
2235 gcc_checking_assert (cgraph_node_can_be_local_p (node
));
2236 if (DECL_COMDAT (node
->decl
) || DECL_EXTERNAL (node
->decl
))
2238 symtab_make_decl_local (node
->decl
);
2240 node
->externally_visible
= false;
2241 node
->forced_by_abi
= false;
2242 node
->local
.local
= true;
2243 node
->unique_name
= (node
->resolution
== LDPR_PREVAILING_DEF_IRONLY
2244 || node
->resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
);
2245 node
->resolution
= LDPR_PREVAILING_DEF_IRONLY
;
2246 gcc_assert (cgraph_function_body_availability (node
) == AVAIL_LOCAL
);
2251 /* Bring NODE local. */
2254 cgraph_make_node_local (struct cgraph_node
*node
)
2256 cgraph_for_node_thunks_and_aliases (node
, cgraph_make_node_local_1
,
2260 /* Worker to set nothrow flag. */
2263 cgraph_set_nothrow_flag_1 (struct cgraph_node
*node
, void *data
)
2265 struct cgraph_edge
*e
;
2267 TREE_NOTHROW (node
->decl
) = data
!= NULL
;
2270 for (e
= node
->callers
; e
; e
= e
->next_caller
)
2271 e
->can_throw_external
= false;
2275 /* Set TREE_NOTHROW on NODE's decl and on aliases of NODE
2276 if any to NOTHROW. */
2279 cgraph_set_nothrow_flag (struct cgraph_node
*node
, bool nothrow
)
2281 cgraph_for_node_thunks_and_aliases (node
, cgraph_set_nothrow_flag_1
,
2282 (void *)(size_t)nothrow
, false);
2285 /* Worker to set const flag. */
2288 cgraph_set_const_flag_1 (struct cgraph_node
*node
, void *data
)
2290 /* Static constructors and destructors without a side effect can be
2292 if (data
&& !((size_t)data
& 2))
2294 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
2295 DECL_STATIC_CONSTRUCTOR (node
->decl
) = 0;
2296 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
2297 DECL_STATIC_DESTRUCTOR (node
->decl
) = 0;
2299 TREE_READONLY (node
->decl
) = data
!= NULL
;
2300 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = ((size_t)data
& 2) != 0;
2304 /* Set TREE_READONLY on NODE's decl and on aliases of NODE
2305 if any to READONLY. */
2308 cgraph_set_const_flag (struct cgraph_node
*node
, bool readonly
, bool looping
)
2310 cgraph_for_node_thunks_and_aliases (node
, cgraph_set_const_flag_1
,
2311 (void *)(size_t)(readonly
+ (int)looping
* 2),
2315 /* Worker to set pure flag. */
2318 cgraph_set_pure_flag_1 (struct cgraph_node
*node
, void *data
)
2320 /* Static constructors and destructors without a side effect can be
2322 if (data
&& !((size_t)data
& 2))
2324 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
2325 DECL_STATIC_CONSTRUCTOR (node
->decl
) = 0;
2326 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
2327 DECL_STATIC_DESTRUCTOR (node
->decl
) = 0;
2329 DECL_PURE_P (node
->decl
) = data
!= NULL
;
2330 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = ((size_t)data
& 2) != 0;
2334 /* Set DECL_PURE_P on NODE's decl and on aliases of NODE
2338 cgraph_set_pure_flag (struct cgraph_node
*node
, bool pure
, bool looping
)
2340 cgraph_for_node_thunks_and_aliases (node
, cgraph_set_pure_flag_1
,
2341 (void *)(size_t)(pure
+ (int)looping
* 2),
2345 /* Return true when NODE can not return or throw and thus
2346 it is safe to ignore its side effects for IPA analysis. */
2349 cgraph_node_cannot_return (struct cgraph_node
*node
)
2351 int flags
= flags_from_decl_or_type (node
->decl
);
2352 if (!flag_exceptions
)
2353 return (flags
& ECF_NORETURN
) != 0;
2355 return ((flags
& (ECF_NORETURN
| ECF_NOTHROW
))
2356 == (ECF_NORETURN
| ECF_NOTHROW
));
2359 /* Return true when call of E can not lead to return from caller
2360 and thus it is safe to ignore its side effects for IPA analysis
2361 when computing side effects of the caller.
2362 FIXME: We could actually mark all edges that have no reaching
2363 patch to the exit block or throw to get better results. */
2365 cgraph_edge_cannot_lead_to_return (struct cgraph_edge
*e
)
2367 if (cgraph_node_cannot_return (e
->caller
))
2369 if (e
->indirect_unknown_callee
)
2371 int flags
= e
->indirect_info
->ecf_flags
;
2372 if (!flag_exceptions
)
2373 return (flags
& ECF_NORETURN
) != 0;
2375 return ((flags
& (ECF_NORETURN
| ECF_NOTHROW
))
2376 == (ECF_NORETURN
| ECF_NOTHROW
));
2379 return cgraph_node_cannot_return (e
->callee
);
2382 /* Return true when function NODE can be removed from callgraph
2383 if all direct calls are eliminated. */
2386 cgraph_can_remove_if_no_direct_calls_and_refs_p (struct cgraph_node
*node
)
2388 gcc_assert (!node
->global
.inlined_to
);
2389 /* Extern inlines can always go, we will use the external definition. */
2390 if (DECL_EXTERNAL (node
->decl
))
2392 /* When function is needed, we can not remove it. */
2393 if (node
->force_output
|| node
->used_from_other_partition
)
2395 if (DECL_STATIC_CONSTRUCTOR (node
->decl
)
2396 || DECL_STATIC_DESTRUCTOR (node
->decl
))
2398 /* Only COMDAT functions can be removed if externally visible. */
2399 if (node
->externally_visible
2400 && (!DECL_COMDAT (node
->decl
)
2401 || node
->forced_by_abi
2402 || symtab_used_from_object_file_p (node
)))
2407 /* Worker for cgraph_can_remove_if_no_direct_calls_p. */
2410 nonremovable_p (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
2412 return !cgraph_can_remove_if_no_direct_calls_and_refs_p (node
);
2415 /* Return true when function NODE and its aliases can be removed from callgraph
2416 if all direct calls are eliminated. */
2419 cgraph_can_remove_if_no_direct_calls_p (struct cgraph_node
*node
)
2421 /* Extern inlines can always go, we will use the external definition. */
2422 if (DECL_EXTERNAL (node
->decl
))
2424 if (node
->address_taken
)
2426 return !cgraph_for_node_and_aliases (node
, nonremovable_p
, NULL
, true);
2429 /* Worker for cgraph_can_remove_if_no_direct_calls_p. */
2432 used_from_object_file_p (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
2434 return symtab_used_from_object_file_p (node
);
2437 /* Return true when function NODE can be expected to be removed
2438 from program when direct calls in this compilation unit are removed.
2440 As a special case COMDAT functions are
2441 cgraph_can_remove_if_no_direct_calls_p while the are not
2442 cgraph_only_called_directly_p (it is possible they are called from other
2445 This function behaves as cgraph_only_called_directly_p because eliminating
2446 all uses of COMDAT function does not make it necessarily disappear from
2447 the program unless we are compiling whole program or we do LTO. In this
2448 case we know we win since dynamic linking will not really discard the
2449 linkonce section. */
2452 cgraph_will_be_removed_from_program_if_no_direct_calls (struct cgraph_node
*node
)
2454 gcc_assert (!node
->global
.inlined_to
);
2455 if (cgraph_for_node_and_aliases (node
, used_from_object_file_p
, NULL
, true))
2457 if (!in_lto_p
&& !flag_whole_program
)
2458 return cgraph_only_called_directly_p (node
);
2461 if (DECL_EXTERNAL (node
->decl
))
2463 return cgraph_can_remove_if_no_direct_calls_p (node
);
2468 /* Worker for cgraph_only_called_directly_p. */
2471 cgraph_not_only_called_directly_p_1 (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
2473 return !cgraph_only_called_directly_or_aliased_p (node
);
2476 /* Return true when function NODE and all its aliases are only called
2478 i.e. it is not externally visible, address was not taken and
2479 it is not used in any other non-standard way. */
2482 cgraph_only_called_directly_p (struct cgraph_node
*node
)
2484 gcc_assert (cgraph_function_or_thunk_node (node
, NULL
) == node
);
2485 return !cgraph_for_node_and_aliases (node
, cgraph_not_only_called_directly_p_1
,
2490 /* Collect all callers of NODE. Worker for collect_callers_of_node. */
2493 collect_callers_of_node_1 (struct cgraph_node
*node
, void *data
)
2495 vec
<cgraph_edge_p
> *redirect_callers
= (vec
<cgraph_edge_p
> *)data
;
2496 struct cgraph_edge
*cs
;
2497 enum availability avail
;
2498 cgraph_function_or_thunk_node (node
, &avail
);
2500 if (avail
> AVAIL_OVERWRITABLE
)
2501 for (cs
= node
->callers
; cs
!= NULL
; cs
= cs
->next_caller
)
2502 if (!cs
->indirect_inlining_edge
)
2503 redirect_callers
->safe_push (cs
);
2507 /* Collect all callers of NODE and its aliases that are known to lead to NODE
2508 (i.e. are not overwritable). */
2511 collect_callers_of_node (struct cgraph_node
*node
)
2513 vec
<cgraph_edge_p
> redirect_callers
= vNULL
;
2514 cgraph_for_node_and_aliases (node
, collect_callers_of_node_1
,
2515 &redirect_callers
, false);
2516 return redirect_callers
;
2519 /* Return TRUE if NODE2 is equivalent to NODE or its clone. */
2521 clone_of_p (struct cgraph_node
*node
, struct cgraph_node
*node2
)
2523 node
= cgraph_function_or_thunk_node (node
, NULL
);
2524 node2
= cgraph_function_or_thunk_node (node2
, NULL
);
2525 while (node
!= node2
&& node2
)
2526 node2
= node2
->clone_of
;
2527 return node2
!= NULL
;
2530 /* Verify edge E count and frequency. */
2533 verify_edge_count_and_frequency (struct cgraph_edge
*e
)
2535 bool error_found
= false;
2538 error ("caller edge count is negative");
2541 if (e
->frequency
< 0)
2543 error ("caller edge frequency is negative");
2546 if (e
->frequency
> CGRAPH_FREQ_MAX
)
2548 error ("caller edge frequency is too large");
2551 if (gimple_has_body_p (e
->caller
->decl
)
2552 && !e
->caller
->global
.inlined_to
2554 /* FIXME: Inline-analysis sets frequency to 0 when edge is optimized out.
2555 Remove this once edges are actually removed from the function at that time. */
2557 || (inline_edge_summary_vec
.exists ()
2558 && ((inline_edge_summary_vec
.length () <= (unsigned) e
->uid
)
2559 || !inline_edge_summary (e
)->predicate
)))
2561 != compute_call_stmt_bb_frequency (e
->caller
->decl
,
2562 gimple_bb (e
->call_stmt
))))
2564 error ("caller edge frequency %i does not match BB frequency %i",
2566 compute_call_stmt_bb_frequency (e
->caller
->decl
,
2567 gimple_bb (e
->call_stmt
)));
2573 /* Switch to THIS_CFUN if needed and print STMT to stderr. */
2575 cgraph_debug_gimple_stmt (struct function
*this_cfun
, gimple stmt
)
2577 bool fndecl_was_null
= false;
2578 /* debug_gimple_stmt needs correct cfun */
2579 if (cfun
!= this_cfun
)
2580 set_cfun (this_cfun
);
2581 /* ...and an actual current_function_decl */
2582 if (!current_function_decl
)
2584 current_function_decl
= this_cfun
->decl
;
2585 fndecl_was_null
= true;
2587 debug_gimple_stmt (stmt
);
2588 if (fndecl_was_null
)
2589 current_function_decl
= NULL
;
2592 /* Verify that call graph edge E corresponds to DECL from the associated
2593 statement. Return true if the verification should fail. */
2596 verify_edge_corresponds_to_fndecl (struct cgraph_edge
*e
, tree decl
)
2598 struct cgraph_node
*node
;
2600 if (!decl
|| e
->callee
->global
.inlined_to
)
2602 if (cgraph_state
== CGRAPH_LTO_STREAMING
)
2604 node
= cgraph_get_node (decl
);
2606 /* We do not know if a node from a different partition is an alias or what it
2607 aliases and therefore cannot do the former_clone_of check reliably. When
2608 body_removed is set, we have lost all information about what was alias or
2609 thunk of and also cannot proceed. */
2611 || node
->body_removed
2612 || node
->in_other_partition
2613 || e
->callee
->in_other_partition
)
2616 /* Optimizers can redirect unreachable calls or calls triggering undefined
2617 behaviour to builtin_unreachable. */
2618 if (DECL_BUILT_IN_CLASS (e
->callee
->decl
) == BUILT_IN_NORMAL
2619 && DECL_FUNCTION_CODE (e
->callee
->decl
) == BUILT_IN_UNREACHABLE
)
2621 node
= cgraph_function_or_thunk_node (node
, NULL
);
2623 if (e
->callee
->former_clone_of
!= node
->decl
2624 /* IPA-CP sometimes redirect edge to clone and then back to the former
2625 function. This ping-pong has to go, eventually. */
2626 && (node
!= cgraph_function_or_thunk_node (e
->callee
, NULL
))
2627 && !clone_of_p (cgraph_function_or_thunk_node (node
, NULL
), e
->callee
))
2633 /* Verify cgraph nodes of given cgraph node. */
2635 verify_cgraph_node (struct cgraph_node
*node
)
2637 struct cgraph_edge
*e
;
2638 struct function
*this_cfun
= DECL_STRUCT_FUNCTION (node
->decl
);
2639 basic_block this_block
;
2640 gimple_stmt_iterator gsi
;
2641 bool error_found
= false;
2646 timevar_push (TV_CGRAPH_VERIFY
);
2647 error_found
|= verify_symtab_base (node
);
2648 for (e
= node
->callees
; e
; e
= e
->next_callee
)
2651 error ("aux field set for edge %s->%s",
2652 identifier_to_locale (e
->caller
->name ()),
2653 identifier_to_locale (e
->callee
->name ()));
2656 if (node
->count
< 0)
2658 error ("execution count is negative");
2661 if (node
->global
.inlined_to
&& node
->same_comdat_group
)
2663 error ("inline clone in same comdat group list");
2666 if (!node
->definition
&& !node
->in_other_partition
&& node
->local
.local
)
2668 error ("local symbols must be defined");
2671 if (node
->global
.inlined_to
&& node
->externally_visible
)
2673 error ("externally visible inline clone");
2676 if (node
->global
.inlined_to
&& node
->address_taken
)
2678 error ("inline clone with address taken");
2681 if (node
->global
.inlined_to
&& node
->force_output
)
2683 error ("inline clone is forced to output");
2686 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
2690 error ("aux field set for indirect edge from %s",
2691 identifier_to_locale (e
->caller
->name ()));
2694 if (!e
->indirect_unknown_callee
2695 || !e
->indirect_info
)
2697 error ("An indirect edge from %s is not marked as indirect or has "
2698 "associated indirect_info, the corresponding statement is: ",
2699 identifier_to_locale (e
->caller
->name ()));
2700 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
2704 bool check_comdat
= symtab_comdat_local_p (node
);
2705 for (e
= node
->callers
; e
; e
= e
->next_caller
)
2707 if (verify_edge_count_and_frequency (e
))
2710 && !symtab_in_same_comdat_p (e
->caller
, node
))
2712 error ("comdat-local function called by %s outside its comdat",
2713 identifier_to_locale (e
->caller
->name ()));
2716 if (!e
->inline_failed
)
2718 if (node
->global
.inlined_to
2719 != (e
->caller
->global
.inlined_to
2720 ? e
->caller
->global
.inlined_to
: e
->caller
))
2722 error ("inlined_to pointer is wrong");
2725 if (node
->callers
->next_caller
)
2727 error ("multiple inline callers");
2732 if (node
->global
.inlined_to
)
2734 error ("inlined_to pointer set for noninline callers");
2738 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
2739 if (verify_edge_count_and_frequency (e
))
2741 if (!node
->callers
&& node
->global
.inlined_to
)
2743 error ("inlined_to pointer is set but no predecessors found");
2746 if (node
->global
.inlined_to
== node
)
2748 error ("inlined_to pointer refers to itself");
2754 struct cgraph_node
*n
;
2755 for (n
= node
->clone_of
->clones
; n
; n
= n
->next_sibling_clone
)
2760 error ("node has wrong clone_of");
2766 struct cgraph_node
*n
;
2767 for (n
= node
->clones
; n
; n
= n
->next_sibling_clone
)
2768 if (n
->clone_of
!= node
)
2772 error ("node has wrong clone list");
2776 if ((node
->prev_sibling_clone
|| node
->next_sibling_clone
) && !node
->clone_of
)
2778 error ("node is in clone list but it is not clone");
2781 if (!node
->prev_sibling_clone
&& node
->clone_of
&& node
->clone_of
->clones
!= node
)
2783 error ("node has wrong prev_clone pointer");
2786 if (node
->prev_sibling_clone
&& node
->prev_sibling_clone
->next_sibling_clone
!= node
)
2788 error ("double linked list of clones corrupted");
2792 if (node
->analyzed
&& node
->alias
)
2794 bool ref_found
= false;
2796 struct ipa_ref
*ref
;
2800 error ("Alias has call edges");
2803 for (i
= 0; ipa_ref_list_reference_iterate (&node
->ref_list
,
2805 if (ref
->use
!= IPA_REF_ALIAS
)
2807 error ("Alias has non-alias reference");
2812 error ("Alias has more than one alias reference");
2819 error ("Analyzed alias has no reference");
2823 if (node
->analyzed
&& node
->thunk
.thunk_p
)
2827 error ("No edge out of thunk node");
2830 else if (node
->callees
->next_callee
)
2832 error ("More than one edge out of thunk node");
2835 if (gimple_has_body_p (node
->decl
))
2837 error ("Thunk is not supposed to have body");
2841 else if (node
->analyzed
&& gimple_has_body_p (node
->decl
)
2842 && !TREE_ASM_WRITTEN (node
->decl
)
2843 && (!DECL_EXTERNAL (node
->decl
) || node
->global
.inlined_to
)
2848 pointer_set_t
*stmts
= pointer_set_create ();
2850 struct ipa_ref
*ref
;
2852 /* Reach the trees by walking over the CFG, and note the
2853 enclosing basic-blocks in the call edges. */
2854 FOR_EACH_BB_FN (this_block
, this_cfun
)
2856 for (gsi
= gsi_start_phis (this_block
);
2857 !gsi_end_p (gsi
); gsi_next (&gsi
))
2858 pointer_set_insert (stmts
, gsi_stmt (gsi
));
2859 for (gsi
= gsi_start_bb (this_block
);
2863 gimple stmt
= gsi_stmt (gsi
);
2864 pointer_set_insert (stmts
, stmt
);
2865 if (is_gimple_call (stmt
))
2867 struct cgraph_edge
*e
= cgraph_edge (node
, stmt
);
2868 tree decl
= gimple_call_fndecl (stmt
);
2873 error ("shared call_stmt:");
2874 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
2877 if (!e
->indirect_unknown_callee
)
2879 if (verify_edge_corresponds_to_fndecl (e
, decl
))
2881 error ("edge points to wrong declaration:");
2882 debug_tree (e
->callee
->decl
);
2883 fprintf (stderr
," Instead of:");
2890 error ("an indirect edge with unknown callee "
2891 "corresponding to a call_stmt with "
2892 "a known declaration:");
2894 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
2900 error ("missing callgraph edge for call stmt:");
2901 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
2908 ipa_ref_list_reference_iterate (&node
->ref_list
, i
, ref
);
2910 if (ref
->stmt
&& !pointer_set_contains (stmts
, ref
->stmt
))
2912 error ("reference to dead statement");
2913 cgraph_debug_gimple_stmt (this_cfun
, ref
->stmt
);
2916 pointer_set_destroy (stmts
);
2919 /* No CFG available?! */
2922 for (e
= node
->callees
; e
; e
= e
->next_callee
)
2926 error ("edge %s->%s has no corresponding call_stmt",
2927 identifier_to_locale (e
->caller
->name ()),
2928 identifier_to_locale (e
->callee
->name ()));
2929 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
2934 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
2936 if (!e
->aux
&& !e
->speculative
)
2938 error ("an indirect edge from %s has no corresponding call_stmt",
2939 identifier_to_locale (e
->caller
->name ()));
2940 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
2948 dump_cgraph_node (stderr
, node
);
2949 internal_error ("verify_cgraph_node failed");
2951 timevar_pop (TV_CGRAPH_VERIFY
);
2954 /* Verify whole cgraph structure. */
2956 verify_cgraph (void)
2958 struct cgraph_node
*node
;
2963 FOR_EACH_FUNCTION (node
)
2964 verify_cgraph_node (node
);
2967 /* Given NODE, walk the alias chain to return the function NODE is alias of.
2968 Walk through thunk, too.
2969 When AVAILABILITY is non-NULL, get minimal availability in the chain. */
2971 struct cgraph_node
*
2972 cgraph_function_node (struct cgraph_node
*node
, enum availability
*availability
)
2976 node
= cgraph_function_or_thunk_node (node
, availability
);
2977 if (node
->thunk
.thunk_p
)
2979 node
= node
->callees
->callee
;
2982 enum availability a
;
2983 a
= cgraph_function_body_availability (node
);
2984 if (a
< *availability
)
2987 node
= cgraph_function_or_thunk_node (node
, availability
);
2989 } while (node
&& node
->thunk
.thunk_p
);
2993 /* When doing LTO, read NODE's body from disk if it is not already present. */
2996 cgraph_get_body (struct cgraph_node
*node
)
2998 struct lto_file_decl_data
*file_data
;
2999 const char *data
, *name
;
3001 tree decl
= node
->decl
;
3003 if (DECL_RESULT (decl
))
3006 gcc_assert (in_lto_p
);
3008 file_data
= node
->lto_file_data
;
3009 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
3011 /* We may have renamed the declaration, e.g., a static function. */
3012 name
= lto_get_decl_name_mapping (file_data
, name
);
3014 data
= lto_get_section_data (file_data
, LTO_section_function_body
,
3018 dump_cgraph_node (stderr
, node
);
3019 fatal_error ("%s: section %s is missing",
3020 file_data
->file_name
,
3024 gcc_assert (DECL_STRUCT_FUNCTION (decl
) == NULL
);
3026 lto_input_function_body (file_data
, node
, data
);
3027 lto_stats
.num_function_bodies
++;
3028 lto_free_section_data (file_data
, LTO_section_function_body
, name
,
3030 lto_free_function_in_decl_state_for_node (node
);
3034 /* Verify if the type of the argument matches that of the function
3035 declaration. If we cannot verify this or there is a mismatch,
3039 gimple_check_call_args (gimple stmt
, tree fndecl
, bool args_count_match
)
3042 unsigned int i
, nargs
;
3044 /* Calls to internal functions always match their signature. */
3045 if (gimple_call_internal_p (stmt
))
3048 nargs
= gimple_call_num_args (stmt
);
3050 /* Get argument types for verification. */
3052 parms
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
3054 parms
= TYPE_ARG_TYPES (gimple_call_fntype (stmt
));
3056 /* Verify if the type of the argument matches that of the function
3057 declaration. If we cannot verify this or there is a mismatch,
3059 if (fndecl
&& DECL_ARGUMENTS (fndecl
))
3061 for (i
= 0, p
= DECL_ARGUMENTS (fndecl
);
3063 i
++, p
= DECL_CHAIN (p
))
3066 /* We cannot distinguish a varargs function from the case
3067 of excess parameters, still deferring the inlining decision
3068 to the callee is possible. */
3071 arg
= gimple_call_arg (stmt
, i
);
3072 if (p
== error_mark_node
3073 || DECL_ARG_TYPE (p
) == error_mark_node
3074 || arg
== error_mark_node
3075 || (!types_compatible_p (DECL_ARG_TYPE (p
), TREE_TYPE (arg
))
3076 && !fold_convertible_p (DECL_ARG_TYPE (p
), arg
)))
3079 if (args_count_match
&& p
)
3084 for (i
= 0, p
= parms
; i
< nargs
; i
++, p
= TREE_CHAIN (p
))
3087 /* If this is a varargs function defer inlining decision
3091 arg
= gimple_call_arg (stmt
, i
);
3092 if (TREE_VALUE (p
) == error_mark_node
3093 || arg
== error_mark_node
3094 || TREE_CODE (TREE_VALUE (p
)) == VOID_TYPE
3095 || (!types_compatible_p (TREE_VALUE (p
), TREE_TYPE (arg
))
3096 && !fold_convertible_p (TREE_VALUE (p
), arg
)))
3108 /* Verify if the type of the argument and lhs of CALL_STMT matches
3109 that of the function declaration CALLEE. If ARGS_COUNT_MATCH is
3110 true, the arg count needs to be the same.
3111 If we cannot verify this or there is a mismatch, return false. */
3114 gimple_check_call_matching_types (gimple call_stmt
, tree callee
,
3115 bool args_count_match
)
3119 if ((DECL_RESULT (callee
)
3120 && !DECL_BY_REFERENCE (DECL_RESULT (callee
))
3121 && (lhs
= gimple_call_lhs (call_stmt
)) != NULL_TREE
3122 && !useless_type_conversion_p (TREE_TYPE (DECL_RESULT (callee
)),
3124 && !fold_convertible_p (TREE_TYPE (DECL_RESULT (callee
)), lhs
))
3125 || !gimple_check_call_args (call_stmt
, callee
, args_count_match
))
3130 #include "gt-cgraph.h"