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"
102 static void cgraph_node_remove_callers (struct cgraph_node *node);
103 static inline void cgraph_edge_remove_caller (struct cgraph_edge *e);
104 static inline void cgraph_edge_remove_callee (struct cgraph_edge *e);
106 /* Hash table used to convert declarations into nodes. */
107 static GTY((param_is (struct cgraph_node))) htab_t cgraph_hash;
108 /* Hash table used to convert assembler names into nodes. */
109 static GTY((param_is (struct cgraph_node))) htab_t assembler_name_hash;
111 /* The linked list of cgraph nodes. */
112 struct cgraph_node *cgraph_nodes;
114 /* Queue of cgraph nodes scheduled to be lowered. */
115 struct cgraph_node *cgraph_nodes_queue;
117 /* Queue of cgraph nodes scheduled to be added into cgraph. This is a
118 secondary queue used during optimization to accommodate passes that
119 may generate new functions that need to be optimized and expanded. */
120 struct cgraph_node *cgraph_new_nodes;
122 /* Number of nodes in existence. */
125 /* Maximal uid used in cgraph nodes. */
128 /* Maximal uid used in cgraph edges. */
129 int cgraph_edge_max_uid;
131 /* Maximal pid used for profiling */
134 /* Set when whole unit has been analyzed so we can access global info. */
135 bool cgraph_global_info_ready = false;
137 /* What state callgraph is in right now. */
138 enum cgraph_state cgraph_state = CGRAPH_STATE_CONSTRUCTION;
140 /* Set when the cgraph is fully build and the basic flags are computed. */
141 bool cgraph_function_flags_ready = false;
143 /* Linked list of cgraph asm nodes. */
144 struct cgraph_asm_node *cgraph_asm_nodes;
146 /* Last node in cgraph_asm_nodes. */
147 static GTY(()) struct cgraph_asm_node *cgraph_asm_last_node;
149 /* The order index of the next cgraph node to be created. This is
150 used so that we can sort the cgraph nodes in order by when we saw
151 them, to support -fno-toplevel-reorder. */
154 /* List of hooks trigerred on cgraph_edge events. */
155 struct cgraph_edge_hook_list {
156 cgraph_edge_hook hook;
158 struct cgraph_edge_hook_list *next;
161 /* List of hooks trigerred on cgraph_node events. */
162 struct cgraph_node_hook_list {
163 cgraph_node_hook hook;
165 struct cgraph_node_hook_list *next;
168 /* List of hooks trigerred on events involving two cgraph_edges. */
169 struct cgraph_2edge_hook_list {
170 cgraph_2edge_hook hook;
172 struct cgraph_2edge_hook_list *next;
175 /* List of hooks trigerred on events involving two cgraph_nodes. */
176 struct cgraph_2node_hook_list {
177 cgraph_2node_hook hook;
179 struct cgraph_2node_hook_list *next;
182 /* List of hooks triggered when an edge is removed. */
183 struct cgraph_edge_hook_list *first_cgraph_edge_removal_hook;
184 /* List of hooks triggered when a node is removed. */
185 struct cgraph_node_hook_list *first_cgraph_node_removal_hook;
186 /* List of hooks triggered when an edge is duplicated. */
187 struct cgraph_2edge_hook_list *first_cgraph_edge_duplicated_hook;
188 /* List of hooks triggered when a node is duplicated. */
189 struct cgraph_2node_hook_list *first_cgraph_node_duplicated_hook;
190 /* List of hooks triggered when an function is inserted. */
191 struct cgraph_node_hook_list *first_cgraph_function_insertion_hook;
193 /* Head of a linked list of unused (freed) call graph nodes.
194 Do not GTY((delete)) this list so UIDs gets reliably recycled. */
195 static GTY(()) struct cgraph_node *free_nodes;
196 /* Head of a linked list of unused (freed) call graph edges.
197 Do not GTY((delete)) this list so UIDs gets reliably recycled. */
198 static GTY(()) struct cgraph_edge *free_edges;
200 /* Macros to access the next item in the list of free cgraph nodes and
202 #define NEXT_FREE_NODE(NODE) (NODE)->next
203 #define NEXT_FREE_EDGE(EDGE) (EDGE)->prev_caller
205 /* Register HOOK to be called with DATA on each removed edge. */
206 struct cgraph_edge_hook_list *
207 cgraph_add_edge_removal_hook (cgraph_edge_hook hook, void *data)
209 struct cgraph_edge_hook_list *entry;
210 struct cgraph_edge_hook_list **ptr = &first_cgraph_edge_removal_hook;
212 entry = (struct cgraph_edge_hook_list *) xmalloc (sizeof (*entry));
222 /* Remove ENTRY from the list of hooks called on removing edges. */
224 cgraph_remove_edge_removal_hook (struct cgraph_edge_hook_list *entry)
226 struct cgraph_edge_hook_list **ptr = &first_cgraph_edge_removal_hook;
228 while (*ptr != entry)
234 /* Call all edge removal hooks. */
236 cgraph_call_edge_removal_hooks (struct cgraph_edge *e)
238 struct cgraph_edge_hook_list *entry = first_cgraph_edge_removal_hook;
241 entry->hook (e, entry->data);
246 /* Register HOOK to be called with DATA on each removed node. */
247 struct cgraph_node_hook_list *
248 cgraph_add_node_removal_hook (cgraph_node_hook hook, void *data)
250 struct cgraph_node_hook_list *entry;
251 struct cgraph_node_hook_list **ptr = &first_cgraph_node_removal_hook;
253 entry = (struct cgraph_node_hook_list *) xmalloc (sizeof (*entry));
263 /* Remove ENTRY from the list of hooks called on removing nodes. */
265 cgraph_remove_node_removal_hook (struct cgraph_node_hook_list *entry)
267 struct cgraph_node_hook_list **ptr = &first_cgraph_node_removal_hook;
269 while (*ptr != entry)
275 /* Call all node removal hooks. */
277 cgraph_call_node_removal_hooks (struct cgraph_node *node)
279 struct cgraph_node_hook_list *entry = first_cgraph_node_removal_hook;
282 entry->hook (node, entry->data);
287 /* Register HOOK to be called with DATA on each inserted node. */
288 struct cgraph_node_hook_list *
289 cgraph_add_function_insertion_hook (cgraph_node_hook hook, void *data)
291 struct cgraph_node_hook_list *entry;
292 struct cgraph_node_hook_list **ptr = &first_cgraph_function_insertion_hook;
294 entry = (struct cgraph_node_hook_list *) xmalloc (sizeof (*entry));
304 /* Remove ENTRY from the list of hooks called on inserted nodes. */
306 cgraph_remove_function_insertion_hook (struct cgraph_node_hook_list *entry)
308 struct cgraph_node_hook_list **ptr = &first_cgraph_function_insertion_hook;
310 while (*ptr != entry)
316 /* Call all node insertion hooks. */
318 cgraph_call_function_insertion_hooks (struct cgraph_node *node)
320 struct cgraph_node_hook_list *entry = first_cgraph_function_insertion_hook;
323 entry->hook (node, entry->data);
328 /* Register HOOK to be called with DATA on each duplicated edge. */
329 struct cgraph_2edge_hook_list *
330 cgraph_add_edge_duplication_hook (cgraph_2edge_hook hook, void *data)
332 struct cgraph_2edge_hook_list *entry;
333 struct cgraph_2edge_hook_list **ptr = &first_cgraph_edge_duplicated_hook;
335 entry = (struct cgraph_2edge_hook_list *) xmalloc (sizeof (*entry));
345 /* Remove ENTRY from the list of hooks called on duplicating edges. */
347 cgraph_remove_edge_duplication_hook (struct cgraph_2edge_hook_list *entry)
349 struct cgraph_2edge_hook_list **ptr = &first_cgraph_edge_duplicated_hook;
351 while (*ptr != entry)
357 /* Call all edge duplication hooks. */
359 cgraph_call_edge_duplication_hooks (struct cgraph_edge *cs1,
360 struct cgraph_edge *cs2)
362 struct cgraph_2edge_hook_list *entry = first_cgraph_edge_duplicated_hook;
365 entry->hook (cs1, cs2, entry->data);
370 /* Register HOOK to be called with DATA on each duplicated node. */
371 struct cgraph_2node_hook_list *
372 cgraph_add_node_duplication_hook (cgraph_2node_hook hook, void *data)
374 struct cgraph_2node_hook_list *entry;
375 struct cgraph_2node_hook_list **ptr = &first_cgraph_node_duplicated_hook;
377 entry = (struct cgraph_2node_hook_list *) xmalloc (sizeof (*entry));
387 /* Remove ENTRY from the list of hooks called on duplicating nodes. */
389 cgraph_remove_node_duplication_hook (struct cgraph_2node_hook_list *entry)
391 struct cgraph_2node_hook_list **ptr = &first_cgraph_node_duplicated_hook;
393 while (*ptr != entry)
399 /* Call all node duplication hooks. */
401 cgraph_call_node_duplication_hooks (struct cgraph_node *node1,
402 struct cgraph_node *node2)
404 struct cgraph_2node_hook_list *entry = first_cgraph_node_duplicated_hook;
407 entry->hook (node1, node2, entry->data);
412 /* Returns a hash code for P. */
415 hash_node (const void *p)
417 const struct cgraph_node *n = (const struct cgraph_node *) p;
418 return (hashval_t) DECL_UID (n->decl);
422 /* Returns nonzero if P1 and P2 are equal. */
425 eq_node (const void *p1, const void *p2)
427 const struct cgraph_node *n1 = (const struct cgraph_node *) p1;
428 const struct cgraph_node *n2 = (const struct cgraph_node *) p2;
429 return DECL_UID (n1->decl) == DECL_UID (n2->decl);
432 /* Allocate new callgraph node. */
434 static inline struct cgraph_node *
435 cgraph_allocate_node (void)
437 struct cgraph_node *node;
442 free_nodes = NEXT_FREE_NODE (node);
446 node = ggc_alloc_cleared_cgraph_node ();
447 node->uid = cgraph_max_uid++;
453 /* Allocate new callgraph node and insert it into basic data structures. */
455 static struct cgraph_node *
456 cgraph_create_node (void)
458 struct cgraph_node *node = cgraph_allocate_node ();
460 node->next = cgraph_nodes;
462 node->order = cgraph_order++;
464 cgraph_nodes->previous = node;
465 node->previous = NULL;
466 node->global.estimated_growth = INT_MIN;
467 node->frequency = NODE_FREQUENCY_NORMAL;
468 ipa_empty_ref_list (&node->ref_list);
474 /* Return cgraph node assigned to DECL. Create new one when needed. */
477 cgraph_node (tree decl)
479 struct cgraph_node key, *node, **slot;
481 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
484 cgraph_hash = htab_create_ggc (10, hash_node, eq_node, NULL);
488 slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, &key, INSERT);
493 if (node->same_body_alias)
494 node = node->same_body;
498 node = cgraph_create_node ();
501 if (DECL_CONTEXT (decl) && TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)
503 node->origin = cgraph_node (DECL_CONTEXT (decl));
504 node->next_nested = node->origin->nested;
505 node->origin->nested = node;
507 if (assembler_name_hash)
510 tree name = DECL_ASSEMBLER_NAME (decl);
512 aslot = htab_find_slot_with_hash (assembler_name_hash, name,
513 decl_assembler_name_hash (name),
515 /* We can have multiple declarations with same assembler name. For C++
516 it is __builtin_strlen and strlen, for instance. Do we need to
517 record them all? Original implementation marked just first one
518 so lets hope for the best. */
525 /* Mark ALIAS as an alias to DECL. */
527 static struct cgraph_node *
528 cgraph_same_body_alias_1 (tree alias, tree decl)
530 struct cgraph_node key, *alias_node, *decl_node, **slot;
532 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
533 gcc_assert (TREE_CODE (alias) == FUNCTION_DECL);
534 decl_node = cgraph_node (decl);
538 slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, &key, INSERT);
540 /* If the cgraph_node has been already created, fail. */
544 alias_node = cgraph_allocate_node ();
545 alias_node->decl = alias;
546 alias_node->same_body_alias = 1;
547 alias_node->same_body = decl_node;
548 alias_node->previous = NULL;
549 if (decl_node->same_body)
550 decl_node->same_body->previous = alias_node;
551 alias_node->next = decl_node->same_body;
552 alias_node->thunk.alias = decl;
553 decl_node->same_body = alias_node;
558 /* Attempt to mark ALIAS as an alias to DECL. Return alias node if successful
560 Same body aliases are output whenever the body of DECL is output,
561 and cgraph_node (ALIAS) transparently returns cgraph_node (DECL). */
564 cgraph_same_body_alias (tree alias, tree decl)
566 #ifndef ASM_OUTPUT_DEF
567 /* If aliases aren't supported by the assembler, fail. */
571 /*gcc_assert (!assembler_name_hash);*/
573 return cgraph_same_body_alias_1 (alias, decl);
576 /* Add thunk alias into callgraph. The alias declaration is ALIAS and it
577 alises DECL with an adjustments made into the first parameter.
578 See comments in thunk_adjust for detail on the parameters. */
581 cgraph_add_thunk (tree alias, tree decl, bool this_adjusting,
582 HOST_WIDE_INT fixed_offset, HOST_WIDE_INT virtual_value,
586 struct cgraph_node *node = cgraph_get_node (alias);
590 gcc_assert (node->local.finalized);
591 gcc_assert (!node->same_body);
592 cgraph_remove_node (node);
595 node = cgraph_same_body_alias_1 (alias, decl);
597 gcc_checking_assert (!virtual_offset
598 || tree_int_cst_equal (virtual_offset,
599 size_int (virtual_value)));
600 node->thunk.fixed_offset = fixed_offset;
601 node->thunk.this_adjusting = this_adjusting;
602 node->thunk.virtual_value = virtual_value;
603 node->thunk.virtual_offset_p = virtual_offset != NULL;
604 node->thunk.alias = real_alias;
605 node->thunk.thunk_p = true;
609 /* Returns the cgraph node assigned to DECL or NULL if no cgraph node
613 cgraph_get_node_or_alias (const_tree decl)
615 struct cgraph_node key, *node = NULL, **slot;
617 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
622 key.decl = CONST_CAST2 (tree, const_tree, decl);
624 slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, &key,
632 /* Returns the cgraph node assigned to DECL or NULL if no cgraph node
636 cgraph_get_node (const_tree decl)
638 struct cgraph_node key, *node = NULL, **slot;
640 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
645 key.decl = CONST_CAST2 (tree, const_tree, decl);
647 slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, &key,
653 if (node->same_body_alias)
654 node = node->same_body;
659 /* Insert already constructed node into hashtable. */
662 cgraph_insert_node_to_hashtable (struct cgraph_node *node)
664 struct cgraph_node **slot;
666 slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, node, INSERT);
672 /* Returns a hash code for P. */
675 hash_node_by_assembler_name (const void *p)
677 const struct cgraph_node *n = (const struct cgraph_node *) p;
678 return (hashval_t) decl_assembler_name_hash (DECL_ASSEMBLER_NAME (n->decl));
681 /* Returns nonzero if P1 and P2 are equal. */
684 eq_assembler_name (const void *p1, const void *p2)
686 const struct cgraph_node *n1 = (const struct cgraph_node *) p1;
687 const_tree name = (const_tree)p2;
688 return (decl_assembler_name_equal (n1->decl, name));
691 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
692 Return NULL if there's no such node. */
695 cgraph_node_for_asm (tree asmname)
697 struct cgraph_node *node;
700 if (!assembler_name_hash)
702 assembler_name_hash =
703 htab_create_ggc (10, hash_node_by_assembler_name, eq_assembler_name,
705 for (node = cgraph_nodes; node; node = node->next)
706 if (!node->global.inlined_to)
708 tree name = DECL_ASSEMBLER_NAME (node->decl);
709 slot = htab_find_slot_with_hash (assembler_name_hash, name,
710 decl_assembler_name_hash (name),
712 /* We can have multiple declarations with same assembler name. For C++
713 it is __builtin_strlen and strlen, for instance. Do we need to
714 record them all? Original implementation marked just first one
715 so lets hope for the best. */
720 struct cgraph_node *alias;
722 for (alias = node->same_body; alias; alias = alias->next)
725 name = DECL_ASSEMBLER_NAME (alias->decl);
726 hash = decl_assembler_name_hash (name);
727 slot = htab_find_slot_with_hash (assembler_name_hash, name,
736 slot = htab_find_slot_with_hash (assembler_name_hash, asmname,
737 decl_assembler_name_hash (asmname),
742 node = (struct cgraph_node *) *slot;
743 if (node->same_body_alias)
744 node = node->same_body;
750 /* Returns a hash value for X (which really is a die_struct). */
753 edge_hash (const void *x)
755 return htab_hash_pointer (((const struct cgraph_edge *) x)->call_stmt);
758 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
761 edge_eq (const void *x, const void *y)
763 return ((const struct cgraph_edge *) x)->call_stmt == y;
766 /* Add call graph edge E to call site hash of its caller. */
769 cgraph_add_edge_to_call_site_hash (struct cgraph_edge *e)
772 slot = htab_find_slot_with_hash (e->caller->call_site_hash,
774 htab_hash_pointer (e->call_stmt),
780 /* Return the callgraph edge representing the GIMPLE_CALL statement
784 cgraph_edge (struct cgraph_node *node, gimple call_stmt)
786 struct cgraph_edge *e, *e2;
789 if (node->call_site_hash)
790 return (struct cgraph_edge *)
791 htab_find_with_hash (node->call_site_hash, call_stmt,
792 htab_hash_pointer (call_stmt));
794 /* This loop may turn out to be performance problem. In such case adding
795 hashtables into call nodes with very many edges is probably best
796 solution. It is not good idea to add pointer into CALL_EXPR itself
797 because we want to make possible having multiple cgraph nodes representing
798 different clones of the same body before the body is actually cloned. */
799 for (e = node->callees; e; e = e->next_callee)
801 if (e->call_stmt == call_stmt)
807 for (e = node->indirect_calls; e; e = e->next_callee)
809 if (e->call_stmt == call_stmt)
816 node->call_site_hash = htab_create_ggc (120, edge_hash, edge_eq, NULL);
817 for (e2 = node->callees; e2; e2 = e2->next_callee)
818 cgraph_add_edge_to_call_site_hash (e2);
819 for (e2 = node->indirect_calls; e2; e2 = e2->next_callee)
820 cgraph_add_edge_to_call_site_hash (e2);
827 /* Change field call_stmt of edge E to NEW_STMT. */
830 cgraph_set_call_stmt (struct cgraph_edge *e, gimple new_stmt)
834 if (e->caller->call_site_hash)
836 htab_remove_elt_with_hash (e->caller->call_site_hash,
838 htab_hash_pointer (e->call_stmt));
841 e->call_stmt = new_stmt;
842 if (e->indirect_unknown_callee
843 && (decl = gimple_call_fndecl (new_stmt)))
845 /* Constant propagation (and possibly also inlining?) can turn an
846 indirect call into a direct one. */
847 struct cgraph_node *new_callee = cgraph_node (decl);
849 cgraph_make_edge_direct (e, new_callee);
852 push_cfun (DECL_STRUCT_FUNCTION (e->caller->decl));
853 e->can_throw_external = stmt_can_throw_external (new_stmt);
855 if (e->caller->call_site_hash)
856 cgraph_add_edge_to_call_site_hash (e);
859 /* Like cgraph_set_call_stmt but walk the clone tree and update all
860 clones sharing the same function body. */
863 cgraph_set_call_stmt_including_clones (struct cgraph_node *orig,
864 gimple old_stmt, gimple new_stmt)
866 struct cgraph_node *node;
867 struct cgraph_edge *edge = cgraph_edge (orig, old_stmt);
870 cgraph_set_call_stmt (edge, new_stmt);
876 struct cgraph_edge *edge = cgraph_edge (node, old_stmt);
878 cgraph_set_call_stmt (edge, new_stmt);
881 else if (node->next_sibling_clone)
882 node = node->next_sibling_clone;
885 while (node != orig && !node->next_sibling_clone)
886 node = node->clone_of;
888 node = node->next_sibling_clone;
893 /* Like cgraph_create_edge walk the clone tree and update all clones sharing
894 same function body. If clones already have edge for OLD_STMT; only
895 update the edge same way as cgraph_set_call_stmt_including_clones does.
897 TODO: COUNT and LOOP_DEPTH should be properly distributed based on relative
898 frequencies of the clones. */
901 cgraph_create_edge_including_clones (struct cgraph_node *orig,
902 struct cgraph_node *callee,
904 gimple stmt, gcov_type count,
905 int freq, int loop_depth,
906 cgraph_inline_failed_t reason)
908 struct cgraph_node *node;
909 struct cgraph_edge *edge;
911 if (!cgraph_edge (orig, stmt))
913 edge = cgraph_create_edge (orig, callee, stmt, count, freq, loop_depth);
914 edge->inline_failed = reason;
921 struct cgraph_edge *edge = cgraph_edge (node, old_stmt);
923 /* It is possible that clones already contain the edge while
924 master didn't. Either we promoted indirect call into direct
925 call in the clone or we are processing clones of unreachable
926 master where edges has been rmeoved. */
928 cgraph_set_call_stmt (edge, stmt);
929 else if (!cgraph_edge (node, stmt))
931 edge = cgraph_create_edge (node, callee, stmt, count,
933 edge->inline_failed = reason;
938 else if (node->next_sibling_clone)
939 node = node->next_sibling_clone;
942 while (node != orig && !node->next_sibling_clone)
943 node = node->clone_of;
945 node = node->next_sibling_clone;
950 /* Give initial reasons why inlining would fail on EDGE. This gets either
951 nullified or usually overwritten by more precise reasons later. */
954 initialize_inline_failed (struct cgraph_edge *e)
956 struct cgraph_node *callee = e->callee;
958 if (e->indirect_unknown_callee)
959 e->inline_failed = CIF_INDIRECT_UNKNOWN_CALL;
960 else if (!callee->analyzed)
961 e->inline_failed = CIF_BODY_NOT_AVAILABLE;
962 else if (callee->local.redefined_extern_inline)
963 e->inline_failed = CIF_REDEFINED_EXTERN_INLINE;
964 else if (!callee->local.inlinable)
965 e->inline_failed = CIF_FUNCTION_NOT_INLINABLE;
966 else if (e->call_stmt && gimple_call_cannot_inline_p (e->call_stmt))
967 e->inline_failed = CIF_MISMATCHED_ARGUMENTS;
969 e->inline_failed = CIF_FUNCTION_NOT_CONSIDERED;
972 /* Allocate a cgraph_edge structure and fill it with data according to the
973 parameters of which only CALLEE can be NULL (when creating an indirect call
976 static struct cgraph_edge *
977 cgraph_create_edge_1 (struct cgraph_node *caller, struct cgraph_node *callee,
978 gimple call_stmt, gcov_type count, int freq, int nest)
980 struct cgraph_edge *edge;
982 /* LTO does not actually have access to the call_stmt since these
983 have not been loaded yet. */
986 /* This is a rather expensive check possibly trigerring
987 construction of call stmt hashtable. */
988 gcc_checking_assert (!cgraph_edge (caller, call_stmt));
990 gcc_assert (is_gimple_call (call_stmt));
996 free_edges = NEXT_FREE_EDGE (edge);
1000 edge = ggc_alloc_cgraph_edge ();
1001 edge->uid = cgraph_edge_max_uid++;
1005 edge->caller = caller;
1006 edge->callee = callee;
1007 edge->prev_caller = NULL;
1008 edge->next_caller = NULL;
1009 edge->prev_callee = NULL;
1010 edge->next_callee = NULL;
1012 edge->count = count;
1013 gcc_assert (count >= 0);
1014 edge->frequency = freq;
1015 gcc_assert (freq >= 0);
1016 gcc_assert (freq <= CGRAPH_FREQ_MAX);
1017 edge->loop_nest = nest;
1019 edge->call_stmt = call_stmt;
1020 push_cfun (DECL_STRUCT_FUNCTION (caller->decl));
1021 edge->can_throw_external
1022 = call_stmt ? stmt_can_throw_external (call_stmt) : false;
1024 edge->call_stmt_cannot_inline_p =
1025 (call_stmt ? gimple_call_cannot_inline_p (call_stmt) : false);
1026 if (call_stmt && caller->call_site_hash)
1027 cgraph_add_edge_to_call_site_hash (edge);
1029 edge->indirect_info = NULL;
1030 edge->indirect_inlining_edge = 0;
1035 /* Create edge from CALLER to CALLEE in the cgraph. */
1037 struct cgraph_edge *
1038 cgraph_create_edge (struct cgraph_node *caller, struct cgraph_node *callee,
1039 gimple call_stmt, gcov_type count, int freq, int nest)
1041 struct cgraph_edge *edge = cgraph_create_edge_1 (caller, callee, call_stmt,
1044 edge->indirect_unknown_callee = 0;
1045 initialize_inline_failed (edge);
1047 edge->next_caller = callee->callers;
1048 if (callee->callers)
1049 callee->callers->prev_caller = edge;
1050 edge->next_callee = caller->callees;
1051 if (caller->callees)
1052 caller->callees->prev_callee = edge;
1053 caller->callees = edge;
1054 callee->callers = edge;
1060 /* Create an indirect edge with a yet-undetermined callee where the call
1061 statement destination is a formal parameter of the caller with index
1064 struct cgraph_edge *
1065 cgraph_create_indirect_edge (struct cgraph_node *caller, gimple call_stmt,
1067 gcov_type count, int freq, int nest)
1069 struct cgraph_edge *edge = cgraph_create_edge_1 (caller, NULL, call_stmt,
1072 edge->indirect_unknown_callee = 1;
1073 initialize_inline_failed (edge);
1075 edge->indirect_info = ggc_alloc_cleared_cgraph_indirect_call_info ();
1076 edge->indirect_info->param_index = -1;
1077 edge->indirect_info->ecf_flags = ecf_flags;
1079 edge->next_callee = caller->indirect_calls;
1080 if (caller->indirect_calls)
1081 caller->indirect_calls->prev_callee = edge;
1082 caller->indirect_calls = edge;
1087 /* Remove the edge E from the list of the callers of the callee. */
1090 cgraph_edge_remove_callee (struct cgraph_edge *e)
1092 gcc_assert (!e->indirect_unknown_callee);
1094 e->prev_caller->next_caller = e->next_caller;
1096 e->next_caller->prev_caller = e->prev_caller;
1097 if (!e->prev_caller)
1098 e->callee->callers = e->next_caller;
1101 /* Remove the edge E from the list of the callees of the caller. */
1104 cgraph_edge_remove_caller (struct cgraph_edge *e)
1107 e->prev_callee->next_callee = e->next_callee;
1109 e->next_callee->prev_callee = e->prev_callee;
1110 if (!e->prev_callee)
1112 if (e->indirect_unknown_callee)
1113 e->caller->indirect_calls = e->next_callee;
1115 e->caller->callees = e->next_callee;
1117 if (e->caller->call_site_hash)
1118 htab_remove_elt_with_hash (e->caller->call_site_hash,
1120 htab_hash_pointer (e->call_stmt));
1123 /* Put the edge onto the free list. */
1126 cgraph_free_edge (struct cgraph_edge *e)
1130 /* Clear out the edge so we do not dangle pointers. */
1131 memset (e, 0, sizeof (*e));
1133 NEXT_FREE_EDGE (e) = free_edges;
1137 /* Remove the edge E in the cgraph. */
1140 cgraph_remove_edge (struct cgraph_edge *e)
1142 /* Call all edge removal hooks. */
1143 cgraph_call_edge_removal_hooks (e);
1145 if (!e->indirect_unknown_callee)
1146 /* Remove from callers list of the callee. */
1147 cgraph_edge_remove_callee (e);
1149 /* Remove from callees list of the callers. */
1150 cgraph_edge_remove_caller (e);
1152 /* Put the edge onto the free list. */
1153 cgraph_free_edge (e);
1156 /* Set callee of call graph edge E and add it to the corresponding set of
1160 cgraph_set_edge_callee (struct cgraph_edge *e, struct cgraph_node *n)
1162 e->prev_caller = NULL;
1164 n->callers->prev_caller = e;
1165 e->next_caller = n->callers;
1170 /* Redirect callee of E to N. The function does not update underlying
1174 cgraph_redirect_edge_callee (struct cgraph_edge *e, struct cgraph_node *n)
1176 /* Remove from callers list of the current callee. */
1177 cgraph_edge_remove_callee (e);
1179 /* Insert to callers list of the new callee. */
1180 cgraph_set_edge_callee (e, n);
1183 /* Make an indirect EDGE with an unknown callee an ordinary edge leading to
1187 cgraph_make_edge_direct (struct cgraph_edge *edge, struct cgraph_node *callee)
1189 edge->indirect_unknown_callee = 0;
1191 /* Get the edge out of the indirect edge list. */
1192 if (edge->prev_callee)
1193 edge->prev_callee->next_callee = edge->next_callee;
1194 if (edge->next_callee)
1195 edge->next_callee->prev_callee = edge->prev_callee;
1196 if (!edge->prev_callee)
1197 edge->caller->indirect_calls = edge->next_callee;
1199 /* Put it into the normal callee list */
1200 edge->prev_callee = NULL;
1201 edge->next_callee = edge->caller->callees;
1202 if (edge->caller->callees)
1203 edge->caller->callees->prev_callee = edge;
1204 edge->caller->callees = edge;
1206 /* Insert to callers list of the new callee. */
1207 cgraph_set_edge_callee (edge, callee);
1209 /* We need to re-determine the inlining status of the edge. */
1210 initialize_inline_failed (edge);
1214 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1215 OLD_STMT changed into NEW_STMT. OLD_CALL is gimple_call_fndecl
1216 of OLD_STMT if it was previously call statement. */
1219 cgraph_update_edges_for_call_stmt_node (struct cgraph_node *node,
1220 gimple old_stmt, tree old_call, gimple new_stmt)
1222 tree new_call = (is_gimple_call (new_stmt)) ? gimple_call_fndecl (new_stmt) : 0;
1224 /* We are seeing indirect calls, then there is nothing to update. */
1225 if (!new_call && !old_call)
1227 /* See if we turned indirect call into direct call or folded call to one builtin
1228 into different bultin. */
1229 if (old_call != new_call)
1231 struct cgraph_edge *e = cgraph_edge (node, old_stmt);
1232 struct cgraph_edge *ne = NULL;
1239 /* See if the edge is already there and has the correct callee. It
1240 might be so because of indirect inlining has already updated
1241 it. We also might've cloned and redirected the edge. */
1242 if (new_call && e->callee)
1244 struct cgraph_node *callee = e->callee;
1247 if (callee->decl == new_call
1248 || callee->former_clone_of == new_call)
1250 callee = callee->clone_of;
1254 /* Otherwise remove edge and create new one; we can't simply redirect
1255 since function has changed, so inline plan and other information
1256 attached to edge is invalid. */
1258 frequency = e->frequency;
1259 loop_nest = e->loop_nest;
1260 cgraph_remove_edge (e);
1264 /* We are seeing new direct call; compute profile info based on BB. */
1265 basic_block bb = gimple_bb (new_stmt);
1267 frequency = compute_call_stmt_bb_frequency (current_function_decl,
1269 loop_nest = bb->loop_depth;
1274 ne = cgraph_create_edge (node, cgraph_node (new_call),
1275 new_stmt, count, frequency,
1277 gcc_assert (ne->inline_failed);
1280 /* We only updated the call stmt; update pointer in cgraph edge.. */
1281 else if (old_stmt != new_stmt)
1282 cgraph_set_call_stmt (cgraph_edge (node, old_stmt), new_stmt);
1285 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1286 OLD_STMT changed into NEW_STMT. OLD_DECL is gimple_call_fndecl
1287 of OLD_STMT before it was updated (updating can happen inplace). */
1290 cgraph_update_edges_for_call_stmt (gimple old_stmt, tree old_decl, gimple new_stmt)
1292 struct cgraph_node *orig = cgraph_node (cfun->decl);
1293 struct cgraph_node *node;
1295 cgraph_update_edges_for_call_stmt_node (orig, old_stmt, old_decl, new_stmt);
1297 for (node = orig->clones; node != orig;)
1299 cgraph_update_edges_for_call_stmt_node (node, old_stmt, old_decl, new_stmt);
1301 node = node->clones;
1302 else if (node->next_sibling_clone)
1303 node = node->next_sibling_clone;
1306 while (node != orig && !node->next_sibling_clone)
1307 node = node->clone_of;
1309 node = node->next_sibling_clone;
1315 /* Remove all callees from the node. */
1318 cgraph_node_remove_callees (struct cgraph_node *node)
1320 struct cgraph_edge *e, *f;
1322 /* It is sufficient to remove the edges from the lists of callers of
1323 the callees. The callee list of the node can be zapped with one
1325 for (e = node->callees; e; e = f)
1328 cgraph_call_edge_removal_hooks (e);
1329 if (!e->indirect_unknown_callee)
1330 cgraph_edge_remove_callee (e);
1331 cgraph_free_edge (e);
1333 for (e = node->indirect_calls; e; e = f)
1336 cgraph_call_edge_removal_hooks (e);
1337 if (!e->indirect_unknown_callee)
1338 cgraph_edge_remove_callee (e);
1339 cgraph_free_edge (e);
1341 node->indirect_calls = NULL;
1342 node->callees = NULL;
1343 if (node->call_site_hash)
1345 htab_delete (node->call_site_hash);
1346 node->call_site_hash = NULL;
1350 /* Remove all callers from the node. */
1353 cgraph_node_remove_callers (struct cgraph_node *node)
1355 struct cgraph_edge *e, *f;
1357 /* It is sufficient to remove the edges from the lists of callees of
1358 the callers. The caller list of the node can be zapped with one
1360 for (e = node->callers; e; e = f)
1363 cgraph_call_edge_removal_hooks (e);
1364 cgraph_edge_remove_caller (e);
1365 cgraph_free_edge (e);
1367 node->callers = NULL;
1370 /* Release memory used to represent body of function NODE. */
1373 cgraph_release_function_body (struct cgraph_node *node)
1375 if (DECL_STRUCT_FUNCTION (node->decl))
1377 tree old_decl = current_function_decl;
1378 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
1379 if (cfun->gimple_df)
1381 current_function_decl = node->decl;
1383 delete_tree_cfg_annotations ();
1385 current_function_decl = old_decl;
1389 gcc_assert (dom_computed[0] == DOM_NONE);
1390 gcc_assert (dom_computed[1] == DOM_NONE);
1393 if (cfun->value_histograms)
1395 gcc_assert (!current_loops);
1397 gimple_set_body (node->decl, NULL);
1398 VEC_free (ipa_opt_pass, heap,
1399 node->ipa_transforms_to_apply);
1400 /* Struct function hangs a lot of data that would leak if we didn't
1401 removed all pointers to it. */
1402 ggc_free (DECL_STRUCT_FUNCTION (node->decl));
1403 DECL_STRUCT_FUNCTION (node->decl) = NULL;
1405 DECL_SAVED_TREE (node->decl) = NULL;
1406 /* If the node is abstract and needed, then do not clear DECL_INITIAL
1407 of its associated function function declaration because it's
1408 needed to emit debug info later. */
1409 if (!node->abstract_and_needed)
1410 DECL_INITIAL (node->decl) = error_mark_node;
1413 /* Remove same body alias node. */
1416 cgraph_remove_same_body_alias (struct cgraph_node *node)
1419 int uid = node->uid;
1421 gcc_assert (node->same_body_alias);
1423 node->previous->next = node->next;
1425 node->same_body->same_body = node->next;
1427 node->next->previous = node->previous;
1429 node->previous = NULL;
1430 slot = htab_find_slot (cgraph_hash, node, NO_INSERT);
1432 htab_clear_slot (cgraph_hash, slot);
1433 if (assembler_name_hash)
1435 tree name = DECL_ASSEMBLER_NAME (node->decl);
1436 slot = htab_find_slot_with_hash (assembler_name_hash, name,
1437 decl_assembler_name_hash (name),
1439 if (slot && *slot == node)
1440 htab_clear_slot (assembler_name_hash, slot);
1443 /* Clear out the node to NULL all pointers and add the node to the free
1445 memset (node, 0, sizeof(*node));
1447 NEXT_FREE_NODE (node) = free_nodes;
1451 /* Remove the node from cgraph. */
1454 cgraph_remove_node (struct cgraph_node *node)
1457 bool kill_body = false;
1458 struct cgraph_node *n;
1459 int uid = node->uid;
1461 cgraph_call_node_removal_hooks (node);
1462 cgraph_node_remove_callers (node);
1463 cgraph_node_remove_callees (node);
1464 ipa_remove_all_references (&node->ref_list);
1465 ipa_remove_all_refering (&node->ref_list);
1466 VEC_free (ipa_opt_pass, heap,
1467 node->ipa_transforms_to_apply);
1469 /* Incremental inlining access removed nodes stored in the postorder list.
1471 node->needed = node->reachable = false;
1472 for (n = node->nested; n; n = n->next_nested)
1474 node->nested = NULL;
1477 struct cgraph_node **node2 = &node->origin->nested;
1479 while (*node2 != node)
1480 node2 = &(*node2)->next_nested;
1481 *node2 = node->next_nested;
1484 node->previous->next = node->next;
1486 cgraph_nodes = node->next;
1488 node->next->previous = node->previous;
1490 node->previous = NULL;
1491 slot = htab_find_slot (cgraph_hash, node, NO_INSERT);
1494 struct cgraph_node *next_inline_clone;
1496 for (next_inline_clone = node->clones;
1497 next_inline_clone && next_inline_clone->decl != node->decl;
1498 next_inline_clone = next_inline_clone->next_sibling_clone)
1501 /* If there is inline clone of the node being removed, we need
1502 to put it into the position of removed node and reorganize all
1503 other clones to be based on it. */
1504 if (next_inline_clone)
1506 struct cgraph_node *n;
1507 struct cgraph_node *new_clones;
1509 *slot = next_inline_clone;
1511 /* Unlink inline clone from the list of clones of removed node. */
1512 if (next_inline_clone->next_sibling_clone)
1513 next_inline_clone->next_sibling_clone->prev_sibling_clone
1514 = next_inline_clone->prev_sibling_clone;
1515 if (next_inline_clone->prev_sibling_clone)
1517 gcc_assert (node->clones != next_inline_clone);
1518 next_inline_clone->prev_sibling_clone->next_sibling_clone
1519 = next_inline_clone->next_sibling_clone;
1523 gcc_assert (node->clones == next_inline_clone);
1524 node->clones = next_inline_clone->next_sibling_clone;
1527 new_clones = node->clones;
1528 node->clones = NULL;
1530 /* Copy clone info. */
1531 next_inline_clone->clone = node->clone;
1533 /* Now place it into clone tree at same level at NODE. */
1534 next_inline_clone->clone_of = node->clone_of;
1535 next_inline_clone->prev_sibling_clone = NULL;
1536 next_inline_clone->next_sibling_clone = NULL;
1539 if (node->clone_of->clones)
1540 node->clone_of->clones->prev_sibling_clone = next_inline_clone;
1541 next_inline_clone->next_sibling_clone = node->clone_of->clones;
1542 node->clone_of->clones = next_inline_clone;
1545 /* Merge the clone list. */
1548 if (!next_inline_clone->clones)
1549 next_inline_clone->clones = new_clones;
1552 n = next_inline_clone->clones;
1553 while (n->next_sibling_clone)
1554 n = n->next_sibling_clone;
1555 n->next_sibling_clone = new_clones;
1556 new_clones->prev_sibling_clone = n;
1560 /* Update clone_of pointers. */
1564 n->clone_of = next_inline_clone;
1565 n = n->next_sibling_clone;
1570 htab_clear_slot (cgraph_hash, slot);
1575 if (node->prev_sibling_clone)
1576 node->prev_sibling_clone->next_sibling_clone = node->next_sibling_clone;
1577 else if (node->clone_of)
1578 node->clone_of->clones = node->next_sibling_clone;
1579 if (node->next_sibling_clone)
1580 node->next_sibling_clone->prev_sibling_clone = node->prev_sibling_clone;
1583 struct cgraph_node *n, *next;
1587 for (n = node->clones; n->next_sibling_clone; n = n->next_sibling_clone)
1588 n->clone_of = node->clone_of;
1589 n->clone_of = node->clone_of;
1590 n->next_sibling_clone = node->clone_of->clones;
1591 if (node->clone_of->clones)
1592 node->clone_of->clones->prev_sibling_clone = n;
1593 node->clone_of->clones = node->clones;
1597 /* We are removing node with clones. this makes clones inconsistent,
1598 but assume they will be removed subsequently and just keep clone
1599 tree intact. This can happen in unreachable function removal since
1600 we remove unreachable functions in random order, not by bottom-up
1601 walk of clone trees. */
1602 for (n = node->clones; n; n = next)
1604 next = n->next_sibling_clone;
1605 n->next_sibling_clone = NULL;
1606 n->prev_sibling_clone = NULL;
1612 while (node->same_body)
1613 cgraph_remove_same_body_alias (node->same_body);
1615 if (node->same_comdat_group)
1617 struct cgraph_node *prev;
1618 for (prev = node->same_comdat_group;
1619 prev->same_comdat_group != node;
1620 prev = prev->same_comdat_group)
1622 if (node->same_comdat_group == prev)
1623 prev->same_comdat_group = NULL;
1625 prev->same_comdat_group = node->same_comdat_group;
1626 node->same_comdat_group = NULL;
1629 /* While all the clones are removed after being proceeded, the function
1630 itself is kept in the cgraph even after it is compiled. Check whether
1631 we are done with this body and reclaim it proactively if this is the case.
1633 if (!kill_body && *slot)
1635 struct cgraph_node *n = (struct cgraph_node *) *slot;
1636 if (!n->clones && !n->clone_of && !n->global.inlined_to
1637 && (cgraph_global_info_ready
1638 && (TREE_ASM_WRITTEN (n->decl) || DECL_EXTERNAL (n->decl)
1639 || n->in_other_partition)))
1642 if (assembler_name_hash)
1644 tree name = DECL_ASSEMBLER_NAME (node->decl);
1645 slot = htab_find_slot_with_hash (assembler_name_hash, name,
1646 decl_assembler_name_hash (name),
1648 /* Inline clones are not hashed. */
1649 if (slot && *slot == node)
1650 htab_clear_slot (assembler_name_hash, slot);
1654 cgraph_release_function_body (node);
1656 if (node->call_site_hash)
1658 htab_delete (node->call_site_hash);
1659 node->call_site_hash = NULL;
1663 /* Clear out the node to NULL all pointers and add the node to the free
1665 memset (node, 0, sizeof(*node));
1667 NEXT_FREE_NODE (node) = free_nodes;
1671 /* Remove the node from cgraph. */
1674 cgraph_remove_node_and_inline_clones (struct cgraph_node *node)
1676 struct cgraph_edge *e, *next;
1677 for (e = node->callees; e; e = next)
1679 next = e->next_callee;
1680 if (!e->inline_failed)
1681 cgraph_remove_node_and_inline_clones (e->callee);
1683 cgraph_remove_node (node);
1686 /* Notify finalize_compilation_unit that given node is reachable. */
1689 cgraph_mark_reachable_node (struct cgraph_node *node)
1691 if (!node->reachable && node->local.finalized)
1693 if (cgraph_global_info_ready)
1695 /* Verify that function does not appear to be needed out of blue
1696 during the optimization process. This can happen for extern
1697 inlines when bodies was removed after inlining. */
1698 gcc_assert ((node->analyzed || node->in_other_partition
1699 || DECL_EXTERNAL (node->decl)));
1702 notice_global_symbol (node->decl);
1703 node->reachable = 1;
1705 node->next_needed = cgraph_nodes_queue;
1706 cgraph_nodes_queue = node;
1710 /* Likewise indicate that a node is needed, i.e. reachable via some
1714 cgraph_mark_needed_node (struct cgraph_node *node)
1717 gcc_assert (!node->global.inlined_to);
1718 cgraph_mark_reachable_node (node);
1721 /* Likewise indicate that a node is having address taken. */
1724 cgraph_mark_address_taken_node (struct cgraph_node *node)
1726 cgraph_mark_reachable_node (node);
1727 node->address_taken = 1;
1730 /* Return local info for the compiled function. */
1732 struct cgraph_local_info *
1733 cgraph_local_info (tree decl)
1735 struct cgraph_node *node;
1737 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
1738 node = cgraph_node (decl);
1739 return &node->local;
1742 /* Return local info for the compiled function. */
1744 struct cgraph_global_info *
1745 cgraph_global_info (tree decl)
1747 struct cgraph_node *node;
1749 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL && cgraph_global_info_ready);
1750 node = cgraph_node (decl);
1751 return &node->global;
1754 /* Return local info for the compiled function. */
1756 struct cgraph_rtl_info *
1757 cgraph_rtl_info (tree decl)
1759 struct cgraph_node *node;
1761 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
1762 node = cgraph_node (decl);
1763 if (decl != current_function_decl
1764 && !TREE_ASM_WRITTEN (node->decl))
1769 /* Return a string describing the failure REASON. */
1772 cgraph_inline_failed_string (cgraph_inline_failed_t reason)
1775 #define DEFCIFCODE(code, string) string,
1777 static const char *cif_string_table[CIF_N_REASONS] = {
1778 #include "cif-code.def"
1781 /* Signedness of an enum type is implementation defined, so cast it
1782 to unsigned before testing. */
1783 gcc_assert ((unsigned) reason < CIF_N_REASONS);
1784 return cif_string_table[reason];
1787 /* Return name of the node used in debug output. */
1789 cgraph_node_name (struct cgraph_node *node)
1791 return lang_hooks.decl_printable_name (node->decl, 2);
1794 /* Names used to print out the availability enum. */
1795 const char * const cgraph_availability_names[] =
1796 {"unset", "not_available", "overwritable", "available", "local"};
1799 /* Dump call graph node NODE to file F. */
1802 dump_cgraph_node (FILE *f, struct cgraph_node *node)
1804 struct cgraph_edge *edge;
1805 int indirect_calls_count = 0;
1807 fprintf (f, "%s/%i(%i)", cgraph_node_name (node), node->uid,
1809 dump_addr (f, " @", (void *)node);
1810 if (DECL_ASSEMBLER_NAME_SET_P (node->decl))
1811 fprintf (f, " (asm: %s)", IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (node->decl)));
1812 if (node->global.inlined_to)
1813 fprintf (f, " (inline copy in %s/%i)",
1814 cgraph_node_name (node->global.inlined_to),
1815 node->global.inlined_to->uid);
1816 if (node->same_comdat_group)
1817 fprintf (f, " (same comdat group as %s/%i)",
1818 cgraph_node_name (node->same_comdat_group),
1819 node->same_comdat_group->uid);
1821 fprintf (f, " (clone of %s/%i)",
1822 cgraph_node_name (node->clone_of),
1823 node->clone_of->uid);
1824 if (cgraph_function_flags_ready)
1825 fprintf (f, " availability:%s",
1826 cgraph_availability_names [cgraph_function_body_availability (node)]);
1828 fprintf (f, " analyzed");
1829 if (node->in_other_partition)
1830 fprintf (f, " in_other_partition");
1832 fprintf (f, " executed "HOST_WIDEST_INT_PRINT_DEC"x",
1833 (HOST_WIDEST_INT)node->count);
1834 if (node->local.inline_summary.self_time)
1835 fprintf (f, " %i time, %i benefit", node->local.inline_summary.self_time,
1836 node->local.inline_summary.time_inlining_benefit);
1837 if (node->global.time && node->global.time
1838 != node->local.inline_summary.self_time)
1839 fprintf (f, " (%i after inlining)", node->global.time);
1840 if (node->local.inline_summary.self_size)
1841 fprintf (f, " %i size, %i benefit", node->local.inline_summary.self_size,
1842 node->local.inline_summary.size_inlining_benefit);
1843 if (node->global.size && node->global.size
1844 != node->local.inline_summary.self_size)
1845 fprintf (f, " (%i after inlining)", node->global.size);
1846 if (node->local.inline_summary.estimated_self_stack_size)
1847 fprintf (f, " %i bytes stack usage", (int)node->local.inline_summary.estimated_self_stack_size);
1848 if (node->global.estimated_stack_size != node->local.inline_summary.estimated_self_stack_size)
1849 fprintf (f, " %i bytes after inlining", (int)node->global.estimated_stack_size);
1851 fprintf (f, " nested in: %s", cgraph_node_name (node->origin));
1853 fprintf (f, " needed");
1854 if (node->address_taken)
1855 fprintf (f, " address_taken");
1856 else if (node->reachable)
1857 fprintf (f, " reachable");
1858 else if (node->reachable_from_other_partition)
1859 fprintf (f, " reachable_from_other_partition");
1860 if (gimple_has_body_p (node->decl))
1861 fprintf (f, " body");
1863 fprintf (f, " process");
1864 if (node->local.local)
1865 fprintf (f, " local");
1866 if (node->local.externally_visible)
1867 fprintf (f, " externally_visible");
1868 if (node->local.finalized)
1869 fprintf (f, " finalized");
1870 if (node->local.disregard_inline_limits)
1871 fprintf (f, " always_inline");
1872 else if (node->local.inlinable)
1873 fprintf (f, " inlinable");
1874 else if (node->local.versionable)
1875 fprintf (f, " versionable");
1876 if (node->local.redefined_extern_inline)
1877 fprintf (f, " redefined_extern_inline");
1878 if (TREE_ASM_WRITTEN (node->decl))
1879 fprintf (f, " asm_written");
1880 if (node->only_called_at_startup)
1881 fprintf (f, " only_called_at_startup");
1882 if (node->only_called_at_exit)
1883 fprintf (f, " only_called_at_exit");
1885 fprintf (f, "\n called by: ");
1886 for (edge = node->callers; edge; edge = edge->next_caller)
1888 fprintf (f, "%s/%i ", cgraph_node_name (edge->caller),
1891 fprintf (f, "("HOST_WIDEST_INT_PRINT_DEC"x) ",
1892 (HOST_WIDEST_INT)edge->count);
1893 if (edge->frequency)
1894 fprintf (f, "(%.2f per call) ",
1895 edge->frequency / (double)CGRAPH_FREQ_BASE);
1896 if (!edge->inline_failed)
1897 fprintf(f, "(inlined) ");
1898 if (edge->indirect_inlining_edge)
1899 fprintf(f, "(indirect_inlining) ");
1900 if (edge->can_throw_external)
1901 fprintf(f, "(can throw external) ");
1904 fprintf (f, "\n calls: ");
1905 for (edge = node->callees; edge; edge = edge->next_callee)
1907 fprintf (f, "%s/%i ", cgraph_node_name (edge->callee),
1909 if (!edge->inline_failed)
1910 fprintf(f, "(inlined) ");
1911 if (edge->indirect_inlining_edge)
1912 fprintf(f, "(indirect_inlining) ");
1914 fprintf (f, "("HOST_WIDEST_INT_PRINT_DEC"x) ",
1915 (HOST_WIDEST_INT)edge->count);
1916 if (edge->frequency)
1917 fprintf (f, "(%.2f per call) ",
1918 edge->frequency / (double)CGRAPH_FREQ_BASE);
1919 if (edge->loop_nest)
1920 fprintf (f, "(nested in %i loops) ", edge->loop_nest);
1921 if (edge->can_throw_external)
1922 fprintf(f, "(can throw external) ");
1925 fprintf (f, " References: ");
1926 ipa_dump_references (f, &node->ref_list);
1927 fprintf (f, " Refering this function: ");
1928 ipa_dump_refering (f, &node->ref_list);
1930 for (edge = node->indirect_calls; edge; edge = edge->next_callee)
1931 indirect_calls_count++;
1932 if (indirect_calls_count)
1933 fprintf (f, " has %i outgoing edges for indirect calls.\n",
1934 indirect_calls_count);
1936 if (node->same_body)
1938 struct cgraph_node *n;
1939 fprintf (f, " aliases & thunks:");
1940 for (n = node->same_body; n; n = n->next)
1942 fprintf (f, " %s/%i", cgraph_node_name (n), n->uid);
1943 if (n->thunk.thunk_p)
1945 fprintf (f, " (thunk of %s fixed ofset %i virtual value %i has "
1946 "virtual offset %i",
1947 lang_hooks.decl_printable_name (n->thunk.alias, 2),
1948 (int)n->thunk.fixed_offset,
1949 (int)n->thunk.virtual_value,
1950 (int)n->thunk.virtual_offset_p);
1953 if (DECL_ASSEMBLER_NAME_SET_P (n->decl))
1954 fprintf (f, " (asm: %s)", IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (n->decl)));
1961 /* Dump call graph node NODE to stderr. */
1964 debug_cgraph_node (struct cgraph_node *node)
1966 dump_cgraph_node (stderr, node);
1970 /* Dump the callgraph to file F. */
1973 dump_cgraph (FILE *f)
1975 struct cgraph_node *node;
1977 fprintf (f, "callgraph:\n\n");
1978 for (node = cgraph_nodes; node; node = node->next)
1979 dump_cgraph_node (f, node);
1983 /* Dump the call graph to stderr. */
1988 dump_cgraph (stderr);
1992 /* Set the DECL_ASSEMBLER_NAME and update cgraph hashtables. */
1995 change_decl_assembler_name (tree decl, tree name)
1997 struct cgraph_node *node;
1999 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
2000 SET_DECL_ASSEMBLER_NAME (decl, name);
2003 if (name == DECL_ASSEMBLER_NAME (decl))
2006 if (assembler_name_hash
2007 && TREE_CODE (decl) == FUNCTION_DECL
2008 && (node = cgraph_get_node_or_alias (decl)) != NULL)
2010 tree old_name = DECL_ASSEMBLER_NAME (decl);
2011 slot = htab_find_slot_with_hash (assembler_name_hash, old_name,
2012 decl_assembler_name_hash (old_name),
2014 /* Inline clones are not hashed. */
2015 if (slot && *slot == node)
2016 htab_clear_slot (assembler_name_hash, slot);
2018 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
2019 && DECL_RTL_SET_P (decl))
2020 warning (0, "%D renamed after being referenced in assembly", decl);
2022 SET_DECL_ASSEMBLER_NAME (decl, name);
2024 if (assembler_name_hash
2025 && TREE_CODE (decl) == FUNCTION_DECL
2026 && (node = cgraph_get_node_or_alias (decl)) != NULL)
2028 slot = htab_find_slot_with_hash (assembler_name_hash, name,
2029 decl_assembler_name_hash (name),
2031 gcc_assert (!*slot);
2036 /* Add a top-level asm statement to the list. */
2038 struct cgraph_asm_node *
2039 cgraph_add_asm_node (tree asm_str)
2041 struct cgraph_asm_node *node;
2043 node = ggc_alloc_cleared_cgraph_asm_node ();
2044 node->asm_str = asm_str;
2045 node->order = cgraph_order++;
2047 if (cgraph_asm_nodes == NULL)
2048 cgraph_asm_nodes = node;
2050 cgraph_asm_last_node->next = node;
2051 cgraph_asm_last_node = node;
2055 /* Return true when the DECL can possibly be inlined. */
2057 cgraph_function_possibly_inlined_p (tree decl)
2059 if (!cgraph_global_info_ready)
2060 return !DECL_UNINLINABLE (decl);
2061 return DECL_POSSIBLY_INLINED (decl);
2064 /* Create clone of E in the node N represented by CALL_EXPR the callgraph. */
2065 struct cgraph_edge *
2066 cgraph_clone_edge (struct cgraph_edge *e, struct cgraph_node *n,
2067 gimple call_stmt, unsigned stmt_uid, gcov_type count_scale,
2068 int freq_scale, int loop_nest, bool update_original)
2070 struct cgraph_edge *new_edge;
2071 gcov_type count = e->count * count_scale / REG_BR_PROB_BASE;
2074 /* We do not want to ignore loop nest after frequency drops to 0. */
2077 freq = e->frequency * (gcov_type) freq_scale / CGRAPH_FREQ_BASE;
2078 if (freq > CGRAPH_FREQ_MAX)
2079 freq = CGRAPH_FREQ_MAX;
2081 if (e->indirect_unknown_callee)
2085 if (call_stmt && (decl = gimple_call_fndecl (call_stmt)))
2087 struct cgraph_node *callee = cgraph_node (decl);
2088 new_edge = cgraph_create_edge (n, callee, call_stmt, count, freq,
2089 e->loop_nest + loop_nest);
2093 new_edge = cgraph_create_indirect_edge (n, call_stmt,
2094 e->indirect_info->ecf_flags,
2096 e->loop_nest + loop_nest);
2097 *new_edge->indirect_info = *e->indirect_info;
2101 new_edge = cgraph_create_edge (n, e->callee, call_stmt, count, freq,
2102 e->loop_nest + loop_nest);
2104 new_edge->inline_failed = e->inline_failed;
2105 new_edge->indirect_inlining_edge = e->indirect_inlining_edge;
2106 new_edge->lto_stmt_uid = stmt_uid;
2107 if (update_original)
2109 e->count -= new_edge->count;
2113 cgraph_call_edge_duplication_hooks (e, new_edge);
2117 /* Create node representing clone of N executed COUNT times. Decrease
2118 the execution counts from original node too.
2119 The new clone will have decl set to DECL that may or may not be the same
2122 When UPDATE_ORIGINAL is true, the counts are subtracted from the original
2123 function's profile to reflect the fact that part of execution is handled
2125 struct cgraph_node *
2126 cgraph_clone_node (struct cgraph_node *n, tree decl, gcov_type count, int freq,
2127 int loop_nest, bool update_original,
2128 VEC(cgraph_edge_p,heap) *redirect_callers)
2130 struct cgraph_node *new_node = cgraph_create_node ();
2131 struct cgraph_edge *e;
2132 gcov_type count_scale;
2135 new_node->decl = decl;
2136 new_node->origin = n->origin;
2137 if (new_node->origin)
2139 new_node->next_nested = new_node->origin->nested;
2140 new_node->origin->nested = new_node;
2142 new_node->analyzed = n->analyzed;
2143 new_node->local = n->local;
2144 new_node->local.externally_visible = false;
2145 new_node->local.local = true;
2146 new_node->local.vtable_method = false;
2147 new_node->global = n->global;
2148 new_node->rtl = n->rtl;
2149 new_node->count = count;
2150 new_node->frequency = n->frequency;
2151 new_node->clone = n->clone;
2152 new_node->clone.tree_map = 0;
2155 if (new_node->count > n->count)
2156 count_scale = REG_BR_PROB_BASE;
2158 count_scale = new_node->count * REG_BR_PROB_BASE / n->count;
2162 if (update_original)
2169 FOR_EACH_VEC_ELT (cgraph_edge_p, redirect_callers, i, e)
2171 /* Redirect calls to the old version node to point to its new
2173 cgraph_redirect_edge_callee (e, new_node);
2177 for (e = n->callees;e; e=e->next_callee)
2178 cgraph_clone_edge (e, new_node, e->call_stmt, e->lto_stmt_uid,
2179 count_scale, freq, loop_nest, update_original);
2181 for (e = n->indirect_calls; e; e = e->next_callee)
2182 cgraph_clone_edge (e, new_node, e->call_stmt, e->lto_stmt_uid,
2183 count_scale, freq, loop_nest, update_original);
2184 ipa_clone_references (new_node, NULL, &n->ref_list);
2186 new_node->next_sibling_clone = n->clones;
2188 n->clones->prev_sibling_clone = new_node;
2189 n->clones = new_node;
2190 new_node->clone_of = n;
2192 cgraph_call_node_duplication_hooks (n, new_node);
2193 if (n->decl != decl)
2195 struct cgraph_node **slot;
2196 slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, new_node, INSERT);
2197 gcc_assert (!*slot);
2199 if (assembler_name_hash)
2202 tree name = DECL_ASSEMBLER_NAME (decl);
2204 aslot = htab_find_slot_with_hash (assembler_name_hash, name,
2205 decl_assembler_name_hash (name),
2207 gcc_assert (!*aslot);
2214 /* Create a new name for clone of DECL, add SUFFIX. Returns an identifier. */
2216 static GTY(()) unsigned int clone_fn_id_num;
2219 clone_function_name (tree decl, const char *suffix)
2221 tree name = DECL_ASSEMBLER_NAME (decl);
2222 size_t len = IDENTIFIER_LENGTH (name);
2223 char *tmp_name, *prefix;
2225 prefix = XALLOCAVEC (char, len + strlen (suffix) + 2);
2226 memcpy (prefix, IDENTIFIER_POINTER (name), len);
2227 strcpy (prefix + len + 1, suffix);
2228 #ifndef NO_DOT_IN_LABEL
2230 #elif !defined NO_DOLLAR_IN_LABEL
2235 ASM_FORMAT_PRIVATE_NAME (tmp_name, prefix, clone_fn_id_num++);
2236 return get_identifier (tmp_name);
2239 /* Create callgraph node clone with new declaration. The actual body will
2240 be copied later at compilation stage.
2242 TODO: after merging in ipa-sra use function call notes instead of args_to_skip
2245 struct cgraph_node *
2246 cgraph_create_virtual_clone (struct cgraph_node *old_node,
2247 VEC(cgraph_edge_p,heap) *redirect_callers,
2248 VEC(ipa_replace_map_p,gc) *tree_map,
2249 bitmap args_to_skip,
2250 const char * suffix)
2252 tree old_decl = old_node->decl;
2253 struct cgraph_node *new_node = NULL;
2256 struct ipa_replace_map *map;
2259 gcc_checking_assert (tree_versionable_function_p (old_decl));
2261 /* Make a new FUNCTION_DECL tree node */
2263 new_decl = copy_node (old_decl);
2265 new_decl = build_function_decl_skip_args (old_decl, args_to_skip);
2266 DECL_STRUCT_FUNCTION (new_decl) = NULL;
2268 /* Generate a new name for the new version. */
2269 DECL_NAME (new_decl) = clone_function_name (old_decl, suffix);
2270 SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
2271 SET_DECL_RTL (new_decl, NULL);
2273 new_node = cgraph_clone_node (old_node, new_decl, old_node->count,
2274 CGRAPH_FREQ_BASE, 0, false,
2276 /* Update the properties.
2277 Make clone visible only within this translation unit. Make sure
2278 that is not weak also.
2279 ??? We cannot use COMDAT linkage because there is no
2280 ABI support for this. */
2281 DECL_EXTERNAL (new_node->decl) = 0;
2282 if (DECL_ONE_ONLY (old_decl))
2283 DECL_SECTION_NAME (new_node->decl) = NULL;
2284 DECL_COMDAT_GROUP (new_node->decl) = 0;
2285 TREE_PUBLIC (new_node->decl) = 0;
2286 DECL_COMDAT (new_node->decl) = 0;
2287 DECL_WEAK (new_node->decl) = 0;
2288 new_node->clone.tree_map = tree_map;
2289 new_node->clone.args_to_skip = args_to_skip;
2290 FOR_EACH_VEC_ELT (ipa_replace_map_p, tree_map, i, map)
2292 tree var = map->new_tree;
2295 if (TREE_CODE (var) != ADDR_EXPR)
2297 var = get_base_var (var);
2301 /* Record references of the future statement initializing the constant
2303 if (TREE_CODE (var) == FUNCTION_DECL)
2304 ipa_record_reference (new_node, NULL, cgraph_node (var),
2305 NULL, IPA_REF_ADDR, NULL);
2306 else if (TREE_CODE (var) == VAR_DECL)
2307 ipa_record_reference (new_node, NULL, NULL, varpool_node (var),
2308 IPA_REF_ADDR, NULL);
2311 new_node->clone.combined_args_to_skip = old_node->clone.combined_args_to_skip;
2312 else if (old_node->clone.combined_args_to_skip)
2314 int newi = 0, oldi = 0;
2316 bitmap new_args_to_skip = BITMAP_GGC_ALLOC ();
2317 struct cgraph_node *orig_node;
2318 for (orig_node = old_node; orig_node->clone_of; orig_node = orig_node->clone_of)
2320 for (arg = DECL_ARGUMENTS (orig_node->decl); arg; arg = DECL_CHAIN (arg), oldi++)
2322 if (bitmap_bit_p (old_node->clone.combined_args_to_skip, oldi))
2324 bitmap_set_bit (new_args_to_skip, oldi);
2327 if (bitmap_bit_p (args_to_skip, newi))
2328 bitmap_set_bit (new_args_to_skip, oldi);
2331 new_node->clone.combined_args_to_skip = new_args_to_skip;
2334 new_node->clone.combined_args_to_skip = args_to_skip;
2335 new_node->local.externally_visible = 0;
2336 new_node->local.local = 1;
2337 new_node->lowered = true;
2338 new_node->reachable = true;
2344 /* NODE is no longer nested function; update cgraph accordingly. */
2346 cgraph_unnest_node (struct cgraph_node *node)
2348 struct cgraph_node **node2 = &node->origin->nested;
2349 gcc_assert (node->origin);
2351 while (*node2 != node)
2352 node2 = &(*node2)->next_nested;
2353 *node2 = node->next_nested;
2354 node->origin = NULL;
2357 /* Return function availability. See cgraph.h for description of individual
2360 cgraph_function_body_availability (struct cgraph_node *node)
2362 enum availability avail;
2363 gcc_assert (cgraph_function_flags_ready);
2364 if (!node->analyzed)
2365 avail = AVAIL_NOT_AVAILABLE;
2366 else if (node->local.local)
2367 avail = AVAIL_LOCAL;
2368 else if (!node->local.externally_visible)
2369 avail = AVAIL_AVAILABLE;
2370 /* Inline functions are safe to be analyzed even if their sybol can
2371 be overwritten at runtime. It is not meaningful to enfore any sane
2372 behaviour on replacing inline function by different body. */
2373 else if (DECL_DECLARED_INLINE_P (node->decl))
2374 avail = AVAIL_AVAILABLE;
2376 /* If the function can be overwritten, return OVERWRITABLE. Take
2377 care at least of two notable extensions - the COMDAT functions
2378 used to share template instantiations in C++ (this is symmetric
2379 to code cp_cannot_inline_tree_fn and probably shall be shared and
2380 the inlinability hooks completely eliminated).
2382 ??? Does the C++ one definition rule allow us to always return
2383 AVAIL_AVAILABLE here? That would be good reason to preserve this
2386 else if (decl_replaceable_p (node->decl) && !DECL_EXTERNAL (node->decl))
2387 avail = AVAIL_OVERWRITABLE;
2388 else avail = AVAIL_AVAILABLE;
2393 /* Add the function FNDECL to the call graph.
2394 Unlike cgraph_finalize_function, this function is intended to be used
2395 by middle end and allows insertion of new function at arbitrary point
2396 of compilation. The function can be either in high, low or SSA form
2399 The function is assumed to be reachable and have address taken (so no
2400 API breaking optimizations are performed on it).
2402 Main work done by this function is to enqueue the function for later
2403 processing to avoid need the passes to be re-entrant. */
2406 cgraph_add_new_function (tree fndecl, bool lowered)
2408 struct cgraph_node *node;
2409 switch (cgraph_state)
2411 case CGRAPH_STATE_CONSTRUCTION:
2412 /* Just enqueue function to be processed at nearest occurrence. */
2413 node = cgraph_node (fndecl);
2414 node->next_needed = cgraph_new_nodes;
2416 node->lowered = true;
2417 cgraph_new_nodes = node;
2420 case CGRAPH_STATE_IPA:
2421 case CGRAPH_STATE_IPA_SSA:
2422 case CGRAPH_STATE_EXPANSION:
2423 /* Bring the function into finalized state and enqueue for later
2424 analyzing and compilation. */
2425 node = cgraph_node (fndecl);
2426 node->local.local = false;
2427 node->local.finalized = true;
2428 node->reachable = node->needed = true;
2429 if (!lowered && cgraph_state == CGRAPH_STATE_EXPANSION)
2431 push_cfun (DECL_STRUCT_FUNCTION (fndecl));
2432 current_function_decl = fndecl;
2433 gimple_register_cfg_hooks ();
2434 tree_lowering_passes (fndecl);
2435 bitmap_obstack_initialize (NULL);
2436 if (!gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl)))
2437 execute_pass_list (pass_early_local_passes.pass.sub);
2438 bitmap_obstack_release (NULL);
2440 current_function_decl = NULL;
2445 node->lowered = true;
2446 node->next_needed = cgraph_new_nodes;
2447 cgraph_new_nodes = node;
2450 case CGRAPH_STATE_FINISHED:
2451 /* At the very end of compilation we have to do all the work up
2453 push_cfun (DECL_STRUCT_FUNCTION (fndecl));
2454 current_function_decl = fndecl;
2455 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);
2462 tree_rest_of_compilation (fndecl);
2464 current_function_decl = NULL;
2468 /* Set a personality if required and we already passed EH lowering. */
2470 && (function_needs_eh_personality (DECL_STRUCT_FUNCTION (fndecl))
2471 == eh_personality_lang))
2472 DECL_FUNCTION_PERSONALITY (fndecl) = lang_hooks.eh_personality ();
2475 /* Return true if NODE can be made local for API change.
2476 Extern inline functions and C++ COMDAT functions can be made local
2477 at the expense of possible code size growth if function is used in multiple
2478 compilation units. */
2480 cgraph_node_can_be_local_p (struct cgraph_node *node)
2482 return (!node->needed && !node->address_taken
2483 && ((DECL_COMDAT (node->decl) && !node->same_comdat_group)
2484 || !node->local.externally_visible));
2487 /* Make DECL local. FIXME: We shouldn't need to mess with rtl this early,
2488 but other code such as notice_global_symbol generates rtl. */
2490 cgraph_make_decl_local (tree decl)
2494 if (TREE_CODE (decl) == VAR_DECL)
2495 DECL_COMMON (decl) = 0;
2496 else gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
2498 if (DECL_COMDAT (decl))
2500 /* It is possible that we are linking against library defining same COMDAT
2501 function. To avoid conflict we need to rename our local name of the
2502 function just in the case WHOPR partitioning decide to make it hidden
2503 to avoid cross partition references. */
2506 const char *old_name;
2508 old_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2509 if (TREE_CODE (decl) == FUNCTION_DECL)
2511 struct cgraph_node *node = cgraph_get_node_or_alias (decl);
2512 change_decl_assembler_name (decl,
2513 clone_function_name (decl, "local"));
2514 if (node->local.lto_file_data)
2515 lto_record_renamed_decl (node->local.lto_file_data,
2518 (DECL_ASSEMBLER_NAME (decl)));
2520 else if (TREE_CODE (decl) == VAR_DECL)
2522 struct varpool_node *vnode = varpool_get_node (decl);
2523 /* change_decl_assembler_name will warn here on vtables because
2524 C++ frontend still sets TREE_SYMBOL_REFERENCED on them. */
2525 SET_DECL_ASSEMBLER_NAME (decl,
2526 clone_function_name (decl, "local"));
2527 if (vnode->lto_file_data)
2528 lto_record_renamed_decl (vnode->lto_file_data,
2531 (DECL_ASSEMBLER_NAME (decl)));
2534 DECL_SECTION_NAME (decl) = 0;
2535 DECL_COMDAT (decl) = 0;
2537 DECL_COMDAT_GROUP (decl) = 0;
2538 DECL_WEAK (decl) = 0;
2539 DECL_EXTERNAL (decl) = 0;
2540 TREE_PUBLIC (decl) = 0;
2541 if (!DECL_RTL_SET_P (decl))
2544 /* Update rtl flags. */
2545 make_decl_rtl (decl);
2547 rtl = DECL_RTL (decl);
2551 symbol = XEXP (rtl, 0);
2552 if (GET_CODE (symbol) != SYMBOL_REF)
2555 SYMBOL_REF_WEAK (symbol) = DECL_WEAK (decl);
2558 /* Bring NODE local. */
2560 cgraph_make_node_local (struct cgraph_node *node)
2562 gcc_assert (cgraph_node_can_be_local_p (node));
2563 if (DECL_COMDAT (node->decl) || DECL_EXTERNAL (node->decl))
2565 struct cgraph_node *alias;
2566 cgraph_make_decl_local (node->decl);
2568 for (alias = node->same_body; alias; alias = alias->next)
2569 cgraph_make_decl_local (alias->decl);
2571 node->local.externally_visible = false;
2572 node->local.local = true;
2573 node->resolution = LDPR_PREVAILING_DEF_IRONLY;
2574 gcc_assert (cgraph_function_body_availability (node) == AVAIL_LOCAL);
2578 /* Set TREE_NOTHROW on NODE's decl and on same_body aliases of NODE
2579 if any to NOTHROW. */
2582 cgraph_set_nothrow_flag (struct cgraph_node *node, bool nothrow)
2584 struct cgraph_node *alias;
2585 TREE_NOTHROW (node->decl) = nothrow;
2586 for (alias = node->same_body; alias; alias = alias->next)
2587 TREE_NOTHROW (alias->decl) = nothrow;
2590 /* Set TREE_READONLY on NODE's decl and on same_body aliases of NODE
2591 if any to READONLY. */
2594 cgraph_set_readonly_flag (struct cgraph_node *node, bool readonly)
2596 struct cgraph_node *alias;
2597 TREE_READONLY (node->decl) = readonly;
2598 for (alias = node->same_body; alias; alias = alias->next)
2599 TREE_READONLY (alias->decl) = readonly;
2602 /* Set DECL_PURE_P on NODE's decl and on same_body aliases of NODE
2606 cgraph_set_pure_flag (struct cgraph_node *node, bool pure)
2608 struct cgraph_node *alias;
2609 DECL_PURE_P (node->decl) = pure;
2610 for (alias = node->same_body; alias; alias = alias->next)
2611 DECL_PURE_P (alias->decl) = pure;
2614 /* Set DECL_LOOPING_CONST_OR_PURE_P on NODE's decl and on
2615 same_body aliases of NODE if any to LOOPING_CONST_OR_PURE. */
2618 cgraph_set_looping_const_or_pure_flag (struct cgraph_node *node,
2619 bool looping_const_or_pure)
2621 struct cgraph_node *alias;
2622 DECL_LOOPING_CONST_OR_PURE_P (node->decl) = looping_const_or_pure;
2623 for (alias = node->same_body; alias; alias = alias->next)
2624 DECL_LOOPING_CONST_OR_PURE_P (alias->decl) = looping_const_or_pure;
2627 /* See if the frequency of NODE can be updated based on frequencies of its
2630 cgraph_propagate_frequency (struct cgraph_node *node)
2632 bool maybe_unlikely_executed = true, maybe_executed_once = true;
2633 bool only_called_at_startup = true;
2634 bool only_called_at_exit = true;
2635 bool changed = false;
2636 struct cgraph_edge *edge;
2638 if (!node->local.local)
2640 gcc_assert (node->analyzed);
2641 if (dump_file && (dump_flags & TDF_DETAILS))
2642 fprintf (dump_file, "Processing frequency %s\n", cgraph_node_name (node));
2644 for (edge = node->callers;
2645 edge && (maybe_unlikely_executed || maybe_executed_once
2646 || only_called_at_startup || only_called_at_exit);
2647 edge = edge->next_caller)
2649 if (edge->caller != node)
2651 only_called_at_startup &= edge->caller->only_called_at_startup;
2652 /* It makes snese to put main() together with the static constructors.
2653 It will be executed for sure, but rest of functions called from
2654 main are definitly not at startup only. */
2655 if (MAIN_NAME_P (DECL_NAME (edge->caller->decl)))
2656 only_called_at_startup = 0;
2657 only_called_at_exit &= edge->caller->only_called_at_exit;
2659 if (!edge->frequency)
2661 switch (edge->caller->frequency)
2663 case NODE_FREQUENCY_UNLIKELY_EXECUTED:
2665 case NODE_FREQUENCY_EXECUTED_ONCE:
2666 if (dump_file && (dump_flags & TDF_DETAILS))
2667 fprintf (dump_file, " Called by %s that is executed once\n",
2668 cgraph_node_name (node));
2669 maybe_unlikely_executed = false;
2670 if (edge->loop_nest)
2672 maybe_executed_once = false;
2673 if (dump_file && (dump_flags & TDF_DETAILS))
2674 fprintf (dump_file, " Called in loop\n");
2677 case NODE_FREQUENCY_HOT:
2678 case NODE_FREQUENCY_NORMAL:
2679 if (dump_file && (dump_flags & TDF_DETAILS))
2680 fprintf (dump_file, " Called by %s that is normal or hot\n",
2681 cgraph_node_name (node));
2682 maybe_unlikely_executed = false;
2683 maybe_executed_once = false;
2687 if ((only_called_at_startup && !only_called_at_exit)
2688 && !node->only_called_at_startup)
2690 node->only_called_at_startup = true;
2692 fprintf (dump_file, "Node %s promoted to only called at startup.\n",
2693 cgraph_node_name (node));
2696 if ((only_called_at_exit && !only_called_at_startup)
2697 && !node->only_called_at_exit)
2699 node->only_called_at_exit = true;
2701 fprintf (dump_file, "Node %s promoted to only called at exit.\n",
2702 cgraph_node_name (node));
2705 /* These come either from profile or user hints; never update them. */
2706 if (node->frequency == NODE_FREQUENCY_HOT
2707 || node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED)
2709 if (maybe_unlikely_executed)
2711 node->frequency = NODE_FREQUENCY_UNLIKELY_EXECUTED;
2713 fprintf (dump_file, "Node %s promoted to unlikely executed.\n",
2714 cgraph_node_name (node));
2717 if (maybe_executed_once && node->frequency != NODE_FREQUENCY_EXECUTED_ONCE)
2719 node->frequency = NODE_FREQUENCY_EXECUTED_ONCE;
2721 fprintf (dump_file, "Node %s promoted to executed once.\n",
2722 cgraph_node_name (node));
2728 /* Return true when NODE can not return or throw and thus
2729 it is safe to ignore its side effects for IPA analysis. */
2732 cgraph_node_cannot_return (struct cgraph_node *node)
2734 int flags = flags_from_decl_or_type (node->decl);
2735 if (!flag_exceptions)
2736 return (flags & ECF_NORETURN) != 0;
2738 return ((flags & (ECF_NORETURN | ECF_NOTHROW))
2739 == (ECF_NORETURN | ECF_NOTHROW));
2742 /* Return true when call of E can not lead to return from caller
2743 and thus it is safe to ignore its side effects for IPA analysis
2744 when computing side effects of the caller.
2745 FIXME: We could actually mark all edges that have no reaching
2746 patch to EXIT_BLOCK_PTR or throw to get better results. */
2748 cgraph_edge_cannot_lead_to_return (struct cgraph_edge *e)
2750 if (cgraph_node_cannot_return (e->caller))
2752 if (e->indirect_unknown_callee)
2754 int flags = e->indirect_info->ecf_flags;
2755 if (!flag_exceptions)
2756 return (flags & ECF_NORETURN) != 0;
2758 return ((flags & (ECF_NORETURN | ECF_NOTHROW))
2759 == (ECF_NORETURN | ECF_NOTHROW));
2762 return cgraph_node_cannot_return (e->callee);
2765 /* Return true when function NODE can be removed from callgraph
2766 if all direct calls are eliminated. */
2769 cgraph_can_remove_if_no_direct_calls_and_refs_p (struct cgraph_node *node)
2771 /* When function is needed, we can not remove it. */
2772 if (node->needed || node->reachable_from_other_partition)
2774 /* Only COMDAT functions can be removed if externally visible. */
2775 if (node->local.externally_visible
2776 && (!DECL_COMDAT (node->decl)
2777 || cgraph_used_from_object_file_p (node)))
2779 /* Constructors and destructors are executed by the runtime, however
2780 we can get rid of all pure constructors and destructors. */
2781 if (DECL_STATIC_CONSTRUCTOR (node->decl)
2782 || DECL_STATIC_DESTRUCTOR (node->decl))
2784 int flags = flags_from_decl_or_type (node->decl);
2786 || !(flags & (ECF_CONST | ECF_PURE))
2787 || (flags & ECF_LOOPING_CONST_OR_PURE))
2793 /* Return true when function NODE can be excpected to be removed
2794 from program when direct calls in this compilation unit are removed.
2796 As a special case COMDAT functions are
2797 cgraph_can_remove_if_no_direct_calls_p while the are not
2798 cgraph_only_called_directly_p (it is possible they are called from other
2801 This function behaves as cgraph_only_called_directly_p because eliminating
2802 all uses of COMDAT function does not make it neccesarily disappear from
2803 the program unless we are compiling whole program or we do LTO. In this
2804 case we know we win since dynamic linking will not really discard the
2805 linkonce section. */
2808 cgraph_will_be_removed_from_program_if_no_direct_calls (struct cgraph_node *node)
2810 if (cgraph_used_from_object_file_p (node))
2812 if (!in_lto_p && !flag_whole_program)
2813 return cgraph_only_called_directly_p (node);
2815 return cgraph_can_remove_if_no_direct_calls_p (node);
2818 /* Return true when RESOLUTION indicate that linker will use
2819 the symbol from non-LTo object files. */
2822 resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution resolution)
2824 return (resolution == LDPR_PREVAILING_DEF
2825 || resolution == LDPR_PREEMPTED_REG
2826 || resolution == LDPR_RESOLVED_EXEC
2827 || resolution == LDPR_RESOLVED_DYN);
2830 /* Return true when NODE is known to be used from other (non-LTO) object file.
2831 Known only when doing LTO via linker plugin. */
2834 cgraph_used_from_object_file_p (struct cgraph_node *node)
2836 struct cgraph_node *alias;
2838 if (!TREE_PUBLIC (node->decl))
2840 if (resolution_used_from_other_file_p (node->resolution))
2842 for (alias = node->same_body; alias; alias = alias->next)
2843 if (TREE_PUBLIC (alias->decl)
2844 && resolution_used_from_other_file_p (alias->resolution))
2849 #include "gt-cgraph.h"