1 /* Callgraph handling code.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
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"
85 #include "tree-dump.h"
86 #include "tree-flow.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;
180 /* Register HOOK to be called with DATA on each removed edge. */
181 struct cgraph_edge_hook_list *
182 cgraph_add_edge_removal_hook (cgraph_edge_hook hook, void *data)
184 struct cgraph_edge_hook_list *entry;
185 struct cgraph_edge_hook_list **ptr = &first_cgraph_edge_removal_hook;
187 entry = (struct cgraph_edge_hook_list *) xmalloc (sizeof (*entry));
197 /* Remove ENTRY from the list of hooks called on removing edges. */
199 cgraph_remove_edge_removal_hook (struct cgraph_edge_hook_list *entry)
201 struct cgraph_edge_hook_list **ptr = &first_cgraph_edge_removal_hook;
203 while (*ptr != entry)
208 /* Call all edge removal hooks. */
210 cgraph_call_edge_removal_hooks (struct cgraph_edge *e)
212 struct cgraph_edge_hook_list *entry = first_cgraph_edge_removal_hook;
215 entry->hook (e, entry->data);
220 /* Register HOOK to be called with DATA on each removed node. */
221 struct cgraph_node_hook_list *
222 cgraph_add_node_removal_hook (cgraph_node_hook hook, void *data)
224 struct cgraph_node_hook_list *entry;
225 struct cgraph_node_hook_list **ptr = &first_cgraph_node_removal_hook;
227 entry = (struct cgraph_node_hook_list *) xmalloc (sizeof (*entry));
237 /* Remove ENTRY from the list of hooks called on removing nodes. */
239 cgraph_remove_node_removal_hook (struct cgraph_node_hook_list *entry)
241 struct cgraph_node_hook_list **ptr = &first_cgraph_node_removal_hook;
243 while (*ptr != entry)
248 /* Call all node removal hooks. */
250 cgraph_call_node_removal_hooks (struct cgraph_node *node)
252 struct cgraph_node_hook_list *entry = first_cgraph_node_removal_hook;
255 entry->hook (node, entry->data);
260 /* Register HOOK to be called with DATA on each removed node. */
261 struct cgraph_node_hook_list *
262 cgraph_add_function_insertion_hook (cgraph_node_hook hook, void *data)
264 struct cgraph_node_hook_list *entry;
265 struct cgraph_node_hook_list **ptr = &first_cgraph_function_insertion_hook;
267 entry = (struct cgraph_node_hook_list *) xmalloc (sizeof (*entry));
277 /* Remove ENTRY from the list of hooks called on removing nodes. */
279 cgraph_remove_function_insertion_hook (struct cgraph_node_hook_list *entry)
281 struct cgraph_node_hook_list **ptr = &first_cgraph_function_insertion_hook;
283 while (*ptr != entry)
288 /* Call all node removal hooks. */
290 cgraph_call_function_insertion_hooks (struct cgraph_node *node)
292 struct cgraph_node_hook_list *entry = first_cgraph_function_insertion_hook;
295 entry->hook (node, entry->data);
300 /* Register HOOK to be called with DATA on each duplicated edge. */
301 struct cgraph_2edge_hook_list *
302 cgraph_add_edge_duplication_hook (cgraph_2edge_hook hook, void *data)
304 struct cgraph_2edge_hook_list *entry;
305 struct cgraph_2edge_hook_list **ptr = &first_cgraph_edge_duplicated_hook;
307 entry = (struct cgraph_2edge_hook_list *) xmalloc (sizeof (*entry));
317 /* Remove ENTRY from the list of hooks called on duplicating edges. */
319 cgraph_remove_edge_duplication_hook (struct cgraph_2edge_hook_list *entry)
321 struct cgraph_2edge_hook_list **ptr = &first_cgraph_edge_duplicated_hook;
323 while (*ptr != entry)
328 /* Call all edge duplication hooks. */
330 cgraph_call_edge_duplication_hooks (struct cgraph_edge *cs1,
331 struct cgraph_edge *cs2)
333 struct cgraph_2edge_hook_list *entry = first_cgraph_edge_duplicated_hook;
336 entry->hook (cs1, cs2, entry->data);
341 /* Register HOOK to be called with DATA on each duplicated node. */
342 struct cgraph_2node_hook_list *
343 cgraph_add_node_duplication_hook (cgraph_2node_hook hook, void *data)
345 struct cgraph_2node_hook_list *entry;
346 struct cgraph_2node_hook_list **ptr = &first_cgraph_node_duplicated_hook;
348 entry = (struct cgraph_2node_hook_list *) xmalloc (sizeof (*entry));
358 /* Remove ENTRY from the list of hooks called on duplicating nodes. */
360 cgraph_remove_node_duplication_hook (struct cgraph_2node_hook_list *entry)
362 struct cgraph_2node_hook_list **ptr = &first_cgraph_node_duplicated_hook;
364 while (*ptr != entry)
369 /* Call all node duplication hooks. */
371 cgraph_call_node_duplication_hooks (struct cgraph_node *node1,
372 struct cgraph_node *node2)
374 struct cgraph_2node_hook_list *entry = first_cgraph_node_duplicated_hook;
377 entry->hook (node1, node2, entry->data);
382 /* Returns a hash code for P. */
385 hash_node (const void *p)
387 const struct cgraph_node *n = (const struct cgraph_node *) p;
388 return (hashval_t) DECL_UID (n->decl);
391 /* Returns nonzero if P1 and P2 are equal. */
394 eq_node (const void *p1, const void *p2)
396 const struct cgraph_node *n1 = (const struct cgraph_node *) p1;
397 const struct cgraph_node *n2 = (const struct cgraph_node *) p2;
398 return DECL_UID (n1->decl) == DECL_UID (n2->decl);
401 /* Allocate new callgraph node and insert it into basic data structures. */
403 static struct cgraph_node *
404 cgraph_create_node (void)
406 struct cgraph_node *node;
408 node = GGC_CNEW (struct cgraph_node);
409 node->next = cgraph_nodes;
410 node->uid = cgraph_max_uid++;
412 node->order = cgraph_order++;
414 cgraph_nodes->previous = node;
415 node->previous = NULL;
416 node->global.estimated_growth = INT_MIN;
422 /* Return cgraph node assigned to DECL. Create new one when needed. */
425 cgraph_node (tree decl)
427 struct cgraph_node key, *node, **slot;
429 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
432 cgraph_hash = htab_create_ggc (10, hash_node, eq_node, NULL);
436 slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, &key, INSERT);
441 if (!node->master_clone)
442 node->master_clone = node;
446 node = cgraph_create_node ();
449 if (DECL_CONTEXT (decl) && TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)
451 node->origin = cgraph_node (DECL_CONTEXT (decl));
452 node->next_nested = node->origin->nested;
453 node->origin->nested = node;
454 node->master_clone = node;
460 /* Insert already constructed node into hashtable. */
463 cgraph_insert_node_to_hashtable (struct cgraph_node *node)
465 struct cgraph_node **slot;
467 slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, node, INSERT);
473 /* Returns a hash code for P. */
476 hash_node_by_assembler_name (const void *p)
478 const struct cgraph_node *n = (const struct cgraph_node *) p;
479 return (hashval_t) decl_assembler_name_hash (DECL_ASSEMBLER_NAME (n->decl));
482 /* Returns nonzero if P1 and P2 are equal. */
485 eq_assembler_name (const void *p1, const void *p2)
487 const struct cgraph_node *n1 = (const struct cgraph_node *) p1;
488 const_tree name = (const_tree)p2;
489 return (decl_assembler_name_equal (n1->decl, name));
492 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
493 Return NULL if there's no such node. */
496 cgraph_node_for_asm (tree asmname)
498 struct cgraph_node *node;
501 if (!assembler_name_hash)
503 assembler_name_hash =
504 htab_create_ggc (10, hash_node_by_assembler_name, eq_assembler_name,
506 for (node = cgraph_nodes; node; node = node->next)
507 if (!node->global.inlined_to)
509 tree name = DECL_ASSEMBLER_NAME (node->decl);
510 slot = htab_find_slot_with_hash (assembler_name_hash, name,
511 decl_assembler_name_hash (name),
513 /* We can have multiple declarations with same assembler name. For C++
514 it is __builtin_strlen and strlen, for instance. Do we need to
515 record them all? Original implementation marked just first one
516 so lets hope for the best. */
523 slot = htab_find_slot_with_hash (assembler_name_hash, asmname,
524 decl_assembler_name_hash (asmname),
528 return (struct cgraph_node *) *slot;
532 /* Returns a hash value for X (which really is a die_struct). */
535 edge_hash (const void *x)
537 return htab_hash_pointer (((const struct cgraph_edge *) x)->call_stmt);
540 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
543 edge_eq (const void *x, const void *y)
545 return ((const struct cgraph_edge *) x)->call_stmt == y;
549 /* Return the callgraph edge representing the GIMPLE_CALL statement
553 cgraph_edge (struct cgraph_node *node, gimple call_stmt)
555 struct cgraph_edge *e, *e2;
558 if (node->call_site_hash)
559 return (struct cgraph_edge *)
560 htab_find_with_hash (node->call_site_hash, call_stmt,
561 htab_hash_pointer (call_stmt));
563 /* This loop may turn out to be performance problem. In such case adding
564 hashtables into call nodes with very many edges is probably best
565 solution. It is not good idea to add pointer into CALL_EXPR itself
566 because we want to make possible having multiple cgraph nodes representing
567 different clones of the same body before the body is actually cloned. */
568 for (e = node->callees; e; e= e->next_callee)
570 if (e->call_stmt == call_stmt)
577 node->call_site_hash = htab_create_ggc (120, edge_hash, edge_eq, NULL);
578 for (e2 = node->callees; e2; e2 = e2->next_callee)
581 slot = htab_find_slot_with_hash (node->call_site_hash,
583 htab_hash_pointer (e2->call_stmt),
594 /* Change field call_smt of edge E to NEW_STMT. */
597 cgraph_set_call_stmt (struct cgraph_edge *e, gimple new_stmt)
599 if (e->caller->call_site_hash)
601 htab_remove_elt_with_hash (e->caller->call_site_hash,
603 htab_hash_pointer (e->call_stmt));
605 e->call_stmt = new_stmt;
606 if (e->caller->call_site_hash)
609 slot = htab_find_slot_with_hash (e->caller->call_site_hash,
612 (e->call_stmt), INSERT);
618 /* Create edge from CALLER to CALLEE in the cgraph. */
621 cgraph_create_edge (struct cgraph_node *caller, struct cgraph_node *callee,
622 gimple call_stmt, gcov_type count, int freq, int nest)
624 struct cgraph_edge *edge = GGC_NEW (struct cgraph_edge);
625 #ifdef ENABLE_CHECKING
626 struct cgraph_edge *e;
628 for (e = caller->callees; e; e = e->next_callee)
629 gcc_assert (e->call_stmt != call_stmt);
632 gcc_assert (is_gimple_call (call_stmt));
634 if (!gimple_body (callee->decl))
635 edge->inline_failed = N_("function body not available");
636 else if (callee->local.redefined_extern_inline)
637 edge->inline_failed = N_("redefined extern inline functions are not "
638 "considered for inlining");
639 else if (callee->local.inlinable)
640 edge->inline_failed = N_("function not considered for inlining");
642 edge->inline_failed = N_("function not inlinable");
646 edge->caller = caller;
647 edge->callee = callee;
648 edge->call_stmt = call_stmt;
649 edge->prev_caller = NULL;
650 edge->next_caller = callee->callers;
652 callee->callers->prev_caller = edge;
653 edge->prev_callee = NULL;
654 edge->next_callee = caller->callees;
656 caller->callees->prev_callee = edge;
657 caller->callees = edge;
658 callee->callers = edge;
660 gcc_assert (count >= 0);
661 edge->frequency = freq;
662 gcc_assert (freq >= 0);
663 gcc_assert (freq <= CGRAPH_FREQ_MAX);
664 edge->loop_nest = nest;
665 edge->indirect_call = 0;
666 edge->uid = cgraph_edge_max_uid++;
667 if (caller->call_site_hash)
670 slot = htab_find_slot_with_hash (caller->call_site_hash,
681 /* Remove the edge E from the list of the callers of the callee. */
684 cgraph_edge_remove_callee (struct cgraph_edge *e)
687 e->prev_caller->next_caller = e->next_caller;
689 e->next_caller->prev_caller = e->prev_caller;
691 e->callee->callers = e->next_caller;
694 /* Remove the edge E from the list of the callees of the caller. */
697 cgraph_edge_remove_caller (struct cgraph_edge *e)
700 e->prev_callee->next_callee = e->next_callee;
702 e->next_callee->prev_callee = e->prev_callee;
704 e->caller->callees = e->next_callee;
705 if (e->caller->call_site_hash)
706 htab_remove_elt_with_hash (e->caller->call_site_hash,
708 htab_hash_pointer (e->call_stmt));
711 /* Remove the edge E in the cgraph. */
714 cgraph_remove_edge (struct cgraph_edge *e)
716 cgraph_call_edge_removal_hooks (e);
717 /* Remove from callers list of the callee. */
718 cgraph_edge_remove_callee (e);
720 /* Remove from callees list of the callers. */
721 cgraph_edge_remove_caller (e);
724 /* Redirect callee of E to N. The function does not update underlying
728 cgraph_redirect_edge_callee (struct cgraph_edge *e, struct cgraph_node *n)
730 /* Remove from callers list of the current callee. */
731 cgraph_edge_remove_callee (e);
733 /* Insert to callers list of the new callee. */
734 e->prev_caller = NULL;
736 n->callers->prev_caller = e;
737 e->next_caller = n->callers;
743 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
744 OLD_STMT changed into NEW_STMT. */
747 cgraph_update_edges_for_call_stmt (gimple old_stmt, gimple new_stmt)
749 tree new_call = (is_gimple_call (new_stmt)) ? gimple_call_fn (new_stmt) : 0;
750 tree old_call = (is_gimple_call (old_stmt)) ? gimple_call_fn (old_stmt) : 0;
751 struct cgraph_node *node = cgraph_node (cfun->decl);
753 if (old_call != new_call)
755 struct cgraph_edge *e = cgraph_edge (node, old_stmt);
756 struct cgraph_edge *ne = NULL;
761 gcov_type count = e->count;
762 int frequency = e->frequency;
763 int loop_nest = e->loop_nest;
765 cgraph_remove_edge (e);
768 new_decl = gimple_call_fndecl (new_stmt);
771 ne = cgraph_create_edge (node, cgraph_node (new_decl),
772 new_stmt, count, frequency,
774 gcc_assert (ne->inline_failed);
779 else if (old_stmt != new_stmt)
781 struct cgraph_edge *e = cgraph_edge (node, old_stmt);
784 cgraph_set_call_stmt (e, new_stmt);
789 /* Remove all callees from the node. */
792 cgraph_node_remove_callees (struct cgraph_node *node)
794 struct cgraph_edge *e;
796 /* It is sufficient to remove the edges from the lists of callers of
797 the callees. The callee list of the node can be zapped with one
799 for (e = node->callees; e; e = e->next_callee)
801 cgraph_call_edge_removal_hooks (e);
802 cgraph_edge_remove_callee (e);
804 node->callees = NULL;
805 if (node->call_site_hash)
807 htab_delete (node->call_site_hash);
808 node->call_site_hash = NULL;
812 /* Remove all callers from the node. */
815 cgraph_node_remove_callers (struct cgraph_node *node)
817 struct cgraph_edge *e;
819 /* It is sufficient to remove the edges from the lists of callees of
820 the callers. The caller list of the node can be zapped with one
822 for (e = node->callers; e; e = e->next_caller)
824 cgraph_call_edge_removal_hooks (e);
825 cgraph_edge_remove_caller (e);
827 node->callers = NULL;
830 /* Release memory used to represent body of function NODE. */
833 cgraph_release_function_body (struct cgraph_node *node)
835 if (DECL_STRUCT_FUNCTION (node->decl)
836 && DECL_STRUCT_FUNCTION (node->decl)->gimple_df)
838 tree old_decl = current_function_decl;
839 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
840 current_function_decl = node->decl;
842 delete_tree_cfg_annotations ();
844 gimple_set_body (node->decl, NULL);
845 current_function_decl = old_decl;
848 DECL_SAVED_TREE (node->decl) = NULL;
849 DECL_STRUCT_FUNCTION (node->decl) = NULL;
850 DECL_INITIAL (node->decl) = error_mark_node;
853 /* Remove the node from cgraph. */
856 cgraph_remove_node (struct cgraph_node *node)
859 bool kill_body = false;
860 struct cgraph_node *n;
862 cgraph_call_node_removal_hooks (node);
863 cgraph_node_remove_callers (node);
864 cgraph_node_remove_callees (node);
866 /* Incremental inlining access removed nodes stored in the postorder list.
868 node->needed = node->reachable = false;
869 for (n = node->nested; n; n = n->next_nested)
874 struct cgraph_node **node2 = &node->origin->nested;
876 while (*node2 != node)
877 node2 = &(*node2)->next_nested;
878 *node2 = node->next_nested;
881 node->previous->next = node->next;
883 cgraph_nodes = node->next;
885 node->next->previous = node->previous;
887 node->previous = NULL;
888 slot = htab_find_slot (cgraph_hash, node, NO_INSERT);
891 if (node->next_clone)
893 struct cgraph_node *new_node = node->next_clone;
894 struct cgraph_node *n;
896 /* Make the next clone be the master clone */
897 for (n = new_node; n; n = n->next_clone)
898 n->master_clone = new_node;
901 node->next_clone->prev_clone = NULL;
905 htab_clear_slot (cgraph_hash, slot);
911 node->prev_clone->next_clone = node->next_clone;
912 if (node->next_clone)
913 node->next_clone->prev_clone = node->prev_clone;
916 /* While all the clones are removed after being proceeded, the function
917 itself is kept in the cgraph even after it is compiled. Check whether
918 we are done with this body and reclaim it proactively if this is the case.
920 if (!kill_body && *slot)
922 struct cgraph_node *n = (struct cgraph_node *) *slot;
923 if (!n->next_clone && !n->global.inlined_to
924 && (cgraph_global_info_ready
925 && (TREE_ASM_WRITTEN (n->decl) || DECL_EXTERNAL (n->decl))))
928 if (assembler_name_hash)
930 tree name = DECL_ASSEMBLER_NAME (node->decl);
931 slot = htab_find_slot_with_hash (assembler_name_hash, name,
932 decl_assembler_name_hash (name),
934 /* Inline clones are not hashed. */
935 if (slot && *slot == node)
936 htab_clear_slot (assembler_name_hash, slot);
940 cgraph_release_function_body (node);
942 if (node->call_site_hash)
944 htab_delete (node->call_site_hash);
945 node->call_site_hash = NULL;
948 /* Do not free the structure itself so the walk over chain can continue. */
951 /* Notify finalize_compilation_unit that given node is reachable. */
954 cgraph_mark_reachable_node (struct cgraph_node *node)
956 if (!node->reachable && node->local.finalized)
958 notice_global_symbol (node->decl);
960 gcc_assert (!cgraph_global_info_ready);
962 node->next_needed = cgraph_nodes_queue;
963 cgraph_nodes_queue = node;
967 /* Likewise indicate that a node is needed, i.e. reachable via some
971 cgraph_mark_needed_node (struct cgraph_node *node)
974 cgraph_mark_reachable_node (node);
977 /* Return local info for the compiled function. */
979 struct cgraph_local_info *
980 cgraph_local_info (tree decl)
982 struct cgraph_node *node;
984 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
985 node = cgraph_node (decl);
989 /* Return local info for the compiled function. */
991 struct cgraph_global_info *
992 cgraph_global_info (tree decl)
994 struct cgraph_node *node;
996 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL && cgraph_global_info_ready);
997 node = cgraph_node (decl);
998 return &node->global;
1001 /* Return local info for the compiled function. */
1003 struct cgraph_rtl_info *
1004 cgraph_rtl_info (tree decl)
1006 struct cgraph_node *node;
1008 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
1009 node = cgraph_node (decl);
1010 if (decl != current_function_decl
1011 && !TREE_ASM_WRITTEN (node->decl))
1016 /* Return name of the node used in debug output. */
1018 cgraph_node_name (struct cgraph_node *node)
1020 return lang_hooks.decl_printable_name (node->decl, 2);
1023 /* Names used to print out the availability enum. */
1024 const char * const cgraph_availability_names[] =
1025 {"unset", "not_available", "overwritable", "available", "local"};
1028 /* Dump call graph node NODE to file F. */
1031 dump_cgraph_node (FILE *f, struct cgraph_node *node)
1033 struct cgraph_edge *edge;
1034 fprintf (f, "%s/%i(%i):", cgraph_node_name (node), node->uid, node->pid);
1035 if (node->global.inlined_to)
1036 fprintf (f, " (inline copy in %s/%i)",
1037 cgraph_node_name (node->global.inlined_to),
1038 node->global.inlined_to->uid);
1039 if (cgraph_function_flags_ready)
1040 fprintf (f, " availability:%s",
1041 cgraph_availability_names [cgraph_function_body_availability (node)]);
1042 if (node->master_clone && node->master_clone->uid != node->uid)
1043 fprintf (f, "(%i)", node->master_clone->uid);
1045 fprintf (f, " executed "HOST_WIDEST_INT_PRINT_DEC"x",
1046 (HOST_WIDEST_INT)node->count);
1047 if (node->local.inline_summary.self_insns)
1048 fprintf (f, " %i insns", node->local.inline_summary.self_insns);
1049 if (node->global.insns && node->global.insns
1050 != node->local.inline_summary.self_insns)
1051 fprintf (f, " (%i after inlining)", node->global.insns);
1052 if (node->local.inline_summary.estimated_self_stack_size)
1053 fprintf (f, " %i bytes stack usage", (int)node->local.inline_summary.estimated_self_stack_size);
1054 if (node->global.estimated_stack_size != node->local.inline_summary.estimated_self_stack_size)
1055 fprintf (f, " %i bytes after inlining", (int)node->global.estimated_stack_size);
1057 fprintf (f, " nested in: %s", cgraph_node_name (node->origin));
1059 fprintf (f, " needed");
1060 else if (node->reachable)
1061 fprintf (f, " reachable");
1062 if (gimple_body (node->decl))
1063 fprintf (f, " body");
1065 fprintf (f, " output");
1066 if (node->local.local)
1067 fprintf (f, " local");
1068 if (node->local.externally_visible)
1069 fprintf (f, " externally_visible");
1070 if (node->local.finalized)
1071 fprintf (f, " finalized");
1072 if (node->local.disregard_inline_limits)
1073 fprintf (f, " always_inline");
1074 else if (node->local.inlinable)
1075 fprintf (f, " inlinable");
1076 if (node->local.redefined_extern_inline)
1077 fprintf (f, " redefined_extern_inline");
1078 if (TREE_ASM_WRITTEN (node->decl))
1079 fprintf (f, " asm_written");
1081 fprintf (f, "\n called by: ");
1082 for (edge = node->callers; edge; edge = edge->next_caller)
1084 fprintf (f, "%s/%i ", cgraph_node_name (edge->caller),
1087 fprintf (f, "("HOST_WIDEST_INT_PRINT_DEC"x) ",
1088 (HOST_WIDEST_INT)edge->count);
1089 if (edge->frequency)
1090 fprintf (f, "(%.2f per call) ",
1091 edge->frequency / (double)CGRAPH_FREQ_BASE);
1092 if (!edge->inline_failed)
1093 fprintf(f, "(inlined) ");
1094 if (edge->indirect_call)
1095 fprintf(f, "(indirect) ");
1098 fprintf (f, "\n calls: ");
1099 for (edge = node->callees; edge; edge = edge->next_callee)
1101 fprintf (f, "%s/%i ", cgraph_node_name (edge->callee),
1103 if (!edge->inline_failed)
1104 fprintf(f, "(inlined) ");
1105 if (edge->indirect_call)
1106 fprintf(f, "(indirect) ");
1108 fprintf (f, "("HOST_WIDEST_INT_PRINT_DEC"x) ",
1109 (HOST_WIDEST_INT)edge->count);
1110 if (edge->frequency)
1111 fprintf (f, "(%.2f per call) ",
1112 edge->frequency / (double)CGRAPH_FREQ_BASE);
1113 if (edge->loop_nest)
1114 fprintf (f, "(nested in %i loops) ", edge->loop_nest);
1120 /* Dump call graph node NODE to stderr. */
1123 debug_cgraph_node (struct cgraph_node *node)
1125 dump_cgraph_node (stderr, node);
1129 /* Dump the callgraph to file F. */
1132 dump_cgraph (FILE *f)
1134 struct cgraph_node *node;
1136 fprintf (f, "callgraph:\n\n");
1137 for (node = cgraph_nodes; node; node = node->next)
1138 dump_cgraph_node (f, node);
1142 /* Dump the call graph to stderr. */
1147 dump_cgraph (stderr);
1151 /* Set the DECL_ASSEMBLER_NAME and update cgraph hashtables. */
1154 change_decl_assembler_name (tree decl, tree name)
1156 gcc_assert (!assembler_name_hash);
1157 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
1159 SET_DECL_ASSEMBLER_NAME (decl, name);
1162 if (name == DECL_ASSEMBLER_NAME (decl))
1165 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
1166 && DECL_RTL_SET_P (decl))
1167 warning (0, "%D renamed after being referenced in assembly", decl);
1169 SET_DECL_ASSEMBLER_NAME (decl, name);
1172 /* Add a top-level asm statement to the list. */
1174 struct cgraph_asm_node *
1175 cgraph_add_asm_node (tree asm_str)
1177 struct cgraph_asm_node *node;
1179 node = GGC_CNEW (struct cgraph_asm_node);
1180 node->asm_str = asm_str;
1181 node->order = cgraph_order++;
1183 if (cgraph_asm_nodes == NULL)
1184 cgraph_asm_nodes = node;
1186 cgraph_asm_last_node->next = node;
1187 cgraph_asm_last_node = node;
1191 /* Return true when the DECL can possibly be inlined. */
1193 cgraph_function_possibly_inlined_p (tree decl)
1195 if (!cgraph_global_info_ready)
1196 return !DECL_UNINLINABLE (decl);
1197 return DECL_POSSIBLY_INLINED (decl);
1200 /* Create clone of E in the node N represented by CALL_EXPR the callgraph. */
1201 struct cgraph_edge *
1202 cgraph_clone_edge (struct cgraph_edge *e, struct cgraph_node *n,
1203 gimple call_stmt, gcov_type count_scale, int freq_scale,
1204 int loop_nest, bool update_original)
1206 struct cgraph_edge *new_edge;
1207 gcov_type count = e->count * count_scale / REG_BR_PROB_BASE;
1208 gcov_type freq = e->frequency * (gcov_type) freq_scale / CGRAPH_FREQ_BASE;
1210 if (freq > CGRAPH_FREQ_MAX)
1211 freq = CGRAPH_FREQ_MAX;
1212 new_edge = cgraph_create_edge (n, e->callee, call_stmt, count, freq,
1213 e->loop_nest + loop_nest);
1215 new_edge->inline_failed = e->inline_failed;
1216 new_edge->indirect_call = e->indirect_call;
1217 if (update_original)
1219 e->count -= new_edge->count;
1223 cgraph_call_edge_duplication_hooks (e, new_edge);
1227 /* Create node representing clone of N executed COUNT times. Decrease
1228 the execution counts from original node too.
1230 When UPDATE_ORIGINAL is true, the counts are subtracted from the original
1231 function's profile to reflect the fact that part of execution is handled
1233 struct cgraph_node *
1234 cgraph_clone_node (struct cgraph_node *n, gcov_type count, int freq,
1235 int loop_nest, bool update_original)
1237 struct cgraph_node *new_node = cgraph_create_node ();
1238 struct cgraph_edge *e;
1239 gcov_type count_scale;
1241 new_node->decl = n->decl;
1242 new_node->origin = n->origin;
1243 if (new_node->origin)
1245 new_node->next_nested = new_node->origin->nested;
1246 new_node->origin->nested = new_node;
1248 new_node->analyzed = n->analyzed;
1249 new_node->local = n->local;
1250 new_node->global = n->global;
1251 new_node->rtl = n->rtl;
1252 new_node->master_clone = n->master_clone;
1253 new_node->count = count;
1256 if (new_node->count > n->count)
1257 count_scale = REG_BR_PROB_BASE;
1259 count_scale = new_node->count * REG_BR_PROB_BASE / n->count;
1263 if (update_original)
1270 for (e = n->callees;e; e=e->next_callee)
1271 cgraph_clone_edge (e, new_node, e->call_stmt, count_scale, freq, loop_nest,
1274 new_node->next_clone = n->next_clone;
1275 new_node->prev_clone = n;
1276 n->next_clone = new_node;
1277 if (new_node->next_clone)
1278 new_node->next_clone->prev_clone = new_node;
1280 cgraph_call_node_duplication_hooks (n, new_node);
1284 /* Return true if N is an master_clone, (see cgraph_master_clone). */
1287 cgraph_is_master_clone (struct cgraph_node *n)
1289 return (n == cgraph_master_clone (n));
1292 struct cgraph_node *
1293 cgraph_master_clone (struct cgraph_node *n)
1295 enum availability avail = cgraph_function_body_availability (n);
1297 if (avail == AVAIL_NOT_AVAILABLE || avail == AVAIL_OVERWRITABLE)
1300 if (!n->master_clone)
1301 n->master_clone = cgraph_node (n->decl);
1303 return n->master_clone;
1306 /* NODE is no longer nested function; update cgraph accordingly. */
1308 cgraph_unnest_node (struct cgraph_node *node)
1310 struct cgraph_node **node2 = &node->origin->nested;
1311 gcc_assert (node->origin);
1313 while (*node2 != node)
1314 node2 = &(*node2)->next_nested;
1315 *node2 = node->next_nested;
1316 node->origin = NULL;
1319 /* Return function availability. See cgraph.h for description of individual
1322 cgraph_function_body_availability (struct cgraph_node *node)
1324 enum availability avail;
1325 gcc_assert (cgraph_function_flags_ready);
1326 if (!node->analyzed)
1327 avail = AVAIL_NOT_AVAILABLE;
1328 else if (node->local.local)
1329 avail = AVAIL_LOCAL;
1330 else if (node->local.externally_visible)
1331 avail = AVAIL_AVAILABLE;
1333 /* If the function can be overwritten, return OVERWRITABLE. Take
1334 care at least of two notable extensions - the COMDAT functions
1335 used to share template instantiations in C++ (this is symmetric
1336 to code cp_cannot_inline_tree_fn and probably shall be shared and
1337 the inlinability hooks completely eliminated).
1339 ??? Does the C++ one definition rule allow us to always return
1340 AVAIL_AVAILABLE here? That would be good reason to preserve this
1341 hook Similarly deal with extern inline functions - this is again
1342 necessary to get C++ shared functions having keyed templates
1343 right and in the C extension documentation we probably should
1344 document the requirement of both versions of function (extern
1345 inline and offline) having same side effect characteristics as
1346 good optimization is what this optimization is about. */
1348 else if (!(*targetm.binds_local_p) (node->decl)
1349 && !DECL_COMDAT (node->decl) && !DECL_EXTERNAL (node->decl))
1350 avail = AVAIL_OVERWRITABLE;
1351 else avail = AVAIL_AVAILABLE;
1356 /* Add the function FNDECL to the call graph.
1357 Unlike cgraph_finalize_function, this function is intended to be used
1358 by middle end and allows insertion of new function at arbitrary point
1359 of compilation. The function can be either in high, low or SSA form
1362 The function is assumed to be reachable and have address taken (so no
1363 API breaking optimizations are performed on it).
1365 Main work done by this function is to enqueue the function for later
1366 processing to avoid need the passes to be re-entrant. */
1369 cgraph_add_new_function (tree fndecl, bool lowered)
1371 struct cgraph_node *node;
1372 switch (cgraph_state)
1374 case CGRAPH_STATE_CONSTRUCTION:
1375 /* Just enqueue function to be processed at nearest occurrence. */
1376 node = cgraph_node (fndecl);
1377 node->next_needed = cgraph_new_nodes;
1379 node->lowered = true;
1380 cgraph_new_nodes = node;
1383 case CGRAPH_STATE_IPA:
1384 case CGRAPH_STATE_IPA_SSA:
1385 case CGRAPH_STATE_EXPANSION:
1386 /* Bring the function into finalized state and enqueue for later
1387 analyzing and compilation. */
1388 node = cgraph_node (fndecl);
1389 node->local.local = false;
1390 node->local.finalized = true;
1391 node->reachable = node->needed = true;
1392 if (!lowered && cgraph_state == CGRAPH_STATE_EXPANSION)
1394 push_cfun (DECL_STRUCT_FUNCTION (fndecl));
1395 current_function_decl = fndecl;
1396 gimple_register_cfg_hooks ();
1397 tree_lowering_passes (fndecl);
1398 bitmap_obstack_initialize (NULL);
1399 if (!gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl)))
1400 execute_pass_list (pass_early_local_passes.pass.sub);
1401 bitmap_obstack_release (NULL);
1403 current_function_decl = NULL;
1408 node->lowered = true;
1409 node->next_needed = cgraph_new_nodes;
1410 cgraph_new_nodes = node;
1413 case CGRAPH_STATE_FINISHED:
1414 /* At the very end of compilation we have to do all the work up
1416 push_cfun (DECL_STRUCT_FUNCTION (fndecl));
1417 current_function_decl = fndecl;
1418 gimple_register_cfg_hooks ();
1420 tree_lowering_passes (fndecl);
1421 bitmap_obstack_initialize (NULL);
1422 if (!gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl)))
1423 execute_pass_list (pass_early_local_passes.pass.sub);
1424 bitmap_obstack_release (NULL);
1425 tree_rest_of_compilation (fndecl);
1427 current_function_decl = NULL;
1432 #include "gt-cgraph.h"