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"
84 #include "tree-gimple.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
;
95 /* The linked list of cgraph nodes. */
96 struct cgraph_node
*cgraph_nodes
;
98 /* Queue of cgraph nodes scheduled to be lowered. */
99 struct cgraph_node
*cgraph_nodes_queue
;
101 /* Queue of cgraph nodes scheduled to be added into cgraph. This is a
102 secondary queue used during optimization to accommodate passes that
103 may generate new functions that need to be optimized and expanded. */
104 struct cgraph_node
*cgraph_new_nodes
;
106 /* Number of nodes in existence. */
109 /* Maximal uid used in cgraph nodes. */
112 /* Maximal pid used for profiling */
115 /* Set when whole unit has been analyzed so we can access global info. */
116 bool cgraph_global_info_ready
= false;
118 /* What state callgraph is in right now. */
119 enum cgraph_state cgraph_state
= CGRAPH_STATE_CONSTRUCTION
;
121 /* Set when the cgraph is fully build and the basic flags are computed. */
122 bool cgraph_function_flags_ready
= false;
124 /* Linked list of cgraph asm nodes. */
125 struct cgraph_asm_node
*cgraph_asm_nodes
;
127 /* Last node in cgraph_asm_nodes. */
128 static GTY(()) struct cgraph_asm_node
*cgraph_asm_last_node
;
130 /* The order index of the next cgraph node to be created. This is
131 used so that we can sort the cgraph nodes in order by when we saw
132 them, to support -fno-toplevel-reorder. */
135 static hashval_t
hash_node (const void *);
136 static int eq_node (const void *, const void *);
138 /* Returns a hash code for P. */
141 hash_node (const void *p
)
143 const struct cgraph_node
*n
= (const struct cgraph_node
*) p
;
144 return (hashval_t
) DECL_UID (n
->decl
);
147 /* Returns nonzero if P1 and P2 are equal. */
150 eq_node (const void *p1
, const void *p2
)
152 const struct cgraph_node
*n1
= (const struct cgraph_node
*) p1
;
153 const struct cgraph_node
*n2
= (const struct cgraph_node
*) p2
;
154 return DECL_UID (n1
->decl
) == DECL_UID (n2
->decl
);
157 /* Allocate new callgraph node and insert it into basic data structures. */
159 static struct cgraph_node
*
160 cgraph_create_node (void)
162 struct cgraph_node
*node
;
164 node
= GGC_CNEW (struct cgraph_node
);
165 node
->next
= cgraph_nodes
;
166 node
->uid
= cgraph_max_uid
++;
168 node
->order
= cgraph_order
++;
170 cgraph_nodes
->previous
= node
;
171 node
->previous
= NULL
;
172 node
->global
.estimated_growth
= INT_MIN
;
175 COPY_HARD_REG_SET (node
->function_used_regs
, call_used_reg_set
);
179 /* Return cgraph node assigned to DECL. Create new one when needed. */
182 cgraph_node (tree decl
)
184 struct cgraph_node key
, *node
, **slot
;
186 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
189 cgraph_hash
= htab_create_ggc (10, hash_node
, eq_node
, NULL
);
193 slot
= (struct cgraph_node
**) htab_find_slot (cgraph_hash
, &key
, INSERT
);
198 if (!node
->master_clone
)
199 node
->master_clone
= node
;
203 node
= cgraph_create_node ();
206 if (DECL_CONTEXT (decl
) && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
208 node
->origin
= cgraph_node (DECL_CONTEXT (decl
));
209 node
->next_nested
= node
->origin
->nested
;
210 node
->origin
->nested
= node
;
211 node
->master_clone
= node
;
216 /* Insert already constructed node into hashtable. */
219 cgraph_insert_node_to_hashtable (struct cgraph_node
*node
)
221 struct cgraph_node
**slot
;
223 slot
= (struct cgraph_node
**) htab_find_slot (cgraph_hash
, node
, INSERT
);
230 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
231 Return NULL if there's no such node. */
234 cgraph_node_for_asm (tree asmname
)
236 struct cgraph_node
*node
;
238 for (node
= cgraph_nodes
; node
; node
= node
->next
)
239 if (decl_assembler_name_equal (node
->decl
, asmname
))
245 /* Returns a hash value for X (which really is a die_struct). */
248 edge_hash (const void *x
)
250 return htab_hash_pointer (((const struct cgraph_edge
*) x
)->call_stmt
);
253 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
256 edge_eq (const void *x
, const void *y
)
258 return ((const struct cgraph_edge
*) x
)->call_stmt
== y
;
261 /* Return callgraph edge representing CALL_EXPR statement. */
263 cgraph_edge (struct cgraph_node
*node
, tree call_stmt
)
265 struct cgraph_edge
*e
, *e2
;
268 if (node
->call_site_hash
)
269 return htab_find_with_hash (node
->call_site_hash
, call_stmt
,
270 htab_hash_pointer (call_stmt
));
272 /* This loop may turn out to be performance problem. In such case adding
273 hashtables into call nodes with very many edges is probably best
274 solution. It is not good idea to add pointer into CALL_EXPR itself
275 because we want to make possible having multiple cgraph nodes representing
276 different clones of the same body before the body is actually cloned. */
277 for (e
= node
->callees
; e
; e
= e
->next_callee
)
279 if (e
->call_stmt
== call_stmt
)
285 node
->call_site_hash
= htab_create_ggc (120, edge_hash
, edge_eq
, NULL
);
286 for (e2
= node
->callees
; e2
; e2
= e2
->next_callee
)
289 slot
= htab_find_slot_with_hash (node
->call_site_hash
,
291 htab_hash_pointer (e2
->call_stmt
),
300 /* Change call_smtt of edge E to NEW_STMT. */
303 cgraph_set_call_stmt (struct cgraph_edge
*e
, tree new_stmt
)
305 if (e
->caller
->call_site_hash
)
307 htab_remove_elt_with_hash (e
->caller
->call_site_hash
,
309 htab_hash_pointer (e
->call_stmt
));
311 e
->call_stmt
= new_stmt
;
312 if (e
->caller
->call_site_hash
)
315 slot
= htab_find_slot_with_hash (e
->caller
->call_site_hash
,
318 (e
->call_stmt
), INSERT
);
324 /* Create edge from CALLER to CALLEE in the cgraph. */
327 cgraph_create_edge (struct cgraph_node
*caller
, struct cgraph_node
*callee
,
328 tree call_stmt
, gcov_type count
, int freq
, int nest
)
330 struct cgraph_edge
*edge
= GGC_NEW (struct cgraph_edge
);
331 #ifdef ENABLE_CHECKING
332 struct cgraph_edge
*e
;
334 for (e
= caller
->callees
; e
; e
= e
->next_callee
)
335 gcc_assert (e
->call_stmt
!= call_stmt
);
338 gcc_assert (get_call_expr_in (call_stmt
));
340 if (!DECL_SAVED_TREE (callee
->decl
))
341 edge
->inline_failed
= N_("function body not available");
342 else if (callee
->local
.redefined_extern_inline
)
343 edge
->inline_failed
= N_("redefined extern inline functions are not "
344 "considered for inlining");
345 else if (callee
->local
.inlinable
)
346 edge
->inline_failed
= N_("function not considered for inlining");
348 edge
->inline_failed
= N_("function not inlinable");
352 edge
->caller
= caller
;
353 edge
->callee
= callee
;
354 edge
->call_stmt
= call_stmt
;
355 edge
->prev_caller
= NULL
;
356 edge
->next_caller
= callee
->callers
;
358 callee
->callers
->prev_caller
= edge
;
359 edge
->prev_callee
= NULL
;
360 edge
->next_callee
= caller
->callees
;
362 caller
->callees
->prev_callee
= edge
;
363 caller
->callees
= edge
;
364 callee
->callers
= edge
;
366 gcc_assert (count
>= 0);
367 edge
->frequency
= freq
;
368 gcc_assert (freq
>= 0);
369 gcc_assert (freq
<= CGRAPH_FREQ_MAX
);
370 edge
->loop_nest
= nest
;
371 if (caller
->call_site_hash
)
374 slot
= htab_find_slot_with_hash (caller
->call_site_hash
,
385 /* Remove the edge E from the list of the callers of the callee. */
388 cgraph_edge_remove_callee (struct cgraph_edge
*e
)
391 e
->prev_caller
->next_caller
= e
->next_caller
;
393 e
->next_caller
->prev_caller
= e
->prev_caller
;
395 e
->callee
->callers
= e
->next_caller
;
398 /* Remove the edge E from the list of the callees of the caller. */
401 cgraph_edge_remove_caller (struct cgraph_edge
*e
)
404 e
->prev_callee
->next_callee
= e
->next_callee
;
406 e
->next_callee
->prev_callee
= e
->prev_callee
;
408 e
->caller
->callees
= e
->next_callee
;
409 if (e
->caller
->call_site_hash
)
410 htab_remove_elt_with_hash (e
->caller
->call_site_hash
,
412 htab_hash_pointer (e
->call_stmt
));
415 /* Remove the edge E in the cgraph. */
418 cgraph_remove_edge (struct cgraph_edge
*e
)
420 /* Remove from callers list of the callee. */
421 cgraph_edge_remove_callee (e
);
423 /* Remove from callees list of the callers. */
424 cgraph_edge_remove_caller (e
);
427 /* Redirect callee of E to N. The function does not update underlying
431 cgraph_redirect_edge_callee (struct cgraph_edge
*e
, struct cgraph_node
*n
)
433 /* Remove from callers list of the current callee. */
434 cgraph_edge_remove_callee (e
);
436 /* Insert to callers list of the new callee. */
437 e
->prev_caller
= NULL
;
439 n
->callers
->prev_caller
= e
;
440 e
->next_caller
= n
->callers
;
445 /* Update or remove corresponding cgraph edge if a call OLD_CALL
446 in OLD_STMT changed into NEW_STMT. */
449 cgraph_update_edges_for_call_stmt (tree old_stmt
, tree old_call
,
452 tree new_call
= get_call_expr_in (new_stmt
);
453 struct cgraph_node
*node
= cgraph_node (cfun
->decl
);
455 if (old_call
!= new_call
)
457 struct cgraph_edge
*e
= cgraph_edge (node
, old_stmt
);
458 struct cgraph_edge
*ne
= NULL
;
463 gcov_type count
= e
->count
;
464 int frequency
= e
->frequency
;
465 int loop_nest
= e
->loop_nest
;
467 cgraph_remove_edge (e
);
470 new_decl
= get_callee_fndecl (new_call
);
473 ne
= cgraph_create_edge (node
, cgraph_node (new_decl
),
474 new_stmt
, count
, frequency
,
476 gcc_assert (ne
->inline_failed
);
481 else if (old_stmt
!= new_stmt
)
483 struct cgraph_edge
*e
= cgraph_edge (node
, old_stmt
);
486 cgraph_set_call_stmt (e
, new_stmt
);
490 /* Remove all callees from the node. */
493 cgraph_node_remove_callees (struct cgraph_node
*node
)
495 struct cgraph_edge
*e
;
497 /* It is sufficient to remove the edges from the lists of callers of
498 the callees. The callee list of the node can be zapped with one
500 for (e
= node
->callees
; e
; e
= e
->next_callee
)
501 cgraph_edge_remove_callee (e
);
502 node
->callees
= NULL
;
503 if (node
->call_site_hash
)
505 htab_delete (node
->call_site_hash
);
506 node
->call_site_hash
= NULL
;
510 /* Remove all callers from the node. */
513 cgraph_node_remove_callers (struct cgraph_node
*node
)
515 struct cgraph_edge
*e
;
517 /* It is sufficient to remove the edges from the lists of callees of
518 the callers. The caller list of the node can be zapped with one
520 for (e
= node
->callers
; e
; e
= e
->next_caller
)
521 cgraph_edge_remove_caller (e
);
522 node
->callers
= NULL
;
525 /* Release memory used to represent body of function NODE. */
528 cgraph_release_function_body (struct cgraph_node
*node
)
530 if (DECL_STRUCT_FUNCTION (node
->decl
)
531 && DECL_STRUCT_FUNCTION (node
->decl
)->gimple_df
)
533 tree old_decl
= current_function_decl
;
534 push_cfun (DECL_STRUCT_FUNCTION (node
->decl
));
535 current_function_decl
= node
->decl
;
537 delete_tree_cfg_annotations ();
539 current_function_decl
= old_decl
;
542 DECL_SAVED_TREE (node
->decl
) = NULL
;
543 DECL_STRUCT_FUNCTION (node
->decl
) = NULL
;
544 DECL_INITIAL (node
->decl
) = error_mark_node
;
547 /* Remove the node from cgraph. */
550 cgraph_remove_node (struct cgraph_node
*node
)
553 bool kill_body
= false;
555 cgraph_node_remove_callers (node
);
556 cgraph_node_remove_callees (node
);
557 /* Incremental inlining access removed nodes stored in the postorder list.
559 node
->needed
= node
->reachable
= false;
561 cgraph_remove_node (node
->nested
);
564 struct cgraph_node
**node2
= &node
->origin
->nested
;
566 while (*node2
!= node
)
567 node2
= &(*node2
)->next_nested
;
568 *node2
= node
->next_nested
;
571 node
->previous
->next
= node
->next
;
573 cgraph_nodes
= node
->next
;
575 node
->next
->previous
= node
->previous
;
577 node
->previous
= NULL
;
578 slot
= htab_find_slot (cgraph_hash
, node
, NO_INSERT
);
581 if (node
->next_clone
)
583 struct cgraph_node
*new_node
= node
->next_clone
;
584 struct cgraph_node
*n
;
586 /* Make the next clone be the master clone */
587 for (n
= new_node
; n
; n
= n
->next_clone
)
588 n
->master_clone
= new_node
;
591 node
->next_clone
->prev_clone
= NULL
;
595 htab_clear_slot (cgraph_hash
, slot
);
601 node
->prev_clone
->next_clone
= node
->next_clone
;
602 if (node
->next_clone
)
603 node
->next_clone
->prev_clone
= node
->prev_clone
;
606 /* While all the clones are removed after being proceeded, the function
607 itself is kept in the cgraph even after it is compiled. Check whether
608 we are done with this body and reclaim it proactively if this is the case.
610 if (!kill_body
&& *slot
)
612 struct cgraph_node
*n
= (struct cgraph_node
*) *slot
;
613 if (!n
->next_clone
&& !n
->global
.inlined_to
614 && (cgraph_global_info_ready
615 && (TREE_ASM_WRITTEN (n
->decl
) || DECL_EXTERNAL (n
->decl
))))
619 if (kill_body
&& flag_unit_at_a_time
)
620 cgraph_release_function_body (node
);
622 if (node
->call_site_hash
)
624 htab_delete (node
->call_site_hash
);
625 node
->call_site_hash
= NULL
;
628 /* Do not free the structure itself so the walk over chain can continue. */
631 /* Notify finalize_compilation_unit that given node is reachable. */
634 cgraph_mark_reachable_node (struct cgraph_node
*node
)
636 if (!node
->reachable
&& node
->local
.finalized
)
638 notice_global_symbol (node
->decl
);
640 gcc_assert (!cgraph_global_info_ready
);
642 node
->next_needed
= cgraph_nodes_queue
;
643 cgraph_nodes_queue
= node
;
647 /* Likewise indicate that a node is needed, i.e. reachable via some
651 cgraph_mark_needed_node (struct cgraph_node
*node
)
654 cgraph_mark_reachable_node (node
);
657 /* Return local info for the compiled function. */
659 struct cgraph_local_info
*
660 cgraph_local_info (tree decl
)
662 struct cgraph_node
*node
;
664 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
665 node
= cgraph_node (decl
);
669 /* Return local info for the compiled function. */
671 struct cgraph_global_info
*
672 cgraph_global_info (tree decl
)
674 struct cgraph_node
*node
;
676 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
&& cgraph_global_info_ready
);
677 node
= cgraph_node (decl
);
678 return &node
->global
;
681 /* Return local info for the compiled function. */
683 struct cgraph_rtl_info
*
684 cgraph_rtl_info (tree decl
)
686 struct cgraph_node
*node
;
688 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
689 node
= cgraph_node (decl
);
690 if (decl
!= current_function_decl
691 && !TREE_ASM_WRITTEN (node
->decl
))
696 /* Return name of the node used in debug output. */
698 cgraph_node_name (struct cgraph_node
*node
)
700 return lang_hooks
.decl_printable_name (node
->decl
, 2);
703 /* Names used to print out the availability enum. */
704 const char * const cgraph_availability_names
[] =
705 {"unset", "not_available", "overwrittable", "available", "local"};
708 /* Dump call graph node NODE to file F. */
711 dump_cgraph_node (FILE *f
, struct cgraph_node
*node
)
713 struct cgraph_edge
*edge
;
714 fprintf (f
, "%s/%i(%i):", cgraph_node_name (node
), node
->uid
, node
->pid
);
715 if (node
->global
.inlined_to
)
716 fprintf (f
, " (inline copy in %s/%i)",
717 cgraph_node_name (node
->global
.inlined_to
),
718 node
->global
.inlined_to
->uid
);
719 if (cgraph_function_flags_ready
)
720 fprintf (f
, " availability:%s",
721 cgraph_availability_names
[cgraph_function_body_availability (node
)]);
722 if (node
->master_clone
&& node
->master_clone
->uid
!= node
->uid
)
723 fprintf (f
, "(%i)", node
->master_clone
->uid
);
725 fprintf (f
, " executed "HOST_WIDEST_INT_PRINT_DEC
"x",
726 (HOST_WIDEST_INT
)node
->count
);
727 if (node
->local
.inline_summary
.self_insns
)
728 fprintf (f
, " %i insns", node
->local
.inline_summary
.self_insns
);
729 if (node
->global
.insns
&& node
->global
.insns
730 != node
->local
.inline_summary
.self_insns
)
731 fprintf (f
, " (%i after inlining)", node
->global
.insns
);
732 if (node
->local
.inline_summary
.estimated_self_stack_size
)
733 fprintf (f
, " %i bytes stack usage", (int)node
->local
.inline_summary
.estimated_self_stack_size
);
734 if (node
->global
.estimated_stack_size
!= node
->local
.inline_summary
.estimated_self_stack_size
)
735 fprintf (f
, " %i bytes after inlining", (int)node
->global
.estimated_stack_size
);
737 fprintf (f
, " nested in: %s", cgraph_node_name (node
->origin
));
739 fprintf (f
, " needed");
740 else if (node
->reachable
)
741 fprintf (f
, " reachable");
742 if (DECL_SAVED_TREE (node
->decl
))
743 fprintf (f
, " tree");
745 fprintf (f
, " output");
746 if (node
->local
.local
)
747 fprintf (f
, " local");
748 if (node
->local
.externally_visible
)
749 fprintf (f
, " externally_visible");
750 if (node
->local
.finalized
)
751 fprintf (f
, " finalized");
752 if (node
->local
.disregard_inline_limits
)
753 fprintf (f
, " always_inline");
754 else if (node
->local
.inlinable
)
755 fprintf (f
, " inlinable");
756 if (node
->local
.redefined_extern_inline
)
757 fprintf (f
, " redefined_extern_inline");
758 if (TREE_ASM_WRITTEN (node
->decl
))
759 fprintf (f
, " asm_written");
761 fprintf (f
, "\n called by: ");
762 for (edge
= node
->callers
; edge
; edge
= edge
->next_caller
)
764 fprintf (f
, "%s/%i ", cgraph_node_name (edge
->caller
),
767 fprintf (f
, "("HOST_WIDEST_INT_PRINT_DEC
"x) ",
768 (HOST_WIDEST_INT
)edge
->count
);
770 fprintf (f
, "(%.2f per call) ",
771 edge
->frequency
/ (double)CGRAPH_FREQ_BASE
);
772 if (!edge
->inline_failed
)
773 fprintf(f
, "(inlined) ");
776 fprintf (f
, "\n calls: ");
777 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
779 fprintf (f
, "%s/%i ", cgraph_node_name (edge
->callee
),
781 if (!edge
->inline_failed
)
782 fprintf(f
, "(inlined) ");
784 fprintf (f
, "("HOST_WIDEST_INT_PRINT_DEC
"x) ",
785 (HOST_WIDEST_INT
)edge
->count
);
787 fprintf (f
, "(%.2f per call) ",
788 edge
->frequency
/ (double)CGRAPH_FREQ_BASE
);
790 fprintf (f
, "(nested in %i loops) ", edge
->loop_nest
);
796 /* Dump call graph node NODE to stderr. */
799 debug_cgraph_node (struct cgraph_node
*node
)
801 dump_cgraph_node (stderr
, node
);
805 /* Dump the callgraph to file F. */
808 dump_cgraph (FILE *f
)
810 struct cgraph_node
*node
;
812 fprintf (f
, "callgraph:\n\n");
813 for (node
= cgraph_nodes
; node
; node
= node
->next
)
814 dump_cgraph_node (f
, node
);
818 /* Dump the call graph to stderr. */
823 dump_cgraph (stderr
);
827 /* Set the DECL_ASSEMBLER_NAME and update cgraph hashtables. */
830 change_decl_assembler_name (tree decl
, tree name
)
832 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
834 SET_DECL_ASSEMBLER_NAME (decl
, name
);
837 if (name
== DECL_ASSEMBLER_NAME (decl
))
840 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
))
841 && DECL_RTL_SET_P (decl
))
842 warning (0, "%D renamed after being referenced in assembly", decl
);
844 SET_DECL_ASSEMBLER_NAME (decl
, name
);
847 /* Add a top-level asm statement to the list. */
849 struct cgraph_asm_node
*
850 cgraph_add_asm_node (tree asm_str
)
852 struct cgraph_asm_node
*node
;
854 node
= GGC_CNEW (struct cgraph_asm_node
);
855 node
->asm_str
= asm_str
;
856 node
->order
= cgraph_order
++;
858 if (cgraph_asm_nodes
== NULL
)
859 cgraph_asm_nodes
= node
;
861 cgraph_asm_last_node
->next
= node
;
862 cgraph_asm_last_node
= node
;
866 /* Return true when the DECL can possibly be inlined. */
868 cgraph_function_possibly_inlined_p (tree decl
)
870 if (!cgraph_global_info_ready
)
871 return (DECL_INLINE (decl
) && !flag_really_no_inline
);
872 return DECL_POSSIBLY_INLINED (decl
);
875 /* Create clone of E in the node N represented by CALL_EXPR the callgraph. */
877 cgraph_clone_edge (struct cgraph_edge
*e
, struct cgraph_node
*n
,
878 tree call_stmt
, gcov_type count_scale
, int freq_scale
,
879 int loop_nest
, bool update_original
)
881 struct cgraph_edge
*new;
882 gcov_type count
= e
->count
* count_scale
/ REG_BR_PROB_BASE
;
883 gcov_type freq
= e
->frequency
* (gcov_type
) freq_scale
/ CGRAPH_FREQ_BASE
;
885 if (freq
> CGRAPH_FREQ_MAX
)
886 freq
= CGRAPH_FREQ_MAX
;
887 new = cgraph_create_edge (n
, e
->callee
, call_stmt
, count
, freq
,
888 e
->loop_nest
+ loop_nest
);
890 new->inline_failed
= e
->inline_failed
;
893 e
->count
-= new->count
;
900 /* Create node representing clone of N executed COUNT times. Decrease
901 the execution counts from original node too.
903 When UPDATE_ORIGINAL is true, the counts are subtracted from the original
904 function's profile to reflect the fact that part of execution is handled
907 cgraph_clone_node (struct cgraph_node
*n
, gcov_type count
, int freq
, int loop_nest
,
908 bool update_original
)
910 struct cgraph_node
*new = cgraph_create_node ();
911 struct cgraph_edge
*e
;
912 gcov_type count_scale
;
915 new->origin
= n
->origin
;
918 new->next_nested
= new->origin
->nested
;
919 new->origin
->nested
= new;
921 new->analyzed
= n
->analyzed
;
922 new->local
= n
->local
;
923 new->global
= n
->global
;
925 new->master_clone
= n
->master_clone
;
928 count_scale
= new->count
* REG_BR_PROB_BASE
/ n
->count
;
938 for (e
= n
->callees
;e
; e
=e
->next_callee
)
939 cgraph_clone_edge (e
, new, e
->call_stmt
, count_scale
, freq
, loop_nest
,
942 new->next_clone
= n
->next_clone
;
946 new->next_clone
->prev_clone
= new;
951 /* Return true if N is an master_clone, (see cgraph_master_clone). */
954 cgraph_is_master_clone (struct cgraph_node
*n
)
956 return (n
== cgraph_master_clone (n
));
960 cgraph_master_clone (struct cgraph_node
*n
)
962 enum availability avail
= cgraph_function_body_availability (n
);
964 if (avail
== AVAIL_NOT_AVAILABLE
|| avail
== AVAIL_OVERWRITABLE
)
967 if (!n
->master_clone
)
968 n
->master_clone
= cgraph_node (n
->decl
);
970 return n
->master_clone
;
973 /* NODE is no longer nested function; update cgraph accordingly. */
975 cgraph_unnest_node (struct cgraph_node
*node
)
977 struct cgraph_node
**node2
= &node
->origin
->nested
;
978 gcc_assert (node
->origin
);
980 while (*node2
!= node
)
981 node2
= &(*node2
)->next_nested
;
982 *node2
= node
->next_nested
;
986 /* Return function availability. See cgraph.h for description of individual
989 cgraph_function_body_availability (struct cgraph_node
*node
)
991 enum availability avail
;
992 gcc_assert (cgraph_function_flags_ready
);
994 avail
= AVAIL_NOT_AVAILABLE
;
995 else if (node
->local
.local
)
997 else if (node
->local
.externally_visible
)
998 avail
= AVAIL_AVAILABLE
;
1000 /* If the function can be overwritten, return OVERWRITABLE. Take
1001 care at least of two notable extensions - the COMDAT functions
1002 used to share template instantiations in C++ (this is symmetric
1003 to code cp_cannot_inline_tree_fn and probably shall be shared and
1004 the inlinability hooks completely eliminated).
1006 ??? Does the C++ one definition rule allow us to always return
1007 AVAIL_AVAILABLE here? That would be good reason to preserve this
1008 hook Similarly deal with extern inline functions - this is again
1009 necessary to get C++ shared functions having keyed templates
1010 right and in the C extension documentation we probably should
1011 document the requirement of both versions of function (extern
1012 inline and offline) having same side effect characteristics as
1013 good optimization is what this optimization is about. */
1015 else if (!(*targetm
.binds_local_p
) (node
->decl
)
1016 && !DECL_COMDAT (node
->decl
) && !DECL_EXTERNAL (node
->decl
))
1017 avail
= AVAIL_OVERWRITABLE
;
1018 else avail
= AVAIL_AVAILABLE
;
1023 /* Add the function FNDECL to the call graph.
1024 Unlike cgraph_finalize_function, this function is intended to be used
1025 by middle end and allows insertion of new function at arbitrary point
1026 of compilation. The function can be either in high, low or SSA form
1029 The function is assumed to be reachable and have address taken (so no
1030 API breaking optimizations are performed on it).
1032 Main work done by this function is to enqueue the function for later
1033 processing to avoid need the passes to be re-entrant. */
1036 cgraph_add_new_function (tree fndecl
, bool lowered
)
1038 struct cgraph_node
*node
;
1039 switch (cgraph_state
)
1041 case CGRAPH_STATE_CONSTRUCTION
:
1042 /* Just enqueue function to be processed at nearest occurence. */
1043 node
= cgraph_node (fndecl
);
1044 node
->next_needed
= cgraph_new_nodes
;
1046 node
->lowered
= true;
1047 cgraph_new_nodes
= node
;
1050 case CGRAPH_STATE_IPA
:
1051 case CGRAPH_STATE_IPA_SSA
:
1052 case CGRAPH_STATE_EXPANSION
:
1053 /* Bring the function into finalized state and enqueue for later
1054 analyzing and compilation. */
1055 node
= cgraph_node (fndecl
);
1056 node
->local
.local
= false;
1057 node
->local
.finalized
= true;
1058 node
->reachable
= node
->needed
= true;
1060 node
->lowered
= true;
1061 node
->next_needed
= cgraph_new_nodes
;
1062 cgraph_new_nodes
= node
;
1065 case CGRAPH_STATE_FINISHED
:
1066 /* At the very end of compilation we have to do all the work up
1068 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
1069 current_function_decl
= fndecl
;
1070 tree_register_cfg_hooks ();
1072 tree_lowering_passes (fndecl
);
1073 bitmap_obstack_initialize (NULL
);
1074 if (!gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)) && optimize
)
1075 execute_pass_list (pass_early_local_passes
.pass
.sub
);
1076 bitmap_obstack_release (NULL
);
1077 tree_rest_of_compilation (fndecl
);
1079 current_function_decl
= NULL
;
1084 #include "gt-cgraph.h"