1 /* Callgraph handling code.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
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 indirect calls or calls
38 from other compilation unit. Flag NEEDED is set for each node that may
39 be accessed in such an invisible way and it shall be considered an
40 entry point to the callgraph.
42 Interprocedural information:
44 Callgraph is place to store data needed for interprocedural optimization.
45 All data structures are divided into three components: local_info that
46 is produced while analyzing the function, global_info that is result
47 of global walking of the callgraph on the end of compilation and
48 rtl_info used by RTL backend to propagate data from already compiled
49 functions to their callers.
53 The function inlining information is decided in advance and maintained
54 in the callgraph as so called inline plan.
55 For each inlined call, the callee's node is cloned to represent the
56 new function copy produced by inliner.
57 Each inlined call gets a unique corresponding clone node of the callee
58 and the data structure is updated while inlining is performed, so
59 the clones are eliminated and their callee edges redirected to the
62 Each edge has "inline_failed" field. When the field is set to NULL,
63 the call will be inlined. When it is non-NULL it contains a reason
64 why inlining wasn't performed. */
68 #include "coretypes.h"
71 #include "tree-inline.h"
72 #include "langhooks.h"
79 #include "basic-block.h"
84 #include "tree-dump.h"
85 #include "tree-flow.h"
86 #include "value-prof.h"
88 static void cgraph_node_remove_callers (struct cgraph_node *node);
89 static inline void cgraph_edge_remove_caller (struct cgraph_edge *e);
90 static inline void cgraph_edge_remove_callee (struct cgraph_edge *e);
92 /* Hash table used to convert declarations into nodes. */
93 static GTY((param_is (struct cgraph_node))) htab_t cgraph_hash;
94 /* Hash table used to convert assembler names into nodes. */
95 static GTY((param_is (struct cgraph_node))) htab_t assembler_name_hash;
97 /* The linked list of cgraph nodes. */
98 struct cgraph_node *cgraph_nodes;
100 /* Queue of cgraph nodes scheduled to be lowered. */
101 struct cgraph_node *cgraph_nodes_queue;
103 /* Queue of cgraph nodes scheduled to be added into cgraph. This is a
104 secondary queue used during optimization to accommodate passes that
105 may generate new functions that need to be optimized and expanded. */
106 struct cgraph_node *cgraph_new_nodes;
108 /* Number of nodes in existence. */
111 /* Maximal uid used in cgraph nodes. */
114 /* Maximal uid used in cgraph edges. */
115 int cgraph_edge_max_uid;
117 /* Maximal pid used for profiling */
120 /* Set when whole unit has been analyzed so we can access global info. */
121 bool cgraph_global_info_ready = false;
123 /* What state callgraph is in right now. */
124 enum cgraph_state cgraph_state = CGRAPH_STATE_CONSTRUCTION;
126 /* Set when the cgraph is fully build and the basic flags are computed. */
127 bool cgraph_function_flags_ready = false;
129 /* Linked list of cgraph asm nodes. */
130 struct cgraph_asm_node *cgraph_asm_nodes;
132 /* Last node in cgraph_asm_nodes. */
133 static GTY(()) struct cgraph_asm_node *cgraph_asm_last_node;
135 /* The order index of the next cgraph node to be created. This is
136 used so that we can sort the cgraph nodes in order by when we saw
137 them, to support -fno-toplevel-reorder. */
140 /* List of hooks trigerred on cgraph_edge events. */
141 struct cgraph_edge_hook_list {
142 cgraph_edge_hook hook;
144 struct cgraph_edge_hook_list *next;
147 /* List of hooks trigerred on cgraph_node events. */
148 struct cgraph_node_hook_list {
149 cgraph_node_hook hook;
151 struct cgraph_node_hook_list *next;
154 /* List of hooks trigerred on events involving two cgraph_edges. */
155 struct cgraph_2edge_hook_list {
156 cgraph_2edge_hook hook;
158 struct cgraph_2edge_hook_list *next;
161 /* List of hooks trigerred on events involving two cgraph_nodes. */
162 struct cgraph_2node_hook_list {
163 cgraph_2node_hook hook;
165 struct cgraph_2node_hook_list *next;
168 /* List of hooks triggered when an edge is removed. */
169 struct cgraph_edge_hook_list *first_cgraph_edge_removal_hook;
170 /* List of hooks triggered when a node is removed. */
171 struct cgraph_node_hook_list *first_cgraph_node_removal_hook;
172 /* List of hooks triggered when an edge is duplicated. */
173 struct cgraph_2edge_hook_list *first_cgraph_edge_duplicated_hook;
174 /* List of hooks triggered when a node is duplicated. */
175 struct cgraph_2node_hook_list *first_cgraph_node_duplicated_hook;
176 /* List of hooks triggered when an function is inserted. */
177 struct cgraph_node_hook_list *first_cgraph_function_insertion_hook;
179 /* Head of a linked list of unused (freed) call graph nodes.
180 Do not GTY((delete)) this list so UIDs gets reliably recycled. */
181 static GTY(()) struct cgraph_node *free_nodes;
182 /* Head of a linked list of unused (freed) call graph edges.
183 Do not GTY((delete)) this list so UIDs gets reliably recycled. */
184 static GTY(()) struct cgraph_edge *free_edges;
186 /* Macros to access the next item in the list of free cgraph nodes and
188 #define NEXT_FREE_NODE(NODE) (NODE)->next
189 #define NEXT_FREE_EDGE(EDGE) (EDGE)->prev_caller
191 /* Register HOOK to be called with DATA on each removed edge. */
192 struct cgraph_edge_hook_list *
193 cgraph_add_edge_removal_hook (cgraph_edge_hook hook, void *data)
195 struct cgraph_edge_hook_list *entry;
196 struct cgraph_edge_hook_list **ptr = &first_cgraph_edge_removal_hook;
198 entry = (struct cgraph_edge_hook_list *) xmalloc (sizeof (*entry));
208 /* Remove ENTRY from the list of hooks called on removing edges. */
210 cgraph_remove_edge_removal_hook (struct cgraph_edge_hook_list *entry)
212 struct cgraph_edge_hook_list **ptr = &first_cgraph_edge_removal_hook;
214 while (*ptr != entry)
220 /* Call all edge removal hooks. */
222 cgraph_call_edge_removal_hooks (struct cgraph_edge *e)
224 struct cgraph_edge_hook_list *entry = first_cgraph_edge_removal_hook;
227 entry->hook (e, entry->data);
232 /* Register HOOK to be called with DATA on each removed node. */
233 struct cgraph_node_hook_list *
234 cgraph_add_node_removal_hook (cgraph_node_hook hook, void *data)
236 struct cgraph_node_hook_list *entry;
237 struct cgraph_node_hook_list **ptr = &first_cgraph_node_removal_hook;
239 entry = (struct cgraph_node_hook_list *) xmalloc (sizeof (*entry));
249 /* Remove ENTRY from the list of hooks called on removing nodes. */
251 cgraph_remove_node_removal_hook (struct cgraph_node_hook_list *entry)
253 struct cgraph_node_hook_list **ptr = &first_cgraph_node_removal_hook;
255 while (*ptr != entry)
261 /* Call all node removal hooks. */
263 cgraph_call_node_removal_hooks (struct cgraph_node *node)
265 struct cgraph_node_hook_list *entry = first_cgraph_node_removal_hook;
268 entry->hook (node, entry->data);
273 /* Register HOOK to be called with DATA on each removed node. */
274 struct cgraph_node_hook_list *
275 cgraph_add_function_insertion_hook (cgraph_node_hook hook, void *data)
277 struct cgraph_node_hook_list *entry;
278 struct cgraph_node_hook_list **ptr = &first_cgraph_function_insertion_hook;
280 entry = (struct cgraph_node_hook_list *) xmalloc (sizeof (*entry));
290 /* Remove ENTRY from the list of hooks called on removing nodes. */
292 cgraph_remove_function_insertion_hook (struct cgraph_node_hook_list *entry)
294 struct cgraph_node_hook_list **ptr = &first_cgraph_function_insertion_hook;
296 while (*ptr != entry)
302 /* Call all node removal hooks. */
304 cgraph_call_function_insertion_hooks (struct cgraph_node *node)
306 struct cgraph_node_hook_list *entry = first_cgraph_function_insertion_hook;
309 entry->hook (node, entry->data);
314 /* Register HOOK to be called with DATA on each duplicated edge. */
315 struct cgraph_2edge_hook_list *
316 cgraph_add_edge_duplication_hook (cgraph_2edge_hook hook, void *data)
318 struct cgraph_2edge_hook_list *entry;
319 struct cgraph_2edge_hook_list **ptr = &first_cgraph_edge_duplicated_hook;
321 entry = (struct cgraph_2edge_hook_list *) xmalloc (sizeof (*entry));
331 /* Remove ENTRY from the list of hooks called on duplicating edges. */
333 cgraph_remove_edge_duplication_hook (struct cgraph_2edge_hook_list *entry)
335 struct cgraph_2edge_hook_list **ptr = &first_cgraph_edge_duplicated_hook;
337 while (*ptr != entry)
343 /* Call all edge duplication hooks. */
345 cgraph_call_edge_duplication_hooks (struct cgraph_edge *cs1,
346 struct cgraph_edge *cs2)
348 struct cgraph_2edge_hook_list *entry = first_cgraph_edge_duplicated_hook;
351 entry->hook (cs1, cs2, entry->data);
356 /* Register HOOK to be called with DATA on each duplicated node. */
357 struct cgraph_2node_hook_list *
358 cgraph_add_node_duplication_hook (cgraph_2node_hook hook, void *data)
360 struct cgraph_2node_hook_list *entry;
361 struct cgraph_2node_hook_list **ptr = &first_cgraph_node_duplicated_hook;
363 entry = (struct cgraph_2node_hook_list *) xmalloc (sizeof (*entry));
373 /* Remove ENTRY from the list of hooks called on duplicating nodes. */
375 cgraph_remove_node_duplication_hook (struct cgraph_2node_hook_list *entry)
377 struct cgraph_2node_hook_list **ptr = &first_cgraph_node_duplicated_hook;
379 while (*ptr != entry)
385 /* Call all node duplication hooks. */
387 cgraph_call_node_duplication_hooks (struct cgraph_node *node1,
388 struct cgraph_node *node2)
390 struct cgraph_2node_hook_list *entry = first_cgraph_node_duplicated_hook;
393 entry->hook (node1, node2, entry->data);
398 /* Returns a hash code for P. */
401 hash_node (const void *p)
403 const struct cgraph_node *n = (const struct cgraph_node *) p;
404 return (hashval_t) DECL_UID (n->decl);
407 /* Returns nonzero if P1 and P2 are equal. */
410 eq_node (const void *p1, const void *p2)
412 const struct cgraph_node *n1 = (const struct cgraph_node *) p1;
413 const struct cgraph_node *n2 = (const struct cgraph_node *) p2;
414 return DECL_UID (n1->decl) == DECL_UID (n2->decl);
417 /* Allocate new callgraph node and insert it into basic data structures. */
419 static struct cgraph_node *
420 cgraph_create_node (void)
422 struct cgraph_node *node;
427 free_nodes = NEXT_FREE_NODE (node);
431 node = GGC_CNEW (struct cgraph_node);
432 node->uid = cgraph_max_uid++;
435 node->next = cgraph_nodes;
437 node->order = cgraph_order++;
439 cgraph_nodes->previous = node;
440 node->previous = NULL;
441 node->global.estimated_growth = INT_MIN;
447 /* Return cgraph node assigned to DECL. Create new one when needed. */
450 cgraph_node (tree decl)
452 struct cgraph_node key, *node, **slot;
454 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
457 cgraph_hash = htab_create_ggc (10, hash_node, eq_node, NULL);
461 slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, &key, INSERT);
469 node = cgraph_create_node ();
472 if (DECL_CONTEXT (decl) && TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)
474 node->origin = cgraph_node (DECL_CONTEXT (decl));
475 node->next_nested = node->origin->nested;
476 node->origin->nested = node;
478 if (assembler_name_hash)
481 tree name = DECL_ASSEMBLER_NAME (decl);
483 aslot = htab_find_slot_with_hash (assembler_name_hash, name,
484 decl_assembler_name_hash (name),
486 /* We can have multiple declarations with same assembler name. For C++
487 it is __builtin_strlen and strlen, for instance. Do we need to
488 record them all? Original implementation marked just first one
489 so lets hope for the best. */
496 /* Returns the cgraph node assigned to DECL or NULL if no cgraph node
500 cgraph_get_node (tree decl)
502 struct cgraph_node key, *node = NULL, **slot;
504 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
507 cgraph_hash = htab_create_ggc (10, hash_node, eq_node, NULL);
511 slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, &key,
519 /* Insert already constructed node into hashtable. */
522 cgraph_insert_node_to_hashtable (struct cgraph_node *node)
524 struct cgraph_node **slot;
526 slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, node, INSERT);
532 /* Returns a hash code for P. */
535 hash_node_by_assembler_name (const void *p)
537 const struct cgraph_node *n = (const struct cgraph_node *) p;
538 return (hashval_t) decl_assembler_name_hash (DECL_ASSEMBLER_NAME (n->decl));
541 /* Returns nonzero if P1 and P2 are equal. */
544 eq_assembler_name (const void *p1, const void *p2)
546 const struct cgraph_node *n1 = (const struct cgraph_node *) p1;
547 const_tree name = (const_tree)p2;
548 return (decl_assembler_name_equal (n1->decl, name));
551 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
552 Return NULL if there's no such node. */
555 cgraph_node_for_asm (tree asmname)
557 struct cgraph_node *node;
560 if (!assembler_name_hash)
562 assembler_name_hash =
563 htab_create_ggc (10, hash_node_by_assembler_name, eq_assembler_name,
565 for (node = cgraph_nodes; node; node = node->next)
566 if (!node->global.inlined_to)
568 tree name = DECL_ASSEMBLER_NAME (node->decl);
569 slot = htab_find_slot_with_hash (assembler_name_hash, name,
570 decl_assembler_name_hash (name),
572 /* We can have multiple declarations with same assembler name. For C++
573 it is __builtin_strlen and strlen, for instance. Do we need to
574 record them all? Original implementation marked just first one
575 so lets hope for the best. */
582 slot = htab_find_slot_with_hash (assembler_name_hash, asmname,
583 decl_assembler_name_hash (asmname),
587 return (struct cgraph_node *) *slot;
591 /* Returns a hash value for X (which really is a die_struct). */
594 edge_hash (const void *x)
596 return htab_hash_pointer (((const struct cgraph_edge *) x)->call_stmt);
599 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
602 edge_eq (const void *x, const void *y)
604 return ((const struct cgraph_edge *) x)->call_stmt == y;
608 /* Return the callgraph edge representing the GIMPLE_CALL statement
612 cgraph_edge (struct cgraph_node *node, gimple call_stmt)
614 struct cgraph_edge *e, *e2;
617 if (node->call_site_hash)
618 return (struct cgraph_edge *)
619 htab_find_with_hash (node->call_site_hash, call_stmt,
620 htab_hash_pointer (call_stmt));
622 /* This loop may turn out to be performance problem. In such case adding
623 hashtables into call nodes with very many edges is probably best
624 solution. It is not good idea to add pointer into CALL_EXPR itself
625 because we want to make possible having multiple cgraph nodes representing
626 different clones of the same body before the body is actually cloned. */
627 for (e = node->callees; e; e= e->next_callee)
629 if (e->call_stmt == call_stmt)
636 node->call_site_hash = htab_create_ggc (120, edge_hash, edge_eq, NULL);
637 for (e2 = node->callees; e2; e2 = e2->next_callee)
640 slot = htab_find_slot_with_hash (node->call_site_hash,
642 htab_hash_pointer (e2->call_stmt),
653 /* Change field call_stmt of edge E to NEW_STMT. */
656 cgraph_set_call_stmt (struct cgraph_edge *e, gimple new_stmt)
658 if (e->caller->call_site_hash)
660 htab_remove_elt_with_hash (e->caller->call_site_hash,
662 htab_hash_pointer (e->call_stmt));
664 e->call_stmt = new_stmt;
665 push_cfun (DECL_STRUCT_FUNCTION (e->caller->decl));
666 e->can_throw_external = stmt_can_throw_external (new_stmt);
668 if (e->caller->call_site_hash)
671 slot = htab_find_slot_with_hash (e->caller->call_site_hash,
674 (e->call_stmt), INSERT);
680 /* Like cgraph_set_call_stmt but walk the clone tree and update all
681 clones sharing the same function body. */
684 cgraph_set_call_stmt_including_clones (struct cgraph_node *orig,
685 gimple old_stmt, gimple new_stmt)
687 struct cgraph_node *node;
688 struct cgraph_edge *edge = cgraph_edge (orig, old_stmt);
691 cgraph_set_call_stmt (edge, new_stmt);
697 struct cgraph_edge *edge = cgraph_edge (node, old_stmt);
699 cgraph_set_call_stmt (edge, new_stmt);
702 else if (node->next_sibling_clone)
703 node = node->next_sibling_clone;
706 while (node != orig && !node->next_sibling_clone)
707 node = node->clone_of;
709 node = node->next_sibling_clone;
714 /* Like cgraph_create_edge walk the clone tree and update all clones sharing
717 TODO: COUNT and LOOP_DEPTH should be properly distributed based on relative
718 frequencies of the clones. */
721 cgraph_create_edge_including_clones (struct cgraph_node *orig,
722 struct cgraph_node *callee,
723 gimple stmt, gcov_type count,
724 int freq, int loop_depth,
725 cgraph_inline_failed_t reason)
727 struct cgraph_node *node;
728 struct cgraph_edge *edge;
730 if (!cgraph_edge (orig, stmt))
732 edge = cgraph_create_edge (orig, callee, stmt, count, freq, loop_depth);
733 edge->inline_failed = reason;
740 /* It is possible that we already constant propagated into the clone
741 and turned indirect call into dirrect call. */
742 if (!cgraph_edge (node, stmt))
744 edge = cgraph_create_edge (node, callee, stmt, count,
746 edge->inline_failed = reason;
751 else if (node->next_sibling_clone)
752 node = node->next_sibling_clone;
755 while (node != orig && !node->next_sibling_clone)
756 node = node->clone_of;
758 node = node->next_sibling_clone;
763 /* Give initial reasons why inlining would fail on EDGE. This gets either
764 nullified or usually overwritten by more precise reasons later. */
767 initialize_inline_failed (struct cgraph_edge *e)
769 struct cgraph_node *callee = e->callee;
771 if (!callee->analyzed)
772 e->inline_failed = CIF_BODY_NOT_AVAILABLE;
773 else if (callee->local.redefined_extern_inline)
774 e->inline_failed = CIF_REDEFINED_EXTERN_INLINE;
775 else if (!callee->local.inlinable)
776 e->inline_failed = CIF_FUNCTION_NOT_INLINABLE;
777 else if (gimple_call_cannot_inline_p (e->call_stmt))
778 e->inline_failed = CIF_MISMATCHED_ARGUMENTS;
780 e->inline_failed = CIF_FUNCTION_NOT_CONSIDERED;
783 /* Create edge from CALLER to CALLEE in the cgraph. */
786 cgraph_create_edge (struct cgraph_node *caller, struct cgraph_node *callee,
787 gimple call_stmt, gcov_type count, int freq, int nest)
789 struct cgraph_edge *edge;
791 #ifdef ENABLE_CHECKING
792 /* This is rather pricely check possibly trigerring construction of call stmt
794 gcc_assert (!cgraph_edge (caller, call_stmt));
797 gcc_assert (is_gimple_call (call_stmt));
802 free_edges = NEXT_FREE_EDGE (edge);
806 edge = GGC_NEW (struct cgraph_edge);
807 edge->uid = cgraph_edge_max_uid++;
812 edge->caller = caller;
813 edge->callee = callee;
814 edge->call_stmt = call_stmt;
815 push_cfun (DECL_STRUCT_FUNCTION (caller->decl));
816 edge->can_throw_external = stmt_can_throw_external (call_stmt);
818 edge->prev_caller = NULL;
819 edge->next_caller = callee->callers;
821 callee->callers->prev_caller = edge;
822 edge->prev_callee = NULL;
823 edge->next_callee = caller->callees;
825 caller->callees->prev_callee = edge;
826 caller->callees = edge;
827 callee->callers = edge;
829 gcc_assert (count >= 0);
830 edge->frequency = freq;
831 gcc_assert (freq >= 0);
832 gcc_assert (freq <= CGRAPH_FREQ_MAX);
833 edge->loop_nest = nest;
834 edge->indirect_call = 0;
835 if (caller->call_site_hash)
838 slot = htab_find_slot_with_hash (caller->call_site_hash,
847 initialize_inline_failed (edge);
852 /* Remove the edge E from the list of the callers of the callee. */
855 cgraph_edge_remove_callee (struct cgraph_edge *e)
858 e->prev_caller->next_caller = e->next_caller;
860 e->next_caller->prev_caller = e->prev_caller;
862 e->callee->callers = e->next_caller;
865 /* Remove the edge E from the list of the callees of the caller. */
868 cgraph_edge_remove_caller (struct cgraph_edge *e)
871 e->prev_callee->next_callee = e->next_callee;
873 e->next_callee->prev_callee = e->prev_callee;
875 e->caller->callees = e->next_callee;
876 if (e->caller->call_site_hash)
877 htab_remove_elt_with_hash (e->caller->call_site_hash,
879 htab_hash_pointer (e->call_stmt));
882 /* Put the edge onto the free list. */
885 cgraph_free_edge (struct cgraph_edge *e)
889 /* Clear out the edge so we do not dangle pointers. */
890 memset (e, 0, sizeof (*e));
892 NEXT_FREE_EDGE (e) = free_edges;
896 /* Remove the edge E in the cgraph. */
899 cgraph_remove_edge (struct cgraph_edge *e)
901 /* Call all edge removal hooks. */
902 cgraph_call_edge_removal_hooks (e);
904 /* Remove from callers list of the callee. */
905 cgraph_edge_remove_callee (e);
907 /* Remove from callees list of the callers. */
908 cgraph_edge_remove_caller (e);
910 /* Put the edge onto the free list. */
911 cgraph_free_edge (e);
914 /* Redirect callee of E to N. The function does not update underlying
918 cgraph_redirect_edge_callee (struct cgraph_edge *e, struct cgraph_node *n)
920 /* Remove from callers list of the current callee. */
921 cgraph_edge_remove_callee (e);
923 /* Insert to callers list of the new callee. */
924 e->prev_caller = NULL;
926 n->callers->prev_caller = e;
927 e->next_caller = n->callers;
933 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
934 OLD_STMT changed into NEW_STMT. OLD_CALL is gimple_call_fndecl
935 of OLD_STMT if it was previously call statement. */
938 cgraph_update_edges_for_call_stmt_node (struct cgraph_node *node,
939 gimple old_stmt, tree old_call, gimple new_stmt)
941 tree new_call = (is_gimple_call (new_stmt)) ? gimple_call_fndecl (new_stmt) : 0;
943 /* We are seeing indirect calls, then there is nothing to update. */
944 if (!new_call && !old_call)
946 /* See if we turned indirect call into direct call or folded call to one builtin
947 into different bultin. */
948 if (old_call != new_call)
950 struct cgraph_edge *e = cgraph_edge (node, old_stmt);
951 struct cgraph_edge *ne = NULL;
958 /* See if the call is already there. It might be because of indirect
959 inlining already found it. */
960 if (new_call && e->callee->decl == new_call)
963 /* Otherwise remove edge and create new one; we can't simply redirect
964 since function has changed, so inline plan and other information
965 attached to edge is invalid. */
966 cgraph_remove_edge (e);
968 frequency = e->frequency;
969 loop_nest = e->loop_nest;
973 /* We are seeing new direct call; compute profile info based on BB. */
974 basic_block bb = gimple_bb (new_stmt);
976 frequency = compute_call_stmt_bb_frequency (current_function_decl,
978 loop_nest = bb->loop_depth;
983 ne = cgraph_create_edge (node, cgraph_node (new_call),
984 new_stmt, count, frequency,
986 gcc_assert (ne->inline_failed);
989 /* We only updated the call stmt; update pointer in cgraph edge.. */
990 else if (old_stmt != new_stmt)
991 cgraph_set_call_stmt (cgraph_edge (node, old_stmt), new_stmt);
994 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
995 OLD_STMT changed into NEW_STMT. OLD_DECL is gimple_call_fndecl
996 of OLD_STMT before it was updated (updating can happen inplace). */
999 cgraph_update_edges_for_call_stmt (gimple old_stmt, tree old_decl, gimple new_stmt)
1001 struct cgraph_node *orig = cgraph_node (cfun->decl);
1002 struct cgraph_node *node;
1004 cgraph_update_edges_for_call_stmt_node (orig, old_stmt, old_decl, new_stmt);
1006 for (node = orig->clones; node != orig;)
1008 cgraph_update_edges_for_call_stmt_node (node, old_stmt, old_decl, new_stmt);
1010 node = node->clones;
1011 else if (node->next_sibling_clone)
1012 node = node->next_sibling_clone;
1015 while (node != orig && !node->next_sibling_clone)
1016 node = node->clone_of;
1018 node = node->next_sibling_clone;
1024 /* Remove all callees from the node. */
1027 cgraph_node_remove_callees (struct cgraph_node *node)
1029 struct cgraph_edge *e, *f;
1031 /* It is sufficient to remove the edges from the lists of callers of
1032 the callees. The callee list of the node can be zapped with one
1034 for (e = node->callees; e; e = f)
1037 cgraph_call_edge_removal_hooks (e);
1038 cgraph_edge_remove_callee (e);
1039 cgraph_free_edge (e);
1041 node->callees = NULL;
1042 if (node->call_site_hash)
1044 htab_delete (node->call_site_hash);
1045 node->call_site_hash = NULL;
1049 /* Remove all callers from the node. */
1052 cgraph_node_remove_callers (struct cgraph_node *node)
1054 struct cgraph_edge *e, *f;
1056 /* It is sufficient to remove the edges from the lists of callees of
1057 the callers. The caller list of the node can be zapped with one
1059 for (e = node->callers; e; e = f)
1062 cgraph_call_edge_removal_hooks (e);
1063 cgraph_edge_remove_caller (e);
1064 cgraph_free_edge (e);
1066 node->callers = NULL;
1069 /* Release memory used to represent body of function NODE. */
1072 cgraph_release_function_body (struct cgraph_node *node)
1074 if (DECL_STRUCT_FUNCTION (node->decl))
1076 tree old_decl = current_function_decl;
1077 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
1078 if (cfun->gimple_df)
1080 current_function_decl = node->decl;
1082 delete_tree_cfg_annotations ();
1084 current_function_decl = old_decl;
1088 gcc_assert (dom_computed[0] == DOM_NONE);
1089 gcc_assert (dom_computed[1] == DOM_NONE);
1092 if (cfun->value_histograms)
1094 gcc_assert (!current_loops);
1096 gimple_set_body (node->decl, NULL);
1097 VEC_free (ipa_opt_pass, heap,
1098 DECL_STRUCT_FUNCTION (node->decl)->ipa_transforms_to_apply);
1099 /* Struct function hangs a lot of data that would leak if we didn't
1100 removed all pointers to it. */
1101 ggc_free (DECL_STRUCT_FUNCTION (node->decl));
1102 DECL_STRUCT_FUNCTION (node->decl) = NULL;
1104 DECL_SAVED_TREE (node->decl) = NULL;
1105 /* If the node is abstract and needed, then do not clear DECL_INITIAL
1106 of its associated function function declaration because it's
1107 needed to emit debug info later. */
1108 if (!node->abstract_and_needed)
1109 DECL_INITIAL (node->decl) = error_mark_node;
1112 /* Remove the node from cgraph. */
1115 cgraph_remove_node (struct cgraph_node *node)
1118 bool kill_body = false;
1119 struct cgraph_node *n;
1120 int uid = node->uid;
1122 cgraph_call_node_removal_hooks (node);
1123 cgraph_node_remove_callers (node);
1124 cgraph_node_remove_callees (node);
1126 /* Incremental inlining access removed nodes stored in the postorder list.
1128 node->needed = node->reachable = false;
1129 for (n = node->nested; n; n = n->next_nested)
1131 node->nested = NULL;
1134 struct cgraph_node **node2 = &node->origin->nested;
1136 while (*node2 != node)
1137 node2 = &(*node2)->next_nested;
1138 *node2 = node->next_nested;
1141 node->previous->next = node->next;
1143 cgraph_nodes = node->next;
1145 node->next->previous = node->previous;
1147 node->previous = NULL;
1148 slot = htab_find_slot (cgraph_hash, node, NO_INSERT);
1151 struct cgraph_node *next_inline_clone;
1153 for (next_inline_clone = node->clones;
1154 next_inline_clone && next_inline_clone->decl != node->decl;
1155 next_inline_clone = next_inline_clone->next_sibling_clone)
1158 /* If there is inline clone of the node being removed, we need
1159 to put it into the position of removed node and reorganize all
1160 other clones to be based on it. */
1161 if (next_inline_clone)
1163 struct cgraph_node *n;
1164 struct cgraph_node *new_clones;
1166 *slot = next_inline_clone;
1168 /* Unlink inline clone from the list of clones of removed node. */
1169 if (next_inline_clone->next_sibling_clone)
1170 next_inline_clone->next_sibling_clone->prev_sibling_clone
1171 = next_inline_clone->prev_sibling_clone;
1172 if (next_inline_clone->prev_sibling_clone)
1174 next_inline_clone->prev_sibling_clone->next_sibling_clone
1175 = next_inline_clone->next_sibling_clone;
1178 node->clones = next_inline_clone->next_sibling_clone;
1180 new_clones = node->clones;
1181 node->clones = NULL;
1183 /* Copy clone info. */
1184 next_inline_clone->clone = node->clone;
1186 /* Now place it into clone tree at same level at NODE. */
1187 next_inline_clone->clone_of = node->clone_of;
1188 next_inline_clone->prev_sibling_clone = NULL;
1189 next_inline_clone->next_sibling_clone = NULL;
1192 next_inline_clone->next_sibling_clone = node->clone_of->clones;
1193 node->clone_of->clones = next_inline_clone;
1196 /* Merge the clone list. */
1199 if (!next_inline_clone->clones)
1200 next_inline_clone->clones = new_clones;
1203 n = next_inline_clone->clones;
1204 while (n->next_sibling_clone)
1205 n = n->next_sibling_clone;
1206 n->next_sibling_clone = new_clones;
1207 new_clones->prev_sibling_clone = n;
1211 /* Update clone_of pointers. */
1215 n->clone_of = next_inline_clone;
1216 n = n->next_sibling_clone;
1221 htab_clear_slot (cgraph_hash, slot);
1227 gcc_assert (node->clone_of);
1228 if (node->prev_sibling_clone)
1229 node->prev_sibling_clone->next_sibling_clone = node->next_sibling_clone;
1230 else if (node->clone_of)
1231 node->clone_of->clones = node->next_sibling_clone;
1232 if (node->next_sibling_clone)
1233 node->next_sibling_clone->prev_sibling_clone = node->prev_sibling_clone;
1236 struct cgraph_node *n;
1238 for (n = node->clones; n->next_sibling_clone; n = n->next_sibling_clone)
1239 n->clone_of = node->clone_of;
1240 n->clone_of = node->clone_of;
1241 n->next_sibling_clone = node->clone_of->clones;
1242 if (node->clone_of->clones)
1243 node->clone_of->clones->prev_sibling_clone = n;
1244 node->clone_of->clones = node->clones;
1247 /* While all the clones are removed after being proceeded, the function
1248 itself is kept in the cgraph even after it is compiled. Check whether
1249 we are done with this body and reclaim it proactively if this is the case.
1251 if (!kill_body && *slot)
1253 struct cgraph_node *n = (struct cgraph_node *) *slot;
1254 if (!n->clones && !n->clone_of && !n->global.inlined_to
1255 && (cgraph_global_info_ready
1256 && (TREE_ASM_WRITTEN (n->decl) || DECL_EXTERNAL (n->decl))))
1259 if (assembler_name_hash)
1261 tree name = DECL_ASSEMBLER_NAME (node->decl);
1262 slot = htab_find_slot_with_hash (assembler_name_hash, name,
1263 decl_assembler_name_hash (name),
1265 /* Inline clones are not hashed. */
1266 if (slot && *slot == node)
1267 htab_clear_slot (assembler_name_hash, slot);
1271 cgraph_release_function_body (node);
1273 if (node->call_site_hash)
1275 htab_delete (node->call_site_hash);
1276 node->call_site_hash = NULL;
1280 /* Clear out the node to NULL all pointers and add the node to the free
1282 memset (node, 0, sizeof(*node));
1284 NEXT_FREE_NODE (node) = free_nodes;
1288 /* Remove the node from cgraph. */
1291 cgraph_remove_node_and_inline_clones (struct cgraph_node *node)
1293 struct cgraph_edge *e, *next;
1294 for (e = node->callees; e; e = next)
1296 next = e->next_callee;
1297 if (!e->inline_failed)
1298 cgraph_remove_node_and_inline_clones (e->callee);
1300 cgraph_remove_node (node);
1303 /* Notify finalize_compilation_unit that given node is reachable. */
1306 cgraph_mark_reachable_node (struct cgraph_node *node)
1308 if (!node->reachable && node->local.finalized)
1310 notice_global_symbol (node->decl);
1311 node->reachable = 1;
1312 gcc_assert (!cgraph_global_info_ready);
1314 node->next_needed = cgraph_nodes_queue;
1315 cgraph_nodes_queue = node;
1319 /* Likewise indicate that a node is needed, i.e. reachable via some
1323 cgraph_mark_needed_node (struct cgraph_node *node)
1326 cgraph_mark_reachable_node (node);
1329 /* Likewise indicate that a node is having address taken. */
1332 cgraph_mark_address_taken_node (struct cgraph_node *node)
1334 node->address_taken = 1;
1335 cgraph_mark_needed_node (node);
1338 /* Return local info for the compiled function. */
1340 struct cgraph_local_info *
1341 cgraph_local_info (tree decl)
1343 struct cgraph_node *node;
1345 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
1346 node = cgraph_node (decl);
1347 return &node->local;
1350 /* Return local info for the compiled function. */
1352 struct cgraph_global_info *
1353 cgraph_global_info (tree decl)
1355 struct cgraph_node *node;
1357 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL && cgraph_global_info_ready);
1358 node = cgraph_node (decl);
1359 return &node->global;
1362 /* Return local info for the compiled function. */
1364 struct cgraph_rtl_info *
1365 cgraph_rtl_info (tree decl)
1367 struct cgraph_node *node;
1369 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
1370 node = cgraph_node (decl);
1371 if (decl != current_function_decl
1372 && !TREE_ASM_WRITTEN (node->decl))
1377 /* Return a string describing the failure REASON. */
1380 cgraph_inline_failed_string (cgraph_inline_failed_t reason)
1383 #define DEFCIFCODE(code, string) string,
1385 static const char *cif_string_table[CIF_N_REASONS] = {
1386 #include "cif-code.def"
1389 /* Signedness of an enum type is implementation defined, so cast it
1390 to unsigned before testing. */
1391 gcc_assert ((unsigned) reason < CIF_N_REASONS);
1392 return cif_string_table[reason];
1395 /* Return name of the node used in debug output. */
1397 cgraph_node_name (struct cgraph_node *node)
1399 return lang_hooks.decl_printable_name (node->decl, 2);
1402 /* Names used to print out the availability enum. */
1403 const char * const cgraph_availability_names[] =
1404 {"unset", "not_available", "overwritable", "available", "local"};
1407 /* Dump call graph node NODE to file F. */
1410 dump_cgraph_node (FILE *f, struct cgraph_node *node)
1412 struct cgraph_edge *edge;
1413 fprintf (f, "%s/%i(%i)", cgraph_node_name (node), node->uid,
1415 dump_addr (f, " @", (void *)node);
1416 if (node->global.inlined_to)
1417 fprintf (f, " (inline copy in %s/%i)",
1418 cgraph_node_name (node->global.inlined_to),
1419 node->global.inlined_to->uid);
1421 fprintf (f, " (clone of %s/%i)",
1422 cgraph_node_name (node->clone_of),
1423 node->clone_of->uid);
1424 if (cgraph_function_flags_ready)
1425 fprintf (f, " availability:%s",
1426 cgraph_availability_names [cgraph_function_body_availability (node)]);
1428 fprintf (f, " executed "HOST_WIDEST_INT_PRINT_DEC"x",
1429 (HOST_WIDEST_INT)node->count);
1430 if (node->local.inline_summary.self_time)
1431 fprintf (f, " %i time, %i benefit", node->local.inline_summary.self_time,
1432 node->local.inline_summary.time_inlining_benefit);
1433 if (node->global.time && node->global.time
1434 != node->local.inline_summary.self_time)
1435 fprintf (f, " (%i after inlining)", node->global.time);
1436 if (node->local.inline_summary.self_size)
1437 fprintf (f, " %i size, %i benefit", node->local.inline_summary.self_size,
1438 node->local.inline_summary.size_inlining_benefit);
1439 if (node->global.size && node->global.size
1440 != node->local.inline_summary.self_size)
1441 fprintf (f, " (%i after inlining)", node->global.size);
1442 if (node->local.inline_summary.estimated_self_stack_size)
1443 fprintf (f, " %i bytes stack usage", (int)node->local.inline_summary.estimated_self_stack_size);
1444 if (node->global.estimated_stack_size != node->local.inline_summary.estimated_self_stack_size)
1445 fprintf (f, " %i bytes after inlining", (int)node->global.estimated_stack_size);
1447 fprintf (f, " nested in: %s", cgraph_node_name (node->origin));
1449 fprintf (f, " needed");
1450 if (node->address_taken)
1451 fprintf (f, " address_taken");
1452 else if (node->reachable)
1453 fprintf (f, " reachable");
1454 if (gimple_has_body_p (node->decl))
1455 fprintf (f, " body");
1457 fprintf (f, " process");
1458 if (node->local.local)
1459 fprintf (f, " local");
1460 if (node->local.externally_visible)
1461 fprintf (f, " externally_visible");
1462 if (node->local.finalized)
1463 fprintf (f, " finalized");
1464 if (node->local.disregard_inline_limits)
1465 fprintf (f, " always_inline");
1466 else if (node->local.inlinable)
1467 fprintf (f, " inlinable");
1468 if (node->local.redefined_extern_inline)
1469 fprintf (f, " redefined_extern_inline");
1470 if (TREE_ASM_WRITTEN (node->decl))
1471 fprintf (f, " asm_written");
1473 fprintf (f, "\n called by: ");
1474 for (edge = node->callers; edge; edge = edge->next_caller)
1476 fprintf (f, "%s/%i ", cgraph_node_name (edge->caller),
1479 fprintf (f, "("HOST_WIDEST_INT_PRINT_DEC"x) ",
1480 (HOST_WIDEST_INT)edge->count);
1481 if (edge->frequency)
1482 fprintf (f, "(%.2f per call) ",
1483 edge->frequency / (double)CGRAPH_FREQ_BASE);
1484 if (!edge->inline_failed)
1485 fprintf(f, "(inlined) ");
1486 if (edge->indirect_call)
1487 fprintf(f, "(indirect) ");
1488 if (edge->can_throw_external)
1489 fprintf(f, "(can throw external) ");
1492 fprintf (f, "\n calls: ");
1493 for (edge = node->callees; edge; edge = edge->next_callee)
1495 fprintf (f, "%s/%i ", cgraph_node_name (edge->callee),
1497 if (!edge->inline_failed)
1498 fprintf(f, "(inlined) ");
1499 if (edge->indirect_call)
1500 fprintf(f, "(indirect) ");
1502 fprintf (f, "("HOST_WIDEST_INT_PRINT_DEC"x) ",
1503 (HOST_WIDEST_INT)edge->count);
1504 if (edge->frequency)
1505 fprintf (f, "(%.2f per call) ",
1506 edge->frequency / (double)CGRAPH_FREQ_BASE);
1507 if (edge->loop_nest)
1508 fprintf (f, "(nested in %i loops) ", edge->loop_nest);
1509 if (edge->can_throw_external)
1510 fprintf(f, "(can throw external) ");
1516 /* Dump call graph node NODE to stderr. */
1519 debug_cgraph_node (struct cgraph_node *node)
1521 dump_cgraph_node (stderr, node);
1525 /* Dump the callgraph to file F. */
1528 dump_cgraph (FILE *f)
1530 struct cgraph_node *node;
1532 fprintf (f, "callgraph:\n\n");
1533 for (node = cgraph_nodes; node; node = node->next)
1534 dump_cgraph_node (f, node);
1538 /* Dump the call graph to stderr. */
1543 dump_cgraph (stderr);
1547 /* Set the DECL_ASSEMBLER_NAME and update cgraph hashtables. */
1550 change_decl_assembler_name (tree decl, tree name)
1552 gcc_assert (!assembler_name_hash);
1553 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
1555 SET_DECL_ASSEMBLER_NAME (decl, name);
1558 if (name == DECL_ASSEMBLER_NAME (decl))
1561 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
1562 && DECL_RTL_SET_P (decl))
1563 warning (0, "%D renamed after being referenced in assembly", decl);
1565 SET_DECL_ASSEMBLER_NAME (decl, name);
1568 /* Add a top-level asm statement to the list. */
1570 struct cgraph_asm_node *
1571 cgraph_add_asm_node (tree asm_str)
1573 struct cgraph_asm_node *node;
1575 node = GGC_CNEW (struct cgraph_asm_node);
1576 node->asm_str = asm_str;
1577 node->order = cgraph_order++;
1579 if (cgraph_asm_nodes == NULL)
1580 cgraph_asm_nodes = node;
1582 cgraph_asm_last_node->next = node;
1583 cgraph_asm_last_node = node;
1587 /* Return true when the DECL can possibly be inlined. */
1589 cgraph_function_possibly_inlined_p (tree decl)
1591 if (!cgraph_global_info_ready)
1592 return !DECL_UNINLINABLE (decl);
1593 return DECL_POSSIBLY_INLINED (decl);
1596 /* Create clone of E in the node N represented by CALL_EXPR the callgraph. */
1597 struct cgraph_edge *
1598 cgraph_clone_edge (struct cgraph_edge *e, struct cgraph_node *n,
1599 gimple call_stmt, gcov_type count_scale, int freq_scale,
1600 int loop_nest, bool update_original)
1602 struct cgraph_edge *new_edge;
1603 gcov_type count = e->count * count_scale / REG_BR_PROB_BASE;
1604 gcov_type freq = e->frequency * (gcov_type) freq_scale / CGRAPH_FREQ_BASE;
1606 if (freq > CGRAPH_FREQ_MAX)
1607 freq = CGRAPH_FREQ_MAX;
1608 new_edge = cgraph_create_edge (n, e->callee, call_stmt, count, freq,
1609 e->loop_nest + loop_nest);
1611 new_edge->inline_failed = e->inline_failed;
1612 new_edge->indirect_call = e->indirect_call;
1613 if (update_original)
1615 e->count -= new_edge->count;
1619 cgraph_call_edge_duplication_hooks (e, new_edge);
1623 /* Create node representing clone of N executed COUNT times. Decrease
1624 the execution counts from original node too.
1626 When UPDATE_ORIGINAL is true, the counts are subtracted from the original
1627 function's profile to reflect the fact that part of execution is handled
1629 struct cgraph_node *
1630 cgraph_clone_node (struct cgraph_node *n, gcov_type count, int freq,
1631 int loop_nest, bool update_original)
1633 struct cgraph_node *new_node = cgraph_create_node ();
1634 struct cgraph_edge *e;
1635 gcov_type count_scale;
1637 new_node->decl = n->decl;
1638 new_node->origin = n->origin;
1639 if (new_node->origin)
1641 new_node->next_nested = new_node->origin->nested;
1642 new_node->origin->nested = new_node;
1644 new_node->analyzed = n->analyzed;
1645 new_node->local = n->local;
1646 new_node->global = n->global;
1647 new_node->rtl = n->rtl;
1648 new_node->count = count;
1649 new_node->clone = n->clone;
1652 if (new_node->count > n->count)
1653 count_scale = REG_BR_PROB_BASE;
1655 count_scale = new_node->count * REG_BR_PROB_BASE / n->count;
1659 if (update_original)
1666 for (e = n->callees;e; e=e->next_callee)
1667 cgraph_clone_edge (e, new_node, e->call_stmt, count_scale, freq, loop_nest,
1670 new_node->next_sibling_clone = n->clones;
1672 n->clones->prev_sibling_clone = new_node;
1673 n->clones = new_node;
1674 new_node->clone_of = n;
1676 cgraph_call_node_duplication_hooks (n, new_node);
1680 /* Create a new name for omp child function. Returns an identifier. */
1682 static GTY(()) unsigned int clone_fn_id_num;
1685 clone_function_name (tree decl)
1687 tree name = DECL_ASSEMBLER_NAME (decl);
1688 size_t len = IDENTIFIER_LENGTH (name);
1689 char *tmp_name, *prefix;
1691 prefix = XALLOCAVEC (char, len + strlen ("_clone") + 1);
1692 memcpy (prefix, IDENTIFIER_POINTER (name), len);
1693 strcpy (prefix + len, "_clone");
1694 #ifndef NO_DOT_IN_LABEL
1696 #elif !defined NO_DOLLAR_IN_LABEL
1699 ASM_FORMAT_PRIVATE_NAME (tmp_name, prefix, clone_fn_id_num++);
1700 return get_identifier (tmp_name);
1703 /* Create callgraph node clone with new declaration. The actual body will
1704 be copied later at compilation stage.
1706 TODO: after merging in ipa-sra use function call notes instead of args_to_skip
1709 struct cgraph_node *
1710 cgraph_create_virtual_clone (struct cgraph_node *old_node,
1711 VEC(cgraph_edge_p,heap) *redirect_callers,
1712 VEC(ipa_replace_map_p,gc) *tree_map,
1713 bitmap args_to_skip)
1715 tree old_decl = old_node->decl;
1716 struct cgraph_node *new_node = NULL;
1718 struct cgraph_node key, **slot;
1720 struct cgraph_edge *e;
1722 gcc_assert (tree_versionable_function_p (old_decl));
1724 /* Make a new FUNCTION_DECL tree node */
1726 new_decl = copy_node (old_decl);
1728 new_decl = build_function_decl_skip_args (old_decl, args_to_skip);
1729 DECL_STRUCT_FUNCTION (new_decl) = NULL;
1731 /* Generate a new name for the new version. */
1732 DECL_NAME (new_decl) = clone_function_name (old_decl);
1733 SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
1734 SET_DECL_RTL (new_decl, NULL);
1736 new_node = cgraph_clone_node (old_node, old_node->count,
1737 CGRAPH_FREQ_BASE, 0, false);
1738 new_node->decl = new_decl;
1739 /* Update the properties.
1740 Make clone visible only within this translation unit. Make sure
1741 that is not weak also.
1742 ??? We cannot use COMDAT linkage because there is no
1743 ABI support for this. */
1744 DECL_EXTERNAL (new_node->decl) = 0;
1745 DECL_COMDAT_GROUP (new_node->decl) = 0;
1746 TREE_PUBLIC (new_node->decl) = 0;
1747 DECL_COMDAT (new_node->decl) = 0;
1748 DECL_WEAK (new_node->decl) = 0;
1749 new_node->clone.tree_map = tree_map;
1750 new_node->clone.args_to_skip = args_to_skip;
1752 new_node->clone.combined_args_to_skip = old_node->clone.combined_args_to_skip;
1753 else if (old_node->clone.combined_args_to_skip)
1755 int newi = 0, oldi = 0;
1757 bitmap new_args_to_skip = BITMAP_GGC_ALLOC ();
1758 struct cgraph_node *orig_node;
1759 for (orig_node = old_node; orig_node->clone_of; orig_node = orig_node->clone_of)
1761 for (arg = DECL_ARGUMENTS (orig_node->decl); arg; arg = TREE_CHAIN (arg), oldi++)
1763 if (bitmap_bit_p (old_node->clone.combined_args_to_skip, oldi))
1765 bitmap_set_bit (new_args_to_skip, oldi);
1768 if (bitmap_bit_p (args_to_skip, newi))
1769 bitmap_set_bit (new_args_to_skip, oldi);
1772 new_node->clone.combined_args_to_skip = new_args_to_skip;
1775 new_node->clone.combined_args_to_skip = args_to_skip;
1776 new_node->local.externally_visible = 0;
1777 new_node->local.local = 1;
1778 new_node->lowered = true;
1779 new_node->reachable = true;
1781 key.decl = new_decl;
1782 slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, &key, INSERT);
1783 gcc_assert (!*slot);
1785 if (assembler_name_hash)
1788 tree name = DECL_ASSEMBLER_NAME (new_decl);
1790 aslot = htab_find_slot_with_hash (assembler_name_hash, name,
1791 decl_assembler_name_hash (name),
1793 gcc_assert (!*aslot);
1796 for (i = 0; VEC_iterate (cgraph_edge_p, redirect_callers, i, e); i++)
1798 /* Redirect calls to the old version node to point to its new
1800 cgraph_redirect_edge_callee (e, new_node);
1806 /* NODE is no longer nested function; update cgraph accordingly. */
1808 cgraph_unnest_node (struct cgraph_node *node)
1810 struct cgraph_node **node2 = &node->origin->nested;
1811 gcc_assert (node->origin);
1813 while (*node2 != node)
1814 node2 = &(*node2)->next_nested;
1815 *node2 = node->next_nested;
1816 node->origin = NULL;
1819 /* Return function availability. See cgraph.h for description of individual
1822 cgraph_function_body_availability (struct cgraph_node *node)
1824 enum availability avail;
1825 gcc_assert (cgraph_function_flags_ready);
1826 if (!node->analyzed)
1827 avail = AVAIL_NOT_AVAILABLE;
1828 else if (node->local.local)
1829 avail = AVAIL_LOCAL;
1830 else if (!node->local.externally_visible)
1831 avail = AVAIL_AVAILABLE;
1832 /* Inline functions are safe to be analyzed even if their sybol can
1833 be overwritten at runtime. It is not meaningful to enfore any sane
1834 behaviour on replacing inline function by different body. */
1835 else if (DECL_DECLARED_INLINE_P (node->decl))
1836 avail = AVAIL_AVAILABLE;
1838 /* If the function can be overwritten, return OVERWRITABLE. Take
1839 care at least of two notable extensions - the COMDAT functions
1840 used to share template instantiations in C++ (this is symmetric
1841 to code cp_cannot_inline_tree_fn and probably shall be shared and
1842 the inlinability hooks completely eliminated).
1844 ??? Does the C++ one definition rule allow us to always return
1845 AVAIL_AVAILABLE here? That would be good reason to preserve this
1848 else if (DECL_REPLACEABLE_P (node->decl) && !DECL_EXTERNAL (node->decl))
1849 avail = AVAIL_OVERWRITABLE;
1850 else avail = AVAIL_AVAILABLE;
1855 /* Add the function FNDECL to the call graph.
1856 Unlike cgraph_finalize_function, this function is intended to be used
1857 by middle end and allows insertion of new function at arbitrary point
1858 of compilation. The function can be either in high, low or SSA form
1861 The function is assumed to be reachable and have address taken (so no
1862 API breaking optimizations are performed on it).
1864 Main work done by this function is to enqueue the function for later
1865 processing to avoid need the passes to be re-entrant. */
1868 cgraph_add_new_function (tree fndecl, bool lowered)
1870 struct cgraph_node *node;
1871 switch (cgraph_state)
1873 case CGRAPH_STATE_CONSTRUCTION:
1874 /* Just enqueue function to be processed at nearest occurrence. */
1875 node = cgraph_node (fndecl);
1876 node->next_needed = cgraph_new_nodes;
1878 node->lowered = true;
1879 cgraph_new_nodes = node;
1882 case CGRAPH_STATE_IPA:
1883 case CGRAPH_STATE_IPA_SSA:
1884 case CGRAPH_STATE_EXPANSION:
1885 /* Bring the function into finalized state and enqueue for later
1886 analyzing and compilation. */
1887 node = cgraph_node (fndecl);
1888 node->local.local = false;
1889 node->local.finalized = true;
1890 node->reachable = node->needed = true;
1891 if (!lowered && cgraph_state == CGRAPH_STATE_EXPANSION)
1893 push_cfun (DECL_STRUCT_FUNCTION (fndecl));
1894 current_function_decl = fndecl;
1895 gimple_register_cfg_hooks ();
1896 /* C++ Thunks are emitted late via this function, gimplify them. */
1897 if (!gimple_body (fndecl))
1898 gimplify_function_tree (fndecl);
1899 tree_lowering_passes (fndecl);
1900 bitmap_obstack_initialize (NULL);
1901 if (!gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl)))
1902 execute_pass_list (pass_early_local_passes.pass.sub);
1903 bitmap_obstack_release (NULL);
1905 current_function_decl = NULL;
1910 node->lowered = true;
1911 node->next_needed = cgraph_new_nodes;
1912 cgraph_new_nodes = node;
1915 case CGRAPH_STATE_FINISHED:
1916 /* At the very end of compilation we have to do all the work up
1918 push_cfun (DECL_STRUCT_FUNCTION (fndecl));
1919 current_function_decl = fndecl;
1920 gimple_register_cfg_hooks ();
1922 tree_lowering_passes (fndecl);
1923 bitmap_obstack_initialize (NULL);
1924 if (!gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl)))
1925 execute_pass_list (pass_early_local_passes.pass.sub);
1926 bitmap_obstack_release (NULL);
1927 tree_rest_of_compilation (fndecl);
1929 current_function_decl = NULL;
1934 /* Return true if NODE can be made local for API change.
1935 Extern inline functions and C++ COMDAT functions can be made local
1936 at the expense of possible code size growth if function is used in multiple
1937 compilation units. */
1939 cgraph_node_can_be_local_p (struct cgraph_node *node)
1941 return !node->needed;
1944 /* Bring NODE local. */
1946 cgraph_make_node_local (struct cgraph_node *node)
1948 gcc_assert (cgraph_node_can_be_local_p (node));
1949 if (DECL_COMDAT (node->decl) || DECL_EXTERNAL (node->decl))
1951 DECL_COMDAT (node->decl) = 0;
1952 DECL_COMDAT_GROUP (node->decl) = 0;
1953 TREE_PUBLIC (node->decl) = 0;
1954 DECL_WEAK (node->decl) = 0;
1955 DECL_EXTERNAL (node->decl) = 0;
1956 node->local.externally_visible = false;
1957 node->local.local = true;
1958 gcc_assert (cgraph_function_body_availability (node) == AVAIL_LOCAL);
1962 #include "gt-cgraph.h"