1 /* Callgraph handling code.
2 Copyright (C) 2003-2021 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 /* This file contains basic routines manipulating call graph
23 The call-graph is a data structure designed for inter-procedural
24 optimization. It represents a multi-graph where nodes are functions
25 (symbols within symbol table) and edges are call sites. */
29 #include "coretypes.h"
36 #include "alloc-pool.h"
37 #include "gimple-ssa.h"
39 #include "lto-streamer.h"
40 #include "fold-const.h"
43 #include "print-tree.h"
44 #include "langhooks.h"
47 #include "gimple-iterator.h"
50 #include "value-prof.h"
51 #include "ipa-utils.h"
52 #include "symbol-summary.h"
55 #include "ipa-fnsummary.h"
57 #include "gimple-pretty-print.h"
62 #include "stringpool.h"
65 #include "tree-into-ssa.h"
66 #include "ipa-inline.h"
67 #include "tree-nested.h"
68 #include "symtab-thunks.h"
69 #include "symtab-clones.h"
71 /* FIXME: Only for PROP_loops, but cgraph shouldn't have to know about this. */
72 #include "tree-pass.h"
74 /* Queue of cgraph nodes scheduled to be lowered. */
75 symtab_node
*x_cgraph_nodes_queue
;
76 #define cgraph_nodes_queue ((cgraph_node *)x_cgraph_nodes_queue)
78 /* Symbol table global context. */
81 /* List of hooks triggered on cgraph_edge events. */
82 struct cgraph_edge_hook_list
{
83 cgraph_edge_hook hook
;
85 struct cgraph_edge_hook_list
*next
;
88 /* List of hooks triggered on cgraph_node events. */
89 struct cgraph_node_hook_list
{
90 cgraph_node_hook hook
;
92 struct cgraph_node_hook_list
*next
;
95 /* List of hooks triggered on events involving two cgraph_edges. */
96 struct cgraph_2edge_hook_list
{
97 cgraph_2edge_hook hook
;
99 struct cgraph_2edge_hook_list
*next
;
102 /* List of hooks triggered on events involving two cgraph_nodes. */
103 struct cgraph_2node_hook_list
{
104 cgraph_2node_hook hook
;
106 struct cgraph_2node_hook_list
*next
;
109 /* Hash descriptor for cgraph_function_version_info. */
111 struct function_version_hasher
: ggc_ptr_hash
<cgraph_function_version_info
>
113 static hashval_t
hash (cgraph_function_version_info
*);
114 static bool equal (cgraph_function_version_info
*,
115 cgraph_function_version_info
*);
118 /* Map a cgraph_node to cgraph_function_version_info using this htab.
119 The cgraph_function_version_info has a THIS_NODE field that is the
120 corresponding cgraph_node.. */
122 static GTY(()) hash_table
<function_version_hasher
> *cgraph_fnver_htab
= NULL
;
124 /* Hash function for cgraph_fnver_htab. */
126 function_version_hasher::hash (cgraph_function_version_info
*ptr
)
128 int uid
= ptr
->this_node
->get_uid ();
129 return (hashval_t
)(uid
);
132 /* eq function for cgraph_fnver_htab. */
134 function_version_hasher::equal (cgraph_function_version_info
*n1
,
135 cgraph_function_version_info
*n2
)
137 return n1
->this_node
->get_uid () == n2
->this_node
->get_uid ();
140 /* Mark as GC root all allocated nodes. */
141 static GTY(()) struct cgraph_function_version_info
*
142 version_info_node
= NULL
;
144 /* Return true if NODE's address can be compared. */
147 symtab_node::address_can_be_compared_p ()
149 /* Address of virtual tables and functions is never compared. */
150 if (DECL_VIRTUAL_P (decl
))
152 /* Address of C++ cdtors is never compared. */
153 if (is_a
<cgraph_node
*> (this)
154 && (DECL_CXX_CONSTRUCTOR_P (decl
)
155 || DECL_CXX_DESTRUCTOR_P (decl
)))
157 /* Constant pool symbols addresses are never compared.
158 flag_merge_constants permits us to assume the same on readonly vars. */
159 if (is_a
<varpool_node
*> (this)
160 && (DECL_IN_CONSTANT_POOL (decl
)
161 || (flag_merge_constants
>= 2
162 && TREE_READONLY (decl
) && !TREE_THIS_VOLATILE (decl
))))
167 /* Get the cgraph_function_version_info node corresponding to node. */
168 cgraph_function_version_info
*
169 cgraph_node::function_version (void)
171 cgraph_function_version_info key
;
172 key
.this_node
= this;
174 if (cgraph_fnver_htab
== NULL
)
177 return cgraph_fnver_htab
->find (&key
);
180 /* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
181 corresponding to cgraph_node NODE. */
182 cgraph_function_version_info
*
183 cgraph_node::insert_new_function_version (void)
185 version_info_node
= NULL
;
186 version_info_node
= ggc_cleared_alloc
<cgraph_function_version_info
> ();
187 version_info_node
->this_node
= this;
189 if (cgraph_fnver_htab
== NULL
)
190 cgraph_fnver_htab
= hash_table
<function_version_hasher
>::create_ggc (2);
192 *cgraph_fnver_htab
->find_slot (version_info_node
, INSERT
)
194 return version_info_node
;
197 /* Remove the cgraph_function_version_info node given by DECL_V. */
199 delete_function_version (cgraph_function_version_info
*decl_v
)
204 if (version_info_node
== decl_v
)
205 version_info_node
= NULL
;
207 if (decl_v
->prev
!= NULL
)
208 decl_v
->prev
->next
= decl_v
->next
;
210 if (decl_v
->next
!= NULL
)
211 decl_v
->next
->prev
= decl_v
->prev
;
213 if (cgraph_fnver_htab
!= NULL
)
214 cgraph_fnver_htab
->remove_elt (decl_v
);
217 /* Remove the cgraph_function_version_info and cgraph_node for DECL. This
218 DECL is a duplicate declaration. */
220 cgraph_node::delete_function_version_by_decl (tree decl
)
222 cgraph_node
*decl_node
= cgraph_node::get (decl
);
224 if (decl_node
== NULL
)
227 delete_function_version (decl_node
->function_version ());
229 decl_node
->remove ();
232 /* Record that DECL1 and DECL2 are semantically identical function
235 cgraph_node::record_function_versions (tree decl1
, tree decl2
)
237 cgraph_node
*decl1_node
= cgraph_node::get_create (decl1
);
238 cgraph_node
*decl2_node
= cgraph_node::get_create (decl2
);
239 cgraph_function_version_info
*decl1_v
= NULL
;
240 cgraph_function_version_info
*decl2_v
= NULL
;
241 cgraph_function_version_info
*before
;
242 cgraph_function_version_info
*after
;
244 gcc_assert (decl1_node
!= NULL
&& decl2_node
!= NULL
);
245 decl1_v
= decl1_node
->function_version ();
246 decl2_v
= decl2_node
->function_version ();
248 if (decl1_v
!= NULL
&& decl2_v
!= NULL
)
252 decl1_v
= decl1_node
->insert_new_function_version ();
255 decl2_v
= decl2_node
->insert_new_function_version ();
257 /* Chain decl2_v and decl1_v. All semantically identical versions
258 will be chained together. */
263 while (before
->next
!= NULL
)
264 before
= before
->next
;
266 while (after
->prev
!= NULL
)
269 before
->next
= after
;
270 after
->prev
= before
;
273 /* Initialize callgraph dump file. */
276 symbol_table::initialize (void)
279 dump_file
= dump_begin (TDI_cgraph
, NULL
);
281 if (!ipa_clones_dump_file
)
282 ipa_clones_dump_file
= dump_begin (TDI_clones
, NULL
);
285 /* Allocate new callgraph node and insert it into basic data structures. */
288 symbol_table::create_empty (void)
291 return new (ggc_alloc
<cgraph_node
> ()) cgraph_node (cgraph_max_uid
++);
294 /* Register HOOK to be called with DATA on each removed edge. */
295 cgraph_edge_hook_list
*
296 symbol_table::add_edge_removal_hook (cgraph_edge_hook hook
, void *data
)
298 cgraph_edge_hook_list
*entry
;
299 cgraph_edge_hook_list
**ptr
= &m_first_edge_removal_hook
;
301 entry
= (cgraph_edge_hook_list
*) xmalloc (sizeof (*entry
));
311 /* Remove ENTRY from the list of hooks called on removing edges. */
313 symbol_table::remove_edge_removal_hook (cgraph_edge_hook_list
*entry
)
315 cgraph_edge_hook_list
**ptr
= &m_first_edge_removal_hook
;
317 while (*ptr
!= entry
)
323 /* Call all edge removal hooks. */
325 symbol_table::call_edge_removal_hooks (cgraph_edge
*e
)
327 cgraph_edge_hook_list
*entry
= m_first_edge_removal_hook
;
330 entry
->hook (e
, entry
->data
);
335 /* Register HOOK to be called with DATA on each removed node. */
336 cgraph_node_hook_list
*
337 symbol_table::add_cgraph_removal_hook (cgraph_node_hook hook
, void *data
)
339 cgraph_node_hook_list
*entry
;
340 cgraph_node_hook_list
**ptr
= &m_first_cgraph_removal_hook
;
342 entry
= (cgraph_node_hook_list
*) xmalloc (sizeof (*entry
));
352 /* Remove ENTRY from the list of hooks called on removing nodes. */
354 symbol_table::remove_cgraph_removal_hook (cgraph_node_hook_list
*entry
)
356 cgraph_node_hook_list
**ptr
= &m_first_cgraph_removal_hook
;
358 while (*ptr
!= entry
)
364 /* Call all node removal hooks. */
366 symbol_table::call_cgraph_removal_hooks (cgraph_node
*node
)
368 cgraph_node_hook_list
*entry
= m_first_cgraph_removal_hook
;
371 entry
->hook (node
, entry
->data
);
376 /* Call all node removal hooks. */
378 symbol_table::call_cgraph_insertion_hooks (cgraph_node
*node
)
380 cgraph_node_hook_list
*entry
= m_first_cgraph_insertion_hook
;
383 entry
->hook (node
, entry
->data
);
389 /* Register HOOK to be called with DATA on each inserted node. */
390 cgraph_node_hook_list
*
391 symbol_table::add_cgraph_insertion_hook (cgraph_node_hook hook
, void *data
)
393 cgraph_node_hook_list
*entry
;
394 cgraph_node_hook_list
**ptr
= &m_first_cgraph_insertion_hook
;
396 entry
= (cgraph_node_hook_list
*) xmalloc (sizeof (*entry
));
406 /* Remove ENTRY from the list of hooks called on inserted nodes. */
408 symbol_table::remove_cgraph_insertion_hook (cgraph_node_hook_list
*entry
)
410 cgraph_node_hook_list
**ptr
= &m_first_cgraph_insertion_hook
;
412 while (*ptr
!= entry
)
418 /* Register HOOK to be called with DATA on each duplicated edge. */
419 cgraph_2edge_hook_list
*
420 symbol_table::add_edge_duplication_hook (cgraph_2edge_hook hook
, void *data
)
422 cgraph_2edge_hook_list
*entry
;
423 cgraph_2edge_hook_list
**ptr
= &m_first_edge_duplicated_hook
;
425 entry
= (cgraph_2edge_hook_list
*) xmalloc (sizeof (*entry
));
435 /* Remove ENTRY from the list of hooks called on duplicating edges. */
437 symbol_table::remove_edge_duplication_hook (cgraph_2edge_hook_list
*entry
)
439 cgraph_2edge_hook_list
**ptr
= &m_first_edge_duplicated_hook
;
441 while (*ptr
!= entry
)
447 /* Call all edge duplication hooks. */
449 symbol_table::call_edge_duplication_hooks (cgraph_edge
*cs1
, cgraph_edge
*cs2
)
451 cgraph_2edge_hook_list
*entry
= m_first_edge_duplicated_hook
;
454 entry
->hook (cs1
, cs2
, entry
->data
);
459 /* Register HOOK to be called with DATA on each duplicated node. */
460 cgraph_2node_hook_list
*
461 symbol_table::add_cgraph_duplication_hook (cgraph_2node_hook hook
, void *data
)
463 cgraph_2node_hook_list
*entry
;
464 cgraph_2node_hook_list
**ptr
= &m_first_cgraph_duplicated_hook
;
466 entry
= (cgraph_2node_hook_list
*) xmalloc (sizeof (*entry
));
476 /* Remove ENTRY from the list of hooks called on duplicating nodes. */
478 symbol_table::remove_cgraph_duplication_hook (cgraph_2node_hook_list
*entry
)
480 cgraph_2node_hook_list
**ptr
= &m_first_cgraph_duplicated_hook
;
482 while (*ptr
!= entry
)
488 /* Call all node duplication hooks. */
490 symbol_table::call_cgraph_duplication_hooks (cgraph_node
*node
,
493 cgraph_2node_hook_list
*entry
= m_first_cgraph_duplicated_hook
;
496 entry
->hook (node
, node2
, entry
->data
);
501 /* Return cgraph node assigned to DECL. Create new one when needed. */
504 cgraph_node::create (tree decl
)
506 cgraph_node
*node
= symtab
->create_empty ();
507 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
511 if ((flag_openacc
|| flag_openmp
)
512 && lookup_attribute ("omp declare target", DECL_ATTRIBUTES (decl
)))
514 node
->offloadable
= 1;
515 if (ENABLE_OFFLOADING
)
516 g
->have_offload
= true;
519 if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl
)))
520 node
->ifunc_resolver
= true;
522 node
->register_symbol ();
523 maybe_record_nested_function (node
);
528 /* Try to find a call graph node for declaration DECL and if it does not exist
529 or if it corresponds to an inline clone, create a new one. */
532 cgraph_node::get_create (tree decl
)
534 cgraph_node
*first_clone
= cgraph_node::get (decl
);
536 if (first_clone
&& !first_clone
->inlined_to
)
539 cgraph_node
*node
= cgraph_node::create (decl
);
542 first_clone
->clone_of
= node
;
543 node
->clones
= first_clone
;
544 node
->order
= first_clone
->order
;
545 symtab
->symtab_prevail_in_asm_name_hash (node
);
546 node
->decl
->decl_with_vis
.symtab_node
= node
;
548 fprintf (dump_file
, "Introduced new external node "
549 "(%s) and turned into root of the clone tree.\n",
553 fprintf (dump_file
, "Introduced new external node "
554 "(%s).\n", node
->dump_name ());
558 /* Mark ALIAS as an alias to DECL. DECL_NODE is cgraph node representing
559 the function body is associated with
560 (not necessarily cgraph_node (DECL)). */
563 cgraph_node::create_alias (tree alias
, tree target
)
565 cgraph_node
*alias_node
;
567 gcc_assert (TREE_CODE (target
) == FUNCTION_DECL
568 || TREE_CODE (target
) == IDENTIFIER_NODE
);
569 gcc_assert (TREE_CODE (alias
) == FUNCTION_DECL
);
570 alias_node
= cgraph_node::get_create (alias
);
571 gcc_assert (!alias_node
->definition
);
572 alias_node
->alias_target
= target
;
573 alias_node
->definition
= true;
574 alias_node
->alias
= true;
575 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (alias
)) != NULL
)
576 alias_node
->transparent_alias
= alias_node
->weakref
= true;
577 if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (alias
)))
578 alias_node
->ifunc_resolver
= true;
582 /* Attempt to mark ALIAS as an alias to DECL. Return alias node if successful
584 Same body aliases are output whenever the body of DECL is output,
585 and cgraph_node::get (ALIAS) transparently returns
586 cgraph_node::get (DECL). */
589 cgraph_node::create_same_body_alias (tree alias
, tree decl
)
593 /* If aliases aren't supported by the assembler, fail. */
594 if (!TARGET_SUPPORTS_ALIASES
)
597 /* Langhooks can create same body aliases of symbols not defined.
598 Those are useless. Drop them on the floor. */
599 if (symtab
->global_info_ready
)
602 n
= cgraph_node::create_alias (alias
, decl
);
603 n
->cpp_implicit_alias
= true;
604 if (symtab
->cpp_implicit_aliases_done
)
605 n
->resolve_alias (cgraph_node::get (decl
));
609 /* Add thunk alias into callgraph. The alias declaration is ALIAS and it
610 aliases DECL with an adjustments made into the first parameter.
611 See comments in struct cgraph_thunk_info for detail on the parameters. */
614 cgraph_node::create_thunk (tree alias
, tree
, bool this_adjusting
,
615 HOST_WIDE_INT fixed_offset
,
616 HOST_WIDE_INT virtual_value
,
617 HOST_WIDE_INT indirect_offset
,
623 node
= cgraph_node::get (alias
);
627 node
= cgraph_node::create (alias
);
629 /* Make sure that if VIRTUAL_OFFSET is in sync with VIRTUAL_VALUE. */
630 gcc_checking_assert (virtual_offset
631 ? virtual_value
== wi::to_wide (virtual_offset
)
632 : virtual_value
== 0);
635 node
->definition
= true;
638 thunk_info local_info
;
639 if (symtab
->state
< CONSTRUCTION
)
642 i
= thunk_info::get_create (node
);
643 i
->fixed_offset
= fixed_offset
;
644 i
->virtual_value
= virtual_value
;
645 i
->indirect_offset
= indirect_offset
;
646 i
->alias
= real_alias
;
647 i
->this_adjusting
= this_adjusting
;
648 i
->virtual_offset_p
= virtual_offset
!= NULL
;
649 if (symtab
->state
< CONSTRUCTION
)
650 i
->register_early (node
);
655 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
656 Return NULL if there's no such node. */
659 cgraph_node::get_for_asmname (tree asmname
)
661 /* We do not want to look at inline clones. */
662 for (symtab_node
*node
= symtab_node::get_for_asmname (asmname
);
664 node
= node
->next_sharing_asm_name
)
666 cgraph_node
*cn
= dyn_cast
<cgraph_node
*> (node
);
667 if (cn
&& !cn
->inlined_to
)
673 /* Returns a hash value for X (which really is a cgraph_edge). */
676 cgraph_edge_hasher::hash (cgraph_edge
*e
)
678 /* This is a really poor hash function, but it is what htab_hash_pointer
680 return (hashval_t
) ((intptr_t)e
->call_stmt
>> 3);
683 /* Returns a hash value for X (which really is a cgraph_edge). */
686 cgraph_edge_hasher::hash (gimple
*call_stmt
)
688 /* This is a really poor hash function, but it is what htab_hash_pointer
690 return (hashval_t
) ((intptr_t)call_stmt
>> 3);
693 /* Return nonzero if the call_stmt of cgraph_edge X is stmt *Y. */
696 cgraph_edge_hasher::equal (cgraph_edge
*x
, gimple
*y
)
698 return x
->call_stmt
== y
;
701 /* Add call graph edge E to call site hash of its caller. */
704 cgraph_update_edge_in_call_site_hash (cgraph_edge
*e
)
706 gimple
*call
= e
->call_stmt
;
707 *e
->caller
->call_site_hash
->find_slot_with_hash
708 (call
, cgraph_edge_hasher::hash (call
), INSERT
) = e
;
711 /* Add call graph edge E to call site hash of its caller. */
714 cgraph_add_edge_to_call_site_hash (cgraph_edge
*e
)
716 /* There are two speculative edges for every statement (one direct,
717 one indirect); always hash the direct one. */
718 if (e
->speculative
&& e
->indirect_unknown_callee
)
720 cgraph_edge
**slot
= e
->caller
->call_site_hash
->find_slot_with_hash
721 (e
->call_stmt
, cgraph_edge_hasher::hash (e
->call_stmt
), INSERT
);
724 gcc_assert (((cgraph_edge
*)*slot
)->speculative
);
725 if (e
->callee
&& (!e
->prev_callee
726 || !e
->prev_callee
->speculative
727 || e
->prev_callee
->call_stmt
!= e
->call_stmt
))
731 gcc_assert (!*slot
|| e
->speculative
);
735 /* Return the callgraph edge representing the GIMPLE_CALL statement
739 cgraph_node::get_edge (gimple
*call_stmt
)
745 return call_site_hash
->find_with_hash
746 (call_stmt
, cgraph_edge_hasher::hash (call_stmt
));
748 /* This loop may turn out to be performance problem. In such case adding
749 hashtables into call nodes with very many edges is probably best
750 solution. It is not good idea to add pointer into CALL_EXPR itself
751 because we want to make possible having multiple cgraph nodes representing
752 different clones of the same body before the body is actually cloned. */
753 for (e
= callees
; e
; e
= e
->next_callee
)
755 if (e
->call_stmt
== call_stmt
)
761 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
763 if (e
->call_stmt
== call_stmt
)
770 call_site_hash
= hash_table
<cgraph_edge_hasher
>::create_ggc (120);
771 for (e2
= callees
; e2
; e2
= e2
->next_callee
)
772 cgraph_add_edge_to_call_site_hash (e2
);
773 for (e2
= indirect_calls
; e2
; e2
= e2
->next_callee
)
774 cgraph_add_edge_to_call_site_hash (e2
);
781 /* Change field call_stmt of edge E to NEW_STMT. If UPDATE_SPECULATIVE and E
782 is any component of speculative edge, then update all components.
783 Speculations can be resolved in the process and EDGE can be removed and
784 deallocated. Return the edge that now represents the call. */
787 cgraph_edge::set_call_stmt (cgraph_edge
*e
, gcall
*new_stmt
,
788 bool update_speculative
)
792 cgraph_node
*new_direct_callee
= NULL
;
793 if ((e
->indirect_unknown_callee
|| e
->speculative
)
794 && (decl
= gimple_call_fndecl (new_stmt
)))
796 /* Constant propagation and especially inlining can turn an indirect call
797 into a direct one. */
798 new_direct_callee
= cgraph_node::get (decl
);
799 gcc_checking_assert (new_direct_callee
);
802 /* Speculative edges has three component, update all of them
804 if (update_speculative
&& e
->speculative
805 /* If we are about to resolve the speculation by calling make_direct
806 below, do not bother going over all the speculative edges now. */
807 && !new_direct_callee
)
809 cgraph_edge
*direct
, *indirect
, *next
;
811 bool e_indirect
= e
->indirect_unknown_callee
;
814 direct
= e
->first_speculative_call_target ();
815 indirect
= e
->speculative_call_indirect_edge ();
817 gcall
*old_stmt
= direct
->call_stmt
;
818 for (cgraph_edge
*d
= direct
; d
; d
= next
)
820 next
= d
->next_speculative_call_target ();
821 cgraph_edge
*d2
= set_call_stmt (d
, new_stmt
, false);
822 gcc_assert (d2
== d
);
825 gcc_checking_assert (indirect
->num_speculative_call_targets_p () == n
);
826 for (unsigned int i
= 0; e
->caller
->iterate_reference (i
, ref
); i
++)
827 if (ref
->speculative
&& ref
->stmt
== old_stmt
)
829 ref
->stmt
= new_stmt
;
833 indirect
= set_call_stmt (indirect
, new_stmt
, false);
834 return e_indirect
? indirect
: direct
;
837 if (new_direct_callee
)
838 e
= make_direct (e
, new_direct_callee
);
840 /* Only direct speculative edges go to call_site_hash. */
841 if (e
->caller
->call_site_hash
842 && (!e
->speculative
|| !e
->indirect_unknown_callee
)
843 /* It is possible that edge was previously speculative. In this case
844 we have different value in call stmt hash which needs preserving. */
845 && e
->caller
->get_edge (e
->call_stmt
) == e
)
846 e
->caller
->call_site_hash
->remove_elt_with_hash
847 (e
->call_stmt
, cgraph_edge_hasher::hash (e
->call_stmt
));
849 e
->call_stmt
= new_stmt
;
851 function
*fun
= DECL_STRUCT_FUNCTION (e
->caller
->decl
);
852 e
->can_throw_external
= stmt_can_throw_external (fun
, new_stmt
);
853 /* Update call stite hash. For speculative calls we only record the first
855 if (e
->caller
->call_site_hash
858 && (!e
->prev_callee
|| !e
->prev_callee
->speculative
859 || e
->prev_callee
->call_stmt
!= e
->call_stmt
))
860 || (e
->speculative
&& !e
->callee
)))
861 cgraph_add_edge_to_call_site_hash (e
);
865 /* Allocate a cgraph_edge structure and fill it with data according to the
866 parameters of which only CALLEE can be NULL (when creating an indirect call
867 edge). CLONING_P should be set if properties that are copied from an
868 original edge should not be calculated. */
871 symbol_table::create_edge (cgraph_node
*caller
, cgraph_node
*callee
,
872 gcall
*call_stmt
, profile_count count
,
873 bool indir_unknown_callee
, bool cloning_p
)
877 /* LTO does not actually have access to the call_stmt since these
878 have not been loaded yet. */
881 /* This is a rather expensive check possibly triggering
882 construction of call stmt hashtable. */
884 gcc_checking_assert (!(e
= caller
->get_edge (call_stmt
))
887 gcc_assert (is_gimple_call (call_stmt
));
890 edge
= ggc_alloc
<cgraph_edge
> ();
891 edge
->m_summary_id
= -1;
894 gcc_assert (++edges_max_uid
!= 0);
895 edge
->m_uid
= edges_max_uid
;
897 edge
->caller
= caller
;
898 edge
->callee
= callee
;
899 edge
->prev_caller
= NULL
;
900 edge
->next_caller
= NULL
;
901 edge
->prev_callee
= NULL
;
902 edge
->next_callee
= NULL
;
903 edge
->lto_stmt_uid
= 0;
904 edge
->speculative_id
= 0;
907 edge
->call_stmt
= call_stmt
;
908 edge
->indirect_info
= NULL
;
909 edge
->indirect_inlining_edge
= 0;
910 edge
->speculative
= false;
911 edge
->indirect_unknown_callee
= indir_unknown_callee
;
912 if (call_stmt
&& caller
->call_site_hash
)
913 cgraph_add_edge_to_call_site_hash (edge
);
918 edge
->can_throw_external
919 = call_stmt
? stmt_can_throw_external (DECL_STRUCT_FUNCTION (caller
->decl
),
921 edge
->inline_failed
= CIF_FUNCTION_NOT_CONSIDERED
;
922 edge
->call_stmt_cannot_inline_p
= false;
924 if (opt_for_fn (edge
->caller
->decl
, flag_devirtualize
)
925 && call_stmt
&& DECL_STRUCT_FUNCTION (caller
->decl
))
926 edge
->in_polymorphic_cdtor
927 = decl_maybe_in_construction_p (NULL
, NULL
, call_stmt
,
930 edge
->in_polymorphic_cdtor
= caller
->thunk
;
932 caller
->calls_declare_variant_alt
|= callee
->declare_variant_alt
;
934 if (callee
&& symtab
->state
!= LTO_STREAMING
935 && edge
->callee
->comdat_local_p ())
936 edge
->caller
->calls_comdat_local
= true;
941 /* Create edge from a given function to CALLEE in the cgraph. CLONING_P should
942 be set if properties that are copied from an original edge should not be
946 cgraph_node::create_edge (cgraph_node
*callee
,
947 gcall
*call_stmt
, profile_count count
, bool cloning_p
)
949 cgraph_edge
*edge
= symtab
->create_edge (this, callee
, call_stmt
, count
,
953 initialize_inline_failed (edge
);
955 edge
->next_caller
= callee
->callers
;
957 callee
->callers
->prev_caller
= edge
;
958 edge
->next_callee
= callees
;
960 callees
->prev_callee
= edge
;
962 callee
->callers
= edge
;
967 /* Allocate cgraph_indirect_call_info and set its fields to default values. */
969 cgraph_indirect_call_info
*
970 cgraph_allocate_init_indirect_info (void)
972 cgraph_indirect_call_info
*ii
;
974 ii
= ggc_cleared_alloc
<cgraph_indirect_call_info
> ();
975 ii
->param_index
= -1;
979 /* Create an indirect edge with a yet-undetermined callee where the call
980 statement destination is a formal parameter of the caller with index
981 PARAM_INDEX. CLONING_P should be set if properties that are copied from an
982 original edge should not be calculated and indirect_info structure should
983 not be calculated. */
986 cgraph_node::create_indirect_edge (gcall
*call_stmt
, int ecf_flags
,
990 cgraph_edge
*edge
= symtab
->create_edge (this, NULL
, call_stmt
, count
, true,
995 initialize_inline_failed (edge
);
997 edge
->indirect_info
= cgraph_allocate_init_indirect_info ();
998 edge
->indirect_info
->ecf_flags
= ecf_flags
;
999 edge
->indirect_info
->vptr_changed
= true;
1001 /* Record polymorphic call info. */
1004 && (target
= gimple_call_fn (call_stmt
))
1005 && virtual_method_call_p (target
))
1007 ipa_polymorphic_call_context
context (decl
, target
, call_stmt
);
1009 /* Only record types can have virtual calls. */
1010 edge
->indirect_info
->polymorphic
= true;
1011 edge
->indirect_info
->param_index
= -1;
1012 edge
->indirect_info
->otr_token
1013 = tree_to_uhwi (OBJ_TYPE_REF_TOKEN (target
));
1014 edge
->indirect_info
->otr_type
= obj_type_ref_class (target
);
1015 gcc_assert (TREE_CODE (edge
->indirect_info
->otr_type
) == RECORD_TYPE
);
1016 edge
->indirect_info
->context
= context
;
1019 edge
->next_callee
= indirect_calls
;
1021 indirect_calls
->prev_callee
= edge
;
1022 indirect_calls
= edge
;
1027 /* Remove the edge from the list of the callees of the caller. */
1030 cgraph_edge::remove_caller (void)
1033 prev_callee
->next_callee
= next_callee
;
1035 next_callee
->prev_callee
= prev_callee
;
1038 if (indirect_unknown_callee
)
1039 caller
->indirect_calls
= next_callee
;
1041 caller
->callees
= next_callee
;
1043 if (caller
->call_site_hash
1044 && this == caller
->get_edge (call_stmt
))
1045 caller
->call_site_hash
->remove_elt_with_hash
1046 (call_stmt
, cgraph_edge_hasher::hash (call_stmt
));
1049 /* Put the edge onto the free list. */
1052 symbol_table::free_edge (cgraph_edge
*e
)
1055 if (e
->m_summary_id
!= -1)
1056 edge_released_summary_ids
.safe_push (e
->m_summary_id
);
1058 if (e
->indirect_info
)
1059 ggc_free (e
->indirect_info
);
1063 /* Remove the edge in the cgraph. */
1066 cgraph_edge::remove (cgraph_edge
*edge
)
1068 /* Call all edge removal hooks. */
1069 symtab
->call_edge_removal_hooks (edge
);
1071 if (!edge
->indirect_unknown_callee
)
1072 /* Remove from callers list of the callee. */
1073 edge
->remove_callee ();
1075 /* Remove from callees list of the callers. */
1076 edge
->remove_caller ();
1078 /* Put the edge onto the free list. */
1079 symtab
->free_edge (edge
);
1082 /* Turn edge into speculative call calling N2. Update
1083 the profile so the direct call is taken COUNT times
1086 At clone materialization time, the indirect call E will
1089 if (call_dest == N2)
1094 At this time the function just creates the direct call,
1095 the reference representing the if conditional and attaches
1096 them all to the original indirect call statement.
1098 speculative_id is used to link direct calls with their corresponding
1099 IPA_REF_ADDR references when representing speculative calls.
1101 Return direct edge created. */
1104 cgraph_edge::make_speculative (cgraph_node
*n2
, profile_count direct_count
,
1105 unsigned int speculative_id
)
1107 cgraph_node
*n
= caller
;
1108 ipa_ref
*ref
= NULL
;
1112 fprintf (dump_file
, "Indirect call -> speculative call %s => %s\n",
1113 n
->dump_name (), n2
->dump_name ());
1115 e2
= n
->create_edge (n2
, call_stmt
, direct_count
);
1116 initialize_inline_failed (e2
);
1117 e2
->speculative
= true;
1118 if (TREE_NOTHROW (n2
->decl
))
1119 e2
->can_throw_external
= false;
1121 e2
->can_throw_external
= can_throw_external
;
1122 e2
->lto_stmt_uid
= lto_stmt_uid
;
1123 e2
->speculative_id
= speculative_id
;
1124 e2
->in_polymorphic_cdtor
= in_polymorphic_cdtor
;
1125 indirect_info
->num_speculative_call_targets
++;
1127 symtab
->call_edge_duplication_hooks (this, e2
);
1128 ref
= n
->create_reference (n2
, IPA_REF_ADDR
, call_stmt
);
1129 ref
->lto_stmt_uid
= lto_stmt_uid
;
1130 ref
->speculative_id
= speculative_id
;
1131 ref
->speculative
= speculative
;
1132 n2
->mark_address_taken ();
1136 /* Speculative call consists of an indirect edge and one or more
1137 direct edge+ref pairs.
1139 Given an edge which is part of speculative call, return the first
1140 direct call edge in the speculative call sequence. */
1143 cgraph_edge::first_speculative_call_target ()
1145 cgraph_edge
*e
= this;
1147 gcc_checking_assert (e
->speculative
);
1150 while (e
->prev_callee
&& e
->prev_callee
->speculative
1151 && e
->prev_callee
->call_stmt
== e
->call_stmt
1152 && e
->prev_callee
->lto_stmt_uid
== e
->lto_stmt_uid
)
1156 /* Call stmt site hash always points to the first target of the
1157 speculative call sequence. */
1159 return e
->caller
->get_edge (e
->call_stmt
);
1160 for (cgraph_edge
*e2
= e
->caller
->callees
; true; e2
= e2
->next_callee
)
1162 && e
->call_stmt
== e2
->call_stmt
1163 && e
->lto_stmt_uid
== e2
->lto_stmt_uid
)
1167 /* We always maintain first direct edge in the call site hash, if one
1168 exists. E is going to be removed. See if it is first one and update
1169 hash accordingly. INDIRECT is the indirect edge of speculative call.
1170 We assume that INDIRECT->num_speculative_call_targets_p () is already
1171 updated for removal of E. */
1173 update_call_stmt_hash_for_removing_direct_edge (cgraph_edge
*e
,
1174 cgraph_edge
*indirect
)
1176 if (e
->caller
->call_site_hash
)
1178 if (e
->caller
->get_edge (e
->call_stmt
) != e
)
1180 else if (!indirect
->num_speculative_call_targets_p ())
1181 cgraph_update_edge_in_call_site_hash (indirect
);
1184 gcc_checking_assert (e
->next_callee
&& e
->next_callee
->speculative
1185 && e
->next_callee
->call_stmt
== e
->call_stmt
);
1186 cgraph_update_edge_in_call_site_hash (e
->next_callee
);
1191 /* Speculative call EDGE turned out to be direct call to CALLEE_DECL. Remove
1192 the speculative call sequence and return edge representing the call, the
1193 original EDGE can be removed and deallocated. Return the edge that now
1194 represents the call.
1196 For "speculative" indirect call that contains multiple "speculative"
1197 targets (i.e. edge->indirect_info->num_speculative_call_targets > 1),
1198 decrease the count and only remove current direct edge.
1200 If no speculative direct call left to the speculative indirect call, remove
1201 the speculative of both the indirect call and corresponding direct edge.
1203 It is up to caller to iteratively resolve each "speculative" direct call and
1204 redirect the call as appropriate. */
1207 cgraph_edge::resolve_speculation (cgraph_edge
*edge
, tree callee_decl
)
1212 gcc_assert (edge
->speculative
&& (!callee_decl
|| edge
->callee
));
1214 e2
= edge
->first_speculative_call_target ();
1217 ref
= e2
->speculative_call_target_ref ();
1218 edge
= edge
->speculative_call_indirect_edge ();
1220 || !ref
->referred
->semantically_equivalent_p
1221 (symtab_node::get (callee_decl
)))
1227 fprintf (dump_file
, "Speculative indirect call %s => %s has "
1228 "turned out to have contradicting known target ",
1229 edge
->caller
->dump_name (),
1230 e2
->callee
->dump_name ());
1231 print_generic_expr (dump_file
, callee_decl
);
1232 fprintf (dump_file
, "\n");
1236 fprintf (dump_file
, "Removing speculative call %s => %s\n",
1237 edge
->caller
->dump_name (),
1238 e2
->callee
->dump_name ());
1244 cgraph_edge
*tmp
= edge
;
1246 fprintf (dump_file
, "Speculative call turned into direct call.\n");
1249 /* FIXME: If EDGE is inlined, we should scale up the frequencies
1250 and counts in the functions inlined through it. */
1252 edge
->count
+= e2
->count
;
1253 if (edge
->num_speculative_call_targets_p ())
1255 /* The indirect edge has multiple speculative targets, don't remove
1256 speculative until all related direct edges are resolved. */
1257 edge
->indirect_info
->num_speculative_call_targets
--;
1258 if (!edge
->indirect_info
->num_speculative_call_targets
)
1259 edge
->speculative
= false;
1262 edge
->speculative
= false;
1263 e2
->speculative
= false;
1264 update_call_stmt_hash_for_removing_direct_edge (e2
, edge
);
1265 ref
->remove_reference ();
1266 if (e2
->indirect_unknown_callee
|| e2
->inline_failed
)
1269 e2
->callee
->remove_symbol_and_inline_clones ();
1273 /* Return edge corresponding to speculative call to a given target.
1274 NULL if speculative call does not have one. */
1277 cgraph_edge::speculative_call_for_target (cgraph_node
*target
)
1279 for (cgraph_edge
*direct
= first_speculative_call_target ();
1281 direct
= direct
->next_speculative_call_target ())
1282 if (direct
->speculative_call_target_ref ()
1283 ->referred
->semantically_equivalent_p (target
))
1288 /* Make an indirect or speculative EDGE with an unknown callee an ordinary edge
1289 leading to CALLEE. Speculations can be resolved in the process and EDGE can
1290 be removed and deallocated. Return the edge that now represents the
1294 cgraph_edge::make_direct (cgraph_edge
*edge
, cgraph_node
*callee
)
1296 gcc_assert (edge
->indirect_unknown_callee
|| edge
->speculative
);
1298 /* If we are redirecting speculative call, make it non-speculative. */
1299 if (edge
->speculative
)
1301 cgraph_edge
*found
= NULL
;
1302 cgraph_edge
*direct
, *next
;
1304 edge
= edge
->speculative_call_indirect_edge ();
1306 /* Look all speculative targets and remove all but one corresponding
1307 to callee (if it exists). */
1308 for (direct
= edge
->first_speculative_call_target ();
1312 next
= direct
->next_speculative_call_target ();
1314 /* Compare ref not direct->callee. Direct edge is possibly
1315 inlined or redirected. */
1316 if (!direct
->speculative_call_target_ref ()
1317 ->referred
->semantically_equivalent_p (callee
))
1318 edge
= direct
->resolve_speculation (direct
, NULL
);
1321 gcc_checking_assert (!found
);
1326 /* On successful speculation just remove the indirect edge and
1327 return the pre existing direct edge.
1328 It is important to not remove it and redirect because the direct
1329 edge may be inlined or redirected. */
1332 cgraph_edge
*e2
= resolve_speculation (found
, callee
->decl
);
1333 gcc_checking_assert (!found
->speculative
&& e2
== found
);
1336 gcc_checking_assert (!edge
->speculative
);
1339 edge
->indirect_unknown_callee
= 0;
1340 ggc_free (edge
->indirect_info
);
1341 edge
->indirect_info
= NULL
;
1343 /* Get the edge out of the indirect edge list. */
1344 if (edge
->prev_callee
)
1345 edge
->prev_callee
->next_callee
= edge
->next_callee
;
1346 if (edge
->next_callee
)
1347 edge
->next_callee
->prev_callee
= edge
->prev_callee
;
1348 if (!edge
->prev_callee
)
1349 edge
->caller
->indirect_calls
= edge
->next_callee
;
1351 /* Put it into the normal callee list */
1352 edge
->prev_callee
= NULL
;
1353 edge
->next_callee
= edge
->caller
->callees
;
1354 if (edge
->caller
->callees
)
1355 edge
->caller
->callees
->prev_callee
= edge
;
1356 edge
->caller
->callees
= edge
;
1358 /* Insert to callers list of the new callee. */
1359 edge
->set_callee (callee
);
1361 /* We need to re-determine the inlining status of the edge. */
1362 initialize_inline_failed (edge
);
1366 /* Redirect callee of the edge to N. The function does not update underlying
1370 cgraph_edge::redirect_callee (cgraph_node
*n
)
1372 bool loc
= callee
->comdat_local_p ();
1373 /* Remove from callers list of the current callee. */
1376 /* Insert to callers list of the new callee. */
1381 if (!loc
&& n
->comdat_local_p ())
1383 cgraph_node
*to
= caller
->inlined_to
? caller
->inlined_to
: caller
;
1384 to
->calls_comdat_local
= true;
1386 else if (loc
&& !n
->comdat_local_p ())
1388 cgraph_node
*to
= caller
->inlined_to
? caller
->inlined_to
: caller
;
1389 gcc_checking_assert (to
->calls_comdat_local
);
1390 to
->calls_comdat_local
= to
->check_calls_comdat_local_p ();
1394 /* If necessary, change the function declaration in the call statement
1395 associated with E so that it corresponds to the edge callee. Speculations
1396 can be resolved in the process and EDGE can be removed and deallocated.
1398 The edge could be one of speculative direct call generated from speculative
1399 indirect call. In this circumstance, decrease the speculative targets
1400 count (i.e. num_speculative_call_targets) and redirect call stmt to the
1401 corresponding i-th target. If no speculative direct call left to the
1402 speculative indirect call, remove "speculative" of the indirect call and
1403 also redirect stmt to it's final direct target.
1405 It is up to caller to iteratively transform each "speculative"
1406 direct call as appropriate. */
1409 cgraph_edge::redirect_call_stmt_to_callee (cgraph_edge
*e
)
1411 tree decl
= gimple_call_fndecl (e
->call_stmt
);
1413 gimple_stmt_iterator gsi
;
1417 /* If there already is an direct call (i.e. as a result of inliner's
1418 substitution), forget about speculating. */
1420 e
= make_direct (e
->speculative_call_indirect_edge (),
1421 cgraph_node::get (decl
));
1424 /* Be sure we redirect all speculative targets before poking
1425 abou tindirect edge. */
1426 gcc_checking_assert (e
->callee
);
1427 cgraph_edge
*indirect
= e
->speculative_call_indirect_edge ();
1431 /* Expand speculation into GIMPLE code. */
1435 "Expanding speculative call of %s -> %s count: ",
1436 e
->caller
->dump_name (),
1437 e
->callee
->dump_name ());
1438 e
->count
.dump (dump_file
);
1439 fprintf (dump_file
, "\n");
1441 push_cfun (DECL_STRUCT_FUNCTION (e
->caller
->decl
));
1443 profile_count all
= indirect
->count
;
1444 for (cgraph_edge
*e2
= e
->first_speculative_call_target ();
1446 e2
= e2
->next_speculative_call_target ())
1447 all
= all
+ e2
->count
;
1448 profile_probability prob
= e
->count
.probability_in (all
);
1449 if (!prob
.initialized_p ())
1450 prob
= profile_probability::even ();
1451 ref
= e
->speculative_call_target_ref ();
1452 new_stmt
= gimple_ic (e
->call_stmt
,
1453 dyn_cast
<cgraph_node
*> (ref
->referred
),
1455 e
->speculative
= false;
1456 if (indirect
->num_speculative_call_targets_p ())
1458 /* The indirect edge has multiple speculative targets, don't
1459 remove speculative until all related direct edges are
1461 indirect
->indirect_info
->num_speculative_call_targets
--;
1462 if (!indirect
->indirect_info
->num_speculative_call_targets
)
1463 indirect
->speculative
= false;
1466 indirect
->speculative
= false;
1467 /* Indirect edges are not both in the call site hash.
1469 update_call_stmt_hash_for_removing_direct_edge (e
, indirect
);
1470 cgraph_edge::set_call_stmt (e
, new_stmt
, false);
1471 e
->count
= gimple_bb (e
->call_stmt
)->count
;
1473 /* Once we are done with expanding the sequence, update also indirect
1474 call probability. Until then the basic block accounts for the
1475 sum of indirect edge and all non-expanded speculations. */
1476 if (!indirect
->speculative
)
1477 indirect
->count
= gimple_bb (indirect
->call_stmt
)->count
;
1478 ref
->speculative
= false;
1481 /* Continue redirecting E to proper target. */
1486 if (e
->indirect_unknown_callee
1487 || decl
== e
->callee
->decl
)
1488 return e
->call_stmt
;
1490 if (decl
&& ipa_saved_clone_sources
)
1492 tree
*p
= ipa_saved_clone_sources
->get (e
->callee
);
1493 if (p
&& decl
== *p
)
1495 gimple_call_set_fndecl (e
->call_stmt
, e
->callee
->decl
);
1496 return e
->call_stmt
;
1499 if (flag_checking
&& decl
)
1501 if (cgraph_node
*node
= cgraph_node::get (decl
))
1503 clone_info
*info
= clone_info::get (node
);
1504 gcc_assert (!info
|| !info
->param_adjustments
);
1508 clone_info
*callee_info
= clone_info::get (e
->callee
);
1509 if (symtab
->dump_file
)
1511 fprintf (symtab
->dump_file
, "updating call of %s -> %s: ",
1512 e
->caller
->dump_name (), e
->callee
->dump_name ());
1513 print_gimple_stmt (symtab
->dump_file
, e
->call_stmt
, 0, dump_flags
);
1514 if (callee_info
&& callee_info
->param_adjustments
)
1515 callee_info
->param_adjustments
->dump (symtab
->dump_file
);
1518 if (ipa_param_adjustments
*padjs
1519 = callee_info
? callee_info
->param_adjustments
: NULL
)
1521 /* We need to defer cleaning EH info on the new statement to
1522 fixup-cfg. We may not have dominator information at this point
1523 and thus would end up with unreachable blocks and have no way
1524 to communicate that we need to run CFG cleanup then. */
1525 int lp_nr
= lookup_stmt_eh_lp (e
->call_stmt
);
1527 remove_stmt_from_eh_lp (e
->call_stmt
);
1529 tree old_fntype
= gimple_call_fntype (e
->call_stmt
);
1530 new_stmt
= padjs
->modify_call (e
, false);
1531 cgraph_node
*origin
= e
->callee
;
1532 while (origin
->clone_of
)
1533 origin
= origin
->clone_of
;
1535 if ((origin
->former_clone_of
1536 && old_fntype
== TREE_TYPE (origin
->former_clone_of
))
1537 || old_fntype
== TREE_TYPE (origin
->decl
))
1538 gimple_call_set_fntype (new_stmt
, TREE_TYPE (e
->callee
->decl
));
1541 tree new_fntype
= padjs
->build_new_function_type (old_fntype
, true);
1542 gimple_call_set_fntype (new_stmt
, new_fntype
);
1546 add_stmt_to_eh_lp (new_stmt
, lp_nr
);
1551 && !fndecl_built_in_p (e
->callee
->decl
, BUILT_IN_UNREACHABLE
))
1552 ipa_verify_edge_has_no_modifications (e
);
1553 new_stmt
= e
->call_stmt
;
1554 gimple_call_set_fndecl (new_stmt
, e
->callee
->decl
);
1555 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), new_stmt
);
1558 /* If changing the call to __cxa_pure_virtual or similar noreturn function,
1559 adjust gimple_call_fntype too. */
1560 if (gimple_call_noreturn_p (new_stmt
)
1561 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (e
->callee
->decl
)))
1562 && TYPE_ARG_TYPES (TREE_TYPE (e
->callee
->decl
))
1563 && (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (e
->callee
->decl
)))
1565 gimple_call_set_fntype (new_stmt
, TREE_TYPE (e
->callee
->decl
));
1567 /* If the call becomes noreturn, remove the LHS if possible. */
1568 tree lhs
= gimple_call_lhs (new_stmt
);
1570 && gimple_call_noreturn_p (new_stmt
)
1571 && (VOID_TYPE_P (TREE_TYPE (gimple_call_fntype (new_stmt
)))
1572 || should_remove_lhs_p (lhs
)))
1574 if (TREE_CODE (lhs
) == SSA_NAME
)
1576 tree var
= create_tmp_reg_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
),
1577 TREE_TYPE (lhs
), NULL
);
1578 var
= get_or_create_ssa_default_def
1579 (DECL_STRUCT_FUNCTION (e
->caller
->decl
), var
);
1580 gimple
*set_stmt
= gimple_build_assign (lhs
, var
);
1581 gsi
= gsi_for_stmt (new_stmt
);
1582 gsi_insert_before_without_update (&gsi
, set_stmt
, GSI_SAME_STMT
);
1583 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), set_stmt
);
1585 gimple_call_set_lhs (new_stmt
, NULL_TREE
);
1586 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), new_stmt
);
1589 /* If new callee has no static chain, remove it. */
1590 if (gimple_call_chain (new_stmt
) && !DECL_STATIC_CHAIN (e
->callee
->decl
))
1592 gimple_call_set_chain (new_stmt
, NULL
);
1593 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), new_stmt
);
1596 maybe_remove_unused_call_args (DECL_STRUCT_FUNCTION (e
->caller
->decl
),
1599 e
->caller
->set_call_stmt_including_clones (e
->call_stmt
, new_stmt
, false);
1601 if (symtab
->dump_file
)
1603 fprintf (symtab
->dump_file
, " updated to:");
1604 print_gimple_stmt (symtab
->dump_file
, e
->call_stmt
, 0, dump_flags
);
1609 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1610 OLD_STMT changed into NEW_STMT. OLD_CALL is gimple_call_fndecl
1611 of OLD_STMT if it was previously call statement.
1612 If NEW_STMT is NULL, the call has been dropped without any
1616 cgraph_update_edges_for_call_stmt_node (cgraph_node
*node
,
1617 gimple
*old_stmt
, tree old_call
,
1620 tree new_call
= (new_stmt
&& is_gimple_call (new_stmt
))
1621 ? gimple_call_fndecl (new_stmt
) : 0;
1623 /* We are seeing indirect calls, then there is nothing to update. */
1624 if (!new_call
&& !old_call
)
1626 /* See if we turned indirect call into direct call or folded call to one builtin
1627 into different builtin. */
1628 if (old_call
!= new_call
)
1630 cgraph_edge
*e
= node
->get_edge (old_stmt
);
1631 cgraph_edge
*ne
= NULL
;
1632 profile_count count
;
1636 /* Keep calls marked as dead dead. */
1637 if (new_stmt
&& is_gimple_call (new_stmt
) && e
->callee
1638 && fndecl_built_in_p (e
->callee
->decl
, BUILT_IN_UNREACHABLE
))
1640 cgraph_edge::set_call_stmt (node
->get_edge (old_stmt
),
1641 as_a
<gcall
*> (new_stmt
));
1644 /* See if the edge is already there and has the correct callee. It
1645 might be so because of indirect inlining has already updated
1646 it. We also might've cloned and redirected the edge. */
1647 if (new_call
&& e
->callee
)
1649 cgraph_node
*callee
= e
->callee
;
1652 if (callee
->decl
== new_call
1653 || callee
->former_clone_of
== new_call
)
1655 cgraph_edge::set_call_stmt (e
, as_a
<gcall
*> (new_stmt
));
1658 callee
= callee
->clone_of
;
1662 /* Otherwise remove edge and create new one; we can't simply redirect
1663 since function has changed, so inline plan and other information
1664 attached to edge is invalid. */
1666 if (e
->indirect_unknown_callee
|| e
->inline_failed
)
1667 cgraph_edge::remove (e
);
1669 e
->callee
->remove_symbol_and_inline_clones ();
1673 /* We are seeing new direct call; compute profile info based on BB. */
1674 basic_block bb
= gimple_bb (new_stmt
);
1680 ne
= node
->create_edge (cgraph_node::get_create (new_call
),
1681 as_a
<gcall
*> (new_stmt
), count
);
1682 gcc_assert (ne
->inline_failed
);
1685 /* We only updated the call stmt; update pointer in cgraph edge.. */
1686 else if (old_stmt
!= new_stmt
)
1687 cgraph_edge::set_call_stmt (node
->get_edge (old_stmt
),
1688 as_a
<gcall
*> (new_stmt
));
1691 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1692 OLD_STMT changed into NEW_STMT. OLD_DECL is gimple_call_fndecl
1693 of OLD_STMT before it was updated (updating can happen inplace). */
1696 cgraph_update_edges_for_call_stmt (gimple
*old_stmt
, tree old_decl
,
1699 cgraph_node
*orig
= cgraph_node::get (cfun
->decl
);
1702 gcc_checking_assert (orig
);
1703 cgraph_update_edges_for_call_stmt_node (orig
, old_stmt
, old_decl
, new_stmt
);
1705 for (node
= orig
->clones
; node
!= orig
;)
1707 cgraph_update_edges_for_call_stmt_node (node
, old_stmt
, old_decl
,
1710 node
= node
->clones
;
1711 else if (node
->next_sibling_clone
)
1712 node
= node
->next_sibling_clone
;
1715 while (node
!= orig
&& !node
->next_sibling_clone
)
1716 node
= node
->clone_of
;
1718 node
= node
->next_sibling_clone
;
1724 /* Remove all callees from the node. */
1727 cgraph_node::remove_callees (void)
1731 calls_comdat_local
= false;
1733 /* It is sufficient to remove the edges from the lists of callers of
1734 the callees. The callee list of the node can be zapped with one
1736 for (e
= callees
; e
; e
= f
)
1739 symtab
->call_edge_removal_hooks (e
);
1740 if (!e
->indirect_unknown_callee
)
1741 e
->remove_callee ();
1742 symtab
->free_edge (e
);
1744 for (e
= indirect_calls
; e
; e
= f
)
1747 symtab
->call_edge_removal_hooks (e
);
1748 if (!e
->indirect_unknown_callee
)
1749 e
->remove_callee ();
1750 symtab
->free_edge (e
);
1752 indirect_calls
= NULL
;
1756 call_site_hash
->empty ();
1757 call_site_hash
= NULL
;
1761 /* Remove all callers from the node. */
1764 cgraph_node::remove_callers (void)
1768 /* It is sufficient to remove the edges from the lists of callees of
1769 the callers. The caller list of the node can be zapped with one
1771 for (e
= callers
; e
; e
= f
)
1774 symtab
->call_edge_removal_hooks (e
);
1775 e
->remove_caller ();
1776 symtab
->free_edge (e
);
1781 /* Helper function for cgraph_release_function_body and free_lang_data.
1782 It releases body from function DECL without having to inspect its
1783 possibly non-existent symtab node. */
1786 release_function_body (tree decl
)
1788 function
*fn
= DECL_STRUCT_FUNCTION (decl
);
1792 && loops_for_fn (fn
))
1794 fn
->curr_properties
&= ~PROP_loops
;
1795 loop_optimizer_finalize (fn
);
1799 delete_tree_ssa (fn
);
1804 gcc_assert (!dom_info_available_p (fn
, CDI_DOMINATORS
));
1805 gcc_assert (!dom_info_available_p (fn
, CDI_POST_DOMINATORS
));
1806 delete_tree_cfg_annotations (fn
);
1810 if (fn
->value_histograms
)
1811 free_histograms (fn
);
1812 gimple_set_body (decl
, NULL
);
1813 /* Struct function hangs a lot of data that would leak if we didn't
1814 removed all pointers to it. */
1816 DECL_STRUCT_FUNCTION (decl
) = NULL
;
1818 DECL_SAVED_TREE (decl
) = NULL
;
1821 /* Release memory used to represent body of function.
1822 Use this only for functions that are released before being translated to
1823 target code (i.e. RTL). Functions that are compiled to RTL and beyond
1824 are free'd in final.c via free_after_compilation().
1825 KEEP_ARGUMENTS are useful only if you want to rebuild body as thunk. */
1828 cgraph_node::release_body (bool keep_arguments
)
1830 ipa_transforms_to_apply
.release ();
1831 if (!used_as_abstract_origin
&& symtab
->state
!= PARSING
)
1833 DECL_RESULT (decl
) = NULL
;
1835 if (!keep_arguments
)
1836 DECL_ARGUMENTS (decl
) = NULL
;
1838 /* If the node is abstract and needed, then do not clear
1839 DECL_INITIAL of its associated function declaration because it's
1840 needed to emit debug info later. */
1841 if (!used_as_abstract_origin
&& DECL_INITIAL (decl
))
1842 DECL_INITIAL (decl
) = error_mark_node
;
1843 release_function_body (decl
);
1846 lto_free_function_in_decl_state_for_node (this);
1847 lto_file_data
= NULL
;
1849 if (flag_checking
&& clones
)
1851 /* It is invalid to release body before materializing clones except
1852 for thunks that don't really need a body. Verify also that we do
1853 not leak pointers to the call statements. */
1854 for (cgraph_node
*node
= clones
; node
;
1855 node
= node
->next_sibling_clone
)
1856 gcc_assert (node
->thunk
&& !node
->callees
->call_stmt
);
1859 remove_all_references ();
1862 /* Remove function from symbol table. */
1865 cgraph_node::remove (void)
1867 bool clone_info_set
= false;
1868 clone_info
*info
, saved_info
;
1869 if (symtab
->ipa_clones_dump_file
&& symtab
->cloned_nodes
.contains (this))
1870 fprintf (symtab
->ipa_clones_dump_file
,
1871 "Callgraph removal;%s;%d;%s;%d;%d\n", asm_name (), order
,
1872 DECL_SOURCE_FILE (decl
), DECL_SOURCE_LINE (decl
),
1873 DECL_SOURCE_COLUMN (decl
));
1875 if ((info
= clone_info::get (this)) != NULL
)
1878 clone_info_set
= true;
1880 symtab
->call_cgraph_removal_hooks (this);
1883 ipa_transforms_to_apply
.release ();
1884 delete_function_version (function_version ());
1886 /* Incremental inlining access removed nodes stored in the postorder list.
1888 force_output
= false;
1889 forced_by_abi
= false;
1891 unregister (clone_info_set
? &saved_info
: NULL
);
1892 if (prev_sibling_clone
)
1893 prev_sibling_clone
->next_sibling_clone
= next_sibling_clone
;
1895 clone_of
->clones
= next_sibling_clone
;
1896 if (next_sibling_clone
)
1897 next_sibling_clone
->prev_sibling_clone
= prev_sibling_clone
;
1900 cgraph_node
*n
, *next
;
1904 for (n
= clones
; n
->next_sibling_clone
; n
= n
->next_sibling_clone
)
1905 n
->clone_of
= clone_of
;
1906 n
->clone_of
= clone_of
;
1907 n
->next_sibling_clone
= clone_of
->clones
;
1908 if (clone_of
->clones
)
1909 clone_of
->clones
->prev_sibling_clone
= n
;
1910 clone_of
->clones
= clones
;
1914 /* We are removing node with clones. This makes clones inconsistent,
1915 but assume they will be removed subsequently and just keep clone
1916 tree intact. This can happen in unreachable function removal since
1917 we remove unreachable functions in random order, not by bottom-up
1918 walk of clone trees. */
1919 for (n
= clones
; n
; n
= next
)
1921 next
= n
->next_sibling_clone
;
1922 n
->next_sibling_clone
= NULL
;
1923 n
->prev_sibling_clone
= NULL
;
1929 /* While all the clones are removed after being proceeded, the function
1930 itself is kept in the cgraph even after it is compiled. Check whether
1931 we are done with this body and reclaim it proactively if this is the case.
1933 if (symtab
->state
!= LTO_STREAMING
)
1935 cgraph_node
*n
= cgraph_node::get (decl
);
1937 || (!n
->clones
&& !n
->clone_of
&& !n
->inlined_to
1938 && ((symtab
->global_info_ready
|| in_lto_p
)
1939 && (TREE_ASM_WRITTEN (n
->decl
)
1940 || DECL_EXTERNAL (n
->decl
)
1942 || (!flag_wpa
&& n
->in_other_partition
)))))
1947 lto_free_function_in_decl_state_for_node (this);
1948 lto_file_data
= NULL
;
1954 call_site_hash
->empty ();
1955 call_site_hash
= NULL
;
1958 symtab
->release_symbol (this);
1961 /* Likewise indicate that a node is having address taken. */
1964 cgraph_node::mark_address_taken (void)
1966 /* Indirect inlining can figure out that all uses of the address are
1970 gcc_assert (cfun
->after_inlining
);
1971 gcc_assert (callers
->indirect_inlining_edge
);
1974 /* FIXME: address_taken flag is used both as a shortcut for testing whether
1975 IPA_REF_ADDR reference exists (and thus it should be set on node
1976 representing alias we take address of) and as a test whether address
1977 of the object was taken (and thus it should be set on node alias is
1978 referring to). We should remove the first use and the remove the
1981 cgraph_node
*node
= ultimate_alias_target ();
1982 node
->address_taken
= 1;
1985 /* Return local info node for the compiled function. */
1988 cgraph_node::local_info_node (tree decl
)
1990 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1991 cgraph_node
*node
= get (decl
);
1994 return node
->ultimate_alias_target ();
1997 /* Return RTL info for the compiled function. */
2000 cgraph_node::rtl_info (const_tree decl
)
2002 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
2003 cgraph_node
*node
= get (decl
);
2006 enum availability avail
;
2007 node
= node
->ultimate_alias_target (&avail
);
2008 if (decl
!= current_function_decl
2009 && (avail
< AVAIL_AVAILABLE
2010 || (node
->decl
!= current_function_decl
2011 && !TREE_ASM_WRITTEN (node
->decl
))))
2013 /* Allocate if it doesn't exist. */
2014 if (node
->rtl
== NULL
)
2016 node
->rtl
= ggc_cleared_alloc
<cgraph_rtl_info
> ();
2017 SET_HARD_REG_SET (node
->rtl
->function_used_regs
);
2022 /* Return a string describing the failure REASON. */
2025 cgraph_inline_failed_string (cgraph_inline_failed_t reason
)
2028 #define DEFCIFCODE(code, type, string) string,
2030 static const char *cif_string_table
[CIF_N_REASONS
] = {
2031 #include "cif-code.def"
2034 /* Signedness of an enum type is implementation defined, so cast it
2035 to unsigned before testing. */
2036 gcc_assert ((unsigned) reason
< CIF_N_REASONS
);
2037 return cif_string_table
[reason
];
2040 /* Return a type describing the failure REASON. */
2042 cgraph_inline_failed_type_t
2043 cgraph_inline_failed_type (cgraph_inline_failed_t reason
)
2046 #define DEFCIFCODE(code, type, string) type,
2048 static cgraph_inline_failed_type_t cif_type_table
[CIF_N_REASONS
] = {
2049 #include "cif-code.def"
2052 /* Signedness of an enum type is implementation defined, so cast it
2053 to unsigned before testing. */
2054 gcc_assert ((unsigned) reason
< CIF_N_REASONS
);
2055 return cif_type_table
[reason
];
2058 /* Names used to print out the availability enum. */
2059 const char * const cgraph_availability_names
[] =
2060 {"unset", "not_available", "overwritable", "available", "local"};
2062 /* Output flags of edge to a file F. */
2065 cgraph_edge::dump_edge_flags (FILE *f
)
2068 fprintf (f
, "(speculative) ");
2070 fprintf (f
, "(inlined) ");
2071 if (call_stmt_cannot_inline_p
)
2072 fprintf (f
, "(call_stmt_cannot_inline_p) ");
2073 if (indirect_inlining_edge
)
2074 fprintf (f
, "(indirect_inlining) ");
2075 if (count
.initialized_p ())
2080 fprintf (f
, "%.2f per call) ", sreal_frequency ().to_double ());
2082 if (can_throw_external
)
2083 fprintf (f
, "(can throw external) ");
2086 /* Dump edge to stderr. */
2089 cgraph_edge::debug (void)
2091 fprintf (stderr
, "%s -> %s ", caller
->dump_asm_name (),
2092 callee
== NULL
? "(null)" : callee
->dump_asm_name ());
2093 dump_edge_flags (stderr
);
2094 fprintf (stderr
, "\n\n");
2100 /* Dump call graph node to file F. */
2103 cgraph_node::dump (FILE *f
)
2110 fprintf (f
, " Function %s is inline copy in %s\n",
2112 inlined_to
->dump_name ());
2114 fprintf (f
, " Clone of %s\n", clone_of
->dump_asm_name ());
2115 if (symtab
->function_flags_ready
)
2116 fprintf (f
, " Availability: %s\n",
2117 cgraph_availability_names
[get_availability ()]);
2120 fprintf (f
, " Profile id: %i\n",
2123 fprintf (f
, " Unit id: %i\n",
2125 cgraph_function_version_info
*vi
= function_version ();
2128 fprintf (f
, " Version info: ");
2129 if (vi
->prev
!= NULL
)
2131 fprintf (f
, "prev: ");
2132 fprintf (f
, "%s ", vi
->prev
->this_node
->dump_asm_name ());
2134 if (vi
->next
!= NULL
)
2136 fprintf (f
, "next: ");
2137 fprintf (f
, "%s ", vi
->next
->this_node
->dump_asm_name ());
2139 if (vi
->dispatcher_resolver
!= NULL_TREE
)
2140 fprintf (f
, "dispatcher: %s",
2141 lang_hooks
.decl_printable_name (vi
->dispatcher_resolver
, 2));
2145 fprintf (f
, " Function flags:");
2146 if (count
.initialized_p ())
2148 fprintf (f
, " count:");
2151 if (tp_first_run
> 0)
2152 fprintf (f
, " first_run:%" PRId64
, (int64_t) tp_first_run
);
2153 if (cgraph_node
*origin
= nested_function_origin (this))
2154 fprintf (f
, " nested in:%s", origin
->dump_asm_name ());
2155 if (gimple_has_body_p (decl
))
2156 fprintf (f
, " body");
2158 fprintf (f
, " process");
2160 fprintf (f
, " local");
2161 if (redefined_extern_inline
)
2162 fprintf (f
, " redefined_extern_inline");
2163 if (only_called_at_startup
)
2164 fprintf (f
, " only_called_at_startup");
2165 if (only_called_at_exit
)
2166 fprintf (f
, " only_called_at_exit");
2168 fprintf (f
, " tm_clone");
2169 if (calls_comdat_local
)
2170 fprintf (f
, " calls_comdat_local");
2172 fprintf (f
, " icf_merged");
2174 fprintf (f
, " merged_comdat");
2175 if (merged_extern_inline
)
2176 fprintf (f
, " merged_extern_inline");
2178 fprintf (f
, " split_part");
2179 if (indirect_call_target
)
2180 fprintf (f
, " indirect_call_target");
2182 fprintf (f
, " nonfreeing_fn");
2183 if (DECL_STATIC_CONSTRUCTOR (decl
))
2184 fprintf (f
," static_constructor (priority:%i)", get_init_priority ());
2185 if (DECL_STATIC_DESTRUCTOR (decl
))
2186 fprintf (f
," static_destructor (priority:%i)", get_fini_priority ());
2187 if (frequency
== NODE_FREQUENCY_HOT
)
2188 fprintf (f
, " hot");
2189 if (frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
)
2190 fprintf (f
, " unlikely_executed");
2191 if (frequency
== NODE_FREQUENCY_EXECUTED_ONCE
)
2192 fprintf (f
, " executed_once");
2193 if (opt_for_fn (decl
, optimize_size
))
2194 fprintf (f
, " optimize_size");
2195 if (parallelized_function
)
2196 fprintf (f
, " parallelized_function");
2197 if (DECL_IS_MALLOC (decl
))
2198 fprintf (f
, " decl_is_malloc");
2199 if (DECL_IS_OPERATOR_NEW_P (decl
))
2200 fprintf (f
, " %soperator_new",
2201 DECL_IS_REPLACEABLE_OPERATOR (decl
) ? "replaceable_" : "");
2202 if (DECL_IS_OPERATOR_DELETE_P (decl
))
2203 fprintf (f
, " %soperator_delete",
2204 DECL_IS_REPLACEABLE_OPERATOR (decl
) ? "replaceable_" : "");
2206 if (DECL_STATIC_CHAIN (decl
))
2207 fprintf (f
, " static_chain");
2213 fprintf (f
, " Thunk");
2214 thunk_info::get (this)->dump (f
);
2216 else if (former_thunk_p ())
2218 fprintf (f
, " Former thunk ");
2219 thunk_info::get (this)->dump (f
);
2221 else gcc_checking_assert (!thunk_info::get (this));
2223 fprintf (f
, " Called by: ");
2225 profile_count sum
= profile_count::zero ();
2226 for (edge
= callers
; edge
; edge
= edge
->next_caller
)
2228 fprintf (f
, "%s ", edge
->caller
->dump_asm_name ());
2229 edge
->dump_edge_flags (f
);
2230 if (edge
->count
.initialized_p ())
2231 sum
+= edge
->count
.ipa ();
2234 fprintf (f
, "\n Calls: ");
2235 for (edge
= callees
; edge
; edge
= edge
->next_callee
)
2237 fprintf (f
, "%s ", edge
->callee
->dump_asm_name ());
2238 edge
->dump_edge_flags (f
);
2242 if (!body_removed
&& count
.ipa ().initialized_p ())
2248 FOR_EACH_ALIAS (this, ref
)
2249 if (dyn_cast
<cgraph_node
*> (ref
->referring
)->count
.initialized_p ())
2250 sum
+= dyn_cast
<cgraph_node
*> (ref
->referring
)->count
.ipa ();
2253 || (symtab
->state
< EXPANSION
2254 && ultimate_alias_target () == this && only_called_directly_p ()))
2255 ok
= !count
.ipa ().differs_from_p (sum
);
2256 else if (count
.ipa () > profile_count::from_gcov_type (100)
2257 && count
.ipa () < sum
.apply_scale (99, 100))
2258 ok
= false, min
= true;
2261 fprintf (f
, " Invalid sum of caller counts ");
2264 fprintf (f
, ", should be at most ");
2266 fprintf (f
, ", should be ");
2267 count
.ipa ().dump (f
);
2272 for (edge
= indirect_calls
; edge
; edge
= edge
->next_callee
)
2274 if (edge
->indirect_info
->polymorphic
)
2276 fprintf (f
, " Polymorphic indirect call of type ");
2277 print_generic_expr (f
, edge
->indirect_info
->otr_type
, TDF_SLIM
);
2278 fprintf (f
, " token:%i", (int) edge
->indirect_info
->otr_token
);
2281 fprintf (f
, " Indirect call");
2282 edge
->dump_edge_flags (f
);
2283 if (edge
->indirect_info
->param_index
!= -1)
2285 fprintf (f
, "of param:%i ", edge
->indirect_info
->param_index
);
2286 if (edge
->indirect_info
->agg_contents
)
2287 fprintf (f
, "loaded from %s %s at offset %i ",
2288 edge
->indirect_info
->member_ptr
? "member ptr" : "aggregate",
2289 edge
->indirect_info
->by_ref
? "passed by reference":"",
2290 (int)edge
->indirect_info
->offset
);
2291 if (edge
->indirect_info
->vptr_changed
)
2292 fprintf (f
, "(vptr maybe changed) ");
2294 fprintf (f
, "num speculative call targets: %i\n",
2295 edge
->indirect_info
->num_speculative_call_targets
);
2296 if (edge
->indirect_info
->polymorphic
)
2297 edge
->indirect_info
->context
.dump (f
);
2301 /* Dump call graph node to file F in graphviz format. */
2304 cgraph_node::dump_graphviz (FILE *f
)
2308 for (edge
= callees
; edge
; edge
= edge
->next_callee
)
2310 cgraph_node
*callee
= edge
->callee
;
2312 fprintf (f
, "\t\"%s\" -> \"%s\"\n", dump_name (), callee
->dump_name ());
2317 /* Dump call graph node NODE to stderr. */
2320 cgraph_node::debug (void)
2325 /* Dump the callgraph to file F. */
2328 cgraph_node::dump_cgraph (FILE *f
)
2332 fprintf (f
, "callgraph:\n\n");
2333 FOR_EACH_FUNCTION (node
)
2337 /* Return true when the DECL can possibly be inlined. */
2340 cgraph_function_possibly_inlined_p (tree decl
)
2342 if (!symtab
->global_info_ready
)
2343 return !DECL_UNINLINABLE (decl
);
2344 return DECL_POSSIBLY_INLINED (decl
);
2347 /* Return function availability. See cgraph.h for description of individual
2350 cgraph_node::get_availability (symtab_node
*ref
)
2354 cgraph_node
*cref
= dyn_cast
<cgraph_node
*> (ref
);
2356 ref
= cref
->inlined_to
;
2358 enum availability avail
;
2359 if (!analyzed
&& !in_other_partition
)
2360 avail
= AVAIL_NOT_AVAILABLE
;
2362 avail
= AVAIL_LOCAL
;
2363 else if (inlined_to
)
2364 avail
= AVAIL_AVAILABLE
;
2365 else if (transparent_alias
)
2366 ultimate_alias_target (&avail
, ref
);
2367 else if (ifunc_resolver
2368 || lookup_attribute ("noipa", DECL_ATTRIBUTES (decl
)))
2369 avail
= AVAIL_INTERPOSABLE
;
2370 else if (!externally_visible
)
2371 avail
= AVAIL_AVAILABLE
;
2372 /* If this is a reference from symbol itself and there are no aliases, we
2373 may be sure that the symbol was not interposed by something else because
2374 the symbol itself would be unreachable otherwise.
2376 Also comdat groups are always resolved in groups. */
2377 else if ((this == ref
&& !has_aliases_p ())
2378 || (ref
&& get_comdat_group ()
2379 && get_comdat_group () == ref
->get_comdat_group ()))
2380 avail
= AVAIL_AVAILABLE
;
2381 /* Inline functions are safe to be analyzed even if their symbol can
2382 be overwritten at runtime. It is not meaningful to enforce any sane
2383 behavior on replacing inline function by different body. */
2384 else if (DECL_DECLARED_INLINE_P (decl
))
2385 avail
= AVAIL_AVAILABLE
;
2387 /* If the function can be overwritten, return OVERWRITABLE. Take
2388 care at least of two notable extensions - the COMDAT functions
2389 used to share template instantiations in C++ (this is symmetric
2390 to code cp_cannot_inline_tree_fn and probably shall be shared and
2391 the inlinability hooks completely eliminated). */
2393 else if (decl_replaceable_p (decl
) && !DECL_EXTERNAL (decl
))
2394 avail
= AVAIL_INTERPOSABLE
;
2395 else avail
= AVAIL_AVAILABLE
;
2400 /* Worker for cgraph_node_can_be_local_p. */
2402 cgraph_node_cannot_be_local_p_1 (cgraph_node
*node
, void *)
2404 return !(!node
->force_output
2405 && !node
->ifunc_resolver
2406 /* Limitation of gas requires us to output targets of symver aliases
2407 as global symbols. This is binutils PR 25295. */
2409 && ((DECL_COMDAT (node
->decl
)
2410 && !node
->forced_by_abi
2411 && !node
->used_from_object_file_p ()
2412 && !node
->same_comdat_group
)
2413 || !node
->externally_visible
));
2416 /* Return true if cgraph_node can be made local for API change.
2417 Extern inline functions and C++ COMDAT functions can be made local
2418 at the expense of possible code size growth if function is used in multiple
2419 compilation units. */
2421 cgraph_node::can_be_local_p (void)
2423 return (!address_taken
2424 && !call_for_symbol_thunks_and_aliases (cgraph_node_cannot_be_local_p_1
,
2428 /* Call callback on cgraph_node, thunks and aliases associated to cgraph_node.
2429 When INCLUDE_OVERWRITABLE is false, overwritable symbols are
2430 skipped. When EXCLUDE_VIRTUAL_THUNKS is true, virtual thunks are
2433 cgraph_node::call_for_symbol_thunks_and_aliases (bool (*callback
)
2434 (cgraph_node
*, void *),
2436 bool include_overwritable
,
2437 bool exclude_virtual_thunks
)
2441 enum availability avail
= AVAIL_AVAILABLE
;
2443 if (include_overwritable
2444 || (avail
= get_availability ()) > AVAIL_INTERPOSABLE
)
2446 if (callback (this, data
))
2449 FOR_EACH_ALIAS (this, ref
)
2451 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2452 if (include_overwritable
2453 || alias
->get_availability () > AVAIL_INTERPOSABLE
)
2454 if (alias
->call_for_symbol_thunks_and_aliases (callback
, data
,
2455 include_overwritable
,
2456 exclude_virtual_thunks
))
2459 if (avail
<= AVAIL_INTERPOSABLE
)
2461 for (e
= callers
; e
; e
= e
->next_caller
)
2462 if (e
->caller
->thunk
2463 && (include_overwritable
2464 || e
->caller
->get_availability () > AVAIL_INTERPOSABLE
)
2465 && !(exclude_virtual_thunks
2466 && thunk_info::get (e
->caller
)->virtual_offset_p
))
2467 if (e
->caller
->call_for_symbol_thunks_and_aliases (callback
, data
,
2468 include_overwritable
,
2469 exclude_virtual_thunks
))
2475 /* Worker to bring NODE local. */
2478 cgraph_node::make_local (cgraph_node
*node
, void *)
2480 gcc_checking_assert (node
->can_be_local_p ());
2481 if (DECL_COMDAT (node
->decl
) || DECL_EXTERNAL (node
->decl
))
2483 node
->make_decl_local ();
2484 node
->set_section (NULL
);
2485 node
->set_comdat_group (NULL
);
2486 node
->externally_visible
= false;
2487 node
->forced_by_abi
= false;
2489 node
->set_section (NULL
);
2490 node
->unique_name
= ((node
->resolution
== LDPR_PREVAILING_DEF_IRONLY
2491 || node
->resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
)
2492 && !flag_incremental_link
);
2493 node
->resolution
= LDPR_PREVAILING_DEF_IRONLY
;
2494 gcc_assert (node
->get_availability () == AVAIL_LOCAL
);
2499 /* Bring cgraph node local. */
2502 cgraph_node::make_local (void)
2504 call_for_symbol_thunks_and_aliases (cgraph_node::make_local
, NULL
, true);
2507 /* Worker to set nothrow flag. */
2510 set_nothrow_flag_1 (cgraph_node
*node
, bool nothrow
, bool non_call
,
2515 if (nothrow
&& !TREE_NOTHROW (node
->decl
))
2517 /* With non-call exceptions we can't say for sure if other function body
2518 was not possibly optimized to still throw. */
2519 if (!non_call
|| node
->binds_to_current_def_p ())
2521 TREE_NOTHROW (node
->decl
) = true;
2523 for (e
= node
->callers
; e
; e
= e
->next_caller
)
2524 e
->can_throw_external
= false;
2527 else if (!nothrow
&& TREE_NOTHROW (node
->decl
))
2529 TREE_NOTHROW (node
->decl
) = false;
2533 FOR_EACH_ALIAS (node
, ref
)
2535 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2536 if (!nothrow
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2537 set_nothrow_flag_1 (alias
, nothrow
, non_call
, changed
);
2539 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
2540 if (e
->caller
->thunk
2541 && (!nothrow
|| e
->caller
->get_availability () > AVAIL_INTERPOSABLE
))
2542 set_nothrow_flag_1 (e
->caller
, nothrow
, non_call
, changed
);
2545 /* Set TREE_NOTHROW on NODE's decl and on aliases of NODE
2546 if any to NOTHROW. */
2549 cgraph_node::set_nothrow_flag (bool nothrow
)
2551 bool changed
= false;
2552 bool non_call
= opt_for_fn (decl
, flag_non_call_exceptions
);
2554 if (!nothrow
|| get_availability () > AVAIL_INTERPOSABLE
)
2555 set_nothrow_flag_1 (this, nothrow
, non_call
, &changed
);
2560 FOR_EACH_ALIAS (this, ref
)
2562 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2563 if (!nothrow
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2564 set_nothrow_flag_1 (alias
, nothrow
, non_call
, &changed
);
2570 /* Worker to set malloc flag. */
2572 set_malloc_flag_1 (cgraph_node
*node
, bool malloc_p
, bool *changed
)
2574 if (malloc_p
&& !DECL_IS_MALLOC (node
->decl
))
2576 DECL_IS_MALLOC (node
->decl
) = true;
2581 FOR_EACH_ALIAS (node
, ref
)
2583 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2584 if (!malloc_p
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2585 set_malloc_flag_1 (alias
, malloc_p
, changed
);
2588 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
2589 if (e
->caller
->thunk
2590 && (!malloc_p
|| e
->caller
->get_availability () > AVAIL_INTERPOSABLE
))
2591 set_malloc_flag_1 (e
->caller
, malloc_p
, changed
);
2594 /* Set DECL_IS_MALLOC on NODE's decl and on NODE's aliases if any. */
2597 cgraph_node::set_malloc_flag (bool malloc_p
)
2599 bool changed
= false;
2601 if (!malloc_p
|| get_availability () > AVAIL_INTERPOSABLE
)
2602 set_malloc_flag_1 (this, malloc_p
, &changed
);
2607 FOR_EACH_ALIAS (this, ref
)
2609 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2610 if (!malloc_p
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2611 set_malloc_flag_1 (alias
, malloc_p
, &changed
);
2617 /* Worker to set noreturng flag. */
2619 set_noreturn_flag_1 (cgraph_node
*node
, bool noreturn_p
, bool *changed
)
2621 if (noreturn_p
&& !TREE_THIS_VOLATILE (node
->decl
))
2623 TREE_THIS_VOLATILE (node
->decl
) = true;
2628 FOR_EACH_ALIAS (node
, ref
)
2630 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2631 if (!noreturn_p
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2632 set_noreturn_flag_1 (alias
, noreturn_p
, changed
);
2635 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
2636 if (e
->caller
->thunk
2637 && (!noreturn_p
|| e
->caller
->get_availability () > AVAIL_INTERPOSABLE
))
2638 set_noreturn_flag_1 (e
->caller
, noreturn_p
, changed
);
2641 /* Set TREE_THIS_VOLATILE on NODE's decl and on NODE's aliases if any. */
2644 cgraph_node::set_noreturn_flag (bool noreturn_p
)
2646 bool changed
= false;
2648 if (!noreturn_p
|| get_availability () > AVAIL_INTERPOSABLE
)
2649 set_noreturn_flag_1 (this, noreturn_p
, &changed
);
2654 FOR_EACH_ALIAS (this, ref
)
2656 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2657 if (!noreturn_p
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2658 set_noreturn_flag_1 (alias
, noreturn_p
, &changed
);
2664 /* Worker to set_const_flag. */
2667 set_const_flag_1 (cgraph_node
*node
, bool set_const
, bool looping
,
2670 /* Static constructors and destructors without a side effect can be
2672 if (set_const
&& !looping
)
2674 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
2676 DECL_STATIC_CONSTRUCTOR (node
->decl
) = 0;
2679 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
2681 DECL_STATIC_DESTRUCTOR (node
->decl
) = 0;
2687 if (TREE_READONLY (node
->decl
))
2689 TREE_READONLY (node
->decl
) = 0;
2690 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2696 /* Consider function:
2703 During early optimization we will turn this into:
2710 Now if this function will be detected as CONST however when interposed
2711 it may end up being just pure. We always must assume the worst
2713 if (TREE_READONLY (node
->decl
))
2715 if (!looping
&& DECL_LOOPING_CONST_OR_PURE_P (node
->decl
))
2717 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2721 else if (node
->binds_to_current_def_p ())
2723 TREE_READONLY (node
->decl
) = true;
2724 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = looping
;
2725 DECL_PURE_P (node
->decl
) = false;
2730 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2731 fprintf (dump_file
, "Dropping state to PURE because function does "
2732 "not bind to current def.\n");
2733 if (!DECL_PURE_P (node
->decl
))
2735 DECL_PURE_P (node
->decl
) = true;
2736 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = looping
;
2739 else if (!looping
&& DECL_LOOPING_CONST_OR_PURE_P (node
->decl
))
2741 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2748 FOR_EACH_ALIAS (node
, ref
)
2750 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2751 if (!set_const
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2752 set_const_flag_1 (alias
, set_const
, looping
, changed
);
2754 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
2755 if (e
->caller
->thunk
2756 && (!set_const
|| e
->caller
->get_availability () > AVAIL_INTERPOSABLE
))
2758 /* Virtual thunks access virtual offset in the vtable, so they can
2759 only be pure, never const. */
2761 && (thunk_info::get (e
->caller
)->virtual_offset_p
2762 || !node
->binds_to_current_def_p (e
->caller
)))
2763 *changed
|= e
->caller
->set_pure_flag (true, looping
);
2765 set_const_flag_1 (e
->caller
, set_const
, looping
, changed
);
2769 /* If SET_CONST is true, mark function, aliases and thunks to be ECF_CONST.
2770 If SET_CONST if false, clear the flag.
2772 When setting the flag be careful about possible interposition and
2773 do not set the flag for functions that can be interposed and set pure
2774 flag for functions that can bind to other definition.
2776 Return true if any change was done. */
2779 cgraph_node::set_const_flag (bool set_const
, bool looping
)
2781 bool changed
= false;
2782 if (!set_const
|| get_availability () > AVAIL_INTERPOSABLE
)
2783 set_const_flag_1 (this, set_const
, looping
, &changed
);
2788 FOR_EACH_ALIAS (this, ref
)
2790 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2791 if (!set_const
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2792 set_const_flag_1 (alias
, set_const
, looping
, &changed
);
2798 /* Info used by set_pure_flag_1. */
2800 struct set_pure_flag_info
2807 /* Worker to set_pure_flag. */
2810 set_pure_flag_1 (cgraph_node
*node
, void *data
)
2812 struct set_pure_flag_info
*info
= (struct set_pure_flag_info
*)data
;
2813 /* Static constructors and destructors without a side effect can be
2815 if (info
->pure
&& !info
->looping
)
2817 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
2819 DECL_STATIC_CONSTRUCTOR (node
->decl
) = 0;
2820 info
->changed
= true;
2822 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
2824 DECL_STATIC_DESTRUCTOR (node
->decl
) = 0;
2825 info
->changed
= true;
2830 if (!DECL_PURE_P (node
->decl
) && !TREE_READONLY (node
->decl
))
2832 DECL_PURE_P (node
->decl
) = true;
2833 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = info
->looping
;
2834 info
->changed
= true;
2836 else if (DECL_LOOPING_CONST_OR_PURE_P (node
->decl
)
2839 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2840 info
->changed
= true;
2845 if (DECL_PURE_P (node
->decl
))
2847 DECL_PURE_P (node
->decl
) = false;
2848 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2849 info
->changed
= true;
2855 /* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node
2858 When setting the flag, be careful about possible interposition.
2859 Return true if any change was done. */
2862 cgraph_node::set_pure_flag (bool pure
, bool looping
)
2864 struct set_pure_flag_info info
= {pure
, looping
, false};
2865 call_for_symbol_thunks_and_aliases (set_pure_flag_1
, &info
, !pure
, true);
2866 return info
.changed
;
2869 /* Return true when cgraph_node cannot return or throw and thus
2870 it is safe to ignore its side effects for IPA analysis. */
2873 cgraph_node::cannot_return_p (void)
2875 int flags
= flags_from_decl_or_type (decl
);
2876 if (!opt_for_fn (decl
, flag_exceptions
))
2877 return (flags
& ECF_NORETURN
) != 0;
2879 return ((flags
& (ECF_NORETURN
| ECF_NOTHROW
))
2880 == (ECF_NORETURN
| ECF_NOTHROW
));
2883 /* Return true when call of edge cannot lead to return from caller
2884 and thus it is safe to ignore its side effects for IPA analysis
2885 when computing side effects of the caller.
2886 FIXME: We could actually mark all edges that have no reaching
2887 patch to the exit block or throw to get better results. */
2889 cgraph_edge::cannot_lead_to_return_p (void)
2891 if (caller
->cannot_return_p ())
2893 if (indirect_unknown_callee
)
2895 int flags
= indirect_info
->ecf_flags
;
2896 if (!opt_for_fn (caller
->decl
, flag_exceptions
))
2897 return (flags
& ECF_NORETURN
) != 0;
2899 return ((flags
& (ECF_NORETURN
| ECF_NOTHROW
))
2900 == (ECF_NORETURN
| ECF_NOTHROW
));
2903 return callee
->cannot_return_p ();
2906 /* Return true if the edge may be considered hot. */
2909 cgraph_edge::maybe_hot_p (void)
2911 if (!maybe_hot_count_p (NULL
, count
.ipa ()))
2913 if (caller
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
2915 && callee
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
))
2917 if (caller
->frequency
> NODE_FREQUENCY_UNLIKELY_EXECUTED
2919 && callee
->frequency
<= NODE_FREQUENCY_EXECUTED_ONCE
))
2921 if (opt_for_fn (caller
->decl
, optimize_size
))
2923 if (caller
->frequency
== NODE_FREQUENCY_HOT
)
2925 if (!count
.initialized_p ())
2927 cgraph_node
*where
= caller
->inlined_to
? caller
->inlined_to
: caller
;
2928 if (!where
->count
.initialized_p ())
2930 if (caller
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
)
2932 if (count
.apply_scale (2, 1) < where
->count
.apply_scale (3, 1))
2935 else if (count
.apply_scale (param_hot_bb_frequency_fraction
, 1)
2941 /* Worker for cgraph_can_remove_if_no_direct_calls_p. */
2944 nonremovable_p (cgraph_node
*node
, void *)
2946 return !node
->can_remove_if_no_direct_calls_and_refs_p ();
2949 /* Return true if whole comdat group can be removed if there are no direct
2953 cgraph_node::can_remove_if_no_direct_calls_p (bool will_inline
)
2955 struct ipa_ref
*ref
;
2957 /* For local symbols or non-comdat group it is the same as
2958 can_remove_if_no_direct_calls_p. */
2959 if (!externally_visible
|| !same_comdat_group
)
2961 if (DECL_EXTERNAL (decl
))
2965 return !call_for_symbol_and_aliases (nonremovable_p
, NULL
, true);
2968 if (will_inline
&& address_taken
)
2971 /* Otherwise check if we can remove the symbol itself and then verify
2972 that only uses of the comdat groups are direct call to THIS
2974 if (!can_remove_if_no_direct_calls_and_refs_p ())
2977 /* Check that all refs come from within the comdat group. */
2978 for (int i
= 0; iterate_referring (i
, ref
); i
++)
2979 if (ref
->referring
->get_comdat_group () != get_comdat_group ())
2982 struct cgraph_node
*target
= ultimate_alias_target ();
2983 for (cgraph_node
*next
= dyn_cast
<cgraph_node
*> (same_comdat_group
);
2984 next
!= this; next
= dyn_cast
<cgraph_node
*> (next
->same_comdat_group
))
2986 if (!externally_visible
)
2989 && !next
->can_remove_if_no_direct_calls_and_refs_p ())
2992 /* If we see different symbol than THIS, be sure to check calls. */
2993 if (next
->ultimate_alias_target () != target
)
2994 for (cgraph_edge
*e
= next
->callers
; e
; e
= e
->next_caller
)
2995 if (e
->caller
->get_comdat_group () != get_comdat_group ()
2999 /* If function is not being inlined, we care only about
3000 references outside of the comdat group. */
3002 for (int i
= 0; next
->iterate_referring (i
, ref
); i
++)
3003 if (ref
->referring
->get_comdat_group () != get_comdat_group ())
3009 /* Return true when function cgraph_node can be expected to be removed
3010 from program when direct calls in this compilation unit are removed.
3012 As a special case COMDAT functions are
3013 cgraph_can_remove_if_no_direct_calls_p while the are not
3014 cgraph_only_called_directly_p (it is possible they are called from other
3017 This function behaves as cgraph_only_called_directly_p because eliminating
3018 all uses of COMDAT function does not make it necessarily disappear from
3019 the program unless we are compiling whole program or we do LTO. In this
3020 case we know we win since dynamic linking will not really discard the
3021 linkonce section. */
3024 cgraph_node::will_be_removed_from_program_if_no_direct_calls_p
3027 gcc_assert (!inlined_to
);
3028 if (DECL_EXTERNAL (decl
))
3031 if (!in_lto_p
&& !flag_whole_program
)
3033 /* If the symbol is in comdat group, we need to verify that whole comdat
3034 group becomes unreachable. Technically we could skip references from
3035 within the group, too. */
3036 if (!only_called_directly_p ())
3038 if (same_comdat_group
&& externally_visible
)
3040 struct cgraph_node
*target
= ultimate_alias_target ();
3042 if (will_inline
&& address_taken
)
3044 for (cgraph_node
*next
= dyn_cast
<cgraph_node
*> (same_comdat_group
);
3046 next
= dyn_cast
<cgraph_node
*> (next
->same_comdat_group
))
3048 if (!externally_visible
)
3051 && !next
->only_called_directly_p ())
3054 /* If we see different symbol than THIS,
3055 be sure to check calls. */
3056 if (next
->ultimate_alias_target () != target
)
3057 for (cgraph_edge
*e
= next
->callers
; e
; e
= e
->next_caller
)
3058 if (e
->caller
->get_comdat_group () != get_comdat_group ()
3066 return can_remove_if_no_direct_calls_p (will_inline
);
3070 /* Worker for cgraph_only_called_directly_p. */
3073 cgraph_not_only_called_directly_p_1 (cgraph_node
*node
, void *)
3075 return !node
->only_called_directly_or_aliased_p ();
3078 /* Return true when function cgraph_node and all its aliases are only called
3080 i.e. it is not externally visible, address was not taken and
3081 it is not used in any other non-standard way. */
3084 cgraph_node::only_called_directly_p (void)
3086 gcc_assert (ultimate_alias_target () == this);
3087 return !call_for_symbol_and_aliases (cgraph_not_only_called_directly_p_1
,
3092 /* Collect all callers of NODE. Worker for collect_callers_of_node. */
3095 collect_callers_of_node_1 (cgraph_node
*node
, void *data
)
3097 vec
<cgraph_edge
*> *redirect_callers
= (vec
<cgraph_edge
*> *)data
;
3099 enum availability avail
;
3100 node
->ultimate_alias_target (&avail
);
3102 if (avail
> AVAIL_INTERPOSABLE
)
3103 for (cs
= node
->callers
; cs
!= NULL
; cs
= cs
->next_caller
)
3104 if (!cs
->indirect_inlining_edge
3105 && !cs
->caller
->thunk
)
3106 redirect_callers
->safe_push (cs
);
3110 /* Collect all callers of cgraph_node and its aliases that are known to lead to
3111 cgraph_node (i.e. are not overwritable). */
3113 auto_vec
<cgraph_edge
*>
3114 cgraph_node::collect_callers (void)
3116 auto_vec
<cgraph_edge
*> redirect_callers
;
3117 call_for_symbol_thunks_and_aliases (collect_callers_of_node_1
,
3118 &redirect_callers
, false);
3119 return redirect_callers
;
3123 /* Return TRUE if NODE2 a clone of NODE or is equivalent to it. Return
3124 optimistically true if this cannot be determined. */
3127 clone_of_p (cgraph_node
*node
, cgraph_node
*node2
)
3129 node
= node
->ultimate_alias_target ();
3130 node2
= node2
->ultimate_alias_target ();
3132 if (node2
->clone_of
== node
3133 || node2
->former_clone_of
== node
->decl
)
3136 if (!node
->thunk
&& !node
->former_thunk_p ())
3139 && node
->decl
!= node2
->decl
3140 && node
->decl
!= node2
->former_clone_of
)
3141 node2
= node2
->clone_of
;
3142 return node2
!= NULL
;
3145 /* There are no virtual clones of thunks so check former_clone_of or if we
3146 might have skipped thunks because this adjustments are no longer
3148 while (node
->thunk
|| node
->former_thunk_p ())
3150 if (!thunk_info::get (node
)->this_adjusting
)
3152 /* In case of instrumented expanded thunks, which can have multiple calls
3153 in them, we do not know how to continue and just have to be
3154 optimistic. The same applies if all calls have already been inlined
3156 if (!node
->callees
|| node
->callees
->next_callee
)
3158 node
= node
->callees
->callee
->ultimate_alias_target ();
3160 clone_info
*info
= clone_info::get (node2
);
3161 if (!info
|| !info
->param_adjustments
3162 || info
->param_adjustments
->first_param_intact_p ())
3164 if (node2
->former_clone_of
== node
->decl
3165 || node2
->former_clone_of
== node
->former_clone_of
)
3168 cgraph_node
*n2
= node2
;
3169 while (n2
&& node
->decl
!= n2
->decl
)
3178 /* Verify edge count and frequency. */
3181 cgraph_edge::verify_count ()
3183 bool error_found
= false;
3184 if (!count
.verify ())
3186 error ("caller edge count invalid");
3192 /* Switch to THIS_CFUN if needed and print STMT to stderr. */
3194 cgraph_debug_gimple_stmt (function
*this_cfun
, gimple
*stmt
)
3196 bool fndecl_was_null
= false;
3197 /* debug_gimple_stmt needs correct cfun */
3198 if (cfun
!= this_cfun
)
3199 set_cfun (this_cfun
);
3200 /* ...and an actual current_function_decl */
3201 if (!current_function_decl
)
3203 current_function_decl
= this_cfun
->decl
;
3204 fndecl_was_null
= true;
3206 debug_gimple_stmt (stmt
);
3207 if (fndecl_was_null
)
3208 current_function_decl
= NULL
;
3211 /* Verify that call graph edge corresponds to DECL from the associated
3212 statement. Return true if the verification should fail. */
3215 cgraph_edge::verify_corresponds_to_fndecl (tree decl
)
3219 if (!decl
|| callee
->inlined_to
)
3221 if (symtab
->state
== LTO_STREAMING
)
3223 node
= cgraph_node::get (decl
);
3225 /* We do not know if a node from a different partition is an alias or what it
3226 aliases and therefore cannot do the former_clone_of check reliably. When
3227 body_removed is set, we have lost all information about what was alias or
3228 thunk of and also cannot proceed. */
3230 || node
->body_removed
3231 || node
->in_other_partition
3232 || callee
->icf_merged
3233 || callee
->in_other_partition
)
3236 node
= node
->ultimate_alias_target ();
3238 /* Optimizers can redirect unreachable calls or calls triggering undefined
3239 behavior to builtin_unreachable. */
3241 if (fndecl_built_in_p (callee
->decl
, BUILT_IN_UNREACHABLE
))
3244 if (callee
->former_clone_of
!= node
->decl
3245 && (node
!= callee
->ultimate_alias_target ())
3246 && !clone_of_p (node
, callee
))
3252 /* Disable warnings about missing quoting in GCC diagnostics for
3253 the verification errors. Their format strings don't follow GCC
3254 diagnostic conventions and the calls are ultimately followed by
3255 one to internal_error. */
3257 # pragma GCC diagnostic push
3258 # pragma GCC diagnostic ignored "-Wformat-diag"
3261 /* Verify consistency of speculative call in NODE corresponding to STMT
3262 and LTO_STMT_UID. If INDIRECT is set, assume that it is the indirect
3263 edge of call sequence. Return true if error is found.
3265 This function is called to every component of indirect call (direct edges,
3266 indirect edge and refs). To save duplicated work, do full testing only
3269 verify_speculative_call (struct cgraph_node
*node
, gimple
*stmt
,
3270 unsigned int lto_stmt_uid
,
3271 struct cgraph_edge
*indirect
)
3273 if (indirect
== NULL
)
3275 for (indirect
= node
->indirect_calls
; indirect
;
3276 indirect
= indirect
->next_callee
)
3277 if (indirect
->call_stmt
== stmt
3278 && indirect
->lto_stmt_uid
== lto_stmt_uid
)
3282 error ("missing indirect call in speculative call sequence");
3285 if (!indirect
->speculative
)
3287 error ("indirect call in speculative call sequence has no "
3288 "speculative flag");
3294 /* Maximal number of targets. We probably will never want to have more than
3296 const unsigned int num
= 256;
3297 cgraph_edge
*direct_calls
[num
];
3300 for (unsigned int i
= 0; i
< num
; i
++)
3302 direct_calls
[i
] = NULL
;
3306 cgraph_edge
*first_call
= NULL
;
3307 cgraph_edge
*prev_call
= NULL
;
3309 for (cgraph_edge
*direct
= node
->callees
; direct
;
3310 direct
= direct
->next_callee
)
3311 if (direct
->call_stmt
== stmt
&& direct
->lto_stmt_uid
== lto_stmt_uid
)
3314 first_call
= direct
;
3315 if (prev_call
&& direct
!= prev_call
->next_callee
)
3317 error ("speculative edges are not adjacent");
3321 if (!direct
->speculative
)
3323 error ("direct call to %s in speculative call sequence has no "
3324 "speculative flag", direct
->callee
->dump_name ());
3327 if (direct
->speculative_id
>= num
)
3329 error ("direct call to %s in speculative call sequence has "
3330 "speculative_id %i out of range",
3331 direct
->callee
->dump_name (), direct
->speculative_id
);
3334 if (direct_calls
[direct
->speculative_id
])
3336 error ("duplicate direct call to %s in speculative call sequence "
3337 "with speculative_id %i",
3338 direct
->callee
->dump_name (), direct
->speculative_id
);
3341 direct_calls
[direct
->speculative_id
] = direct
;
3344 if (first_call
->call_stmt
3345 && first_call
!= node
->get_edge (first_call
->call_stmt
))
3347 error ("call stmt hash does not point to first direct edge of "
3348 "speculative call sequence");
3353 for (int i
= 0; node
->iterate_reference (i
, ref
); i
++)
3354 if (ref
->speculative
3355 && ref
->stmt
== stmt
&& ref
->lto_stmt_uid
== lto_stmt_uid
)
3357 if (ref
->speculative_id
>= num
)
3359 error ("direct call to %s in speculative call sequence has "
3360 "speculative_id %i out of range",
3361 ref
->referred
->dump_name (), ref
->speculative_id
);
3364 if (refs
[ref
->speculative_id
])
3366 error ("duplicate reference %s in speculative call sequence "
3367 "with speculative_id %i",
3368 ref
->referred
->dump_name (), ref
->speculative_id
);
3371 refs
[ref
->speculative_id
] = ref
;
3374 int num_targets
= 0;
3375 for (unsigned int i
= 0 ; i
< num
; i
++)
3377 if (refs
[i
] && !direct_calls
[i
])
3379 error ("missing direct call for speculation %i", i
);
3382 if (!refs
[i
] && direct_calls
[i
])
3384 error ("missing ref for speculation %i", i
);
3387 if (refs
[i
] != NULL
)
3391 if (num_targets
!= indirect
->num_speculative_call_targets_p ())
3393 error ("number of speculative targets %i mismatched with "
3394 "num_speculative_call_targets %i",
3396 indirect
->num_speculative_call_targets_p ());
3402 /* Verify cgraph nodes of given cgraph node. */
3404 cgraph_node::verify_node (void)
3407 function
*this_cfun
= DECL_STRUCT_FUNCTION (decl
);
3408 basic_block this_block
;
3409 gimple_stmt_iterator gsi
;
3410 bool error_found
= false;
3412 ipa_ref
*ref
= NULL
;
3417 timevar_push (TV_CGRAPH_VERIFY
);
3418 error_found
|= verify_base ();
3419 for (e
= callees
; e
; e
= e
->next_callee
)
3422 error ("aux field set for edge %s->%s",
3423 identifier_to_locale (e
->caller
->name ()),
3424 identifier_to_locale (e
->callee
->name ()));
3427 if (!count
.verify ())
3429 error ("cgraph count invalid");
3432 if (inlined_to
&& same_comdat_group
)
3434 error ("inline clone in same comdat group list");
3437 if (inlined_to
&& !count
.compatible_p (inlined_to
->count
))
3439 error ("inline clone count is not compatible");
3441 inlined_to
->count
.debug ();
3444 if (tp_first_run
< 0)
3446 error ("tp_first_run must be non-negative");
3449 if (!definition
&& !in_other_partition
&& local
)
3451 error ("local symbols must be defined");
3454 if (inlined_to
&& externally_visible
)
3456 error ("externally visible inline clone");
3459 if (inlined_to
&& address_taken
)
3461 error ("inline clone with address taken");
3464 if (inlined_to
&& force_output
)
3466 error ("inline clone is forced to output");
3469 if (symtab
->state
!= LTO_STREAMING
)
3471 if (calls_comdat_local
&& !same_comdat_group
)
3473 error ("calls_comdat_local is set outside of a comdat group");
3476 if (!inlined_to
&& calls_comdat_local
!= check_calls_comdat_local_p ())
3478 error ("invalid calls_comdat_local flag");
3482 if (DECL_IS_MALLOC (decl
)
3483 && !POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (decl
))))
3485 error ("malloc attribute should be used for a function that "
3486 "returns a pointer");
3489 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
3493 error ("aux field set for indirect edge from %s",
3494 identifier_to_locale (e
->caller
->name ()));
3497 if (!e
->count
.compatible_p (count
))
3499 error ("edge count is not compatible with function count");
3504 if (!e
->indirect_unknown_callee
3505 || !e
->indirect_info
)
3507 error ("An indirect edge from %s is not marked as indirect or has "
3508 "associated indirect_info, the corresponding statement is: ",
3509 identifier_to_locale (e
->caller
->name ()));
3510 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3513 if (e
->call_stmt
&& e
->lto_stmt_uid
)
3515 error ("edge has both call_stmt and lto_stmt_uid set");
3519 bool check_comdat
= comdat_local_p ();
3520 for (e
= callers
; e
; e
= e
->next_caller
)
3522 if (e
->verify_count ())
3525 && !in_same_comdat_group_p (e
->caller
))
3527 error ("comdat-local function called by %s outside its comdat",
3528 identifier_to_locale (e
->caller
->name ()));
3531 if (!e
->inline_failed
)
3534 != (e
->caller
->inlined_to
3535 ? e
->caller
->inlined_to
: e
->caller
))
3537 error ("inlined_to pointer is wrong");
3540 if (callers
->next_caller
)
3542 error ("multiple inline callers");
3549 error ("inlined_to pointer set for noninline callers");
3553 for (e
= callees
; e
; e
= e
->next_callee
)
3555 if (e
->verify_count ())
3557 if (!e
->count
.compatible_p (count
))
3559 error ("edge count is not compatible with function count");
3564 if (gimple_has_body_p (e
->caller
->decl
)
3565 && !e
->caller
->inlined_to
3567 /* Optimized out calls are redirected to __builtin_unreachable. */
3568 && (e
->count
.nonzero_p ()
3569 || ! e
->callee
->decl
3570 || !fndecl_built_in_p (e
->callee
->decl
, BUILT_IN_UNREACHABLE
))
3572 == ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (decl
))->count
3573 && (!e
->count
.ipa_p ()
3574 && e
->count
.differs_from_p (gimple_bb (e
->call_stmt
)->count
)))
3576 error ("caller edge count does not match BB count");
3577 fprintf (stderr
, "edge count: ");
3578 e
->count
.dump (stderr
);
3579 fprintf (stderr
, "\n bb count: ");
3580 gimple_bb (e
->call_stmt
)->count
.dump (stderr
);
3581 fprintf (stderr
, "\n");
3584 if (e
->call_stmt
&& e
->lto_stmt_uid
)
3586 error ("edge has both call_stmt and lto_stmt_uid set");
3590 && verify_speculative_call (e
->caller
, e
->call_stmt
, e
->lto_stmt_uid
,
3594 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
3596 if (e
->verify_count ())
3598 if (gimple_has_body_p (e
->caller
->decl
)
3599 && !e
->caller
->inlined_to
3601 && e
->count
.ipa_p ()
3603 == ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (decl
))->count
3604 && (!e
->count
.ipa_p ()
3605 && e
->count
.differs_from_p (gimple_bb (e
->call_stmt
)->count
)))
3607 error ("indirect call count does not match BB count");
3608 fprintf (stderr
, "edge count: ");
3609 e
->count
.dump (stderr
);
3610 fprintf (stderr
, "\n bb count: ");
3611 gimple_bb (e
->call_stmt
)->count
.dump (stderr
);
3612 fprintf (stderr
, "\n");
3616 && verify_speculative_call (e
->caller
, e
->call_stmt
, e
->lto_stmt_uid
,
3620 for (i
= 0; iterate_reference (i
, ref
); i
++)
3622 if (ref
->stmt
&& ref
->lto_stmt_uid
)
3624 error ("reference has both stmt and lto_stmt_uid set");
3627 if (ref
->speculative
3628 && verify_speculative_call (this, ref
->stmt
,
3629 ref
->lto_stmt_uid
, NULL
))
3633 if (!callers
&& inlined_to
)
3635 error ("inlined_to pointer is set but no predecessors found");
3638 if (inlined_to
== this)
3640 error ("inlined_to pointer refers to itself");
3646 cgraph_node
*first_clone
= clone_of
->clones
;
3647 if (first_clone
!= this)
3649 if (prev_sibling_clone
->clone_of
!= clone_of
)
3651 error ("cgraph_node has wrong clone_of");
3659 for (n
= clones
; n
; n
= n
->next_sibling_clone
)
3660 if (n
->clone_of
!= this)
3664 error ("cgraph_node has wrong clone list");
3668 if ((prev_sibling_clone
|| next_sibling_clone
) && !clone_of
)
3670 error ("cgraph_node is in clone list but it is not clone");
3673 if (!prev_sibling_clone
&& clone_of
&& clone_of
->clones
!= this)
3675 error ("cgraph_node has wrong prev_clone pointer");
3678 if (prev_sibling_clone
&& prev_sibling_clone
->next_sibling_clone
!= this)
3680 error ("double linked list of clones corrupted");
3684 if (analyzed
&& alias
)
3686 bool ref_found
= false;
3688 ipa_ref
*ref
= NULL
;
3692 error ("Alias has call edges");
3695 for (i
= 0; iterate_reference (i
, ref
); i
++)
3696 if (ref
->use
!= IPA_REF_ALIAS
)
3698 error ("Alias has non-alias reference");
3703 error ("Alias has more than one alias reference");
3710 error ("Analyzed alias has no reference");
3715 if (analyzed
&& thunk
)
3719 error ("No edge out of thunk node");
3722 else if (callees
->next_callee
)
3724 error ("More than one edge out of thunk node");
3727 if (gimple_has_body_p (decl
) && !inlined_to
)
3729 error ("Thunk is not supposed to have body");
3733 else if (analyzed
&& gimple_has_body_p (decl
)
3734 && !TREE_ASM_WRITTEN (decl
)
3735 && (!DECL_EXTERNAL (decl
) || inlined_to
)
3740 hash_set
<gimple
*> stmts
;
3742 /* Reach the trees by walking over the CFG, and note the
3743 enclosing basic-blocks in the call edges. */
3744 FOR_EACH_BB_FN (this_block
, this_cfun
)
3746 for (gsi
= gsi_start_phis (this_block
);
3747 !gsi_end_p (gsi
); gsi_next (&gsi
))
3748 stmts
.add (gsi_stmt (gsi
));
3749 for (gsi
= gsi_start_bb (this_block
);
3753 gimple
*stmt
= gsi_stmt (gsi
);
3755 if (is_gimple_call (stmt
))
3757 cgraph_edge
*e
= get_edge (stmt
);
3758 tree decl
= gimple_call_fndecl (stmt
);
3763 error ("shared call_stmt:");
3764 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
3767 if (!e
->indirect_unknown_callee
)
3769 if (e
->verify_corresponds_to_fndecl (decl
))
3771 error ("edge points to wrong declaration:");
3772 debug_tree (e
->callee
->decl
);
3773 fprintf (stderr
," Instead of:");
3780 error ("an indirect edge with unknown callee "
3781 "corresponding to a call_stmt with "
3782 "a known declaration:");
3784 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3790 error ("missing callgraph edge for call stmt:");
3791 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
3797 for (i
= 0; iterate_reference (i
, ref
); i
++)
3798 if (ref
->stmt
&& !stmts
.contains (ref
->stmt
))
3800 error ("reference to dead statement");
3801 cgraph_debug_gimple_stmt (this_cfun
, ref
->stmt
);
3806 /* No CFG available?! */
3809 for (e
= callees
; e
; e
= e
->next_callee
)
3811 if (!e
->aux
&& !e
->speculative
)
3813 error ("edge %s->%s has no corresponding call_stmt",
3814 identifier_to_locale (e
->caller
->name ()),
3815 identifier_to_locale (e
->callee
->name ()));
3816 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3821 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
3823 if (!e
->aux
&& !e
->speculative
)
3825 error ("an indirect edge from %s has no corresponding call_stmt",
3826 identifier_to_locale (e
->caller
->name ()));
3827 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3834 if (nested_function_info
*info
= nested_function_info::get (this))
3836 if (info
->nested
!= NULL
)
3838 for (cgraph_node
*n
= info
->nested
; n
!= NULL
;
3839 n
= next_nested_function (n
))
3841 nested_function_info
*ninfo
= nested_function_info::get (n
);
3842 if (ninfo
->origin
== NULL
)
3844 error ("missing origin for a node in a nested list");
3847 else if (ninfo
->origin
!= this)
3849 error ("origin points to a different parent");
3855 if (info
->next_nested
!= NULL
&& info
->origin
== NULL
)
3857 error ("missing origin for a node in a nested list");
3865 internal_error ("verify_cgraph_node failed");
3867 timevar_pop (TV_CGRAPH_VERIFY
);
3870 /* Verify whole cgraph structure. */
3872 cgraph_node::verify_cgraph_nodes (void)
3879 FOR_EACH_FUNCTION (node
)
3884 # pragma GCC diagnostic pop
3887 /* Walk the alias chain to return the function cgraph_node is alias of.
3888 Walk through thunks, too.
3889 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3890 When REF is non-NULL, assume that reference happens in symbol REF
3891 when determining the availability. */
3894 cgraph_node::function_symbol (enum availability
*availability
,
3895 struct symtab_node
*ref
)
3897 cgraph_node
*node
= ultimate_alias_target (availability
, ref
);
3901 enum availability a
;
3904 node
= node
->callees
->callee
;
3905 node
= node
->ultimate_alias_target (availability
? &a
: NULL
, ref
);
3906 if (availability
&& a
< *availability
)
3912 /* Walk the alias chain to return the function cgraph_node is alias of.
3913 Walk through non virtual thunks, too. Thus we return either a function
3914 or a virtual thunk node.
3915 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3916 When REF is non-NULL, assume that reference happens in symbol REF
3917 when determining the availability. */
3920 cgraph_node::function_or_virtual_thunk_symbol
3921 (enum availability
*availability
,
3922 struct symtab_node
*ref
)
3924 cgraph_node
*node
= ultimate_alias_target (availability
, ref
);
3926 while (node
->thunk
&& !thunk_info::get (node
)->virtual_offset_p
)
3928 enum availability a
;
3931 node
= node
->callees
->callee
;
3932 node
= node
->ultimate_alias_target (availability
? &a
: NULL
, ref
);
3933 if (availability
&& a
< *availability
)
3939 /* When doing LTO, read cgraph_node's body from disk if it is not already
3940 present. Also perform any necessary clone materializations. */
3943 cgraph_node::get_untransformed_body ()
3945 lto_file_decl_data
*file_data
;
3946 const char *data
, *name
;
3948 tree decl
= this->decl
;
3950 /* See if there is clone to be materialized.
3951 (inline clones does not need materialization, but we can be seeing
3952 an inline clone of real clone). */
3953 cgraph_node
*p
= this;
3954 for (cgraph_node
*c
= clone_of
; c
; c
= c
->clone_of
)
3956 if (c
->decl
!= decl
)
3957 p
->materialize_clone ();
3961 /* Check if body is already there. Either we have gimple body or
3962 the function is thunk and in that case we set DECL_ARGUMENTS. */
3963 if (DECL_ARGUMENTS (decl
) || gimple_has_body_p (decl
))
3966 gcc_assert (in_lto_p
&& !DECL_RESULT (decl
));
3968 timevar_push (TV_IPA_LTO_GIMPLE_IN
);
3970 file_data
= lto_file_data
;
3971 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
3973 /* We may have renamed the declaration, e.g., a static function. */
3974 name
= lto_get_decl_name_mapping (file_data
, name
);
3975 struct lto_in_decl_state
*decl_state
3976 = lto_get_function_in_decl_state (file_data
, decl
);
3978 cgraph_node
*origin
= this;
3979 while (origin
->clone_of
)
3980 origin
= origin
->clone_of
;
3982 int stream_order
= origin
->order
- file_data
->order_base
;
3983 data
= lto_get_section_data (file_data
, LTO_section_function_body
,
3984 name
, stream_order
, &len
,
3985 decl_state
->compressed
);
3987 fatal_error (input_location
, "%s: section %s.%d is missing",
3988 file_data
->file_name
, name
, stream_order
);
3990 gcc_assert (DECL_STRUCT_FUNCTION (decl
) == NULL
);
3993 fprintf (stderr
, " in:%s", IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
3994 lto_input_function_body (file_data
, this, data
);
3995 lto_stats
.num_function_bodies
++;
3996 lto_free_section_data (file_data
, LTO_section_function_body
, name
,
3997 data
, len
, decl_state
->compressed
);
3998 lto_free_function_in_decl_state_for_node (this);
3999 /* Keep lto file data so ipa-inline-analysis knows about cross module
4002 timevar_pop (TV_IPA_LTO_GIMPLE_IN
);
4007 /* Prepare function body. When doing LTO, read cgraph_node's body from disk
4008 if it is not already present. When some IPA transformations are scheduled,
4012 cgraph_node::get_body (void)
4016 updated
= get_untransformed_body ();
4018 /* Getting transformed body makes no sense for inline clones;
4019 we should never use this on real clones because they are materialized
4021 TODO: Materializing clones here will likely lead to smaller LTRANS
4023 gcc_assert (!inlined_to
&& !clone_of
);
4024 if (ipa_transforms_to_apply
.exists ())
4026 opt_pass
*saved_current_pass
= current_pass
;
4027 FILE *saved_dump_file
= dump_file
;
4028 const char *saved_dump_file_name
= dump_file_name
;
4029 dump_flags_t saved_dump_flags
= dump_flags
;
4030 dump_file_name
= NULL
;
4031 set_dump_file (NULL
);
4033 push_cfun (DECL_STRUCT_FUNCTION (decl
));
4035 update_ssa (TODO_update_ssa_only_virtuals
);
4036 execute_all_ipa_transforms (true);
4037 cgraph_edge::rebuild_edges ();
4038 free_dominance_info (CDI_DOMINATORS
);
4039 free_dominance_info (CDI_POST_DOMINATORS
);
4043 current_pass
= saved_current_pass
;
4044 set_dump_file (saved_dump_file
);
4045 dump_file_name
= saved_dump_file_name
;
4046 dump_flags
= saved_dump_flags
;
4051 /* Return the DECL_STRUCT_FUNCTION of the function. */
4054 cgraph_node::get_fun () const
4056 const cgraph_node
*node
= this;
4057 struct function
*fun
= DECL_STRUCT_FUNCTION (node
->decl
);
4059 while (!fun
&& node
->clone_of
)
4061 node
= node
->clone_of
;
4062 fun
= DECL_STRUCT_FUNCTION (node
->decl
);
4068 /* Reset all state within cgraph.c so that we can rerun the compiler
4069 within the same process. For use by toplev::finalize. */
4072 cgraph_c_finalize (void)
4074 nested_function_info::release ();
4075 thunk_info::release ();
4076 clone_info::release ();
4079 x_cgraph_nodes_queue
= NULL
;
4081 cgraph_fnver_htab
= NULL
;
4082 version_info_node
= NULL
;
4085 /* A worker for call_for_symbol_and_aliases. */
4088 cgraph_node::call_for_symbol_and_aliases_1 (bool (*callback
) (cgraph_node
*,
4091 bool include_overwritable
)
4094 FOR_EACH_ALIAS (this, ref
)
4096 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
4097 if (include_overwritable
4098 || alias
->get_availability () > AVAIL_INTERPOSABLE
)
4099 if (alias
->call_for_symbol_and_aliases (callback
, data
,
4100 include_overwritable
))
4106 /* Return true if NODE has thunk. */
4109 cgraph_node::has_thunk_p (cgraph_node
*node
, void *)
4111 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
4112 if (e
->caller
->thunk
)
4117 /* Expected frequency of executions within the function. */
4120 cgraph_edge::sreal_frequency ()
4122 return count
.to_sreal_scale (caller
->inlined_to
4123 ? caller
->inlined_to
->count
4128 /* During LTO stream in this can be used to check whether call can possibly
4129 be internal to the current translation unit. */
4132 cgraph_edge::possibly_call_in_translation_unit_p (void)
4134 gcc_checking_assert (in_lto_p
&& caller
->prevailing_p ());
4136 /* While incremental linking we may end up getting function body later. */
4137 if (flag_incremental_link
== INCREMENTAL_LINK_LTO
)
4140 /* We may be smarter here and avoid streaming in indirect calls we can't
4141 track, but that would require arranging streaming the indirect call
4146 /* If callee is local to the original translation unit, it will be
4148 if (!TREE_PUBLIC (callee
->decl
) && !DECL_EXTERNAL (callee
->decl
))
4151 /* Otherwise we need to lookup prevailing symbol (symbol table is not merged,
4152 yet) and see if it is a definition. In fact we may also resolve aliases,
4153 but that is probably not too important. */
4154 symtab_node
*node
= callee
;
4155 for (int n
= 10; node
->previous_sharing_asm_name
&& n
; n
--)
4156 node
= node
->previous_sharing_asm_name
;
4157 if (node
->previous_sharing_asm_name
)
4158 node
= symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (callee
->decl
));
4159 gcc_assert (TREE_PUBLIC (node
->decl
));
4160 return node
->get_availability () >= AVAIL_INTERPOSABLE
;
4163 /* Return num_speculative_targets of this edge. */
4166 cgraph_edge::num_speculative_call_targets_p (void)
4168 return indirect_info
? indirect_info
->num_speculative_call_targets
: 0;
4171 /* Check if function calls comdat local. This is used to recompute
4172 calls_comdat_local flag after function transformations. */
4174 cgraph_node::check_calls_comdat_local_p ()
4176 for (cgraph_edge
*e
= callees
; e
; e
= e
->next_callee
)
4177 if (e
->inline_failed
4178 ? e
->callee
->comdat_local_p ()
4179 : e
->callee
->check_calls_comdat_local_p ())
4184 /* Return true if this node represents a former, i.e. an expanded, thunk. */
4187 cgraph_node::former_thunk_p (void)
4191 thunk_info
*i
= thunk_info::get (this);
4194 gcc_checking_assert (i
->fixed_offset
|| i
->virtual_offset_p
4195 || i
->indirect_offset
);
4199 /* A stashed copy of "symtab" for use by selftest::symbol_table_test.
4200 This needs to be a global so that it can be a GC root, and thus
4201 prevent the stashed copy from being garbage-collected if the GC runs
4202 during a symbol_table_test. */
4204 symbol_table
*saved_symtab
;
4208 namespace selftest
{
4210 /* class selftest::symbol_table_test. */
4212 /* Constructor. Store the old value of symtab, and create a new one. */
4214 symbol_table_test::symbol_table_test ()
4216 gcc_assert (saved_symtab
== NULL
);
4217 saved_symtab
= symtab
;
4218 symtab
= new (ggc_alloc
<symbol_table
> ()) symbol_table ();
4221 /* Destructor. Restore the old value of symtab. */
4223 symbol_table_test::~symbol_table_test ()
4225 gcc_assert (saved_symtab
!= NULL
);
4226 symtab
= saved_symtab
;
4227 saved_symtab
= NULL
;
4230 /* Verify that symbol_table_test works. */
4233 test_symbol_table_test ()
4235 /* Simulate running two selftests involving symbol tables. */
4236 for (int i
= 0; i
< 2; i
++)
4238 symbol_table_test stt
;
4239 tree test_decl
= build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
,
4240 get_identifier ("test_decl"),
4241 build_function_type_list (void_type_node
,
4243 cgraph_node
*node
= cgraph_node::get_create (test_decl
);
4246 /* Verify that the node has order 0 on both iterations,
4247 and thus that nodes have predictable dump names in selftests. */
4248 ASSERT_EQ (node
->order
, 0);
4249 ASSERT_STREQ (node
->dump_name (), "test_decl/0");
4253 /* Run all of the selftests within this file. */
4258 test_symbol_table_test ();
4261 } // namespace selftest
4263 #endif /* CHECKING_P */
4265 #include "gt-cgraph.h"