1 /* Callgraph handling code.
2 Copyright (C) 2003-2019 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"
63 #include "stringpool.h"
67 /* FIXME: Only for PROP_loops, but cgraph shouldn't have to know about this. */
68 #include "tree-pass.h"
70 /* Queue of cgraph nodes scheduled to be lowered. */
71 symtab_node
*x_cgraph_nodes_queue
;
72 #define cgraph_nodes_queue ((cgraph_node *)x_cgraph_nodes_queue)
74 /* Symbol table global context. */
77 /* List of hooks triggered on cgraph_edge events. */
78 struct cgraph_edge_hook_list
{
79 cgraph_edge_hook hook
;
81 struct cgraph_edge_hook_list
*next
;
84 /* List of hooks triggered on cgraph_node events. */
85 struct cgraph_node_hook_list
{
86 cgraph_node_hook hook
;
88 struct cgraph_node_hook_list
*next
;
91 /* List of hooks triggered on events involving two cgraph_edges. */
92 struct cgraph_2edge_hook_list
{
93 cgraph_2edge_hook hook
;
95 struct cgraph_2edge_hook_list
*next
;
98 /* List of hooks triggered on events involving two cgraph_nodes. */
99 struct cgraph_2node_hook_list
{
100 cgraph_2node_hook hook
;
102 struct cgraph_2node_hook_list
*next
;
105 /* Hash descriptor for cgraph_function_version_info. */
107 struct function_version_hasher
: ggc_ptr_hash
<cgraph_function_version_info
>
109 static hashval_t
hash (cgraph_function_version_info
*);
110 static bool equal (cgraph_function_version_info
*,
111 cgraph_function_version_info
*);
114 /* Map a cgraph_node to cgraph_function_version_info using this htab.
115 The cgraph_function_version_info has a THIS_NODE field that is the
116 corresponding cgraph_node.. */
118 static GTY(()) hash_table
<function_version_hasher
> *cgraph_fnver_htab
= NULL
;
120 /* Hash function for cgraph_fnver_htab. */
122 function_version_hasher::hash (cgraph_function_version_info
*ptr
)
124 int uid
= ptr
->this_node
->get_uid ();
125 return (hashval_t
)(uid
);
128 /* eq function for cgraph_fnver_htab. */
130 function_version_hasher::equal (cgraph_function_version_info
*n1
,
131 cgraph_function_version_info
*n2
)
133 return n1
->this_node
->get_uid () == n2
->this_node
->get_uid ();
136 /* Mark as GC root all allocated nodes. */
137 static GTY(()) struct cgraph_function_version_info
*
138 version_info_node
= NULL
;
140 /* Return true if NODE's address can be compared. */
143 symtab_node::address_can_be_compared_p ()
145 /* Address of virtual tables and functions is never compared. */
146 if (DECL_VIRTUAL_P (decl
))
148 /* Address of C++ cdtors is never compared. */
149 if (is_a
<cgraph_node
*> (this)
150 && (DECL_CXX_CONSTRUCTOR_P (decl
)
151 || DECL_CXX_DESTRUCTOR_P (decl
)))
153 /* Constant pool symbols addresses are never compared.
154 flag_merge_constants permits us to assume the same on readonly vars. */
155 if (is_a
<varpool_node
*> (this)
156 && (DECL_IN_CONSTANT_POOL (decl
)
157 || (flag_merge_constants
>= 2
158 && TREE_READONLY (decl
) && !TREE_THIS_VOLATILE (decl
))))
163 /* Get the cgraph_function_version_info node corresponding to node. */
164 cgraph_function_version_info
*
165 cgraph_node::function_version (void)
167 cgraph_function_version_info key
;
168 key
.this_node
= this;
170 if (cgraph_fnver_htab
== NULL
)
173 return cgraph_fnver_htab
->find (&key
);
176 /* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
177 corresponding to cgraph_node NODE. */
178 cgraph_function_version_info
*
179 cgraph_node::insert_new_function_version (void)
181 version_info_node
= NULL
;
182 version_info_node
= ggc_cleared_alloc
<cgraph_function_version_info
> ();
183 version_info_node
->this_node
= this;
185 if (cgraph_fnver_htab
== NULL
)
186 cgraph_fnver_htab
= hash_table
<function_version_hasher
>::create_ggc (2);
188 *cgraph_fnver_htab
->find_slot (version_info_node
, INSERT
)
190 return version_info_node
;
193 /* Remove the cgraph_function_version_info node given by DECL_V. */
195 delete_function_version (cgraph_function_version_info
*decl_v
)
200 if (version_info_node
== decl_v
)
201 version_info_node
= NULL
;
203 if (decl_v
->prev
!= NULL
)
204 decl_v
->prev
->next
= decl_v
->next
;
206 if (decl_v
->next
!= NULL
)
207 decl_v
->next
->prev
= decl_v
->prev
;
209 if (cgraph_fnver_htab
!= NULL
)
210 cgraph_fnver_htab
->remove_elt (decl_v
);
213 /* Remove the cgraph_function_version_info and cgraph_node for DECL. This
214 DECL is a duplicate declaration. */
216 cgraph_node::delete_function_version_by_decl (tree decl
)
218 cgraph_node
*decl_node
= cgraph_node::get (decl
);
220 if (decl_node
== NULL
)
223 delete_function_version (decl_node
->function_version ());
225 decl_node
->remove ();
228 /* Record that DECL1 and DECL2 are semantically identical function
231 cgraph_node::record_function_versions (tree decl1
, tree decl2
)
233 cgraph_node
*decl1_node
= cgraph_node::get_create (decl1
);
234 cgraph_node
*decl2_node
= cgraph_node::get_create (decl2
);
235 cgraph_function_version_info
*decl1_v
= NULL
;
236 cgraph_function_version_info
*decl2_v
= NULL
;
237 cgraph_function_version_info
*before
;
238 cgraph_function_version_info
*after
;
240 gcc_assert (decl1_node
!= NULL
&& decl2_node
!= NULL
);
241 decl1_v
= decl1_node
->function_version ();
242 decl2_v
= decl2_node
->function_version ();
244 if (decl1_v
!= NULL
&& decl2_v
!= NULL
)
248 decl1_v
= decl1_node
->insert_new_function_version ();
251 decl2_v
= decl2_node
->insert_new_function_version ();
253 /* Chain decl2_v and decl1_v. All semantically identical versions
254 will be chained together. */
259 while (before
->next
!= NULL
)
260 before
= before
->next
;
262 while (after
->prev
!= NULL
)
265 before
->next
= after
;
266 after
->prev
= before
;
269 /* Initialize callgraph dump file. */
272 symbol_table::initialize (void)
275 dump_file
= dump_begin (TDI_cgraph
, NULL
);
277 if (!ipa_clones_dump_file
)
278 ipa_clones_dump_file
= dump_begin (TDI_clones
, NULL
);
281 /* Allocate new callgraph node and insert it into basic data structures. */
284 symbol_table::create_empty (void)
286 cgraph_node
*node
= allocate_cgraph_symbol ();
288 node
->type
= SYMTAB_FUNCTION
;
289 node
->frequency
= NODE_FREQUENCY_NORMAL
;
290 node
->count_materialization_scale
= REG_BR_PROB_BASE
;
296 /* Register HOOK to be called with DATA on each removed edge. */
297 cgraph_edge_hook_list
*
298 symbol_table::add_edge_removal_hook (cgraph_edge_hook hook
, void *data
)
300 cgraph_edge_hook_list
*entry
;
301 cgraph_edge_hook_list
**ptr
= &m_first_edge_removal_hook
;
303 entry
= (cgraph_edge_hook_list
*) xmalloc (sizeof (*entry
));
313 /* Remove ENTRY from the list of hooks called on removing edges. */
315 symbol_table::remove_edge_removal_hook (cgraph_edge_hook_list
*entry
)
317 cgraph_edge_hook_list
**ptr
= &m_first_edge_removal_hook
;
319 while (*ptr
!= entry
)
325 /* Call all edge removal hooks. */
327 symbol_table::call_edge_removal_hooks (cgraph_edge
*e
)
329 cgraph_edge_hook_list
*entry
= m_first_edge_removal_hook
;
332 entry
->hook (e
, entry
->data
);
337 /* Register HOOK to be called with DATA on each removed node. */
338 cgraph_node_hook_list
*
339 symbol_table::add_cgraph_removal_hook (cgraph_node_hook hook
, void *data
)
341 cgraph_node_hook_list
*entry
;
342 cgraph_node_hook_list
**ptr
= &m_first_cgraph_removal_hook
;
344 entry
= (cgraph_node_hook_list
*) xmalloc (sizeof (*entry
));
354 /* Remove ENTRY from the list of hooks called on removing nodes. */
356 symbol_table::remove_cgraph_removal_hook (cgraph_node_hook_list
*entry
)
358 cgraph_node_hook_list
**ptr
= &m_first_cgraph_removal_hook
;
360 while (*ptr
!= entry
)
366 /* Call all node removal hooks. */
368 symbol_table::call_cgraph_removal_hooks (cgraph_node
*node
)
370 cgraph_node_hook_list
*entry
= m_first_cgraph_removal_hook
;
373 entry
->hook (node
, entry
->data
);
378 /* Call all node removal hooks. */
380 symbol_table::call_cgraph_insertion_hooks (cgraph_node
*node
)
382 cgraph_node_hook_list
*entry
= m_first_cgraph_insertion_hook
;
385 entry
->hook (node
, entry
->data
);
391 /* Register HOOK to be called with DATA on each inserted node. */
392 cgraph_node_hook_list
*
393 symbol_table::add_cgraph_insertion_hook (cgraph_node_hook hook
, void *data
)
395 cgraph_node_hook_list
*entry
;
396 cgraph_node_hook_list
**ptr
= &m_first_cgraph_insertion_hook
;
398 entry
= (cgraph_node_hook_list
*) xmalloc (sizeof (*entry
));
408 /* Remove ENTRY from the list of hooks called on inserted nodes. */
410 symbol_table::remove_cgraph_insertion_hook (cgraph_node_hook_list
*entry
)
412 cgraph_node_hook_list
**ptr
= &m_first_cgraph_insertion_hook
;
414 while (*ptr
!= entry
)
420 /* Register HOOK to be called with DATA on each duplicated edge. */
421 cgraph_2edge_hook_list
*
422 symbol_table::add_edge_duplication_hook (cgraph_2edge_hook hook
, void *data
)
424 cgraph_2edge_hook_list
*entry
;
425 cgraph_2edge_hook_list
**ptr
= &m_first_edge_duplicated_hook
;
427 entry
= (cgraph_2edge_hook_list
*) xmalloc (sizeof (*entry
));
437 /* Remove ENTRY from the list of hooks called on duplicating edges. */
439 symbol_table::remove_edge_duplication_hook (cgraph_2edge_hook_list
*entry
)
441 cgraph_2edge_hook_list
**ptr
= &m_first_edge_duplicated_hook
;
443 while (*ptr
!= entry
)
449 /* Call all edge duplication hooks. */
451 symbol_table::call_edge_duplication_hooks (cgraph_edge
*cs1
, cgraph_edge
*cs2
)
453 cgraph_2edge_hook_list
*entry
= m_first_edge_duplicated_hook
;
456 entry
->hook (cs1
, cs2
, entry
->data
);
461 /* Register HOOK to be called with DATA on each duplicated node. */
462 cgraph_2node_hook_list
*
463 symbol_table::add_cgraph_duplication_hook (cgraph_2node_hook hook
, void *data
)
465 cgraph_2node_hook_list
*entry
;
466 cgraph_2node_hook_list
**ptr
= &m_first_cgraph_duplicated_hook
;
468 entry
= (cgraph_2node_hook_list
*) xmalloc (sizeof (*entry
));
478 /* Remove ENTRY from the list of hooks called on duplicating nodes. */
480 symbol_table::remove_cgraph_duplication_hook (cgraph_2node_hook_list
*entry
)
482 cgraph_2node_hook_list
**ptr
= &m_first_cgraph_duplicated_hook
;
484 while (*ptr
!= entry
)
490 /* Call all node duplication hooks. */
492 symbol_table::call_cgraph_duplication_hooks (cgraph_node
*node
,
495 cgraph_2node_hook_list
*entry
= m_first_cgraph_duplicated_hook
;
498 entry
->hook (node
, node2
, entry
->data
);
503 /* Return cgraph node assigned to DECL. Create new one when needed. */
506 cgraph_node::create (tree decl
)
508 cgraph_node
*node
= symtab
->create_empty ();
509 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
513 node
->count
= profile_count::uninitialized ();
515 if ((flag_openacc
|| flag_openmp
)
516 && lookup_attribute ("omp declare target", DECL_ATTRIBUTES (decl
)))
518 node
->offloadable
= 1;
519 if (ENABLE_OFFLOADING
)
520 g
->have_offload
= true;
523 if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl
)))
524 node
->ifunc_resolver
= true;
526 node
->register_symbol ();
528 if (DECL_CONTEXT (decl
) && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
530 node
->origin
= cgraph_node::get_create (DECL_CONTEXT (decl
));
531 node
->next_nested
= node
->origin
->nested
;
532 node
->origin
->nested
= node
;
537 /* Try to find a call graph node for declaration DECL and if it does not exist
538 or if it corresponds to an inline clone, create a new one. */
541 cgraph_node::get_create (tree decl
)
543 cgraph_node
*first_clone
= cgraph_node::get (decl
);
545 if (first_clone
&& !first_clone
->inlined_to
)
548 cgraph_node
*node
= cgraph_node::create (decl
);
551 first_clone
->clone_of
= node
;
552 node
->clones
= first_clone
;
553 node
->order
= first_clone
->order
;
554 symtab
->symtab_prevail_in_asm_name_hash (node
);
555 node
->decl
->decl_with_vis
.symtab_node
= node
;
557 fprintf (dump_file
, "Introduced new external node "
558 "(%s) and turned into root of the clone tree.\n",
562 fprintf (dump_file
, "Introduced new external node "
563 "(%s).\n", node
->dump_name ());
567 /* Mark ALIAS as an alias to DECL. DECL_NODE is cgraph node representing
568 the function body is associated with (not necessarily cgraph_node (DECL). */
571 cgraph_node::create_alias (tree alias
, tree target
)
573 cgraph_node
*alias_node
;
575 gcc_assert (TREE_CODE (target
) == FUNCTION_DECL
576 || TREE_CODE (target
) == IDENTIFIER_NODE
);
577 gcc_assert (TREE_CODE (alias
) == FUNCTION_DECL
);
578 alias_node
= cgraph_node::get_create (alias
);
579 gcc_assert (!alias_node
->definition
);
580 alias_node
->alias_target
= target
;
581 alias_node
->definition
= true;
582 alias_node
->alias
= true;
583 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (alias
)) != NULL
)
584 alias_node
->transparent_alias
= alias_node
->weakref
= true;
585 if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (alias
)))
586 alias_node
->ifunc_resolver
= true;
590 /* Attempt to mark ALIAS as an alias to DECL. Return alias node if successful
592 Same body aliases are output whenever the body of DECL is output,
593 and cgraph_node::get (ALIAS) transparently returns
594 cgraph_node::get (DECL). */
597 cgraph_node::create_same_body_alias (tree alias
, tree decl
)
601 /* If aliases aren't supported by the assembler, fail. */
602 if (!TARGET_SUPPORTS_ALIASES
)
605 /* Langhooks can create same body aliases of symbols not defined.
606 Those are useless. Drop them on the floor. */
607 if (symtab
->global_info_ready
)
610 n
= cgraph_node::create_alias (alias
, decl
);
611 n
->cpp_implicit_alias
= true;
612 if (symtab
->cpp_implicit_aliases_done
)
613 n
->resolve_alias (cgraph_node::get (decl
));
617 /* Add thunk alias into callgraph. The alias declaration is ALIAS and it
618 aliases DECL with an adjustments made into the first parameter.
619 See comments in struct cgraph_thunk_info for detail on the parameters. */
622 cgraph_node::create_thunk (tree alias
, tree
, bool this_adjusting
,
623 HOST_WIDE_INT fixed_offset
,
624 HOST_WIDE_INT virtual_value
,
625 HOST_WIDE_INT indirect_offset
,
631 node
= cgraph_node::get (alias
);
635 node
= cgraph_node::create (alias
);
637 /* Make sure that if VIRTUAL_OFFSET is in sync with VIRTUAL_VALUE. */
638 gcc_checking_assert (virtual_offset
639 ? virtual_value
== wi::to_wide (virtual_offset
)
640 : virtual_value
== 0);
642 node
->thunk
.fixed_offset
= fixed_offset
;
643 node
->thunk
.virtual_value
= virtual_value
;
644 node
->thunk
.indirect_offset
= indirect_offset
;
645 node
->thunk
.alias
= real_alias
;
646 node
->thunk
.this_adjusting
= this_adjusting
;
647 node
->thunk
.virtual_offset_p
= virtual_offset
!= NULL
;
648 node
->thunk
.thunk_p
= true;
649 node
->definition
= true;
654 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
655 Return NULL if there's no such node. */
658 cgraph_node::get_for_asmname (tree asmname
)
660 /* We do not want to look at inline clones. */
661 for (symtab_node
*node
= symtab_node::get_for_asmname (asmname
);
663 node
= node
->next_sharing_asm_name
)
665 cgraph_node
*cn
= dyn_cast
<cgraph_node
*> (node
);
666 if (cn
&& !cn
->inlined_to
)
672 /* Returns a hash value for X (which really is a cgraph_edge). */
675 cgraph_edge_hasher::hash (cgraph_edge
*e
)
677 /* This is a really poor hash function, but it is what htab_hash_pointer
679 return (hashval_t
) ((intptr_t)e
->call_stmt
>> 3);
682 /* Returns a hash value for X (which really is a cgraph_edge). */
685 cgraph_edge_hasher::hash (gimple
*call_stmt
)
687 /* This is a really poor hash function, but it is what htab_hash_pointer
689 return (hashval_t
) ((intptr_t)call_stmt
>> 3);
692 /* Return nonzero if the call_stmt of cgraph_edge X is stmt *Y. */
695 cgraph_edge_hasher::equal (cgraph_edge
*x
, gimple
*y
)
697 return x
->call_stmt
== y
;
700 /* Add call graph edge E to call site hash of its caller. */
703 cgraph_update_edge_in_call_site_hash (cgraph_edge
*e
)
705 gimple
*call
= e
->call_stmt
;
706 *e
->caller
->call_site_hash
->find_slot_with_hash
707 (call
, cgraph_edge_hasher::hash (call
), INSERT
) = e
;
710 /* Add call graph edge E to call site hash of its caller. */
713 cgraph_add_edge_to_call_site_hash (cgraph_edge
*e
)
715 /* There are two speculative edges for every statement (one direct,
716 one indirect); always hash the direct one. */
717 if (e
->speculative
&& e
->indirect_unknown_callee
)
719 cgraph_edge
**slot
= e
->caller
->call_site_hash
->find_slot_with_hash
720 (e
->call_stmt
, cgraph_edge_hasher::hash (e
->call_stmt
), INSERT
);
723 gcc_assert (((cgraph_edge
*)*slot
)->speculative
);
728 gcc_assert (!*slot
|| e
->speculative
);
732 /* Return the callgraph edge representing the GIMPLE_CALL statement
736 cgraph_node::get_edge (gimple
*call_stmt
)
742 return call_site_hash
->find_with_hash
743 (call_stmt
, cgraph_edge_hasher::hash (call_stmt
));
745 /* This loop may turn out to be performance problem. In such case adding
746 hashtables into call nodes with very many edges is probably best
747 solution. It is not good idea to add pointer into CALL_EXPR itself
748 because we want to make possible having multiple cgraph nodes representing
749 different clones of the same body before the body is actually cloned. */
750 for (e
= callees
; e
; e
= e
->next_callee
)
752 if (e
->call_stmt
== call_stmt
)
758 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
760 if (e
->call_stmt
== call_stmt
)
767 call_site_hash
= hash_table
<cgraph_edge_hasher
>::create_ggc (120);
768 for (e2
= callees
; e2
; e2
= e2
->next_callee
)
769 cgraph_add_edge_to_call_site_hash (e2
);
770 for (e2
= indirect_calls
; e2
; e2
= e2
->next_callee
)
771 cgraph_add_edge_to_call_site_hash (e2
);
778 /* Change field call_stmt of edge to NEW_STMT.
779 If UPDATE_SPECULATIVE and E is any component of speculative
780 edge, then update all components. */
783 cgraph_edge::set_call_stmt (gcall
*new_stmt
, bool update_speculative
)
787 /* Speculative edges has three component, update all of them
789 if (update_speculative
&& speculative
)
791 cgraph_edge
*direct
, *indirect
;
794 speculative_call_info (direct
, indirect
, ref
);
795 direct
->set_call_stmt (new_stmt
, false);
796 indirect
->set_call_stmt (new_stmt
, false);
797 ref
->stmt
= new_stmt
;
801 /* Only direct speculative edges go to call_site_hash. */
802 if (caller
->call_site_hash
803 && (!speculative
|| !indirect_unknown_callee
))
805 caller
->call_site_hash
->remove_elt_with_hash
806 (call_stmt
, cgraph_edge_hasher::hash (call_stmt
));
809 cgraph_edge
*e
= this;
811 call_stmt
= new_stmt
;
812 if (indirect_unknown_callee
813 && (decl
= gimple_call_fndecl (new_stmt
)))
815 /* Constant propagation (and possibly also inlining?) can turn an
816 indirect call into a direct one. */
817 cgraph_node
*new_callee
= cgraph_node::get (decl
);
819 gcc_checking_assert (new_callee
);
820 e
= make_direct (new_callee
);
823 function
*fun
= DECL_STRUCT_FUNCTION (e
->caller
->decl
);
824 e
->can_throw_external
= stmt_can_throw_external (fun
, new_stmt
);
825 if (e
->caller
->call_site_hash
)
826 cgraph_add_edge_to_call_site_hash (e
);
829 /* Allocate a cgraph_edge structure and fill it with data according to the
830 parameters of which only CALLEE can be NULL (when creating an indirect call
831 edge). CLONING_P should be set if properties that are copied from an
832 original edge should not be calculated. */
835 symbol_table::create_edge (cgraph_node
*caller
, cgraph_node
*callee
,
836 gcall
*call_stmt
, profile_count count
,
837 bool indir_unknown_callee
, bool cloning_p
)
841 /* LTO does not actually have access to the call_stmt since these
842 have not been loaded yet. */
845 /* This is a rather expensive check possibly triggering
846 construction of call stmt hashtable. */
848 gcc_checking_assert (!(e
= caller
->get_edge (call_stmt
))
851 gcc_assert (is_gimple_call (call_stmt
));
854 edge
= ggc_alloc
<cgraph_edge
> ();
855 edge
->m_summary_id
= -1;
858 gcc_assert (++edges_max_uid
!= 0);
859 edge
->m_uid
= edges_max_uid
;
861 edge
->caller
= caller
;
862 edge
->callee
= callee
;
863 edge
->prev_caller
= NULL
;
864 edge
->next_caller
= NULL
;
865 edge
->prev_callee
= NULL
;
866 edge
->next_callee
= NULL
;
867 edge
->lto_stmt_uid
= 0;
870 edge
->call_stmt
= call_stmt
;
871 edge
->indirect_info
= NULL
;
872 edge
->indirect_inlining_edge
= 0;
873 edge
->speculative
= false;
874 edge
->indirect_unknown_callee
= indir_unknown_callee
;
875 if (call_stmt
&& caller
->call_site_hash
)
876 cgraph_add_edge_to_call_site_hash (edge
);
881 edge
->can_throw_external
882 = call_stmt
? stmt_can_throw_external (DECL_STRUCT_FUNCTION (caller
->decl
),
884 edge
->inline_failed
= CIF_FUNCTION_NOT_CONSIDERED
;
885 edge
->call_stmt_cannot_inline_p
= false;
887 if (opt_for_fn (edge
->caller
->decl
, flag_devirtualize
)
888 && call_stmt
&& DECL_STRUCT_FUNCTION (caller
->decl
))
889 edge
->in_polymorphic_cdtor
890 = decl_maybe_in_construction_p (NULL
, NULL
, call_stmt
,
893 edge
->in_polymorphic_cdtor
= caller
->thunk
.thunk_p
;
898 /* Create edge from a given function to CALLEE in the cgraph. CLONING_P should
899 be set if properties that are copied from an original edge should not be
903 cgraph_node::create_edge (cgraph_node
*callee
,
904 gcall
*call_stmt
, profile_count count
, bool cloning_p
)
906 cgraph_edge
*edge
= symtab
->create_edge (this, callee
, call_stmt
, count
,
910 initialize_inline_failed (edge
);
912 edge
->next_caller
= callee
->callers
;
914 callee
->callers
->prev_caller
= edge
;
915 edge
->next_callee
= callees
;
917 callees
->prev_callee
= edge
;
919 callee
->callers
= edge
;
924 /* Allocate cgraph_indirect_call_info and set its fields to default values. */
926 cgraph_indirect_call_info
*
927 cgraph_allocate_init_indirect_info (void)
929 cgraph_indirect_call_info
*ii
;
931 ii
= ggc_cleared_alloc
<cgraph_indirect_call_info
> ();
932 ii
->param_index
= -1;
936 /* Create an indirect edge with a yet-undetermined callee where the call
937 statement destination is a formal parameter of the caller with index
938 PARAM_INDEX. CLONING_P should be set if properties that are copied from an
939 original edge should not be calculated and indirect_info structure should
940 not be calculated. */
943 cgraph_node::create_indirect_edge (gcall
*call_stmt
, int ecf_flags
,
947 cgraph_edge
*edge
= symtab
->create_edge (this, NULL
, call_stmt
, count
, true,
952 initialize_inline_failed (edge
);
954 edge
->indirect_info
= cgraph_allocate_init_indirect_info ();
955 edge
->indirect_info
->ecf_flags
= ecf_flags
;
956 edge
->indirect_info
->vptr_changed
= true;
958 /* Record polymorphic call info. */
961 && (target
= gimple_call_fn (call_stmt
))
962 && virtual_method_call_p (target
))
964 ipa_polymorphic_call_context
context (decl
, target
, call_stmt
);
966 /* Only record types can have virtual calls. */
967 edge
->indirect_info
->polymorphic
= true;
968 edge
->indirect_info
->param_index
= -1;
969 edge
->indirect_info
->otr_token
970 = tree_to_uhwi (OBJ_TYPE_REF_TOKEN (target
));
971 edge
->indirect_info
->otr_type
= obj_type_ref_class (target
);
972 gcc_assert (TREE_CODE (edge
->indirect_info
->otr_type
) == RECORD_TYPE
);
973 edge
->indirect_info
->context
= context
;
976 edge
->next_callee
= indirect_calls
;
978 indirect_calls
->prev_callee
= edge
;
979 indirect_calls
= edge
;
984 /* Remove the edge from the list of the callees of the caller. */
987 cgraph_edge::remove_caller (void)
990 prev_callee
->next_callee
= next_callee
;
992 next_callee
->prev_callee
= prev_callee
;
995 if (indirect_unknown_callee
)
996 caller
->indirect_calls
= next_callee
;
998 caller
->callees
= next_callee
;
1000 if (caller
->call_site_hash
)
1001 caller
->call_site_hash
->remove_elt_with_hash
1002 (call_stmt
, cgraph_edge_hasher::hash (call_stmt
));
1005 /* Put the edge onto the free list. */
1008 symbol_table::free_edge (cgraph_edge
*e
)
1011 if (e
->m_summary_id
!= -1)
1012 edge_released_summary_ids
.safe_push (e
->m_summary_id
);
1014 if (e
->indirect_info
)
1015 ggc_free (e
->indirect_info
);
1019 /* Remove the edge in the cgraph. */
1022 cgraph_edge::remove (void)
1024 /* Call all edge removal hooks. */
1025 symtab
->call_edge_removal_hooks (this);
1027 if (!indirect_unknown_callee
)
1028 /* Remove from callers list of the callee. */
1031 /* Remove from callees list of the callers. */
1034 /* Put the edge onto the free list. */
1035 symtab
->free_edge (this);
1038 /* Turn edge into speculative call calling N2. Update
1039 the profile so the direct call is taken COUNT times
1042 At clone materialization time, the indirect call E will
1045 if (call_dest == N2)
1050 At this time the function just creates the direct call,
1051 the reference representing the if conditional and attaches
1052 them all to the original indirect call statement.
1054 Return direct edge created. */
1057 cgraph_edge::make_speculative (cgraph_node
*n2
, profile_count direct_count
)
1059 cgraph_node
*n
= caller
;
1060 ipa_ref
*ref
= NULL
;
1064 fprintf (dump_file
, "Indirect call -> speculative call %s => %s\n",
1065 n
->dump_name (), n2
->dump_name ());
1067 e2
= n
->create_edge (n2
, call_stmt
, direct_count
);
1068 initialize_inline_failed (e2
);
1069 e2
->speculative
= true;
1070 if (TREE_NOTHROW (n2
->decl
))
1071 e2
->can_throw_external
= false;
1073 e2
->can_throw_external
= can_throw_external
;
1074 e2
->lto_stmt_uid
= lto_stmt_uid
;
1075 e2
->in_polymorphic_cdtor
= in_polymorphic_cdtor
;
1077 symtab
->call_edge_duplication_hooks (this, e2
);
1078 ref
= n
->create_reference (n2
, IPA_REF_ADDR
, call_stmt
);
1079 ref
->lto_stmt_uid
= lto_stmt_uid
;
1080 ref
->speculative
= speculative
;
1081 n2
->mark_address_taken ();
1085 /* Speculative call consist of three components:
1086 1) an indirect edge representing the original call
1087 2) an direct edge representing the new call
1088 3) ADDR_EXPR reference representing the speculative check.
1089 All three components are attached to single statement (the indirect
1090 call) and if one of them exists, all of them must exist.
1092 Given speculative call edge, return all three components.
1096 cgraph_edge::speculative_call_info (cgraph_edge
*&direct
,
1097 cgraph_edge
*&indirect
,
1098 ipa_ref
*&reference
)
1103 cgraph_edge
*e
= this;
1105 if (!e
->indirect_unknown_callee
)
1106 for (e2
= e
->caller
->indirect_calls
;
1107 e2
->call_stmt
!= e
->call_stmt
|| e2
->lto_stmt_uid
!= e
->lto_stmt_uid
;
1108 e2
= e2
->next_callee
)
1113 /* We can take advantage of the call stmt hash. */
1116 e
= e
->caller
->get_edge (e2
->call_stmt
);
1117 gcc_assert (e
->speculative
&& !e
->indirect_unknown_callee
);
1120 for (e
= e
->caller
->callees
;
1121 e2
->call_stmt
!= e
->call_stmt
1122 || e2
->lto_stmt_uid
!= e
->lto_stmt_uid
;
1126 gcc_assert (e
->speculative
&& e2
->speculative
);
1131 for (i
= 0; e
->caller
->iterate_reference (i
, ref
); i
++)
1132 if (ref
->speculative
1133 && ((ref
->stmt
&& ref
->stmt
== e
->call_stmt
)
1134 || (!ref
->stmt
&& ref
->lto_stmt_uid
== e
->lto_stmt_uid
)))
1140 /* Speculative edge always consist of all three components - direct edge,
1141 indirect and reference. */
1143 gcc_assert (e
&& e2
&& ref
);
1146 /* Speculative call edge turned out to be direct call to CALLEE_DECL.
1147 Remove the speculative call sequence and return edge representing the call.
1148 It is up to caller to redirect the call as appropriate. */
1151 cgraph_edge::resolve_speculation (tree callee_decl
)
1153 cgraph_edge
*edge
= this;
1157 gcc_assert (edge
->speculative
);
1158 edge
->speculative_call_info (e2
, edge
, ref
);
1160 || !ref
->referred
->semantically_equivalent_p
1161 (symtab_node::get (callee_decl
)))
1167 fprintf (dump_file
, "Speculative indirect call %s => %s has "
1168 "turned out to have contradicting known target ",
1169 edge
->caller
->dump_name (),
1170 e2
->callee
->dump_name ());
1171 print_generic_expr (dump_file
, callee_decl
);
1172 fprintf (dump_file
, "\n");
1176 fprintf (dump_file
, "Removing speculative call %s => %s\n",
1177 edge
->caller
->dump_name (),
1178 e2
->callee
->dump_name ());
1184 cgraph_edge
*tmp
= edge
;
1186 fprintf (dump_file
, "Speculative call turned into direct call.\n");
1189 /* FIXME: If EDGE is inlined, we should scale up the frequencies and counts
1190 in the functions inlined through it. */
1192 edge
->count
+= e2
->count
;
1193 edge
->speculative
= false;
1194 e2
->speculative
= false;
1195 ref
->remove_reference ();
1196 if (e2
->indirect_unknown_callee
|| e2
->inline_failed
)
1199 e2
->callee
->remove_symbol_and_inline_clones ();
1200 if (edge
->caller
->call_site_hash
)
1201 cgraph_update_edge_in_call_site_hash (edge
);
1205 /* Make an indirect edge with an unknown callee an ordinary edge leading to
1206 CALLEE. DELTA is an integer constant that is to be added to the this
1207 pointer (first parameter) to compensate for skipping a thunk adjustment. */
1210 cgraph_edge::make_direct (cgraph_node
*callee
)
1212 cgraph_edge
*edge
= this;
1213 gcc_assert (indirect_unknown_callee
);
1215 /* If we are redirecting speculative call, make it non-speculative. */
1216 if (indirect_unknown_callee
&& speculative
)
1218 edge
= edge
->resolve_speculation (callee
->decl
);
1220 /* On successful speculation just return the pre existing direct edge. */
1221 if (!edge
->indirect_unknown_callee
)
1225 indirect_unknown_callee
= 0;
1226 ggc_free (indirect_info
);
1227 indirect_info
= NULL
;
1229 /* Get the edge out of the indirect edge list. */
1231 prev_callee
->next_callee
= next_callee
;
1233 next_callee
->prev_callee
= prev_callee
;
1235 caller
->indirect_calls
= next_callee
;
1237 /* Put it into the normal callee list */
1239 next_callee
= caller
->callees
;
1240 if (caller
->callees
)
1241 caller
->callees
->prev_callee
= edge
;
1242 caller
->callees
= edge
;
1244 /* Insert to callers list of the new callee. */
1245 edge
->set_callee (callee
);
1247 /* We need to re-determine the inlining status of the edge. */
1248 initialize_inline_failed (edge
);
1252 /* If necessary, change the function declaration in the call statement
1253 associated with E so that it corresponds to the edge callee. */
1256 cgraph_edge::redirect_call_stmt_to_callee (void)
1258 cgraph_edge
*e
= this;
1260 tree decl
= gimple_call_fndecl (e
->call_stmt
);
1262 gimple_stmt_iterator gsi
;
1270 e
->speculative_call_info (e
, e2
, ref
);
1271 /* If there already is an direct call (i.e. as a result of inliner's
1272 substitution), forget about speculating. */
1274 e
= e
->resolve_speculation (decl
);
1277 /* Expand speculation into GIMPLE code. */
1281 "Expanding speculative call of %s -> %s count: ",
1282 e
->caller
->dump_name (),
1283 e
->callee
->dump_name ());
1284 e
->count
.dump (dump_file
);
1285 fprintf (dump_file
, "\n");
1287 gcc_assert (e2
->speculative
);
1288 push_cfun (DECL_STRUCT_FUNCTION (e
->caller
->decl
));
1290 profile_probability prob
= e
->count
.probability_in (e
->count
1292 if (!prob
.initialized_p ())
1293 prob
= profile_probability::even ();
1294 new_stmt
= gimple_ic (e
->call_stmt
,
1295 dyn_cast
<cgraph_node
*> (ref
->referred
),
1297 e
->speculative
= false;
1298 e
->caller
->set_call_stmt_including_clones (e
->call_stmt
, new_stmt
,
1300 e
->count
= gimple_bb (e
->call_stmt
)->count
;
1301 e2
->speculative
= false;
1302 e2
->count
= gimple_bb (e2
->call_stmt
)->count
;
1303 ref
->speculative
= false;
1305 /* Indirect edges are not both in the call site hash.
1307 if (e
->caller
->call_site_hash
)
1308 cgraph_update_edge_in_call_site_hash (e2
);
1310 /* Continue redirecting E to proper target. */
1315 if (e
->indirect_unknown_callee
1316 || decl
== e
->callee
->decl
)
1317 return e
->call_stmt
;
1319 if (flag_checking
&& decl
)
1321 cgraph_node
*node
= cgraph_node::get (decl
);
1322 gcc_assert (!node
|| !node
->clone
.param_adjustments
);
1325 if (symtab
->dump_file
)
1327 fprintf (symtab
->dump_file
, "updating call of %s -> %s: ",
1328 e
->caller
->dump_name (), e
->callee
->dump_name ());
1329 print_gimple_stmt (symtab
->dump_file
, e
->call_stmt
, 0, dump_flags
);
1330 if (e
->callee
->clone
.param_adjustments
)
1331 e
->callee
->clone
.param_adjustments
->dump (symtab
->dump_file
);
1332 unsigned performed_len
1333 = vec_safe_length (e
->caller
->clone
.performed_splits
);
1334 if (performed_len
> 0)
1335 fprintf (symtab
->dump_file
, "Performed splits records:\n");
1336 for (unsigned i
= 0; i
< performed_len
; i
++)
1338 ipa_param_performed_split
*sm
1339 = &(*e
->caller
->clone
.performed_splits
)[i
];
1340 print_node_brief (symtab
->dump_file
, " dummy_decl: ", sm
->dummy_decl
,
1342 fprintf (symtab
->dump_file
, ", unit_offset: %u\n", sm
->unit_offset
);
1346 if (ipa_param_adjustments
*padjs
= e
->callee
->clone
.param_adjustments
)
1348 /* We need to defer cleaning EH info on the new statement to
1349 fixup-cfg. We may not have dominator information at this point
1350 and thus would end up with unreachable blocks and have no way
1351 to communicate that we need to run CFG cleanup then. */
1352 int lp_nr
= lookup_stmt_eh_lp (e
->call_stmt
);
1354 remove_stmt_from_eh_lp (e
->call_stmt
);
1356 tree old_fntype
= gimple_call_fntype (e
->call_stmt
);
1357 new_stmt
= padjs
->modify_call (e
->call_stmt
,
1358 e
->caller
->clone
.performed_splits
,
1359 e
->callee
->decl
, false);
1360 cgraph_node
*origin
= e
->callee
;
1361 while (origin
->clone_of
)
1362 origin
= origin
->clone_of
;
1364 if ((origin
->former_clone_of
1365 && old_fntype
== TREE_TYPE (origin
->former_clone_of
))
1366 || old_fntype
== TREE_TYPE (origin
->decl
))
1367 gimple_call_set_fntype (new_stmt
, TREE_TYPE (e
->callee
->decl
));
1370 tree new_fntype
= padjs
->build_new_function_type (old_fntype
, true);
1371 gimple_call_set_fntype (new_stmt
, new_fntype
);
1375 add_stmt_to_eh_lp (new_stmt
, lp_nr
);
1379 new_stmt
= e
->call_stmt
;
1380 gimple_call_set_fndecl (new_stmt
, e
->callee
->decl
);
1381 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), new_stmt
);
1384 /* If changing the call to __cxa_pure_virtual or similar noreturn function,
1385 adjust gimple_call_fntype too. */
1386 if (gimple_call_noreturn_p (new_stmt
)
1387 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (e
->callee
->decl
)))
1388 && TYPE_ARG_TYPES (TREE_TYPE (e
->callee
->decl
))
1389 && (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (e
->callee
->decl
)))
1391 gimple_call_set_fntype (new_stmt
, TREE_TYPE (e
->callee
->decl
));
1393 /* If the call becomes noreturn, remove the LHS if possible. */
1394 tree lhs
= gimple_call_lhs (new_stmt
);
1396 && gimple_call_noreturn_p (new_stmt
)
1397 && (VOID_TYPE_P (TREE_TYPE (gimple_call_fntype (new_stmt
)))
1398 || should_remove_lhs_p (lhs
)))
1400 if (TREE_CODE (lhs
) == SSA_NAME
)
1402 tree var
= create_tmp_reg_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
),
1403 TREE_TYPE (lhs
), NULL
);
1404 var
= get_or_create_ssa_default_def
1405 (DECL_STRUCT_FUNCTION (e
->caller
->decl
), var
);
1406 gimple
*set_stmt
= gimple_build_assign (lhs
, var
);
1407 gsi
= gsi_for_stmt (new_stmt
);
1408 gsi_insert_before_without_update (&gsi
, set_stmt
, GSI_SAME_STMT
);
1409 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), set_stmt
);
1411 gimple_call_set_lhs (new_stmt
, NULL_TREE
);
1412 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), new_stmt
);
1415 /* If new callee has no static chain, remove it. */
1416 if (gimple_call_chain (new_stmt
) && !DECL_STATIC_CHAIN (e
->callee
->decl
))
1418 gimple_call_set_chain (new_stmt
, NULL
);
1419 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), new_stmt
);
1422 maybe_remove_unused_call_args (DECL_STRUCT_FUNCTION (e
->caller
->decl
),
1425 e
->caller
->set_call_stmt_including_clones (e
->call_stmt
, new_stmt
, false);
1427 if (symtab
->dump_file
)
1429 fprintf (symtab
->dump_file
, " updated to:");
1430 print_gimple_stmt (symtab
->dump_file
, e
->call_stmt
, 0, dump_flags
);
1435 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1436 OLD_STMT changed into NEW_STMT. OLD_CALL is gimple_call_fndecl
1437 of OLD_STMT if it was previously call statement.
1438 If NEW_STMT is NULL, the call has been dropped without any
1442 cgraph_update_edges_for_call_stmt_node (cgraph_node
*node
,
1443 gimple
*old_stmt
, tree old_call
,
1446 tree new_call
= (new_stmt
&& is_gimple_call (new_stmt
))
1447 ? gimple_call_fndecl (new_stmt
) : 0;
1449 /* We are seeing indirect calls, then there is nothing to update. */
1450 if (!new_call
&& !old_call
)
1452 /* See if we turned indirect call into direct call or folded call to one builtin
1453 into different builtin. */
1454 if (old_call
!= new_call
)
1456 cgraph_edge
*e
= node
->get_edge (old_stmt
);
1457 cgraph_edge
*ne
= NULL
;
1458 profile_count count
;
1462 /* Keep calls marked as dead dead. */
1463 if (new_stmt
&& is_gimple_call (new_stmt
) && e
->callee
1464 && fndecl_built_in_p (e
->callee
->decl
, BUILT_IN_UNREACHABLE
))
1466 node
->get_edge (old_stmt
)->set_call_stmt
1467 (as_a
<gcall
*> (new_stmt
));
1470 /* See if the edge is already there and has the correct callee. It
1471 might be so because of indirect inlining has already updated
1472 it. We also might've cloned and redirected the edge. */
1473 if (new_call
&& e
->callee
)
1475 cgraph_node
*callee
= e
->callee
;
1478 if (callee
->decl
== new_call
1479 || callee
->former_clone_of
== new_call
)
1481 e
->set_call_stmt (as_a
<gcall
*> (new_stmt
));
1484 callee
= callee
->clone_of
;
1488 /* Otherwise remove edge and create new one; we can't simply redirect
1489 since function has changed, so inline plan and other information
1490 attached to edge is invalid. */
1492 if (e
->indirect_unknown_callee
|| e
->inline_failed
)
1495 e
->callee
->remove_symbol_and_inline_clones ();
1499 /* We are seeing new direct call; compute profile info based on BB. */
1500 basic_block bb
= gimple_bb (new_stmt
);
1506 ne
= node
->create_edge (cgraph_node::get_create (new_call
),
1507 as_a
<gcall
*> (new_stmt
), count
);
1508 gcc_assert (ne
->inline_failed
);
1511 /* We only updated the call stmt; update pointer in cgraph edge.. */
1512 else if (old_stmt
!= new_stmt
)
1513 node
->get_edge (old_stmt
)->set_call_stmt (as_a
<gcall
*> (new_stmt
));
1516 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1517 OLD_STMT changed into NEW_STMT. OLD_DECL is gimple_call_fndecl
1518 of OLD_STMT before it was updated (updating can happen inplace). */
1521 cgraph_update_edges_for_call_stmt (gimple
*old_stmt
, tree old_decl
,
1524 cgraph_node
*orig
= cgraph_node::get (cfun
->decl
);
1527 gcc_checking_assert (orig
);
1528 cgraph_update_edges_for_call_stmt_node (orig
, old_stmt
, old_decl
, new_stmt
);
1530 for (node
= orig
->clones
; node
!= orig
;)
1532 cgraph_update_edges_for_call_stmt_node (node
, old_stmt
, old_decl
, new_stmt
);
1534 node
= node
->clones
;
1535 else if (node
->next_sibling_clone
)
1536 node
= node
->next_sibling_clone
;
1539 while (node
!= orig
&& !node
->next_sibling_clone
)
1540 node
= node
->clone_of
;
1542 node
= node
->next_sibling_clone
;
1548 /* Remove all callees from the node. */
1551 cgraph_node::remove_callees (void)
1555 /* It is sufficient to remove the edges from the lists of callers of
1556 the callees. The callee list of the node can be zapped with one
1558 for (e
= callees
; e
; e
= f
)
1561 symtab
->call_edge_removal_hooks (e
);
1562 if (!e
->indirect_unknown_callee
)
1563 e
->remove_callee ();
1564 symtab
->free_edge (e
);
1566 for (e
= indirect_calls
; e
; e
= f
)
1569 symtab
->call_edge_removal_hooks (e
);
1570 if (!e
->indirect_unknown_callee
)
1571 e
->remove_callee ();
1572 symtab
->free_edge (e
);
1574 indirect_calls
= NULL
;
1578 call_site_hash
->empty ();
1579 call_site_hash
= NULL
;
1583 /* Remove all callers from the node. */
1586 cgraph_node::remove_callers (void)
1590 /* It is sufficient to remove the edges from the lists of callees of
1591 the callers. The caller list of the node can be zapped with one
1593 for (e
= callers
; e
; e
= f
)
1596 symtab
->call_edge_removal_hooks (e
);
1597 e
->remove_caller ();
1598 symtab
->free_edge (e
);
1603 /* Helper function for cgraph_release_function_body and free_lang_data.
1604 It releases body from function DECL without having to inspect its
1605 possibly non-existent symtab node. */
1608 release_function_body (tree decl
)
1610 function
*fn
= DECL_STRUCT_FUNCTION (decl
);
1614 && loops_for_fn (fn
))
1616 fn
->curr_properties
&= ~PROP_loops
;
1617 loop_optimizer_finalize (fn
);
1621 delete_tree_ssa (fn
);
1626 gcc_assert (!dom_info_available_p (fn
, CDI_DOMINATORS
));
1627 gcc_assert (!dom_info_available_p (fn
, CDI_POST_DOMINATORS
));
1628 delete_tree_cfg_annotations (fn
);
1632 if (fn
->value_histograms
)
1633 free_histograms (fn
);
1634 gimple_set_body (decl
, NULL
);
1635 /* Struct function hangs a lot of data that would leak if we didn't
1636 removed all pointers to it. */
1638 DECL_STRUCT_FUNCTION (decl
) = NULL
;
1640 DECL_SAVED_TREE (decl
) = NULL
;
1643 /* Release memory used to represent body of function.
1644 Use this only for functions that are released before being translated to
1645 target code (i.e. RTL). Functions that are compiled to RTL and beyond
1646 are free'd in final.c via free_after_compilation().
1647 KEEP_ARGUMENTS are useful only if you want to rebuild body as thunk. */
1650 cgraph_node::release_body (bool keep_arguments
)
1652 ipa_transforms_to_apply
.release ();
1653 if (!used_as_abstract_origin
&& symtab
->state
!= PARSING
)
1655 DECL_RESULT (decl
) = NULL
;
1657 if (!keep_arguments
)
1658 DECL_ARGUMENTS (decl
) = NULL
;
1660 /* If the node is abstract and needed, then do not clear
1661 DECL_INITIAL of its associated function declaration because it's
1662 needed to emit debug info later. */
1663 if (!used_as_abstract_origin
&& DECL_INITIAL (decl
))
1664 DECL_INITIAL (decl
) = error_mark_node
;
1665 release_function_body (decl
);
1668 lto_free_function_in_decl_state_for_node (this);
1669 lto_file_data
= NULL
;
1673 /* Remove function from symbol table. */
1676 cgraph_node::remove (void)
1678 if (symtab
->ipa_clones_dump_file
&& symtab
->cloned_nodes
.contains (this))
1679 fprintf (symtab
->ipa_clones_dump_file
,
1680 "Callgraph removal;%s;%d;%s;%d;%d\n", asm_name (), order
,
1681 DECL_SOURCE_FILE (decl
), DECL_SOURCE_LINE (decl
),
1682 DECL_SOURCE_COLUMN (decl
));
1684 symtab
->call_cgraph_removal_hooks (this);
1687 ipa_transforms_to_apply
.release ();
1688 delete_function_version (function_version ());
1690 /* Incremental inlining access removed nodes stored in the postorder list.
1692 force_output
= false;
1693 forced_by_abi
= false;
1695 for (cgraph_node
*n
= nested
; n
; n
= next
)
1697 next
= n
->next_nested
;
1699 n
->next_nested
= NULL
;
1704 cgraph_node
**node2
= &origin
->nested
;
1706 while (*node2
!= this)
1707 node2
= &(*node2
)->next_nested
;
1708 *node2
= next_nested
;
1711 if (prev_sibling_clone
)
1712 prev_sibling_clone
->next_sibling_clone
= next_sibling_clone
;
1714 clone_of
->clones
= next_sibling_clone
;
1715 if (next_sibling_clone
)
1716 next_sibling_clone
->prev_sibling_clone
= prev_sibling_clone
;
1719 cgraph_node
*n
, *next
;
1723 for (n
= clones
; n
->next_sibling_clone
; n
= n
->next_sibling_clone
)
1724 n
->clone_of
= clone_of
;
1725 n
->clone_of
= clone_of
;
1726 n
->next_sibling_clone
= clone_of
->clones
;
1727 if (clone_of
->clones
)
1728 clone_of
->clones
->prev_sibling_clone
= n
;
1729 clone_of
->clones
= clones
;
1733 /* We are removing node with clones. This makes clones inconsistent,
1734 but assume they will be removed subsequently and just keep clone
1735 tree intact. This can happen in unreachable function removal since
1736 we remove unreachable functions in random order, not by bottom-up
1737 walk of clone trees. */
1738 for (n
= clones
; n
; n
= next
)
1740 next
= n
->next_sibling_clone
;
1741 n
->next_sibling_clone
= NULL
;
1742 n
->prev_sibling_clone
= NULL
;
1748 /* While all the clones are removed after being proceeded, the function
1749 itself is kept in the cgraph even after it is compiled. Check whether
1750 we are done with this body and reclaim it proactively if this is the case.
1752 if (symtab
->state
!= LTO_STREAMING
)
1754 cgraph_node
*n
= cgraph_node::get (decl
);
1756 || (!n
->clones
&& !n
->clone_of
&& !n
->inlined_to
1757 && ((symtab
->global_info_ready
|| in_lto_p
)
1758 && (TREE_ASM_WRITTEN (n
->decl
)
1759 || DECL_EXTERNAL (n
->decl
)
1761 || (!flag_wpa
&& n
->in_other_partition
)))))
1766 lto_free_function_in_decl_state_for_node (this);
1767 lto_file_data
= NULL
;
1773 call_site_hash
->empty ();
1774 call_site_hash
= NULL
;
1777 symtab
->release_symbol (this);
1780 /* Likewise indicate that a node is having address taken. */
1783 cgraph_node::mark_address_taken (void)
1785 /* Indirect inlining can figure out that all uses of the address are
1789 gcc_assert (cfun
->after_inlining
);
1790 gcc_assert (callers
->indirect_inlining_edge
);
1793 /* FIXME: address_taken flag is used both as a shortcut for testing whether
1794 IPA_REF_ADDR reference exists (and thus it should be set on node
1795 representing alias we take address of) and as a test whether address
1796 of the object was taken (and thus it should be set on node alias is
1797 referring to). We should remove the first use and the remove the
1800 cgraph_node
*node
= ultimate_alias_target ();
1801 node
->address_taken
= 1;
1804 /* Return local info node for the compiled function. */
1807 cgraph_node::local_info_node (tree decl
)
1809 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1810 cgraph_node
*node
= get (decl
);
1813 return node
->ultimate_alias_target ();
1816 /* Return RTL info for the compiled function. */
1819 cgraph_node::rtl_info (const_tree decl
)
1821 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1822 cgraph_node
*node
= get (decl
);
1825 enum availability avail
;
1826 node
= node
->ultimate_alias_target (&avail
);
1827 if (decl
!= current_function_decl
1828 && (avail
< AVAIL_AVAILABLE
1829 || (node
->decl
!= current_function_decl
1830 && !TREE_ASM_WRITTEN (node
->decl
))))
1832 /* Allocate if it doesn't exist. */
1833 if (node
->rtl
== NULL
)
1835 node
->rtl
= ggc_cleared_alloc
<cgraph_rtl_info
> ();
1836 SET_HARD_REG_SET (node
->rtl
->function_used_regs
);
1841 /* Return a string describing the failure REASON. */
1844 cgraph_inline_failed_string (cgraph_inline_failed_t reason
)
1847 #define DEFCIFCODE(code, type, string) string,
1849 static const char *cif_string_table
[CIF_N_REASONS
] = {
1850 #include "cif-code.def"
1853 /* Signedness of an enum type is implementation defined, so cast it
1854 to unsigned before testing. */
1855 gcc_assert ((unsigned) reason
< CIF_N_REASONS
);
1856 return cif_string_table
[reason
];
1859 /* Return a type describing the failure REASON. */
1861 cgraph_inline_failed_type_t
1862 cgraph_inline_failed_type (cgraph_inline_failed_t reason
)
1865 #define DEFCIFCODE(code, type, string) type,
1867 static cgraph_inline_failed_type_t cif_type_table
[CIF_N_REASONS
] = {
1868 #include "cif-code.def"
1871 /* Signedness of an enum type is implementation defined, so cast it
1872 to unsigned before testing. */
1873 gcc_assert ((unsigned) reason
< CIF_N_REASONS
);
1874 return cif_type_table
[reason
];
1877 /* Names used to print out the availability enum. */
1878 const char * const cgraph_availability_names
[] =
1879 {"unset", "not_available", "overwritable", "available", "local"};
1881 /* Output flags of edge to a file F. */
1884 cgraph_edge::dump_edge_flags (FILE *f
)
1887 fprintf (f
, "(speculative) ");
1889 fprintf (f
, "(inlined) ");
1890 if (call_stmt_cannot_inline_p
)
1891 fprintf (f
, "(call_stmt_cannot_inline_p) ");
1892 if (indirect_inlining_edge
)
1893 fprintf (f
, "(indirect_inlining) ");
1894 if (count
.initialized_p ())
1899 fprintf (f
, "%.2f per call) ", sreal_frequency ().to_double ());
1901 if (can_throw_external
)
1902 fprintf (f
, "(can throw external) ");
1905 /* Dump call graph node to file F. */
1908 cgraph_node::dump (FILE *f
)
1915 fprintf (f
, " Function %s is inline copy in %s\n",
1917 inlined_to
->dump_name ());
1919 fprintf (f
, " Clone of %s\n", clone_of
->dump_asm_name ());
1920 if (symtab
->function_flags_ready
)
1921 fprintf (f
, " Availability: %s\n",
1922 cgraph_availability_names
[get_availability ()]);
1925 fprintf (f
, " Profile id: %i\n",
1927 cgraph_function_version_info
*vi
= function_version ();
1930 fprintf (f
, " Version info: ");
1931 if (vi
->prev
!= NULL
)
1933 fprintf (f
, "prev: ");
1934 fprintf (f
, "%s ", vi
->prev
->this_node
->dump_asm_name ());
1936 if (vi
->next
!= NULL
)
1938 fprintf (f
, "next: ");
1939 fprintf (f
, "%s ", vi
->next
->this_node
->dump_asm_name ());
1941 if (vi
->dispatcher_resolver
!= NULL_TREE
)
1942 fprintf (f
, "dispatcher: %s",
1943 lang_hooks
.decl_printable_name (vi
->dispatcher_resolver
, 2));
1947 fprintf (f
, " Function flags:");
1948 if (count
.initialized_p ())
1950 fprintf (f
, " count:");
1953 if (tp_first_run
> 0)
1954 fprintf (f
, " first_run:%i", tp_first_run
);
1956 fprintf (f
, " nested in:%s", origin
->asm_name ());
1957 if (gimple_has_body_p (decl
))
1958 fprintf (f
, " body");
1960 fprintf (f
, " process");
1962 fprintf (f
, " local");
1963 if (redefined_extern_inline
)
1964 fprintf (f
, " redefined_extern_inline");
1965 if (only_called_at_startup
)
1966 fprintf (f
, " only_called_at_startup");
1967 if (only_called_at_exit
)
1968 fprintf (f
, " only_called_at_exit");
1970 fprintf (f
, " tm_clone");
1971 if (calls_comdat_local
)
1972 fprintf (f
, " calls_comdat_local");
1974 fprintf (f
, " icf_merged");
1976 fprintf (f
, " merged_comdat");
1978 fprintf (f
, " split_part");
1979 if (indirect_call_target
)
1980 fprintf (f
, " indirect_call_target");
1982 fprintf (f
, " nonfreeing_fn");
1983 if (DECL_STATIC_CONSTRUCTOR (decl
))
1984 fprintf (f
," static_constructor (priority:%i)", get_init_priority ());
1985 if (DECL_STATIC_DESTRUCTOR (decl
))
1986 fprintf (f
," static_destructor (priority:%i)", get_fini_priority ());
1987 if (frequency
== NODE_FREQUENCY_HOT
)
1988 fprintf (f
, " hot");
1989 if (frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
)
1990 fprintf (f
, " unlikely_executed");
1991 if (frequency
== NODE_FREQUENCY_EXECUTED_ONCE
)
1992 fprintf (f
, " executed_once");
1993 if (opt_for_fn (decl
, optimize_size
))
1994 fprintf (f
, " optimize_size");
1995 if (parallelized_function
)
1996 fprintf (f
, " parallelized_function");
1997 if (DECL_IS_OPERATOR_NEW_P (decl
))
1998 fprintf (f
, " operator_new");
1999 if (DECL_IS_OPERATOR_DELETE_P (decl
))
2000 fprintf (f
, " operator_delete");
2007 fprintf (f
, " Thunk");
2009 fprintf (f
, " of %s (asm:%s)",
2010 lang_hooks
.decl_printable_name (thunk
.alias
, 2),
2011 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk
.alias
)));
2012 fprintf (f
, " fixed offset %i virtual value %i indirect_offset %i "
2013 "has virtual offset %i\n",
2014 (int)thunk
.fixed_offset
,
2015 (int)thunk
.virtual_value
,
2016 (int)thunk
.indirect_offset
,
2017 (int)thunk
.virtual_offset_p
);
2019 else if (former_thunk_p ())
2020 fprintf (f
, " Former thunk fixed offset %i virtual value %i "
2021 "indirect_offset %i has virtual offset %i\n",
2022 (int)thunk
.fixed_offset
,
2023 (int)thunk
.virtual_value
,
2024 (int)thunk
.indirect_offset
,
2025 (int)thunk
.virtual_offset_p
);
2026 if (alias
&& thunk
.alias
2027 && DECL_P (thunk
.alias
))
2029 fprintf (f
, " Alias of %s",
2030 lang_hooks
.decl_printable_name (thunk
.alias
, 2));
2031 if (DECL_ASSEMBLER_NAME_SET_P (thunk
.alias
))
2032 fprintf (f
, " (asm:%s)",
2033 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk
.alias
)));
2037 fprintf (f
, " Called by: ");
2039 profile_count sum
= profile_count::zero ();
2040 for (edge
= callers
; edge
; edge
= edge
->next_caller
)
2042 fprintf (f
, "%s ", edge
->caller
->dump_name ());
2043 edge
->dump_edge_flags (f
);
2044 if (edge
->count
.initialized_p ())
2045 sum
+= edge
->count
.ipa ();
2048 fprintf (f
, "\n Calls: ");
2049 for (edge
= callees
; edge
; edge
= edge
->next_callee
)
2051 fprintf (f
, "%s ", edge
->callee
->dump_name ());
2052 edge
->dump_edge_flags (f
);
2056 if (count
.ipa ().initialized_p ())
2062 FOR_EACH_ALIAS (this, ref
)
2063 if (dyn_cast
<cgraph_node
*> (ref
->referring
)->count
.initialized_p ())
2064 sum
+= dyn_cast
<cgraph_node
*> (ref
->referring
)->count
.ipa ();
2067 || (symtab
->state
< EXPANSION
2068 && ultimate_alias_target () == this && only_called_directly_p ()))
2069 ok
= !count
.ipa ().differs_from_p (sum
);
2070 else if (count
.ipa () > profile_count::from_gcov_type (100)
2071 && count
.ipa () < sum
.apply_scale (99, 100))
2072 ok
= false, min
= true;
2075 fprintf (f
, " Invalid sum of caller counts ");
2078 fprintf (f
, ", should be at most ");
2080 fprintf (f
, ", should be ");
2081 count
.ipa ().dump (f
);
2086 for (edge
= indirect_calls
; edge
; edge
= edge
->next_callee
)
2088 if (edge
->indirect_info
->polymorphic
)
2090 fprintf (f
, " Polymorphic indirect call of type ");
2091 print_generic_expr (f
, edge
->indirect_info
->otr_type
, TDF_SLIM
);
2092 fprintf (f
, " token:%i", (int) edge
->indirect_info
->otr_token
);
2095 fprintf (f
, " Indirect call");
2096 edge
->dump_edge_flags (f
);
2097 if (edge
->indirect_info
->param_index
!= -1)
2099 fprintf (f
, " of param:%i", edge
->indirect_info
->param_index
);
2100 if (edge
->indirect_info
->agg_contents
)
2101 fprintf (f
, " loaded from %s %s at offset %i",
2102 edge
->indirect_info
->member_ptr
? "member ptr" : "aggregate",
2103 edge
->indirect_info
->by_ref
? "passed by reference":"",
2104 (int)edge
->indirect_info
->offset
);
2105 if (edge
->indirect_info
->vptr_changed
)
2106 fprintf (f
, " (vptr maybe changed)");
2109 if (edge
->indirect_info
->polymorphic
)
2110 edge
->indirect_info
->context
.dump (f
);
2114 /* Dump call graph node to file F in graphviz format. */
2117 cgraph_node::dump_graphviz (FILE *f
)
2121 for (edge
= callees
; edge
; edge
= edge
->next_callee
)
2123 cgraph_node
*callee
= edge
->callee
;
2125 fprintf (f
, "\t\"%s\" -> \"%s\"\n", dump_name (), callee
->dump_name ());
2130 /* Dump call graph node NODE to stderr. */
2133 cgraph_node::debug (void)
2138 /* Dump the callgraph to file F. */
2141 cgraph_node::dump_cgraph (FILE *f
)
2145 fprintf (f
, "callgraph:\n\n");
2146 FOR_EACH_FUNCTION (node
)
2150 /* Return true when the DECL can possibly be inlined. */
2153 cgraph_function_possibly_inlined_p (tree decl
)
2155 if (!symtab
->global_info_ready
)
2156 return !DECL_UNINLINABLE (decl
);
2157 return DECL_POSSIBLY_INLINED (decl
);
2160 /* cgraph_node is no longer nested function; update cgraph accordingly. */
2162 cgraph_node::unnest (void)
2164 cgraph_node
**node2
= &origin
->nested
;
2165 gcc_assert (origin
);
2167 while (*node2
!= this)
2168 node2
= &(*node2
)->next_nested
;
2169 *node2
= next_nested
;
2173 /* Return function availability. See cgraph.h for description of individual
2176 cgraph_node::get_availability (symtab_node
*ref
)
2180 cgraph_node
*cref
= dyn_cast
<cgraph_node
*> (ref
);
2182 ref
= cref
->inlined_to
;
2184 enum availability avail
;
2186 avail
= AVAIL_NOT_AVAILABLE
;
2188 avail
= AVAIL_LOCAL
;
2189 else if (inlined_to
)
2190 avail
= AVAIL_AVAILABLE
;
2191 else if (transparent_alias
)
2192 ultimate_alias_target (&avail
, ref
);
2193 else if (ifunc_resolver
2194 || lookup_attribute ("noipa", DECL_ATTRIBUTES (decl
)))
2195 avail
= AVAIL_INTERPOSABLE
;
2196 else if (!externally_visible
)
2197 avail
= AVAIL_AVAILABLE
;
2198 /* If this is a reference from symbol itself and there are no aliases, we
2199 may be sure that the symbol was not interposed by something else because
2200 the symbol itself would be unreachable otherwise.
2202 Also comdat groups are always resolved in groups. */
2203 else if ((this == ref
&& !has_aliases_p ())
2204 || (ref
&& get_comdat_group ()
2205 && get_comdat_group () == ref
->get_comdat_group ()))
2206 avail
= AVAIL_AVAILABLE
;
2207 /* Inline functions are safe to be analyzed even if their symbol can
2208 be overwritten at runtime. It is not meaningful to enforce any sane
2209 behavior on replacing inline function by different body. */
2210 else if (DECL_DECLARED_INLINE_P (decl
))
2211 avail
= AVAIL_AVAILABLE
;
2213 /* If the function can be overwritten, return OVERWRITABLE. Take
2214 care at least of two notable extensions - the COMDAT functions
2215 used to share template instantiations in C++ (this is symmetric
2216 to code cp_cannot_inline_tree_fn and probably shall be shared and
2217 the inlinability hooks completely eliminated). */
2219 else if (decl_replaceable_p (decl
) && !DECL_EXTERNAL (decl
))
2220 avail
= AVAIL_INTERPOSABLE
;
2221 else avail
= AVAIL_AVAILABLE
;
2226 /* Worker for cgraph_node_can_be_local_p. */
2228 cgraph_node_cannot_be_local_p_1 (cgraph_node
*node
, void *)
2230 return !(!node
->force_output
2231 && ((DECL_COMDAT (node
->decl
)
2232 && !node
->forced_by_abi
2233 && !node
->used_from_object_file_p ()
2234 && !node
->same_comdat_group
)
2235 || !node
->externally_visible
));
2238 /* Return true if cgraph_node can be made local for API change.
2239 Extern inline functions and C++ COMDAT functions can be made local
2240 at the expense of possible code size growth if function is used in multiple
2241 compilation units. */
2243 cgraph_node::can_be_local_p (void)
2245 return (!address_taken
2246 && !call_for_symbol_thunks_and_aliases (cgraph_node_cannot_be_local_p_1
,
2250 /* Call callback on cgraph_node, thunks and aliases associated to cgraph_node.
2251 When INCLUDE_OVERWRITABLE is false, overwritable symbols are
2252 skipped. When EXCLUDE_VIRTUAL_THUNKS is true, virtual thunks are
2255 cgraph_node::call_for_symbol_thunks_and_aliases (bool (*callback
)
2256 (cgraph_node
*, void *),
2258 bool include_overwritable
,
2259 bool exclude_virtual_thunks
)
2263 enum availability avail
= AVAIL_AVAILABLE
;
2265 if (include_overwritable
2266 || (avail
= get_availability ()) > AVAIL_INTERPOSABLE
)
2268 if (callback (this, data
))
2271 FOR_EACH_ALIAS (this, ref
)
2273 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2274 if (include_overwritable
2275 || alias
->get_availability () > AVAIL_INTERPOSABLE
)
2276 if (alias
->call_for_symbol_thunks_and_aliases (callback
, data
,
2277 include_overwritable
,
2278 exclude_virtual_thunks
))
2281 if (avail
<= AVAIL_INTERPOSABLE
)
2283 for (e
= callers
; e
; e
= e
->next_caller
)
2284 if (e
->caller
->thunk
.thunk_p
2285 && (include_overwritable
2286 || e
->caller
->get_availability () > AVAIL_INTERPOSABLE
)
2287 && !(exclude_virtual_thunks
2288 && e
->caller
->thunk
.virtual_offset_p
))
2289 if (e
->caller
->call_for_symbol_thunks_and_aliases (callback
, data
,
2290 include_overwritable
,
2291 exclude_virtual_thunks
))
2297 /* Worker to bring NODE local. */
2300 cgraph_node::make_local (cgraph_node
*node
, void *)
2302 gcc_checking_assert (node
->can_be_local_p ());
2303 if (DECL_COMDAT (node
->decl
) || DECL_EXTERNAL (node
->decl
))
2305 node
->make_decl_local ();
2306 node
->set_section (NULL
);
2307 node
->set_comdat_group (NULL
);
2308 node
->externally_visible
= false;
2309 node
->forced_by_abi
= false;
2311 node
->set_section (NULL
);
2312 node
->unique_name
= ((node
->resolution
== LDPR_PREVAILING_DEF_IRONLY
2313 || node
->resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
)
2314 && !flag_incremental_link
);
2315 node
->resolution
= LDPR_PREVAILING_DEF_IRONLY
;
2316 gcc_assert (node
->get_availability () == AVAIL_LOCAL
);
2321 /* Bring cgraph node local. */
2324 cgraph_node::make_local (void)
2326 call_for_symbol_thunks_and_aliases (cgraph_node::make_local
, NULL
, true);
2329 /* Worker to set nothrow flag. */
2332 set_nothrow_flag_1 (cgraph_node
*node
, bool nothrow
, bool non_call
,
2337 if (nothrow
&& !TREE_NOTHROW (node
->decl
))
2339 /* With non-call exceptions we can't say for sure if other function body
2340 was not possibly optimized to still throw. */
2341 if (!non_call
|| node
->binds_to_current_def_p ())
2343 TREE_NOTHROW (node
->decl
) = true;
2345 for (e
= node
->callers
; e
; e
= e
->next_caller
)
2346 e
->can_throw_external
= false;
2349 else if (!nothrow
&& TREE_NOTHROW (node
->decl
))
2351 TREE_NOTHROW (node
->decl
) = false;
2355 FOR_EACH_ALIAS (node
, ref
)
2357 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2358 if (!nothrow
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2359 set_nothrow_flag_1 (alias
, nothrow
, non_call
, changed
);
2361 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
2362 if (e
->caller
->thunk
.thunk_p
2363 && (!nothrow
|| e
->caller
->get_availability () > AVAIL_INTERPOSABLE
))
2364 set_nothrow_flag_1 (e
->caller
, nothrow
, non_call
, changed
);
2367 /* Set TREE_NOTHROW on NODE's decl and on aliases of NODE
2368 if any to NOTHROW. */
2371 cgraph_node::set_nothrow_flag (bool nothrow
)
2373 bool changed
= false;
2374 bool non_call
= opt_for_fn (decl
, flag_non_call_exceptions
);
2376 if (!nothrow
|| get_availability () > AVAIL_INTERPOSABLE
)
2377 set_nothrow_flag_1 (this, nothrow
, non_call
, &changed
);
2382 FOR_EACH_ALIAS (this, ref
)
2384 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2385 if (!nothrow
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2386 set_nothrow_flag_1 (alias
, nothrow
, non_call
, &changed
);
2392 /* Worker to set malloc flag. */
2394 set_malloc_flag_1 (cgraph_node
*node
, bool malloc_p
, bool *changed
)
2396 if (malloc_p
&& !DECL_IS_MALLOC (node
->decl
))
2398 DECL_IS_MALLOC (node
->decl
) = true;
2403 FOR_EACH_ALIAS (node
, ref
)
2405 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2406 if (!malloc_p
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2407 set_malloc_flag_1 (alias
, malloc_p
, changed
);
2410 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
2411 if (e
->caller
->thunk
.thunk_p
2412 && (!malloc_p
|| e
->caller
->get_availability () > AVAIL_INTERPOSABLE
))
2413 set_malloc_flag_1 (e
->caller
, malloc_p
, changed
);
2416 /* Set DECL_IS_MALLOC on NODE's decl and on NODE's aliases if any. */
2419 cgraph_node::set_malloc_flag (bool malloc_p
)
2421 bool changed
= false;
2423 if (!malloc_p
|| get_availability () > AVAIL_INTERPOSABLE
)
2424 set_malloc_flag_1 (this, malloc_p
, &changed
);
2429 FOR_EACH_ALIAS (this, ref
)
2431 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2432 if (!malloc_p
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2433 set_malloc_flag_1 (alias
, malloc_p
, &changed
);
2439 /* Worker to set_const_flag. */
2442 set_const_flag_1 (cgraph_node
*node
, bool set_const
, bool looping
,
2445 /* Static constructors and destructors without a side effect can be
2447 if (set_const
&& !looping
)
2449 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
2451 DECL_STATIC_CONSTRUCTOR (node
->decl
) = 0;
2454 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
2456 DECL_STATIC_DESTRUCTOR (node
->decl
) = 0;
2462 if (TREE_READONLY (node
->decl
))
2464 TREE_READONLY (node
->decl
) = 0;
2465 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2471 /* Consider function:
2478 During early optimization we will turn this into:
2485 Now if this function will be detected as CONST however when interposed
2486 it may end up being just pure. We always must assume the worst
2488 if (TREE_READONLY (node
->decl
))
2490 if (!looping
&& DECL_LOOPING_CONST_OR_PURE_P (node
->decl
))
2492 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2496 else if (node
->binds_to_current_def_p ())
2498 TREE_READONLY (node
->decl
) = true;
2499 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = looping
;
2500 DECL_PURE_P (node
->decl
) = false;
2505 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2506 fprintf (dump_file
, "Dropping state to PURE because function does "
2507 "not bind to current def.\n");
2508 if (!DECL_PURE_P (node
->decl
))
2510 DECL_PURE_P (node
->decl
) = true;
2511 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = looping
;
2514 else if (!looping
&& DECL_LOOPING_CONST_OR_PURE_P (node
->decl
))
2516 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2523 FOR_EACH_ALIAS (node
, ref
)
2525 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2526 if (!set_const
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2527 set_const_flag_1 (alias
, set_const
, looping
, changed
);
2529 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
2530 if (e
->caller
->thunk
.thunk_p
2531 && (!set_const
|| e
->caller
->get_availability () > AVAIL_INTERPOSABLE
))
2533 /* Virtual thunks access virtual offset in the vtable, so they can
2534 only be pure, never const. */
2536 && (e
->caller
->thunk
.virtual_offset_p
2537 || !node
->binds_to_current_def_p (e
->caller
)))
2538 *changed
|= e
->caller
->set_pure_flag (true, looping
);
2540 set_const_flag_1 (e
->caller
, set_const
, looping
, changed
);
2544 /* If SET_CONST is true, mark function, aliases and thunks to be ECF_CONST.
2545 If SET_CONST if false, clear the flag.
2547 When setting the flag be careful about possible interposition and
2548 do not set the flag for functions that can be interposed and set pure
2549 flag for functions that can bind to other definition.
2551 Return true if any change was done. */
2554 cgraph_node::set_const_flag (bool set_const
, bool looping
)
2556 bool changed
= false;
2557 if (!set_const
|| get_availability () > AVAIL_INTERPOSABLE
)
2558 set_const_flag_1 (this, set_const
, looping
, &changed
);
2563 FOR_EACH_ALIAS (this, ref
)
2565 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2566 if (!set_const
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2567 set_const_flag_1 (alias
, set_const
, looping
, &changed
);
2573 /* Info used by set_pure_flag_1. */
2575 struct set_pure_flag_info
2582 /* Worker to set_pure_flag. */
2585 set_pure_flag_1 (cgraph_node
*node
, void *data
)
2587 struct set_pure_flag_info
*info
= (struct set_pure_flag_info
*)data
;
2588 /* Static constructors and destructors without a side effect can be
2590 if (info
->pure
&& !info
->looping
)
2592 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
2594 DECL_STATIC_CONSTRUCTOR (node
->decl
) = 0;
2595 info
->changed
= true;
2597 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
2599 DECL_STATIC_DESTRUCTOR (node
->decl
) = 0;
2600 info
->changed
= true;
2605 if (!DECL_PURE_P (node
->decl
) && !TREE_READONLY (node
->decl
))
2607 DECL_PURE_P (node
->decl
) = true;
2608 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = info
->looping
;
2609 info
->changed
= true;
2611 else if (DECL_LOOPING_CONST_OR_PURE_P (node
->decl
)
2614 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2615 info
->changed
= true;
2620 if (DECL_PURE_P (node
->decl
))
2622 DECL_PURE_P (node
->decl
) = false;
2623 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2624 info
->changed
= true;
2630 /* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node
2633 When setting the flag, be careful about possible interposition.
2634 Return true if any change was done. */
2637 cgraph_node::set_pure_flag (bool pure
, bool looping
)
2639 struct set_pure_flag_info info
= {pure
, looping
, false};
2640 call_for_symbol_thunks_and_aliases (set_pure_flag_1
, &info
, !pure
, true);
2641 return info
.changed
;
2644 /* Return true when cgraph_node cannot return or throw and thus
2645 it is safe to ignore its side effects for IPA analysis. */
2648 cgraph_node::cannot_return_p (void)
2650 int flags
= flags_from_decl_or_type (decl
);
2651 if (!opt_for_fn (decl
, flag_exceptions
))
2652 return (flags
& ECF_NORETURN
) != 0;
2654 return ((flags
& (ECF_NORETURN
| ECF_NOTHROW
))
2655 == (ECF_NORETURN
| ECF_NOTHROW
));
2658 /* Return true when call of edge cannot lead to return from caller
2659 and thus it is safe to ignore its side effects for IPA analysis
2660 when computing side effects of the caller.
2661 FIXME: We could actually mark all edges that have no reaching
2662 patch to the exit block or throw to get better results. */
2664 cgraph_edge::cannot_lead_to_return_p (void)
2666 if (caller
->cannot_return_p ())
2668 if (indirect_unknown_callee
)
2670 int flags
= indirect_info
->ecf_flags
;
2671 if (!opt_for_fn (caller
->decl
, flag_exceptions
))
2672 return (flags
& ECF_NORETURN
) != 0;
2674 return ((flags
& (ECF_NORETURN
| ECF_NOTHROW
))
2675 == (ECF_NORETURN
| ECF_NOTHROW
));
2678 return callee
->cannot_return_p ();
2681 /* Return true if the edge may be considered hot. */
2684 cgraph_edge::maybe_hot_p (void)
2686 if (!maybe_hot_count_p (NULL
, count
.ipa ()))
2688 if (caller
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
2690 && callee
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
))
2692 if (caller
->frequency
> NODE_FREQUENCY_UNLIKELY_EXECUTED
2694 && callee
->frequency
<= NODE_FREQUENCY_EXECUTED_ONCE
))
2696 if (opt_for_fn (caller
->decl
, optimize_size
))
2698 if (caller
->frequency
== NODE_FREQUENCY_HOT
)
2700 if (!count
.initialized_p ())
2702 cgraph_node
*where
= caller
->inlined_to
? caller
->inlined_to
: caller
;
2703 if (!where
->count
.initialized_p ())
2705 if (caller
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
)
2707 if (count
.apply_scale (2, 1) < where
->count
.apply_scale (3, 1))
2710 else if (count
.apply_scale (param_hot_bb_frequency_fraction
, 1)
2716 /* Worker for cgraph_can_remove_if_no_direct_calls_p. */
2719 nonremovable_p (cgraph_node
*node
, void *)
2721 return !node
->can_remove_if_no_direct_calls_and_refs_p ();
2724 /* Return true if whole comdat group can be removed if there are no direct
2728 cgraph_node::can_remove_if_no_direct_calls_p (bool will_inline
)
2730 struct ipa_ref
*ref
;
2732 /* For local symbols or non-comdat group it is the same as
2733 can_remove_if_no_direct_calls_p. */
2734 if (!externally_visible
|| !same_comdat_group
)
2736 if (DECL_EXTERNAL (decl
))
2740 return !call_for_symbol_and_aliases (nonremovable_p
, NULL
, true);
2743 if (will_inline
&& address_taken
)
2746 /* Otherwise check if we can remove the symbol itself and then verify
2747 that only uses of the comdat groups are direct call to THIS
2749 if (!can_remove_if_no_direct_calls_and_refs_p ())
2752 /* Check that all refs come from within the comdat group. */
2753 for (int i
= 0; iterate_referring (i
, ref
); i
++)
2754 if (ref
->referring
->get_comdat_group () != get_comdat_group ())
2757 struct cgraph_node
*target
= ultimate_alias_target ();
2758 for (cgraph_node
*next
= dyn_cast
<cgraph_node
*> (same_comdat_group
);
2759 next
!= this; next
= dyn_cast
<cgraph_node
*> (next
->same_comdat_group
))
2761 if (!externally_visible
)
2764 && !next
->can_remove_if_no_direct_calls_and_refs_p ())
2767 /* If we see different symbol than THIS, be sure to check calls. */
2768 if (next
->ultimate_alias_target () != target
)
2769 for (cgraph_edge
*e
= next
->callers
; e
; e
= e
->next_caller
)
2770 if (e
->caller
->get_comdat_group () != get_comdat_group ()
2774 /* If function is not being inlined, we care only about
2775 references outside of the comdat group. */
2777 for (int i
= 0; next
->iterate_referring (i
, ref
); i
++)
2778 if (ref
->referring
->get_comdat_group () != get_comdat_group ())
2784 /* Return true when function cgraph_node can be expected to be removed
2785 from program when direct calls in this compilation unit are removed.
2787 As a special case COMDAT functions are
2788 cgraph_can_remove_if_no_direct_calls_p while the are not
2789 cgraph_only_called_directly_p (it is possible they are called from other
2792 This function behaves as cgraph_only_called_directly_p because eliminating
2793 all uses of COMDAT function does not make it necessarily disappear from
2794 the program unless we are compiling whole program or we do LTO. In this
2795 case we know we win since dynamic linking will not really discard the
2796 linkonce section. */
2799 cgraph_node::will_be_removed_from_program_if_no_direct_calls_p
2802 gcc_assert (!inlined_to
);
2803 if (DECL_EXTERNAL (decl
))
2806 if (!in_lto_p
&& !flag_whole_program
)
2808 /* If the symbol is in comdat group, we need to verify that whole comdat
2809 group becomes unreachable. Technically we could skip references from
2810 within the group, too. */
2811 if (!only_called_directly_p ())
2813 if (same_comdat_group
&& externally_visible
)
2815 struct cgraph_node
*target
= ultimate_alias_target ();
2817 if (will_inline
&& address_taken
)
2819 for (cgraph_node
*next
= dyn_cast
<cgraph_node
*> (same_comdat_group
);
2821 next
= dyn_cast
<cgraph_node
*> (next
->same_comdat_group
))
2823 if (!externally_visible
)
2826 && !next
->only_called_directly_p ())
2829 /* If we see different symbol than THIS,
2830 be sure to check calls. */
2831 if (next
->ultimate_alias_target () != target
)
2832 for (cgraph_edge
*e
= next
->callers
; e
; e
= e
->next_caller
)
2833 if (e
->caller
->get_comdat_group () != get_comdat_group ()
2841 return can_remove_if_no_direct_calls_p (will_inline
);
2845 /* Worker for cgraph_only_called_directly_p. */
2848 cgraph_not_only_called_directly_p_1 (cgraph_node
*node
, void *)
2850 return !node
->only_called_directly_or_aliased_p ();
2853 /* Return true when function cgraph_node and all its aliases are only called
2855 i.e. it is not externally visible, address was not taken and
2856 it is not used in any other non-standard way. */
2859 cgraph_node::only_called_directly_p (void)
2861 gcc_assert (ultimate_alias_target () == this);
2862 return !call_for_symbol_and_aliases (cgraph_not_only_called_directly_p_1
,
2867 /* Collect all callers of NODE. Worker for collect_callers_of_node. */
2870 collect_callers_of_node_1 (cgraph_node
*node
, void *data
)
2872 vec
<cgraph_edge
*> *redirect_callers
= (vec
<cgraph_edge
*> *)data
;
2874 enum availability avail
;
2875 node
->ultimate_alias_target (&avail
);
2877 if (avail
> AVAIL_INTERPOSABLE
)
2878 for (cs
= node
->callers
; cs
!= NULL
; cs
= cs
->next_caller
)
2879 if (!cs
->indirect_inlining_edge
2880 && !cs
->caller
->thunk
.thunk_p
)
2881 redirect_callers
->safe_push (cs
);
2885 /* Collect all callers of cgraph_node and its aliases that are known to lead to
2886 cgraph_node (i.e. are not overwritable). */
2889 cgraph_node::collect_callers (void)
2891 vec
<cgraph_edge
*> redirect_callers
= vNULL
;
2892 call_for_symbol_thunks_and_aliases (collect_callers_of_node_1
,
2893 &redirect_callers
, false);
2894 return redirect_callers
;
2898 /* Return TRUE if NODE2 a clone of NODE or is equivalent to it. Return
2899 optimistically true if this cannot be determined. */
2902 clone_of_p (cgraph_node
*node
, cgraph_node
*node2
)
2904 node
= node
->ultimate_alias_target ();
2905 node2
= node2
->ultimate_alias_target ();
2907 if (node2
->clone_of
== node
2908 || node2
->former_clone_of
== node
->decl
)
2911 if (!node
->thunk
.thunk_p
&& !node
->former_thunk_p ())
2913 while (node2
&& node
->decl
!= node2
->decl
)
2914 node2
= node2
->clone_of
;
2915 return node2
!= NULL
;
2918 /* There are no virtual clones of thunks so check former_clone_of or if we
2919 might have skipped thunks because this adjustments are no longer
2921 while (node
->thunk
.thunk_p
|| node
->former_thunk_p ())
2923 if (!node
->thunk
.this_adjusting
)
2925 /* In case of instrumented expanded thunks, which can have multiple calls
2926 in them, we do not know how to continue and just have to be
2928 if (node
->callees
->next_callee
)
2930 node
= node
->callees
->callee
->ultimate_alias_target ();
2932 if (!node2
->clone
.param_adjustments
2933 || node2
->clone
.param_adjustments
->first_param_intact_p ())
2935 if (node2
->former_clone_of
== node
->decl
)
2938 cgraph_node
*n2
= node2
;
2939 while (n2
&& node
->decl
!= n2
->decl
)
2948 /* Verify edge count and frequency. */
2951 cgraph_edge::verify_count ()
2953 bool error_found
= false;
2954 if (!count
.verify ())
2956 error ("caller edge count invalid");
2962 /* Switch to THIS_CFUN if needed and print STMT to stderr. */
2964 cgraph_debug_gimple_stmt (function
*this_cfun
, gimple
*stmt
)
2966 bool fndecl_was_null
= false;
2967 /* debug_gimple_stmt needs correct cfun */
2968 if (cfun
!= this_cfun
)
2969 set_cfun (this_cfun
);
2970 /* ...and an actual current_function_decl */
2971 if (!current_function_decl
)
2973 current_function_decl
= this_cfun
->decl
;
2974 fndecl_was_null
= true;
2976 debug_gimple_stmt (stmt
);
2977 if (fndecl_was_null
)
2978 current_function_decl
= NULL
;
2981 /* Verify that call graph edge corresponds to DECL from the associated
2982 statement. Return true if the verification should fail. */
2985 cgraph_edge::verify_corresponds_to_fndecl (tree decl
)
2989 if (!decl
|| callee
->inlined_to
)
2991 if (symtab
->state
== LTO_STREAMING
)
2993 node
= cgraph_node::get (decl
);
2995 /* We do not know if a node from a different partition is an alias or what it
2996 aliases and therefore cannot do the former_clone_of check reliably. When
2997 body_removed is set, we have lost all information about what was alias or
2998 thunk of and also cannot proceed. */
3000 || node
->body_removed
3001 || node
->in_other_partition
3002 || callee
->icf_merged
3003 || callee
->in_other_partition
)
3006 node
= node
->ultimate_alias_target ();
3008 /* Optimizers can redirect unreachable calls or calls triggering undefined
3009 behavior to builtin_unreachable. */
3011 if (fndecl_built_in_p (callee
->decl
, BUILT_IN_UNREACHABLE
))
3014 if (callee
->former_clone_of
!= node
->decl
3015 && (node
!= callee
->ultimate_alias_target ())
3016 && !clone_of_p (node
, callee
))
3022 /* Disable warnings about missing quoting in GCC diagnostics for
3023 the verification errors. Their format strings don't follow GCC
3024 diagnostic conventions and the calls are ultimately followed by
3025 one to internal_error. */
3027 # pragma GCC diagnostic push
3028 # pragma GCC diagnostic ignored "-Wformat-diag"
3031 /* Verify cgraph nodes of given cgraph node. */
3033 cgraph_node::verify_node (void)
3036 function
*this_cfun
= DECL_STRUCT_FUNCTION (decl
);
3037 basic_block this_block
;
3038 gimple_stmt_iterator gsi
;
3039 bool error_found
= false;
3044 timevar_push (TV_CGRAPH_VERIFY
);
3045 error_found
|= verify_base ();
3046 for (e
= callees
; e
; e
= e
->next_callee
)
3049 error ("aux field set for edge %s->%s",
3050 identifier_to_locale (e
->caller
->name ()),
3051 identifier_to_locale (e
->callee
->name ()));
3054 if (!count
.verify ())
3056 error ("cgraph count invalid");
3059 if (inlined_to
&& same_comdat_group
)
3061 error ("inline clone in same comdat group list");
3064 if (!definition
&& !in_other_partition
&& local
)
3066 error ("local symbols must be defined");
3069 if (inlined_to
&& externally_visible
)
3071 error ("externally visible inline clone");
3074 if (inlined_to
&& address_taken
)
3076 error ("inline clone with address taken");
3079 if (inlined_to
&& force_output
)
3081 error ("inline clone is forced to output");
3084 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
3088 error ("aux field set for indirect edge from %s",
3089 identifier_to_locale (e
->caller
->name ()));
3092 if (!e
->indirect_unknown_callee
3093 || !e
->indirect_info
)
3095 error ("An indirect edge from %s is not marked as indirect or has "
3096 "associated indirect_info, the corresponding statement is: ",
3097 identifier_to_locale (e
->caller
->name ()));
3098 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3102 bool check_comdat
= comdat_local_p ();
3103 for (e
= callers
; e
; e
= e
->next_caller
)
3105 if (e
->verify_count ())
3108 && !in_same_comdat_group_p (e
->caller
))
3110 error ("comdat-local function called by %s outside its comdat",
3111 identifier_to_locale (e
->caller
->name ()));
3114 if (!e
->inline_failed
)
3117 != (e
->caller
->inlined_to
3118 ? e
->caller
->inlined_to
: e
->caller
))
3120 error ("inlined_to pointer is wrong");
3123 if (callers
->next_caller
)
3125 error ("multiple inline callers");
3132 error ("inlined_to pointer set for noninline callers");
3136 for (e
= callees
; e
; e
= e
->next_callee
)
3138 if (e
->verify_count ())
3140 if (gimple_has_body_p (e
->caller
->decl
)
3141 && !e
->caller
->inlined_to
3143 /* Optimized out calls are redirected to __builtin_unreachable. */
3144 && (e
->count
.nonzero_p ()
3145 || ! e
->callee
->decl
3146 || !fndecl_built_in_p (e
->callee
->decl
, BUILT_IN_UNREACHABLE
))
3148 == ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (decl
))->count
3149 && (!e
->count
.ipa_p ()
3150 && e
->count
.differs_from_p (gimple_bb (e
->call_stmt
)->count
)))
3152 error ("caller edge count does not match BB count");
3153 fprintf (stderr
, "edge count: ");
3154 e
->count
.dump (stderr
);
3155 fprintf (stderr
, "\n bb count: ");
3156 gimple_bb (e
->call_stmt
)->count
.dump (stderr
);
3157 fprintf (stderr
, "\n");
3161 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
3163 if (e
->verify_count ())
3165 if (gimple_has_body_p (e
->caller
->decl
)
3166 && !e
->caller
->inlined_to
3168 && e
->count
.ipa_p ()
3170 == ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (decl
))->count
3171 && (!e
->count
.ipa_p ()
3172 && e
->count
.differs_from_p (gimple_bb (e
->call_stmt
)->count
)))
3174 error ("indirect call count does not match BB count");
3175 fprintf (stderr
, "edge count: ");
3176 e
->count
.dump (stderr
);
3177 fprintf (stderr
, "\n bb count: ");
3178 gimple_bb (e
->call_stmt
)->count
.dump (stderr
);
3179 fprintf (stderr
, "\n");
3183 if (!callers
&& inlined_to
)
3185 error ("inlined_to pointer is set but no predecessors found");
3188 if (inlined_to
== this)
3190 error ("inlined_to pointer refers to itself");
3196 cgraph_node
*first_clone
= clone_of
->clones
;
3197 if (first_clone
!= this)
3199 if (prev_sibling_clone
->clone_of
!= clone_of
)
3201 error ("cgraph_node has wrong clone_of");
3209 for (n
= clones
; n
; n
= n
->next_sibling_clone
)
3210 if (n
->clone_of
!= this)
3214 error ("cgraph_node has wrong clone list");
3218 if ((prev_sibling_clone
|| next_sibling_clone
) && !clone_of
)
3220 error ("cgraph_node is in clone list but it is not clone");
3223 if (!prev_sibling_clone
&& clone_of
&& clone_of
->clones
!= this)
3225 error ("cgraph_node has wrong prev_clone pointer");
3228 if (prev_sibling_clone
&& prev_sibling_clone
->next_sibling_clone
!= this)
3230 error ("double linked list of clones corrupted");
3234 if (analyzed
&& alias
)
3236 bool ref_found
= false;
3238 ipa_ref
*ref
= NULL
;
3242 error ("Alias has call edges");
3245 for (i
= 0; iterate_reference (i
, ref
); i
++)
3246 if (ref
->use
!= IPA_REF_ALIAS
)
3248 error ("Alias has non-alias reference");
3253 error ("Alias has more than one alias reference");
3260 error ("Analyzed alias has no reference");
3265 if (analyzed
&& thunk
.thunk_p
)
3269 error ("No edge out of thunk node");
3272 else if (callees
->next_callee
)
3274 error ("More than one edge out of thunk node");
3277 if (gimple_has_body_p (decl
) && !inlined_to
)
3279 error ("Thunk is not supposed to have body");
3283 else if (analyzed
&& gimple_has_body_p (decl
)
3284 && !TREE_ASM_WRITTEN (decl
)
3285 && (!DECL_EXTERNAL (decl
) || inlined_to
)
3290 hash_set
<gimple
*> stmts
;
3292 ipa_ref
*ref
= NULL
;
3294 /* Reach the trees by walking over the CFG, and note the
3295 enclosing basic-blocks in the call edges. */
3296 FOR_EACH_BB_FN (this_block
, this_cfun
)
3298 for (gsi
= gsi_start_phis (this_block
);
3299 !gsi_end_p (gsi
); gsi_next (&gsi
))
3300 stmts
.add (gsi_stmt (gsi
));
3301 for (gsi
= gsi_start_bb (this_block
);
3305 gimple
*stmt
= gsi_stmt (gsi
);
3307 if (is_gimple_call (stmt
))
3309 cgraph_edge
*e
= get_edge (stmt
);
3310 tree decl
= gimple_call_fndecl (stmt
);
3315 error ("shared call_stmt:");
3316 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
3319 if (!e
->indirect_unknown_callee
)
3321 if (e
->verify_corresponds_to_fndecl (decl
))
3323 error ("edge points to wrong declaration:");
3324 debug_tree (e
->callee
->decl
);
3325 fprintf (stderr
," Instead of:");
3332 error ("an indirect edge with unknown callee "
3333 "corresponding to a call_stmt with "
3334 "a known declaration:");
3336 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3342 error ("missing callgraph edge for call stmt:");
3343 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
3349 for (i
= 0; iterate_reference (i
, ref
); i
++)
3350 if (ref
->stmt
&& !stmts
.contains (ref
->stmt
))
3352 error ("reference to dead statement");
3353 cgraph_debug_gimple_stmt (this_cfun
, ref
->stmt
);
3358 /* No CFG available?! */
3361 for (e
= callees
; e
; e
= e
->next_callee
)
3365 error ("edge %s->%s has no corresponding call_stmt",
3366 identifier_to_locale (e
->caller
->name ()),
3367 identifier_to_locale (e
->callee
->name ()));
3368 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3373 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
3375 if (!e
->aux
&& !e
->speculative
)
3377 error ("an indirect edge from %s has no corresponding call_stmt",
3378 identifier_to_locale (e
->caller
->name ()));
3379 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3388 for (cgraph_node
*n
= nested
; n
!= NULL
; n
= n
->next_nested
)
3390 if (n
->origin
== NULL
)
3392 error ("missing origin for a node in a nested list");
3395 else if (n
->origin
!= this)
3397 error ("origin points to a different parent");
3403 if (next_nested
!= NULL
&& origin
== NULL
)
3405 error ("missing origin for a node in a nested list");
3412 internal_error ("verify_cgraph_node failed");
3414 timevar_pop (TV_CGRAPH_VERIFY
);
3417 /* Verify whole cgraph structure. */
3419 cgraph_node::verify_cgraph_nodes (void)
3426 FOR_EACH_FUNCTION (node
)
3431 # pragma GCC diagnostic pop
3434 /* Walk the alias chain to return the function cgraph_node is alias of.
3435 Walk through thunks, too.
3436 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3437 When REF is non-NULL, assume that reference happens in symbol REF
3438 when determining the availability. */
3441 cgraph_node::function_symbol (enum availability
*availability
,
3442 struct symtab_node
*ref
)
3444 cgraph_node
*node
= ultimate_alias_target (availability
, ref
);
3446 while (node
->thunk
.thunk_p
)
3449 node
= node
->callees
->callee
;
3452 enum availability a
;
3453 a
= node
->get_availability (ref
);
3454 if (a
< *availability
)
3457 node
= node
->ultimate_alias_target (availability
, ref
);
3462 /* Walk the alias chain to return the function cgraph_node is alias of.
3463 Walk through non virtual thunks, too. Thus we return either a function
3464 or a virtual thunk node.
3465 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3466 When REF is non-NULL, assume that reference happens in symbol REF
3467 when determining the availability. */
3470 cgraph_node::function_or_virtual_thunk_symbol
3471 (enum availability
*availability
,
3472 struct symtab_node
*ref
)
3474 cgraph_node
*node
= ultimate_alias_target (availability
, ref
);
3476 while (node
->thunk
.thunk_p
&& !node
->thunk
.virtual_offset_p
)
3479 node
= node
->callees
->callee
;
3482 enum availability a
;
3483 a
= node
->get_availability (ref
);
3484 if (a
< *availability
)
3487 node
= node
->ultimate_alias_target (availability
, ref
);
3492 /* When doing LTO, read cgraph_node's body from disk if it is not already
3496 cgraph_node::get_untransformed_body (void)
3498 lto_file_decl_data
*file_data
;
3499 const char *data
, *name
;
3501 tree decl
= this->decl
;
3503 /* Check if body is already there. Either we have gimple body or
3504 the function is thunk and in that case we set DECL_ARGUMENTS. */
3505 if (DECL_ARGUMENTS (decl
) || gimple_has_body_p (decl
))
3508 gcc_assert (in_lto_p
&& !DECL_RESULT (decl
));
3510 timevar_push (TV_IPA_LTO_GIMPLE_IN
);
3512 file_data
= lto_file_data
;
3513 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
3515 /* We may have renamed the declaration, e.g., a static function. */
3516 name
= lto_get_decl_name_mapping (file_data
, name
);
3517 struct lto_in_decl_state
*decl_state
3518 = lto_get_function_in_decl_state (file_data
, decl
);
3520 cgraph_node
*origin
= this;
3521 while (origin
->clone_of
)
3522 origin
= origin
->clone_of
;
3524 int stream_order
= origin
->order
- file_data
->order_base
;
3525 data
= lto_get_section_data (file_data
, LTO_section_function_body
,
3526 name
, stream_order
, &len
,
3527 decl_state
->compressed
);
3529 fatal_error (input_location
, "%s: section %s.%d is missing",
3530 file_data
->file_name
, name
, stream_order
);
3532 gcc_assert (DECL_STRUCT_FUNCTION (decl
) == NULL
);
3535 fprintf (stderr
, " in:%s", IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
3536 lto_input_function_body (file_data
, this, data
);
3537 lto_stats
.num_function_bodies
++;
3538 lto_free_section_data (file_data
, LTO_section_function_body
, name
,
3539 data
, len
, decl_state
->compressed
);
3540 lto_free_function_in_decl_state_for_node (this);
3541 /* Keep lto file data so ipa-inline-analysis knows about cross module
3544 timevar_pop (TV_IPA_LTO_GIMPLE_IN
);
3549 /* Prepare function body. When doing LTO, read cgraph_node's body from disk
3550 if it is not already present. When some IPA transformations are scheduled,
3554 cgraph_node::get_body (void)
3558 updated
= get_untransformed_body ();
3560 /* Getting transformed body makes no sense for inline clones;
3561 we should never use this on real clones because they are materialized
3563 TODO: Materializing clones here will likely lead to smaller LTRANS
3565 gcc_assert (!inlined_to
&& !clone_of
);
3566 if (ipa_transforms_to_apply
.exists ())
3568 opt_pass
*saved_current_pass
= current_pass
;
3569 FILE *saved_dump_file
= dump_file
;
3570 const char *saved_dump_file_name
= dump_file_name
;
3571 dump_flags_t saved_dump_flags
= dump_flags
;
3572 dump_file_name
= NULL
;
3573 set_dump_file (NULL
);
3575 push_cfun (DECL_STRUCT_FUNCTION (decl
));
3576 execute_all_ipa_transforms (true);
3577 cgraph_edge::rebuild_edges ();
3578 free_dominance_info (CDI_DOMINATORS
);
3579 free_dominance_info (CDI_POST_DOMINATORS
);
3583 current_pass
= saved_current_pass
;
3584 set_dump_file (saved_dump_file
);
3585 dump_file_name
= saved_dump_file_name
;
3586 dump_flags
= saved_dump_flags
;
3591 /* Return the DECL_STRUCT_FUNCTION of the function. */
3594 cgraph_node::get_fun () const
3596 const cgraph_node
*node
= this;
3597 struct function
*fun
= DECL_STRUCT_FUNCTION (node
->decl
);
3599 while (!fun
&& node
->clone_of
)
3601 node
= node
->clone_of
;
3602 fun
= DECL_STRUCT_FUNCTION (node
->decl
);
3608 /* Reset all state within cgraph.c so that we can rerun the compiler
3609 within the same process. For use by toplev::finalize. */
3612 cgraph_c_finalize (void)
3616 x_cgraph_nodes_queue
= NULL
;
3618 cgraph_fnver_htab
= NULL
;
3619 version_info_node
= NULL
;
3622 /* A worker for call_for_symbol_and_aliases. */
3625 cgraph_node::call_for_symbol_and_aliases_1 (bool (*callback
) (cgraph_node
*,
3628 bool include_overwritable
)
3631 FOR_EACH_ALIAS (this, ref
)
3633 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
3634 if (include_overwritable
3635 || alias
->get_availability () > AVAIL_INTERPOSABLE
)
3636 if (alias
->call_for_symbol_and_aliases (callback
, data
,
3637 include_overwritable
))
3643 /* Return true if NODE has thunk. */
3646 cgraph_node::has_thunk_p (cgraph_node
*node
, void *)
3648 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
3649 if (e
->caller
->thunk
.thunk_p
)
3654 /* Expected frequency of executions within the function. */
3657 cgraph_edge::sreal_frequency ()
3659 return count
.to_sreal_scale (caller
->inlined_to
3660 ? caller
->inlined_to
->count
3665 /* During LTO stream in this can be used to check whether call can possibly
3666 be internal to the current translation unit. */
3669 cgraph_edge::possibly_call_in_translation_unit_p (void)
3671 gcc_checking_assert (in_lto_p
&& caller
->prevailing_p ());
3673 /* While incremental linking we may end up getting function body later. */
3674 if (flag_incremental_link
== INCREMENTAL_LINK_LTO
)
3677 /* We may be smarter here and avoid streaming in indirect calls we can't
3678 track, but that would require arranging streaming the indirect call
3683 /* If callee is local to the original translation unit, it will be
3685 if (!TREE_PUBLIC (callee
->decl
) && !DECL_EXTERNAL (callee
->decl
))
3688 /* Otherwise we need to lookup prevailing symbol (symbol table is not merged,
3689 yet) and see if it is a definition. In fact we may also resolve aliases,
3690 but that is probably not too important. */
3691 symtab_node
*node
= callee
;
3692 for (int n
= 10; node
->previous_sharing_asm_name
&& n
; n
--)
3693 node
= node
->previous_sharing_asm_name
;
3694 if (node
->previous_sharing_asm_name
)
3695 node
= symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (callee
->decl
));
3696 gcc_assert (TREE_PUBLIC (node
->decl
));
3697 return node
->get_availability () >= AVAIL_INTERPOSABLE
;
3700 /* A stashed copy of "symtab" for use by selftest::symbol_table_test.
3701 This needs to be a global so that it can be a GC root, and thus
3702 prevent the stashed copy from being garbage-collected if the GC runs
3703 during a symbol_table_test. */
3705 symbol_table
*saved_symtab
;
3709 namespace selftest
{
3711 /* class selftest::symbol_table_test. */
3713 /* Constructor. Store the old value of symtab, and create a new one. */
3715 symbol_table_test::symbol_table_test ()
3717 gcc_assert (saved_symtab
== NULL
);
3718 saved_symtab
= symtab
;
3719 symtab
= new (ggc_alloc
<symbol_table
> ()) symbol_table ();
3722 /* Destructor. Restore the old value of symtab. */
3724 symbol_table_test::~symbol_table_test ()
3726 gcc_assert (saved_symtab
!= NULL
);
3727 symtab
= saved_symtab
;
3728 saved_symtab
= NULL
;
3731 /* Verify that symbol_table_test works. */
3734 test_symbol_table_test ()
3736 /* Simulate running two selftests involving symbol tables. */
3737 for (int i
= 0; i
< 2; i
++)
3739 symbol_table_test stt
;
3740 tree test_decl
= build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
,
3741 get_identifier ("test_decl"),
3742 build_function_type_list (void_type_node
,
3744 cgraph_node
*node
= cgraph_node::get_create (test_decl
);
3747 /* Verify that the node has order 0 on both iterations,
3748 and thus that nodes have predictable dump names in selftests. */
3749 ASSERT_EQ (node
->order
, 0);
3750 ASSERT_STREQ (node
->dump_name (), "test_decl/0");
3754 /* Run all of the selftests within this file. */
3759 test_symbol_table_test ();
3762 } // namespace selftest
3764 #endif /* CHECKING_P */
3766 #include "gt-cgraph.h"