1 /* Callgraph handling code.
2 Copyright (C) 2003-2015 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 intra-procedural optimization.
24 It represents a multi-graph where nodes are functions and edges are call sites. */
28 #include "coretypes.h"
33 #include "fold-const.h"
36 #include "print-tree.h"
37 #include "tree-inline.h"
38 #include "langhooks.h"
44 #include "dominance.h"
46 #include "basic-block.h"
47 #include "plugin-api.h"
48 #include "hard-reg-set.h"
53 #include "tree-ssa-alias.h"
54 #include "internal-fn.h"
56 #include "gimple-expr.h"
58 #include "gimple-iterator.h"
61 #include "gimple-ssa.h"
64 #include "value-prof.h"
66 #include "diagnostic-core.h"
68 #include "ipa-utils.h"
69 #include "lto-streamer.h"
70 #include "alloc-pool.h"
71 #include "symbol-summary.h"
73 #include "ipa-inline.h"
75 #include "gimple-pretty-print.h"
76 #include "insn-config.h"
86 #include "tree-chkp.h"
89 /* FIXME: Only for PROP_loops, but cgraph shouldn't have to know about this. */
90 #include "tree-pass.h"
92 /* Queue of cgraph nodes scheduled to be lowered. */
93 symtab_node
*x_cgraph_nodes_queue
;
94 #define cgraph_nodes_queue ((cgraph_node *)x_cgraph_nodes_queue)
96 /* Symbol table global context. */
99 /* List of hooks triggered on cgraph_edge events. */
100 struct cgraph_edge_hook_list
{
101 cgraph_edge_hook hook
;
103 struct cgraph_edge_hook_list
*next
;
106 /* List of hooks triggered on cgraph_node events. */
107 struct cgraph_node_hook_list
{
108 cgraph_node_hook hook
;
110 struct cgraph_node_hook_list
*next
;
113 /* List of hooks triggered on events involving two cgraph_edges. */
114 struct cgraph_2edge_hook_list
{
115 cgraph_2edge_hook hook
;
117 struct cgraph_2edge_hook_list
*next
;
120 /* List of hooks triggered on events involving two cgraph_nodes. */
121 struct cgraph_2node_hook_list
{
122 cgraph_2node_hook hook
;
124 struct cgraph_2node_hook_list
*next
;
127 /* Hash descriptor for cgraph_function_version_info. */
129 struct function_version_hasher
: ggc_hasher
<cgraph_function_version_info
*>
131 static hashval_t
hash (cgraph_function_version_info
*);
132 static bool equal (cgraph_function_version_info
*,
133 cgraph_function_version_info
*);
136 /* Map a cgraph_node to cgraph_function_version_info using this htab.
137 The cgraph_function_version_info has a THIS_NODE field that is the
138 corresponding cgraph_node.. */
140 static GTY(()) hash_table
<function_version_hasher
> *cgraph_fnver_htab
= NULL
;
142 /* Hash function for cgraph_fnver_htab. */
144 function_version_hasher::hash (cgraph_function_version_info
*ptr
)
146 int uid
= ptr
->this_node
->uid
;
147 return (hashval_t
)(uid
);
150 /* eq function for cgraph_fnver_htab. */
152 function_version_hasher::equal (cgraph_function_version_info
*n1
,
153 cgraph_function_version_info
*n2
)
155 return n1
->this_node
->uid
== n2
->this_node
->uid
;
158 /* Mark as GC root all allocated nodes. */
159 static GTY(()) struct cgraph_function_version_info
*
160 version_info_node
= NULL
;
162 /* Get the cgraph_function_version_info node corresponding to node. */
163 cgraph_function_version_info
*
164 cgraph_node::function_version (void)
166 cgraph_function_version_info key
;
167 key
.this_node
= this;
169 if (cgraph_fnver_htab
== NULL
)
172 return cgraph_fnver_htab
->find (&key
);
175 /* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
176 corresponding to cgraph_node NODE. */
177 cgraph_function_version_info
*
178 cgraph_node::insert_new_function_version (void)
180 version_info_node
= NULL
;
181 version_info_node
= ggc_cleared_alloc
<cgraph_function_version_info
> ();
182 version_info_node
->this_node
= this;
184 if (cgraph_fnver_htab
== NULL
)
185 cgraph_fnver_htab
= hash_table
<function_version_hasher
>::create_ggc (2);
187 *cgraph_fnver_htab
->find_slot (version_info_node
, INSERT
)
189 return version_info_node
;
192 /* Remove the cgraph_function_version_info and cgraph_node for DECL. This
193 DECL is a duplicate declaration. */
195 cgraph_node::delete_function_version (tree decl
)
197 cgraph_node
*decl_node
= cgraph_node::get (decl
);
198 cgraph_function_version_info
*decl_v
= NULL
;
200 if (decl_node
== NULL
)
203 decl_v
= decl_node
->function_version ();
208 if (decl_v
->prev
!= NULL
)
209 decl_v
->prev
->next
= decl_v
->next
;
211 if (decl_v
->next
!= NULL
)
212 decl_v
->next
->prev
= decl_v
->prev
;
214 if (cgraph_fnver_htab
!= NULL
)
215 cgraph_fnver_htab
->remove_elt (decl_v
);
217 decl_node
->remove ();
220 /* Record that DECL1 and DECL2 are semantically identical function
223 cgraph_node::record_function_versions (tree decl1
, tree decl2
)
225 cgraph_node
*decl1_node
= cgraph_node::get_create (decl1
);
226 cgraph_node
*decl2_node
= cgraph_node::get_create (decl2
);
227 cgraph_function_version_info
*decl1_v
= NULL
;
228 cgraph_function_version_info
*decl2_v
= NULL
;
229 cgraph_function_version_info
*before
;
230 cgraph_function_version_info
*after
;
232 gcc_assert (decl1_node
!= NULL
&& decl2_node
!= NULL
);
233 decl1_v
= decl1_node
->function_version ();
234 decl2_v
= decl2_node
->function_version ();
236 if (decl1_v
!= NULL
&& decl2_v
!= NULL
)
240 decl1_v
= decl1_node
->insert_new_function_version ();
243 decl2_v
= decl2_node
->insert_new_function_version ();
245 /* Chain decl2_v and decl1_v. All semantically identical versions
246 will be chained together. */
251 while (before
->next
!= NULL
)
252 before
= before
->next
;
254 while (after
->prev
!= NULL
)
257 before
->next
= after
;
258 after
->prev
= before
;
261 /* Initialize callgraph dump file. */
264 symbol_table::initialize (void)
267 dump_file
= dump_begin (TDI_cgraph
, NULL
);
270 /* Allocate new callgraph node and insert it into basic data structures. */
273 symbol_table::create_empty (void)
275 cgraph_node
*node
= allocate_cgraph_symbol ();
277 node
->type
= SYMTAB_FUNCTION
;
278 node
->frequency
= NODE_FREQUENCY_NORMAL
;
279 node
->count_materialization_scale
= REG_BR_PROB_BASE
;
285 /* Register HOOK to be called with DATA on each removed edge. */
286 cgraph_edge_hook_list
*
287 symbol_table::add_edge_removal_hook (cgraph_edge_hook hook
, void *data
)
289 cgraph_edge_hook_list
*entry
;
290 cgraph_edge_hook_list
**ptr
= &m_first_edge_removal_hook
;
292 entry
= (cgraph_edge_hook_list
*) xmalloc (sizeof (*entry
));
302 /* Remove ENTRY from the list of hooks called on removing edges. */
304 symbol_table::remove_edge_removal_hook (cgraph_edge_hook_list
*entry
)
306 cgraph_edge_hook_list
**ptr
= &m_first_edge_removal_hook
;
308 while (*ptr
!= entry
)
314 /* Call all edge removal hooks. */
316 symbol_table::call_edge_removal_hooks (cgraph_edge
*e
)
318 cgraph_edge_hook_list
*entry
= m_first_edge_removal_hook
;
321 entry
->hook (e
, entry
->data
);
326 /* Register HOOK to be called with DATA on each removed node. */
327 cgraph_node_hook_list
*
328 symbol_table::add_cgraph_removal_hook (cgraph_node_hook hook
, void *data
)
330 cgraph_node_hook_list
*entry
;
331 cgraph_node_hook_list
**ptr
= &m_first_cgraph_removal_hook
;
333 entry
= (cgraph_node_hook_list
*) xmalloc (sizeof (*entry
));
343 /* Remove ENTRY from the list of hooks called on removing nodes. */
345 symbol_table::remove_cgraph_removal_hook (cgraph_node_hook_list
*entry
)
347 cgraph_node_hook_list
**ptr
= &m_first_cgraph_removal_hook
;
349 while (*ptr
!= entry
)
355 /* Call all node removal hooks. */
357 symbol_table::call_cgraph_removal_hooks (cgraph_node
*node
)
359 cgraph_node_hook_list
*entry
= m_first_cgraph_removal_hook
;
362 entry
->hook (node
, entry
->data
);
367 /* Call all node removal hooks. */
369 symbol_table::call_cgraph_insertion_hooks (cgraph_node
*node
)
371 cgraph_node_hook_list
*entry
= m_first_cgraph_insertion_hook
;
374 entry
->hook (node
, entry
->data
);
380 /* Register HOOK to be called with DATA on each inserted node. */
381 cgraph_node_hook_list
*
382 symbol_table::add_cgraph_insertion_hook (cgraph_node_hook hook
, void *data
)
384 cgraph_node_hook_list
*entry
;
385 cgraph_node_hook_list
**ptr
= &m_first_cgraph_insertion_hook
;
387 entry
= (cgraph_node_hook_list
*) xmalloc (sizeof (*entry
));
397 /* Remove ENTRY from the list of hooks called on inserted nodes. */
399 symbol_table::remove_cgraph_insertion_hook (cgraph_node_hook_list
*entry
)
401 cgraph_node_hook_list
**ptr
= &m_first_cgraph_insertion_hook
;
403 while (*ptr
!= entry
)
409 /* Register HOOK to be called with DATA on each duplicated edge. */
410 cgraph_2edge_hook_list
*
411 symbol_table::add_edge_duplication_hook (cgraph_2edge_hook hook
, void *data
)
413 cgraph_2edge_hook_list
*entry
;
414 cgraph_2edge_hook_list
**ptr
= &m_first_edge_duplicated_hook
;
416 entry
= (cgraph_2edge_hook_list
*) xmalloc (sizeof (*entry
));
426 /* Remove ENTRY from the list of hooks called on duplicating edges. */
428 symbol_table::remove_edge_duplication_hook (cgraph_2edge_hook_list
*entry
)
430 cgraph_2edge_hook_list
**ptr
= &m_first_edge_duplicated_hook
;
432 while (*ptr
!= entry
)
438 /* Call all edge duplication hooks. */
440 symbol_table::call_edge_duplication_hooks (cgraph_edge
*cs1
, cgraph_edge
*cs2
)
442 cgraph_2edge_hook_list
*entry
= m_first_edge_duplicated_hook
;
445 entry
->hook (cs1
, cs2
, entry
->data
);
450 /* Register HOOK to be called with DATA on each duplicated node. */
451 cgraph_2node_hook_list
*
452 symbol_table::add_cgraph_duplication_hook (cgraph_2node_hook hook
, void *data
)
454 cgraph_2node_hook_list
*entry
;
455 cgraph_2node_hook_list
**ptr
= &m_first_cgraph_duplicated_hook
;
457 entry
= (cgraph_2node_hook_list
*) xmalloc (sizeof (*entry
));
467 /* Remove ENTRY from the list of hooks called on duplicating nodes. */
469 symbol_table::remove_cgraph_duplication_hook (cgraph_2node_hook_list
*entry
)
471 cgraph_2node_hook_list
**ptr
= &m_first_cgraph_duplicated_hook
;
473 while (*ptr
!= entry
)
479 /* Call all node duplication hooks. */
481 symbol_table::call_cgraph_duplication_hooks (cgraph_node
*node
,
484 cgraph_2node_hook_list
*entry
= m_first_cgraph_duplicated_hook
;
487 entry
->hook (node
, node2
, entry
->data
);
492 /* Return cgraph node assigned to DECL. Create new one when needed. */
495 cgraph_node::create (tree decl
)
497 cgraph_node
*node
= symtab
->create_empty ();
498 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
502 if ((flag_openacc
|| flag_openmp
)
503 && lookup_attribute ("omp declare target", DECL_ATTRIBUTES (decl
)))
505 node
->offloadable
= 1;
506 #ifdef ENABLE_OFFLOADING
507 g
->have_offload
= true;
511 node
->register_symbol ();
513 if (DECL_CONTEXT (decl
) && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
515 node
->origin
= cgraph_node::get_create (DECL_CONTEXT (decl
));
516 node
->next_nested
= node
->origin
->nested
;
517 node
->origin
->nested
= node
;
522 /* Try to find a call graph node for declaration DECL and if it does not exist
523 or if it corresponds to an inline clone, create a new one. */
526 cgraph_node::get_create (tree decl
)
528 cgraph_node
*first_clone
= cgraph_node::get (decl
);
530 if (first_clone
&& !first_clone
->global
.inlined_to
)
533 cgraph_node
*node
= cgraph_node::create (decl
);
536 first_clone
->clone_of
= node
;
537 node
->clones
= first_clone
;
538 symtab
->symtab_prevail_in_asm_name_hash (node
);
539 node
->decl
->decl_with_vis
.symtab_node
= node
;
541 fprintf (dump_file
, "Introduced new external node "
542 "(%s/%i) and turned into root of the clone tree.\n",
543 node
->name (), node
->order
);
546 fprintf (dump_file
, "Introduced new external node "
547 "(%s/%i).\n", node
->name (), node
->order
);
551 /* Mark ALIAS as an alias to DECL. DECL_NODE is cgraph node representing
552 the function body is associated with (not necessarily cgraph_node (DECL). */
555 cgraph_node::create_alias (tree alias
, tree target
)
557 cgraph_node
*alias_node
;
559 gcc_assert (TREE_CODE (target
) == FUNCTION_DECL
560 || TREE_CODE (target
) == IDENTIFIER_NODE
);
561 gcc_assert (TREE_CODE (alias
) == FUNCTION_DECL
);
562 alias_node
= cgraph_node::get_create (alias
);
563 gcc_assert (!alias_node
->definition
);
564 alias_node
->alias_target
= target
;
565 alias_node
->definition
= true;
566 alias_node
->alias
= true;
567 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (alias
)) != NULL
)
568 alias_node
->weakref
= true;
572 /* Attempt to mark ALIAS as an alias to DECL. Return alias node if successful
574 Same body aliases are output whenever the body of DECL is output,
575 and cgraph_node::get (ALIAS) transparently returns
576 cgraph_node::get (DECL). */
579 cgraph_node::create_same_body_alias (tree alias
, tree decl
)
582 #ifndef ASM_OUTPUT_DEF
583 /* If aliases aren't supported by the assembler, fail. */
586 /* Langhooks can create same body aliases of symbols not defined.
587 Those are useless. Drop them on the floor. */
588 if (symtab
->global_info_ready
)
591 n
= cgraph_node::create_alias (alias
, decl
);
592 n
->cpp_implicit_alias
= true;
593 if (symtab
->cpp_implicit_aliases_done
)
594 n
->resolve_alias (cgraph_node::get (decl
));
598 /* Add thunk alias into callgraph. The alias declaration is ALIAS and it
599 aliases DECL with an adjustments made into the first parameter.
600 See comments in thunk_adjust for detail on the parameters. */
603 cgraph_node::create_thunk (tree alias
, tree
, bool this_adjusting
,
604 HOST_WIDE_INT fixed_offset
,
605 HOST_WIDE_INT virtual_value
,
611 node
= cgraph_node::get (alias
);
615 node
= cgraph_node::create (alias
);
616 gcc_checking_assert (!virtual_offset
617 || wi::eq_p (virtual_offset
, virtual_value
));
618 node
->thunk
.fixed_offset
= fixed_offset
;
619 node
->thunk
.this_adjusting
= this_adjusting
;
620 node
->thunk
.virtual_value
= virtual_value
;
621 node
->thunk
.virtual_offset_p
= virtual_offset
!= NULL
;
622 node
->thunk
.alias
= real_alias
;
623 node
->thunk
.thunk_p
= true;
624 node
->definition
= true;
629 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
630 Return NULL if there's no such node. */
633 cgraph_node::get_for_asmname (tree asmname
)
635 /* We do not want to look at inline clones. */
636 for (symtab_node
*node
= symtab_node::get_for_asmname (asmname
);
638 node
= node
->next_sharing_asm_name
)
640 cgraph_node
*cn
= dyn_cast
<cgraph_node
*> (node
);
641 if (cn
&& !cn
->global
.inlined_to
)
647 /* Returns a hash value for X (which really is a cgraph_edge). */
650 cgraph_edge_hasher::hash (cgraph_edge
*e
)
652 /* This is a really poor hash function, but it is what htab_hash_pointer
654 return (hashval_t
) ((intptr_t)e
->call_stmt
>> 3);
657 /* Returns a hash value for X (which really is a cgraph_edge). */
660 cgraph_edge_hasher::hash (gimple call_stmt
)
662 /* This is a really poor hash function, but it is what htab_hash_pointer
664 return (hashval_t
) ((intptr_t)call_stmt
>> 3);
667 /* Return nonzero if the call_stmt of of cgraph_edge X is stmt *Y. */
670 cgraph_edge_hasher::equal (cgraph_edge
*x
, gimple y
)
672 return x
->call_stmt
== y
;
675 /* Add call graph edge E to call site hash of its caller. */
678 cgraph_update_edge_in_call_site_hash (cgraph_edge
*e
)
680 gimple call
= e
->call_stmt
;
681 *e
->caller
->call_site_hash
->find_slot_with_hash
682 (call
, cgraph_edge_hasher::hash (call
), INSERT
) = e
;
685 /* Add call graph edge E to call site hash of its caller. */
688 cgraph_add_edge_to_call_site_hash (cgraph_edge
*e
)
690 /* There are two speculative edges for every statement (one direct,
691 one indirect); always hash the direct one. */
692 if (e
->speculative
&& e
->indirect_unknown_callee
)
694 cgraph_edge
**slot
= e
->caller
->call_site_hash
->find_slot_with_hash
695 (e
->call_stmt
, cgraph_edge_hasher::hash (e
->call_stmt
), INSERT
);
698 gcc_assert (((cgraph_edge
*)*slot
)->speculative
);
703 gcc_assert (!*slot
|| e
->speculative
);
707 /* Return the callgraph edge representing the GIMPLE_CALL statement
711 cgraph_node::get_edge (gimple call_stmt
)
717 return call_site_hash
->find_with_hash
718 (call_stmt
, cgraph_edge_hasher::hash (call_stmt
));
720 /* This loop may turn out to be performance problem. In such case adding
721 hashtables into call nodes with very many edges is probably best
722 solution. It is not good idea to add pointer into CALL_EXPR itself
723 because we want to make possible having multiple cgraph nodes representing
724 different clones of the same body before the body is actually cloned. */
725 for (e
= callees
; e
; e
= e
->next_callee
)
727 if (e
->call_stmt
== call_stmt
)
733 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
735 if (e
->call_stmt
== call_stmt
)
742 call_site_hash
= hash_table
<cgraph_edge_hasher
>::create_ggc (120);
743 for (e2
= callees
; e2
; e2
= e2
->next_callee
)
744 cgraph_add_edge_to_call_site_hash (e2
);
745 for (e2
= indirect_calls
; e2
; e2
= e2
->next_callee
)
746 cgraph_add_edge_to_call_site_hash (e2
);
753 /* Change field call_stmt of edge to NEW_STMT.
754 If UPDATE_SPECULATIVE and E is any component of speculative
755 edge, then update all components. */
758 cgraph_edge::set_call_stmt (gcall
*new_stmt
, bool update_speculative
)
762 /* Speculative edges has three component, update all of them
764 if (update_speculative
&& speculative
)
766 cgraph_edge
*direct
, *indirect
;
769 speculative_call_info (direct
, indirect
, ref
);
770 direct
->set_call_stmt (new_stmt
, false);
771 indirect
->set_call_stmt (new_stmt
, false);
772 ref
->stmt
= new_stmt
;
776 /* Only direct speculative edges go to call_site_hash. */
777 if (caller
->call_site_hash
778 && (!speculative
|| !indirect_unknown_callee
))
780 caller
->call_site_hash
->remove_elt_with_hash
781 (call_stmt
, cgraph_edge_hasher::hash (call_stmt
));
784 cgraph_edge
*e
= this;
786 call_stmt
= new_stmt
;
787 if (indirect_unknown_callee
788 && (decl
= gimple_call_fndecl (new_stmt
)))
790 /* Constant propagation (and possibly also inlining?) can turn an
791 indirect call into a direct one. */
792 cgraph_node
*new_callee
= cgraph_node::get (decl
);
794 gcc_checking_assert (new_callee
);
795 e
= make_direct (new_callee
);
798 push_cfun (DECL_STRUCT_FUNCTION (e
->caller
->decl
));
799 e
->can_throw_external
= stmt_can_throw_external (new_stmt
);
801 if (e
->caller
->call_site_hash
)
802 cgraph_add_edge_to_call_site_hash (e
);
805 /* Allocate a cgraph_edge structure and fill it with data according to the
806 parameters of which only CALLEE can be NULL (when creating an indirect call
810 symbol_table::create_edge (cgraph_node
*caller
, cgraph_node
*callee
,
811 gcall
*call_stmt
, gcov_type count
, int freq
,
812 bool indir_unknown_callee
)
816 /* LTO does not actually have access to the call_stmt since these
817 have not been loaded yet. */
820 /* This is a rather expensive check possibly triggering
821 construction of call stmt hashtable. */
822 #ifdef ENABLE_CHECKING
824 gcc_checking_assert (
825 !(e
= caller
->get_edge (call_stmt
)) || e
->speculative
);
828 gcc_assert (is_gimple_call (call_stmt
));
834 free_edges
= NEXT_FREE_EDGE (edge
);
838 edge
= ggc_alloc
<cgraph_edge
> ();
839 edge
->uid
= edges_max_uid
++;
845 edge
->caller
= caller
;
846 edge
->callee
= callee
;
847 edge
->prev_caller
= NULL
;
848 edge
->next_caller
= NULL
;
849 edge
->prev_callee
= NULL
;
850 edge
->next_callee
= NULL
;
851 edge
->lto_stmt_uid
= 0;
854 gcc_assert (count
>= 0);
855 edge
->frequency
= freq
;
856 gcc_assert (freq
>= 0);
857 gcc_assert (freq
<= CGRAPH_FREQ_MAX
);
859 edge
->call_stmt
= call_stmt
;
860 push_cfun (DECL_STRUCT_FUNCTION (caller
->decl
));
861 edge
->can_throw_external
862 = call_stmt
? stmt_can_throw_external (call_stmt
) : false;
865 && callee
&& callee
->decl
866 && !gimple_check_call_matching_types (call_stmt
, callee
->decl
,
868 edge
->call_stmt_cannot_inline_p
= true;
870 edge
->call_stmt_cannot_inline_p
= false;
872 edge
->indirect_info
= NULL
;
873 edge
->indirect_inlining_edge
= 0;
874 edge
->speculative
= false;
875 edge
->indirect_unknown_callee
= indir_unknown_callee
;
876 if (opt_for_fn (edge
->caller
->decl
, flag_devirtualize
)
877 && call_stmt
&& DECL_STRUCT_FUNCTION (caller
->decl
))
878 edge
->in_polymorphic_cdtor
879 = decl_maybe_in_construction_p (NULL
, NULL
, call_stmt
,
882 edge
->in_polymorphic_cdtor
= caller
->thunk
.thunk_p
;
883 if (call_stmt
&& caller
->call_site_hash
)
884 cgraph_add_edge_to_call_site_hash (edge
);
889 /* Create edge from a given function to CALLEE in the cgraph. */
892 cgraph_node::create_edge (cgraph_node
*callee
,
893 gcall
*call_stmt
, gcov_type count
, int freq
)
895 cgraph_edge
*edge
= symtab
->create_edge (this, callee
, call_stmt
, count
,
898 initialize_inline_failed (edge
);
900 edge
->next_caller
= callee
->callers
;
902 callee
->callers
->prev_caller
= edge
;
903 edge
->next_callee
= callees
;
905 callees
->prev_callee
= edge
;
907 callee
->callers
= edge
;
912 /* Allocate cgraph_indirect_call_info and set its fields to default values. */
914 cgraph_indirect_call_info
*
915 cgraph_allocate_init_indirect_info (void)
917 cgraph_indirect_call_info
*ii
;
919 ii
= ggc_cleared_alloc
<cgraph_indirect_call_info
> ();
920 ii
->param_index
= -1;
924 /* Create an indirect edge with a yet-undetermined callee where the call
925 statement destination is a formal parameter of the caller with index
929 cgraph_node::create_indirect_edge (gcall
*call_stmt
, int ecf_flags
,
930 gcov_type count
, int freq
,
931 bool compute_indirect_info
)
933 cgraph_edge
*edge
= symtab
->create_edge (this, NULL
, call_stmt
,
937 initialize_inline_failed (edge
);
939 edge
->indirect_info
= cgraph_allocate_init_indirect_info ();
940 edge
->indirect_info
->ecf_flags
= ecf_flags
;
941 edge
->indirect_info
->vptr_changed
= true;
943 /* Record polymorphic call info. */
944 if (compute_indirect_info
946 && (target
= gimple_call_fn (call_stmt
))
947 && virtual_method_call_p (target
))
949 ipa_polymorphic_call_context
context (decl
, target
, call_stmt
);
951 /* Only record types can have virtual calls. */
952 edge
->indirect_info
->polymorphic
= true;
953 edge
->indirect_info
->param_index
= -1;
954 edge
->indirect_info
->otr_token
955 = tree_to_uhwi (OBJ_TYPE_REF_TOKEN (target
));
956 edge
->indirect_info
->otr_type
= obj_type_ref_class (target
);
957 gcc_assert (TREE_CODE (edge
->indirect_info
->otr_type
) == RECORD_TYPE
);
958 edge
->indirect_info
->context
= context
;
961 edge
->next_callee
= indirect_calls
;
963 indirect_calls
->prev_callee
= edge
;
964 indirect_calls
= edge
;
969 /* Remove the edge from the list of the callees of the caller. */
972 cgraph_edge::remove_caller (void)
975 prev_callee
->next_callee
= next_callee
;
977 next_callee
->prev_callee
= prev_callee
;
980 if (indirect_unknown_callee
)
981 caller
->indirect_calls
= next_callee
;
983 caller
->callees
= next_callee
;
985 if (caller
->call_site_hash
)
986 caller
->call_site_hash
->remove_elt_with_hash
987 (call_stmt
, cgraph_edge_hasher::hash (call_stmt
));
990 /* Put the edge onto the free list. */
993 symbol_table::free_edge (cgraph_edge
*e
)
997 if (e
->indirect_info
)
998 ggc_free (e
->indirect_info
);
1000 /* Clear out the edge so we do not dangle pointers. */
1001 memset (e
, 0, sizeof (*e
));
1003 NEXT_FREE_EDGE (e
) = free_edges
;
1008 /* Remove the edge in the cgraph. */
1011 cgraph_edge::remove (void)
1013 /* Call all edge removal hooks. */
1014 symtab
->call_edge_removal_hooks (this);
1016 if (!indirect_unknown_callee
)
1017 /* Remove from callers list of the callee. */
1020 /* Remove from callees list of the callers. */
1023 /* Put the edge onto the free list. */
1024 symtab
->free_edge (this);
1027 /* Turn edge into speculative call calling N2. Update
1028 the profile so the direct call is taken COUNT times
1031 At clone materialization time, the indirect call E will
1034 if (call_dest == N2)
1039 At this time the function just creates the direct call,
1040 the referencd representing the if conditional and attaches
1041 them all to the orginal indirect call statement.
1043 Return direct edge created. */
1046 cgraph_edge::make_speculative (cgraph_node
*n2
, gcov_type direct_count
,
1047 int direct_frequency
)
1049 cgraph_node
*n
= caller
;
1050 ipa_ref
*ref
= NULL
;
1055 fprintf (dump_file
, "Indirect call -> speculative call"
1056 " %s/%i => %s/%i\n",
1057 xstrdup_for_dump (n
->name ()), n
->order
,
1058 xstrdup_for_dump (n2
->name ()), n2
->order
);
1061 e2
= n
->create_edge (n2
, call_stmt
, direct_count
, direct_frequency
);
1062 initialize_inline_failed (e2
);
1063 e2
->speculative
= true;
1064 if (TREE_NOTHROW (n2
->decl
))
1065 e2
->can_throw_external
= false;
1067 e2
->can_throw_external
= can_throw_external
;
1068 e2
->lto_stmt_uid
= lto_stmt_uid
;
1069 e2
->in_polymorphic_cdtor
= in_polymorphic_cdtor
;
1071 frequency
-= e2
->frequency
;
1072 symtab
->call_edge_duplication_hooks (this, e2
);
1073 ref
= n
->create_reference (n2
, IPA_REF_ADDR
, call_stmt
);
1074 ref
->lto_stmt_uid
= lto_stmt_uid
;
1075 ref
->speculative
= speculative
;
1076 n2
->mark_address_taken ();
1080 /* Speculative call consist of three components:
1081 1) an indirect edge representing the original call
1082 2) an direct edge representing the new call
1083 3) ADDR_EXPR reference representing the speculative check.
1084 All three components are attached to single statement (the indirect
1085 call) and if one of them exists, all of them must exist.
1087 Given speculative call edge, return all three components.
1091 cgraph_edge::speculative_call_info (cgraph_edge
*&direct
,
1092 cgraph_edge
*&indirect
,
1093 ipa_ref
*&reference
)
1098 cgraph_edge
*e
= this;
1100 if (!e
->indirect_unknown_callee
)
1101 for (e2
= e
->caller
->indirect_calls
;
1102 e2
->call_stmt
!= e
->call_stmt
|| e2
->lto_stmt_uid
!= e
->lto_stmt_uid
;
1103 e2
= e2
->next_callee
)
1108 /* We can take advantage of the call stmt hash. */
1111 e
= e
->caller
->get_edge (e2
->call_stmt
);
1112 gcc_assert (e
->speculative
&& !e
->indirect_unknown_callee
);
1115 for (e
= e
->caller
->callees
;
1116 e2
->call_stmt
!= e
->call_stmt
1117 || e2
->lto_stmt_uid
!= e
->lto_stmt_uid
;
1121 gcc_assert (e
->speculative
&& e2
->speculative
);
1126 for (i
= 0; e
->caller
->iterate_reference (i
, ref
); i
++)
1127 if (ref
->speculative
1128 && ((ref
->stmt
&& ref
->stmt
== e
->call_stmt
)
1129 || (!ref
->stmt
&& ref
->lto_stmt_uid
== e
->lto_stmt_uid
)))
1135 /* Speculative edge always consist of all three components - direct edge,
1136 indirect and reference. */
1138 gcc_assert (e
&& e2
&& ref
);
1141 /* Speculative call edge turned out to be direct call to CALLE_DECL.
1142 Remove the speculative call sequence and return edge representing the call.
1143 It is up to caller to redirect the call as appropriate. */
1146 cgraph_edge::resolve_speculation (tree callee_decl
)
1148 cgraph_edge
*edge
= this;
1152 gcc_assert (edge
->speculative
);
1153 edge
->speculative_call_info (e2
, edge
, ref
);
1155 || !ref
->referred
->semantically_equivalent_p
1156 (symtab_node::get (callee_decl
)))
1162 fprintf (dump_file
, "Speculative indirect call %s/%i => %s/%i has "
1163 "turned out to have contradicting known target ",
1164 xstrdup_for_dump (edge
->caller
->name ()),
1165 edge
->caller
->order
,
1166 xstrdup_for_dump (e2
->callee
->name ()),
1168 print_generic_expr (dump_file
, callee_decl
, 0);
1169 fprintf (dump_file
, "\n");
1173 fprintf (dump_file
, "Removing speculative call %s/%i => %s/%i\n",
1174 xstrdup_for_dump (edge
->caller
->name ()),
1175 edge
->caller
->order
,
1176 xstrdup_for_dump (e2
->callee
->name ()),
1183 cgraph_edge
*tmp
= edge
;
1185 fprintf (dump_file
, "Speculative call turned into direct call.\n");
1188 /* FIXME: If EDGE is inlined, we should scale up the frequencies and counts
1189 in the functions inlined through it. */
1191 edge
->count
+= e2
->count
;
1192 edge
->frequency
+= e2
->frequency
;
1193 if (edge
->frequency
> CGRAPH_FREQ_MAX
)
1194 edge
->frequency
= CGRAPH_FREQ_MAX
;
1195 edge
->speculative
= false;
1196 e2
->speculative
= false;
1197 ref
->remove_reference ();
1198 if (e2
->indirect_unknown_callee
|| e2
->inline_failed
)
1201 e2
->callee
->remove_symbol_and_inline_clones ();
1202 if (edge
->caller
->call_site_hash
)
1203 cgraph_update_edge_in_call_site_hash (edge
);
1207 /* Make an indirect edge with an unknown callee an ordinary edge leading to
1208 CALLEE. DELTA is an integer constant that is to be added to the this
1209 pointer (first parameter) to compensate for skipping a thunk adjustment. */
1212 cgraph_edge::make_direct (cgraph_node
*callee
)
1214 cgraph_edge
*edge
= this;
1215 gcc_assert (indirect_unknown_callee
);
1217 /* If we are redirecting speculative call, make it non-speculative. */
1218 if (indirect_unknown_callee
&& speculative
)
1220 edge
= edge
->resolve_speculation (callee
->decl
);
1222 /* On successful speculation just return the pre existing direct edge. */
1223 if (!indirect_unknown_callee
)
1227 indirect_unknown_callee
= 0;
1228 ggc_free (indirect_info
);
1229 indirect_info
= NULL
;
1231 /* Get the edge out of the indirect edge list. */
1233 prev_callee
->next_callee
= next_callee
;
1235 next_callee
->prev_callee
= prev_callee
;
1237 caller
->indirect_calls
= next_callee
;
1239 /* Put it into the normal callee list */
1241 next_callee
= caller
->callees
;
1242 if (caller
->callees
)
1243 caller
->callees
->prev_callee
= edge
;
1244 caller
->callees
= edge
;
1246 /* Insert to callers list of the new callee. */
1247 edge
->set_callee (callee
);
1250 call_stmt_cannot_inline_p
1251 = !gimple_check_call_matching_types (call_stmt
, callee
->decl
,
1254 /* We need to re-determine the inlining status of the edge. */
1255 initialize_inline_failed (edge
);
1259 /* If necessary, change the function declaration in the call statement
1260 associated with E so that it corresponds to the edge callee. */
1263 cgraph_edge::redirect_call_stmt_to_callee (void)
1265 cgraph_edge
*e
= this;
1267 tree decl
= gimple_call_fndecl (e
->call_stmt
);
1268 tree lhs
= gimple_call_lhs (e
->call_stmt
);
1270 gimple_stmt_iterator gsi
;
1271 bool skip_bounds
= false;
1272 #ifdef ENABLE_CHECKING
1282 e
->speculative_call_info (e
, e2
, ref
);
1283 /* If there already is an direct call (i.e. as a result of inliner's
1284 substitution), forget about speculating. */
1286 e
= e
->resolve_speculation (decl
);
1287 /* If types do not match, speculation was likely wrong.
1288 The direct edge was posisbly redirected to the clone with a different
1289 signature. We did not update the call statement yet, so compare it
1290 with the reference that still points to the proper type. */
1291 else if (!gimple_check_call_matching_types (e
->call_stmt
,
1292 ref
->referred
->decl
,
1296 fprintf (dump_file
, "Not expanding speculative call of %s/%i -> %s/%i\n"
1298 xstrdup_for_dump (e
->caller
->name ()),
1300 xstrdup_for_dump (e
->callee
->name ()),
1302 e
= e
->resolve_speculation ();
1303 /* We are producing the final function body and will throw away the
1304 callgraph edges really soon. Reset the counts/frequencies to
1305 keep verifier happy in the case of roundoff errors. */
1306 e
->count
= gimple_bb (e
->call_stmt
)->count
;
1307 e
->frequency
= compute_call_stmt_bb_frequency
1308 (e
->caller
->decl
, gimple_bb (e
->call_stmt
));
1310 /* Expand speculation into GIMPLE code. */
1315 "Expanding speculative call of %s/%i -> %s/%i count:"
1317 xstrdup_for_dump (e
->caller
->name ()),
1319 xstrdup_for_dump (e
->callee
->name ()),
1322 gcc_assert (e2
->speculative
);
1323 push_cfun (DECL_STRUCT_FUNCTION (e
->caller
->decl
));
1324 new_stmt
= gimple_ic (e
->call_stmt
,
1325 dyn_cast
<cgraph_node
*> (ref
->referred
),
1326 e
->count
|| e2
->count
1327 ? RDIV (e
->count
* REG_BR_PROB_BASE
,
1328 e
->count
+ e2
->count
)
1329 : e
->frequency
|| e2
->frequency
1330 ? RDIV (e
->frequency
* REG_BR_PROB_BASE
,
1331 e
->frequency
+ e2
->frequency
)
1332 : REG_BR_PROB_BASE
/ 2,
1333 e
->count
, e
->count
+ e2
->count
);
1334 e
->speculative
= false;
1335 e
->caller
->set_call_stmt_including_clones (e
->call_stmt
, new_stmt
,
1338 /* Fix edges for BUILT_IN_CHKP_BNDRET calls attached to the
1339 processed call stmt. */
1340 if (gimple_call_with_bounds_p (new_stmt
)
1341 && gimple_call_lhs (new_stmt
)
1342 && chkp_retbnd_call_by_val (gimple_call_lhs (e2
->call_stmt
)))
1344 tree dresult
= gimple_call_lhs (new_stmt
);
1345 tree iresult
= gimple_call_lhs (e2
->call_stmt
);
1346 gcall
*dbndret
= chkp_retbnd_call_by_val (dresult
);
1347 gcall
*ibndret
= chkp_retbnd_call_by_val (iresult
);
1348 struct cgraph_edge
*iedge
1349 = e2
->caller
->cgraph_node::get_edge (ibndret
);
1350 struct cgraph_edge
*dedge
;
1354 dedge
= iedge
->caller
->create_edge (iedge
->callee
,
1357 dedge
->frequency
= compute_call_stmt_bb_frequency
1358 (dedge
->caller
->decl
, gimple_bb (dedge
->call_stmt
));
1360 iedge
->frequency
= compute_call_stmt_bb_frequency
1361 (iedge
->caller
->decl
, gimple_bb (iedge
->call_stmt
));
1364 e
->frequency
= compute_call_stmt_bb_frequency
1365 (e
->caller
->decl
, gimple_bb (e
->call_stmt
));
1366 e2
->frequency
= compute_call_stmt_bb_frequency
1367 (e2
->caller
->decl
, gimple_bb (e2
->call_stmt
));
1368 e2
->speculative
= false;
1369 ref
->speculative
= false;
1371 /* Indirect edges are not both in the call site hash.
1373 if (e
->caller
->call_site_hash
)
1374 cgraph_update_edge_in_call_site_hash (e2
);
1376 /* Continue redirecting E to proper target. */
1380 /* We might propagate instrumented function pointer into
1381 not instrumented function and vice versa. In such a
1382 case we need to either fix function declaration or
1383 remove bounds from call statement. */
1384 if (flag_check_pointer_bounds
&& e
->callee
)
1385 skip_bounds
= chkp_redirect_edge (e
);
1387 if (e
->indirect_unknown_callee
1388 || (decl
== e
->callee
->decl
1390 return e
->call_stmt
;
1392 #ifdef ENABLE_CHECKING
1395 node
= cgraph_node::get (decl
);
1396 gcc_assert (!node
|| !node
->clone
.combined_args_to_skip
);
1400 if (symtab
->dump_file
)
1402 fprintf (symtab
->dump_file
, "updating call of %s/%i -> %s/%i: ",
1403 xstrdup_for_dump (e
->caller
->name ()), e
->caller
->order
,
1404 xstrdup_for_dump (e
->callee
->name ()), e
->callee
->order
);
1405 print_gimple_stmt (symtab
->dump_file
, e
->call_stmt
, 0, dump_flags
);
1406 if (e
->callee
->clone
.combined_args_to_skip
)
1408 fprintf (symtab
->dump_file
, " combined args to skip: ");
1409 dump_bitmap (symtab
->dump_file
,
1410 e
->callee
->clone
.combined_args_to_skip
);
1414 if (e
->callee
->clone
.combined_args_to_skip
1419 new_stmt
= e
->call_stmt
;
1420 if (e
->callee
->clone
.combined_args_to_skip
)
1422 = gimple_call_copy_skip_args (new_stmt
,
1423 e
->callee
->clone
.combined_args_to_skip
);
1425 new_stmt
= chkp_copy_call_skip_bounds (new_stmt
);
1427 gimple_call_set_fndecl (new_stmt
, e
->callee
->decl
);
1428 gimple_call_set_fntype (new_stmt
, gimple_call_fntype (e
->call_stmt
));
1430 if (gimple_vdef (new_stmt
)
1431 && TREE_CODE (gimple_vdef (new_stmt
)) == SSA_NAME
)
1432 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt
)) = new_stmt
;
1434 gsi
= gsi_for_stmt (e
->call_stmt
);
1435 gsi_replace (&gsi
, new_stmt
, false);
1436 /* We need to defer cleaning EH info on the new statement to
1437 fixup-cfg. We may not have dominator information at this point
1438 and thus would end up with unreachable blocks and have no way
1439 to communicate that we need to run CFG cleanup then. */
1440 lp_nr
= lookup_stmt_eh_lp (e
->call_stmt
);
1443 remove_stmt_from_eh_lp (e
->call_stmt
);
1444 add_stmt_to_eh_lp (new_stmt
, lp_nr
);
1449 new_stmt
= e
->call_stmt
;
1450 gimple_call_set_fndecl (new_stmt
, e
->callee
->decl
);
1451 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), new_stmt
);
1454 /* If the call becomes noreturn, remove the LHS if possible. */
1456 && (gimple_call_flags (new_stmt
) & ECF_NORETURN
)
1457 && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs
))) == INTEGER_CST
)
1459 if (TREE_CODE (lhs
) == SSA_NAME
)
1461 tree var
= create_tmp_reg_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
),
1462 TREE_TYPE (lhs
), NULL
);
1463 var
= get_or_create_ssa_default_def
1464 (DECL_STRUCT_FUNCTION (e
->caller
->decl
), var
);
1465 gimple set_stmt
= gimple_build_assign (lhs
, var
);
1466 gsi
= gsi_for_stmt (new_stmt
);
1467 gsi_insert_before_without_update (&gsi
, set_stmt
, GSI_SAME_STMT
);
1468 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), set_stmt
);
1470 gimple_call_set_lhs (new_stmt
, NULL_TREE
);
1471 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), new_stmt
);
1474 /* If new callee has no static chain, remove it. */
1475 if (gimple_call_chain (new_stmt
) && !DECL_STATIC_CHAIN (e
->callee
->decl
))
1477 gimple_call_set_chain (new_stmt
, NULL
);
1478 update_stmt_fn (DECL_STRUCT_FUNCTION (e
->caller
->decl
), new_stmt
);
1481 maybe_remove_unused_call_args (DECL_STRUCT_FUNCTION (e
->caller
->decl
),
1484 e
->caller
->set_call_stmt_including_clones (e
->call_stmt
, new_stmt
, false);
1486 if (symtab
->dump_file
)
1488 fprintf (symtab
->dump_file
, " updated to:");
1489 print_gimple_stmt (symtab
->dump_file
, e
->call_stmt
, 0, dump_flags
);
1494 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1495 OLD_STMT changed into NEW_STMT. OLD_CALL is gimple_call_fndecl
1496 of OLD_STMT if it was previously call statement.
1497 If NEW_STMT is NULL, the call has been dropped without any
1501 cgraph_update_edges_for_call_stmt_node (cgraph_node
*node
,
1502 gimple old_stmt
, tree old_call
,
1505 tree new_call
= (new_stmt
&& is_gimple_call (new_stmt
))
1506 ? gimple_call_fndecl (new_stmt
) : 0;
1508 /* We are seeing indirect calls, then there is nothing to update. */
1509 if (!new_call
&& !old_call
)
1511 /* See if we turned indirect call into direct call or folded call to one builtin
1512 into different builtin. */
1513 if (old_call
!= new_call
)
1515 cgraph_edge
*e
= node
->get_edge (old_stmt
);
1516 cgraph_edge
*ne
= NULL
;
1522 /* Keep calls marked as dead dead. */
1523 if (new_stmt
&& is_gimple_call (new_stmt
) && e
->callee
1524 && DECL_BUILT_IN_CLASS (e
->callee
->decl
) == BUILT_IN_NORMAL
1525 && DECL_FUNCTION_CODE (e
->callee
->decl
) == BUILT_IN_UNREACHABLE
)
1527 node
->get_edge (old_stmt
)->set_call_stmt
1528 (as_a
<gcall
*> (new_stmt
));
1531 /* See if the edge is already there and has the correct callee. It
1532 might be so because of indirect inlining has already updated
1533 it. We also might've cloned and redirected the edge. */
1534 if (new_call
&& e
->callee
)
1536 cgraph_node
*callee
= e
->callee
;
1539 if (callee
->decl
== new_call
1540 || callee
->former_clone_of
== new_call
)
1542 e
->set_call_stmt (as_a
<gcall
*> (new_stmt
));
1545 callee
= callee
->clone_of
;
1549 /* Otherwise remove edge and create new one; we can't simply redirect
1550 since function has changed, so inline plan and other information
1551 attached to edge is invalid. */
1553 frequency
= e
->frequency
;
1554 if (e
->indirect_unknown_callee
|| e
->inline_failed
)
1557 e
->callee
->remove_symbol_and_inline_clones ();
1561 /* We are seeing new direct call; compute profile info based on BB. */
1562 basic_block bb
= gimple_bb (new_stmt
);
1564 frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
1570 ne
= node
->create_edge (cgraph_node::get_create (new_call
),
1571 as_a
<gcall
*> (new_stmt
), count
,
1573 gcc_assert (ne
->inline_failed
);
1576 /* We only updated the call stmt; update pointer in cgraph edge.. */
1577 else if (old_stmt
!= new_stmt
)
1578 node
->get_edge (old_stmt
)->set_call_stmt (as_a
<gcall
*> (new_stmt
));
1581 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1582 OLD_STMT changed into NEW_STMT. OLD_DECL is gimple_call_fndecl
1583 of OLD_STMT before it was updated (updating can happen inplace). */
1586 cgraph_update_edges_for_call_stmt (gimple old_stmt
, tree old_decl
, gimple new_stmt
)
1588 cgraph_node
*orig
= cgraph_node::get (cfun
->decl
);
1591 gcc_checking_assert (orig
);
1592 cgraph_update_edges_for_call_stmt_node (orig
, old_stmt
, old_decl
, new_stmt
);
1594 for (node
= orig
->clones
; node
!= orig
;)
1596 cgraph_update_edges_for_call_stmt_node (node
, old_stmt
, old_decl
, new_stmt
);
1598 node
= node
->clones
;
1599 else if (node
->next_sibling_clone
)
1600 node
= node
->next_sibling_clone
;
1603 while (node
!= orig
&& !node
->next_sibling_clone
)
1604 node
= node
->clone_of
;
1606 node
= node
->next_sibling_clone
;
1612 /* Remove all callees from the node. */
1615 cgraph_node::remove_callees (void)
1619 /* It is sufficient to remove the edges from the lists of callers of
1620 the callees. The callee list of the node can be zapped with one
1622 for (e
= callees
; e
; e
= f
)
1625 symtab
->call_edge_removal_hooks (e
);
1626 if (!e
->indirect_unknown_callee
)
1627 e
->remove_callee ();
1628 symtab
->free_edge (e
);
1630 for (e
= indirect_calls
; e
; e
= f
)
1633 symtab
->call_edge_removal_hooks (e
);
1634 if (!e
->indirect_unknown_callee
)
1635 e
->remove_callee ();
1636 symtab
->free_edge (e
);
1638 indirect_calls
= NULL
;
1642 call_site_hash
->empty ();
1643 call_site_hash
= NULL
;
1647 /* Remove all callers from the node. */
1650 cgraph_node::remove_callers (void)
1654 /* It is sufficient to remove the edges from the lists of callees of
1655 the callers. The caller list of the node can be zapped with one
1657 for (e
= callers
; e
; e
= f
)
1660 symtab
->call_edge_removal_hooks (e
);
1661 e
->remove_caller ();
1662 symtab
->free_edge (e
);
1667 /* Helper function for cgraph_release_function_body and free_lang_data.
1668 It releases body from function DECL without having to inspect its
1669 possibly non-existent symtab node. */
1672 release_function_body (tree decl
)
1674 if (DECL_STRUCT_FUNCTION (decl
))
1676 if (DECL_STRUCT_FUNCTION (decl
)->cfg
1677 || DECL_STRUCT_FUNCTION (decl
)->gimple_df
)
1679 push_cfun (DECL_STRUCT_FUNCTION (decl
));
1683 cfun
->curr_properties
&= ~PROP_loops
;
1684 loop_optimizer_finalize ();
1686 if (cfun
->gimple_df
)
1689 delete_tree_cfg_annotations ();
1694 gcc_assert (!dom_info_available_p (CDI_DOMINATORS
));
1695 gcc_assert (!dom_info_available_p (CDI_POST_DOMINATORS
));
1699 if (cfun
->value_histograms
)
1703 gimple_set_body (decl
, NULL
);
1704 /* Struct function hangs a lot of data that would leak if we didn't
1705 removed all pointers to it. */
1706 ggc_free (DECL_STRUCT_FUNCTION (decl
));
1707 DECL_STRUCT_FUNCTION (decl
) = NULL
;
1709 DECL_SAVED_TREE (decl
) = NULL
;
1712 /* Release memory used to represent body of function.
1713 Use this only for functions that are released before being translated to
1714 target code (i.e. RTL). Functions that are compiled to RTL and beyond
1715 are free'd in final.c via free_after_compilation().
1716 KEEP_ARGUMENTS are useful only if you want to rebuild body as thunk. */
1719 cgraph_node::release_body (bool keep_arguments
)
1721 ipa_transforms_to_apply
.release ();
1722 if (!used_as_abstract_origin
&& symtab
->state
!= PARSING
)
1724 DECL_RESULT (decl
) = NULL
;
1726 if (!keep_arguments
)
1727 DECL_ARGUMENTS (decl
) = NULL
;
1729 /* If the node is abstract and needed, then do not clear DECL_INITIAL
1730 of its associated function function declaration because it's
1731 needed to emit debug info later. */
1732 if (!used_as_abstract_origin
&& DECL_INITIAL (decl
))
1733 DECL_INITIAL (decl
) = error_mark_node
;
1734 release_function_body (decl
);
1737 lto_free_function_in_decl_state_for_node (this);
1738 lto_file_data
= NULL
;
1742 /* Remove function from symbol table. */
1745 cgraph_node::remove (void)
1748 int uid
= this->uid
;
1750 symtab
->call_cgraph_removal_hooks (this);
1753 ipa_transforms_to_apply
.release ();
1755 /* Incremental inlining access removed nodes stored in the postorder list.
1757 force_output
= false;
1758 forced_by_abi
= false;
1759 for (n
= nested
; n
; n
= n
->next_nested
)
1764 cgraph_node
**node2
= &origin
->nested
;
1766 while (*node2
!= this)
1767 node2
= &(*node2
)->next_nested
;
1768 *node2
= next_nested
;
1771 if (prev_sibling_clone
)
1772 prev_sibling_clone
->next_sibling_clone
= next_sibling_clone
;
1774 clone_of
->clones
= next_sibling_clone
;
1775 if (next_sibling_clone
)
1776 next_sibling_clone
->prev_sibling_clone
= prev_sibling_clone
;
1779 cgraph_node
*n
, *next
;
1783 for (n
= clones
; n
->next_sibling_clone
; n
= n
->next_sibling_clone
)
1784 n
->clone_of
= clone_of
;
1785 n
->clone_of
= clone_of
;
1786 n
->next_sibling_clone
= clone_of
->clones
;
1787 if (clone_of
->clones
)
1788 clone_of
->clones
->prev_sibling_clone
= n
;
1789 clone_of
->clones
= clones
;
1793 /* We are removing node with clones. This makes clones inconsistent,
1794 but assume they will be removed subsequently and just keep clone
1795 tree intact. This can happen in unreachable function removal since
1796 we remove unreachable functions in random order, not by bottom-up
1797 walk of clone trees. */
1798 for (n
= clones
; n
; n
= next
)
1800 next
= n
->next_sibling_clone
;
1801 n
->next_sibling_clone
= NULL
;
1802 n
->prev_sibling_clone
= NULL
;
1808 /* While all the clones are removed after being proceeded, the function
1809 itself is kept in the cgraph even after it is compiled. Check whether
1810 we are done with this body and reclaim it proactively if this is the case.
1812 if (symtab
->state
!= LTO_STREAMING
)
1814 n
= cgraph_node::get (decl
);
1816 || (!n
->clones
&& !n
->clone_of
&& !n
->global
.inlined_to
1817 && ((symtab
->global_info_ready
|| in_lto_p
)
1818 && (TREE_ASM_WRITTEN (n
->decl
)
1819 || DECL_EXTERNAL (n
->decl
)
1821 || (!flag_wpa
&& n
->in_other_partition
)))))
1826 lto_free_function_in_decl_state_for_node (this);
1827 lto_file_data
= NULL
;
1833 call_site_hash
->empty ();
1834 call_site_hash
= NULL
;
1837 if (instrumented_version
)
1839 instrumented_version
->instrumented_version
= NULL
;
1840 instrumented_version
= NULL
;
1843 symtab
->release_symbol (this, uid
);
1846 /* Likewise indicate that a node is having address taken. */
1849 cgraph_node::mark_address_taken (void)
1851 /* Indirect inlining can figure out that all uses of the address are
1853 if (global
.inlined_to
)
1855 gcc_assert (cfun
->after_inlining
);
1856 gcc_assert (callers
->indirect_inlining_edge
);
1859 /* FIXME: address_taken flag is used both as a shortcut for testing whether
1860 IPA_REF_ADDR reference exists (and thus it should be set on node
1861 representing alias we take address of) and as a test whether address
1862 of the object was taken (and thus it should be set on node alias is
1863 referring to). We should remove the first use and the remove the
1866 cgraph_node
*node
= ultimate_alias_target ();
1867 node
->address_taken
= 1;
1870 /* Return local info for the compiled function. */
1873 cgraph_node::local_info (tree decl
)
1875 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1876 cgraph_node
*node
= get (decl
);
1879 return &node
->ultimate_alias_target ()->local
;
1882 /* Return local info for the compiled function. */
1885 cgraph_node::rtl_info (tree decl
)
1887 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1888 cgraph_node
*node
= get (decl
);
1891 node
= node
->ultimate_alias_target ();
1892 if (node
->decl
!= current_function_decl
1893 && !TREE_ASM_WRITTEN (node
->decl
))
1895 /* Allocate if it doesnt exist. */
1896 if (node
->ultimate_alias_target ()->rtl
== NULL
)
1897 node
->ultimate_alias_target ()->rtl
= ggc_cleared_alloc
<cgraph_rtl_info
> ();
1898 return node
->ultimate_alias_target ()->rtl
;
1901 /* Return a string describing the failure REASON. */
1904 cgraph_inline_failed_string (cgraph_inline_failed_t reason
)
1907 #define DEFCIFCODE(code, type, string) string,
1909 static const char *cif_string_table
[CIF_N_REASONS
] = {
1910 #include "cif-code.def"
1913 /* Signedness of an enum type is implementation defined, so cast it
1914 to unsigned before testing. */
1915 gcc_assert ((unsigned) reason
< CIF_N_REASONS
);
1916 return cif_string_table
[reason
];
1919 /* Return a type describing the failure REASON. */
1921 cgraph_inline_failed_type_t
1922 cgraph_inline_failed_type (cgraph_inline_failed_t reason
)
1925 #define DEFCIFCODE(code, type, string) type,
1927 static cgraph_inline_failed_type_t cif_type_table
[CIF_N_REASONS
] = {
1928 #include "cif-code.def"
1931 /* Signedness of an enum type is implementation defined, so cast it
1932 to unsigned before testing. */
1933 gcc_assert ((unsigned) reason
< CIF_N_REASONS
);
1934 return cif_type_table
[reason
];
1937 /* Names used to print out the availability enum. */
1938 const char * const cgraph_availability_names
[] =
1939 {"unset", "not_available", "overwritable", "available", "local"};
1941 /* Output flags of edge to a file F. */
1944 cgraph_edge::dump_edge_flags (FILE *f
)
1947 fprintf (f
, "(speculative) ");
1949 fprintf (f
, "(inlined) ");
1950 if (indirect_inlining_edge
)
1951 fprintf (f
, "(indirect_inlining) ");
1953 fprintf (f
, "(%" PRId64
"x) ", (int64_t)count
);
1955 fprintf (f
, "(%.2f per call) ", frequency
/ (double)CGRAPH_FREQ_BASE
);
1956 if (can_throw_external
)
1957 fprintf (f
, "(can throw external) ");
1960 /* Dump call graph node to file F. */
1963 cgraph_node::dump (FILE *f
)
1969 if (global
.inlined_to
)
1970 fprintf (f
, " Function %s/%i is inline copy in %s/%i\n",
1971 xstrdup_for_dump (name ()),
1973 xstrdup_for_dump (global
.inlined_to
->name ()),
1974 global
.inlined_to
->order
);
1976 fprintf (f
, " Clone of %s/%i\n",
1977 clone_of
->asm_name (),
1979 if (symtab
->function_flags_ready
)
1980 fprintf (f
, " Availability: %s\n",
1981 cgraph_availability_names
[get_availability ()]);
1984 fprintf (f
, " Profile id: %i\n",
1986 fprintf (f
, " First run: %i\n", tp_first_run
);
1987 fprintf (f
, " Function flags:");
1989 fprintf (f
, " executed %" PRId64
"x",
1992 fprintf (f
, " nested in: %s", origin
->asm_name ());
1993 if (gimple_has_body_p (decl
))
1994 fprintf (f
, " body");
1996 fprintf (f
, " process");
1998 fprintf (f
, " local");
1999 if (local
.redefined_extern_inline
)
2000 fprintf (f
, " redefined_extern_inline");
2001 if (only_called_at_startup
)
2002 fprintf (f
, " only_called_at_startup");
2003 if (only_called_at_exit
)
2004 fprintf (f
, " only_called_at_exit");
2006 fprintf (f
, " tm_clone");
2008 fprintf (f
, " icf_merged");
2010 fprintf (f
, " nonfreeing_fn");
2011 if (DECL_STATIC_CONSTRUCTOR (decl
))
2012 fprintf (f
," static_constructor (priority:%i)", get_init_priority ());
2013 if (DECL_STATIC_DESTRUCTOR (decl
))
2014 fprintf (f
," static_destructor (priority:%i)", get_fini_priority ());
2015 if (frequency
== NODE_FREQUENCY_HOT
)
2016 fprintf (f
, " hot");
2017 if (frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
)
2018 fprintf (f
, " unlikely_executed");
2019 if (frequency
== NODE_FREQUENCY_EXECUTED_ONCE
)
2020 fprintf (f
, " executed_once");
2021 if (only_called_at_startup
)
2022 fprintf (f
, " only_called_at_startup");
2023 if (only_called_at_exit
)
2024 fprintf (f
, " only_called_at_exit");
2025 if (opt_for_fn (decl
, optimize_size
))
2026 fprintf (f
, " optimize_size");
2027 if (parallelized_function
)
2028 fprintf (f
, " parallelized_function");
2034 fprintf (f
, " Thunk");
2036 fprintf (f
, " of %s (asm: %s)",
2037 lang_hooks
.decl_printable_name (thunk
.alias
, 2),
2038 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk
.alias
)));
2039 fprintf (f
, " fixed offset %i virtual value %i has "
2040 "virtual offset %i)\n",
2041 (int)thunk
.fixed_offset
,
2042 (int)thunk
.virtual_value
,
2043 (int)thunk
.virtual_offset_p
);
2045 if (alias
&& thunk
.alias
2046 && DECL_P (thunk
.alias
))
2048 fprintf (f
, " Alias of %s",
2049 lang_hooks
.decl_printable_name (thunk
.alias
, 2));
2050 if (DECL_ASSEMBLER_NAME_SET_P (thunk
.alias
))
2051 fprintf (f
, " (asm: %s)",
2052 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk
.alias
)));
2056 fprintf (f
, " Called by: ");
2058 for (edge
= callers
; edge
; edge
= edge
->next_caller
)
2060 fprintf (f
, "%s/%i ", edge
->caller
->asm_name (),
2061 edge
->caller
->order
);
2062 edge
->dump_edge_flags (f
);
2065 fprintf (f
, "\n Calls: ");
2066 for (edge
= callees
; edge
; edge
= edge
->next_callee
)
2068 fprintf (f
, "%s/%i ", edge
->callee
->asm_name (),
2069 edge
->callee
->order
);
2070 edge
->dump_edge_flags (f
);
2074 for (edge
= indirect_calls
; edge
; edge
= edge
->next_callee
)
2076 if (edge
->indirect_info
->polymorphic
)
2078 fprintf (f
, " Polymorphic indirect call of type ");
2079 print_generic_expr (f
, edge
->indirect_info
->otr_type
, TDF_SLIM
);
2080 fprintf (f
, " token:%i", (int) edge
->indirect_info
->otr_token
);
2083 fprintf (f
, " Indirect call");
2084 edge
->dump_edge_flags (f
);
2085 if (edge
->indirect_info
->param_index
!= -1)
2087 fprintf (f
, " of param:%i", edge
->indirect_info
->param_index
);
2088 if (edge
->indirect_info
->agg_contents
)
2089 fprintf (f
, " loaded from %s %s at offset %i",
2090 edge
->indirect_info
->member_ptr
? "member ptr" : "aggregate",
2091 edge
->indirect_info
->by_ref
? "passed by reference":"",
2092 (int)edge
->indirect_info
->offset
);
2093 if (edge
->indirect_info
->vptr_changed
)
2094 fprintf (f
, " (vptr maybe changed)");
2097 if (edge
->indirect_info
->polymorphic
)
2098 edge
->indirect_info
->context
.dump (f
);
2101 if (instrumentation_clone
)
2102 fprintf (f
, " Is instrumented version.\n");
2103 else if (instrumented_version
)
2104 fprintf (f
, " Has instrumented version.\n");
2107 /* Dump call graph node NODE to stderr. */
2110 cgraph_node::debug (void)
2115 /* Dump the callgraph to file F. */
2118 cgraph_node::dump_cgraph (FILE *f
)
2122 fprintf (f
, "callgraph:\n\n");
2123 FOR_EACH_FUNCTION (node
)
2127 /* Return true when the DECL can possibly be inlined. */
2130 cgraph_function_possibly_inlined_p (tree decl
)
2132 if (!symtab
->global_info_ready
)
2133 return !DECL_UNINLINABLE (decl
);
2134 return DECL_POSSIBLY_INLINED (decl
);
2137 /* cgraph_node is no longer nested function; update cgraph accordingly. */
2139 cgraph_node::unnest (void)
2141 cgraph_node
**node2
= &origin
->nested
;
2142 gcc_assert (origin
);
2144 while (*node2
!= this)
2145 node2
= &(*node2
)->next_nested
;
2146 *node2
= next_nested
;
2150 /* Return function availability. See cgraph.h for description of individual
2153 cgraph_node::get_availability (void)
2155 enum availability avail
;
2157 avail
= AVAIL_NOT_AVAILABLE
;
2158 else if (local
.local
)
2159 avail
= AVAIL_LOCAL
;
2160 else if (alias
&& weakref
)
2161 ultimate_alias_target (&avail
);
2162 else if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl
)))
2163 avail
= AVAIL_INTERPOSABLE
;
2164 else if (!externally_visible
)
2165 avail
= AVAIL_AVAILABLE
;
2166 /* Inline functions are safe to be analyzed even if their symbol can
2167 be overwritten at runtime. It is not meaningful to enforce any sane
2168 behaviour on replacing inline function by different body. */
2169 else if (DECL_DECLARED_INLINE_P (decl
))
2170 avail
= AVAIL_AVAILABLE
;
2172 /* If the function can be overwritten, return OVERWRITABLE. Take
2173 care at least of two notable extensions - the COMDAT functions
2174 used to share template instantiations in C++ (this is symmetric
2175 to code cp_cannot_inline_tree_fn and probably shall be shared and
2176 the inlinability hooks completely eliminated).
2178 ??? Does the C++ one definition rule allow us to always return
2179 AVAIL_AVAILABLE here? That would be good reason to preserve this
2182 else if (decl_replaceable_p (decl
) && !DECL_EXTERNAL (decl
))
2183 avail
= AVAIL_INTERPOSABLE
;
2184 else avail
= AVAIL_AVAILABLE
;
2189 /* Worker for cgraph_node_can_be_local_p. */
2191 cgraph_node_cannot_be_local_p_1 (cgraph_node
*node
, void *)
2193 return !(!node
->force_output
2194 && ((DECL_COMDAT (node
->decl
)
2195 && !node
->forced_by_abi
2196 && !node
->used_from_object_file_p ()
2197 && !node
->same_comdat_group
)
2198 || !node
->externally_visible
));
2201 /* Return true if cgraph_node can be made local for API change.
2202 Extern inline functions and C++ COMDAT functions can be made local
2203 at the expense of possible code size growth if function is used in multiple
2204 compilation units. */
2206 cgraph_node::can_be_local_p (void)
2208 return (!address_taken
2209 && !call_for_symbol_thunks_and_aliases (cgraph_node_cannot_be_local_p_1
,
2213 /* Call callback on cgraph_node, thunks and aliases associated to cgraph_node.
2214 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
2215 skipped. When EXCLUDE_VIRTUAL_THUNKS is true, virtual thunks are
2218 cgraph_node::call_for_symbol_thunks_and_aliases (bool (*callback
)
2219 (cgraph_node
*, void *),
2221 bool include_overwritable
,
2222 bool exclude_virtual_thunks
)
2227 if (callback (this, data
))
2229 FOR_EACH_ALIAS (this, ref
)
2231 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
2232 if (include_overwritable
2233 || alias
->get_availability () > AVAIL_INTERPOSABLE
)
2234 if (alias
->call_for_symbol_thunks_and_aliases (callback
, data
,
2235 include_overwritable
,
2236 exclude_virtual_thunks
))
2239 for (e
= callers
; e
; e
= e
->next_caller
)
2240 if (e
->caller
->thunk
.thunk_p
2241 && (include_overwritable
2242 || e
->caller
->get_availability () > AVAIL_INTERPOSABLE
)
2243 && !(exclude_virtual_thunks
2244 && e
->caller
->thunk
.virtual_offset_p
))
2245 if (e
->caller
->call_for_symbol_thunks_and_aliases (callback
, data
,
2246 include_overwritable
,
2247 exclude_virtual_thunks
))
2253 /* Worker to bring NODE local. */
2256 cgraph_node::make_local (cgraph_node
*node
, void *)
2258 gcc_checking_assert (node
->can_be_local_p ());
2259 if (DECL_COMDAT (node
->decl
) || DECL_EXTERNAL (node
->decl
))
2261 node
->make_decl_local ();
2262 node
->set_section (NULL
);
2263 node
->set_comdat_group (NULL
);
2264 node
->externally_visible
= false;
2265 node
->forced_by_abi
= false;
2266 node
->local
.local
= true;
2267 node
->set_section (NULL
);
2268 node
->unique_name
= (node
->resolution
== LDPR_PREVAILING_DEF_IRONLY
2269 || node
->resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
);
2270 node
->resolution
= LDPR_PREVAILING_DEF_IRONLY
;
2271 gcc_assert (node
->get_availability () == AVAIL_LOCAL
);
2276 /* Bring cgraph node local. */
2279 cgraph_node::make_local (void)
2281 call_for_symbol_thunks_and_aliases (cgraph_node::make_local
, NULL
, true);
2284 /* Worker to set nothrow flag. */
2287 cgraph_set_nothrow_flag_1 (cgraph_node
*node
, void *data
)
2291 TREE_NOTHROW (node
->decl
) = data
!= NULL
;
2294 for (e
= node
->callers
; e
; e
= e
->next_caller
)
2295 e
->can_throw_external
= false;
2299 /* Set TREE_NOTHROW on NODE's decl and on aliases of NODE
2300 if any to NOTHROW. */
2303 cgraph_node::set_nothrow_flag (bool nothrow
)
2305 call_for_symbol_thunks_and_aliases (cgraph_set_nothrow_flag_1
,
2306 (void *)(size_t)nothrow
, false);
2309 /* Worker to set const flag. */
2312 cgraph_set_const_flag_1 (cgraph_node
*node
, void *data
)
2314 /* Static constructors and destructors without a side effect can be
2316 if (data
&& !((size_t)data
& 2))
2318 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
2319 DECL_STATIC_CONSTRUCTOR (node
->decl
) = 0;
2320 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
2321 DECL_STATIC_DESTRUCTOR (node
->decl
) = 0;
2323 TREE_READONLY (node
->decl
) = data
!= NULL
;
2324 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = ((size_t)data
& 2) != 0;
2328 /* Set TREE_READONLY on cgraph_node's decl and on aliases of the node
2329 if any to READONLY. */
2332 cgraph_node::set_const_flag (bool readonly
, bool looping
)
2334 call_for_symbol_thunks_and_aliases (cgraph_set_const_flag_1
,
2335 (void *)(size_t)(readonly
+ (int)looping
* 2),
2339 /* Worker to set pure flag. */
2342 cgraph_set_pure_flag_1 (cgraph_node
*node
, void *data
)
2344 /* Static constructors and destructors without a side effect can be
2346 if (data
&& !((size_t)data
& 2))
2348 if (DECL_STATIC_CONSTRUCTOR (node
->decl
))
2349 DECL_STATIC_CONSTRUCTOR (node
->decl
) = 0;
2350 if (DECL_STATIC_DESTRUCTOR (node
->decl
))
2351 DECL_STATIC_DESTRUCTOR (node
->decl
) = 0;
2353 DECL_PURE_P (node
->decl
) = data
!= NULL
;
2354 DECL_LOOPING_CONST_OR_PURE_P (node
->decl
) = ((size_t)data
& 2) != 0;
2358 /* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node
2362 cgraph_node::set_pure_flag (bool pure
, bool looping
)
2364 call_for_symbol_thunks_and_aliases (cgraph_set_pure_flag_1
,
2365 (void *)(size_t)(pure
+ (int)looping
* 2),
2369 /* Return true when cgraph_node can not return or throw and thus
2370 it is safe to ignore its side effects for IPA analysis. */
2373 cgraph_node::cannot_return_p (void)
2375 int flags
= flags_from_decl_or_type (decl
);
2376 if (!opt_for_fn (decl
, flag_exceptions
))
2377 return (flags
& ECF_NORETURN
) != 0;
2379 return ((flags
& (ECF_NORETURN
| ECF_NOTHROW
))
2380 == (ECF_NORETURN
| ECF_NOTHROW
));
2383 /* Return true when call of edge can not lead to return from caller
2384 and thus it is safe to ignore its side effects for IPA analysis
2385 when computing side effects of the caller.
2386 FIXME: We could actually mark all edges that have no reaching
2387 patch to the exit block or throw to get better results. */
2389 cgraph_edge::cannot_lead_to_return_p (void)
2391 if (caller
->cannot_return_p ())
2393 if (indirect_unknown_callee
)
2395 int flags
= indirect_info
->ecf_flags
;
2396 if (!opt_for_fn (caller
->decl
, flag_exceptions
))
2397 return (flags
& ECF_NORETURN
) != 0;
2399 return ((flags
& (ECF_NORETURN
| ECF_NOTHROW
))
2400 == (ECF_NORETURN
| ECF_NOTHROW
));
2403 return callee
->cannot_return_p ();
2406 /* Return true if the call can be hot. */
2409 cgraph_edge::maybe_hot_p (void)
2411 /* TODO: Export profile_status from cfun->cfg to cgraph_node. */
2413 && opt_for_fn (caller
->decl
, flag_branch_probabilities
)
2414 && !maybe_hot_count_p (NULL
, count
))
2416 if (caller
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
2418 && callee
->frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
))
2420 if (caller
->frequency
> NODE_FREQUENCY_UNLIKELY_EXECUTED
2422 && callee
->frequency
<= NODE_FREQUENCY_EXECUTED_ONCE
))
2424 if (opt_for_fn (caller
->decl
, optimize_size
))
2426 if (caller
->frequency
== NODE_FREQUENCY_HOT
)
2428 if (caller
->frequency
== NODE_FREQUENCY_EXECUTED_ONCE
2429 && frequency
< CGRAPH_FREQ_BASE
* 3 / 2)
2431 if (opt_for_fn (caller
->decl
, flag_guess_branch_prob
))
2433 if (PARAM_VALUE (HOT_BB_FREQUENCY_FRACTION
) == 0
2434 || frequency
<= (CGRAPH_FREQ_BASE
2435 / PARAM_VALUE (HOT_BB_FREQUENCY_FRACTION
)))
2441 /* Worker for cgraph_can_remove_if_no_direct_calls_p. */
2444 nonremovable_p (cgraph_node
*node
, void *)
2446 return !node
->can_remove_if_no_direct_calls_and_refs_p ();
2449 /* Return true if whole comdat group can be removed if there are no direct
2453 cgraph_node::can_remove_if_no_direct_calls_p (bool will_inline
)
2455 struct ipa_ref
*ref
;
2457 /* For local symbols or non-comdat group it is the same as
2458 can_remove_if_no_direct_calls_p. */
2459 if (!externally_visible
|| !same_comdat_group
)
2461 if (DECL_EXTERNAL (decl
))
2465 return !call_for_symbol_and_aliases (nonremovable_p
, NULL
, true);
2468 if (will_inline
&& address_taken
)
2471 /* Otheriwse check if we can remove the symbol itself and then verify
2472 that only uses of the comdat groups are direct call to THIS
2474 if (!can_remove_if_no_direct_calls_and_refs_p ())
2477 /* Check that all refs come from within the comdat group. */
2478 for (int i
= 0; iterate_referring (i
, ref
); i
++)
2479 if (ref
->referring
->get_comdat_group () != get_comdat_group ())
2482 struct cgraph_node
*target
= ultimate_alias_target ();
2483 for (cgraph_node
*next
= dyn_cast
<cgraph_node
*> (same_comdat_group
);
2484 next
!= this; next
= dyn_cast
<cgraph_node
*> (next
->same_comdat_group
))
2486 if (!externally_visible
)
2489 && !next
->can_remove_if_no_direct_calls_and_refs_p ())
2492 /* If we see different symbol than THIS, be sure to check calls. */
2493 if (next
->ultimate_alias_target () != target
)
2494 for (cgraph_edge
*e
= next
->callers
; e
; e
= e
->next_caller
)
2495 if (e
->caller
->get_comdat_group () != get_comdat_group ()
2499 /* If function is not being inlined, we care only about
2500 references outside of the comdat group. */
2502 for (int i
= 0; next
->iterate_referring (i
, ref
); i
++)
2503 if (ref
->referring
->get_comdat_group () != get_comdat_group ())
2509 /* Return true when function cgraph_node can be expected to be removed
2510 from program when direct calls in this compilation unit are removed.
2512 As a special case COMDAT functions are
2513 cgraph_can_remove_if_no_direct_calls_p while the are not
2514 cgraph_only_called_directly_p (it is possible they are called from other
2517 This function behaves as cgraph_only_called_directly_p because eliminating
2518 all uses of COMDAT function does not make it necessarily disappear from
2519 the program unless we are compiling whole program or we do LTO. In this
2520 case we know we win since dynamic linking will not really discard the
2521 linkonce section. */
2524 cgraph_node::will_be_removed_from_program_if_no_direct_calls_p
2527 gcc_assert (!global
.inlined_to
);
2528 if (DECL_EXTERNAL (decl
))
2531 if (!in_lto_p
&& !flag_whole_program
)
2533 /* If the symbol is in comdat group, we need to verify that whole comdat
2534 group becomes unreachable. Technically we could skip references from
2535 within the group, too. */
2536 if (!only_called_directly_p ())
2538 if (same_comdat_group
&& externally_visible
)
2540 struct cgraph_node
*target
= ultimate_alias_target ();
2542 if (will_inline
&& address_taken
)
2544 for (cgraph_node
*next
= dyn_cast
<cgraph_node
*> (same_comdat_group
);
2546 next
= dyn_cast
<cgraph_node
*> (next
->same_comdat_group
))
2548 if (!externally_visible
)
2551 && !next
->only_called_directly_p ())
2554 /* If we see different symbol than THIS,
2555 be sure to check calls. */
2556 if (next
->ultimate_alias_target () != target
)
2557 for (cgraph_edge
*e
= next
->callers
; e
; e
= e
->next_caller
)
2558 if (e
->caller
->get_comdat_group () != get_comdat_group ()
2566 return can_remove_if_no_direct_calls_p (will_inline
);
2570 /* Worker for cgraph_only_called_directly_p. */
2573 cgraph_not_only_called_directly_p_1 (cgraph_node
*node
, void *)
2575 return !node
->only_called_directly_or_aliased_p ();
2578 /* Return true when function cgraph_node and all its aliases are only called
2580 i.e. it is not externally visible, address was not taken and
2581 it is not used in any other non-standard way. */
2584 cgraph_node::only_called_directly_p (void)
2586 gcc_assert (ultimate_alias_target () == this);
2587 return !call_for_symbol_and_aliases (cgraph_not_only_called_directly_p_1
,
2592 /* Collect all callers of NODE. Worker for collect_callers_of_node. */
2595 collect_callers_of_node_1 (cgraph_node
*node
, void *data
)
2597 vec
<cgraph_edge
*> *redirect_callers
= (vec
<cgraph_edge
*> *)data
;
2599 enum availability avail
;
2600 node
->ultimate_alias_target (&avail
);
2602 if (avail
> AVAIL_INTERPOSABLE
)
2603 for (cs
= node
->callers
; cs
!= NULL
; cs
= cs
->next_caller
)
2604 if (!cs
->indirect_inlining_edge
)
2605 redirect_callers
->safe_push (cs
);
2609 /* Collect all callers of cgraph_node and its aliases that are known to lead to
2610 cgraph_node (i.e. are not overwritable). */
2613 cgraph_node::collect_callers (void)
2615 vec
<cgraph_edge
*> redirect_callers
= vNULL
;
2616 call_for_symbol_thunks_and_aliases (collect_callers_of_node_1
,
2617 &redirect_callers
, false);
2618 return redirect_callers
;
2621 /* Return TRUE if NODE2 a clone of NODE or is equivalent to it. */
2624 clone_of_p (cgraph_node
*node
, cgraph_node
*node2
)
2626 bool skipped_thunk
= false;
2627 node
= node
->ultimate_alias_target ();
2628 node2
= node2
->ultimate_alias_target ();
2630 /* There are no virtual clones of thunks so check former_clone_of or if we
2631 might have skipped thunks because this adjustments are no longer
2633 while (node
->thunk
.thunk_p
)
2635 if (node2
->former_clone_of
== node
->decl
)
2637 if (!node
->thunk
.this_adjusting
)
2639 node
= node
->callees
->callee
->ultimate_alias_target ();
2640 skipped_thunk
= true;
2645 if (!node2
->clone
.args_to_skip
2646 || !bitmap_bit_p (node2
->clone
.args_to_skip
, 0))
2648 if (node2
->former_clone_of
== node
->decl
)
2650 else if (!node2
->clone_of
)
2654 while (node
!= node2
&& node2
)
2655 node2
= node2
->clone_of
;
2656 return node2
!= NULL
;
2659 /* Verify edge count and frequency. */
2662 cgraph_edge::verify_count_and_frequency ()
2664 bool error_found
= false;
2667 error ("caller edge count is negative");
2672 error ("caller edge frequency is negative");
2675 if (frequency
> CGRAPH_FREQ_MAX
)
2677 error ("caller edge frequency is too large");
2683 /* Switch to THIS_CFUN if needed and print STMT to stderr. */
2685 cgraph_debug_gimple_stmt (function
*this_cfun
, gimple stmt
)
2687 bool fndecl_was_null
= false;
2688 /* debug_gimple_stmt needs correct cfun */
2689 if (cfun
!= this_cfun
)
2690 set_cfun (this_cfun
);
2691 /* ...and an actual current_function_decl */
2692 if (!current_function_decl
)
2694 current_function_decl
= this_cfun
->decl
;
2695 fndecl_was_null
= true;
2697 debug_gimple_stmt (stmt
);
2698 if (fndecl_was_null
)
2699 current_function_decl
= NULL
;
2702 /* Verify that call graph edge corresponds to DECL from the associated
2703 statement. Return true if the verification should fail. */
2706 cgraph_edge::verify_corresponds_to_fndecl (tree decl
)
2710 if (!decl
|| callee
->global
.inlined_to
)
2712 if (symtab
->state
== LTO_STREAMING
)
2714 node
= cgraph_node::get (decl
);
2716 /* We do not know if a node from a different partition is an alias or what it
2717 aliases and therefore cannot do the former_clone_of check reliably. When
2718 body_removed is set, we have lost all information about what was alias or
2719 thunk of and also cannot proceed. */
2721 || node
->body_removed
2722 || node
->in_other_partition
2723 || callee
->icf_merged
2724 || callee
->in_other_partition
)
2727 node
= node
->ultimate_alias_target ();
2729 /* Optimizers can redirect unreachable calls or calls triggering undefined
2730 behaviour to builtin_unreachable. */
2731 if (DECL_BUILT_IN_CLASS (callee
->decl
) == BUILT_IN_NORMAL
2732 && DECL_FUNCTION_CODE (callee
->decl
) == BUILT_IN_UNREACHABLE
)
2735 if (callee
->former_clone_of
!= node
->decl
2736 && (node
!= callee
->ultimate_alias_target ())
2737 && !clone_of_p (node
, callee
))
2743 /* Verify cgraph nodes of given cgraph node. */
2745 cgraph_node::verify_node (void)
2748 function
*this_cfun
= DECL_STRUCT_FUNCTION (decl
);
2749 basic_block this_block
;
2750 gimple_stmt_iterator gsi
;
2751 bool error_found
= false;
2756 timevar_push (TV_CGRAPH_VERIFY
);
2757 error_found
|= verify_base ();
2758 for (e
= callees
; e
; e
= e
->next_callee
)
2761 error ("aux field set for edge %s->%s",
2762 identifier_to_locale (e
->caller
->name ()),
2763 identifier_to_locale (e
->callee
->name ()));
2768 error ("execution count is negative");
2771 if (global
.inlined_to
&& same_comdat_group
)
2773 error ("inline clone in same comdat group list");
2776 if (!definition
&& !in_other_partition
&& local
.local
)
2778 error ("local symbols must be defined");
2781 if (global
.inlined_to
&& externally_visible
)
2783 error ("externally visible inline clone");
2786 if (global
.inlined_to
&& address_taken
)
2788 error ("inline clone with address taken");
2791 if (global
.inlined_to
&& force_output
)
2793 error ("inline clone is forced to output");
2796 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
2800 error ("aux field set for indirect edge from %s",
2801 identifier_to_locale (e
->caller
->name ()));
2804 if (!e
->indirect_unknown_callee
2805 || !e
->indirect_info
)
2807 error ("An indirect edge from %s is not marked as indirect or has "
2808 "associated indirect_info, the corresponding statement is: ",
2809 identifier_to_locale (e
->caller
->name ()));
2810 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
2814 bool check_comdat
= comdat_local_p ();
2815 for (e
= callers
; e
; e
= e
->next_caller
)
2817 if (e
->verify_count_and_frequency ())
2820 && !in_same_comdat_group_p (e
->caller
))
2822 error ("comdat-local function called by %s outside its comdat",
2823 identifier_to_locale (e
->caller
->name ()));
2826 if (!e
->inline_failed
)
2828 if (global
.inlined_to
2829 != (e
->caller
->global
.inlined_to
2830 ? e
->caller
->global
.inlined_to
: e
->caller
))
2832 error ("inlined_to pointer is wrong");
2835 if (callers
->next_caller
)
2837 error ("multiple inline callers");
2842 if (global
.inlined_to
)
2844 error ("inlined_to pointer set for noninline callers");
2848 for (e
= callees
; e
; e
= e
->next_callee
)
2850 if (e
->verify_count_and_frequency ())
2852 if (gimple_has_body_p (e
->caller
->decl
)
2853 && !e
->caller
->global
.inlined_to
2855 /* Optimized out calls are redirected to __builtin_unreachable. */
2858 != builtin_decl_implicit (BUILT_IN_UNREACHABLE
))
2860 != compute_call_stmt_bb_frequency (e
->caller
->decl
,
2861 gimple_bb (e
->call_stmt
))))
2863 error ("caller edge frequency %i does not match BB frequency %i",
2865 compute_call_stmt_bb_frequency (e
->caller
->decl
,
2866 gimple_bb (e
->call_stmt
)));
2870 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
2872 if (e
->verify_count_and_frequency ())
2874 if (gimple_has_body_p (e
->caller
->decl
)
2875 && !e
->caller
->global
.inlined_to
2878 != compute_call_stmt_bb_frequency (e
->caller
->decl
,
2879 gimple_bb (e
->call_stmt
))))
2881 error ("indirect call frequency %i does not match BB frequency %i",
2883 compute_call_stmt_bb_frequency (e
->caller
->decl
,
2884 gimple_bb (e
->call_stmt
)));
2888 if (!callers
&& global
.inlined_to
)
2890 error ("inlined_to pointer is set but no predecessors found");
2893 if (global
.inlined_to
== this)
2895 error ("inlined_to pointer refers to itself");
2902 for (n
= clone_of
->clones
; n
; n
= n
->next_sibling_clone
)
2907 error ("cgraph_node has wrong clone_of");
2914 for (n
= clones
; n
; n
= n
->next_sibling_clone
)
2915 if (n
->clone_of
!= this)
2919 error ("cgraph_node has wrong clone list");
2923 if ((prev_sibling_clone
|| next_sibling_clone
) && !clone_of
)
2925 error ("cgraph_node is in clone list but it is not clone");
2928 if (!prev_sibling_clone
&& clone_of
&& clone_of
->clones
!= this)
2930 error ("cgraph_node has wrong prev_clone pointer");
2933 if (prev_sibling_clone
&& prev_sibling_clone
->next_sibling_clone
!= this)
2935 error ("double linked list of clones corrupted");
2939 if (analyzed
&& alias
)
2941 bool ref_found
= false;
2943 ipa_ref
*ref
= NULL
;
2947 error ("Alias has call edges");
2950 for (i
= 0; iterate_reference (i
, ref
); i
++)
2951 if (ref
->use
== IPA_REF_CHKP
)
2953 else if (ref
->use
!= IPA_REF_ALIAS
)
2955 error ("Alias has non-alias reference");
2960 error ("Alias has more than one alias reference");
2967 error ("Analyzed alias has no reference");
2972 /* Check instrumented version reference. */
2973 if (instrumented_version
2974 && instrumented_version
->instrumented_version
!= this)
2976 error ("Instrumentation clone does not reference original node");
2980 /* Cannot have orig_decl for not instrumented nodes. */
2981 if (!instrumentation_clone
&& orig_decl
)
2983 error ("Not instrumented node has non-NULL original declaration");
2987 /* If original not instrumented node still exists then we may check
2988 original declaration is set properly. */
2989 if (instrumented_version
2991 && orig_decl
!= instrumented_version
->decl
)
2993 error ("Instrumented node has wrong original declaration");
2997 /* Check all nodes have chkp reference to their instrumented versions. */
2999 && instrumented_version
3000 && !instrumentation_clone
)
3002 bool ref_found
= false;
3004 struct ipa_ref
*ref
;
3006 for (i
= 0; iterate_reference (i
, ref
); i
++)
3007 if (ref
->use
== IPA_REF_CHKP
)
3011 error ("Node has more than one chkp reference");
3014 if (ref
->referred
!= instrumented_version
)
3016 error ("Wrong node is referenced with chkp reference");
3024 error ("Analyzed node has no reference to instrumented version");
3029 if (instrumentation_clone
3030 && DECL_BUILT_IN_CLASS (decl
) == NOT_BUILT_IN
)
3032 tree name
= DECL_ASSEMBLER_NAME (decl
);
3033 tree orig_name
= DECL_ASSEMBLER_NAME (orig_decl
);
3035 if (!IDENTIFIER_TRANSPARENT_ALIAS (name
)
3036 || TREE_CHAIN (name
) != orig_name
)
3038 error ("Alias chain for instrumented node is broken");
3043 if (analyzed
&& thunk
.thunk_p
)
3047 error ("No edge out of thunk node");
3050 else if (callees
->next_callee
)
3052 error ("More than one edge out of thunk node");
3055 if (gimple_has_body_p (decl
))
3057 error ("Thunk is not supposed to have body");
3060 if (thunk
.add_pointer_bounds_args
3061 && !instrumented_version
->semantically_equivalent_p (callees
->callee
))
3063 error ("Instrumentation thunk has wrong edge callee");
3067 else if (analyzed
&& gimple_has_body_p (decl
)
3068 && !TREE_ASM_WRITTEN (decl
)
3069 && (!DECL_EXTERNAL (decl
) || global
.inlined_to
)
3074 hash_set
<gimple
> stmts
;
3076 ipa_ref
*ref
= NULL
;
3078 /* Reach the trees by walking over the CFG, and note the
3079 enclosing basic-blocks in the call edges. */
3080 FOR_EACH_BB_FN (this_block
, this_cfun
)
3082 for (gsi
= gsi_start_phis (this_block
);
3083 !gsi_end_p (gsi
); gsi_next (&gsi
))
3084 stmts
.add (gsi_stmt (gsi
));
3085 for (gsi
= gsi_start_bb (this_block
);
3089 gimple stmt
= gsi_stmt (gsi
);
3091 if (is_gimple_call (stmt
))
3093 cgraph_edge
*e
= get_edge (stmt
);
3094 tree decl
= gimple_call_fndecl (stmt
);
3099 error ("shared call_stmt:");
3100 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
3103 if (!e
->indirect_unknown_callee
)
3105 if (e
->verify_corresponds_to_fndecl (decl
))
3107 error ("edge points to wrong declaration:");
3108 debug_tree (e
->callee
->decl
);
3109 fprintf (stderr
," Instead of:");
3116 error ("an indirect edge with unknown callee "
3117 "corresponding to a call_stmt with "
3118 "a known declaration:");
3120 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3126 error ("missing callgraph edge for call stmt:");
3127 cgraph_debug_gimple_stmt (this_cfun
, stmt
);
3133 for (i
= 0; iterate_reference (i
, ref
); i
++)
3134 if (ref
->stmt
&& !stmts
.contains (ref
->stmt
))
3136 error ("reference to dead statement");
3137 cgraph_debug_gimple_stmt (this_cfun
, ref
->stmt
);
3142 /* No CFG available?! */
3145 for (e
= callees
; e
; e
= e
->next_callee
)
3149 error ("edge %s->%s has no corresponding call_stmt",
3150 identifier_to_locale (e
->caller
->name ()),
3151 identifier_to_locale (e
->callee
->name ()));
3152 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3157 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
3159 if (!e
->aux
&& !e
->speculative
)
3161 error ("an indirect edge from %s has no corresponding call_stmt",
3162 identifier_to_locale (e
->caller
->name ()));
3163 cgraph_debug_gimple_stmt (this_cfun
, e
->call_stmt
);
3172 internal_error ("verify_cgraph_node failed");
3174 timevar_pop (TV_CGRAPH_VERIFY
);
3177 /* Verify whole cgraph structure. */
3179 cgraph_node::verify_cgraph_nodes (void)
3186 FOR_EACH_FUNCTION (node
)
3190 /* Walk the alias chain to return the function cgraph_node is alias of.
3191 Walk through thunks, too.
3192 When AVAILABILITY is non-NULL, get minimal availability in the chain. */
3195 cgraph_node::function_symbol (enum availability
*availability
)
3197 cgraph_node
*node
= ultimate_alias_target (availability
);
3199 while (node
->thunk
.thunk_p
)
3201 node
= node
->callees
->callee
;
3204 enum availability a
;
3205 a
= node
->get_availability ();
3206 if (a
< *availability
)
3209 node
= node
->ultimate_alias_target (availability
);
3214 /* Walk the alias chain to return the function cgraph_node is alias of.
3215 Walk through non virtual thunks, too. Thus we return either a function
3216 or a virtual thunk node.
3217 When AVAILABILITY is non-NULL, get minimal availability in the chain. */
3220 cgraph_node::function_or_virtual_thunk_symbol
3221 (enum availability
*availability
)
3223 cgraph_node
*node
= ultimate_alias_target (availability
);
3225 while (node
->thunk
.thunk_p
&& !node
->thunk
.virtual_offset_p
)
3227 node
= node
->callees
->callee
;
3230 enum availability a
;
3231 a
= node
->get_availability ();
3232 if (a
< *availability
)
3235 node
= node
->ultimate_alias_target (availability
);
3240 /* When doing LTO, read cgraph_node's body from disk if it is not already
3244 cgraph_node::get_untransformed_body (void)
3246 lto_file_decl_data
*file_data
;
3247 const char *data
, *name
;
3249 tree decl
= this->decl
;
3251 if (DECL_RESULT (decl
))
3254 gcc_assert (in_lto_p
);
3256 timevar_push (TV_IPA_LTO_GIMPLE_IN
);
3258 file_data
= lto_file_data
;
3259 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
3261 /* We may have renamed the declaration, e.g., a static function. */
3262 name
= lto_get_decl_name_mapping (file_data
, name
);
3264 data
= lto_get_section_data (file_data
, LTO_section_function_body
,
3267 fatal_error (input_location
, "%s: section %s is missing",
3268 file_data
->file_name
,
3271 gcc_assert (DECL_STRUCT_FUNCTION (decl
) == NULL
);
3273 lto_input_function_body (file_data
, this, data
);
3274 lto_stats
.num_function_bodies
++;
3275 lto_free_section_data (file_data
, LTO_section_function_body
, name
,
3277 lto_free_function_in_decl_state_for_node (this);
3278 /* Keep lto file data so ipa-inline-analysis knows about cross module
3281 timevar_pop (TV_IPA_LTO_GIMPLE_IN
);
3286 /* Prepare function body. When doing LTO, read cgraph_node's body from disk
3287 if it is not already present. When some IPA transformations are scheduled,
3291 cgraph_node::get_body (void)
3295 updated
= get_untransformed_body ();
3297 /* Getting transformed body makes no sense for inline clones;
3298 we should never use this on real clones becuase they are materialized
3300 TODO: Materializing clones here will likely lead to smaller LTRANS
3302 gcc_assert (!global
.inlined_to
&& !clone_of
);
3303 if (ipa_transforms_to_apply
.exists ())
3305 opt_pass
*saved_current_pass
= current_pass
;
3306 FILE *saved_dump_file
= dump_file
;
3307 int saved_dump_flags
= dump_flags
;
3309 push_cfun (DECL_STRUCT_FUNCTION (decl
));
3310 execute_all_ipa_transforms ();
3311 cgraph_edge::rebuild_edges ();
3312 free_dominance_info (CDI_DOMINATORS
);
3313 free_dominance_info (CDI_POST_DOMINATORS
);
3317 current_pass
= saved_current_pass
;
3318 dump_file
= saved_dump_file
;
3319 dump_flags
= saved_dump_flags
;
3324 /* Return the DECL_STRUCT_FUNCTION of the function. */
3327 cgraph_node::get_fun (void)
3329 cgraph_node
*node
= this;
3330 struct function
*fun
= DECL_STRUCT_FUNCTION (node
->decl
);
3332 while (!fun
&& node
->clone_of
)
3334 node
= node
->clone_of
;
3335 fun
= DECL_STRUCT_FUNCTION (node
->decl
);
3341 /* Verify if the type of the argument matches that of the function
3342 declaration. If we cannot verify this or there is a mismatch,
3346 gimple_check_call_args (gimple stmt
, tree fndecl
, bool args_count_match
)
3349 unsigned int i
, nargs
;
3351 /* Calls to internal functions always match their signature. */
3352 if (gimple_call_internal_p (stmt
))
3355 nargs
= gimple_call_num_args (stmt
);
3357 /* Get argument types for verification. */
3359 parms
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
3361 parms
= TYPE_ARG_TYPES (gimple_call_fntype (stmt
));
3363 /* Verify if the type of the argument matches that of the function
3364 declaration. If we cannot verify this or there is a mismatch,
3366 if (fndecl
&& DECL_ARGUMENTS (fndecl
))
3368 for (i
= 0, p
= DECL_ARGUMENTS (fndecl
);
3370 i
++, p
= DECL_CHAIN (p
))
3373 /* We cannot distinguish a varargs function from the case
3374 of excess parameters, still deferring the inlining decision
3375 to the callee is possible. */
3378 arg
= gimple_call_arg (stmt
, i
);
3379 if (p
== error_mark_node
3380 || DECL_ARG_TYPE (p
) == error_mark_node
3381 || arg
== error_mark_node
3382 || (!types_compatible_p (DECL_ARG_TYPE (p
), TREE_TYPE (arg
))
3383 && !fold_convertible_p (DECL_ARG_TYPE (p
), arg
)))
3386 if (args_count_match
&& p
)
3391 for (i
= 0, p
= parms
; i
< nargs
; i
++, p
= TREE_CHAIN (p
))
3394 /* If this is a varargs function defer inlining decision
3398 arg
= gimple_call_arg (stmt
, i
);
3399 if (TREE_VALUE (p
) == error_mark_node
3400 || arg
== error_mark_node
3401 || TREE_CODE (TREE_VALUE (p
)) == VOID_TYPE
3402 || (!types_compatible_p (TREE_VALUE (p
), TREE_TYPE (arg
))
3403 && !fold_convertible_p (TREE_VALUE (p
), arg
)))
3415 /* Verify if the type of the argument and lhs of CALL_STMT matches
3416 that of the function declaration CALLEE. If ARGS_COUNT_MATCH is
3417 true, the arg count needs to be the same.
3418 If we cannot verify this or there is a mismatch, return false. */
3421 gimple_check_call_matching_types (gimple call_stmt
, tree callee
,
3422 bool args_count_match
)
3426 if ((DECL_RESULT (callee
)
3427 && !DECL_BY_REFERENCE (DECL_RESULT (callee
))
3428 && (lhs
= gimple_call_lhs (call_stmt
)) != NULL_TREE
3429 && !useless_type_conversion_p (TREE_TYPE (DECL_RESULT (callee
)),
3431 && !fold_convertible_p (TREE_TYPE (DECL_RESULT (callee
)), lhs
))
3432 || !gimple_check_call_args (call_stmt
, callee
, args_count_match
))
3437 /* Reset all state within cgraph.c so that we can rerun the compiler
3438 within the same process. For use by toplev::finalize. */
3441 cgraph_c_finalize (void)
3445 x_cgraph_nodes_queue
= NULL
;
3447 cgraph_fnver_htab
= NULL
;
3448 version_info_node
= NULL
;
3451 /* A wroker for call_for_symbol_and_aliases. */
3454 cgraph_node::call_for_symbol_and_aliases_1 (bool (*callback
) (cgraph_node
*,
3457 bool include_overwritable
)
3460 FOR_EACH_ALIAS (this, ref
)
3462 cgraph_node
*alias
= dyn_cast
<cgraph_node
*> (ref
->referring
);
3463 if (include_overwritable
3464 || alias
->get_availability () > AVAIL_INTERPOSABLE
)
3465 if (alias
->call_for_symbol_and_aliases (callback
, data
,
3466 include_overwritable
))
3472 /* Return true if NODE has thunk. */
3475 cgraph_node::has_thunk_p (cgraph_node
*node
, void *)
3477 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
3478 if (e
->caller
->thunk
.thunk_p
)
3483 #include "gt-cgraph.h"