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-dump.h"
85 #include "tree-flow.h"
86 #include "value-prof.h"
88 static void cgraph_node_remove_callers (struct cgraph_node
*node
);
89 static inline void cgraph_edge_remove_caller (struct cgraph_edge
*e
);
90 static inline void cgraph_edge_remove_callee (struct cgraph_edge
*e
);
92 /* Hash table used to convert declarations into nodes. */
93 static GTY((param_is (struct cgraph_node
))) htab_t cgraph_hash
;
94 /* Hash table used to convert assembler names into nodes. */
95 static GTY((param_is (struct cgraph_node
))) htab_t assembler_name_hash
;
97 /* The linked list of cgraph nodes. */
98 struct cgraph_node
*cgraph_nodes
;
100 /* Queue of cgraph nodes scheduled to be lowered. */
101 struct cgraph_node
*cgraph_nodes_queue
;
103 /* Queue of cgraph nodes scheduled to be added into cgraph. This is a
104 secondary queue used during optimization to accommodate passes that
105 may generate new functions that need to be optimized and expanded. */
106 struct cgraph_node
*cgraph_new_nodes
;
108 /* Number of nodes in existence. */
111 /* Maximal uid used in cgraph nodes. */
114 /* Maximal uid used in cgraph edges. */
115 int cgraph_edge_max_uid
;
117 /* Maximal pid used for profiling */
120 /* Set when whole unit has been analyzed so we can access global info. */
121 bool cgraph_global_info_ready
= false;
123 /* What state callgraph is in right now. */
124 enum cgraph_state cgraph_state
= CGRAPH_STATE_CONSTRUCTION
;
126 /* Set when the cgraph is fully build and the basic flags are computed. */
127 bool cgraph_function_flags_ready
= false;
129 /* Linked list of cgraph asm nodes. */
130 struct cgraph_asm_node
*cgraph_asm_nodes
;
132 /* Last node in cgraph_asm_nodes. */
133 static GTY(()) struct cgraph_asm_node
*cgraph_asm_last_node
;
135 /* The order index of the next cgraph node to be created. This is
136 used so that we can sort the cgraph nodes in order by when we saw
137 them, to support -fno-toplevel-reorder. */
140 /* List of hooks trigerred on cgraph_edge events. */
141 struct cgraph_edge_hook_list
{
142 cgraph_edge_hook hook
;
144 struct cgraph_edge_hook_list
*next
;
147 /* List of hooks trigerred on cgraph_node events. */
148 struct cgraph_node_hook_list
{
149 cgraph_node_hook hook
;
151 struct cgraph_node_hook_list
*next
;
154 /* List of hooks trigerred on events involving two cgraph_edges. */
155 struct cgraph_2edge_hook_list
{
156 cgraph_2edge_hook hook
;
158 struct cgraph_2edge_hook_list
*next
;
161 /* List of hooks trigerred on events involving two cgraph_nodes. */
162 struct cgraph_2node_hook_list
{
163 cgraph_2node_hook hook
;
165 struct cgraph_2node_hook_list
*next
;
168 /* List of hooks triggered when an edge is removed. */
169 struct cgraph_edge_hook_list
*first_cgraph_edge_removal_hook
;
170 /* List of hooks triggered when a node is removed. */
171 struct cgraph_node_hook_list
*first_cgraph_node_removal_hook
;
172 /* List of hooks triggered when an edge is duplicated. */
173 struct cgraph_2edge_hook_list
*first_cgraph_edge_duplicated_hook
;
174 /* List of hooks triggered when a node is duplicated. */
175 struct cgraph_2node_hook_list
*first_cgraph_node_duplicated_hook
;
176 /* List of hooks triggered when an function is inserted. */
177 struct cgraph_node_hook_list
*first_cgraph_function_insertion_hook
;
179 /* Head of a linked list of unused (freed) call graph nodes.
180 Do not GTY((delete)) this list so UIDs gets reliably recycled. */
181 static GTY(()) struct cgraph_node
*free_nodes
;
182 /* Head of a linked list of unused (freed) call graph edges.
183 Do not GTY((delete)) this list so UIDs gets reliably recycled. */
184 static GTY(()) struct cgraph_edge
*free_edges
;
186 /* Macros to access the next item in the list of free cgraph nodes and
188 #define NEXT_FREE_NODE(NODE) (NODE)->next
189 #define NEXT_FREE_EDGE(EDGE) (EDGE)->prev_caller
191 /* Register HOOK to be called with DATA on each removed edge. */
192 struct cgraph_edge_hook_list
*
193 cgraph_add_edge_removal_hook (cgraph_edge_hook hook
, void *data
)
195 struct cgraph_edge_hook_list
*entry
;
196 struct cgraph_edge_hook_list
**ptr
= &first_cgraph_edge_removal_hook
;
198 entry
= (struct cgraph_edge_hook_list
*) xmalloc (sizeof (*entry
));
208 /* Remove ENTRY from the list of hooks called on removing edges. */
210 cgraph_remove_edge_removal_hook (struct cgraph_edge_hook_list
*entry
)
212 struct cgraph_edge_hook_list
**ptr
= &first_cgraph_edge_removal_hook
;
214 while (*ptr
!= entry
)
220 /* Call all edge removal hooks. */
222 cgraph_call_edge_removal_hooks (struct cgraph_edge
*e
)
224 struct cgraph_edge_hook_list
*entry
= first_cgraph_edge_removal_hook
;
227 entry
->hook (e
, entry
->data
);
232 /* Register HOOK to be called with DATA on each removed node. */
233 struct cgraph_node_hook_list
*
234 cgraph_add_node_removal_hook (cgraph_node_hook hook
, void *data
)
236 struct cgraph_node_hook_list
*entry
;
237 struct cgraph_node_hook_list
**ptr
= &first_cgraph_node_removal_hook
;
239 entry
= (struct cgraph_node_hook_list
*) xmalloc (sizeof (*entry
));
249 /* Remove ENTRY from the list of hooks called on removing nodes. */
251 cgraph_remove_node_removal_hook (struct cgraph_node_hook_list
*entry
)
253 struct cgraph_node_hook_list
**ptr
= &first_cgraph_node_removal_hook
;
255 while (*ptr
!= entry
)
261 /* Call all node removal hooks. */
263 cgraph_call_node_removal_hooks (struct cgraph_node
*node
)
265 struct cgraph_node_hook_list
*entry
= first_cgraph_node_removal_hook
;
268 entry
->hook (node
, entry
->data
);
273 /* Register HOOK to be called with DATA on each removed node. */
274 struct cgraph_node_hook_list
*
275 cgraph_add_function_insertion_hook (cgraph_node_hook hook
, void *data
)
277 struct cgraph_node_hook_list
*entry
;
278 struct cgraph_node_hook_list
**ptr
= &first_cgraph_function_insertion_hook
;
280 entry
= (struct cgraph_node_hook_list
*) xmalloc (sizeof (*entry
));
290 /* Remove ENTRY from the list of hooks called on removing nodes. */
292 cgraph_remove_function_insertion_hook (struct cgraph_node_hook_list
*entry
)
294 struct cgraph_node_hook_list
**ptr
= &first_cgraph_function_insertion_hook
;
296 while (*ptr
!= entry
)
302 /* Call all node removal hooks. */
304 cgraph_call_function_insertion_hooks (struct cgraph_node
*node
)
306 struct cgraph_node_hook_list
*entry
= first_cgraph_function_insertion_hook
;
309 entry
->hook (node
, entry
->data
);
314 /* Register HOOK to be called with DATA on each duplicated edge. */
315 struct cgraph_2edge_hook_list
*
316 cgraph_add_edge_duplication_hook (cgraph_2edge_hook hook
, void *data
)
318 struct cgraph_2edge_hook_list
*entry
;
319 struct cgraph_2edge_hook_list
**ptr
= &first_cgraph_edge_duplicated_hook
;
321 entry
= (struct cgraph_2edge_hook_list
*) xmalloc (sizeof (*entry
));
331 /* Remove ENTRY from the list of hooks called on duplicating edges. */
333 cgraph_remove_edge_duplication_hook (struct cgraph_2edge_hook_list
*entry
)
335 struct cgraph_2edge_hook_list
**ptr
= &first_cgraph_edge_duplicated_hook
;
337 while (*ptr
!= entry
)
343 /* Call all edge duplication hooks. */
345 cgraph_call_edge_duplication_hooks (struct cgraph_edge
*cs1
,
346 struct cgraph_edge
*cs2
)
348 struct cgraph_2edge_hook_list
*entry
= first_cgraph_edge_duplicated_hook
;
351 entry
->hook (cs1
, cs2
, entry
->data
);
356 /* Register HOOK to be called with DATA on each duplicated node. */
357 struct cgraph_2node_hook_list
*
358 cgraph_add_node_duplication_hook (cgraph_2node_hook hook
, void *data
)
360 struct cgraph_2node_hook_list
*entry
;
361 struct cgraph_2node_hook_list
**ptr
= &first_cgraph_node_duplicated_hook
;
363 entry
= (struct cgraph_2node_hook_list
*) xmalloc (sizeof (*entry
));
373 /* Remove ENTRY from the list of hooks called on duplicating nodes. */
375 cgraph_remove_node_duplication_hook (struct cgraph_2node_hook_list
*entry
)
377 struct cgraph_2node_hook_list
**ptr
= &first_cgraph_node_duplicated_hook
;
379 while (*ptr
!= entry
)
385 /* Call all node duplication hooks. */
387 cgraph_call_node_duplication_hooks (struct cgraph_node
*node1
,
388 struct cgraph_node
*node2
)
390 struct cgraph_2node_hook_list
*entry
= first_cgraph_node_duplicated_hook
;
393 entry
->hook (node1
, node2
, entry
->data
);
398 /* Returns a hash code for P. */
401 hash_node (const void *p
)
403 const struct cgraph_node
*n
= (const struct cgraph_node
*) p
;
404 return (hashval_t
) DECL_UID (n
->decl
);
407 /* Returns nonzero if P1 and P2 are equal. */
410 eq_node (const void *p1
, const void *p2
)
412 const struct cgraph_node
*n1
= (const struct cgraph_node
*) p1
;
413 const struct cgraph_node
*n2
= (const struct cgraph_node
*) p2
;
414 return DECL_UID (n1
->decl
) == DECL_UID (n2
->decl
);
417 /* Allocate new callgraph node and insert it into basic data structures. */
419 static struct cgraph_node
*
420 cgraph_create_node (void)
422 struct cgraph_node
*node
;
427 free_nodes
= NEXT_FREE_NODE (node
);
431 node
= GGC_CNEW (struct cgraph_node
);
432 node
->uid
= cgraph_max_uid
++;
435 node
->next
= cgraph_nodes
;
437 node
->order
= cgraph_order
++;
439 cgraph_nodes
->previous
= node
;
440 node
->previous
= NULL
;
441 node
->global
.estimated_growth
= INT_MIN
;
447 /* Return cgraph node assigned to DECL. Create new one when needed. */
450 cgraph_node (tree decl
)
452 struct cgraph_node key
, *node
, **slot
;
454 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
457 cgraph_hash
= htab_create_ggc (10, hash_node
, eq_node
, NULL
);
461 slot
= (struct cgraph_node
**) htab_find_slot (cgraph_hash
, &key
, INSERT
);
469 node
= cgraph_create_node ();
472 if (DECL_CONTEXT (decl
) && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
474 node
->origin
= cgraph_node (DECL_CONTEXT (decl
));
475 node
->next_nested
= node
->origin
->nested
;
476 node
->origin
->nested
= node
;
478 if (assembler_name_hash
)
481 tree name
= DECL_ASSEMBLER_NAME (decl
);
483 aslot
= htab_find_slot_with_hash (assembler_name_hash
, name
,
484 decl_assembler_name_hash (name
),
486 /* We can have multiple declarations with same assembler name. For C++
487 it is __builtin_strlen and strlen, for instance. Do we need to
488 record them all? Original implementation marked just first one
489 so lets hope for the best. */
496 /* Insert already constructed node into hashtable. */
499 cgraph_insert_node_to_hashtable (struct cgraph_node
*node
)
501 struct cgraph_node
**slot
;
503 slot
= (struct cgraph_node
**) htab_find_slot (cgraph_hash
, node
, INSERT
);
509 /* Returns a hash code for P. */
512 hash_node_by_assembler_name (const void *p
)
514 const struct cgraph_node
*n
= (const struct cgraph_node
*) p
;
515 return (hashval_t
) decl_assembler_name_hash (DECL_ASSEMBLER_NAME (n
->decl
));
518 /* Returns nonzero if P1 and P2 are equal. */
521 eq_assembler_name (const void *p1
, const void *p2
)
523 const struct cgraph_node
*n1
= (const struct cgraph_node
*) p1
;
524 const_tree name
= (const_tree
)p2
;
525 return (decl_assembler_name_equal (n1
->decl
, name
));
528 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
529 Return NULL if there's no such node. */
532 cgraph_node_for_asm (tree asmname
)
534 struct cgraph_node
*node
;
537 if (!assembler_name_hash
)
539 assembler_name_hash
=
540 htab_create_ggc (10, hash_node_by_assembler_name
, eq_assembler_name
,
542 for (node
= cgraph_nodes
; node
; node
= node
->next
)
543 if (!node
->global
.inlined_to
)
545 tree name
= DECL_ASSEMBLER_NAME (node
->decl
);
546 slot
= htab_find_slot_with_hash (assembler_name_hash
, name
,
547 decl_assembler_name_hash (name
),
549 /* We can have multiple declarations with same assembler name. For C++
550 it is __builtin_strlen and strlen, for instance. Do we need to
551 record them all? Original implementation marked just first one
552 so lets hope for the best. */
559 slot
= htab_find_slot_with_hash (assembler_name_hash
, asmname
,
560 decl_assembler_name_hash (asmname
),
564 return (struct cgraph_node
*) *slot
;
568 /* Returns a hash value for X (which really is a die_struct). */
571 edge_hash (const void *x
)
573 return htab_hash_pointer (((const struct cgraph_edge
*) x
)->call_stmt
);
576 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
579 edge_eq (const void *x
, const void *y
)
581 return ((const struct cgraph_edge
*) x
)->call_stmt
== y
;
585 /* Return the callgraph edge representing the GIMPLE_CALL statement
589 cgraph_edge (struct cgraph_node
*node
, gimple call_stmt
)
591 struct cgraph_edge
*e
, *e2
;
594 if (node
->call_site_hash
)
595 return (struct cgraph_edge
*)
596 htab_find_with_hash (node
->call_site_hash
, call_stmt
,
597 htab_hash_pointer (call_stmt
));
599 /* This loop may turn out to be performance problem. In such case adding
600 hashtables into call nodes with very many edges is probably best
601 solution. It is not good idea to add pointer into CALL_EXPR itself
602 because we want to make possible having multiple cgraph nodes representing
603 different clones of the same body before the body is actually cloned. */
604 for (e
= node
->callees
; e
; e
= e
->next_callee
)
606 if (e
->call_stmt
== call_stmt
)
613 node
->call_site_hash
= htab_create_ggc (120, edge_hash
, edge_eq
, NULL
);
614 for (e2
= node
->callees
; e2
; e2
= e2
->next_callee
)
617 slot
= htab_find_slot_with_hash (node
->call_site_hash
,
619 htab_hash_pointer (e2
->call_stmt
),
630 /* Change field call_stmt of edge E to NEW_STMT. */
633 cgraph_set_call_stmt (struct cgraph_edge
*e
, gimple new_stmt
)
635 if (e
->caller
->call_site_hash
)
637 htab_remove_elt_with_hash (e
->caller
->call_site_hash
,
639 htab_hash_pointer (e
->call_stmt
));
641 e
->call_stmt
= new_stmt
;
642 push_cfun (DECL_STRUCT_FUNCTION (e
->caller
->decl
));
643 e
->can_throw_external
= stmt_can_throw_external (new_stmt
);
645 if (e
->caller
->call_site_hash
)
648 slot
= htab_find_slot_with_hash (e
->caller
->call_site_hash
,
651 (e
->call_stmt
), INSERT
);
657 /* Like cgraph_set_call_stmt but walk the clone tree and update all clones sharing
658 same function body. */
661 cgraph_set_call_stmt_including_clones (struct cgraph_node
*orig
,
662 gimple old_stmt
, gimple new_stmt
)
664 struct cgraph_node
*node
;
665 struct cgraph_edge
*edge
= cgraph_edge (orig
, old_stmt
);
668 cgraph_set_call_stmt (edge
, new_stmt
);
670 for (node
= orig
->clones
; node
!= orig
;)
672 struct cgraph_edge
*edge
= cgraph_edge (node
, old_stmt
);
674 cgraph_set_call_stmt (edge
, new_stmt
);
677 else if (node
->next_sibling_clone
)
678 node
= node
->next_sibling_clone
;
681 while (node
!= orig
&& !node
->next_sibling_clone
)
682 node
= node
->clone_of
;
684 node
= node
->next_sibling_clone
;
689 /* Like cgraph_create_edge walk the clone tree and update all clones sharing
692 TODO: COUNT and LOOP_DEPTH should be properly distributed based on relative
693 frequencies of the clones.
697 cgraph_create_edge_including_clones (struct cgraph_node
*orig
, struct cgraph_node
*callee
,
698 gimple stmt
, gcov_type count
, int freq
,
700 cgraph_inline_failed_t reason
)
702 struct cgraph_node
*node
;
704 cgraph_create_edge (orig
, callee
, stmt
, count
, freq
, loop_depth
)->inline_failed
=
708 for (node
= orig
->clones
; node
!= orig
;)
710 /* It is possible that we already constant propagated into the clone
711 and turned indirect call into dirrect call. */
712 if (!cgraph_edge (node
, stmt
))
713 cgraph_create_edge (node
, callee
, stmt
, count
, freq
,
714 loop_depth
)->inline_failed
= reason
;
718 else if (node
->next_sibling_clone
)
719 node
= node
->next_sibling_clone
;
722 while (node
!= orig
&& !node
->next_sibling_clone
)
723 node
= node
->clone_of
;
725 node
= node
->next_sibling_clone
;
730 /* Give initial reasons why inlining would fail on EDGE. This gets either
731 nullified or usually overwritten by more precise reasons later. */
734 initialize_inline_failed (struct cgraph_edge
*e
)
736 struct cgraph_node
*callee
= e
->callee
;
738 if (!callee
->analyzed
)
739 e
->inline_failed
= CIF_BODY_NOT_AVAILABLE
;
740 else if (callee
->local
.redefined_extern_inline
)
741 e
->inline_failed
= CIF_REDEFINED_EXTERN_INLINE
;
742 else if (!callee
->local
.inlinable
)
743 e
->inline_failed
= CIF_FUNCTION_NOT_INLINABLE
;
744 else if (gimple_call_cannot_inline_p (e
->call_stmt
))
745 e
->inline_failed
= CIF_MISMATCHED_ARGUMENTS
;
747 e
->inline_failed
= CIF_FUNCTION_NOT_CONSIDERED
;
750 /* Create edge from CALLER to CALLEE in the cgraph. */
753 cgraph_create_edge (struct cgraph_node
*caller
, struct cgraph_node
*callee
,
754 gimple call_stmt
, gcov_type count
, int freq
, int nest
)
756 struct cgraph_edge
*edge
;
758 #ifdef ENABLE_CHECKING
759 /* This is rather pricely check possibly trigerring construction of call stmt
761 gcc_assert (!cgraph_edge (caller
, call_stmt
));
764 gcc_assert (is_gimple_call (call_stmt
));
769 free_edges
= NEXT_FREE_EDGE (edge
);
773 edge
= GGC_NEW (struct cgraph_edge
);
774 edge
->uid
= cgraph_edge_max_uid
++;
779 edge
->caller
= caller
;
780 edge
->callee
= callee
;
781 edge
->call_stmt
= call_stmt
;
782 push_cfun (DECL_STRUCT_FUNCTION (caller
->decl
));
783 edge
->can_throw_external
= stmt_can_throw_external (call_stmt
);
785 edge
->prev_caller
= NULL
;
786 edge
->next_caller
= callee
->callers
;
788 callee
->callers
->prev_caller
= edge
;
789 edge
->prev_callee
= NULL
;
790 edge
->next_callee
= caller
->callees
;
792 caller
->callees
->prev_callee
= edge
;
793 caller
->callees
= edge
;
794 callee
->callers
= edge
;
796 gcc_assert (count
>= 0);
797 edge
->frequency
= freq
;
798 gcc_assert (freq
>= 0);
799 gcc_assert (freq
<= CGRAPH_FREQ_MAX
);
800 edge
->loop_nest
= nest
;
801 edge
->indirect_call
= 0;
802 if (caller
->call_site_hash
)
805 slot
= htab_find_slot_with_hash (caller
->call_site_hash
,
814 initialize_inline_failed (edge
);
819 /* Remove the edge E from the list of the callers of the callee. */
822 cgraph_edge_remove_callee (struct cgraph_edge
*e
)
825 e
->prev_caller
->next_caller
= e
->next_caller
;
827 e
->next_caller
->prev_caller
= e
->prev_caller
;
829 e
->callee
->callers
= e
->next_caller
;
832 /* Remove the edge E from the list of the callees of the caller. */
835 cgraph_edge_remove_caller (struct cgraph_edge
*e
)
838 e
->prev_callee
->next_callee
= e
->next_callee
;
840 e
->next_callee
->prev_callee
= e
->prev_callee
;
842 e
->caller
->callees
= e
->next_callee
;
843 if (e
->caller
->call_site_hash
)
844 htab_remove_elt_with_hash (e
->caller
->call_site_hash
,
846 htab_hash_pointer (e
->call_stmt
));
849 /* Put the edge onto the free list. */
852 cgraph_free_edge (struct cgraph_edge
*e
)
856 /* Clear out the edge so we do not dangle pointers. */
857 memset (e
, 0, sizeof (*e
));
859 NEXT_FREE_EDGE (e
) = free_edges
;
863 /* Remove the edge E in the cgraph. */
866 cgraph_remove_edge (struct cgraph_edge
*e
)
868 /* Call all edge removal hooks. */
869 cgraph_call_edge_removal_hooks (e
);
871 /* Remove from callers list of the callee. */
872 cgraph_edge_remove_callee (e
);
874 /* Remove from callees list of the callers. */
875 cgraph_edge_remove_caller (e
);
877 /* Put the edge onto the free list. */
878 cgraph_free_edge (e
);
881 /* Redirect callee of E to N. The function does not update underlying
885 cgraph_redirect_edge_callee (struct cgraph_edge
*e
, struct cgraph_node
*n
)
887 /* Remove from callers list of the current callee. */
888 cgraph_edge_remove_callee (e
);
890 /* Insert to callers list of the new callee. */
891 e
->prev_caller
= NULL
;
893 n
->callers
->prev_caller
= e
;
894 e
->next_caller
= n
->callers
;
900 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
901 OLD_STMT changed into NEW_STMT. OLD_CALL is gimple_call_fndecl
902 of OLD_STMT if it was previously call statement. */
905 cgraph_update_edges_for_call_stmt_node (struct cgraph_node
*node
,
906 gimple old_stmt
, tree old_call
, gimple new_stmt
)
908 tree new_call
= (is_gimple_call (new_stmt
)) ? gimple_call_fndecl (new_stmt
) : 0;
910 /* We are seeing indirect calls, then there is nothing to update. */
911 if (!new_call
&& !old_call
)
913 /* See if we turned indirect call into direct call or folded call to one builtin
914 into different bultin. */
915 if (old_call
!= new_call
)
917 struct cgraph_edge
*e
= cgraph_edge (node
, old_stmt
);
918 struct cgraph_edge
*ne
= NULL
;
925 /* See if the call is already there. It might be because of indirect
926 inlining already found it. */
927 if (new_call
&& e
->callee
->decl
== new_call
)
930 /* Otherwise remove edge and create new one; we can't simply redirect
931 since function has changed, so inline plan and other information
932 attached to edge is invalid. */
933 cgraph_remove_edge (e
);
935 frequency
= e
->frequency
;
936 loop_nest
= e
->loop_nest
;
940 /* We are seeing new direct call; compute profile info based on BB. */
941 basic_block bb
= gimple_bb (new_stmt
);
943 frequency
= compute_call_stmt_bb_frequency (current_function_decl
,
945 loop_nest
= bb
->loop_depth
;
950 ne
= cgraph_create_edge (node
, cgraph_node (new_call
),
951 new_stmt
, count
, frequency
,
953 gcc_assert (ne
->inline_failed
);
956 /* We only updated the call stmt; update pointer in cgraph edge.. */
957 else if (old_stmt
!= new_stmt
)
958 cgraph_set_call_stmt (cgraph_edge (node
, old_stmt
), new_stmt
);
961 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
962 OLD_STMT changed into NEW_STMT. OLD_DECL is gimple_call_fndecl
963 of OLD_STMT before it was updated (updating can happen inplace). */
966 cgraph_update_edges_for_call_stmt (gimple old_stmt
, tree old_decl
, gimple new_stmt
)
968 struct cgraph_node
*orig
= cgraph_node (cfun
->decl
);
969 struct cgraph_node
*node
;
971 cgraph_update_edges_for_call_stmt_node (orig
, old_stmt
, old_decl
, new_stmt
);
973 for (node
= orig
->clones
; node
!= orig
;)
975 cgraph_update_edges_for_call_stmt_node (node
, old_stmt
, old_decl
, new_stmt
);
978 else if (node
->next_sibling_clone
)
979 node
= node
->next_sibling_clone
;
982 while (node
!= orig
&& !node
->next_sibling_clone
)
983 node
= node
->clone_of
;
985 node
= node
->next_sibling_clone
;
991 /* Remove all callees from the node. */
994 cgraph_node_remove_callees (struct cgraph_node
*node
)
996 struct cgraph_edge
*e
, *f
;
998 /* It is sufficient to remove the edges from the lists of callers of
999 the callees. The callee list of the node can be zapped with one
1001 for (e
= node
->callees
; e
; e
= f
)
1004 cgraph_call_edge_removal_hooks (e
);
1005 cgraph_edge_remove_callee (e
);
1006 cgraph_free_edge (e
);
1008 node
->callees
= NULL
;
1009 if (node
->call_site_hash
)
1011 htab_delete (node
->call_site_hash
);
1012 node
->call_site_hash
= NULL
;
1016 /* Remove all callers from the node. */
1019 cgraph_node_remove_callers (struct cgraph_node
*node
)
1021 struct cgraph_edge
*e
, *f
;
1023 /* It is sufficient to remove the edges from the lists of callees of
1024 the callers. The caller list of the node can be zapped with one
1026 for (e
= node
->callers
; e
; e
= f
)
1029 cgraph_call_edge_removal_hooks (e
);
1030 cgraph_edge_remove_caller (e
);
1031 cgraph_free_edge (e
);
1033 node
->callers
= NULL
;
1036 /* Release memory used to represent body of function NODE. */
1039 cgraph_release_function_body (struct cgraph_node
*node
)
1041 if (DECL_STRUCT_FUNCTION (node
->decl
))
1043 tree old_decl
= current_function_decl
;
1044 push_cfun (DECL_STRUCT_FUNCTION (node
->decl
));
1045 if (cfun
->gimple_df
)
1047 current_function_decl
= node
->decl
;
1049 delete_tree_cfg_annotations ();
1051 current_function_decl
= old_decl
;
1055 gcc_assert (dom_computed
[0] == DOM_NONE
);
1056 gcc_assert (dom_computed
[1] == DOM_NONE
);
1059 if (cfun
->value_histograms
)
1061 gcc_assert (!current_loops
);
1063 gimple_set_body (node
->decl
, NULL
);
1064 VEC_free (ipa_opt_pass
, heap
,
1065 DECL_STRUCT_FUNCTION (node
->decl
)->ipa_transforms_to_apply
);
1066 /* Struct function hangs a lot of data that would leak if we didn't
1067 removed all pointers to it. */
1068 ggc_free (DECL_STRUCT_FUNCTION (node
->decl
));
1069 DECL_STRUCT_FUNCTION (node
->decl
) = NULL
;
1071 DECL_SAVED_TREE (node
->decl
) = NULL
;
1072 /* If the node is abstract and needed, then do not clear DECL_INITIAL
1073 of its associated function function declaration because it's
1074 needed to emit debug info later. */
1075 if (!node
->abstract_and_needed
)
1076 DECL_INITIAL (node
->decl
) = error_mark_node
;
1079 /* Remove the node from cgraph. */
1082 cgraph_remove_node (struct cgraph_node
*node
)
1085 bool kill_body
= false;
1086 struct cgraph_node
*n
;
1087 int uid
= node
->uid
;
1089 cgraph_call_node_removal_hooks (node
);
1090 cgraph_node_remove_callers (node
);
1091 cgraph_node_remove_callees (node
);
1093 /* Incremental inlining access removed nodes stored in the postorder list.
1095 node
->needed
= node
->reachable
= false;
1096 for (n
= node
->nested
; n
; n
= n
->next_nested
)
1098 node
->nested
= NULL
;
1101 struct cgraph_node
**node2
= &node
->origin
->nested
;
1103 while (*node2
!= node
)
1104 node2
= &(*node2
)->next_nested
;
1105 *node2
= node
->next_nested
;
1108 node
->previous
->next
= node
->next
;
1110 cgraph_nodes
= node
->next
;
1112 node
->next
->previous
= node
->previous
;
1114 node
->previous
= NULL
;
1115 slot
= htab_find_slot (cgraph_hash
, node
, NO_INSERT
);
1118 struct cgraph_node
*next_inline_clone
;
1120 for (next_inline_clone
= node
->clones
;
1121 next_inline_clone
&& next_inline_clone
->decl
!= node
->decl
;
1122 next_inline_clone
= next_inline_clone
->next_sibling_clone
)
1125 /* If there is inline clone of the node being removed, we need
1126 to put it into the position of removed node and reorganize all
1127 other clones to be based on it. */
1128 if (next_inline_clone
)
1130 struct cgraph_node
*n
;
1131 struct cgraph_node
*new_clones
;
1133 *slot
= next_inline_clone
;
1135 /* Unlink inline clone from the list of clones of removed node. */
1136 if (next_inline_clone
->next_sibling_clone
)
1137 next_inline_clone
->next_sibling_clone
->prev_sibling_clone
1138 = next_inline_clone
->prev_sibling_clone
;
1139 if (next_inline_clone
->prev_sibling_clone
)
1141 next_inline_clone
->prev_sibling_clone
->next_sibling_clone
1142 = next_inline_clone
->next_sibling_clone
;
1145 node
->clones
= next_inline_clone
->next_sibling_clone
;
1147 new_clones
= node
->clones
;
1148 node
->clones
= NULL
;
1150 /* Copy clone info. */
1151 next_inline_clone
->clone
= node
->clone
;
1153 /* Now place it into clone tree at same level at NODE. */
1154 next_inline_clone
->clone_of
= node
->clone_of
;
1155 next_inline_clone
->prev_sibling_clone
= NULL
;
1156 next_inline_clone
->next_sibling_clone
= NULL
;
1159 next_inline_clone
->next_sibling_clone
= node
->clone_of
->clones
;
1160 node
->clone_of
->clones
= next_inline_clone
;
1163 /* Merge the clone list. */
1166 if (!next_inline_clone
->clones
)
1167 next_inline_clone
->clones
= new_clones
;
1170 n
= next_inline_clone
->clones
;
1171 while (n
->next_sibling_clone
)
1172 n
= n
->next_sibling_clone
;
1173 n
->next_sibling_clone
= new_clones
;
1174 new_clones
->prev_sibling_clone
= n
;
1178 /* Update clone_of pointers. */
1182 n
->clone_of
= next_inline_clone
;
1183 n
= n
->next_sibling_clone
;
1188 htab_clear_slot (cgraph_hash
, slot
);
1194 gcc_assert (node
->clone_of
);
1195 if (node
->prev_sibling_clone
)
1196 node
->prev_sibling_clone
->next_sibling_clone
= node
->next_sibling_clone
;
1197 else if (node
->clone_of
)
1198 node
->clone_of
->clones
= node
->next_sibling_clone
;
1199 if (node
->next_sibling_clone
)
1200 node
->next_sibling_clone
->prev_sibling_clone
= node
->prev_sibling_clone
;
1203 struct cgraph_node
*n
;
1205 for (n
= node
->clones
; n
->next_sibling_clone
; n
= n
->next_sibling_clone
)
1206 n
->clone_of
= node
->clone_of
;
1207 n
->clone_of
= node
->clone_of
;
1208 n
->next_sibling_clone
= node
->clone_of
->clones
;
1209 if (node
->clone_of
->clones
)
1210 node
->clone_of
->clones
->prev_sibling_clone
= n
;
1211 node
->clone_of
->clones
= node
->clones
;
1214 /* While all the clones are removed after being proceeded, the function
1215 itself is kept in the cgraph even after it is compiled. Check whether
1216 we are done with this body and reclaim it proactively if this is the case.
1218 if (!kill_body
&& *slot
)
1220 struct cgraph_node
*n
= (struct cgraph_node
*) *slot
;
1221 if (!n
->clones
&& !n
->clone_of
&& !n
->global
.inlined_to
1222 && (cgraph_global_info_ready
1223 && (TREE_ASM_WRITTEN (n
->decl
) || DECL_EXTERNAL (n
->decl
))))
1226 if (assembler_name_hash
)
1228 tree name
= DECL_ASSEMBLER_NAME (node
->decl
);
1229 slot
= htab_find_slot_with_hash (assembler_name_hash
, name
,
1230 decl_assembler_name_hash (name
),
1232 /* Inline clones are not hashed. */
1233 if (slot
&& *slot
== node
)
1234 htab_clear_slot (assembler_name_hash
, slot
);
1238 cgraph_release_function_body (node
);
1240 if (node
->call_site_hash
)
1242 htab_delete (node
->call_site_hash
);
1243 node
->call_site_hash
= NULL
;
1247 /* Clear out the node to NULL all pointers and add the node to the free
1249 memset (node
, 0, sizeof(*node
));
1251 NEXT_FREE_NODE (node
) = free_nodes
;
1255 /* Remove the node from cgraph. */
1258 cgraph_remove_node_and_inline_clones (struct cgraph_node
*node
)
1260 struct cgraph_edge
*e
, *next
;
1261 for (e
= node
->callees
; e
; e
= next
)
1263 next
= e
->next_callee
;
1264 if (!e
->inline_failed
)
1265 cgraph_remove_node_and_inline_clones (e
->callee
);
1267 cgraph_remove_node (node
);
1270 /* Notify finalize_compilation_unit that given node is reachable. */
1273 cgraph_mark_reachable_node (struct cgraph_node
*node
)
1275 if (!node
->reachable
&& node
->local
.finalized
)
1277 notice_global_symbol (node
->decl
);
1278 node
->reachable
= 1;
1279 gcc_assert (!cgraph_global_info_ready
);
1281 node
->next_needed
= cgraph_nodes_queue
;
1282 cgraph_nodes_queue
= node
;
1286 /* Likewise indicate that a node is needed, i.e. reachable via some
1290 cgraph_mark_needed_node (struct cgraph_node
*node
)
1293 cgraph_mark_reachable_node (node
);
1296 /* Likewise indicate that a node is having address taken. */
1299 cgraph_mark_address_taken_node (struct cgraph_node
*node
)
1301 node
->address_taken
= 1;
1302 cgraph_mark_needed_node (node
);
1305 /* Return local info for the compiled function. */
1307 struct cgraph_local_info
*
1308 cgraph_local_info (tree decl
)
1310 struct cgraph_node
*node
;
1312 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1313 node
= cgraph_node (decl
);
1314 return &node
->local
;
1317 /* Return local info for the compiled function. */
1319 struct cgraph_global_info
*
1320 cgraph_global_info (tree decl
)
1322 struct cgraph_node
*node
;
1324 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
&& cgraph_global_info_ready
);
1325 node
= cgraph_node (decl
);
1326 return &node
->global
;
1329 /* Return local info for the compiled function. */
1331 struct cgraph_rtl_info
*
1332 cgraph_rtl_info (tree decl
)
1334 struct cgraph_node
*node
;
1336 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1337 node
= cgraph_node (decl
);
1338 if (decl
!= current_function_decl
1339 && !TREE_ASM_WRITTEN (node
->decl
))
1344 /* Return a string describing the failure REASON. */
1347 cgraph_inline_failed_string (cgraph_inline_failed_t reason
)
1350 #define DEFCIFCODE(code, string) string,
1352 static const char *cif_string_table
[CIF_N_REASONS
] = {
1353 #include "cif-code.def"
1356 /* Signedness of an enum type is implementation defined, so cast it
1357 to unsigned before testing. */
1358 gcc_assert ((unsigned) reason
< CIF_N_REASONS
);
1359 return cif_string_table
[reason
];
1362 /* Return name of the node used in debug output. */
1364 cgraph_node_name (struct cgraph_node
*node
)
1366 return lang_hooks
.decl_printable_name (node
->decl
, 2);
1369 /* Names used to print out the availability enum. */
1370 const char * const cgraph_availability_names
[] =
1371 {"unset", "not_available", "overwritable", "available", "local"};
1374 /* Dump call graph node NODE to file F. */
1377 dump_cgraph_node (FILE *f
, struct cgraph_node
*node
)
1379 struct cgraph_edge
*edge
;
1380 fprintf (f
, "%s/%i(%i) [%p]:", cgraph_node_name (node
), node
->uid
,
1381 node
->pid
, (void *) node
);
1382 if (node
->global
.inlined_to
)
1383 fprintf (f
, " (inline copy in %s/%i)",
1384 cgraph_node_name (node
->global
.inlined_to
),
1385 node
->global
.inlined_to
->uid
);
1387 fprintf (f
, " (clone of %s/%i)",
1388 cgraph_node_name (node
->clone_of
),
1389 node
->clone_of
->uid
);
1390 if (cgraph_function_flags_ready
)
1391 fprintf (f
, " availability:%s",
1392 cgraph_availability_names
[cgraph_function_body_availability (node
)]);
1394 fprintf (f
, " executed "HOST_WIDEST_INT_PRINT_DEC
"x",
1395 (HOST_WIDEST_INT
)node
->count
);
1396 if (node
->local
.inline_summary
.self_insns
)
1397 fprintf (f
, " %i insns", node
->local
.inline_summary
.self_insns
);
1398 if (node
->global
.insns
&& node
->global
.insns
1399 != node
->local
.inline_summary
.self_insns
)
1400 fprintf (f
, " (%i after inlining)", node
->global
.insns
);
1401 if (node
->local
.inline_summary
.estimated_self_stack_size
)
1402 fprintf (f
, " %i bytes stack usage", (int)node
->local
.inline_summary
.estimated_self_stack_size
);
1403 if (node
->global
.estimated_stack_size
!= node
->local
.inline_summary
.estimated_self_stack_size
)
1404 fprintf (f
, " %i bytes after inlining", (int)node
->global
.estimated_stack_size
);
1406 fprintf (f
, " nested in: %s", cgraph_node_name (node
->origin
));
1408 fprintf (f
, " needed");
1409 if (node
->address_taken
)
1410 fprintf (f
, " address_taken");
1411 else if (node
->reachable
)
1412 fprintf (f
, " reachable");
1413 if (gimple_has_body_p (node
->decl
))
1414 fprintf (f
, " body");
1416 fprintf (f
, " process");
1417 if (node
->local
.local
)
1418 fprintf (f
, " local");
1419 if (node
->local
.externally_visible
)
1420 fprintf (f
, " externally_visible");
1421 if (node
->local
.finalized
)
1422 fprintf (f
, " finalized");
1423 if (node
->local
.disregard_inline_limits
)
1424 fprintf (f
, " always_inline");
1425 else if (node
->local
.inlinable
)
1426 fprintf (f
, " inlinable");
1427 if (node
->local
.redefined_extern_inline
)
1428 fprintf (f
, " redefined_extern_inline");
1429 if (TREE_ASM_WRITTEN (node
->decl
))
1430 fprintf (f
, " asm_written");
1432 fprintf (f
, "\n called by: ");
1433 for (edge
= node
->callers
; edge
; edge
= edge
->next_caller
)
1435 fprintf (f
, "%s/%i ", cgraph_node_name (edge
->caller
),
1438 fprintf (f
, "("HOST_WIDEST_INT_PRINT_DEC
"x) ",
1439 (HOST_WIDEST_INT
)edge
->count
);
1440 if (edge
->frequency
)
1441 fprintf (f
, "(%.2f per call) ",
1442 edge
->frequency
/ (double)CGRAPH_FREQ_BASE
);
1443 if (!edge
->inline_failed
)
1444 fprintf(f
, "(inlined) ");
1445 if (edge
->indirect_call
)
1446 fprintf(f
, "(indirect) ");
1447 if (edge
->can_throw_external
)
1448 fprintf(f
, "(can throw external) ");
1451 fprintf (f
, "\n calls: ");
1452 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
1454 fprintf (f
, "%s/%i ", cgraph_node_name (edge
->callee
),
1456 if (!edge
->inline_failed
)
1457 fprintf(f
, "(inlined) ");
1458 if (edge
->indirect_call
)
1459 fprintf(f
, "(indirect) ");
1461 fprintf (f
, "("HOST_WIDEST_INT_PRINT_DEC
"x) ",
1462 (HOST_WIDEST_INT
)edge
->count
);
1463 if (edge
->frequency
)
1464 fprintf (f
, "(%.2f per call) ",
1465 edge
->frequency
/ (double)CGRAPH_FREQ_BASE
);
1466 if (edge
->loop_nest
)
1467 fprintf (f
, "(nested in %i loops) ", edge
->loop_nest
);
1468 if (edge
->can_throw_external
)
1469 fprintf(f
, "(can throw external) ");
1475 /* Dump call graph node NODE to stderr. */
1478 debug_cgraph_node (struct cgraph_node
*node
)
1480 dump_cgraph_node (stderr
, node
);
1484 /* Dump the callgraph to file F. */
1487 dump_cgraph (FILE *f
)
1489 struct cgraph_node
*node
;
1491 fprintf (f
, "callgraph:\n\n");
1492 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1493 dump_cgraph_node (f
, node
);
1497 /* Dump the call graph to stderr. */
1502 dump_cgraph (stderr
);
1506 /* Set the DECL_ASSEMBLER_NAME and update cgraph hashtables. */
1509 change_decl_assembler_name (tree decl
, tree name
)
1511 gcc_assert (!assembler_name_hash
);
1512 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
1514 SET_DECL_ASSEMBLER_NAME (decl
, name
);
1517 if (name
== DECL_ASSEMBLER_NAME (decl
))
1520 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
))
1521 && DECL_RTL_SET_P (decl
))
1522 warning (0, "%D renamed after being referenced in assembly", decl
);
1524 SET_DECL_ASSEMBLER_NAME (decl
, name
);
1527 /* Add a top-level asm statement to the list. */
1529 struct cgraph_asm_node
*
1530 cgraph_add_asm_node (tree asm_str
)
1532 struct cgraph_asm_node
*node
;
1534 node
= GGC_CNEW (struct cgraph_asm_node
);
1535 node
->asm_str
= asm_str
;
1536 node
->order
= cgraph_order
++;
1538 if (cgraph_asm_nodes
== NULL
)
1539 cgraph_asm_nodes
= node
;
1541 cgraph_asm_last_node
->next
= node
;
1542 cgraph_asm_last_node
= node
;
1546 /* Return true when the DECL can possibly be inlined. */
1548 cgraph_function_possibly_inlined_p (tree decl
)
1550 if (!cgraph_global_info_ready
)
1551 return !DECL_UNINLINABLE (decl
);
1552 return DECL_POSSIBLY_INLINED (decl
);
1555 /* Create clone of E in the node N represented by CALL_EXPR the callgraph. */
1556 struct cgraph_edge
*
1557 cgraph_clone_edge (struct cgraph_edge
*e
, struct cgraph_node
*n
,
1558 gimple call_stmt
, gcov_type count_scale
, int freq_scale
,
1559 int loop_nest
, bool update_original
)
1561 struct cgraph_edge
*new_edge
;
1562 gcov_type count
= e
->count
* count_scale
/ REG_BR_PROB_BASE
;
1563 gcov_type freq
= e
->frequency
* (gcov_type
) freq_scale
/ CGRAPH_FREQ_BASE
;
1565 if (freq
> CGRAPH_FREQ_MAX
)
1566 freq
= CGRAPH_FREQ_MAX
;
1567 new_edge
= cgraph_create_edge (n
, e
->callee
, call_stmt
, count
, freq
,
1568 e
->loop_nest
+ loop_nest
);
1570 new_edge
->inline_failed
= e
->inline_failed
;
1571 new_edge
->indirect_call
= e
->indirect_call
;
1572 if (update_original
)
1574 e
->count
-= new_edge
->count
;
1578 cgraph_call_edge_duplication_hooks (e
, new_edge
);
1582 /* Create node representing clone of N executed COUNT times. Decrease
1583 the execution counts from original node too.
1585 When UPDATE_ORIGINAL is true, the counts are subtracted from the original
1586 function's profile to reflect the fact that part of execution is handled
1588 struct cgraph_node
*
1589 cgraph_clone_node (struct cgraph_node
*n
, gcov_type count
, int freq
,
1590 int loop_nest
, bool update_original
)
1592 struct cgraph_node
*new_node
= cgraph_create_node ();
1593 struct cgraph_edge
*e
;
1594 gcov_type count_scale
;
1596 new_node
->decl
= n
->decl
;
1597 new_node
->origin
= n
->origin
;
1598 if (new_node
->origin
)
1600 new_node
->next_nested
= new_node
->origin
->nested
;
1601 new_node
->origin
->nested
= new_node
;
1603 new_node
->analyzed
= n
->analyzed
;
1604 new_node
->local
= n
->local
;
1605 new_node
->global
= n
->global
;
1606 new_node
->rtl
= n
->rtl
;
1607 new_node
->count
= count
;
1608 new_node
->clone
= n
->clone
;
1611 if (new_node
->count
> n
->count
)
1612 count_scale
= REG_BR_PROB_BASE
;
1614 count_scale
= new_node
->count
* REG_BR_PROB_BASE
/ n
->count
;
1618 if (update_original
)
1625 for (e
= n
->callees
;e
; e
=e
->next_callee
)
1626 cgraph_clone_edge (e
, new_node
, e
->call_stmt
, count_scale
, freq
, loop_nest
,
1629 new_node
->next_sibling_clone
= n
->clones
;
1631 n
->clones
->prev_sibling_clone
= new_node
;
1632 n
->clones
= new_node
;
1633 new_node
->clone_of
= n
;
1635 cgraph_call_node_duplication_hooks (n
, new_node
);
1639 /* Create a new name for omp child function. Returns an identifier. */
1641 static GTY(()) unsigned int clone_fn_id_num
;
1644 clone_function_name (tree decl
)
1646 tree name
= DECL_ASSEMBLER_NAME (decl
);
1647 size_t len
= IDENTIFIER_LENGTH (name
);
1648 char *tmp_name
, *prefix
;
1650 prefix
= XALLOCAVEC (char, len
+ strlen ("_clone") + 1);
1651 memcpy (prefix
, IDENTIFIER_POINTER (name
), len
);
1652 strcpy (prefix
+ len
, "_clone");
1653 #ifndef NO_DOT_IN_LABEL
1655 #elif !defined NO_DOLLAR_IN_LABEL
1658 ASM_FORMAT_PRIVATE_NAME (tmp_name
, prefix
, clone_fn_id_num
++);
1659 return get_identifier (tmp_name
);
1662 /* Create callgraph node clone with new declaration. The actual body will
1663 be copied later at compilation stage.
1665 TODO: after merging in ipa-sra use function call notes instead of args_to_skip
1668 struct cgraph_node
*
1669 cgraph_create_virtual_clone (struct cgraph_node
*old_node
,
1670 VEC(cgraph_edge_p
,heap
) *redirect_callers
,
1671 VEC(ipa_replace_map_p
,gc
) *tree_map
,
1672 bitmap args_to_skip
)
1674 tree old_decl
= old_node
->decl
;
1675 struct cgraph_node
*new_node
= NULL
;
1677 struct cgraph_node key
, **slot
;
1679 struct cgraph_edge
*e
;
1681 gcc_assert (tree_versionable_function_p (old_decl
));
1683 /* Make a new FUNCTION_DECL tree node */
1685 new_decl
= copy_node (old_decl
);
1687 new_decl
= build_function_decl_skip_args (old_decl
, args_to_skip
);
1688 DECL_STRUCT_FUNCTION (new_decl
) = NULL
;
1690 /* Generate a new name for the new version. */
1691 DECL_NAME (new_decl
) = clone_function_name (old_decl
);
1692 SET_DECL_ASSEMBLER_NAME (new_decl
, DECL_NAME (new_decl
));
1693 SET_DECL_RTL (new_decl
, NULL
);
1695 new_node
= cgraph_clone_node (old_node
, old_node
->count
,
1696 CGRAPH_FREQ_BASE
, 0, false);
1697 new_node
->decl
= new_decl
;
1698 /* Update the properties.
1699 Make clone visible only within this translation unit. Make sure
1700 that is not weak also.
1701 ??? We cannot use COMDAT linkage because there is no
1702 ABI support for this. */
1703 DECL_EXTERNAL (new_node
->decl
) = 0;
1704 DECL_ONE_ONLY (new_node
->decl
) = 0;
1705 TREE_PUBLIC (new_node
->decl
) = 0;
1706 DECL_COMDAT (new_node
->decl
) = 0;
1707 DECL_WEAK (new_node
->decl
) = 0;
1708 new_node
->clone
.tree_map
= tree_map
;
1709 new_node
->clone
.args_to_skip
= args_to_skip
;
1710 new_node
->local
.externally_visible
= 0;
1711 new_node
->local
.local
= 1;
1712 new_node
->lowered
= true;
1713 new_node
->reachable
= true;
1715 key
.decl
= new_decl
;
1716 slot
= (struct cgraph_node
**) htab_find_slot (cgraph_hash
, &key
, INSERT
);
1717 gcc_assert (!*slot
);
1719 if (assembler_name_hash
)
1722 tree name
= DECL_ASSEMBLER_NAME (new_decl
);
1724 aslot
= htab_find_slot_with_hash (assembler_name_hash
, name
,
1725 decl_assembler_name_hash (name
),
1727 gcc_assert (!*aslot
);
1730 for (i
= 0; VEC_iterate (cgraph_edge_p
, redirect_callers
, i
, e
); i
++)
1732 /* Redirect calls to the old version node to point to its new
1734 cgraph_redirect_edge_callee (e
, new_node
);
1740 /* NODE is no longer nested function; update cgraph accordingly. */
1742 cgraph_unnest_node (struct cgraph_node
*node
)
1744 struct cgraph_node
**node2
= &node
->origin
->nested
;
1745 gcc_assert (node
->origin
);
1747 while (*node2
!= node
)
1748 node2
= &(*node2
)->next_nested
;
1749 *node2
= node
->next_nested
;
1750 node
->origin
= NULL
;
1753 /* Return function availability. See cgraph.h for description of individual
1756 cgraph_function_body_availability (struct cgraph_node
*node
)
1758 enum availability avail
;
1759 gcc_assert (cgraph_function_flags_ready
);
1760 if (!node
->analyzed
)
1761 avail
= AVAIL_NOT_AVAILABLE
;
1762 else if (node
->local
.local
)
1763 avail
= AVAIL_LOCAL
;
1764 else if (!node
->local
.externally_visible
)
1765 avail
= AVAIL_AVAILABLE
;
1766 /* Inline functions are safe to be analyzed even if their sybol can
1767 be overwritten at runtime. It is not meaningful to enfore any sane
1768 behaviour on replacing inline function by different body. */
1769 else if (DECL_DECLARED_INLINE_P (node
->decl
))
1770 avail
= AVAIL_AVAILABLE
;
1772 /* If the function can be overwritten, return OVERWRITABLE. Take
1773 care at least of two notable extensions - the COMDAT functions
1774 used to share template instantiations in C++ (this is symmetric
1775 to code cp_cannot_inline_tree_fn and probably shall be shared and
1776 the inlinability hooks completely eliminated).
1778 ??? Does the C++ one definition rule allow us to always return
1779 AVAIL_AVAILABLE here? That would be good reason to preserve this
1782 else if (DECL_REPLACEABLE_P (node
->decl
) && !DECL_EXTERNAL (node
->decl
))
1783 avail
= AVAIL_OVERWRITABLE
;
1784 else avail
= AVAIL_AVAILABLE
;
1789 /* Add the function FNDECL to the call graph.
1790 Unlike cgraph_finalize_function, this function is intended to be used
1791 by middle end and allows insertion of new function at arbitrary point
1792 of compilation. The function can be either in high, low or SSA form
1795 The function is assumed to be reachable and have address taken (so no
1796 API breaking optimizations are performed on it).
1798 Main work done by this function is to enqueue the function for later
1799 processing to avoid need the passes to be re-entrant. */
1802 cgraph_add_new_function (tree fndecl
, bool lowered
)
1804 struct cgraph_node
*node
;
1805 switch (cgraph_state
)
1807 case CGRAPH_STATE_CONSTRUCTION
:
1808 /* Just enqueue function to be processed at nearest occurrence. */
1809 node
= cgraph_node (fndecl
);
1810 node
->next_needed
= cgraph_new_nodes
;
1812 node
->lowered
= true;
1813 cgraph_new_nodes
= node
;
1816 case CGRAPH_STATE_IPA
:
1817 case CGRAPH_STATE_IPA_SSA
:
1818 case CGRAPH_STATE_EXPANSION
:
1819 /* Bring the function into finalized state and enqueue for later
1820 analyzing and compilation. */
1821 node
= cgraph_node (fndecl
);
1822 node
->local
.local
= false;
1823 node
->local
.finalized
= true;
1824 node
->reachable
= node
->needed
= true;
1825 if (!lowered
&& cgraph_state
== CGRAPH_STATE_EXPANSION
)
1827 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
1828 current_function_decl
= fndecl
;
1829 gimple_register_cfg_hooks ();
1830 tree_lowering_passes (fndecl
);
1831 bitmap_obstack_initialize (NULL
);
1832 if (!gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
1833 execute_pass_list (pass_early_local_passes
.pass
.sub
);
1834 bitmap_obstack_release (NULL
);
1836 current_function_decl
= NULL
;
1841 node
->lowered
= true;
1842 node
->next_needed
= cgraph_new_nodes
;
1843 cgraph_new_nodes
= node
;
1846 case CGRAPH_STATE_FINISHED
:
1847 /* At the very end of compilation we have to do all the work up
1849 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
1850 current_function_decl
= fndecl
;
1851 gimple_register_cfg_hooks ();
1853 tree_lowering_passes (fndecl
);
1854 bitmap_obstack_initialize (NULL
);
1855 if (!gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
1856 execute_pass_list (pass_early_local_passes
.pass
.sub
);
1857 bitmap_obstack_release (NULL
);
1858 tree_rest_of_compilation (fndecl
);
1860 current_function_decl
= NULL
;
1865 #include "gt-cgraph.h"