2 Copyright (C) 2003-2013 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 3, 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 COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 /* This module provide facilities for clonning functions. I.e. creating
22 new functions based on existing functions with simple modifications,
23 such as replacement of parameters.
25 To allow whole program optimization without actual presence of function
26 bodies, an additional infrastructure is provided for so-called virtual
29 A virtual clone in the callgraph is a function that has no
30 associated body, just a description of how to create its body based
31 on a different function (which itself may be a virtual clone).
33 The description of function modifications includes adjustments to
34 the function's signature (which allows, for example, removing or
35 adding function arguments), substitutions to perform on the
36 function body, and, for inlined functions, a pointer to the
37 function that it will be inlined into.
39 It is also possible to redirect any edge of the callgraph from a
40 function to its virtual clone. This implies updating of the call
41 site to adjust for the new function signature.
43 Most of the transformations performed by inter-procedural
44 optimizations can be represented via virtual clones. For
45 instance, a constant propagation pass can produce a virtual clone
46 of the function which replaces one of its arguments by a
47 constant. The inliner can represent its decisions by producing a
48 clone of a function whose body will be later integrated into
51 Using virtual clones, the program can be easily updated
52 during the Execute stage, solving most of pass interactions
53 problems that would otherwise occur during Transform.
55 Virtual clones are later materialized in the LTRANS stage and
56 turned into real functions. Passes executed after the virtual
57 clone were introduced also perform their Transform stage
58 on new functions, so for a pass there is no significant
59 difference between operating on a real function or a virtual
60 clone introduced before its Execute stage.
62 Optimization passes then work on virtual clones introduced before
63 their Execute stage as if they were real functions. The
64 only difference is that clones are not visible during the
65 Generate Summary stage. */
69 #include "coretypes.h"
73 #include "tree-flow.h"
74 #include "tree-inline.h"
75 #include "langhooks.h"
76 #include "pointer-set.h"
83 #include "diagnostic.h"
89 #include "tree-iterator.h"
90 #include "tree-dump.h"
91 #include "gimple-pretty-print.h"
93 #include "ipa-inline.h"
94 #include "ipa-utils.h"
95 #include "lto-streamer.h"
98 /* Create clone of E in the node N represented by CALL_EXPR the callgraph. */
100 cgraph_clone_edge (struct cgraph_edge
*e
, struct cgraph_node
*n
,
101 gimple call_stmt
, unsigned stmt_uid
, gcov_type count_scale
,
102 int freq_scale
, bool update_original
)
104 struct cgraph_edge
*new_edge
;
105 gcov_type count
= e
->count
* count_scale
/ REG_BR_PROB_BASE
;
108 /* We do not want to ignore loop nest after frequency drops to 0. */
111 freq
= e
->frequency
* (gcov_type
) freq_scale
/ CGRAPH_FREQ_BASE
;
112 if (freq
> CGRAPH_FREQ_MAX
)
113 freq
= CGRAPH_FREQ_MAX
;
115 if (e
->indirect_unknown_callee
)
119 if (call_stmt
&& (decl
= gimple_call_fndecl (call_stmt
)))
121 struct cgraph_node
*callee
= cgraph_get_node (decl
);
122 gcc_checking_assert (callee
);
123 new_edge
= cgraph_create_edge (n
, callee
, call_stmt
, count
, freq
);
127 new_edge
= cgraph_create_indirect_edge (n
, call_stmt
,
128 e
->indirect_info
->ecf_flags
,
130 *new_edge
->indirect_info
= *e
->indirect_info
;
135 new_edge
= cgraph_create_edge (n
, e
->callee
, call_stmt
, count
, freq
);
136 if (e
->indirect_info
)
138 new_edge
->indirect_info
139 = ggc_alloc_cleared_cgraph_indirect_call_info ();
140 *new_edge
->indirect_info
= *e
->indirect_info
;
144 new_edge
->inline_failed
= e
->inline_failed
;
145 new_edge
->indirect_inlining_edge
= e
->indirect_inlining_edge
;
146 new_edge
->lto_stmt_uid
= stmt_uid
;
147 /* Clone flags that depend on call_stmt availability manually. */
148 new_edge
->can_throw_external
= e
->can_throw_external
;
149 new_edge
->call_stmt_cannot_inline_p
= e
->call_stmt_cannot_inline_p
;
152 e
->count
-= new_edge
->count
;
156 cgraph_call_edge_duplication_hooks (e
, new_edge
);
161 /* Create node representing clone of N executed COUNT times. Decrease
162 the execution counts from original node too.
163 The new clone will have decl set to DECL that may or may not be the same
166 When UPDATE_ORIGINAL is true, the counts are subtracted from the original
167 function's profile to reflect the fact that part of execution is handled
169 When CALL_DUPLICATOIN_HOOK is true, the ipa passes are acknowledged about
170 the new clone. Otherwise the caller is responsible for doing so later. */
173 cgraph_clone_node (struct cgraph_node
*n
, tree decl
, gcov_type count
, int freq
,
174 bool update_original
,
175 vec
<cgraph_edge_p
> redirect_callers
,
176 bool call_duplication_hook
)
178 struct cgraph_node
*new_node
= cgraph_create_empty_node ();
179 struct cgraph_edge
*e
;
180 gcov_type count_scale
;
183 new_node
->symbol
.decl
= decl
;
184 symtab_register_node ((symtab_node
)new_node
);
185 new_node
->origin
= n
->origin
;
186 new_node
->symbol
.lto_file_data
= n
->symbol
.lto_file_data
;
187 if (new_node
->origin
)
189 new_node
->next_nested
= new_node
->origin
->nested
;
190 new_node
->origin
->nested
= new_node
;
192 new_node
->analyzed
= n
->analyzed
;
193 new_node
->local
= n
->local
;
194 new_node
->symbol
.externally_visible
= false;
195 new_node
->local
.local
= true;
196 new_node
->global
= n
->global
;
197 new_node
->rtl
= n
->rtl
;
198 new_node
->count
= count
;
199 new_node
->frequency
= n
->frequency
;
200 new_node
->clone
= n
->clone
;
201 new_node
->clone
.tree_map
= NULL
;
204 if (new_node
->count
> n
->count
)
205 count_scale
= REG_BR_PROB_BASE
;
207 count_scale
= new_node
->count
* REG_BR_PROB_BASE
/ n
->count
;
218 FOR_EACH_VEC_ELT (redirect_callers
, i
, e
)
220 /* Redirect calls to the old version node to point to its new
222 cgraph_redirect_edge_callee (e
, new_node
);
226 for (e
= n
->callees
;e
; e
=e
->next_callee
)
227 cgraph_clone_edge (e
, new_node
, e
->call_stmt
, e
->lto_stmt_uid
,
228 count_scale
, freq
, update_original
);
230 for (e
= n
->indirect_calls
; e
; e
= e
->next_callee
)
231 cgraph_clone_edge (e
, new_node
, e
->call_stmt
, e
->lto_stmt_uid
,
232 count_scale
, freq
, update_original
);
233 ipa_clone_references ((symtab_node
)new_node
, &n
->symbol
.ref_list
);
235 new_node
->next_sibling_clone
= n
->clones
;
237 n
->clones
->prev_sibling_clone
= new_node
;
238 n
->clones
= new_node
;
239 new_node
->clone_of
= n
;
241 if (call_duplication_hook
)
242 cgraph_call_node_duplication_hooks (n
, new_node
);
246 /* Create a new name for clone of DECL, add SUFFIX. Returns an identifier. */
248 static GTY(()) unsigned int clone_fn_id_num
;
251 clone_function_name (tree decl
, const char *suffix
)
253 tree name
= DECL_ASSEMBLER_NAME (decl
);
254 size_t len
= IDENTIFIER_LENGTH (name
);
255 char *tmp_name
, *prefix
;
257 prefix
= XALLOCAVEC (char, len
+ strlen (suffix
) + 2);
258 memcpy (prefix
, IDENTIFIER_POINTER (name
), len
);
259 strcpy (prefix
+ len
+ 1, suffix
);
260 #ifndef NO_DOT_IN_LABEL
262 #elif !defined NO_DOLLAR_IN_LABEL
267 ASM_FORMAT_PRIVATE_NAME (tmp_name
, prefix
, clone_fn_id_num
++);
268 return get_identifier (tmp_name
);
271 /* Create callgraph node clone with new declaration. The actual body will
272 be copied later at compilation stage.
274 TODO: after merging in ipa-sra use function call notes instead of args_to_skip
278 cgraph_create_virtual_clone (struct cgraph_node
*old_node
,
279 vec
<cgraph_edge_p
> redirect_callers
,
280 vec
<ipa_replace_map_p
, va_gc
> *tree_map
,
284 tree old_decl
= old_node
->symbol
.decl
;
285 struct cgraph_node
*new_node
= NULL
;
288 struct ipa_replace_map
*map
;
291 gcc_checking_assert (tree_versionable_function_p (old_decl
));
293 gcc_assert (old_node
->local
.can_change_signature
|| !args_to_skip
);
295 /* Make a new FUNCTION_DECL tree node */
297 new_decl
= copy_node (old_decl
);
299 new_decl
= build_function_decl_skip_args (old_decl
, args_to_skip
, false);
300 DECL_STRUCT_FUNCTION (new_decl
) = NULL
;
302 /* Generate a new name for the new version. */
303 DECL_NAME (new_decl
) = clone_function_name (old_decl
, suffix
);
304 SET_DECL_ASSEMBLER_NAME (new_decl
, DECL_NAME (new_decl
));
305 SET_DECL_RTL (new_decl
, NULL
);
307 new_node
= cgraph_clone_node (old_node
, new_decl
, old_node
->count
,
308 CGRAPH_FREQ_BASE
, false,
309 redirect_callers
, false);
310 /* Update the properties.
311 Make clone visible only within this translation unit. Make sure
312 that is not weak also.
313 ??? We cannot use COMDAT linkage because there is no
314 ABI support for this. */
315 DECL_EXTERNAL (new_node
->symbol
.decl
) = 0;
316 if (DECL_ONE_ONLY (old_decl
))
317 DECL_SECTION_NAME (new_node
->symbol
.decl
) = NULL
;
318 DECL_COMDAT_GROUP (new_node
->symbol
.decl
) = 0;
319 TREE_PUBLIC (new_node
->symbol
.decl
) = 0;
320 DECL_COMDAT (new_node
->symbol
.decl
) = 0;
321 DECL_WEAK (new_node
->symbol
.decl
) = 0;
322 DECL_VIRTUAL_P (new_node
->symbol
.decl
) = 0;
323 DECL_STATIC_CONSTRUCTOR (new_node
->symbol
.decl
) = 0;
324 DECL_STATIC_DESTRUCTOR (new_node
->symbol
.decl
) = 0;
325 new_node
->clone
.tree_map
= tree_map
;
326 new_node
->clone
.args_to_skip
= args_to_skip
;
327 FOR_EACH_VEC_SAFE_ELT (tree_map
, i
, map
)
329 tree var
= map
->new_tree
;
330 symtab_node ref_node
;
333 if (TREE_CODE (var
) != ADDR_EXPR
)
335 var
= get_base_var (var
);
338 if (TREE_CODE (var
) != FUNCTION_DECL
339 && TREE_CODE (var
) != VAR_DECL
)
342 /* Record references of the future statement initializing the constant
344 ref_node
= symtab_get_node (var
);
345 gcc_checking_assert (ref_node
);
346 ipa_record_reference ((symtab_node
)new_node
, (symtab_node
)ref_node
,
350 new_node
->clone
.combined_args_to_skip
= old_node
->clone
.combined_args_to_skip
;
351 else if (old_node
->clone
.combined_args_to_skip
)
353 int newi
= 0, oldi
= 0;
355 bitmap new_args_to_skip
= BITMAP_GGC_ALLOC ();
356 struct cgraph_node
*orig_node
;
357 for (orig_node
= old_node
; orig_node
->clone_of
; orig_node
= orig_node
->clone_of
)
359 for (arg
= DECL_ARGUMENTS (orig_node
->symbol
.decl
);
360 arg
; arg
= DECL_CHAIN (arg
), oldi
++)
362 if (bitmap_bit_p (old_node
->clone
.combined_args_to_skip
, oldi
))
364 bitmap_set_bit (new_args_to_skip
, oldi
);
367 if (bitmap_bit_p (args_to_skip
, newi
))
368 bitmap_set_bit (new_args_to_skip
, oldi
);
371 new_node
->clone
.combined_args_to_skip
= new_args_to_skip
;
374 new_node
->clone
.combined_args_to_skip
= args_to_skip
;
375 new_node
->symbol
.externally_visible
= 0;
376 new_node
->local
.local
= 1;
377 new_node
->lowered
= true;
379 cgraph_call_node_duplication_hooks (old_node
, new_node
);
385 /* NODE is being removed from symbol table; see if its entry can be replaced by
386 other inline clone. */
388 cgraph_find_replacement_node (struct cgraph_node
*node
)
390 struct cgraph_node
*next_inline_clone
, *replacement
;
392 for (next_inline_clone
= node
->clones
;
394 && next_inline_clone
->symbol
.decl
!= node
->symbol
.decl
;
395 next_inline_clone
= next_inline_clone
->next_sibling_clone
)
398 /* If there is inline clone of the node being removed, we need
399 to put it into the position of removed node and reorganize all
400 other clones to be based on it. */
401 if (next_inline_clone
)
403 struct cgraph_node
*n
;
404 struct cgraph_node
*new_clones
;
406 replacement
= next_inline_clone
;
408 /* Unlink inline clone from the list of clones of removed node. */
409 if (next_inline_clone
->next_sibling_clone
)
410 next_inline_clone
->next_sibling_clone
->prev_sibling_clone
411 = next_inline_clone
->prev_sibling_clone
;
412 if (next_inline_clone
->prev_sibling_clone
)
414 gcc_assert (node
->clones
!= next_inline_clone
);
415 next_inline_clone
->prev_sibling_clone
->next_sibling_clone
416 = next_inline_clone
->next_sibling_clone
;
420 gcc_assert (node
->clones
== next_inline_clone
);
421 node
->clones
= next_inline_clone
->next_sibling_clone
;
424 new_clones
= node
->clones
;
427 /* Copy clone info. */
428 next_inline_clone
->clone
= node
->clone
;
430 /* Now place it into clone tree at same level at NODE. */
431 next_inline_clone
->clone_of
= node
->clone_of
;
432 next_inline_clone
->prev_sibling_clone
= NULL
;
433 next_inline_clone
->next_sibling_clone
= NULL
;
436 if (node
->clone_of
->clones
)
437 node
->clone_of
->clones
->prev_sibling_clone
= next_inline_clone
;
438 next_inline_clone
->next_sibling_clone
= node
->clone_of
->clones
;
439 node
->clone_of
->clones
= next_inline_clone
;
442 /* Merge the clone list. */
445 if (!next_inline_clone
->clones
)
446 next_inline_clone
->clones
= new_clones
;
449 n
= next_inline_clone
->clones
;
450 while (n
->next_sibling_clone
)
451 n
= n
->next_sibling_clone
;
452 n
->next_sibling_clone
= new_clones
;
453 new_clones
->prev_sibling_clone
= n
;
457 /* Update clone_of pointers. */
461 n
->clone_of
= next_inline_clone
;
462 n
= n
->next_sibling_clone
;
470 /* Like cgraph_set_call_stmt but walk the clone tree and update all
471 clones sharing the same function body. */
474 cgraph_set_call_stmt_including_clones (struct cgraph_node
*orig
,
475 gimple old_stmt
, gimple new_stmt
)
477 struct cgraph_node
*node
;
478 struct cgraph_edge
*edge
= cgraph_edge (orig
, old_stmt
);
481 cgraph_set_call_stmt (edge
, new_stmt
);
487 struct cgraph_edge
*edge
= cgraph_edge (node
, old_stmt
);
489 cgraph_set_call_stmt (edge
, new_stmt
);
492 else if (node
->next_sibling_clone
)
493 node
= node
->next_sibling_clone
;
496 while (node
!= orig
&& !node
->next_sibling_clone
)
497 node
= node
->clone_of
;
499 node
= node
->next_sibling_clone
;
504 /* Like cgraph_create_edge walk the clone tree and update all clones sharing
505 same function body. If clones already have edge for OLD_STMT; only
506 update the edge same way as cgraph_set_call_stmt_including_clones does.
508 TODO: COUNT and LOOP_DEPTH should be properly distributed based on relative
509 frequencies of the clones. */
512 cgraph_create_edge_including_clones (struct cgraph_node
*orig
,
513 struct cgraph_node
*callee
,
515 gimple stmt
, gcov_type count
,
517 cgraph_inline_failed_t reason
)
519 struct cgraph_node
*node
;
520 struct cgraph_edge
*edge
;
522 if (!cgraph_edge (orig
, stmt
))
524 edge
= cgraph_create_edge (orig
, callee
, stmt
, count
, freq
);
525 edge
->inline_failed
= reason
;
532 struct cgraph_edge
*edge
= cgraph_edge (node
, old_stmt
);
534 /* It is possible that clones already contain the edge while
535 master didn't. Either we promoted indirect call into direct
536 call in the clone or we are processing clones of unreachable
537 master where edges has been removed. */
539 cgraph_set_call_stmt (edge
, stmt
);
540 else if (!cgraph_edge (node
, stmt
))
542 edge
= cgraph_create_edge (node
, callee
, stmt
, count
,
544 edge
->inline_failed
= reason
;
549 else if (node
->next_sibling_clone
)
550 node
= node
->next_sibling_clone
;
553 while (node
!= orig
&& !node
->next_sibling_clone
)
554 node
= node
->clone_of
;
556 node
= node
->next_sibling_clone
;
561 /* Remove the node from cgraph and all inline clones inlined into it.
562 Skip however removal of FORBIDDEN_NODE and return true if it needs to be
563 removed. This allows to call the function from outer loop walking clone
567 cgraph_remove_node_and_inline_clones (struct cgraph_node
*node
, struct cgraph_node
*forbidden_node
)
569 struct cgraph_edge
*e
, *next
;
572 if (node
== forbidden_node
)
574 for (e
= node
->callees
; e
; e
= next
)
576 next
= e
->next_callee
;
577 if (!e
->inline_failed
)
578 found
|= cgraph_remove_node_and_inline_clones (e
->callee
, forbidden_node
);
580 cgraph_remove_node (node
);
584 /* The edges representing the callers of the NEW_VERSION node were
585 fixed by cgraph_function_versioning (), now the call_expr in their
586 respective tree code should be updated to call the NEW_VERSION. */
589 update_call_expr (struct cgraph_node
*new_version
)
591 struct cgraph_edge
*e
;
593 gcc_assert (new_version
);
595 /* Update the call expr on the edges to call the new version. */
596 for (e
= new_version
->callers
; e
; e
= e
->next_caller
)
598 struct function
*inner_function
= DECL_STRUCT_FUNCTION (e
->caller
->symbol
.decl
);
599 gimple_call_set_fndecl (e
->call_stmt
, new_version
->symbol
.decl
);
600 maybe_clean_eh_stmt_fn (inner_function
, e
->call_stmt
);
605 /* Create a new cgraph node which is the new version of
606 OLD_VERSION node. REDIRECT_CALLERS holds the callers
607 edges which should be redirected to point to
608 NEW_VERSION. ALL the callees edges of OLD_VERSION
609 are cloned to the new version node. Return the new
612 If non-NULL BLOCK_TO_COPY determine what basic blocks
613 was copied to prevent duplications of calls that are dead
617 cgraph_copy_node_for_versioning (struct cgraph_node
*old_version
,
619 vec
<cgraph_edge_p
> redirect_callers
,
622 struct cgraph_node
*new_version
;
623 struct cgraph_edge
*e
;
626 gcc_assert (old_version
);
628 new_version
= cgraph_create_node (new_decl
);
630 new_version
->analyzed
= old_version
->analyzed
;
631 new_version
->local
= old_version
->local
;
632 new_version
->symbol
.externally_visible
= false;
633 new_version
->local
.local
= old_version
->analyzed
;
634 new_version
->global
= old_version
->global
;
635 new_version
->rtl
= old_version
->rtl
;
636 new_version
->count
= old_version
->count
;
638 for (e
= old_version
->callees
; e
; e
=e
->next_callee
)
640 || bitmap_bit_p (bbs_to_copy
, gimple_bb (e
->call_stmt
)->index
))
641 cgraph_clone_edge (e
, new_version
, e
->call_stmt
,
642 e
->lto_stmt_uid
, REG_BR_PROB_BASE
,
645 for (e
= old_version
->indirect_calls
; e
; e
=e
->next_callee
)
647 || bitmap_bit_p (bbs_to_copy
, gimple_bb (e
->call_stmt
)->index
))
648 cgraph_clone_edge (e
, new_version
, e
->call_stmt
,
649 e
->lto_stmt_uid
, REG_BR_PROB_BASE
,
652 FOR_EACH_VEC_ELT (redirect_callers
, i
, e
)
654 /* Redirect calls to the old version node to point to its new
656 cgraph_redirect_edge_callee (e
, new_version
);
659 cgraph_call_node_duplication_hooks (old_version
, new_version
);
664 /* Perform function versioning.
665 Function versioning includes copying of the tree and
666 a callgraph update (creating a new cgraph node and updating
667 its callees and callers).
669 REDIRECT_CALLERS varray includes the edges to be redirected
672 TREE_MAP is a mapping of tree nodes we want to replace with
673 new ones (according to results of prior analysis).
674 OLD_VERSION_NODE is the node that is versioned.
676 If non-NULL ARGS_TO_SKIP determine function parameters to remove
678 If SKIP_RETURN is true, the new version will return void.
679 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
680 If non_NULL NEW_ENTRY determine new entry BB of the clone.
682 Return the new version's cgraph node. */
685 cgraph_function_versioning (struct cgraph_node
*old_version_node
,
686 vec
<cgraph_edge_p
> redirect_callers
,
687 vec
<ipa_replace_map_p
, va_gc
> *tree_map
,
691 basic_block new_entry_block
,
692 const char *clone_name
)
694 tree old_decl
= old_version_node
->symbol
.decl
;
695 struct cgraph_node
*new_version_node
= NULL
;
698 if (!tree_versionable_function_p (old_decl
))
701 gcc_assert (old_version_node
->local
.can_change_signature
|| !args_to_skip
);
703 /* Make a new FUNCTION_DECL tree node for the new version. */
704 if (!args_to_skip
&& !skip_return
)
705 new_decl
= copy_node (old_decl
);
708 = build_function_decl_skip_args (old_decl
, args_to_skip
, skip_return
);
710 /* Generate a new name for the new version. */
711 DECL_NAME (new_decl
) = clone_function_name (old_decl
, clone_name
);
712 SET_DECL_ASSEMBLER_NAME (new_decl
, DECL_NAME (new_decl
));
713 SET_DECL_RTL (new_decl
, NULL
);
715 /* When the old decl was a con-/destructor make sure the clone isn't. */
716 DECL_STATIC_CONSTRUCTOR(new_decl
) = 0;
717 DECL_STATIC_DESTRUCTOR(new_decl
) = 0;
719 /* Create the new version's call-graph node.
720 and update the edges of the new node. */
722 cgraph_copy_node_for_versioning (old_version_node
, new_decl
,
723 redirect_callers
, bbs_to_copy
);
725 /* Copy the OLD_VERSION_NODE function tree to the new version. */
726 tree_function_versioning (old_decl
, new_decl
, tree_map
, false, args_to_skip
,
727 skip_return
, bbs_to_copy
, new_entry_block
);
729 /* Update the new version's properties.
730 Make The new version visible only within this translation unit. Make sure
731 that is not weak also.
732 ??? We cannot use COMDAT linkage because there is no
733 ABI support for this. */
734 symtab_make_decl_local (new_version_node
->symbol
.decl
);
735 DECL_VIRTUAL_P (new_version_node
->symbol
.decl
) = 0;
736 new_version_node
->symbol
.externally_visible
= 0;
737 new_version_node
->local
.local
= 1;
738 new_version_node
->lowered
= true;
740 /* Update the call_expr on the edges to call the new version node. */
741 update_call_expr (new_version_node
);
743 cgraph_call_function_insertion_hooks (new_version_node
);
744 return new_version_node
;
747 /* Given virtual clone, turn it into actual clone. */
750 cgraph_materialize_clone (struct cgraph_node
*node
)
752 bitmap_obstack_initialize (NULL
);
753 node
->former_clone_of
= node
->clone_of
->symbol
.decl
;
754 if (node
->clone_of
->former_clone_of
)
755 node
->former_clone_of
= node
->clone_of
->former_clone_of
;
756 /* Copy the OLD_VERSION_NODE function tree to the new version. */
757 tree_function_versioning (node
->clone_of
->symbol
.decl
, node
->symbol
.decl
,
758 node
->clone
.tree_map
, true,
759 node
->clone
.args_to_skip
, false,
761 if (cgraph_dump_file
)
763 dump_function_to_file (node
->clone_of
->symbol
.decl
, cgraph_dump_file
, dump_flags
);
764 dump_function_to_file (node
->symbol
.decl
, cgraph_dump_file
, dump_flags
);
767 /* Function is no longer clone. */
768 if (node
->next_sibling_clone
)
769 node
->next_sibling_clone
->prev_sibling_clone
= node
->prev_sibling_clone
;
770 if (node
->prev_sibling_clone
)
771 node
->prev_sibling_clone
->next_sibling_clone
= node
->next_sibling_clone
;
773 node
->clone_of
->clones
= node
->next_sibling_clone
;
774 node
->next_sibling_clone
= NULL
;
775 node
->prev_sibling_clone
= NULL
;
776 if (!node
->clone_of
->analyzed
&& !node
->clone_of
->clones
)
778 cgraph_release_function_body (node
->clone_of
);
779 cgraph_node_remove_callees (node
->clone_of
);
780 ipa_remove_all_references (&node
->clone_of
->symbol
.ref_list
);
782 node
->clone_of
= NULL
;
783 bitmap_obstack_release (NULL
);
786 /* Once all functions from compilation unit are in memory, produce all clones
787 and update all calls. We might also do this on demand if we don't want to
788 bring all functions to memory prior compilation, but current WHOPR
789 implementation does that and it is is bit easier to keep everything right in
793 cgraph_materialize_all_clones (void)
795 struct cgraph_node
*node
;
796 bool stabilized
= false;
798 if (cgraph_dump_file
)
799 fprintf (cgraph_dump_file
, "Materializing clones\n");
800 #ifdef ENABLE_CHECKING
804 /* We can also do topological order, but number of iterations should be
805 bounded by number of IPA passes since single IPA pass is probably not
806 going to create clones of clones it created itself. */
810 FOR_EACH_FUNCTION (node
)
812 if (node
->clone_of
&& node
->symbol
.decl
!= node
->clone_of
->symbol
.decl
813 && !gimple_has_body_p (node
->symbol
.decl
))
815 if (gimple_has_body_p (node
->clone_of
->symbol
.decl
))
817 if (cgraph_dump_file
)
819 fprintf (cgraph_dump_file
, "cloning %s to %s\n",
820 xstrdup (cgraph_node_name (node
->clone_of
)),
821 xstrdup (cgraph_node_name (node
)));
822 if (node
->clone
.tree_map
)
825 fprintf (cgraph_dump_file
, " replace map: ");
827 i
< vec_safe_length (node
->clone
.tree_map
);
830 struct ipa_replace_map
*replace_info
;
831 replace_info
= (*node
->clone
.tree_map
)[i
];
832 print_generic_expr (cgraph_dump_file
, replace_info
->old_tree
, 0);
833 fprintf (cgraph_dump_file
, " -> ");
834 print_generic_expr (cgraph_dump_file
, replace_info
->new_tree
, 0);
835 fprintf (cgraph_dump_file
, "%s%s;",
836 replace_info
->replace_p
? "(replace)":"",
837 replace_info
->ref_p
? "(ref)":"");
839 fprintf (cgraph_dump_file
, "\n");
841 if (node
->clone
.args_to_skip
)
843 fprintf (cgraph_dump_file
, " args_to_skip: ");
844 dump_bitmap (cgraph_dump_file
, node
->clone
.args_to_skip
);
846 if (node
->clone
.args_to_skip
)
848 fprintf (cgraph_dump_file
, " combined_args_to_skip:");
849 dump_bitmap (cgraph_dump_file
, node
->clone
.combined_args_to_skip
);
852 cgraph_materialize_clone (node
);
858 FOR_EACH_FUNCTION (node
)
859 if (!node
->analyzed
&& node
->callees
)
860 cgraph_node_remove_callees (node
);
861 if (cgraph_dump_file
)
862 fprintf (cgraph_dump_file
, "Materialization Call site updates done.\n");
863 #ifdef ENABLE_CHECKING
866 symtab_remove_unreachable_nodes (false, cgraph_dump_file
);
869 #include "gt-cgraphclones.h"