1 /* Callgraph handling code.
2 Copyright (C) 2003-2020 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 /* This file contains basic routines manipulating call graph
23 The call-graph is a data structure designed for inter-procedural
24 optimization. It represents a multi-graph where nodes are functions
25 (symbols within symbol table) and edges are call sites. */
29 #include "coretypes.h"
36 #include "alloc-pool.h"
37 #include "gimple-ssa.h"
39 #include "lto-streamer.h"
40 #include "fold-const.h"
43 #include "print-tree.h"
44 #include "langhooks.h"
47 #include "gimple-iterator.h"
50 #include "value-prof.h"
51 #include "ipa-utils.h"
52 #include "symbol-summary.h"
55 #include "ipa-fnsummary.h"
57 #include "gimple-pretty-print.h"
62 #include "stringpool.h"
65 #include "tree-into-ssa.h"
67 /* FIXME: Only for PROP_loops, but cgraph shouldn't have to know about this. */
68 #include "tree-pass.h"
70 /* Queue of cgraph nodes scheduled to be lowered. */
71 symtab_node
*x_cgraph_nodes_queue
;
72 #define cgraph_nodes_queue ((cgraph_node *)x_cgraph_nodes_queue)
74 /* Symbol table global context. */
77 /* List of hooks triggered on cgraph_edge events. */
78 struct cgraph_edge_hook_list
{
79 cgraph_edge_hook hook
;
81 struct cgraph_edge_hook_list
*next
;
84 /* List of hooks triggered on cgraph_node events. */
85 struct cgraph_node_hook_list
{
86 cgraph_node_hook hook
;
88 struct cgraph_node_hook_list
*next
;
91 /* List of hooks triggered on events involving two cgraph_edges. */
92 struct cgraph_2edge_hook_list
{
93 cgraph_2edge_hook hook
;
95 struct cgraph_2edge_hook_list
*next
;
98 /* List of hooks triggered on events involving two cgraph_nodes. */
99 struct cgraph_2node_hook_list
{
100 cgraph_2node_hook hook
;
102 struct cgraph_2node_hook_list
*next
;
105 /* Hash descriptor for cgraph_function_version_info. */
107 struct function_version_hasher
: ggc_ptr_hash
<cgraph_function_version_info
>
109 static hashval_t
hash (cgraph_function_version_info
*);
110 static bool equal (cgraph_function_version_info
*,
111 cgraph_function_version_info
*);
114 /* Map a cgraph_node to cgraph_function_version_info using this htab.
115 The cgraph_function_version_info has a THIS_NODE field that is the
116 corresponding cgraph_node.. */
118 static GTY(()) hash_table
<function_version_hasher
> *cgraph_fnver_htab
= NULL
;
120 /* Hash function for cgraph_fnver_htab. */
122 function_version_hasher::hash (cgraph_function_version_info
*ptr
)
124 int uid
= ptr
->this_node
->get_uid ();
125 return (hashval_t
)(uid
);
128 /* eq function for cgraph_fnver_htab. */
130 function_version_hasher::equal (cgraph_function_version_info
*n1
,
131 cgraph_function_version_info
*n2
)
133 return n1
->this_node
->get_uid () == n2
->this_node
->get_uid ();
136 /* Mark as GC root all allocated nodes. */
137 static GTY(()) struct cgraph_function_version_info
*
138 version_info_node
= NULL
;
140 /* Return true if NODE's address can be compared. */
143 symtab_node::address_can_be_compared_p ()
145 /* Address of virtual tables and functions is never compared. */
146 if (DECL_VIRTUAL_P (decl
))
148 /* Address of C++ cdtors is never compared. */
149 if (is_a
<cgraph_node
*> (this)
150 && (DECL_CXX_CONSTRUCTOR_P (decl
)
151 || DECL_CXX_DESTRUCTOR_P (decl
)))
153 /* Constant pool symbols addresses are never compared.
154 flag_merge_constants permits us to assume the same on readonly vars. */
155 if (is_a
<varpool_node
*> (this)
156 && (DECL_IN_CONSTANT_POOL (decl
)
157 || (flag_merge_constants
>= 2
158 && TREE_READONLY (decl
) && !TREE_THIS_VOLATILE (decl
))))
163 /* Get the cgraph_function_version_info node corresponding to node. */
164 cgraph_function_version_info
*
165 cgraph_node::function_version (void)
167 cgraph_function_version_info key
;
168 key
.this_node
= this;
170 if (cgraph_fnver_htab
== NULL
)
173 return cgraph_fnver_htab
->find (&key
);
176 /* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
177 corresponding to cgraph_node NODE. */
178 cgraph_function_version_info
*
179 cgraph_node::insert_new_function_version (void)
181 version_info_node
= NULL
;
182 version_info_node
= ggc_cleared_alloc
<cgraph_function_version_info
> ();
183 version_info_node
->this_node
= this;
185 if (cgraph_fnver_htab
== NULL
)
186 cgraph_fnver_htab
= hash_table
<function_version_hasher
>::create_ggc (2);
188 *cgraph_fnver_htab
->find_slot (version_info_node
, INSERT
)
190 return version_info_node
;
193 /* Remove the cgraph_function_version_info node given by DECL_V. */
195 delete_function_version (cgraph_function_version_info
*decl_v
)
200 if (version_info_node
== decl_v
)
201 version_info_node
= NULL
;
203 if (decl_v
->prev
!= NULL
)
204 decl_v
->prev
->next
= decl_v
->next
;
206 if (decl_v
->next
!= NULL
)
207 decl_v
->next
->prev
= decl_v
->prev
;
209 if (cgraph_fnver_htab
!= NULL
)
210 cgraph_fnver_htab
->remove_elt (decl_v
);
213 /* Remove the cgraph_function_version_info and cgraph_node for DECL. This
214 DECL is a duplicate declaration. */
216 cgraph_node::delete_function_version_by_decl (tree decl
)
218 cgraph_node
*decl_node
= cgraph_node::get (decl
);
220 if (decl_node
== NULL
)
223 delete_function_version (decl_node
->function_version ());
225 decl_node
->remove ();
228 /* Record that DECL1 and DECL2 are semantically identical function
231 cgraph_node::record_function_versions (tree decl1
, tree decl2
)
233 cgraph_node
*decl1_node
= cgraph_node::get_create (decl1
);
234 cgraph_node
*decl2_node
= cgraph_node::get_create (decl2
);
235 cgraph_function_version_info
*decl1_v
= NULL
;
236 cgraph_function_version_info
*decl2_v
= NULL
;
237 cgraph_function_version_info
*before
;
238 cgraph_function_version_info
*after
;
240 gcc_assert (decl1_node
!= NULL
&& decl2_node
!= NULL
);
241 decl1_v
= decl1_node
->function_version ();
242 decl2_v
= decl2_node
->function_version ();
244 if (decl1_v
!= NULL
&& decl2_v
!= NULL
)
248 decl1_v
= decl1_node
->insert_new_function_version ();
251 decl2_v
= decl2_node
->insert_new_function_version ();
253 /* Chain decl2_v and decl1_v. All semantically identical versions
254 will be chained together. */
259 while (before
->next
!= NULL
)
260 before
= before
->next
;
262 while (after
->prev
!= NULL
)
265 before
->next
= after
;
266 after
->prev
= before
;
269 /* Initialize callgraph dump file. */
272 symbol_table::initialize (void)
275 dump_file
= dump_begin (TDI_cgraph
, NULL
);
277 if (!ipa_clones_dump_file
)
278 ipa_clones_dump_file
= dump_begin (TDI_clones
, NULL
);
281 /* Allocate new callgraph node and insert it into basic data structures. */
284 symbol_table::create_empty (void)
287 return new (ggc_alloc
<cgraph_node
> ()) cgraph_node (cgraph_max_uid
++);
290 /* Register HOOK to be called with DATA on each removed edge. */
291 cgraph_edge_hook_list
*
292 symbol_table::add_edge_removal_hook (cgraph_edge_hook hook
, void *data
)
294 cgraph_edge_hook_list
*entry
;
295 cgraph_edge_hook_list
**ptr
= &m_first_edge_removal_hook
;
297 entry
= (cgraph_edge_hook_list
*) xmalloc (sizeof (*entry
));
307 /* Remove ENTRY from the list of hooks called on removing edges. */
309 symbol_table::remove_edge_removal_hook (cgraph_edge_hook_list
*entry
)
311 cgraph_edge_hook_list
**ptr
= &m_first_edge_removal_hook
;
313 while (*ptr
!= entry
)
319 /* Call all edge removal hooks. */
321 symbol_table::call_edge_removal_hooks (cgraph_edge
*e
)
323 cgraph_edge_hook_list
*entry
= m_first_edge_removal_hook
;
326 entry
->hook (e
, entry
->data
);
331 /* Register HOOK to be called with DATA on each removed node. */
332 cgraph_node_hook_list
*
333 symbol_table::add_cgraph_removal_hook (cgraph_node_hook hook
, void *data
)
335 cgraph_node_hook_list
*entry
;
336 cgraph_node_hook_list
**ptr
= &m_first_cgraph_removal_hook
;
338 entry
= (cgraph_node_hook_list
*) xmalloc (sizeof (*entry
));
348 /* Remove ENTRY from the list of hooks called on removing nodes. */
350 symbol_table::remove_cgraph_removal_hook (cgraph_node_hook_list
*entry
)
352 cgraph_node_hook_list
**ptr
= &m_first_cgraph_removal_hook
;
354 while (*ptr
!= entry
)
360 /* Call all node removal hooks. */
362 symbol_table::call_cgraph_removal_hooks (cgraph_node
*node
)
364 cgraph_node_hook_list
*entry
= m_first_cgraph_removal_hook
;
367 entry
->hook (node
, entry
->data
);
372 /* Call all node removal hooks. */
374 symbol_table::call_cgraph_insertion_hooks (cgraph_node
*node
)
376 cgraph_node_hook_list
*entry
= m_first_cgraph_insertion_hook
;
379 entry
->hook (node
, entry
->data
);
385 /* Register HOOK to be called with DATA on each inserted node. */
386 cgraph_node_hook_list
*
387 symbol_table::add_cgraph_insertion_hook (cgraph_node_hook hook
, void *data
)
389 cgraph_node_hook_list
*entry
;
390 cgraph_node_hook_list
**ptr
= &m_first_cgraph_insertion_hook
;
392 entry
= (cgraph_node_hook_list
*) xmalloc (sizeof (*entry
));
402 /* Remove ENTRY from the list of hooks called on inserted nodes. */
404 symbol_table::remove_cgraph_insertion_hook (cgraph_node_hook_list
*entry
)
406 cgraph_node_hook_list
**ptr
= &m_first_cgraph_insertion_hook
;
408 while (*ptr
!= entry
)
414 /* Register HOOK to be called with DATA on each duplicated edge. */
415 cgraph_2edge_hook_list
*
416 symbol_table::add_edge_duplication_hook (cgraph_2edge_hook hook
, void *data
)
418 cgraph_2edge_hook_list
*entry
;
419 cgraph_2edge_hook_list
**ptr
= &m_first_edge_duplicated_hook
;
421 entry
= (cgraph_2edge_hook_list
*) xmalloc (sizeof (*entry
));
431 /* Remove ENTRY from the list of hooks called on duplicating edges. */
433 symbol_table::remove_edge_duplication_hook (cgraph_2edge_hook_list
*entry
)
435 cgraph_2edge_hook_list
**ptr
= &m_first_edge_duplicated_hook
;
437 while (*ptr
!= entry
)
443 /* Call all edge duplication hooks. */
445 symbol_table::call_edge_duplication_hooks (cgraph_edge
*cs1
, cgraph_edge
*cs2
)
447 cgraph_2edge_hook_list
*entry
= m_first_edge_duplicated_hook
;
450 entry
->hook (cs1
, cs2
, entry
->data
);
455 /* Register HOOK to be called with DATA on each duplicated node. */
456 cgraph_2node_hook_list
*
457 symbol_table::add_cgraph_duplication_hook (cgraph_2node_hook hook
, void *data
)
459 cgraph_2node_hook_list
*entry
;
460 cgraph_2node_hook_list
**ptr
= &m_first_cgraph_duplicated_hook
;
462 entry
= (cgraph_2node_hook_list
*) xmalloc (sizeof (*entry
));
472 /* Remove ENTRY from the list of hooks called on duplicating nodes. */
474 symbol_table::remove_cgraph_duplication_hook (cgraph_2node_hook_list
*entry
)
476 cgraph_2node_hook_list
**ptr
= &m_first_cgraph_duplicated_hook
;
478 while (*ptr
!= entry
)
484 /* Call all node duplication hooks. */
486 symbol_table::call_cgraph_duplication_hooks (cgraph_node
*node
,
489 cgraph_2node_hook_list
*entry
= m_first_cgraph_duplicated_hook
;
492 entry
->hook (node
, node2
, entry
->data
);
497 /* Return cgraph node assigned to DECL. Create new one when needed. */
500 cgraph_node::create (tree decl
)
502 cgraph_node
*node
= symtab
->create_empty ();
503 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
507 if ((flag_openacc
|| flag_openmp
)
508 && lookup_attribute ("omp declare target", DECL_ATTRIBUTES (decl
)))
510 node
->offloadable
= 1;
511 if (ENABLE_OFFLOADING
)
512 g
->have_offload
= true;
515 if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl
)))
516 node
->ifunc_resolver
= true;
518 node
->register_symbol ();
520 if (DECL_CONTEXT (decl
) && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
522 node
->origin
= cgraph_node::get_create (DECL_CONTEXT (decl
));
523 node
->next_nested
= node
->origin
->nested
;
524 node
->origin
->nested
= node
;
529 /* Try to find a call graph node for declaration DECL and if it does not exist
530 or if it corresponds to an inline clone, create a new one. */
533 cgraph_node::get_create (tree decl
)
535 cgraph_node
*first_clone
= cgraph_node::get (decl
);
537 if (first_clone
&& !first_clone
->inlined_to
)
540 cgraph_node
*node
= cgraph_node::create (decl
);
543 first_clone
->clone_of
= node
;
544 node
->clones
= first_clone
;
545 node
->order
= first_clone
->order
;
546 symtab
->symtab_prevail_in_asm_name_hash (node
);
547 node
->decl
->decl_with_vis
.symtab_node
= node
;
549 fprintf (dump_file
, "Introduced new external node "
550 "(%s) and turned into root of the clone tree.\n",
554 fprintf (dump_file
, "Introduced new external node "
555 "(%s).\n", node
->dump_name ());
559 /* Mark ALIAS as an alias to DECL. DECL_NODE is cgraph node representing
560 the function body is associated with (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);
634 node
->thunk
.fixed_offset
= fixed_offset
;
635 node
->thunk
.virtual_value
= virtual_value
;
636 node
->thunk
.indirect_offset
= indirect_offset
;
637 node
->thunk
.alias
= real_alias
;
638 node
->thunk
.this_adjusting
= this_adjusting
;
639 node
->thunk
.virtual_offset_p
= virtual_offset
!= NULL
;
640 node
->thunk
.thunk_p
= true;
641 node
->definition
= true;
646 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
647 Return NULL if there's no such node. */
650 cgraph_node::get_for_asmname (tree asmname
)
652 /* We do not want to look at inline clones. */
653 for (symtab_node
*node
= symtab_node::get_for_asmname (asmname
);
655 node
= node
->next_sharing_asm_name
)
657 cgraph_node
*cn
= dyn_cast
<cgraph_node
*> (node
);
658 if (cn
&& !cn
->inlined_to
)
664 /* Returns a hash value for X (which really is a cgraph_edge). */
667 cgraph_edge_hasher::hash (cgraph_edge
*e
)
669 /* This is a really poor hash function, but it is what htab_hash_pointer
671 return (hashval_t
) ((intptr_t)e
->call_stmt
>> 3);
674 /* Returns a hash value for X (which really is a cgraph_edge). */
677 cgraph_edge_hasher::hash (gimple
*call_stmt
)
679 /* This is a really poor hash function, but it is what htab_hash_pointer
681 return (hashval_t
) ((intptr_t)call_stmt
>> 3);
684 /* Return nonzero if the call_stmt of cgraph_edge X is stmt *Y. */
687 cgraph_edge_hasher::equal (cgraph_edge
*x
, gimple
*y
)
689 return x
->call_stmt
== y
;
692 /* Add call graph edge E to call site hash of its caller. */
695 cgraph_update_edge_in_call_site_hash (cgraph_edge
*e
)
697 gimple
*call
= e
->call_stmt
;
698 *e
->caller
->call_site_hash
->find_slot_with_hash
699 (call
, cgraph_edge_hasher::hash (call
), INSERT
) = e
;
702 /* Add call graph edge E to call site hash of its caller. */
705 cgraph_add_edge_to_call_site_hash (cgraph_edge
*e
)
707 /* There are two speculative edges for every statement (one direct,
708 one indirect); always hash the direct one. */
709 if (e
->speculative
&& e
->indirect_unknown_callee
)
711 cgraph_edge
**slot
= e
->caller
->call_site_hash
->find_slot_with_hash
712 (e
->call_stmt
, cgraph_edge_hasher::hash (e
->call_stmt
), INSERT
);
715 gcc_assert (((cgraph_edge
*)*slot
)->speculative
);
720 gcc_assert (!*slot
|| e
->speculative
);
724 /* Return the callgraph edge representing the GIMPLE_CALL statement
728 cgraph_node::get_edge (gimple
*call_stmt
)
734 return call_site_hash
->find_with_hash
735 (call_stmt
, cgraph_edge_hasher::hash (call_stmt
));
737 /* This loop may turn out to be performance problem. In such case adding
738 hashtables into call nodes with very many edges is probably best
739 solution. It is not good idea to add pointer into CALL_EXPR itself
740 because we want to make possible having multiple cgraph nodes representing
741 different clones of the same body before the body is actually cloned. */
742 for (e
= callees
; e
; e
= e
->next_callee
)
744 if (e
->call_stmt
== call_stmt
)
750 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
752 if (e
->call_stmt
== call_stmt
)
759 call_site_hash
= hash_table
<cgraph_edge_hasher
>::create_ggc (120);
760 for (e2
= callees
; e2
; e2
= e2
->next_callee
)
761 cgraph_add_edge_to_call_site_hash (e2
);
762 for (e2
= indirect_calls
; e2
; e2
= e2
->next_callee
)
763 cgraph_add_edge_to_call_site_hash (e2
);
770 /* Change field call_stmt of edge to NEW_STMT.
771 If UPDATE_SPECULATIVE and E is any component of speculative
772 edge, then update all components. */
775 cgraph_edge::set_call_stmt (gcall
*new_stmt
, bool update_speculative
)
779 /* Speculative edges has three component, update all of them
781 if (update_speculative
&& speculative
)
783 cgraph_edge
*direct
, *indirect
;
786 speculative_call_info (direct
, indirect
, ref
);
787 direct
->set_call_stmt (new_stmt
, false);
788 indirect
->set_call_stmt (new_stmt
, false);
789 ref
->stmt
= new_stmt
;
793 /* Only direct speculative edges go to call_site_hash. */
794 if (caller
->call_site_hash
795 && (!speculative
|| !indirect_unknown_callee
))
797 caller
->call_site_hash
->remove_elt_with_hash
798 (call_stmt
, cgraph_edge_hasher::hash (call_stmt
));
801 cgraph_edge
*e
= this;
803 call_stmt
= new_stmt
;
804 if (indirect_unknown_callee
805 && (decl
= gimple_call_fndecl (new_stmt
)))
807 /* Constant propagation (and possibly also inlining?) can turn an
808 indirect call into a direct one. */
809 cgraph_node
*new_callee
= cgraph_node::get (decl
);
811 gcc_checking_assert (new_callee
);
812 e
= make_direct (new_callee
);
815 function
*fun
= DECL_STRUCT_FUNCTION (e
->caller
->decl
);
816 e
->can_throw_external
= stmt_can_throw_external (fun
, new_stmt
);
817 if (e
->caller
->call_site_hash
)
818 cgraph_add_edge_to_call_site_hash (e
);
821 /* Allocate a cgraph_edge structure and fill it with data according to the
822 parameters of which only CALLEE can be NULL (when creating an indirect call
823 edge). CLONING_P should be set if properties that are copied from an
824 original edge should not be calculated. */
827 symbol_table::create_edge (cgraph_node
*caller
, cgraph_node
*callee
,
828 gcall
*call_stmt
, profile_count count
,
829 bool indir_unknown_callee
, bool cloning_p
)
833 /* LTO does not actually have access to the call_stmt since these
834 have not been loaded yet. */
837 /* This is a rather expensive check possibly triggering
838 construction of call stmt hashtable. */
840 gcc_checking_assert (!(e
= caller
->get_edge (call_stmt
))
843 gcc_assert (is_gimple_call (call_stmt
));
846 edge
= ggc_alloc
<cgraph_edge
> ();
847 edge
->m_summary_id
= -1;
850 gcc_assert (++edges_max_uid
!= 0);
851 edge
->m_uid
= edges_max_uid
;
853 edge
->caller
= caller
;
854 edge
->callee
= callee
;
855 edge
->prev_caller
= NULL
;
856 edge
->next_caller
= NULL
;
857 edge
->prev_callee
= NULL
;
858 edge
->next_callee
= NULL
;
859 edge
->lto_stmt_uid
= 0;
862 edge
->call_stmt
= call_stmt
;
863 edge
->indirect_info
= NULL
;
864 edge
->indirect_inlining_edge
= 0;
865 edge
->speculative
= false;
866 edge
->indirect_unknown_callee
= indir_unknown_callee
;
867 if (call_stmt
&& caller
->call_site_hash
)
868 cgraph_add_edge_to_call_site_hash (edge
);
873 edge
->can_throw_external
874 = call_stmt
? stmt_can_throw_external (DECL_STRUCT_FUNCTION (caller
->decl
),
876 edge
->inline_failed
= CIF_FUNCTION_NOT_CONSIDERED
;
877 edge
->call_stmt_cannot_inline_p
= false;
879 if (opt_for_fn (edge
->caller
->decl
, flag_devirtualize
)
880 && call_stmt
&& DECL_STRUCT_FUNCTION (caller
->decl
))
881 edge
->in_polymorphic_cdtor
882 = decl_maybe_in_construction_p (NULL
, NULL
, call_stmt
,
885 edge
->in_polymorphic_cdtor
= caller
->thunk
.thunk_p
;
890 /* Create edge from a given function to CALLEE in the cgraph. CLONING_P should
891 be set if properties that are copied from an original edge should not be
895 cgraph_node::create_edge (cgraph_node
*callee
,
896 gcall
*call_stmt
, profile_count count
, bool cloning_p
)
898 cgraph_edge
*edge
= symtab
->create_edge (this, callee
, call_stmt
, count
,
902 initialize_inline_failed (edge
);
904 edge
->next_caller
= callee
->callers
;
906 callee
->callers
->prev_caller
= edge
;
907 edge
->next_callee
= callees
;
909 callees
->prev_callee
= edge
;
911 callee
->callers
= edge
;
916 /* Allocate cgraph_indirect_call_info and set its fields to default values. */
918 cgraph_indirect_call_info
*
919 cgraph_allocate_init_indirect_info (void)
921 cgraph_indirect_call_info
*ii
;
923 ii
= ggc_cleared_alloc
<cgraph_indirect_call_info
> ();
924 ii
->param_index
= -1;
928 /* Create an indirect edge with a yet-undetermined callee where the call
929 statement destination is a formal parameter of the caller with index
930 PARAM_INDEX. CLONING_P should be set if properties that are copied from an
931 original edge should not be calculated and indirect_info structure should
932 not be calculated. */
935 cgraph_node::create_indirect_edge (gcall
*call_stmt
, int ecf_flags
,
939 cgraph_edge
*edge
= symtab
->create_edge (this, NULL
, call_stmt
, count
, true,
944 initialize_inline_failed (edge
);
946 edge
->indirect_info
= cgraph_allocate_init_indirect_info ();
947 edge
->indirect_info
->ecf_flags
= ecf_flags
;
948 edge
->indirect_info
->vptr_changed
= true;
950 /* Record polymorphic call info. */
953 && (target
= gimple_call_fn (call_stmt
))
954 && virtual_method_call_p (target
))
956 ipa_polymorphic_call_context
context (decl
, target
, call_stmt
);
958 /* Only record types can have virtual calls. */
959 edge
->indirect_info
->polymorphic
= true;
960 edge
->indirect_info
->param_index
= -1;
961 edge
->indirect_info
->otr_token
962 = tree_to_uhwi (OBJ_TYPE_REF_TOKEN (target
));
963 edge
->indirect_info
->otr_type
= obj_type_ref_class (target
);
964 gcc_assert (TREE_CODE (edge
->indirect_info
->otr_type
) == RECORD_TYPE
);
965 edge
->indirect_info
->context
= context
;
968 edge
->next_callee
= indirect_calls
;
970 indirect_calls
->prev_callee
= edge
;
971 indirect_calls
= edge
;
976 /* Remove the edge from the list of the callees of the caller. */
979 cgraph_edge::remove_caller (void)
982 prev_callee
->next_callee
= next_callee
;
984 next_callee
->prev_callee
= prev_callee
;
987 if (indirect_unknown_callee
)
988 caller
->indirect_calls
= next_callee
;
990 caller
->callees
= next_callee
;
992 if (caller
->call_site_hash
)
993 caller
->call_site_hash
->remove_elt_with_hash
994 (call_stmt
, cgraph_edge_hasher::hash (call_stmt
));
997 /* Put the edge onto the free list. */
1000 symbol_table::free_edge (cgraph_edge
*e
)
1003 if (e
->m_summary_id
!= -1)
1004 edge_released_summary_ids
.safe_push (e
->m_summary_id
);
1006 if (e
->indirect_info
)
1007 ggc_free (e
->indirect_info
);
1011 /* Remove the edge in the cgraph. */
1014 cgraph_edge::remove (void)
1016 /* Call all edge removal hooks. */
1017 symtab
->call_edge_removal_hooks (this);
1019 if (!indirect_unknown_callee
)
1020 /* Remove from callers list of the callee. */
1023 /* Remove from callees list of the callers. */
1026 /* Put the edge onto the free list. */
1027 symtab
->free_edge (this);
1030 /* Turn edge into speculative call calling N2. Update
1031 the profile so the direct call is taken COUNT times
1034 At clone materialization time, the indirect call E will
1037 if (call_dest == N2)
1042 At this time the function just creates the direct call,
1043 the reference representing the if conditional and attaches
1044 them all to the original indirect call statement.
1046 Return direct edge created. */
1049 cgraph_edge::make_speculative (cgraph_node
*n2
, profile_count direct_count
)
1051 cgraph_node
*n
= caller
;
1052 ipa_ref
*ref
= NULL
;
1056 fprintf (dump_file
, "Indirect call -> speculative call %s => %s\n",
1057 n
->dump_name (), n2
->dump_name ());
1059 e2
= n
->create_edge (n2
, call_stmt
, direct_count
);
1060 initialize_inline_failed (e2
);
1061 e2
->speculative
= true;
1062 if (TREE_NOTHROW (n2
->decl
))
1063 e2
->can_throw_external
= false;
1065 e2
->can_throw_external
= can_throw_external
;
1066 e2
->lto_stmt_uid
= lto_stmt_uid
;
1067 e2
->in_polymorphic_cdtor
= in_polymorphic_cdtor
;
1069 symtab
->call_edge_duplication_hooks (this, e2
);
1070 ref
= n
->create_reference (n2
, IPA_REF_ADDR
, call_stmt
);
1071 ref
->lto_stmt_uid
= lto_stmt_uid
;
1072 ref
->speculative
= speculative
;
1073 n2
->mark_address_taken ();
1077 /* Speculative call consist of three components:
1078 1) an indirect edge representing the original call
1079 2) an direct edge representing the new call
1080 3) ADDR_EXPR reference representing the speculative check.
1081 All three components are attached to single statement (the indirect
1082 call) and if one of them exists, all of them must exist.
1084 Given speculative call edge, return all three components.
1088 cgraph_edge::speculative_call_info (cgraph_edge
*&direct
,
1089 cgraph_edge
*&indirect
,
1090 ipa_ref
*&reference
)
1095 cgraph_edge
*e
= this;
1097 if (!e
->indirect_unknown_callee
)
1098 for (e2
= e
->caller
->indirect_calls
;
1099 e2
->call_stmt
!= e
->call_stmt
|| e2
->lto_stmt_uid
!= e
->lto_stmt_uid
;
1100 e2
= e2
->next_callee
)
1105 /* We can take advantage of the call stmt hash. */
1108 e
= e
->caller
->get_edge (e2
->call_stmt
);
1109 gcc_assert (e
->speculative
&& !e
->indirect_unknown_callee
);
1112 for (e
= e
->caller
->callees
;
1113 e2
->call_stmt
!= e
->call_stmt
1114 || e2
->lto_stmt_uid
!= e
->lto_stmt_uid
;
1118 gcc_assert (e
->speculative
&& e2
->speculative
);
1123 for (i
= 0; e
->caller
->iterate_reference (i
, ref
); i
++)
1124 if (ref
->speculative
1125 && ((ref
->stmt
&& ref
->stmt
== e
->call_stmt
)
1126 || (!ref
->stmt
&& ref
->lto_stmt_uid
== e
->lto_stmt_uid
)))
1132 /* Speculative edge always consist of all three components - direct edge,
1133 indirect and reference. */
1135 gcc_assert (e
&& e2
&& ref
);
1138 /* Speculative call edge turned out to be direct call to CALLEE_DECL.
1139 Remove the speculative call sequence and return edge representing the call.
1140 It is up to caller to redirect the call as appropriate. */
1143 cgraph_edge::resolve_speculation (tree callee_decl
)
1145 cgraph_edge
*edge
= this;
1149 gcc_assert (edge
->speculative
);
1150 edge
->speculative_call_info (e2
, edge
, ref
);
1152 || !ref
->referred
->semantically_equivalent_p
1153 (symtab_node::get (callee_decl
)))
1159 fprintf (dump_file
, "Speculative indirect call %s => %s has "
1160 "turned out to have contradicting known target ",
1161 edge
->caller
->dump_name (),
1162 e2
->callee
->dump_name ());
1163 print_generic_expr (dump_file
, callee_decl
);
1164 fprintf (dump_file
, "\n");
1168 fprintf (dump_file
, "Removing speculative call %s => %s\n",
1169 edge
->caller
->dump_name (),
1170 e2
->callee
->dump_name ());
1176 cgraph_edge
*tmp
= edge
;
1178 fprintf (dump_file
, "Speculative call turned into direct call.\n");
1181 /* FIXME: If EDGE is inlined, we should scale up the frequencies and counts
1182 in the functions inlined through it. */
1184 edge
->count
+= e2
->count
;
1185 edge
->speculative
= false;
1186 e2
->speculative
= false;
1187 ref
->remove_reference ();
1188 if (e2
->indirect_unknown_callee
|| e2
->inline_failed
)
1191 e2
->callee
->remove_symbol_and_inline_clones ();
1192 if (edge
->caller
->call_site_hash
)
1193 cgraph_update_edge_in_call_site_hash (edge
);
1197 /* Make an indirect edge with an unknown callee an ordinary edge leading to
1198 CALLEE. DELTA is an integer constant that is to be added to the this
1199 pointer (first parameter) to compensate for skipping a thunk adjustment. */
1202 cgraph_edge::make_direct (cgraph_node
*callee
)
1204 cgraph_edge
*edge
= this;
1205 gcc_assert (indirect_unknown_callee
);
1207 /* If we are redirecting speculative call, make it non-speculative. */
1208 if (indirect_unknown_callee
&& speculative
)
1210 edge
= edge
->resolve_speculation (callee
->decl
);
1212 /* On successful speculation just return the pre existing direct edge. */
1213 if (!edge
->indirect_unknown_callee
)
1217 indirect_unknown_callee
= 0;
1218 ggc_free (indirect_info
);
1219 indirect_info
= NULL
;
1221 /* Get the edge out of the indirect edge list. */
1223 prev_callee
->next_callee
= next_callee
;
1225 next_callee
->prev_callee
= prev_callee
;
1227 caller
->indirect_calls
= next_callee
;
1229 /* Put it into the normal callee list */
1231 next_callee
= caller
->callees
;
1232 if (caller
->callees
)
1233 caller
->callees
->prev_callee
= edge
;
1234 caller
->callees
= edge
;
1236 /* Insert to callers list of the new callee. */
1237 edge
->set_callee (callee
);
1239 /* We need to re-determine the inlining status of the edge. */
1240 initialize_inline_failed (edge
);
1244 /* If necessary, change the function declaration in the call statement
1245 associated with E so that it corresponds to the edge callee. */
1248 cgraph_edge::redirect_call_stmt_to_callee (void)
1250 cgraph_edge
*e
= this;
1252 tree decl
= gimple_call_fndecl (e
->call_stmt
);
1254 gimple_stmt_iterator gsi
;
1262 e
->speculative_call_info (e
, e2
, ref
);
1263 /* If there already is an direct call (i.e. as a result of inliner's
1264 substitution), forget about speculating. */
1266 e
= e
->resolve_speculation (decl
);
1269 /* Expand speculation into GIMPLE code. */
1273 "Expanding speculative call of %s -> %s count: ",
1274 e
->caller
->dump_name (),
1275 e
->callee
->dump_name ());
1276 e
->count
.dump (dump_file
);
1277 fprintf (dump_file
, "\n");
1279 gcc_assert (e2
->speculative
);
1280 push_cfun (DECL_STRUCT_FUNCTION (e
->caller
->decl
));
1282 profile_probability prob
= e
->count
.probability_in (e
->count
1284 if (!prob
.initialized_p ())
1285 prob
= profile_probability::even ();
1286 new_stmt
= gimple_ic (e
->call_stmt
,
1287 dyn_cast
<cgraph_node
*> (ref
->referred
),
1289 e
->speculative
= false;
1290 e
->caller
->set_call_stmt_including_clones (e
->call_stmt
, new_stmt
,
1292 e
->count
= gimple_bb (e
->call_stmt
)->count
;
1293 e2
->speculative
= false;
1294 e2
->count
= gimple_bb (e2
->call_stmt
)->count
;
1295 ref
->speculative
= false;
1297 /* Indirect edges are not both in the call site hash.
1299 if (e
->caller
->call_site_hash
)
1300 cgraph_update_edge_in_call_site_hash (e2
);
1302 /* Continue redirecting E to proper target. */
1307 if (e
->indirect_unknown_callee
1308 || decl
== e
->callee
->decl
)
1309 return e
->call_stmt
;
1311 if (flag_checking
&& decl
)
1313 cgraph_node
*node
= cgraph_node::get (decl
);
1314 gcc_assert (!node
|| !node
->clone
.param_adjustments
);
1317 if (symtab
->dump_file
)
1319 fprintf (symtab
->dump_file
, "updating call of %s -> %s: ",
1320 e
->caller
->dump_name (), e
->callee
->dump_name ());
1321 print_gimple_stmt (symtab
->dump_file
, e
->call_stmt
, 0, dump_flags
);
1322 if (e
->callee
->clone
.param_adjustments
)
1323 e
->callee
->clone
.param_adjustments
->dump (symtab
->dump_file
);
1324 unsigned performed_len
1325 = vec_safe_length (e
->caller
->clone
.performed_splits
);
1326 if (performed_len
> 0)
1327 fprintf (symtab
->dump_file
, "Performed splits records:\n");
1328 for (unsigned i
= 0; i
< performed_len
; i
++)
1330 ipa_param_performed_split
*sm
1331 = &(*e
->caller
->clone
.performed_splits
)[i
];
1332 print_node_brief (symtab
->dump_file
, " dummy_decl: ", sm
->dummy_decl
,
1334 fprintf (symtab
->dump_file
, ", unit_offset: %u\n", sm
->unit_offset
);
1338 if (ipa_param_adjustments
*padjs
= e
->callee
->clone
.param_adjustments
)
1340 /* We need to defer cleaning EH info on the new statement to
1341 fixup-cfg. We may not have dominator information at this point
1342 and thus would end up with unreachable blocks and have no way
1343 to communicate that we need to run CFG cleanup then. */
1344 int lp_nr
= lookup_stmt_eh_lp (e
->call_stmt
);
1346 remove_stmt_from_eh_lp (e
->call_stmt
);
1348 tree old_fntype
= gimple_call_fntype (e
->call_stmt
);
1349 new_stmt
= padjs
->modify_call (e
->call_stmt
,
1350 e
->caller
->clone
.performed_splits
,
1351 e
->callee
->decl
, false);
1352 cgraph_node
*origin
= e
->callee
;
1353 while (origin
->clone_of
)
1354 origin
= origin
->clone_of
;
1356 if ((origin
->former_clone_of
1357 && old_fntype
== TREE_TYPE (origin
->former_clone_of
))
1358 || old_fntype
== TREE_TYPE (origin
->decl
))
1359 gimple_call_set_fntype (new_stmt
, TREE_TYPE (e
->callee
->decl
));
1362 tree new_fntype
= padjs
->build_new_function_type (old_fntype
, true);
1363 gimple_call_set_fntype (new_stmt
, new_fntype
);
1367 add_stmt_to_eh_lp (new_stmt
, lp_nr
);
1371 new_stmt
= e
->call_stmt
;
1372 gimple_call_set_fndecl (new_stmt
, e
->callee
->decl
);
1373 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), new_stmt
);
1376 /* If changing the call to __cxa_pure_virtual or similar noreturn function,
1377 adjust gimple_call_fntype too. */
1378 if (gimple_call_noreturn_p (new_stmt
)
1379 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (e
->callee
->decl
)))
1380 && TYPE_ARG_TYPES (TREE_TYPE (e
->callee
->decl
))
1381 && (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (e
->callee
->decl
)))
1383 gimple_call_set_fntype (new_stmt
, TREE_TYPE (e
->callee
->decl
));
1385 /* If the call becomes noreturn, remove the LHS if possible. */
1386 tree lhs
= gimple_call_lhs (new_stmt
);
1388 && gimple_call_noreturn_p (new_stmt
)
1389 && (VOID_TYPE_P (TREE_TYPE (gimple_call_fntype (new_stmt
)))
1390 || should_remove_lhs_p (lhs
)))
1392 if (TREE_CODE (lhs
) == SSA_NAME
)
1394 tree var
= create_tmp_reg_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
),
1395 TREE_TYPE (lhs
), NULL
);
1396 var
= get_or_create_ssa_default_def
1397 (DECL_STRUCT_FUNCTION (e
->caller
->decl
), var
);
1398 gimple
*set_stmt
= gimple_build_assign (lhs
, var
);
1399 gsi
= gsi_for_stmt (new_stmt
);
1400 gsi_insert_before_without_update (&gsi
, set_stmt
, GSI_SAME_STMT
);
1401 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), set_stmt
);
1403 gimple_call_set_lhs (new_stmt
, NULL_TREE
);
1404 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), new_stmt
);
1407 /* If new callee has no static chain, remove it. */
1408 if (gimple_call_chain (new_stmt
) && !DECL_STATIC_CHAIN (e
->callee
->decl
))
1410 gimple_call_set_chain (new_stmt
, NULL
);
1411 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), new_stmt
);
1414 maybe_remove_unused_call_args (DECL_STRUCT_FUNCTION (e
->caller
->decl
),
1417 e
->caller
->set_call_stmt_including_clones (e
->call_stmt
, new_stmt
, false);
1419 if (symtab
->dump_file
)
1421 fprintf (symtab
->dump_file
, " updated to:");
1422 print_gimple_stmt (symtab
->dump_file
, e
->call_stmt
, 0, dump_flags
);
1427 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1428 OLD_STMT changed into NEW_STMT. OLD_CALL is gimple_call_fndecl
1429 of OLD_STMT if it was previously call statement.
1430 If NEW_STMT is NULL, the call has been dropped without any
1434 cgraph_update_edges_for_call_stmt_node (cgraph_node
*node
,
1435 gimple
*old_stmt
, tree old_call
,
1438 tree new_call
= (new_stmt
&& is_gimple_call (new_stmt
))
1439 ? gimple_call_fndecl (new_stmt
) : 0;
1441 /* We are seeing indirect calls, then there is nothing to update. */
1442 if (!new_call
&& !old_call
)
1444 /* See if we turned indirect call into direct call or folded call to one builtin
1445 into different builtin. */
1446 if (old_call
!= new_call
)
1448 cgraph_edge
*e
= node
->get_edge (old_stmt
);
1449 cgraph_edge
*ne
= NULL
;
1450 profile_count count
;
1454 /* Keep calls marked as dead dead. */
1455 if (new_stmt
&& is_gimple_call (new_stmt
) && e
->callee
1456 && fndecl_built_in_p (e
->callee
->decl
, BUILT_IN_UNREACHABLE
))
1458 node
->get_edge (old_stmt
)->set_call_stmt
1459 (as_a
<gcall
*> (new_stmt
));
1462 /* See if the edge is already there and has the correct callee. It
1463 might be so because of indirect inlining has already updated
1464 it. We also might've cloned and redirected the edge. */
1465 if (new_call
&& e
->callee
)
1467 cgraph_node
*callee
= e
->callee
;
1470 if (callee
->decl
== new_call
1471 || callee
->former_clone_of
== new_call
)
1473 e
->set_call_stmt (as_a
<gcall
*> (new_stmt
));
1476 callee
= callee
->clone_of
;
1480 /* Otherwise remove edge and create new one; we can't simply redirect
1481 since function has changed, so inline plan and other information
1482 attached to edge is invalid. */
1484 if (e
->indirect_unknown_callee
|| e
->inline_failed
)
1487 e
->callee
->remove_symbol_and_inline_clones ();
1491 /* We are seeing new direct call; compute profile info based on BB. */
1492 basic_block bb
= gimple_bb (new_stmt
);
1498 ne
= node
->create_edge (cgraph_node::get_create (new_call
),
1499 as_a
<gcall
*> (new_stmt
), count
);
1500 gcc_assert (ne
->inline_failed
);
1503 /* We only updated the call stmt; update pointer in cgraph edge.. */
1504 else if (old_stmt
!= new_stmt
)
1505 node
->get_edge (old_stmt
)->set_call_stmt (as_a
<gcall
*> (new_stmt
));
1508 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1509 OLD_STMT changed into NEW_STMT. OLD_DECL is gimple_call_fndecl
1510 of OLD_STMT before it was updated (updating can happen inplace). */
1513 cgraph_update_edges_for_call_stmt (gimple
*old_stmt
, tree old_decl
,
1516 cgraph_node
*orig
= cgraph_node::get (cfun
->decl
);
1519 gcc_checking_assert (orig
);
1520 cgraph_update_edges_for_call_stmt_node (orig
, old_stmt
, old_decl
, new_stmt
);
1522 for (node
= orig
->clones
; node
!= orig
;)
1524 cgraph_update_edges_for_call_stmt_node (node
, old_stmt
, old_decl
, new_stmt
);
1526 node
= node
->clones
;
1527 else if (node
->next_sibling_clone
)
1528 node
= node
->next_sibling_clone
;
1531 while (node
!= orig
&& !node
->next_sibling_clone
)
1532 node
= node
->clone_of
;
1534 node
= node
->next_sibling_clone
;
1540 /* Remove all callees from the node. */
1543 cgraph_node::remove_callees (void)
1547 /* It is sufficient to remove the edges from the lists of callers of
1548 the callees. The callee list of the node can be zapped with one
1550 for (e
= callees
; e
; e
= f
)
1553 symtab
->call_edge_removal_hooks (e
);
1554 if (!e
->indirect_unknown_callee
)
1555 e
->remove_callee ();
1556 symtab
->free_edge (e
);
1558 for (e
= indirect_calls
; e
; e
= f
)
1561 symtab
->call_edge_removal_hooks (e
);
1562 if (!e
->indirect_unknown_callee
)
1563 e
->remove_callee ();
1564 symtab
->free_edge (e
);
1566 indirect_calls
= NULL
;
1570 call_site_hash
->empty ();
1571 call_site_hash
= NULL
;
1575 /* Remove all callers from the node. */
1578 cgraph_node::remove_callers (void)
1582 /* It is sufficient to remove the edges from the lists of callees of
1583 the callers. The caller list of the node can be zapped with one
1585 for (e
= callers
; e
; e
= f
)
1588 symtab
->call_edge_removal_hooks (e
);
1589 e
->remove_caller ();
1590 symtab
->free_edge (e
);
1595 /* Helper function for cgraph_release_function_body and free_lang_data.
1596 It releases body from function DECL without having to inspect its
1597 possibly non-existent symtab node. */
1600 release_function_body (tree decl
)
1602 function
*fn
= DECL_STRUCT_FUNCTION (decl
);
1606 && loops_for_fn (fn
))
1608 fn
->curr_properties
&= ~PROP_loops
;
1609 loop_optimizer_finalize (fn
);
1613 delete_tree_ssa (fn
);
1618 gcc_assert (!dom_info_available_p (fn
, CDI_DOMINATORS
));
1619 gcc_assert (!dom_info_available_p (fn
, CDI_POST_DOMINATORS
));
1620 delete_tree_cfg_annotations (fn
);
1624 if (fn
->value_histograms
)
1625 free_histograms (fn
);
1626 gimple_set_body (decl
, NULL
);
1627 /* Struct function hangs a lot of data that would leak if we didn't
1628 removed all pointers to it. */
1630 DECL_STRUCT_FUNCTION (decl
) = NULL
;
1632 DECL_SAVED_TREE (decl
) = NULL
;
1635 /* Release memory used to represent body of function.
1636 Use this only for functions that are released before being translated to
1637 target code (i.e. RTL). Functions that are compiled to RTL and beyond
1638 are free'd in final.c via free_after_compilation().
1639 KEEP_ARGUMENTS are useful only if you want to rebuild body as thunk. */
1642 cgraph_node::release_body (bool keep_arguments
)
1644 ipa_transforms_to_apply
.release ();
1645 if (!used_as_abstract_origin
&& symtab
->state
!= PARSING
)
1647 DECL_RESULT (decl
) = NULL
;
1649 if (!keep_arguments
)
1650 DECL_ARGUMENTS (decl
) = NULL
;
1652 /* If the node is abstract and needed, then do not clear
1653 DECL_INITIAL of its associated function declaration because it's
1654 needed to emit debug info later. */
1655 if (!used_as_abstract_origin
&& DECL_INITIAL (decl
))
1656 DECL_INITIAL (decl
) = error_mark_node
;
1657 release_function_body (decl
);
1660 lto_free_function_in_decl_state_for_node (this);
1661 lto_file_data
= NULL
;
1665 /* Remove function from symbol table. */
1668 cgraph_node::remove (void)
1670 if (symtab
->ipa_clones_dump_file
&& symtab
->cloned_nodes
.contains (this))
1671 fprintf (symtab
->ipa_clones_dump_file
,
1672 "Callgraph removal;%s;%d;%s;%d;%d\n", asm_name (), order
,
1673 DECL_SOURCE_FILE (decl
), DECL_SOURCE_LINE (decl
),
1674 DECL_SOURCE_COLUMN (decl
));
1676 symtab
->call_cgraph_removal_hooks (this);
1679 ipa_transforms_to_apply
.release ();
1680 delete_function_version (function_version ());
1682 /* Incremental inlining access removed nodes stored in the postorder list.
1684 force_output
= false;
1685 forced_by_abi
= false;
1687 for (cgraph_node
*n
= nested
; n
; n
= next
)
1689 next
= n
->next_nested
;
1691 n
->next_nested
= NULL
;
1696 cgraph_node
**node2
= &origin
->nested
;
1698 while (*node2
!= this)
1699 node2
= &(*node2
)->next_nested
;
1700 *node2
= next_nested
;
1703 if (prev_sibling_clone
)
1704 prev_sibling_clone
->next_sibling_clone
= next_sibling_clone
;
1706 clone_of
->clones
= next_sibling_clone
;
1707 if (next_sibling_clone
)
1708 next_sibling_clone
->prev_sibling_clone
= prev_sibling_clone
;
1711 cgraph_node
*n
, *next
;
1715 for (n
= clones
; n
->next_sibling_clone
; n
= n
->next_sibling_clone
)
1716 n
->clone_of
= clone_of
;
1717 n
->clone_of
= clone_of
;
1718 n
->next_sibling_clone
= clone_of
->clones
;
1719 if (clone_of
->clones
)
1720 clone_of
->clones
->prev_sibling_clone
= n
;
1721 clone_of
->clones
= clones
;
1725 /* We are removing node with clones. This makes clones inconsistent,
1726 but assume they will be removed subsequently and just keep clone
1727 tree intact. This can happen in unreachable function removal since
1728 we remove unreachable functions in random order, not by bottom-up
1729 walk of clone trees. */
1730 for (n
= clones
; n
; n
= next
)
1732 next
= n
->next_sibling_clone
;
1733 n
->next_sibling_clone
= NULL
;
1734 n
->prev_sibling_clone
= NULL
;
1740 /* While all the clones are removed after being proceeded, the function
1741 itself is kept in the cgraph even after it is compiled. Check whether
1742 we are done with this body and reclaim it proactively if this is the case.
1744 if (symtab
->state
!= LTO_STREAMING
)
1746 cgraph_node
*n
= cgraph_node::get (decl
);
1748 || (!n
->clones
&& !n
->clone_of
&& !n
->inlined_to
1749 && ((symtab
->global_info_ready
|| in_lto_p
)
1750 && (TREE_ASM_WRITTEN (n
->decl
)
1751 || DECL_EXTERNAL (n
->decl
)
1753 || (!flag_wpa
&& n
->in_other_partition
)))))
1758 lto_free_function_in_decl_state_for_node (this);
1759 lto_file_data
= NULL
;
1765 call_site_hash
->empty ();
1766 call_site_hash
= NULL
;
1769 symtab
->release_symbol (this);
1772 /* Likewise indicate that a node is having address taken. */
1775 cgraph_node::mark_address_taken (void)
1777 /* Indirect inlining can figure out that all uses of the address are
1781 gcc_assert (cfun
->after_inlining
);
1782 gcc_assert (callers
->indirect_inlining_edge
);
1785 /* FIXME: address_taken flag is used both as a shortcut for testing whether
1786 IPA_REF_ADDR reference exists (and thus it should be set on node
1787 representing alias we take address of) and as a test whether address
1788 of the object was taken (and thus it should be set on node alias is
1789 referring to). We should remove the first use and the remove the
1792 cgraph_node
*node
= ultimate_alias_target ();
1793 node
->address_taken
= 1;
1796 /* Return local info node for the compiled function. */
1799 cgraph_node::local_info_node (tree decl
)
1801 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1802 cgraph_node
*node
= get (decl
);
1805 return node
->ultimate_alias_target ();
1808 /* Return RTL info for the compiled function. */
1811 cgraph_node::rtl_info (const_tree decl
)
1813 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1814 cgraph_node
*node
= get (decl
);
1817 enum availability avail
;
1818 node
= node
->ultimate_alias_target (&avail
);
1819 if (decl
!= current_function_decl
1820 && (avail
< AVAIL_AVAILABLE
1821 || (node
->decl
!= current_function_decl
1822 && !TREE_ASM_WRITTEN (node
->decl
))))
1824 /* Allocate if it doesn't exist. */
1825 if (node
->rtl
== NULL
)
1827 node
->rtl
= ggc_cleared_alloc
<cgraph_rtl_info
> ();
1828 SET_HARD_REG_SET (node
->rtl
->function_used_regs
);
1833 /* Return a string describing the failure REASON. */
1836 cgraph_inline_failed_string (cgraph_inline_failed_t reason
)
1839 #define DEFCIFCODE(code, type, string) string,
1841 static const char *cif_string_table
[CIF_N_REASONS
] = {
1842 #include "cif-code.def"
1845 /* Signedness of an enum type is implementation defined, so cast it
1846 to unsigned before testing. */
1847 gcc_assert ((unsigned) reason
< CIF_N_REASONS
);
1848 return cif_string_table
[reason
];
1851 /* Return a type describing the failure REASON. */
1853 cgraph_inline_failed_type_t
1854 cgraph_inline_failed_type (cgraph_inline_failed_t reason
)
1857 #define DEFCIFCODE(code, type, string) type,
1859 static cgraph_inline_failed_type_t cif_type_table
[CIF_N_REASONS
] = {
1860 #include "cif-code.def"
1863 /* Signedness of an enum type is implementation defined, so cast it
1864 to unsigned before testing. */
1865 gcc_assert ((unsigned) reason
< CIF_N_REASONS
);
1866 return cif_type_table
[reason
];
1869 /* Names used to print out the availability enum. */
1870 const char * const cgraph_availability_names
[] =
1871 {"unset", "not_available", "overwritable", "available", "local"};
1873 /* Output flags of edge to a file F. */
1876 cgraph_edge::dump_edge_flags (FILE *f
)
1879 fprintf (f
, "(speculative) ");
1881 fprintf (f
, "(inlined) ");
1882 if (call_stmt_cannot_inline_p
)
1883 fprintf (f
, "(call_stmt_cannot_inline_p) ");
1884 if (indirect_inlining_edge
)
1885 fprintf (f
, "(indirect_inlining) ");
1886 if (count
.initialized_p ())
1891 fprintf (f
, "%.2f per call) ", sreal_frequency ().to_double ());
1893 if (can_throw_external
)
1894 fprintf (f
, "(can throw external) ");
1897 /* Dump call graph node to file F. */
1900 cgraph_node::dump (FILE *f
)
1907 fprintf (f
, " Function %s is inline copy in %s\n",
1909 inlined_to
->dump_name ());
1911 fprintf (f
, " Clone of %s\n", clone_of
->dump_asm_name ());
1912 if (symtab
->function_flags_ready
)
1913 fprintf (f
, " Availability: %s\n",
1914 cgraph_availability_names
[get_availability ()]);
1917 fprintf (f
, " Profile id: %i\n",
1920 fprintf (f
, " Unit id: %i\n",
1922 cgraph_function_version_info
*vi
= function_version ();
1925 fprintf (f
, " Version info: ");
1926 if (vi
->prev
!= NULL
)
1928 fprintf (f
, "prev: ");
1929 fprintf (f
, "%s ", vi
->prev
->this_node
->dump_asm_name ());
1931 if (vi
->next
!= NULL
)
1933 fprintf (f
, "next: ");
1934 fprintf (f
, "%s ", vi
->next
->this_node
->dump_asm_name ());
1936 if (vi
->dispatcher_resolver
!= NULL_TREE
)
1937 fprintf (f
, "dispatcher: %s",
1938 lang_hooks
.decl_printable_name (vi
->dispatcher_resolver
, 2));
1942 fprintf (f
, " Function flags:");
1943 if (count
.initialized_p ())
1945 fprintf (f
, " count:");
1948 if (tp_first_run
> 0)
1949 fprintf (f
, " first_run:%" PRId64
, (int64_t) tp_first_run
);
1951 fprintf (f
, " nested in:%s", origin
->asm_name ());
1952 if (gimple_has_body_p (decl
))
1953 fprintf (f
, " body");
1955 fprintf (f
, " process");
1957 fprintf (f
, " local");
1958 if (redefined_extern_inline
)
1959 fprintf (f
, " redefined_extern_inline");
1960 if (only_called_at_startup
)
1961 fprintf (f
, " only_called_at_startup");
1962 if (only_called_at_exit
)
1963 fprintf (f
, " only_called_at_exit");
1965 fprintf (f
, " tm_clone");
1966 if (calls_comdat_local
)
1967 fprintf (f
, " calls_comdat_local");
1969 fprintf (f
, " icf_merged");
1971 fprintf (f
, " merged_comdat");
1972 if (merged_extern_inline
)
1973 fprintf (f
, " merged_extern_inline");
1975 fprintf (f
, " split_part");
1976 if (indirect_call_target
)
1977 fprintf (f
, " indirect_call_target");
1979 fprintf (f
, " nonfreeing_fn");
1980 if (DECL_STATIC_CONSTRUCTOR (decl
))
1981 fprintf (f
," static_constructor (priority:%i)", get_init_priority ());
1982 if (DECL_STATIC_DESTRUCTOR (decl
))
1983 fprintf (f
," static_destructor (priority:%i)", get_fini_priority ());
1984 if (frequency
== NODE_FREQUENCY_HOT
)
1985 fprintf (f
, " hot");
1986 if (frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
)
1987 fprintf (f
, " unlikely_executed");
1988 if (frequency
== NODE_FREQUENCY_EXECUTED_ONCE
)
1989 fprintf (f
, " executed_once");
1990 if (opt_for_fn (decl
, optimize_size
))
1991 fprintf (f
, " optimize_size");
1992 if (parallelized_function
)
1993 fprintf (f
, " parallelized_function");
1994 if (DECL_IS_OPERATOR_NEW_P (decl
))
1995 fprintf (f
, " operator_new");
1996 if (DECL_IS_OPERATOR_DELETE_P (decl
))
1997 fprintf (f
, " operator_delete");
2004 fprintf (f
, " Thunk");
2006 fprintf (f
, " of %s (asm:%s)",
2007 lang_hooks
.decl_printable_name (thunk
.alias
, 2),
2008 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk
.alias
)));
2009 fprintf (f
, " fixed offset %i virtual value %i indirect_offset %i "
2010 "has virtual offset %i\n",
2011 (int)thunk
.fixed_offset
,
2012 (int)thunk
.virtual_value
,
2013 (int)thunk
.indirect_offset
,
2014 (int)thunk
.virtual_offset_p
);
2016 else if (former_thunk_p ())
2017 fprintf (f
, " Former thunk fixed offset %i virtual value %i "
2018 "indirect_offset %i has virtual offset %i\n",
2019 (int)thunk
.fixed_offset
,
2020 (int)thunk
.virtual_value
,
2021 (int)thunk
.indirect_offset
,
2022 (int)thunk
.virtual_offset_p
);
2023 if (alias
&& thunk
.alias
2024 && DECL_P (thunk
.alias
))
2026 fprintf (f
, " Alias of %s",
2027 lang_hooks
.decl_printable_name (thunk
.alias
, 2));
2028 if (DECL_ASSEMBLER_NAME_SET_P (thunk
.alias
))
2029 fprintf (f
, " (asm:%s)",
2030 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk
.alias
)));
2034 fprintf (f
, " Called by: ");
2036 profile_count sum
= profile_count::zero ();
2037 for (edge
= callers
; edge
; edge
= edge
->next_caller
)
2039 fprintf (f
, "%s ", edge
->caller
->dump_asm_name ());
2040 edge
->dump_edge_flags (f
);
2041 if (edge
->count
.initialized_p ())
2042 sum
+= edge
->count
.ipa ();
2045 fprintf (f
, "\n Calls: ");
2046 for (edge
= callees
; edge
; edge
= edge
->next_callee
)
2048 fprintf (f
, "%s ", edge
->callee
->dump_asm_name ());
2049 edge
->dump_edge_flags (f
);
2053 if (count
.ipa ().initialized_p ())
2059 FOR_EACH_ALIAS (this, ref
)
2060 if (dyn_cast
<cgraph_node
*> (ref
->referring
)->count
.initialized_p ())
2061 sum
+= dyn_cast
<cgraph_node
*> (ref
->referring
)->count
.ipa ();
2064 || (symtab
->state
< EXPANSION
2065 && ultimate_alias_target () == this && only_called_directly_p ()))
2066 ok
= !count
.ipa ().differs_from_p (sum
);
2067 else if (count
.ipa () > profile_count::from_gcov_type (100)
2068 && count
.ipa () < sum
.apply_scale (99, 100))
2069 ok
= false, min
= true;
2072 fprintf (f
, " Invalid sum of caller counts ");
2075 fprintf (f
, ", should be at most ");
2077 fprintf (f
, ", should be ");
2078 count
.ipa ().dump (f
);
2083 for (edge
= indirect_calls
; edge
; edge
= edge
->next_callee
)
2085 if (edge
->indirect_info
->polymorphic
)
2087 fprintf (f
, " Polymorphic indirect call of type ");
2088 print_generic_expr (f
, edge
->indirect_info
->otr_type
, TDF_SLIM
);
2089 fprintf (f
, " token:%i", (int) edge
->indirect_info
->otr_token
);
2092 fprintf (f
, " Indirect call");
2093 edge
->dump_edge_flags (f
);
2094 if (edge
->indirect_info
->param_index
!= -1)
2096 fprintf (f
, " of param:%i", edge
->indirect_info
->param_index
);
2097 if (edge
->indirect_info
->agg_contents
)
2098 fprintf (f
, " loaded from %s %s at offset %i",
2099 edge
->indirect_info
->member_ptr
? "member ptr" : "aggregate",
2100 edge
->indirect_info
->by_ref
? "passed by reference":"",
2101 (int)edge
->indirect_info
->offset
);
2102 if (edge
->indirect_info
->vptr_changed
)
2103 fprintf (f
, " (vptr maybe changed)");
2106 if (edge
->indirect_info
->polymorphic
)
2107 edge
->indirect_info
->context
.dump (f
);
2111 /* Dump call graph node to file F in graphviz format. */
2114 cgraph_node::dump_graphviz (FILE *f
)
2118 for (edge
= callees
; edge
; edge
= edge
->next_callee
)
2120 cgraph_node
*callee
= edge
->callee
;
2122 fprintf (f
, "\t\"%s\" -> \"%s\"\n", dump_name (), callee
->dump_name ());
2127 /* Dump call graph node NODE to stderr. */
2130 cgraph_node::debug (void)
2135 /* Dump the callgraph to file F. */
2138 cgraph_node::dump_cgraph (FILE *f
)
2142 fprintf (f
, "callgraph:\n\n");
2143 FOR_EACH_FUNCTION (node
)
2147 /* Return true when the DECL can possibly be inlined. */
2150 cgraph_function_possibly_inlined_p (tree decl
)
2152 if (!symtab
->global_info_ready
)
2153 return !DECL_UNINLINABLE (decl
);
2154 return DECL_POSSIBLY_INLINED (decl
);
2157 /* cgraph_node is no longer nested function; update cgraph accordingly. */
2159 cgraph_node::unnest (void)
2161 cgraph_node
**node2
= &origin
->nested
;
2162 gcc_assert (origin
);
2164 while (*node2
!= this)
2165 node2
= &(*node2
)->next_nested
;
2166 *node2
= next_nested
;
2170 /* Return function availability. See cgraph.h for description of individual
2173 cgraph_node::get_availability (symtab_node
*ref
)
2177 cgraph_node
*cref
= dyn_cast
<cgraph_node
*> (ref
);
2179 ref
= cref
->inlined_to
;
2181 enum availability avail
;
2183 avail
= AVAIL_NOT_AVAILABLE
;
2185 avail
= AVAIL_LOCAL
;
2186 else if (inlined_to
)
2187 avail
= AVAIL_AVAILABLE
;
2188 else if (transparent_alias
)
2189 ultimate_alias_target (&avail
, ref
);
2190 else if (ifunc_resolver
2191 || lookup_attribute ("noipa", DECL_ATTRIBUTES (decl
)))
2192 avail
= AVAIL_INTERPOSABLE
;
2193 else if (!externally_visible
)
2194 avail
= AVAIL_AVAILABLE
;
2195 /* If this is a reference from symbol itself and there are no aliases, we
2196 may be sure that the symbol was not interposed by something else because
2197 the symbol itself would be unreachable otherwise.
2199 Also comdat groups are always resolved in groups. */
2200 else if ((this == ref
&& !has_aliases_p ())
2201 || (ref
&& get_comdat_group ()
2202 && get_comdat_group () == ref
->get_comdat_group ()))
2203 avail
= AVAIL_AVAILABLE
;
2204 /* Inline functions are safe to be analyzed even if their symbol can
2205 be overwritten at runtime. It is not meaningful to enforce any sane
2206 behavior on replacing inline function by different body. */
2207 else if (DECL_DECLARED_INLINE_P (decl
))
2208 avail
= AVAIL_AVAILABLE
;
2210 /* If the function can be overwritten, return OVERWRITABLE. Take
2211 care at least of two notable extensions - the COMDAT functions
2212 used to share template instantiations in C++ (this is symmetric
2213 to code cp_cannot_inline_tree_fn and probably shall be shared and
2214 the inlinability hooks completely eliminated). */
2216 else if (decl_replaceable_p (decl
) && !DECL_EXTERNAL (decl
))
2217 avail
= AVAIL_INTERPOSABLE
;
2218 else avail
= AVAIL_AVAILABLE
;
2223 /* Worker for cgraph_node_can_be_local_p. */
2225 cgraph_node_cannot_be_local_p_1 (cgraph_node
*node
, void *)
2227 return !(!node
->force_output
2228 && !node
->ifunc_resolver
2229 /* Limitation of gas requires us to output targets of symver aliases
2230 as global symbols. This is binutils PR 25295. */
2232 && ((DECL_COMDAT (node
->decl
)
2233 && !node
->forced_by_abi
2234 && !node
->used_from_object_file_p ()
2235 && !node
->same_comdat_group
)
2236 || !node
->externally_visible
));
2239 /* Return true if cgraph_node can be made local for API change.
2240 Extern inline functions and C++ COMDAT functions can be made local
2241 at the expense of possible code size growth if function is used in multiple
2242 compilation units. */
2244 cgraph_node::can_be_local_p (void)
2246 return (!address_taken
2247 && !call_for_symbol_thunks_and_aliases (cgraph_node_cannot_be_local_p_1
,
2251 /* Call callback on cgraph_node, thunks and aliases associated to cgraph_node.
2252 When INCLUDE_OVERWRITABLE is false, overwritable symbols are
2253 skipped. When EXCLUDE_VIRTUAL_THUNKS is true, virtual thunks are
2256 cgraph_node::call_for_symbol_thunks_and_aliases (bool (*callback
)
2257 (cgraph_node
*, void *),
2259 bool include_overwritable
,
2260 bool exclude_virtual_thunks
)
2264 enum availability avail
= AVAIL_AVAILABLE
;
2266 if (include_overwritable
2267 || (avail
= get_availability ()) > AVAIL_INTERPOSABLE
)
2269 if (callback (this, data
))
2272 FOR_EACH_ALIAS (this, ref
)
2274 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2275 if (include_overwritable
2276 || alias
->get_availability () > AVAIL_INTERPOSABLE
)
2277 if (alias
->call_for_symbol_thunks_and_aliases (callback
, data
,
2278 include_overwritable
,
2279 exclude_virtual_thunks
))
2282 if (avail
<= AVAIL_INTERPOSABLE
)
2284 for (e
= callers
; e
; e
= e
->next_caller
)
2285 if (e
->caller
->thunk
.thunk_p
2286 && (include_overwritable
2287 || e
->caller
->get_availability () > AVAIL_INTERPOSABLE
)
2288 && !(exclude_virtual_thunks
2289 && e
->caller
->thunk
.virtual_offset_p
))
2290 if (e
->caller
->call_for_symbol_thunks_and_aliases (callback
, data
,
2291 include_overwritable
,
2292 exclude_virtual_thunks
))
2298 /* Worker to bring NODE local. */
2301 cgraph_node::make_local (cgraph_node
*node
, void *)
2303 gcc_checking_assert (node
->can_be_local_p ());
2304 if (DECL_COMDAT (node
->decl
) || DECL_EXTERNAL (node
->decl
))
2306 node
->make_decl_local ();
2307 node
->set_section (NULL
);
2308 node
->set_comdat_group (NULL
);
2309 node
->externally_visible
= false;
2310 node
->forced_by_abi
= false;
2312 node
->set_section (NULL
);
2313 node
->unique_name
= ((node
->resolution
== LDPR_PREVAILING_DEF_IRONLY
2314 || node
->resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
)
2315 && !flag_incremental_link
);
2316 node
->resolution
= LDPR_PREVAILING_DEF_IRONLY
;
2317 gcc_assert (node
->get_availability () == AVAIL_LOCAL
);
2322 /* Bring cgraph node local. */
2325 cgraph_node::make_local (void)
2327 call_for_symbol_thunks_and_aliases (cgraph_node::make_local
, NULL
, true);
2330 /* Worker to set nothrow flag. */
2333 set_nothrow_flag_1 (cgraph_node
*node
, bool nothrow
, bool non_call
,
2338 if (nothrow
&& !TREE_NOTHROW (node
->decl
))
2340 /* With non-call exceptions we can't say for sure if other function body
2341 was not possibly optimized to still throw. */
2342 if (!non_call
|| node
->binds_to_current_def_p ())
2344 TREE_NOTHROW (node
->decl
) = true;
2346 for (e
= node
->callers
; e
; e
= e
->next_caller
)
2347 e
->can_throw_external
= false;
2350 else if (!nothrow
&& TREE_NOTHROW (node
->decl
))
2352 TREE_NOTHROW (node
->decl
) = false;
2356 FOR_EACH_ALIAS (node
, ref
)
2358 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2359 if (!nothrow
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2360 set_nothrow_flag_1 (alias
, nothrow
, non_call
, changed
);
2362 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
2363 if (e
->caller
->thunk
.thunk_p
2364 && (!nothrow
|| e
->caller
->get_availability () > AVAIL_INTERPOSABLE
))
2365 set_nothrow_flag_1 (e
->caller
, nothrow
, non_call
, changed
);
2368 /* Set TREE_NOTHROW on NODE's decl and on aliases of NODE
2369 if any to NOTHROW. */
2372 cgraph_node::set_nothrow_flag (bool nothrow
)
2374 bool changed
= false;
2375 bool non_call
= opt_for_fn (decl
, flag_non_call_exceptions
);
2377 if (!nothrow
|| get_availability () > AVAIL_INTERPOSABLE
)
2378 set_nothrow_flag_1 (this, nothrow
, non_call
, &changed
);
2383 FOR_EACH_ALIAS (this, ref
)
2385 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2386 if (!nothrow
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2387 set_nothrow_flag_1 (alias
, nothrow
, non_call
, &changed
);
2393 /* Worker to set malloc flag. */
2395 set_malloc_flag_1 (cgraph_node
*node
, bool malloc_p
, bool *changed
)
2397 if (malloc_p
&& !DECL_IS_MALLOC (node
->decl
))
2399 DECL_IS_MALLOC (node
->decl
) = true;
2404 FOR_EACH_ALIAS (node
, ref
)
2406 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2407 if (!malloc_p
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2408 set_malloc_flag_1 (alias
, malloc_p
, changed
);
2411 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
2412 if (e
->caller
->thunk
.thunk_p
2413 && (!malloc_p
|| e
->caller
->get_availability () > AVAIL_INTERPOSABLE
))
2414 set_malloc_flag_1 (e
->caller
, malloc_p
, changed
);
2417 /* Set DECL_IS_MALLOC on NODE's decl and on NODE's aliases if any. */
2420 cgraph_node::set_malloc_flag (bool malloc_p
)
2422 bool changed
= false;
2424 if (!malloc_p
|| get_availability () > AVAIL_INTERPOSABLE
)
2425 set_malloc_flag_1 (this, malloc_p
, &changed
);
2430 FOR_EACH_ALIAS (this, ref
)
2432 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2433 if (!malloc_p
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2434 set_malloc_flag_1 (alias
, malloc_p
, &changed
);
2440 /* Worker to set_const_flag. */
2443 set_const_flag_1 (cgraph_node
*node
, bool set_const
, bool looping
,
2446 /* Static constructors and destructors without a side effect can be
2448 if (set_const
&& !looping
)
2450 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
2452 DECL_STATIC_CONSTRUCTOR (node
->decl
) = 0;
2455 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
2457 DECL_STATIC_DESTRUCTOR (node
->decl
) = 0;
2463 if (TREE_READONLY (node
->decl
))
2465 TREE_READONLY (node
->decl
) = 0;
2466 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2472 /* Consider function:
2479 During early optimization we will turn this into:
2486 Now if this function will be detected as CONST however when interposed
2487 it may end up being just pure. We always must assume the worst
2489 if (TREE_READONLY (node
->decl
))
2491 if (!looping
&& DECL_LOOPING_CONST_OR_PURE_P (node
->decl
))
2493 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2497 else if (node
->binds_to_current_def_p ())
2499 TREE_READONLY (node
->decl
) = true;
2500 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = looping
;
2501 DECL_PURE_P (node
->decl
) = false;
2506 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2507 fprintf (dump_file
, "Dropping state to PURE because function does "
2508 "not bind to current def.\n");
2509 if (!DECL_PURE_P (node
->decl
))
2511 DECL_PURE_P (node
->decl
) = true;
2512 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = looping
;
2515 else if (!looping
&& DECL_LOOPING_CONST_OR_PURE_P (node
->decl
))
2517 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2524 FOR_EACH_ALIAS (node
, ref
)
2526 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2527 if (!set_const
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2528 set_const_flag_1 (alias
, set_const
, looping
, changed
);
2530 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
2531 if (e
->caller
->thunk
.thunk_p
2532 && (!set_const
|| e
->caller
->get_availability () > AVAIL_INTERPOSABLE
))
2534 /* Virtual thunks access virtual offset in the vtable, so they can
2535 only be pure, never const. */
2537 && (e
->caller
->thunk
.virtual_offset_p
2538 || !node
->binds_to_current_def_p (e
->caller
)))
2539 *changed
|= e
->caller
->set_pure_flag (true, looping
);
2541 set_const_flag_1 (e
->caller
, set_const
, looping
, changed
);
2545 /* If SET_CONST is true, mark function, aliases and thunks to be ECF_CONST.
2546 If SET_CONST if false, clear the flag.
2548 When setting the flag be careful about possible interposition and
2549 do not set the flag for functions that can be interposed and set pure
2550 flag for functions that can bind to other definition.
2552 Return true if any change was done. */
2555 cgraph_node::set_const_flag (bool set_const
, bool looping
)
2557 bool changed
= false;
2558 if (!set_const
|| get_availability () > AVAIL_INTERPOSABLE
)
2559 set_const_flag_1 (this, set_const
, looping
, &changed
);
2564 FOR_EACH_ALIAS (this, ref
)
2566 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2567 if (!set_const
|| alias
->get_availability () > AVAIL_INTERPOSABLE
)
2568 set_const_flag_1 (alias
, set_const
, looping
, &changed
);
2574 /* Info used by set_pure_flag_1. */
2576 struct set_pure_flag_info
2583 /* Worker to set_pure_flag. */
2586 set_pure_flag_1 (cgraph_node
*node
, void *data
)
2588 struct set_pure_flag_info
*info
= (struct set_pure_flag_info
*)data
;
2589 /* Static constructors and destructors without a side effect can be
2591 if (info
->pure
&& !info
->looping
)
2593 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
2595 DECL_STATIC_CONSTRUCTOR (node
->decl
) = 0;
2596 info
->changed
= true;
2598 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
2600 DECL_STATIC_DESTRUCTOR (node
->decl
) = 0;
2601 info
->changed
= true;
2606 if (!DECL_PURE_P (node
->decl
) && !TREE_READONLY (node
->decl
))
2608 DECL_PURE_P (node
->decl
) = true;
2609 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = info
->looping
;
2610 info
->changed
= true;
2612 else if (DECL_LOOPING_CONST_OR_PURE_P (node
->decl
)
2615 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2616 info
->changed
= true;
2621 if (DECL_PURE_P (node
->decl
))
2623 DECL_PURE_P (node
->decl
) = false;
2624 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = false;
2625 info
->changed
= true;
2631 /* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node
2634 When setting the flag, be careful about possible interposition.
2635 Return true if any change was done. */
2638 cgraph_node::set_pure_flag (bool pure
, bool looping
)
2640 struct set_pure_flag_info info
= {pure
, looping
, false};
2641 call_for_symbol_thunks_and_aliases (set_pure_flag_1
, &info
, !pure
, true);
2642 return info
.changed
;
2645 /* Return true when cgraph_node cannot return or throw and thus
2646 it is safe to ignore its side effects for IPA analysis. */
2649 cgraph_node::cannot_return_p (void)
2651 int flags
= flags_from_decl_or_type (decl
);
2652 if (!opt_for_fn (decl
, flag_exceptions
))
2653 return (flags
& ECF_NORETURN
) != 0;
2655 return ((flags
& (ECF_NORETURN
| ECF_NOTHROW
))
2656 == (ECF_NORETURN
| ECF_NOTHROW
));
2659 /* Return true when call of edge cannot lead to return from caller
2660 and thus it is safe to ignore its side effects for IPA analysis
2661 when computing side effects of the caller.
2662 FIXME: We could actually mark all edges that have no reaching
2663 patch to the exit block or throw to get better results. */
2665 cgraph_edge::cannot_lead_to_return_p (void)
2667 if (caller
->cannot_return_p ())
2669 if (indirect_unknown_callee
)
2671 int flags
= indirect_info
->ecf_flags
;
2672 if (!opt_for_fn (caller
->decl
, flag_exceptions
))
2673 return (flags
& ECF_NORETURN
) != 0;
2675 return ((flags
& (ECF_NORETURN
| ECF_NOTHROW
))
2676 == (ECF_NORETURN
| ECF_NOTHROW
));
2679 return callee
->cannot_return_p ();
2682 /* Return true if the edge may be considered hot. */
2685 cgraph_edge::maybe_hot_p (void)
2687 if (!maybe_hot_count_p (NULL
, count
.ipa ()))
2689 if (caller
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
2691 && callee
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
))
2693 if (caller
->frequency
> NODE_FREQUENCY_UNLIKELY_EXECUTED
2695 && callee
->frequency
<= NODE_FREQUENCY_EXECUTED_ONCE
))
2697 if (opt_for_fn (caller
->decl
, optimize_size
))
2699 if (caller
->frequency
== NODE_FREQUENCY_HOT
)
2701 if (!count
.initialized_p ())
2703 cgraph_node
*where
= caller
->inlined_to
? caller
->inlined_to
: caller
;
2704 if (!where
->count
.initialized_p ())
2706 if (caller
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
)
2708 if (count
.apply_scale (2, 1) < where
->count
.apply_scale (3, 1))
2711 else if (count
.apply_scale (param_hot_bb_frequency_fraction
, 1)
2717 /* Worker for cgraph_can_remove_if_no_direct_calls_p. */
2720 nonremovable_p (cgraph_node
*node
, void *)
2722 return !node
->can_remove_if_no_direct_calls_and_refs_p ();
2725 /* Return true if whole comdat group can be removed if there are no direct
2729 cgraph_node::can_remove_if_no_direct_calls_p (bool will_inline
)
2731 struct ipa_ref
*ref
;
2733 /* For local symbols or non-comdat group it is the same as
2734 can_remove_if_no_direct_calls_p. */
2735 if (!externally_visible
|| !same_comdat_group
)
2737 if (DECL_EXTERNAL (decl
))
2741 return !call_for_symbol_and_aliases (nonremovable_p
, NULL
, true);
2744 if (will_inline
&& address_taken
)
2747 /* Otherwise check if we can remove the symbol itself and then verify
2748 that only uses of the comdat groups are direct call to THIS
2750 if (!can_remove_if_no_direct_calls_and_refs_p ())
2753 /* Check that all refs come from within the comdat group. */
2754 for (int i
= 0; iterate_referring (i
, ref
); i
++)
2755 if (ref
->referring
->get_comdat_group () != get_comdat_group ())
2758 struct cgraph_node
*target
= ultimate_alias_target ();
2759 for (cgraph_node
*next
= dyn_cast
<cgraph_node
*> (same_comdat_group
);
2760 next
!= this; next
= dyn_cast
<cgraph_node
*> (next
->same_comdat_group
))
2762 if (!externally_visible
)
2765 && !next
->can_remove_if_no_direct_calls_and_refs_p ())
2768 /* If we see different symbol than THIS, be sure to check calls. */
2769 if (next
->ultimate_alias_target () != target
)
2770 for (cgraph_edge
*e
= next
->callers
; e
; e
= e
->next_caller
)
2771 if (e
->caller
->get_comdat_group () != get_comdat_group ()
2775 /* If function is not being inlined, we care only about
2776 references outside of the comdat group. */
2778 for (int i
= 0; next
->iterate_referring (i
, ref
); i
++)
2779 if (ref
->referring
->get_comdat_group () != get_comdat_group ())
2785 /* Return true when function cgraph_node can be expected to be removed
2786 from program when direct calls in this compilation unit are removed.
2788 As a special case COMDAT functions are
2789 cgraph_can_remove_if_no_direct_calls_p while the are not
2790 cgraph_only_called_directly_p (it is possible they are called from other
2793 This function behaves as cgraph_only_called_directly_p because eliminating
2794 all uses of COMDAT function does not make it necessarily disappear from
2795 the program unless we are compiling whole program or we do LTO. In this
2796 case we know we win since dynamic linking will not really discard the
2797 linkonce section. */
2800 cgraph_node::will_be_removed_from_program_if_no_direct_calls_p
2803 gcc_assert (!inlined_to
);
2804 if (DECL_EXTERNAL (decl
))
2807 if (!in_lto_p
&& !flag_whole_program
)
2809 /* If the symbol is in comdat group, we need to verify that whole comdat
2810 group becomes unreachable. Technically we could skip references from
2811 within the group, too. */
2812 if (!only_called_directly_p ())
2814 if (same_comdat_group
&& externally_visible
)
2816 struct cgraph_node
*target
= ultimate_alias_target ();
2818 if (will_inline
&& address_taken
)
2820 for (cgraph_node
*next
= dyn_cast
<cgraph_node
*> (same_comdat_group
);
2822 next
= dyn_cast
<cgraph_node
*> (next
->same_comdat_group
))
2824 if (!externally_visible
)
2827 && !next
->only_called_directly_p ())
2830 /* If we see different symbol than THIS,
2831 be sure to check calls. */
2832 if (next
->ultimate_alias_target () != target
)
2833 for (cgraph_edge
*e
= next
->callers
; e
; e
= e
->next_caller
)
2834 if (e
->caller
->get_comdat_group () != get_comdat_group ()
2842 return can_remove_if_no_direct_calls_p (will_inline
);
2846 /* Worker for cgraph_only_called_directly_p. */
2849 cgraph_not_only_called_directly_p_1 (cgraph_node
*node
, void *)
2851 return !node
->only_called_directly_or_aliased_p ();
2854 /* Return true when function cgraph_node and all its aliases are only called
2856 i.e. it is not externally visible, address was not taken and
2857 it is not used in any other non-standard way. */
2860 cgraph_node::only_called_directly_p (void)
2862 gcc_assert (ultimate_alias_target () == this);
2863 return !call_for_symbol_and_aliases (cgraph_not_only_called_directly_p_1
,
2868 /* Collect all callers of NODE. Worker for collect_callers_of_node. */
2871 collect_callers_of_node_1 (cgraph_node
*node
, void *data
)
2873 vec
<cgraph_edge
*> *redirect_callers
= (vec
<cgraph_edge
*> *)data
;
2875 enum availability avail
;
2876 node
->ultimate_alias_target (&avail
);
2878 if (avail
> AVAIL_INTERPOSABLE
)
2879 for (cs
= node
->callers
; cs
!= NULL
; cs
= cs
->next_caller
)
2880 if (!cs
->indirect_inlining_edge
2881 && !cs
->caller
->thunk
.thunk_p
)
2882 redirect_callers
->safe_push (cs
);
2886 /* Collect all callers of cgraph_node and its aliases that are known to lead to
2887 cgraph_node (i.e. are not overwritable). */
2890 cgraph_node::collect_callers (void)
2892 vec
<cgraph_edge
*> redirect_callers
= vNULL
;
2893 call_for_symbol_thunks_and_aliases (collect_callers_of_node_1
,
2894 &redirect_callers
, false);
2895 return redirect_callers
;
2899 /* Return TRUE if NODE2 a clone of NODE or is equivalent to it. Return
2900 optimistically true if this cannot be determined. */
2903 clone_of_p (cgraph_node
*node
, cgraph_node
*node2
)
2905 node
= node
->ultimate_alias_target ();
2906 node2
= node2
->ultimate_alias_target ();
2908 if (node2
->clone_of
== node
2909 || node2
->former_clone_of
== node
->decl
)
2912 if (!node
->thunk
.thunk_p
&& !node
->former_thunk_p ())
2914 while (node2
&& node
->decl
!= node2
->decl
)
2915 node2
= node2
->clone_of
;
2916 return node2
!= NULL
;
2919 /* There are no virtual clones of thunks so check former_clone_of or if we
2920 might have skipped thunks because this adjustments are no longer
2922 while (node
->thunk
.thunk_p
|| node
->former_thunk_p ())
2924 if (!node
->thunk
.this_adjusting
)
2926 /* In case of instrumented expanded thunks, which can have multiple calls
2927 in them, we do not know how to continue and just have to be
2929 if (node
->callees
->next_callee
)
2931 node
= node
->callees
->callee
->ultimate_alias_target ();
2933 if (!node2
->clone
.param_adjustments
2934 || node2
->clone
.param_adjustments
->first_param_intact_p ())
2936 if (node2
->former_clone_of
== node
->decl
)
2939 cgraph_node
*n2
= node2
;
2940 while (n2
&& node
->decl
!= n2
->decl
)
2949 /* Verify edge count and frequency. */
2952 cgraph_edge::verify_count ()
2954 bool error_found
= false;
2955 if (!count
.verify ())
2957 error ("caller edge count invalid");
2963 /* Switch to THIS_CFUN if needed and print STMT to stderr. */
2965 cgraph_debug_gimple_stmt (function
*this_cfun
, gimple
*stmt
)
2967 bool fndecl_was_null
= false;
2968 /* debug_gimple_stmt needs correct cfun */
2969 if (cfun
!= this_cfun
)
2970 set_cfun (this_cfun
);
2971 /* ...and an actual current_function_decl */
2972 if (!current_function_decl
)
2974 current_function_decl
= this_cfun
->decl
;
2975 fndecl_was_null
= true;
2977 debug_gimple_stmt (stmt
);
2978 if (fndecl_was_null
)
2979 current_function_decl
= NULL
;
2982 /* Verify that call graph edge corresponds to DECL from the associated
2983 statement. Return true if the verification should fail. */
2986 cgraph_edge::verify_corresponds_to_fndecl (tree decl
)
2990 if (!decl
|| callee
->inlined_to
)
2992 if (symtab
->state
== LTO_STREAMING
)
2994 node
= cgraph_node::get (decl
);
2996 /* We do not know if a node from a different partition is an alias or what it
2997 aliases and therefore cannot do the former_clone_of check reliably. When
2998 body_removed is set, we have lost all information about what was alias or
2999 thunk of and also cannot proceed. */
3001 || node
->body_removed
3002 || node
->in_other_partition
3003 || callee
->icf_merged
3004 || callee
->in_other_partition
)
3007 node
= node
->ultimate_alias_target ();
3009 /* Optimizers can redirect unreachable calls or calls triggering undefined
3010 behavior to builtin_unreachable. */
3012 if (fndecl_built_in_p (callee
->decl
, BUILT_IN_UNREACHABLE
))
3015 if (callee
->former_clone_of
!= node
->decl
3016 && (node
!= callee
->ultimate_alias_target ())
3017 && !clone_of_p (node
, callee
))
3023 /* Disable warnings about missing quoting in GCC diagnostics for
3024 the verification errors. Their format strings don't follow GCC
3025 diagnostic conventions and the calls are ultimately followed by
3026 one to internal_error. */
3028 # pragma GCC diagnostic push
3029 # pragma GCC diagnostic ignored "-Wformat-diag"
3032 /* Verify cgraph nodes of given cgraph node. */
3034 cgraph_node::verify_node (void)
3037 function
*this_cfun
= DECL_STRUCT_FUNCTION (decl
);
3038 basic_block this_block
;
3039 gimple_stmt_iterator gsi
;
3040 bool error_found
= false;
3045 timevar_push (TV_CGRAPH_VERIFY
);
3046 error_found
|= verify_base ();
3047 for (e
= callees
; e
; e
= e
->next_callee
)
3050 error ("aux field set for edge %s->%s",
3051 identifier_to_locale (e
->caller
->name ()),
3052 identifier_to_locale (e
->callee
->name ()));
3055 if (!count
.verify ())
3057 error ("cgraph count invalid");
3060 if (inlined_to
&& same_comdat_group
)
3062 error ("inline clone in same comdat group list");
3065 if (inlined_to
&& !count
.compatible_p (inlined_to
->count
))
3067 error ("inline clone count is not compatible");
3069 inlined_to
->count
.debug ();
3072 if (tp_first_run
< 0)
3074 error ("tp_first_run must be non-negative");
3077 if (!definition
&& !in_other_partition
&& local
)
3079 error ("local symbols must be defined");
3082 if (inlined_to
&& externally_visible
)
3084 error ("externally visible inline clone");
3087 if (inlined_to
&& address_taken
)
3089 error ("inline clone with address taken");
3092 if (inlined_to
&& force_output
)
3094 error ("inline clone is forced to output");
3097 if (calls_comdat_local
&& !same_comdat_group
)
3099 error ("calls_comdat_local is set outside of a comdat group");
3102 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
3106 error ("aux field set for indirect edge from %s",
3107 identifier_to_locale (e
->caller
->name ()));
3110 if (!e
->count
.compatible_p (count
))
3112 error ("edge count is not compatible with function count");
3117 if (!e
->indirect_unknown_callee
3118 || !e
->indirect_info
)
3120 error ("An indirect edge from %s is not marked as indirect or has "
3121 "associated indirect_info, the corresponding statement is: ",
3122 identifier_to_locale (e
->caller
->name ()));
3123 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3127 bool check_comdat
= comdat_local_p ();
3128 for (e
= callers
; e
; e
= e
->next_caller
)
3130 if (e
->verify_count ())
3133 && !in_same_comdat_group_p (e
->caller
))
3135 error ("comdat-local function called by %s outside its comdat",
3136 identifier_to_locale (e
->caller
->name ()));
3139 if (!e
->inline_failed
)
3142 != (e
->caller
->inlined_to
3143 ? e
->caller
->inlined_to
: e
->caller
))
3145 error ("inlined_to pointer is wrong");
3148 if (callers
->next_caller
)
3150 error ("multiple inline callers");
3157 error ("inlined_to pointer set for noninline callers");
3161 for (e
= callees
; e
; e
= e
->next_callee
)
3163 if (e
->verify_count ())
3165 if (!e
->count
.compatible_p (count
))
3167 error ("edge count is not compatible with function count");
3172 if (gimple_has_body_p (e
->caller
->decl
)
3173 && !e
->caller
->inlined_to
3175 /* Optimized out calls are redirected to __builtin_unreachable. */
3176 && (e
->count
.nonzero_p ()
3177 || ! e
->callee
->decl
3178 || !fndecl_built_in_p (e
->callee
->decl
, BUILT_IN_UNREACHABLE
))
3180 == ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (decl
))->count
3181 && (!e
->count
.ipa_p ()
3182 && e
->count
.differs_from_p (gimple_bb (e
->call_stmt
)->count
)))
3184 error ("caller edge count does not match BB count");
3185 fprintf (stderr
, "edge count: ");
3186 e
->count
.dump (stderr
);
3187 fprintf (stderr
, "\n bb count: ");
3188 gimple_bb (e
->call_stmt
)->count
.dump (stderr
);
3189 fprintf (stderr
, "\n");
3193 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
3195 if (e
->verify_count ())
3197 if (gimple_has_body_p (e
->caller
->decl
)
3198 && !e
->caller
->inlined_to
3200 && e
->count
.ipa_p ()
3202 == ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (decl
))->count
3203 && (!e
->count
.ipa_p ()
3204 && e
->count
.differs_from_p (gimple_bb (e
->call_stmt
)->count
)))
3206 error ("indirect call count does not match BB count");
3207 fprintf (stderr
, "edge count: ");
3208 e
->count
.dump (stderr
);
3209 fprintf (stderr
, "\n bb count: ");
3210 gimple_bb (e
->call_stmt
)->count
.dump (stderr
);
3211 fprintf (stderr
, "\n");
3215 if (!callers
&& inlined_to
)
3217 error ("inlined_to pointer is set but no predecessors found");
3220 if (inlined_to
== this)
3222 error ("inlined_to pointer refers to itself");
3228 cgraph_node
*first_clone
= clone_of
->clones
;
3229 if (first_clone
!= this)
3231 if (prev_sibling_clone
->clone_of
!= clone_of
)
3233 error ("cgraph_node has wrong clone_of");
3241 for (n
= clones
; n
; n
= n
->next_sibling_clone
)
3242 if (n
->clone_of
!= this)
3246 error ("cgraph_node has wrong clone list");
3250 if ((prev_sibling_clone
|| next_sibling_clone
) && !clone_of
)
3252 error ("cgraph_node is in clone list but it is not clone");
3255 if (!prev_sibling_clone
&& clone_of
&& clone_of
->clones
!= this)
3257 error ("cgraph_node has wrong prev_clone pointer");
3260 if (prev_sibling_clone
&& prev_sibling_clone
->next_sibling_clone
!= this)
3262 error ("double linked list of clones corrupted");
3266 if (analyzed
&& alias
)
3268 bool ref_found
= false;
3270 ipa_ref
*ref
= NULL
;
3274 error ("Alias has call edges");
3277 for (i
= 0; iterate_reference (i
, ref
); i
++)
3278 if (ref
->use
!= IPA_REF_ALIAS
)
3280 error ("Alias has non-alias reference");
3285 error ("Alias has more than one alias reference");
3292 error ("Analyzed alias has no reference");
3297 if (analyzed
&& thunk
.thunk_p
)
3301 error ("No edge out of thunk node");
3304 else if (callees
->next_callee
)
3306 error ("More than one edge out of thunk node");
3309 if (gimple_has_body_p (decl
) && !inlined_to
)
3311 error ("Thunk is not supposed to have body");
3315 else if (analyzed
&& gimple_has_body_p (decl
)
3316 && !TREE_ASM_WRITTEN (decl
)
3317 && (!DECL_EXTERNAL (decl
) || inlined_to
)
3322 hash_set
<gimple
*> stmts
;
3324 ipa_ref
*ref
= NULL
;
3326 /* Reach the trees by walking over the CFG, and note the
3327 enclosing basic-blocks in the call edges. */
3328 FOR_EACH_BB_FN (this_block
, this_cfun
)
3330 for (gsi
= gsi_start_phis (this_block
);
3331 !gsi_end_p (gsi
); gsi_next (&gsi
))
3332 stmts
.add (gsi_stmt (gsi
));
3333 for (gsi
= gsi_start_bb (this_block
);
3337 gimple
*stmt
= gsi_stmt (gsi
);
3339 if (is_gimple_call (stmt
))
3341 cgraph_edge
*e
= get_edge (stmt
);
3342 tree decl
= gimple_call_fndecl (stmt
);
3347 error ("shared call_stmt:");
3348 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
3351 if (!e
->indirect_unknown_callee
)
3353 if (e
->verify_corresponds_to_fndecl (decl
))
3355 error ("edge points to wrong declaration:");
3356 debug_tree (e
->callee
->decl
);
3357 fprintf (stderr
," Instead of:");
3364 error ("an indirect edge with unknown callee "
3365 "corresponding to a call_stmt with "
3366 "a known declaration:");
3368 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3374 error ("missing callgraph edge for call stmt:");
3375 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
3381 for (i
= 0; iterate_reference (i
, ref
); i
++)
3382 if (ref
->stmt
&& !stmts
.contains (ref
->stmt
))
3384 error ("reference to dead statement");
3385 cgraph_debug_gimple_stmt (this_cfun
, ref
->stmt
);
3390 /* No CFG available?! */
3393 for (e
= callees
; e
; e
= e
->next_callee
)
3397 error ("edge %s->%s has no corresponding call_stmt",
3398 identifier_to_locale (e
->caller
->name ()),
3399 identifier_to_locale (e
->callee
->name ()));
3400 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3405 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
3407 if (!e
->aux
&& !e
->speculative
)
3409 error ("an indirect edge from %s has no corresponding call_stmt",
3410 identifier_to_locale (e
->caller
->name ()));
3411 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3420 for (cgraph_node
*n
= nested
; n
!= NULL
; n
= n
->next_nested
)
3422 if (n
->origin
== NULL
)
3424 error ("missing origin for a node in a nested list");
3427 else if (n
->origin
!= this)
3429 error ("origin points to a different parent");
3435 if (next_nested
!= NULL
&& origin
== NULL
)
3437 error ("missing origin for a node in a nested list");
3444 internal_error ("verify_cgraph_node failed");
3446 timevar_pop (TV_CGRAPH_VERIFY
);
3449 /* Verify whole cgraph structure. */
3451 cgraph_node::verify_cgraph_nodes (void)
3458 FOR_EACH_FUNCTION (node
)
3463 # pragma GCC diagnostic pop
3466 /* Walk the alias chain to return the function cgraph_node is alias of.
3467 Walk through thunks, too.
3468 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3469 When REF is non-NULL, assume that reference happens in symbol REF
3470 when determining the availability. */
3473 cgraph_node::function_symbol (enum availability
*availability
,
3474 struct symtab_node
*ref
)
3476 cgraph_node
*node
= ultimate_alias_target (availability
, ref
);
3478 while (node
->thunk
.thunk_p
)
3481 node
= node
->callees
->callee
;
3484 enum availability a
;
3485 a
= node
->get_availability (ref
);
3486 if (a
< *availability
)
3489 node
= node
->ultimate_alias_target (availability
, ref
);
3494 /* Walk the alias chain to return the function cgraph_node is alias of.
3495 Walk through non virtual thunks, too. Thus we return either a function
3496 or a virtual thunk node.
3497 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3498 When REF is non-NULL, assume that reference happens in symbol REF
3499 when determining the availability. */
3502 cgraph_node::function_or_virtual_thunk_symbol
3503 (enum availability
*availability
,
3504 struct symtab_node
*ref
)
3506 cgraph_node
*node
= ultimate_alias_target (availability
, ref
);
3508 while (node
->thunk
.thunk_p
&& !node
->thunk
.virtual_offset_p
)
3511 node
= node
->callees
->callee
;
3514 enum availability a
;
3515 a
= node
->get_availability (ref
);
3516 if (a
< *availability
)
3519 node
= node
->ultimate_alias_target (availability
, ref
);
3524 /* When doing LTO, read cgraph_node's body from disk if it is not already
3528 cgraph_node::get_untransformed_body (void)
3530 lto_file_decl_data
*file_data
;
3531 const char *data
, *name
;
3533 tree decl
= this->decl
;
3535 /* Check if body is already there. Either we have gimple body or
3536 the function is thunk and in that case we set DECL_ARGUMENTS. */
3537 if (DECL_ARGUMENTS (decl
) || gimple_has_body_p (decl
))
3540 gcc_assert (in_lto_p
&& !DECL_RESULT (decl
));
3542 timevar_push (TV_IPA_LTO_GIMPLE_IN
);
3544 file_data
= lto_file_data
;
3545 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
3547 /* We may have renamed the declaration, e.g., a static function. */
3548 name
= lto_get_decl_name_mapping (file_data
, name
);
3549 struct lto_in_decl_state
*decl_state
3550 = lto_get_function_in_decl_state (file_data
, decl
);
3552 cgraph_node
*origin
= this;
3553 while (origin
->clone_of
)
3554 origin
= origin
->clone_of
;
3556 int stream_order
= origin
->order
- file_data
->order_base
;
3557 data
= lto_get_section_data (file_data
, LTO_section_function_body
,
3558 name
, stream_order
, &len
,
3559 decl_state
->compressed
);
3561 fatal_error (input_location
, "%s: section %s.%d is missing",
3562 file_data
->file_name
, name
, stream_order
);
3564 gcc_assert (DECL_STRUCT_FUNCTION (decl
) == NULL
);
3567 fprintf (stderr
, " in:%s", IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
3568 lto_input_function_body (file_data
, this, data
);
3569 lto_stats
.num_function_bodies
++;
3570 lto_free_section_data (file_data
, LTO_section_function_body
, name
,
3571 data
, len
, decl_state
->compressed
);
3572 lto_free_function_in_decl_state_for_node (this);
3573 /* Keep lto file data so ipa-inline-analysis knows about cross module
3576 timevar_pop (TV_IPA_LTO_GIMPLE_IN
);
3581 /* Prepare function body. When doing LTO, read cgraph_node's body from disk
3582 if it is not already present. When some IPA transformations are scheduled,
3586 cgraph_node::get_body (void)
3590 updated
= get_untransformed_body ();
3592 /* Getting transformed body makes no sense for inline clones;
3593 we should never use this on real clones because they are materialized
3595 TODO: Materializing clones here will likely lead to smaller LTRANS
3597 gcc_assert (!inlined_to
&& !clone_of
);
3598 if (ipa_transforms_to_apply
.exists ())
3600 opt_pass
*saved_current_pass
= current_pass
;
3601 FILE *saved_dump_file
= dump_file
;
3602 const char *saved_dump_file_name
= dump_file_name
;
3603 dump_flags_t saved_dump_flags
= dump_flags
;
3604 dump_file_name
= NULL
;
3605 set_dump_file (NULL
);
3607 push_cfun (DECL_STRUCT_FUNCTION (decl
));
3609 update_ssa (TODO_update_ssa_only_virtuals
);
3610 execute_all_ipa_transforms (true);
3611 cgraph_edge::rebuild_edges ();
3612 free_dominance_info (CDI_DOMINATORS
);
3613 free_dominance_info (CDI_POST_DOMINATORS
);
3617 current_pass
= saved_current_pass
;
3618 set_dump_file (saved_dump_file
);
3619 dump_file_name
= saved_dump_file_name
;
3620 dump_flags
= saved_dump_flags
;
3625 /* Return the DECL_STRUCT_FUNCTION of the function. */
3628 cgraph_node::get_fun () const
3630 const cgraph_node
*node
= this;
3631 struct function
*fun
= DECL_STRUCT_FUNCTION (node
->decl
);
3633 while (!fun
&& node
->clone_of
)
3635 node
= node
->clone_of
;
3636 fun
= DECL_STRUCT_FUNCTION (node
->decl
);
3642 /* Reset all state within cgraph.c so that we can rerun the compiler
3643 within the same process. For use by toplev::finalize. */
3646 cgraph_c_finalize (void)
3650 x_cgraph_nodes_queue
= NULL
;
3652 cgraph_fnver_htab
= NULL
;
3653 version_info_node
= NULL
;
3656 /* A worker for call_for_symbol_and_aliases. */
3659 cgraph_node::call_for_symbol_and_aliases_1 (bool (*callback
) (cgraph_node
*,
3662 bool include_overwritable
)
3665 FOR_EACH_ALIAS (this, ref
)
3667 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
3668 if (include_overwritable
3669 || alias
->get_availability () > AVAIL_INTERPOSABLE
)
3670 if (alias
->call_for_symbol_and_aliases (callback
, data
,
3671 include_overwritable
))
3677 /* Return true if NODE has thunk. */
3680 cgraph_node::has_thunk_p (cgraph_node
*node
, void *)
3682 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
3683 if (e
->caller
->thunk
.thunk_p
)
3688 /* Expected frequency of executions within the function. */
3691 cgraph_edge::sreal_frequency ()
3693 return count
.to_sreal_scale (caller
->inlined_to
3694 ? caller
->inlined_to
->count
3699 /* During LTO stream in this can be used to check whether call can possibly
3700 be internal to the current translation unit. */
3703 cgraph_edge::possibly_call_in_translation_unit_p (void)
3705 gcc_checking_assert (in_lto_p
&& caller
->prevailing_p ());
3707 /* While incremental linking we may end up getting function body later. */
3708 if (flag_incremental_link
== INCREMENTAL_LINK_LTO
)
3711 /* We may be smarter here and avoid streaming in indirect calls we can't
3712 track, but that would require arranging streaming the indirect call
3717 /* If callee is local to the original translation unit, it will be
3719 if (!TREE_PUBLIC (callee
->decl
) && !DECL_EXTERNAL (callee
->decl
))
3722 /* Otherwise we need to lookup prevailing symbol (symbol table is not merged,
3723 yet) and see if it is a definition. In fact we may also resolve aliases,
3724 but that is probably not too important. */
3725 symtab_node
*node
= callee
;
3726 for (int n
= 10; node
->previous_sharing_asm_name
&& n
; n
--)
3727 node
= node
->previous_sharing_asm_name
;
3728 if (node
->previous_sharing_asm_name
)
3729 node
= symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (callee
->decl
));
3730 gcc_assert (TREE_PUBLIC (node
->decl
));
3731 return node
->get_availability () >= AVAIL_INTERPOSABLE
;
3734 /* A stashed copy of "symtab" for use by selftest::symbol_table_test.
3735 This needs to be a global so that it can be a GC root, and thus
3736 prevent the stashed copy from being garbage-collected if the GC runs
3737 during a symbol_table_test. */
3739 symbol_table
*saved_symtab
;
3743 namespace selftest
{
3745 /* class selftest::symbol_table_test. */
3747 /* Constructor. Store the old value of symtab, and create a new one. */
3749 symbol_table_test::symbol_table_test ()
3751 gcc_assert (saved_symtab
== NULL
);
3752 saved_symtab
= symtab
;
3753 symtab
= new (ggc_alloc
<symbol_table
> ()) symbol_table ();
3756 /* Destructor. Restore the old value of symtab. */
3758 symbol_table_test::~symbol_table_test ()
3760 gcc_assert (saved_symtab
!= NULL
);
3761 symtab
= saved_symtab
;
3762 saved_symtab
= NULL
;
3765 /* Verify that symbol_table_test works. */
3768 test_symbol_table_test ()
3770 /* Simulate running two selftests involving symbol tables. */
3771 for (int i
= 0; i
< 2; i
++)
3773 symbol_table_test stt
;
3774 tree test_decl
= build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
,
3775 get_identifier ("test_decl"),
3776 build_function_type_list (void_type_node
,
3778 cgraph_node
*node
= cgraph_node::get_create (test_decl
);
3781 /* Verify that the node has order 0 on both iterations,
3782 and thus that nodes have predictable dump names in selftests. */
3783 ASSERT_EQ (node
->order
, 0);
3784 ASSERT_STREQ (node
->dump_name (), "test_decl/0");
3788 /* Run all of the selftests within this file. */
3793 test_symbol_table_test ();
3796 } // namespace selftest
3798 #endif /* CHECKING_P */
3800 #include "gt-cgraph.h"