1 /* Callgraph handling code.
2 Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
22 /* This file contains basic routines manipulating call graph and variable pool
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 (in
32 contrast to tree DECL nodes where we can have multiple nodes for each
35 The mapping from declarations to call-graph nodes is done using hash table
36 based on DECL_ASSEMBLER_NAME, so it is essential for assembler name to
37 not change once the declaration is inserted into the call-graph.
38 The call-graph nodes are created lazily using cgraph_node function when
39 called for unknown declaration.
41 When built, there is one edge for each direct call. It is possible that
42 the reference will be later optimized out. The call-graph is built
43 conservatively in order to make conservative data flow analysis possible.
45 The callgraph at the moment does not represent indirect calls or calls
46 from other compilation unit. Flag NEEDED is set for each node that may
47 be accessed in such an invisible way and it shall be considered an
48 entry point to the callgraph.
50 Intraprocedural information:
52 Callgraph is place to store data needed for intraprocedural optimization.
53 All data structures are divided into three components: local_info that
54 is produced while analyzing the function, global_info that is result
55 of global walking of the callgraph on the end of compilation and
56 rtl_info used by RTL backend to propagate data from already compiled
57 functions to their callers.
61 The function inlining information is decided in advance and maintained
62 in the callgraph as so called inline plan.
63 For each inlined call, the callee's node is cloned to represent the
64 new function copy produced by inliner.
65 Each inlined call gets a unique corresponding clone node of the callee
66 and the data structure is updated while inlining is performed, so
67 the clones are eliminated and their callee edges redirected to the
70 Each edge has "inline_failed" field. When the field is set to NULL,
71 the call will be inlined. When it is non-NULL it contains a reason
72 why inlining wasn't performed.
75 The varpool data structure:
77 Varpool is used to maintain variables in similar manner as call-graph
78 is used for functions. Most of the API is symmetric replacing cgraph
79 function prefix by cgraph_varpool */
84 #include "coretypes.h"
87 #include "langhooks.h"
99 static void cgraph_node_remove_callers (struct cgraph_node
*node
);
100 static inline void cgraph_edge_remove_caller (struct cgraph_edge
*e
);
101 static inline void cgraph_edge_remove_callee (struct cgraph_edge
*e
);
103 /* Hash table used to convert declarations into nodes. */
104 static GTY((param_is (struct cgraph_node
))) htab_t cgraph_hash
;
106 /* The linked list of cgraph nodes. */
107 struct cgraph_node
*cgraph_nodes
;
109 /* Queue of cgraph nodes scheduled to be lowered. */
110 struct cgraph_node
*cgraph_nodes_queue
;
112 /* Number of nodes in existence. */
115 /* Maximal uid used in cgraph nodes. */
118 /* Set when whole unit has been analyzed so we can access global info. */
119 bool cgraph_global_info_ready
= false;
121 /* Hash table used to convert declarations into nodes. */
122 static GTY((param_is (struct cgraph_varpool_node
))) htab_t cgraph_varpool_hash
;
124 /* Queue of cgraph nodes scheduled to be lowered and output. */
125 struct cgraph_varpool_node
*cgraph_varpool_nodes_queue
;
127 /* The linked list of cgraph varpool nodes. */
128 static GTY(()) struct cgraph_varpool_node
*cgraph_varpool_nodes
;
130 static hashval_t
hash_node (const void *);
131 static int eq_node (const void *, const void *);
133 /* Returns a hash code for P. */
136 hash_node (const void *p
)
138 const struct cgraph_node
*n
= p
;
139 return (hashval_t
) DECL_UID (n
->decl
);
142 /* Returns nonzero if P1 and P2 are equal. */
145 eq_node (const void *p1
, const void *p2
)
147 const struct cgraph_node
*n1
= p1
, *n2
= p2
;
148 return DECL_UID (n1
->decl
) == DECL_UID (n2
->decl
);
151 /* Allocate new callgraph node and insert it into basic data structures. */
152 static struct cgraph_node
*
153 cgraph_create_node (void)
155 struct cgraph_node
*node
;
157 node
= ggc_alloc_cleared (sizeof (*node
));
158 node
->next
= cgraph_nodes
;
159 node
->uid
= cgraph_max_uid
++;
161 cgraph_nodes
->previous
= node
;
162 node
->previous
= NULL
;
168 /* Return cgraph node assigned to DECL. Create new one when needed. */
170 cgraph_node (tree decl
)
172 struct cgraph_node key
, *node
, **slot
;
174 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
177 cgraph_hash
= htab_create_ggc (10, hash_node
, eq_node
, NULL
);
181 slot
= (struct cgraph_node
**) htab_find_slot (cgraph_hash
, &key
, INSERT
);
186 node
= cgraph_create_node ();
189 if (DECL_CONTEXT (decl
) && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
191 node
->origin
= cgraph_node (DECL_CONTEXT (decl
));
192 node
->next_nested
= node
->origin
->nested
;
193 node
->origin
->nested
= node
;
198 /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */
201 decl_assembler_name_equal (tree decl
, tree asmname
)
203 tree decl_asmname
= DECL_ASSEMBLER_NAME (decl
);
205 if (decl_asmname
== asmname
)
208 /* If the target assembler name was set by the user, things are trickier.
209 We have a leading '*' to begin with. After that, it's arguable what
210 is the correct thing to do with -fleading-underscore. Arguably, we've
211 historically been doing the wrong thing in assemble_alias by always
212 printing the leading underscore. Since we're not changing that, make
213 sure user_label_prefix follows the '*' before matching. */
214 if (IDENTIFIER_POINTER (decl_asmname
)[0] == '*')
216 const char *decl_str
= IDENTIFIER_POINTER (decl_asmname
) + 1;
217 size_t ulp_len
= strlen (user_label_prefix
);
221 else if (strncmp (decl_str
, user_label_prefix
, ulp_len
) == 0)
226 return strcmp (decl_str
, IDENTIFIER_POINTER (asmname
)) == 0;
233 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
234 Return NULL if there's no such node. */
237 cgraph_node_for_asm (tree asmname
)
239 struct cgraph_node
*node
;
241 for (node
= cgraph_nodes
; node
; node
= node
->next
)
242 if (decl_assembler_name_equal (node
->decl
, asmname
))
248 /* Return callgraph edge representing CALL_EXPR. */
250 cgraph_edge (struct cgraph_node
*node
, tree call_expr
)
252 struct cgraph_edge
*e
;
254 /* This loop may turn out to be performance problem. In such case adding
255 hashtables into call nodes with very many edges is probably best
256 solution. It is not good idea to add pointer into CALL_EXPR itself
257 because we want to make possible having multiple cgraph nodes representing
258 different clones of the same body before the body is actually cloned. */
259 for (e
= node
->callees
; e
; e
= e
->next_callee
)
260 if (e
->call_expr
== call_expr
)
265 /* Create edge from CALLER to CALLEE in the cgraph. */
268 cgraph_create_edge (struct cgraph_node
*caller
, struct cgraph_node
*callee
,
271 struct cgraph_edge
*edge
= ggc_alloc (sizeof (struct cgraph_edge
));
272 #ifdef ENABLE_CHECKING
273 struct cgraph_edge
*e
;
275 for (e
= caller
->callees
; e
; e
= e
->next_callee
)
276 gcc_assert (e
->call_expr
!= call_expr
);
279 gcc_assert (TREE_CODE (call_expr
) == CALL_EXPR
);
281 if (!DECL_SAVED_TREE (callee
->decl
))
282 edge
->inline_failed
= N_("function body not available");
283 else if (callee
->local
.redefined_extern_inline
)
284 edge
->inline_failed
= N_("redefined extern inline functions are not "
285 "considered for inlining");
286 else if (callee
->local
.inlinable
)
287 edge
->inline_failed
= N_("function not considered for inlining");
289 edge
->inline_failed
= N_("function not inlinable");
293 edge
->caller
= caller
;
294 edge
->callee
= callee
;
295 edge
->call_expr
= call_expr
;
296 edge
->prev_caller
= NULL
;
297 edge
->next_caller
= callee
->callers
;
299 callee
->callers
->prev_caller
= edge
;
300 edge
->prev_callee
= NULL
;
301 edge
->next_callee
= caller
->callees
;
303 caller
->callees
->prev_callee
= edge
;
304 caller
->callees
= edge
;
305 callee
->callers
= edge
;
309 /* Remove the edge E from the list of the callers of the callee. */
312 cgraph_edge_remove_callee (struct cgraph_edge
*e
)
315 e
->prev_caller
->next_caller
= e
->next_caller
;
317 e
->next_caller
->prev_caller
= e
->prev_caller
;
319 e
->callee
->callers
= e
->next_caller
;
322 /* Remove the edge E from the list of the callees of the caller. */
325 cgraph_edge_remove_caller (struct cgraph_edge
*e
)
328 e
->prev_callee
->next_callee
= e
->next_callee
;
330 e
->next_callee
->prev_callee
= e
->prev_callee
;
332 e
->caller
->callees
= e
->next_callee
;
335 /* Remove the edge E in the cgraph. */
338 cgraph_remove_edge (struct cgraph_edge
*e
)
340 /* Remove from callers list of the callee. */
341 cgraph_edge_remove_callee (e
);
343 /* Remove from callees list of the callers. */
344 cgraph_edge_remove_caller (e
);
347 /* Redirect callee of E to N. The function does not update underlying
351 cgraph_redirect_edge_callee (struct cgraph_edge
*e
, struct cgraph_node
*n
)
353 /* Remove from callers list of the current callee. */
354 cgraph_edge_remove_callee (e
);
356 /* Insert to callers list of the new callee. */
357 e
->prev_caller
= NULL
;
359 n
->callers
->prev_caller
= e
;
360 e
->next_caller
= n
->callers
;
365 /* Remove all callees from the node. */
368 cgraph_node_remove_callees (struct cgraph_node
*node
)
370 struct cgraph_edge
*e
;
372 /* It is sufficient to remove the edges from the lists of callers of
373 the callees. The callee list of the node can be zapped with one
375 for (e
= node
->callees
; e
; e
= e
->next_callee
)
376 cgraph_edge_remove_callee (e
);
377 node
->callees
= NULL
;
380 /* Remove all callers from the node. */
383 cgraph_node_remove_callers (struct cgraph_node
*node
)
385 struct cgraph_edge
*e
;
387 /* It is sufficient to remove the edges from the lists of callees of
388 the callers. The caller list of the node can be zapped with one
390 for (e
= node
->callers
; e
; e
= e
->next_caller
)
391 cgraph_edge_remove_caller (e
);
392 node
->callers
= NULL
;
395 /* Remove the node from cgraph. */
398 cgraph_remove_node (struct cgraph_node
*node
)
403 cgraph_node_remove_callers (node
);
404 cgraph_node_remove_callees (node
);
406 cgraph_remove_node (node
->nested
);
409 struct cgraph_node
**node2
= &node
->origin
->nested
;
411 while (*node2
!= node
)
412 node2
= &(*node2
)->next_nested
;
413 *node2
= node
->next_nested
;
416 node
->previous
->next
= node
->next
;
418 cgraph_nodes
= node
->next
;
420 node
->next
->previous
= node
->previous
;
421 slot
= htab_find_slot (cgraph_hash
, node
, NO_INSERT
);
424 if (node
->next_clone
)
425 *slot
= node
->next_clone
;
428 htab_clear_slot (cgraph_hash
, slot
);
429 if (!dump_enabled_p (TDI_tree_all
))
431 DECL_SAVED_TREE (node
->decl
) = NULL
;
432 DECL_STRUCT_FUNCTION (node
->decl
) = NULL
;
439 struct cgraph_node
*n
;
441 for (n
= *slot
; n
->next_clone
!= node
; n
= n
->next_clone
)
443 n
->next_clone
= node
->next_clone
;
446 /* Work out whether we still need a function body (either there is inline
447 clone or there is out of line function whose body is not written). */
448 if (check_dead
&& flag_unit_at_a_time
)
450 struct cgraph_node
*n
;
452 for (n
= *slot
; n
; n
= n
->next_clone
)
453 if (n
->global
.inlined_to
454 || (!n
->global
.inlined_to
455 && !TREE_ASM_WRITTEN (n
->decl
) && !DECL_EXTERNAL (n
->decl
)))
457 if (!n
&& !dump_enabled_p (TDI_tree_all
))
459 DECL_SAVED_TREE (node
->decl
) = NULL
;
460 DECL_STRUCT_FUNCTION (node
->decl
) = NULL
;
461 DECL_INITIAL (node
->decl
) = error_mark_node
;
465 /* Do not free the structure itself so the walk over chain can continue. */
468 /* Notify finalize_compilation_unit that given node is reachable. */
471 cgraph_mark_reachable_node (struct cgraph_node
*node
)
473 if (!node
->reachable
&& node
->local
.finalized
)
475 notice_global_symbol (node
->decl
);
478 node
->next_needed
= cgraph_nodes_queue
;
479 cgraph_nodes_queue
= node
;
483 /* Likewise indicate that a node is needed, i.e. reachable via some
487 cgraph_mark_needed_node (struct cgraph_node
*node
)
490 cgraph_mark_reachable_node (node
);
493 /* Return local info for the compiled function. */
495 struct cgraph_local_info
*
496 cgraph_local_info (tree decl
)
498 struct cgraph_node
*node
;
500 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
501 node
= cgraph_node (decl
);
505 /* Return local info for the compiled function. */
507 struct cgraph_global_info
*
508 cgraph_global_info (tree decl
)
510 struct cgraph_node
*node
;
512 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
&& cgraph_global_info_ready
);
513 node
= cgraph_node (decl
);
514 return &node
->global
;
517 /* Return local info for the compiled function. */
519 struct cgraph_rtl_info
*
520 cgraph_rtl_info (tree decl
)
522 struct cgraph_node
*node
;
524 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
525 node
= cgraph_node (decl
);
526 if (decl
!= current_function_decl
527 && !TREE_ASM_WRITTEN (node
->decl
))
532 /* Return name of the node used in debug output. */
534 cgraph_node_name (struct cgraph_node
*node
)
536 return lang_hooks
.decl_printable_name (node
->decl
, 2);
539 /* Dump given cgraph node. */
541 dump_cgraph_node (FILE *f
, struct cgraph_node
*node
)
543 struct cgraph_edge
*edge
;
544 fprintf (f
, "%s/%i:", cgraph_node_name (node
), node
->uid
);
545 if (node
->global
.inlined_to
)
546 fprintf (f
, " (inline copy in %s/%i)",
547 cgraph_node_name (node
->global
.inlined_to
),
548 node
->global
.inlined_to
->uid
);
549 if (node
->local
.self_insns
)
550 fprintf (f
, " %i insns", node
->local
.self_insns
);
551 if (node
->global
.insns
&& node
->global
.insns
!= node
->local
.self_insns
)
552 fprintf (f
, " (%i after inlining)", node
->global
.insns
);
554 fprintf (f
, " nested in: %s", cgraph_node_name (node
->origin
));
556 fprintf (f
, " needed");
557 else if (node
->reachable
)
558 fprintf (f
, " reachable");
559 if (DECL_SAVED_TREE (node
->decl
))
560 fprintf (f
, " tree");
562 fprintf (f
, " output");
563 if (node
->local
.local
)
564 fprintf (f
, " local");
565 if (node
->local
.disregard_inline_limits
)
566 fprintf (f
, " always_inline");
567 else if (node
->local
.inlinable
)
568 fprintf (f
, " inlinable");
569 if (TREE_ASM_WRITTEN (node
->decl
))
570 fprintf (f
, " asm_written");
572 fprintf (f
, "\n called by: ");
573 for (edge
= node
->callers
; edge
; edge
= edge
->next_caller
)
575 fprintf (f
, "%s/%i ", cgraph_node_name (edge
->caller
),
577 if (!edge
->inline_failed
)
578 fprintf(f
, "(inlined) ");
581 fprintf (f
, "\n calls: ");
582 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
584 fprintf (f
, "%s/%i ", cgraph_node_name (edge
->callee
),
586 if (!edge
->inline_failed
)
587 fprintf(f
, "(inlined) ");
592 /* Dump the callgraph. */
595 dump_cgraph (FILE *f
)
597 struct cgraph_node
*node
;
599 fprintf (f
, "callgraph:\n\n");
600 for (node
= cgraph_nodes
; node
; node
= node
->next
)
601 dump_cgraph_node (f
, node
);
604 /* Returns a hash code for P. */
607 hash_varpool_node (const void *p
)
609 const struct cgraph_varpool_node
*n
= p
;
610 return (hashval_t
) DECL_UID (n
->decl
);
613 /* Returns nonzero if P1 and P2 are equal. */
616 eq_varpool_node (const void *p1
, const void *p2
)
618 const struct cgraph_varpool_node
*n1
= p1
, *n2
= p2
;
619 return DECL_UID (n1
->decl
) == DECL_UID (n2
->decl
);
622 /* Return cgraph_varpool node assigned to DECL. Create new one when needed. */
623 struct cgraph_varpool_node
*
624 cgraph_varpool_node (tree decl
)
626 struct cgraph_varpool_node key
, *node
, **slot
;
628 gcc_assert (DECL_P (decl
) && TREE_CODE (decl
) != FUNCTION_DECL
);
630 if (!cgraph_varpool_hash
)
631 cgraph_varpool_hash
= htab_create_ggc (10, hash_varpool_node
,
632 eq_varpool_node
, NULL
);
634 slot
= (struct cgraph_varpool_node
**)
635 htab_find_slot (cgraph_varpool_hash
, &key
, INSERT
);
638 node
= ggc_alloc_cleared (sizeof (*node
));
640 node
->next
= cgraph_varpool_nodes
;
641 cgraph_varpool_nodes
= node
;
646 struct cgraph_varpool_node
*
647 cgraph_varpool_node_for_asm (tree asmname
)
649 struct cgraph_varpool_node
*node
;
651 for (node
= cgraph_varpool_nodes
; node
; node
= node
->next
)
652 if (decl_assembler_name_equal (node
->decl
, asmname
))
658 /* Set the DECL_ASSEMBLER_NAME and update cgraph hashtables. */
660 change_decl_assembler_name (tree decl
, tree name
)
662 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
664 SET_DECL_ASSEMBLER_NAME (decl
, name
);
667 if (name
== DECL_ASSEMBLER_NAME (decl
))
670 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
))
671 && DECL_RTL_SET_P (decl
))
672 warning ("%D renamed after being referenced in assembly", decl
);
674 SET_DECL_ASSEMBLER_NAME (decl
, name
);
677 /* Notify finalize_compilation_unit that given node is reachable
680 cgraph_varpool_mark_needed_node (struct cgraph_varpool_node
*node
)
682 if (!node
->needed
&& node
->finalized
)
684 node
->next_needed
= cgraph_varpool_nodes_queue
;
685 cgraph_varpool_nodes_queue
= node
;
686 notice_global_symbol (node
->decl
);
692 cgraph_varpool_finalize_decl (tree decl
)
694 struct cgraph_varpool_node
*node
= cgraph_varpool_node (decl
);
696 /* The first declaration of a variable that comes through this function
697 decides whether it is global (in C, has external linkage)
698 or local (in C, has internal linkage). So do nothing more
699 if this function has already run. */
704 node
->next_needed
= cgraph_varpool_nodes_queue
;
705 cgraph_varpool_nodes_queue
= node
;
706 notice_global_symbol (decl
);
708 node
->finalized
= true;
710 if (/* Externally visible variables must be output. The exception are
711 COMDAT functions that must be output only when they are needed. */
712 (TREE_PUBLIC (decl
) && !DECL_COMDAT (decl
))
713 /* Function whose name is output to the assembler file must be produced.
714 It is possible to assemble the name later after finalizing the function
715 and the fact is noticed in assemble_name then. */
716 || (DECL_ASSEMBLER_NAME_SET_P (decl
)
717 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
))))
719 cgraph_varpool_mark_needed_node (node
);
724 cgraph_varpool_assemble_pending_decls (void)
726 bool changed
= false;
728 while (cgraph_varpool_nodes_queue
)
730 tree decl
= cgraph_varpool_nodes_queue
->decl
;
731 struct cgraph_varpool_node
*node
= cgraph_varpool_nodes_queue
;
733 cgraph_varpool_nodes_queue
= cgraph_varpool_nodes_queue
->next_needed
;
734 if (!TREE_ASM_WRITTEN (decl
))
736 assemble_variable (decl
, 0, 1, 0);
739 node
->next_needed
= NULL
;
744 /* Return true when the DECL can possibly be inlined. */
746 cgraph_function_possibly_inlined_p (tree decl
)
748 if (!cgraph_global_info_ready
)
749 return (DECL_INLINE (decl
) && !flag_really_no_inline
);
750 return DECL_POSSIBLY_INLINED (decl
);
753 /* Create clone of E in the node N represented by CALL_EXPR the callgraph. */
755 cgraph_clone_edge (struct cgraph_edge
*e
, struct cgraph_node
*n
, tree call_expr
)
757 struct cgraph_edge
*new = cgraph_create_edge (n
, e
->callee
, call_expr
);
759 new->inline_failed
= e
->inline_failed
;
763 /* Create node representing clone of N. */
765 cgraph_clone_node (struct cgraph_node
*n
)
767 struct cgraph_node
*new = cgraph_create_node ();
768 struct cgraph_edge
*e
;
771 new->origin
= n
->origin
;
774 new->next_nested
= new->origin
->nested
;
775 new->origin
->nested
= new;
777 new->analyzed
= n
->analyzed
;
778 new->local
= n
->local
;
779 new->global
= n
->global
;
782 for (e
= n
->callees
;e
; e
=e
->next_callee
)
783 cgraph_clone_edge (e
, new, e
->call_expr
);
785 new->next_clone
= n
->next_clone
;
791 /* NODE is no longer nested function; update cgraph accordingly. */
793 cgraph_unnest_node (struct cgraph_node
*node
)
795 struct cgraph_node
**node2
= &node
->origin
->nested
;
796 gcc_assert (node
->origin
);
798 while (*node2
!= node
)
799 node2
= &(*node2
)->next_nested
;
800 *node2
= node
->next_nested
;
803 #include "gt-cgraph.h"