1 /* Callgraph handling code.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
4 Contributed by Jan Hubicka
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* This file contains basic routines manipulating call graph
26 The call-graph is data structure designed for intra-procedural optimization
27 but it is also used in non-unit-at-a-time compilation to allow easier code
30 The call-graph consist of nodes and edges represented via linked lists.
31 Each function (external or not) corresponds to the unique node.
33 The mapping from declarations to call-graph nodes is done using hash table
34 based on DECL_UID. The call-graph nodes are created lazily using
35 cgraph_node function when called for unknown declaration.
37 The callgraph at the moment does not represent all indirect calls or calls
38 from other compilation units. Flag NEEDED is set for each node that may be
39 accessed in such an invisible way and it shall be considered an entry point
42 On the other hand, the callgraph currently does contain some edges for
43 indirect calls with unknown callees which can be accessed through
44 indirect_calls field of a node. It should be noted however that at the
45 moment only calls which are potential candidates for indirect inlining are
48 Interprocedural information:
50 Callgraph is place to store data needed for interprocedural optimization.
51 All data structures are divided into three components: local_info that
52 is produced while analyzing the function, global_info that is result
53 of global walking of the callgraph on the end of compilation and
54 rtl_info used by RTL backend to propagate data from already compiled
55 functions to their callers.
57 Moreover, each node has a uid which can be used to keep information in
58 on-the-side arrays. UIDs are reused and therefore reasonably dense.
62 The function inlining information is decided in advance and maintained
63 in the callgraph as so called inline plan.
64 For each inlined call, the callee's node is cloned to represent the
65 new function copy produced by inliner.
66 Each inlined call gets a unique corresponding clone node of the callee
67 and the data structure is updated while inlining is performed, so
68 the clones are eliminated and their callee edges redirected to the
71 Each edge has "inline_failed" field. When the field is set to NULL,
72 the call will be inlined. When it is non-NULL it contains a reason
73 why inlining wasn't performed. */
77 #include "coretypes.h"
80 #include "tree-inline.h"
81 #include "langhooks.h"
88 #include "basic-block.h"
93 #include "tree-dump.h"
94 #include "tree-flow.h"
95 #include "value-prof.h"
97 #include "diagnostic-core.h"
99 #include "ipa-utils.h"
100 #include "lto-streamer.h"
101 #include "ipa-inline.h"
103 const char * const ld_plugin_symbol_resolution_names[]=
108 "prevailing_def_ironly",
116 static void cgraph_node_remove_callers (struct cgraph_node *node);
117 static inline void cgraph_edge_remove_caller (struct cgraph_edge *e);
118 static inline void cgraph_edge_remove_callee (struct cgraph_edge *e);
120 /* Hash table used to convert declarations into nodes. */
121 static GTY((param_is (struct cgraph_node))) htab_t cgraph_hash;
122 /* Hash table used to convert assembler names into nodes. */
123 static GTY((param_is (struct cgraph_node))) htab_t assembler_name_hash;
125 /* The linked list of cgraph nodes. */
126 struct cgraph_node *cgraph_nodes;
128 /* Queue of cgraph nodes scheduled to be lowered. */
129 struct cgraph_node *cgraph_nodes_queue;
131 /* Queue of cgraph nodes scheduled to be added into cgraph. This is a
132 secondary queue used during optimization to accommodate passes that
133 may generate new functions that need to be optimized and expanded. */
134 struct cgraph_node *cgraph_new_nodes;
136 /* Number of nodes in existence. */
139 /* Maximal uid used in cgraph nodes. */
142 /* Maximal uid used in cgraph edges. */
143 int cgraph_edge_max_uid;
145 /* Maximal pid used for profiling */
148 /* Set when whole unit has been analyzed so we can access global info. */
149 bool cgraph_global_info_ready = false;
151 /* What state callgraph is in right now. */
152 enum cgraph_state cgraph_state = CGRAPH_STATE_CONSTRUCTION;
154 /* Set when the cgraph is fully build and the basic flags are computed. */
155 bool cgraph_function_flags_ready = false;
157 /* Linked list of cgraph asm nodes. */
158 struct cgraph_asm_node *cgraph_asm_nodes;
160 /* Last node in cgraph_asm_nodes. */
161 static GTY(()) struct cgraph_asm_node *cgraph_asm_last_node;
163 /* The order index of the next cgraph node to be created. This is
164 used so that we can sort the cgraph nodes in order by when we saw
165 them, to support -fno-toplevel-reorder. */
168 /* List of hooks triggered on cgraph_edge events. */
169 struct cgraph_edge_hook_list {
170 cgraph_edge_hook hook;
172 struct cgraph_edge_hook_list *next;
175 /* List of hooks triggered on cgraph_node events. */
176 struct cgraph_node_hook_list {
177 cgraph_node_hook hook;
179 struct cgraph_node_hook_list *next;
182 /* List of hooks triggered on events involving two cgraph_edges. */
183 struct cgraph_2edge_hook_list {
184 cgraph_2edge_hook hook;
186 struct cgraph_2edge_hook_list *next;
189 /* List of hooks triggered on events involving two cgraph_nodes. */
190 struct cgraph_2node_hook_list {
191 cgraph_2node_hook hook;
193 struct cgraph_2node_hook_list *next;
196 /* List of hooks triggered when an edge is removed. */
197 struct cgraph_edge_hook_list *first_cgraph_edge_removal_hook;
198 /* List of hooks triggered when a node is removed. */
199 struct cgraph_node_hook_list *first_cgraph_node_removal_hook;
200 /* List of hooks triggered when an edge is duplicated. */
201 struct cgraph_2edge_hook_list *first_cgraph_edge_duplicated_hook;
202 /* List of hooks triggered when a node is duplicated. */
203 struct cgraph_2node_hook_list *first_cgraph_node_duplicated_hook;
204 /* List of hooks triggered when an function is inserted. */
205 struct cgraph_node_hook_list *first_cgraph_function_insertion_hook;
207 /* Head of a linked list of unused (freed) call graph nodes.
208 Do not GTY((delete)) this list so UIDs gets reliably recycled. */
209 static GTY(()) struct cgraph_node *free_nodes;
210 /* Head of a linked list of unused (freed) call graph edges.
211 Do not GTY((delete)) this list so UIDs gets reliably recycled. */
212 static GTY(()) struct cgraph_edge *free_edges;
214 /* Macros to access the next item in the list of free cgraph nodes and
216 #define NEXT_FREE_NODE(NODE) (NODE)->next
217 #define NEXT_FREE_EDGE(EDGE) (EDGE)->prev_caller
219 /* Register HOOK to be called with DATA on each removed edge. */
220 struct cgraph_edge_hook_list *
221 cgraph_add_edge_removal_hook (cgraph_edge_hook hook, void *data)
223 struct cgraph_edge_hook_list *entry;
224 struct cgraph_edge_hook_list **ptr = &first_cgraph_edge_removal_hook;
226 entry = (struct cgraph_edge_hook_list *) xmalloc (sizeof (*entry));
236 /* Remove ENTRY from the list of hooks called on removing edges. */
238 cgraph_remove_edge_removal_hook (struct cgraph_edge_hook_list *entry)
240 struct cgraph_edge_hook_list **ptr = &first_cgraph_edge_removal_hook;
242 while (*ptr != entry)
248 /* Call all edge removal hooks. */
250 cgraph_call_edge_removal_hooks (struct cgraph_edge *e)
252 struct cgraph_edge_hook_list *entry = first_cgraph_edge_removal_hook;
255 entry->hook (e, entry->data);
260 /* Register HOOK to be called with DATA on each removed node. */
261 struct cgraph_node_hook_list *
262 cgraph_add_node_removal_hook (cgraph_node_hook hook, void *data)
264 struct cgraph_node_hook_list *entry;
265 struct cgraph_node_hook_list **ptr = &first_cgraph_node_removal_hook;
267 entry = (struct cgraph_node_hook_list *) xmalloc (sizeof (*entry));
277 /* Remove ENTRY from the list of hooks called on removing nodes. */
279 cgraph_remove_node_removal_hook (struct cgraph_node_hook_list *entry)
281 struct cgraph_node_hook_list **ptr = &first_cgraph_node_removal_hook;
283 while (*ptr != entry)
289 /* Call all node removal hooks. */
291 cgraph_call_node_removal_hooks (struct cgraph_node *node)
293 struct cgraph_node_hook_list *entry = first_cgraph_node_removal_hook;
296 entry->hook (node, entry->data);
301 /* Register HOOK to be called with DATA on each inserted node. */
302 struct cgraph_node_hook_list *
303 cgraph_add_function_insertion_hook (cgraph_node_hook hook, void *data)
305 struct cgraph_node_hook_list *entry;
306 struct cgraph_node_hook_list **ptr = &first_cgraph_function_insertion_hook;
308 entry = (struct cgraph_node_hook_list *) xmalloc (sizeof (*entry));
318 /* Remove ENTRY from the list of hooks called on inserted nodes. */
320 cgraph_remove_function_insertion_hook (struct cgraph_node_hook_list *entry)
322 struct cgraph_node_hook_list **ptr = &first_cgraph_function_insertion_hook;
324 while (*ptr != entry)
330 /* Call all node insertion hooks. */
332 cgraph_call_function_insertion_hooks (struct cgraph_node *node)
334 struct cgraph_node_hook_list *entry = first_cgraph_function_insertion_hook;
337 entry->hook (node, entry->data);
342 /* Register HOOK to be called with DATA on each duplicated edge. */
343 struct cgraph_2edge_hook_list *
344 cgraph_add_edge_duplication_hook (cgraph_2edge_hook hook, void *data)
346 struct cgraph_2edge_hook_list *entry;
347 struct cgraph_2edge_hook_list **ptr = &first_cgraph_edge_duplicated_hook;
349 entry = (struct cgraph_2edge_hook_list *) xmalloc (sizeof (*entry));
359 /* Remove ENTRY from the list of hooks called on duplicating edges. */
361 cgraph_remove_edge_duplication_hook (struct cgraph_2edge_hook_list *entry)
363 struct cgraph_2edge_hook_list **ptr = &first_cgraph_edge_duplicated_hook;
365 while (*ptr != entry)
371 /* Call all edge duplication hooks. */
373 cgraph_call_edge_duplication_hooks (struct cgraph_edge *cs1,
374 struct cgraph_edge *cs2)
376 struct cgraph_2edge_hook_list *entry = first_cgraph_edge_duplicated_hook;
379 entry->hook (cs1, cs2, entry->data);
384 /* Register HOOK to be called with DATA on each duplicated node. */
385 struct cgraph_2node_hook_list *
386 cgraph_add_node_duplication_hook (cgraph_2node_hook hook, void *data)
388 struct cgraph_2node_hook_list *entry;
389 struct cgraph_2node_hook_list **ptr = &first_cgraph_node_duplicated_hook;
391 entry = (struct cgraph_2node_hook_list *) xmalloc (sizeof (*entry));
401 /* Remove ENTRY from the list of hooks called on duplicating nodes. */
403 cgraph_remove_node_duplication_hook (struct cgraph_2node_hook_list *entry)
405 struct cgraph_2node_hook_list **ptr = &first_cgraph_node_duplicated_hook;
407 while (*ptr != entry)
413 /* Call all node duplication hooks. */
415 cgraph_call_node_duplication_hooks (struct cgraph_node *node1,
416 struct cgraph_node *node2)
418 struct cgraph_2node_hook_list *entry = first_cgraph_node_duplicated_hook;
421 entry->hook (node1, node2, entry->data);
426 /* Returns a hash code for P. */
429 hash_node (const void *p)
431 const struct cgraph_node *n = (const struct cgraph_node *) p;
432 return (hashval_t) DECL_UID (n->decl);
436 /* Returns nonzero if P1 and P2 are equal. */
439 eq_node (const void *p1, const void *p2)
441 const struct cgraph_node *n1 = (const struct cgraph_node *) p1;
442 const struct cgraph_node *n2 = (const struct cgraph_node *) p2;
443 return DECL_UID (n1->decl) == DECL_UID (n2->decl);
446 /* Allocate new callgraph node. */
448 static inline struct cgraph_node *
449 cgraph_allocate_node (void)
451 struct cgraph_node *node;
456 free_nodes = NEXT_FREE_NODE (node);
460 node = ggc_alloc_cleared_cgraph_node ();
461 node->uid = cgraph_max_uid++;
467 /* Allocate new callgraph node and insert it into basic data structures. */
469 static struct cgraph_node *
470 cgraph_create_node_1 (void)
472 struct cgraph_node *node = cgraph_allocate_node ();
474 node->next = cgraph_nodes;
476 node->order = cgraph_order++;
478 cgraph_nodes->previous = node;
479 node->previous = NULL;
480 node->frequency = NODE_FREQUENCY_NORMAL;
481 node->count_materialization_scale = REG_BR_PROB_BASE;
482 ipa_empty_ref_list (&node->ref_list);
488 /* Return cgraph node assigned to DECL. Create new one when needed. */
491 cgraph_create_node (tree decl)
493 struct cgraph_node key, *node, **slot;
495 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
498 cgraph_hash = htab_create_ggc (10, hash_node, eq_node, NULL);
501 slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, &key, INSERT);
504 node = cgraph_create_node_1 ();
507 if (DECL_CONTEXT (decl) && TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)
509 node->origin = cgraph_get_create_node (DECL_CONTEXT (decl));
510 node->next_nested = node->origin->nested;
511 node->origin->nested = node;
513 if (assembler_name_hash)
516 tree name = DECL_ASSEMBLER_NAME (decl);
518 aslot = htab_find_slot_with_hash (assembler_name_hash, name,
519 decl_assembler_name_hash (name),
521 /* We can have multiple declarations with same assembler name. For C++
522 it is __builtin_strlen and strlen, for instance. Do we need to
523 record them all? Original implementation marked just first one
524 so lets hope for the best. */
531 /* Try to find a call graph node for declaration DECL and if it does not exist,
535 cgraph_get_create_node (tree decl)
537 struct cgraph_node *node;
539 node = cgraph_get_node (decl);
543 return cgraph_create_node (decl);
546 /* Mark ALIAS as an alias to DECL. DECL_NODE is cgraph node representing
547 the function body is associated with (not neccesarily cgraph_node (DECL). */
549 static struct cgraph_node *
550 cgraph_same_body_alias_1 (struct cgraph_node *decl_node, tree alias, tree decl)
552 struct cgraph_node key, *alias_node, **slot;
554 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
555 gcc_assert (TREE_CODE (alias) == FUNCTION_DECL);
559 slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, &key, INSERT);
561 /* If the cgraph_node has been already created, fail. */
565 alias_node = cgraph_allocate_node ();
566 alias_node->decl = alias;
567 alias_node->same_body_alias = 1;
568 alias_node->same_body = decl_node;
569 alias_node->previous = NULL;
570 if (decl_node->same_body)
571 decl_node->same_body->previous = alias_node;
572 alias_node->next = decl_node->same_body;
573 alias_node->thunk.alias = decl;
574 decl_node->same_body = alias_node;
579 /* Attempt to mark ALIAS as an alias to DECL. Return alias node if successful
581 Same body aliases are output whenever the body of DECL is output,
582 and cgraph_get_node (ALIAS) transparently returns cgraph_get_node (DECL). */
585 cgraph_same_body_alias (struct cgraph_node *decl_node, tree alias, tree decl)
587 #ifndef ASM_OUTPUT_DEF
588 /* If aliases aren't supported by the assembler, fail. */
592 /*gcc_assert (!assembler_name_hash);*/
594 return cgraph_same_body_alias_1 (decl_node, alias, decl);
597 /* Add thunk alias into callgraph. The alias declaration is ALIAS and it
598 aliases DECL with an adjustments made into the first parameter.
599 See comments in thunk_adjust for detail on the parameters. */
602 cgraph_add_thunk (struct cgraph_node *decl_node, tree alias, tree decl,
604 HOST_WIDE_INT fixed_offset, HOST_WIDE_INT virtual_value,
608 struct cgraph_node *node = cgraph_get_node (alias);
612 gcc_assert (node->local.finalized);
613 gcc_assert (!node->same_body);
614 cgraph_remove_node (node);
617 node = cgraph_same_body_alias_1 (decl_node, alias, decl);
619 gcc_checking_assert (!virtual_offset
620 || tree_int_cst_equal (virtual_offset,
621 size_int (virtual_value)));
622 node->thunk.fixed_offset = fixed_offset;
623 node->thunk.this_adjusting = this_adjusting;
624 node->thunk.virtual_value = virtual_value;
625 node->thunk.virtual_offset_p = virtual_offset != NULL;
626 node->thunk.alias = real_alias;
627 node->thunk.thunk_p = true;
631 /* Returns the cgraph node assigned to DECL or NULL if no cgraph node
635 cgraph_get_node_or_alias (const_tree decl)
637 struct cgraph_node key, *node = NULL, **slot;
639 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
644 key.decl = CONST_CAST2 (tree, const_tree, decl);
646 slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, &key,
654 /* Returns the cgraph node assigned to DECL or NULL if no cgraph node
658 cgraph_get_node (const_tree decl)
660 struct cgraph_node key, *node = NULL, **slot;
662 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
667 key.decl = CONST_CAST2 (tree, const_tree, decl);
669 slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, &key,
675 if (node->same_body_alias)
676 node = node->same_body;
681 /* Insert already constructed node into hashtable. */
684 cgraph_insert_node_to_hashtable (struct cgraph_node *node)
686 struct cgraph_node **slot;
688 slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, node, INSERT);
694 /* Returns a hash code for P. */
697 hash_node_by_assembler_name (const void *p)
699 const struct cgraph_node *n = (const struct cgraph_node *) p;
700 return (hashval_t) decl_assembler_name_hash (DECL_ASSEMBLER_NAME (n->decl));
703 /* Returns nonzero if P1 and P2 are equal. */
706 eq_assembler_name (const void *p1, const void *p2)
708 const struct cgraph_node *n1 = (const struct cgraph_node *) p1;
709 const_tree name = (const_tree)p2;
710 return (decl_assembler_name_equal (n1->decl, name));
713 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
714 Return NULL if there's no such node. */
717 cgraph_node_for_asm (tree asmname)
719 struct cgraph_node *node;
722 if (!assembler_name_hash)
724 assembler_name_hash =
725 htab_create_ggc (10, hash_node_by_assembler_name, eq_assembler_name,
727 for (node = cgraph_nodes; node; node = node->next)
728 if (!node->global.inlined_to)
730 tree name = DECL_ASSEMBLER_NAME (node->decl);
731 slot = htab_find_slot_with_hash (assembler_name_hash, name,
732 decl_assembler_name_hash (name),
734 /* We can have multiple declarations with same assembler name. For C++
735 it is __builtin_strlen and strlen, for instance. Do we need to
736 record them all? Original implementation marked just first one
737 so lets hope for the best. */
742 struct cgraph_node *alias;
744 for (alias = node->same_body; alias; alias = alias->next)
747 name = DECL_ASSEMBLER_NAME (alias->decl);
748 hash = decl_assembler_name_hash (name);
749 slot = htab_find_slot_with_hash (assembler_name_hash, name,
758 slot = htab_find_slot_with_hash (assembler_name_hash, asmname,
759 decl_assembler_name_hash (asmname),
764 node = (struct cgraph_node *) *slot;
765 if (node->same_body_alias)
766 node = node->same_body;
772 /* Returns a hash value for X (which really is a die_struct). */
775 edge_hash (const void *x)
777 return htab_hash_pointer (((const struct cgraph_edge *) x)->call_stmt);
780 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
783 edge_eq (const void *x, const void *y)
785 return ((const struct cgraph_edge *) x)->call_stmt == y;
788 /* Add call graph edge E to call site hash of its caller. */
791 cgraph_add_edge_to_call_site_hash (struct cgraph_edge *e)
794 slot = htab_find_slot_with_hash (e->caller->call_site_hash,
796 htab_hash_pointer (e->call_stmt),
802 /* Return the callgraph edge representing the GIMPLE_CALL statement
806 cgraph_edge (struct cgraph_node *node, gimple call_stmt)
808 struct cgraph_edge *e, *e2;
811 if (node->call_site_hash)
812 return (struct cgraph_edge *)
813 htab_find_with_hash (node->call_site_hash, call_stmt,
814 htab_hash_pointer (call_stmt));
816 /* This loop may turn out to be performance problem. In such case adding
817 hashtables into call nodes with very many edges is probably best
818 solution. It is not good idea to add pointer into CALL_EXPR itself
819 because we want to make possible having multiple cgraph nodes representing
820 different clones of the same body before the body is actually cloned. */
821 for (e = node->callees; e; e = e->next_callee)
823 if (e->call_stmt == call_stmt)
829 for (e = node->indirect_calls; e; e = e->next_callee)
831 if (e->call_stmt == call_stmt)
838 node->call_site_hash = htab_create_ggc (120, edge_hash, edge_eq, NULL);
839 for (e2 = node->callees; e2; e2 = e2->next_callee)
840 cgraph_add_edge_to_call_site_hash (e2);
841 for (e2 = node->indirect_calls; e2; e2 = e2->next_callee)
842 cgraph_add_edge_to_call_site_hash (e2);
849 /* Change field call_stmt of edge E to NEW_STMT. */
852 cgraph_set_call_stmt (struct cgraph_edge *e, gimple new_stmt)
856 if (e->caller->call_site_hash)
858 htab_remove_elt_with_hash (e->caller->call_site_hash,
860 htab_hash_pointer (e->call_stmt));
863 e->call_stmt = new_stmt;
864 if (e->indirect_unknown_callee
865 && (decl = gimple_call_fndecl (new_stmt)))
867 /* Constant propagation (and possibly also inlining?) can turn an
868 indirect call into a direct one. */
869 struct cgraph_node *new_callee = cgraph_get_node (decl);
871 gcc_checking_assert (new_callee);
872 cgraph_make_edge_direct (e, new_callee, 0);
875 push_cfun (DECL_STRUCT_FUNCTION (e->caller->decl));
876 e->can_throw_external = stmt_can_throw_external (new_stmt);
878 if (e->caller->call_site_hash)
879 cgraph_add_edge_to_call_site_hash (e);
882 /* Like cgraph_set_call_stmt but walk the clone tree and update all
883 clones sharing the same function body. */
886 cgraph_set_call_stmt_including_clones (struct cgraph_node *orig,
887 gimple old_stmt, gimple new_stmt)
889 struct cgraph_node *node;
890 struct cgraph_edge *edge = cgraph_edge (orig, old_stmt);
893 cgraph_set_call_stmt (edge, new_stmt);
899 struct cgraph_edge *edge = cgraph_edge (node, old_stmt);
901 cgraph_set_call_stmt (edge, new_stmt);
904 else if (node->next_sibling_clone)
905 node = node->next_sibling_clone;
908 while (node != orig && !node->next_sibling_clone)
909 node = node->clone_of;
911 node = node->next_sibling_clone;
916 /* Like cgraph_create_edge walk the clone tree and update all clones sharing
917 same function body. If clones already have edge for OLD_STMT; only
918 update the edge same way as cgraph_set_call_stmt_including_clones does.
920 TODO: COUNT and LOOP_DEPTH should be properly distributed based on relative
921 frequencies of the clones. */
924 cgraph_create_edge_including_clones (struct cgraph_node *orig,
925 struct cgraph_node *callee,
927 gimple stmt, gcov_type count,
928 int freq, int loop_depth,
929 cgraph_inline_failed_t reason)
931 struct cgraph_node *node;
932 struct cgraph_edge *edge;
934 if (!cgraph_edge (orig, stmt))
936 edge = cgraph_create_edge (orig, callee, stmt, count, freq, loop_depth);
937 edge->inline_failed = reason;
944 struct cgraph_edge *edge = cgraph_edge (node, old_stmt);
946 /* It is possible that clones already contain the edge while
947 master didn't. Either we promoted indirect call into direct
948 call in the clone or we are processing clones of unreachable
949 master where edges has been removed. */
951 cgraph_set_call_stmt (edge, stmt);
952 else if (!cgraph_edge (node, stmt))
954 edge = cgraph_create_edge (node, callee, stmt, count,
956 edge->inline_failed = reason;
961 else if (node->next_sibling_clone)
962 node = node->next_sibling_clone;
965 while (node != orig && !node->next_sibling_clone)
966 node = node->clone_of;
968 node = node->next_sibling_clone;
973 /* Allocate a cgraph_edge structure and fill it with data according to the
974 parameters of which only CALLEE can be NULL (when creating an indirect call
977 static struct cgraph_edge *
978 cgraph_create_edge_1 (struct cgraph_node *caller, struct cgraph_node *callee,
979 gimple call_stmt, gcov_type count, int freq, int nest)
981 struct cgraph_edge *edge;
983 /* LTO does not actually have access to the call_stmt since these
984 have not been loaded yet. */
987 /* This is a rather expensive check possibly triggering
988 construction of call stmt hashtable. */
989 gcc_checking_assert (!cgraph_edge (caller, call_stmt));
991 gcc_assert (is_gimple_call (call_stmt));
997 free_edges = NEXT_FREE_EDGE (edge);
1001 edge = ggc_alloc_cgraph_edge ();
1002 edge->uid = cgraph_edge_max_uid++;
1006 edge->caller = caller;
1007 edge->callee = callee;
1008 edge->prev_caller = NULL;
1009 edge->next_caller = NULL;
1010 edge->prev_callee = NULL;
1011 edge->next_callee = NULL;
1013 edge->count = count;
1014 gcc_assert (count >= 0);
1015 edge->frequency = freq;
1016 gcc_assert (freq >= 0);
1017 gcc_assert (freq <= CGRAPH_FREQ_MAX);
1018 edge->loop_nest = nest;
1020 edge->call_stmt = call_stmt;
1021 edge->call_stmt_size = 0;
1022 edge->call_stmt_time = 0;
1023 push_cfun (DECL_STRUCT_FUNCTION (caller->decl));
1024 edge->can_throw_external
1025 = call_stmt ? stmt_can_throw_external (call_stmt) : false;
1027 edge->call_stmt_cannot_inline_p =
1028 (call_stmt ? gimple_call_cannot_inline_p (call_stmt) : false);
1029 if (call_stmt && caller->call_site_hash)
1030 cgraph_add_edge_to_call_site_hash (edge);
1032 edge->indirect_info = NULL;
1033 edge->indirect_inlining_edge = 0;
1038 /* Create edge from CALLER to CALLEE in the cgraph. */
1040 struct cgraph_edge *
1041 cgraph_create_edge (struct cgraph_node *caller, struct cgraph_node *callee,
1042 gimple call_stmt, gcov_type count, int freq, int nest)
1044 struct cgraph_edge *edge = cgraph_create_edge_1 (caller, callee, call_stmt,
1047 edge->indirect_unknown_callee = 0;
1048 initialize_inline_failed (edge);
1050 edge->next_caller = callee->callers;
1051 if (callee->callers)
1052 callee->callers->prev_caller = edge;
1053 edge->next_callee = caller->callees;
1054 if (caller->callees)
1055 caller->callees->prev_callee = edge;
1056 caller->callees = edge;
1057 callee->callers = edge;
1062 /* Allocate cgraph_indirect_call_info and set its fields to default values. */
1064 struct cgraph_indirect_call_info *
1065 cgraph_allocate_init_indirect_info (void)
1067 struct cgraph_indirect_call_info *ii;
1069 ii = ggc_alloc_cleared_cgraph_indirect_call_info ();
1070 ii->param_index = -1;
1074 /* Create an indirect edge with a yet-undetermined callee where the call
1075 statement destination is a formal parameter of the caller with index
1078 struct cgraph_edge *
1079 cgraph_create_indirect_edge (struct cgraph_node *caller, gimple call_stmt,
1081 gcov_type count, int freq, int nest)
1083 struct cgraph_edge *edge = cgraph_create_edge_1 (caller, NULL, call_stmt,
1086 edge->indirect_unknown_callee = 1;
1087 initialize_inline_failed (edge);
1089 edge->indirect_info = cgraph_allocate_init_indirect_info ();
1090 edge->indirect_info->ecf_flags = ecf_flags;
1092 edge->next_callee = caller->indirect_calls;
1093 if (caller->indirect_calls)
1094 caller->indirect_calls->prev_callee = edge;
1095 caller->indirect_calls = edge;
1100 /* Remove the edge E from the list of the callers of the callee. */
1103 cgraph_edge_remove_callee (struct cgraph_edge *e)
1105 gcc_assert (!e->indirect_unknown_callee);
1107 e->prev_caller->next_caller = e->next_caller;
1109 e->next_caller->prev_caller = e->prev_caller;
1110 if (!e->prev_caller)
1111 e->callee->callers = e->next_caller;
1114 /* Remove the edge E from the list of the callees of the caller. */
1117 cgraph_edge_remove_caller (struct cgraph_edge *e)
1120 e->prev_callee->next_callee = e->next_callee;
1122 e->next_callee->prev_callee = e->prev_callee;
1123 if (!e->prev_callee)
1125 if (e->indirect_unknown_callee)
1126 e->caller->indirect_calls = e->next_callee;
1128 e->caller->callees = e->next_callee;
1130 if (e->caller->call_site_hash)
1131 htab_remove_elt_with_hash (e->caller->call_site_hash,
1133 htab_hash_pointer (e->call_stmt));
1136 /* Put the edge onto the free list. */
1139 cgraph_free_edge (struct cgraph_edge *e)
1143 /* Clear out the edge so we do not dangle pointers. */
1144 memset (e, 0, sizeof (*e));
1146 NEXT_FREE_EDGE (e) = free_edges;
1150 /* Remove the edge E in the cgraph. */
1153 cgraph_remove_edge (struct cgraph_edge *e)
1155 /* Call all edge removal hooks. */
1156 cgraph_call_edge_removal_hooks (e);
1158 if (!e->indirect_unknown_callee)
1159 /* Remove from callers list of the callee. */
1160 cgraph_edge_remove_callee (e);
1162 /* Remove from callees list of the callers. */
1163 cgraph_edge_remove_caller (e);
1165 /* Put the edge onto the free list. */
1166 cgraph_free_edge (e);
1169 /* Set callee of call graph edge E and add it to the corresponding set of
1173 cgraph_set_edge_callee (struct cgraph_edge *e, struct cgraph_node *n)
1175 e->prev_caller = NULL;
1177 n->callers->prev_caller = e;
1178 e->next_caller = n->callers;
1183 /* Redirect callee of E to N. The function does not update underlying
1187 cgraph_redirect_edge_callee (struct cgraph_edge *e, struct cgraph_node *n)
1189 /* Remove from callers list of the current callee. */
1190 cgraph_edge_remove_callee (e);
1192 /* Insert to callers list of the new callee. */
1193 cgraph_set_edge_callee (e, n);
1196 /* Make an indirect EDGE with an unknown callee an ordinary edge leading to
1197 CALLEE. DELTA is an integer constant that is to be added to the this
1198 pointer (first parameter) to compensate for skipping a thunk adjustment. */
1201 cgraph_make_edge_direct (struct cgraph_edge *edge, struct cgraph_node *callee,
1202 HOST_WIDE_INT delta)
1204 edge->indirect_unknown_callee = 0;
1205 edge->indirect_info->thunk_delta = delta;
1207 /* Get the edge out of the indirect edge list. */
1208 if (edge->prev_callee)
1209 edge->prev_callee->next_callee = edge->next_callee;
1210 if (edge->next_callee)
1211 edge->next_callee->prev_callee = edge->prev_callee;
1212 if (!edge->prev_callee)
1213 edge->caller->indirect_calls = edge->next_callee;
1215 /* Put it into the normal callee list */
1216 edge->prev_callee = NULL;
1217 edge->next_callee = edge->caller->callees;
1218 if (edge->caller->callees)
1219 edge->caller->callees->prev_callee = edge;
1220 edge->caller->callees = edge;
1222 /* Insert to callers list of the new callee. */
1223 cgraph_set_edge_callee (edge, callee);
1225 /* We need to re-determine the inlining status of the edge. */
1226 initialize_inline_failed (edge);
1230 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1231 OLD_STMT changed into NEW_STMT. OLD_CALL is gimple_call_fndecl
1232 of OLD_STMT if it was previously call statement. */
1235 cgraph_update_edges_for_call_stmt_node (struct cgraph_node *node,
1236 gimple old_stmt, tree old_call, gimple new_stmt)
1238 tree new_call = (is_gimple_call (new_stmt)) ? gimple_call_fndecl (new_stmt) : 0;
1240 /* We are seeing indirect calls, then there is nothing to update. */
1241 if (!new_call && !old_call)
1243 /* See if we turned indirect call into direct call or folded call to one builtin
1244 into different builtin. */
1245 if (old_call != new_call)
1247 struct cgraph_edge *e = cgraph_edge (node, old_stmt);
1248 struct cgraph_edge *ne = NULL;
1255 /* See if the edge is already there and has the correct callee. It
1256 might be so because of indirect inlining has already updated
1257 it. We also might've cloned and redirected the edge. */
1258 if (new_call && e->callee)
1260 struct cgraph_node *callee = e->callee;
1263 if (callee->decl == new_call
1264 || callee->former_clone_of == new_call)
1266 callee = callee->clone_of;
1270 /* Otherwise remove edge and create new one; we can't simply redirect
1271 since function has changed, so inline plan and other information
1272 attached to edge is invalid. */
1274 frequency = e->frequency;
1275 loop_nest = e->loop_nest;
1276 cgraph_remove_edge (e);
1280 /* We are seeing new direct call; compute profile info based on BB. */
1281 basic_block bb = gimple_bb (new_stmt);
1283 frequency = compute_call_stmt_bb_frequency (current_function_decl,
1285 loop_nest = bb->loop_depth;
1290 ne = cgraph_create_edge (node, cgraph_get_create_node (new_call),
1291 new_stmt, count, frequency,
1293 gcc_assert (ne->inline_failed);
1296 /* We only updated the call stmt; update pointer in cgraph edge.. */
1297 else if (old_stmt != new_stmt)
1298 cgraph_set_call_stmt (cgraph_edge (node, old_stmt), new_stmt);
1301 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1302 OLD_STMT changed into NEW_STMT. OLD_DECL is gimple_call_fndecl
1303 of OLD_STMT before it was updated (updating can happen inplace). */
1306 cgraph_update_edges_for_call_stmt (gimple old_stmt, tree old_decl, gimple new_stmt)
1308 struct cgraph_node *orig = cgraph_get_node (cfun->decl);
1309 struct cgraph_node *node;
1311 gcc_checking_assert (orig);
1312 cgraph_update_edges_for_call_stmt_node (orig, old_stmt, old_decl, new_stmt);
1314 for (node = orig->clones; node != orig;)
1316 cgraph_update_edges_for_call_stmt_node (node, old_stmt, old_decl, new_stmt);
1318 node = node->clones;
1319 else if (node->next_sibling_clone)
1320 node = node->next_sibling_clone;
1323 while (node != orig && !node->next_sibling_clone)
1324 node = node->clone_of;
1326 node = node->next_sibling_clone;
1332 /* Remove all callees from the node. */
1335 cgraph_node_remove_callees (struct cgraph_node *node)
1337 struct cgraph_edge *e, *f;
1339 /* It is sufficient to remove the edges from the lists of callers of
1340 the callees. The callee list of the node can be zapped with one
1342 for (e = node->callees; e; e = f)
1345 cgraph_call_edge_removal_hooks (e);
1346 if (!e->indirect_unknown_callee)
1347 cgraph_edge_remove_callee (e);
1348 cgraph_free_edge (e);
1350 for (e = node->indirect_calls; e; e = f)
1353 cgraph_call_edge_removal_hooks (e);
1354 if (!e->indirect_unknown_callee)
1355 cgraph_edge_remove_callee (e);
1356 cgraph_free_edge (e);
1358 node->indirect_calls = NULL;
1359 node->callees = NULL;
1360 if (node->call_site_hash)
1362 htab_delete (node->call_site_hash);
1363 node->call_site_hash = NULL;
1367 /* Remove all callers from the node. */
1370 cgraph_node_remove_callers (struct cgraph_node *node)
1372 struct cgraph_edge *e, *f;
1374 /* It is sufficient to remove the edges from the lists of callees of
1375 the callers. The caller list of the node can be zapped with one
1377 for (e = node->callers; e; e = f)
1380 cgraph_call_edge_removal_hooks (e);
1381 cgraph_edge_remove_caller (e);
1382 cgraph_free_edge (e);
1384 node->callers = NULL;
1387 /* Release memory used to represent body of function NODE. */
1390 cgraph_release_function_body (struct cgraph_node *node)
1392 if (DECL_STRUCT_FUNCTION (node->decl))
1394 tree old_decl = current_function_decl;
1395 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
1396 if (cfun->gimple_df)
1398 current_function_decl = node->decl;
1400 delete_tree_cfg_annotations ();
1402 current_function_decl = old_decl;
1406 gcc_assert (dom_computed[0] == DOM_NONE);
1407 gcc_assert (dom_computed[1] == DOM_NONE);
1410 if (cfun->value_histograms)
1412 gcc_assert (!current_loops);
1414 gimple_set_body (node->decl, NULL);
1415 VEC_free (ipa_opt_pass, heap,
1416 node->ipa_transforms_to_apply);
1417 /* Struct function hangs a lot of data that would leak if we didn't
1418 removed all pointers to it. */
1419 ggc_free (DECL_STRUCT_FUNCTION (node->decl));
1420 DECL_STRUCT_FUNCTION (node->decl) = NULL;
1422 DECL_SAVED_TREE (node->decl) = NULL;
1423 /* If the node is abstract and needed, then do not clear DECL_INITIAL
1424 of its associated function function declaration because it's
1425 needed to emit debug info later. */
1426 if (!node->abstract_and_needed)
1427 DECL_INITIAL (node->decl) = error_mark_node;
1430 /* Remove same body alias node. */
1433 cgraph_remove_same_body_alias (struct cgraph_node *node)
1436 int uid = node->uid;
1438 gcc_assert (node->same_body_alias);
1440 node->previous->next = node->next;
1442 node->same_body->same_body = node->next;
1444 node->next->previous = node->previous;
1446 node->previous = NULL;
1447 slot = htab_find_slot (cgraph_hash, node, NO_INSERT);
1449 htab_clear_slot (cgraph_hash, slot);
1450 if (assembler_name_hash)
1452 tree name = DECL_ASSEMBLER_NAME (node->decl);
1453 slot = htab_find_slot_with_hash (assembler_name_hash, name,
1454 decl_assembler_name_hash (name),
1456 if (slot && *slot == node)
1457 htab_clear_slot (assembler_name_hash, slot);
1460 /* Clear out the node to NULL all pointers and add the node to the free
1462 memset (node, 0, sizeof(*node));
1464 NEXT_FREE_NODE (node) = free_nodes;
1468 /* Remove the node from cgraph. */
1471 cgraph_remove_node (struct cgraph_node *node)
1474 bool kill_body = false;
1475 struct cgraph_node *n;
1476 int uid = node->uid;
1478 cgraph_call_node_removal_hooks (node);
1479 cgraph_node_remove_callers (node);
1480 cgraph_node_remove_callees (node);
1481 ipa_remove_all_references (&node->ref_list);
1482 ipa_remove_all_refering (&node->ref_list);
1483 VEC_free (ipa_opt_pass, heap,
1484 node->ipa_transforms_to_apply);
1486 /* Incremental inlining access removed nodes stored in the postorder list.
1488 node->needed = node->reachable = false;
1489 for (n = node->nested; n; n = n->next_nested)
1491 node->nested = NULL;
1494 struct cgraph_node **node2 = &node->origin->nested;
1496 while (*node2 != node)
1497 node2 = &(*node2)->next_nested;
1498 *node2 = node->next_nested;
1501 node->previous->next = node->next;
1503 cgraph_nodes = node->next;
1505 node->next->previous = node->previous;
1507 node->previous = NULL;
1508 slot = htab_find_slot (cgraph_hash, node, NO_INSERT);
1511 struct cgraph_node *next_inline_clone;
1513 for (next_inline_clone = node->clones;
1514 next_inline_clone && next_inline_clone->decl != node->decl;
1515 next_inline_clone = next_inline_clone->next_sibling_clone)
1518 /* If there is inline clone of the node being removed, we need
1519 to put it into the position of removed node and reorganize all
1520 other clones to be based on it. */
1521 if (next_inline_clone)
1523 struct cgraph_node *n;
1524 struct cgraph_node *new_clones;
1526 *slot = next_inline_clone;
1528 /* Unlink inline clone from the list of clones of removed node. */
1529 if (next_inline_clone->next_sibling_clone)
1530 next_inline_clone->next_sibling_clone->prev_sibling_clone
1531 = next_inline_clone->prev_sibling_clone;
1532 if (next_inline_clone->prev_sibling_clone)
1534 gcc_assert (node->clones != next_inline_clone);
1535 next_inline_clone->prev_sibling_clone->next_sibling_clone
1536 = next_inline_clone->next_sibling_clone;
1540 gcc_assert (node->clones == next_inline_clone);
1541 node->clones = next_inline_clone->next_sibling_clone;
1544 new_clones = node->clones;
1545 node->clones = NULL;
1547 /* Copy clone info. */
1548 next_inline_clone->clone = node->clone;
1550 /* Now place it into clone tree at same level at NODE. */
1551 next_inline_clone->clone_of = node->clone_of;
1552 next_inline_clone->prev_sibling_clone = NULL;
1553 next_inline_clone->next_sibling_clone = NULL;
1556 if (node->clone_of->clones)
1557 node->clone_of->clones->prev_sibling_clone = next_inline_clone;
1558 next_inline_clone->next_sibling_clone = node->clone_of->clones;
1559 node->clone_of->clones = next_inline_clone;
1562 /* Merge the clone list. */
1565 if (!next_inline_clone->clones)
1566 next_inline_clone->clones = new_clones;
1569 n = next_inline_clone->clones;
1570 while (n->next_sibling_clone)
1571 n = n->next_sibling_clone;
1572 n->next_sibling_clone = new_clones;
1573 new_clones->prev_sibling_clone = n;
1577 /* Update clone_of pointers. */
1581 n->clone_of = next_inline_clone;
1582 n = n->next_sibling_clone;
1587 htab_clear_slot (cgraph_hash, slot);
1592 if (node->prev_sibling_clone)
1593 node->prev_sibling_clone->next_sibling_clone = node->next_sibling_clone;
1594 else if (node->clone_of)
1595 node->clone_of->clones = node->next_sibling_clone;
1596 if (node->next_sibling_clone)
1597 node->next_sibling_clone->prev_sibling_clone = node->prev_sibling_clone;
1600 struct cgraph_node *n, *next;
1604 for (n = node->clones; n->next_sibling_clone; n = n->next_sibling_clone)
1605 n->clone_of = node->clone_of;
1606 n->clone_of = node->clone_of;
1607 n->next_sibling_clone = node->clone_of->clones;
1608 if (node->clone_of->clones)
1609 node->clone_of->clones->prev_sibling_clone = n;
1610 node->clone_of->clones = node->clones;
1614 /* We are removing node with clones. this makes clones inconsistent,
1615 but assume they will be removed subsequently and just keep clone
1616 tree intact. This can happen in unreachable function removal since
1617 we remove unreachable functions in random order, not by bottom-up
1618 walk of clone trees. */
1619 for (n = node->clones; n; n = next)
1621 next = n->next_sibling_clone;
1622 n->next_sibling_clone = NULL;
1623 n->prev_sibling_clone = NULL;
1629 while (node->same_body)
1630 cgraph_remove_same_body_alias (node->same_body);
1632 if (node->same_comdat_group)
1634 struct cgraph_node *prev;
1635 for (prev = node->same_comdat_group;
1636 prev->same_comdat_group != node;
1637 prev = prev->same_comdat_group)
1639 if (node->same_comdat_group == prev)
1640 prev->same_comdat_group = NULL;
1642 prev->same_comdat_group = node->same_comdat_group;
1643 node->same_comdat_group = NULL;
1646 /* While all the clones are removed after being proceeded, the function
1647 itself is kept in the cgraph even after it is compiled. Check whether
1648 we are done with this body and reclaim it proactively if this is the case.
1650 if (!kill_body && *slot)
1652 struct cgraph_node *n = (struct cgraph_node *) *slot;
1653 if (!n->clones && !n->clone_of && !n->global.inlined_to
1654 && (cgraph_global_info_ready
1655 && (TREE_ASM_WRITTEN (n->decl) || DECL_EXTERNAL (n->decl)
1656 || n->in_other_partition)))
1659 if (assembler_name_hash)
1661 tree name = DECL_ASSEMBLER_NAME (node->decl);
1662 slot = htab_find_slot_with_hash (assembler_name_hash, name,
1663 decl_assembler_name_hash (name),
1665 /* Inline clones are not hashed. */
1666 if (slot && *slot == node)
1667 htab_clear_slot (assembler_name_hash, slot);
1671 cgraph_release_function_body (node);
1673 if (node->call_site_hash)
1675 htab_delete (node->call_site_hash);
1676 node->call_site_hash = NULL;
1680 /* Clear out the node to NULL all pointers and add the node to the free
1682 memset (node, 0, sizeof(*node));
1684 NEXT_FREE_NODE (node) = free_nodes;
1688 /* Remove the node from cgraph. */
1691 cgraph_remove_node_and_inline_clones (struct cgraph_node *node)
1693 struct cgraph_edge *e, *next;
1694 for (e = node->callees; e; e = next)
1696 next = e->next_callee;
1697 if (!e->inline_failed)
1698 cgraph_remove_node_and_inline_clones (e->callee);
1700 cgraph_remove_node (node);
1703 /* Notify finalize_compilation_unit that given node is reachable. */
1706 cgraph_mark_reachable_node (struct cgraph_node *node)
1708 if (!node->reachable && node->local.finalized)
1710 if (cgraph_global_info_ready)
1712 /* Verify that function does not appear to be needed out of blue
1713 during the optimization process. This can happen for extern
1714 inlines when bodies was removed after inlining. */
1715 gcc_assert ((node->analyzed || node->in_other_partition
1716 || DECL_EXTERNAL (node->decl)));
1719 notice_global_symbol (node->decl);
1720 node->reachable = 1;
1722 node->next_needed = cgraph_nodes_queue;
1723 cgraph_nodes_queue = node;
1727 /* Likewise indicate that a node is needed, i.e. reachable via some
1731 cgraph_mark_needed_node (struct cgraph_node *node)
1734 gcc_assert (!node->global.inlined_to);
1735 cgraph_mark_reachable_node (node);
1738 /* Likewise indicate that a node is having address taken. */
1741 cgraph_mark_address_taken_node (struct cgraph_node *node)
1743 gcc_assert (!node->global.inlined_to);
1744 cgraph_mark_reachable_node (node);
1745 node->address_taken = 1;
1748 /* Return local info for the compiled function. */
1750 struct cgraph_local_info *
1751 cgraph_local_info (tree decl)
1753 struct cgraph_node *node;
1755 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
1756 node = cgraph_get_node (decl);
1759 return &node->local;
1762 /* Return local info for the compiled function. */
1764 struct cgraph_global_info *
1765 cgraph_global_info (tree decl)
1767 struct cgraph_node *node;
1769 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL && cgraph_global_info_ready);
1770 node = cgraph_get_node (decl);
1773 return &node->global;
1776 /* Return local info for the compiled function. */
1778 struct cgraph_rtl_info *
1779 cgraph_rtl_info (tree decl)
1781 struct cgraph_node *node;
1783 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
1784 node = cgraph_get_node (decl);
1786 || (decl != current_function_decl
1787 && !TREE_ASM_WRITTEN (node->decl)))
1792 /* Return a string describing the failure REASON. */
1795 cgraph_inline_failed_string (cgraph_inline_failed_t reason)
1798 #define DEFCIFCODE(code, string) string,
1800 static const char *cif_string_table[CIF_N_REASONS] = {
1801 #include "cif-code.def"
1804 /* Signedness of an enum type is implementation defined, so cast it
1805 to unsigned before testing. */
1806 gcc_assert ((unsigned) reason < CIF_N_REASONS);
1807 return cif_string_table[reason];
1810 /* Return name of the node used in debug output. */
1812 cgraph_node_name (struct cgraph_node *node)
1814 return lang_hooks.decl_printable_name (node->decl, 2);
1817 /* Names used to print out the availability enum. */
1818 const char * const cgraph_availability_names[] =
1819 {"unset", "not_available", "overwritable", "available", "local"};
1822 /* Dump call graph node NODE to file F. */
1825 dump_cgraph_node (FILE *f, struct cgraph_node *node)
1827 struct cgraph_edge *edge;
1828 int indirect_calls_count = 0;
1830 fprintf (f, "%s/%i(%i)", cgraph_node_name (node), node->uid,
1832 dump_addr (f, " @", (void *)node);
1833 if (DECL_ASSEMBLER_NAME_SET_P (node->decl))
1834 fprintf (f, " (asm: %s)", IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (node->decl)));
1835 if (node->global.inlined_to)
1836 fprintf (f, " (inline copy in %s/%i)",
1837 cgraph_node_name (node->global.inlined_to),
1838 node->global.inlined_to->uid);
1839 if (node->same_comdat_group)
1840 fprintf (f, " (same comdat group as %s/%i)",
1841 cgraph_node_name (node->same_comdat_group),
1842 node->same_comdat_group->uid);
1844 fprintf (f, " (clone of %s/%i)",
1845 cgraph_node_name (node->clone_of),
1846 node->clone_of->uid);
1847 if (cgraph_function_flags_ready)
1848 fprintf (f, " availability:%s",
1849 cgraph_availability_names [cgraph_function_body_availability (node)]);
1851 fprintf (f, " analyzed");
1852 if (node->in_other_partition)
1853 fprintf (f, " in_other_partition");
1855 fprintf (f, " executed "HOST_WIDEST_INT_PRINT_DEC"x",
1856 (HOST_WIDEST_INT)node->count);
1858 fprintf (f, " nested in: %s", cgraph_node_name (node->origin));
1860 fprintf (f, " needed");
1861 if (node->address_taken)
1862 fprintf (f, " address_taken");
1863 else if (node->reachable)
1864 fprintf (f, " reachable");
1865 else if (node->reachable_from_other_partition)
1866 fprintf (f, " reachable_from_other_partition");
1867 if (gimple_has_body_p (node->decl))
1868 fprintf (f, " body");
1870 fprintf (f, " process");
1871 if (node->local.local)
1872 fprintf (f, " local");
1873 if (node->local.externally_visible)
1874 fprintf (f, " externally_visible");
1875 if (node->resolution != LDPR_UNKNOWN)
1877 ld_plugin_symbol_resolution_names[(int)node->resolution]);
1878 if (node->local.finalized)
1879 fprintf (f, " finalized");
1880 if (node->local.redefined_extern_inline)
1881 fprintf (f, " redefined_extern_inline");
1882 if (TREE_ASM_WRITTEN (node->decl))
1883 fprintf (f, " asm_written");
1884 if (node->only_called_at_startup)
1885 fprintf (f, " only_called_at_startup");
1886 if (node->only_called_at_exit)
1887 fprintf (f, " only_called_at_exit");
1889 fprintf (f, "\n called by: ");
1890 for (edge = node->callers; edge; edge = edge->next_caller)
1892 fprintf (f, "%s/%i ", cgraph_node_name (edge->caller),
1895 fprintf (f, "("HOST_WIDEST_INT_PRINT_DEC"x) ",
1896 (HOST_WIDEST_INT)edge->count);
1897 if (edge->frequency)
1898 fprintf (f, "(%.2f per call) ",
1899 edge->frequency / (double)CGRAPH_FREQ_BASE);
1900 if (!edge->inline_failed)
1901 fprintf(f, "(inlined) ");
1902 if (edge->indirect_inlining_edge)
1903 fprintf(f, "(indirect_inlining) ");
1904 if (edge->can_throw_external)
1905 fprintf(f, "(can throw external) ");
1908 fprintf (f, "\n calls: ");
1909 for (edge = node->callees; edge; edge = edge->next_callee)
1911 fprintf (f, "%s/%i ", cgraph_node_name (edge->callee),
1913 if (!edge->inline_failed)
1914 fprintf(f, "(inlined) ");
1915 if (edge->indirect_inlining_edge)
1916 fprintf(f, "(indirect_inlining) ");
1918 fprintf (f, "("HOST_WIDEST_INT_PRINT_DEC"x) ",
1919 (HOST_WIDEST_INT)edge->count);
1920 if (edge->frequency)
1921 fprintf (f, "(%.2f per call) ",
1922 edge->frequency / (double)CGRAPH_FREQ_BASE);
1923 if (edge->loop_nest)
1924 fprintf (f, "(nested in %i loops) ", edge->loop_nest);
1925 if (edge->can_throw_external)
1926 fprintf(f, "(can throw external) ");
1929 fprintf (f, " References: ");
1930 ipa_dump_references (f, &node->ref_list);
1931 fprintf (f, " Refering this function: ");
1932 ipa_dump_refering (f, &node->ref_list);
1934 for (edge = node->indirect_calls; edge; edge = edge->next_callee)
1935 indirect_calls_count++;
1936 if (indirect_calls_count)
1937 fprintf (f, " has %i outgoing edges for indirect calls.\n",
1938 indirect_calls_count);
1940 if (node->same_body)
1942 struct cgraph_node *n;
1943 fprintf (f, " aliases & thunks:");
1944 for (n = node->same_body; n; n = n->next)
1946 fprintf (f, " %s/%i", cgraph_node_name (n), n->uid);
1947 if (n->thunk.thunk_p)
1949 fprintf (f, " (thunk of %s fixed offset %i virtual value %i has "
1950 "virtual offset %i",
1951 lang_hooks.decl_printable_name (n->thunk.alias, 2),
1952 (int)n->thunk.fixed_offset,
1953 (int)n->thunk.virtual_value,
1954 (int)n->thunk.virtual_offset_p);
1957 if (DECL_ASSEMBLER_NAME_SET_P (n->decl))
1958 fprintf (f, " (asm: %s)", IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (n->decl)));
1965 /* Dump call graph node NODE to stderr. */
1968 debug_cgraph_node (struct cgraph_node *node)
1970 dump_cgraph_node (stderr, node);
1974 /* Dump the callgraph to file F. */
1977 dump_cgraph (FILE *f)
1979 struct cgraph_node *node;
1981 fprintf (f, "callgraph:\n\n");
1982 for (node = cgraph_nodes; node; node = node->next)
1983 dump_cgraph_node (f, node);
1987 /* Dump the call graph to stderr. */
1992 dump_cgraph (stderr);
1996 /* Set the DECL_ASSEMBLER_NAME and update cgraph hashtables. */
1999 change_decl_assembler_name (tree decl, tree name)
2001 struct cgraph_node *node;
2003 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
2004 SET_DECL_ASSEMBLER_NAME (decl, name);
2007 if (name == DECL_ASSEMBLER_NAME (decl))
2010 if (assembler_name_hash
2011 && TREE_CODE (decl) == FUNCTION_DECL
2012 && (node = cgraph_get_node_or_alias (decl)) != NULL)
2014 tree old_name = DECL_ASSEMBLER_NAME (decl);
2015 slot = htab_find_slot_with_hash (assembler_name_hash, old_name,
2016 decl_assembler_name_hash (old_name),
2018 /* Inline clones are not hashed. */
2019 if (slot && *slot == node)
2020 htab_clear_slot (assembler_name_hash, slot);
2022 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
2023 && DECL_RTL_SET_P (decl))
2024 warning (0, "%D renamed after being referenced in assembly", decl);
2026 SET_DECL_ASSEMBLER_NAME (decl, name);
2028 if (assembler_name_hash
2029 && TREE_CODE (decl) == FUNCTION_DECL
2030 && (node = cgraph_get_node_or_alias (decl)) != NULL)
2032 slot = htab_find_slot_with_hash (assembler_name_hash, name,
2033 decl_assembler_name_hash (name),
2035 gcc_assert (!*slot);
2040 /* Add a top-level asm statement to the list. */
2042 struct cgraph_asm_node *
2043 cgraph_add_asm_node (tree asm_str)
2045 struct cgraph_asm_node *node;
2047 node = ggc_alloc_cleared_cgraph_asm_node ();
2048 node->asm_str = asm_str;
2049 node->order = cgraph_order++;
2051 if (cgraph_asm_nodes == NULL)
2052 cgraph_asm_nodes = node;
2054 cgraph_asm_last_node->next = node;
2055 cgraph_asm_last_node = node;
2059 /* Return true when the DECL can possibly be inlined. */
2061 cgraph_function_possibly_inlined_p (tree decl)
2063 if (!cgraph_global_info_ready)
2064 return !DECL_UNINLINABLE (decl);
2065 return DECL_POSSIBLY_INLINED (decl);
2068 /* Create clone of E in the node N represented by CALL_EXPR the callgraph. */
2069 struct cgraph_edge *
2070 cgraph_clone_edge (struct cgraph_edge *e, struct cgraph_node *n,
2071 gimple call_stmt, unsigned stmt_uid, gcov_type count_scale,
2072 int freq_scale, int loop_nest, bool update_original)
2074 struct cgraph_edge *new_edge;
2075 gcov_type count = e->count * count_scale / REG_BR_PROB_BASE;
2078 /* We do not want to ignore loop nest after frequency drops to 0. */
2081 freq = e->frequency * (gcov_type) freq_scale / CGRAPH_FREQ_BASE;
2082 if (freq > CGRAPH_FREQ_MAX)
2083 freq = CGRAPH_FREQ_MAX;
2085 if (e->indirect_unknown_callee)
2089 if (call_stmt && (decl = gimple_call_fndecl (call_stmt)))
2091 struct cgraph_node *callee = cgraph_get_node (decl);
2092 gcc_checking_assert (callee);
2093 new_edge = cgraph_create_edge (n, callee, call_stmt, count, freq,
2094 e->loop_nest + loop_nest);
2098 new_edge = cgraph_create_indirect_edge (n, call_stmt,
2099 e->indirect_info->ecf_flags,
2101 e->loop_nest + loop_nest);
2102 *new_edge->indirect_info = *e->indirect_info;
2107 new_edge = cgraph_create_edge (n, e->callee, call_stmt, count, freq,
2108 e->loop_nest + loop_nest);
2109 if (e->indirect_info)
2111 new_edge->indirect_info
2112 = ggc_alloc_cleared_cgraph_indirect_call_info ();
2113 *new_edge->indirect_info = *e->indirect_info;
2117 new_edge->call_stmt_size = e->call_stmt_size;
2118 new_edge->call_stmt_time = e->call_stmt_time;
2119 new_edge->inline_failed = e->inline_failed;
2120 new_edge->indirect_inlining_edge = e->indirect_inlining_edge;
2121 new_edge->lto_stmt_uid = stmt_uid;
2122 /* Clone flags that depend on call_stmt availability manually. */
2123 new_edge->can_throw_external = e->can_throw_external;
2124 new_edge->call_stmt_cannot_inline_p = e->call_stmt_cannot_inline_p;
2125 if (update_original)
2127 e->count -= new_edge->count;
2131 cgraph_call_edge_duplication_hooks (e, new_edge);
2135 /* Create node representing clone of N executed COUNT times. Decrease
2136 the execution counts from original node too.
2137 The new clone will have decl set to DECL that may or may not be the same
2140 When UPDATE_ORIGINAL is true, the counts are subtracted from the original
2141 function's profile to reflect the fact that part of execution is handled
2143 struct cgraph_node *
2144 cgraph_clone_node (struct cgraph_node *n, tree decl, gcov_type count, int freq,
2145 int loop_nest, bool update_original,
2146 VEC(cgraph_edge_p,heap) *redirect_callers)
2148 struct cgraph_node *new_node = cgraph_create_node_1 ();
2149 struct cgraph_edge *e;
2150 gcov_type count_scale;
2153 new_node->decl = decl;
2154 new_node->origin = n->origin;
2155 if (new_node->origin)
2157 new_node->next_nested = new_node->origin->nested;
2158 new_node->origin->nested = new_node;
2160 new_node->analyzed = n->analyzed;
2161 new_node->local = n->local;
2162 new_node->local.externally_visible = false;
2163 new_node->local.local = true;
2164 new_node->global = n->global;
2165 new_node->rtl = n->rtl;
2166 new_node->count = count;
2167 new_node->frequency = n->frequency;
2168 new_node->clone = n->clone;
2169 new_node->clone.tree_map = 0;
2172 if (new_node->count > n->count)
2173 count_scale = REG_BR_PROB_BASE;
2175 count_scale = new_node->count * REG_BR_PROB_BASE / n->count;
2179 if (update_original)
2186 FOR_EACH_VEC_ELT (cgraph_edge_p, redirect_callers, i, e)
2188 /* Redirect calls to the old version node to point to its new
2190 cgraph_redirect_edge_callee (e, new_node);
2194 for (e = n->callees;e; e=e->next_callee)
2195 cgraph_clone_edge (e, new_node, e->call_stmt, e->lto_stmt_uid,
2196 count_scale, freq, loop_nest, update_original);
2198 for (e = n->indirect_calls; e; e = e->next_callee)
2199 cgraph_clone_edge (e, new_node, e->call_stmt, e->lto_stmt_uid,
2200 count_scale, freq, loop_nest, update_original);
2201 ipa_clone_references (new_node, NULL, &n->ref_list);
2203 new_node->next_sibling_clone = n->clones;
2205 n->clones->prev_sibling_clone = new_node;
2206 n->clones = new_node;
2207 new_node->clone_of = n;
2209 cgraph_call_node_duplication_hooks (n, new_node);
2210 if (n->decl != decl)
2212 struct cgraph_node **slot;
2213 slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, new_node, INSERT);
2214 gcc_assert (!*slot);
2216 if (assembler_name_hash)
2219 tree name = DECL_ASSEMBLER_NAME (decl);
2221 aslot = htab_find_slot_with_hash (assembler_name_hash, name,
2222 decl_assembler_name_hash (name),
2224 gcc_assert (!*aslot);
2231 /* Create a new name for clone of DECL, add SUFFIX. Returns an identifier. */
2233 static GTY(()) unsigned int clone_fn_id_num;
2236 clone_function_name (tree decl, const char *suffix)
2238 tree name = DECL_ASSEMBLER_NAME (decl);
2239 size_t len = IDENTIFIER_LENGTH (name);
2240 char *tmp_name, *prefix;
2242 prefix = XALLOCAVEC (char, len + strlen (suffix) + 2);
2243 memcpy (prefix, IDENTIFIER_POINTER (name), len);
2244 strcpy (prefix + len + 1, suffix);
2245 #ifndef NO_DOT_IN_LABEL
2247 #elif !defined NO_DOLLAR_IN_LABEL
2252 ASM_FORMAT_PRIVATE_NAME (tmp_name, prefix, clone_fn_id_num++);
2253 return get_identifier (tmp_name);
2256 /* Create callgraph node clone with new declaration. The actual body will
2257 be copied later at compilation stage.
2259 TODO: after merging in ipa-sra use function call notes instead of args_to_skip
2262 struct cgraph_node *
2263 cgraph_create_virtual_clone (struct cgraph_node *old_node,
2264 VEC(cgraph_edge_p,heap) *redirect_callers,
2265 VEC(ipa_replace_map_p,gc) *tree_map,
2266 bitmap args_to_skip,
2267 const char * suffix)
2269 tree old_decl = old_node->decl;
2270 struct cgraph_node *new_node = NULL;
2273 struct ipa_replace_map *map;
2276 gcc_checking_assert (tree_versionable_function_p (old_decl));
2278 gcc_assert (old_node->local.can_change_signature || !args_to_skip);
2280 /* Make a new FUNCTION_DECL tree node */
2282 new_decl = copy_node (old_decl);
2284 new_decl = build_function_decl_skip_args (old_decl, args_to_skip);
2285 DECL_STRUCT_FUNCTION (new_decl) = NULL;
2287 /* Generate a new name for the new version. */
2288 DECL_NAME (new_decl) = clone_function_name (old_decl, suffix);
2289 SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
2290 SET_DECL_RTL (new_decl, NULL);
2292 new_node = cgraph_clone_node (old_node, new_decl, old_node->count,
2293 CGRAPH_FREQ_BASE, 0, false,
2295 /* Update the properties.
2296 Make clone visible only within this translation unit. Make sure
2297 that is not weak also.
2298 ??? We cannot use COMDAT linkage because there is no
2299 ABI support for this. */
2300 DECL_EXTERNAL (new_node->decl) = 0;
2301 if (DECL_ONE_ONLY (old_decl))
2302 DECL_SECTION_NAME (new_node->decl) = NULL;
2303 DECL_COMDAT_GROUP (new_node->decl) = 0;
2304 TREE_PUBLIC (new_node->decl) = 0;
2305 DECL_COMDAT (new_node->decl) = 0;
2306 DECL_WEAK (new_node->decl) = 0;
2307 new_node->clone.tree_map = tree_map;
2308 new_node->clone.args_to_skip = args_to_skip;
2309 FOR_EACH_VEC_ELT (ipa_replace_map_p, tree_map, i, map)
2311 tree var = map->new_tree;
2314 if (TREE_CODE (var) != ADDR_EXPR)
2316 var = get_base_var (var);
2320 /* Record references of the future statement initializing the constant
2322 if (TREE_CODE (var) == FUNCTION_DECL)
2324 struct cgraph_node *ref_node = cgraph_get_node (var);
2325 gcc_checking_assert (ref_node);
2326 ipa_record_reference (new_node, NULL, ref_node, NULL, IPA_REF_ADDR,
2329 else if (TREE_CODE (var) == VAR_DECL)
2330 ipa_record_reference (new_node, NULL, NULL, varpool_node (var),
2331 IPA_REF_ADDR, NULL);
2334 new_node->clone.combined_args_to_skip = old_node->clone.combined_args_to_skip;
2335 else if (old_node->clone.combined_args_to_skip)
2337 int newi = 0, oldi = 0;
2339 bitmap new_args_to_skip = BITMAP_GGC_ALLOC ();
2340 struct cgraph_node *orig_node;
2341 for (orig_node = old_node; orig_node->clone_of; orig_node = orig_node->clone_of)
2343 for (arg = DECL_ARGUMENTS (orig_node->decl); arg; arg = DECL_CHAIN (arg), oldi++)
2345 if (bitmap_bit_p (old_node->clone.combined_args_to_skip, oldi))
2347 bitmap_set_bit (new_args_to_skip, oldi);
2350 if (bitmap_bit_p (args_to_skip, newi))
2351 bitmap_set_bit (new_args_to_skip, oldi);
2354 new_node->clone.combined_args_to_skip = new_args_to_skip;
2357 new_node->clone.combined_args_to_skip = args_to_skip;
2358 new_node->local.externally_visible = 0;
2359 new_node->local.local = 1;
2360 new_node->lowered = true;
2361 new_node->reachable = true;
2367 /* NODE is no longer nested function; update cgraph accordingly. */
2369 cgraph_unnest_node (struct cgraph_node *node)
2371 struct cgraph_node **node2 = &node->origin->nested;
2372 gcc_assert (node->origin);
2374 while (*node2 != node)
2375 node2 = &(*node2)->next_nested;
2376 *node2 = node->next_nested;
2377 node->origin = NULL;
2380 /* Return function availability. See cgraph.h for description of individual
2383 cgraph_function_body_availability (struct cgraph_node *node)
2385 enum availability avail;
2386 gcc_assert (cgraph_function_flags_ready);
2387 if (!node->analyzed)
2388 avail = AVAIL_NOT_AVAILABLE;
2389 else if (node->local.local)
2390 avail = AVAIL_LOCAL;
2391 else if (!node->local.externally_visible)
2392 avail = AVAIL_AVAILABLE;
2393 /* Inline functions are safe to be analyzed even if their symbol can
2394 be overwritten at runtime. It is not meaningful to enforce any sane
2395 behaviour on replacing inline function by different body. */
2396 else if (DECL_DECLARED_INLINE_P (node->decl))
2397 avail = AVAIL_AVAILABLE;
2399 /* If the function can be overwritten, return OVERWRITABLE. Take
2400 care at least of two notable extensions - the COMDAT functions
2401 used to share template instantiations in C++ (this is symmetric
2402 to code cp_cannot_inline_tree_fn and probably shall be shared and
2403 the inlinability hooks completely eliminated).
2405 ??? Does the C++ one definition rule allow us to always return
2406 AVAIL_AVAILABLE here? That would be good reason to preserve this
2409 else if (decl_replaceable_p (node->decl) && !DECL_EXTERNAL (node->decl))
2410 avail = AVAIL_OVERWRITABLE;
2411 else avail = AVAIL_AVAILABLE;
2416 /* Add the function FNDECL to the call graph.
2417 Unlike cgraph_finalize_function, this function is intended to be used
2418 by middle end and allows insertion of new function at arbitrary point
2419 of compilation. The function can be either in high, low or SSA form
2422 The function is assumed to be reachable and have address taken (so no
2423 API breaking optimizations are performed on it).
2425 Main work done by this function is to enqueue the function for later
2426 processing to avoid need the passes to be re-entrant. */
2429 cgraph_add_new_function (tree fndecl, bool lowered)
2431 struct cgraph_node *node;
2432 switch (cgraph_state)
2434 case CGRAPH_STATE_CONSTRUCTION:
2435 /* Just enqueue function to be processed at nearest occurrence. */
2436 node = cgraph_create_node (fndecl);
2437 node->next_needed = cgraph_new_nodes;
2439 node->lowered = true;
2440 cgraph_new_nodes = node;
2443 case CGRAPH_STATE_IPA:
2444 case CGRAPH_STATE_IPA_SSA:
2445 case CGRAPH_STATE_EXPANSION:
2446 /* Bring the function into finalized state and enqueue for later
2447 analyzing and compilation. */
2448 node = cgraph_get_create_node (fndecl);
2449 node->local.local = false;
2450 node->local.finalized = true;
2451 node->reachable = node->needed = true;
2452 if (!lowered && cgraph_state == CGRAPH_STATE_EXPANSION)
2454 push_cfun (DECL_STRUCT_FUNCTION (fndecl));
2455 current_function_decl = fndecl;
2456 gimple_register_cfg_hooks ();
2457 tree_lowering_passes (fndecl);
2458 bitmap_obstack_initialize (NULL);
2459 if (!gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl)))
2460 execute_pass_list (pass_early_local_passes.pass.sub);
2461 bitmap_obstack_release (NULL);
2463 current_function_decl = NULL;
2468 node->lowered = true;
2469 node->next_needed = cgraph_new_nodes;
2470 cgraph_new_nodes = node;
2473 case CGRAPH_STATE_FINISHED:
2474 /* At the very end of compilation we have to do all the work up
2476 node = cgraph_create_node (fndecl);
2478 node->lowered = true;
2479 cgraph_analyze_function (node);
2480 push_cfun (DECL_STRUCT_FUNCTION (fndecl));
2481 current_function_decl = fndecl;
2482 gimple_register_cfg_hooks ();
2483 bitmap_obstack_initialize (NULL);
2484 if (!gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl)))
2485 execute_pass_list (pass_early_local_passes.pass.sub);
2486 bitmap_obstack_release (NULL);
2487 tree_rest_of_compilation (fndecl);
2489 current_function_decl = NULL;
2493 /* Set a personality if required and we already passed EH lowering. */
2495 && (function_needs_eh_personality (DECL_STRUCT_FUNCTION (fndecl))
2496 == eh_personality_lang))
2497 DECL_FUNCTION_PERSONALITY (fndecl) = lang_hooks.eh_personality ();
2500 /* Return true if NODE can be made local for API change.
2501 Extern inline functions and C++ COMDAT functions can be made local
2502 at the expense of possible code size growth if function is used in multiple
2503 compilation units. */
2505 cgraph_node_can_be_local_p (struct cgraph_node *node)
2507 return (!node->needed && !node->address_taken
2508 && ((DECL_COMDAT (node->decl) && !node->same_comdat_group)
2509 || !node->local.externally_visible));
2512 /* Make DECL local. FIXME: We shouldn't need to mess with rtl this early,
2513 but other code such as notice_global_symbol generates rtl. */
2515 cgraph_make_decl_local (tree decl)
2519 if (TREE_CODE (decl) == VAR_DECL)
2520 DECL_COMMON (decl) = 0;
2521 else gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
2523 if (DECL_COMDAT (decl))
2525 /* It is possible that we are linking against library defining same COMDAT
2526 function. To avoid conflict we need to rename our local name of the
2527 function just in the case WHOPR partitioning decide to make it hidden
2528 to avoid cross partition references. */
2531 const char *old_name;
2533 old_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2534 if (TREE_CODE (decl) == FUNCTION_DECL)
2536 struct cgraph_node *node = cgraph_get_node_or_alias (decl);
2537 change_decl_assembler_name (decl,
2538 clone_function_name (decl, "local"));
2539 if (node->local.lto_file_data)
2540 lto_record_renamed_decl (node->local.lto_file_data,
2543 (DECL_ASSEMBLER_NAME (decl)));
2545 else if (TREE_CODE (decl) == VAR_DECL)
2547 struct varpool_node *vnode = varpool_get_node (decl);
2548 /* change_decl_assembler_name will warn here on vtables because
2549 C++ frontend still sets TREE_SYMBOL_REFERENCED on them. */
2550 SET_DECL_ASSEMBLER_NAME (decl,
2551 clone_function_name (decl, "local"));
2552 if (vnode->lto_file_data)
2553 lto_record_renamed_decl (vnode->lto_file_data,
2556 (DECL_ASSEMBLER_NAME (decl)));
2559 DECL_SECTION_NAME (decl) = 0;
2560 DECL_COMDAT (decl) = 0;
2562 DECL_COMDAT_GROUP (decl) = 0;
2563 DECL_WEAK (decl) = 0;
2564 DECL_EXTERNAL (decl) = 0;
2565 TREE_PUBLIC (decl) = 0;
2566 if (!DECL_RTL_SET_P (decl))
2569 /* Update rtl flags. */
2570 make_decl_rtl (decl);
2572 rtl = DECL_RTL (decl);
2576 symbol = XEXP (rtl, 0);
2577 if (GET_CODE (symbol) != SYMBOL_REF)
2580 SYMBOL_REF_WEAK (symbol) = DECL_WEAK (decl);
2583 /* Bring NODE local. */
2585 cgraph_make_node_local (struct cgraph_node *node)
2587 gcc_assert (cgraph_node_can_be_local_p (node));
2588 if (DECL_COMDAT (node->decl) || DECL_EXTERNAL (node->decl))
2590 struct cgraph_node *alias;
2591 cgraph_make_decl_local (node->decl);
2593 for (alias = node->same_body; alias; alias = alias->next)
2594 cgraph_make_decl_local (alias->decl);
2596 node->local.externally_visible = false;
2597 node->local.local = true;
2598 node->resolution = LDPR_PREVAILING_DEF_IRONLY;
2599 gcc_assert (cgraph_function_body_availability (node) == AVAIL_LOCAL);
2603 /* Set TREE_NOTHROW on NODE's decl and on same_body aliases of NODE
2604 if any to NOTHROW. */
2607 cgraph_set_nothrow_flag (struct cgraph_node *node, bool nothrow)
2609 struct cgraph_node *alias;
2610 TREE_NOTHROW (node->decl) = nothrow;
2611 for (alias = node->same_body; alias; alias = alias->next)
2612 TREE_NOTHROW (alias->decl) = nothrow;
2615 /* Set TREE_READONLY on NODE's decl and on same_body aliases of NODE
2616 if any to READONLY. */
2619 cgraph_set_const_flag (struct cgraph_node *node, bool readonly, bool looping)
2621 struct cgraph_node *alias;
2622 /* Static constructors and destructors without a side effect can be
2624 if (!looping && readonly)
2626 if (DECL_STATIC_CONSTRUCTOR (node->decl))
2627 DECL_STATIC_CONSTRUCTOR (node->decl) = 0;
2628 if (DECL_STATIC_DESTRUCTOR (node->decl))
2629 DECL_STATIC_DESTRUCTOR (node->decl) = 0;
2631 TREE_READONLY (node->decl) = readonly;
2632 DECL_LOOPING_CONST_OR_PURE_P (node->decl) = looping;
2633 for (alias = node->same_body; alias; alias = alias->next)
2635 TREE_READONLY (alias->decl) = readonly;
2636 DECL_LOOPING_CONST_OR_PURE_P (alias->decl) = looping;
2640 /* Set DECL_PURE_P on NODE's decl and on same_body aliases of NODE
2644 cgraph_set_pure_flag (struct cgraph_node *node, bool pure, bool looping)
2646 struct cgraph_node *alias;
2647 /* Static constructors and destructors without a side effect can be
2649 if (!looping && pure)
2651 if (DECL_STATIC_CONSTRUCTOR (node->decl))
2652 DECL_STATIC_CONSTRUCTOR (node->decl) = 0;
2653 if (DECL_STATIC_DESTRUCTOR (node->decl))
2654 DECL_STATIC_DESTRUCTOR (node->decl) = 0;
2656 DECL_PURE_P (node->decl) = pure;
2657 DECL_LOOPING_CONST_OR_PURE_P (node->decl) = looping;
2658 for (alias = node->same_body; alias; alias = alias->next)
2660 DECL_PURE_P (alias->decl) = pure;
2661 DECL_LOOPING_CONST_OR_PURE_P (alias->decl) = looping;
2665 /* See if the frequency of NODE can be updated based on frequencies of its
2668 cgraph_propagate_frequency (struct cgraph_node *node)
2670 bool maybe_unlikely_executed = true, maybe_executed_once = true;
2671 bool only_called_at_startup = true;
2672 bool only_called_at_exit = true;
2673 bool changed = false;
2674 struct cgraph_edge *edge;
2676 if (!node->local.local)
2678 gcc_assert (node->analyzed);
2679 if (dump_file && (dump_flags & TDF_DETAILS))
2680 fprintf (dump_file, "Processing frequency %s\n", cgraph_node_name (node));
2682 for (edge = node->callers;
2683 edge && (maybe_unlikely_executed || maybe_executed_once
2684 || only_called_at_startup || only_called_at_exit);
2685 edge = edge->next_caller)
2687 if (edge->caller != node)
2689 only_called_at_startup &= edge->caller->only_called_at_startup;
2690 /* It makes sense to put main() together with the static constructors.
2691 It will be executed for sure, but rest of functions called from
2692 main are definitely not at startup only. */
2693 if (MAIN_NAME_P (DECL_NAME (edge->caller->decl)))
2694 only_called_at_startup = 0;
2695 only_called_at_exit &= edge->caller->only_called_at_exit;
2697 if (!edge->frequency)
2699 switch (edge->caller->frequency)
2701 case NODE_FREQUENCY_UNLIKELY_EXECUTED:
2703 case NODE_FREQUENCY_EXECUTED_ONCE:
2704 if (dump_file && (dump_flags & TDF_DETAILS))
2705 fprintf (dump_file, " Called by %s that is executed once\n",
2706 cgraph_node_name (edge->caller));
2707 maybe_unlikely_executed = false;
2708 if (edge->loop_nest)
2710 maybe_executed_once = false;
2711 if (dump_file && (dump_flags & TDF_DETAILS))
2712 fprintf (dump_file, " Called in loop\n");
2715 case NODE_FREQUENCY_HOT:
2716 case NODE_FREQUENCY_NORMAL:
2717 if (dump_file && (dump_flags & TDF_DETAILS))
2718 fprintf (dump_file, " Called by %s that is normal or hot\n",
2719 cgraph_node_name (edge->caller));
2720 maybe_unlikely_executed = false;
2721 maybe_executed_once = false;
2725 if ((only_called_at_startup && !only_called_at_exit)
2726 && !node->only_called_at_startup)
2728 node->only_called_at_startup = true;
2730 fprintf (dump_file, "Node %s promoted to only called at startup.\n",
2731 cgraph_node_name (node));
2734 if ((only_called_at_exit && !only_called_at_startup)
2735 && !node->only_called_at_exit)
2737 node->only_called_at_exit = true;
2739 fprintf (dump_file, "Node %s promoted to only called at exit.\n",
2740 cgraph_node_name (node));
2743 /* These come either from profile or user hints; never update them. */
2744 if (node->frequency == NODE_FREQUENCY_HOT
2745 || node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED)
2747 if (maybe_unlikely_executed)
2749 node->frequency = NODE_FREQUENCY_UNLIKELY_EXECUTED;
2751 fprintf (dump_file, "Node %s promoted to unlikely executed.\n",
2752 cgraph_node_name (node));
2755 else if (maybe_executed_once && node->frequency != NODE_FREQUENCY_EXECUTED_ONCE)
2757 node->frequency = NODE_FREQUENCY_EXECUTED_ONCE;
2759 fprintf (dump_file, "Node %s promoted to executed once.\n",
2760 cgraph_node_name (node));
2766 /* Return true when NODE can not return or throw and thus
2767 it is safe to ignore its side effects for IPA analysis. */
2770 cgraph_node_cannot_return (struct cgraph_node *node)
2772 int flags = flags_from_decl_or_type (node->decl);
2773 if (!flag_exceptions)
2774 return (flags & ECF_NORETURN) != 0;
2776 return ((flags & (ECF_NORETURN | ECF_NOTHROW))
2777 == (ECF_NORETURN | ECF_NOTHROW));
2780 /* Return true when call of E can not lead to return from caller
2781 and thus it is safe to ignore its side effects for IPA analysis
2782 when computing side effects of the caller.
2783 FIXME: We could actually mark all edges that have no reaching
2784 patch to EXIT_BLOCK_PTR or throw to get better results. */
2786 cgraph_edge_cannot_lead_to_return (struct cgraph_edge *e)
2788 if (cgraph_node_cannot_return (e->caller))
2790 if (e->indirect_unknown_callee)
2792 int flags = e->indirect_info->ecf_flags;
2793 if (!flag_exceptions)
2794 return (flags & ECF_NORETURN) != 0;
2796 return ((flags & (ECF_NORETURN | ECF_NOTHROW))
2797 == (ECF_NORETURN | ECF_NOTHROW));
2800 return cgraph_node_cannot_return (e->callee);
2803 /* Return true when function NODE can be removed from callgraph
2804 if all direct calls are eliminated. */
2807 cgraph_can_remove_if_no_direct_calls_and_refs_p (struct cgraph_node *node)
2809 gcc_assert (!node->global.inlined_to);
2810 /* Extern inlines can always go, we will use the external definition. */
2811 if (DECL_EXTERNAL (node->decl))
2813 /* When function is needed, we can not remove it. */
2814 if (node->needed || node->reachable_from_other_partition)
2816 if (DECL_STATIC_CONSTRUCTOR (node->decl)
2817 || DECL_STATIC_DESTRUCTOR (node->decl))
2819 /* Only COMDAT functions can be removed if externally visible. */
2820 if (node->local.externally_visible
2821 && (!DECL_COMDAT (node->decl)
2822 || cgraph_used_from_object_file_p (node)))
2827 /* Return true when function NODE can be expected to be removed
2828 from program when direct calls in this compilation unit are removed.
2830 As a special case COMDAT functions are
2831 cgraph_can_remove_if_no_direct_calls_p while the are not
2832 cgraph_only_called_directly_p (it is possible they are called from other
2835 This function behaves as cgraph_only_called_directly_p because eliminating
2836 all uses of COMDAT function does not make it necessarily disappear from
2837 the program unless we are compiling whole program or we do LTO. In this
2838 case we know we win since dynamic linking will not really discard the
2839 linkonce section. */
2842 cgraph_will_be_removed_from_program_if_no_direct_calls (struct cgraph_node *node)
2844 gcc_assert (!node->global.inlined_to);
2845 if (cgraph_used_from_object_file_p (node))
2847 if (!in_lto_p && !flag_whole_program)
2848 return cgraph_only_called_directly_p (node);
2851 if (DECL_EXTERNAL (node->decl))
2853 return cgraph_can_remove_if_no_direct_calls_p (node);
2857 /* Return true when RESOLUTION indicate that linker will use
2858 the symbol from non-LTO object files. */
2861 resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution resolution)
2863 return (resolution == LDPR_PREVAILING_DEF
2864 || resolution == LDPR_PREEMPTED_REG
2865 || resolution == LDPR_RESOLVED_EXEC
2866 || resolution == LDPR_RESOLVED_DYN);
2869 /* Return true when NODE is known to be used from other (non-LTO) object file.
2870 Known only when doing LTO via linker plugin. */
2873 cgraph_used_from_object_file_p (struct cgraph_node *node)
2875 struct cgraph_node *alias;
2877 gcc_assert (!node->global.inlined_to);
2878 if (!TREE_PUBLIC (node->decl) || DECL_EXTERNAL (node->decl))
2880 if (resolution_used_from_other_file_p (node->resolution))
2882 for (alias = node->same_body; alias; alias = alias->next)
2883 if (TREE_PUBLIC (alias->decl)
2884 && resolution_used_from_other_file_p (alias->resolution))
2889 #include "gt-cgraph.h"