1 /* Callgraph handling code.
2 Copyright (C) 2003-2022 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 ipa_verify_edge_has_no_modifications (e
);
1553 new_stmt
= e
->call_stmt
;
1554 gimple_call_set_fndecl (new_stmt
, e
->callee
->decl
);
1555 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), new_stmt
);
1558 /* If changing the call to __cxa_pure_virtual or similar noreturn function,
1559 adjust gimple_call_fntype too. */
1560 if (gimple_call_noreturn_p (new_stmt
)
1561 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (e
->callee
->decl
)))
1562 && TYPE_ARG_TYPES (TREE_TYPE (e
->callee
->decl
))
1563 && (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (e
->callee
->decl
)))
1565 gimple_call_set_fntype (new_stmt
, TREE_TYPE (e
->callee
->decl
));
1567 /* If the call becomes noreturn, remove the LHS if possible. */
1568 tree lhs
= gimple_call_lhs (new_stmt
);
1570 && gimple_call_noreturn_p (new_stmt
)
1571 && (VOID_TYPE_P (TREE_TYPE (gimple_call_fntype (new_stmt
)))
1572 || should_remove_lhs_p (lhs
)))
1574 gimple_call_set_lhs (new_stmt
, NULL_TREE
);
1575 /* We need to fix up the SSA name to avoid checking errors. */
1576 if (TREE_CODE (lhs
) == SSA_NAME
)
1578 tree var
= create_tmp_reg_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
),
1579 TREE_TYPE (lhs
), NULL
);
1580 SET_SSA_NAME_VAR_OR_IDENTIFIER (lhs
, var
);
1581 SSA_NAME_DEF_STMT (lhs
) = gimple_build_nop ();
1582 set_ssa_default_def (DECL_STRUCT_FUNCTION (e
->caller
->decl
),
1585 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), new_stmt
);
1588 /* If new callee has no static chain, remove it. */
1589 if (gimple_call_chain (new_stmt
) && !DECL_STATIC_CHAIN (e
->callee
->decl
))
1591 gimple_call_set_chain (new_stmt
, NULL
);
1592 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), new_stmt
);
1595 maybe_remove_unused_call_args (DECL_STRUCT_FUNCTION (e
->caller
->decl
),
1598 e
->caller
->set_call_stmt_including_clones (e
->call_stmt
, new_stmt
, false);
1600 if (symtab
->dump_file
)
1602 fprintf (symtab
->dump_file
, " updated to:");
1603 print_gimple_stmt (symtab
->dump_file
, e
->call_stmt
, 0, dump_flags
);
1608 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1609 OLD_STMT changed into NEW_STMT. OLD_CALL is gimple_call_fndecl
1610 of OLD_STMT if it was previously call statement.
1611 If NEW_STMT is NULL, the call has been dropped without any
1615 cgraph_update_edges_for_call_stmt_node (cgraph_node
*node
,
1616 gimple
*old_stmt
, tree old_call
,
1619 tree new_call
= (new_stmt
&& is_gimple_call (new_stmt
))
1620 ? gimple_call_fndecl (new_stmt
) : 0;
1622 /* We are seeing indirect calls, then there is nothing to update. */
1623 if (!new_call
&& !old_call
)
1625 /* See if we turned indirect call into direct call or folded call to one builtin
1626 into different builtin. */
1627 if (old_call
!= new_call
)
1629 cgraph_edge
*e
= node
->get_edge (old_stmt
);
1630 cgraph_edge
*ne
= NULL
;
1631 profile_count count
;
1635 /* Keep calls marked as dead dead. */
1636 if (new_stmt
&& is_gimple_call (new_stmt
) && e
->callee
1637 && fndecl_built_in_p (e
->callee
->decl
, BUILT_IN_UNREACHABLE
))
1639 cgraph_edge::set_call_stmt (node
->get_edge (old_stmt
),
1640 as_a
<gcall
*> (new_stmt
));
1643 /* See if the edge is already there and has the correct callee. It
1644 might be so because of indirect inlining has already updated
1645 it. We also might've cloned and redirected the edge. */
1646 if (new_call
&& e
->callee
)
1648 cgraph_node
*callee
= e
->callee
;
1651 if (callee
->decl
== new_call
1652 || callee
->former_clone_of
== new_call
)
1654 cgraph_edge::set_call_stmt (e
, as_a
<gcall
*> (new_stmt
));
1657 callee
= callee
->clone_of
;
1661 /* Otherwise remove edge and create new one; we can't simply redirect
1662 since function has changed, so inline plan and other information
1663 attached to edge is invalid. */
1665 if (e
->indirect_unknown_callee
|| e
->inline_failed
)
1666 cgraph_edge::remove (e
);
1668 e
->callee
->remove_symbol_and_inline_clones ();
1672 /* We are seeing new direct call; compute profile info based on BB. */
1673 basic_block bb
= gimple_bb (new_stmt
);
1679 ne
= node
->create_edge (cgraph_node::get_create (new_call
),
1680 as_a
<gcall
*> (new_stmt
), count
);
1681 gcc_assert (ne
->inline_failed
);
1684 /* We only updated the call stmt; update pointer in cgraph edge.. */
1685 else if (old_stmt
!= new_stmt
)
1686 cgraph_edge::set_call_stmt (node
->get_edge (old_stmt
),
1687 as_a
<gcall
*> (new_stmt
));
1690 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1691 OLD_STMT changed into NEW_STMT. OLD_DECL is gimple_call_fndecl
1692 of OLD_STMT before it was updated (updating can happen inplace). */
1695 cgraph_update_edges_for_call_stmt (gimple
*old_stmt
, tree old_decl
,
1698 cgraph_node
*orig
= cgraph_node::get (cfun
->decl
);
1701 gcc_checking_assert (orig
);
1702 cgraph_update_edges_for_call_stmt_node (orig
, old_stmt
, old_decl
, new_stmt
);
1704 for (node
= orig
->clones
; node
!= orig
;)
1706 cgraph_update_edges_for_call_stmt_node (node
, old_stmt
, old_decl
,
1709 node
= node
->clones
;
1710 else if (node
->next_sibling_clone
)
1711 node
= node
->next_sibling_clone
;
1714 while (node
!= orig
&& !node
->next_sibling_clone
)
1715 node
= node
->clone_of
;
1717 node
= node
->next_sibling_clone
;
1723 /* Remove all callees from the node. */
1726 cgraph_node::remove_callees (void)
1730 calls_comdat_local
= false;
1732 /* It is sufficient to remove the edges from the lists of callers of
1733 the callees. The callee list of the node can be zapped with one
1735 for (e
= callees
; e
; e
= f
)
1738 symtab
->call_edge_removal_hooks (e
);
1739 if (!e
->indirect_unknown_callee
)
1740 e
->remove_callee ();
1741 symtab
->free_edge (e
);
1743 for (e
= indirect_calls
; e
; e
= f
)
1746 symtab
->call_edge_removal_hooks (e
);
1747 if (!e
->indirect_unknown_callee
)
1748 e
->remove_callee ();
1749 symtab
->free_edge (e
);
1751 indirect_calls
= NULL
;
1755 call_site_hash
->empty ();
1756 call_site_hash
= NULL
;
1760 /* Remove all callers from the node. */
1763 cgraph_node::remove_callers (void)
1767 /* It is sufficient to remove the edges from the lists of callees of
1768 the callers. The caller list of the node can be zapped with one
1770 for (e
= callers
; e
; e
= f
)
1773 symtab
->call_edge_removal_hooks (e
);
1774 e
->remove_caller ();
1775 symtab
->free_edge (e
);
1780 /* Helper function for cgraph_release_function_body and free_lang_data.
1781 It releases body from function DECL without having to inspect its
1782 possibly non-existent symtab node. */
1785 release_function_body (tree decl
)
1787 function
*fn
= DECL_STRUCT_FUNCTION (decl
);
1791 && loops_for_fn (fn
))
1793 fn
->curr_properties
&= ~PROP_loops
;
1794 loop_optimizer_finalize (fn
);
1798 delete_tree_ssa (fn
);
1803 gcc_assert (!dom_info_available_p (fn
, CDI_DOMINATORS
));
1804 gcc_assert (!dom_info_available_p (fn
, CDI_POST_DOMINATORS
));
1805 delete_tree_cfg_annotations (fn
);
1809 if (fn
->value_histograms
)
1810 free_histograms (fn
);
1811 gimple_set_body (decl
, NULL
);
1812 /* Struct function hangs a lot of data that would leak if we didn't
1813 removed all pointers to it. */
1815 DECL_STRUCT_FUNCTION (decl
) = NULL
;
1817 DECL_SAVED_TREE (decl
) = NULL
;
1820 /* Release memory used to represent body of function.
1821 Use this only for functions that are released before being translated to
1822 target code (i.e. RTL). Functions that are compiled to RTL and beyond
1823 are free'd in final.cc via free_after_compilation().
1824 KEEP_ARGUMENTS are useful only if you want to rebuild body as thunk. */
1827 cgraph_node::release_body (bool keep_arguments
)
1829 ipa_transforms_to_apply
.release ();
1830 if (!used_as_abstract_origin
&& symtab
->state
!= PARSING
)
1832 DECL_RESULT (decl
) = NULL
;
1834 if (!keep_arguments
)
1835 DECL_ARGUMENTS (decl
) = NULL
;
1837 /* If the node is abstract and needed, then do not clear
1838 DECL_INITIAL of its associated function declaration because it's
1839 needed to emit debug info later. */
1840 if (!used_as_abstract_origin
&& DECL_INITIAL (decl
))
1841 DECL_INITIAL (decl
) = error_mark_node
;
1842 release_function_body (decl
);
1845 lto_free_function_in_decl_state_for_node (this);
1846 lto_file_data
= NULL
;
1848 if (flag_checking
&& clones
)
1850 /* It is invalid to release body before materializing clones except
1851 for thunks that don't really need a body. Verify also that we do
1852 not leak pointers to the call statements. */
1853 for (cgraph_node
*node
= clones
; node
;
1854 node
= node
->next_sibling_clone
)
1855 gcc_assert (node
->thunk
&& !node
->callees
->call_stmt
);
1858 remove_all_references ();
1861 /* Remove function from symbol table. */
1864 cgraph_node::remove (void)
1866 bool clone_info_set
= false;
1867 clone_info
*info
, saved_info
;
1868 if (symtab
->ipa_clones_dump_file
&& symtab
->cloned_nodes
.contains (this))
1869 fprintf (symtab
->ipa_clones_dump_file
,
1870 "Callgraph removal;%s;%d;%s;%d;%d\n", asm_name (), order
,
1871 DECL_SOURCE_FILE (decl
), DECL_SOURCE_LINE (decl
),
1872 DECL_SOURCE_COLUMN (decl
));
1874 if ((info
= clone_info::get (this)) != NULL
)
1877 clone_info_set
= true;
1879 symtab
->call_cgraph_removal_hooks (this);
1882 ipa_transforms_to_apply
.release ();
1883 delete_function_version (function_version ());
1885 /* Incremental inlining access removed nodes stored in the postorder list.
1887 force_output
= false;
1888 forced_by_abi
= false;
1890 unregister (clone_info_set
? &saved_info
: NULL
);
1891 if (prev_sibling_clone
)
1892 prev_sibling_clone
->next_sibling_clone
= next_sibling_clone
;
1895 clone_of
->clones
= next_sibling_clone
;
1896 if (!clone_of
->analyzed
&& !clone_of
->clones
&& !clones
)
1897 clone_of
->release_body ();
1899 if (next_sibling_clone
)
1900 next_sibling_clone
->prev_sibling_clone
= prev_sibling_clone
;
1903 cgraph_node
*n
, *next
;
1907 for (n
= clones
; n
->next_sibling_clone
; n
= n
->next_sibling_clone
)
1908 n
->clone_of
= clone_of
;
1909 n
->clone_of
= clone_of
;
1910 n
->next_sibling_clone
= clone_of
->clones
;
1911 if (clone_of
->clones
)
1912 clone_of
->clones
->prev_sibling_clone
= n
;
1913 clone_of
->clones
= clones
;
1917 /* We are removing node with clones. This makes clones inconsistent,
1918 but assume they will be removed subsequently and just keep clone
1919 tree intact. This can happen in unreachable function removal since
1920 we remove unreachable functions in random order, not by bottom-up
1921 walk of clone trees. */
1922 for (n
= clones
; n
; n
= next
)
1924 next
= n
->next_sibling_clone
;
1925 n
->next_sibling_clone
= NULL
;
1926 n
->prev_sibling_clone
= NULL
;
1932 /* While all the clones are removed after being proceeded, the function
1933 itself is kept in the cgraph even after it is compiled. Check whether
1934 we are done with this body and reclaim it proactively if this is the case.
1936 if (symtab
->state
!= LTO_STREAMING
)
1938 cgraph_node
*n
= cgraph_node::get (decl
);
1940 || (!n
->clones
&& !n
->clone_of
&& !n
->inlined_to
1941 && ((symtab
->global_info_ready
|| in_lto_p
)
1942 && (TREE_ASM_WRITTEN (n
->decl
)
1943 || DECL_EXTERNAL (n
->decl
)
1945 || (!flag_wpa
&& n
->in_other_partition
)))))
1950 lto_free_function_in_decl_state_for_node (this);
1951 lto_file_data
= NULL
;
1957 call_site_hash
->empty ();
1958 call_site_hash
= NULL
;
1961 symtab
->release_symbol (this);
1964 /* Likewise indicate that a node is having address taken. */
1967 cgraph_node::mark_address_taken (void)
1969 /* Indirect inlining can figure out that all uses of the address are
1973 gcc_assert (cfun
->after_inlining
);
1974 gcc_assert (callers
->indirect_inlining_edge
);
1977 /* FIXME: address_taken flag is used both as a shortcut for testing whether
1978 IPA_REF_ADDR reference exists (and thus it should be set on node
1979 representing alias we take address of) and as a test whether address
1980 of the object was taken (and thus it should be set on node alias is
1981 referring to). We should remove the first use and the remove the
1984 cgraph_node
*node
= ultimate_alias_target ();
1985 node
->address_taken
= 1;
1988 /* Return local info node for the compiled function. */
1991 cgraph_node::local_info_node (tree decl
)
1993 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1994 cgraph_node
*node
= get (decl
);
1997 return node
->ultimate_alias_target ();
2000 /* Return RTL info for the compiled function. */
2003 cgraph_node::rtl_info (const_tree decl
)
2005 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
2006 cgraph_node
*node
= get (decl
);
2009 enum availability avail
;
2010 node
= node
->ultimate_alias_target (&avail
);
2011 if (decl
!= current_function_decl
2012 && (avail
< AVAIL_AVAILABLE
2013 || (node
->decl
!= current_function_decl
2014 && !TREE_ASM_WRITTEN (node
->decl
))))
2016 /* Allocate if it doesn't exist. */
2017 if (node
->rtl
== NULL
)
2019 node
->rtl
= ggc_cleared_alloc
<cgraph_rtl_info
> ();
2020 SET_HARD_REG_SET (node
->rtl
->function_used_regs
);
2025 /* Return a string describing the failure REASON. */
2028 cgraph_inline_failed_string (cgraph_inline_failed_t reason
)
2031 #define DEFCIFCODE(code, type, string) string,
2033 static const char *cif_string_table
[CIF_N_REASONS
] = {
2034 #include "cif-code.def"
2037 /* Signedness of an enum type is implementation defined, so cast it
2038 to unsigned before testing. */
2039 gcc_assert ((unsigned) reason
< CIF_N_REASONS
);
2040 return cif_string_table
[reason
];
2043 /* Return a type describing the failure REASON. */
2045 cgraph_inline_failed_type_t
2046 cgraph_inline_failed_type (cgraph_inline_failed_t reason
)
2049 #define DEFCIFCODE(code, type, string) type,
2051 static cgraph_inline_failed_type_t cif_type_table
[CIF_N_REASONS
] = {
2052 #include "cif-code.def"
2055 /* Signedness of an enum type is implementation defined, so cast it
2056 to unsigned before testing. */
2057 gcc_assert ((unsigned) reason
< CIF_N_REASONS
);
2058 return cif_type_table
[reason
];
2061 /* Names used to print out the availability enum. */
2062 const char * const cgraph_availability_names
[] =
2063 {"unset", "not_available", "overwritable", "available", "local"};
2065 /* Output flags of edge to a file F. */
2068 cgraph_edge::dump_edge_flags (FILE *f
)
2071 fprintf (f
, "(speculative) ");
2073 fprintf (f
, "(inlined) ");
2074 if (call_stmt_cannot_inline_p
)
2075 fprintf (f
, "(call_stmt_cannot_inline_p) ");
2076 if (indirect_inlining_edge
)
2077 fprintf (f
, "(indirect_inlining) ");
2078 if (count
.initialized_p ())
2083 fprintf (f
, "%.2f per call) ", sreal_frequency ().to_double ());
2085 if (can_throw_external
)
2086 fprintf (f
, "(can throw external) ");
2089 /* Dump edge to stderr. */
2092 cgraph_edge::debug (void)
2094 fprintf (stderr
, "%s -> %s ", caller
->dump_asm_name (),
2095 callee
== NULL
? "(null)" : callee
->dump_asm_name ());
2096 dump_edge_flags (stderr
);
2097 fprintf (stderr
, "\n\n");
2103 /* Dump call graph node to file F. */
2106 cgraph_node::dump (FILE *f
)
2113 fprintf (f
, " Function %s is inline copy in %s\n",
2115 inlined_to
->dump_name ());
2117 fprintf (f
, " Clone of %s\n", clone_of
->dump_asm_name ());
2118 if (symtab
->function_flags_ready
)
2119 fprintf (f
, " Availability: %s\n",
2120 cgraph_availability_names
[get_availability ()]);
2123 fprintf (f
, " Profile id: %i\n",
2126 fprintf (f
, " Unit id: %i\n",
2128 cgraph_function_version_info
*vi
= function_version ();
2131 fprintf (f
, " Version info: ");
2132 if (vi
->prev
!= NULL
)
2134 fprintf (f
, "prev: ");
2135 fprintf (f
, "%s ", vi
->prev
->this_node
->dump_asm_name ());
2137 if (vi
->next
!= NULL
)
2139 fprintf (f
, "next: ");
2140 fprintf (f
, "%s ", vi
->next
->this_node
->dump_asm_name ());
2142 if (vi
->dispatcher_resolver
!= NULL_TREE
)
2143 fprintf (f
, "dispatcher: %s",
2144 lang_hooks
.decl_printable_name (vi
->dispatcher_resolver
, 2));
2148 fprintf (f
, " Function flags:");
2149 if (count
.initialized_p ())
2151 fprintf (f
, " count:");
2154 if (tp_first_run
> 0)
2155 fprintf (f
, " first_run:%" PRId64
, (int64_t) tp_first_run
);
2156 if (cgraph_node
*origin
= nested_function_origin (this))
2157 fprintf (f
, " nested in:%s", origin
->dump_asm_name ());
2158 if (gimple_has_body_p (decl
))
2159 fprintf (f
, " body");
2161 fprintf (f
, " process");
2163 fprintf (f
, " local");
2164 if (redefined_extern_inline
)
2165 fprintf (f
, " redefined_extern_inline");
2166 if (only_called_at_startup
)
2167 fprintf (f
, " only_called_at_startup");
2168 if (only_called_at_exit
)
2169 fprintf (f
, " only_called_at_exit");
2171 fprintf (f
, " tm_clone");
2172 if (calls_comdat_local
)
2173 fprintf (f
, " calls_comdat_local");
2175 fprintf (f
, " icf_merged");
2177 fprintf (f
, " merged_comdat");
2178 if (merged_extern_inline
)
2179 fprintf (f
, " merged_extern_inline");
2181 fprintf (f
, " split_part");
2182 if (indirect_call_target
)
2183 fprintf (f
, " indirect_call_target");
2185 fprintf (f
, " nonfreeing_fn");
2186 if (DECL_STATIC_CONSTRUCTOR (decl
))
2187 fprintf (f
," static_constructor (priority:%i)", get_init_priority ());
2188 if (DECL_STATIC_DESTRUCTOR (decl
))
2189 fprintf (f
," static_destructor (priority:%i)", get_fini_priority ());
2190 if (frequency
== NODE_FREQUENCY_HOT
)
2191 fprintf (f
, " hot");
2192 if (frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
)
2193 fprintf (f
, " unlikely_executed");
2194 if (frequency
== NODE_FREQUENCY_EXECUTED_ONCE
)
2195 fprintf (f
, " executed_once");
2196 if (opt_for_fn (decl
, optimize_size
))
2197 fprintf (f
, " optimize_size");
2198 if (parallelized_function
)
2199 fprintf (f
, " parallelized_function");
2200 if (DECL_IS_MALLOC (decl
))
2201 fprintf (f
, " decl_is_malloc");
2202 if (DECL_IS_OPERATOR_NEW_P (decl
))
2203 fprintf (f
, " %soperator_new",
2204 DECL_IS_REPLACEABLE_OPERATOR (decl
) ? "replaceable_" : "");
2205 if (DECL_IS_OPERATOR_DELETE_P (decl
))
2206 fprintf (f
, " %soperator_delete",
2207 DECL_IS_REPLACEABLE_OPERATOR (decl
) ? "replaceable_" : "");
2209 if (DECL_STATIC_CHAIN (decl
))
2210 fprintf (f
, " static_chain");
2216 fprintf (f
, " Thunk");
2217 thunk_info::get (this)->dump (f
);
2219 else if (former_thunk_p ())
2221 fprintf (f
, " Former thunk ");
2222 thunk_info::get (this)->dump (f
);
2224 else gcc_checking_assert (!thunk_info::get (this));
2226 fprintf (f
, " Called by: ");
2228 profile_count sum
= profile_count::zero ();
2229 for (edge
= callers
; edge
; edge
= edge
->next_caller
)
2231 fprintf (f
, "%s ", edge
->caller
->dump_asm_name ());
2232 edge
->dump_edge_flags (f
);
2233 if (edge
->count
.initialized_p ())
2234 sum
+= edge
->count
.ipa ();
2237 fprintf (f
, "\n Calls: ");
2238 for (edge
= callees
; edge
; edge
= edge
->next_callee
)
2240 fprintf (f
, "%s ", edge
->callee
->dump_asm_name ());
2241 edge
->dump_edge_flags (f
);
2245 if (!body_removed
&& count
.ipa ().initialized_p ())
2251 FOR_EACH_ALIAS (this, ref
)
2252 if (dyn_cast
<cgraph_node
*> (ref
->referring
)->count
.initialized_p ())
2253 sum
+= dyn_cast
<cgraph_node
*> (ref
->referring
)->count
.ipa ();
2256 || (symtab
->state
< EXPANSION
2257 && ultimate_alias_target () == this && only_called_directly_p ()))
2258 ok
= !count
.ipa ().differs_from_p (sum
);
2259 else if (count
.ipa () > profile_count::from_gcov_type (100)
2260 && count
.ipa () < sum
.apply_scale (99, 100))
2261 ok
= false, min
= true;
2264 fprintf (f
, " Invalid sum of caller counts ");
2267 fprintf (f
, ", should be at most ");
2269 fprintf (f
, ", should be ");
2270 count
.ipa ().dump (f
);
2275 for (edge
= indirect_calls
; edge
; edge
= edge
->next_callee
)
2277 if (edge
->indirect_info
->polymorphic
)
2279 fprintf (f
, " Polymorphic indirect call of type ");
2280 print_generic_expr (f
, edge
->indirect_info
->otr_type
, TDF_SLIM
);
2281 fprintf (f
, " token:%i", (int) edge
->indirect_info
->otr_token
);
2284 fprintf (f
, " Indirect call");
2285 edge
->dump_edge_flags (f
);
2286 if (edge
->indirect_info
->param_index
!= -1)
2288 fprintf (f
, "of param:%i ", edge
->indirect_info
->param_index
);
2289 if (edge
->indirect_info
->agg_contents
)
2290 fprintf (f
, "loaded from %s %s at offset %i ",
2291 edge
->indirect_info
->member_ptr
? "member ptr" : "aggregate",
2292 edge
->indirect_info
->by_ref
? "passed by reference":"",
2293 (int)edge
->indirect_info
->offset
);
2294 if (edge
->indirect_info
->vptr_changed
)
2295 fprintf (f
, "(vptr maybe changed) ");
2297 fprintf (f
, "num speculative call targets: %i\n",
2298 edge
->indirect_info
->num_speculative_call_targets
);
2299 if (edge
->indirect_info
->polymorphic
)
2300 edge
->indirect_info
->context
.dump (f
);
2304 /* Dump call graph node to file F in graphviz format. */
2307 cgraph_node::dump_graphviz (FILE *f
)
2311 for (edge
= callees
; edge
; edge
= edge
->next_callee
)
2313 cgraph_node
*callee
= edge
->callee
;
2315 fprintf (f
, "\t\"%s\" -> \"%s\"\n", dump_name (), callee
->dump_name ());
2320 /* Dump call graph node NODE to stderr. */
2323 cgraph_node::debug (void)
2328 /* Dump the callgraph to file F. */
2331 cgraph_node::dump_cgraph (FILE *f
)
2335 fprintf (f
, "callgraph:\n\n");
2336 FOR_EACH_FUNCTION (node
)
2340 /* Return true when the DECL can possibly be inlined. */
2343 cgraph_function_possibly_inlined_p (tree decl
)
2345 if (!symtab
->global_info_ready
)
2346 return !DECL_UNINLINABLE (decl
);
2347 return DECL_POSSIBLY_INLINED (decl
);
2350 /* Return function availability. See cgraph.h for description of individual
2353 cgraph_node::get_availability (symtab_node
*ref
)
2357 cgraph_node
*cref
= dyn_cast
<cgraph_node
*> (ref
);
2359 ref
= cref
->inlined_to
;
2361 enum availability avail
;
2362 if (!analyzed
&& !in_other_partition
)
2363 avail
= AVAIL_NOT_AVAILABLE
;
2365 avail
= AVAIL_LOCAL
;
2366 else if (inlined_to
)
2367 avail
= AVAIL_AVAILABLE
;
2368 else if (transparent_alias
)
2369 ultimate_alias_target (&avail
, ref
);
2370 else if (ifunc_resolver
2371 || lookup_attribute ("noipa", DECL_ATTRIBUTES (decl
)))
2372 avail
= AVAIL_INTERPOSABLE
;
2373 else if (!externally_visible
)
2374 avail
= AVAIL_AVAILABLE
;
2375 /* If this is a reference from symbol itself and there are no aliases, we
2376 may be sure that the symbol was not interposed by something else because
2377 the symbol itself would be unreachable otherwise.
2379 Also comdat groups are always resolved in groups. */
2380 else if ((this == ref
&& !has_aliases_p ())
2381 || (ref
&& get_comdat_group ()
2382 && get_comdat_group () == ref
->get_comdat_group ()))
2383 avail
= AVAIL_AVAILABLE
;
2384 /* Inline functions are safe to be analyzed even if their symbol can
2385 be overwritten at runtime. It is not meaningful to enforce any sane
2386 behavior on replacing inline function by different body. */
2387 else if (DECL_DECLARED_INLINE_P (decl
))
2388 avail
= AVAIL_AVAILABLE
;
2390 /* If the function can be overwritten, return OVERWRITABLE. Take
2391 care at least of two notable extensions - the COMDAT functions
2392 used to share template instantiations in C++ (this is symmetric
2393 to code cp_cannot_inline_tree_fn and probably shall be shared and
2394 the inlinability hooks completely eliminated). */
2396 else if (decl_replaceable_p (decl
, semantic_interposition
)
2397 && !DECL_EXTERNAL (decl
))
2398 avail
= AVAIL_INTERPOSABLE
;
2399 else avail
= AVAIL_AVAILABLE
;
2404 /* Worker for cgraph_node_can_be_local_p. */
2406 cgraph_node_cannot_be_local_p_1 (cgraph_node
*node
, void *)
2408 return !(!node
->force_output
2409 && !node
->ifunc_resolver
2410 /* Limitation of gas requires us to output targets of symver aliases
2411 as global symbols. This is binutils PR 25295. */
2413 && ((DECL_COMDAT (node
->decl
)
2414 && !node
->forced_by_abi
2415 && !node
->used_from_object_file_p ()
2416 && !node
->same_comdat_group
)
2417 || !node
->externally_visible
));
2420 /* Return true if cgraph_node can be made local for API change.
2421 Extern inline functions and C++ COMDAT functions can be made local
2422 at the expense of possible code size growth if function is used in multiple
2423 compilation units. */
2425 cgraph_node::can_be_local_p (void)
2427 return (!address_taken
2428 && !call_for_symbol_thunks_and_aliases (cgraph_node_cannot_be_local_p_1
,
2432 /* Call callback on cgraph_node, thunks and aliases associated to cgraph_node.
2433 When INCLUDE_OVERWRITABLE is false, overwritable symbols are
2434 skipped. When EXCLUDE_VIRTUAL_THUNKS is true, virtual thunks are
2437 cgraph_node::call_for_symbol_thunks_and_aliases (bool (*callback
)
2438 (cgraph_node
*, void *),
2440 bool include_overwritable
,
2441 bool exclude_virtual_thunks
)
2445 enum availability avail
= AVAIL_AVAILABLE
;
2447 if (include_overwritable
2448 || (avail
= get_availability ()) > AVAIL_INTERPOSABLE
)
2450 if (callback (this, data
))
2453 FOR_EACH_ALIAS (this, ref
)
2455 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2456 if (include_overwritable
2457 || alias
->get_availability () > AVAIL_INTERPOSABLE
)
2458 if (alias
->call_for_symbol_thunks_and_aliases (callback
, data
,
2459 include_overwritable
,
2460 exclude_virtual_thunks
))
2463 if (avail
<= AVAIL_INTERPOSABLE
)
2465 for (e
= callers
; e
; e
= e
->next_caller
)
2466 if (e
->caller
->thunk
2467 && (include_overwritable
2468 || e
->caller
->get_availability () > AVAIL_INTERPOSABLE
)
2469 && !(exclude_virtual_thunks
2470 && thunk_info::get (e
->caller
)->virtual_offset_p
))
2471 if (e
->caller
->call_for_symbol_thunks_and_aliases (callback
, data
,
2472 include_overwritable
,
2473 exclude_virtual_thunks
))
2479 /* Worker to bring NODE local. */
2482 cgraph_node::make_local (cgraph_node
*node
, void *)
2484 gcc_checking_assert (node
->can_be_local_p ());
2485 if (DECL_COMDAT (node
->decl
) || DECL_EXTERNAL (node
->decl
))
2487 node
->make_decl_local ();
2488 node
->set_section (NULL
);
2489 node
->set_comdat_group (NULL
);
2490 node
->externally_visible
= false;
2491 node
->forced_by_abi
= false;
2493 node
->set_section (NULL
);
2494 node
->unique_name
= ((node
->resolution
== LDPR_PREVAILING_DEF_IRONLY
2495 || node
->resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
)
2496 && !flag_incremental_link
);
2497 node
->resolution
= LDPR_PREVAILING_DEF_IRONLY
;
2498 gcc_assert (node
->get_availability () == AVAIL_LOCAL
);
2503 /* Bring cgraph node local. */
2506 cgraph_node::make_local (void)
2508 call_for_symbol_thunks_and_aliases (cgraph_node::make_local
, NULL
, true);
2511 /* Worker to set nothrow flag. */
2514 set_nothrow_flag_1 (cgraph_node
*node
, bool nothrow
, bool non_call
,
2519 if (nothrow
&& !TREE_NOTHROW (node
->decl
))
2521 /* With non-call exceptions we can't say for sure if other function body
2522 was not possibly optimized to still throw. */
2523 if (!non_call
|| node
->binds_to_current_def_p ())
2525 TREE_NOTHROW (node
->decl
) = true;
2527 for (e
= node
->callers
; e
; e
= e
->next_caller
)
2528 e
->can_throw_external
= false;
2531 else if (!nothrow
&& TREE_NOTHROW (node
->decl
))
2533 TREE_NOTHROW (node
->decl
) = false;
2537 FOR_EACH_ALIAS (node
, ref
)
2539 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2540 if (!nothrow
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2541 set_nothrow_flag_1 (alias
, nothrow
, non_call
, changed
);
2543 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
2544 if (e
->caller
->thunk
2545 && (!nothrow
|| e
->caller
->get_availability () > AVAIL_INTERPOSABLE
))
2546 set_nothrow_flag_1 (e
->caller
, nothrow
, non_call
, changed
);
2549 /* Set TREE_NOTHROW on NODE's decl and on aliases of NODE
2550 if any to NOTHROW. */
2553 cgraph_node::set_nothrow_flag (bool nothrow
)
2555 bool changed
= false;
2556 bool non_call
= opt_for_fn (decl
, flag_non_call_exceptions
);
2558 if (!nothrow
|| get_availability () > AVAIL_INTERPOSABLE
)
2559 set_nothrow_flag_1 (this, nothrow
, non_call
, &changed
);
2564 FOR_EACH_ALIAS (this, ref
)
2566 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2567 if (!nothrow
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2568 set_nothrow_flag_1 (alias
, nothrow
, non_call
, &changed
);
2574 /* Worker to set malloc flag. */
2576 set_malloc_flag_1 (cgraph_node
*node
, bool malloc_p
, bool *changed
)
2578 if (malloc_p
&& !DECL_IS_MALLOC (node
->decl
))
2580 DECL_IS_MALLOC (node
->decl
) = true;
2585 FOR_EACH_ALIAS (node
, ref
)
2587 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2588 if (!malloc_p
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2589 set_malloc_flag_1 (alias
, malloc_p
, changed
);
2592 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
2593 if (e
->caller
->thunk
2594 && (!malloc_p
|| e
->caller
->get_availability () > AVAIL_INTERPOSABLE
))
2595 set_malloc_flag_1 (e
->caller
, malloc_p
, changed
);
2598 /* Set DECL_IS_MALLOC on NODE's decl and on NODE's aliases if any. */
2601 cgraph_node::set_malloc_flag (bool malloc_p
)
2603 bool changed
= false;
2605 if (!malloc_p
|| get_availability () > AVAIL_INTERPOSABLE
)
2606 set_malloc_flag_1 (this, malloc_p
, &changed
);
2611 FOR_EACH_ALIAS (this, ref
)
2613 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2614 if (!malloc_p
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2615 set_malloc_flag_1 (alias
, malloc_p
, &changed
);
2621 /* Worker to set noreturng flag. */
2623 set_noreturn_flag_1 (cgraph_node
*node
, bool noreturn_p
, bool *changed
)
2625 if (noreturn_p
&& !TREE_THIS_VOLATILE (node
->decl
))
2627 TREE_THIS_VOLATILE (node
->decl
) = true;
2632 FOR_EACH_ALIAS (node
, ref
)
2634 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2635 if (!noreturn_p
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2636 set_noreturn_flag_1 (alias
, noreturn_p
, changed
);
2639 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
2640 if (e
->caller
->thunk
2641 && (!noreturn_p
|| e
->caller
->get_availability () > AVAIL_INTERPOSABLE
))
2642 set_noreturn_flag_1 (e
->caller
, noreturn_p
, changed
);
2645 /* Set TREE_THIS_VOLATILE on NODE's decl and on NODE's aliases if any. */
2648 cgraph_node::set_noreturn_flag (bool noreturn_p
)
2650 bool changed
= false;
2652 if (!noreturn_p
|| get_availability () > AVAIL_INTERPOSABLE
)
2653 set_noreturn_flag_1 (this, noreturn_p
, &changed
);
2658 FOR_EACH_ALIAS (this, ref
)
2660 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2661 if (!noreturn_p
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2662 set_noreturn_flag_1 (alias
, noreturn_p
, &changed
);
2668 /* Worker to set_const_flag. */
2671 set_const_flag_1 (cgraph_node
*node
, bool set_const
, bool looping
,
2674 /* Static constructors and destructors without a side effect can be
2676 if (set_const
&& !looping
)
2678 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
2680 DECL_STATIC_CONSTRUCTOR (node
->decl
) = 0;
2683 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
2685 DECL_STATIC_DESTRUCTOR (node
->decl
) = 0;
2691 if (TREE_READONLY (node
->decl
))
2693 TREE_READONLY (node
->decl
) = 0;
2694 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2700 /* Consider function:
2707 During early optimization we will turn this into:
2714 Now if this function will be detected as CONST however when interposed
2715 it may end up being just pure. We always must assume the worst
2717 if (TREE_READONLY (node
->decl
))
2719 if (!looping
&& DECL_LOOPING_CONST_OR_PURE_P (node
->decl
))
2721 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2725 else if (node
->binds_to_current_def_p ())
2727 TREE_READONLY (node
->decl
) = true;
2728 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = looping
;
2729 DECL_PURE_P (node
->decl
) = false;
2734 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2735 fprintf (dump_file
, "Dropping state to PURE because function does "
2736 "not bind to current def.\n");
2737 if (!DECL_PURE_P (node
->decl
))
2739 DECL_PURE_P (node
->decl
) = true;
2740 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = looping
;
2743 else if (!looping
&& DECL_LOOPING_CONST_OR_PURE_P (node
->decl
))
2745 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2752 FOR_EACH_ALIAS (node
, ref
)
2754 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2755 if (!set_const
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2756 set_const_flag_1 (alias
, set_const
, looping
, changed
);
2758 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
2759 if (e
->caller
->thunk
2760 && (!set_const
|| e
->caller
->get_availability () > AVAIL_INTERPOSABLE
))
2762 /* Virtual thunks access virtual offset in the vtable, so they can
2763 only be pure, never const. */
2765 && (thunk_info::get (e
->caller
)->virtual_offset_p
2766 || !node
->binds_to_current_def_p (e
->caller
)))
2767 *changed
|= e
->caller
->set_pure_flag (true, looping
);
2769 set_const_flag_1 (e
->caller
, set_const
, looping
, changed
);
2773 /* If SET_CONST is true, mark function, aliases and thunks to be ECF_CONST.
2774 If SET_CONST if false, clear the flag.
2776 When setting the flag be careful about possible interposition and
2777 do not set the flag for functions that can be interposed and set pure
2778 flag for functions that can bind to other definition.
2780 Return true if any change was done. */
2783 cgraph_node::set_const_flag (bool set_const
, bool looping
)
2785 bool changed
= false;
2786 if (!set_const
|| get_availability () > AVAIL_INTERPOSABLE
)
2787 set_const_flag_1 (this, set_const
, looping
, &changed
);
2792 FOR_EACH_ALIAS (this, ref
)
2794 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2795 if (!set_const
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2796 set_const_flag_1 (alias
, set_const
, looping
, &changed
);
2802 /* Info used by set_pure_flag_1. */
2804 struct set_pure_flag_info
2811 /* Worker to set_pure_flag. */
2814 set_pure_flag_1 (cgraph_node
*node
, void *data
)
2816 struct set_pure_flag_info
*info
= (struct set_pure_flag_info
*)data
;
2817 /* Static constructors and destructors without a side effect can be
2819 if (info
->pure
&& !info
->looping
)
2821 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
2823 DECL_STATIC_CONSTRUCTOR (node
->decl
) = 0;
2824 info
->changed
= true;
2826 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
2828 DECL_STATIC_DESTRUCTOR (node
->decl
) = 0;
2829 info
->changed
= true;
2834 if (!DECL_PURE_P (node
->decl
) && !TREE_READONLY (node
->decl
))
2836 DECL_PURE_P (node
->decl
) = true;
2837 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = info
->looping
;
2838 info
->changed
= true;
2840 else if (DECL_LOOPING_CONST_OR_PURE_P (node
->decl
)
2843 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2844 info
->changed
= true;
2849 if (DECL_PURE_P (node
->decl
))
2851 DECL_PURE_P (node
->decl
) = false;
2852 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2853 info
->changed
= true;
2859 /* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node
2862 When setting the flag, be careful about possible interposition.
2863 Return true if any change was done. */
2866 cgraph_node::set_pure_flag (bool pure
, bool looping
)
2868 struct set_pure_flag_info info
= {pure
, looping
, false};
2869 call_for_symbol_thunks_and_aliases (set_pure_flag_1
, &info
, !pure
, true);
2870 return info
.changed
;
2873 /* Return true when cgraph_node cannot return or throw and thus
2874 it is safe to ignore its side effects for IPA analysis. */
2877 cgraph_node::cannot_return_p (void)
2879 int flags
= flags_from_decl_or_type (decl
);
2880 if (!opt_for_fn (decl
, flag_exceptions
))
2881 return (flags
& ECF_NORETURN
) != 0;
2883 return ((flags
& (ECF_NORETURN
| ECF_NOTHROW
))
2884 == (ECF_NORETURN
| ECF_NOTHROW
));
2887 /* Return true when call of edge cannot lead to return from caller
2888 and thus it is safe to ignore its side effects for IPA analysis
2889 when computing side effects of the caller.
2890 FIXME: We could actually mark all edges that have no reaching
2891 patch to the exit block or throw to get better results. */
2893 cgraph_edge::cannot_lead_to_return_p (void)
2895 if (caller
->cannot_return_p ())
2897 if (indirect_unknown_callee
)
2899 int flags
= indirect_info
->ecf_flags
;
2900 if (!opt_for_fn (caller
->decl
, flag_exceptions
))
2901 return (flags
& ECF_NORETURN
) != 0;
2903 return ((flags
& (ECF_NORETURN
| ECF_NOTHROW
))
2904 == (ECF_NORETURN
| ECF_NOTHROW
));
2907 return callee
->cannot_return_p ();
2910 /* Return true if the edge may be considered hot. */
2913 cgraph_edge::maybe_hot_p (void)
2915 if (!maybe_hot_count_p (NULL
, count
.ipa ()))
2917 if (caller
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
2919 && callee
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
))
2921 if (caller
->frequency
> NODE_FREQUENCY_UNLIKELY_EXECUTED
2923 && callee
->frequency
<= NODE_FREQUENCY_EXECUTED_ONCE
))
2925 if (opt_for_fn (caller
->decl
, optimize_size
))
2927 if (caller
->frequency
== NODE_FREQUENCY_HOT
)
2929 if (!count
.initialized_p ())
2931 cgraph_node
*where
= caller
->inlined_to
? caller
->inlined_to
: caller
;
2932 if (!where
->count
.initialized_p ())
2934 if (caller
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
)
2936 if (count
* 2 < where
->count
* 3)
2939 else if (count
* param_hot_bb_frequency_fraction
< where
->count
)
2944 /* Worker for cgraph_can_remove_if_no_direct_calls_p. */
2947 nonremovable_p (cgraph_node
*node
, void *)
2949 return !node
->can_remove_if_no_direct_calls_and_refs_p ();
2952 /* Return true if whole comdat group can be removed if there are no direct
2956 cgraph_node::can_remove_if_no_direct_calls_p (bool will_inline
)
2958 struct ipa_ref
*ref
;
2960 /* For local symbols or non-comdat group it is the same as
2961 can_remove_if_no_direct_calls_p. */
2962 if (!externally_visible
|| !same_comdat_group
)
2964 if (DECL_EXTERNAL (decl
))
2968 return !call_for_symbol_and_aliases (nonremovable_p
, NULL
, true);
2971 if (will_inline
&& address_taken
)
2974 /* Otherwise check if we can remove the symbol itself and then verify
2975 that only uses of the comdat groups are direct call to THIS
2977 if (!can_remove_if_no_direct_calls_and_refs_p ())
2980 /* Check that all refs come from within the comdat group. */
2981 for (int i
= 0; iterate_referring (i
, ref
); i
++)
2982 if (ref
->referring
->get_comdat_group () != get_comdat_group ())
2985 struct cgraph_node
*target
= ultimate_alias_target ();
2986 for (cgraph_node
*next
= dyn_cast
<cgraph_node
*> (same_comdat_group
);
2987 next
!= this; next
= dyn_cast
<cgraph_node
*> (next
->same_comdat_group
))
2989 if (!externally_visible
)
2992 && !next
->can_remove_if_no_direct_calls_and_refs_p ())
2995 /* If we see different symbol than THIS, be sure to check calls. */
2996 if (next
->ultimate_alias_target () != target
)
2997 for (cgraph_edge
*e
= next
->callers
; e
; e
= e
->next_caller
)
2998 if (e
->caller
->get_comdat_group () != get_comdat_group ()
3002 /* If function is not being inlined, we care only about
3003 references outside of the comdat group. */
3005 for (int i
= 0; next
->iterate_referring (i
, ref
); i
++)
3006 if (ref
->referring
->get_comdat_group () != get_comdat_group ())
3012 /* Return true when function cgraph_node can be expected to be removed
3013 from program when direct calls in this compilation unit are removed.
3015 As a special case COMDAT functions are
3016 cgraph_can_remove_if_no_direct_calls_p while the are not
3017 cgraph_only_called_directly_p (it is possible they are called from other
3020 This function behaves as cgraph_only_called_directly_p because eliminating
3021 all uses of COMDAT function does not make it necessarily disappear from
3022 the program unless we are compiling whole program or we do LTO. In this
3023 case we know we win since dynamic linking will not really discard the
3024 linkonce section. */
3027 cgraph_node::will_be_removed_from_program_if_no_direct_calls_p
3030 gcc_assert (!inlined_to
);
3031 if (DECL_EXTERNAL (decl
))
3034 if (!in_lto_p
&& !flag_whole_program
)
3036 /* If the symbol is in comdat group, we need to verify that whole comdat
3037 group becomes unreachable. Technically we could skip references from
3038 within the group, too. */
3039 if (!only_called_directly_p ())
3041 if (same_comdat_group
&& externally_visible
)
3043 struct cgraph_node
*target
= ultimate_alias_target ();
3045 if (will_inline
&& address_taken
)
3047 for (cgraph_node
*next
= dyn_cast
<cgraph_node
*> (same_comdat_group
);
3049 next
= dyn_cast
<cgraph_node
*> (next
->same_comdat_group
))
3051 if (!externally_visible
)
3054 && !next
->only_called_directly_p ())
3057 /* If we see different symbol than THIS,
3058 be sure to check calls. */
3059 if (next
->ultimate_alias_target () != target
)
3060 for (cgraph_edge
*e
= next
->callers
; e
; e
= e
->next_caller
)
3061 if (e
->caller
->get_comdat_group () != get_comdat_group ()
3069 return can_remove_if_no_direct_calls_p (will_inline
);
3073 /* Worker for cgraph_only_called_directly_p. */
3076 cgraph_not_only_called_directly_p_1 (cgraph_node
*node
, void *)
3078 return !node
->only_called_directly_or_aliased_p ();
3081 /* Return true when function cgraph_node and all its aliases are only called
3083 i.e. it is not externally visible, address was not taken and
3084 it is not used in any other non-standard way. */
3087 cgraph_node::only_called_directly_p (void)
3089 gcc_assert (ultimate_alias_target () == this);
3090 return !call_for_symbol_and_aliases (cgraph_not_only_called_directly_p_1
,
3095 /* Collect all callers of NODE. Worker for collect_callers_of_node. */
3098 collect_callers_of_node_1 (cgraph_node
*node
, void *data
)
3100 vec
<cgraph_edge
*> *redirect_callers
= (vec
<cgraph_edge
*> *)data
;
3102 enum availability avail
;
3103 node
->ultimate_alias_target (&avail
);
3105 if (avail
> AVAIL_INTERPOSABLE
)
3106 for (cs
= node
->callers
; cs
!= NULL
; cs
= cs
->next_caller
)
3107 if (!cs
->indirect_inlining_edge
3108 && !cs
->caller
->thunk
)
3109 redirect_callers
->safe_push (cs
);
3113 /* Collect all callers of cgraph_node and its aliases that are known to lead to
3114 cgraph_node (i.e. are not overwritable). */
3116 auto_vec
<cgraph_edge
*>
3117 cgraph_node::collect_callers (void)
3119 auto_vec
<cgraph_edge
*> redirect_callers
;
3120 call_for_symbol_thunks_and_aliases (collect_callers_of_node_1
,
3121 &redirect_callers
, false);
3122 return redirect_callers
;
3126 /* Return TRUE if NODE2 a clone of NODE or is equivalent to it. Return
3127 optimistically true if this cannot be determined. */
3130 clone_of_p (cgraph_node
*node
, cgraph_node
*node2
)
3132 node
= node
->ultimate_alias_target ();
3133 node2
= node2
->ultimate_alias_target ();
3135 if (node2
->clone_of
== node
3136 || node2
->former_clone_of
== node
->decl
)
3139 if (!node
->thunk
&& !node
->former_thunk_p ())
3142 && node
->decl
!= node2
->decl
3143 && node
->decl
!= node2
->former_clone_of
)
3144 node2
= node2
->clone_of
;
3145 return node2
!= NULL
;
3148 /* There are no virtual clones of thunks so check former_clone_of or if we
3149 might have skipped thunks because this adjustments are no longer
3151 while (node
->thunk
|| node
->former_thunk_p ())
3153 if (!thunk_info::get (node
)->this_adjusting
)
3155 /* In case of instrumented expanded thunks, which can have multiple calls
3156 in them, we do not know how to continue and just have to be
3157 optimistic. The same applies if all calls have already been inlined
3159 if (!node
->callees
|| node
->callees
->next_callee
)
3161 node
= node
->callees
->callee
->ultimate_alias_target ();
3163 clone_info
*info
= clone_info::get (node2
);
3164 if (!info
|| !info
->param_adjustments
3165 || info
->param_adjustments
->first_param_intact_p ())
3167 if (node2
->former_clone_of
== node
->decl
3168 || node2
->former_clone_of
== node
->former_clone_of
)
3171 cgraph_node
*n2
= node2
;
3172 while (n2
&& node
->decl
!= n2
->decl
)
3181 /* Verify edge count and frequency. */
3184 cgraph_edge::verify_count ()
3186 bool error_found
= false;
3187 if (!count
.verify ())
3189 error ("caller edge count invalid");
3195 /* Switch to THIS_CFUN if needed and print STMT to stderr. */
3197 cgraph_debug_gimple_stmt (function
*this_cfun
, gimple
*stmt
)
3199 bool fndecl_was_null
= false;
3200 /* debug_gimple_stmt needs correct cfun */
3201 if (cfun
!= this_cfun
)
3202 set_cfun (this_cfun
);
3203 /* ...and an actual current_function_decl */
3204 if (!current_function_decl
)
3206 current_function_decl
= this_cfun
->decl
;
3207 fndecl_was_null
= true;
3209 debug_gimple_stmt (stmt
);
3210 if (fndecl_was_null
)
3211 current_function_decl
= NULL
;
3214 /* Verify that call graph edge corresponds to DECL from the associated
3215 statement. Return true if the verification should fail. */
3218 cgraph_edge::verify_corresponds_to_fndecl (tree decl
)
3222 if (!decl
|| callee
->inlined_to
)
3224 if (symtab
->state
== LTO_STREAMING
)
3226 node
= cgraph_node::get (decl
);
3228 /* We do not know if a node from a different partition is an alias or what it
3229 aliases and therefore cannot do the former_clone_of check reliably. When
3230 body_removed is set, we have lost all information about what was alias or
3231 thunk of and also cannot proceed. */
3233 || node
->body_removed
3234 || node
->in_other_partition
3235 || callee
->icf_merged
3236 || callee
->in_other_partition
)
3239 node
= node
->ultimate_alias_target ();
3241 /* Optimizers can redirect unreachable calls or calls triggering undefined
3242 behavior to builtin_unreachable. */
3244 if (fndecl_built_in_p (callee
->decl
, BUILT_IN_UNREACHABLE
))
3247 if (callee
->former_clone_of
!= node
->decl
3248 && (node
!= callee
->ultimate_alias_target ())
3249 && !clone_of_p (node
, callee
))
3255 /* Disable warnings about missing quoting in GCC diagnostics for
3256 the verification errors. Their format strings don't follow GCC
3257 diagnostic conventions and the calls are ultimately followed by
3258 one to internal_error. */
3260 # pragma GCC diagnostic push
3261 # pragma GCC diagnostic ignored "-Wformat-diag"
3264 /* Verify consistency of speculative call in NODE corresponding to STMT
3265 and LTO_STMT_UID. If INDIRECT is set, assume that it is the indirect
3266 edge of call sequence. Return true if error is found.
3268 This function is called to every component of indirect call (direct edges,
3269 indirect edge and refs). To save duplicated work, do full testing only
3272 verify_speculative_call (struct cgraph_node
*node
, gimple
*stmt
,
3273 unsigned int lto_stmt_uid
,
3274 struct cgraph_edge
*indirect
)
3276 if (indirect
== NULL
)
3278 for (indirect
= node
->indirect_calls
; indirect
;
3279 indirect
= indirect
->next_callee
)
3280 if (indirect
->call_stmt
== stmt
3281 && indirect
->lto_stmt_uid
== lto_stmt_uid
)
3285 error ("missing indirect call in speculative call sequence");
3288 if (!indirect
->speculative
)
3290 error ("indirect call in speculative call sequence has no "
3291 "speculative flag");
3297 /* Maximal number of targets. We probably will never want to have more than
3299 const unsigned int num
= 256;
3300 cgraph_edge
*direct_calls
[num
];
3303 for (unsigned int i
= 0; i
< num
; i
++)
3305 direct_calls
[i
] = NULL
;
3309 cgraph_edge
*first_call
= NULL
;
3310 cgraph_edge
*prev_call
= NULL
;
3312 for (cgraph_edge
*direct
= node
->callees
; direct
;
3313 direct
= direct
->next_callee
)
3314 if (direct
->call_stmt
== stmt
&& direct
->lto_stmt_uid
== lto_stmt_uid
)
3317 first_call
= direct
;
3318 if (prev_call
&& direct
!= prev_call
->next_callee
)
3320 error ("speculative edges are not adjacent");
3324 if (!direct
->speculative
)
3326 error ("direct call to %s in speculative call sequence has no "
3327 "speculative flag", direct
->callee
->dump_name ());
3330 if (direct
->speculative_id
>= num
)
3332 error ("direct call to %s in speculative call sequence has "
3333 "speculative_id %i out of range",
3334 direct
->callee
->dump_name (), direct
->speculative_id
);
3337 if (direct_calls
[direct
->speculative_id
])
3339 error ("duplicate direct call to %s in speculative call sequence "
3340 "with speculative_id %i",
3341 direct
->callee
->dump_name (), direct
->speculative_id
);
3344 direct_calls
[direct
->speculative_id
] = direct
;
3347 if (first_call
->call_stmt
3348 && first_call
!= node
->get_edge (first_call
->call_stmt
))
3350 error ("call stmt hash does not point to first direct edge of "
3351 "speculative call sequence");
3356 for (int i
= 0; node
->iterate_reference (i
, ref
); i
++)
3357 if (ref
->speculative
3358 && ref
->stmt
== stmt
&& ref
->lto_stmt_uid
== lto_stmt_uid
)
3360 if (ref
->speculative_id
>= num
)
3362 error ("direct call to %s in speculative call sequence has "
3363 "speculative_id %i out of range",
3364 ref
->referred
->dump_name (), ref
->speculative_id
);
3367 if (refs
[ref
->speculative_id
])
3369 error ("duplicate reference %s in speculative call sequence "
3370 "with speculative_id %i",
3371 ref
->referred
->dump_name (), ref
->speculative_id
);
3374 refs
[ref
->speculative_id
] = ref
;
3377 int num_targets
= 0;
3378 for (unsigned int i
= 0 ; i
< num
; i
++)
3380 if (refs
[i
] && !direct_calls
[i
])
3382 error ("missing direct call for speculation %i", i
);
3385 if (!refs
[i
] && direct_calls
[i
])
3387 error ("missing ref for speculation %i", i
);
3390 if (refs
[i
] != NULL
)
3394 if (num_targets
!= indirect
->num_speculative_call_targets_p ())
3396 error ("number of speculative targets %i mismatched with "
3397 "num_speculative_call_targets %i",
3399 indirect
->num_speculative_call_targets_p ());
3405 /* Verify cgraph nodes of given cgraph node. */
3407 cgraph_node::verify_node (void)
3410 function
*this_cfun
= DECL_STRUCT_FUNCTION (decl
);
3411 basic_block this_block
;
3412 gimple_stmt_iterator gsi
;
3413 bool error_found
= false;
3415 ipa_ref
*ref
= NULL
;
3420 timevar_push (TV_CGRAPH_VERIFY
);
3421 error_found
|= verify_base ();
3422 for (e
= callees
; e
; e
= e
->next_callee
)
3425 error ("aux field set for edge %s->%s",
3426 identifier_to_locale (e
->caller
->name ()),
3427 identifier_to_locale (e
->callee
->name ()));
3430 if (!count
.verify ())
3432 error ("cgraph count invalid");
3435 if (inlined_to
&& same_comdat_group
)
3437 error ("inline clone in same comdat group list");
3440 if (inlined_to
&& !count
.compatible_p (inlined_to
->count
))
3442 error ("inline clone count is not compatible");
3444 inlined_to
->count
.debug ();
3447 if (tp_first_run
< 0)
3449 error ("tp_first_run must be non-negative");
3452 if (!definition
&& !in_other_partition
&& local
)
3454 error ("local symbols must be defined");
3457 if (inlined_to
&& externally_visible
)
3459 error ("externally visible inline clone");
3462 if (inlined_to
&& address_taken
)
3464 error ("inline clone with address taken");
3467 if (inlined_to
&& force_output
)
3469 error ("inline clone is forced to output");
3472 if (symtab
->state
!= LTO_STREAMING
)
3474 if (calls_comdat_local
&& !same_comdat_group
)
3476 error ("calls_comdat_local is set outside of a comdat group");
3479 if (!inlined_to
&& calls_comdat_local
!= check_calls_comdat_local_p ())
3481 error ("invalid calls_comdat_local flag");
3485 if (DECL_IS_MALLOC (decl
)
3486 && !POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (decl
))))
3488 error ("malloc attribute should be used for a function that "
3489 "returns a pointer");
3493 && externally_visible
3494 /* For aliases in lto1 free_lang_data doesn't guarantee preservation
3495 of opt_for_fn (decl, flag_semantic_interposition). See PR105399. */
3496 && (!alias
|| !in_lto_p
)
3497 && semantic_interposition
3498 != opt_for_fn (decl
, flag_semantic_interposition
))
3500 error ("semantic interposition mismatch");
3503 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
3507 error ("aux field set for indirect edge from %s",
3508 identifier_to_locale (e
->caller
->name ()));
3511 if (!e
->count
.compatible_p (count
))
3513 error ("edge count is not compatible with function count");
3518 if (!e
->indirect_unknown_callee
3519 || !e
->indirect_info
)
3521 error ("An indirect edge from %s is not marked as indirect or has "
3522 "associated indirect_info, the corresponding statement is: ",
3523 identifier_to_locale (e
->caller
->name ()));
3524 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3527 if (e
->call_stmt
&& e
->lto_stmt_uid
)
3529 error ("edge has both call_stmt and lto_stmt_uid set");
3533 bool check_comdat
= comdat_local_p ();
3534 for (e
= callers
; e
; e
= e
->next_caller
)
3536 if (e
->verify_count ())
3539 && !in_same_comdat_group_p (e
->caller
))
3541 error ("comdat-local function called by %s outside its comdat",
3542 identifier_to_locale (e
->caller
->name ()));
3545 if (!e
->inline_failed
)
3548 != (e
->caller
->inlined_to
3549 ? e
->caller
->inlined_to
: e
->caller
))
3551 error ("inlined_to pointer is wrong");
3554 if (callers
->next_caller
)
3556 error ("multiple inline callers");
3563 error ("inlined_to pointer set for noninline callers");
3567 for (e
= callees
; e
; e
= e
->next_callee
)
3569 if (e
->verify_count ())
3571 if (!e
->count
.compatible_p (count
))
3573 error ("edge count is not compatible with function count");
3578 if (gimple_has_body_p (e
->caller
->decl
)
3579 && !e
->caller
->inlined_to
3581 /* Optimized out calls are redirected to __builtin_unreachable. */
3582 && (e
->count
.nonzero_p ()
3583 || ! e
->callee
->decl
3584 || !fndecl_built_in_p (e
->callee
->decl
, BUILT_IN_UNREACHABLE
))
3586 == ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (decl
))->count
3587 && (!e
->count
.ipa_p ()
3588 && e
->count
.differs_from_p (gimple_bb (e
->call_stmt
)->count
)))
3590 error ("caller edge count does not match BB count");
3591 fprintf (stderr
, "edge count: ");
3592 e
->count
.dump (stderr
);
3593 fprintf (stderr
, "\n bb count: ");
3594 gimple_bb (e
->call_stmt
)->count
.dump (stderr
);
3595 fprintf (stderr
, "\n");
3598 if (e
->call_stmt
&& e
->lto_stmt_uid
)
3600 error ("edge has both call_stmt and lto_stmt_uid set");
3604 && verify_speculative_call (e
->caller
, e
->call_stmt
, e
->lto_stmt_uid
,
3608 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
3610 if (e
->verify_count ())
3612 if (gimple_has_body_p (e
->caller
->decl
)
3613 && !e
->caller
->inlined_to
3615 && e
->count
.ipa_p ()
3617 == ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (decl
))->count
3618 && (!e
->count
.ipa_p ()
3619 && e
->count
.differs_from_p (gimple_bb (e
->call_stmt
)->count
)))
3621 error ("indirect call count does not match BB count");
3622 fprintf (stderr
, "edge count: ");
3623 e
->count
.dump (stderr
);
3624 fprintf (stderr
, "\n bb count: ");
3625 gimple_bb (e
->call_stmt
)->count
.dump (stderr
);
3626 fprintf (stderr
, "\n");
3630 && verify_speculative_call (e
->caller
, e
->call_stmt
, e
->lto_stmt_uid
,
3634 for (i
= 0; iterate_reference (i
, ref
); i
++)
3636 if (ref
->stmt
&& ref
->lto_stmt_uid
)
3638 error ("reference has both stmt and lto_stmt_uid set");
3641 if (ref
->speculative
3642 && verify_speculative_call (this, ref
->stmt
,
3643 ref
->lto_stmt_uid
, NULL
))
3647 if (!callers
&& inlined_to
)
3649 error ("inlined_to pointer is set but no predecessors found");
3652 if (inlined_to
== this)
3654 error ("inlined_to pointer refers to itself");
3660 cgraph_node
*first_clone
= clone_of
->clones
;
3661 if (first_clone
!= this)
3663 if (prev_sibling_clone
->clone_of
!= clone_of
)
3665 error ("cgraph_node has wrong clone_of");
3673 for (n
= clones
; n
; n
= n
->next_sibling_clone
)
3674 if (n
->clone_of
!= this)
3678 error ("cgraph_node has wrong clone list");
3682 if ((prev_sibling_clone
|| next_sibling_clone
) && !clone_of
)
3684 error ("cgraph_node is in clone list but it is not clone");
3687 if (!prev_sibling_clone
&& clone_of
&& clone_of
->clones
!= this)
3689 error ("cgraph_node has wrong prev_clone pointer");
3692 if (prev_sibling_clone
&& prev_sibling_clone
->next_sibling_clone
!= this)
3694 error ("double linked list of clones corrupted");
3698 if (analyzed
&& alias
)
3700 bool ref_found
= false;
3702 ipa_ref
*ref
= NULL
;
3706 error ("Alias has call edges");
3709 for (i
= 0; iterate_reference (i
, ref
); i
++)
3710 if (ref
->use
!= IPA_REF_ALIAS
)
3712 error ("Alias has non-alias reference");
3717 error ("Alias has more than one alias reference");
3724 error ("Analyzed alias has no reference");
3729 if (analyzed
&& thunk
)
3733 error ("No edge out of thunk node");
3736 else if (callees
->next_callee
)
3738 error ("More than one edge out of thunk node");
3741 if (gimple_has_body_p (decl
) && !inlined_to
)
3743 error ("Thunk is not supposed to have body");
3747 else if (analyzed
&& gimple_has_body_p (decl
)
3748 && !TREE_ASM_WRITTEN (decl
)
3749 && (!DECL_EXTERNAL (decl
) || inlined_to
)
3752 if ((this_cfun
->curr_properties
& PROP_assumptions_done
) != 0)
3754 else if (this_cfun
->cfg
)
3756 hash_set
<gimple
*> stmts
;
3758 /* Reach the trees by walking over the CFG, and note the
3759 enclosing basic-blocks in the call edges. */
3760 FOR_EACH_BB_FN (this_block
, this_cfun
)
3762 for (gsi
= gsi_start_phis (this_block
);
3763 !gsi_end_p (gsi
); gsi_next (&gsi
))
3764 stmts
.add (gsi_stmt (gsi
));
3765 for (gsi
= gsi_start_bb (this_block
);
3769 gimple
*stmt
= gsi_stmt (gsi
);
3771 if (is_gimple_call (stmt
))
3773 cgraph_edge
*e
= get_edge (stmt
);
3774 tree decl
= gimple_call_fndecl (stmt
);
3779 error ("shared call_stmt:");
3780 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
3783 if (!e
->indirect_unknown_callee
)
3785 if (e
->verify_corresponds_to_fndecl (decl
))
3787 error ("edge points to wrong declaration:");
3788 debug_tree (e
->callee
->decl
);
3789 fprintf (stderr
," Instead of:");
3796 error ("an indirect edge with unknown callee "
3797 "corresponding to a call_stmt with "
3798 "a known declaration:");
3800 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3806 error ("missing callgraph edge for call stmt:");
3807 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
3813 for (i
= 0; iterate_reference (i
, ref
); i
++)
3814 if (ref
->stmt
&& !stmts
.contains (ref
->stmt
))
3816 error ("reference to dead statement");
3817 cgraph_debug_gimple_stmt (this_cfun
, ref
->stmt
);
3822 /* No CFG available?! */
3825 for (e
= callees
; e
; e
= e
->next_callee
)
3827 if (!e
->aux
&& !e
->speculative
)
3829 error ("edge %s->%s has no corresponding call_stmt",
3830 identifier_to_locale (e
->caller
->name ()),
3831 identifier_to_locale (e
->callee
->name ()));
3832 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3837 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
3839 if (!e
->aux
&& !e
->speculative
)
3841 error ("an indirect edge from %s has no corresponding call_stmt",
3842 identifier_to_locale (e
->caller
->name ()));
3843 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3850 if (nested_function_info
*info
= nested_function_info::get (this))
3852 if (info
->nested
!= NULL
)
3854 for (cgraph_node
*n
= info
->nested
; n
!= NULL
;
3855 n
= next_nested_function (n
))
3857 nested_function_info
*ninfo
= nested_function_info::get (n
);
3858 if (ninfo
->origin
== NULL
)
3860 error ("missing origin for a node in a nested list");
3863 else if (ninfo
->origin
!= this)
3865 error ("origin points to a different parent");
3871 if (info
->next_nested
!= NULL
&& info
->origin
== NULL
)
3873 error ("missing origin for a node in a nested list");
3881 internal_error ("verify_cgraph_node failed");
3883 timevar_pop (TV_CGRAPH_VERIFY
);
3886 /* Verify whole cgraph structure. */
3888 cgraph_node::verify_cgraph_nodes (void)
3895 FOR_EACH_FUNCTION (node
)
3900 # pragma GCC diagnostic pop
3903 /* Walk the alias chain to return the function cgraph_node is alias of.
3904 Walk through thunks, too.
3905 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3906 When REF is non-NULL, assume that reference happens in symbol REF
3907 when determining the availability. */
3910 cgraph_node::function_symbol (enum availability
*availability
,
3911 struct symtab_node
*ref
)
3913 cgraph_node
*node
= ultimate_alias_target (availability
, ref
);
3917 enum availability a
;
3920 node
= node
->callees
->callee
;
3921 node
= node
->ultimate_alias_target (availability
? &a
: NULL
, ref
);
3922 if (availability
&& a
< *availability
)
3928 /* Walk the alias chain to return the function cgraph_node is alias of.
3929 Walk through non virtual thunks, too. Thus we return either a function
3930 or a virtual thunk node.
3931 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3932 When REF is non-NULL, assume that reference happens in symbol REF
3933 when determining the availability. */
3936 cgraph_node::function_or_virtual_thunk_symbol
3937 (enum availability
*availability
,
3938 struct symtab_node
*ref
)
3940 cgraph_node
*node
= ultimate_alias_target (availability
, ref
);
3942 while (node
->thunk
&& !thunk_info::get (node
)->virtual_offset_p
)
3944 enum availability a
;
3947 node
= node
->callees
->callee
;
3948 node
= node
->ultimate_alias_target (availability
? &a
: NULL
, ref
);
3949 if (availability
&& a
< *availability
)
3955 /* When doing LTO, read cgraph_node's body from disk if it is not already
3956 present. Also perform any necessary clone materializations. */
3959 cgraph_node::get_untransformed_body ()
3961 lto_file_decl_data
*file_data
;
3962 const char *data
, *name
;
3964 tree decl
= this->decl
;
3966 /* See if there is clone to be materialized.
3967 (inline clones does not need materialization, but we can be seeing
3968 an inline clone of real clone). */
3969 cgraph_node
*p
= this;
3970 for (cgraph_node
*c
= clone_of
; c
; c
= c
->clone_of
)
3972 if (c
->decl
!= decl
)
3973 p
->materialize_clone ();
3977 /* Check if body is already there. Either we have gimple body or
3978 the function is thunk and in that case we set DECL_ARGUMENTS. */
3979 if (DECL_ARGUMENTS (decl
) || gimple_has_body_p (decl
))
3982 gcc_assert (in_lto_p
&& !DECL_RESULT (decl
));
3984 timevar_push (TV_IPA_LTO_GIMPLE_IN
);
3986 file_data
= lto_file_data
;
3987 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
3989 /* We may have renamed the declaration, e.g., a static function. */
3990 name
= lto_get_decl_name_mapping (file_data
, name
);
3991 struct lto_in_decl_state
*decl_state
3992 = lto_get_function_in_decl_state (file_data
, decl
);
3994 cgraph_node
*origin
= this;
3995 while (origin
->clone_of
)
3996 origin
= origin
->clone_of
;
3998 int stream_order
= origin
->order
- file_data
->order_base
;
3999 data
= lto_get_section_data (file_data
, LTO_section_function_body
,
4000 name
, stream_order
, &len
,
4001 decl_state
->compressed
);
4003 fatal_error (input_location
, "%s: section %s.%d is missing",
4004 file_data
->file_name
, name
, stream_order
);
4006 gcc_assert (DECL_STRUCT_FUNCTION (decl
) == NULL
);
4009 fprintf (stderr
, " in:%s", IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
4010 lto_input_function_body (file_data
, this, data
);
4011 lto_stats
.num_function_bodies
++;
4012 lto_free_section_data (file_data
, LTO_section_function_body
, name
,
4013 data
, len
, decl_state
->compressed
);
4014 lto_free_function_in_decl_state_for_node (this);
4015 /* Keep lto file data so ipa-inline-analysis knows about cross module
4018 timevar_pop (TV_IPA_LTO_GIMPLE_IN
);
4023 /* Prepare function body. When doing LTO, read cgraph_node's body from disk
4024 if it is not already present. When some IPA transformations are scheduled,
4028 cgraph_node::get_body (void)
4032 updated
= get_untransformed_body ();
4034 /* Getting transformed body makes no sense for inline clones;
4035 we should never use this on real clones because they are materialized
4037 TODO: Materializing clones here will likely lead to smaller LTRANS
4039 gcc_assert (!inlined_to
&& !clone_of
);
4040 if (ipa_transforms_to_apply
.exists ())
4042 opt_pass
*saved_current_pass
= current_pass
;
4043 FILE *saved_dump_file
= dump_file
;
4044 const char *saved_dump_file_name
= dump_file_name
;
4045 dump_flags_t saved_dump_flags
= dump_flags
;
4046 dump_file_name
= NULL
;
4047 set_dump_file (NULL
);
4049 push_cfun (DECL_STRUCT_FUNCTION (decl
));
4051 update_ssa (TODO_update_ssa_only_virtuals
);
4052 execute_all_ipa_transforms (true);
4053 cgraph_edge::rebuild_edges ();
4054 free_dominance_info (CDI_DOMINATORS
);
4055 free_dominance_info (CDI_POST_DOMINATORS
);
4059 current_pass
= saved_current_pass
;
4060 set_dump_file (saved_dump_file
);
4061 dump_file_name
= saved_dump_file_name
;
4062 dump_flags
= saved_dump_flags
;
4067 /* Return the DECL_STRUCT_FUNCTION of the function. */
4070 cgraph_node::get_fun () const
4072 const cgraph_node
*node
= this;
4073 struct function
*fun
= DECL_STRUCT_FUNCTION (node
->decl
);
4075 while (!fun
&& node
->clone_of
)
4077 node
= node
->clone_of
;
4078 fun
= DECL_STRUCT_FUNCTION (node
->decl
);
4084 /* Reset all state within cgraph.cc so that we can rerun the compiler
4085 within the same process. For use by toplev::finalize. */
4088 cgraph_cc_finalize (void)
4090 nested_function_info::release ();
4091 thunk_info::release ();
4092 clone_info::release ();
4095 x_cgraph_nodes_queue
= NULL
;
4097 cgraph_fnver_htab
= NULL
;
4098 version_info_node
= NULL
;
4101 /* A worker for call_for_symbol_and_aliases. */
4104 cgraph_node::call_for_symbol_and_aliases_1 (bool (*callback
) (cgraph_node
*,
4107 bool include_overwritable
)
4110 FOR_EACH_ALIAS (this, ref
)
4112 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
4113 if (include_overwritable
4114 || alias
->get_availability () > AVAIL_INTERPOSABLE
)
4115 if (alias
->call_for_symbol_and_aliases (callback
, data
,
4116 include_overwritable
))
4122 /* Return true if NODE has thunk. */
4125 cgraph_node::has_thunk_p (cgraph_node
*node
, void *)
4127 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
4128 if (e
->caller
->thunk
)
4133 /* Expected frequency of executions within the function. */
4136 cgraph_edge::sreal_frequency ()
4138 return count
.to_sreal_scale (caller
->inlined_to
4139 ? caller
->inlined_to
->count
4144 /* During LTO stream in this can be used to check whether call can possibly
4145 be internal to the current translation unit. */
4148 cgraph_edge::possibly_call_in_translation_unit_p (void)
4150 gcc_checking_assert (in_lto_p
&& caller
->prevailing_p ());
4152 /* While incremental linking we may end up getting function body later. */
4153 if (flag_incremental_link
== INCREMENTAL_LINK_LTO
)
4156 /* We may be smarter here and avoid streaming in indirect calls we can't
4157 track, but that would require arranging streaming the indirect call
4162 /* If callee is local to the original translation unit, it will be
4164 if (!TREE_PUBLIC (callee
->decl
) && !DECL_EXTERNAL (callee
->decl
))
4167 /* Otherwise we need to lookup prevailing symbol (symbol table is not merged,
4168 yet) and see if it is a definition. In fact we may also resolve aliases,
4169 but that is probably not too important. */
4170 symtab_node
*node
= callee
;
4171 for (int n
= 10; node
->previous_sharing_asm_name
&& n
; n
--)
4172 node
= node
->previous_sharing_asm_name
;
4173 if (node
->previous_sharing_asm_name
)
4174 node
= symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (callee
->decl
));
4175 gcc_assert (TREE_PUBLIC (node
->decl
));
4176 return node
->get_availability () >= AVAIL_INTERPOSABLE
;
4179 /* Return num_speculative_targets of this edge. */
4182 cgraph_edge::num_speculative_call_targets_p (void)
4184 return indirect_info
? indirect_info
->num_speculative_call_targets
: 0;
4187 /* Check if function calls comdat local. This is used to recompute
4188 calls_comdat_local flag after function transformations. */
4190 cgraph_node::check_calls_comdat_local_p ()
4192 for (cgraph_edge
*e
= callees
; e
; e
= e
->next_callee
)
4193 if (e
->inline_failed
4194 ? e
->callee
->comdat_local_p ()
4195 : e
->callee
->check_calls_comdat_local_p ())
4200 /* Return true if this node represents a former, i.e. an expanded, thunk. */
4203 cgraph_node::former_thunk_p (void)
4207 thunk_info
*i
= thunk_info::get (this);
4210 gcc_checking_assert (i
->fixed_offset
|| i
->virtual_offset_p
4211 || i
->indirect_offset
);
4215 /* A stashed copy of "symtab" for use by selftest::symbol_table_test.
4216 This needs to be a global so that it can be a GC root, and thus
4217 prevent the stashed copy from being garbage-collected if the GC runs
4218 during a symbol_table_test. */
4220 symbol_table
*saved_symtab
;
4224 namespace selftest
{
4226 /* class selftest::symbol_table_test. */
4228 /* Constructor. Store the old value of symtab, and create a new one. */
4230 symbol_table_test::symbol_table_test ()
4232 gcc_assert (saved_symtab
== NULL
);
4233 saved_symtab
= symtab
;
4234 symtab
= new (ggc_alloc
<symbol_table
> ()) symbol_table ();
4237 /* Destructor. Restore the old value of symtab. */
4239 symbol_table_test::~symbol_table_test ()
4241 gcc_assert (saved_symtab
!= NULL
);
4242 symtab
= saved_symtab
;
4243 saved_symtab
= NULL
;
4246 /* Verify that symbol_table_test works. */
4249 test_symbol_table_test ()
4251 /* Simulate running two selftests involving symbol tables. */
4252 for (int i
= 0; i
< 2; i
++)
4254 symbol_table_test stt
;
4255 tree test_decl
= build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
,
4256 get_identifier ("test_decl"),
4257 build_function_type_list (void_type_node
,
4259 cgraph_node
*node
= cgraph_node::get_create (test_decl
);
4262 /* Verify that the node has order 0 on both iterations,
4263 and thus that nodes have predictable dump names in selftests. */
4264 ASSERT_EQ (node
->order
, 0);
4265 ASSERT_STREQ (node
->dump_name (), "test_decl/0");
4269 /* Run all of the selftests within this file. */
4274 test_symbol_table_test ();
4277 } // namespace selftest
4279 #endif /* CHECKING_P */
4281 #include "gt-cgraph.h"