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"
76 #include "basic-block.h"
77 #include "tree-ssa-alias.h"
78 #include "internal-fn.h"
80 #include "gimple-expr.h"
85 #include "tree-inline.h"
86 #include "langhooks.h"
91 #include "diagnostic.h"
96 #include "tree-iterator.h"
97 #include "tree-dump.h"
98 #include "gimple-pretty-print.h"
100 #include "ipa-inline.h"
101 #include "ipa-utils.h"
102 #include "lto-streamer.h"
105 /* Create clone of edge in the node N represented by CALL_EXPR
109 cgraph_edge::clone (cgraph_node
*n
, gimple call_stmt
, unsigned stmt_uid
,
110 gcov_type count_scale
, int freq_scale
, bool update_original
)
112 cgraph_edge
*new_edge
;
113 gcov_type gcov_count
= apply_probability (count
, count_scale
);
116 /* We do not want to ignore loop nest after frequency drops to 0. */
119 freq
= frequency
* (gcov_type
) freq_scale
/ CGRAPH_FREQ_BASE
;
120 if (freq
> CGRAPH_FREQ_MAX
)
121 freq
= CGRAPH_FREQ_MAX
;
123 if (indirect_unknown_callee
)
127 if (call_stmt
&& (decl
= gimple_call_fndecl (call_stmt
))
128 /* When the call is speculative, we need to resolve it
129 via cgraph_resolve_speculation and not here. */
132 cgraph_node
*callee
= cgraph_node::get (decl
);
133 gcc_checking_assert (callee
);
134 new_edge
= n
->create_edge (callee
, call_stmt
, gcov_count
, freq
);
138 new_edge
= n
->create_indirect_edge (call_stmt
,
139 indirect_info
->ecf_flags
,
141 *new_edge
->indirect_info
= *indirect_info
;
146 new_edge
= n
->create_edge (callee
, call_stmt
, gcov_count
, freq
);
149 new_edge
->indirect_info
150 = ggc_cleared_alloc
<cgraph_indirect_call_info
> ();
151 *new_edge
->indirect_info
= *indirect_info
;
155 new_edge
->inline_failed
= inline_failed
;
156 new_edge
->indirect_inlining_edge
= indirect_inlining_edge
;
157 new_edge
->lto_stmt_uid
= stmt_uid
;
158 /* Clone flags that depend on call_stmt availability manually. */
159 new_edge
->can_throw_external
= can_throw_external
;
160 new_edge
->call_stmt_cannot_inline_p
= call_stmt_cannot_inline_p
;
161 new_edge
->speculative
= speculative
;
164 count
-= new_edge
->count
;
168 symtab
->call_edge_duplication_hooks (this, new_edge
);
172 /* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP and the
173 return value if SKIP_RETURN is true. */
176 build_function_type_skip_args (tree orig_type
, bitmap args_to_skip
,
179 tree new_type
= NULL
;
180 tree args
, new_args
= NULL
;
184 for (args
= TYPE_ARG_TYPES (orig_type
); args
&& args
!= void_list_node
;
185 args
= TREE_CHAIN (args
), i
++)
186 if (!args_to_skip
|| !bitmap_bit_p (args_to_skip
, i
))
187 new_args
= tree_cons (NULL_TREE
, TREE_VALUE (args
), new_args
);
189 new_reversed
= nreverse (new_args
);
193 TREE_CHAIN (new_args
) = void_list_node
;
195 new_reversed
= void_list_node
;
198 /* Use copy_node to preserve as much as possible from original type
199 (debug info, attribute lists etc.)
200 Exception is METHOD_TYPEs must have THIS argument.
201 When we are asked to remove it, we need to build new FUNCTION_TYPE
203 if (TREE_CODE (orig_type
) != METHOD_TYPE
205 || !bitmap_bit_p (args_to_skip
, 0))
207 new_type
= build_distinct_type_copy (orig_type
);
208 TYPE_ARG_TYPES (new_type
) = new_reversed
;
213 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type
),
215 TYPE_CONTEXT (new_type
) = TYPE_CONTEXT (orig_type
);
219 TREE_TYPE (new_type
) = void_type_node
;
224 /* Build variant of function decl ORIG_DECL skipping ARGS_TO_SKIP and the
225 return value if SKIP_RETURN is true.
227 Arguments from DECL_ARGUMENTS list can't be removed now, since they are
228 linked by TREE_CHAIN directly. The caller is responsible for eliminating
229 them when they are being duplicated (i.e. copy_arguments_for_versioning). */
232 build_function_decl_skip_args (tree orig_decl
, bitmap args_to_skip
,
235 tree new_decl
= copy_node (orig_decl
);
238 new_type
= TREE_TYPE (orig_decl
);
239 if (prototype_p (new_type
)
240 || (skip_return
&& !VOID_TYPE_P (TREE_TYPE (new_type
))))
242 = build_function_type_skip_args (new_type
, args_to_skip
, skip_return
);
243 TREE_TYPE (new_decl
) = new_type
;
245 /* For declarations setting DECL_VINDEX (i.e. methods)
246 we expect first argument to be THIS pointer. */
247 if (args_to_skip
&& bitmap_bit_p (args_to_skip
, 0))
248 DECL_VINDEX (new_decl
) = NULL_TREE
;
250 /* When signature changes, we need to clear builtin info. */
251 if (DECL_BUILT_IN (new_decl
)
253 && !bitmap_empty_p (args_to_skip
))
255 DECL_BUILT_IN_CLASS (new_decl
) = NOT_BUILT_IN
;
256 DECL_FUNCTION_CODE (new_decl
) = (enum built_in_function
) 0;
258 /* The FE might have information and assumptions about the other
260 DECL_LANG_SPECIFIC (new_decl
) = NULL
;
264 /* Set flags of NEW_NODE and its decl. NEW_NODE is a newly created private
265 clone or its thunk. */
268 set_new_clone_decl_and_node_flags (cgraph_node
*new_node
)
270 DECL_EXTERNAL (new_node
->decl
) = 0;
271 TREE_PUBLIC (new_node
->decl
) = 0;
272 DECL_COMDAT (new_node
->decl
) = 0;
273 DECL_WEAK (new_node
->decl
) = 0;
274 DECL_VIRTUAL_P (new_node
->decl
) = 0;
275 DECL_STATIC_CONSTRUCTOR (new_node
->decl
) = 0;
276 DECL_STATIC_DESTRUCTOR (new_node
->decl
) = 0;
278 new_node
->externally_visible
= 0;
279 new_node
->local
.local
= 1;
280 new_node
->lowered
= true;
283 /* Duplicate thunk THUNK if necessary but make it to refer to NODE.
284 ARGS_TO_SKIP, if non-NULL, determines which parameters should be omitted.
285 Function can return NODE if no thunk is necessary, which can happen when
286 thunk is this_adjusting but we are removing this parameter. */
289 duplicate_thunk_for_node (cgraph_node
*thunk
, cgraph_node
*node
)
291 cgraph_node
*new_thunk
, *thunk_of
;
292 thunk_of
= thunk
->callees
->callee
->ultimate_alias_target ();
294 if (thunk_of
->thunk
.thunk_p
)
295 node
= duplicate_thunk_for_node (thunk_of
, node
);
298 for (cs
= node
->callers
; cs
; cs
= cs
->next_caller
)
299 if (cs
->caller
->thunk
.thunk_p
300 && cs
->caller
->thunk
.this_adjusting
== thunk
->thunk
.this_adjusting
301 && cs
->caller
->thunk
.fixed_offset
== thunk
->thunk
.fixed_offset
302 && cs
->caller
->thunk
.virtual_offset_p
== thunk
->thunk
.virtual_offset_p
303 && cs
->caller
->thunk
.virtual_value
== thunk
->thunk
.virtual_value
)
307 if (!node
->clone
.args_to_skip
)
308 new_decl
= copy_node (thunk
->decl
);
311 /* We do not need to duplicate this_adjusting thunks if we have removed
313 if (thunk
->thunk
.this_adjusting
314 && bitmap_bit_p (node
->clone
.args_to_skip
, 0))
317 new_decl
= build_function_decl_skip_args (thunk
->decl
,
318 node
->clone
.args_to_skip
,
322 tree
*link
= &DECL_ARGUMENTS (new_decl
);
324 for (tree pd
= DECL_ARGUMENTS (thunk
->decl
); pd
; pd
= DECL_CHAIN (pd
), i
++)
326 if (!node
->clone
.args_to_skip
327 || !bitmap_bit_p (node
->clone
.args_to_skip
, i
))
329 tree nd
= copy_node (pd
);
330 DECL_CONTEXT (nd
) = new_decl
;
332 link
= &DECL_CHAIN (nd
);
337 gcc_checking_assert (!DECL_STRUCT_FUNCTION (new_decl
));
338 gcc_checking_assert (!DECL_INITIAL (new_decl
));
339 gcc_checking_assert (!DECL_RESULT (new_decl
));
340 gcc_checking_assert (!DECL_RTL_SET_P (new_decl
));
342 DECL_NAME (new_decl
) = clone_function_name (thunk
->decl
, "artificial_thunk");
343 SET_DECL_ASSEMBLER_NAME (new_decl
, DECL_NAME (new_decl
));
345 new_thunk
= cgraph_node::create (new_decl
);
346 set_new_clone_decl_and_node_flags (new_thunk
);
347 new_thunk
->definition
= true;
348 new_thunk
->thunk
= thunk
->thunk
;
349 new_thunk
->unique_name
= in_lto_p
;
350 new_thunk
->former_clone_of
= thunk
->decl
;
351 new_thunk
->clone
.args_to_skip
= node
->clone
.args_to_skip
;
352 new_thunk
->clone
.combined_args_to_skip
= node
->clone
.combined_args_to_skip
;
354 cgraph_edge
*e
= new_thunk
->create_edge (node
, NULL
, 0,
356 e
->call_stmt_cannot_inline_p
= true;
357 symtab
->call_edge_duplication_hooks (thunk
->callees
, e
);
358 if (new_thunk
->expand_thunk (false, false))
360 new_thunk
->thunk
.thunk_p
= false;
361 new_thunk
->analyze ();
364 symtab
->call_cgraph_duplication_hooks (thunk
, new_thunk
);
368 /* If E does not lead to a thunk, simply redirect it to N. Otherwise create
369 one or more equivalent thunks for N and redirect E to the first in the
373 redirect_edge_duplicating_thunks (cgraph_edge
*e
, cgraph_node
*n
)
375 cgraph_node
*orig_to
= e
->callee
->ultimate_alias_target ();
376 if (orig_to
->thunk
.thunk_p
)
377 n
= duplicate_thunk_for_node (orig_to
, n
);
379 e
->redirect_callee (n
);
382 /* Create node representing clone of N executed COUNT times. Decrease
383 the execution counts from original node too.
384 The new clone will have decl set to DECL that may or may not be the same
387 When UPDATE_ORIGINAL is true, the counts are subtracted from the original
388 function's profile to reflect the fact that part of execution is handled
390 When CALL_DUPLICATOIN_HOOK is true, the ipa passes are acknowledged about
391 the new clone. Otherwise the caller is responsible for doing so later.
393 If the new node is being inlined into another one, NEW_INLINED_TO should be
394 the outline function the new one is (even indirectly) inlined to. All hooks
395 will see this in node's global.inlined_to, when invoked. Can be NULL if the
396 node is not inlined. */
399 cgraph_node::create_clone (tree decl
, gcov_type gcov_count
, int freq
,
400 bool update_original
,
401 vec
<cgraph_edge
*> redirect_callers
,
402 bool call_duplication_hook
,
403 cgraph_node
*new_inlined_to
,
406 cgraph_node
*new_node
= symtab
->create_empty ();
408 gcov_type count_scale
;
411 new_node
->decl
= decl
;
412 new_node
->register_symbol ();
413 new_node
->origin
= origin
;
414 new_node
->lto_file_data
= lto_file_data
;
415 if (new_node
->origin
)
417 new_node
->next_nested
= new_node
->origin
->nested
;
418 new_node
->origin
->nested
= new_node
;
420 new_node
->analyzed
= analyzed
;
421 new_node
->definition
= definition
;
422 new_node
->local
= local
;
423 new_node
->externally_visible
= false;
424 new_node
->no_reorder
= no_reorder
;
425 new_node
->local
.local
= true;
426 new_node
->global
= global
;
427 new_node
->global
.inlined_to
= new_inlined_to
;
429 new_node
->count
= count
;
430 new_node
->frequency
= frequency
;
431 new_node
->tp_first_run
= tp_first_run
;
432 new_node
->tm_clone
= tm_clone
;
434 new_node
->clone
.tree_map
= NULL
;
435 new_node
->clone
.args_to_skip
= args_to_skip
;
437 new_node
->clone
.combined_args_to_skip
= clone
.combined_args_to_skip
;
438 else if (clone
.combined_args_to_skip
)
440 new_node
->clone
.combined_args_to_skip
= BITMAP_GGC_ALLOC ();
441 bitmap_ior (new_node
->clone
.combined_args_to_skip
,
442 clone
.combined_args_to_skip
, args_to_skip
);
445 new_node
->clone
.combined_args_to_skip
= args_to_skip
;
449 if (new_node
->count
> count
)
450 count_scale
= REG_BR_PROB_BASE
;
452 count_scale
= GCOV_COMPUTE_SCALE (new_node
->count
, count
);
463 FOR_EACH_VEC_ELT (redirect_callers
, i
, e
)
465 /* Redirect calls to the old version node to point to its new
466 version. The only exception is when the edge was proved to
467 be unreachable during the clonning procedure. */
469 || DECL_BUILT_IN_CLASS (e
->callee
->decl
) != BUILT_IN_NORMAL
470 || DECL_FUNCTION_CODE (e
->callee
->decl
) != BUILT_IN_UNREACHABLE
)
471 redirect_edge_duplicating_thunks (e
, new_node
);
474 for (e
= callees
;e
; e
=e
->next_callee
)
475 e
->clone (new_node
, e
->call_stmt
, e
->lto_stmt_uid
, count_scale
,
476 freq
, update_original
);
478 for (e
= indirect_calls
; e
; e
= e
->next_callee
)
479 e
->clone (new_node
, e
->call_stmt
, e
->lto_stmt_uid
,
480 count_scale
, freq
, update_original
);
481 new_node
->clone_references (this);
483 new_node
->next_sibling_clone
= clones
;
485 clones
->prev_sibling_clone
= new_node
;
487 new_node
->clone_of
= this;
489 if (call_duplication_hook
)
490 symtab
->call_cgraph_duplication_hooks (this, new_node
);
494 /* Return a new assembler name for a clone of DECL with SUFFIX. */
496 static GTY(()) unsigned int clone_fn_id_num
;
499 clone_function_name (tree decl
, const char *suffix
)
501 tree name
= DECL_ASSEMBLER_NAME (decl
);
502 size_t len
= IDENTIFIER_LENGTH (name
);
503 char *tmp_name
, *prefix
;
505 prefix
= XALLOCAVEC (char, len
+ strlen (suffix
) + 2);
506 memcpy (prefix
, IDENTIFIER_POINTER (name
), len
);
507 strcpy (prefix
+ len
+ 1, suffix
);
508 #ifndef NO_DOT_IN_LABEL
510 #elif !defined NO_DOLLAR_IN_LABEL
515 ASM_FORMAT_PRIVATE_NAME (tmp_name
, prefix
, clone_fn_id_num
++);
516 return get_identifier (tmp_name
);
519 /* Create callgraph node clone with new declaration. The actual body will
520 be copied later at compilation stage.
522 TODO: after merging in ipa-sra use function call notes instead of args_to_skip
526 cgraph_node::create_virtual_clone (vec
<cgraph_edge
*> redirect_callers
,
527 vec
<ipa_replace_map
*, va_gc
> *tree_map
,
528 bitmap args_to_skip
, const char * suffix
)
530 tree old_decl
= decl
;
531 cgraph_node
*new_node
= NULL
;
534 ipa_replace_map
*map
;
538 gcc_checking_assert (tree_versionable_function_p (old_decl
));
540 gcc_assert (local
.can_change_signature
|| !args_to_skip
);
542 /* Make a new FUNCTION_DECL tree node */
544 new_decl
= copy_node (old_decl
);
546 new_decl
= build_function_decl_skip_args (old_decl
, args_to_skip
, false);
548 /* These pointers represent function body and will be populated only when clone
550 gcc_assert (new_decl
!= old_decl
);
551 DECL_STRUCT_FUNCTION (new_decl
) = NULL
;
552 DECL_ARGUMENTS (new_decl
) = NULL
;
553 DECL_INITIAL (new_decl
) = NULL
;
554 DECL_RESULT (new_decl
) = NULL
;
555 /* We can not do DECL_RESULT (new_decl) = NULL; here because of LTO partitioning
556 sometimes storing only clone decl instead of original. */
558 /* Generate a new name for the new version. */
559 len
= IDENTIFIER_LENGTH (DECL_NAME (old_decl
));
560 name
= XALLOCAVEC (char, len
+ strlen (suffix
) + 2);
561 memcpy (name
, IDENTIFIER_POINTER (DECL_NAME (old_decl
)), len
);
562 strcpy (name
+ len
+ 1, suffix
);
564 DECL_NAME (new_decl
) = get_identifier (name
);
565 SET_DECL_ASSEMBLER_NAME (new_decl
, clone_function_name (old_decl
, suffix
));
566 SET_DECL_RTL (new_decl
, NULL
);
568 new_node
= create_clone (new_decl
, count
, CGRAPH_FREQ_BASE
, false,
569 redirect_callers
, false, NULL
, args_to_skip
);
571 /* Update the properties.
572 Make clone visible only within this translation unit. Make sure
573 that is not weak also.
574 ??? We cannot use COMDAT linkage because there is no
575 ABI support for this. */
576 set_new_clone_decl_and_node_flags (new_node
);
577 new_node
->clone
.tree_map
= tree_map
;
579 /* Clones of global symbols or symbols with unique names are unique. */
580 if ((TREE_PUBLIC (old_decl
)
581 && !DECL_EXTERNAL (old_decl
)
582 && !DECL_WEAK (old_decl
)
583 && !DECL_COMDAT (old_decl
))
585 new_node
->unique_name
= true;
586 FOR_EACH_VEC_SAFE_ELT (tree_map
, i
, map
)
587 new_node
->maybe_create_reference (map
->new_tree
, IPA_REF_ADDR
, NULL
);
589 if (ipa_transforms_to_apply
.exists ())
590 new_node
->ipa_transforms_to_apply
591 = ipa_transforms_to_apply
.copy ();
593 symtab
->call_cgraph_duplication_hooks (this, new_node
);
598 /* callgraph node being removed from symbol table; see if its entry can be
599 replaced by other inline clone. */
601 cgraph_node::find_replacement (void)
603 cgraph_node
*next_inline_clone
, *replacement
;
605 for (next_inline_clone
= clones
;
607 && next_inline_clone
->decl
!= decl
;
608 next_inline_clone
= next_inline_clone
->next_sibling_clone
)
611 /* If there is inline clone of the node being removed, we need
612 to put it into the position of removed node and reorganize all
613 other clones to be based on it. */
614 if (next_inline_clone
)
617 cgraph_node
*new_clones
;
619 replacement
= next_inline_clone
;
621 /* Unlink inline clone from the list of clones of removed node. */
622 if (next_inline_clone
->next_sibling_clone
)
623 next_inline_clone
->next_sibling_clone
->prev_sibling_clone
624 = next_inline_clone
->prev_sibling_clone
;
625 if (next_inline_clone
->prev_sibling_clone
)
627 gcc_assert (clones
!= next_inline_clone
);
628 next_inline_clone
->prev_sibling_clone
->next_sibling_clone
629 = next_inline_clone
->next_sibling_clone
;
633 gcc_assert (clones
== next_inline_clone
);
634 clones
= next_inline_clone
->next_sibling_clone
;
640 /* Copy clone info. */
641 next_inline_clone
->clone
= clone
;
643 /* Now place it into clone tree at same level at NODE. */
644 next_inline_clone
->clone_of
= clone_of
;
645 next_inline_clone
->prev_sibling_clone
= NULL
;
646 next_inline_clone
->next_sibling_clone
= NULL
;
649 if (clone_of
->clones
)
650 clone_of
->clones
->prev_sibling_clone
= next_inline_clone
;
651 next_inline_clone
->next_sibling_clone
= clone_of
->clones
;
652 clone_of
->clones
= next_inline_clone
;
655 /* Merge the clone list. */
658 if (!next_inline_clone
->clones
)
659 next_inline_clone
->clones
= new_clones
;
662 n
= next_inline_clone
->clones
;
663 while (n
->next_sibling_clone
)
664 n
= n
->next_sibling_clone
;
665 n
->next_sibling_clone
= new_clones
;
666 new_clones
->prev_sibling_clone
= n
;
670 /* Update clone_of pointers. */
674 n
->clone_of
= next_inline_clone
;
675 n
= n
->next_sibling_clone
;
683 /* Like cgraph_set_call_stmt but walk the clone tree and update all
684 clones sharing the same function body.
685 When WHOLE_SPECULATIVE_EDGES is true, all three components of
686 speculative edge gets updated. Otherwise we update only direct
690 cgraph_node::set_call_stmt_including_clones (gimple old_stmt
, gimple new_stmt
,
691 bool update_speculative
)
694 cgraph_edge
*edge
= get_edge (old_stmt
);
697 edge
->set_call_stmt (new_stmt
, update_speculative
);
703 cgraph_edge
*edge
= node
->get_edge (old_stmt
);
706 edge
->set_call_stmt (new_stmt
, update_speculative
);
707 /* If UPDATE_SPECULATIVE is false, it means that we are turning
708 speculative call into a real code sequence. Update the
710 if (edge
->speculative
&& !update_speculative
)
712 cgraph_edge
*direct
, *indirect
;
715 gcc_assert (!edge
->indirect_unknown_callee
);
716 edge
->speculative_call_info (direct
, indirect
, ref
);
717 direct
->speculative
= false;
718 indirect
->speculative
= false;
719 ref
->speculative
= false;
724 else if (node
->next_sibling_clone
)
725 node
= node
->next_sibling_clone
;
728 while (node
!= this && !node
->next_sibling_clone
)
729 node
= node
->clone_of
;
731 node
= node
->next_sibling_clone
;
736 /* Like cgraph_create_edge walk the clone tree and update all clones sharing
737 same function body. If clones already have edge for OLD_STMT; only
738 update the edge same way as cgraph_set_call_stmt_including_clones does.
740 TODO: COUNT and LOOP_DEPTH should be properly distributed based on relative
741 frequencies of the clones. */
744 cgraph_node::create_edge_including_clones (cgraph_node
*callee
,
745 gimple old_stmt
, gimple stmt
,
748 cgraph_inline_failed_t reason
)
753 if (!get_edge (stmt
))
755 edge
= create_edge (callee
, stmt
, count
, freq
);
756 edge
->inline_failed
= reason
;
763 cgraph_edge
*edge
= node
->get_edge (old_stmt
);
765 /* It is possible that clones already contain the edge while
766 master didn't. Either we promoted indirect call into direct
767 call in the clone or we are processing clones of unreachable
768 master where edges has been removed. */
770 edge
->set_call_stmt (stmt
);
771 else if (! node
->get_edge (stmt
))
773 edge
= node
->create_edge (callee
, stmt
, count
, freq
);
774 edge
->inline_failed
= reason
;
779 else if (node
->next_sibling_clone
)
780 node
= node
->next_sibling_clone
;
783 while (node
!= this && !node
->next_sibling_clone
)
784 node
= node
->clone_of
;
786 node
= node
->next_sibling_clone
;
791 /* Remove the node from cgraph and all inline clones inlined into it.
792 Skip however removal of FORBIDDEN_NODE and return true if it needs to be
793 removed. This allows to call the function from outer loop walking clone
797 cgraph_node::remove_symbol_and_inline_clones (cgraph_node
*forbidden_node
)
799 cgraph_edge
*e
, *next
;
802 if (this == forbidden_node
)
807 for (e
= callees
; e
; e
= next
)
809 next
= e
->next_callee
;
810 if (!e
->inline_failed
)
811 found
|= e
->callee
->remove_symbol_and_inline_clones (forbidden_node
);
817 /* The edges representing the callers of the NEW_VERSION node were
818 fixed by cgraph_function_versioning (), now the call_expr in their
819 respective tree code should be updated to call the NEW_VERSION. */
822 update_call_expr (cgraph_node
*new_version
)
826 gcc_assert (new_version
);
828 /* Update the call expr on the edges to call the new version. */
829 for (e
= new_version
->callers
; e
; e
= e
->next_caller
)
831 function
*inner_function
= DECL_STRUCT_FUNCTION (e
->caller
->decl
);
832 gimple_call_set_fndecl (e
->call_stmt
, new_version
->decl
);
833 maybe_clean_eh_stmt_fn (inner_function
, e
->call_stmt
);
838 /* Create a new cgraph node which is the new version of
839 callgraph node. REDIRECT_CALLERS holds the callers
840 edges which should be redirected to point to
841 NEW_VERSION. ALL the callees edges of the node
842 are cloned to the new version node. Return the new
845 If non-NULL BLOCK_TO_COPY determine what basic blocks
846 was copied to prevent duplications of calls that are dead
850 cgraph_node::create_version_clone (tree new_decl
,
851 vec
<cgraph_edge
*> redirect_callers
,
854 cgraph_node
*new_version
;
858 new_version
= cgraph_node::create (new_decl
);
860 new_version
->analyzed
= analyzed
;
861 new_version
->definition
= definition
;
862 new_version
->local
= local
;
863 new_version
->externally_visible
= false;
864 new_version
->no_reorder
= no_reorder
;
865 new_version
->local
.local
= new_version
->definition
;
866 new_version
->global
= global
;
867 new_version
->rtl
= rtl
;
868 new_version
->count
= count
;
870 for (e
= callees
; e
; e
=e
->next_callee
)
872 || bitmap_bit_p (bbs_to_copy
, gimple_bb (e
->call_stmt
)->index
))
873 e
->clone (new_version
, e
->call_stmt
,
874 e
->lto_stmt_uid
, REG_BR_PROB_BASE
,
877 for (e
= indirect_calls
; e
; e
=e
->next_callee
)
879 || bitmap_bit_p (bbs_to_copy
, gimple_bb (e
->call_stmt
)->index
))
880 e
->clone (new_version
, e
->call_stmt
,
881 e
->lto_stmt_uid
, REG_BR_PROB_BASE
,
884 FOR_EACH_VEC_ELT (redirect_callers
, i
, e
)
886 /* Redirect calls to the old version node to point to its new
888 e
->redirect_callee (new_version
);
891 symtab
->call_cgraph_duplication_hooks (this, new_version
);
896 /* Perform function versioning.
897 Function versioning includes copying of the tree and
898 a callgraph update (creating a new cgraph node and updating
899 its callees and callers).
901 REDIRECT_CALLERS varray includes the edges to be redirected
904 TREE_MAP is a mapping of tree nodes we want to replace with
905 new ones (according to results of prior analysis).
907 If non-NULL ARGS_TO_SKIP determine function parameters to remove
909 If SKIP_RETURN is true, the new version will return void.
910 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
911 If non_NULL NEW_ENTRY determine new entry BB of the clone.
913 Return the new version's cgraph node. */
916 cgraph_node::create_version_clone_with_body
917 (vec
<cgraph_edge
*> redirect_callers
,
918 vec
<ipa_replace_map
*, va_gc
> *tree_map
, bitmap args_to_skip
,
919 bool skip_return
, bitmap bbs_to_copy
, basic_block new_entry_block
,
920 const char *clone_name
)
922 tree old_decl
= decl
;
923 cgraph_node
*new_version_node
= NULL
;
926 if (!tree_versionable_function_p (old_decl
))
929 gcc_assert (local
.can_change_signature
|| !args_to_skip
);
931 /* Make a new FUNCTION_DECL tree node for the new version. */
932 if (!args_to_skip
&& !skip_return
)
933 new_decl
= copy_node (old_decl
);
936 = build_function_decl_skip_args (old_decl
, args_to_skip
, skip_return
);
938 /* Generate a new name for the new version. */
939 DECL_NAME (new_decl
) = clone_function_name (old_decl
, clone_name
);
940 SET_DECL_ASSEMBLER_NAME (new_decl
, DECL_NAME (new_decl
));
941 SET_DECL_RTL (new_decl
, NULL
);
943 /* When the old decl was a con-/destructor make sure the clone isn't. */
944 DECL_STATIC_CONSTRUCTOR (new_decl
) = 0;
945 DECL_STATIC_DESTRUCTOR (new_decl
) = 0;
947 /* Create the new version's call-graph node.
948 and update the edges of the new node. */
949 new_version_node
= create_version_clone (new_decl
, redirect_callers
,
952 if (ipa_transforms_to_apply
.exists ())
953 new_version_node
->ipa_transforms_to_apply
954 = ipa_transforms_to_apply
.copy ();
955 /* Copy the OLD_VERSION_NODE function tree to the new version. */
956 tree_function_versioning (old_decl
, new_decl
, tree_map
, false, args_to_skip
,
957 skip_return
, bbs_to_copy
, new_entry_block
);
959 /* Update the new version's properties.
960 Make The new version visible only within this translation unit. Make sure
961 that is not weak also.
962 ??? We cannot use COMDAT linkage because there is no
963 ABI support for this. */
964 new_version_node
->make_decl_local ();
965 DECL_VIRTUAL_P (new_version_node
->decl
) = 0;
966 new_version_node
->externally_visible
= 0;
967 new_version_node
->local
.local
= 1;
968 new_version_node
->lowered
= true;
969 /* Clones of global symbols or symbols with unique names are unique. */
970 if ((TREE_PUBLIC (old_decl
)
971 && !DECL_EXTERNAL (old_decl
)
972 && !DECL_WEAK (old_decl
)
973 && !DECL_COMDAT (old_decl
))
975 new_version_node
->unique_name
= true;
977 /* Update the call_expr on the edges to call the new version node. */
978 update_call_expr (new_version_node
);
980 symtab
->call_cgraph_insertion_hooks (this);
981 return new_version_node
;
984 /* Given virtual clone, turn it into actual clone. */
987 cgraph_materialize_clone (cgraph_node
*node
)
989 bitmap_obstack_initialize (NULL
);
990 node
->former_clone_of
= node
->clone_of
->decl
;
991 if (node
->clone_of
->former_clone_of
)
992 node
->former_clone_of
= node
->clone_of
->former_clone_of
;
993 /* Copy the OLD_VERSION_NODE function tree to the new version. */
994 tree_function_versioning (node
->clone_of
->decl
, node
->decl
,
995 node
->clone
.tree_map
, true,
996 node
->clone
.args_to_skip
, false,
998 if (symtab
->dump_file
)
1000 dump_function_to_file (node
->clone_of
->decl
, symtab
->dump_file
,
1002 dump_function_to_file (node
->decl
, symtab
->dump_file
, dump_flags
);
1005 /* Function is no longer clone. */
1006 if (node
->next_sibling_clone
)
1007 node
->next_sibling_clone
->prev_sibling_clone
= node
->prev_sibling_clone
;
1008 if (node
->prev_sibling_clone
)
1009 node
->prev_sibling_clone
->next_sibling_clone
= node
->next_sibling_clone
;
1011 node
->clone_of
->clones
= node
->next_sibling_clone
;
1012 node
->next_sibling_clone
= NULL
;
1013 node
->prev_sibling_clone
= NULL
;
1014 if (!node
->clone_of
->analyzed
&& !node
->clone_of
->clones
)
1016 node
->clone_of
->release_body ();
1017 node
->clone_of
->remove_callees ();
1018 node
->clone_of
->remove_all_references ();
1020 node
->clone_of
= NULL
;
1021 bitmap_obstack_release (NULL
);
1024 /* Once all functions from compilation unit are in memory, produce all clones
1025 and update all calls. We might also do this on demand if we don't want to
1026 bring all functions to memory prior compilation, but current WHOPR
1027 implementation does that and it is is bit easier to keep everything right in
1031 symbol_table::materialize_all_clones (void)
1034 bool stabilized
= false;
1037 if (symtab
->dump_file
)
1038 fprintf (symtab
->dump_file
, "Materializing clones\n");
1039 #ifdef ENABLE_CHECKING
1040 cgraph_node::verify_cgraph_nodes ();
1043 /* We can also do topological order, but number of iterations should be
1044 bounded by number of IPA passes since single IPA pass is probably not
1045 going to create clones of clones it created itself. */
1049 FOR_EACH_FUNCTION (node
)
1051 if (node
->clone_of
&& node
->decl
!= node
->clone_of
->decl
1052 && !gimple_has_body_p (node
->decl
))
1054 if (!node
->clone_of
->clone_of
)
1055 node
->clone_of
->get_body ();
1056 if (gimple_has_body_p (node
->clone_of
->decl
))
1058 if (symtab
->dump_file
)
1060 fprintf (symtab
->dump_file
, "cloning %s to %s\n",
1061 xstrdup (node
->clone_of
->name ()),
1062 xstrdup (node
->name ()));
1063 if (node
->clone
.tree_map
)
1066 fprintf (symtab
->dump_file
, " replace map: ");
1068 i
< vec_safe_length (node
->clone
.tree_map
);
1071 ipa_replace_map
*replace_info
;
1072 replace_info
= (*node
->clone
.tree_map
)[i
];
1073 print_generic_expr (symtab
->dump_file
, replace_info
->old_tree
, 0);
1074 fprintf (symtab
->dump_file
, " -> ");
1075 print_generic_expr (symtab
->dump_file
, replace_info
->new_tree
, 0);
1076 fprintf (symtab
->dump_file
, "%s%s;",
1077 replace_info
->replace_p
? "(replace)":"",
1078 replace_info
->ref_p
? "(ref)":"");
1080 fprintf (symtab
->dump_file
, "\n");
1082 if (node
->clone
.args_to_skip
)
1084 fprintf (symtab
->dump_file
, " args_to_skip: ");
1085 dump_bitmap (symtab
->dump_file
,
1086 node
->clone
.args_to_skip
);
1088 if (node
->clone
.args_to_skip
)
1090 fprintf (symtab
->dump_file
, " combined_args_to_skip:");
1091 dump_bitmap (symtab
->dump_file
, node
->clone
.combined_args_to_skip
);
1094 cgraph_materialize_clone (node
);
1100 FOR_EACH_FUNCTION (node
)
1101 if (!node
->analyzed
&& node
->callees
)
1103 node
->remove_callees ();
1104 node
->remove_all_references ();
1107 node
->clear_stmts_in_references ();
1108 if (symtab
->dump_file
)
1109 fprintf (symtab
->dump_file
, "Materialization Call site updates done.\n");
1110 #ifdef ENABLE_CHECKING
1111 cgraph_node::verify_cgraph_nodes ();
1113 symtab
->remove_unreachable_nodes (false, symtab
->dump_file
);
1116 #include "gt-cgraphclones.h"