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 "double-int.h"
40 #include "fold-const.h"
43 #include "print-tree.h"
44 #include "tree-inline.h"
45 #include "langhooks.h"
52 #include "dominance.h"
54 #include "basic-block.h"
57 #include "plugin-api.h"
58 #include "hard-reg-set.h"
63 #include "tree-ssa-alias.h"
64 #include "internal-fn.h"
66 #include "gimple-expr.h"
68 #include "gimple-iterator.h"
71 #include "gimple-ssa.h"
74 #include "value-prof.h"
76 #include "diagnostic-core.h"
78 #include "ipa-utils.h"
79 #include "lto-streamer.h"
80 #include "alloc-pool.h"
81 #include "symbol-summary.h"
83 #include "ipa-inline.h"
85 #include "gimple-pretty-print.h"
86 #include "statistics.h"
88 #include "fixed-value.h"
89 #include "insn-config.h"
99 #include "tree-chkp.h"
102 /* FIXME: Only for PROP_loops, but cgraph shouldn't have to know about this. */
103 #include "tree-pass.h"
105 /* Queue of cgraph nodes scheduled to be lowered. */
106 symtab_node *x_cgraph_nodes_queue;
107 #define cgraph_nodes_queue ((cgraph_node *)x_cgraph_nodes_queue)
109 /* Symbol table global context. */
110 symbol_table *symtab;
112 /* List of hooks triggered on cgraph_edge events. */
113 struct cgraph_edge_hook_list {
114 cgraph_edge_hook hook;
116 struct cgraph_edge_hook_list *next;
119 /* List of hooks triggered on cgraph_node events. */
120 struct cgraph_node_hook_list {
121 cgraph_node_hook hook;
123 struct cgraph_node_hook_list *next;
126 /* List of hooks triggered on events involving two cgraph_edges. */
127 struct cgraph_2edge_hook_list {
128 cgraph_2edge_hook hook;
130 struct cgraph_2edge_hook_list *next;
133 /* List of hooks triggered on events involving two cgraph_nodes. */
134 struct cgraph_2node_hook_list {
135 cgraph_2node_hook hook;
137 struct cgraph_2node_hook_list *next;
140 /* Hash descriptor for cgraph_function_version_info. */
142 struct function_version_hasher : ggc_hasher<cgraph_function_version_info *>
144 static hashval_t hash (cgraph_function_version_info *);
145 static bool equal (cgraph_function_version_info *,
146 cgraph_function_version_info *);
149 /* Map a cgraph_node to cgraph_function_version_info using this htab.
150 The cgraph_function_version_info has a THIS_NODE field that is the
151 corresponding cgraph_node.. */
153 static GTY(()) hash_table<function_version_hasher> *cgraph_fnver_htab = NULL;
155 /* Hash function for cgraph_fnver_htab. */
157 function_version_hasher::hash (cgraph_function_version_info *ptr)
159 int uid = ptr->this_node->uid;
160 return (hashval_t)(uid);
163 /* eq function for cgraph_fnver_htab. */
165 function_version_hasher::equal (cgraph_function_version_info *n1,
166 cgraph_function_version_info *n2)
168 return n1->this_node->uid == n2->this_node->uid;
171 /* Mark as GC root all allocated nodes. */
172 static GTY(()) struct cgraph_function_version_info *
173 version_info_node = NULL;
175 /* Get the cgraph_function_version_info node corresponding to node. */
176 cgraph_function_version_info *
177 cgraph_node::function_version (void)
179 cgraph_function_version_info key;
180 key.this_node = this;
182 if (cgraph_fnver_htab == NULL)
185 return cgraph_fnver_htab->find (&key);
188 /* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
189 corresponding to cgraph_node NODE. */
190 cgraph_function_version_info *
191 cgraph_node::insert_new_function_version (void)
193 version_info_node = NULL;
194 version_info_node = ggc_cleared_alloc<cgraph_function_version_info> ();
195 version_info_node->this_node = this;
197 if (cgraph_fnver_htab == NULL)
198 cgraph_fnver_htab = hash_table<function_version_hasher>::create_ggc (2);
200 *cgraph_fnver_htab->find_slot (version_info_node, INSERT)
202 return version_info_node;
205 /* Remove the cgraph_function_version_info and cgraph_node for DECL. This
206 DECL is a duplicate declaration. */
208 cgraph_node::delete_function_version (tree decl)
210 cgraph_node *decl_node = cgraph_node::get (decl);
211 cgraph_function_version_info *decl_v = NULL;
213 if (decl_node == NULL)
216 decl_v = decl_node->function_version ();
221 if (decl_v->prev != NULL)
222 decl_v->prev->next = decl_v->next;
224 if (decl_v->next != NULL)
225 decl_v->next->prev = decl_v->prev;
227 if (cgraph_fnver_htab != NULL)
228 cgraph_fnver_htab->remove_elt (decl_v);
230 decl_node->remove ();
233 /* Record that DECL1 and DECL2 are semantically identical function
236 cgraph_node::record_function_versions (tree decl1, tree decl2)
238 cgraph_node *decl1_node = cgraph_node::get_create (decl1);
239 cgraph_node *decl2_node = cgraph_node::get_create (decl2);
240 cgraph_function_version_info *decl1_v = NULL;
241 cgraph_function_version_info *decl2_v = NULL;
242 cgraph_function_version_info *before;
243 cgraph_function_version_info *after;
245 gcc_assert (decl1_node != NULL && decl2_node != NULL);
246 decl1_v = decl1_node->function_version ();
247 decl2_v = decl2_node->function_version ();
249 if (decl1_v != NULL && decl2_v != NULL)
253 decl1_v = decl1_node->insert_new_function_version ();
256 decl2_v = decl2_node->insert_new_function_version ();
258 /* Chain decl2_v and decl1_v. All semantically identical versions
259 will be chained together. */
264 while (before->next != NULL)
265 before = before->next;
267 while (after->prev != NULL)
270 before->next = after;
271 after->prev = before;
274 /* Initialize callgraph dump file. */
277 symbol_table::initialize (void)
280 dump_file = dump_begin (TDI_cgraph, NULL);
283 /* Allocate new callgraph node and insert it into basic data structures. */
286 symbol_table::create_empty (void)
288 cgraph_node *node = allocate_cgraph_symbol ();
290 node->type = SYMTAB_FUNCTION;
291 node->frequency = NODE_FREQUENCY_NORMAL;
292 node->count_materialization_scale = REG_BR_PROB_BASE;
298 /* Register HOOK to be called with DATA on each removed edge. */
299 cgraph_edge_hook_list *
300 symbol_table::add_edge_removal_hook (cgraph_edge_hook hook, void *data)
302 cgraph_edge_hook_list *entry;
303 cgraph_edge_hook_list **ptr = &m_first_edge_removal_hook;
305 entry = (cgraph_edge_hook_list *) xmalloc (sizeof (*entry));
315 /* Remove ENTRY from the list of hooks called on removing edges. */
317 symbol_table::remove_edge_removal_hook (cgraph_edge_hook_list *entry)
319 cgraph_edge_hook_list **ptr = &m_first_edge_removal_hook;
321 while (*ptr != entry)
327 /* Call all edge removal hooks. */
329 symbol_table::call_edge_removal_hooks (cgraph_edge *e)
331 cgraph_edge_hook_list *entry = m_first_edge_removal_hook;
334 entry->hook (e, entry->data);
339 /* Register HOOK to be called with DATA on each removed node. */
340 cgraph_node_hook_list *
341 symbol_table::add_cgraph_removal_hook (cgraph_node_hook hook, void *data)
343 cgraph_node_hook_list *entry;
344 cgraph_node_hook_list **ptr = &m_first_cgraph_removal_hook;
346 entry = (cgraph_node_hook_list *) xmalloc (sizeof (*entry));
356 /* Remove ENTRY from the list of hooks called on removing nodes. */
358 symbol_table::remove_cgraph_removal_hook (cgraph_node_hook_list *entry)
360 cgraph_node_hook_list **ptr = &m_first_cgraph_removal_hook;
362 while (*ptr != entry)
368 /* Call all node removal hooks. */
370 symbol_table::call_cgraph_removal_hooks (cgraph_node *node)
372 cgraph_node_hook_list *entry = m_first_cgraph_removal_hook;
375 entry->hook (node, entry->data);
380 /* Call all node removal hooks. */
382 symbol_table::call_cgraph_insertion_hooks (cgraph_node *node)
384 cgraph_node_hook_list *entry = m_first_cgraph_insertion_hook;
387 entry->hook (node, entry->data);
393 /* Register HOOK to be called with DATA on each inserted node. */
394 cgraph_node_hook_list *
395 symbol_table::add_cgraph_insertion_hook (cgraph_node_hook hook, void *data)
397 cgraph_node_hook_list *entry;
398 cgraph_node_hook_list **ptr = &m_first_cgraph_insertion_hook;
400 entry = (cgraph_node_hook_list *) xmalloc (sizeof (*entry));
410 /* Remove ENTRY from the list of hooks called on inserted nodes. */
412 symbol_table::remove_cgraph_insertion_hook (cgraph_node_hook_list *entry)
414 cgraph_node_hook_list **ptr = &m_first_cgraph_insertion_hook;
416 while (*ptr != entry)
422 /* Register HOOK to be called with DATA on each duplicated edge. */
423 cgraph_2edge_hook_list *
424 symbol_table::add_edge_duplication_hook (cgraph_2edge_hook hook, void *data)
426 cgraph_2edge_hook_list *entry;
427 cgraph_2edge_hook_list **ptr = &m_first_edge_duplicated_hook;
429 entry = (cgraph_2edge_hook_list *) xmalloc (sizeof (*entry));
439 /* Remove ENTRY from the list of hooks called on duplicating edges. */
441 symbol_table::remove_edge_duplication_hook (cgraph_2edge_hook_list *entry)
443 cgraph_2edge_hook_list **ptr = &m_first_edge_duplicated_hook;
445 while (*ptr != entry)
451 /* Call all edge duplication hooks. */
453 symbol_table::call_edge_duplication_hooks (cgraph_edge *cs1, cgraph_edge *cs2)
455 cgraph_2edge_hook_list *entry = m_first_edge_duplicated_hook;
458 entry->hook (cs1, cs2, entry->data);
463 /* Register HOOK to be called with DATA on each duplicated node. */
464 cgraph_2node_hook_list *
465 symbol_table::add_cgraph_duplication_hook (cgraph_2node_hook hook, void *data)
467 cgraph_2node_hook_list *entry;
468 cgraph_2node_hook_list **ptr = &m_first_cgraph_duplicated_hook;
470 entry = (cgraph_2node_hook_list *) xmalloc (sizeof (*entry));
480 /* Remove ENTRY from the list of hooks called on duplicating nodes. */
482 symbol_table::remove_cgraph_duplication_hook (cgraph_2node_hook_list *entry)
484 cgraph_2node_hook_list **ptr = &m_first_cgraph_duplicated_hook;
486 while (*ptr != entry)
492 /* Call all node duplication hooks. */
494 symbol_table::call_cgraph_duplication_hooks (cgraph_node *node,
497 cgraph_2node_hook_list *entry = m_first_cgraph_duplicated_hook;
500 entry->hook (node, node2, entry->data);
505 /* Return cgraph node assigned to DECL. Create new one when needed. */
508 cgraph_node::create (tree decl)
510 cgraph_node *node = symtab->create_empty ();
511 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
515 if ((flag_openacc || flag_openmp)
516 && lookup_attribute ("omp declare target", DECL_ATTRIBUTES (decl)))
518 node->offloadable = 1;
519 #ifdef ENABLE_OFFLOADING
520 g->have_offload = true;
524 node->register_symbol ();
526 if (DECL_CONTEXT (decl) && TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)
528 node->origin = cgraph_node::get_create (DECL_CONTEXT (decl));
529 node->next_nested = node->origin->nested;
530 node->origin->nested = node;
535 /* Try to find a call graph node for declaration DECL and if it does not exist
536 or if it corresponds to an inline clone, create a new one. */
539 cgraph_node::get_create (tree decl)
541 cgraph_node *first_clone = cgraph_node::get (decl);
543 if (first_clone && !first_clone->global.inlined_to)
546 cgraph_node *node = cgraph_node::create (decl);
549 first_clone->clone_of = node;
550 node->clones = first_clone;
551 symtab->symtab_prevail_in_asm_name_hash (node);
552 node->decl->decl_with_vis.symtab_node = node;
554 fprintf (dump_file, "Introduced new external node "
555 "(%s/%i) and turned into root of the clone tree.\n",
556 xstrdup_for_dump (node->name ()), node->order);
559 fprintf (dump_file, "Introduced new external node "
560 "(%s/%i).\n", xstrdup_for_dump (node->name ()),
565 /* Mark ALIAS as an alias to DECL. DECL_NODE is cgraph node representing
566 the function body is associated with (not necessarily cgraph_node (DECL). */
569 cgraph_node::create_alias (tree alias, tree target)
571 cgraph_node *alias_node;
573 gcc_assert (TREE_CODE (target) == FUNCTION_DECL
574 || TREE_CODE (target) == IDENTIFIER_NODE);
575 gcc_assert (TREE_CODE (alias) == FUNCTION_DECL);
576 alias_node = cgraph_node::get_create (alias);
577 gcc_assert (!alias_node->definition);
578 alias_node->alias_target = target;
579 alias_node->definition = true;
580 alias_node->alias = true;
581 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (alias)) != NULL)
582 alias_node->weakref = true;
586 /* Attempt to mark ALIAS as an alias to DECL. Return alias node if successful
588 Same body aliases are output whenever the body of DECL is output,
589 and cgraph_node::get (ALIAS) transparently returns
590 cgraph_node::get (DECL). */
593 cgraph_node::create_same_body_alias (tree alias, tree decl)
596 #ifndef ASM_OUTPUT_DEF
597 /* If aliases aren't supported by the assembler, fail. */
600 /* Langhooks can create same body aliases of symbols not defined.
601 Those are useless. Drop them on the floor. */
602 if (symtab->global_info_ready)
605 n = cgraph_node::create_alias (alias, decl);
606 n->cpp_implicit_alias = true;
607 if (symtab->cpp_implicit_aliases_done)
608 n->resolve_alias (cgraph_node::get (decl));
612 /* Add thunk alias into callgraph. The alias declaration is ALIAS and it
613 aliases DECL with an adjustments made into the first parameter.
614 See comments in thunk_adjust for detail on the parameters. */
617 cgraph_node::create_thunk (tree alias, tree, bool this_adjusting,
618 HOST_WIDE_INT fixed_offset,
619 HOST_WIDE_INT virtual_value,
625 node = cgraph_node::get (alias);
629 node = cgraph_node::create (alias);
630 gcc_checking_assert (!virtual_offset
631 || wi::eq_p (virtual_offset, virtual_value));
632 node->thunk.fixed_offset = fixed_offset;
633 node->thunk.this_adjusting = this_adjusting;
634 node->thunk.virtual_value = virtual_value;
635 node->thunk.virtual_offset_p = virtual_offset != NULL;
636 node->thunk.alias = real_alias;
637 node->thunk.thunk_p = true;
638 node->definition = true;
643 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
644 Return NULL if there's no such node. */
647 cgraph_node::get_for_asmname (tree asmname)
649 /* We do not want to look at inline clones. */
650 for (symtab_node *node = symtab_node::get_for_asmname (asmname);
652 node = node->next_sharing_asm_name)
654 cgraph_node *cn = dyn_cast <cgraph_node *> (node);
655 if (cn && !cn->global.inlined_to)
661 /* Returns a hash value for X (which really is a cgraph_edge). */
664 cgraph_edge_hasher::hash (cgraph_edge *e)
666 /* This is a really poor hash function, but it is what htab_hash_pointer
668 return (hashval_t) ((intptr_t)e->call_stmt >> 3);
671 /* Returns a hash value for X (which really is a cgraph_edge). */
674 cgraph_edge_hasher::hash (gimple call_stmt)
676 /* This is a really poor hash function, but it is what htab_hash_pointer
678 return (hashval_t) ((intptr_t)call_stmt >> 3);
681 /* Return nonzero if the call_stmt of of cgraph_edge X is stmt *Y. */
684 cgraph_edge_hasher::equal (cgraph_edge *x, gimple y)
686 return x->call_stmt == y;
689 /* Add call graph edge E to call site hash of its caller. */
692 cgraph_update_edge_in_call_site_hash (cgraph_edge *e)
694 gimple call = e->call_stmt;
695 *e->caller->call_site_hash->find_slot_with_hash
696 (call, cgraph_edge_hasher::hash (call), INSERT) = e;
699 /* Add call graph edge E to call site hash of its caller. */
702 cgraph_add_edge_to_call_site_hash (cgraph_edge *e)
704 /* There are two speculative edges for every statement (one direct,
705 one indirect); always hash the direct one. */
706 if (e->speculative && e->indirect_unknown_callee)
708 cgraph_edge **slot = e->caller->call_site_hash->find_slot_with_hash
709 (e->call_stmt, cgraph_edge_hasher::hash (e->call_stmt), INSERT);
712 gcc_assert (((cgraph_edge *)*slot)->speculative);
717 gcc_assert (!*slot || e->speculative);
721 /* Return the callgraph edge representing the GIMPLE_CALL statement
725 cgraph_node::get_edge (gimple call_stmt)
731 return call_site_hash->find_with_hash
732 (call_stmt, cgraph_edge_hasher::hash (call_stmt));
734 /* This loop may turn out to be performance problem. In such case adding
735 hashtables into call nodes with very many edges is probably best
736 solution. It is not good idea to add pointer into CALL_EXPR itself
737 because we want to make possible having multiple cgraph nodes representing
738 different clones of the same body before the body is actually cloned. */
739 for (e = callees; e; e = e->next_callee)
741 if (e->call_stmt == call_stmt)
747 for (e = indirect_calls; e; e = e->next_callee)
749 if (e->call_stmt == call_stmt)
756 call_site_hash = hash_table<cgraph_edge_hasher>::create_ggc (120);
757 for (e2 = callees; e2; e2 = e2->next_callee)
758 cgraph_add_edge_to_call_site_hash (e2);
759 for (e2 = indirect_calls; e2; e2 = e2->next_callee)
760 cgraph_add_edge_to_call_site_hash (e2);
767 /* Change field call_stmt of edge to NEW_STMT.
768 If UPDATE_SPECULATIVE and E is any component of speculative
769 edge, then update all components. */
772 cgraph_edge::set_call_stmt (gcall *new_stmt, bool update_speculative)
776 /* Speculative edges has three component, update all of them
778 if (update_speculative && speculative)
780 cgraph_edge *direct, *indirect;
783 speculative_call_info (direct, indirect, ref);
784 direct->set_call_stmt (new_stmt, false);
785 indirect->set_call_stmt (new_stmt, false);
786 ref->stmt = new_stmt;
790 /* Only direct speculative edges go to call_site_hash. */
791 if (caller->call_site_hash
792 && (!speculative || !indirect_unknown_callee))
794 caller->call_site_hash->remove_elt_with_hash
795 (call_stmt, cgraph_edge_hasher::hash (call_stmt));
798 cgraph_edge *e = this;
800 call_stmt = new_stmt;
801 if (indirect_unknown_callee
802 && (decl = gimple_call_fndecl (new_stmt)))
804 /* Constant propagation (and possibly also inlining?) can turn an
805 indirect call into a direct one. */
806 cgraph_node *new_callee = cgraph_node::get (decl);
808 gcc_checking_assert (new_callee);
809 e = make_direct (new_callee);
812 push_cfun (DECL_STRUCT_FUNCTION (e->caller->decl));
813 e->can_throw_external = stmt_can_throw_external (new_stmt);
815 if (e->caller->call_site_hash)
816 cgraph_add_edge_to_call_site_hash (e);
819 /* Allocate a cgraph_edge structure and fill it with data according to the
820 parameters of which only CALLEE can be NULL (when creating an indirect call
824 symbol_table::create_edge (cgraph_node *caller, cgraph_node *callee,
825 gcall *call_stmt, gcov_type count, int freq,
826 bool indir_unknown_callee)
830 /* LTO does not actually have access to the call_stmt since these
831 have not been loaded yet. */
834 /* This is a rather expensive check possibly triggering
835 construction of call stmt hashtable. */
836 #ifdef ENABLE_CHECKING
838 gcc_checking_assert (
839 !(e = caller->get_edge (call_stmt)) || e->speculative);
842 gcc_assert (is_gimple_call (call_stmt));
848 free_edges = NEXT_FREE_EDGE (edge);
852 edge = ggc_alloc<cgraph_edge> ();
853 edge->uid = edges_max_uid++;
859 edge->caller = caller;
860 edge->callee = callee;
861 edge->prev_caller = NULL;
862 edge->next_caller = NULL;
863 edge->prev_callee = NULL;
864 edge->next_callee = NULL;
865 edge->lto_stmt_uid = 0;
868 gcc_assert (count >= 0);
869 edge->frequency = freq;
870 gcc_assert (freq >= 0);
871 gcc_assert (freq <= CGRAPH_FREQ_MAX);
873 edge->call_stmt = call_stmt;
874 push_cfun (DECL_STRUCT_FUNCTION (caller->decl));
875 edge->can_throw_external
876 = call_stmt ? stmt_can_throw_external (call_stmt) : false;
879 && callee && callee->decl
880 && !gimple_check_call_matching_types (call_stmt, callee->decl,
882 edge->call_stmt_cannot_inline_p = true;
884 edge->call_stmt_cannot_inline_p = false;
886 edge->indirect_info = NULL;
887 edge->indirect_inlining_edge = 0;
888 edge->speculative = false;
889 edge->indirect_unknown_callee = indir_unknown_callee;
890 if (opt_for_fn (edge->caller->decl, flag_devirtualize)
891 && call_stmt && DECL_STRUCT_FUNCTION (caller->decl))
892 edge->in_polymorphic_cdtor
893 = decl_maybe_in_construction_p (NULL, NULL, call_stmt,
896 edge->in_polymorphic_cdtor = caller->thunk.thunk_p;
897 if (call_stmt && caller->call_site_hash)
898 cgraph_add_edge_to_call_site_hash (edge);
903 /* Create edge from a given function to CALLEE in the cgraph. */
906 cgraph_node::create_edge (cgraph_node *callee,
907 gcall *call_stmt, gcov_type count, int freq)
909 cgraph_edge *edge = symtab->create_edge (this, callee, call_stmt, count,
912 initialize_inline_failed (edge);
914 edge->next_caller = callee->callers;
916 callee->callers->prev_caller = edge;
917 edge->next_callee = callees;
919 callees->prev_callee = edge;
921 callee->callers = edge;
926 /* Allocate cgraph_indirect_call_info and set its fields to default values. */
928 cgraph_indirect_call_info *
929 cgraph_allocate_init_indirect_info (void)
931 cgraph_indirect_call_info *ii;
933 ii = ggc_cleared_alloc<cgraph_indirect_call_info> ();
934 ii->param_index = -1;
938 /* Create an indirect edge with a yet-undetermined callee where the call
939 statement destination is a formal parameter of the caller with index
943 cgraph_node::create_indirect_edge (gcall *call_stmt, int ecf_flags,
944 gcov_type count, int freq,
945 bool compute_indirect_info)
947 cgraph_edge *edge = symtab->create_edge (this, NULL, call_stmt,
951 initialize_inline_failed (edge);
953 edge->indirect_info = cgraph_allocate_init_indirect_info ();
954 edge->indirect_info->ecf_flags = ecf_flags;
955 edge->indirect_info->vptr_changed = true;
957 /* Record polymorphic call info. */
958 if (compute_indirect_info
960 && (target = gimple_call_fn (call_stmt))
961 && virtual_method_call_p (target))
963 ipa_polymorphic_call_context context (decl, target, call_stmt);
965 /* Only record types can have virtual calls. */
966 edge->indirect_info->polymorphic = true;
967 edge->indirect_info->param_index = -1;
968 edge->indirect_info->otr_token
969 = tree_to_uhwi (OBJ_TYPE_REF_TOKEN (target));
970 edge->indirect_info->otr_type = obj_type_ref_class (target);
971 gcc_assert (TREE_CODE (edge->indirect_info->otr_type) == RECORD_TYPE);
972 edge->indirect_info->context = context;
975 edge->next_callee = indirect_calls;
977 indirect_calls->prev_callee = edge;
978 indirect_calls = edge;
983 /* Remove the edge from the list of the callees of the caller. */
986 cgraph_edge::remove_caller (void)
989 prev_callee->next_callee = next_callee;
991 next_callee->prev_callee = prev_callee;
994 if (indirect_unknown_callee)
995 caller->indirect_calls = next_callee;
997 caller->callees = next_callee;
999 if (caller->call_site_hash)
1000 caller->call_site_hash->remove_elt_with_hash
1001 (call_stmt, cgraph_edge_hasher::hash (call_stmt));
1004 /* Put the edge onto the free list. */
1007 symbol_table::free_edge (cgraph_edge *e)
1011 if (e->indirect_info)
1012 ggc_free (e->indirect_info);
1014 /* Clear out the edge so we do not dangle pointers. */
1015 memset (e, 0, sizeof (*e));
1017 NEXT_FREE_EDGE (e) = free_edges;
1022 /* Remove the edge in the cgraph. */
1025 cgraph_edge::remove (void)
1027 /* Call all edge removal hooks. */
1028 symtab->call_edge_removal_hooks (this);
1030 if (!indirect_unknown_callee)
1031 /* Remove from callers list of the callee. */
1034 /* Remove from callees list of the callers. */
1037 /* Put the edge onto the free list. */
1038 symtab->free_edge (this);
1041 /* Turn edge into speculative call calling N2. Update
1042 the profile so the direct call is taken COUNT times
1045 At clone materialization time, the indirect call E will
1048 if (call_dest == N2)
1053 At this time the function just creates the direct call,
1054 the referencd representing the if conditional and attaches
1055 them all to the orginal indirect call statement.
1057 Return direct edge created. */
1060 cgraph_edge::make_speculative (cgraph_node *n2, gcov_type direct_count,
1061 int direct_frequency)
1063 cgraph_node *n = caller;
1064 ipa_ref *ref = NULL;
1069 fprintf (dump_file, "Indirect call -> speculative call"
1070 " %s/%i => %s/%i\n",
1071 xstrdup_for_dump (n->name ()), n->order,
1072 xstrdup_for_dump (n2->name ()), n2->order);
1075 e2 = n->create_edge (n2, call_stmt, direct_count, direct_frequency);
1076 initialize_inline_failed (e2);
1077 e2->speculative = true;
1078 if (TREE_NOTHROW (n2->decl))
1079 e2->can_throw_external = false;
1081 e2->can_throw_external = can_throw_external;
1082 e2->lto_stmt_uid = lto_stmt_uid;
1083 e2->in_polymorphic_cdtor = in_polymorphic_cdtor;
1085 frequency -= e2->frequency;
1086 symtab->call_edge_duplication_hooks (this, e2);
1087 ref = n->create_reference (n2, IPA_REF_ADDR, call_stmt);
1088 ref->lto_stmt_uid = lto_stmt_uid;
1089 ref->speculative = speculative;
1090 n2->mark_address_taken ();
1094 /* Speculative call consist of three components:
1095 1) an indirect edge representing the original call
1096 2) an direct edge representing the new call
1097 3) ADDR_EXPR reference representing the speculative check.
1098 All three components are attached to single statement (the indirect
1099 call) and if one of them exists, all of them must exist.
1101 Given speculative call edge, return all three components.
1105 cgraph_edge::speculative_call_info (cgraph_edge *&direct,
1106 cgraph_edge *&indirect,
1107 ipa_ref *&reference)
1112 cgraph_edge *e = this;
1114 if (!e->indirect_unknown_callee)
1115 for (e2 = e->caller->indirect_calls;
1116 e2->call_stmt != e->call_stmt || e2->lto_stmt_uid != e->lto_stmt_uid;
1117 e2 = e2->next_callee)
1122 /* We can take advantage of the call stmt hash. */
1125 e = e->caller->get_edge (e2->call_stmt);
1126 gcc_assert (e->speculative && !e->indirect_unknown_callee);
1129 for (e = e->caller->callees;
1130 e2->call_stmt != e->call_stmt
1131 || e2->lto_stmt_uid != e->lto_stmt_uid;
1135 gcc_assert (e->speculative && e2->speculative);
1140 for (i = 0; e->caller->iterate_reference (i, ref); i++)
1141 if (ref->speculative
1142 && ((ref->stmt && ref->stmt == e->call_stmt)
1143 || (!ref->stmt && ref->lto_stmt_uid == e->lto_stmt_uid)))
1149 /* Speculative edge always consist of all three components - direct edge,
1150 indirect and reference. */
1152 gcc_assert (e && e2 && ref);
1155 /* Speculative call edge turned out to be direct call to CALLE_DECL.
1156 Remove the speculative call sequence and return edge representing the call.
1157 It is up to caller to redirect the call as appropriate. */
1160 cgraph_edge::resolve_speculation (tree callee_decl)
1162 cgraph_edge *edge = this;
1166 gcc_assert (edge->speculative);
1167 edge->speculative_call_info (e2, edge, ref);
1169 || !ref->referred->semantically_equivalent_p
1170 (symtab_node::get (callee_decl)))
1176 fprintf (dump_file, "Speculative indirect call %s/%i => %s/%i has "
1177 "turned out to have contradicting known target ",
1178 xstrdup_for_dump (edge->caller->name ()),
1179 edge->caller->order,
1180 xstrdup_for_dump (e2->callee->name ()),
1182 print_generic_expr (dump_file, callee_decl, 0);
1183 fprintf (dump_file, "\n");
1187 fprintf (dump_file, "Removing speculative call %s/%i => %s/%i\n",
1188 xstrdup_for_dump (edge->caller->name ()),
1189 edge->caller->order,
1190 xstrdup_for_dump (e2->callee->name ()),
1197 cgraph_edge *tmp = edge;
1199 fprintf (dump_file, "Speculative call turned into direct call.\n");
1202 /* FIXME: If EDGE is inlined, we should scale up the frequencies and counts
1203 in the functions inlined through it. */
1205 edge->count += e2->count;
1206 edge->frequency += e2->frequency;
1207 if (edge->frequency > CGRAPH_FREQ_MAX)
1208 edge->frequency = CGRAPH_FREQ_MAX;
1209 edge->speculative = false;
1210 e2->speculative = false;
1211 ref->remove_reference ();
1212 if (e2->indirect_unknown_callee || e2->inline_failed)
1215 e2->callee->remove_symbol_and_inline_clones ();
1216 if (edge->caller->call_site_hash)
1217 cgraph_update_edge_in_call_site_hash (edge);
1221 /* Make an indirect edge with an unknown callee an ordinary edge leading to
1222 CALLEE. DELTA is an integer constant that is to be added to the this
1223 pointer (first parameter) to compensate for skipping a thunk adjustment. */
1226 cgraph_edge::make_direct (cgraph_node *callee)
1228 cgraph_edge *edge = this;
1229 gcc_assert (indirect_unknown_callee);
1231 /* If we are redirecting speculative call, make it non-speculative. */
1232 if (indirect_unknown_callee && speculative)
1234 edge = edge->resolve_speculation (callee->decl);
1236 /* On successful speculation just return the pre existing direct edge. */
1237 if (!indirect_unknown_callee)
1241 indirect_unknown_callee = 0;
1242 ggc_free (indirect_info);
1243 indirect_info = NULL;
1245 /* Get the edge out of the indirect edge list. */
1247 prev_callee->next_callee = next_callee;
1249 next_callee->prev_callee = prev_callee;
1251 caller->indirect_calls = next_callee;
1253 /* Put it into the normal callee list */
1255 next_callee = caller->callees;
1256 if (caller->callees)
1257 caller->callees->prev_callee = edge;
1258 caller->callees = edge;
1260 /* Insert to callers list of the new callee. */
1261 edge->set_callee (callee);
1264 call_stmt_cannot_inline_p
1265 = !gimple_check_call_matching_types (call_stmt, callee->decl,
1268 /* We need to re-determine the inlining status of the edge. */
1269 initialize_inline_failed (edge);
1273 /* If necessary, change the function declaration in the call statement
1274 associated with E so that it corresponds to the edge callee. */
1277 cgraph_edge::redirect_call_stmt_to_callee (void)
1279 cgraph_edge *e = this;
1281 tree decl = gimple_call_fndecl (e->call_stmt);
1282 tree lhs = gimple_call_lhs (e->call_stmt);
1284 gimple_stmt_iterator gsi;
1285 #ifdef ENABLE_CHECKING
1295 e->speculative_call_info (e, e2, ref);
1296 /* If there already is an direct call (i.e. as a result of inliner's
1297 substitution), forget about speculating. */
1299 e = e->resolve_speculation (decl);
1300 /* If types do not match, speculation was likely wrong.
1301 The direct edge was posisbly redirected to the clone with a different
1302 signature. We did not update the call statement yet, so compare it
1303 with the reference that still points to the proper type. */
1304 else if (!gimple_check_call_matching_types (e->call_stmt,
1305 ref->referred->decl,
1309 fprintf (dump_file, "Not expanding speculative call of %s/%i -> %s/%i\n"
1311 xstrdup_for_dump (e->caller->name ()),
1313 xstrdup_for_dump (e->callee->name ()),
1315 e = e->resolve_speculation ();
1316 /* We are producing the final function body and will throw away the
1317 callgraph edges really soon. Reset the counts/frequencies to
1318 keep verifier happy in the case of roundoff errors. */
1319 e->count = gimple_bb (e->call_stmt)->count;
1320 e->frequency = compute_call_stmt_bb_frequency
1321 (e->caller->decl, gimple_bb (e->call_stmt));
1323 /* Expand speculation into GIMPLE code. */
1328 "Expanding speculative call of %s/%i -> %s/%i count:"
1330 xstrdup_for_dump (e->caller->name ()),
1332 xstrdup_for_dump (e->callee->name ()),
1335 gcc_assert (e2->speculative);
1336 push_cfun (DECL_STRUCT_FUNCTION (e->caller->decl));
1337 new_stmt = gimple_ic (e->call_stmt,
1338 dyn_cast<cgraph_node *> (ref->referred),
1339 e->count || e2->count
1340 ? RDIV (e->count * REG_BR_PROB_BASE,
1341 e->count + e2->count)
1342 : e->frequency || e2->frequency
1343 ? RDIV (e->frequency * REG_BR_PROB_BASE,
1344 e->frequency + e2->frequency)
1345 : REG_BR_PROB_BASE / 2,
1346 e->count, e->count + e2->count);
1347 e->speculative = false;
1348 e->caller->set_call_stmt_including_clones (e->call_stmt, new_stmt,
1351 /* Fix edges for BUILT_IN_CHKP_BNDRET calls attached to the
1352 processed call stmt. */
1353 if (gimple_call_with_bounds_p (new_stmt)
1354 && gimple_call_lhs (new_stmt)
1355 && chkp_retbnd_call_by_val (gimple_call_lhs (e2->call_stmt)))
1357 tree dresult = gimple_call_lhs (new_stmt);
1358 tree iresult = gimple_call_lhs (e2->call_stmt);
1359 gcall *dbndret = chkp_retbnd_call_by_val (dresult);
1360 gcall *ibndret = chkp_retbnd_call_by_val (iresult);
1361 struct cgraph_edge *iedge
1362 = e2->caller->cgraph_node::get_edge (ibndret);
1363 struct cgraph_edge *dedge;
1367 dedge = iedge->caller->create_edge (iedge->callee,
1370 dedge->frequency = compute_call_stmt_bb_frequency
1371 (dedge->caller->decl, gimple_bb (dedge->call_stmt));
1373 iedge->frequency = compute_call_stmt_bb_frequency
1374 (iedge->caller->decl, gimple_bb (iedge->call_stmt));
1377 e->frequency = compute_call_stmt_bb_frequency
1378 (e->caller->decl, gimple_bb (e->call_stmt));
1379 e2->frequency = compute_call_stmt_bb_frequency
1380 (e2->caller->decl, gimple_bb (e2->call_stmt));
1381 e2->speculative = false;
1382 ref->speculative = false;
1384 /* Indirect edges are not both in the call site hash.
1386 if (e->caller->call_site_hash)
1387 cgraph_update_edge_in_call_site_hash (e2);
1389 /* Continue redirecting E to proper target. */
1393 if (e->indirect_unknown_callee
1394 || decl == e->callee->decl)
1395 return e->call_stmt;
1397 #ifdef ENABLE_CHECKING
1400 node = cgraph_node::get (decl);
1401 gcc_assert (!node || !node->clone.combined_args_to_skip);
1405 if (symtab->dump_file)
1407 fprintf (symtab->dump_file, "updating call of %s/%i -> %s/%i: ",
1408 xstrdup_for_dump (e->caller->name ()), e->caller->order,
1409 xstrdup_for_dump (e->callee->name ()), e->callee->order);
1410 print_gimple_stmt (symtab->dump_file, e->call_stmt, 0, dump_flags);
1411 if (e->callee->clone.combined_args_to_skip)
1413 fprintf (symtab->dump_file, " combined args to skip: ");
1414 dump_bitmap (symtab->dump_file,
1415 e->callee->clone.combined_args_to_skip);
1419 if (e->callee->clone.combined_args_to_skip)
1424 = gimple_call_copy_skip_args (e->call_stmt,
1425 e->callee->clone.combined_args_to_skip);
1426 gimple_call_set_fndecl (new_stmt, e->callee->decl);
1427 gimple_call_set_fntype (new_stmt, gimple_call_fntype (e->call_stmt));
1429 if (gimple_vdef (new_stmt)
1430 && TREE_CODE (gimple_vdef (new_stmt)) == SSA_NAME)
1431 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt)) = new_stmt;
1433 gsi = gsi_for_stmt (e->call_stmt);
1434 gsi_replace (&gsi, new_stmt, false);
1435 /* We need to defer cleaning EH info on the new statement to
1436 fixup-cfg. We may not have dominator information at this point
1437 and thus would end up with unreachable blocks and have no way
1438 to communicate that we need to run CFG cleanup then. */
1439 lp_nr = lookup_stmt_eh_lp (e->call_stmt);
1442 remove_stmt_from_eh_lp (e->call_stmt);
1443 add_stmt_to_eh_lp (new_stmt, lp_nr);
1448 new_stmt = e->call_stmt;
1449 gimple_call_set_fndecl (new_stmt, e->callee->decl);
1450 update_stmt_fn (DECL_STRUCT_FUNCTION (e->caller->decl), new_stmt);
1453 /* If the call becomes noreturn, remove the lhs. */
1454 if (lhs && (gimple_call_flags (new_stmt) & ECF_NORETURN))
1456 if (TREE_CODE (lhs) == SSA_NAME)
1458 tree var = create_tmp_reg_fn (DECL_STRUCT_FUNCTION (e->caller->decl),
1459 TREE_TYPE (lhs), NULL);
1460 var = get_or_create_ssa_default_def
1461 (DECL_STRUCT_FUNCTION (e->caller->decl), var);
1462 gimple set_stmt = gimple_build_assign (lhs, var);
1463 gsi = gsi_for_stmt (new_stmt);
1464 gsi_insert_before_without_update (&gsi, set_stmt, GSI_SAME_STMT);
1465 update_stmt_fn (DECL_STRUCT_FUNCTION (e->caller->decl), set_stmt);
1467 gimple_call_set_lhs (new_stmt, NULL_TREE);
1468 update_stmt_fn (DECL_STRUCT_FUNCTION (e->caller->decl), new_stmt);
1471 /* If new callee has no static chain, remove it. */
1472 if (gimple_call_chain (new_stmt) && !DECL_STATIC_CHAIN (e->callee->decl))
1474 gimple_call_set_chain (new_stmt, NULL);
1475 update_stmt_fn (DECL_STRUCT_FUNCTION (e->caller->decl), new_stmt);
1478 maybe_remove_unused_call_args (DECL_STRUCT_FUNCTION (e->caller->decl),
1481 e->caller->set_call_stmt_including_clones (e->call_stmt, new_stmt, false);
1483 if (symtab->dump_file)
1485 fprintf (symtab->dump_file, " updated to:");
1486 print_gimple_stmt (symtab->dump_file, e->call_stmt, 0, dump_flags);
1491 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1492 OLD_STMT changed into NEW_STMT. OLD_CALL is gimple_call_fndecl
1493 of OLD_STMT if it was previously call statement.
1494 If NEW_STMT is NULL, the call has been dropped without any
1498 cgraph_update_edges_for_call_stmt_node (cgraph_node *node,
1499 gimple old_stmt, tree old_call,
1502 tree new_call = (new_stmt && is_gimple_call (new_stmt))
1503 ? gimple_call_fndecl (new_stmt) : 0;
1505 /* We are seeing indirect calls, then there is nothing to update. */
1506 if (!new_call && !old_call)
1508 /* See if we turned indirect call into direct call or folded call to one builtin
1509 into different builtin. */
1510 if (old_call != new_call)
1512 cgraph_edge *e = node->get_edge (old_stmt);
1513 cgraph_edge *ne = NULL;
1519 /* See if the edge is already there and has the correct callee. It
1520 might be so because of indirect inlining has already updated
1521 it. We also might've cloned and redirected the edge. */
1522 if (new_call && e->callee)
1524 cgraph_node *callee = e->callee;
1527 if (callee->decl == new_call
1528 || callee->former_clone_of == new_call)
1530 e->set_call_stmt (as_a <gcall *> (new_stmt));
1533 callee = callee->clone_of;
1537 /* Otherwise remove edge and create new one; we can't simply redirect
1538 since function has changed, so inline plan and other information
1539 attached to edge is invalid. */
1541 frequency = e->frequency;
1542 if (e->indirect_unknown_callee || e->inline_failed)
1545 e->callee->remove_symbol_and_inline_clones ();
1549 /* We are seeing new direct call; compute profile info based on BB. */
1550 basic_block bb = gimple_bb (new_stmt);
1552 frequency = compute_call_stmt_bb_frequency (current_function_decl,
1558 ne = node->create_edge (cgraph_node::get_create (new_call),
1559 as_a <gcall *> (new_stmt), count,
1561 gcc_assert (ne->inline_failed);
1564 /* We only updated the call stmt; update pointer in cgraph edge.. */
1565 else if (old_stmt != new_stmt)
1566 node->get_edge (old_stmt)->set_call_stmt (as_a <gcall *> (new_stmt));
1569 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1570 OLD_STMT changed into NEW_STMT. OLD_DECL is gimple_call_fndecl
1571 of OLD_STMT before it was updated (updating can happen inplace). */
1574 cgraph_update_edges_for_call_stmt (gimple old_stmt, tree old_decl, gimple new_stmt)
1576 cgraph_node *orig = cgraph_node::get (cfun->decl);
1579 gcc_checking_assert (orig);
1580 cgraph_update_edges_for_call_stmt_node (orig, old_stmt, old_decl, new_stmt);
1582 for (node = orig->clones; node != orig;)
1584 cgraph_update_edges_for_call_stmt_node (node, old_stmt, old_decl, new_stmt);
1586 node = node->clones;
1587 else if (node->next_sibling_clone)
1588 node = node->next_sibling_clone;
1591 while (node != orig && !node->next_sibling_clone)
1592 node = node->clone_of;
1594 node = node->next_sibling_clone;
1600 /* Remove all callees from the node. */
1603 cgraph_node::remove_callees (void)
1607 /* It is sufficient to remove the edges from the lists of callers of
1608 the callees. The callee list of the node can be zapped with one
1610 for (e = callees; e; e = f)
1613 symtab->call_edge_removal_hooks (e);
1614 if (!e->indirect_unknown_callee)
1615 e->remove_callee ();
1616 symtab->free_edge (e);
1618 for (e = indirect_calls; e; e = f)
1621 symtab->call_edge_removal_hooks (e);
1622 if (!e->indirect_unknown_callee)
1623 e->remove_callee ();
1624 symtab->free_edge (e);
1626 indirect_calls = NULL;
1630 call_site_hash->empty ();
1631 call_site_hash = NULL;
1635 /* Remove all callers from the node. */
1638 cgraph_node::remove_callers (void)
1642 /* It is sufficient to remove the edges from the lists of callees of
1643 the callers. The caller list of the node can be zapped with one
1645 for (e = callers; e; e = f)
1648 symtab->call_edge_removal_hooks (e);
1649 e->remove_caller ();
1650 symtab->free_edge (e);
1655 /* Helper function for cgraph_release_function_body and free_lang_data.
1656 It releases body from function DECL without having to inspect its
1657 possibly non-existent symtab node. */
1660 release_function_body (tree decl)
1662 if (DECL_STRUCT_FUNCTION (decl))
1664 if (DECL_STRUCT_FUNCTION (decl)->cfg
1665 || DECL_STRUCT_FUNCTION (decl)->gimple_df)
1667 push_cfun (DECL_STRUCT_FUNCTION (decl));
1671 cfun->curr_properties &= ~PROP_loops;
1672 loop_optimizer_finalize ();
1674 if (cfun->gimple_df)
1677 delete_tree_cfg_annotations ();
1682 gcc_assert (!dom_info_available_p (CDI_DOMINATORS));
1683 gcc_assert (!dom_info_available_p (CDI_POST_DOMINATORS));
1687 if (cfun->value_histograms)
1691 gimple_set_body (decl, NULL);
1692 /* Struct function hangs a lot of data that would leak if we didn't
1693 removed all pointers to it. */
1694 ggc_free (DECL_STRUCT_FUNCTION (decl));
1695 DECL_STRUCT_FUNCTION (decl) = NULL;
1697 DECL_SAVED_TREE (decl) = NULL;
1700 /* Release memory used to represent body of function.
1701 Use this only for functions that are released before being translated to
1702 target code (i.e. RTL). Functions that are compiled to RTL and beyond
1703 are free'd in final.c via free_after_compilation().
1704 KEEP_ARGUMENTS are useful only if you want to rebuild body as thunk. */
1707 cgraph_node::release_body (bool keep_arguments)
1709 ipa_transforms_to_apply.release ();
1710 if (!used_as_abstract_origin && symtab->state != PARSING)
1712 DECL_RESULT (decl) = NULL;
1714 if (!keep_arguments)
1715 DECL_ARGUMENTS (decl) = NULL;
1717 /* If the node is abstract and needed, then do not clear DECL_INITIAL
1718 of its associated function function declaration because it's
1719 needed to emit debug info later. */
1720 if (!used_as_abstract_origin && DECL_INITIAL (decl))
1721 DECL_INITIAL (decl) = error_mark_node;
1722 release_function_body (decl);
1725 lto_free_function_in_decl_state_for_node (this);
1726 lto_file_data = NULL;
1730 /* Remove function from symbol table. */
1733 cgraph_node::remove (void)
1736 int uid = this->uid;
1738 symtab->call_cgraph_removal_hooks (this);
1741 ipa_transforms_to_apply.release ();
1743 /* Incremental inlining access removed nodes stored in the postorder list.
1745 force_output = false;
1746 forced_by_abi = false;
1747 for (n = nested; n; n = n->next_nested)
1752 cgraph_node **node2 = &origin->nested;
1754 while (*node2 != this)
1755 node2 = &(*node2)->next_nested;
1756 *node2 = next_nested;
1759 if (prev_sibling_clone)
1760 prev_sibling_clone->next_sibling_clone = next_sibling_clone;
1762 clone_of->clones = next_sibling_clone;
1763 if (next_sibling_clone)
1764 next_sibling_clone->prev_sibling_clone = prev_sibling_clone;
1767 cgraph_node *n, *next;
1771 for (n = clones; n->next_sibling_clone; n = n->next_sibling_clone)
1772 n->clone_of = clone_of;
1773 n->clone_of = clone_of;
1774 n->next_sibling_clone = clone_of->clones;
1775 if (clone_of->clones)
1776 clone_of->clones->prev_sibling_clone = n;
1777 clone_of->clones = clones;
1781 /* We are removing node with clones. This makes clones inconsistent,
1782 but assume they will be removed subsequently and just keep clone
1783 tree intact. This can happen in unreachable function removal since
1784 we remove unreachable functions in random order, not by bottom-up
1785 walk of clone trees. */
1786 for (n = clones; n; n = next)
1788 next = n->next_sibling_clone;
1789 n->next_sibling_clone = NULL;
1790 n->prev_sibling_clone = NULL;
1796 /* While all the clones are removed after being proceeded, the function
1797 itself is kept in the cgraph even after it is compiled. Check whether
1798 we are done with this body and reclaim it proactively if this is the case.
1800 if (symtab->state != LTO_STREAMING)
1802 n = cgraph_node::get (decl);
1804 || (!n->clones && !n->clone_of && !n->global.inlined_to
1805 && ((symtab->global_info_ready || in_lto_p)
1806 && (TREE_ASM_WRITTEN (n->decl)
1807 || DECL_EXTERNAL (n->decl)
1809 || (!flag_wpa && n->in_other_partition)))))
1814 lto_free_function_in_decl_state_for_node (this);
1815 lto_file_data = NULL;
1821 call_site_hash->empty ();
1822 call_site_hash = NULL;
1825 if (instrumented_version)
1827 instrumented_version->instrumented_version = NULL;
1828 instrumented_version = NULL;
1831 symtab->release_symbol (this, uid);
1834 /* Likewise indicate that a node is having address taken. */
1837 cgraph_node::mark_address_taken (void)
1839 /* Indirect inlining can figure out that all uses of the address are
1841 if (global.inlined_to)
1843 gcc_assert (cfun->after_inlining);
1844 gcc_assert (callers->indirect_inlining_edge);
1847 /* FIXME: address_taken flag is used both as a shortcut for testing whether
1848 IPA_REF_ADDR reference exists (and thus it should be set on node
1849 representing alias we take address of) and as a test whether address
1850 of the object was taken (and thus it should be set on node alias is
1851 referring to). We should remove the first use and the remove the
1854 cgraph_node *node = ultimate_alias_target ();
1855 node->address_taken = 1;
1858 /* Return local info for the compiled function. */
1861 cgraph_node::local_info (tree decl)
1863 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
1864 cgraph_node *node = get (decl);
1867 return &node->ultimate_alias_target ()->local;
1870 /* Return local info for the compiled function. */
1873 cgraph_node::rtl_info (tree decl)
1875 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
1876 cgraph_node *node = get (decl);
1879 node = node->ultimate_alias_target ();
1880 if (node->decl != current_function_decl
1881 && !TREE_ASM_WRITTEN (node->decl))
1883 return &node->ultimate_alias_target ()->rtl;
1886 /* Return a string describing the failure REASON. */
1889 cgraph_inline_failed_string (cgraph_inline_failed_t reason)
1892 #define DEFCIFCODE(code, type, string) string,
1894 static const char *cif_string_table[CIF_N_REASONS] = {
1895 #include "cif-code.def"
1898 /* Signedness of an enum type is implementation defined, so cast it
1899 to unsigned before testing. */
1900 gcc_assert ((unsigned) reason < CIF_N_REASONS);
1901 return cif_string_table[reason];
1904 /* Return a type describing the failure REASON. */
1906 cgraph_inline_failed_type_t
1907 cgraph_inline_failed_type (cgraph_inline_failed_t reason)
1910 #define DEFCIFCODE(code, type, string) type,
1912 static cgraph_inline_failed_type_t cif_type_table[CIF_N_REASONS] = {
1913 #include "cif-code.def"
1916 /* Signedness of an enum type is implementation defined, so cast it
1917 to unsigned before testing. */
1918 gcc_assert ((unsigned) reason < CIF_N_REASONS);
1919 return cif_type_table[reason];
1922 /* Names used to print out the availability enum. */
1923 const char * const cgraph_availability_names[] =
1924 {"unset", "not_available", "overwritable", "available", "local"};
1926 /* Output flags of edge to a file F. */
1929 cgraph_edge::dump_edge_flags (FILE *f)
1932 fprintf (f, "(speculative) ");
1934 fprintf (f, "(inlined) ");
1935 if (indirect_inlining_edge)
1936 fprintf (f, "(indirect_inlining) ");
1938 fprintf (f, "(%"PRId64"x) ", (int64_t)count);
1940 fprintf (f, "(%.2f per call) ", frequency / (double)CGRAPH_FREQ_BASE);
1941 if (can_throw_external)
1942 fprintf (f, "(can throw external) ");
1945 /* Dump call graph node to file F. */
1948 cgraph_node::dump (FILE *f)
1954 if (global.inlined_to)
1955 fprintf (f, " Function %s/%i is inline copy in %s/%i\n",
1956 xstrdup_for_dump (name ()),
1958 xstrdup_for_dump (global.inlined_to->name ()),
1959 global.inlined_to->order);
1961 fprintf (f, " Clone of %s/%i\n",
1962 clone_of->asm_name (),
1964 if (symtab->function_flags_ready)
1965 fprintf (f, " Availability: %s\n",
1966 cgraph_availability_names [get_availability ()]);
1969 fprintf (f, " Profile id: %i\n",
1971 fprintf (f, " First run: %i\n", tp_first_run);
1972 fprintf (f, " Function flags:");
1974 fprintf (f, " executed %"PRId64"x",
1977 fprintf (f, " nested in: %s", origin->asm_name ());
1978 if (gimple_has_body_p (decl))
1979 fprintf (f, " body");
1981 fprintf (f, " process");
1983 fprintf (f, " local");
1984 if (local.redefined_extern_inline)
1985 fprintf (f, " redefined_extern_inline");
1986 if (only_called_at_startup)
1987 fprintf (f, " only_called_at_startup");
1988 if (only_called_at_exit)
1989 fprintf (f, " only_called_at_exit");
1991 fprintf (f, " tm_clone");
1993 fprintf (f, " icf_merged");
1995 fprintf (f, " nonfreeing_fn");
1996 if (DECL_STATIC_CONSTRUCTOR (decl))
1997 fprintf (f," static_constructor (priority:%i)", get_init_priority ());
1998 if (DECL_STATIC_DESTRUCTOR (decl))
1999 fprintf (f," static_destructor (priority:%i)", get_fini_priority ());
2000 if (frequency == NODE_FREQUENCY_HOT)
2001 fprintf (f, " hot");
2002 if (frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED)
2003 fprintf (f, " unlikely_executed");
2004 if (frequency == NODE_FREQUENCY_EXECUTED_ONCE)
2005 fprintf (f, " executed_once");
2006 if (only_called_at_startup)
2007 fprintf (f, " only_called_at_startup");
2008 if (only_called_at_exit)
2009 fprintf (f, " only_called_at_exit");
2010 if (opt_for_fn (decl, optimize_size))
2011 fprintf (f, " optimize_size");
2017 fprintf (f, " Thunk");
2019 fprintf (f, " of %s (asm: %s)",
2020 lang_hooks.decl_printable_name (thunk.alias, 2),
2021 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk.alias)));
2022 fprintf (f, " fixed offset %i virtual value %i has "
2023 "virtual offset %i)\n",
2024 (int)thunk.fixed_offset,
2025 (int)thunk.virtual_value,
2026 (int)thunk.virtual_offset_p);
2028 if (alias && thunk.alias
2029 && DECL_P (thunk.alias))
2031 fprintf (f, " Alias of %s",
2032 lang_hooks.decl_printable_name (thunk.alias, 2));
2033 if (DECL_ASSEMBLER_NAME_SET_P (thunk.alias))
2034 fprintf (f, " (asm: %s)",
2035 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk.alias)));
2039 fprintf (f, " Called by: ");
2041 for (edge = callers; edge; edge = edge->next_caller)
2043 fprintf (f, "%s/%i ", edge->caller->asm_name (),
2044 edge->caller->order);
2045 edge->dump_edge_flags (f);
2048 fprintf (f, "\n Calls: ");
2049 for (edge = callees; edge; edge = edge->next_callee)
2051 fprintf (f, "%s/%i ", edge->callee->asm_name (),
2052 edge->callee->order);
2053 edge->dump_edge_flags (f);
2057 for (edge = indirect_calls; edge; edge = edge->next_callee)
2059 if (edge->indirect_info->polymorphic)
2061 fprintf (f, " Polymorphic indirect call of type ");
2062 print_generic_expr (f, edge->indirect_info->otr_type, TDF_SLIM);
2063 fprintf (f, " token:%i", (int) edge->indirect_info->otr_token);
2066 fprintf (f, " Indirect call");
2067 edge->dump_edge_flags (f);
2068 if (edge->indirect_info->param_index != -1)
2070 fprintf (f, " of param:%i", edge->indirect_info->param_index);
2071 if (edge->indirect_info->agg_contents)
2072 fprintf (f, " loaded from %s %s at offset %i",
2073 edge->indirect_info->member_ptr ? "member ptr" : "aggregate",
2074 edge->indirect_info->by_ref ? "passed by reference":"",
2075 (int)edge->indirect_info->offset);
2076 if (edge->indirect_info->vptr_changed)
2077 fprintf (f, " (vptr maybe changed)");
2080 if (edge->indirect_info->polymorphic)
2081 edge->indirect_info->context.dump (f);
2084 if (instrumentation_clone)
2085 fprintf (f, " Is instrumented version.\n");
2086 else if (instrumented_version)
2087 fprintf (f, " Has instrumented version.\n");
2090 /* Dump call graph node NODE to stderr. */
2093 cgraph_node::debug (void)
2098 /* Dump the callgraph to file F. */
2101 cgraph_node::dump_cgraph (FILE *f)
2105 fprintf (f, "callgraph:\n\n");
2106 FOR_EACH_FUNCTION (node)
2110 /* Return true when the DECL can possibly be inlined. */
2113 cgraph_function_possibly_inlined_p (tree decl)
2115 if (!symtab->global_info_ready)
2116 return !DECL_UNINLINABLE (decl);
2117 return DECL_POSSIBLY_INLINED (decl);
2120 /* cgraph_node is no longer nested function; update cgraph accordingly. */
2122 cgraph_node::unnest (void)
2124 cgraph_node **node2 = &origin->nested;
2125 gcc_assert (origin);
2127 while (*node2 != this)
2128 node2 = &(*node2)->next_nested;
2129 *node2 = next_nested;
2133 /* Return function availability. See cgraph.h for description of individual
2136 cgraph_node::get_availability (void)
2138 enum availability avail;
2140 avail = AVAIL_NOT_AVAILABLE;
2141 else if (local.local)
2142 avail = AVAIL_LOCAL;
2143 else if (alias && weakref)
2144 ultimate_alias_target (&avail);
2145 else if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl)))
2146 avail = AVAIL_INTERPOSABLE;
2147 else if (!externally_visible)
2148 avail = AVAIL_AVAILABLE;
2149 /* Inline functions are safe to be analyzed even if their symbol can
2150 be overwritten at runtime. It is not meaningful to enforce any sane
2151 behaviour on replacing inline function by different body. */
2152 else if (DECL_DECLARED_INLINE_P (decl))
2153 avail = AVAIL_AVAILABLE;
2155 /* If the function can be overwritten, return OVERWRITABLE. Take
2156 care at least of two notable extensions - the COMDAT functions
2157 used to share template instantiations in C++ (this is symmetric
2158 to code cp_cannot_inline_tree_fn and probably shall be shared and
2159 the inlinability hooks completely eliminated).
2161 ??? Does the C++ one definition rule allow us to always return
2162 AVAIL_AVAILABLE here? That would be good reason to preserve this
2165 else if (decl_replaceable_p (decl) && !DECL_EXTERNAL (decl))
2166 avail = AVAIL_INTERPOSABLE;
2167 else avail = AVAIL_AVAILABLE;
2172 /* Worker for cgraph_node_can_be_local_p. */
2174 cgraph_node_cannot_be_local_p_1 (cgraph_node *node, void *)
2176 return !(!node->force_output
2177 && ((DECL_COMDAT (node->decl)
2178 && !node->forced_by_abi
2179 && !node->used_from_object_file_p ()
2180 && !node->same_comdat_group)
2181 || !node->externally_visible));
2184 /* Return true if cgraph_node can be made local for API change.
2185 Extern inline functions and C++ COMDAT functions can be made local
2186 at the expense of possible code size growth if function is used in multiple
2187 compilation units. */
2189 cgraph_node::can_be_local_p (void)
2191 return (!address_taken
2192 && !call_for_symbol_thunks_and_aliases (cgraph_node_cannot_be_local_p_1,
2196 /* Call callback on cgraph_node, thunks and aliases associated to cgraph_node.
2197 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
2198 skipped. When EXCLUDE_VIRTUAL_THUNKS is true, virtual thunks are
2201 cgraph_node::call_for_symbol_thunks_and_aliases (bool (*callback)
2202 (cgraph_node *, void *),
2204 bool include_overwritable,
2205 bool exclude_virtual_thunks)
2210 if (callback (this, data))
2212 FOR_EACH_ALIAS (this, ref)
2214 cgraph_node *alias = dyn_cast <cgraph_node *> (ref->referring);
2215 if (include_overwritable
2216 || alias->get_availability () > AVAIL_INTERPOSABLE)
2217 if (alias->call_for_symbol_thunks_and_aliases (callback, data,
2218 include_overwritable,
2219 exclude_virtual_thunks))
2222 for (e = callers; e; e = e->next_caller)
2223 if (e->caller->thunk.thunk_p
2224 && (include_overwritable
2225 || e->caller->get_availability () > AVAIL_INTERPOSABLE)
2226 && !(exclude_virtual_thunks
2227 && e->caller->thunk.virtual_offset_p))
2228 if (e->caller->call_for_symbol_thunks_and_aliases (callback, data,
2229 include_overwritable,
2230 exclude_virtual_thunks))
2236 /* Worker to bring NODE local. */
2239 cgraph_node::make_local (cgraph_node *node, void *)
2241 gcc_checking_assert (node->can_be_local_p ());
2242 if (DECL_COMDAT (node->decl) || DECL_EXTERNAL (node->decl))
2244 node->make_decl_local ();
2245 node->set_section (NULL);
2246 node->set_comdat_group (NULL);
2247 node->externally_visible = false;
2248 node->forced_by_abi = false;
2249 node->local.local = true;
2250 node->set_section (NULL);
2251 node->unique_name = (node->resolution == LDPR_PREVAILING_DEF_IRONLY
2252 || node->resolution == LDPR_PREVAILING_DEF_IRONLY_EXP);
2253 node->resolution = LDPR_PREVAILING_DEF_IRONLY;
2254 gcc_assert (node->get_availability () == AVAIL_LOCAL);
2259 /* Bring cgraph node local. */
2262 cgraph_node::make_local (void)
2264 call_for_symbol_thunks_and_aliases (cgraph_node::make_local, NULL, true);
2267 /* Worker to set nothrow flag. */
2270 cgraph_set_nothrow_flag_1 (cgraph_node *node, void *data)
2274 TREE_NOTHROW (node->decl) = data != NULL;
2277 for (e = node->callers; e; e = e->next_caller)
2278 e->can_throw_external = false;
2282 /* Set TREE_NOTHROW on NODE's decl and on aliases of NODE
2283 if any to NOTHROW. */
2286 cgraph_node::set_nothrow_flag (bool nothrow)
2288 call_for_symbol_thunks_and_aliases (cgraph_set_nothrow_flag_1,
2289 (void *)(size_t)nothrow, false);
2292 /* Worker to set const flag. */
2295 cgraph_set_const_flag_1 (cgraph_node *node, void *data)
2297 /* Static constructors and destructors without a side effect can be
2299 if (data && !((size_t)data & 2))
2301 if (DECL_STATIC_CONSTRUCTOR (node->decl))
2302 DECL_STATIC_CONSTRUCTOR (node->decl) = 0;
2303 if (DECL_STATIC_DESTRUCTOR (node->decl))
2304 DECL_STATIC_DESTRUCTOR (node->decl) = 0;
2306 TREE_READONLY (node->decl) = data != NULL;
2307 DECL_LOOPING_CONST_OR_PURE_P (node->decl) = ((size_t)data & 2) != 0;
2311 /* Set TREE_READONLY on cgraph_node's decl and on aliases of the node
2312 if any to READONLY. */
2315 cgraph_node::set_const_flag (bool readonly, bool looping)
2317 call_for_symbol_thunks_and_aliases (cgraph_set_const_flag_1,
2318 (void *)(size_t)(readonly + (int)looping * 2),
2322 /* Worker to set pure flag. */
2325 cgraph_set_pure_flag_1 (cgraph_node *node, void *data)
2327 /* Static constructors and destructors without a side effect can be
2329 if (data && !((size_t)data & 2))
2331 if (DECL_STATIC_CONSTRUCTOR (node->decl))
2332 DECL_STATIC_CONSTRUCTOR (node->decl) = 0;
2333 if (DECL_STATIC_DESTRUCTOR (node->decl))
2334 DECL_STATIC_DESTRUCTOR (node->decl) = 0;
2336 DECL_PURE_P (node->decl) = data != NULL;
2337 DECL_LOOPING_CONST_OR_PURE_P (node->decl) = ((size_t)data & 2) != 0;
2341 /* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node
2345 cgraph_node::set_pure_flag (bool pure, bool looping)
2347 call_for_symbol_thunks_and_aliases (cgraph_set_pure_flag_1,
2348 (void *)(size_t)(pure + (int)looping * 2),
2352 /* Return true when cgraph_node can not return or throw and thus
2353 it is safe to ignore its side effects for IPA analysis. */
2356 cgraph_node::cannot_return_p (void)
2358 int flags = flags_from_decl_or_type (decl);
2359 if (!opt_for_fn (decl, flag_exceptions))
2360 return (flags & ECF_NORETURN) != 0;
2362 return ((flags & (ECF_NORETURN | ECF_NOTHROW))
2363 == (ECF_NORETURN | ECF_NOTHROW));
2366 /* Return true when call of edge can not lead to return from caller
2367 and thus it is safe to ignore its side effects for IPA analysis
2368 when computing side effects of the caller.
2369 FIXME: We could actually mark all edges that have no reaching
2370 patch to the exit block or throw to get better results. */
2372 cgraph_edge::cannot_lead_to_return_p (void)
2374 if (caller->cannot_return_p ())
2376 if (indirect_unknown_callee)
2378 int flags = indirect_info->ecf_flags;
2379 if (!opt_for_fn (caller->decl, flag_exceptions))
2380 return (flags & ECF_NORETURN) != 0;
2382 return ((flags & (ECF_NORETURN | ECF_NOTHROW))
2383 == (ECF_NORETURN | ECF_NOTHROW));
2386 return callee->cannot_return_p ();
2389 /* Return true if the call can be hot. */
2392 cgraph_edge::maybe_hot_p (void)
2394 /* TODO: Export profile_status from cfun->cfg to cgraph_node. */
2396 && opt_for_fn (caller->decl, flag_branch_probabilities)
2397 && !maybe_hot_count_p (NULL, count))
2399 if (caller->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED
2401 && callee->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED))
2403 if (caller->frequency > NODE_FREQUENCY_UNLIKELY_EXECUTED
2405 && callee->frequency <= NODE_FREQUENCY_EXECUTED_ONCE))
2407 if (opt_for_fn (caller->decl, optimize_size))
2409 if (caller->frequency == NODE_FREQUENCY_HOT)
2411 if (caller->frequency == NODE_FREQUENCY_EXECUTED_ONCE
2412 && frequency < CGRAPH_FREQ_BASE * 3 / 2)
2414 if (opt_for_fn (caller->decl, flag_guess_branch_prob))
2416 if (PARAM_VALUE (HOT_BB_FREQUENCY_FRACTION) == 0
2417 || frequency <= (CGRAPH_FREQ_BASE
2418 / PARAM_VALUE (HOT_BB_FREQUENCY_FRACTION)))
2424 /* Worker for cgraph_can_remove_if_no_direct_calls_p. */
2427 nonremovable_p (cgraph_node *node, void *)
2429 return !node->can_remove_if_no_direct_calls_and_refs_p ();
2432 /* Return true if whole comdat group can be removed if there are no direct
2436 cgraph_node::can_remove_if_no_direct_calls_p (bool will_inline)
2438 struct ipa_ref *ref;
2440 /* For local symbols or non-comdat group it is the same as
2441 can_remove_if_no_direct_calls_p. */
2442 if (!externally_visible || !same_comdat_group)
2444 if (DECL_EXTERNAL (decl))
2448 return !call_for_symbol_and_aliases (nonremovable_p, NULL, true);
2451 if (will_inline && address_taken)
2454 /* Otheriwse check if we can remove the symbol itself and then verify
2455 that only uses of the comdat groups are direct call to THIS
2457 if (!can_remove_if_no_direct_calls_and_refs_p ())
2460 /* Check that all refs come from within the comdat group. */
2461 for (int i = 0; iterate_referring (i, ref); i++)
2462 if (ref->referring->get_comdat_group () != get_comdat_group ())
2465 struct cgraph_node *target = ultimate_alias_target ();
2466 for (cgraph_node *next = dyn_cast<cgraph_node *> (same_comdat_group);
2467 next != this; next = dyn_cast<cgraph_node *> (next->same_comdat_group))
2469 if (!externally_visible)
2472 && !next->can_remove_if_no_direct_calls_and_refs_p ())
2475 /* If we see different symbol than THIS, be sure to check calls. */
2476 if (next->ultimate_alias_target () != target)
2477 for (cgraph_edge *e = next->callers; e; e = e->next_caller)
2478 if (e->caller->get_comdat_group () != get_comdat_group ()
2482 /* If function is not being inlined, we care only about
2483 references outside of the comdat group. */
2485 for (int i = 0; next->iterate_referring (i, ref); i++)
2486 if (ref->referring->get_comdat_group () != get_comdat_group ())
2492 /* Return true when function cgraph_node can be expected to be removed
2493 from program when direct calls in this compilation unit are removed.
2495 As a special case COMDAT functions are
2496 cgraph_can_remove_if_no_direct_calls_p while the are not
2497 cgraph_only_called_directly_p (it is possible they are called from other
2500 This function behaves as cgraph_only_called_directly_p because eliminating
2501 all uses of COMDAT function does not make it necessarily disappear from
2502 the program unless we are compiling whole program or we do LTO. In this
2503 case we know we win since dynamic linking will not really discard the
2504 linkonce section. */
2507 cgraph_node::will_be_removed_from_program_if_no_direct_calls_p
2510 gcc_assert (!global.inlined_to);
2511 if (DECL_EXTERNAL (decl))
2514 if (!in_lto_p && !flag_whole_program)
2516 /* If the symbol is in comdat group, we need to verify that whole comdat
2517 group becomes unreachable. Technically we could skip references from
2518 within the group, too. */
2519 if (!only_called_directly_p ())
2521 if (same_comdat_group && externally_visible)
2523 struct cgraph_node *target = ultimate_alias_target ();
2525 if (will_inline && address_taken)
2527 for (cgraph_node *next = dyn_cast<cgraph_node *> (same_comdat_group);
2529 next = dyn_cast<cgraph_node *> (next->same_comdat_group))
2531 if (!externally_visible)
2534 && !next->only_called_directly_p ())
2537 /* If we see different symbol than THIS,
2538 be sure to check calls. */
2539 if (next->ultimate_alias_target () != target)
2540 for (cgraph_edge *e = next->callers; e; e = e->next_caller)
2541 if (e->caller->get_comdat_group () != get_comdat_group ()
2549 return can_remove_if_no_direct_calls_p (will_inline);
2553 /* Worker for cgraph_only_called_directly_p. */
2556 cgraph_not_only_called_directly_p_1 (cgraph_node *node, void *)
2558 return !node->only_called_directly_or_aliased_p ();
2561 /* Return true when function cgraph_node and all its aliases are only called
2563 i.e. it is not externally visible, address was not taken and
2564 it is not used in any other non-standard way. */
2567 cgraph_node::only_called_directly_p (void)
2569 gcc_assert (ultimate_alias_target () == this);
2570 return !call_for_symbol_and_aliases (cgraph_not_only_called_directly_p_1,
2575 /* Collect all callers of NODE. Worker for collect_callers_of_node. */
2578 collect_callers_of_node_1 (cgraph_node *node, void *data)
2580 vec<cgraph_edge *> *redirect_callers = (vec<cgraph_edge *> *)data;
2582 enum availability avail;
2583 node->ultimate_alias_target (&avail);
2585 if (avail > AVAIL_INTERPOSABLE)
2586 for (cs = node->callers; cs != NULL; cs = cs->next_caller)
2587 if (!cs->indirect_inlining_edge)
2588 redirect_callers->safe_push (cs);
2592 /* Collect all callers of cgraph_node and its aliases that are known to lead to
2593 cgraph_node (i.e. are not overwritable). */
2596 cgraph_node::collect_callers (void)
2598 vec<cgraph_edge *> redirect_callers = vNULL;
2599 call_for_symbol_thunks_and_aliases (collect_callers_of_node_1,
2600 &redirect_callers, false);
2601 return redirect_callers;
2604 /* Return TRUE if NODE2 a clone of NODE or is equivalent to it. */
2607 clone_of_p (cgraph_node *node, cgraph_node *node2)
2609 bool skipped_thunk = false;
2610 node = node->ultimate_alias_target ();
2611 node2 = node2->ultimate_alias_target ();
2613 /* There are no virtual clones of thunks so check former_clone_of or if we
2614 might have skipped thunks because this adjustments are no longer
2616 while (node->thunk.thunk_p)
2618 if (node2->former_clone_of == node->decl)
2620 if (!node->thunk.this_adjusting)
2622 node = node->callees->callee->ultimate_alias_target ();
2623 skipped_thunk = true;
2628 if (!node2->clone.args_to_skip
2629 || !bitmap_bit_p (node2->clone.args_to_skip, 0))
2631 if (node2->former_clone_of == node->decl)
2633 else if (!node2->clone_of)
2637 while (node != node2 && node2)
2638 node2 = node2->clone_of;
2639 return node2 != NULL;
2642 /* Verify edge count and frequency. */
2645 cgraph_edge::verify_count_and_frequency ()
2647 bool error_found = false;
2650 error ("caller edge count is negative");
2655 error ("caller edge frequency is negative");
2658 if (frequency > CGRAPH_FREQ_MAX)
2660 error ("caller edge frequency is too large");
2663 if (gimple_has_body_p (caller->decl)
2664 && !caller->global.inlined_to
2666 /* FIXME: Inline-analysis sets frequency to 0 when edge is optimized out.
2667 Remove this once edges are actually removed from the function at that time. */
2669 || (inline_edge_summary_vec.exists ()
2670 && ((inline_edge_summary_vec.length () <= (unsigned) uid)
2671 || !inline_edge_summary (this)->predicate)))
2673 != compute_call_stmt_bb_frequency (caller->decl,
2674 gimple_bb (call_stmt))))
2676 error ("caller edge frequency %i does not match BB frequency %i",
2678 compute_call_stmt_bb_frequency (caller->decl,
2679 gimple_bb (call_stmt)));
2685 /* Switch to THIS_CFUN if needed and print STMT to stderr. */
2687 cgraph_debug_gimple_stmt (function *this_cfun, gimple stmt)
2689 bool fndecl_was_null = false;
2690 /* debug_gimple_stmt needs correct cfun */
2691 if (cfun != this_cfun)
2692 set_cfun (this_cfun);
2693 /* ...and an actual current_function_decl */
2694 if (!current_function_decl)
2696 current_function_decl = this_cfun->decl;
2697 fndecl_was_null = true;
2699 debug_gimple_stmt (stmt);
2700 if (fndecl_was_null)
2701 current_function_decl = NULL;
2704 /* Verify that call graph edge corresponds to DECL from the associated
2705 statement. Return true if the verification should fail. */
2708 cgraph_edge::verify_corresponds_to_fndecl (tree decl)
2712 if (!decl || callee->global.inlined_to)
2714 if (symtab->state == LTO_STREAMING)
2716 node = cgraph_node::get (decl);
2718 /* We do not know if a node from a different partition is an alias or what it
2719 aliases and therefore cannot do the former_clone_of check reliably. When
2720 body_removed is set, we have lost all information about what was alias or
2721 thunk of and also cannot proceed. */
2723 || node->body_removed
2724 || node->in_other_partition
2725 || callee->icf_merged
2726 || callee->in_other_partition)
2729 node = node->ultimate_alias_target ();
2731 /* Optimizers can redirect unreachable calls or calls triggering undefined
2732 behaviour to builtin_unreachable. */
2733 if (DECL_BUILT_IN_CLASS (callee->decl) == BUILT_IN_NORMAL
2734 && DECL_FUNCTION_CODE (callee->decl) == BUILT_IN_UNREACHABLE)
2737 if (callee->former_clone_of != node->decl
2738 && (node != callee->ultimate_alias_target ())
2739 && !clone_of_p (node, callee))
2745 /* Verify cgraph nodes of given cgraph node. */
2747 cgraph_node::verify_node (void)
2750 function *this_cfun = DECL_STRUCT_FUNCTION (decl);
2751 basic_block this_block;
2752 gimple_stmt_iterator gsi;
2753 bool error_found = false;
2758 timevar_push (TV_CGRAPH_VERIFY);
2759 error_found |= verify_base ();
2760 for (e = callees; e; e = e->next_callee)
2763 error ("aux field set for edge %s->%s",
2764 identifier_to_locale (e->caller->name ()),
2765 identifier_to_locale (e->callee->name ()));
2770 error ("execution count is negative");
2773 if (global.inlined_to && same_comdat_group)
2775 error ("inline clone in same comdat group list");
2778 if (!definition && !in_other_partition && local.local)
2780 error ("local symbols must be defined");
2783 if (global.inlined_to && externally_visible)
2785 error ("externally visible inline clone");
2788 if (global.inlined_to && address_taken)
2790 error ("inline clone with address taken");
2793 if (global.inlined_to && force_output)
2795 error ("inline clone is forced to output");
2798 for (e = indirect_calls; e; e = e->next_callee)
2802 error ("aux field set for indirect edge from %s",
2803 identifier_to_locale (e->caller->name ()));
2806 if (!e->indirect_unknown_callee
2807 || !e->indirect_info)
2809 error ("An indirect edge from %s is not marked as indirect or has "
2810 "associated indirect_info, the corresponding statement is: ",
2811 identifier_to_locale (e->caller->name ()));
2812 cgraph_debug_gimple_stmt (this_cfun, e->call_stmt);
2816 bool check_comdat = comdat_local_p ();
2817 for (e = callers; e; e = e->next_caller)
2819 if (e->verify_count_and_frequency ())
2822 && !in_same_comdat_group_p (e->caller))
2824 error ("comdat-local function called by %s outside its comdat",
2825 identifier_to_locale (e->caller->name ()));
2828 if (!e->inline_failed)
2830 if (global.inlined_to
2831 != (e->caller->global.inlined_to
2832 ? e->caller->global.inlined_to : e->caller))
2834 error ("inlined_to pointer is wrong");
2837 if (callers->next_caller)
2839 error ("multiple inline callers");
2844 if (global.inlined_to)
2846 error ("inlined_to pointer set for noninline callers");
2850 for (e = indirect_calls; e; e = e->next_callee)
2851 if (e->verify_count_and_frequency ())
2853 if (!callers && global.inlined_to)
2855 error ("inlined_to pointer is set but no predecessors found");
2858 if (global.inlined_to == this)
2860 error ("inlined_to pointer refers to itself");
2867 for (n = clone_of->clones; n; n = n->next_sibling_clone)
2872 error ("cgraph_node has wrong clone_of");
2879 for (n = clones; n; n = n->next_sibling_clone)
2880 if (n->clone_of != this)
2884 error ("cgraph_node has wrong clone list");
2888 if ((prev_sibling_clone || next_sibling_clone) && !clone_of)
2890 error ("cgraph_node is in clone list but it is not clone");
2893 if (!prev_sibling_clone && clone_of && clone_of->clones != this)
2895 error ("cgraph_node has wrong prev_clone pointer");
2898 if (prev_sibling_clone && prev_sibling_clone->next_sibling_clone != this)
2900 error ("double linked list of clones corrupted");
2904 if (analyzed && alias)
2906 bool ref_found = false;
2908 ipa_ref *ref = NULL;
2912 error ("Alias has call edges");
2915 for (i = 0; iterate_reference (i, ref); i++)
2916 if (ref->use == IPA_REF_CHKP)
2918 else if (ref->use != IPA_REF_ALIAS)
2920 error ("Alias has non-alias reference");
2925 error ("Alias has more than one alias reference");
2932 error ("Analyzed alias has no reference");
2937 /* Check instrumented version reference. */
2938 if (instrumented_version
2939 && instrumented_version->instrumented_version != this)
2941 error ("Instrumentation clone does not reference original node");
2945 /* Cannot have orig_decl for not instrumented nodes. */
2946 if (!instrumentation_clone && orig_decl)
2948 error ("Not instrumented node has non-NULL original declaration");
2952 /* If original not instrumented node still exists then we may check
2953 original declaration is set properly. */
2954 if (instrumented_version
2956 && orig_decl != instrumented_version->decl)
2958 error ("Instrumented node has wrong original declaration");
2962 /* Check all nodes have chkp reference to their instrumented versions. */
2964 && instrumented_version
2965 && !instrumentation_clone)
2967 bool ref_found = false;
2969 struct ipa_ref *ref;
2971 for (i = 0; iterate_reference (i, ref); i++)
2972 if (ref->use == IPA_REF_CHKP)
2976 error ("Node has more than one chkp reference");
2979 if (ref->referred != instrumented_version)
2981 error ("Wrong node is referenced with chkp reference");
2989 error ("Analyzed node has no reference to instrumented version");
2994 if (analyzed && thunk.thunk_p)
2998 error ("No edge out of thunk node");
3001 else if (callees->next_callee)
3003 error ("More than one edge out of thunk node");
3006 if (gimple_has_body_p (decl))
3008 error ("Thunk is not supposed to have body");
3011 if (thunk.add_pointer_bounds_args
3012 && !instrumented_version->semantically_equivalent_p (callees->callee))
3014 error ("Instrumentation thunk has wrong edge callee");
3018 else if (analyzed && gimple_has_body_p (decl)
3019 && !TREE_ASM_WRITTEN (decl)
3020 && (!DECL_EXTERNAL (decl) || global.inlined_to)
3025 hash_set<gimple> stmts;
3027 ipa_ref *ref = NULL;
3029 /* Reach the trees by walking over the CFG, and note the
3030 enclosing basic-blocks in the call edges. */
3031 FOR_EACH_BB_FN (this_block, this_cfun)
3033 for (gsi = gsi_start_phis (this_block);
3034 !gsi_end_p (gsi); gsi_next (&gsi))
3035 stmts.add (gsi_stmt (gsi));
3036 for (gsi = gsi_start_bb (this_block);
3040 gimple stmt = gsi_stmt (gsi);
3042 if (is_gimple_call (stmt))
3044 cgraph_edge *e = get_edge (stmt);
3045 tree decl = gimple_call_fndecl (stmt);
3050 error ("shared call_stmt:");
3051 cgraph_debug_gimple_stmt (this_cfun, stmt);
3054 if (!e->indirect_unknown_callee)
3056 if (e->verify_corresponds_to_fndecl (decl))
3058 error ("edge points to wrong declaration:");
3059 debug_tree (e->callee->decl);
3060 fprintf (stderr," Instead of:");
3067 error ("an indirect edge with unknown callee "
3068 "corresponding to a call_stmt with "
3069 "a known declaration:");
3071 cgraph_debug_gimple_stmt (this_cfun, e->call_stmt);
3077 error ("missing callgraph edge for call stmt:");
3078 cgraph_debug_gimple_stmt (this_cfun, stmt);
3084 for (i = 0; iterate_reference (i, ref); i++)
3085 if (ref->stmt && !stmts.contains (ref->stmt))
3087 error ("reference to dead statement");
3088 cgraph_debug_gimple_stmt (this_cfun, ref->stmt);
3093 /* No CFG available?! */
3096 for (e = callees; e; e = e->next_callee)
3100 error ("edge %s->%s has no corresponding call_stmt",
3101 identifier_to_locale (e->caller->name ()),
3102 identifier_to_locale (e->callee->name ()));
3103 cgraph_debug_gimple_stmt (this_cfun, e->call_stmt);
3108 for (e = indirect_calls; e; e = e->next_callee)
3110 if (!e->aux && !e->speculative)
3112 error ("an indirect edge from %s has no corresponding call_stmt",
3113 identifier_to_locale (e->caller->name ()));
3114 cgraph_debug_gimple_stmt (this_cfun, e->call_stmt);
3123 internal_error ("verify_cgraph_node failed");
3125 timevar_pop (TV_CGRAPH_VERIFY);
3128 /* Verify whole cgraph structure. */
3130 cgraph_node::verify_cgraph_nodes (void)
3137 FOR_EACH_FUNCTION (node)
3141 /* Walk the alias chain to return the function cgraph_node is alias of.
3142 Walk through thunks, too.
3143 When AVAILABILITY is non-NULL, get minimal availability in the chain. */
3146 cgraph_node::function_symbol (enum availability *availability)
3148 cgraph_node *node = ultimate_alias_target (availability);
3150 while (node->thunk.thunk_p)
3152 node = node->callees->callee;
3155 enum availability a;
3156 a = node->get_availability ();
3157 if (a < *availability)
3160 node = node->ultimate_alias_target (availability);
3165 /* Walk the alias chain to return the function cgraph_node is alias of.
3166 Walk through non virtual thunks, too. Thus we return either a function
3167 or a virtual thunk node.
3168 When AVAILABILITY is non-NULL, get minimal availability in the chain. */
3171 cgraph_node::function_or_virtual_thunk_symbol
3172 (enum availability *availability)
3174 cgraph_node *node = ultimate_alias_target (availability);
3176 while (node->thunk.thunk_p && !node->thunk.virtual_offset_p)
3178 node = node->callees->callee;
3181 enum availability a;
3182 a = node->get_availability ();
3183 if (a < *availability)
3186 node = node->ultimate_alias_target (availability);
3191 /* When doing LTO, read cgraph_node's body from disk if it is not already
3195 cgraph_node::get_untransformed_body (void)
3197 lto_file_decl_data *file_data;
3198 const char *data, *name;
3200 tree decl = this->decl;
3202 if (DECL_RESULT (decl))
3205 gcc_assert (in_lto_p);
3207 timevar_push (TV_IPA_LTO_GIMPLE_IN);
3209 file_data = lto_file_data;
3210 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
3212 /* We may have renamed the declaration, e.g., a static function. */
3213 name = lto_get_decl_name_mapping (file_data, name);
3215 data = lto_get_section_data (file_data, LTO_section_function_body,
3218 fatal_error (input_location, "%s: section %s is missing",
3219 file_data->file_name,
3222 gcc_assert (DECL_STRUCT_FUNCTION (decl) == NULL);
3224 lto_input_function_body (file_data, this, data);
3225 lto_stats.num_function_bodies++;
3226 lto_free_section_data (file_data, LTO_section_function_body, name,
3228 lto_free_function_in_decl_state_for_node (this);
3229 /* Keep lto file data so ipa-inline-analysis knows about cross module
3232 timevar_pop (TV_IPA_LTO_GIMPLE_IN);
3237 /* Prepare function body. When doing LTO, read cgraph_node's body from disk
3238 if it is not already present. When some IPA transformations are scheduled,
3242 cgraph_node::get_body (void)
3246 updated = get_untransformed_body ();
3248 /* Getting transformed body makes no sense for inline clones;
3249 we should never use this on real clones becuase they are materialized
3251 TODO: Materializing clones here will likely lead to smaller LTRANS
3253 gcc_assert (!global.inlined_to && !clone_of);
3254 if (ipa_transforms_to_apply.exists ())
3256 opt_pass *saved_current_pass = current_pass;
3257 FILE *saved_dump_file = dump_file;
3258 int saved_dump_flags = dump_flags;
3260 push_cfun (DECL_STRUCT_FUNCTION (decl));
3261 execute_all_ipa_transforms ();
3262 cgraph_edge::rebuild_edges ();
3263 free_dominance_info (CDI_DOMINATORS);
3264 free_dominance_info (CDI_POST_DOMINATORS);
3268 current_pass = saved_current_pass;
3269 dump_file = saved_dump_file;
3270 dump_flags = saved_dump_flags;
3275 /* Return the DECL_STRUCT_FUNCTION of the function. */
3278 cgraph_node::get_fun (void)
3280 cgraph_node *node = this;
3281 struct function *fun = DECL_STRUCT_FUNCTION (node->decl);
3283 while (!fun && node->clone_of)
3285 node = node->clone_of;
3286 fun = DECL_STRUCT_FUNCTION (node->decl);
3292 /* Verify if the type of the argument matches that of the function
3293 declaration. If we cannot verify this or there is a mismatch,
3297 gimple_check_call_args (gimple stmt, tree fndecl, bool args_count_match)
3300 unsigned int i, nargs;
3302 /* Calls to internal functions always match their signature. */
3303 if (gimple_call_internal_p (stmt))
3306 nargs = gimple_call_num_args (stmt);
3308 /* Get argument types for verification. */
3310 parms = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
3312 parms = TYPE_ARG_TYPES (gimple_call_fntype (stmt));
3314 /* Verify if the type of the argument matches that of the function
3315 declaration. If we cannot verify this or there is a mismatch,
3317 if (fndecl && DECL_ARGUMENTS (fndecl))
3319 for (i = 0, p = DECL_ARGUMENTS (fndecl);
3321 i++, p = DECL_CHAIN (p))
3324 /* We cannot distinguish a varargs function from the case
3325 of excess parameters, still deferring the inlining decision
3326 to the callee is possible. */
3329 arg = gimple_call_arg (stmt, i);
3330 if (p == error_mark_node
3331 || DECL_ARG_TYPE (p) == error_mark_node
3332 || arg == error_mark_node
3333 || (!types_compatible_p (DECL_ARG_TYPE (p), TREE_TYPE (arg))
3334 && !fold_convertible_p (DECL_ARG_TYPE (p), arg)))
3337 if (args_count_match && p)
3342 for (i = 0, p = parms; i < nargs; i++, p = TREE_CHAIN (p))
3345 /* If this is a varargs function defer inlining decision
3349 arg = gimple_call_arg (stmt, i);
3350 if (TREE_VALUE (p) == error_mark_node
3351 || arg == error_mark_node
3352 || TREE_CODE (TREE_VALUE (p)) == VOID_TYPE
3353 || (!types_compatible_p (TREE_VALUE (p), TREE_TYPE (arg))
3354 && !fold_convertible_p (TREE_VALUE (p), arg)))
3366 /* Verify if the type of the argument and lhs of CALL_STMT matches
3367 that of the function declaration CALLEE. If ARGS_COUNT_MATCH is
3368 true, the arg count needs to be the same.
3369 If we cannot verify this or there is a mismatch, return false. */
3372 gimple_check_call_matching_types (gimple call_stmt, tree callee,
3373 bool args_count_match)
3377 if ((DECL_RESULT (callee)
3378 && !DECL_BY_REFERENCE (DECL_RESULT (callee))
3379 && (lhs = gimple_call_lhs (call_stmt)) != NULL_TREE
3380 && !useless_type_conversion_p (TREE_TYPE (DECL_RESULT (callee)),
3382 && !fold_convertible_p (TREE_TYPE (DECL_RESULT (callee)), lhs))
3383 || !gimple_check_call_args (call_stmt, callee, args_count_match))
3388 /* Reset all state within cgraph.c so that we can rerun the compiler
3389 within the same process. For use by toplev::finalize. */
3392 cgraph_c_finalize (void)
3396 x_cgraph_nodes_queue = NULL;
3398 cgraph_fnver_htab = NULL;
3399 version_info_node = NULL;
3402 /* A wroker for call_for_symbol_and_aliases. */
3405 cgraph_node::call_for_symbol_and_aliases_1 (bool (*callback) (cgraph_node *,
3408 bool include_overwritable)
3411 FOR_EACH_ALIAS (this, ref)
3413 cgraph_node *alias = dyn_cast <cgraph_node *> (ref->referring);
3414 if (include_overwritable
3415 || alias->get_availability () > AVAIL_INTERPOSABLE)
3416 if (alias->call_for_symbol_and_aliases (callback, data,
3417 include_overwritable))
3423 /* Return true if NODE has thunk. */
3426 cgraph_node::has_thunk_p (cgraph_node *node, void *)
3428 for (cgraph_edge *e = node->callers; e; e = e->next_caller)
3429 if (e->caller->thunk.thunk_p)
3434 #include "gt-cgraph.h"