1 /* Callgraph handling code.
2 Copyright (C) 2003-2020 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
);
511 if ((flag_openacc
|| flag_openmp
)
512 && lookup_attribute ("omp declare target", DECL_ATTRIBUTES (decl
)))
514 node
->offloadable
= 1;
515 if (ENABLE_OFFLOADING
)
516 g
->have_offload
= true;
519 if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl
)))
520 node
->ifunc_resolver
= true;
522 node
->register_symbol ();
523 maybe_record_nested_function (node
);
528 /* Try to find a call graph node for declaration DECL and if it does not exist
529 or if it corresponds to an inline clone, create a new one. */
532 cgraph_node::get_create (tree decl
)
534 cgraph_node
*first_clone
= cgraph_node::get (decl
);
536 if (first_clone
&& !first_clone
->inlined_to
)
539 cgraph_node
*node
= cgraph_node::create (decl
);
542 first_clone
->clone_of
= node
;
543 node
->clones
= first_clone
;
544 node
->order
= first_clone
->order
;
545 symtab
->symtab_prevail_in_asm_name_hash (node
);
546 node
->decl
->decl_with_vis
.symtab_node
= node
;
548 fprintf (dump_file
, "Introduced new external node "
549 "(%s) and turned into root of the clone tree.\n",
553 fprintf (dump_file
, "Introduced new external node "
554 "(%s).\n", node
->dump_name ());
558 /* Mark ALIAS as an alias to DECL. DECL_NODE is cgraph node representing
559 the function body is associated with
560 (not necessarily cgraph_node (DECL)). */
563 cgraph_node::create_alias (tree alias
, tree target
)
565 cgraph_node
*alias_node
;
567 gcc_assert (TREE_CODE (target
) == FUNCTION_DECL
568 || TREE_CODE (target
) == IDENTIFIER_NODE
);
569 gcc_assert (TREE_CODE (alias
) == FUNCTION_DECL
);
570 alias_node
= cgraph_node::get_create (alias
);
571 gcc_assert (!alias_node
->definition
);
572 alias_node
->alias_target
= target
;
573 alias_node
->definition
= true;
574 alias_node
->alias
= true;
575 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (alias
)) != NULL
)
576 alias_node
->transparent_alias
= alias_node
->weakref
= true;
577 if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (alias
)))
578 alias_node
->ifunc_resolver
= true;
582 /* Attempt to mark ALIAS as an alias to DECL. Return alias node if successful
584 Same body aliases are output whenever the body of DECL is output,
585 and cgraph_node::get (ALIAS) transparently returns
586 cgraph_node::get (DECL). */
589 cgraph_node::create_same_body_alias (tree alias
, tree decl
)
593 /* If aliases aren't supported by the assembler, fail. */
594 if (!TARGET_SUPPORTS_ALIASES
)
597 /* Langhooks can create same body aliases of symbols not defined.
598 Those are useless. Drop them on the floor. */
599 if (symtab
->global_info_ready
)
602 n
= cgraph_node::create_alias (alias
, decl
);
603 n
->cpp_implicit_alias
= true;
604 if (symtab
->cpp_implicit_aliases_done
)
605 n
->resolve_alias (cgraph_node::get (decl
));
609 /* Add thunk alias into callgraph. The alias declaration is ALIAS and it
610 aliases DECL with an adjustments made into the first parameter.
611 See comments in struct cgraph_thunk_info for detail on the parameters. */
614 cgraph_node::create_thunk (tree alias
, tree
, bool this_adjusting
,
615 HOST_WIDE_INT fixed_offset
,
616 HOST_WIDE_INT virtual_value
,
617 HOST_WIDE_INT indirect_offset
,
623 node
= cgraph_node::get (alias
);
627 node
= cgraph_node::create (alias
);
629 /* Make sure that if VIRTUAL_OFFSET is in sync with VIRTUAL_VALUE. */
630 gcc_checking_assert (virtual_offset
631 ? virtual_value
== wi::to_wide (virtual_offset
)
632 : virtual_value
== 0);
635 node
->definition
= true;
638 thunk_info local_info
;
639 if (symtab
->state
< CONSTRUCTION
)
642 i
= thunk_info::get_create (node
);
643 i
->fixed_offset
= fixed_offset
;
644 i
->virtual_value
= virtual_value
;
645 i
->indirect_offset
= indirect_offset
;
646 i
->alias
= real_alias
;
647 i
->this_adjusting
= this_adjusting
;
648 i
->virtual_offset_p
= virtual_offset
!= NULL
;
649 if (symtab
->state
< CONSTRUCTION
)
650 i
->register_early (node
);
655 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
656 Return NULL if there's no such node. */
659 cgraph_node::get_for_asmname (tree asmname
)
661 /* We do not want to look at inline clones. */
662 for (symtab_node
*node
= symtab_node::get_for_asmname (asmname
);
664 node
= node
->next_sharing_asm_name
)
666 cgraph_node
*cn
= dyn_cast
<cgraph_node
*> (node
);
667 if (cn
&& !cn
->inlined_to
)
673 /* Returns a hash value for X (which really is a cgraph_edge). */
676 cgraph_edge_hasher::hash (cgraph_edge
*e
)
678 /* This is a really poor hash function, but it is what htab_hash_pointer
680 return (hashval_t
) ((intptr_t)e
->call_stmt
>> 3);
683 /* Returns a hash value for X (which really is a cgraph_edge). */
686 cgraph_edge_hasher::hash (gimple
*call_stmt
)
688 /* This is a really poor hash function, but it is what htab_hash_pointer
690 return (hashval_t
) ((intptr_t)call_stmt
>> 3);
693 /* Return nonzero if the call_stmt of cgraph_edge X is stmt *Y. */
696 cgraph_edge_hasher::equal (cgraph_edge
*x
, gimple
*y
)
698 return x
->call_stmt
== y
;
701 /* Add call graph edge E to call site hash of its caller. */
704 cgraph_update_edge_in_call_site_hash (cgraph_edge
*e
)
706 gimple
*call
= e
->call_stmt
;
707 *e
->caller
->call_site_hash
->find_slot_with_hash
708 (call
, cgraph_edge_hasher::hash (call
), INSERT
) = e
;
711 /* Add call graph edge E to call site hash of its caller. */
714 cgraph_add_edge_to_call_site_hash (cgraph_edge
*e
)
716 /* There are two speculative edges for every statement (one direct,
717 one indirect); always hash the direct one. */
718 if (e
->speculative
&& e
->indirect_unknown_callee
)
720 cgraph_edge
**slot
= e
->caller
->call_site_hash
->find_slot_with_hash
721 (e
->call_stmt
, cgraph_edge_hasher::hash (e
->call_stmt
), INSERT
);
724 gcc_assert (((cgraph_edge
*)*slot
)->speculative
);
725 if (e
->callee
&& (!e
->prev_callee
726 || !e
->prev_callee
->speculative
727 || e
->prev_callee
->call_stmt
!= e
->call_stmt
))
731 gcc_assert (!*slot
|| e
->speculative
);
735 /* Return the callgraph edge representing the GIMPLE_CALL statement
739 cgraph_node::get_edge (gimple
*call_stmt
)
745 return call_site_hash
->find_with_hash
746 (call_stmt
, cgraph_edge_hasher::hash (call_stmt
));
748 /* This loop may turn out to be performance problem. In such case adding
749 hashtables into call nodes with very many edges is probably best
750 solution. It is not good idea to add pointer into CALL_EXPR itself
751 because we want to make possible having multiple cgraph nodes representing
752 different clones of the same body before the body is actually cloned. */
753 for (e
= callees
; e
; e
= e
->next_callee
)
755 if (e
->call_stmt
== call_stmt
)
761 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
763 if (e
->call_stmt
== call_stmt
)
770 call_site_hash
= hash_table
<cgraph_edge_hasher
>::create_ggc (120);
771 for (e2
= callees
; e2
; e2
= e2
->next_callee
)
772 cgraph_add_edge_to_call_site_hash (e2
);
773 for (e2
= indirect_calls
; e2
; e2
= e2
->next_callee
)
774 cgraph_add_edge_to_call_site_hash (e2
);
781 /* Change field call_stmt of edge E to NEW_STMT. If UPDATE_SPECULATIVE and E
782 is any component of speculative edge, then update all components.
783 Speculations can be resolved in the process and EDGE can be removed and
784 deallocated. Return the edge that now represents the call. */
787 cgraph_edge::set_call_stmt (cgraph_edge
*e
, gcall
*new_stmt
,
788 bool update_speculative
)
792 /* Speculative edges has three component, update all of them
794 if (update_speculative
&& e
->speculative
)
796 cgraph_edge
*direct
, *indirect
, *next
;
798 bool e_indirect
= e
->indirect_unknown_callee
;
801 direct
= e
->first_speculative_call_target ();
802 indirect
= e
->speculative_call_indirect_edge ();
804 gcall
*old_stmt
= direct
->call_stmt
;
805 for (cgraph_edge
*d
= direct
; d
; d
= next
)
807 next
= d
->next_speculative_call_target ();
808 cgraph_edge
*d2
= set_call_stmt (d
, new_stmt
, false);
809 gcc_assert (d2
== d
);
812 gcc_checking_assert (indirect
->num_speculative_call_targets_p () == n
);
813 for (unsigned int i
= 0; e
->caller
->iterate_reference (i
, ref
); i
++)
814 if (ref
->speculative
&& ref
->stmt
== old_stmt
)
816 ref
->stmt
= new_stmt
;
820 indirect
= set_call_stmt (indirect
, new_stmt
, false);
821 return e_indirect
? indirect
: direct
;
824 /* Only direct speculative edges go to call_site_hash. */
825 if (e
->caller
->call_site_hash
826 && (!e
->speculative
|| !e
->indirect_unknown_callee
)
827 /* It is possible that edge was previously speculative. In this case
828 we have different value in call stmt hash which needs preserving. */
829 && e
->caller
->get_edge (e
->call_stmt
) == e
)
830 e
->caller
->call_site_hash
->remove_elt_with_hash
831 (e
->call_stmt
, cgraph_edge_hasher::hash (e
->call_stmt
));
833 e
->call_stmt
= new_stmt
;
834 if (e
->indirect_unknown_callee
835 && (decl
= gimple_call_fndecl (new_stmt
)))
837 /* Constant propagation (and possibly also inlining?) can turn an
838 indirect call into a direct one. */
839 cgraph_node
*new_callee
= cgraph_node::get (decl
);
841 gcc_checking_assert (new_callee
);
842 e
= make_direct (e
, new_callee
);
845 function
*fun
= DECL_STRUCT_FUNCTION (e
->caller
->decl
);
846 e
->can_throw_external
= stmt_can_throw_external (fun
, new_stmt
);
847 /* Update call stite hash. For speculative calls we only record the first
849 if (e
->caller
->call_site_hash
852 && (!e
->prev_callee
|| !e
->prev_callee
->speculative
853 || e
->prev_callee
->call_stmt
!= e
->call_stmt
))
854 || (e
->speculative
&& !e
->callee
)))
855 cgraph_add_edge_to_call_site_hash (e
);
859 /* Allocate a cgraph_edge structure and fill it with data according to the
860 parameters of which only CALLEE can be NULL (when creating an indirect call
861 edge). CLONING_P should be set if properties that are copied from an
862 original edge should not be calculated. */
865 symbol_table::create_edge (cgraph_node
*caller
, cgraph_node
*callee
,
866 gcall
*call_stmt
, profile_count count
,
867 bool indir_unknown_callee
, bool cloning_p
)
871 /* LTO does not actually have access to the call_stmt since these
872 have not been loaded yet. */
875 /* This is a rather expensive check possibly triggering
876 construction of call stmt hashtable. */
878 gcc_checking_assert (!(e
= caller
->get_edge (call_stmt
))
881 gcc_assert (is_gimple_call (call_stmt
));
884 edge
= ggc_alloc
<cgraph_edge
> ();
885 edge
->m_summary_id
= -1;
888 gcc_assert (++edges_max_uid
!= 0);
889 edge
->m_uid
= edges_max_uid
;
891 edge
->caller
= caller
;
892 edge
->callee
= callee
;
893 edge
->prev_caller
= NULL
;
894 edge
->next_caller
= NULL
;
895 edge
->prev_callee
= NULL
;
896 edge
->next_callee
= NULL
;
897 edge
->lto_stmt_uid
= 0;
898 edge
->speculative_id
= 0;
901 edge
->call_stmt
= call_stmt
;
902 edge
->indirect_info
= NULL
;
903 edge
->indirect_inlining_edge
= 0;
904 edge
->speculative
= false;
905 edge
->indirect_unknown_callee
= indir_unknown_callee
;
906 if (call_stmt
&& caller
->call_site_hash
)
907 cgraph_add_edge_to_call_site_hash (edge
);
912 edge
->can_throw_external
913 = call_stmt
? stmt_can_throw_external (DECL_STRUCT_FUNCTION (caller
->decl
),
915 edge
->inline_failed
= CIF_FUNCTION_NOT_CONSIDERED
;
916 edge
->call_stmt_cannot_inline_p
= false;
918 if (opt_for_fn (edge
->caller
->decl
, flag_devirtualize
)
919 && call_stmt
&& DECL_STRUCT_FUNCTION (caller
->decl
))
920 edge
->in_polymorphic_cdtor
921 = decl_maybe_in_construction_p (NULL
, NULL
, call_stmt
,
924 edge
->in_polymorphic_cdtor
= caller
->thunk
;
926 caller
->calls_declare_variant_alt
|= callee
->declare_variant_alt
;
928 if (callee
&& symtab
->state
!= LTO_STREAMING
929 && edge
->callee
->comdat_local_p ())
930 edge
->caller
->calls_comdat_local
= true;
935 /* Create edge from a given function to CALLEE in the cgraph. CLONING_P should
936 be set if properties that are copied from an original edge should not be
940 cgraph_node::create_edge (cgraph_node
*callee
,
941 gcall
*call_stmt
, profile_count count
, bool cloning_p
)
943 cgraph_edge
*edge
= symtab
->create_edge (this, callee
, call_stmt
, count
,
947 initialize_inline_failed (edge
);
949 edge
->next_caller
= callee
->callers
;
951 callee
->callers
->prev_caller
= edge
;
952 edge
->next_callee
= callees
;
954 callees
->prev_callee
= edge
;
956 callee
->callers
= edge
;
961 /* Allocate cgraph_indirect_call_info and set its fields to default values. */
963 cgraph_indirect_call_info
*
964 cgraph_allocate_init_indirect_info (void)
966 cgraph_indirect_call_info
*ii
;
968 ii
= ggc_cleared_alloc
<cgraph_indirect_call_info
> ();
969 ii
->param_index
= -1;
973 /* Create an indirect edge with a yet-undetermined callee where the call
974 statement destination is a formal parameter of the caller with index
975 PARAM_INDEX. CLONING_P should be set if properties that are copied from an
976 original edge should not be calculated and indirect_info structure should
977 not be calculated. */
980 cgraph_node::create_indirect_edge (gcall
*call_stmt
, int ecf_flags
,
984 cgraph_edge
*edge
= symtab
->create_edge (this, NULL
, call_stmt
, count
, true,
989 initialize_inline_failed (edge
);
991 edge
->indirect_info
= cgraph_allocate_init_indirect_info ();
992 edge
->indirect_info
->ecf_flags
= ecf_flags
;
993 edge
->indirect_info
->vptr_changed
= true;
995 /* Record polymorphic call info. */
998 && (target
= gimple_call_fn (call_stmt
))
999 && virtual_method_call_p (target
))
1001 ipa_polymorphic_call_context
context (decl
, target
, call_stmt
);
1003 /* Only record types can have virtual calls. */
1004 edge
->indirect_info
->polymorphic
= true;
1005 edge
->indirect_info
->param_index
= -1;
1006 edge
->indirect_info
->otr_token
1007 = tree_to_uhwi (OBJ_TYPE_REF_TOKEN (target
));
1008 edge
->indirect_info
->otr_type
= obj_type_ref_class (target
);
1009 gcc_assert (TREE_CODE (edge
->indirect_info
->otr_type
) == RECORD_TYPE
);
1010 edge
->indirect_info
->context
= context
;
1013 edge
->next_callee
= indirect_calls
;
1015 indirect_calls
->prev_callee
= edge
;
1016 indirect_calls
= edge
;
1021 /* Remove the edge from the list of the callees of the caller. */
1024 cgraph_edge::remove_caller (void)
1027 prev_callee
->next_callee
= next_callee
;
1029 next_callee
->prev_callee
= prev_callee
;
1032 if (indirect_unknown_callee
)
1033 caller
->indirect_calls
= next_callee
;
1035 caller
->callees
= next_callee
;
1037 if (caller
->call_site_hash
1038 && this == caller
->get_edge (call_stmt
))
1039 caller
->call_site_hash
->remove_elt_with_hash
1040 (call_stmt
, cgraph_edge_hasher::hash (call_stmt
));
1043 /* Put the edge onto the free list. */
1046 symbol_table::free_edge (cgraph_edge
*e
)
1049 if (e
->m_summary_id
!= -1)
1050 edge_released_summary_ids
.safe_push (e
->m_summary_id
);
1052 if (e
->indirect_info
)
1053 ggc_free (e
->indirect_info
);
1057 /* Remove the edge in the cgraph. */
1060 cgraph_edge::remove (cgraph_edge
*edge
)
1062 /* Call all edge removal hooks. */
1063 symtab
->call_edge_removal_hooks (edge
);
1065 if (!edge
->indirect_unknown_callee
)
1066 /* Remove from callers list of the callee. */
1067 edge
->remove_callee ();
1069 /* Remove from callees list of the callers. */
1070 edge
->remove_caller ();
1072 /* Put the edge onto the free list. */
1073 symtab
->free_edge (edge
);
1076 /* Turn edge into speculative call calling N2. Update
1077 the profile so the direct call is taken COUNT times
1080 At clone materialization time, the indirect call E will
1083 if (call_dest == N2)
1088 At this time the function just creates the direct call,
1089 the reference representing the if conditional and attaches
1090 them all to the original indirect call statement.
1092 speculative_id is used to link direct calls with their corresponding
1093 IPA_REF_ADDR references when representing speculative calls.
1095 Return direct edge created. */
1098 cgraph_edge::make_speculative (cgraph_node
*n2
, profile_count direct_count
,
1099 unsigned int speculative_id
)
1101 cgraph_node
*n
= caller
;
1102 ipa_ref
*ref
= NULL
;
1106 fprintf (dump_file
, "Indirect call -> speculative call %s => %s\n",
1107 n
->dump_name (), n2
->dump_name ());
1109 e2
= n
->create_edge (n2
, call_stmt
, direct_count
);
1110 initialize_inline_failed (e2
);
1111 e2
->speculative
= true;
1112 if (TREE_NOTHROW (n2
->decl
))
1113 e2
->can_throw_external
= false;
1115 e2
->can_throw_external
= can_throw_external
;
1116 e2
->lto_stmt_uid
= lto_stmt_uid
;
1117 e2
->speculative_id
= speculative_id
;
1118 e2
->in_polymorphic_cdtor
= in_polymorphic_cdtor
;
1119 indirect_info
->num_speculative_call_targets
++;
1121 symtab
->call_edge_duplication_hooks (this, e2
);
1122 ref
= n
->create_reference (n2
, IPA_REF_ADDR
, call_stmt
);
1123 ref
->lto_stmt_uid
= lto_stmt_uid
;
1124 ref
->speculative_id
= speculative_id
;
1125 ref
->speculative
= speculative
;
1126 n2
->mark_address_taken ();
1130 /* Speculative call consists of an indirect edge and one or more
1131 direct edge+ref pairs.
1133 Given an edge which is part of speculative call, return the first
1134 direct call edge in the speculative call sequence. */
1137 cgraph_edge::first_speculative_call_target ()
1139 cgraph_edge
*e
= this;
1141 gcc_checking_assert (e
->speculative
);
1144 while (e
->prev_callee
&& e
->prev_callee
->speculative
1145 && e
->prev_callee
->call_stmt
== e
->call_stmt
1146 && e
->prev_callee
->lto_stmt_uid
== e
->lto_stmt_uid
)
1150 /* Call stmt site hash always points to the first target of the
1151 speculative call sequence. */
1153 return e
->caller
->get_edge (e
->call_stmt
);
1154 for (cgraph_edge
*e2
= e
->caller
->callees
; true; e2
= e2
->next_callee
)
1156 && e
->call_stmt
== e2
->call_stmt
1157 && e
->lto_stmt_uid
== e2
->lto_stmt_uid
)
1161 /* We always maintain first direct edge in the call site hash, if one
1162 exists. E is going to be removed. See if it is first one and update
1163 hash accordingly. INDIRECT is the indirect edge of speculative call.
1164 We assume that INDIRECT->num_speculative_call_targets_p () is already
1165 updated for removal of E. */
1167 update_call_stmt_hash_for_removing_direct_edge (cgraph_edge
*e
,
1168 cgraph_edge
*indirect
)
1170 if (e
->caller
->call_site_hash
)
1172 if (e
->caller
->get_edge (e
->call_stmt
) != e
)
1174 else if (!indirect
->num_speculative_call_targets_p ())
1175 cgraph_update_edge_in_call_site_hash (indirect
);
1178 gcc_checking_assert (e
->next_callee
&& e
->next_callee
->speculative
1179 && e
->next_callee
->call_stmt
== e
->call_stmt
);
1180 cgraph_update_edge_in_call_site_hash (e
->next_callee
);
1185 /* Speculative call EDGE turned out to be direct call to CALLEE_DECL. Remove
1186 the speculative call sequence and return edge representing the call, the
1187 original EDGE can be removed and deallocated. Return the edge that now
1188 represents the call.
1190 For "speculative" indirect call that contains multiple "speculative"
1191 targets (i.e. edge->indirect_info->num_speculative_call_targets > 1),
1192 decrease the count and only remove current direct edge.
1194 If no speculative direct call left to the speculative indirect call, remove
1195 the speculative of both the indirect call and corresponding direct edge.
1197 It is up to caller to iteratively resolve each "speculative" direct call and
1198 redirect the call as appropriate. */
1201 cgraph_edge::resolve_speculation (cgraph_edge
*edge
, tree callee_decl
)
1206 gcc_assert (edge
->speculative
&& (!callee_decl
|| edge
->callee
));
1208 e2
= edge
->first_speculative_call_target ();
1211 ref
= e2
->speculative_call_target_ref ();
1212 edge
= edge
->speculative_call_indirect_edge ();
1214 || !ref
->referred
->semantically_equivalent_p
1215 (symtab_node::get (callee_decl
)))
1221 fprintf (dump_file
, "Speculative indirect call %s => %s has "
1222 "turned out to have contradicting known target ",
1223 edge
->caller
->dump_name (),
1224 e2
->callee
->dump_name ());
1225 print_generic_expr (dump_file
, callee_decl
);
1226 fprintf (dump_file
, "\n");
1230 fprintf (dump_file
, "Removing speculative call %s => %s\n",
1231 edge
->caller
->dump_name (),
1232 e2
->callee
->dump_name ());
1238 cgraph_edge
*tmp
= edge
;
1240 fprintf (dump_file
, "Speculative call turned into direct call.\n");
1243 /* FIXME: If EDGE is inlined, we should scale up the frequencies
1244 and counts in the functions inlined through it. */
1246 edge
->count
+= e2
->count
;
1247 if (edge
->num_speculative_call_targets_p ())
1249 /* The indirect edge has multiple speculative targets, don't remove
1250 speculative until all related direct edges are resolved. */
1251 edge
->indirect_info
->num_speculative_call_targets
--;
1252 if (!edge
->indirect_info
->num_speculative_call_targets
)
1253 edge
->speculative
= false;
1256 edge
->speculative
= false;
1257 e2
->speculative
= false;
1258 update_call_stmt_hash_for_removing_direct_edge (e2
, edge
);
1259 ref
->remove_reference ();
1260 if (e2
->indirect_unknown_callee
|| e2
->inline_failed
)
1263 e2
->callee
->remove_symbol_and_inline_clones ();
1267 /* Return edge corresponding to speculative call to a given target.
1268 NULL if speculative call does not have one. */
1271 cgraph_edge::speculative_call_for_target (cgraph_node
*target
)
1273 for (cgraph_edge
*direct
= first_speculative_call_target ();
1275 direct
= direct
->next_speculative_call_target ())
1276 if (direct
->speculative_call_target_ref ()
1277 ->referred
->semantically_equivalent_p (target
))
1282 /* Make an indirect edge with an unknown callee an ordinary edge leading to
1283 CALLEE. Speculations can be resolved in the process and EDGE can be removed
1284 and deallocated. Return the edge that now represents the call. */
1287 cgraph_edge::make_direct (cgraph_edge
*edge
, cgraph_node
*callee
)
1289 gcc_assert (edge
->indirect_unknown_callee
);
1291 /* If we are redirecting speculative call, make it non-speculative. */
1292 if (edge
->speculative
)
1294 cgraph_edge
*found
= NULL
;
1295 cgraph_edge
*direct
, *next
;
1297 edge
= edge
->speculative_call_indirect_edge ();
1299 /* Look all speculative targets and remove all but one corresponding
1300 to callee (if it exists). */
1301 for (direct
= edge
->first_speculative_call_target ();
1305 next
= direct
->next_speculative_call_target ();
1307 /* Compare ref not direct->callee. Direct edge is possibly
1308 inlined or redirected. */
1309 if (!direct
->speculative_call_target_ref ()
1310 ->referred
->semantically_equivalent_p (callee
))
1311 edge
= direct
->resolve_speculation (direct
, NULL
);
1314 gcc_checking_assert (!found
);
1319 /* On successful speculation just remove the indirect edge and
1320 return the pre existing direct edge.
1321 It is important to not remove it and redirect because the direct
1322 edge may be inlined or redirected. */
1325 cgraph_edge
*e2
= resolve_speculation (found
, callee
->decl
);
1326 gcc_checking_assert (!found
->speculative
&& e2
== found
);
1329 gcc_checking_assert (!edge
->speculative
);
1332 edge
->indirect_unknown_callee
= 0;
1333 ggc_free (edge
->indirect_info
);
1334 edge
->indirect_info
= NULL
;
1336 /* Get the edge out of the indirect edge list. */
1337 if (edge
->prev_callee
)
1338 edge
->prev_callee
->next_callee
= edge
->next_callee
;
1339 if (edge
->next_callee
)
1340 edge
->next_callee
->prev_callee
= edge
->prev_callee
;
1341 if (!edge
->prev_callee
)
1342 edge
->caller
->indirect_calls
= edge
->next_callee
;
1344 /* Put it into the normal callee list */
1345 edge
->prev_callee
= NULL
;
1346 edge
->next_callee
= edge
->caller
->callees
;
1347 if (edge
->caller
->callees
)
1348 edge
->caller
->callees
->prev_callee
= edge
;
1349 edge
->caller
->callees
= edge
;
1351 /* Insert to callers list of the new callee. */
1352 edge
->set_callee (callee
);
1354 /* We need to re-determine the inlining status of the edge. */
1355 initialize_inline_failed (edge
);
1359 /* Redirect callee of the edge to N. The function does not update underlying
1363 cgraph_edge::redirect_callee (cgraph_node
*n
)
1365 bool loc
= callee
->comdat_local_p ();
1366 /* Remove from callers list of the current callee. */
1369 /* Insert to callers list of the new callee. */
1374 if (!loc
&& n
->comdat_local_p ())
1376 cgraph_node
*to
= caller
->inlined_to
? caller
->inlined_to
: caller
;
1377 to
->calls_comdat_local
= true;
1379 else if (loc
&& !n
->comdat_local_p ())
1381 cgraph_node
*to
= caller
->inlined_to
? caller
->inlined_to
: caller
;
1382 gcc_checking_assert (to
->calls_comdat_local
);
1383 to
->calls_comdat_local
= to
->check_calls_comdat_local_p ();
1387 /* If necessary, change the function declaration in the call statement
1388 associated with E so that it corresponds to the edge callee. Speculations
1389 can be resolved in the process and EDGE can be removed and deallocated.
1391 The edge could be one of speculative direct call generated from speculative
1392 indirect call. In this circumstance, decrease the speculative targets
1393 count (i.e. num_speculative_call_targets) and redirect call stmt to the
1394 corresponding i-th target. If no speculative direct call left to the
1395 speculative indirect call, remove "speculative" of the indirect call and
1396 also redirect stmt to it's final direct target.
1398 It is up to caller to iteratively transform each "speculative"
1399 direct call as appropriate. */
1402 cgraph_edge::redirect_call_stmt_to_callee (cgraph_edge
*e
)
1404 tree decl
= gimple_call_fndecl (e
->call_stmt
);
1406 gimple_stmt_iterator gsi
;
1410 /* If there already is an direct call (i.e. as a result of inliner's
1411 substitution), forget about speculating. */
1413 e
= make_direct (e
->speculative_call_indirect_edge (),
1414 cgraph_node::get (decl
));
1417 /* Be sure we redirect all speculative targets before poking
1418 abou tindirect edge. */
1419 gcc_checking_assert (e
->callee
);
1420 cgraph_edge
*indirect
= e
->speculative_call_indirect_edge ();
1424 /* Expand speculation into GIMPLE code. */
1428 "Expanding speculative call of %s -> %s count: ",
1429 e
->caller
->dump_name (),
1430 e
->callee
->dump_name ());
1431 e
->count
.dump (dump_file
);
1432 fprintf (dump_file
, "\n");
1434 push_cfun (DECL_STRUCT_FUNCTION (e
->caller
->decl
));
1436 profile_count all
= indirect
->count
;
1437 for (cgraph_edge
*e2
= e
->first_speculative_call_target ();
1439 e2
= e2
->next_speculative_call_target ())
1440 all
= all
+ e2
->count
;
1441 profile_probability prob
= e
->count
.probability_in (all
);
1442 if (!prob
.initialized_p ())
1443 prob
= profile_probability::even ();
1444 ref
= e
->speculative_call_target_ref ();
1445 new_stmt
= gimple_ic (e
->call_stmt
,
1446 dyn_cast
<cgraph_node
*> (ref
->referred
),
1448 e
->speculative
= false;
1449 if (indirect
->num_speculative_call_targets_p ())
1451 /* The indirect edge has multiple speculative targets, don't
1452 remove speculative until all related direct edges are
1454 indirect
->indirect_info
->num_speculative_call_targets
--;
1455 if (!indirect
->indirect_info
->num_speculative_call_targets
)
1456 indirect
->speculative
= false;
1459 indirect
->speculative
= false;
1460 /* Indirect edges are not both in the call site hash.
1462 update_call_stmt_hash_for_removing_direct_edge (e
, indirect
);
1463 cgraph_edge::set_call_stmt (e
, new_stmt
, false);
1464 e
->count
= gimple_bb (e
->call_stmt
)->count
;
1466 /* Once we are done with expanding the sequence, update also indirect
1467 call probability. Until then the basic block accounts for the
1468 sum of indirect edge and all non-expanded speculations. */
1469 if (!indirect
->speculative
)
1470 indirect
->count
= gimple_bb (indirect
->call_stmt
)->count
;
1471 ref
->speculative
= false;
1474 /* Continue redirecting E to proper target. */
1479 if (e
->indirect_unknown_callee
1480 || decl
== e
->callee
->decl
)
1481 return e
->call_stmt
;
1483 if (decl
&& ipa_saved_clone_sources
)
1485 tree
*p
= ipa_saved_clone_sources
->get (e
->callee
);
1486 if (p
&& decl
== *p
)
1488 gimple_call_set_fndecl (e
->call_stmt
, e
->callee
->decl
);
1489 return e
->call_stmt
;
1492 if (flag_checking
&& decl
)
1494 if (cgraph_node
*node
= cgraph_node::get (decl
))
1496 clone_info
*info
= clone_info::get (node
);
1497 gcc_assert (!info
|| !info
->param_adjustments
);
1501 clone_info
*callee_info
= clone_info::get (e
->callee
);
1502 clone_info
*caller_info
= clone_info::get (e
->caller
);
1504 if (symtab
->dump_file
)
1506 fprintf (symtab
->dump_file
, "updating call of %s -> %s: ",
1507 e
->caller
->dump_name (), e
->callee
->dump_name ());
1508 print_gimple_stmt (symtab
->dump_file
, e
->call_stmt
, 0, dump_flags
);
1509 if (callee_info
&& callee_info
->param_adjustments
)
1510 callee_info
->param_adjustments
->dump (symtab
->dump_file
);
1511 unsigned performed_len
1512 = caller_info
? vec_safe_length (caller_info
->performed_splits
) : 0;
1513 if (performed_len
> 0)
1514 fprintf (symtab
->dump_file
, "Performed splits records:\n");
1515 for (unsigned i
= 0; i
< performed_len
; i
++)
1517 ipa_param_performed_split
*sm
1518 = &(*caller_info
->performed_splits
)[i
];
1519 print_node_brief (symtab
->dump_file
, " dummy_decl: ", sm
->dummy_decl
,
1521 fprintf (symtab
->dump_file
, ", unit_offset: %u\n", sm
->unit_offset
);
1525 if (ipa_param_adjustments
*padjs
1526 = callee_info
? callee_info
->param_adjustments
: NULL
)
1528 /* We need to defer cleaning EH info on the new statement to
1529 fixup-cfg. We may not have dominator information at this point
1530 and thus would end up with unreachable blocks and have no way
1531 to communicate that we need to run CFG cleanup then. */
1532 int lp_nr
= lookup_stmt_eh_lp (e
->call_stmt
);
1534 remove_stmt_from_eh_lp (e
->call_stmt
);
1536 tree old_fntype
= gimple_call_fntype (e
->call_stmt
);
1537 new_stmt
= padjs
->modify_call (e
->call_stmt
,
1539 ? caller_info
->performed_splits
: NULL
,
1540 e
->callee
->decl
, false);
1541 cgraph_node
*origin
= e
->callee
;
1542 while (origin
->clone_of
)
1543 origin
= origin
->clone_of
;
1545 if ((origin
->former_clone_of
1546 && old_fntype
== TREE_TYPE (origin
->former_clone_of
))
1547 || old_fntype
== TREE_TYPE (origin
->decl
))
1548 gimple_call_set_fntype (new_stmt
, TREE_TYPE (e
->callee
->decl
));
1551 tree new_fntype
= padjs
->build_new_function_type (old_fntype
, true);
1552 gimple_call_set_fntype (new_stmt
, new_fntype
);
1556 add_stmt_to_eh_lp (new_stmt
, lp_nr
);
1560 new_stmt
= e
->call_stmt
;
1561 gimple_call_set_fndecl (new_stmt
, e
->callee
->decl
);
1562 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), new_stmt
);
1565 /* If changing the call to __cxa_pure_virtual or similar noreturn function,
1566 adjust gimple_call_fntype too. */
1567 if (gimple_call_noreturn_p (new_stmt
)
1568 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (e
->callee
->decl
)))
1569 && TYPE_ARG_TYPES (TREE_TYPE (e
->callee
->decl
))
1570 && (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (e
->callee
->decl
)))
1572 gimple_call_set_fntype (new_stmt
, TREE_TYPE (e
->callee
->decl
));
1574 /* If the call becomes noreturn, remove the LHS if possible. */
1575 tree lhs
= gimple_call_lhs (new_stmt
);
1577 && gimple_call_noreturn_p (new_stmt
)
1578 && (VOID_TYPE_P (TREE_TYPE (gimple_call_fntype (new_stmt
)))
1579 || should_remove_lhs_p (lhs
)))
1581 if (TREE_CODE (lhs
) == SSA_NAME
)
1583 tree var
= create_tmp_reg_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
),
1584 TREE_TYPE (lhs
), NULL
);
1585 var
= get_or_create_ssa_default_def
1586 (DECL_STRUCT_FUNCTION (e
->caller
->decl
), var
);
1587 gimple
*set_stmt
= gimple_build_assign (lhs
, var
);
1588 gsi
= gsi_for_stmt (new_stmt
);
1589 gsi_insert_before_without_update (&gsi
, set_stmt
, GSI_SAME_STMT
);
1590 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), set_stmt
);
1592 gimple_call_set_lhs (new_stmt
, NULL_TREE
);
1593 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), new_stmt
);
1596 /* If new callee has no static chain, remove it. */
1597 if (gimple_call_chain (new_stmt
) && !DECL_STATIC_CHAIN (e
->callee
->decl
))
1599 gimple_call_set_chain (new_stmt
, NULL
);
1600 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), new_stmt
);
1603 maybe_remove_unused_call_args (DECL_STRUCT_FUNCTION (e
->caller
->decl
),
1606 e
->caller
->set_call_stmt_including_clones (e
->call_stmt
, new_stmt
, false);
1608 if (symtab
->dump_file
)
1610 fprintf (symtab
->dump_file
, " updated to:");
1611 print_gimple_stmt (symtab
->dump_file
, e
->call_stmt
, 0, dump_flags
);
1616 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1617 OLD_STMT changed into NEW_STMT. OLD_CALL is gimple_call_fndecl
1618 of OLD_STMT if it was previously call statement.
1619 If NEW_STMT is NULL, the call has been dropped without any
1623 cgraph_update_edges_for_call_stmt_node (cgraph_node
*node
,
1624 gimple
*old_stmt
, tree old_call
,
1627 tree new_call
= (new_stmt
&& is_gimple_call (new_stmt
))
1628 ? gimple_call_fndecl (new_stmt
) : 0;
1630 /* We are seeing indirect calls, then there is nothing to update. */
1631 if (!new_call
&& !old_call
)
1633 /* See if we turned indirect call into direct call or folded call to one builtin
1634 into different builtin. */
1635 if (old_call
!= new_call
)
1637 cgraph_edge
*e
= node
->get_edge (old_stmt
);
1638 cgraph_edge
*ne
= NULL
;
1639 profile_count count
;
1643 /* Keep calls marked as dead dead. */
1644 if (new_stmt
&& is_gimple_call (new_stmt
) && e
->callee
1645 && fndecl_built_in_p (e
->callee
->decl
, BUILT_IN_UNREACHABLE
))
1647 cgraph_edge::set_call_stmt (node
->get_edge (old_stmt
),
1648 as_a
<gcall
*> (new_stmt
));
1651 /* See if the edge is already there and has the correct callee. It
1652 might be so because of indirect inlining has already updated
1653 it. We also might've cloned and redirected the edge. */
1654 if (new_call
&& e
->callee
)
1656 cgraph_node
*callee
= e
->callee
;
1659 if (callee
->decl
== new_call
1660 || callee
->former_clone_of
== new_call
)
1662 cgraph_edge::set_call_stmt (e
, as_a
<gcall
*> (new_stmt
));
1665 callee
= callee
->clone_of
;
1669 /* Otherwise remove edge and create new one; we can't simply redirect
1670 since function has changed, so inline plan and other information
1671 attached to edge is invalid. */
1673 if (e
->indirect_unknown_callee
|| e
->inline_failed
)
1674 cgraph_edge::remove (e
);
1676 e
->callee
->remove_symbol_and_inline_clones ();
1680 /* We are seeing new direct call; compute profile info based on BB. */
1681 basic_block bb
= gimple_bb (new_stmt
);
1687 ne
= node
->create_edge (cgraph_node::get_create (new_call
),
1688 as_a
<gcall
*> (new_stmt
), count
);
1689 gcc_assert (ne
->inline_failed
);
1692 /* We only updated the call stmt; update pointer in cgraph edge.. */
1693 else if (old_stmt
!= new_stmt
)
1694 cgraph_edge::set_call_stmt (node
->get_edge (old_stmt
),
1695 as_a
<gcall
*> (new_stmt
));
1698 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1699 OLD_STMT changed into NEW_STMT. OLD_DECL is gimple_call_fndecl
1700 of OLD_STMT before it was updated (updating can happen inplace). */
1703 cgraph_update_edges_for_call_stmt (gimple
*old_stmt
, tree old_decl
,
1706 cgraph_node
*orig
= cgraph_node::get (cfun
->decl
);
1709 gcc_checking_assert (orig
);
1710 cgraph_update_edges_for_call_stmt_node (orig
, old_stmt
, old_decl
, new_stmt
);
1712 for (node
= orig
->clones
; node
!= orig
;)
1714 cgraph_update_edges_for_call_stmt_node (node
, old_stmt
, old_decl
,
1717 node
= node
->clones
;
1718 else if (node
->next_sibling_clone
)
1719 node
= node
->next_sibling_clone
;
1722 while (node
!= orig
&& !node
->next_sibling_clone
)
1723 node
= node
->clone_of
;
1725 node
= node
->next_sibling_clone
;
1731 /* Remove all callees from the node. */
1734 cgraph_node::remove_callees (void)
1738 calls_comdat_local
= false;
1740 /* It is sufficient to remove the edges from the lists of callers of
1741 the callees. The callee list of the node can be zapped with one
1743 for (e
= callees
; 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 for (e
= indirect_calls
; e
; e
= f
)
1754 symtab
->call_edge_removal_hooks (e
);
1755 if (!e
->indirect_unknown_callee
)
1756 e
->remove_callee ();
1757 symtab
->free_edge (e
);
1759 indirect_calls
= NULL
;
1763 call_site_hash
->empty ();
1764 call_site_hash
= NULL
;
1768 /* Remove all callers from the node. */
1771 cgraph_node::remove_callers (void)
1775 /* It is sufficient to remove the edges from the lists of callees of
1776 the callers. The caller list of the node can be zapped with one
1778 for (e
= callers
; e
; e
= f
)
1781 symtab
->call_edge_removal_hooks (e
);
1782 e
->remove_caller ();
1783 symtab
->free_edge (e
);
1788 /* Helper function for cgraph_release_function_body and free_lang_data.
1789 It releases body from function DECL without having to inspect its
1790 possibly non-existent symtab node. */
1793 release_function_body (tree decl
)
1795 function
*fn
= DECL_STRUCT_FUNCTION (decl
);
1799 && loops_for_fn (fn
))
1801 fn
->curr_properties
&= ~PROP_loops
;
1802 loop_optimizer_finalize (fn
);
1806 delete_tree_ssa (fn
);
1811 gcc_assert (!dom_info_available_p (fn
, CDI_DOMINATORS
));
1812 gcc_assert (!dom_info_available_p (fn
, CDI_POST_DOMINATORS
));
1813 delete_tree_cfg_annotations (fn
);
1817 if (fn
->value_histograms
)
1818 free_histograms (fn
);
1819 gimple_set_body (decl
, NULL
);
1820 /* Struct function hangs a lot of data that would leak if we didn't
1821 removed all pointers to it. */
1823 DECL_STRUCT_FUNCTION (decl
) = NULL
;
1825 DECL_SAVED_TREE (decl
) = NULL
;
1828 /* Release memory used to represent body of function.
1829 Use this only for functions that are released before being translated to
1830 target code (i.e. RTL). Functions that are compiled to RTL and beyond
1831 are free'd in final.c via free_after_compilation().
1832 KEEP_ARGUMENTS are useful only if you want to rebuild body as thunk. */
1835 cgraph_node::release_body (bool keep_arguments
)
1837 ipa_transforms_to_apply
.release ();
1838 if (!used_as_abstract_origin
&& symtab
->state
!= PARSING
)
1840 DECL_RESULT (decl
) = NULL
;
1842 if (!keep_arguments
)
1843 DECL_ARGUMENTS (decl
) = NULL
;
1845 /* If the node is abstract and needed, then do not clear
1846 DECL_INITIAL of its associated function declaration because it's
1847 needed to emit debug info later. */
1848 if (!used_as_abstract_origin
&& DECL_INITIAL (decl
))
1849 DECL_INITIAL (decl
) = error_mark_node
;
1850 release_function_body (decl
);
1853 lto_free_function_in_decl_state_for_node (this);
1854 lto_file_data
= NULL
;
1858 /* Remove function from symbol table. */
1861 cgraph_node::remove (void)
1863 bool clone_info_set
= false;
1864 clone_info
*info
, saved_info
;
1865 if (symtab
->ipa_clones_dump_file
&& symtab
->cloned_nodes
.contains (this))
1866 fprintf (symtab
->ipa_clones_dump_file
,
1867 "Callgraph removal;%s;%d;%s;%d;%d\n", asm_name (), order
,
1868 DECL_SOURCE_FILE (decl
), DECL_SOURCE_LINE (decl
),
1869 DECL_SOURCE_COLUMN (decl
));
1871 if ((info
= clone_info::get (this)) != NULL
)
1874 clone_info_set
= true;
1876 symtab
->call_cgraph_removal_hooks (this);
1879 ipa_transforms_to_apply
.release ();
1880 delete_function_version (function_version ());
1882 /* Incremental inlining access removed nodes stored in the postorder list.
1884 force_output
= false;
1885 forced_by_abi
= false;
1887 unregister (clone_info_set
? &saved_info
: NULL
);
1888 if (prev_sibling_clone
)
1889 prev_sibling_clone
->next_sibling_clone
= next_sibling_clone
;
1891 clone_of
->clones
= next_sibling_clone
;
1892 if (next_sibling_clone
)
1893 next_sibling_clone
->prev_sibling_clone
= prev_sibling_clone
;
1896 cgraph_node
*n
, *next
;
1900 for (n
= clones
; n
->next_sibling_clone
; n
= n
->next_sibling_clone
)
1901 n
->clone_of
= clone_of
;
1902 n
->clone_of
= clone_of
;
1903 n
->next_sibling_clone
= clone_of
->clones
;
1904 if (clone_of
->clones
)
1905 clone_of
->clones
->prev_sibling_clone
= n
;
1906 clone_of
->clones
= clones
;
1910 /* We are removing node with clones. This makes clones inconsistent,
1911 but assume they will be removed subsequently and just keep clone
1912 tree intact. This can happen in unreachable function removal since
1913 we remove unreachable functions in random order, not by bottom-up
1914 walk of clone trees. */
1915 for (n
= clones
; n
; n
= next
)
1917 next
= n
->next_sibling_clone
;
1918 n
->next_sibling_clone
= NULL
;
1919 n
->prev_sibling_clone
= NULL
;
1925 /* While all the clones are removed after being proceeded, the function
1926 itself is kept in the cgraph even after it is compiled. Check whether
1927 we are done with this body and reclaim it proactively if this is the case.
1929 if (symtab
->state
!= LTO_STREAMING
)
1931 cgraph_node
*n
= cgraph_node::get (decl
);
1933 || (!n
->clones
&& !n
->clone_of
&& !n
->inlined_to
1934 && ((symtab
->global_info_ready
|| in_lto_p
)
1935 && (TREE_ASM_WRITTEN (n
->decl
)
1936 || DECL_EXTERNAL (n
->decl
)
1938 || (!flag_wpa
&& n
->in_other_partition
)))))
1943 lto_free_function_in_decl_state_for_node (this);
1944 lto_file_data
= NULL
;
1950 call_site_hash
->empty ();
1951 call_site_hash
= NULL
;
1954 symtab
->release_symbol (this);
1957 /* Likewise indicate that a node is having address taken. */
1960 cgraph_node::mark_address_taken (void)
1962 /* Indirect inlining can figure out that all uses of the address are
1966 gcc_assert (cfun
->after_inlining
);
1967 gcc_assert (callers
->indirect_inlining_edge
);
1970 /* FIXME: address_taken flag is used both as a shortcut for testing whether
1971 IPA_REF_ADDR reference exists (and thus it should be set on node
1972 representing alias we take address of) and as a test whether address
1973 of the object was taken (and thus it should be set on node alias is
1974 referring to). We should remove the first use and the remove the
1977 cgraph_node
*node
= ultimate_alias_target ();
1978 node
->address_taken
= 1;
1981 /* Return local info node for the compiled function. */
1984 cgraph_node::local_info_node (tree decl
)
1986 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1987 cgraph_node
*node
= get (decl
);
1990 return node
->ultimate_alias_target ();
1993 /* Return RTL info for the compiled function. */
1996 cgraph_node::rtl_info (const_tree decl
)
1998 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1999 cgraph_node
*node
= get (decl
);
2002 enum availability avail
;
2003 node
= node
->ultimate_alias_target (&avail
);
2004 if (decl
!= current_function_decl
2005 && (avail
< AVAIL_AVAILABLE
2006 || (node
->decl
!= current_function_decl
2007 && !TREE_ASM_WRITTEN (node
->decl
))))
2009 /* Allocate if it doesn't exist. */
2010 if (node
->rtl
== NULL
)
2012 node
->rtl
= ggc_cleared_alloc
<cgraph_rtl_info
> ();
2013 SET_HARD_REG_SET (node
->rtl
->function_used_regs
);
2018 /* Return a string describing the failure REASON. */
2021 cgraph_inline_failed_string (cgraph_inline_failed_t reason
)
2024 #define DEFCIFCODE(code, type, string) string,
2026 static const char *cif_string_table
[CIF_N_REASONS
] = {
2027 #include "cif-code.def"
2030 /* Signedness of an enum type is implementation defined, so cast it
2031 to unsigned before testing. */
2032 gcc_assert ((unsigned) reason
< CIF_N_REASONS
);
2033 return cif_string_table
[reason
];
2036 /* Return a type describing the failure REASON. */
2038 cgraph_inline_failed_type_t
2039 cgraph_inline_failed_type (cgraph_inline_failed_t reason
)
2042 #define DEFCIFCODE(code, type, string) type,
2044 static cgraph_inline_failed_type_t cif_type_table
[CIF_N_REASONS
] = {
2045 #include "cif-code.def"
2048 /* Signedness of an enum type is implementation defined, so cast it
2049 to unsigned before testing. */
2050 gcc_assert ((unsigned) reason
< CIF_N_REASONS
);
2051 return cif_type_table
[reason
];
2054 /* Names used to print out the availability enum. */
2055 const char * const cgraph_availability_names
[] =
2056 {"unset", "not_available", "overwritable", "available", "local"};
2058 /* Output flags of edge to a file F. */
2061 cgraph_edge::dump_edge_flags (FILE *f
)
2064 fprintf (f
, "(speculative) ");
2066 fprintf (f
, "(inlined) ");
2067 if (call_stmt_cannot_inline_p
)
2068 fprintf (f
, "(call_stmt_cannot_inline_p) ");
2069 if (indirect_inlining_edge
)
2070 fprintf (f
, "(indirect_inlining) ");
2071 if (count
.initialized_p ())
2076 fprintf (f
, "%.2f per call) ", sreal_frequency ().to_double ());
2078 if (can_throw_external
)
2079 fprintf (f
, "(can throw external) ");
2082 /* Dump edge to stderr. */
2085 cgraph_edge::debug (void)
2087 fprintf (stderr
, "%s -> %s ", caller
->dump_asm_name (),
2088 callee
== NULL
? "(null)" : callee
->dump_asm_name ());
2089 dump_edge_flags (stderr
);
2090 fprintf (stderr
, "\n\n");
2096 /* Dump call graph node to file F. */
2099 cgraph_node::dump (FILE *f
)
2106 fprintf (f
, " Function %s is inline copy in %s\n",
2108 inlined_to
->dump_name ());
2110 fprintf (f
, " Clone of %s\n", clone_of
->dump_asm_name ());
2111 if (symtab
->function_flags_ready
)
2112 fprintf (f
, " Availability: %s\n",
2113 cgraph_availability_names
[get_availability ()]);
2116 fprintf (f
, " Profile id: %i\n",
2119 fprintf (f
, " Unit id: %i\n",
2121 cgraph_function_version_info
*vi
= function_version ();
2124 fprintf (f
, " Version info: ");
2125 if (vi
->prev
!= NULL
)
2127 fprintf (f
, "prev: ");
2128 fprintf (f
, "%s ", vi
->prev
->this_node
->dump_asm_name ());
2130 if (vi
->next
!= NULL
)
2132 fprintf (f
, "next: ");
2133 fprintf (f
, "%s ", vi
->next
->this_node
->dump_asm_name ());
2135 if (vi
->dispatcher_resolver
!= NULL_TREE
)
2136 fprintf (f
, "dispatcher: %s",
2137 lang_hooks
.decl_printable_name (vi
->dispatcher_resolver
, 2));
2141 fprintf (f
, " Function flags:");
2142 if (count
.initialized_p ())
2144 fprintf (f
, " count:");
2147 if (tp_first_run
> 0)
2148 fprintf (f
, " first_run:%" PRId64
, (int64_t) tp_first_run
);
2149 if (cgraph_node
*origin
= nested_function_origin (this))
2150 fprintf (f
, " nested in:%s", origin
->dump_asm_name ());
2151 if (gimple_has_body_p (decl
))
2152 fprintf (f
, " body");
2154 fprintf (f
, " process");
2156 fprintf (f
, " local");
2157 if (redefined_extern_inline
)
2158 fprintf (f
, " redefined_extern_inline");
2159 if (only_called_at_startup
)
2160 fprintf (f
, " only_called_at_startup");
2161 if (only_called_at_exit
)
2162 fprintf (f
, " only_called_at_exit");
2164 fprintf (f
, " tm_clone");
2165 if (calls_comdat_local
)
2166 fprintf (f
, " calls_comdat_local");
2168 fprintf (f
, " icf_merged");
2170 fprintf (f
, " merged_comdat");
2171 if (merged_extern_inline
)
2172 fprintf (f
, " merged_extern_inline");
2174 fprintf (f
, " split_part");
2175 if (indirect_call_target
)
2176 fprintf (f
, " indirect_call_target");
2178 fprintf (f
, " nonfreeing_fn");
2179 if (DECL_STATIC_CONSTRUCTOR (decl
))
2180 fprintf (f
," static_constructor (priority:%i)", get_init_priority ());
2181 if (DECL_STATIC_DESTRUCTOR (decl
))
2182 fprintf (f
," static_destructor (priority:%i)", get_fini_priority ());
2183 if (frequency
== NODE_FREQUENCY_HOT
)
2184 fprintf (f
, " hot");
2185 if (frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
)
2186 fprintf (f
, " unlikely_executed");
2187 if (frequency
== NODE_FREQUENCY_EXECUTED_ONCE
)
2188 fprintf (f
, " executed_once");
2189 if (opt_for_fn (decl
, optimize_size
))
2190 fprintf (f
, " optimize_size");
2191 if (parallelized_function
)
2192 fprintf (f
, " parallelized_function");
2193 if (DECL_IS_OPERATOR_NEW_P (decl
))
2194 fprintf (f
, " %soperator_new",
2195 DECL_IS_REPLACEABLE_OPERATOR (decl
) ? "replaceable_" : "");
2196 if (DECL_IS_OPERATOR_DELETE_P (decl
))
2197 fprintf (f
, " %soperator_delete",
2198 DECL_IS_REPLACEABLE_OPERATOR (decl
) ? "replaceable_" : "");
2204 fprintf (f
, " Thunk");
2205 thunk_info::get (this)->dump (f
);
2207 else if (former_thunk_p ())
2209 fprintf (f
, " Former thunk ");
2210 thunk_info::get (this)->dump (f
);
2212 else gcc_checking_assert (!thunk_info::get (this));
2214 fprintf (f
, " Called by: ");
2216 profile_count sum
= profile_count::zero ();
2217 for (edge
= callers
; edge
; edge
= edge
->next_caller
)
2219 fprintf (f
, "%s ", edge
->caller
->dump_asm_name ());
2220 edge
->dump_edge_flags (f
);
2221 if (edge
->count
.initialized_p ())
2222 sum
+= edge
->count
.ipa ();
2225 fprintf (f
, "\n Calls: ");
2226 for (edge
= callees
; edge
; edge
= edge
->next_callee
)
2228 fprintf (f
, "%s ", edge
->callee
->dump_asm_name ());
2229 edge
->dump_edge_flags (f
);
2233 if (count
.ipa ().initialized_p ())
2239 FOR_EACH_ALIAS (this, ref
)
2240 if (dyn_cast
<cgraph_node
*> (ref
->referring
)->count
.initialized_p ())
2241 sum
+= dyn_cast
<cgraph_node
*> (ref
->referring
)->count
.ipa ();
2244 || (symtab
->state
< EXPANSION
2245 && ultimate_alias_target () == this && only_called_directly_p ()))
2246 ok
= !count
.ipa ().differs_from_p (sum
);
2247 else if (count
.ipa () > profile_count::from_gcov_type (100)
2248 && count
.ipa () < sum
.apply_scale (99, 100))
2249 ok
= false, min
= true;
2252 fprintf (f
, " Invalid sum of caller counts ");
2255 fprintf (f
, ", should be at most ");
2257 fprintf (f
, ", should be ");
2258 count
.ipa ().dump (f
);
2263 for (edge
= indirect_calls
; edge
; edge
= edge
->next_callee
)
2265 if (edge
->indirect_info
->polymorphic
)
2267 fprintf (f
, " Polymorphic indirect call of type ");
2268 print_generic_expr (f
, edge
->indirect_info
->otr_type
, TDF_SLIM
);
2269 fprintf (f
, " token:%i", (int) edge
->indirect_info
->otr_token
);
2272 fprintf (f
, " Indirect call");
2273 edge
->dump_edge_flags (f
);
2274 if (edge
->indirect_info
->param_index
!= -1)
2276 fprintf (f
, "of param:%i ", edge
->indirect_info
->param_index
);
2277 if (edge
->indirect_info
->agg_contents
)
2278 fprintf (f
, "loaded from %s %s at offset %i ",
2279 edge
->indirect_info
->member_ptr
? "member ptr" : "aggregate",
2280 edge
->indirect_info
->by_ref
? "passed by reference":"",
2281 (int)edge
->indirect_info
->offset
);
2282 if (edge
->indirect_info
->vptr_changed
)
2283 fprintf (f
, "(vptr maybe changed) ");
2285 fprintf (f
, "num speculative call targets: %i\n",
2286 edge
->indirect_info
->num_speculative_call_targets
);
2287 if (edge
->indirect_info
->polymorphic
)
2288 edge
->indirect_info
->context
.dump (f
);
2292 /* Dump call graph node to file F in graphviz format. */
2295 cgraph_node::dump_graphviz (FILE *f
)
2299 for (edge
= callees
; edge
; edge
= edge
->next_callee
)
2301 cgraph_node
*callee
= edge
->callee
;
2303 fprintf (f
, "\t\"%s\" -> \"%s\"\n", dump_name (), callee
->dump_name ());
2308 /* Dump call graph node NODE to stderr. */
2311 cgraph_node::debug (void)
2316 /* Dump the callgraph to file F. */
2319 cgraph_node::dump_cgraph (FILE *f
)
2323 fprintf (f
, "callgraph:\n\n");
2324 FOR_EACH_FUNCTION (node
)
2328 /* Return true when the DECL can possibly be inlined. */
2331 cgraph_function_possibly_inlined_p (tree decl
)
2333 if (!symtab
->global_info_ready
)
2334 return !DECL_UNINLINABLE (decl
);
2335 return DECL_POSSIBLY_INLINED (decl
);
2338 /* Return function availability. See cgraph.h for description of individual
2341 cgraph_node::get_availability (symtab_node
*ref
)
2345 cgraph_node
*cref
= dyn_cast
<cgraph_node
*> (ref
);
2347 ref
= cref
->inlined_to
;
2349 enum availability avail
;
2350 if (!analyzed
&& !in_other_partition
)
2351 avail
= AVAIL_NOT_AVAILABLE
;
2353 avail
= AVAIL_LOCAL
;
2354 else if (inlined_to
)
2355 avail
= AVAIL_AVAILABLE
;
2356 else if (transparent_alias
)
2357 ultimate_alias_target (&avail
, ref
);
2358 else if (ifunc_resolver
2359 || lookup_attribute ("noipa", DECL_ATTRIBUTES (decl
)))
2360 avail
= AVAIL_INTERPOSABLE
;
2361 else if (!externally_visible
)
2362 avail
= AVAIL_AVAILABLE
;
2363 /* If this is a reference from symbol itself and there are no aliases, we
2364 may be sure that the symbol was not interposed by something else because
2365 the symbol itself would be unreachable otherwise.
2367 Also comdat groups are always resolved in groups. */
2368 else if ((this == ref
&& !has_aliases_p ())
2369 || (ref
&& get_comdat_group ()
2370 && get_comdat_group () == ref
->get_comdat_group ()))
2371 avail
= AVAIL_AVAILABLE
;
2372 /* Inline functions are safe to be analyzed even if their symbol can
2373 be overwritten at runtime. It is not meaningful to enforce any sane
2374 behavior on replacing inline function by different body. */
2375 else if (DECL_DECLARED_INLINE_P (decl
))
2376 avail
= AVAIL_AVAILABLE
;
2378 /* If the function can be overwritten, return OVERWRITABLE. Take
2379 care at least of two notable extensions - the COMDAT functions
2380 used to share template instantiations in C++ (this is symmetric
2381 to code cp_cannot_inline_tree_fn and probably shall be shared and
2382 the inlinability hooks completely eliminated). */
2384 else if (decl_replaceable_p (decl
) && !DECL_EXTERNAL (decl
))
2385 avail
= AVAIL_INTERPOSABLE
;
2386 else avail
= AVAIL_AVAILABLE
;
2391 /* Worker for cgraph_node_can_be_local_p. */
2393 cgraph_node_cannot_be_local_p_1 (cgraph_node
*node
, void *)
2395 return !(!node
->force_output
2396 && !node
->ifunc_resolver
2397 /* Limitation of gas requires us to output targets of symver aliases
2398 as global symbols. This is binutils PR 25295. */
2400 && ((DECL_COMDAT (node
->decl
)
2401 && !node
->forced_by_abi
2402 && !node
->used_from_object_file_p ()
2403 && !node
->same_comdat_group
)
2404 || !node
->externally_visible
));
2407 /* Return true if cgraph_node can be made local for API change.
2408 Extern inline functions and C++ COMDAT functions can be made local
2409 at the expense of possible code size growth if function is used in multiple
2410 compilation units. */
2412 cgraph_node::can_be_local_p (void)
2414 return (!address_taken
2415 && !call_for_symbol_thunks_and_aliases (cgraph_node_cannot_be_local_p_1
,
2419 /* Call callback on cgraph_node, thunks and aliases associated to cgraph_node.
2420 When INCLUDE_OVERWRITABLE is false, overwritable symbols are
2421 skipped. When EXCLUDE_VIRTUAL_THUNKS is true, virtual thunks are
2424 cgraph_node::call_for_symbol_thunks_and_aliases (bool (*callback
)
2425 (cgraph_node
*, void *),
2427 bool include_overwritable
,
2428 bool exclude_virtual_thunks
)
2432 enum availability avail
= AVAIL_AVAILABLE
;
2434 if (include_overwritable
2435 || (avail
= get_availability ()) > AVAIL_INTERPOSABLE
)
2437 if (callback (this, data
))
2440 FOR_EACH_ALIAS (this, ref
)
2442 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2443 if (include_overwritable
2444 || alias
->get_availability () > AVAIL_INTERPOSABLE
)
2445 if (alias
->call_for_symbol_thunks_and_aliases (callback
, data
,
2446 include_overwritable
,
2447 exclude_virtual_thunks
))
2450 if (avail
<= AVAIL_INTERPOSABLE
)
2452 for (e
= callers
; e
; e
= e
->next_caller
)
2453 if (e
->caller
->thunk
2454 && (include_overwritable
2455 || e
->caller
->get_availability () > AVAIL_INTERPOSABLE
)
2456 && !(exclude_virtual_thunks
2457 && thunk_info::get (e
->caller
)->virtual_offset_p
))
2458 if (e
->caller
->call_for_symbol_thunks_and_aliases (callback
, data
,
2459 include_overwritable
,
2460 exclude_virtual_thunks
))
2466 /* Worker to bring NODE local. */
2469 cgraph_node::make_local (cgraph_node
*node
, void *)
2471 gcc_checking_assert (node
->can_be_local_p ());
2472 if (DECL_COMDAT (node
->decl
) || DECL_EXTERNAL (node
->decl
))
2474 node
->make_decl_local ();
2475 node
->set_section (NULL
);
2476 node
->set_comdat_group (NULL
);
2477 node
->externally_visible
= false;
2478 node
->forced_by_abi
= false;
2480 node
->set_section (NULL
);
2481 node
->unique_name
= ((node
->resolution
== LDPR_PREVAILING_DEF_IRONLY
2482 || node
->resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
)
2483 && !flag_incremental_link
);
2484 node
->resolution
= LDPR_PREVAILING_DEF_IRONLY
;
2485 gcc_assert (node
->get_availability () == AVAIL_LOCAL
);
2490 /* Bring cgraph node local. */
2493 cgraph_node::make_local (void)
2495 call_for_symbol_thunks_and_aliases (cgraph_node::make_local
, NULL
, true);
2498 /* Worker to set nothrow flag. */
2501 set_nothrow_flag_1 (cgraph_node
*node
, bool nothrow
, bool non_call
,
2506 if (nothrow
&& !TREE_NOTHROW (node
->decl
))
2508 /* With non-call exceptions we can't say for sure if other function body
2509 was not possibly optimized to still throw. */
2510 if (!non_call
|| node
->binds_to_current_def_p ())
2512 TREE_NOTHROW (node
->decl
) = true;
2514 for (e
= node
->callers
; e
; e
= e
->next_caller
)
2515 e
->can_throw_external
= false;
2518 else if (!nothrow
&& TREE_NOTHROW (node
->decl
))
2520 TREE_NOTHROW (node
->decl
) = false;
2524 FOR_EACH_ALIAS (node
, ref
)
2526 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2527 if (!nothrow
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2528 set_nothrow_flag_1 (alias
, nothrow
, non_call
, changed
);
2530 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
2531 if (e
->caller
->thunk
2532 && (!nothrow
|| e
->caller
->get_availability () > AVAIL_INTERPOSABLE
))
2533 set_nothrow_flag_1 (e
->caller
, nothrow
, non_call
, changed
);
2536 /* Set TREE_NOTHROW on NODE's decl and on aliases of NODE
2537 if any to NOTHROW. */
2540 cgraph_node::set_nothrow_flag (bool nothrow
)
2542 bool changed
= false;
2543 bool non_call
= opt_for_fn (decl
, flag_non_call_exceptions
);
2545 if (!nothrow
|| get_availability () > AVAIL_INTERPOSABLE
)
2546 set_nothrow_flag_1 (this, nothrow
, non_call
, &changed
);
2551 FOR_EACH_ALIAS (this, ref
)
2553 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2554 if (!nothrow
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2555 set_nothrow_flag_1 (alias
, nothrow
, non_call
, &changed
);
2561 /* Worker to set malloc flag. */
2563 set_malloc_flag_1 (cgraph_node
*node
, bool malloc_p
, bool *changed
)
2565 if (malloc_p
&& !DECL_IS_MALLOC (node
->decl
))
2567 DECL_IS_MALLOC (node
->decl
) = true;
2572 FOR_EACH_ALIAS (node
, ref
)
2574 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2575 if (!malloc_p
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2576 set_malloc_flag_1 (alias
, malloc_p
, changed
);
2579 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
2580 if (e
->caller
->thunk
2581 && (!malloc_p
|| e
->caller
->get_availability () > AVAIL_INTERPOSABLE
))
2582 set_malloc_flag_1 (e
->caller
, malloc_p
, changed
);
2585 /* Set DECL_IS_MALLOC on NODE's decl and on NODE's aliases if any. */
2588 cgraph_node::set_malloc_flag (bool malloc_p
)
2590 bool changed
= false;
2592 if (!malloc_p
|| get_availability () > AVAIL_INTERPOSABLE
)
2593 set_malloc_flag_1 (this, malloc_p
, &changed
);
2598 FOR_EACH_ALIAS (this, ref
)
2600 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2601 if (!malloc_p
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2602 set_malloc_flag_1 (alias
, malloc_p
, &changed
);
2608 /* Worker to set_const_flag. */
2611 set_const_flag_1 (cgraph_node
*node
, bool set_const
, bool looping
,
2614 /* Static constructors and destructors without a side effect can be
2616 if (set_const
&& !looping
)
2618 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
2620 DECL_STATIC_CONSTRUCTOR (node
->decl
) = 0;
2623 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
2625 DECL_STATIC_DESTRUCTOR (node
->decl
) = 0;
2631 if (TREE_READONLY (node
->decl
))
2633 TREE_READONLY (node
->decl
) = 0;
2634 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2640 /* Consider function:
2647 During early optimization we will turn this into:
2654 Now if this function will be detected as CONST however when interposed
2655 it may end up being just pure. We always must assume the worst
2657 if (TREE_READONLY (node
->decl
))
2659 if (!looping
&& DECL_LOOPING_CONST_OR_PURE_P (node
->decl
))
2661 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2665 else if (node
->binds_to_current_def_p ())
2667 TREE_READONLY (node
->decl
) = true;
2668 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = looping
;
2669 DECL_PURE_P (node
->decl
) = false;
2674 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2675 fprintf (dump_file
, "Dropping state to PURE because function does "
2676 "not bind to current def.\n");
2677 if (!DECL_PURE_P (node
->decl
))
2679 DECL_PURE_P (node
->decl
) = true;
2680 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = looping
;
2683 else if (!looping
&& DECL_LOOPING_CONST_OR_PURE_P (node
->decl
))
2685 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2692 FOR_EACH_ALIAS (node
, ref
)
2694 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2695 if (!set_const
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2696 set_const_flag_1 (alias
, set_const
, looping
, changed
);
2698 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
2699 if (e
->caller
->thunk
2700 && (!set_const
|| e
->caller
->get_availability () > AVAIL_INTERPOSABLE
))
2702 /* Virtual thunks access virtual offset in the vtable, so they can
2703 only be pure, never const. */
2705 && (thunk_info::get (e
->caller
)->virtual_offset_p
2706 || !node
->binds_to_current_def_p (e
->caller
)))
2707 *changed
|= e
->caller
->set_pure_flag (true, looping
);
2709 set_const_flag_1 (e
->caller
, set_const
, looping
, changed
);
2713 /* If SET_CONST is true, mark function, aliases and thunks to be ECF_CONST.
2714 If SET_CONST if false, clear the flag.
2716 When setting the flag be careful about possible interposition and
2717 do not set the flag for functions that can be interposed and set pure
2718 flag for functions that can bind to other definition.
2720 Return true if any change was done. */
2723 cgraph_node::set_const_flag (bool set_const
, bool looping
)
2725 bool changed
= false;
2726 if (!set_const
|| get_availability () > AVAIL_INTERPOSABLE
)
2727 set_const_flag_1 (this, set_const
, looping
, &changed
);
2732 FOR_EACH_ALIAS (this, ref
)
2734 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2735 if (!set_const
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2736 set_const_flag_1 (alias
, set_const
, looping
, &changed
);
2742 /* Info used by set_pure_flag_1. */
2744 struct set_pure_flag_info
2751 /* Worker to set_pure_flag. */
2754 set_pure_flag_1 (cgraph_node
*node
, void *data
)
2756 struct set_pure_flag_info
*info
= (struct set_pure_flag_info
*)data
;
2757 /* Static constructors and destructors without a side effect can be
2759 if (info
->pure
&& !info
->looping
)
2761 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
2763 DECL_STATIC_CONSTRUCTOR (node
->decl
) = 0;
2764 info
->changed
= true;
2766 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
2768 DECL_STATIC_DESTRUCTOR (node
->decl
) = 0;
2769 info
->changed
= true;
2774 if (!DECL_PURE_P (node
->decl
) && !TREE_READONLY (node
->decl
))
2776 DECL_PURE_P (node
->decl
) = true;
2777 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = info
->looping
;
2778 info
->changed
= true;
2780 else if (DECL_LOOPING_CONST_OR_PURE_P (node
->decl
)
2783 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2784 info
->changed
= true;
2789 if (DECL_PURE_P (node
->decl
))
2791 DECL_PURE_P (node
->decl
) = false;
2792 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2793 info
->changed
= true;
2799 /* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node
2802 When setting the flag, be careful about possible interposition.
2803 Return true if any change was done. */
2806 cgraph_node::set_pure_flag (bool pure
, bool looping
)
2808 struct set_pure_flag_info info
= {pure
, looping
, false};
2809 call_for_symbol_thunks_and_aliases (set_pure_flag_1
, &info
, !pure
, true);
2810 return info
.changed
;
2813 /* Return true when cgraph_node cannot return or throw and thus
2814 it is safe to ignore its side effects for IPA analysis. */
2817 cgraph_node::cannot_return_p (void)
2819 int flags
= flags_from_decl_or_type (decl
);
2820 if (!opt_for_fn (decl
, flag_exceptions
))
2821 return (flags
& ECF_NORETURN
) != 0;
2823 return ((flags
& (ECF_NORETURN
| ECF_NOTHROW
))
2824 == (ECF_NORETURN
| ECF_NOTHROW
));
2827 /* Return true when call of edge cannot lead to return from caller
2828 and thus it is safe to ignore its side effects for IPA analysis
2829 when computing side effects of the caller.
2830 FIXME: We could actually mark all edges that have no reaching
2831 patch to the exit block or throw to get better results. */
2833 cgraph_edge::cannot_lead_to_return_p (void)
2835 if (caller
->cannot_return_p ())
2837 if (indirect_unknown_callee
)
2839 int flags
= indirect_info
->ecf_flags
;
2840 if (!opt_for_fn (caller
->decl
, flag_exceptions
))
2841 return (flags
& ECF_NORETURN
) != 0;
2843 return ((flags
& (ECF_NORETURN
| ECF_NOTHROW
))
2844 == (ECF_NORETURN
| ECF_NOTHROW
));
2847 return callee
->cannot_return_p ();
2850 /* Return true if the edge may be considered hot. */
2853 cgraph_edge::maybe_hot_p (void)
2855 if (!maybe_hot_count_p (NULL
, count
.ipa ()))
2857 if (caller
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
2859 && callee
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
))
2861 if (caller
->frequency
> NODE_FREQUENCY_UNLIKELY_EXECUTED
2863 && callee
->frequency
<= NODE_FREQUENCY_EXECUTED_ONCE
))
2865 if (opt_for_fn (caller
->decl
, optimize_size
))
2867 if (caller
->frequency
== NODE_FREQUENCY_HOT
)
2869 if (!count
.initialized_p ())
2871 cgraph_node
*where
= caller
->inlined_to
? caller
->inlined_to
: caller
;
2872 if (!where
->count
.initialized_p ())
2874 if (caller
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
)
2876 if (count
.apply_scale (2, 1) < where
->count
.apply_scale (3, 1))
2879 else if (count
.apply_scale (param_hot_bb_frequency_fraction
, 1)
2885 /* Worker for cgraph_can_remove_if_no_direct_calls_p. */
2888 nonremovable_p (cgraph_node
*node
, void *)
2890 return !node
->can_remove_if_no_direct_calls_and_refs_p ();
2893 /* Return true if whole comdat group can be removed if there are no direct
2897 cgraph_node::can_remove_if_no_direct_calls_p (bool will_inline
)
2899 struct ipa_ref
*ref
;
2901 /* For local symbols or non-comdat group it is the same as
2902 can_remove_if_no_direct_calls_p. */
2903 if (!externally_visible
|| !same_comdat_group
)
2905 if (DECL_EXTERNAL (decl
))
2909 return !call_for_symbol_and_aliases (nonremovable_p
, NULL
, true);
2912 if (will_inline
&& address_taken
)
2915 /* Otherwise check if we can remove the symbol itself and then verify
2916 that only uses of the comdat groups are direct call to THIS
2918 if (!can_remove_if_no_direct_calls_and_refs_p ())
2921 /* Check that all refs come from within the comdat group. */
2922 for (int i
= 0; iterate_referring (i
, ref
); i
++)
2923 if (ref
->referring
->get_comdat_group () != get_comdat_group ())
2926 struct cgraph_node
*target
= ultimate_alias_target ();
2927 for (cgraph_node
*next
= dyn_cast
<cgraph_node
*> (same_comdat_group
);
2928 next
!= this; next
= dyn_cast
<cgraph_node
*> (next
->same_comdat_group
))
2930 if (!externally_visible
)
2933 && !next
->can_remove_if_no_direct_calls_and_refs_p ())
2936 /* If we see different symbol than THIS, be sure to check calls. */
2937 if (next
->ultimate_alias_target () != target
)
2938 for (cgraph_edge
*e
= next
->callers
; e
; e
= e
->next_caller
)
2939 if (e
->caller
->get_comdat_group () != get_comdat_group ()
2943 /* If function is not being inlined, we care only about
2944 references outside of the comdat group. */
2946 for (int i
= 0; next
->iterate_referring (i
, ref
); i
++)
2947 if (ref
->referring
->get_comdat_group () != get_comdat_group ())
2953 /* Return true when function cgraph_node can be expected to be removed
2954 from program when direct calls in this compilation unit are removed.
2956 As a special case COMDAT functions are
2957 cgraph_can_remove_if_no_direct_calls_p while the are not
2958 cgraph_only_called_directly_p (it is possible they are called from other
2961 This function behaves as cgraph_only_called_directly_p because eliminating
2962 all uses of COMDAT function does not make it necessarily disappear from
2963 the program unless we are compiling whole program or we do LTO. In this
2964 case we know we win since dynamic linking will not really discard the
2965 linkonce section. */
2968 cgraph_node::will_be_removed_from_program_if_no_direct_calls_p
2971 gcc_assert (!inlined_to
);
2972 if (DECL_EXTERNAL (decl
))
2975 if (!in_lto_p
&& !flag_whole_program
)
2977 /* If the symbol is in comdat group, we need to verify that whole comdat
2978 group becomes unreachable. Technically we could skip references from
2979 within the group, too. */
2980 if (!only_called_directly_p ())
2982 if (same_comdat_group
&& externally_visible
)
2984 struct cgraph_node
*target
= ultimate_alias_target ();
2986 if (will_inline
&& address_taken
)
2988 for (cgraph_node
*next
= dyn_cast
<cgraph_node
*> (same_comdat_group
);
2990 next
= dyn_cast
<cgraph_node
*> (next
->same_comdat_group
))
2992 if (!externally_visible
)
2995 && !next
->only_called_directly_p ())
2998 /* If we see different symbol than THIS,
2999 be sure to check calls. */
3000 if (next
->ultimate_alias_target () != target
)
3001 for (cgraph_edge
*e
= next
->callers
; e
; e
= e
->next_caller
)
3002 if (e
->caller
->get_comdat_group () != get_comdat_group ()
3010 return can_remove_if_no_direct_calls_p (will_inline
);
3014 /* Worker for cgraph_only_called_directly_p. */
3017 cgraph_not_only_called_directly_p_1 (cgraph_node
*node
, void *)
3019 return !node
->only_called_directly_or_aliased_p ();
3022 /* Return true when function cgraph_node and all its aliases are only called
3024 i.e. it is not externally visible, address was not taken and
3025 it is not used in any other non-standard way. */
3028 cgraph_node::only_called_directly_p (void)
3030 gcc_assert (ultimate_alias_target () == this);
3031 return !call_for_symbol_and_aliases (cgraph_not_only_called_directly_p_1
,
3036 /* Collect all callers of NODE. Worker for collect_callers_of_node. */
3039 collect_callers_of_node_1 (cgraph_node
*node
, void *data
)
3041 vec
<cgraph_edge
*> *redirect_callers
= (vec
<cgraph_edge
*> *)data
;
3043 enum availability avail
;
3044 node
->ultimate_alias_target (&avail
);
3046 if (avail
> AVAIL_INTERPOSABLE
)
3047 for (cs
= node
->callers
; cs
!= NULL
; cs
= cs
->next_caller
)
3048 if (!cs
->indirect_inlining_edge
3049 && !cs
->caller
->thunk
)
3050 redirect_callers
->safe_push (cs
);
3054 /* Collect all callers of cgraph_node and its aliases that are known to lead to
3055 cgraph_node (i.e. are not overwritable). */
3058 cgraph_node::collect_callers (void)
3060 vec
<cgraph_edge
*> redirect_callers
= vNULL
;
3061 call_for_symbol_thunks_and_aliases (collect_callers_of_node_1
,
3062 &redirect_callers
, false);
3063 return redirect_callers
;
3067 /* Return TRUE if NODE2 a clone of NODE or is equivalent to it. Return
3068 optimistically true if this cannot be determined. */
3071 clone_of_p (cgraph_node
*node
, cgraph_node
*node2
)
3073 node
= node
->ultimate_alias_target ();
3074 node2
= node2
->ultimate_alias_target ();
3076 if (node2
->clone_of
== node
3077 || node2
->former_clone_of
== node
->decl
)
3080 if (!node
->thunk
&& !node
->former_thunk_p ())
3082 while (node2
&& node
->decl
!= node2
->decl
)
3083 node2
= node2
->clone_of
;
3084 return node2
!= NULL
;
3087 /* There are no virtual clones of thunks so check former_clone_of or if we
3088 might have skipped thunks because this adjustments are no longer
3090 while (node
->thunk
|| node
->former_thunk_p ())
3092 if (!thunk_info::get (node
)->this_adjusting
)
3094 /* In case of instrumented expanded thunks, which can have multiple calls
3095 in them, we do not know how to continue and just have to be
3096 optimistic. The same applies if all calls have already been inlined
3098 if (!node
->callees
|| node
->callees
->next_callee
)
3100 node
= node
->callees
->callee
->ultimate_alias_target ();
3102 clone_info
*info
= clone_info::get (node2
);
3103 if (!info
|| !info
->param_adjustments
3104 || info
->param_adjustments
->first_param_intact_p ())
3106 if (node2
->former_clone_of
== node
->decl
3107 || node2
->former_clone_of
== node
->former_clone_of
)
3110 cgraph_node
*n2
= node2
;
3111 while (n2
&& node
->decl
!= n2
->decl
)
3120 /* Verify edge count and frequency. */
3123 cgraph_edge::verify_count ()
3125 bool error_found
= false;
3126 if (!count
.verify ())
3128 error ("caller edge count invalid");
3134 /* Switch to THIS_CFUN if needed and print STMT to stderr. */
3136 cgraph_debug_gimple_stmt (function
*this_cfun
, gimple
*stmt
)
3138 bool fndecl_was_null
= false;
3139 /* debug_gimple_stmt needs correct cfun */
3140 if (cfun
!= this_cfun
)
3141 set_cfun (this_cfun
);
3142 /* ...and an actual current_function_decl */
3143 if (!current_function_decl
)
3145 current_function_decl
= this_cfun
->decl
;
3146 fndecl_was_null
= true;
3148 debug_gimple_stmt (stmt
);
3149 if (fndecl_was_null
)
3150 current_function_decl
= NULL
;
3153 /* Verify that call graph edge corresponds to DECL from the associated
3154 statement. Return true if the verification should fail. */
3157 cgraph_edge::verify_corresponds_to_fndecl (tree decl
)
3161 if (!decl
|| callee
->inlined_to
)
3163 if (symtab
->state
== LTO_STREAMING
)
3165 node
= cgraph_node::get (decl
);
3167 /* We do not know if a node from a different partition is an alias or what it
3168 aliases and therefore cannot do the former_clone_of check reliably. When
3169 body_removed is set, we have lost all information about what was alias or
3170 thunk of and also cannot proceed. */
3172 || node
->body_removed
3173 || node
->in_other_partition
3174 || callee
->icf_merged
3175 || callee
->in_other_partition
)
3178 node
= node
->ultimate_alias_target ();
3180 /* Optimizers can redirect unreachable calls or calls triggering undefined
3181 behavior to builtin_unreachable. */
3183 if (fndecl_built_in_p (callee
->decl
, BUILT_IN_UNREACHABLE
))
3186 if (callee
->former_clone_of
!= node
->decl
3187 && (node
!= callee
->ultimate_alias_target ())
3188 && !clone_of_p (node
, callee
))
3194 /* Disable warnings about missing quoting in GCC diagnostics for
3195 the verification errors. Their format strings don't follow GCC
3196 diagnostic conventions and the calls are ultimately followed by
3197 one to internal_error. */
3199 # pragma GCC diagnostic push
3200 # pragma GCC diagnostic ignored "-Wformat-diag"
3203 /* Verify consistency of speculative call in NODE corresponding to STMT
3204 and LTO_STMT_UID. If INDIRECT is set, assume that it is the indirect
3205 edge of call sequence. Return true if error is found.
3207 This function is called to every component of indirect call (direct edges,
3208 indirect edge and refs). To save duplicated work, do full testing only
3211 verify_speculative_call (struct cgraph_node
*node
, gimple
*stmt
,
3212 unsigned int lto_stmt_uid
,
3213 struct cgraph_edge
*indirect
)
3215 if (indirect
== NULL
)
3217 for (indirect
= node
->indirect_calls
; indirect
;
3218 indirect
= indirect
->next_callee
)
3219 if (indirect
->call_stmt
== stmt
3220 && indirect
->lto_stmt_uid
== lto_stmt_uid
)
3224 error ("missing indirect call in speculative call sequence");
3227 if (!indirect
->speculative
)
3229 error ("indirect call in speculative call sequence has no "
3230 "speculative flag");
3236 /* Maximal number of targets. We probably will never want to have more than
3238 const unsigned int num
= 256;
3239 cgraph_edge
*direct_calls
[num
];
3242 for (unsigned int i
= 0; i
< num
; i
++)
3244 direct_calls
[i
] = NULL
;
3248 cgraph_edge
*first_call
= NULL
;
3249 cgraph_edge
*prev_call
= NULL
;
3251 for (cgraph_edge
*direct
= node
->callees
; direct
;
3252 direct
= direct
->next_callee
)
3253 if (direct
->call_stmt
== stmt
&& direct
->lto_stmt_uid
== lto_stmt_uid
)
3256 first_call
= direct
;
3257 if (prev_call
&& direct
!= prev_call
->next_callee
)
3259 error ("speculative edges are not adjacent");
3263 if (!direct
->speculative
)
3265 error ("direct call to %s in speculative call sequence has no "
3266 "speculative flag", direct
->callee
->dump_name ());
3269 if (direct
->speculative_id
>= num
)
3271 error ("direct call to %s in speculative call sequence has "
3272 "speculative_id %i out of range",
3273 direct
->callee
->dump_name (), direct
->speculative_id
);
3276 if (direct_calls
[direct
->speculative_id
])
3278 error ("duplicate direct call to %s in speculative call sequence "
3279 "with speculative_id %i",
3280 direct
->callee
->dump_name (), direct
->speculative_id
);
3283 direct_calls
[direct
->speculative_id
] = direct
;
3286 if (first_call
->call_stmt
3287 && first_call
!= node
->get_edge (first_call
->call_stmt
))
3289 error ("call stmt hash does not point to first direct edge of "
3290 "speculative call sequence");
3295 for (int i
= 0; node
->iterate_reference (i
, ref
); i
++)
3296 if (ref
->speculative
3297 && ref
->stmt
== stmt
&& ref
->lto_stmt_uid
== lto_stmt_uid
)
3299 if (ref
->speculative_id
>= num
)
3301 error ("direct call to %s in speculative call sequence has "
3302 "speculative_id %i out of range",
3303 ref
->referred
->dump_name (), ref
->speculative_id
);
3306 if (refs
[ref
->speculative_id
])
3308 error ("duplicate reference %s in speculative call sequence "
3309 "with speculative_id %i",
3310 ref
->referred
->dump_name (), ref
->speculative_id
);
3313 refs
[ref
->speculative_id
] = ref
;
3316 int num_targets
= 0;
3317 for (unsigned int i
= 0 ; i
< num
; i
++)
3319 if (refs
[i
] && !direct_calls
[i
])
3321 error ("missing direct call for speculation %i", i
);
3324 if (!refs
[i
] && direct_calls
[i
])
3326 error ("missing ref for speculation %i", i
);
3329 if (refs
[i
] != NULL
)
3333 if (num_targets
!= indirect
->num_speculative_call_targets_p ())
3335 error ("number of speculative targets %i mismatched with "
3336 "num_speculative_call_targets %i",
3338 indirect
->num_speculative_call_targets_p ());
3344 /* Verify cgraph nodes of given cgraph node. */
3346 cgraph_node::verify_node (void)
3349 function
*this_cfun
= DECL_STRUCT_FUNCTION (decl
);
3350 basic_block this_block
;
3351 gimple_stmt_iterator gsi
;
3352 bool error_found
= false;
3354 ipa_ref
*ref
= NULL
;
3359 timevar_push (TV_CGRAPH_VERIFY
);
3360 error_found
|= verify_base ();
3361 for (e
= callees
; e
; e
= e
->next_callee
)
3364 error ("aux field set for edge %s->%s",
3365 identifier_to_locale (e
->caller
->name ()),
3366 identifier_to_locale (e
->callee
->name ()));
3369 if (!count
.verify ())
3371 error ("cgraph count invalid");
3374 if (inlined_to
&& same_comdat_group
)
3376 error ("inline clone in same comdat group list");
3379 if (inlined_to
&& !count
.compatible_p (inlined_to
->count
))
3381 error ("inline clone count is not compatible");
3383 inlined_to
->count
.debug ();
3386 if (tp_first_run
< 0)
3388 error ("tp_first_run must be non-negative");
3391 if (!definition
&& !in_other_partition
&& local
)
3393 error ("local symbols must be defined");
3396 if (inlined_to
&& externally_visible
)
3398 error ("externally visible inline clone");
3401 if (inlined_to
&& address_taken
)
3403 error ("inline clone with address taken");
3406 if (inlined_to
&& force_output
)
3408 error ("inline clone is forced to output");
3411 if (symtab
->state
!= LTO_STREAMING
)
3413 if (calls_comdat_local
&& !same_comdat_group
)
3415 error ("calls_comdat_local is set outside of a comdat group");
3418 if (!inlined_to
&& calls_comdat_local
!= check_calls_comdat_local_p ())
3420 error ("invalid calls_comdat_local flag");
3424 if (DECL_IS_MALLOC (decl
)
3425 && !POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (decl
))))
3427 error ("malloc attribute should be used for a function that "
3428 "returns a pointer");
3431 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
3435 error ("aux field set for indirect edge from %s",
3436 identifier_to_locale (e
->caller
->name ()));
3439 if (!e
->count
.compatible_p (count
))
3441 error ("edge count is not compatible with function count");
3446 if (!e
->indirect_unknown_callee
3447 || !e
->indirect_info
)
3449 error ("An indirect edge from %s is not marked as indirect or has "
3450 "associated indirect_info, the corresponding statement is: ",
3451 identifier_to_locale (e
->caller
->name ()));
3452 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3455 if (e
->call_stmt
&& e
->lto_stmt_uid
)
3457 error ("edge has both call_stmt and lto_stmt_uid set");
3461 bool check_comdat
= comdat_local_p ();
3462 for (e
= callers
; e
; e
= e
->next_caller
)
3464 if (e
->verify_count ())
3467 && !in_same_comdat_group_p (e
->caller
))
3469 error ("comdat-local function called by %s outside its comdat",
3470 identifier_to_locale (e
->caller
->name ()));
3473 if (!e
->inline_failed
)
3476 != (e
->caller
->inlined_to
3477 ? e
->caller
->inlined_to
: e
->caller
))
3479 error ("inlined_to pointer is wrong");
3482 if (callers
->next_caller
)
3484 error ("multiple inline callers");
3491 error ("inlined_to pointer set for noninline callers");
3495 for (e
= callees
; e
; e
= e
->next_callee
)
3497 if (e
->verify_count ())
3499 if (!e
->count
.compatible_p (count
))
3501 error ("edge count is not compatible with function count");
3506 if (gimple_has_body_p (e
->caller
->decl
)
3507 && !e
->caller
->inlined_to
3509 /* Optimized out calls are redirected to __builtin_unreachable. */
3510 && (e
->count
.nonzero_p ()
3511 || ! e
->callee
->decl
3512 || !fndecl_built_in_p (e
->callee
->decl
, BUILT_IN_UNREACHABLE
))
3514 == ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (decl
))->count
3515 && (!e
->count
.ipa_p ()
3516 && e
->count
.differs_from_p (gimple_bb (e
->call_stmt
)->count
)))
3518 error ("caller edge count does not match BB count");
3519 fprintf (stderr
, "edge count: ");
3520 e
->count
.dump (stderr
);
3521 fprintf (stderr
, "\n bb count: ");
3522 gimple_bb (e
->call_stmt
)->count
.dump (stderr
);
3523 fprintf (stderr
, "\n");
3526 if (e
->call_stmt
&& e
->lto_stmt_uid
)
3528 error ("edge has both call_stmt and lto_stmt_uid set");
3532 && verify_speculative_call (e
->caller
, e
->call_stmt
, e
->lto_stmt_uid
,
3536 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
3538 if (e
->verify_count ())
3540 if (gimple_has_body_p (e
->caller
->decl
)
3541 && !e
->caller
->inlined_to
3543 && e
->count
.ipa_p ()
3545 == ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (decl
))->count
3546 && (!e
->count
.ipa_p ()
3547 && e
->count
.differs_from_p (gimple_bb (e
->call_stmt
)->count
)))
3549 error ("indirect call count does not match BB count");
3550 fprintf (stderr
, "edge count: ");
3551 e
->count
.dump (stderr
);
3552 fprintf (stderr
, "\n bb count: ");
3553 gimple_bb (e
->call_stmt
)->count
.dump (stderr
);
3554 fprintf (stderr
, "\n");
3558 && verify_speculative_call (e
->caller
, e
->call_stmt
, e
->lto_stmt_uid
,
3562 for (i
= 0; iterate_reference (i
, ref
); i
++)
3564 if (ref
->stmt
&& ref
->lto_stmt_uid
)
3566 error ("reference has both stmt and lto_stmt_uid set");
3569 if (ref
->speculative
3570 && verify_speculative_call (this, ref
->stmt
,
3571 ref
->lto_stmt_uid
, NULL
))
3575 if (!callers
&& inlined_to
)
3577 error ("inlined_to pointer is set but no predecessors found");
3580 if (inlined_to
== this)
3582 error ("inlined_to pointer refers to itself");
3588 cgraph_node
*first_clone
= clone_of
->clones
;
3589 if (first_clone
!= this)
3591 if (prev_sibling_clone
->clone_of
!= clone_of
)
3593 error ("cgraph_node has wrong clone_of");
3601 for (n
= clones
; n
; n
= n
->next_sibling_clone
)
3602 if (n
->clone_of
!= this)
3606 error ("cgraph_node has wrong clone list");
3610 if ((prev_sibling_clone
|| next_sibling_clone
) && !clone_of
)
3612 error ("cgraph_node is in clone list but it is not clone");
3615 if (!prev_sibling_clone
&& clone_of
&& clone_of
->clones
!= this)
3617 error ("cgraph_node has wrong prev_clone pointer");
3620 if (prev_sibling_clone
&& prev_sibling_clone
->next_sibling_clone
!= this)
3622 error ("double linked list of clones corrupted");
3626 if (analyzed
&& alias
)
3628 bool ref_found
= false;
3630 ipa_ref
*ref
= NULL
;
3634 error ("Alias has call edges");
3637 for (i
= 0; iterate_reference (i
, ref
); i
++)
3638 if (ref
->use
!= IPA_REF_ALIAS
)
3640 error ("Alias has non-alias reference");
3645 error ("Alias has more than one alias reference");
3652 error ("Analyzed alias has no reference");
3657 if (analyzed
&& thunk
)
3661 error ("No edge out of thunk node");
3664 else if (callees
->next_callee
)
3666 error ("More than one edge out of thunk node");
3669 if (gimple_has_body_p (decl
) && !inlined_to
)
3671 error ("Thunk is not supposed to have body");
3675 else if (analyzed
&& gimple_has_body_p (decl
)
3676 && !TREE_ASM_WRITTEN (decl
)
3677 && (!DECL_EXTERNAL (decl
) || inlined_to
)
3682 hash_set
<gimple
*> stmts
;
3684 /* Reach the trees by walking over the CFG, and note the
3685 enclosing basic-blocks in the call edges. */
3686 FOR_EACH_BB_FN (this_block
, this_cfun
)
3688 for (gsi
= gsi_start_phis (this_block
);
3689 !gsi_end_p (gsi
); gsi_next (&gsi
))
3690 stmts
.add (gsi_stmt (gsi
));
3691 for (gsi
= gsi_start_bb (this_block
);
3695 gimple
*stmt
= gsi_stmt (gsi
);
3697 if (is_gimple_call (stmt
))
3699 cgraph_edge
*e
= get_edge (stmt
);
3700 tree decl
= gimple_call_fndecl (stmt
);
3705 error ("shared call_stmt:");
3706 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
3709 if (!e
->indirect_unknown_callee
)
3711 if (e
->verify_corresponds_to_fndecl (decl
))
3713 error ("edge points to wrong declaration:");
3714 debug_tree (e
->callee
->decl
);
3715 fprintf (stderr
," Instead of:");
3722 error ("an indirect edge with unknown callee "
3723 "corresponding to a call_stmt with "
3724 "a known declaration:");
3726 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3732 error ("missing callgraph edge for call stmt:");
3733 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
3739 for (i
= 0; iterate_reference (i
, ref
); i
++)
3740 if (ref
->stmt
&& !stmts
.contains (ref
->stmt
))
3742 error ("reference to dead statement");
3743 cgraph_debug_gimple_stmt (this_cfun
, ref
->stmt
);
3748 /* No CFG available?! */
3751 for (e
= callees
; e
; e
= e
->next_callee
)
3753 if (!e
->aux
&& !e
->speculative
)
3755 error ("edge %s->%s has no corresponding call_stmt",
3756 identifier_to_locale (e
->caller
->name ()),
3757 identifier_to_locale (e
->callee
->name ()));
3758 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3763 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
3765 if (!e
->aux
&& !e
->speculative
)
3767 error ("an indirect edge from %s has no corresponding call_stmt",
3768 identifier_to_locale (e
->caller
->name ()));
3769 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3776 if (nested_function_info
*info
= nested_function_info::get (this))
3778 if (info
->nested
!= NULL
)
3780 for (cgraph_node
*n
= info
->nested
; n
!= NULL
;
3781 n
= next_nested_function (n
))
3783 nested_function_info
*ninfo
= nested_function_info::get (n
);
3784 if (ninfo
->origin
== NULL
)
3786 error ("missing origin for a node in a nested list");
3789 else if (ninfo
->origin
!= this)
3791 error ("origin points to a different parent");
3797 if (info
->next_nested
!= NULL
&& info
->origin
== NULL
)
3799 error ("missing origin for a node in a nested list");
3807 internal_error ("verify_cgraph_node failed");
3809 timevar_pop (TV_CGRAPH_VERIFY
);
3812 /* Verify whole cgraph structure. */
3814 cgraph_node::verify_cgraph_nodes (void)
3821 FOR_EACH_FUNCTION (node
)
3826 # pragma GCC diagnostic pop
3829 /* Walk the alias chain to return the function cgraph_node is alias of.
3830 Walk through thunks, too.
3831 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3832 When REF is non-NULL, assume that reference happens in symbol REF
3833 when determining the availability. */
3836 cgraph_node::function_symbol (enum availability
*availability
,
3837 struct symtab_node
*ref
)
3839 cgraph_node
*node
= ultimate_alias_target (availability
, ref
);
3843 enum availability a
;
3846 node
= node
->callees
->callee
;
3847 node
= node
->ultimate_alias_target (availability
? &a
: NULL
, ref
);
3848 if (availability
&& a
< *availability
)
3854 /* Walk the alias chain to return the function cgraph_node is alias of.
3855 Walk through non virtual thunks, too. Thus we return either a function
3856 or a virtual thunk node.
3857 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3858 When REF is non-NULL, assume that reference happens in symbol REF
3859 when determining the availability. */
3862 cgraph_node::function_or_virtual_thunk_symbol
3863 (enum availability
*availability
,
3864 struct symtab_node
*ref
)
3866 cgraph_node
*node
= ultimate_alias_target (availability
, ref
);
3868 while (node
->thunk
&& !thunk_info::get (node
)->virtual_offset_p
)
3870 enum availability a
;
3873 node
= node
->callees
->callee
;
3874 node
= node
->ultimate_alias_target (availability
? &a
: NULL
, ref
);
3875 if (availability
&& a
< *availability
)
3881 /* When doing LTO, read cgraph_node's body from disk if it is not already
3882 present. Also perform any necessary clone materializations. */
3885 cgraph_node::get_untransformed_body ()
3887 lto_file_decl_data
*file_data
;
3888 const char *data
, *name
;
3890 tree decl
= this->decl
;
3892 /* See if there is clone to be materialized.
3893 (inline clones does not need materialization, but we can be seeing
3894 an inline clone of real clone). */
3895 cgraph_node
*p
= this;
3896 for (cgraph_node
*c
= clone_of
; c
; c
= c
->clone_of
)
3898 if (c
->decl
!= decl
)
3899 p
->materialize_clone ();
3903 /* Check if body is already there. Either we have gimple body or
3904 the function is thunk and in that case we set DECL_ARGUMENTS. */
3905 if (DECL_ARGUMENTS (decl
) || gimple_has_body_p (decl
))
3908 gcc_assert (in_lto_p
&& !DECL_RESULT (decl
));
3910 timevar_push (TV_IPA_LTO_GIMPLE_IN
);
3912 file_data
= lto_file_data
;
3913 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
3915 /* We may have renamed the declaration, e.g., a static function. */
3916 name
= lto_get_decl_name_mapping (file_data
, name
);
3917 struct lto_in_decl_state
*decl_state
3918 = lto_get_function_in_decl_state (file_data
, decl
);
3920 cgraph_node
*origin
= this;
3921 while (origin
->clone_of
)
3922 origin
= origin
->clone_of
;
3924 int stream_order
= origin
->order
- file_data
->order_base
;
3925 data
= lto_get_section_data (file_data
, LTO_section_function_body
,
3926 name
, stream_order
, &len
,
3927 decl_state
->compressed
);
3929 fatal_error (input_location
, "%s: section %s.%d is missing",
3930 file_data
->file_name
, name
, stream_order
);
3932 gcc_assert (DECL_STRUCT_FUNCTION (decl
) == NULL
);
3935 fprintf (stderr
, " in:%s", IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
3936 lto_input_function_body (file_data
, this, data
);
3937 lto_stats
.num_function_bodies
++;
3938 lto_free_section_data (file_data
, LTO_section_function_body
, name
,
3939 data
, len
, decl_state
->compressed
);
3940 lto_free_function_in_decl_state_for_node (this);
3941 /* Keep lto file data so ipa-inline-analysis knows about cross module
3944 timevar_pop (TV_IPA_LTO_GIMPLE_IN
);
3949 /* Prepare function body. When doing LTO, read cgraph_node's body from disk
3950 if it is not already present. When some IPA transformations are scheduled,
3954 cgraph_node::get_body (void)
3958 updated
= get_untransformed_body ();
3960 /* Getting transformed body makes no sense for inline clones;
3961 we should never use this on real clones because they are materialized
3963 TODO: Materializing clones here will likely lead to smaller LTRANS
3965 gcc_assert (!inlined_to
&& !clone_of
);
3966 if (ipa_transforms_to_apply
.exists ())
3968 opt_pass
*saved_current_pass
= current_pass
;
3969 FILE *saved_dump_file
= dump_file
;
3970 const char *saved_dump_file_name
= dump_file_name
;
3971 dump_flags_t saved_dump_flags
= dump_flags
;
3972 dump_file_name
= NULL
;
3973 set_dump_file (NULL
);
3975 push_cfun (DECL_STRUCT_FUNCTION (decl
));
3977 update_ssa (TODO_update_ssa_only_virtuals
);
3978 execute_all_ipa_transforms (true);
3979 cgraph_edge::rebuild_edges ();
3980 free_dominance_info (CDI_DOMINATORS
);
3981 free_dominance_info (CDI_POST_DOMINATORS
);
3985 current_pass
= saved_current_pass
;
3986 set_dump_file (saved_dump_file
);
3987 dump_file_name
= saved_dump_file_name
;
3988 dump_flags
= saved_dump_flags
;
3993 /* Return the DECL_STRUCT_FUNCTION of the function. */
3996 cgraph_node::get_fun () const
3998 const cgraph_node
*node
= this;
3999 struct function
*fun
= DECL_STRUCT_FUNCTION (node
->decl
);
4001 while (!fun
&& node
->clone_of
)
4003 node
= node
->clone_of
;
4004 fun
= DECL_STRUCT_FUNCTION (node
->decl
);
4010 /* Reset all state within cgraph.c so that we can rerun the compiler
4011 within the same process. For use by toplev::finalize. */
4014 cgraph_c_finalize (void)
4016 nested_function_info::release ();
4017 thunk_info::release ();
4018 clone_info::release ();
4021 x_cgraph_nodes_queue
= NULL
;
4023 cgraph_fnver_htab
= NULL
;
4024 version_info_node
= NULL
;
4027 /* A worker for call_for_symbol_and_aliases. */
4030 cgraph_node::call_for_symbol_and_aliases_1 (bool (*callback
) (cgraph_node
*,
4033 bool include_overwritable
)
4036 FOR_EACH_ALIAS (this, ref
)
4038 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
4039 if (include_overwritable
4040 || alias
->get_availability () > AVAIL_INTERPOSABLE
)
4041 if (alias
->call_for_symbol_and_aliases (callback
, data
,
4042 include_overwritable
))
4048 /* Return true if NODE has thunk. */
4051 cgraph_node::has_thunk_p (cgraph_node
*node
, void *)
4053 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
4054 if (e
->caller
->thunk
)
4059 /* Expected frequency of executions within the function. */
4062 cgraph_edge::sreal_frequency ()
4064 return count
.to_sreal_scale (caller
->inlined_to
4065 ? caller
->inlined_to
->count
4070 /* During LTO stream in this can be used to check whether call can possibly
4071 be internal to the current translation unit. */
4074 cgraph_edge::possibly_call_in_translation_unit_p (void)
4076 gcc_checking_assert (in_lto_p
&& caller
->prevailing_p ());
4078 /* While incremental linking we may end up getting function body later. */
4079 if (flag_incremental_link
== INCREMENTAL_LINK_LTO
)
4082 /* We may be smarter here and avoid streaming in indirect calls we can't
4083 track, but that would require arranging streaming the indirect call
4088 /* If callee is local to the original translation unit, it will be
4090 if (!TREE_PUBLIC (callee
->decl
) && !DECL_EXTERNAL (callee
->decl
))
4093 /* Otherwise we need to lookup prevailing symbol (symbol table is not merged,
4094 yet) and see if it is a definition. In fact we may also resolve aliases,
4095 but that is probably not too important. */
4096 symtab_node
*node
= callee
;
4097 for (int n
= 10; node
->previous_sharing_asm_name
&& n
; n
--)
4098 node
= node
->previous_sharing_asm_name
;
4099 if (node
->previous_sharing_asm_name
)
4100 node
= symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (callee
->decl
));
4101 gcc_assert (TREE_PUBLIC (node
->decl
));
4102 return node
->get_availability () >= AVAIL_INTERPOSABLE
;
4105 /* Return num_speculative_targets of this edge. */
4108 cgraph_edge::num_speculative_call_targets_p (void)
4110 return indirect_info
? indirect_info
->num_speculative_call_targets
: 0;
4113 /* Check if function calls comdat local. This is used to recompute
4114 calls_comdat_local flag after function transformations. */
4116 cgraph_node::check_calls_comdat_local_p ()
4118 for (cgraph_edge
*e
= callees
; e
; e
= e
->next_callee
)
4119 if (e
->inline_failed
4120 ? e
->callee
->comdat_local_p ()
4121 : e
->callee
->check_calls_comdat_local_p ())
4126 /* Return true if this node represents a former, i.e. an expanded, thunk. */
4129 cgraph_node::former_thunk_p (void)
4133 thunk_info
*i
= thunk_info::get (this);
4136 gcc_checking_assert (i
->fixed_offset
|| i
->virtual_offset_p
4137 || i
->indirect_offset
);
4141 /* A stashed copy of "symtab" for use by selftest::symbol_table_test.
4142 This needs to be a global so that it can be a GC root, and thus
4143 prevent the stashed copy from being garbage-collected if the GC runs
4144 during a symbol_table_test. */
4146 symbol_table
*saved_symtab
;
4150 namespace selftest
{
4152 /* class selftest::symbol_table_test. */
4154 /* Constructor. Store the old value of symtab, and create a new one. */
4156 symbol_table_test::symbol_table_test ()
4158 gcc_assert (saved_symtab
== NULL
);
4159 saved_symtab
= symtab
;
4160 symtab
= new (ggc_alloc
<symbol_table
> ()) symbol_table ();
4163 /* Destructor. Restore the old value of symtab. */
4165 symbol_table_test::~symbol_table_test ()
4167 gcc_assert (saved_symtab
!= NULL
);
4168 symtab
= saved_symtab
;
4169 saved_symtab
= NULL
;
4172 /* Verify that symbol_table_test works. */
4175 test_symbol_table_test ()
4177 /* Simulate running two selftests involving symbol tables. */
4178 for (int i
= 0; i
< 2; i
++)
4180 symbol_table_test stt
;
4181 tree test_decl
= build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
,
4182 get_identifier ("test_decl"),
4183 build_function_type_list (void_type_node
,
4185 cgraph_node
*node
= cgraph_node::get_create (test_decl
);
4188 /* Verify that the node has order 0 on both iterations,
4189 and thus that nodes have predictable dump names in selftests. */
4190 ASSERT_EQ (node
->order
, 0);
4191 ASSERT_STREQ (node
->dump_name (), "test_decl/0");
4195 /* Run all of the selftests within this file. */
4200 test_symbol_table_test ();
4203 } // namespace selftest
4205 #endif /* CHECKING_P */
4207 #include "gt-cgraph.h"