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"
87 #include "value-prof.h"
89 static void cgraph_node_remove_callers (struct cgraph_node
*node
);
90 static inline void cgraph_edge_remove_caller (struct cgraph_edge
*e
);
91 static inline void cgraph_edge_remove_callee (struct cgraph_edge
*e
);
93 /* Hash table used to convert declarations into nodes. */
94 static GTY((param_is (struct cgraph_node
))) htab_t cgraph_hash
;
95 /* Hash table used to convert assembler names into nodes. */
96 static GTY((param_is (struct cgraph_node
))) htab_t assembler_name_hash
;
98 /* The linked list of cgraph nodes. */
99 struct cgraph_node
*cgraph_nodes
;
101 /* Queue of cgraph nodes scheduled to be lowered. */
102 struct cgraph_node
*cgraph_nodes_queue
;
104 /* Queue of cgraph nodes scheduled to be added into cgraph. This is a
105 secondary queue used during optimization to accommodate passes that
106 may generate new functions that need to be optimized and expanded. */
107 struct cgraph_node
*cgraph_new_nodes
;
109 /* Number of nodes in existence. */
112 /* Maximal uid used in cgraph nodes. */
115 /* Maximal uid used in cgraph edges. */
116 int cgraph_edge_max_uid
;
118 /* Maximal pid used for profiling */
121 /* Set when whole unit has been analyzed so we can access global info. */
122 bool cgraph_global_info_ready
= false;
124 /* What state callgraph is in right now. */
125 enum cgraph_state cgraph_state
= CGRAPH_STATE_CONSTRUCTION
;
127 /* Set when the cgraph is fully build and the basic flags are computed. */
128 bool cgraph_function_flags_ready
= false;
130 /* Linked list of cgraph asm nodes. */
131 struct cgraph_asm_node
*cgraph_asm_nodes
;
133 /* Last node in cgraph_asm_nodes. */
134 static GTY(()) struct cgraph_asm_node
*cgraph_asm_last_node
;
136 /* The order index of the next cgraph node to be created. This is
137 used so that we can sort the cgraph nodes in order by when we saw
138 them, to support -fno-toplevel-reorder. */
141 /* List of hooks trigerred on cgraph_edge events. */
142 struct cgraph_edge_hook_list
{
143 cgraph_edge_hook hook
;
145 struct cgraph_edge_hook_list
*next
;
148 /* List of hooks trigerred on cgraph_node events. */
149 struct cgraph_node_hook_list
{
150 cgraph_node_hook hook
;
152 struct cgraph_node_hook_list
*next
;
155 /* List of hooks trigerred on events involving two cgraph_edges. */
156 struct cgraph_2edge_hook_list
{
157 cgraph_2edge_hook hook
;
159 struct cgraph_2edge_hook_list
*next
;
162 /* List of hooks trigerred on events involving two cgraph_nodes. */
163 struct cgraph_2node_hook_list
{
164 cgraph_2node_hook hook
;
166 struct cgraph_2node_hook_list
*next
;
169 /* List of hooks triggered when an edge is removed. */
170 struct cgraph_edge_hook_list
*first_cgraph_edge_removal_hook
;
171 /* List of hooks triggered when a node is removed. */
172 struct cgraph_node_hook_list
*first_cgraph_node_removal_hook
;
173 /* List of hooks triggered when an edge is duplicated. */
174 struct cgraph_2edge_hook_list
*first_cgraph_edge_duplicated_hook
;
175 /* List of hooks triggered when a node is duplicated. */
176 struct cgraph_2node_hook_list
*first_cgraph_node_duplicated_hook
;
177 /* List of hooks triggered when an function is inserted. */
178 struct cgraph_node_hook_list
*first_cgraph_function_insertion_hook
;
180 /* Head of a linked list of unused (freed) call graph nodes.
181 Do not GTY((delete)) this list so UIDs gets reliably recycled. */
182 static GTY(()) struct cgraph_node
*free_nodes
;
183 /* Head of a linked list of unused (freed) call graph edges.
184 Do not GTY((delete)) this list so UIDs gets reliably recycled. */
185 static GTY(()) struct cgraph_edge
*free_edges
;
187 /* Macros to access the next item in the list of free cgraph nodes and
189 #define NEXT_FREE_NODE(NODE) (NODE)->next
190 #define NEXT_FREE_EDGE(EDGE) (EDGE)->prev_caller
192 /* Register HOOK to be called with DATA on each removed edge. */
193 struct cgraph_edge_hook_list
*
194 cgraph_add_edge_removal_hook (cgraph_edge_hook hook
, void *data
)
196 struct cgraph_edge_hook_list
*entry
;
197 struct cgraph_edge_hook_list
**ptr
= &first_cgraph_edge_removal_hook
;
199 entry
= (struct cgraph_edge_hook_list
*) xmalloc (sizeof (*entry
));
209 /* Remove ENTRY from the list of hooks called on removing edges. */
211 cgraph_remove_edge_removal_hook (struct cgraph_edge_hook_list
*entry
)
213 struct cgraph_edge_hook_list
**ptr
= &first_cgraph_edge_removal_hook
;
215 while (*ptr
!= entry
)
221 /* Call all edge removal hooks. */
223 cgraph_call_edge_removal_hooks (struct cgraph_edge
*e
)
225 struct cgraph_edge_hook_list
*entry
= first_cgraph_edge_removal_hook
;
228 entry
->hook (e
, entry
->data
);
233 /* Register HOOK to be called with DATA on each removed node. */
234 struct cgraph_node_hook_list
*
235 cgraph_add_node_removal_hook (cgraph_node_hook hook
, void *data
)
237 struct cgraph_node_hook_list
*entry
;
238 struct cgraph_node_hook_list
**ptr
= &first_cgraph_node_removal_hook
;
240 entry
= (struct cgraph_node_hook_list
*) xmalloc (sizeof (*entry
));
250 /* Remove ENTRY from the list of hooks called on removing nodes. */
252 cgraph_remove_node_removal_hook (struct cgraph_node_hook_list
*entry
)
254 struct cgraph_node_hook_list
**ptr
= &first_cgraph_node_removal_hook
;
256 while (*ptr
!= entry
)
262 /* Call all node removal hooks. */
264 cgraph_call_node_removal_hooks (struct cgraph_node
*node
)
266 struct cgraph_node_hook_list
*entry
= first_cgraph_node_removal_hook
;
269 entry
->hook (node
, entry
->data
);
274 /* Register HOOK to be called with DATA on each removed node. */
275 struct cgraph_node_hook_list
*
276 cgraph_add_function_insertion_hook (cgraph_node_hook hook
, void *data
)
278 struct cgraph_node_hook_list
*entry
;
279 struct cgraph_node_hook_list
**ptr
= &first_cgraph_function_insertion_hook
;
281 entry
= (struct cgraph_node_hook_list
*) xmalloc (sizeof (*entry
));
291 /* Remove ENTRY from the list of hooks called on removing nodes. */
293 cgraph_remove_function_insertion_hook (struct cgraph_node_hook_list
*entry
)
295 struct cgraph_node_hook_list
**ptr
= &first_cgraph_function_insertion_hook
;
297 while (*ptr
!= entry
)
303 /* Call all node removal hooks. */
305 cgraph_call_function_insertion_hooks (struct cgraph_node
*node
)
307 struct cgraph_node_hook_list
*entry
= first_cgraph_function_insertion_hook
;
310 entry
->hook (node
, entry
->data
);
315 /* Register HOOK to be called with DATA on each duplicated edge. */
316 struct cgraph_2edge_hook_list
*
317 cgraph_add_edge_duplication_hook (cgraph_2edge_hook hook
, void *data
)
319 struct cgraph_2edge_hook_list
*entry
;
320 struct cgraph_2edge_hook_list
**ptr
= &first_cgraph_edge_duplicated_hook
;
322 entry
= (struct cgraph_2edge_hook_list
*) xmalloc (sizeof (*entry
));
332 /* Remove ENTRY from the list of hooks called on duplicating edges. */
334 cgraph_remove_edge_duplication_hook (struct cgraph_2edge_hook_list
*entry
)
336 struct cgraph_2edge_hook_list
**ptr
= &first_cgraph_edge_duplicated_hook
;
338 while (*ptr
!= entry
)
344 /* Call all edge duplication hooks. */
346 cgraph_call_edge_duplication_hooks (struct cgraph_edge
*cs1
,
347 struct cgraph_edge
*cs2
)
349 struct cgraph_2edge_hook_list
*entry
= first_cgraph_edge_duplicated_hook
;
352 entry
->hook (cs1
, cs2
, entry
->data
);
357 /* Register HOOK to be called with DATA on each duplicated node. */
358 struct cgraph_2node_hook_list
*
359 cgraph_add_node_duplication_hook (cgraph_2node_hook hook
, void *data
)
361 struct cgraph_2node_hook_list
*entry
;
362 struct cgraph_2node_hook_list
**ptr
= &first_cgraph_node_duplicated_hook
;
364 entry
= (struct cgraph_2node_hook_list
*) xmalloc (sizeof (*entry
));
374 /* Remove ENTRY from the list of hooks called on duplicating nodes. */
376 cgraph_remove_node_duplication_hook (struct cgraph_2node_hook_list
*entry
)
378 struct cgraph_2node_hook_list
**ptr
= &first_cgraph_node_duplicated_hook
;
380 while (*ptr
!= entry
)
386 /* Call all node duplication hooks. */
388 cgraph_call_node_duplication_hooks (struct cgraph_node
*node1
,
389 struct cgraph_node
*node2
)
391 struct cgraph_2node_hook_list
*entry
= first_cgraph_node_duplicated_hook
;
394 entry
->hook (node1
, node2
, entry
->data
);
399 /* Returns a hash code for P. */
402 hash_node (const void *p
)
404 const struct cgraph_node
*n
= (const struct cgraph_node
*) p
;
405 return (hashval_t
) DECL_UID (n
->decl
);
408 /* Returns nonzero if P1 and P2 are equal. */
411 eq_node (const void *p1
, const void *p2
)
413 const struct cgraph_node
*n1
= (const struct cgraph_node
*) p1
;
414 const struct cgraph_node
*n2
= (const struct cgraph_node
*) p2
;
415 return DECL_UID (n1
->decl
) == DECL_UID (n2
->decl
);
418 /* Allocate new callgraph node and insert it into basic data structures. */
420 static struct cgraph_node
*
421 cgraph_create_node (void)
423 struct cgraph_node
*node
;
428 free_nodes
= NEXT_FREE_NODE (node
);
432 node
= GGC_CNEW (struct cgraph_node
);
433 node
->uid
= cgraph_max_uid
++;
436 node
->next
= cgraph_nodes
;
438 node
->order
= cgraph_order
++;
440 cgraph_nodes
->previous
= node
;
441 node
->previous
= NULL
;
442 node
->global
.estimated_growth
= INT_MIN
;
448 /* Return cgraph node assigned to DECL. Create new one when needed. */
451 cgraph_node (tree decl
)
453 struct cgraph_node key
, *node
, **slot
;
455 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
458 cgraph_hash
= htab_create_ggc (10, hash_node
, eq_node
, NULL
);
462 slot
= (struct cgraph_node
**) htab_find_slot (cgraph_hash
, &key
, INSERT
);
470 node
= cgraph_create_node ();
473 if (DECL_CONTEXT (decl
) && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
475 node
->origin
= cgraph_node (DECL_CONTEXT (decl
));
476 node
->next_nested
= node
->origin
->nested
;
477 node
->origin
->nested
= node
;
479 if (assembler_name_hash
)
482 tree name
= DECL_ASSEMBLER_NAME (decl
);
484 aslot
= htab_find_slot_with_hash (assembler_name_hash
, name
,
485 decl_assembler_name_hash (name
),
487 /* We can have multiple declarations with same assembler name. For C++
488 it is __builtin_strlen and strlen, for instance. Do we need to
489 record them all? Original implementation marked just first one
490 so lets hope for the best. */
497 /* Insert already constructed node into hashtable. */
500 cgraph_insert_node_to_hashtable (struct cgraph_node
*node
)
502 struct cgraph_node
**slot
;
504 slot
= (struct cgraph_node
**) htab_find_slot (cgraph_hash
, node
, INSERT
);
510 /* Returns a hash code for P. */
513 hash_node_by_assembler_name (const void *p
)
515 const struct cgraph_node
*n
= (const struct cgraph_node
*) p
;
516 return (hashval_t
) decl_assembler_name_hash (DECL_ASSEMBLER_NAME (n
->decl
));
519 /* Returns nonzero if P1 and P2 are equal. */
522 eq_assembler_name (const void *p1
, const void *p2
)
524 const struct cgraph_node
*n1
= (const struct cgraph_node
*) p1
;
525 const_tree name
= (const_tree
)p2
;
526 return (decl_assembler_name_equal (n1
->decl
, name
));
529 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
530 Return NULL if there's no such node. */
533 cgraph_node_for_asm (tree asmname
)
535 struct cgraph_node
*node
;
538 if (!assembler_name_hash
)
540 assembler_name_hash
=
541 htab_create_ggc (10, hash_node_by_assembler_name
, eq_assembler_name
,
543 for (node
= cgraph_nodes
; node
; node
= node
->next
)
544 if (!node
->global
.inlined_to
)
546 tree name
= DECL_ASSEMBLER_NAME (node
->decl
);
547 slot
= htab_find_slot_with_hash (assembler_name_hash
, name
,
548 decl_assembler_name_hash (name
),
550 /* We can have multiple declarations with same assembler name. For C++
551 it is __builtin_strlen and strlen, for instance. Do we need to
552 record them all? Original implementation marked just first one
553 so lets hope for the best. */
560 slot
= htab_find_slot_with_hash (assembler_name_hash
, asmname
,
561 decl_assembler_name_hash (asmname
),
565 return (struct cgraph_node
*) *slot
;
569 /* Returns a hash value for X (which really is a die_struct). */
572 edge_hash (const void *x
)
574 return htab_hash_pointer (((const struct cgraph_edge
*) x
)->call_stmt
);
577 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
580 edge_eq (const void *x
, const void *y
)
582 return ((const struct cgraph_edge
*) x
)->call_stmt
== y
;
586 /* Return the callgraph edge representing the GIMPLE_CALL statement
590 cgraph_edge (struct cgraph_node
*node
, gimple call_stmt
)
592 struct cgraph_edge
*e
, *e2
;
595 if (node
->call_site_hash
)
596 return (struct cgraph_edge
*)
597 htab_find_with_hash (node
->call_site_hash
, call_stmt
,
598 htab_hash_pointer (call_stmt
));
600 /* This loop may turn out to be performance problem. In such case adding
601 hashtables into call nodes with very many edges is probably best
602 solution. It is not good idea to add pointer into CALL_EXPR itself
603 because we want to make possible having multiple cgraph nodes representing
604 different clones of the same body before the body is actually cloned. */
605 for (e
= node
->callees
; e
; e
= e
->next_callee
)
607 if (e
->call_stmt
== call_stmt
)
614 node
->call_site_hash
= htab_create_ggc (120, edge_hash
, edge_eq
, NULL
);
615 for (e2
= node
->callees
; e2
; e2
= e2
->next_callee
)
618 slot
= htab_find_slot_with_hash (node
->call_site_hash
,
620 htab_hash_pointer (e2
->call_stmt
),
631 /* Change field call_smt of edge E to NEW_STMT. */
634 cgraph_set_call_stmt (struct cgraph_edge
*e
, gimple new_stmt
)
636 if (e
->caller
->call_site_hash
)
638 htab_remove_elt_with_hash (e
->caller
->call_site_hash
,
640 htab_hash_pointer (e
->call_stmt
));
642 e
->call_stmt
= new_stmt
;
643 if (e
->caller
->call_site_hash
)
646 slot
= htab_find_slot_with_hash (e
->caller
->call_site_hash
,
649 (e
->call_stmt
), INSERT
);
655 /* Give initial reasons why inlining would fail on EDGE. This gets either
656 nullified or usually overwritten by more precise reasons later. */
659 initialize_inline_failed (struct cgraph_edge
*e
)
661 struct cgraph_node
*callee
= e
->callee
;
663 if (!callee
->analyzed
)
664 e
->inline_failed
= CIF_BODY_NOT_AVAILABLE
;
665 else if (callee
->local
.redefined_extern_inline
)
666 e
->inline_failed
= CIF_REDEFINED_EXTERN_INLINE
;
667 else if (!callee
->local
.inlinable
)
668 e
->inline_failed
= CIF_FUNCTION_NOT_INLINABLE
;
669 else if (gimple_call_cannot_inline_p (e
->call_stmt
))
670 e
->inline_failed
= CIF_MISMATCHED_ARGUMENTS
;
672 e
->inline_failed
= CIF_FUNCTION_NOT_CONSIDERED
;
675 /* Create edge from CALLER to CALLEE in the cgraph. */
678 cgraph_create_edge (struct cgraph_node
*caller
, struct cgraph_node
*callee
,
679 gimple call_stmt
, gcov_type count
, int freq
, int nest
)
681 struct cgraph_edge
*edge
;
683 #ifdef ENABLE_CHECKING
684 /* This is rather pricely check possibly trigerring construction of call stmt
686 gcc_assert (!cgraph_edge (caller
, call_stmt
));
689 gcc_assert (is_gimple_call (call_stmt
));
694 free_edges
= NEXT_FREE_EDGE (edge
);
698 edge
= GGC_NEW (struct cgraph_edge
);
699 edge
->uid
= cgraph_edge_max_uid
++;
704 edge
->caller
= caller
;
705 edge
->callee
= callee
;
706 edge
->call_stmt
= call_stmt
;
707 edge
->prev_caller
= NULL
;
708 edge
->next_caller
= callee
->callers
;
710 callee
->callers
->prev_caller
= edge
;
711 edge
->prev_callee
= NULL
;
712 edge
->next_callee
= caller
->callees
;
714 caller
->callees
->prev_callee
= edge
;
715 caller
->callees
= edge
;
716 callee
->callers
= edge
;
718 gcc_assert (count
>= 0);
719 edge
->frequency
= freq
;
720 gcc_assert (freq
>= 0);
721 gcc_assert (freq
<= CGRAPH_FREQ_MAX
);
722 edge
->loop_nest
= nest
;
723 edge
->indirect_call
= 0;
724 if (caller
->call_site_hash
)
727 slot
= htab_find_slot_with_hash (caller
->call_site_hash
,
736 initialize_inline_failed (edge
);
741 /* Remove the edge E from the list of the callers of the callee. */
744 cgraph_edge_remove_callee (struct cgraph_edge
*e
)
747 e
->prev_caller
->next_caller
= e
->next_caller
;
749 e
->next_caller
->prev_caller
= e
->prev_caller
;
751 e
->callee
->callers
= e
->next_caller
;
754 /* Remove the edge E from the list of the callees of the caller. */
757 cgraph_edge_remove_caller (struct cgraph_edge
*e
)
760 e
->prev_callee
->next_callee
= e
->next_callee
;
762 e
->next_callee
->prev_callee
= e
->prev_callee
;
764 e
->caller
->callees
= e
->next_callee
;
765 if (e
->caller
->call_site_hash
)
766 htab_remove_elt_with_hash (e
->caller
->call_site_hash
,
768 htab_hash_pointer (e
->call_stmt
));
771 /* Put the edge onto the free list. */
774 cgraph_free_edge (struct cgraph_edge
*e
)
778 /* Clear out the edge so we do not dangle pointers. */
779 memset (e
, 0, sizeof (*e
));
781 NEXT_FREE_EDGE (e
) = free_edges
;
785 /* Remove the edge E in the cgraph. */
788 cgraph_remove_edge (struct cgraph_edge
*e
)
790 /* Call all edge removal hooks. */
791 cgraph_call_edge_removal_hooks (e
);
793 /* Remove from callers list of the callee. */
794 cgraph_edge_remove_callee (e
);
796 /* Remove from callees list of the callers. */
797 cgraph_edge_remove_caller (e
);
799 /* Put the edge onto the free list. */
800 cgraph_free_edge (e
);
803 /* Redirect callee of E to N. The function does not update underlying
807 cgraph_redirect_edge_callee (struct cgraph_edge
*e
, struct cgraph_node
*n
)
809 /* Remove from callers list of the current callee. */
810 cgraph_edge_remove_callee (e
);
812 /* Insert to callers list of the new callee. */
813 e
->prev_caller
= NULL
;
815 n
->callers
->prev_caller
= e
;
816 e
->next_caller
= n
->callers
;
822 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
823 OLD_STMT changed into NEW_STMT. */
826 cgraph_update_edges_for_call_stmt (gimple old_stmt
, gimple new_stmt
)
828 tree new_call
= (is_gimple_call (new_stmt
)) ? gimple_call_fn (new_stmt
) : 0;
829 tree old_call
= (is_gimple_call (old_stmt
)) ? gimple_call_fn (old_stmt
) : 0;
830 struct cgraph_node
*node
= cgraph_node (cfun
->decl
);
832 if (old_call
!= new_call
)
834 struct cgraph_edge
*e
= cgraph_edge (node
, old_stmt
);
835 struct cgraph_edge
*ne
= NULL
;
840 gcov_type count
= e
->count
;
841 int frequency
= e
->frequency
;
842 int loop_nest
= e
->loop_nest
;
844 cgraph_remove_edge (e
);
847 new_decl
= gimple_call_fndecl (new_stmt
);
850 ne
= cgraph_create_edge (node
, cgraph_node (new_decl
),
851 new_stmt
, count
, frequency
,
853 gcc_assert (ne
->inline_failed
);
858 else if (old_stmt
!= new_stmt
)
860 struct cgraph_edge
*e
= cgraph_edge (node
, old_stmt
);
863 cgraph_set_call_stmt (e
, new_stmt
);
868 /* Remove all callees from the node. */
871 cgraph_node_remove_callees (struct cgraph_node
*node
)
873 struct cgraph_edge
*e
, *f
;
875 /* It is sufficient to remove the edges from the lists of callers of
876 the callees. The callee list of the node can be zapped with one
878 for (e
= node
->callees
; e
; e
= f
)
881 cgraph_call_edge_removal_hooks (e
);
882 cgraph_edge_remove_callee (e
);
883 cgraph_free_edge (e
);
885 node
->callees
= NULL
;
886 if (node
->call_site_hash
)
888 htab_delete (node
->call_site_hash
);
889 node
->call_site_hash
= NULL
;
893 /* Remove all callers from the node. */
896 cgraph_node_remove_callers (struct cgraph_node
*node
)
898 struct cgraph_edge
*e
, *f
;
900 /* It is sufficient to remove the edges from the lists of callees of
901 the callers. The caller list of the node can be zapped with one
903 for (e
= node
->callers
; e
; e
= f
)
906 cgraph_call_edge_removal_hooks (e
);
907 cgraph_edge_remove_caller (e
);
908 cgraph_free_edge (e
);
910 node
->callers
= NULL
;
913 /* Release memory used to represent body of function NODE. */
916 cgraph_release_function_body (struct cgraph_node
*node
)
918 if (DECL_STRUCT_FUNCTION (node
->decl
))
920 tree old_decl
= current_function_decl
;
921 push_cfun (DECL_STRUCT_FUNCTION (node
->decl
));
924 current_function_decl
= node
->decl
;
926 delete_tree_cfg_annotations ();
928 current_function_decl
= old_decl
;
932 gcc_assert (dom_computed
[0] == DOM_NONE
);
933 gcc_assert (dom_computed
[1] == DOM_NONE
);
936 if (cfun
->value_histograms
)
938 gcc_assert (!current_loops
);
940 gimple_set_body (node
->decl
, NULL
);
941 VEC_free (ipa_opt_pass
, heap
,
942 DECL_STRUCT_FUNCTION (node
->decl
)->ipa_transforms_to_apply
);
943 /* Struct function hangs a lot of data that would leak if we didn't
944 removed all pointers to it. */
945 ggc_free (DECL_STRUCT_FUNCTION (node
->decl
));
946 DECL_STRUCT_FUNCTION (node
->decl
) = NULL
;
948 DECL_SAVED_TREE (node
->decl
) = NULL
;
949 /* If the node is abstract and needed, then do not clear DECL_INITIAL
950 of its associated function function declaration because it's
951 needed to emit debug info later. */
952 if (!node
->abstract_and_needed
)
953 DECL_INITIAL (node
->decl
) = error_mark_node
;
956 /* Remove the node from cgraph. */
959 cgraph_remove_node (struct cgraph_node
*node
)
962 bool kill_body
= false;
963 struct cgraph_node
*n
;
966 cgraph_call_node_removal_hooks (node
);
967 cgraph_node_remove_callers (node
);
968 cgraph_node_remove_callees (node
);
970 /* Incremental inlining access removed nodes stored in the postorder list.
972 node
->needed
= node
->reachable
= false;
973 for (n
= node
->nested
; n
; n
= n
->next_nested
)
978 struct cgraph_node
**node2
= &node
->origin
->nested
;
980 while (*node2
!= node
)
981 node2
= &(*node2
)->next_nested
;
982 *node2
= node
->next_nested
;
985 node
->previous
->next
= node
->next
;
987 cgraph_nodes
= node
->next
;
989 node
->next
->previous
= node
->previous
;
991 node
->previous
= NULL
;
992 slot
= htab_find_slot (cgraph_hash
, node
, NO_INSERT
);
995 if (node
->next_clone
)
997 struct cgraph_node
*new_node
= node
->next_clone
;
1000 node
->next_clone
->prev_clone
= NULL
;
1004 htab_clear_slot (cgraph_hash
, slot
);
1010 node
->prev_clone
->next_clone
= node
->next_clone
;
1011 if (node
->next_clone
)
1012 node
->next_clone
->prev_clone
= node
->prev_clone
;
1015 /* While all the clones are removed after being proceeded, the function
1016 itself is kept in the cgraph even after it is compiled. Check whether
1017 we are done with this body and reclaim it proactively if this is the case.
1019 if (!kill_body
&& *slot
)
1021 struct cgraph_node
*n
= (struct cgraph_node
*) *slot
;
1022 if (!n
->next_clone
&& !n
->global
.inlined_to
1023 && (cgraph_global_info_ready
1024 && (TREE_ASM_WRITTEN (n
->decl
) || DECL_EXTERNAL (n
->decl
))))
1027 if (assembler_name_hash
)
1029 tree name
= DECL_ASSEMBLER_NAME (node
->decl
);
1030 slot
= htab_find_slot_with_hash (assembler_name_hash
, name
,
1031 decl_assembler_name_hash (name
),
1033 /* Inline clones are not hashed. */
1034 if (slot
&& *slot
== node
)
1035 htab_clear_slot (assembler_name_hash
, slot
);
1039 cgraph_release_function_body (node
);
1041 if (node
->call_site_hash
)
1043 htab_delete (node
->call_site_hash
);
1044 node
->call_site_hash
= NULL
;
1048 /* Clear out the node to NULL all pointers and add the node to the free
1050 memset (node
, 0, sizeof(*node
));
1052 NEXT_FREE_NODE (node
) = free_nodes
;
1056 /* Notify finalize_compilation_unit that given node is reachable. */
1059 cgraph_mark_reachable_node (struct cgraph_node
*node
)
1061 if (!node
->reachable
&& node
->local
.finalized
)
1063 notice_global_symbol (node
->decl
);
1064 node
->reachable
= 1;
1065 gcc_assert (!cgraph_global_info_ready
);
1067 node
->next_needed
= cgraph_nodes_queue
;
1068 cgraph_nodes_queue
= node
;
1072 /* Likewise indicate that a node is needed, i.e. reachable via some
1076 cgraph_mark_needed_node (struct cgraph_node
*node
)
1079 cgraph_mark_reachable_node (node
);
1082 /* Return local info for the compiled function. */
1084 struct cgraph_local_info
*
1085 cgraph_local_info (tree decl
)
1087 struct cgraph_node
*node
;
1089 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1090 node
= cgraph_node (decl
);
1091 return &node
->local
;
1094 /* Return local info for the compiled function. */
1096 struct cgraph_global_info
*
1097 cgraph_global_info (tree decl
)
1099 struct cgraph_node
*node
;
1101 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
&& cgraph_global_info_ready
);
1102 node
= cgraph_node (decl
);
1103 return &node
->global
;
1106 /* Return local info for the compiled function. */
1108 struct cgraph_rtl_info
*
1109 cgraph_rtl_info (tree decl
)
1111 struct cgraph_node
*node
;
1113 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1114 node
= cgraph_node (decl
);
1115 if (decl
!= current_function_decl
1116 && !TREE_ASM_WRITTEN (node
->decl
))
1121 /* Return a string describing the failure REASON. */
1124 cgraph_inline_failed_string (cgraph_inline_failed_t reason
)
1127 #define DEFCIFCODE(code, string) string,
1129 static const char *cif_string_table
[CIF_N_REASONS
] = {
1130 #include "cif-code.def"
1133 /* Signedness of an enum type is implementation defined, so cast it
1134 to unsigned before testing. */
1135 gcc_assert ((unsigned) reason
< CIF_N_REASONS
);
1136 return cif_string_table
[reason
];
1139 /* Return name of the node used in debug output. */
1141 cgraph_node_name (struct cgraph_node
*node
)
1143 return lang_hooks
.decl_printable_name (node
->decl
, 2);
1146 /* Names used to print out the availability enum. */
1147 const char * const cgraph_availability_names
[] =
1148 {"unset", "not_available", "overwritable", "available", "local"};
1151 /* Dump call graph node NODE to file F. */
1154 dump_cgraph_node (FILE *f
, struct cgraph_node
*node
)
1156 struct cgraph_edge
*edge
;
1157 fprintf (f
, "%s/%i(%i):", cgraph_node_name (node
), node
->uid
, node
->pid
);
1158 if (node
->global
.inlined_to
)
1159 fprintf (f
, " (inline copy in %s/%i)",
1160 cgraph_node_name (node
->global
.inlined_to
),
1161 node
->global
.inlined_to
->uid
);
1162 if (cgraph_function_flags_ready
)
1163 fprintf (f
, " availability:%s",
1164 cgraph_availability_names
[cgraph_function_body_availability (node
)]);
1166 fprintf (f
, " executed "HOST_WIDEST_INT_PRINT_DEC
"x",
1167 (HOST_WIDEST_INT
)node
->count
);
1168 if (node
->local
.inline_summary
.self_insns
)
1169 fprintf (f
, " %i insns", node
->local
.inline_summary
.self_insns
);
1170 if (node
->global
.insns
&& node
->global
.insns
1171 != node
->local
.inline_summary
.self_insns
)
1172 fprintf (f
, " (%i after inlining)", node
->global
.insns
);
1173 if (node
->local
.inline_summary
.estimated_self_stack_size
)
1174 fprintf (f
, " %i bytes stack usage", (int)node
->local
.inline_summary
.estimated_self_stack_size
);
1175 if (node
->global
.estimated_stack_size
!= node
->local
.inline_summary
.estimated_self_stack_size
)
1176 fprintf (f
, " %i bytes after inlining", (int)node
->global
.estimated_stack_size
);
1178 fprintf (f
, " nested in: %s", cgraph_node_name (node
->origin
));
1180 fprintf (f
, " needed");
1181 else if (node
->reachable
)
1182 fprintf (f
, " reachable");
1183 if (gimple_has_body_p (node
->decl
))
1184 fprintf (f
, " body");
1186 fprintf (f
, " process");
1187 if (node
->local
.local
)
1188 fprintf (f
, " local");
1189 if (node
->local
.externally_visible
)
1190 fprintf (f
, " externally_visible");
1191 if (node
->local
.finalized
)
1192 fprintf (f
, " finalized");
1193 if (node
->local
.disregard_inline_limits
)
1194 fprintf (f
, " always_inline");
1195 else if (node
->local
.inlinable
)
1196 fprintf (f
, " inlinable");
1197 if (node
->local
.redefined_extern_inline
)
1198 fprintf (f
, " redefined_extern_inline");
1199 if (TREE_ASM_WRITTEN (node
->decl
))
1200 fprintf (f
, " asm_written");
1202 fprintf (f
, "\n called by: ");
1203 for (edge
= node
->callers
; edge
; edge
= edge
->next_caller
)
1205 fprintf (f
, "%s/%i ", cgraph_node_name (edge
->caller
),
1208 fprintf (f
, "("HOST_WIDEST_INT_PRINT_DEC
"x) ",
1209 (HOST_WIDEST_INT
)edge
->count
);
1210 if (edge
->frequency
)
1211 fprintf (f
, "(%.2f per call) ",
1212 edge
->frequency
/ (double)CGRAPH_FREQ_BASE
);
1213 if (!edge
->inline_failed
)
1214 fprintf(f
, "(inlined) ");
1215 if (edge
->indirect_call
)
1216 fprintf(f
, "(indirect) ");
1219 fprintf (f
, "\n calls: ");
1220 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
1222 fprintf (f
, "%s/%i ", cgraph_node_name (edge
->callee
),
1224 if (!edge
->inline_failed
)
1225 fprintf(f
, "(inlined) ");
1226 if (edge
->indirect_call
)
1227 fprintf(f
, "(indirect) ");
1229 fprintf (f
, "("HOST_WIDEST_INT_PRINT_DEC
"x) ",
1230 (HOST_WIDEST_INT
)edge
->count
);
1231 if (edge
->frequency
)
1232 fprintf (f
, "(%.2f per call) ",
1233 edge
->frequency
/ (double)CGRAPH_FREQ_BASE
);
1234 if (edge
->loop_nest
)
1235 fprintf (f
, "(nested in %i loops) ", edge
->loop_nest
);
1241 /* Dump call graph node NODE to stderr. */
1244 debug_cgraph_node (struct cgraph_node
*node
)
1246 dump_cgraph_node (stderr
, node
);
1250 /* Dump the callgraph to file F. */
1253 dump_cgraph (FILE *f
)
1255 struct cgraph_node
*node
;
1257 fprintf (f
, "callgraph:\n\n");
1258 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1259 dump_cgraph_node (f
, node
);
1263 /* Dump the call graph to stderr. */
1268 dump_cgraph (stderr
);
1272 /* Set the DECL_ASSEMBLER_NAME and update cgraph hashtables. */
1275 change_decl_assembler_name (tree decl
, tree name
)
1277 gcc_assert (!assembler_name_hash
);
1278 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
1280 SET_DECL_ASSEMBLER_NAME (decl
, name
);
1283 if (name
== DECL_ASSEMBLER_NAME (decl
))
1286 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
))
1287 && DECL_RTL_SET_P (decl
))
1288 warning (0, "%D renamed after being referenced in assembly", decl
);
1290 SET_DECL_ASSEMBLER_NAME (decl
, name
);
1293 /* Add a top-level asm statement to the list. */
1295 struct cgraph_asm_node
*
1296 cgraph_add_asm_node (tree asm_str
)
1298 struct cgraph_asm_node
*node
;
1300 node
= GGC_CNEW (struct cgraph_asm_node
);
1301 node
->asm_str
= asm_str
;
1302 node
->order
= cgraph_order
++;
1304 if (cgraph_asm_nodes
== NULL
)
1305 cgraph_asm_nodes
= node
;
1307 cgraph_asm_last_node
->next
= node
;
1308 cgraph_asm_last_node
= node
;
1312 /* Return true when the DECL can possibly be inlined. */
1314 cgraph_function_possibly_inlined_p (tree decl
)
1316 if (!cgraph_global_info_ready
)
1317 return !DECL_UNINLINABLE (decl
);
1318 return DECL_POSSIBLY_INLINED (decl
);
1321 /* Create clone of E in the node N represented by CALL_EXPR the callgraph. */
1322 struct cgraph_edge
*
1323 cgraph_clone_edge (struct cgraph_edge
*e
, struct cgraph_node
*n
,
1324 gimple call_stmt
, gcov_type count_scale
, int freq_scale
,
1325 int loop_nest
, bool update_original
)
1327 struct cgraph_edge
*new_edge
;
1328 gcov_type count
= e
->count
* count_scale
/ REG_BR_PROB_BASE
;
1329 gcov_type freq
= e
->frequency
* (gcov_type
) freq_scale
/ CGRAPH_FREQ_BASE
;
1331 if (freq
> CGRAPH_FREQ_MAX
)
1332 freq
= CGRAPH_FREQ_MAX
;
1333 new_edge
= cgraph_create_edge (n
, e
->callee
, call_stmt
, count
, freq
,
1334 e
->loop_nest
+ loop_nest
);
1336 new_edge
->inline_failed
= e
->inline_failed
;
1337 new_edge
->indirect_call
= e
->indirect_call
;
1338 if (update_original
)
1340 e
->count
-= new_edge
->count
;
1344 cgraph_call_edge_duplication_hooks (e
, new_edge
);
1348 /* Create node representing clone of N executed COUNT times. Decrease
1349 the execution counts from original node too.
1351 When UPDATE_ORIGINAL is true, the counts are subtracted from the original
1352 function's profile to reflect the fact that part of execution is handled
1354 struct cgraph_node
*
1355 cgraph_clone_node (struct cgraph_node
*n
, gcov_type count
, int freq
,
1356 int loop_nest
, bool update_original
)
1358 struct cgraph_node
*new_node
= cgraph_create_node ();
1359 struct cgraph_edge
*e
;
1360 gcov_type count_scale
;
1362 new_node
->decl
= n
->decl
;
1363 new_node
->origin
= n
->origin
;
1364 if (new_node
->origin
)
1366 new_node
->next_nested
= new_node
->origin
->nested
;
1367 new_node
->origin
->nested
= new_node
;
1369 new_node
->analyzed
= n
->analyzed
;
1370 new_node
->local
= n
->local
;
1371 new_node
->global
= n
->global
;
1372 new_node
->rtl
= n
->rtl
;
1373 new_node
->count
= count
;
1376 if (new_node
->count
> n
->count
)
1377 count_scale
= REG_BR_PROB_BASE
;
1379 count_scale
= new_node
->count
* REG_BR_PROB_BASE
/ n
->count
;
1383 if (update_original
)
1390 for (e
= n
->callees
;e
; e
=e
->next_callee
)
1391 cgraph_clone_edge (e
, new_node
, e
->call_stmt
, count_scale
, freq
, loop_nest
,
1394 new_node
->next_clone
= n
->next_clone
;
1395 new_node
->prev_clone
= n
;
1396 n
->next_clone
= new_node
;
1397 if (new_node
->next_clone
)
1398 new_node
->next_clone
->prev_clone
= new_node
;
1400 cgraph_call_node_duplication_hooks (n
, new_node
);
1404 /* NODE is no longer nested function; update cgraph accordingly. */
1406 cgraph_unnest_node (struct cgraph_node
*node
)
1408 struct cgraph_node
**node2
= &node
->origin
->nested
;
1409 gcc_assert (node
->origin
);
1411 while (*node2
!= node
)
1412 node2
= &(*node2
)->next_nested
;
1413 *node2
= node
->next_nested
;
1414 node
->origin
= NULL
;
1417 /* Return function availability. See cgraph.h for description of individual
1420 cgraph_function_body_availability (struct cgraph_node
*node
)
1422 enum availability avail
;
1423 gcc_assert (cgraph_function_flags_ready
);
1424 if (!node
->analyzed
)
1425 avail
= AVAIL_NOT_AVAILABLE
;
1426 else if (node
->local
.local
)
1427 avail
= AVAIL_LOCAL
;
1428 else if (!node
->local
.externally_visible
)
1429 avail
= AVAIL_AVAILABLE
;
1430 /* Inline functions are safe to be analyzed even if their sybol can
1431 be overwritten at runtime. It is not meaningful to enfore any sane
1432 behaviour on replacing inline function by different body. */
1433 else if (DECL_DECLARED_INLINE_P (node
->decl
))
1434 avail
= AVAIL_AVAILABLE
;
1436 /* If the function can be overwritten, return OVERWRITABLE. Take
1437 care at least of two notable extensions - the COMDAT functions
1438 used to share template instantiations in C++ (this is symmetric
1439 to code cp_cannot_inline_tree_fn and probably shall be shared and
1440 the inlinability hooks completely eliminated).
1442 ??? Does the C++ one definition rule allow us to always return
1443 AVAIL_AVAILABLE here? That would be good reason to preserve this
1446 else if (DECL_REPLACEABLE_P (node
->decl
) && !DECL_EXTERNAL (node
->decl
))
1447 avail
= AVAIL_OVERWRITABLE
;
1448 else avail
= AVAIL_AVAILABLE
;
1453 /* Add the function FNDECL to the call graph.
1454 Unlike cgraph_finalize_function, this function is intended to be used
1455 by middle end and allows insertion of new function at arbitrary point
1456 of compilation. The function can be either in high, low or SSA form
1459 The function is assumed to be reachable and have address taken (so no
1460 API breaking optimizations are performed on it).
1462 Main work done by this function is to enqueue the function for later
1463 processing to avoid need the passes to be re-entrant. */
1466 cgraph_add_new_function (tree fndecl
, bool lowered
)
1468 struct cgraph_node
*node
;
1469 switch (cgraph_state
)
1471 case CGRAPH_STATE_CONSTRUCTION
:
1472 /* Just enqueue function to be processed at nearest occurrence. */
1473 node
= cgraph_node (fndecl
);
1474 node
->next_needed
= cgraph_new_nodes
;
1476 node
->lowered
= true;
1477 cgraph_new_nodes
= node
;
1480 case CGRAPH_STATE_IPA
:
1481 case CGRAPH_STATE_IPA_SSA
:
1482 case CGRAPH_STATE_EXPANSION
:
1483 /* Bring the function into finalized state and enqueue for later
1484 analyzing and compilation. */
1485 node
= cgraph_node (fndecl
);
1486 node
->local
.local
= false;
1487 node
->local
.finalized
= true;
1488 node
->reachable
= node
->needed
= true;
1489 if (!lowered
&& cgraph_state
== CGRAPH_STATE_EXPANSION
)
1491 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
1492 current_function_decl
= fndecl
;
1493 gimple_register_cfg_hooks ();
1494 tree_lowering_passes (fndecl
);
1495 bitmap_obstack_initialize (NULL
);
1496 if (!gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
1497 execute_pass_list (pass_early_local_passes
.pass
.sub
);
1498 bitmap_obstack_release (NULL
);
1500 current_function_decl
= NULL
;
1505 node
->lowered
= true;
1506 node
->next_needed
= cgraph_new_nodes
;
1507 cgraph_new_nodes
= node
;
1510 case CGRAPH_STATE_FINISHED
:
1511 /* At the very end of compilation we have to do all the work up
1513 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
1514 current_function_decl
= fndecl
;
1515 gimple_register_cfg_hooks ();
1517 tree_lowering_passes (fndecl
);
1518 bitmap_obstack_initialize (NULL
);
1519 if (!gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
1520 execute_pass_list (pass_early_local_passes
.pass
.sub
);
1521 bitmap_obstack_release (NULL
);
1522 tree_rest_of_compilation (fndecl
);
1524 current_function_decl
= NULL
;
1529 #include "gt-cgraph.h"