2 Copyright (C) 2003-2014 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 "stringpool.h"
78 #include "hard-reg-set.h"
82 #include "basic-block.h"
83 #include "tree-ssa-alias.h"
84 #include "internal-fn.h"
86 #include "gimple-expr.h"
91 #include "tree-inline.h"
92 #include "langhooks.h"
97 #include "diagnostic.h"
100 #include "ipa-prop.h"
101 #include "tree-iterator.h"
102 #include "tree-dump.h"
103 #include "gimple-pretty-print.h"
104 #include "coverage.h"
105 #include "ipa-inline.h"
106 #include "ipa-utils.h"
107 #include "lto-streamer.h"
110 /* Create clone of edge in the node N represented by CALL_EXPR
114 cgraph_edge::clone (cgraph_node
*n
, gimple call_stmt
, unsigned stmt_uid
,
115 gcov_type count_scale
, int freq_scale
, bool update_original
)
117 cgraph_edge
*new_edge
;
118 gcov_type gcov_count
= apply_probability (count
, count_scale
);
121 /* We do not want to ignore loop nest after frequency drops to 0. */
124 freq
= frequency
* (gcov_type
) freq_scale
/ CGRAPH_FREQ_BASE
;
125 if (freq
> CGRAPH_FREQ_MAX
)
126 freq
= CGRAPH_FREQ_MAX
;
128 if (indirect_unknown_callee
)
132 if (call_stmt
&& (decl
= gimple_call_fndecl (call_stmt
))
133 /* When the call is speculative, we need to resolve it
134 via cgraph_resolve_speculation and not here. */
137 cgraph_node
*callee
= cgraph_node::get (decl
);
138 gcc_checking_assert (callee
);
139 new_edge
= n
->create_edge (callee
, call_stmt
, gcov_count
, freq
);
143 new_edge
= n
->create_indirect_edge (call_stmt
,
144 indirect_info
->ecf_flags
,
146 *new_edge
->indirect_info
= *indirect_info
;
151 new_edge
= n
->create_edge (callee
, call_stmt
, gcov_count
, freq
);
154 new_edge
->indirect_info
155 = ggc_cleared_alloc
<cgraph_indirect_call_info
> ();
156 *new_edge
->indirect_info
= *indirect_info
;
160 new_edge
->inline_failed
= inline_failed
;
161 new_edge
->indirect_inlining_edge
= indirect_inlining_edge
;
162 new_edge
->lto_stmt_uid
= stmt_uid
;
163 /* Clone flags that depend on call_stmt availability manually. */
164 new_edge
->can_throw_external
= can_throw_external
;
165 new_edge
->call_stmt_cannot_inline_p
= call_stmt_cannot_inline_p
;
166 new_edge
->speculative
= speculative
;
167 new_edge
->in_polymorphic_cdtor
= in_polymorphic_cdtor
;
170 count
-= new_edge
->count
;
174 symtab
->call_edge_duplication_hooks (this, new_edge
);
178 /* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP and the
179 return value if SKIP_RETURN is true. */
182 build_function_type_skip_args (tree orig_type
, bitmap args_to_skip
,
185 tree new_type
= NULL
;
186 tree args
, new_args
= NULL
;
190 for (args
= TYPE_ARG_TYPES (orig_type
); args
&& args
!= void_list_node
;
191 args
= TREE_CHAIN (args
), i
++)
192 if (!args_to_skip
|| !bitmap_bit_p (args_to_skip
, i
))
193 new_args
= tree_cons (NULL_TREE
, TREE_VALUE (args
), new_args
);
195 new_reversed
= nreverse (new_args
);
199 TREE_CHAIN (new_args
) = void_list_node
;
201 new_reversed
= void_list_node
;
204 /* Use copy_node to preserve as much as possible from original type
205 (debug info, attribute lists etc.)
206 Exception is METHOD_TYPEs must have THIS argument.
207 When we are asked to remove it, we need to build new FUNCTION_TYPE
209 if (TREE_CODE (orig_type
) != METHOD_TYPE
211 || !bitmap_bit_p (args_to_skip
, 0))
213 new_type
= build_distinct_type_copy (orig_type
);
214 TYPE_ARG_TYPES (new_type
) = new_reversed
;
219 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type
),
221 TYPE_CONTEXT (new_type
) = TYPE_CONTEXT (orig_type
);
225 TREE_TYPE (new_type
) = void_type_node
;
230 /* Build variant of function decl ORIG_DECL skipping ARGS_TO_SKIP and the
231 return value if SKIP_RETURN is true.
233 Arguments from DECL_ARGUMENTS list can't be removed now, since they are
234 linked by TREE_CHAIN directly. The caller is responsible for eliminating
235 them when they are being duplicated (i.e. copy_arguments_for_versioning). */
238 build_function_decl_skip_args (tree orig_decl
, bitmap args_to_skip
,
241 tree new_decl
= copy_node (orig_decl
);
244 new_type
= TREE_TYPE (orig_decl
);
245 if (prototype_p (new_type
)
246 || (skip_return
&& !VOID_TYPE_P (TREE_TYPE (new_type
))))
248 = build_function_type_skip_args (new_type
, args_to_skip
, skip_return
);
249 TREE_TYPE (new_decl
) = new_type
;
251 /* For declarations setting DECL_VINDEX (i.e. methods)
252 we expect first argument to be THIS pointer. */
253 if (args_to_skip
&& bitmap_bit_p (args_to_skip
, 0))
254 DECL_VINDEX (new_decl
) = NULL_TREE
;
256 /* When signature changes, we need to clear builtin info. */
257 if (DECL_BUILT_IN (new_decl
)
259 && !bitmap_empty_p (args_to_skip
))
261 DECL_BUILT_IN_CLASS (new_decl
) = NOT_BUILT_IN
;
262 DECL_FUNCTION_CODE (new_decl
) = (enum built_in_function
) 0;
264 /* The FE might have information and assumptions about the other
266 DECL_LANG_SPECIFIC (new_decl
) = NULL
;
270 /* Set flags of NEW_NODE and its decl. NEW_NODE is a newly created private
271 clone or its thunk. */
274 set_new_clone_decl_and_node_flags (cgraph_node
*new_node
)
276 DECL_EXTERNAL (new_node
->decl
) = 0;
277 TREE_PUBLIC (new_node
->decl
) = 0;
278 DECL_COMDAT (new_node
->decl
) = 0;
279 DECL_WEAK (new_node
->decl
) = 0;
280 DECL_VIRTUAL_P (new_node
->decl
) = 0;
281 DECL_STATIC_CONSTRUCTOR (new_node
->decl
) = 0;
282 DECL_STATIC_DESTRUCTOR (new_node
->decl
) = 0;
284 new_node
->externally_visible
= 0;
285 new_node
->local
.local
= 1;
286 new_node
->lowered
= true;
289 /* Duplicate thunk THUNK if necessary but make it to refer to NODE.
290 ARGS_TO_SKIP, if non-NULL, determines which parameters should be omitted.
291 Function can return NODE if no thunk is necessary, which can happen when
292 thunk is this_adjusting but we are removing this parameter. */
295 duplicate_thunk_for_node (cgraph_node
*thunk
, cgraph_node
*node
)
297 cgraph_node
*new_thunk
, *thunk_of
;
298 thunk_of
= thunk
->callees
->callee
->ultimate_alias_target ();
300 if (thunk_of
->thunk
.thunk_p
)
301 node
= duplicate_thunk_for_node (thunk_of
, node
);
303 if (!DECL_ARGUMENTS (thunk
->decl
))
307 for (cs
= node
->callers
; cs
; cs
= cs
->next_caller
)
308 if (cs
->caller
->thunk
.thunk_p
309 && cs
->caller
->thunk
.this_adjusting
== thunk
->thunk
.this_adjusting
310 && cs
->caller
->thunk
.fixed_offset
== thunk
->thunk
.fixed_offset
311 && cs
->caller
->thunk
.virtual_offset_p
== thunk
->thunk
.virtual_offset_p
312 && cs
->caller
->thunk
.virtual_value
== thunk
->thunk
.virtual_value
)
316 if (!node
->clone
.args_to_skip
)
317 new_decl
= copy_node (thunk
->decl
);
320 /* We do not need to duplicate this_adjusting thunks if we have removed
322 if (thunk
->thunk
.this_adjusting
323 && bitmap_bit_p (node
->clone
.args_to_skip
, 0))
326 new_decl
= build_function_decl_skip_args (thunk
->decl
,
327 node
->clone
.args_to_skip
,
331 tree
*link
= &DECL_ARGUMENTS (new_decl
);
333 for (tree pd
= DECL_ARGUMENTS (thunk
->decl
); pd
; pd
= DECL_CHAIN (pd
), i
++)
335 if (!node
->clone
.args_to_skip
336 || !bitmap_bit_p (node
->clone
.args_to_skip
, i
))
338 tree nd
= copy_node (pd
);
339 DECL_CONTEXT (nd
) = new_decl
;
341 link
= &DECL_CHAIN (nd
);
346 gcc_checking_assert (!DECL_STRUCT_FUNCTION (new_decl
));
347 gcc_checking_assert (!DECL_INITIAL (new_decl
));
348 gcc_checking_assert (!DECL_RESULT (new_decl
));
349 gcc_checking_assert (!DECL_RTL_SET_P (new_decl
));
351 DECL_NAME (new_decl
) = clone_function_name (thunk
->decl
, "artificial_thunk");
352 SET_DECL_ASSEMBLER_NAME (new_decl
, DECL_NAME (new_decl
));
354 new_thunk
= cgraph_node::create (new_decl
);
355 set_new_clone_decl_and_node_flags (new_thunk
);
356 new_thunk
->definition
= true;
357 new_thunk
->thunk
= thunk
->thunk
;
358 new_thunk
->unique_name
= in_lto_p
;
359 new_thunk
->former_clone_of
= thunk
->decl
;
360 new_thunk
->clone
.args_to_skip
= node
->clone
.args_to_skip
;
361 new_thunk
->clone
.combined_args_to_skip
= node
->clone
.combined_args_to_skip
;
363 cgraph_edge
*e
= new_thunk
->create_edge (node
, NULL
, 0,
365 e
->call_stmt_cannot_inline_p
= true;
366 symtab
->call_edge_duplication_hooks (thunk
->callees
, e
);
367 if (new_thunk
->expand_thunk (false, false))
369 new_thunk
->thunk
.thunk_p
= false;
370 new_thunk
->analyze ();
373 symtab
->call_cgraph_duplication_hooks (thunk
, new_thunk
);
377 /* If E does not lead to a thunk, simply redirect it to N. Otherwise create
378 one or more equivalent thunks for N and redirect E to the first in the
382 redirect_edge_duplicating_thunks (cgraph_edge
*e
, cgraph_node
*n
)
384 cgraph_node
*orig_to
= e
->callee
->ultimate_alias_target ();
385 if (orig_to
->thunk
.thunk_p
)
386 n
= duplicate_thunk_for_node (orig_to
, n
);
388 e
->redirect_callee (n
);
391 /* Create node representing clone of N executed COUNT times. Decrease
392 the execution counts from original node too.
393 The new clone will have decl set to DECL that may or may not be the same
396 When UPDATE_ORIGINAL is true, the counts are subtracted from the original
397 function's profile to reflect the fact that part of execution is handled
399 When CALL_DUPLICATOIN_HOOK is true, the ipa passes are acknowledged about
400 the new clone. Otherwise the caller is responsible for doing so later.
402 If the new node is being inlined into another one, NEW_INLINED_TO should be
403 the outline function the new one is (even indirectly) inlined to. All hooks
404 will see this in node's global.inlined_to, when invoked. Can be NULL if the
405 node is not inlined. */
408 cgraph_node::create_clone (tree decl
, gcov_type gcov_count
, int freq
,
409 bool update_original
,
410 vec
<cgraph_edge
*> redirect_callers
,
411 bool call_duplication_hook
,
412 cgraph_node
*new_inlined_to
,
415 cgraph_node
*new_node
= symtab
->create_empty ();
417 gcov_type count_scale
;
420 new_node
->decl
= decl
;
421 new_node
->register_symbol ();
422 new_node
->origin
= origin
;
423 new_node
->lto_file_data
= lto_file_data
;
424 if (new_node
->origin
)
426 new_node
->next_nested
= new_node
->origin
->nested
;
427 new_node
->origin
->nested
= new_node
;
429 new_node
->analyzed
= analyzed
;
430 new_node
->definition
= definition
;
431 new_node
->local
= local
;
432 new_node
->externally_visible
= false;
433 new_node
->no_reorder
= no_reorder
;
434 new_node
->local
.local
= true;
435 new_node
->global
= global
;
436 new_node
->global
.inlined_to
= new_inlined_to
;
438 new_node
->count
= count
;
439 new_node
->frequency
= frequency
;
440 new_node
->tp_first_run
= tp_first_run
;
441 new_node
->tm_clone
= tm_clone
;
443 new_node
->clone
.tree_map
= NULL
;
444 new_node
->clone
.args_to_skip
= args_to_skip
;
446 new_node
->clone
.combined_args_to_skip
= clone
.combined_args_to_skip
;
447 else if (clone
.combined_args_to_skip
)
449 new_node
->clone
.combined_args_to_skip
= BITMAP_GGC_ALLOC ();
450 bitmap_ior (new_node
->clone
.combined_args_to_skip
,
451 clone
.combined_args_to_skip
, args_to_skip
);
454 new_node
->clone
.combined_args_to_skip
= args_to_skip
;
458 if (new_node
->count
> count
)
459 count_scale
= REG_BR_PROB_BASE
;
461 count_scale
= GCOV_COMPUTE_SCALE (new_node
->count
, count
);
472 FOR_EACH_VEC_ELT (redirect_callers
, i
, e
)
474 /* Redirect calls to the old version node to point to its new
475 version. The only exception is when the edge was proved to
476 be unreachable during the clonning procedure. */
478 || DECL_BUILT_IN_CLASS (e
->callee
->decl
) != BUILT_IN_NORMAL
479 || DECL_FUNCTION_CODE (e
->callee
->decl
) != BUILT_IN_UNREACHABLE
)
480 redirect_edge_duplicating_thunks (e
, new_node
);
483 for (e
= callees
;e
; e
=e
->next_callee
)
484 e
->clone (new_node
, e
->call_stmt
, e
->lto_stmt_uid
, count_scale
,
485 freq
, update_original
);
487 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
488 e
->clone (new_node
, e
->call_stmt
, e
->lto_stmt_uid
,
489 count_scale
, freq
, update_original
);
490 new_node
->clone_references (this);
492 new_node
->next_sibling_clone
= clones
;
494 clones
->prev_sibling_clone
= new_node
;
496 new_node
->clone_of
= this;
498 if (call_duplication_hook
)
499 symtab
->call_cgraph_duplication_hooks (this, new_node
);
503 /* Return a new assembler name for a clone of DECL with SUFFIX. */
505 static GTY(()) unsigned int clone_fn_id_num
;
508 clone_function_name (tree decl
, const char *suffix
)
510 tree name
= DECL_ASSEMBLER_NAME (decl
);
511 size_t len
= IDENTIFIER_LENGTH (name
);
512 char *tmp_name
, *prefix
;
514 prefix
= XALLOCAVEC (char, len
+ strlen (suffix
) + 2);
515 memcpy (prefix
, IDENTIFIER_POINTER (name
), len
);
516 strcpy (prefix
+ len
+ 1, suffix
);
517 #ifndef NO_DOT_IN_LABEL
519 #elif !defined NO_DOLLAR_IN_LABEL
524 ASM_FORMAT_PRIVATE_NAME (tmp_name
, prefix
, clone_fn_id_num
++);
525 return get_identifier (tmp_name
);
528 /* Create callgraph node clone with new declaration. The actual body will
529 be copied later at compilation stage.
531 TODO: after merging in ipa-sra use function call notes instead of args_to_skip
535 cgraph_node::create_virtual_clone (vec
<cgraph_edge
*> redirect_callers
,
536 vec
<ipa_replace_map
*, va_gc
> *tree_map
,
537 bitmap args_to_skip
, const char * suffix
)
539 tree old_decl
= decl
;
540 cgraph_node
*new_node
= NULL
;
543 ipa_replace_map
*map
;
547 gcc_checking_assert (tree_versionable_function_p (old_decl
));
549 gcc_assert (local
.can_change_signature
|| !args_to_skip
);
551 /* Make a new FUNCTION_DECL tree node */
553 new_decl
= copy_node (old_decl
);
555 new_decl
= build_function_decl_skip_args (old_decl
, args_to_skip
, false);
557 /* These pointers represent function body and will be populated only when clone
559 gcc_assert (new_decl
!= old_decl
);
560 DECL_STRUCT_FUNCTION (new_decl
) = NULL
;
561 DECL_ARGUMENTS (new_decl
) = NULL
;
562 DECL_INITIAL (new_decl
) = NULL
;
563 DECL_RESULT (new_decl
) = NULL
;
564 /* We can not do DECL_RESULT (new_decl) = NULL; here because of LTO partitioning
565 sometimes storing only clone decl instead of original. */
567 /* Generate a new name for the new version. */
568 len
= IDENTIFIER_LENGTH (DECL_NAME (old_decl
));
569 name
= XALLOCAVEC (char, len
+ strlen (suffix
) + 2);
570 memcpy (name
, IDENTIFIER_POINTER (DECL_NAME (old_decl
)), len
);
571 strcpy (name
+ len
+ 1, suffix
);
573 DECL_NAME (new_decl
) = get_identifier (name
);
574 SET_DECL_ASSEMBLER_NAME (new_decl
, clone_function_name (old_decl
, suffix
));
575 SET_DECL_RTL (new_decl
, NULL
);
577 new_node
= create_clone (new_decl
, count
, CGRAPH_FREQ_BASE
, false,
578 redirect_callers
, false, NULL
, args_to_skip
);
580 /* Update the properties.
581 Make clone visible only within this translation unit. Make sure
582 that is not weak also.
583 ??? We cannot use COMDAT linkage because there is no
584 ABI support for this. */
585 set_new_clone_decl_and_node_flags (new_node
);
586 new_node
->clone
.tree_map
= tree_map
;
588 /* Clones of global symbols or symbols with unique names are unique. */
589 if ((TREE_PUBLIC (old_decl
)
590 && !DECL_EXTERNAL (old_decl
)
591 && !DECL_WEAK (old_decl
)
592 && !DECL_COMDAT (old_decl
))
594 new_node
->unique_name
= true;
595 FOR_EACH_VEC_SAFE_ELT (tree_map
, i
, map
)
596 new_node
->maybe_create_reference (map
->new_tree
, IPA_REF_ADDR
, NULL
);
598 if (ipa_transforms_to_apply
.exists ())
599 new_node
->ipa_transforms_to_apply
600 = ipa_transforms_to_apply
.copy ();
602 symtab
->call_cgraph_duplication_hooks (this, new_node
);
607 /* callgraph node being removed from symbol table; see if its entry can be
608 replaced by other inline clone. */
610 cgraph_node::find_replacement (void)
612 cgraph_node
*next_inline_clone
, *replacement
;
614 for (next_inline_clone
= clones
;
616 && next_inline_clone
->decl
!= decl
;
617 next_inline_clone
= next_inline_clone
->next_sibling_clone
)
620 /* If there is inline clone of the node being removed, we need
621 to put it into the position of removed node and reorganize all
622 other clones to be based on it. */
623 if (next_inline_clone
)
626 cgraph_node
*new_clones
;
628 replacement
= next_inline_clone
;
630 /* Unlink inline clone from the list of clones of removed node. */
631 if (next_inline_clone
->next_sibling_clone
)
632 next_inline_clone
->next_sibling_clone
->prev_sibling_clone
633 = next_inline_clone
->prev_sibling_clone
;
634 if (next_inline_clone
->prev_sibling_clone
)
636 gcc_assert (clones
!= next_inline_clone
);
637 next_inline_clone
->prev_sibling_clone
->next_sibling_clone
638 = next_inline_clone
->next_sibling_clone
;
642 gcc_assert (clones
== next_inline_clone
);
643 clones
= next_inline_clone
->next_sibling_clone
;
649 /* Copy clone info. */
650 next_inline_clone
->clone
= clone
;
652 /* Now place it into clone tree at same level at NODE. */
653 next_inline_clone
->clone_of
= clone_of
;
654 next_inline_clone
->prev_sibling_clone
= NULL
;
655 next_inline_clone
->next_sibling_clone
= NULL
;
658 if (clone_of
->clones
)
659 clone_of
->clones
->prev_sibling_clone
= next_inline_clone
;
660 next_inline_clone
->next_sibling_clone
= clone_of
->clones
;
661 clone_of
->clones
= next_inline_clone
;
664 /* Merge the clone list. */
667 if (!next_inline_clone
->clones
)
668 next_inline_clone
->clones
= new_clones
;
671 n
= next_inline_clone
->clones
;
672 while (n
->next_sibling_clone
)
673 n
= n
->next_sibling_clone
;
674 n
->next_sibling_clone
= new_clones
;
675 new_clones
->prev_sibling_clone
= n
;
679 /* Update clone_of pointers. */
683 n
->clone_of
= next_inline_clone
;
684 n
= n
->next_sibling_clone
;
692 /* Like cgraph_set_call_stmt but walk the clone tree and update all
693 clones sharing the same function body.
694 When WHOLE_SPECULATIVE_EDGES is true, all three components of
695 speculative edge gets updated. Otherwise we update only direct
699 cgraph_node::set_call_stmt_including_clones (gimple old_stmt
, gimple new_stmt
,
700 bool update_speculative
)
703 cgraph_edge
*edge
= get_edge (old_stmt
);
706 edge
->set_call_stmt (new_stmt
, update_speculative
);
712 cgraph_edge
*edge
= node
->get_edge (old_stmt
);
715 edge
->set_call_stmt (new_stmt
, update_speculative
);
716 /* If UPDATE_SPECULATIVE is false, it means that we are turning
717 speculative call into a real code sequence. Update the
719 if (edge
->speculative
&& !update_speculative
)
721 cgraph_edge
*direct
, *indirect
;
724 gcc_assert (!edge
->indirect_unknown_callee
);
725 edge
->speculative_call_info (direct
, indirect
, ref
);
726 direct
->speculative
= false;
727 indirect
->speculative
= false;
728 ref
->speculative
= false;
733 else if (node
->next_sibling_clone
)
734 node
= node
->next_sibling_clone
;
737 while (node
!= this && !node
->next_sibling_clone
)
738 node
= node
->clone_of
;
740 node
= node
->next_sibling_clone
;
745 /* Like cgraph_create_edge walk the clone tree and update all clones sharing
746 same function body. If clones already have edge for OLD_STMT; only
747 update the edge same way as cgraph_set_call_stmt_including_clones does.
749 TODO: COUNT and LOOP_DEPTH should be properly distributed based on relative
750 frequencies of the clones. */
753 cgraph_node::create_edge_including_clones (cgraph_node
*callee
,
754 gimple old_stmt
, gimple stmt
,
757 cgraph_inline_failed_t reason
)
762 if (!get_edge (stmt
))
764 edge
= create_edge (callee
, stmt
, count
, freq
);
765 edge
->inline_failed
= reason
;
772 cgraph_edge
*edge
= node
->get_edge (old_stmt
);
774 /* It is possible that clones already contain the edge while
775 master didn't. Either we promoted indirect call into direct
776 call in the clone or we are processing clones of unreachable
777 master where edges has been removed. */
779 edge
->set_call_stmt (stmt
);
780 else if (! node
->get_edge (stmt
))
782 edge
= node
->create_edge (callee
, stmt
, count
, freq
);
783 edge
->inline_failed
= reason
;
788 else if (node
->next_sibling_clone
)
789 node
= node
->next_sibling_clone
;
792 while (node
!= this && !node
->next_sibling_clone
)
793 node
= node
->clone_of
;
795 node
= node
->next_sibling_clone
;
800 /* Remove the node from cgraph and all inline clones inlined into it.
801 Skip however removal of FORBIDDEN_NODE and return true if it needs to be
802 removed. This allows to call the function from outer loop walking clone
806 cgraph_node::remove_symbol_and_inline_clones (cgraph_node
*forbidden_node
)
808 cgraph_edge
*e
, *next
;
811 if (this == forbidden_node
)
816 for (e
= callees
; e
; e
= next
)
818 next
= e
->next_callee
;
819 if (!e
->inline_failed
)
820 found
|= e
->callee
->remove_symbol_and_inline_clones (forbidden_node
);
826 /* The edges representing the callers of the NEW_VERSION node were
827 fixed by cgraph_function_versioning (), now the call_expr in their
828 respective tree code should be updated to call the NEW_VERSION. */
831 update_call_expr (cgraph_node
*new_version
)
835 gcc_assert (new_version
);
837 /* Update the call expr on the edges to call the new version. */
838 for (e
= new_version
->callers
; e
; e
= e
->next_caller
)
840 function
*inner_function
= DECL_STRUCT_FUNCTION (e
->caller
->decl
);
841 gimple_call_set_fndecl (e
->call_stmt
, new_version
->decl
);
842 maybe_clean_eh_stmt_fn (inner_function
, e
->call_stmt
);
847 /* Create a new cgraph node which is the new version of
848 callgraph node. REDIRECT_CALLERS holds the callers
849 edges which should be redirected to point to
850 NEW_VERSION. ALL the callees edges of the node
851 are cloned to the new version node. Return the new
854 If non-NULL BLOCK_TO_COPY determine what basic blocks
855 was copied to prevent duplications of calls that are dead
859 cgraph_node::create_version_clone (tree new_decl
,
860 vec
<cgraph_edge
*> redirect_callers
,
863 cgraph_node
*new_version
;
867 new_version
= cgraph_node::create (new_decl
);
869 new_version
->analyzed
= analyzed
;
870 new_version
->definition
= definition
;
871 new_version
->local
= local
;
872 new_version
->externally_visible
= false;
873 new_version
->no_reorder
= no_reorder
;
874 new_version
->local
.local
= new_version
->definition
;
875 new_version
->global
= global
;
876 new_version
->rtl
= rtl
;
877 new_version
->count
= count
;
879 for (e
= callees
; e
; e
=e
->next_callee
)
881 || bitmap_bit_p (bbs_to_copy
, gimple_bb (e
->call_stmt
)->index
))
882 e
->clone (new_version
, e
->call_stmt
,
883 e
->lto_stmt_uid
, REG_BR_PROB_BASE
,
886 for (e
= indirect_calls
; e
; e
=e
->next_callee
)
888 || bitmap_bit_p (bbs_to_copy
, gimple_bb (e
->call_stmt
)->index
))
889 e
->clone (new_version
, e
->call_stmt
,
890 e
->lto_stmt_uid
, REG_BR_PROB_BASE
,
893 FOR_EACH_VEC_ELT (redirect_callers
, i
, e
)
895 /* Redirect calls to the old version node to point to its new
897 e
->redirect_callee (new_version
);
900 symtab
->call_cgraph_duplication_hooks (this, new_version
);
905 /* Perform function versioning.
906 Function versioning includes copying of the tree and
907 a callgraph update (creating a new cgraph node and updating
908 its callees and callers).
910 REDIRECT_CALLERS varray includes the edges to be redirected
913 TREE_MAP is a mapping of tree nodes we want to replace with
914 new ones (according to results of prior analysis).
916 If non-NULL ARGS_TO_SKIP determine function parameters to remove
918 If SKIP_RETURN is true, the new version will return void.
919 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
920 If non_NULL NEW_ENTRY determine new entry BB of the clone.
922 Return the new version's cgraph node. */
925 cgraph_node::create_version_clone_with_body
926 (vec
<cgraph_edge
*> redirect_callers
,
927 vec
<ipa_replace_map
*, va_gc
> *tree_map
, bitmap args_to_skip
,
928 bool skip_return
, bitmap bbs_to_copy
, basic_block new_entry_block
,
929 const char *clone_name
)
931 tree old_decl
= decl
;
932 cgraph_node
*new_version_node
= NULL
;
935 if (!tree_versionable_function_p (old_decl
))
938 gcc_assert (local
.can_change_signature
|| !args_to_skip
);
940 /* Make a new FUNCTION_DECL tree node for the new version. */
941 if (!args_to_skip
&& !skip_return
)
942 new_decl
= copy_node (old_decl
);
945 = build_function_decl_skip_args (old_decl
, args_to_skip
, skip_return
);
947 /* Generate a new name for the new version. */
948 DECL_NAME (new_decl
) = clone_function_name (old_decl
, clone_name
);
949 SET_DECL_ASSEMBLER_NAME (new_decl
, DECL_NAME (new_decl
));
950 SET_DECL_RTL (new_decl
, NULL
);
952 /* When the old decl was a con-/destructor make sure the clone isn't. */
953 DECL_STATIC_CONSTRUCTOR (new_decl
) = 0;
954 DECL_STATIC_DESTRUCTOR (new_decl
) = 0;
956 /* Create the new version's call-graph node.
957 and update the edges of the new node. */
958 new_version_node
= create_version_clone (new_decl
, redirect_callers
,
961 if (ipa_transforms_to_apply
.exists ())
962 new_version_node
->ipa_transforms_to_apply
963 = ipa_transforms_to_apply
.copy ();
964 /* Copy the OLD_VERSION_NODE function tree to the new version. */
965 tree_function_versioning (old_decl
, new_decl
, tree_map
, false, args_to_skip
,
966 skip_return
, bbs_to_copy
, new_entry_block
);
968 /* Update the new version's properties.
969 Make The new version visible only within this translation unit. Make sure
970 that is not weak also.
971 ??? We cannot use COMDAT linkage because there is no
972 ABI support for this. */
973 new_version_node
->make_decl_local ();
974 DECL_VIRTUAL_P (new_version_node
->decl
) = 0;
975 new_version_node
->externally_visible
= 0;
976 new_version_node
->local
.local
= 1;
977 new_version_node
->lowered
= true;
978 /* Clones of global symbols or symbols with unique names are unique. */
979 if ((TREE_PUBLIC (old_decl
)
980 && !DECL_EXTERNAL (old_decl
)
981 && !DECL_WEAK (old_decl
)
982 && !DECL_COMDAT (old_decl
))
984 new_version_node
->unique_name
= true;
986 /* Update the call_expr on the edges to call the new version node. */
987 update_call_expr (new_version_node
);
989 symtab
->call_cgraph_insertion_hooks (this);
990 return new_version_node
;
993 /* Given virtual clone, turn it into actual clone. */
996 cgraph_materialize_clone (cgraph_node
*node
)
998 bitmap_obstack_initialize (NULL
);
999 node
->former_clone_of
= node
->clone_of
->decl
;
1000 if (node
->clone_of
->former_clone_of
)
1001 node
->former_clone_of
= node
->clone_of
->former_clone_of
;
1002 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1003 tree_function_versioning (node
->clone_of
->decl
, node
->decl
,
1004 node
->clone
.tree_map
, true,
1005 node
->clone
.args_to_skip
, false,
1007 if (symtab
->dump_file
)
1009 dump_function_to_file (node
->clone_of
->decl
, symtab
->dump_file
,
1011 dump_function_to_file (node
->decl
, symtab
->dump_file
, dump_flags
);
1014 /* Function is no longer clone. */
1015 if (node
->next_sibling_clone
)
1016 node
->next_sibling_clone
->prev_sibling_clone
= node
->prev_sibling_clone
;
1017 if (node
->prev_sibling_clone
)
1018 node
->prev_sibling_clone
->next_sibling_clone
= node
->next_sibling_clone
;
1020 node
->clone_of
->clones
= node
->next_sibling_clone
;
1021 node
->next_sibling_clone
= NULL
;
1022 node
->prev_sibling_clone
= NULL
;
1023 if (!node
->clone_of
->analyzed
&& !node
->clone_of
->clones
)
1025 node
->clone_of
->release_body ();
1026 node
->clone_of
->remove_callees ();
1027 node
->clone_of
->remove_all_references ();
1029 node
->clone_of
= NULL
;
1030 bitmap_obstack_release (NULL
);
1033 /* Once all functions from compilation unit are in memory, produce all clones
1034 and update all calls. We might also do this on demand if we don't want to
1035 bring all functions to memory prior compilation, but current WHOPR
1036 implementation does that and it is is bit easier to keep everything right in
1040 symbol_table::materialize_all_clones (void)
1043 bool stabilized
= false;
1046 if (symtab
->dump_file
)
1047 fprintf (symtab
->dump_file
, "Materializing clones\n");
1048 #ifdef ENABLE_CHECKING
1049 cgraph_node::verify_cgraph_nodes ();
1052 /* We can also do topological order, but number of iterations should be
1053 bounded by number of IPA passes since single IPA pass is probably not
1054 going to create clones of clones it created itself. */
1058 FOR_EACH_FUNCTION (node
)
1060 if (node
->clone_of
&& node
->decl
!= node
->clone_of
->decl
1061 && !gimple_has_body_p (node
->decl
))
1063 if (!node
->clone_of
->clone_of
)
1064 node
->clone_of
->get_body ();
1065 if (gimple_has_body_p (node
->clone_of
->decl
))
1067 if (symtab
->dump_file
)
1069 fprintf (symtab
->dump_file
, "cloning %s to %s\n",
1070 xstrdup (node
->clone_of
->name ()),
1071 xstrdup (node
->name ()));
1072 if (node
->clone
.tree_map
)
1075 fprintf (symtab
->dump_file
, " replace map: ");
1077 i
< vec_safe_length (node
->clone
.tree_map
);
1080 ipa_replace_map
*replace_info
;
1081 replace_info
= (*node
->clone
.tree_map
)[i
];
1082 print_generic_expr (symtab
->dump_file
, replace_info
->old_tree
, 0);
1083 fprintf (symtab
->dump_file
, " -> ");
1084 print_generic_expr (symtab
->dump_file
, replace_info
->new_tree
, 0);
1085 fprintf (symtab
->dump_file
, "%s%s;",
1086 replace_info
->replace_p
? "(replace)":"",
1087 replace_info
->ref_p
? "(ref)":"");
1089 fprintf (symtab
->dump_file
, "\n");
1091 if (node
->clone
.args_to_skip
)
1093 fprintf (symtab
->dump_file
, " args_to_skip: ");
1094 dump_bitmap (symtab
->dump_file
,
1095 node
->clone
.args_to_skip
);
1097 if (node
->clone
.args_to_skip
)
1099 fprintf (symtab
->dump_file
, " combined_args_to_skip:");
1100 dump_bitmap (symtab
->dump_file
, node
->clone
.combined_args_to_skip
);
1103 cgraph_materialize_clone (node
);
1109 FOR_EACH_FUNCTION (node
)
1110 if (!node
->analyzed
&& node
->callees
)
1112 node
->remove_callees ();
1113 node
->remove_all_references ();
1116 node
->clear_stmts_in_references ();
1117 if (symtab
->dump_file
)
1118 fprintf (symtab
->dump_file
, "Materialization Call site updates done.\n");
1119 #ifdef ENABLE_CHECKING
1120 cgraph_node::verify_cgraph_nodes ();
1122 symtab
->remove_unreachable_nodes (false, symtab
->dump_file
);
1125 #include "gt-cgraphclones.h"