1 /* Callgraph handling code.
2 Copyright (C) 2003-2021 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 cgraph_node
*new_direct_callee
= NULL
;
793 if ((e
->indirect_unknown_callee
|| e
->speculative
)
794 && (decl
= gimple_call_fndecl (new_stmt
)))
796 /* Constant propagation and especially inlining can turn an indirect call
797 into a direct one. */
798 new_direct_callee
= cgraph_node::get (decl
);
799 gcc_checking_assert (new_direct_callee
);
802 /* Speculative edges has three component, update all of them
804 if (update_speculative
&& e
->speculative
805 /* If we are about to resolve the speculation by calling make_direct
806 below, do not bother going over all the speculative edges now. */
807 && !new_direct_callee
)
809 cgraph_edge
*direct
, *indirect
, *next
;
811 bool e_indirect
= e
->indirect_unknown_callee
;
814 direct
= e
->first_speculative_call_target ();
815 indirect
= e
->speculative_call_indirect_edge ();
817 gcall
*old_stmt
= direct
->call_stmt
;
818 for (cgraph_edge
*d
= direct
; d
; d
= next
)
820 next
= d
->next_speculative_call_target ();
821 cgraph_edge
*d2
= set_call_stmt (d
, new_stmt
, false);
822 gcc_assert (d2
== d
);
825 gcc_checking_assert (indirect
->num_speculative_call_targets_p () == n
);
826 for (unsigned int i
= 0; e
->caller
->iterate_reference (i
, ref
); i
++)
827 if (ref
->speculative
&& ref
->stmt
== old_stmt
)
829 ref
->stmt
= new_stmt
;
833 indirect
= set_call_stmt (indirect
, new_stmt
, false);
834 return e_indirect
? indirect
: direct
;
837 if (new_direct_callee
)
838 e
= make_direct (e
, new_direct_callee
);
840 /* Only direct speculative edges go to call_site_hash. */
841 if (e
->caller
->call_site_hash
842 && (!e
->speculative
|| !e
->indirect_unknown_callee
)
843 /* It is possible that edge was previously speculative. In this case
844 we have different value in call stmt hash which needs preserving. */
845 && e
->caller
->get_edge (e
->call_stmt
) == e
)
846 e
->caller
->call_site_hash
->remove_elt_with_hash
847 (e
->call_stmt
, cgraph_edge_hasher::hash (e
->call_stmt
));
849 e
->call_stmt
= new_stmt
;
851 function
*fun
= DECL_STRUCT_FUNCTION (e
->caller
->decl
);
852 e
->can_throw_external
= stmt_can_throw_external (fun
, new_stmt
);
853 /* Update call stite hash. For speculative calls we only record the first
855 if (e
->caller
->call_site_hash
858 && (!e
->prev_callee
|| !e
->prev_callee
->speculative
859 || e
->prev_callee
->call_stmt
!= e
->call_stmt
))
860 || (e
->speculative
&& !e
->callee
)))
861 cgraph_add_edge_to_call_site_hash (e
);
865 /* Allocate a cgraph_edge structure and fill it with data according to the
866 parameters of which only CALLEE can be NULL (when creating an indirect call
867 edge). CLONING_P should be set if properties that are copied from an
868 original edge should not be calculated. */
871 symbol_table::create_edge (cgraph_node
*caller
, cgraph_node
*callee
,
872 gcall
*call_stmt
, profile_count count
,
873 bool indir_unknown_callee
, bool cloning_p
)
877 /* LTO does not actually have access to the call_stmt since these
878 have not been loaded yet. */
881 /* This is a rather expensive check possibly triggering
882 construction of call stmt hashtable. */
884 gcc_checking_assert (!(e
= caller
->get_edge (call_stmt
))
887 gcc_assert (is_gimple_call (call_stmt
));
890 edge
= ggc_alloc
<cgraph_edge
> ();
891 edge
->m_summary_id
= -1;
894 gcc_assert (++edges_max_uid
!= 0);
895 edge
->m_uid
= edges_max_uid
;
897 edge
->caller
= caller
;
898 edge
->callee
= callee
;
899 edge
->prev_caller
= NULL
;
900 edge
->next_caller
= NULL
;
901 edge
->prev_callee
= NULL
;
902 edge
->next_callee
= NULL
;
903 edge
->lto_stmt_uid
= 0;
904 edge
->speculative_id
= 0;
907 edge
->call_stmt
= call_stmt
;
908 edge
->indirect_info
= NULL
;
909 edge
->indirect_inlining_edge
= 0;
910 edge
->speculative
= false;
911 edge
->indirect_unknown_callee
= indir_unknown_callee
;
912 if (call_stmt
&& caller
->call_site_hash
)
913 cgraph_add_edge_to_call_site_hash (edge
);
918 edge
->can_throw_external
919 = call_stmt
? stmt_can_throw_external (DECL_STRUCT_FUNCTION (caller
->decl
),
921 edge
->inline_failed
= CIF_FUNCTION_NOT_CONSIDERED
;
922 edge
->call_stmt_cannot_inline_p
= false;
924 if (opt_for_fn (edge
->caller
->decl
, flag_devirtualize
)
925 && call_stmt
&& DECL_STRUCT_FUNCTION (caller
->decl
))
926 edge
->in_polymorphic_cdtor
927 = decl_maybe_in_construction_p (NULL
, NULL
, call_stmt
,
930 edge
->in_polymorphic_cdtor
= caller
->thunk
;
932 caller
->calls_declare_variant_alt
|= callee
->declare_variant_alt
;
934 if (callee
&& symtab
->state
!= LTO_STREAMING
935 && edge
->callee
->comdat_local_p ())
936 edge
->caller
->calls_comdat_local
= true;
941 /* Create edge from a given function to CALLEE in the cgraph. CLONING_P should
942 be set if properties that are copied from an original edge should not be
946 cgraph_node::create_edge (cgraph_node
*callee
,
947 gcall
*call_stmt
, profile_count count
, bool cloning_p
)
949 cgraph_edge
*edge
= symtab
->create_edge (this, callee
, call_stmt
, count
,
953 initialize_inline_failed (edge
);
955 edge
->next_caller
= callee
->callers
;
957 callee
->callers
->prev_caller
= edge
;
958 edge
->next_callee
= callees
;
960 callees
->prev_callee
= edge
;
962 callee
->callers
= edge
;
967 /* Allocate cgraph_indirect_call_info and set its fields to default values. */
969 cgraph_indirect_call_info
*
970 cgraph_allocate_init_indirect_info (void)
972 cgraph_indirect_call_info
*ii
;
974 ii
= ggc_cleared_alloc
<cgraph_indirect_call_info
> ();
975 ii
->param_index
= -1;
979 /* Create an indirect edge with a yet-undetermined callee where the call
980 statement destination is a formal parameter of the caller with index
981 PARAM_INDEX. CLONING_P should be set if properties that are copied from an
982 original edge should not be calculated and indirect_info structure should
983 not be calculated. */
986 cgraph_node::create_indirect_edge (gcall
*call_stmt
, int ecf_flags
,
990 cgraph_edge
*edge
= symtab
->create_edge (this, NULL
, call_stmt
, count
, true,
995 initialize_inline_failed (edge
);
997 edge
->indirect_info
= cgraph_allocate_init_indirect_info ();
998 edge
->indirect_info
->ecf_flags
= ecf_flags
;
999 edge
->indirect_info
->vptr_changed
= true;
1001 /* Record polymorphic call info. */
1004 && (target
= gimple_call_fn (call_stmt
))
1005 && virtual_method_call_p (target
))
1007 ipa_polymorphic_call_context
context (decl
, target
, call_stmt
);
1009 /* Only record types can have virtual calls. */
1010 edge
->indirect_info
->polymorphic
= true;
1011 edge
->indirect_info
->param_index
= -1;
1012 edge
->indirect_info
->otr_token
1013 = tree_to_uhwi (OBJ_TYPE_REF_TOKEN (target
));
1014 edge
->indirect_info
->otr_type
= obj_type_ref_class (target
);
1015 gcc_assert (TREE_CODE (edge
->indirect_info
->otr_type
) == RECORD_TYPE
);
1016 edge
->indirect_info
->context
= context
;
1019 edge
->next_callee
= indirect_calls
;
1021 indirect_calls
->prev_callee
= edge
;
1022 indirect_calls
= edge
;
1027 /* Remove the edge from the list of the callees of the caller. */
1030 cgraph_edge::remove_caller (void)
1033 prev_callee
->next_callee
= next_callee
;
1035 next_callee
->prev_callee
= prev_callee
;
1038 if (indirect_unknown_callee
)
1039 caller
->indirect_calls
= next_callee
;
1041 caller
->callees
= next_callee
;
1043 if (caller
->call_site_hash
1044 && this == caller
->get_edge (call_stmt
))
1045 caller
->call_site_hash
->remove_elt_with_hash
1046 (call_stmt
, cgraph_edge_hasher::hash (call_stmt
));
1049 /* Put the edge onto the free list. */
1052 symbol_table::free_edge (cgraph_edge
*e
)
1055 if (e
->m_summary_id
!= -1)
1056 edge_released_summary_ids
.safe_push (e
->m_summary_id
);
1058 if (e
->indirect_info
)
1059 ggc_free (e
->indirect_info
);
1063 /* Remove the edge in the cgraph. */
1066 cgraph_edge::remove (cgraph_edge
*edge
)
1068 /* Call all edge removal hooks. */
1069 symtab
->call_edge_removal_hooks (edge
);
1071 if (!edge
->indirect_unknown_callee
)
1072 /* Remove from callers list of the callee. */
1073 edge
->remove_callee ();
1075 /* Remove from callees list of the callers. */
1076 edge
->remove_caller ();
1078 /* Put the edge onto the free list. */
1079 symtab
->free_edge (edge
);
1082 /* Turn edge into speculative call calling N2. Update
1083 the profile so the direct call is taken COUNT times
1086 At clone materialization time, the indirect call E will
1089 if (call_dest == N2)
1094 At this time the function just creates the direct call,
1095 the reference representing the if conditional and attaches
1096 them all to the original indirect call statement.
1098 speculative_id is used to link direct calls with their corresponding
1099 IPA_REF_ADDR references when representing speculative calls.
1101 Return direct edge created. */
1104 cgraph_edge::make_speculative (cgraph_node
*n2
, profile_count direct_count
,
1105 unsigned int speculative_id
)
1107 cgraph_node
*n
= caller
;
1108 ipa_ref
*ref
= NULL
;
1112 fprintf (dump_file
, "Indirect call -> speculative call %s => %s\n",
1113 n
->dump_name (), n2
->dump_name ());
1115 e2
= n
->create_edge (n2
, call_stmt
, direct_count
);
1116 initialize_inline_failed (e2
);
1117 e2
->speculative
= true;
1118 if (TREE_NOTHROW (n2
->decl
))
1119 e2
->can_throw_external
= false;
1121 e2
->can_throw_external
= can_throw_external
;
1122 e2
->lto_stmt_uid
= lto_stmt_uid
;
1123 e2
->speculative_id
= speculative_id
;
1124 e2
->in_polymorphic_cdtor
= in_polymorphic_cdtor
;
1125 indirect_info
->num_speculative_call_targets
++;
1127 symtab
->call_edge_duplication_hooks (this, e2
);
1128 ref
= n
->create_reference (n2
, IPA_REF_ADDR
, call_stmt
);
1129 ref
->lto_stmt_uid
= lto_stmt_uid
;
1130 ref
->speculative_id
= speculative_id
;
1131 ref
->speculative
= speculative
;
1132 n2
->mark_address_taken ();
1136 /* Speculative call consists of an indirect edge and one or more
1137 direct edge+ref pairs.
1139 Given an edge which is part of speculative call, return the first
1140 direct call edge in the speculative call sequence. */
1143 cgraph_edge::first_speculative_call_target ()
1145 cgraph_edge
*e
= this;
1147 gcc_checking_assert (e
->speculative
);
1150 while (e
->prev_callee
&& e
->prev_callee
->speculative
1151 && e
->prev_callee
->call_stmt
== e
->call_stmt
1152 && e
->prev_callee
->lto_stmt_uid
== e
->lto_stmt_uid
)
1156 /* Call stmt site hash always points to the first target of the
1157 speculative call sequence. */
1159 return e
->caller
->get_edge (e
->call_stmt
);
1160 for (cgraph_edge
*e2
= e
->caller
->callees
; true; e2
= e2
->next_callee
)
1162 && e
->call_stmt
== e2
->call_stmt
1163 && e
->lto_stmt_uid
== e2
->lto_stmt_uid
)
1167 /* We always maintain first direct edge in the call site hash, if one
1168 exists. E is going to be removed. See if it is first one and update
1169 hash accordingly. INDIRECT is the indirect edge of speculative call.
1170 We assume that INDIRECT->num_speculative_call_targets_p () is already
1171 updated for removal of E. */
1173 update_call_stmt_hash_for_removing_direct_edge (cgraph_edge
*e
,
1174 cgraph_edge
*indirect
)
1176 if (e
->caller
->call_site_hash
)
1178 if (e
->caller
->get_edge (e
->call_stmt
) != e
)
1180 else if (!indirect
->num_speculative_call_targets_p ())
1181 cgraph_update_edge_in_call_site_hash (indirect
);
1184 gcc_checking_assert (e
->next_callee
&& e
->next_callee
->speculative
1185 && e
->next_callee
->call_stmt
== e
->call_stmt
);
1186 cgraph_update_edge_in_call_site_hash (e
->next_callee
);
1191 /* Speculative call EDGE turned out to be direct call to CALLEE_DECL. Remove
1192 the speculative call sequence and return edge representing the call, the
1193 original EDGE can be removed and deallocated. Return the edge that now
1194 represents the call.
1196 For "speculative" indirect call that contains multiple "speculative"
1197 targets (i.e. edge->indirect_info->num_speculative_call_targets > 1),
1198 decrease the count and only remove current direct edge.
1200 If no speculative direct call left to the speculative indirect call, remove
1201 the speculative of both the indirect call and corresponding direct edge.
1203 It is up to caller to iteratively resolve each "speculative" direct call and
1204 redirect the call as appropriate. */
1207 cgraph_edge::resolve_speculation (cgraph_edge
*edge
, tree callee_decl
)
1212 gcc_assert (edge
->speculative
&& (!callee_decl
|| edge
->callee
));
1214 e2
= edge
->first_speculative_call_target ();
1217 ref
= e2
->speculative_call_target_ref ();
1218 edge
= edge
->speculative_call_indirect_edge ();
1220 || !ref
->referred
->semantically_equivalent_p
1221 (symtab_node::get (callee_decl
)))
1227 fprintf (dump_file
, "Speculative indirect call %s => %s has "
1228 "turned out to have contradicting known target ",
1229 edge
->caller
->dump_name (),
1230 e2
->callee
->dump_name ());
1231 print_generic_expr (dump_file
, callee_decl
);
1232 fprintf (dump_file
, "\n");
1236 fprintf (dump_file
, "Removing speculative call %s => %s\n",
1237 edge
->caller
->dump_name (),
1238 e2
->callee
->dump_name ());
1244 cgraph_edge
*tmp
= edge
;
1246 fprintf (dump_file
, "Speculative call turned into direct call.\n");
1249 /* FIXME: If EDGE is inlined, we should scale up the frequencies
1250 and counts in the functions inlined through it. */
1252 edge
->count
+= e2
->count
;
1253 if (edge
->num_speculative_call_targets_p ())
1255 /* The indirect edge has multiple speculative targets, don't remove
1256 speculative until all related direct edges are resolved. */
1257 edge
->indirect_info
->num_speculative_call_targets
--;
1258 if (!edge
->indirect_info
->num_speculative_call_targets
)
1259 edge
->speculative
= false;
1262 edge
->speculative
= false;
1263 e2
->speculative
= false;
1264 update_call_stmt_hash_for_removing_direct_edge (e2
, edge
);
1265 ref
->remove_reference ();
1266 if (e2
->indirect_unknown_callee
|| e2
->inline_failed
)
1269 e2
->callee
->remove_symbol_and_inline_clones ();
1273 /* Return edge corresponding to speculative call to a given target.
1274 NULL if speculative call does not have one. */
1277 cgraph_edge::speculative_call_for_target (cgraph_node
*target
)
1279 for (cgraph_edge
*direct
= first_speculative_call_target ();
1281 direct
= direct
->next_speculative_call_target ())
1282 if (direct
->speculative_call_target_ref ()
1283 ->referred
->semantically_equivalent_p (target
))
1288 /* Make an indirect or speculative EDGE with an unknown callee an ordinary edge
1289 leading to CALLEE. Speculations can be resolved in the process and EDGE can
1290 be removed and deallocated. Return the edge that now represents the
1294 cgraph_edge::make_direct (cgraph_edge
*edge
, cgraph_node
*callee
)
1296 gcc_assert (edge
->indirect_unknown_callee
|| edge
->speculative
);
1298 /* If we are redirecting speculative call, make it non-speculative. */
1299 if (edge
->speculative
)
1301 cgraph_edge
*found
= NULL
;
1302 cgraph_edge
*direct
, *next
;
1304 edge
= edge
->speculative_call_indirect_edge ();
1306 /* Look all speculative targets and remove all but one corresponding
1307 to callee (if it exists). */
1308 for (direct
= edge
->first_speculative_call_target ();
1312 next
= direct
->next_speculative_call_target ();
1314 /* Compare ref not direct->callee. Direct edge is possibly
1315 inlined or redirected. */
1316 if (!direct
->speculative_call_target_ref ()
1317 ->referred
->semantically_equivalent_p (callee
))
1318 edge
= direct
->resolve_speculation (direct
, NULL
);
1321 gcc_checking_assert (!found
);
1326 /* On successful speculation just remove the indirect edge and
1327 return the pre existing direct edge.
1328 It is important to not remove it and redirect because the direct
1329 edge may be inlined or redirected. */
1332 cgraph_edge
*e2
= resolve_speculation (found
, callee
->decl
);
1333 gcc_checking_assert (!found
->speculative
&& e2
== found
);
1336 gcc_checking_assert (!edge
->speculative
);
1339 edge
->indirect_unknown_callee
= 0;
1340 ggc_free (edge
->indirect_info
);
1341 edge
->indirect_info
= NULL
;
1343 /* Get the edge out of the indirect edge list. */
1344 if (edge
->prev_callee
)
1345 edge
->prev_callee
->next_callee
= edge
->next_callee
;
1346 if (edge
->next_callee
)
1347 edge
->next_callee
->prev_callee
= edge
->prev_callee
;
1348 if (!edge
->prev_callee
)
1349 edge
->caller
->indirect_calls
= edge
->next_callee
;
1351 /* Put it into the normal callee list */
1352 edge
->prev_callee
= NULL
;
1353 edge
->next_callee
= edge
->caller
->callees
;
1354 if (edge
->caller
->callees
)
1355 edge
->caller
->callees
->prev_callee
= edge
;
1356 edge
->caller
->callees
= edge
;
1358 /* Insert to callers list of the new callee. */
1359 edge
->set_callee (callee
);
1361 /* We need to re-determine the inlining status of the edge. */
1362 initialize_inline_failed (edge
);
1366 /* Redirect callee of the edge to N. The function does not update underlying
1370 cgraph_edge::redirect_callee (cgraph_node
*n
)
1372 bool loc
= callee
->comdat_local_p ();
1373 /* Remove from callers list of the current callee. */
1376 /* Insert to callers list of the new callee. */
1381 if (!loc
&& n
->comdat_local_p ())
1383 cgraph_node
*to
= caller
->inlined_to
? caller
->inlined_to
: caller
;
1384 to
->calls_comdat_local
= true;
1386 else if (loc
&& !n
->comdat_local_p ())
1388 cgraph_node
*to
= caller
->inlined_to
? caller
->inlined_to
: caller
;
1389 gcc_checking_assert (to
->calls_comdat_local
);
1390 to
->calls_comdat_local
= to
->check_calls_comdat_local_p ();
1394 /* If necessary, change the function declaration in the call statement
1395 associated with E so that it corresponds to the edge callee. Speculations
1396 can be resolved in the process and EDGE can be removed and deallocated.
1398 The edge could be one of speculative direct call generated from speculative
1399 indirect call. In this circumstance, decrease the speculative targets
1400 count (i.e. num_speculative_call_targets) and redirect call stmt to the
1401 corresponding i-th target. If no speculative direct call left to the
1402 speculative indirect call, remove "speculative" of the indirect call and
1403 also redirect stmt to it's final direct target.
1405 It is up to caller to iteratively transform each "speculative"
1406 direct call as appropriate. */
1409 cgraph_edge::redirect_call_stmt_to_callee (cgraph_edge
*e
)
1411 tree decl
= gimple_call_fndecl (e
->call_stmt
);
1413 gimple_stmt_iterator gsi
;
1417 /* If there already is an direct call (i.e. as a result of inliner's
1418 substitution), forget about speculating. */
1420 e
= make_direct (e
->speculative_call_indirect_edge (),
1421 cgraph_node::get (decl
));
1424 /* Be sure we redirect all speculative targets before poking
1425 abou tindirect edge. */
1426 gcc_checking_assert (e
->callee
);
1427 cgraph_edge
*indirect
= e
->speculative_call_indirect_edge ();
1431 /* Expand speculation into GIMPLE code. */
1435 "Expanding speculative call of %s -> %s count: ",
1436 e
->caller
->dump_name (),
1437 e
->callee
->dump_name ());
1438 e
->count
.dump (dump_file
);
1439 fprintf (dump_file
, "\n");
1441 push_cfun (DECL_STRUCT_FUNCTION (e
->caller
->decl
));
1443 profile_count all
= indirect
->count
;
1444 for (cgraph_edge
*e2
= e
->first_speculative_call_target ();
1446 e2
= e2
->next_speculative_call_target ())
1447 all
= all
+ e2
->count
;
1448 profile_probability prob
= e
->count
.probability_in (all
);
1449 if (!prob
.initialized_p ())
1450 prob
= profile_probability::even ();
1451 ref
= e
->speculative_call_target_ref ();
1452 new_stmt
= gimple_ic (e
->call_stmt
,
1453 dyn_cast
<cgraph_node
*> (ref
->referred
),
1455 e
->speculative
= false;
1456 if (indirect
->num_speculative_call_targets_p ())
1458 /* The indirect edge has multiple speculative targets, don't
1459 remove speculative until all related direct edges are
1461 indirect
->indirect_info
->num_speculative_call_targets
--;
1462 if (!indirect
->indirect_info
->num_speculative_call_targets
)
1463 indirect
->speculative
= false;
1466 indirect
->speculative
= false;
1467 /* Indirect edges are not both in the call site hash.
1469 update_call_stmt_hash_for_removing_direct_edge (e
, indirect
);
1470 cgraph_edge::set_call_stmt (e
, new_stmt
, false);
1471 e
->count
= gimple_bb (e
->call_stmt
)->count
;
1473 /* Once we are done with expanding the sequence, update also indirect
1474 call probability. Until then the basic block accounts for the
1475 sum of indirect edge and all non-expanded speculations. */
1476 if (!indirect
->speculative
)
1477 indirect
->count
= gimple_bb (indirect
->call_stmt
)->count
;
1478 ref
->speculative
= false;
1481 /* Continue redirecting E to proper target. */
1486 if (e
->indirect_unknown_callee
1487 || decl
== e
->callee
->decl
)
1488 return e
->call_stmt
;
1490 if (decl
&& ipa_saved_clone_sources
)
1492 tree
*p
= ipa_saved_clone_sources
->get (e
->callee
);
1493 if (p
&& decl
== *p
)
1495 gimple_call_set_fndecl (e
->call_stmt
, e
->callee
->decl
);
1496 return e
->call_stmt
;
1499 if (flag_checking
&& decl
)
1501 if (cgraph_node
*node
= cgraph_node::get (decl
))
1503 clone_info
*info
= clone_info::get (node
);
1504 gcc_assert (!info
|| !info
->param_adjustments
);
1508 clone_info
*callee_info
= clone_info::get (e
->callee
);
1509 clone_info
*caller_info
= clone_info::get (e
->caller
);
1511 if (symtab
->dump_file
)
1513 fprintf (symtab
->dump_file
, "updating call of %s -> %s: ",
1514 e
->caller
->dump_name (), e
->callee
->dump_name ());
1515 print_gimple_stmt (symtab
->dump_file
, e
->call_stmt
, 0, dump_flags
);
1516 if (callee_info
&& callee_info
->param_adjustments
)
1517 callee_info
->param_adjustments
->dump (symtab
->dump_file
);
1518 unsigned performed_len
1519 = caller_info
? vec_safe_length (caller_info
->performed_splits
) : 0;
1520 if (performed_len
> 0)
1521 fprintf (symtab
->dump_file
, "Performed splits records:\n");
1522 for (unsigned i
= 0; i
< performed_len
; i
++)
1524 ipa_param_performed_split
*sm
1525 = &(*caller_info
->performed_splits
)[i
];
1526 print_node_brief (symtab
->dump_file
, " dummy_decl: ", sm
->dummy_decl
,
1528 fprintf (symtab
->dump_file
, ", unit_offset: %u\n", sm
->unit_offset
);
1532 if (ipa_param_adjustments
*padjs
1533 = callee_info
? callee_info
->param_adjustments
: NULL
)
1535 /* We need to defer cleaning EH info on the new statement to
1536 fixup-cfg. We may not have dominator information at this point
1537 and thus would end up with unreachable blocks and have no way
1538 to communicate that we need to run CFG cleanup then. */
1539 int lp_nr
= lookup_stmt_eh_lp (e
->call_stmt
);
1541 remove_stmt_from_eh_lp (e
->call_stmt
);
1543 tree old_fntype
= gimple_call_fntype (e
->call_stmt
);
1544 new_stmt
= padjs
->modify_call (e
->call_stmt
,
1546 ? caller_info
->performed_splits
: NULL
,
1547 e
->callee
->decl
, false);
1548 cgraph_node
*origin
= e
->callee
;
1549 while (origin
->clone_of
)
1550 origin
= origin
->clone_of
;
1552 if ((origin
->former_clone_of
1553 && old_fntype
== TREE_TYPE (origin
->former_clone_of
))
1554 || old_fntype
== TREE_TYPE (origin
->decl
))
1555 gimple_call_set_fntype (new_stmt
, TREE_TYPE (e
->callee
->decl
));
1558 tree new_fntype
= padjs
->build_new_function_type (old_fntype
, true);
1559 gimple_call_set_fntype (new_stmt
, new_fntype
);
1563 add_stmt_to_eh_lp (new_stmt
, lp_nr
);
1567 new_stmt
= e
->call_stmt
;
1568 gimple_call_set_fndecl (new_stmt
, e
->callee
->decl
);
1569 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), new_stmt
);
1572 /* If changing the call to __cxa_pure_virtual or similar noreturn function,
1573 adjust gimple_call_fntype too. */
1574 if (gimple_call_noreturn_p (new_stmt
)
1575 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (e
->callee
->decl
)))
1576 && TYPE_ARG_TYPES (TREE_TYPE (e
->callee
->decl
))
1577 && (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (e
->callee
->decl
)))
1579 gimple_call_set_fntype (new_stmt
, TREE_TYPE (e
->callee
->decl
));
1581 /* If the call becomes noreturn, remove the LHS if possible. */
1582 tree lhs
= gimple_call_lhs (new_stmt
);
1584 && gimple_call_noreturn_p (new_stmt
)
1585 && (VOID_TYPE_P (TREE_TYPE (gimple_call_fntype (new_stmt
)))
1586 || should_remove_lhs_p (lhs
)))
1588 if (TREE_CODE (lhs
) == SSA_NAME
)
1590 tree var
= create_tmp_reg_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
),
1591 TREE_TYPE (lhs
), NULL
);
1592 var
= get_or_create_ssa_default_def
1593 (DECL_STRUCT_FUNCTION (e
->caller
->decl
), var
);
1594 gimple
*set_stmt
= gimple_build_assign (lhs
, var
);
1595 gsi
= gsi_for_stmt (new_stmt
);
1596 gsi_insert_before_without_update (&gsi
, set_stmt
, GSI_SAME_STMT
);
1597 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), set_stmt
);
1599 gimple_call_set_lhs (new_stmt
, NULL_TREE
);
1600 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), new_stmt
);
1603 /* If new callee has no static chain, remove it. */
1604 if (gimple_call_chain (new_stmt
) && !DECL_STATIC_CHAIN (e
->callee
->decl
))
1606 gimple_call_set_chain (new_stmt
, NULL
);
1607 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), new_stmt
);
1610 maybe_remove_unused_call_args (DECL_STRUCT_FUNCTION (e
->caller
->decl
),
1613 e
->caller
->set_call_stmt_including_clones (e
->call_stmt
, new_stmt
, false);
1615 if (symtab
->dump_file
)
1617 fprintf (symtab
->dump_file
, " updated to:");
1618 print_gimple_stmt (symtab
->dump_file
, e
->call_stmt
, 0, dump_flags
);
1623 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1624 OLD_STMT changed into NEW_STMT. OLD_CALL is gimple_call_fndecl
1625 of OLD_STMT if it was previously call statement.
1626 If NEW_STMT is NULL, the call has been dropped without any
1630 cgraph_update_edges_for_call_stmt_node (cgraph_node
*node
,
1631 gimple
*old_stmt
, tree old_call
,
1634 tree new_call
= (new_stmt
&& is_gimple_call (new_stmt
))
1635 ? gimple_call_fndecl (new_stmt
) : 0;
1637 /* We are seeing indirect calls, then there is nothing to update. */
1638 if (!new_call
&& !old_call
)
1640 /* See if we turned indirect call into direct call or folded call to one builtin
1641 into different builtin. */
1642 if (old_call
!= new_call
)
1644 cgraph_edge
*e
= node
->get_edge (old_stmt
);
1645 cgraph_edge
*ne
= NULL
;
1646 profile_count count
;
1650 /* Keep calls marked as dead dead. */
1651 if (new_stmt
&& is_gimple_call (new_stmt
) && e
->callee
1652 && fndecl_built_in_p (e
->callee
->decl
, BUILT_IN_UNREACHABLE
))
1654 cgraph_edge::set_call_stmt (node
->get_edge (old_stmt
),
1655 as_a
<gcall
*> (new_stmt
));
1658 /* See if the edge is already there and has the correct callee. It
1659 might be so because of indirect inlining has already updated
1660 it. We also might've cloned and redirected the edge. */
1661 if (new_call
&& e
->callee
)
1663 cgraph_node
*callee
= e
->callee
;
1666 if (callee
->decl
== new_call
1667 || callee
->former_clone_of
== new_call
)
1669 cgraph_edge::set_call_stmt (e
, as_a
<gcall
*> (new_stmt
));
1672 callee
= callee
->clone_of
;
1676 /* Otherwise remove edge and create new one; we can't simply redirect
1677 since function has changed, so inline plan and other information
1678 attached to edge is invalid. */
1680 if (e
->indirect_unknown_callee
|| e
->inline_failed
)
1681 cgraph_edge::remove (e
);
1683 e
->callee
->remove_symbol_and_inline_clones ();
1687 /* We are seeing new direct call; compute profile info based on BB. */
1688 basic_block bb
= gimple_bb (new_stmt
);
1694 ne
= node
->create_edge (cgraph_node::get_create (new_call
),
1695 as_a
<gcall
*> (new_stmt
), count
);
1696 gcc_assert (ne
->inline_failed
);
1699 /* We only updated the call stmt; update pointer in cgraph edge.. */
1700 else if (old_stmt
!= new_stmt
)
1701 cgraph_edge::set_call_stmt (node
->get_edge (old_stmt
),
1702 as_a
<gcall
*> (new_stmt
));
1705 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1706 OLD_STMT changed into NEW_STMT. OLD_DECL is gimple_call_fndecl
1707 of OLD_STMT before it was updated (updating can happen inplace). */
1710 cgraph_update_edges_for_call_stmt (gimple
*old_stmt
, tree old_decl
,
1713 cgraph_node
*orig
= cgraph_node::get (cfun
->decl
);
1716 gcc_checking_assert (orig
);
1717 cgraph_update_edges_for_call_stmt_node (orig
, old_stmt
, old_decl
, new_stmt
);
1719 for (node
= orig
->clones
; node
!= orig
;)
1721 cgraph_update_edges_for_call_stmt_node (node
, old_stmt
, old_decl
,
1724 node
= node
->clones
;
1725 else if (node
->next_sibling_clone
)
1726 node
= node
->next_sibling_clone
;
1729 while (node
!= orig
&& !node
->next_sibling_clone
)
1730 node
= node
->clone_of
;
1732 node
= node
->next_sibling_clone
;
1738 /* Remove all callees from the node. */
1741 cgraph_node::remove_callees (void)
1745 calls_comdat_local
= false;
1747 /* It is sufficient to remove the edges from the lists of callers of
1748 the callees. The callee list of the node can be zapped with one
1750 for (e
= callees
; e
; e
= f
)
1753 symtab
->call_edge_removal_hooks (e
);
1754 if (!e
->indirect_unknown_callee
)
1755 e
->remove_callee ();
1756 symtab
->free_edge (e
);
1758 for (e
= indirect_calls
; e
; e
= f
)
1761 symtab
->call_edge_removal_hooks (e
);
1762 if (!e
->indirect_unknown_callee
)
1763 e
->remove_callee ();
1764 symtab
->free_edge (e
);
1766 indirect_calls
= NULL
;
1770 call_site_hash
->empty ();
1771 call_site_hash
= NULL
;
1775 /* Remove all callers from the node. */
1778 cgraph_node::remove_callers (void)
1782 /* It is sufficient to remove the edges from the lists of callees of
1783 the callers. The caller list of the node can be zapped with one
1785 for (e
= callers
; e
; e
= f
)
1788 symtab
->call_edge_removal_hooks (e
);
1789 e
->remove_caller ();
1790 symtab
->free_edge (e
);
1795 /* Helper function for cgraph_release_function_body and free_lang_data.
1796 It releases body from function DECL without having to inspect its
1797 possibly non-existent symtab node. */
1800 release_function_body (tree decl
)
1802 function
*fn
= DECL_STRUCT_FUNCTION (decl
);
1806 && loops_for_fn (fn
))
1808 fn
->curr_properties
&= ~PROP_loops
;
1809 loop_optimizer_finalize (fn
);
1813 delete_tree_ssa (fn
);
1818 gcc_assert (!dom_info_available_p (fn
, CDI_DOMINATORS
));
1819 gcc_assert (!dom_info_available_p (fn
, CDI_POST_DOMINATORS
));
1820 delete_tree_cfg_annotations (fn
);
1824 if (fn
->value_histograms
)
1825 free_histograms (fn
);
1826 gimple_set_body (decl
, NULL
);
1827 /* Struct function hangs a lot of data that would leak if we didn't
1828 removed all pointers to it. */
1830 DECL_STRUCT_FUNCTION (decl
) = NULL
;
1832 DECL_SAVED_TREE (decl
) = NULL
;
1835 /* Release memory used to represent body of function.
1836 Use this only for functions that are released before being translated to
1837 target code (i.e. RTL). Functions that are compiled to RTL and beyond
1838 are free'd in final.c via free_after_compilation().
1839 KEEP_ARGUMENTS are useful only if you want to rebuild body as thunk. */
1842 cgraph_node::release_body (bool keep_arguments
)
1844 ipa_transforms_to_apply
.release ();
1845 if (!used_as_abstract_origin
&& symtab
->state
!= PARSING
)
1847 DECL_RESULT (decl
) = NULL
;
1849 if (!keep_arguments
)
1850 DECL_ARGUMENTS (decl
) = NULL
;
1852 /* If the node is abstract and needed, then do not clear
1853 DECL_INITIAL of its associated function declaration because it's
1854 needed to emit debug info later. */
1855 if (!used_as_abstract_origin
&& DECL_INITIAL (decl
))
1856 DECL_INITIAL (decl
) = error_mark_node
;
1857 release_function_body (decl
);
1860 lto_free_function_in_decl_state_for_node (this);
1861 lto_file_data
= NULL
;
1863 if (flag_checking
&& clones
)
1865 /* It is invalid to release body before materializing clones except
1866 for thunks that don't really need a body. Verify also that we do
1867 not leak pointers to the call statements. */
1868 for (cgraph_node
*node
= clones
; node
;
1869 node
= node
->next_sibling_clone
)
1870 gcc_assert (node
->thunk
&& !node
->callees
->call_stmt
);
1873 remove_all_references ();
1876 /* Remove function from symbol table. */
1879 cgraph_node::remove (void)
1881 bool clone_info_set
= false;
1882 clone_info
*info
, saved_info
;
1883 if (symtab
->ipa_clones_dump_file
&& symtab
->cloned_nodes
.contains (this))
1884 fprintf (symtab
->ipa_clones_dump_file
,
1885 "Callgraph removal;%s;%d;%s;%d;%d\n", asm_name (), order
,
1886 DECL_SOURCE_FILE (decl
), DECL_SOURCE_LINE (decl
),
1887 DECL_SOURCE_COLUMN (decl
));
1889 if ((info
= clone_info::get (this)) != NULL
)
1892 clone_info_set
= true;
1894 symtab
->call_cgraph_removal_hooks (this);
1897 ipa_transforms_to_apply
.release ();
1898 delete_function_version (function_version ());
1900 /* Incremental inlining access removed nodes stored in the postorder list.
1902 force_output
= false;
1903 forced_by_abi
= false;
1905 unregister (clone_info_set
? &saved_info
: NULL
);
1906 if (prev_sibling_clone
)
1907 prev_sibling_clone
->next_sibling_clone
= next_sibling_clone
;
1909 clone_of
->clones
= next_sibling_clone
;
1910 if (next_sibling_clone
)
1911 next_sibling_clone
->prev_sibling_clone
= prev_sibling_clone
;
1914 cgraph_node
*n
, *next
;
1918 for (n
= clones
; n
->next_sibling_clone
; n
= n
->next_sibling_clone
)
1919 n
->clone_of
= clone_of
;
1920 n
->clone_of
= clone_of
;
1921 n
->next_sibling_clone
= clone_of
->clones
;
1922 if (clone_of
->clones
)
1923 clone_of
->clones
->prev_sibling_clone
= n
;
1924 clone_of
->clones
= clones
;
1928 /* We are removing node with clones. This makes clones inconsistent,
1929 but assume they will be removed subsequently and just keep clone
1930 tree intact. This can happen in unreachable function removal since
1931 we remove unreachable functions in random order, not by bottom-up
1932 walk of clone trees. */
1933 for (n
= clones
; n
; n
= next
)
1935 next
= n
->next_sibling_clone
;
1936 n
->next_sibling_clone
= NULL
;
1937 n
->prev_sibling_clone
= NULL
;
1943 /* While all the clones are removed after being proceeded, the function
1944 itself is kept in the cgraph even after it is compiled. Check whether
1945 we are done with this body and reclaim it proactively if this is the case.
1947 if (symtab
->state
!= LTO_STREAMING
)
1949 cgraph_node
*n
= cgraph_node::get (decl
);
1951 || (!n
->clones
&& !n
->clone_of
&& !n
->inlined_to
1952 && ((symtab
->global_info_ready
|| in_lto_p
)
1953 && (TREE_ASM_WRITTEN (n
->decl
)
1954 || DECL_EXTERNAL (n
->decl
)
1956 || (!flag_wpa
&& n
->in_other_partition
)))))
1961 lto_free_function_in_decl_state_for_node (this);
1962 lto_file_data
= NULL
;
1968 call_site_hash
->empty ();
1969 call_site_hash
= NULL
;
1972 symtab
->release_symbol (this);
1975 /* Likewise indicate that a node is having address taken. */
1978 cgraph_node::mark_address_taken (void)
1980 /* Indirect inlining can figure out that all uses of the address are
1984 gcc_assert (cfun
->after_inlining
);
1985 gcc_assert (callers
->indirect_inlining_edge
);
1988 /* FIXME: address_taken flag is used both as a shortcut for testing whether
1989 IPA_REF_ADDR reference exists (and thus it should be set on node
1990 representing alias we take address of) and as a test whether address
1991 of the object was taken (and thus it should be set on node alias is
1992 referring to). We should remove the first use and the remove the
1995 cgraph_node
*node
= ultimate_alias_target ();
1996 node
->address_taken
= 1;
1999 /* Return local info node for the compiled function. */
2002 cgraph_node::local_info_node (tree decl
)
2004 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
2005 cgraph_node
*node
= get (decl
);
2008 return node
->ultimate_alias_target ();
2011 /* Return RTL info for the compiled function. */
2014 cgraph_node::rtl_info (const_tree decl
)
2016 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
2017 cgraph_node
*node
= get (decl
);
2020 enum availability avail
;
2021 node
= node
->ultimate_alias_target (&avail
);
2022 if (decl
!= current_function_decl
2023 && (avail
< AVAIL_AVAILABLE
2024 || (node
->decl
!= current_function_decl
2025 && !TREE_ASM_WRITTEN (node
->decl
))))
2027 /* Allocate if it doesn't exist. */
2028 if (node
->rtl
== NULL
)
2030 node
->rtl
= ggc_cleared_alloc
<cgraph_rtl_info
> ();
2031 SET_HARD_REG_SET (node
->rtl
->function_used_regs
);
2036 /* Return a string describing the failure REASON. */
2039 cgraph_inline_failed_string (cgraph_inline_failed_t reason
)
2042 #define DEFCIFCODE(code, type, string) string,
2044 static const char *cif_string_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_string_table
[reason
];
2054 /* Return a type describing the failure REASON. */
2056 cgraph_inline_failed_type_t
2057 cgraph_inline_failed_type (cgraph_inline_failed_t reason
)
2060 #define DEFCIFCODE(code, type, string) type,
2062 static cgraph_inline_failed_type_t cif_type_table
[CIF_N_REASONS
] = {
2063 #include "cif-code.def"
2066 /* Signedness of an enum type is implementation defined, so cast it
2067 to unsigned before testing. */
2068 gcc_assert ((unsigned) reason
< CIF_N_REASONS
);
2069 return cif_type_table
[reason
];
2072 /* Names used to print out the availability enum. */
2073 const char * const cgraph_availability_names
[] =
2074 {"unset", "not_available", "overwritable", "available", "local"};
2076 /* Output flags of edge to a file F. */
2079 cgraph_edge::dump_edge_flags (FILE *f
)
2082 fprintf (f
, "(speculative) ");
2084 fprintf (f
, "(inlined) ");
2085 if (call_stmt_cannot_inline_p
)
2086 fprintf (f
, "(call_stmt_cannot_inline_p) ");
2087 if (indirect_inlining_edge
)
2088 fprintf (f
, "(indirect_inlining) ");
2089 if (count
.initialized_p ())
2094 fprintf (f
, "%.2f per call) ", sreal_frequency ().to_double ());
2096 if (can_throw_external
)
2097 fprintf (f
, "(can throw external) ");
2100 /* Dump edge to stderr. */
2103 cgraph_edge::debug (void)
2105 fprintf (stderr
, "%s -> %s ", caller
->dump_asm_name (),
2106 callee
== NULL
? "(null)" : callee
->dump_asm_name ());
2107 dump_edge_flags (stderr
);
2108 fprintf (stderr
, "\n\n");
2114 /* Dump call graph node to file F. */
2117 cgraph_node::dump (FILE *f
)
2124 fprintf (f
, " Function %s is inline copy in %s\n",
2126 inlined_to
->dump_name ());
2128 fprintf (f
, " Clone of %s\n", clone_of
->dump_asm_name ());
2129 if (symtab
->function_flags_ready
)
2130 fprintf (f
, " Availability: %s\n",
2131 cgraph_availability_names
[get_availability ()]);
2134 fprintf (f
, " Profile id: %i\n",
2137 fprintf (f
, " Unit id: %i\n",
2139 cgraph_function_version_info
*vi
= function_version ();
2142 fprintf (f
, " Version info: ");
2143 if (vi
->prev
!= NULL
)
2145 fprintf (f
, "prev: ");
2146 fprintf (f
, "%s ", vi
->prev
->this_node
->dump_asm_name ());
2148 if (vi
->next
!= NULL
)
2150 fprintf (f
, "next: ");
2151 fprintf (f
, "%s ", vi
->next
->this_node
->dump_asm_name ());
2153 if (vi
->dispatcher_resolver
!= NULL_TREE
)
2154 fprintf (f
, "dispatcher: %s",
2155 lang_hooks
.decl_printable_name (vi
->dispatcher_resolver
, 2));
2159 fprintf (f
, " Function flags:");
2160 if (count
.initialized_p ())
2162 fprintf (f
, " count:");
2165 if (tp_first_run
> 0)
2166 fprintf (f
, " first_run:%" PRId64
, (int64_t) tp_first_run
);
2167 if (cgraph_node
*origin
= nested_function_origin (this))
2168 fprintf (f
, " nested in:%s", origin
->dump_asm_name ());
2169 if (gimple_has_body_p (decl
))
2170 fprintf (f
, " body");
2172 fprintf (f
, " process");
2174 fprintf (f
, " local");
2175 if (redefined_extern_inline
)
2176 fprintf (f
, " redefined_extern_inline");
2177 if (only_called_at_startup
)
2178 fprintf (f
, " only_called_at_startup");
2179 if (only_called_at_exit
)
2180 fprintf (f
, " only_called_at_exit");
2182 fprintf (f
, " tm_clone");
2183 if (calls_comdat_local
)
2184 fprintf (f
, " calls_comdat_local");
2186 fprintf (f
, " icf_merged");
2188 fprintf (f
, " merged_comdat");
2189 if (merged_extern_inline
)
2190 fprintf (f
, " merged_extern_inline");
2192 fprintf (f
, " split_part");
2193 if (indirect_call_target
)
2194 fprintf (f
, " indirect_call_target");
2196 fprintf (f
, " nonfreeing_fn");
2197 if (DECL_STATIC_CONSTRUCTOR (decl
))
2198 fprintf (f
," static_constructor (priority:%i)", get_init_priority ());
2199 if (DECL_STATIC_DESTRUCTOR (decl
))
2200 fprintf (f
," static_destructor (priority:%i)", get_fini_priority ());
2201 if (frequency
== NODE_FREQUENCY_HOT
)
2202 fprintf (f
, " hot");
2203 if (frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
)
2204 fprintf (f
, " unlikely_executed");
2205 if (frequency
== NODE_FREQUENCY_EXECUTED_ONCE
)
2206 fprintf (f
, " executed_once");
2207 if (opt_for_fn (decl
, optimize_size
))
2208 fprintf (f
, " optimize_size");
2209 if (parallelized_function
)
2210 fprintf (f
, " parallelized_function");
2211 if (DECL_IS_MALLOC (decl
))
2212 fprintf (f
, " decl_is_malloc");
2213 if (DECL_IS_OPERATOR_NEW_P (decl
))
2214 fprintf (f
, " %soperator_new",
2215 DECL_IS_REPLACEABLE_OPERATOR (decl
) ? "replaceable_" : "");
2216 if (DECL_IS_OPERATOR_DELETE_P (decl
))
2217 fprintf (f
, " %soperator_delete",
2218 DECL_IS_REPLACEABLE_OPERATOR (decl
) ? "replaceable_" : "");
2224 fprintf (f
, " Thunk");
2225 thunk_info::get (this)->dump (f
);
2227 else if (former_thunk_p ())
2229 fprintf (f
, " Former thunk ");
2230 thunk_info::get (this)->dump (f
);
2232 else gcc_checking_assert (!thunk_info::get (this));
2234 fprintf (f
, " Called by: ");
2236 profile_count sum
= profile_count::zero ();
2237 for (edge
= callers
; edge
; edge
= edge
->next_caller
)
2239 fprintf (f
, "%s ", edge
->caller
->dump_asm_name ());
2240 edge
->dump_edge_flags (f
);
2241 if (edge
->count
.initialized_p ())
2242 sum
+= edge
->count
.ipa ();
2245 fprintf (f
, "\n Calls: ");
2246 for (edge
= callees
; edge
; edge
= edge
->next_callee
)
2248 fprintf (f
, "%s ", edge
->callee
->dump_asm_name ());
2249 edge
->dump_edge_flags (f
);
2253 if (count
.ipa ().initialized_p ())
2259 FOR_EACH_ALIAS (this, ref
)
2260 if (dyn_cast
<cgraph_node
*> (ref
->referring
)->count
.initialized_p ())
2261 sum
+= dyn_cast
<cgraph_node
*> (ref
->referring
)->count
.ipa ();
2264 || (symtab
->state
< EXPANSION
2265 && ultimate_alias_target () == this && only_called_directly_p ()))
2266 ok
= !count
.ipa ().differs_from_p (sum
);
2267 else if (count
.ipa () > profile_count::from_gcov_type (100)
2268 && count
.ipa () < sum
.apply_scale (99, 100))
2269 ok
= false, min
= true;
2272 fprintf (f
, " Invalid sum of caller counts ");
2275 fprintf (f
, ", should be at most ");
2277 fprintf (f
, ", should be ");
2278 count
.ipa ().dump (f
);
2283 for (edge
= indirect_calls
; edge
; edge
= edge
->next_callee
)
2285 if (edge
->indirect_info
->polymorphic
)
2287 fprintf (f
, " Polymorphic indirect call of type ");
2288 print_generic_expr (f
, edge
->indirect_info
->otr_type
, TDF_SLIM
);
2289 fprintf (f
, " token:%i", (int) edge
->indirect_info
->otr_token
);
2292 fprintf (f
, " Indirect call");
2293 edge
->dump_edge_flags (f
);
2294 if (edge
->indirect_info
->param_index
!= -1)
2296 fprintf (f
, "of param:%i ", edge
->indirect_info
->param_index
);
2297 if (edge
->indirect_info
->agg_contents
)
2298 fprintf (f
, "loaded from %s %s at offset %i ",
2299 edge
->indirect_info
->member_ptr
? "member ptr" : "aggregate",
2300 edge
->indirect_info
->by_ref
? "passed by reference":"",
2301 (int)edge
->indirect_info
->offset
);
2302 if (edge
->indirect_info
->vptr_changed
)
2303 fprintf (f
, "(vptr maybe changed) ");
2305 fprintf (f
, "num speculative call targets: %i\n",
2306 edge
->indirect_info
->num_speculative_call_targets
);
2307 if (edge
->indirect_info
->polymorphic
)
2308 edge
->indirect_info
->context
.dump (f
);
2312 /* Dump call graph node to file F in graphviz format. */
2315 cgraph_node::dump_graphviz (FILE *f
)
2319 for (edge
= callees
; edge
; edge
= edge
->next_callee
)
2321 cgraph_node
*callee
= edge
->callee
;
2323 fprintf (f
, "\t\"%s\" -> \"%s\"\n", dump_name (), callee
->dump_name ());
2328 /* Dump call graph node NODE to stderr. */
2331 cgraph_node::debug (void)
2336 /* Dump the callgraph to file F. */
2339 cgraph_node::dump_cgraph (FILE *f
)
2343 fprintf (f
, "callgraph:\n\n");
2344 FOR_EACH_FUNCTION (node
)
2348 /* Return true when the DECL can possibly be inlined. */
2351 cgraph_function_possibly_inlined_p (tree decl
)
2353 if (!symtab
->global_info_ready
)
2354 return !DECL_UNINLINABLE (decl
);
2355 return DECL_POSSIBLY_INLINED (decl
);
2358 /* Return function availability. See cgraph.h for description of individual
2361 cgraph_node::get_availability (symtab_node
*ref
)
2365 cgraph_node
*cref
= dyn_cast
<cgraph_node
*> (ref
);
2367 ref
= cref
->inlined_to
;
2369 enum availability avail
;
2370 if (!analyzed
&& !in_other_partition
)
2371 avail
= AVAIL_NOT_AVAILABLE
;
2373 avail
= AVAIL_LOCAL
;
2374 else if (inlined_to
)
2375 avail
= AVAIL_AVAILABLE
;
2376 else if (transparent_alias
)
2377 ultimate_alias_target (&avail
, ref
);
2378 else if (ifunc_resolver
2379 || lookup_attribute ("noipa", DECL_ATTRIBUTES (decl
)))
2380 avail
= AVAIL_INTERPOSABLE
;
2381 else if (!externally_visible
)
2382 avail
= AVAIL_AVAILABLE
;
2383 /* If this is a reference from symbol itself and there are no aliases, we
2384 may be sure that the symbol was not interposed by something else because
2385 the symbol itself would be unreachable otherwise.
2387 Also comdat groups are always resolved in groups. */
2388 else if ((this == ref
&& !has_aliases_p ())
2389 || (ref
&& get_comdat_group ()
2390 && get_comdat_group () == ref
->get_comdat_group ()))
2391 avail
= AVAIL_AVAILABLE
;
2392 /* Inline functions are safe to be analyzed even if their symbol can
2393 be overwritten at runtime. It is not meaningful to enforce any sane
2394 behavior on replacing inline function by different body. */
2395 else if (DECL_DECLARED_INLINE_P (decl
))
2396 avail
= AVAIL_AVAILABLE
;
2398 /* If the function can be overwritten, return OVERWRITABLE. Take
2399 care at least of two notable extensions - the COMDAT functions
2400 used to share template instantiations in C++ (this is symmetric
2401 to code cp_cannot_inline_tree_fn and probably shall be shared and
2402 the inlinability hooks completely eliminated). */
2404 else if (decl_replaceable_p (decl
) && !DECL_EXTERNAL (decl
))
2405 avail
= AVAIL_INTERPOSABLE
;
2406 else avail
= AVAIL_AVAILABLE
;
2411 /* Worker for cgraph_node_can_be_local_p. */
2413 cgraph_node_cannot_be_local_p_1 (cgraph_node
*node
, void *)
2415 return !(!node
->force_output
2416 && !node
->ifunc_resolver
2417 /* Limitation of gas requires us to output targets of symver aliases
2418 as global symbols. This is binutils PR 25295. */
2420 && ((DECL_COMDAT (node
->decl
)
2421 && !node
->forced_by_abi
2422 && !node
->used_from_object_file_p ()
2423 && !node
->same_comdat_group
)
2424 || !node
->externally_visible
));
2427 /* Return true if cgraph_node can be made local for API change.
2428 Extern inline functions and C++ COMDAT functions can be made local
2429 at the expense of possible code size growth if function is used in multiple
2430 compilation units. */
2432 cgraph_node::can_be_local_p (void)
2434 return (!address_taken
2435 && !call_for_symbol_thunks_and_aliases (cgraph_node_cannot_be_local_p_1
,
2439 /* Call callback on cgraph_node, thunks and aliases associated to cgraph_node.
2440 When INCLUDE_OVERWRITABLE is false, overwritable symbols are
2441 skipped. When EXCLUDE_VIRTUAL_THUNKS is true, virtual thunks are
2444 cgraph_node::call_for_symbol_thunks_and_aliases (bool (*callback
)
2445 (cgraph_node
*, void *),
2447 bool include_overwritable
,
2448 bool exclude_virtual_thunks
)
2452 enum availability avail
= AVAIL_AVAILABLE
;
2454 if (include_overwritable
2455 || (avail
= get_availability ()) > AVAIL_INTERPOSABLE
)
2457 if (callback (this, data
))
2460 FOR_EACH_ALIAS (this, ref
)
2462 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2463 if (include_overwritable
2464 || alias
->get_availability () > AVAIL_INTERPOSABLE
)
2465 if (alias
->call_for_symbol_thunks_and_aliases (callback
, data
,
2466 include_overwritable
,
2467 exclude_virtual_thunks
))
2470 if (avail
<= AVAIL_INTERPOSABLE
)
2472 for (e
= callers
; e
; e
= e
->next_caller
)
2473 if (e
->caller
->thunk
2474 && (include_overwritable
2475 || e
->caller
->get_availability () > AVAIL_INTERPOSABLE
)
2476 && !(exclude_virtual_thunks
2477 && thunk_info::get (e
->caller
)->virtual_offset_p
))
2478 if (e
->caller
->call_for_symbol_thunks_and_aliases (callback
, data
,
2479 include_overwritable
,
2480 exclude_virtual_thunks
))
2486 /* Worker to bring NODE local. */
2489 cgraph_node::make_local (cgraph_node
*node
, void *)
2491 gcc_checking_assert (node
->can_be_local_p ());
2492 if (DECL_COMDAT (node
->decl
) || DECL_EXTERNAL (node
->decl
))
2494 node
->make_decl_local ();
2495 node
->set_section (NULL
);
2496 node
->set_comdat_group (NULL
);
2497 node
->externally_visible
= false;
2498 node
->forced_by_abi
= false;
2500 node
->set_section (NULL
);
2501 node
->unique_name
= ((node
->resolution
== LDPR_PREVAILING_DEF_IRONLY
2502 || node
->resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
)
2503 && !flag_incremental_link
);
2504 node
->resolution
= LDPR_PREVAILING_DEF_IRONLY
;
2505 gcc_assert (node
->get_availability () == AVAIL_LOCAL
);
2510 /* Bring cgraph node local. */
2513 cgraph_node::make_local (void)
2515 call_for_symbol_thunks_and_aliases (cgraph_node::make_local
, NULL
, true);
2518 /* Worker to set nothrow flag. */
2521 set_nothrow_flag_1 (cgraph_node
*node
, bool nothrow
, bool non_call
,
2526 if (nothrow
&& !TREE_NOTHROW (node
->decl
))
2528 /* With non-call exceptions we can't say for sure if other function body
2529 was not possibly optimized to still throw. */
2530 if (!non_call
|| node
->binds_to_current_def_p ())
2532 TREE_NOTHROW (node
->decl
) = true;
2534 for (e
= node
->callers
; e
; e
= e
->next_caller
)
2535 e
->can_throw_external
= false;
2538 else if (!nothrow
&& TREE_NOTHROW (node
->decl
))
2540 TREE_NOTHROW (node
->decl
) = false;
2544 FOR_EACH_ALIAS (node
, ref
)
2546 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2547 if (!nothrow
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2548 set_nothrow_flag_1 (alias
, nothrow
, non_call
, changed
);
2550 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
2551 if (e
->caller
->thunk
2552 && (!nothrow
|| e
->caller
->get_availability () > AVAIL_INTERPOSABLE
))
2553 set_nothrow_flag_1 (e
->caller
, nothrow
, non_call
, changed
);
2556 /* Set TREE_NOTHROW on NODE's decl and on aliases of NODE
2557 if any to NOTHROW. */
2560 cgraph_node::set_nothrow_flag (bool nothrow
)
2562 bool changed
= false;
2563 bool non_call
= opt_for_fn (decl
, flag_non_call_exceptions
);
2565 if (!nothrow
|| get_availability () > AVAIL_INTERPOSABLE
)
2566 set_nothrow_flag_1 (this, nothrow
, non_call
, &changed
);
2571 FOR_EACH_ALIAS (this, ref
)
2573 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2574 if (!nothrow
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2575 set_nothrow_flag_1 (alias
, nothrow
, non_call
, &changed
);
2581 /* Worker to set malloc flag. */
2583 set_malloc_flag_1 (cgraph_node
*node
, bool malloc_p
, bool *changed
)
2585 if (malloc_p
&& !DECL_IS_MALLOC (node
->decl
))
2587 DECL_IS_MALLOC (node
->decl
) = true;
2592 FOR_EACH_ALIAS (node
, ref
)
2594 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2595 if (!malloc_p
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2596 set_malloc_flag_1 (alias
, malloc_p
, changed
);
2599 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
2600 if (e
->caller
->thunk
2601 && (!malloc_p
|| e
->caller
->get_availability () > AVAIL_INTERPOSABLE
))
2602 set_malloc_flag_1 (e
->caller
, malloc_p
, changed
);
2605 /* Set DECL_IS_MALLOC on NODE's decl and on NODE's aliases if any. */
2608 cgraph_node::set_malloc_flag (bool malloc_p
)
2610 bool changed
= false;
2612 if (!malloc_p
|| get_availability () > AVAIL_INTERPOSABLE
)
2613 set_malloc_flag_1 (this, malloc_p
, &changed
);
2618 FOR_EACH_ALIAS (this, ref
)
2620 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2621 if (!malloc_p
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2622 set_malloc_flag_1 (alias
, malloc_p
, &changed
);
2628 /* Worker to set_const_flag. */
2631 set_const_flag_1 (cgraph_node
*node
, bool set_const
, bool looping
,
2634 /* Static constructors and destructors without a side effect can be
2636 if (set_const
&& !looping
)
2638 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
2640 DECL_STATIC_CONSTRUCTOR (node
->decl
) = 0;
2643 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
2645 DECL_STATIC_DESTRUCTOR (node
->decl
) = 0;
2651 if (TREE_READONLY (node
->decl
))
2653 TREE_READONLY (node
->decl
) = 0;
2654 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2660 /* Consider function:
2667 During early optimization we will turn this into:
2674 Now if this function will be detected as CONST however when interposed
2675 it may end up being just pure. We always must assume the worst
2677 if (TREE_READONLY (node
->decl
))
2679 if (!looping
&& DECL_LOOPING_CONST_OR_PURE_P (node
->decl
))
2681 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2685 else if (node
->binds_to_current_def_p ())
2687 TREE_READONLY (node
->decl
) = true;
2688 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = looping
;
2689 DECL_PURE_P (node
->decl
) = false;
2694 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2695 fprintf (dump_file
, "Dropping state to PURE because function does "
2696 "not bind to current def.\n");
2697 if (!DECL_PURE_P (node
->decl
))
2699 DECL_PURE_P (node
->decl
) = true;
2700 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = looping
;
2703 else if (!looping
&& DECL_LOOPING_CONST_OR_PURE_P (node
->decl
))
2705 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2712 FOR_EACH_ALIAS (node
, ref
)
2714 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2715 if (!set_const
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2716 set_const_flag_1 (alias
, set_const
, looping
, changed
);
2718 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
2719 if (e
->caller
->thunk
2720 && (!set_const
|| e
->caller
->get_availability () > AVAIL_INTERPOSABLE
))
2722 /* Virtual thunks access virtual offset in the vtable, so they can
2723 only be pure, never const. */
2725 && (thunk_info::get (e
->caller
)->virtual_offset_p
2726 || !node
->binds_to_current_def_p (e
->caller
)))
2727 *changed
|= e
->caller
->set_pure_flag (true, looping
);
2729 set_const_flag_1 (e
->caller
, set_const
, looping
, changed
);
2733 /* If SET_CONST is true, mark function, aliases and thunks to be ECF_CONST.
2734 If SET_CONST if false, clear the flag.
2736 When setting the flag be careful about possible interposition and
2737 do not set the flag for functions that can be interposed and set pure
2738 flag for functions that can bind to other definition.
2740 Return true if any change was done. */
2743 cgraph_node::set_const_flag (bool set_const
, bool looping
)
2745 bool changed
= false;
2746 if (!set_const
|| get_availability () > AVAIL_INTERPOSABLE
)
2747 set_const_flag_1 (this, set_const
, looping
, &changed
);
2752 FOR_EACH_ALIAS (this, ref
)
2754 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2755 if (!set_const
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2756 set_const_flag_1 (alias
, set_const
, looping
, &changed
);
2762 /* Info used by set_pure_flag_1. */
2764 struct set_pure_flag_info
2771 /* Worker to set_pure_flag. */
2774 set_pure_flag_1 (cgraph_node
*node
, void *data
)
2776 struct set_pure_flag_info
*info
= (struct set_pure_flag_info
*)data
;
2777 /* Static constructors and destructors without a side effect can be
2779 if (info
->pure
&& !info
->looping
)
2781 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
2783 DECL_STATIC_CONSTRUCTOR (node
->decl
) = 0;
2784 info
->changed
= true;
2786 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
2788 DECL_STATIC_DESTRUCTOR (node
->decl
) = 0;
2789 info
->changed
= true;
2794 if (!DECL_PURE_P (node
->decl
) && !TREE_READONLY (node
->decl
))
2796 DECL_PURE_P (node
->decl
) = true;
2797 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = info
->looping
;
2798 info
->changed
= true;
2800 else if (DECL_LOOPING_CONST_OR_PURE_P (node
->decl
)
2803 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2804 info
->changed
= true;
2809 if (DECL_PURE_P (node
->decl
))
2811 DECL_PURE_P (node
->decl
) = false;
2812 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2813 info
->changed
= true;
2819 /* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node
2822 When setting the flag, be careful about possible interposition.
2823 Return true if any change was done. */
2826 cgraph_node::set_pure_flag (bool pure
, bool looping
)
2828 struct set_pure_flag_info info
= {pure
, looping
, false};
2829 call_for_symbol_thunks_and_aliases (set_pure_flag_1
, &info
, !pure
, true);
2830 return info
.changed
;
2833 /* Return true when cgraph_node cannot return or throw and thus
2834 it is safe to ignore its side effects for IPA analysis. */
2837 cgraph_node::cannot_return_p (void)
2839 int flags
= flags_from_decl_or_type (decl
);
2840 if (!opt_for_fn (decl
, flag_exceptions
))
2841 return (flags
& ECF_NORETURN
) != 0;
2843 return ((flags
& (ECF_NORETURN
| ECF_NOTHROW
))
2844 == (ECF_NORETURN
| ECF_NOTHROW
));
2847 /* Return true when call of edge cannot lead to return from caller
2848 and thus it is safe to ignore its side effects for IPA analysis
2849 when computing side effects of the caller.
2850 FIXME: We could actually mark all edges that have no reaching
2851 patch to the exit block or throw to get better results. */
2853 cgraph_edge::cannot_lead_to_return_p (void)
2855 if (caller
->cannot_return_p ())
2857 if (indirect_unknown_callee
)
2859 int flags
= indirect_info
->ecf_flags
;
2860 if (!opt_for_fn (caller
->decl
, flag_exceptions
))
2861 return (flags
& ECF_NORETURN
) != 0;
2863 return ((flags
& (ECF_NORETURN
| ECF_NOTHROW
))
2864 == (ECF_NORETURN
| ECF_NOTHROW
));
2867 return callee
->cannot_return_p ();
2870 /* Return true if the edge may be considered hot. */
2873 cgraph_edge::maybe_hot_p (void)
2875 if (!maybe_hot_count_p (NULL
, count
.ipa ()))
2877 if (caller
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
2879 && callee
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
))
2881 if (caller
->frequency
> NODE_FREQUENCY_UNLIKELY_EXECUTED
2883 && callee
->frequency
<= NODE_FREQUENCY_EXECUTED_ONCE
))
2885 if (opt_for_fn (caller
->decl
, optimize_size
))
2887 if (caller
->frequency
== NODE_FREQUENCY_HOT
)
2889 if (!count
.initialized_p ())
2891 cgraph_node
*where
= caller
->inlined_to
? caller
->inlined_to
: caller
;
2892 if (!where
->count
.initialized_p ())
2894 if (caller
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
)
2896 if (count
.apply_scale (2, 1) < where
->count
.apply_scale (3, 1))
2899 else if (count
.apply_scale (param_hot_bb_frequency_fraction
, 1)
2905 /* Worker for cgraph_can_remove_if_no_direct_calls_p. */
2908 nonremovable_p (cgraph_node
*node
, void *)
2910 return !node
->can_remove_if_no_direct_calls_and_refs_p ();
2913 /* Return true if whole comdat group can be removed if there are no direct
2917 cgraph_node::can_remove_if_no_direct_calls_p (bool will_inline
)
2919 struct ipa_ref
*ref
;
2921 /* For local symbols or non-comdat group it is the same as
2922 can_remove_if_no_direct_calls_p. */
2923 if (!externally_visible
|| !same_comdat_group
)
2925 if (DECL_EXTERNAL (decl
))
2929 return !call_for_symbol_and_aliases (nonremovable_p
, NULL
, true);
2932 if (will_inline
&& address_taken
)
2935 /* Otherwise check if we can remove the symbol itself and then verify
2936 that only uses of the comdat groups are direct call to THIS
2938 if (!can_remove_if_no_direct_calls_and_refs_p ())
2941 /* Check that all refs come from within the comdat group. */
2942 for (int i
= 0; iterate_referring (i
, ref
); i
++)
2943 if (ref
->referring
->get_comdat_group () != get_comdat_group ())
2946 struct cgraph_node
*target
= ultimate_alias_target ();
2947 for (cgraph_node
*next
= dyn_cast
<cgraph_node
*> (same_comdat_group
);
2948 next
!= this; next
= dyn_cast
<cgraph_node
*> (next
->same_comdat_group
))
2950 if (!externally_visible
)
2953 && !next
->can_remove_if_no_direct_calls_and_refs_p ())
2956 /* If we see different symbol than THIS, be sure to check calls. */
2957 if (next
->ultimate_alias_target () != target
)
2958 for (cgraph_edge
*e
= next
->callers
; e
; e
= e
->next_caller
)
2959 if (e
->caller
->get_comdat_group () != get_comdat_group ()
2963 /* If function is not being inlined, we care only about
2964 references outside of the comdat group. */
2966 for (int i
= 0; next
->iterate_referring (i
, ref
); i
++)
2967 if (ref
->referring
->get_comdat_group () != get_comdat_group ())
2973 /* Return true when function cgraph_node can be expected to be removed
2974 from program when direct calls in this compilation unit are removed.
2976 As a special case COMDAT functions are
2977 cgraph_can_remove_if_no_direct_calls_p while the are not
2978 cgraph_only_called_directly_p (it is possible they are called from other
2981 This function behaves as cgraph_only_called_directly_p because eliminating
2982 all uses of COMDAT function does not make it necessarily disappear from
2983 the program unless we are compiling whole program or we do LTO. In this
2984 case we know we win since dynamic linking will not really discard the
2985 linkonce section. */
2988 cgraph_node::will_be_removed_from_program_if_no_direct_calls_p
2991 gcc_assert (!inlined_to
);
2992 if (DECL_EXTERNAL (decl
))
2995 if (!in_lto_p
&& !flag_whole_program
)
2997 /* If the symbol is in comdat group, we need to verify that whole comdat
2998 group becomes unreachable. Technically we could skip references from
2999 within the group, too. */
3000 if (!only_called_directly_p ())
3002 if (same_comdat_group
&& externally_visible
)
3004 struct cgraph_node
*target
= ultimate_alias_target ();
3006 if (will_inline
&& address_taken
)
3008 for (cgraph_node
*next
= dyn_cast
<cgraph_node
*> (same_comdat_group
);
3010 next
= dyn_cast
<cgraph_node
*> (next
->same_comdat_group
))
3012 if (!externally_visible
)
3015 && !next
->only_called_directly_p ())
3018 /* If we see different symbol than THIS,
3019 be sure to check calls. */
3020 if (next
->ultimate_alias_target () != target
)
3021 for (cgraph_edge
*e
= next
->callers
; e
; e
= e
->next_caller
)
3022 if (e
->caller
->get_comdat_group () != get_comdat_group ()
3030 return can_remove_if_no_direct_calls_p (will_inline
);
3034 /* Worker for cgraph_only_called_directly_p. */
3037 cgraph_not_only_called_directly_p_1 (cgraph_node
*node
, void *)
3039 return !node
->only_called_directly_or_aliased_p ();
3042 /* Return true when function cgraph_node and all its aliases are only called
3044 i.e. it is not externally visible, address was not taken and
3045 it is not used in any other non-standard way. */
3048 cgraph_node::only_called_directly_p (void)
3050 gcc_assert (ultimate_alias_target () == this);
3051 return !call_for_symbol_and_aliases (cgraph_not_only_called_directly_p_1
,
3056 /* Collect all callers of NODE. Worker for collect_callers_of_node. */
3059 collect_callers_of_node_1 (cgraph_node
*node
, void *data
)
3061 vec
<cgraph_edge
*> *redirect_callers
= (vec
<cgraph_edge
*> *)data
;
3063 enum availability avail
;
3064 node
->ultimate_alias_target (&avail
);
3066 if (avail
> AVAIL_INTERPOSABLE
)
3067 for (cs
= node
->callers
; cs
!= NULL
; cs
= cs
->next_caller
)
3068 if (!cs
->indirect_inlining_edge
3069 && !cs
->caller
->thunk
)
3070 redirect_callers
->safe_push (cs
);
3074 /* Collect all callers of cgraph_node and its aliases that are known to lead to
3075 cgraph_node (i.e. are not overwritable). */
3078 cgraph_node::collect_callers (void)
3080 vec
<cgraph_edge
*> redirect_callers
= vNULL
;
3081 call_for_symbol_thunks_and_aliases (collect_callers_of_node_1
,
3082 &redirect_callers
, false);
3083 return redirect_callers
;
3087 /* Return TRUE if NODE2 a clone of NODE or is equivalent to it. Return
3088 optimistically true if this cannot be determined. */
3091 clone_of_p (cgraph_node
*node
, cgraph_node
*node2
)
3093 node
= node
->ultimate_alias_target ();
3094 node2
= node2
->ultimate_alias_target ();
3096 if (node2
->clone_of
== node
3097 || node2
->former_clone_of
== node
->decl
)
3100 if (!node
->thunk
&& !node
->former_thunk_p ())
3103 && node
->decl
!= node2
->decl
3104 && node
->decl
!= node2
->former_clone_of
)
3105 node2
= node2
->clone_of
;
3106 return node2
!= NULL
;
3109 /* There are no virtual clones of thunks so check former_clone_of or if we
3110 might have skipped thunks because this adjustments are no longer
3112 while (node
->thunk
|| node
->former_thunk_p ())
3114 if (!thunk_info::get (node
)->this_adjusting
)
3116 /* In case of instrumented expanded thunks, which can have multiple calls
3117 in them, we do not know how to continue and just have to be
3118 optimistic. The same applies if all calls have already been inlined
3120 if (!node
->callees
|| node
->callees
->next_callee
)
3122 node
= node
->callees
->callee
->ultimate_alias_target ();
3124 clone_info
*info
= clone_info::get (node2
);
3125 if (!info
|| !info
->param_adjustments
3126 || info
->param_adjustments
->first_param_intact_p ())
3128 if (node2
->former_clone_of
== node
->decl
3129 || node2
->former_clone_of
== node
->former_clone_of
)
3132 cgraph_node
*n2
= node2
;
3133 while (n2
&& node
->decl
!= n2
->decl
)
3142 /* Verify edge count and frequency. */
3145 cgraph_edge::verify_count ()
3147 bool error_found
= false;
3148 if (!count
.verify ())
3150 error ("caller edge count invalid");
3156 /* Switch to THIS_CFUN if needed and print STMT to stderr. */
3158 cgraph_debug_gimple_stmt (function
*this_cfun
, gimple
*stmt
)
3160 bool fndecl_was_null
= false;
3161 /* debug_gimple_stmt needs correct cfun */
3162 if (cfun
!= this_cfun
)
3163 set_cfun (this_cfun
);
3164 /* ...and an actual current_function_decl */
3165 if (!current_function_decl
)
3167 current_function_decl
= this_cfun
->decl
;
3168 fndecl_was_null
= true;
3170 debug_gimple_stmt (stmt
);
3171 if (fndecl_was_null
)
3172 current_function_decl
= NULL
;
3175 /* Verify that call graph edge corresponds to DECL from the associated
3176 statement. Return true if the verification should fail. */
3179 cgraph_edge::verify_corresponds_to_fndecl (tree decl
)
3183 if (!decl
|| callee
->inlined_to
)
3185 if (symtab
->state
== LTO_STREAMING
)
3187 node
= cgraph_node::get (decl
);
3189 /* We do not know if a node from a different partition is an alias or what it
3190 aliases and therefore cannot do the former_clone_of check reliably. When
3191 body_removed is set, we have lost all information about what was alias or
3192 thunk of and also cannot proceed. */
3194 || node
->body_removed
3195 || node
->in_other_partition
3196 || callee
->icf_merged
3197 || callee
->in_other_partition
)
3200 node
= node
->ultimate_alias_target ();
3202 /* Optimizers can redirect unreachable calls or calls triggering undefined
3203 behavior to builtin_unreachable. */
3205 if (fndecl_built_in_p (callee
->decl
, BUILT_IN_UNREACHABLE
))
3208 if (callee
->former_clone_of
!= node
->decl
3209 && (node
!= callee
->ultimate_alias_target ())
3210 && !clone_of_p (node
, callee
))
3216 /* Disable warnings about missing quoting in GCC diagnostics for
3217 the verification errors. Their format strings don't follow GCC
3218 diagnostic conventions and the calls are ultimately followed by
3219 one to internal_error. */
3221 # pragma GCC diagnostic push
3222 # pragma GCC diagnostic ignored "-Wformat-diag"
3225 /* Verify consistency of speculative call in NODE corresponding to STMT
3226 and LTO_STMT_UID. If INDIRECT is set, assume that it is the indirect
3227 edge of call sequence. Return true if error is found.
3229 This function is called to every component of indirect call (direct edges,
3230 indirect edge and refs). To save duplicated work, do full testing only
3233 verify_speculative_call (struct cgraph_node
*node
, gimple
*stmt
,
3234 unsigned int lto_stmt_uid
,
3235 struct cgraph_edge
*indirect
)
3237 if (indirect
== NULL
)
3239 for (indirect
= node
->indirect_calls
; indirect
;
3240 indirect
= indirect
->next_callee
)
3241 if (indirect
->call_stmt
== stmt
3242 && indirect
->lto_stmt_uid
== lto_stmt_uid
)
3246 error ("missing indirect call in speculative call sequence");
3249 if (!indirect
->speculative
)
3251 error ("indirect call in speculative call sequence has no "
3252 "speculative flag");
3258 /* Maximal number of targets. We probably will never want to have more than
3260 const unsigned int num
= 256;
3261 cgraph_edge
*direct_calls
[num
];
3264 for (unsigned int i
= 0; i
< num
; i
++)
3266 direct_calls
[i
] = NULL
;
3270 cgraph_edge
*first_call
= NULL
;
3271 cgraph_edge
*prev_call
= NULL
;
3273 for (cgraph_edge
*direct
= node
->callees
; direct
;
3274 direct
= direct
->next_callee
)
3275 if (direct
->call_stmt
== stmt
&& direct
->lto_stmt_uid
== lto_stmt_uid
)
3278 first_call
= direct
;
3279 if (prev_call
&& direct
!= prev_call
->next_callee
)
3281 error ("speculative edges are not adjacent");
3285 if (!direct
->speculative
)
3287 error ("direct call to %s in speculative call sequence has no "
3288 "speculative flag", direct
->callee
->dump_name ());
3291 if (direct
->speculative_id
>= num
)
3293 error ("direct call to %s in speculative call sequence has "
3294 "speculative_id %i out of range",
3295 direct
->callee
->dump_name (), direct
->speculative_id
);
3298 if (direct_calls
[direct
->speculative_id
])
3300 error ("duplicate direct call to %s in speculative call sequence "
3301 "with speculative_id %i",
3302 direct
->callee
->dump_name (), direct
->speculative_id
);
3305 direct_calls
[direct
->speculative_id
] = direct
;
3308 if (first_call
->call_stmt
3309 && first_call
!= node
->get_edge (first_call
->call_stmt
))
3311 error ("call stmt hash does not point to first direct edge of "
3312 "speculative call sequence");
3317 for (int i
= 0; node
->iterate_reference (i
, ref
); i
++)
3318 if (ref
->speculative
3319 && ref
->stmt
== stmt
&& ref
->lto_stmt_uid
== lto_stmt_uid
)
3321 if (ref
->speculative_id
>= num
)
3323 error ("direct call to %s in speculative call sequence has "
3324 "speculative_id %i out of range",
3325 ref
->referred
->dump_name (), ref
->speculative_id
);
3328 if (refs
[ref
->speculative_id
])
3330 error ("duplicate reference %s in speculative call sequence "
3331 "with speculative_id %i",
3332 ref
->referred
->dump_name (), ref
->speculative_id
);
3335 refs
[ref
->speculative_id
] = ref
;
3338 int num_targets
= 0;
3339 for (unsigned int i
= 0 ; i
< num
; i
++)
3341 if (refs
[i
] && !direct_calls
[i
])
3343 error ("missing direct call for speculation %i", i
);
3346 if (!refs
[i
] && direct_calls
[i
])
3348 error ("missing ref for speculation %i", i
);
3351 if (refs
[i
] != NULL
)
3355 if (num_targets
!= indirect
->num_speculative_call_targets_p ())
3357 error ("number of speculative targets %i mismatched with "
3358 "num_speculative_call_targets %i",
3360 indirect
->num_speculative_call_targets_p ());
3366 /* Verify cgraph nodes of given cgraph node. */
3368 cgraph_node::verify_node (void)
3371 function
*this_cfun
= DECL_STRUCT_FUNCTION (decl
);
3372 basic_block this_block
;
3373 gimple_stmt_iterator gsi
;
3374 bool error_found
= false;
3376 ipa_ref
*ref
= NULL
;
3381 timevar_push (TV_CGRAPH_VERIFY
);
3382 error_found
|= verify_base ();
3383 for (e
= callees
; e
; e
= e
->next_callee
)
3386 error ("aux field set for edge %s->%s",
3387 identifier_to_locale (e
->caller
->name ()),
3388 identifier_to_locale (e
->callee
->name ()));
3391 if (!count
.verify ())
3393 error ("cgraph count invalid");
3396 if (inlined_to
&& same_comdat_group
)
3398 error ("inline clone in same comdat group list");
3401 if (inlined_to
&& !count
.compatible_p (inlined_to
->count
))
3403 error ("inline clone count is not compatible");
3405 inlined_to
->count
.debug ();
3408 if (tp_first_run
< 0)
3410 error ("tp_first_run must be non-negative");
3413 if (!definition
&& !in_other_partition
&& local
)
3415 error ("local symbols must be defined");
3418 if (inlined_to
&& externally_visible
)
3420 error ("externally visible inline clone");
3423 if (inlined_to
&& address_taken
)
3425 error ("inline clone with address taken");
3428 if (inlined_to
&& force_output
)
3430 error ("inline clone is forced to output");
3433 if (symtab
->state
!= LTO_STREAMING
)
3435 if (calls_comdat_local
&& !same_comdat_group
)
3437 error ("calls_comdat_local is set outside of a comdat group");
3440 if (!inlined_to
&& calls_comdat_local
!= check_calls_comdat_local_p ())
3442 error ("invalid calls_comdat_local flag");
3446 if (DECL_IS_MALLOC (decl
)
3447 && !POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (decl
))))
3449 error ("malloc attribute should be used for a function that "
3450 "returns a pointer");
3453 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
3457 error ("aux field set for indirect edge from %s",
3458 identifier_to_locale (e
->caller
->name ()));
3461 if (!e
->count
.compatible_p (count
))
3463 error ("edge count is not compatible with function count");
3468 if (!e
->indirect_unknown_callee
3469 || !e
->indirect_info
)
3471 error ("An indirect edge from %s is not marked as indirect or has "
3472 "associated indirect_info, the corresponding statement is: ",
3473 identifier_to_locale (e
->caller
->name ()));
3474 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3477 if (e
->call_stmt
&& e
->lto_stmt_uid
)
3479 error ("edge has both call_stmt and lto_stmt_uid set");
3483 bool check_comdat
= comdat_local_p ();
3484 for (e
= callers
; e
; e
= e
->next_caller
)
3486 if (e
->verify_count ())
3489 && !in_same_comdat_group_p (e
->caller
))
3491 error ("comdat-local function called by %s outside its comdat",
3492 identifier_to_locale (e
->caller
->name ()));
3495 if (!e
->inline_failed
)
3498 != (e
->caller
->inlined_to
3499 ? e
->caller
->inlined_to
: e
->caller
))
3501 error ("inlined_to pointer is wrong");
3504 if (callers
->next_caller
)
3506 error ("multiple inline callers");
3513 error ("inlined_to pointer set for noninline callers");
3517 for (e
= callees
; e
; e
= e
->next_callee
)
3519 if (e
->verify_count ())
3521 if (!e
->count
.compatible_p (count
))
3523 error ("edge count is not compatible with function count");
3528 if (gimple_has_body_p (e
->caller
->decl
)
3529 && !e
->caller
->inlined_to
3531 /* Optimized out calls are redirected to __builtin_unreachable. */
3532 && (e
->count
.nonzero_p ()
3533 || ! e
->callee
->decl
3534 || !fndecl_built_in_p (e
->callee
->decl
, BUILT_IN_UNREACHABLE
))
3536 == ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (decl
))->count
3537 && (!e
->count
.ipa_p ()
3538 && e
->count
.differs_from_p (gimple_bb (e
->call_stmt
)->count
)))
3540 error ("caller edge count does not match BB count");
3541 fprintf (stderr
, "edge count: ");
3542 e
->count
.dump (stderr
);
3543 fprintf (stderr
, "\n bb count: ");
3544 gimple_bb (e
->call_stmt
)->count
.dump (stderr
);
3545 fprintf (stderr
, "\n");
3548 if (e
->call_stmt
&& e
->lto_stmt_uid
)
3550 error ("edge has both call_stmt and lto_stmt_uid set");
3554 && verify_speculative_call (e
->caller
, e
->call_stmt
, e
->lto_stmt_uid
,
3558 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
3560 if (e
->verify_count ())
3562 if (gimple_has_body_p (e
->caller
->decl
)
3563 && !e
->caller
->inlined_to
3565 && e
->count
.ipa_p ()
3567 == ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (decl
))->count
3568 && (!e
->count
.ipa_p ()
3569 && e
->count
.differs_from_p (gimple_bb (e
->call_stmt
)->count
)))
3571 error ("indirect call count does not match BB count");
3572 fprintf (stderr
, "edge count: ");
3573 e
->count
.dump (stderr
);
3574 fprintf (stderr
, "\n bb count: ");
3575 gimple_bb (e
->call_stmt
)->count
.dump (stderr
);
3576 fprintf (stderr
, "\n");
3580 && verify_speculative_call (e
->caller
, e
->call_stmt
, e
->lto_stmt_uid
,
3584 for (i
= 0; iterate_reference (i
, ref
); i
++)
3586 if (ref
->stmt
&& ref
->lto_stmt_uid
)
3588 error ("reference has both stmt and lto_stmt_uid set");
3591 if (ref
->speculative
3592 && verify_speculative_call (this, ref
->stmt
,
3593 ref
->lto_stmt_uid
, NULL
))
3597 if (!callers
&& inlined_to
)
3599 error ("inlined_to pointer is set but no predecessors found");
3602 if (inlined_to
== this)
3604 error ("inlined_to pointer refers to itself");
3610 cgraph_node
*first_clone
= clone_of
->clones
;
3611 if (first_clone
!= this)
3613 if (prev_sibling_clone
->clone_of
!= clone_of
)
3615 error ("cgraph_node has wrong clone_of");
3623 for (n
= clones
; n
; n
= n
->next_sibling_clone
)
3624 if (n
->clone_of
!= this)
3628 error ("cgraph_node has wrong clone list");
3632 if ((prev_sibling_clone
|| next_sibling_clone
) && !clone_of
)
3634 error ("cgraph_node is in clone list but it is not clone");
3637 if (!prev_sibling_clone
&& clone_of
&& clone_of
->clones
!= this)
3639 error ("cgraph_node has wrong prev_clone pointer");
3642 if (prev_sibling_clone
&& prev_sibling_clone
->next_sibling_clone
!= this)
3644 error ("double linked list of clones corrupted");
3648 if (analyzed
&& alias
)
3650 bool ref_found
= false;
3652 ipa_ref
*ref
= NULL
;
3656 error ("Alias has call edges");
3659 for (i
= 0; iterate_reference (i
, ref
); i
++)
3660 if (ref
->use
!= IPA_REF_ALIAS
)
3662 error ("Alias has non-alias reference");
3667 error ("Alias has more than one alias reference");
3674 error ("Analyzed alias has no reference");
3679 if (analyzed
&& thunk
)
3683 error ("No edge out of thunk node");
3686 else if (callees
->next_callee
)
3688 error ("More than one edge out of thunk node");
3691 if (gimple_has_body_p (decl
) && !inlined_to
)
3693 error ("Thunk is not supposed to have body");
3697 else if (analyzed
&& gimple_has_body_p (decl
)
3698 && !TREE_ASM_WRITTEN (decl
)
3699 && (!DECL_EXTERNAL (decl
) || inlined_to
)
3704 hash_set
<gimple
*> stmts
;
3706 /* Reach the trees by walking over the CFG, and note the
3707 enclosing basic-blocks in the call edges. */
3708 FOR_EACH_BB_FN (this_block
, this_cfun
)
3710 for (gsi
= gsi_start_phis (this_block
);
3711 !gsi_end_p (gsi
); gsi_next (&gsi
))
3712 stmts
.add (gsi_stmt (gsi
));
3713 for (gsi
= gsi_start_bb (this_block
);
3717 gimple
*stmt
= gsi_stmt (gsi
);
3719 if (is_gimple_call (stmt
))
3721 cgraph_edge
*e
= get_edge (stmt
);
3722 tree decl
= gimple_call_fndecl (stmt
);
3727 error ("shared call_stmt:");
3728 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
3731 if (!e
->indirect_unknown_callee
)
3733 if (e
->verify_corresponds_to_fndecl (decl
))
3735 error ("edge points to wrong declaration:");
3736 debug_tree (e
->callee
->decl
);
3737 fprintf (stderr
," Instead of:");
3744 error ("an indirect edge with unknown callee "
3745 "corresponding to a call_stmt with "
3746 "a known declaration:");
3748 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3754 error ("missing callgraph edge for call stmt:");
3755 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
3761 for (i
= 0; iterate_reference (i
, ref
); i
++)
3762 if (ref
->stmt
&& !stmts
.contains (ref
->stmt
))
3764 error ("reference to dead statement");
3765 cgraph_debug_gimple_stmt (this_cfun
, ref
->stmt
);
3770 /* No CFG available?! */
3773 for (e
= callees
; e
; e
= e
->next_callee
)
3775 if (!e
->aux
&& !e
->speculative
)
3777 error ("edge %s->%s has no corresponding call_stmt",
3778 identifier_to_locale (e
->caller
->name ()),
3779 identifier_to_locale (e
->callee
->name ()));
3780 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3785 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
3787 if (!e
->aux
&& !e
->speculative
)
3789 error ("an indirect edge from %s has no corresponding call_stmt",
3790 identifier_to_locale (e
->caller
->name ()));
3791 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3798 if (nested_function_info
*info
= nested_function_info::get (this))
3800 if (info
->nested
!= NULL
)
3802 for (cgraph_node
*n
= info
->nested
; n
!= NULL
;
3803 n
= next_nested_function (n
))
3805 nested_function_info
*ninfo
= nested_function_info::get (n
);
3806 if (ninfo
->origin
== NULL
)
3808 error ("missing origin for a node in a nested list");
3811 else if (ninfo
->origin
!= this)
3813 error ("origin points to a different parent");
3819 if (info
->next_nested
!= NULL
&& info
->origin
== NULL
)
3821 error ("missing origin for a node in a nested list");
3829 internal_error ("verify_cgraph_node failed");
3831 timevar_pop (TV_CGRAPH_VERIFY
);
3834 /* Verify whole cgraph structure. */
3836 cgraph_node::verify_cgraph_nodes (void)
3843 FOR_EACH_FUNCTION (node
)
3848 # pragma GCC diagnostic pop
3851 /* Walk the alias chain to return the function cgraph_node is alias of.
3852 Walk through thunks, too.
3853 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3854 When REF is non-NULL, assume that reference happens in symbol REF
3855 when determining the availability. */
3858 cgraph_node::function_symbol (enum availability
*availability
,
3859 struct symtab_node
*ref
)
3861 cgraph_node
*node
= ultimate_alias_target (availability
, ref
);
3865 enum availability a
;
3868 node
= node
->callees
->callee
;
3869 node
= node
->ultimate_alias_target (availability
? &a
: NULL
, ref
);
3870 if (availability
&& a
< *availability
)
3876 /* Walk the alias chain to return the function cgraph_node is alias of.
3877 Walk through non virtual thunks, too. Thus we return either a function
3878 or a virtual thunk node.
3879 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3880 When REF is non-NULL, assume that reference happens in symbol REF
3881 when determining the availability. */
3884 cgraph_node::function_or_virtual_thunk_symbol
3885 (enum availability
*availability
,
3886 struct symtab_node
*ref
)
3888 cgraph_node
*node
= ultimate_alias_target (availability
, ref
);
3890 while (node
->thunk
&& !thunk_info::get (node
)->virtual_offset_p
)
3892 enum availability a
;
3895 node
= node
->callees
->callee
;
3896 node
= node
->ultimate_alias_target (availability
? &a
: NULL
, ref
);
3897 if (availability
&& a
< *availability
)
3903 /* When doing LTO, read cgraph_node's body from disk if it is not already
3904 present. Also perform any necessary clone materializations. */
3907 cgraph_node::get_untransformed_body ()
3909 lto_file_decl_data
*file_data
;
3910 const char *data
, *name
;
3912 tree decl
= this->decl
;
3914 /* See if there is clone to be materialized.
3915 (inline clones does not need materialization, but we can be seeing
3916 an inline clone of real clone). */
3917 cgraph_node
*p
= this;
3918 for (cgraph_node
*c
= clone_of
; c
; c
= c
->clone_of
)
3920 if (c
->decl
!= decl
)
3921 p
->materialize_clone ();
3925 /* Check if body is already there. Either we have gimple body or
3926 the function is thunk and in that case we set DECL_ARGUMENTS. */
3927 if (DECL_ARGUMENTS (decl
) || gimple_has_body_p (decl
))
3930 gcc_assert (in_lto_p
&& !DECL_RESULT (decl
));
3932 timevar_push (TV_IPA_LTO_GIMPLE_IN
);
3934 file_data
= lto_file_data
;
3935 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
3937 /* We may have renamed the declaration, e.g., a static function. */
3938 name
= lto_get_decl_name_mapping (file_data
, name
);
3939 struct lto_in_decl_state
*decl_state
3940 = lto_get_function_in_decl_state (file_data
, decl
);
3942 cgraph_node
*origin
= this;
3943 while (origin
->clone_of
)
3944 origin
= origin
->clone_of
;
3946 int stream_order
= origin
->order
- file_data
->order_base
;
3947 data
= lto_get_section_data (file_data
, LTO_section_function_body
,
3948 name
, stream_order
, &len
,
3949 decl_state
->compressed
);
3951 fatal_error (input_location
, "%s: section %s.%d is missing",
3952 file_data
->file_name
, name
, stream_order
);
3954 gcc_assert (DECL_STRUCT_FUNCTION (decl
) == NULL
);
3957 fprintf (stderr
, " in:%s", IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
3958 lto_input_function_body (file_data
, this, data
);
3959 lto_stats
.num_function_bodies
++;
3960 lto_free_section_data (file_data
, LTO_section_function_body
, name
,
3961 data
, len
, decl_state
->compressed
);
3962 lto_free_function_in_decl_state_for_node (this);
3963 /* Keep lto file data so ipa-inline-analysis knows about cross module
3966 timevar_pop (TV_IPA_LTO_GIMPLE_IN
);
3971 /* Prepare function body. When doing LTO, read cgraph_node's body from disk
3972 if it is not already present. When some IPA transformations are scheduled,
3976 cgraph_node::get_body (void)
3980 updated
= get_untransformed_body ();
3982 /* Getting transformed body makes no sense for inline clones;
3983 we should never use this on real clones because they are materialized
3985 TODO: Materializing clones here will likely lead to smaller LTRANS
3987 gcc_assert (!inlined_to
&& !clone_of
);
3988 if (ipa_transforms_to_apply
.exists ())
3990 opt_pass
*saved_current_pass
= current_pass
;
3991 FILE *saved_dump_file
= dump_file
;
3992 const char *saved_dump_file_name
= dump_file_name
;
3993 dump_flags_t saved_dump_flags
= dump_flags
;
3994 dump_file_name
= NULL
;
3995 set_dump_file (NULL
);
3997 push_cfun (DECL_STRUCT_FUNCTION (decl
));
3999 update_ssa (TODO_update_ssa_only_virtuals
);
4000 execute_all_ipa_transforms (true);
4001 cgraph_edge::rebuild_edges ();
4002 free_dominance_info (CDI_DOMINATORS
);
4003 free_dominance_info (CDI_POST_DOMINATORS
);
4007 current_pass
= saved_current_pass
;
4008 set_dump_file (saved_dump_file
);
4009 dump_file_name
= saved_dump_file_name
;
4010 dump_flags
= saved_dump_flags
;
4015 /* Return the DECL_STRUCT_FUNCTION of the function. */
4018 cgraph_node::get_fun () const
4020 const cgraph_node
*node
= this;
4021 struct function
*fun
= DECL_STRUCT_FUNCTION (node
->decl
);
4023 while (!fun
&& node
->clone_of
)
4025 node
= node
->clone_of
;
4026 fun
= DECL_STRUCT_FUNCTION (node
->decl
);
4032 /* Reset all state within cgraph.c so that we can rerun the compiler
4033 within the same process. For use by toplev::finalize. */
4036 cgraph_c_finalize (void)
4038 nested_function_info::release ();
4039 thunk_info::release ();
4040 clone_info::release ();
4043 x_cgraph_nodes_queue
= NULL
;
4045 cgraph_fnver_htab
= NULL
;
4046 version_info_node
= NULL
;
4049 /* A worker for call_for_symbol_and_aliases. */
4052 cgraph_node::call_for_symbol_and_aliases_1 (bool (*callback
) (cgraph_node
*,
4055 bool include_overwritable
)
4058 FOR_EACH_ALIAS (this, ref
)
4060 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
4061 if (include_overwritable
4062 || alias
->get_availability () > AVAIL_INTERPOSABLE
)
4063 if (alias
->call_for_symbol_and_aliases (callback
, data
,
4064 include_overwritable
))
4070 /* Return true if NODE has thunk. */
4073 cgraph_node::has_thunk_p (cgraph_node
*node
, void *)
4075 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
4076 if (e
->caller
->thunk
)
4081 /* Expected frequency of executions within the function. */
4084 cgraph_edge::sreal_frequency ()
4086 return count
.to_sreal_scale (caller
->inlined_to
4087 ? caller
->inlined_to
->count
4092 /* During LTO stream in this can be used to check whether call can possibly
4093 be internal to the current translation unit. */
4096 cgraph_edge::possibly_call_in_translation_unit_p (void)
4098 gcc_checking_assert (in_lto_p
&& caller
->prevailing_p ());
4100 /* While incremental linking we may end up getting function body later. */
4101 if (flag_incremental_link
== INCREMENTAL_LINK_LTO
)
4104 /* We may be smarter here and avoid streaming in indirect calls we can't
4105 track, but that would require arranging streaming the indirect call
4110 /* If callee is local to the original translation unit, it will be
4112 if (!TREE_PUBLIC (callee
->decl
) && !DECL_EXTERNAL (callee
->decl
))
4115 /* Otherwise we need to lookup prevailing symbol (symbol table is not merged,
4116 yet) and see if it is a definition. In fact we may also resolve aliases,
4117 but that is probably not too important. */
4118 symtab_node
*node
= callee
;
4119 for (int n
= 10; node
->previous_sharing_asm_name
&& n
; n
--)
4120 node
= node
->previous_sharing_asm_name
;
4121 if (node
->previous_sharing_asm_name
)
4122 node
= symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (callee
->decl
));
4123 gcc_assert (TREE_PUBLIC (node
->decl
));
4124 return node
->get_availability () >= AVAIL_INTERPOSABLE
;
4127 /* Return num_speculative_targets of this edge. */
4130 cgraph_edge::num_speculative_call_targets_p (void)
4132 return indirect_info
? indirect_info
->num_speculative_call_targets
: 0;
4135 /* Check if function calls comdat local. This is used to recompute
4136 calls_comdat_local flag after function transformations. */
4138 cgraph_node::check_calls_comdat_local_p ()
4140 for (cgraph_edge
*e
= callees
; e
; e
= e
->next_callee
)
4141 if (e
->inline_failed
4142 ? e
->callee
->comdat_local_p ()
4143 : e
->callee
->check_calls_comdat_local_p ())
4148 /* Return true if this node represents a former, i.e. an expanded, thunk. */
4151 cgraph_node::former_thunk_p (void)
4155 thunk_info
*i
= thunk_info::get (this);
4158 gcc_checking_assert (i
->fixed_offset
|| i
->virtual_offset_p
4159 || i
->indirect_offset
);
4163 /* A stashed copy of "symtab" for use by selftest::symbol_table_test.
4164 This needs to be a global so that it can be a GC root, and thus
4165 prevent the stashed copy from being garbage-collected if the GC runs
4166 during a symbol_table_test. */
4168 symbol_table
*saved_symtab
;
4172 namespace selftest
{
4174 /* class selftest::symbol_table_test. */
4176 /* Constructor. Store the old value of symtab, and create a new one. */
4178 symbol_table_test::symbol_table_test ()
4180 gcc_assert (saved_symtab
== NULL
);
4181 saved_symtab
= symtab
;
4182 symtab
= new (ggc_alloc
<symbol_table
> ()) symbol_table ();
4185 /* Destructor. Restore the old value of symtab. */
4187 symbol_table_test::~symbol_table_test ()
4189 gcc_assert (saved_symtab
!= NULL
);
4190 symtab
= saved_symtab
;
4191 saved_symtab
= NULL
;
4194 /* Verify that symbol_table_test works. */
4197 test_symbol_table_test ()
4199 /* Simulate running two selftests involving symbol tables. */
4200 for (int i
= 0; i
< 2; i
++)
4202 symbol_table_test stt
;
4203 tree test_decl
= build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
,
4204 get_identifier ("test_decl"),
4205 build_function_type_list (void_type_node
,
4207 cgraph_node
*node
= cgraph_node::get_create (test_decl
);
4210 /* Verify that the node has order 0 on both iterations,
4211 and thus that nodes have predictable dump names in selftests. */
4212 ASSERT_EQ (node
->order
, 0);
4213 ASSERT_STREQ (node
->dump_name (), "test_decl/0");
4217 /* Run all of the selftests within this file. */
4222 test_symbol_table_test ();
4225 } // namespace selftest
4227 #endif /* CHECKING_P */
4229 #include "gt-cgraph.h"