1 /* Callgraph handling code.
2 Copyright (C) 2003-2023 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 inter-procedural
24 optimization. It represents a multi-graph where nodes are functions
25 (symbols within symbol table) and edges are call sites. */
29 #include "coretypes.h"
36 #include "alloc-pool.h"
37 #include "gimple-ssa.h"
39 #include "lto-streamer.h"
40 #include "fold-const.h"
43 #include "print-tree.h"
44 #include "langhooks.h"
47 #include "gimple-iterator.h"
50 #include "value-prof.h"
51 #include "ipa-utils.h"
52 #include "symbol-summary.h"
55 #include "ipa-fnsummary.h"
57 #include "gimple-pretty-print.h"
62 #include "stringpool.h"
65 #include "tree-into-ssa.h"
66 #include "ipa-inline.h"
67 #include "tree-nested.h"
68 #include "symtab-thunks.h"
69 #include "symtab-clones.h"
71 /* FIXME: Only for PROP_loops, but cgraph shouldn't have to know about this. */
72 #include "tree-pass.h"
74 /* Queue of cgraph nodes scheduled to be lowered. */
75 symtab_node
*x_cgraph_nodes_queue
;
76 #define cgraph_nodes_queue ((cgraph_node *)x_cgraph_nodes_queue)
78 /* Symbol table global context. */
81 /* List of hooks triggered on cgraph_edge events. */
82 struct cgraph_edge_hook_list
{
83 cgraph_edge_hook hook
;
85 struct cgraph_edge_hook_list
*next
;
88 /* List of hooks triggered on cgraph_node events. */
89 struct cgraph_node_hook_list
{
90 cgraph_node_hook hook
;
92 struct cgraph_node_hook_list
*next
;
95 /* List of hooks triggered on events involving two cgraph_edges. */
96 struct cgraph_2edge_hook_list
{
97 cgraph_2edge_hook hook
;
99 struct cgraph_2edge_hook_list
*next
;
102 /* List of hooks triggered on events involving two cgraph_nodes. */
103 struct cgraph_2node_hook_list
{
104 cgraph_2node_hook hook
;
106 struct cgraph_2node_hook_list
*next
;
109 /* Hash descriptor for cgraph_function_version_info. */
111 struct function_version_hasher
: ggc_ptr_hash
<cgraph_function_version_info
>
113 static hashval_t
hash (cgraph_function_version_info
*);
114 static bool equal (cgraph_function_version_info
*,
115 cgraph_function_version_info
*);
118 /* Map a cgraph_node to cgraph_function_version_info using this htab.
119 The cgraph_function_version_info has a THIS_NODE field that is the
120 corresponding cgraph_node.. */
122 static GTY(()) hash_table
<function_version_hasher
> *cgraph_fnver_htab
= NULL
;
124 /* Hash function for cgraph_fnver_htab. */
126 function_version_hasher::hash (cgraph_function_version_info
*ptr
)
128 int uid
= ptr
->this_node
->get_uid ();
129 return (hashval_t
)(uid
);
132 /* eq function for cgraph_fnver_htab. */
134 function_version_hasher::equal (cgraph_function_version_info
*n1
,
135 cgraph_function_version_info
*n2
)
137 return n1
->this_node
->get_uid () == n2
->this_node
->get_uid ();
140 /* Mark as GC root all allocated nodes. */
141 static GTY(()) struct cgraph_function_version_info
*
142 version_info_node
= NULL
;
144 /* Return true if NODE's address can be compared. */
147 symtab_node::address_can_be_compared_p ()
149 /* Address of virtual tables and functions is never compared. */
150 if (DECL_VIRTUAL_P (decl
))
152 /* Address of C++ cdtors is never compared. */
153 if (is_a
<cgraph_node
*> (this)
154 && (DECL_CXX_CONSTRUCTOR_P (decl
)
155 || DECL_CXX_DESTRUCTOR_P (decl
)))
157 /* Constant pool symbols addresses are never compared.
158 flag_merge_constants permits us to assume the same on readonly vars. */
159 if (is_a
<varpool_node
*> (this)
160 && (DECL_IN_CONSTANT_POOL (decl
)
161 || (flag_merge_constants
>= 2
162 && TREE_READONLY (decl
) && !TREE_THIS_VOLATILE (decl
))))
167 /* Get the cgraph_function_version_info node corresponding to node. */
168 cgraph_function_version_info
*
169 cgraph_node::function_version (void)
171 cgraph_function_version_info key
;
172 key
.this_node
= this;
174 if (cgraph_fnver_htab
== NULL
)
177 return cgraph_fnver_htab
->find (&key
);
180 /* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
181 corresponding to cgraph_node NODE. */
182 cgraph_function_version_info
*
183 cgraph_node::insert_new_function_version (void)
185 version_info_node
= NULL
;
186 version_info_node
= ggc_cleared_alloc
<cgraph_function_version_info
> ();
187 version_info_node
->this_node
= this;
189 if (cgraph_fnver_htab
== NULL
)
190 cgraph_fnver_htab
= hash_table
<function_version_hasher
>::create_ggc (2);
192 *cgraph_fnver_htab
->find_slot (version_info_node
, INSERT
)
194 return version_info_node
;
197 /* Remove the cgraph_function_version_info node given by DECL_V. */
199 delete_function_version (cgraph_function_version_info
*decl_v
)
204 if (version_info_node
== decl_v
)
205 version_info_node
= NULL
;
207 if (decl_v
->prev
!= NULL
)
208 decl_v
->prev
->next
= decl_v
->next
;
210 if (decl_v
->next
!= NULL
)
211 decl_v
->next
->prev
= decl_v
->prev
;
213 if (cgraph_fnver_htab
!= NULL
)
214 cgraph_fnver_htab
->remove_elt (decl_v
);
217 /* Remove the cgraph_function_version_info and cgraph_node for DECL. This
218 DECL is a duplicate declaration. */
220 cgraph_node::delete_function_version_by_decl (tree decl
)
222 cgraph_node
*decl_node
= cgraph_node::get (decl
);
224 if (decl_node
== NULL
)
227 delete_function_version (decl_node
->function_version ());
229 decl_node
->remove ();
232 /* Record that DECL1 and DECL2 are semantically identical function
235 cgraph_node::record_function_versions (tree decl1
, tree decl2
)
237 cgraph_node
*decl1_node
= cgraph_node::get_create (decl1
);
238 cgraph_node
*decl2_node
= cgraph_node::get_create (decl2
);
239 cgraph_function_version_info
*decl1_v
= NULL
;
240 cgraph_function_version_info
*decl2_v
= NULL
;
241 cgraph_function_version_info
*before
;
242 cgraph_function_version_info
*after
;
244 gcc_assert (decl1_node
!= NULL
&& decl2_node
!= NULL
);
245 decl1_v
= decl1_node
->function_version ();
246 decl2_v
= decl2_node
->function_version ();
248 if (decl1_v
!= NULL
&& decl2_v
!= NULL
)
252 decl1_v
= decl1_node
->insert_new_function_version ();
255 decl2_v
= decl2_node
->insert_new_function_version ();
257 /* Chain decl2_v and decl1_v. All semantically identical versions
258 will be chained together. */
263 while (before
->next
!= NULL
)
264 before
= before
->next
;
266 while (after
->prev
!= NULL
)
269 before
->next
= after
;
270 after
->prev
= before
;
273 /* Initialize callgraph dump file. */
276 symbol_table::initialize (void)
279 dump_file
= dump_begin (TDI_cgraph
, NULL
);
281 if (!ipa_clones_dump_file
)
282 ipa_clones_dump_file
= dump_begin (TDI_clones
, NULL
);
285 /* Allocate new callgraph node and insert it into basic data structures. */
288 symbol_table::create_empty (void)
291 return new (ggc_alloc
<cgraph_node
> ()) cgraph_node (cgraph_max_uid
++);
294 /* Register HOOK to be called with DATA on each removed edge. */
295 cgraph_edge_hook_list
*
296 symbol_table::add_edge_removal_hook (cgraph_edge_hook hook
, void *data
)
298 cgraph_edge_hook_list
*entry
;
299 cgraph_edge_hook_list
**ptr
= &m_first_edge_removal_hook
;
301 entry
= (cgraph_edge_hook_list
*) xmalloc (sizeof (*entry
));
311 /* Remove ENTRY from the list of hooks called on removing edges. */
313 symbol_table::remove_edge_removal_hook (cgraph_edge_hook_list
*entry
)
315 cgraph_edge_hook_list
**ptr
= &m_first_edge_removal_hook
;
317 while (*ptr
!= entry
)
323 /* Call all edge removal hooks. */
325 symbol_table::call_edge_removal_hooks (cgraph_edge
*e
)
327 cgraph_edge_hook_list
*entry
= m_first_edge_removal_hook
;
330 entry
->hook (e
, entry
->data
);
335 /* Register HOOK to be called with DATA on each removed node. */
336 cgraph_node_hook_list
*
337 symbol_table::add_cgraph_removal_hook (cgraph_node_hook hook
, void *data
)
339 cgraph_node_hook_list
*entry
;
340 cgraph_node_hook_list
**ptr
= &m_first_cgraph_removal_hook
;
342 entry
= (cgraph_node_hook_list
*) xmalloc (sizeof (*entry
));
352 /* Remove ENTRY from the list of hooks called on removing nodes. */
354 symbol_table::remove_cgraph_removal_hook (cgraph_node_hook_list
*entry
)
356 cgraph_node_hook_list
**ptr
= &m_first_cgraph_removal_hook
;
358 while (*ptr
!= entry
)
364 /* Call all node removal hooks. */
366 symbol_table::call_cgraph_removal_hooks (cgraph_node
*node
)
368 cgraph_node_hook_list
*entry
= m_first_cgraph_removal_hook
;
371 entry
->hook (node
, entry
->data
);
376 /* Call all node removal hooks. */
378 symbol_table::call_cgraph_insertion_hooks (cgraph_node
*node
)
380 cgraph_node_hook_list
*entry
= m_first_cgraph_insertion_hook
;
383 entry
->hook (node
, entry
->data
);
389 /* Register HOOK to be called with DATA on each inserted node. */
390 cgraph_node_hook_list
*
391 symbol_table::add_cgraph_insertion_hook (cgraph_node_hook hook
, void *data
)
393 cgraph_node_hook_list
*entry
;
394 cgraph_node_hook_list
**ptr
= &m_first_cgraph_insertion_hook
;
396 entry
= (cgraph_node_hook_list
*) xmalloc (sizeof (*entry
));
406 /* Remove ENTRY from the list of hooks called on inserted nodes. */
408 symbol_table::remove_cgraph_insertion_hook (cgraph_node_hook_list
*entry
)
410 cgraph_node_hook_list
**ptr
= &m_first_cgraph_insertion_hook
;
412 while (*ptr
!= entry
)
418 /* Register HOOK to be called with DATA on each duplicated edge. */
419 cgraph_2edge_hook_list
*
420 symbol_table::add_edge_duplication_hook (cgraph_2edge_hook hook
, void *data
)
422 cgraph_2edge_hook_list
*entry
;
423 cgraph_2edge_hook_list
**ptr
= &m_first_edge_duplicated_hook
;
425 entry
= (cgraph_2edge_hook_list
*) xmalloc (sizeof (*entry
));
435 /* Remove ENTRY from the list of hooks called on duplicating edges. */
437 symbol_table::remove_edge_duplication_hook (cgraph_2edge_hook_list
*entry
)
439 cgraph_2edge_hook_list
**ptr
= &m_first_edge_duplicated_hook
;
441 while (*ptr
!= entry
)
447 /* Call all edge duplication hooks. */
449 symbol_table::call_edge_duplication_hooks (cgraph_edge
*cs1
, cgraph_edge
*cs2
)
451 cgraph_2edge_hook_list
*entry
= m_first_edge_duplicated_hook
;
454 entry
->hook (cs1
, cs2
, entry
->data
);
459 /* Register HOOK to be called with DATA on each duplicated node. */
460 cgraph_2node_hook_list
*
461 symbol_table::add_cgraph_duplication_hook (cgraph_2node_hook hook
, void *data
)
463 cgraph_2node_hook_list
*entry
;
464 cgraph_2node_hook_list
**ptr
= &m_first_cgraph_duplicated_hook
;
466 entry
= (cgraph_2node_hook_list
*) xmalloc (sizeof (*entry
));
476 /* Remove ENTRY from the list of hooks called on duplicating nodes. */
478 symbol_table::remove_cgraph_duplication_hook (cgraph_2node_hook_list
*entry
)
480 cgraph_2node_hook_list
**ptr
= &m_first_cgraph_duplicated_hook
;
482 while (*ptr
!= entry
)
488 /* Call all node duplication hooks. */
490 symbol_table::call_cgraph_duplication_hooks (cgraph_node
*node
,
493 cgraph_2node_hook_list
*entry
= m_first_cgraph_duplicated_hook
;
496 entry
->hook (node
, node2
, entry
->data
);
501 /* Return cgraph node assigned to DECL. Create new one when needed. */
504 cgraph_node::create (tree decl
)
506 cgraph_node
*node
= symtab
->create_empty ();
507 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
510 node
->semantic_interposition
= opt_for_fn (decl
, flag_semantic_interposition
);
512 if ((flag_openacc
|| flag_openmp
)
513 && lookup_attribute ("omp declare target", DECL_ATTRIBUTES (decl
)))
515 node
->offloadable
= 1;
516 if (ENABLE_OFFLOADING
)
517 g
->have_offload
= true;
520 if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl
)))
521 node
->ifunc_resolver
= true;
523 node
->register_symbol ();
524 maybe_record_nested_function (node
);
529 /* Try to find a call graph node for declaration DECL and if it does not exist
530 or if it corresponds to an inline clone, create a new one. */
533 cgraph_node::get_create (tree decl
)
535 cgraph_node
*first_clone
= cgraph_node::get (decl
);
537 if (first_clone
&& !first_clone
->inlined_to
)
540 cgraph_node
*node
= cgraph_node::create (decl
);
543 first_clone
->clone_of
= node
;
544 node
->clones
= first_clone
;
545 node
->order
= first_clone
->order
;
546 symtab
->symtab_prevail_in_asm_name_hash (node
);
547 node
->decl
->decl_with_vis
.symtab_node
= node
;
548 if (dump_file
&& symtab
->state
!= PARSING
)
549 fprintf (dump_file
, "Introduced new external node "
550 "(%s) and turned into root of the clone tree.\n",
553 else if (dump_file
&& symtab
->state
!= PARSING
)
554 fprintf (dump_file
, "Introduced new external node "
555 "(%s).\n", node
->dump_name ());
559 /* Mark ALIAS as an alias to DECL. DECL_NODE is cgraph node representing
560 the function body is associated with
561 (not necessarily cgraph_node (DECL)). */
564 cgraph_node::create_alias (tree alias
, tree target
)
566 cgraph_node
*alias_node
;
568 gcc_assert (TREE_CODE (target
) == FUNCTION_DECL
569 || TREE_CODE (target
) == IDENTIFIER_NODE
);
570 gcc_assert (TREE_CODE (alias
) == FUNCTION_DECL
);
571 alias_node
= cgraph_node::get_create (alias
);
572 gcc_assert (!alias_node
->definition
);
573 alias_node
->alias_target
= target
;
574 alias_node
->definition
= true;
575 alias_node
->alias
= true;
576 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (alias
)) != NULL
)
577 alias_node
->transparent_alias
= alias_node
->weakref
= true;
578 if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (alias
)))
579 alias_node
->ifunc_resolver
= true;
583 /* Attempt to mark ALIAS as an alias to DECL. Return alias node if successful
585 Same body aliases are output whenever the body of DECL is output,
586 and cgraph_node::get (ALIAS) transparently returns
587 cgraph_node::get (DECL). */
590 cgraph_node::create_same_body_alias (tree alias
, tree decl
)
594 /* If aliases aren't supported by the assembler, fail. */
595 if (!TARGET_SUPPORTS_ALIASES
)
598 /* Langhooks can create same body aliases of symbols not defined.
599 Those are useless. Drop them on the floor. */
600 if (symtab
->global_info_ready
)
603 n
= cgraph_node::create_alias (alias
, decl
);
604 n
->cpp_implicit_alias
= true;
605 if (symtab
->cpp_implicit_aliases_done
)
606 n
->resolve_alias (cgraph_node::get (decl
));
610 /* Add thunk alias into callgraph. The alias declaration is ALIAS and it
611 aliases DECL with an adjustments made into the first parameter.
612 See comments in struct cgraph_thunk_info for detail on the parameters. */
615 cgraph_node::create_thunk (tree alias
, tree
, bool this_adjusting
,
616 HOST_WIDE_INT fixed_offset
,
617 HOST_WIDE_INT virtual_value
,
618 HOST_WIDE_INT indirect_offset
,
624 node
= cgraph_node::get (alias
);
628 node
= cgraph_node::create (alias
);
630 /* Make sure that if VIRTUAL_OFFSET is in sync with VIRTUAL_VALUE. */
631 gcc_checking_assert (virtual_offset
632 ? virtual_value
== wi::to_wide (virtual_offset
)
633 : virtual_value
== 0);
636 node
->definition
= true;
639 thunk_info local_info
;
640 if (symtab
->state
< CONSTRUCTION
)
643 i
= thunk_info::get_create (node
);
644 i
->fixed_offset
= fixed_offset
;
645 i
->virtual_value
= virtual_value
;
646 i
->indirect_offset
= indirect_offset
;
647 i
->alias
= real_alias
;
648 i
->this_adjusting
= this_adjusting
;
649 i
->virtual_offset_p
= virtual_offset
!= NULL
;
650 if (symtab
->state
< CONSTRUCTION
)
651 i
->register_early (node
);
656 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
657 Return NULL if there's no such node. */
660 cgraph_node::get_for_asmname (tree asmname
)
662 /* We do not want to look at inline clones. */
663 for (symtab_node
*node
= symtab_node::get_for_asmname (asmname
);
665 node
= node
->next_sharing_asm_name
)
667 cgraph_node
*cn
= dyn_cast
<cgraph_node
*> (node
);
668 if (cn
&& !cn
->inlined_to
)
674 /* Returns a hash value for X (which really is a cgraph_edge). */
677 cgraph_edge_hasher::hash (cgraph_edge
*e
)
679 /* This is a really poor hash function, but it is what htab_hash_pointer
681 return (hashval_t
) ((intptr_t)e
->call_stmt
>> 3);
684 /* Returns a hash value for X (which really is a cgraph_edge). */
687 cgraph_edge_hasher::hash (gimple
*call_stmt
)
689 /* This is a really poor hash function, but it is what htab_hash_pointer
691 return (hashval_t
) ((intptr_t)call_stmt
>> 3);
694 /* Return nonzero if the call_stmt of cgraph_edge X is stmt *Y. */
697 cgraph_edge_hasher::equal (cgraph_edge
*x
, gimple
*y
)
699 return x
->call_stmt
== y
;
702 /* Add call graph edge E to call site hash of its caller. */
705 cgraph_update_edge_in_call_site_hash (cgraph_edge
*e
)
707 gimple
*call
= e
->call_stmt
;
708 *e
->caller
->call_site_hash
->find_slot_with_hash
709 (call
, cgraph_edge_hasher::hash (call
), INSERT
) = e
;
712 /* Add call graph edge E to call site hash of its caller. */
715 cgraph_add_edge_to_call_site_hash (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 cgraph_edge
**slot
= e
->caller
->call_site_hash
->find_slot_with_hash
722 (e
->call_stmt
, cgraph_edge_hasher::hash (e
->call_stmt
), INSERT
);
725 gcc_assert (((cgraph_edge
*)*slot
)->speculative
);
726 if (e
->callee
&& (!e
->prev_callee
727 || !e
->prev_callee
->speculative
728 || e
->prev_callee
->call_stmt
!= e
->call_stmt
))
732 gcc_assert (!*slot
|| e
->speculative
);
736 /* Return the callgraph edge representing the GIMPLE_CALL statement
740 cgraph_node::get_edge (gimple
*call_stmt
)
746 return call_site_hash
->find_with_hash
747 (call_stmt
, cgraph_edge_hasher::hash (call_stmt
));
749 /* This loop may turn out to be performance problem. In such case adding
750 hashtables into call nodes with very many edges is probably best
751 solution. It is not good idea to add pointer into CALL_EXPR itself
752 because we want to make possible having multiple cgraph nodes representing
753 different clones of the same body before the body is actually cloned. */
754 for (e
= callees
; e
; e
= e
->next_callee
)
756 if (e
->call_stmt
== call_stmt
)
762 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
764 if (e
->call_stmt
== call_stmt
)
771 call_site_hash
= hash_table
<cgraph_edge_hasher
>::create_ggc (120);
772 for (e2
= callees
; e2
; e2
= e2
->next_callee
)
773 cgraph_add_edge_to_call_site_hash (e2
);
774 for (e2
= indirect_calls
; e2
; e2
= e2
->next_callee
)
775 cgraph_add_edge_to_call_site_hash (e2
);
782 /* Change field call_stmt of edge E to NEW_STMT. If UPDATE_SPECULATIVE and E
783 is any component of speculative edge, then update all components.
784 Speculations can be resolved in the process and EDGE can be removed and
785 deallocated. Return the edge that now represents the call. */
788 cgraph_edge::set_call_stmt (cgraph_edge
*e
, gcall
*new_stmt
,
789 bool update_speculative
)
793 cgraph_node
*new_direct_callee
= NULL
;
794 if ((e
->indirect_unknown_callee
|| e
->speculative
)
795 && (decl
= gimple_call_fndecl (new_stmt
)))
797 /* Constant propagation and especially inlining can turn an indirect call
798 into a direct one. */
799 new_direct_callee
= cgraph_node::get (decl
);
800 gcc_checking_assert (new_direct_callee
);
803 /* Speculative edges has three component, update all of them
805 if (update_speculative
&& e
->speculative
806 /* If we are about to resolve the speculation by calling make_direct
807 below, do not bother going over all the speculative edges now. */
808 && !new_direct_callee
)
810 cgraph_edge
*direct
, *indirect
, *next
;
812 bool e_indirect
= e
->indirect_unknown_callee
;
815 direct
= e
->first_speculative_call_target ();
816 indirect
= e
->speculative_call_indirect_edge ();
818 gcall
*old_stmt
= direct
->call_stmt
;
819 for (cgraph_edge
*d
= direct
; d
; d
= next
)
821 next
= d
->next_speculative_call_target ();
822 cgraph_edge
*d2
= set_call_stmt (d
, new_stmt
, false);
823 gcc_assert (d2
== d
);
826 gcc_checking_assert (indirect
->num_speculative_call_targets_p () == n
);
827 for (unsigned int i
= 0; e
->caller
->iterate_reference (i
, ref
); i
++)
828 if (ref
->speculative
&& ref
->stmt
== old_stmt
)
830 ref
->stmt
= new_stmt
;
834 indirect
= set_call_stmt (indirect
, new_stmt
, false);
835 return e_indirect
? indirect
: direct
;
838 if (new_direct_callee
)
839 e
= make_direct (e
, new_direct_callee
);
841 /* Only direct speculative edges go to call_site_hash. */
842 if (e
->caller
->call_site_hash
843 && (!e
->speculative
|| !e
->indirect_unknown_callee
)
844 /* It is possible that edge was previously speculative. In this case
845 we have different value in call stmt hash which needs preserving. */
846 && e
->caller
->get_edge (e
->call_stmt
) == e
)
847 e
->caller
->call_site_hash
->remove_elt_with_hash
848 (e
->call_stmt
, cgraph_edge_hasher::hash (e
->call_stmt
));
850 e
->call_stmt
= new_stmt
;
852 function
*fun
= DECL_STRUCT_FUNCTION (e
->caller
->decl
);
853 e
->can_throw_external
= stmt_can_throw_external (fun
, new_stmt
);
854 /* Update call stite hash. For speculative calls we only record the first
856 if (e
->caller
->call_site_hash
859 && (!e
->prev_callee
|| !e
->prev_callee
->speculative
860 || e
->prev_callee
->call_stmt
!= e
->call_stmt
))
861 || (e
->speculative
&& !e
->callee
)))
862 cgraph_add_edge_to_call_site_hash (e
);
866 /* Allocate a cgraph_edge structure and fill it with data according to the
867 parameters of which only CALLEE can be NULL (when creating an indirect call
868 edge). CLONING_P should be set if properties that are copied from an
869 original edge should not be calculated. */
872 symbol_table::create_edge (cgraph_node
*caller
, cgraph_node
*callee
,
873 gcall
*call_stmt
, profile_count count
,
874 bool indir_unknown_callee
, bool cloning_p
)
878 /* LTO does not actually have access to the call_stmt since these
879 have not been loaded yet. */
882 /* This is a rather expensive check possibly triggering
883 construction of call stmt hashtable. */
885 gcc_checking_assert (!(e
= caller
->get_edge (call_stmt
))
888 gcc_assert (is_gimple_call (call_stmt
));
891 edge
= ggc_alloc
<cgraph_edge
> ();
892 edge
->m_summary_id
= -1;
895 gcc_assert (++edges_max_uid
!= 0);
896 edge
->m_uid
= edges_max_uid
;
898 edge
->caller
= caller
;
899 edge
->callee
= callee
;
900 edge
->prev_caller
= NULL
;
901 edge
->next_caller
= NULL
;
902 edge
->prev_callee
= NULL
;
903 edge
->next_callee
= NULL
;
904 edge
->lto_stmt_uid
= 0;
905 edge
->speculative_id
= 0;
908 edge
->call_stmt
= call_stmt
;
909 edge
->indirect_info
= NULL
;
910 edge
->indirect_inlining_edge
= 0;
911 edge
->speculative
= false;
912 edge
->indirect_unknown_callee
= indir_unknown_callee
;
913 if (call_stmt
&& caller
->call_site_hash
)
914 cgraph_add_edge_to_call_site_hash (edge
);
919 edge
->can_throw_external
920 = call_stmt
? stmt_can_throw_external (DECL_STRUCT_FUNCTION (caller
->decl
),
922 edge
->inline_failed
= CIF_FUNCTION_NOT_CONSIDERED
;
923 edge
->call_stmt_cannot_inline_p
= false;
925 if (opt_for_fn (edge
->caller
->decl
, flag_devirtualize
)
926 && call_stmt
&& DECL_STRUCT_FUNCTION (caller
->decl
))
927 edge
->in_polymorphic_cdtor
928 = decl_maybe_in_construction_p (NULL
, NULL
, call_stmt
,
931 edge
->in_polymorphic_cdtor
= caller
->thunk
;
933 caller
->calls_declare_variant_alt
|= callee
->declare_variant_alt
;
935 if (callee
&& symtab
->state
!= LTO_STREAMING
936 && edge
->callee
->comdat_local_p ())
937 edge
->caller
->calls_comdat_local
= true;
942 /* Create edge from a given function to CALLEE in the cgraph. CLONING_P should
943 be set if properties that are copied from an original edge should not be
947 cgraph_node::create_edge (cgraph_node
*callee
,
948 gcall
*call_stmt
, profile_count count
, bool cloning_p
)
950 cgraph_edge
*edge
= symtab
->create_edge (this, callee
, call_stmt
, count
,
954 initialize_inline_failed (edge
);
956 edge
->next_caller
= callee
->callers
;
958 callee
->callers
->prev_caller
= edge
;
959 edge
->next_callee
= callees
;
961 callees
->prev_callee
= edge
;
963 callee
->callers
= edge
;
968 /* Allocate cgraph_indirect_call_info and set its fields to default values. */
970 cgraph_indirect_call_info
*
971 cgraph_allocate_init_indirect_info (void)
973 cgraph_indirect_call_info
*ii
;
975 ii
= ggc_cleared_alloc
<cgraph_indirect_call_info
> ();
976 ii
->param_index
= -1;
980 /* Create an indirect edge with a yet-undetermined callee where the call
981 statement destination is a formal parameter of the caller with index
982 PARAM_INDEX. CLONING_P should be set if properties that are copied from an
983 original edge should not be calculated and indirect_info structure should
984 not be calculated. */
987 cgraph_node::create_indirect_edge (gcall
*call_stmt
, int ecf_flags
,
991 cgraph_edge
*edge
= symtab
->create_edge (this, NULL
, call_stmt
, count
, true,
996 initialize_inline_failed (edge
);
998 edge
->indirect_info
= cgraph_allocate_init_indirect_info ();
999 edge
->indirect_info
->ecf_flags
= ecf_flags
;
1000 edge
->indirect_info
->vptr_changed
= true;
1002 /* Record polymorphic call info. */
1005 && (target
= gimple_call_fn (call_stmt
))
1006 && virtual_method_call_p (target
))
1008 ipa_polymorphic_call_context
context (decl
, target
, call_stmt
);
1010 /* Only record types can have virtual calls. */
1011 edge
->indirect_info
->polymorphic
= true;
1012 edge
->indirect_info
->param_index
= -1;
1013 edge
->indirect_info
->otr_token
1014 = tree_to_uhwi (OBJ_TYPE_REF_TOKEN (target
));
1015 edge
->indirect_info
->otr_type
= obj_type_ref_class (target
);
1016 gcc_assert (TREE_CODE (edge
->indirect_info
->otr_type
) == RECORD_TYPE
);
1017 edge
->indirect_info
->context
= context
;
1020 edge
->next_callee
= indirect_calls
;
1022 indirect_calls
->prev_callee
= edge
;
1023 indirect_calls
= edge
;
1028 /* Remove the edge from the list of the callees of the caller. */
1031 cgraph_edge::remove_caller (void)
1034 prev_callee
->next_callee
= next_callee
;
1036 next_callee
->prev_callee
= prev_callee
;
1039 if (indirect_unknown_callee
)
1040 caller
->indirect_calls
= next_callee
;
1042 caller
->callees
= next_callee
;
1044 if (caller
->call_site_hash
1045 && this == caller
->get_edge (call_stmt
))
1046 caller
->call_site_hash
->remove_elt_with_hash
1047 (call_stmt
, cgraph_edge_hasher::hash (call_stmt
));
1050 /* Put the edge onto the free list. */
1053 symbol_table::free_edge (cgraph_edge
*e
)
1056 if (e
->m_summary_id
!= -1)
1057 edge_released_summary_ids
.safe_push (e
->m_summary_id
);
1059 if (e
->indirect_info
)
1060 ggc_free (e
->indirect_info
);
1064 /* Remove the edge in the cgraph. */
1067 cgraph_edge::remove (cgraph_edge
*edge
)
1069 /* Call all edge removal hooks. */
1070 symtab
->call_edge_removal_hooks (edge
);
1072 if (!edge
->indirect_unknown_callee
)
1073 /* Remove from callers list of the callee. */
1074 edge
->remove_callee ();
1076 /* Remove from callees list of the callers. */
1077 edge
->remove_caller ();
1079 /* Put the edge onto the free list. */
1080 symtab
->free_edge (edge
);
1083 /* Turn edge 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 reference representing the if conditional and attaches
1097 them all to the original indirect call statement.
1099 speculative_id is used to link direct calls with their corresponding
1100 IPA_REF_ADDR references when representing speculative calls.
1102 Return direct edge created. */
1105 cgraph_edge::make_speculative (cgraph_node
*n2
, profile_count direct_count
,
1106 unsigned int speculative_id
)
1108 cgraph_node
*n
= caller
;
1109 ipa_ref
*ref
= NULL
;
1113 fprintf (dump_file
, "Indirect call -> speculative call %s => %s\n",
1114 n
->dump_name (), n2
->dump_name ());
1116 e2
= n
->create_edge (n2
, call_stmt
, direct_count
);
1117 initialize_inline_failed (e2
);
1118 e2
->speculative
= true;
1119 if (TREE_NOTHROW (n2
->decl
))
1120 e2
->can_throw_external
= false;
1122 e2
->can_throw_external
= can_throw_external
;
1123 e2
->lto_stmt_uid
= lto_stmt_uid
;
1124 e2
->speculative_id
= speculative_id
;
1125 e2
->in_polymorphic_cdtor
= in_polymorphic_cdtor
;
1126 indirect_info
->num_speculative_call_targets
++;
1128 symtab
->call_edge_duplication_hooks (this, e2
);
1129 ref
= n
->create_reference (n2
, IPA_REF_ADDR
, call_stmt
);
1130 ref
->lto_stmt_uid
= lto_stmt_uid
;
1131 ref
->speculative_id
= speculative_id
;
1132 ref
->speculative
= speculative
;
1133 n2
->mark_address_taken ();
1137 /* Speculative call consists of an indirect edge and one or more
1138 direct edge+ref pairs.
1140 Given an edge which is part of speculative call, return the first
1141 direct call edge in the speculative call sequence. */
1144 cgraph_edge::first_speculative_call_target ()
1146 cgraph_edge
*e
= this;
1148 gcc_checking_assert (e
->speculative
);
1151 while (e
->prev_callee
&& e
->prev_callee
->speculative
1152 && e
->prev_callee
->call_stmt
== e
->call_stmt
1153 && e
->prev_callee
->lto_stmt_uid
== e
->lto_stmt_uid
)
1157 /* Call stmt site hash always points to the first target of the
1158 speculative call sequence. */
1160 return e
->caller
->get_edge (e
->call_stmt
);
1161 for (cgraph_edge
*e2
= e
->caller
->callees
; true; e2
= e2
->next_callee
)
1163 && e
->call_stmt
== e2
->call_stmt
1164 && e
->lto_stmt_uid
== e2
->lto_stmt_uid
)
1168 /* We always maintain first direct edge in the call site hash, if one
1169 exists. E is going to be removed. See if it is first one and update
1170 hash accordingly. INDIRECT is the indirect edge of speculative call.
1171 We assume that INDIRECT->num_speculative_call_targets_p () is already
1172 updated for removal of E. */
1174 update_call_stmt_hash_for_removing_direct_edge (cgraph_edge
*e
,
1175 cgraph_edge
*indirect
)
1177 if (e
->caller
->call_site_hash
)
1179 if (e
->caller
->get_edge (e
->call_stmt
) != e
)
1181 else if (!indirect
->num_speculative_call_targets_p ())
1182 cgraph_update_edge_in_call_site_hash (indirect
);
1185 gcc_checking_assert (e
->next_callee
&& e
->next_callee
->speculative
1186 && e
->next_callee
->call_stmt
== e
->call_stmt
);
1187 cgraph_update_edge_in_call_site_hash (e
->next_callee
);
1192 /* Speculative call EDGE turned out to be direct call to CALLEE_DECL. Remove
1193 the speculative call sequence and return edge representing the call, the
1194 original EDGE can be removed and deallocated. Return the edge that now
1195 represents the call.
1197 For "speculative" indirect call that contains multiple "speculative"
1198 targets (i.e. edge->indirect_info->num_speculative_call_targets > 1),
1199 decrease the count and only remove current direct edge.
1201 If no speculative direct call left to the speculative indirect call, remove
1202 the speculative of both the indirect call and corresponding direct edge.
1204 It is up to caller to iteratively resolve each "speculative" direct call and
1205 redirect the call as appropriate. */
1208 cgraph_edge::resolve_speculation (cgraph_edge
*edge
, tree callee_decl
)
1213 gcc_assert (edge
->speculative
&& (!callee_decl
|| edge
->callee
));
1215 e2
= edge
->first_speculative_call_target ();
1218 ref
= e2
->speculative_call_target_ref ();
1219 edge
= edge
->speculative_call_indirect_edge ();
1221 || !ref
->referred
->semantically_equivalent_p
1222 (symtab_node::get (callee_decl
)))
1228 fprintf (dump_file
, "Speculative indirect call %s => %s has "
1229 "turned out to have contradicting known target ",
1230 edge
->caller
->dump_name (),
1231 e2
->callee
->dump_name ());
1232 print_generic_expr (dump_file
, callee_decl
);
1233 fprintf (dump_file
, "\n");
1237 fprintf (dump_file
, "Removing speculative call %s => %s\n",
1238 edge
->caller
->dump_name (),
1239 e2
->callee
->dump_name ());
1245 cgraph_edge
*tmp
= edge
;
1247 fprintf (dump_file
, "Speculative call turned into direct call.\n");
1250 /* FIXME: If EDGE is inlined, we should scale up the frequencies
1251 and counts in the functions inlined through it. */
1253 edge
->count
+= e2
->count
;
1254 if (edge
->num_speculative_call_targets_p ())
1256 /* The indirect edge has multiple speculative targets, don't remove
1257 speculative until all related direct edges are resolved. */
1258 edge
->indirect_info
->num_speculative_call_targets
--;
1259 if (!edge
->indirect_info
->num_speculative_call_targets
)
1260 edge
->speculative
= false;
1263 edge
->speculative
= false;
1264 e2
->speculative
= false;
1265 update_call_stmt_hash_for_removing_direct_edge (e2
, edge
);
1266 ref
->remove_reference ();
1267 if (e2
->indirect_unknown_callee
|| e2
->inline_failed
)
1270 e2
->callee
->remove_symbol_and_inline_clones ();
1274 /* Return edge corresponding to speculative call to a given target.
1275 NULL if speculative call does not have one. */
1278 cgraph_edge::speculative_call_for_target (cgraph_node
*target
)
1280 for (cgraph_edge
*direct
= first_speculative_call_target ();
1282 direct
= direct
->next_speculative_call_target ())
1283 if (direct
->speculative_call_target_ref ()
1284 ->referred
->semantically_equivalent_p (target
))
1289 /* Make an indirect or speculative EDGE with an unknown callee an ordinary edge
1290 leading to CALLEE. Speculations can be resolved in the process and EDGE can
1291 be removed and deallocated. Return the edge that now represents the
1295 cgraph_edge::make_direct (cgraph_edge
*edge
, cgraph_node
*callee
)
1297 gcc_assert (edge
->indirect_unknown_callee
|| edge
->speculative
);
1299 /* If we are redirecting speculative call, make it non-speculative. */
1300 if (edge
->speculative
)
1302 cgraph_edge
*found
= NULL
;
1303 cgraph_edge
*direct
, *next
;
1305 edge
= edge
->speculative_call_indirect_edge ();
1307 /* Look all speculative targets and remove all but one corresponding
1308 to callee (if it exists). */
1309 for (direct
= edge
->first_speculative_call_target ();
1313 next
= direct
->next_speculative_call_target ();
1315 /* Compare ref not direct->callee. Direct edge is possibly
1316 inlined or redirected. */
1317 if (!direct
->speculative_call_target_ref ()
1318 ->referred
->semantically_equivalent_p (callee
))
1319 edge
= direct
->resolve_speculation (direct
, NULL
);
1322 gcc_checking_assert (!found
);
1327 /* On successful speculation just remove the indirect edge and
1328 return the pre existing direct edge.
1329 It is important to not remove it and redirect because the direct
1330 edge may be inlined or redirected. */
1333 cgraph_edge
*e2
= resolve_speculation (found
, callee
->decl
);
1334 gcc_checking_assert (!found
->speculative
&& e2
== found
);
1337 gcc_checking_assert (!edge
->speculative
);
1340 edge
->indirect_unknown_callee
= 0;
1341 ggc_free (edge
->indirect_info
);
1342 edge
->indirect_info
= NULL
;
1344 /* Get the edge out of the indirect edge list. */
1345 if (edge
->prev_callee
)
1346 edge
->prev_callee
->next_callee
= edge
->next_callee
;
1347 if (edge
->next_callee
)
1348 edge
->next_callee
->prev_callee
= edge
->prev_callee
;
1349 if (!edge
->prev_callee
)
1350 edge
->caller
->indirect_calls
= edge
->next_callee
;
1352 /* Put it into the normal callee list */
1353 edge
->prev_callee
= NULL
;
1354 edge
->next_callee
= edge
->caller
->callees
;
1355 if (edge
->caller
->callees
)
1356 edge
->caller
->callees
->prev_callee
= edge
;
1357 edge
->caller
->callees
= edge
;
1359 /* Insert to callers list of the new callee. */
1360 edge
->set_callee (callee
);
1362 /* We need to re-determine the inlining status of the edge. */
1363 initialize_inline_failed (edge
);
1367 /* Redirect callee of the edge to N. The function does not update underlying
1371 cgraph_edge::redirect_callee (cgraph_node
*n
)
1373 bool loc
= callee
->comdat_local_p ();
1374 /* Remove from callers list of the current callee. */
1377 /* Insert to callers list of the new callee. */
1382 if (!loc
&& n
->comdat_local_p ())
1384 cgraph_node
*to
= caller
->inlined_to
? caller
->inlined_to
: caller
;
1385 to
->calls_comdat_local
= true;
1387 else if (loc
&& !n
->comdat_local_p ())
1389 cgraph_node
*to
= caller
->inlined_to
? caller
->inlined_to
: caller
;
1390 gcc_checking_assert (to
->calls_comdat_local
);
1391 to
->calls_comdat_local
= to
->check_calls_comdat_local_p ();
1395 /* If necessary, change the function declaration in the call statement
1396 associated with E so that it corresponds to the edge callee. Speculations
1397 can be resolved in the process and EDGE can be removed and deallocated.
1399 The edge could be one of speculative direct call generated from speculative
1400 indirect call. In this circumstance, decrease the speculative targets
1401 count (i.e. num_speculative_call_targets) and redirect call stmt to the
1402 corresponding i-th target. If no speculative direct call left to the
1403 speculative indirect call, remove "speculative" of the indirect call and
1404 also redirect stmt to it's final direct target.
1406 It is up to caller to iteratively transform each "speculative"
1407 direct call as appropriate. */
1410 cgraph_edge::redirect_call_stmt_to_callee (cgraph_edge
*e
)
1412 tree decl
= gimple_call_fndecl (e
->call_stmt
);
1417 /* If there already is an direct call (i.e. as a result of inliner's
1418 substitution), forget about speculating. */
1420 e
= make_direct (e
->speculative_call_indirect_edge (),
1421 cgraph_node::get (decl
));
1424 /* Be sure we redirect all speculative targets before poking
1425 about indirect edge. */
1426 gcc_checking_assert (e
->callee
);
1427 cgraph_edge
*indirect
= e
->speculative_call_indirect_edge ();
1431 /* Expand speculation into GIMPLE code. */
1435 "Expanding speculative call of %s -> %s count: ",
1436 e
->caller
->dump_name (),
1437 e
->callee
->dump_name ());
1438 e
->count
.dump (dump_file
);
1439 fprintf (dump_file
, "\n");
1441 push_cfun (DECL_STRUCT_FUNCTION (e
->caller
->decl
));
1443 profile_count all
= indirect
->count
;
1444 for (cgraph_edge
*e2
= e
->first_speculative_call_target ();
1446 e2
= e2
->next_speculative_call_target ())
1447 all
= all
+ e2
->count
;
1448 profile_probability prob
= e
->count
.probability_in (all
);
1449 if (!prob
.initialized_p ())
1450 prob
= profile_probability::even ();
1451 ref
= e
->speculative_call_target_ref ();
1452 new_stmt
= gimple_ic (e
->call_stmt
,
1453 dyn_cast
<cgraph_node
*> (ref
->referred
),
1455 e
->speculative
= false;
1456 if (indirect
->num_speculative_call_targets_p ())
1458 /* The indirect edge has multiple speculative targets, don't
1459 remove speculative until all related direct edges are
1461 indirect
->indirect_info
->num_speculative_call_targets
--;
1462 if (!indirect
->indirect_info
->num_speculative_call_targets
)
1463 indirect
->speculative
= false;
1466 indirect
->speculative
= false;
1467 /* Indirect edges are not both in the call site hash.
1469 update_call_stmt_hash_for_removing_direct_edge (e
, indirect
);
1470 cgraph_edge::set_call_stmt (e
, new_stmt
, false);
1471 e
->count
= gimple_bb (e
->call_stmt
)->count
;
1473 /* Once we are done with expanding the sequence, update also indirect
1474 call probability. Until then the basic block accounts for the
1475 sum of indirect edge and all non-expanded speculations. */
1476 if (!indirect
->speculative
)
1477 indirect
->count
= gimple_bb (indirect
->call_stmt
)->count
;
1478 ref
->speculative
= false;
1481 /* Continue redirecting E to proper target. */
1486 if (e
->indirect_unknown_callee
1487 || decl
== e
->callee
->decl
)
1488 return e
->call_stmt
;
1490 if (decl
&& ipa_saved_clone_sources
)
1492 tree
*p
= ipa_saved_clone_sources
->get (e
->callee
);
1493 if (p
&& decl
== *p
)
1495 gimple_call_set_fndecl (e
->call_stmt
, e
->callee
->decl
);
1496 return e
->call_stmt
;
1499 if (flag_checking
&& decl
)
1501 if (cgraph_node
*node
= cgraph_node::get (decl
))
1503 clone_info
*info
= clone_info::get (node
);
1504 gcc_assert (!info
|| !info
->param_adjustments
);
1508 clone_info
*callee_info
= clone_info::get (e
->callee
);
1509 if (symtab
->dump_file
)
1511 fprintf (symtab
->dump_file
, "updating call of %s -> %s: ",
1512 e
->caller
->dump_name (), e
->callee
->dump_name ());
1513 print_gimple_stmt (symtab
->dump_file
, e
->call_stmt
, 0, dump_flags
);
1514 if (callee_info
&& callee_info
->param_adjustments
)
1515 callee_info
->param_adjustments
->dump (symtab
->dump_file
);
1518 if (ipa_param_adjustments
*padjs
1519 = callee_info
? callee_info
->param_adjustments
: NULL
)
1521 /* We need to defer cleaning EH info on the new statement to
1522 fixup-cfg. We may not have dominator information at this point
1523 and thus would end up with unreachable blocks and have no way
1524 to communicate that we need to run CFG cleanup then. */
1525 int lp_nr
= lookup_stmt_eh_lp (e
->call_stmt
);
1527 remove_stmt_from_eh_lp (e
->call_stmt
);
1529 tree old_fntype
= gimple_call_fntype (e
->call_stmt
);
1530 new_stmt
= padjs
->modify_call (e
, false);
1531 cgraph_node
*origin
= e
->callee
;
1532 while (origin
->clone_of
)
1533 origin
= origin
->clone_of
;
1535 if ((origin
->former_clone_of
1536 && old_fntype
== TREE_TYPE (origin
->former_clone_of
))
1537 || old_fntype
== TREE_TYPE (origin
->decl
))
1538 gimple_call_set_fntype (new_stmt
, TREE_TYPE (e
->callee
->decl
));
1541 tree new_fntype
= padjs
->build_new_function_type (old_fntype
, true);
1542 gimple_call_set_fntype (new_stmt
, new_fntype
);
1546 add_stmt_to_eh_lp (new_stmt
, lp_nr
);
1551 && !fndecl_built_in_p (e
->callee
->decl
, BUILT_IN_UNREACHABLE
)
1552 && !fndecl_built_in_p (e
->callee
->decl
, BUILT_IN_UNREACHABLE_TRAP
))
1553 ipa_verify_edge_has_no_modifications (e
);
1554 new_stmt
= e
->call_stmt
;
1555 gimple_call_set_fndecl (new_stmt
, e
->callee
->decl
);
1556 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), new_stmt
);
1559 /* If changing the call to __cxa_pure_virtual or similar noreturn function,
1560 adjust gimple_call_fntype too. */
1561 if (gimple_call_noreturn_p (new_stmt
)
1562 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (e
->callee
->decl
)))
1563 && TYPE_ARG_TYPES (TREE_TYPE (e
->callee
->decl
))
1564 && (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (e
->callee
->decl
)))
1566 gimple_call_set_fntype (new_stmt
, TREE_TYPE (e
->callee
->decl
));
1568 /* If the call becomes noreturn, remove the LHS if possible. */
1569 tree lhs
= gimple_call_lhs (new_stmt
);
1571 && gimple_call_noreturn_p (new_stmt
)
1572 && (VOID_TYPE_P (TREE_TYPE (gimple_call_fntype (new_stmt
)))
1573 || should_remove_lhs_p (lhs
)))
1575 gimple_call_set_lhs (new_stmt
, NULL_TREE
);
1576 /* We need to fix up the SSA name to avoid checking errors. */
1577 if (TREE_CODE (lhs
) == SSA_NAME
)
1579 tree var
= create_tmp_reg_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
),
1580 TREE_TYPE (lhs
), NULL
);
1581 SET_SSA_NAME_VAR_OR_IDENTIFIER (lhs
, var
);
1582 SSA_NAME_DEF_STMT (lhs
) = gimple_build_nop ();
1583 set_ssa_default_def (DECL_STRUCT_FUNCTION (e
->caller
->decl
),
1586 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), new_stmt
);
1589 /* If new callee has no static chain, remove it. */
1590 if (gimple_call_chain (new_stmt
) && !DECL_STATIC_CHAIN (e
->callee
->decl
))
1592 gimple_call_set_chain (new_stmt
, NULL
);
1593 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), new_stmt
);
1596 maybe_remove_unused_call_args (DECL_STRUCT_FUNCTION (e
->caller
->decl
),
1599 e
->caller
->set_call_stmt_including_clones (e
->call_stmt
, new_stmt
, false);
1601 if (symtab
->dump_file
)
1603 fprintf (symtab
->dump_file
, " updated to:");
1604 print_gimple_stmt (symtab
->dump_file
, e
->call_stmt
, 0, dump_flags
);
1609 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1610 OLD_STMT changed into NEW_STMT. OLD_CALL is gimple_call_fndecl
1611 of OLD_STMT if it was previously call statement.
1612 If NEW_STMT is NULL, the call has been dropped without any
1616 cgraph_update_edges_for_call_stmt_node (cgraph_node
*node
,
1617 gimple
*old_stmt
, tree old_call
,
1620 tree new_call
= (new_stmt
&& is_gimple_call (new_stmt
))
1621 ? gimple_call_fndecl (new_stmt
) : 0;
1623 /* We are seeing indirect calls, then there is nothing to update. */
1624 if (!new_call
&& !old_call
)
1626 /* See if we turned indirect call into direct call or folded call to one builtin
1627 into different builtin. */
1628 if (old_call
!= new_call
)
1630 cgraph_edge
*e
= node
->get_edge (old_stmt
);
1631 cgraph_edge
*ne
= NULL
;
1632 profile_count count
;
1636 /* Keep calls marked as dead dead. */
1637 if (new_stmt
&& is_gimple_call (new_stmt
) && e
->callee
1638 && (fndecl_built_in_p (e
->callee
->decl
, BUILT_IN_UNREACHABLE
)
1639 || fndecl_built_in_p (e
->callee
->decl
,
1640 BUILT_IN_UNREACHABLE_TRAP
)))
1642 cgraph_edge::set_call_stmt (node
->get_edge (old_stmt
),
1643 as_a
<gcall
*> (new_stmt
));
1646 /* See if the edge is already there and has the correct callee. It
1647 might be so because of indirect inlining has already updated
1648 it. We also might've cloned and redirected the edge. */
1649 if (new_call
&& e
->callee
)
1651 cgraph_node
*callee
= e
->callee
;
1654 if (callee
->decl
== new_call
1655 || callee
->former_clone_of
== new_call
)
1657 cgraph_edge::set_call_stmt (e
, as_a
<gcall
*> (new_stmt
));
1660 callee
= callee
->clone_of
;
1664 /* Otherwise remove edge and create new one; we can't simply redirect
1665 since function has changed, so inline plan and other information
1666 attached to edge is invalid. */
1668 if (e
->indirect_unknown_callee
|| e
->inline_failed
)
1669 cgraph_edge::remove (e
);
1671 e
->callee
->remove_symbol_and_inline_clones ();
1675 /* We are seeing new direct call; compute profile info based on BB. */
1676 basic_block bb
= gimple_bb (new_stmt
);
1682 ne
= node
->create_edge (cgraph_node::get_create (new_call
),
1683 as_a
<gcall
*> (new_stmt
), count
);
1684 gcc_assert (ne
->inline_failed
);
1687 /* We only updated the call stmt; update pointer in cgraph edge.. */
1688 else if (old_stmt
!= new_stmt
)
1689 cgraph_edge::set_call_stmt (node
->get_edge (old_stmt
),
1690 as_a
<gcall
*> (new_stmt
));
1693 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1694 OLD_STMT changed into NEW_STMT. OLD_DECL is gimple_call_fndecl
1695 of OLD_STMT before it was updated (updating can happen inplace). */
1698 cgraph_update_edges_for_call_stmt (gimple
*old_stmt
, tree old_decl
,
1701 cgraph_node
*orig
= cgraph_node::get (cfun
->decl
);
1704 gcc_checking_assert (orig
);
1705 cgraph_update_edges_for_call_stmt_node (orig
, old_stmt
, old_decl
, new_stmt
);
1707 for (node
= orig
->clones
; node
!= orig
;)
1709 cgraph_update_edges_for_call_stmt_node (node
, old_stmt
, old_decl
,
1712 node
= node
->clones
;
1713 else if (node
->next_sibling_clone
)
1714 node
= node
->next_sibling_clone
;
1717 while (node
!= orig
&& !node
->next_sibling_clone
)
1718 node
= node
->clone_of
;
1720 node
= node
->next_sibling_clone
;
1726 /* Remove all callees from the node. */
1729 cgraph_node::remove_callees (void)
1733 calls_comdat_local
= false;
1735 /* It is sufficient to remove the edges from the lists of callers of
1736 the callees. The callee list of the node can be zapped with one
1738 for (e
= callees
; e
; e
= f
)
1741 symtab
->call_edge_removal_hooks (e
);
1742 if (!e
->indirect_unknown_callee
)
1743 e
->remove_callee ();
1744 symtab
->free_edge (e
);
1746 for (e
= indirect_calls
; e
; e
= f
)
1749 symtab
->call_edge_removal_hooks (e
);
1750 if (!e
->indirect_unknown_callee
)
1751 e
->remove_callee ();
1752 symtab
->free_edge (e
);
1754 indirect_calls
= NULL
;
1758 call_site_hash
->empty ();
1759 call_site_hash
= NULL
;
1763 /* Remove all callers from the node. */
1766 cgraph_node::remove_callers (void)
1770 /* It is sufficient to remove the edges from the lists of callees of
1771 the callers. The caller list of the node can be zapped with one
1773 for (e
= callers
; e
; e
= f
)
1776 symtab
->call_edge_removal_hooks (e
);
1777 e
->remove_caller ();
1778 symtab
->free_edge (e
);
1783 /* Helper function for cgraph_release_function_body and free_lang_data.
1784 It releases body from function DECL without having to inspect its
1785 possibly non-existent symtab node. */
1788 release_function_body (tree decl
)
1790 function
*fn
= DECL_STRUCT_FUNCTION (decl
);
1794 && loops_for_fn (fn
))
1796 fn
->curr_properties
&= ~PROP_loops
;
1797 loop_optimizer_finalize (fn
);
1801 delete_tree_ssa (fn
);
1806 gcc_assert (!dom_info_available_p (fn
, CDI_DOMINATORS
));
1807 gcc_assert (!dom_info_available_p (fn
, CDI_POST_DOMINATORS
));
1808 delete_tree_cfg_annotations (fn
);
1812 if (fn
->value_histograms
)
1813 free_histograms (fn
);
1814 gimple_set_body (decl
, NULL
);
1815 /* Struct function hangs a lot of data that would leak if we didn't
1816 removed all pointers to it. */
1818 DECL_STRUCT_FUNCTION (decl
) = NULL
;
1820 DECL_SAVED_TREE (decl
) = NULL
;
1823 /* Release memory used to represent body of function.
1824 Use this only for functions that are released before being translated to
1825 target code (i.e. RTL). Functions that are compiled to RTL and beyond
1826 are free'd in final.cc via free_after_compilation().
1827 KEEP_ARGUMENTS are useful only if you want to rebuild body as thunk. */
1830 cgraph_node::release_body (bool keep_arguments
)
1832 ipa_transforms_to_apply
.release ();
1833 if (!used_as_abstract_origin
&& symtab
->state
!= PARSING
)
1835 DECL_RESULT (decl
) = NULL
;
1837 if (!keep_arguments
)
1838 DECL_ARGUMENTS (decl
) = NULL
;
1840 /* If the node is abstract and needed, then do not clear
1841 DECL_INITIAL of its associated function declaration because it's
1842 needed to emit debug info later. */
1843 if (!used_as_abstract_origin
&& DECL_INITIAL (decl
))
1844 DECL_INITIAL (decl
) = error_mark_node
;
1845 release_function_body (decl
);
1848 lto_free_function_in_decl_state_for_node (this);
1849 lto_file_data
= NULL
;
1851 if (flag_checking
&& clones
)
1853 /* It is invalid to release body before materializing clones except
1854 for thunks that don't really need a body. Verify also that we do
1855 not leak pointers to the call statements. */
1856 for (cgraph_node
*node
= clones
; node
;
1857 node
= node
->next_sibling_clone
)
1858 gcc_assert (node
->thunk
&& !node
->callees
->call_stmt
);
1861 remove_all_references ();
1864 /* Remove function from symbol table. */
1867 cgraph_node::remove (void)
1869 bool clone_info_set
= false;
1870 clone_info
*info
, saved_info
;
1871 if (symtab
->ipa_clones_dump_file
&& symtab
->cloned_nodes
.contains (this))
1872 fprintf (symtab
->ipa_clones_dump_file
,
1873 "Callgraph removal;%s;%d;%s;%d;%d\n", asm_name (), order
,
1874 DECL_SOURCE_FILE (decl
), DECL_SOURCE_LINE (decl
),
1875 DECL_SOURCE_COLUMN (decl
));
1877 if ((info
= clone_info::get (this)) != NULL
)
1880 clone_info_set
= true;
1882 symtab
->call_cgraph_removal_hooks (this);
1885 ipa_transforms_to_apply
.release ();
1886 delete_function_version (function_version ());
1888 /* Incremental inlining access removed nodes stored in the postorder list.
1890 force_output
= false;
1891 forced_by_abi
= false;
1893 unregister (clone_info_set
? &saved_info
: NULL
);
1894 if (prev_sibling_clone
)
1895 prev_sibling_clone
->next_sibling_clone
= next_sibling_clone
;
1898 clone_of
->clones
= next_sibling_clone
;
1901 bool need_body
= false;
1902 for (cgraph_node
*n
= clone_of
; n
; n
= n
->clone_of
)
1903 if (n
->analyzed
|| n
->clones
)
1909 clone_of
->release_body ();
1912 if (next_sibling_clone
)
1913 next_sibling_clone
->prev_sibling_clone
= prev_sibling_clone
;
1916 cgraph_node
*n
, *next
;
1920 for (n
= clones
; n
->next_sibling_clone
; n
= n
->next_sibling_clone
)
1921 n
->clone_of
= clone_of
;
1922 n
->clone_of
= clone_of
;
1923 n
->next_sibling_clone
= clone_of
->clones
;
1924 if (clone_of
->clones
)
1925 clone_of
->clones
->prev_sibling_clone
= n
;
1926 clone_of
->clones
= clones
;
1930 /* We are removing node with clones. This makes clones inconsistent,
1931 but assume they will be removed subsequently and just keep clone
1932 tree intact. This can happen in unreachable function removal since
1933 we remove unreachable functions in random order, not by bottom-up
1934 walk of clone trees. */
1935 for (n
= clones
; n
; n
= next
)
1937 next
= n
->next_sibling_clone
;
1938 n
->next_sibling_clone
= NULL
;
1939 n
->prev_sibling_clone
= NULL
;
1945 /* While all the clones are removed after being proceeded, the function
1946 itself is kept in the cgraph even after it is compiled. Check whether
1947 we are done with this body and reclaim it proactively if this is the case.
1949 if (symtab
->state
!= LTO_STREAMING
)
1951 cgraph_node
*n
= cgraph_node::get (decl
);
1953 || (!n
->clones
&& !n
->clone_of
&& !n
->inlined_to
1954 && ((symtab
->global_info_ready
|| in_lto_p
)
1955 && (TREE_ASM_WRITTEN (n
->decl
)
1956 || DECL_EXTERNAL (n
->decl
)
1958 || (!flag_wpa
&& n
->in_other_partition
)))))
1963 lto_free_function_in_decl_state_for_node (this);
1964 lto_file_data
= NULL
;
1970 call_site_hash
->empty ();
1971 call_site_hash
= NULL
;
1974 symtab
->release_symbol (this);
1977 /* Likewise indicate that a node is having address taken. */
1980 cgraph_node::mark_address_taken (void)
1982 /* Indirect inlining can figure out that all uses of the address are
1986 gcc_assert (cfun
->after_inlining
);
1987 gcc_assert (callers
->indirect_inlining_edge
);
1990 /* FIXME: address_taken flag is used both as a shortcut for testing whether
1991 IPA_REF_ADDR reference exists (and thus it should be set on node
1992 representing alias we take address of) and as a test whether address
1993 of the object was taken (and thus it should be set on node alias is
1994 referring to). We should remove the first use and the remove the
1997 cgraph_node
*node
= ultimate_alias_target ();
1998 node
->address_taken
= 1;
2001 /* Return local info node for the compiled function. */
2004 cgraph_node::local_info_node (tree decl
)
2006 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
2007 cgraph_node
*node
= get (decl
);
2010 return node
->ultimate_alias_target ();
2013 /* Return RTL info for the compiled function. */
2016 cgraph_node::rtl_info (const_tree decl
)
2018 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
2019 cgraph_node
*node
= get (decl
);
2022 enum availability avail
;
2023 node
= node
->ultimate_alias_target (&avail
);
2024 if (decl
!= current_function_decl
2025 && (avail
< AVAIL_AVAILABLE
2026 || (node
->decl
!= current_function_decl
2027 && !TREE_ASM_WRITTEN (node
->decl
))))
2029 /* Allocate if it doesn't exist. */
2030 if (node
->rtl
== NULL
)
2032 node
->rtl
= ggc_cleared_alloc
<cgraph_rtl_info
> ();
2033 SET_HARD_REG_SET (node
->rtl
->function_used_regs
);
2038 /* Return a string describing the failure REASON. */
2041 cgraph_inline_failed_string (cgraph_inline_failed_t reason
)
2044 #define DEFCIFCODE(code, type, string) string,
2046 static const char *cif_string_table
[CIF_N_REASONS
] = {
2047 #include "cif-code.def"
2050 /* Signedness of an enum type is implementation defined, so cast it
2051 to unsigned before testing. */
2052 gcc_assert ((unsigned) reason
< CIF_N_REASONS
);
2053 return cif_string_table
[reason
];
2056 /* Return a type describing the failure REASON. */
2058 cgraph_inline_failed_type_t
2059 cgraph_inline_failed_type (cgraph_inline_failed_t reason
)
2062 #define DEFCIFCODE(code, type, string) type,
2064 static cgraph_inline_failed_type_t cif_type_table
[CIF_N_REASONS
] = {
2065 #include "cif-code.def"
2068 /* Signedness of an enum type is implementation defined, so cast it
2069 to unsigned before testing. */
2070 gcc_assert ((unsigned) reason
< CIF_N_REASONS
);
2071 return cif_type_table
[reason
];
2074 /* Names used to print out the availability enum. */
2075 const char * const cgraph_availability_names
[] =
2076 {"unset", "not_available", "overwritable", "available", "local"};
2078 /* Output flags of edge to a file F. */
2081 cgraph_edge::dump_edge_flags (FILE *f
)
2084 fprintf (f
, "(speculative) ");
2086 fprintf (f
, "(inlined) ");
2087 if (call_stmt_cannot_inline_p
)
2088 fprintf (f
, "(call_stmt_cannot_inline_p) ");
2089 if (indirect_inlining_edge
)
2090 fprintf (f
, "(indirect_inlining) ");
2091 if (count
.initialized_p ())
2096 fprintf (f
, "%.2f per call) ", sreal_frequency ().to_double ());
2098 if (can_throw_external
)
2099 fprintf (f
, "(can throw external) ");
2102 /* Dump edge to stderr. */
2105 cgraph_edge::debug (void)
2107 fprintf (stderr
, "%s -> %s ", caller
->dump_asm_name (),
2108 callee
== NULL
? "(null)" : callee
->dump_asm_name ());
2109 dump_edge_flags (stderr
);
2110 fprintf (stderr
, "\n\n");
2116 /* Dump call graph node to file F. */
2119 cgraph_node::dump (FILE *f
)
2126 fprintf (f
, " Function %s is inline copy in %s\n",
2128 inlined_to
->dump_name ());
2130 fprintf (f
, " Clone of %s\n", clone_of
->dump_asm_name ());
2131 if (symtab
->function_flags_ready
)
2132 fprintf (f
, " Availability: %s\n",
2133 cgraph_availability_names
[get_availability ()]);
2136 fprintf (f
, " Profile id: %i\n",
2139 fprintf (f
, " Unit id: %i\n",
2141 cgraph_function_version_info
*vi
= function_version ();
2144 fprintf (f
, " Version info: ");
2145 if (vi
->prev
!= NULL
)
2147 fprintf (f
, "prev: ");
2148 fprintf (f
, "%s ", vi
->prev
->this_node
->dump_asm_name ());
2150 if (vi
->next
!= NULL
)
2152 fprintf (f
, "next: ");
2153 fprintf (f
, "%s ", vi
->next
->this_node
->dump_asm_name ());
2155 if (vi
->dispatcher_resolver
!= NULL_TREE
)
2156 fprintf (f
, "dispatcher: %s",
2157 lang_hooks
.decl_printable_name (vi
->dispatcher_resolver
, 2));
2161 fprintf (f
, " Function flags:");
2162 if (count
.initialized_p ())
2164 fprintf (f
, " count:");
2167 if (tp_first_run
> 0)
2168 fprintf (f
, " first_run:%" PRId64
, (int64_t) tp_first_run
);
2169 if (cgraph_node
*origin
= nested_function_origin (this))
2170 fprintf (f
, " nested in:%s", origin
->dump_asm_name ());
2171 if (gimple_has_body_p (decl
))
2172 fprintf (f
, " body");
2174 fprintf (f
, " process");
2176 fprintf (f
, " local");
2177 if (redefined_extern_inline
)
2178 fprintf (f
, " redefined_extern_inline");
2179 if (only_called_at_startup
)
2180 fprintf (f
, " only_called_at_startup");
2181 if (only_called_at_exit
)
2182 fprintf (f
, " only_called_at_exit");
2184 fprintf (f
, " tm_clone");
2185 if (calls_comdat_local
)
2186 fprintf (f
, " calls_comdat_local");
2188 fprintf (f
, " icf_merged");
2190 fprintf (f
, " merged_comdat");
2191 if (merged_extern_inline
)
2192 fprintf (f
, " merged_extern_inline");
2194 fprintf (f
, " split_part");
2195 if (indirect_call_target
)
2196 fprintf (f
, " indirect_call_target");
2198 fprintf (f
, " nonfreeing_fn");
2199 if (DECL_STATIC_CONSTRUCTOR (decl
))
2200 fprintf (f
," static_constructor (priority:%i)", get_init_priority ());
2201 if (DECL_STATIC_DESTRUCTOR (decl
))
2202 fprintf (f
," static_destructor (priority:%i)", get_fini_priority ());
2203 if (frequency
== NODE_FREQUENCY_HOT
)
2204 fprintf (f
, " hot");
2205 if (frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
)
2206 fprintf (f
, " unlikely_executed");
2207 if (frequency
== NODE_FREQUENCY_EXECUTED_ONCE
)
2208 fprintf (f
, " executed_once");
2209 if (opt_for_fn (decl
, optimize_size
))
2210 fprintf (f
, " optimize_size");
2211 if (parallelized_function
)
2212 fprintf (f
, " parallelized_function");
2213 if (DECL_IS_MALLOC (decl
))
2214 fprintf (f
, " decl_is_malloc");
2215 if (DECL_IS_OPERATOR_NEW_P (decl
))
2216 fprintf (f
, " %soperator_new",
2217 DECL_IS_REPLACEABLE_OPERATOR (decl
) ? "replaceable_" : "");
2218 if (DECL_IS_OPERATOR_DELETE_P (decl
))
2219 fprintf (f
, " %soperator_delete",
2220 DECL_IS_REPLACEABLE_OPERATOR (decl
) ? "replaceable_" : "");
2222 if (DECL_STATIC_CHAIN (decl
))
2223 fprintf (f
, " static_chain");
2229 fprintf (f
, " Thunk");
2230 thunk_info::get (this)->dump (f
);
2232 else if (former_thunk_p ())
2234 fprintf (f
, " Former thunk ");
2235 thunk_info::get (this)->dump (f
);
2237 else gcc_checking_assert (!thunk_info::get (this));
2239 fprintf (f
, " Called by: ");
2241 profile_count sum
= profile_count::zero ();
2242 for (edge
= callers
; edge
; edge
= edge
->next_caller
)
2244 fprintf (f
, "%s ", edge
->caller
->dump_asm_name ());
2245 edge
->dump_edge_flags (f
);
2246 if (edge
->count
.initialized_p ())
2247 sum
+= edge
->count
.ipa ();
2250 fprintf (f
, "\n Calls: ");
2251 for (edge
= callees
; edge
; edge
= edge
->next_callee
)
2253 fprintf (f
, "%s ", edge
->callee
->dump_asm_name ());
2254 edge
->dump_edge_flags (f
);
2258 if (!body_removed
&& count
.ipa ().initialized_p ())
2264 FOR_EACH_ALIAS (this, ref
)
2265 if (dyn_cast
<cgraph_node
*> (ref
->referring
)->count
.initialized_p ())
2266 sum
+= dyn_cast
<cgraph_node
*> (ref
->referring
)->count
.ipa ();
2269 || (symtab
->state
< EXPANSION
2270 && ultimate_alias_target () == this && only_called_directly_p ()))
2271 ok
= !count
.ipa ().differs_from_p (sum
);
2272 else if (count
.ipa () > profile_count::from_gcov_type (100)
2273 && count
.ipa () < sum
.apply_scale (99, 100))
2274 ok
= false, min
= true;
2277 fprintf (f
, " Invalid sum of caller counts ");
2280 fprintf (f
, ", should be at most ");
2282 fprintf (f
, ", should be ");
2283 count
.ipa ().dump (f
);
2288 for (edge
= indirect_calls
; edge
; edge
= edge
->next_callee
)
2290 if (edge
->indirect_info
->polymorphic
)
2292 fprintf (f
, " Polymorphic indirect call of type ");
2293 print_generic_expr (f
, edge
->indirect_info
->otr_type
, TDF_SLIM
);
2294 fprintf (f
, " token:%i", (int) edge
->indirect_info
->otr_token
);
2297 fprintf (f
, " Indirect call");
2298 edge
->dump_edge_flags (f
);
2299 if (edge
->indirect_info
->param_index
!= -1)
2301 fprintf (f
, "of param:%i ", edge
->indirect_info
->param_index
);
2302 if (edge
->indirect_info
->agg_contents
)
2303 fprintf (f
, "loaded from %s %s at offset %i ",
2304 edge
->indirect_info
->member_ptr
? "member ptr" : "aggregate",
2305 edge
->indirect_info
->by_ref
? "passed by reference":"",
2306 (int)edge
->indirect_info
->offset
);
2307 if (edge
->indirect_info
->vptr_changed
)
2308 fprintf (f
, "(vptr maybe changed) ");
2310 fprintf (f
, "num speculative call targets: %i\n",
2311 edge
->indirect_info
->num_speculative_call_targets
);
2312 if (edge
->indirect_info
->polymorphic
)
2313 edge
->indirect_info
->context
.dump (f
);
2317 /* Dump call graph node to file F in graphviz format. */
2320 cgraph_node::dump_graphviz (FILE *f
)
2324 for (edge
= callees
; edge
; edge
= edge
->next_callee
)
2326 cgraph_node
*callee
= edge
->callee
;
2328 fprintf (f
, "\t\"%s\" -> \"%s\"\n", dump_name (), callee
->dump_name ());
2333 /* Dump call graph node NODE to stderr. */
2336 cgraph_node::debug (void)
2341 /* Dump the callgraph to file F. */
2344 cgraph_node::dump_cgraph (FILE *f
)
2348 fprintf (f
, "callgraph:\n\n");
2349 FOR_EACH_FUNCTION (node
)
2353 /* Return true when the DECL can possibly be inlined. */
2356 cgraph_function_possibly_inlined_p (tree decl
)
2358 if (!symtab
->global_info_ready
)
2359 return !DECL_UNINLINABLE (decl
);
2360 return DECL_POSSIBLY_INLINED (decl
);
2363 /* Return function availability. See cgraph.h for description of individual
2366 cgraph_node::get_availability (symtab_node
*ref
)
2370 cgraph_node
*cref
= dyn_cast
<cgraph_node
*> (ref
);
2372 ref
= cref
->inlined_to
;
2374 enum availability avail
;
2375 if (!analyzed
&& !in_other_partition
)
2376 avail
= AVAIL_NOT_AVAILABLE
;
2378 avail
= AVAIL_LOCAL
;
2379 else if (inlined_to
)
2380 avail
= AVAIL_AVAILABLE
;
2381 else if (transparent_alias
)
2382 ultimate_alias_target (&avail
, ref
);
2383 else if (ifunc_resolver
2384 || lookup_attribute ("noipa", DECL_ATTRIBUTES (decl
)))
2385 avail
= AVAIL_INTERPOSABLE
;
2386 else if (!externally_visible
)
2387 avail
= AVAIL_AVAILABLE
;
2388 /* If this is a reference from symbol itself and there are no aliases, we
2389 may be sure that the symbol was not interposed by something else because
2390 the symbol itself would be unreachable otherwise.
2392 Also comdat groups are always resolved in groups. */
2393 else if ((this == ref
&& !has_aliases_p ())
2394 || (ref
&& get_comdat_group ()
2395 && get_comdat_group () == ref
->get_comdat_group ()))
2396 avail
= AVAIL_AVAILABLE
;
2397 /* Inline functions are safe to be analyzed even if their symbol can
2398 be overwritten at runtime. It is not meaningful to enforce any sane
2399 behavior on replacing inline function by different body. */
2400 else if (DECL_DECLARED_INLINE_P (decl
))
2401 avail
= AVAIL_AVAILABLE
;
2403 /* If the function can be overwritten, return OVERWRITABLE. Take
2404 care at least of two notable extensions - the COMDAT functions
2405 used to share template instantiations in C++ (this is symmetric
2406 to code cp_cannot_inline_tree_fn and probably shall be shared and
2407 the inlinability hooks completely eliminated). */
2409 else if (decl_replaceable_p (decl
, semantic_interposition
)
2410 && !DECL_EXTERNAL (decl
))
2411 avail
= AVAIL_INTERPOSABLE
;
2412 else avail
= AVAIL_AVAILABLE
;
2417 /* Worker for cgraph_node_can_be_local_p. */
2419 cgraph_node_cannot_be_local_p_1 (cgraph_node
*node
, void *)
2421 return !(!node
->force_output
2422 && !node
->ifunc_resolver
2423 /* Limitation of gas requires us to output targets of symver aliases
2424 as global symbols. This is binutils PR 25295. */
2426 && ((DECL_COMDAT (node
->decl
)
2427 && !node
->forced_by_abi
2428 && !node
->used_from_object_file_p ()
2429 && !node
->same_comdat_group
)
2430 || !node
->externally_visible
));
2433 /* Return true if cgraph_node can be made local for API change.
2434 Extern inline functions and C++ COMDAT functions can be made local
2435 at the expense of possible code size growth if function is used in multiple
2436 compilation units. */
2438 cgraph_node::can_be_local_p (void)
2440 return (!address_taken
2441 && !call_for_symbol_thunks_and_aliases (cgraph_node_cannot_be_local_p_1
,
2445 /* Call callback on cgraph_node, thunks and aliases associated to cgraph_node.
2446 When INCLUDE_OVERWRITABLE is false, overwritable symbols are
2447 skipped. When EXCLUDE_VIRTUAL_THUNKS is true, virtual thunks are
2450 cgraph_node::call_for_symbol_thunks_and_aliases (bool (*callback
)
2451 (cgraph_node
*, void *),
2453 bool include_overwritable
,
2454 bool exclude_virtual_thunks
)
2458 enum availability avail
= AVAIL_AVAILABLE
;
2460 if (include_overwritable
2461 || (avail
= get_availability ()) > AVAIL_INTERPOSABLE
)
2463 if (callback (this, data
))
2466 FOR_EACH_ALIAS (this, ref
)
2468 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2469 if (include_overwritable
2470 || alias
->get_availability () > AVAIL_INTERPOSABLE
)
2471 if (alias
->call_for_symbol_thunks_and_aliases (callback
, data
,
2472 include_overwritable
,
2473 exclude_virtual_thunks
))
2476 if (avail
<= AVAIL_INTERPOSABLE
)
2478 for (e
= callers
; e
; e
= e
->next_caller
)
2479 if (e
->caller
->thunk
2480 && (include_overwritable
2481 || e
->caller
->get_availability () > AVAIL_INTERPOSABLE
)
2482 && !(exclude_virtual_thunks
2483 && thunk_info::get (e
->caller
)->virtual_offset_p
))
2484 if (e
->caller
->call_for_symbol_thunks_and_aliases (callback
, data
,
2485 include_overwritable
,
2486 exclude_virtual_thunks
))
2492 /* Worker to bring NODE local. */
2495 cgraph_node::make_local (cgraph_node
*node
, void *)
2497 gcc_checking_assert (node
->can_be_local_p ());
2498 if (DECL_COMDAT (node
->decl
) || DECL_EXTERNAL (node
->decl
))
2500 node
->make_decl_local ();
2501 node
->set_section (NULL
);
2502 node
->set_comdat_group (NULL
);
2503 node
->externally_visible
= false;
2504 node
->forced_by_abi
= false;
2506 node
->unique_name
= ((node
->resolution
== LDPR_PREVAILING_DEF_IRONLY
2507 || node
->resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
)
2508 && !flag_incremental_link
);
2509 node
->resolution
= LDPR_PREVAILING_DEF_IRONLY
;
2510 gcc_assert (node
->get_availability () == AVAIL_LOCAL
);
2515 /* Bring cgraph node local. */
2518 cgraph_node::make_local (void)
2520 call_for_symbol_thunks_and_aliases (cgraph_node::make_local
, NULL
, true);
2523 /* Worker to set nothrow flag. */
2526 set_nothrow_flag_1 (cgraph_node
*node
, bool nothrow
, bool non_call
,
2531 if (nothrow
&& !TREE_NOTHROW (node
->decl
))
2533 /* With non-call exceptions we can't say for sure if other function body
2534 was not possibly optimized to still throw. */
2535 if (!non_call
|| node
->binds_to_current_def_p ())
2537 TREE_NOTHROW (node
->decl
) = true;
2539 for (e
= node
->callers
; e
; e
= e
->next_caller
)
2540 e
->can_throw_external
= false;
2543 else if (!nothrow
&& TREE_NOTHROW (node
->decl
))
2545 TREE_NOTHROW (node
->decl
) = false;
2549 FOR_EACH_ALIAS (node
, ref
)
2551 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2552 if (!nothrow
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2553 set_nothrow_flag_1 (alias
, nothrow
, non_call
, changed
);
2555 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
2556 if (e
->caller
->thunk
2557 && (!nothrow
|| e
->caller
->get_availability () > AVAIL_INTERPOSABLE
))
2558 set_nothrow_flag_1 (e
->caller
, nothrow
, non_call
, changed
);
2561 /* Set TREE_NOTHROW on NODE's decl and on aliases of NODE
2562 if any to NOTHROW. */
2565 cgraph_node::set_nothrow_flag (bool nothrow
)
2567 bool changed
= false;
2568 bool non_call
= opt_for_fn (decl
, flag_non_call_exceptions
);
2570 if (!nothrow
|| get_availability () > AVAIL_INTERPOSABLE
)
2571 set_nothrow_flag_1 (this, nothrow
, non_call
, &changed
);
2576 FOR_EACH_ALIAS (this, ref
)
2578 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2579 if (!nothrow
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2580 set_nothrow_flag_1 (alias
, nothrow
, non_call
, &changed
);
2586 /* Worker to set malloc flag. */
2588 set_malloc_flag_1 (cgraph_node
*node
, bool malloc_p
, bool *changed
)
2590 if (malloc_p
&& !DECL_IS_MALLOC (node
->decl
))
2592 DECL_IS_MALLOC (node
->decl
) = true;
2597 FOR_EACH_ALIAS (node
, ref
)
2599 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2600 if (!malloc_p
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2601 set_malloc_flag_1 (alias
, malloc_p
, changed
);
2604 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
2605 if (e
->caller
->thunk
2606 && (!malloc_p
|| e
->caller
->get_availability () > AVAIL_INTERPOSABLE
))
2607 set_malloc_flag_1 (e
->caller
, malloc_p
, changed
);
2610 /* Set DECL_IS_MALLOC on NODE's decl and on NODE's aliases if any. */
2613 cgraph_node::set_malloc_flag (bool malloc_p
)
2615 bool changed
= false;
2617 if (!malloc_p
|| get_availability () > AVAIL_INTERPOSABLE
)
2618 set_malloc_flag_1 (this, malloc_p
, &changed
);
2623 FOR_EACH_ALIAS (this, ref
)
2625 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2626 if (!malloc_p
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2627 set_malloc_flag_1 (alias
, malloc_p
, &changed
);
2633 /* Worker to set noreturng flag. */
2635 set_noreturn_flag_1 (cgraph_node
*node
, bool noreturn_p
, bool *changed
)
2637 if (noreturn_p
&& !TREE_THIS_VOLATILE (node
->decl
))
2639 TREE_THIS_VOLATILE (node
->decl
) = true;
2644 FOR_EACH_ALIAS (node
, ref
)
2646 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2647 if (!noreturn_p
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2648 set_noreturn_flag_1 (alias
, noreturn_p
, changed
);
2651 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
2652 if (e
->caller
->thunk
2653 && (!noreturn_p
|| e
->caller
->get_availability () > AVAIL_INTERPOSABLE
))
2654 set_noreturn_flag_1 (e
->caller
, noreturn_p
, changed
);
2657 /* Set TREE_THIS_VOLATILE on NODE's decl and on NODE's aliases if any. */
2660 cgraph_node::set_noreturn_flag (bool noreturn_p
)
2662 bool changed
= false;
2664 if (!noreturn_p
|| get_availability () > AVAIL_INTERPOSABLE
)
2665 set_noreturn_flag_1 (this, noreturn_p
, &changed
);
2670 FOR_EACH_ALIAS (this, ref
)
2672 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2673 if (!noreturn_p
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2674 set_noreturn_flag_1 (alias
, noreturn_p
, &changed
);
2680 /* Worker to set_const_flag. */
2683 set_const_flag_1 (cgraph_node
*node
, bool set_const
, bool looping
,
2686 /* Static constructors and destructors without a side effect can be
2688 if (set_const
&& !looping
)
2690 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
2692 DECL_STATIC_CONSTRUCTOR (node
->decl
) = 0;
2695 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
2697 DECL_STATIC_DESTRUCTOR (node
->decl
) = 0;
2703 if (TREE_READONLY (node
->decl
))
2705 TREE_READONLY (node
->decl
) = 0;
2706 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2712 /* Consider function:
2719 During early optimization we will turn this into:
2726 Now if this function will be detected as CONST however when interposed
2727 it may end up being just pure. We always must assume the worst
2729 if (TREE_READONLY (node
->decl
))
2731 if (!looping
&& DECL_LOOPING_CONST_OR_PURE_P (node
->decl
))
2733 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2737 else if (node
->binds_to_current_def_p ())
2739 TREE_READONLY (node
->decl
) = true;
2740 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = looping
;
2741 DECL_PURE_P (node
->decl
) = false;
2746 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2747 fprintf (dump_file
, "Dropping state to PURE because function does "
2748 "not bind to current def.\n");
2749 if (!DECL_PURE_P (node
->decl
))
2751 DECL_PURE_P (node
->decl
) = true;
2752 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = looping
;
2755 else if (!looping
&& DECL_LOOPING_CONST_OR_PURE_P (node
->decl
))
2757 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2764 FOR_EACH_ALIAS (node
, ref
)
2766 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2767 if (!set_const
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2768 set_const_flag_1 (alias
, set_const
, looping
, changed
);
2770 for (struct cgraph_node
*n
= node
->simd_clones
; n
!= NULL
;
2771 n
= n
->simdclone
->next_clone
)
2772 set_const_flag_1 (n
, set_const
, looping
, changed
);
2773 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
2774 if (e
->caller
->thunk
2775 && (!set_const
|| e
->caller
->get_availability () > AVAIL_INTERPOSABLE
))
2777 /* Virtual thunks access virtual offset in the vtable, so they can
2778 only be pure, never const. */
2780 && (thunk_info::get (e
->caller
)->virtual_offset_p
2781 || !node
->binds_to_current_def_p (e
->caller
)))
2782 *changed
|= e
->caller
->set_pure_flag (true, looping
);
2784 set_const_flag_1 (e
->caller
, set_const
, looping
, changed
);
2788 /* If SET_CONST is true, mark function, aliases and thunks to be ECF_CONST.
2789 If SET_CONST if false, clear the flag.
2791 When setting the flag be careful about possible interposition and
2792 do not set the flag for functions that can be interposed and set pure
2793 flag for functions that can bind to other definition.
2795 Return true if any change was done. */
2798 cgraph_node::set_const_flag (bool set_const
, bool looping
)
2800 bool changed
= false;
2801 if (!set_const
|| get_availability () > AVAIL_INTERPOSABLE
)
2802 set_const_flag_1 (this, set_const
, looping
, &changed
);
2807 FOR_EACH_ALIAS (this, ref
)
2809 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2810 if (!set_const
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2811 set_const_flag_1 (alias
, set_const
, looping
, &changed
);
2817 /* Info used by set_pure_flag_1. */
2819 struct set_pure_flag_info
2826 /* Worker to set_pure_flag. */
2829 set_pure_flag_1 (cgraph_node
*node
, void *data
)
2831 struct set_pure_flag_info
*info
= (struct set_pure_flag_info
*)data
;
2832 /* Static constructors and destructors without a side effect can be
2834 if (info
->pure
&& !info
->looping
)
2836 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
2838 DECL_STATIC_CONSTRUCTOR (node
->decl
) = 0;
2839 info
->changed
= true;
2841 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
2843 DECL_STATIC_DESTRUCTOR (node
->decl
) = 0;
2844 info
->changed
= true;
2849 if (!DECL_PURE_P (node
->decl
) && !TREE_READONLY (node
->decl
))
2851 DECL_PURE_P (node
->decl
) = true;
2852 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = info
->looping
;
2853 info
->changed
= true;
2855 else if (DECL_LOOPING_CONST_OR_PURE_P (node
->decl
)
2858 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2859 info
->changed
= true;
2864 if (DECL_PURE_P (node
->decl
))
2866 DECL_PURE_P (node
->decl
) = false;
2867 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2868 info
->changed
= true;
2874 /* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node
2877 When setting the flag, be careful about possible interposition.
2878 Return true if any change was done. */
2881 cgraph_node::set_pure_flag (bool pure
, bool looping
)
2883 struct set_pure_flag_info info
= {pure
, looping
, false};
2884 call_for_symbol_thunks_and_aliases (set_pure_flag_1
, &info
, !pure
, true);
2885 for (struct cgraph_node
*n
= simd_clones
; n
!= NULL
;
2886 n
= n
->simdclone
->next_clone
)
2887 set_pure_flag_1 (n
, &info
);
2888 return info
.changed
;
2891 /* Return true when cgraph_node cannot return or throw and thus
2892 it is safe to ignore its side effects for IPA analysis. */
2895 cgraph_node::cannot_return_p (void)
2897 int flags
= flags_from_decl_or_type (decl
);
2898 if (!opt_for_fn (decl
, flag_exceptions
))
2899 return (flags
& ECF_NORETURN
) != 0;
2901 return ((flags
& (ECF_NORETURN
| ECF_NOTHROW
))
2902 == (ECF_NORETURN
| ECF_NOTHROW
));
2905 /* Return true when call of edge cannot lead to return from caller
2906 and thus it is safe to ignore its side effects for IPA analysis
2907 when computing side effects of the caller.
2908 FIXME: We could actually mark all edges that have no reaching
2909 patch to the exit block or throw to get better results. */
2911 cgraph_edge::cannot_lead_to_return_p (void)
2913 if (caller
->cannot_return_p ())
2915 if (indirect_unknown_callee
)
2917 int flags
= indirect_info
->ecf_flags
;
2918 if (!opt_for_fn (caller
->decl
, flag_exceptions
))
2919 return (flags
& ECF_NORETURN
) != 0;
2921 return ((flags
& (ECF_NORETURN
| ECF_NOTHROW
))
2922 == (ECF_NORETURN
| ECF_NOTHROW
));
2925 return callee
->cannot_return_p ();
2928 /* Return true if the edge may be considered hot. */
2931 cgraph_edge::maybe_hot_p (void)
2933 if (!maybe_hot_count_p (NULL
, count
.ipa ()))
2935 if (caller
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
2937 && callee
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
))
2939 if (caller
->frequency
> NODE_FREQUENCY_UNLIKELY_EXECUTED
2941 && callee
->frequency
<= NODE_FREQUENCY_EXECUTED_ONCE
))
2943 if (opt_for_fn (caller
->decl
, optimize_size
))
2945 if (caller
->frequency
== NODE_FREQUENCY_HOT
)
2947 if (!count
.initialized_p ())
2949 cgraph_node
*where
= caller
->inlined_to
? caller
->inlined_to
: caller
;
2950 if (!where
->count
.initialized_p ())
2952 if (caller
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
)
2954 if (count
* 2 < where
->count
* 3)
2957 else if (count
* param_hot_bb_frequency_fraction
< where
->count
)
2962 /* Worker for cgraph_can_remove_if_no_direct_calls_p. */
2965 nonremovable_p (cgraph_node
*node
, void *)
2967 return !node
->can_remove_if_no_direct_calls_and_refs_p ();
2970 /* Return true if whole comdat group can be removed if there are no direct
2974 cgraph_node::can_remove_if_no_direct_calls_p (bool will_inline
)
2976 struct ipa_ref
*ref
;
2978 /* For local symbols or non-comdat group it is the same as
2979 can_remove_if_no_direct_calls_p. */
2980 if (!externally_visible
|| !same_comdat_group
)
2982 if (DECL_EXTERNAL (decl
))
2986 return !call_for_symbol_and_aliases (nonremovable_p
, NULL
, true);
2989 if (will_inline
&& address_taken
)
2992 /* Otherwise check if we can remove the symbol itself and then verify
2993 that only uses of the comdat groups are direct call to THIS
2995 if (!can_remove_if_no_direct_calls_and_refs_p ())
2998 /* Check that all refs come from within the comdat group. */
2999 for (int i
= 0; iterate_referring (i
, ref
); i
++)
3000 if (ref
->referring
->get_comdat_group () != get_comdat_group ())
3003 struct cgraph_node
*target
= ultimate_alias_target ();
3004 for (cgraph_node
*next
= dyn_cast
<cgraph_node
*> (same_comdat_group
);
3005 next
!= this; next
= dyn_cast
<cgraph_node
*> (next
->same_comdat_group
))
3007 if (!externally_visible
)
3010 && !next
->can_remove_if_no_direct_calls_and_refs_p ())
3013 /* If we see different symbol than THIS, be sure to check calls. */
3014 if (next
->ultimate_alias_target () != target
)
3015 for (cgraph_edge
*e
= next
->callers
; e
; e
= e
->next_caller
)
3016 if (e
->caller
->get_comdat_group () != get_comdat_group ()
3020 /* If function is not being inlined, we care only about
3021 references outside of the comdat group. */
3023 for (int i
= 0; next
->iterate_referring (i
, ref
); i
++)
3024 if (ref
->referring
->get_comdat_group () != get_comdat_group ())
3030 /* Return true when function cgraph_node can be expected to be removed
3031 from program when direct calls in this compilation unit are removed.
3033 As a special case COMDAT functions are
3034 cgraph_can_remove_if_no_direct_calls_p while the are not
3035 cgraph_only_called_directly_p (it is possible they are called from other
3038 This function behaves as cgraph_only_called_directly_p because eliminating
3039 all uses of COMDAT function does not make it necessarily disappear from
3040 the program unless we are compiling whole program or we do LTO. In this
3041 case we know we win since dynamic linking will not really discard the
3042 linkonce section. */
3045 cgraph_node::will_be_removed_from_program_if_no_direct_calls_p
3048 gcc_assert (!inlined_to
);
3049 if (DECL_EXTERNAL (decl
))
3052 if (!in_lto_p
&& !flag_whole_program
)
3054 /* If the symbol is in comdat group, we need to verify that whole comdat
3055 group becomes unreachable. Technically we could skip references from
3056 within the group, too. */
3057 if (!only_called_directly_p ())
3059 if (same_comdat_group
&& externally_visible
)
3061 struct cgraph_node
*target
= ultimate_alias_target ();
3063 if (will_inline
&& address_taken
)
3065 for (cgraph_node
*next
= dyn_cast
<cgraph_node
*> (same_comdat_group
);
3067 next
= dyn_cast
<cgraph_node
*> (next
->same_comdat_group
))
3069 if (!externally_visible
)
3072 && !next
->only_called_directly_p ())
3075 /* If we see different symbol than THIS,
3076 be sure to check calls. */
3077 if (next
->ultimate_alias_target () != target
)
3078 for (cgraph_edge
*e
= next
->callers
; e
; e
= e
->next_caller
)
3079 if (e
->caller
->get_comdat_group () != get_comdat_group ()
3087 return can_remove_if_no_direct_calls_p (will_inline
);
3091 /* Worker for cgraph_only_called_directly_p. */
3094 cgraph_not_only_called_directly_p_1 (cgraph_node
*node
, void *)
3096 return !node
->only_called_directly_or_aliased_p ();
3099 /* Return true when function cgraph_node and all its aliases are only called
3101 i.e. it is not externally visible, address was not taken and
3102 it is not used in any other non-standard way. */
3105 cgraph_node::only_called_directly_p (void)
3107 gcc_assert (ultimate_alias_target () == this);
3108 return !call_for_symbol_and_aliases (cgraph_not_only_called_directly_p_1
,
3113 /* Collect all callers of NODE. Worker for collect_callers_of_node. */
3116 collect_callers_of_node_1 (cgraph_node
*node
, void *data
)
3118 vec
<cgraph_edge
*> *redirect_callers
= (vec
<cgraph_edge
*> *)data
;
3120 enum availability avail
;
3121 node
->ultimate_alias_target (&avail
);
3123 if (avail
> AVAIL_INTERPOSABLE
)
3124 for (cs
= node
->callers
; cs
!= NULL
; cs
= cs
->next_caller
)
3125 if (!cs
->indirect_inlining_edge
3126 && !cs
->caller
->thunk
)
3127 redirect_callers
->safe_push (cs
);
3131 /* Collect all callers of cgraph_node and its aliases that are known to lead to
3132 cgraph_node (i.e. are not overwritable). */
3134 auto_vec
<cgraph_edge
*>
3135 cgraph_node::collect_callers (void)
3137 auto_vec
<cgraph_edge
*> redirect_callers
;
3138 call_for_symbol_thunks_and_aliases (collect_callers_of_node_1
,
3139 &redirect_callers
, false);
3140 return redirect_callers
;
3144 /* Return TRUE if NODE2 a clone of NODE or is equivalent to it. Return
3145 optimistically true if this cannot be determined. */
3148 clone_of_p (cgraph_node
*node
, cgraph_node
*node2
)
3150 node
= node
->ultimate_alias_target ();
3151 node2
= node2
->ultimate_alias_target ();
3153 if (node2
->clone_of
== node
3154 || node2
->former_clone_of
== node
->decl
)
3157 if (!node
->thunk
&& !node
->former_thunk_p ())
3160 && node
->decl
!= node2
->decl
3161 && node
->decl
!= node2
->former_clone_of
)
3162 node2
= node2
->clone_of
;
3163 return node2
!= NULL
;
3166 /* There are no virtual clones of thunks so check former_clone_of or if we
3167 might have skipped thunks because this adjustments are no longer
3169 while (node
->thunk
|| node
->former_thunk_p ())
3171 if (!thunk_info::get (node
)->this_adjusting
)
3173 /* In case of instrumented expanded thunks, which can have multiple calls
3174 in them, we do not know how to continue and just have to be
3175 optimistic. The same applies if all calls have already been inlined
3177 if (!node
->callees
|| node
->callees
->next_callee
)
3179 node
= node
->callees
->callee
->ultimate_alias_target ();
3181 clone_info
*info
= clone_info::get (node2
);
3182 if (!info
|| !info
->param_adjustments
3183 || info
->param_adjustments
->first_param_intact_p ())
3185 if (node2
->former_clone_of
== node
->decl
3186 || node2
->former_clone_of
== node
->former_clone_of
)
3189 cgraph_node
*n2
= node2
;
3190 while (n2
&& node
->decl
!= n2
->decl
)
3199 /* Verify edge count and frequency. */
3202 cgraph_edge::verify_count ()
3204 bool error_found
= false;
3205 if (!count
.verify ())
3207 error ("caller edge count invalid");
3213 /* Switch to THIS_CFUN if needed and print STMT to stderr. */
3215 cgraph_debug_gimple_stmt (function
*this_cfun
, gimple
*stmt
)
3217 bool fndecl_was_null
= false;
3218 /* debug_gimple_stmt needs correct cfun */
3219 if (cfun
!= this_cfun
)
3220 set_cfun (this_cfun
);
3221 /* ...and an actual current_function_decl */
3222 if (!current_function_decl
)
3224 current_function_decl
= this_cfun
->decl
;
3225 fndecl_was_null
= true;
3227 debug_gimple_stmt (stmt
);
3228 if (fndecl_was_null
)
3229 current_function_decl
= NULL
;
3232 /* Verify that call graph edge corresponds to DECL from the associated
3233 statement. Return true if the verification should fail. */
3236 cgraph_edge::verify_corresponds_to_fndecl (tree decl
)
3240 if (!decl
|| callee
->inlined_to
)
3242 if (symtab
->state
== LTO_STREAMING
)
3244 node
= cgraph_node::get (decl
);
3246 /* We do not know if a node from a different partition is an alias or what it
3247 aliases and therefore cannot do the former_clone_of check reliably. When
3248 body_removed is set, we have lost all information about what was alias or
3249 thunk of and also cannot proceed. */
3251 || node
->body_removed
3252 || node
->in_other_partition
3253 || callee
->icf_merged
3254 || callee
->in_other_partition
)
3257 node
= node
->ultimate_alias_target ();
3259 /* Optimizers can redirect unreachable calls or calls triggering undefined
3260 behavior to __builtin_unreachable or __builtin_unreachable trap. */
3262 if (fndecl_built_in_p (callee
->decl
, BUILT_IN_NORMAL
)
3263 && (DECL_FUNCTION_CODE (callee
->decl
) == BUILT_IN_UNREACHABLE
3264 || DECL_FUNCTION_CODE (callee
->decl
) == BUILT_IN_UNREACHABLE_TRAP
))
3267 if (callee
->former_clone_of
!= node
->decl
3268 && (node
!= callee
->ultimate_alias_target ())
3269 && !clone_of_p (node
, callee
))
3275 /* Disable warnings about missing quoting in GCC diagnostics for
3276 the verification errors. Their format strings don't follow GCC
3277 diagnostic conventions and the calls are ultimately followed by
3278 one to internal_error. */
3280 # pragma GCC diagnostic push
3281 # pragma GCC diagnostic ignored "-Wformat-diag"
3284 /* Verify consistency of speculative call in NODE corresponding to STMT
3285 and LTO_STMT_UID. If INDIRECT is set, assume that it is the indirect
3286 edge of call sequence. Return true if error is found.
3288 This function is called to every component of indirect call (direct edges,
3289 indirect edge and refs). To save duplicated work, do full testing only
3292 verify_speculative_call (struct cgraph_node
*node
, gimple
*stmt
,
3293 unsigned int lto_stmt_uid
,
3294 struct cgraph_edge
*indirect
)
3296 if (indirect
== NULL
)
3298 for (indirect
= node
->indirect_calls
; indirect
;
3299 indirect
= indirect
->next_callee
)
3300 if (indirect
->call_stmt
== stmt
3301 && indirect
->lto_stmt_uid
== lto_stmt_uid
)
3305 error ("missing indirect call in speculative call sequence");
3308 if (!indirect
->speculative
)
3310 error ("indirect call in speculative call sequence has no "
3311 "speculative flag");
3317 /* Maximal number of targets. We probably will never want to have more than
3319 const unsigned int num
= 256;
3320 cgraph_edge
*direct_calls
[num
];
3323 for (unsigned int i
= 0; i
< num
; i
++)
3325 direct_calls
[i
] = NULL
;
3329 cgraph_edge
*first_call
= NULL
;
3330 cgraph_edge
*prev_call
= NULL
;
3332 for (cgraph_edge
*direct
= node
->callees
; direct
;
3333 direct
= direct
->next_callee
)
3334 if (direct
->call_stmt
== stmt
&& direct
->lto_stmt_uid
== lto_stmt_uid
)
3337 first_call
= direct
;
3338 if (prev_call
&& direct
!= prev_call
->next_callee
)
3340 error ("speculative edges are not adjacent");
3344 if (!direct
->speculative
)
3346 error ("direct call to %s in speculative call sequence has no "
3347 "speculative flag", direct
->callee
->dump_name ());
3350 if (direct
->speculative_id
>= num
)
3352 error ("direct call to %s in speculative call sequence has "
3353 "speculative_id %i out of range",
3354 direct
->callee
->dump_name (), direct
->speculative_id
);
3357 if (direct_calls
[direct
->speculative_id
])
3359 error ("duplicate direct call to %s in speculative call sequence "
3360 "with speculative_id %i",
3361 direct
->callee
->dump_name (), direct
->speculative_id
);
3364 direct_calls
[direct
->speculative_id
] = direct
;
3367 if (first_call
->call_stmt
3368 && first_call
!= node
->get_edge (first_call
->call_stmt
))
3370 error ("call stmt hash does not point to first direct edge of "
3371 "speculative call sequence");
3376 for (int i
= 0; node
->iterate_reference (i
, ref
); i
++)
3377 if (ref
->speculative
3378 && ref
->stmt
== stmt
&& ref
->lto_stmt_uid
== lto_stmt_uid
)
3380 if (ref
->speculative_id
>= num
)
3382 error ("direct call to %s in speculative call sequence has "
3383 "speculative_id %i out of range",
3384 ref
->referred
->dump_name (), ref
->speculative_id
);
3387 if (refs
[ref
->speculative_id
])
3389 error ("duplicate reference %s in speculative call sequence "
3390 "with speculative_id %i",
3391 ref
->referred
->dump_name (), ref
->speculative_id
);
3394 refs
[ref
->speculative_id
] = ref
;
3397 int num_targets
= 0;
3398 for (unsigned int i
= 0 ; i
< num
; i
++)
3400 if (refs
[i
] && !direct_calls
[i
])
3402 error ("missing direct call for speculation %i", i
);
3405 if (!refs
[i
] && direct_calls
[i
])
3407 error ("missing ref for speculation %i", i
);
3410 if (refs
[i
] != NULL
)
3414 if (num_targets
!= indirect
->num_speculative_call_targets_p ())
3416 error ("number of speculative targets %i mismatched with "
3417 "num_speculative_call_targets %i",
3419 indirect
->num_speculative_call_targets_p ());
3425 /* Verify cgraph nodes of given cgraph node. */
3427 cgraph_node::verify_node (void)
3430 function
*this_cfun
= DECL_STRUCT_FUNCTION (decl
);
3431 basic_block this_block
;
3432 gimple_stmt_iterator gsi
;
3433 bool error_found
= false;
3435 ipa_ref
*ref
= NULL
;
3440 timevar_push (TV_CGRAPH_VERIFY
);
3441 error_found
|= verify_base ();
3442 for (e
= callees
; e
; e
= e
->next_callee
)
3445 error ("aux field set for edge %s->%s",
3446 identifier_to_locale (e
->caller
->name ()),
3447 identifier_to_locale (e
->callee
->name ()));
3450 if (!count
.verify ())
3452 error ("cgraph count invalid");
3455 if (inlined_to
&& same_comdat_group
)
3457 error ("inline clone in same comdat group list");
3460 if (inlined_to
&& !count
.compatible_p (inlined_to
->count
))
3462 error ("inline clone count is not compatible");
3464 inlined_to
->count
.debug ();
3467 if (tp_first_run
< 0)
3469 error ("tp_first_run must be non-negative");
3472 if (!definition
&& !in_other_partition
&& local
)
3474 error ("local symbols must be defined");
3477 if (inlined_to
&& externally_visible
)
3479 error ("externally visible inline clone");
3482 if (inlined_to
&& address_taken
)
3484 error ("inline clone with address taken");
3487 if (inlined_to
&& force_output
)
3489 error ("inline clone is forced to output");
3492 if (symtab
->state
!= LTO_STREAMING
)
3494 if (calls_comdat_local
&& !same_comdat_group
)
3496 error ("calls_comdat_local is set outside of a comdat group");
3499 if (!inlined_to
&& calls_comdat_local
!= check_calls_comdat_local_p ())
3501 error ("invalid calls_comdat_local flag");
3505 if (DECL_IS_MALLOC (decl
)
3506 && !POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (decl
))))
3508 error ("malloc attribute should be used for a function that "
3509 "returns a pointer");
3513 && externally_visible
3514 /* For aliases in lto1 free_lang_data doesn't guarantee preservation
3515 of opt_for_fn (decl, flag_semantic_interposition). See PR105399. */
3516 && (!alias
|| !in_lto_p
)
3517 && semantic_interposition
3518 != opt_for_fn (decl
, flag_semantic_interposition
))
3520 error ("semantic interposition mismatch");
3523 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
3527 error ("aux field set for indirect edge from %s",
3528 identifier_to_locale (e
->caller
->name ()));
3531 if (!e
->count
.compatible_p (count
))
3533 error ("edge count is not compatible with function count");
3538 if (!e
->indirect_unknown_callee
3539 || !e
->indirect_info
)
3541 error ("An indirect edge from %s is not marked as indirect or has "
3542 "associated indirect_info, the corresponding statement is: ",
3543 identifier_to_locale (e
->caller
->name ()));
3544 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3547 if (e
->call_stmt
&& e
->lto_stmt_uid
)
3549 error ("edge has both call_stmt and lto_stmt_uid set");
3553 bool check_comdat
= comdat_local_p ();
3554 for (e
= callers
; e
; e
= e
->next_caller
)
3556 if (e
->verify_count ())
3559 && !in_same_comdat_group_p (e
->caller
))
3561 error ("comdat-local function called by %s outside its comdat",
3562 identifier_to_locale (e
->caller
->name ()));
3565 if (!e
->inline_failed
)
3568 != (e
->caller
->inlined_to
3569 ? e
->caller
->inlined_to
: e
->caller
))
3571 error ("inlined_to pointer is wrong");
3574 if (callers
->next_caller
)
3576 error ("multiple inline callers");
3583 error ("inlined_to pointer set for noninline callers");
3587 for (e
= callees
; e
; e
= e
->next_callee
)
3589 if (e
->verify_count ())
3591 if (!e
->count
.compatible_p (count
))
3593 error ("edge count is not compatible with function count");
3598 if (gimple_has_body_p (e
->caller
->decl
)
3599 && !e
->caller
->inlined_to
3601 /* Optimized out calls are redirected to __builtin_unreachable. */
3602 && (e
->count
.nonzero_p ()
3603 || ! e
->callee
->decl
3604 || !(fndecl_built_in_p (e
->callee
->decl
, BUILT_IN_UNREACHABLE
)
3605 || fndecl_built_in_p (e
->callee
->decl
,
3606 BUILT_IN_UNREACHABLE_TRAP
)))
3608 == ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (decl
))->count
3609 && (!e
->count
.ipa_p ()
3610 && e
->count
.differs_from_p (gimple_bb (e
->call_stmt
)->count
)))
3612 error ("caller edge count does not match BB count");
3613 fprintf (stderr
, "edge count: ");
3614 e
->count
.dump (stderr
);
3615 fprintf (stderr
, "\n bb count: ");
3616 gimple_bb (e
->call_stmt
)->count
.dump (stderr
);
3617 fprintf (stderr
, "\n");
3620 if (e
->call_stmt
&& e
->lto_stmt_uid
)
3622 error ("edge has both call_stmt and lto_stmt_uid set");
3626 && verify_speculative_call (e
->caller
, e
->call_stmt
, e
->lto_stmt_uid
,
3630 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
3632 if (e
->verify_count ())
3634 if (gimple_has_body_p (e
->caller
->decl
)
3635 && !e
->caller
->inlined_to
3637 && e
->count
.ipa_p ()
3639 == ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (decl
))->count
3640 && (!e
->count
.ipa_p ()
3641 && e
->count
.differs_from_p (gimple_bb (e
->call_stmt
)->count
)))
3643 error ("indirect call count does not match BB count");
3644 fprintf (stderr
, "edge count: ");
3645 e
->count
.dump (stderr
);
3646 fprintf (stderr
, "\n bb count: ");
3647 gimple_bb (e
->call_stmt
)->count
.dump (stderr
);
3648 fprintf (stderr
, "\n");
3652 && verify_speculative_call (e
->caller
, e
->call_stmt
, e
->lto_stmt_uid
,
3656 for (i
= 0; iterate_reference (i
, ref
); i
++)
3658 if (ref
->stmt
&& ref
->lto_stmt_uid
)
3660 error ("reference has both stmt and lto_stmt_uid set");
3663 if (ref
->speculative
3664 && verify_speculative_call (this, ref
->stmt
,
3665 ref
->lto_stmt_uid
, NULL
))
3669 if (!callers
&& inlined_to
)
3671 error ("inlined_to pointer is set but no predecessors found");
3674 if (inlined_to
== this)
3676 error ("inlined_to pointer refers to itself");
3682 cgraph_node
*first_clone
= clone_of
->clones
;
3683 if (first_clone
!= this)
3685 if (prev_sibling_clone
->clone_of
!= clone_of
)
3687 error ("cgraph_node has wrong clone_of");
3695 for (n
= clones
; n
; n
= n
->next_sibling_clone
)
3696 if (n
->clone_of
!= this)
3700 error ("cgraph_node has wrong clone list");
3704 if ((prev_sibling_clone
|| next_sibling_clone
) && !clone_of
)
3706 error ("cgraph_node is in clone list but it is not clone");
3709 if (!prev_sibling_clone
&& clone_of
&& clone_of
->clones
!= this)
3711 error ("cgraph_node has wrong prev_clone pointer");
3714 if (prev_sibling_clone
&& prev_sibling_clone
->next_sibling_clone
!= this)
3716 error ("double linked list of clones corrupted");
3720 if (analyzed
&& alias
)
3722 bool ref_found
= false;
3724 ipa_ref
*ref
= NULL
;
3728 error ("Alias has call edges");
3731 for (i
= 0; iterate_reference (i
, ref
); i
++)
3732 if (ref
->use
!= IPA_REF_ALIAS
)
3734 error ("Alias has non-alias reference");
3739 error ("Alias has more than one alias reference");
3746 error ("Analyzed alias has no reference");
3751 if (analyzed
&& thunk
)
3755 error ("No edge out of thunk node");
3758 else if (callees
->next_callee
)
3760 error ("More than one edge out of thunk node");
3763 if (gimple_has_body_p (decl
) && !inlined_to
)
3765 error ("Thunk is not supposed to have body");
3769 else if (analyzed
&& gimple_has_body_p (decl
)
3770 && !TREE_ASM_WRITTEN (decl
)
3771 && (!DECL_EXTERNAL (decl
) || inlined_to
)
3774 if ((this_cfun
->curr_properties
& PROP_assumptions_done
) != 0)
3776 else if (this_cfun
->cfg
)
3778 hash_set
<gimple
*> stmts
;
3780 /* Reach the trees by walking over the CFG, and note the
3781 enclosing basic-blocks in the call edges. */
3782 FOR_EACH_BB_FN (this_block
, this_cfun
)
3784 for (gsi
= gsi_start_phis (this_block
);
3785 !gsi_end_p (gsi
); gsi_next (&gsi
))
3786 stmts
.add (gsi_stmt (gsi
));
3787 for (gsi
= gsi_start_bb (this_block
);
3791 gimple
*stmt
= gsi_stmt (gsi
);
3793 if (is_gimple_call (stmt
))
3795 cgraph_edge
*e
= get_edge (stmt
);
3796 tree decl
= gimple_call_fndecl (stmt
);
3801 error ("shared call_stmt:");
3802 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
3805 if (!e
->indirect_unknown_callee
)
3807 if (e
->verify_corresponds_to_fndecl (decl
))
3809 error ("edge points to wrong declaration:");
3810 debug_tree (e
->callee
->decl
);
3811 fprintf (stderr
," Instead of:");
3818 error ("an indirect edge with unknown callee "
3819 "corresponding to a call_stmt with "
3820 "a known declaration:");
3822 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3828 error ("missing callgraph edge for call stmt:");
3829 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
3835 for (i
= 0; iterate_reference (i
, ref
); i
++)
3836 if (ref
->stmt
&& !stmts
.contains (ref
->stmt
))
3838 error ("reference to dead statement");
3839 cgraph_debug_gimple_stmt (this_cfun
, ref
->stmt
);
3844 /* No CFG available?! */
3847 for (e
= callees
; e
; e
= e
->next_callee
)
3849 if (!e
->aux
&& !e
->speculative
)
3851 error ("edge %s->%s has no corresponding call_stmt",
3852 identifier_to_locale (e
->caller
->name ()),
3853 identifier_to_locale (e
->callee
->name ()));
3854 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3859 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
3861 if (!e
->aux
&& !e
->speculative
)
3863 error ("an indirect edge from %s has no corresponding call_stmt",
3864 identifier_to_locale (e
->caller
->name ()));
3865 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3872 if (nested_function_info
*info
= nested_function_info::get (this))
3874 if (info
->nested
!= NULL
)
3876 for (cgraph_node
*n
= info
->nested
; n
!= NULL
;
3877 n
= next_nested_function (n
))
3879 nested_function_info
*ninfo
= nested_function_info::get (n
);
3880 if (ninfo
->origin
== NULL
)
3882 error ("missing origin for a node in a nested list");
3885 else if (ninfo
->origin
!= this)
3887 error ("origin points to a different parent");
3893 if (info
->next_nested
!= NULL
&& info
->origin
== NULL
)
3895 error ("missing origin for a node in a nested list");
3903 internal_error ("verify_cgraph_node failed");
3905 timevar_pop (TV_CGRAPH_VERIFY
);
3908 /* Verify whole cgraph structure. */
3910 cgraph_node::verify_cgraph_nodes (void)
3917 FOR_EACH_FUNCTION (node
)
3922 # pragma GCC diagnostic pop
3925 /* Walk the alias chain to return the function cgraph_node is alias of.
3926 Walk through thunks, too.
3927 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3928 When REF is non-NULL, assume that reference happens in symbol REF
3929 when determining the availability. */
3932 cgraph_node::function_symbol (enum availability
*availability
,
3933 struct symtab_node
*ref
)
3935 cgraph_node
*node
= ultimate_alias_target (availability
, ref
);
3939 enum availability a
;
3942 node
= node
->callees
->callee
;
3943 node
= node
->ultimate_alias_target (availability
? &a
: NULL
, ref
);
3944 if (availability
&& a
< *availability
)
3950 /* Walk the alias chain to return the function cgraph_node is alias of.
3951 Walk through non virtual thunks, too. Thus we return either a function
3952 or a virtual thunk node.
3953 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3954 When REF is non-NULL, assume that reference happens in symbol REF
3955 when determining the availability. */
3958 cgraph_node::function_or_virtual_thunk_symbol
3959 (enum availability
*availability
,
3960 struct symtab_node
*ref
)
3962 cgraph_node
*node
= ultimate_alias_target (availability
, ref
);
3964 while (node
->thunk
&& !thunk_info::get (node
)->virtual_offset_p
)
3966 enum availability a
;
3969 node
= node
->callees
->callee
;
3970 node
= node
->ultimate_alias_target (availability
? &a
: NULL
, ref
);
3971 if (availability
&& a
< *availability
)
3977 /* When doing LTO, read cgraph_node's body from disk if it is not already
3978 present. Also perform any necessary clone materializations. */
3981 cgraph_node::get_untransformed_body ()
3983 lto_file_decl_data
*file_data
;
3984 const char *data
, *name
;
3986 tree decl
= this->decl
;
3988 /* See if there is clone to be materialized.
3989 (inline clones does not need materialization, but we can be seeing
3990 an inline clone of real clone). */
3991 cgraph_node
*p
= this;
3992 for (cgraph_node
*c
= clone_of
; c
; c
= c
->clone_of
)
3994 if (c
->decl
!= decl
)
3995 p
->materialize_clone ();
3999 /* Check if body is already there. Either we have gimple body or
4000 the function is thunk and in that case we set DECL_ARGUMENTS. */
4001 if (DECL_ARGUMENTS (decl
) || gimple_has_body_p (decl
))
4004 gcc_assert (in_lto_p
&& !DECL_RESULT (decl
));
4006 timevar_push (TV_IPA_LTO_GIMPLE_IN
);
4008 file_data
= lto_file_data
;
4009 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
4011 /* We may have renamed the declaration, e.g., a static function. */
4012 name
= lto_get_decl_name_mapping (file_data
, name
);
4013 struct lto_in_decl_state
*decl_state
4014 = lto_get_function_in_decl_state (file_data
, decl
);
4016 cgraph_node
*origin
= this;
4017 while (origin
->clone_of
)
4018 origin
= origin
->clone_of
;
4020 int stream_order
= origin
->order
- file_data
->order_base
;
4021 data
= lto_get_section_data (file_data
, LTO_section_function_body
,
4022 name
, stream_order
, &len
,
4023 decl_state
->compressed
);
4025 fatal_error (input_location
, "%s: section %s.%d is missing",
4026 file_data
->file_name
, name
, stream_order
);
4028 gcc_assert (DECL_STRUCT_FUNCTION (decl
) == NULL
);
4031 fprintf (stderr
, " in:%s", IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
4032 lto_input_function_body (file_data
, this, data
);
4033 lto_stats
.num_function_bodies
++;
4034 lto_free_section_data (file_data
, LTO_section_function_body
, name
,
4035 data
, len
, decl_state
->compressed
);
4036 lto_free_function_in_decl_state_for_node (this);
4037 /* Keep lto file data so ipa-inline-analysis knows about cross module
4040 timevar_pop (TV_IPA_LTO_GIMPLE_IN
);
4045 /* Prepare function body. When doing LTO, read cgraph_node's body from disk
4046 if it is not already present. When some IPA transformations are scheduled,
4050 cgraph_node::get_body (void)
4054 updated
= get_untransformed_body ();
4056 /* Getting transformed body makes no sense for inline clones;
4057 we should never use this on real clones because they are materialized
4059 TODO: Materializing clones here will likely lead to smaller LTRANS
4061 gcc_assert (!inlined_to
&& !clone_of
);
4062 if (ipa_transforms_to_apply
.exists ())
4064 opt_pass
*saved_current_pass
= current_pass
;
4065 FILE *saved_dump_file
= dump_file
;
4066 const char *saved_dump_file_name
= dump_file_name
;
4067 dump_flags_t saved_dump_flags
= dump_flags
;
4068 dump_file_name
= NULL
;
4069 set_dump_file (NULL
);
4071 push_cfun (DECL_STRUCT_FUNCTION (decl
));
4073 update_ssa (TODO_update_ssa_only_virtuals
);
4074 execute_all_ipa_transforms (true);
4075 cgraph_edge::rebuild_edges ();
4076 free_dominance_info (CDI_DOMINATORS
);
4077 free_dominance_info (CDI_POST_DOMINATORS
);
4081 current_pass
= saved_current_pass
;
4082 set_dump_file (saved_dump_file
);
4083 dump_file_name
= saved_dump_file_name
;
4084 dump_flags
= saved_dump_flags
;
4089 /* Return the DECL_STRUCT_FUNCTION of the function. */
4092 cgraph_node::get_fun () const
4094 const cgraph_node
*node
= this;
4095 struct function
*fun
= DECL_STRUCT_FUNCTION (node
->decl
);
4097 while (!fun
&& node
->clone_of
)
4099 node
= node
->clone_of
;
4100 fun
= DECL_STRUCT_FUNCTION (node
->decl
);
4106 /* Reset all state within cgraph.cc so that we can rerun the compiler
4107 within the same process. For use by toplev::finalize. */
4110 cgraph_cc_finalize (void)
4112 nested_function_info::release ();
4113 thunk_info::release ();
4114 clone_info::release ();
4117 x_cgraph_nodes_queue
= NULL
;
4119 cgraph_fnver_htab
= NULL
;
4120 version_info_node
= NULL
;
4123 /* A worker for call_for_symbol_and_aliases. */
4126 cgraph_node::call_for_symbol_and_aliases_1 (bool (*callback
) (cgraph_node
*,
4129 bool include_overwritable
)
4132 FOR_EACH_ALIAS (this, ref
)
4134 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
4135 if (include_overwritable
4136 || alias
->get_availability () > AVAIL_INTERPOSABLE
)
4137 if (alias
->call_for_symbol_and_aliases (callback
, data
,
4138 include_overwritable
))
4144 /* Return true if NODE has thunk. */
4147 cgraph_node::has_thunk_p (cgraph_node
*node
, void *)
4149 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
4150 if (e
->caller
->thunk
)
4155 /* Expected frequency of executions within the function. */
4158 cgraph_edge::sreal_frequency ()
4160 return count
.to_sreal_scale (caller
->inlined_to
4161 ? caller
->inlined_to
->count
4166 /* During LTO stream in this can be used to check whether call can possibly
4167 be internal to the current translation unit. */
4170 cgraph_edge::possibly_call_in_translation_unit_p (void)
4172 gcc_checking_assert (in_lto_p
&& caller
->prevailing_p ());
4174 /* While incremental linking we may end up getting function body later. */
4175 if (flag_incremental_link
== INCREMENTAL_LINK_LTO
)
4178 /* We may be smarter here and avoid streaming in indirect calls we can't
4179 track, but that would require arranging streaming the indirect call
4184 /* If callee is local to the original translation unit, it will be
4186 if (!TREE_PUBLIC (callee
->decl
) && !DECL_EXTERNAL (callee
->decl
))
4189 /* Otherwise we need to lookup prevailing symbol (symbol table is not merged,
4190 yet) and see if it is a definition. In fact we may also resolve aliases,
4191 but that is probably not too important. */
4192 symtab_node
*node
= callee
;
4193 for (int n
= 10; node
->previous_sharing_asm_name
&& n
; n
--)
4194 node
= node
->previous_sharing_asm_name
;
4195 if (node
->previous_sharing_asm_name
)
4196 node
= symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (callee
->decl
));
4197 gcc_assert (TREE_PUBLIC (node
->decl
) || DECL_EXTERNAL (node
->decl
));
4198 return node
->get_availability () >= AVAIL_INTERPOSABLE
;
4201 /* Return num_speculative_targets of this edge. */
4204 cgraph_edge::num_speculative_call_targets_p (void)
4206 return indirect_info
? indirect_info
->num_speculative_call_targets
: 0;
4209 /* Check if function calls comdat local. This is used to recompute
4210 calls_comdat_local flag after function transformations. */
4212 cgraph_node::check_calls_comdat_local_p ()
4214 for (cgraph_edge
*e
= callees
; e
; e
= e
->next_callee
)
4215 if (e
->inline_failed
4216 ? e
->callee
->comdat_local_p ()
4217 : e
->callee
->check_calls_comdat_local_p ())
4222 /* Return true if this node represents a former, i.e. an expanded, thunk. */
4225 cgraph_node::former_thunk_p (void)
4229 thunk_info
*i
= thunk_info::get (this);
4232 gcc_checking_assert (i
->fixed_offset
|| i
->virtual_offset_p
4233 || i
->indirect_offset
);
4237 /* A stashed copy of "symtab" for use by selftest::symbol_table_test.
4238 This needs to be a global so that it can be a GC root, and thus
4239 prevent the stashed copy from being garbage-collected if the GC runs
4240 during a symbol_table_test. */
4242 symbol_table
*saved_symtab
;
4246 namespace selftest
{
4248 /* class selftest::symbol_table_test. */
4250 /* Constructor. Store the old value of symtab, and create a new one. */
4252 symbol_table_test::symbol_table_test ()
4254 gcc_assert (saved_symtab
== NULL
);
4255 saved_symtab
= symtab
;
4256 symtab
= new (ggc_alloc
<symbol_table
> ()) symbol_table ();
4259 /* Destructor. Restore the old value of symtab. */
4261 symbol_table_test::~symbol_table_test ()
4263 gcc_assert (saved_symtab
!= NULL
);
4264 symtab
= saved_symtab
;
4265 saved_symtab
= NULL
;
4268 /* Verify that symbol_table_test works. */
4271 test_symbol_table_test ()
4273 /* Simulate running two selftests involving symbol tables. */
4274 for (int i
= 0; i
< 2; i
++)
4276 symbol_table_test stt
;
4277 tree test_decl
= build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
,
4278 get_identifier ("test_decl"),
4279 build_function_type_list (void_type_node
,
4281 cgraph_node
*node
= cgraph_node::get_create (test_decl
);
4284 /* Verify that the node has order 0 on both iterations,
4285 and thus that nodes have predictable dump names in selftests. */
4286 ASSERT_EQ (node
->order
, 0);
4287 ASSERT_STREQ (node
->dump_name (), "test_decl/0");
4291 /* Run all of the selftests within this file. */
4296 test_symbol_table_test ();
4299 } // namespace selftest
4301 #endif /* CHECKING_P */
4303 #include "gt-cgraph.h"