* g++.dg/cpp/ucn-1.C: Fix typo.
[official-gcc.git] / gcc / cgraphclones.c
blob143ca33d93a10960e22b6fa90a852af8ca0619d0
1 /* Callgraph clones
2 Copyright (C) 2003-2015 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
10 version.
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
15 for more details.
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
27 clones
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
49 a given function.
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. */
67 #include "config.h"
68 #include "system.h"
69 #include "coretypes.h"
70 #include "backend.h"
71 #include "target.h"
72 #include "rtl.h"
73 #include "tree.h"
74 #include "gimple.h"
75 #include "stringpool.h"
76 #include "cgraph.h"
77 #include "lto-streamer.h"
78 #include "tree-eh.h"
79 #include "tree-cfg.h"
80 #include "tree-inline.h"
81 #include "tree-dump.h"
82 #include "gimple-pretty-print.h"
84 /* Create clone of edge in the node N represented by CALL_EXPR
85 the callgraph. */
87 cgraph_edge *
88 cgraph_edge::clone (cgraph_node *n, gcall *call_stmt, unsigned stmt_uid,
89 gcov_type count_scale, int freq_scale, bool update_original)
91 cgraph_edge *new_edge;
92 gcov_type gcov_count = apply_probability (count, count_scale);
93 gcov_type freq;
95 /* We do not want to ignore loop nest after frequency drops to 0. */
96 if (!freq_scale)
97 freq_scale = 1;
98 freq = frequency * (gcov_type) freq_scale / CGRAPH_FREQ_BASE;
99 if (freq > CGRAPH_FREQ_MAX)
100 freq = CGRAPH_FREQ_MAX;
102 if (indirect_unknown_callee)
104 tree decl;
106 if (call_stmt && (decl = gimple_call_fndecl (call_stmt))
107 /* When the call is speculative, we need to resolve it
108 via cgraph_resolve_speculation and not here. */
109 && !speculative)
111 cgraph_node *callee = cgraph_node::get (decl);
112 gcc_checking_assert (callee);
113 new_edge = n->create_edge (callee, call_stmt, gcov_count, freq);
115 else
117 new_edge = n->create_indirect_edge (call_stmt,
118 indirect_info->ecf_flags,
119 count, freq, false);
120 *new_edge->indirect_info = *indirect_info;
123 else
125 new_edge = n->create_edge (callee, call_stmt, gcov_count, freq);
126 if (indirect_info)
128 new_edge->indirect_info
129 = ggc_cleared_alloc<cgraph_indirect_call_info> ();
130 *new_edge->indirect_info = *indirect_info;
134 new_edge->inline_failed = inline_failed;
135 new_edge->indirect_inlining_edge = indirect_inlining_edge;
136 new_edge->lto_stmt_uid = stmt_uid;
137 /* Clone flags that depend on call_stmt availability manually. */
138 new_edge->can_throw_external = can_throw_external;
139 new_edge->call_stmt_cannot_inline_p = call_stmt_cannot_inline_p;
140 new_edge->speculative = speculative;
141 new_edge->in_polymorphic_cdtor = in_polymorphic_cdtor;
142 if (update_original)
144 count -= new_edge->count;
145 if (count < 0)
146 count = 0;
148 symtab->call_edge_duplication_hooks (this, new_edge);
149 return new_edge;
152 /* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP and the
153 return value if SKIP_RETURN is true. */
155 static tree
156 build_function_type_skip_args (tree orig_type, bitmap args_to_skip,
157 bool skip_return)
159 tree new_type = NULL;
160 tree args, new_args = NULL;
161 tree new_reversed;
162 int i = 0;
164 for (args = TYPE_ARG_TYPES (orig_type); args && args != void_list_node;
165 args = TREE_CHAIN (args), i++)
166 if (!args_to_skip || !bitmap_bit_p (args_to_skip, i))
167 new_args = tree_cons (NULL_TREE, TREE_VALUE (args), new_args);
169 new_reversed = nreverse (new_args);
170 if (args)
172 if (new_reversed)
173 TREE_CHAIN (new_args) = void_list_node;
174 else
175 new_reversed = void_list_node;
178 /* Use copy_node to preserve as much as possible from original type
179 (debug info, attribute lists etc.)
180 Exception is METHOD_TYPEs must have THIS argument.
181 When we are asked to remove it, we need to build new FUNCTION_TYPE
182 instead. */
183 if (TREE_CODE (orig_type) != METHOD_TYPE
184 || !args_to_skip
185 || !bitmap_bit_p (args_to_skip, 0))
187 new_type = build_distinct_type_copy (orig_type);
188 TYPE_ARG_TYPES (new_type) = new_reversed;
190 else
192 new_type
193 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type),
194 new_reversed));
195 TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type);
198 if (skip_return)
199 TREE_TYPE (new_type) = void_type_node;
201 return new_type;
204 /* Build variant of function decl ORIG_DECL skipping ARGS_TO_SKIP and the
205 return value if SKIP_RETURN is true.
207 Arguments from DECL_ARGUMENTS list can't be removed now, since they are
208 linked by TREE_CHAIN directly. The caller is responsible for eliminating
209 them when they are being duplicated (i.e. copy_arguments_for_versioning). */
211 static tree
212 build_function_decl_skip_args (tree orig_decl, bitmap args_to_skip,
213 bool skip_return)
215 tree new_decl = copy_node (orig_decl);
216 tree new_type;
218 new_type = TREE_TYPE (orig_decl);
219 if (prototype_p (new_type)
220 || (skip_return && !VOID_TYPE_P (TREE_TYPE (new_type))))
221 new_type
222 = build_function_type_skip_args (new_type, args_to_skip, skip_return);
223 TREE_TYPE (new_decl) = new_type;
225 /* For declarations setting DECL_VINDEX (i.e. methods)
226 we expect first argument to be THIS pointer. */
227 if (args_to_skip && bitmap_bit_p (args_to_skip, 0))
228 DECL_VINDEX (new_decl) = NULL_TREE;
230 /* When signature changes, we need to clear builtin info. */
231 if (DECL_BUILT_IN (new_decl)
232 && args_to_skip
233 && !bitmap_empty_p (args_to_skip))
235 DECL_BUILT_IN_CLASS (new_decl) = NOT_BUILT_IN;
236 DECL_FUNCTION_CODE (new_decl) = (enum built_in_function) 0;
238 /* The FE might have information and assumptions about the other
239 arguments. */
240 DECL_LANG_SPECIFIC (new_decl) = NULL;
241 return new_decl;
244 /* Set flags of NEW_NODE and its decl. NEW_NODE is a newly created private
245 clone or its thunk. */
247 static void
248 set_new_clone_decl_and_node_flags (cgraph_node *new_node)
250 DECL_EXTERNAL (new_node->decl) = 0;
251 TREE_PUBLIC (new_node->decl) = 0;
252 DECL_COMDAT (new_node->decl) = 0;
253 DECL_WEAK (new_node->decl) = 0;
254 DECL_VIRTUAL_P (new_node->decl) = 0;
255 DECL_STATIC_CONSTRUCTOR (new_node->decl) = 0;
256 DECL_STATIC_DESTRUCTOR (new_node->decl) = 0;
258 new_node->externally_visible = 0;
259 new_node->local.local = 1;
260 new_node->lowered = true;
263 /* Duplicate thunk THUNK if necessary but make it to refer to NODE.
264 ARGS_TO_SKIP, if non-NULL, determines which parameters should be omitted.
265 Function can return NODE if no thunk is necessary, which can happen when
266 thunk is this_adjusting but we are removing this parameter. */
268 static cgraph_node *
269 duplicate_thunk_for_node (cgraph_node *thunk, cgraph_node *node)
271 cgraph_node *new_thunk, *thunk_of;
272 thunk_of = thunk->callees->callee->ultimate_alias_target ();
274 if (thunk_of->thunk.thunk_p)
275 node = duplicate_thunk_for_node (thunk_of, node);
277 if (!DECL_ARGUMENTS (thunk->decl))
278 thunk->get_untransformed_body ();
280 cgraph_edge *cs;
281 for (cs = node->callers; cs; cs = cs->next_caller)
282 if (cs->caller->thunk.thunk_p
283 && cs->caller->thunk.this_adjusting == thunk->thunk.this_adjusting
284 && cs->caller->thunk.fixed_offset == thunk->thunk.fixed_offset
285 && cs->caller->thunk.virtual_offset_p == thunk->thunk.virtual_offset_p
286 && cs->caller->thunk.virtual_value == thunk->thunk.virtual_value)
287 return cs->caller;
289 tree new_decl;
290 if (!node->clone.args_to_skip)
291 new_decl = copy_node (thunk->decl);
292 else
294 /* We do not need to duplicate this_adjusting thunks if we have removed
295 this. */
296 if (thunk->thunk.this_adjusting
297 && bitmap_bit_p (node->clone.args_to_skip, 0))
298 return node;
300 new_decl = build_function_decl_skip_args (thunk->decl,
301 node->clone.args_to_skip,
302 false);
305 tree *link = &DECL_ARGUMENTS (new_decl);
306 int i = 0;
307 for (tree pd = DECL_ARGUMENTS (thunk->decl); pd; pd = DECL_CHAIN (pd), i++)
309 if (!node->clone.args_to_skip
310 || !bitmap_bit_p (node->clone.args_to_skip, i))
312 tree nd = copy_node (pd);
313 DECL_CONTEXT (nd) = new_decl;
314 *link = nd;
315 link = &DECL_CHAIN (nd);
318 *link = NULL_TREE;
320 gcc_checking_assert (!DECL_STRUCT_FUNCTION (new_decl));
321 gcc_checking_assert (!DECL_INITIAL (new_decl));
322 gcc_checking_assert (!DECL_RESULT (new_decl));
323 gcc_checking_assert (!DECL_RTL_SET_P (new_decl));
325 DECL_NAME (new_decl) = clone_function_name (thunk->decl, "artificial_thunk");
326 SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
328 new_thunk = cgraph_node::create (new_decl);
329 set_new_clone_decl_and_node_flags (new_thunk);
330 new_thunk->definition = true;
331 new_thunk->thunk = thunk->thunk;
332 new_thunk->unique_name = in_lto_p;
333 new_thunk->former_clone_of = thunk->decl;
334 new_thunk->clone.args_to_skip = node->clone.args_to_skip;
335 new_thunk->clone.combined_args_to_skip = node->clone.combined_args_to_skip;
337 cgraph_edge *e = new_thunk->create_edge (node, NULL, 0,
338 CGRAPH_FREQ_BASE);
339 e->call_stmt_cannot_inline_p = true;
340 symtab->call_edge_duplication_hooks (thunk->callees, e);
341 symtab->call_cgraph_duplication_hooks (thunk, new_thunk);
342 return new_thunk;
345 /* If E does not lead to a thunk, simply redirect it to N. Otherwise create
346 one or more equivalent thunks for N and redirect E to the first in the
347 chain. Note that it is then necessary to call
348 n->expand_all_artificial_thunks once all callers are redirected. */
350 void
351 cgraph_edge::redirect_callee_duplicating_thunks (cgraph_node *n)
353 cgraph_node *orig_to = callee->ultimate_alias_target ();
354 if (orig_to->thunk.thunk_p)
355 n = duplicate_thunk_for_node (orig_to, n);
357 redirect_callee (n);
360 /* Call expand_thunk on all callers that are thunks and if analyze those nodes
361 that were expanded. */
363 void
364 cgraph_node::expand_all_artificial_thunks ()
366 cgraph_edge *e;
367 for (e = callers; e;)
368 if (e->caller->thunk.thunk_p)
370 cgraph_node *thunk = e->caller;
372 e = e->next_caller;
373 if (thunk->expand_thunk (false, false))
375 thunk->thunk.thunk_p = false;
376 thunk->analyze ();
378 thunk->expand_all_artificial_thunks ();
380 else
381 e = e->next_caller;
384 /* Create node representing clone of N executed COUNT times. Decrease
385 the execution counts from original node too.
386 The new clone will have decl set to DECL that may or may not be the same
387 as decl of N.
389 When UPDATE_ORIGINAL is true, the counts are subtracted from the original
390 function's profile to reflect the fact that part of execution is handled
391 by node.
392 When CALL_DUPLICATOIN_HOOK is true, the ipa passes are acknowledged about
393 the new clone. Otherwise the caller is responsible for doing so later.
395 If the new node is being inlined into another one, NEW_INLINED_TO should be
396 the outline function the new one is (even indirectly) inlined to. All hooks
397 will see this in node's global.inlined_to, when invoked. Can be NULL if the
398 node is not inlined. */
400 cgraph_node *
401 cgraph_node::create_clone (tree new_decl, gcov_type gcov_count, int freq,
402 bool update_original,
403 vec<cgraph_edge *> redirect_callers,
404 bool call_duplication_hook,
405 cgraph_node *new_inlined_to,
406 bitmap args_to_skip)
408 cgraph_node *new_node = symtab->create_empty ();
409 cgraph_edge *e;
410 gcov_type count_scale;
411 unsigned i;
413 new_node->decl = new_decl;
414 new_node->register_symbol ();
415 new_node->origin = origin;
416 new_node->lto_file_data = lto_file_data;
417 if (new_node->origin)
419 new_node->next_nested = new_node->origin->nested;
420 new_node->origin->nested = new_node;
422 new_node->analyzed = analyzed;
423 new_node->definition = definition;
424 new_node->local = local;
425 new_node->externally_visible = false;
426 new_node->no_reorder = no_reorder;
427 new_node->local.local = true;
428 new_node->global = global;
429 new_node->global.inlined_to = new_inlined_to;
430 new_node->rtl = rtl;
431 new_node->count = count;
432 new_node->frequency = frequency;
433 new_node->tp_first_run = tp_first_run;
434 new_node->tm_clone = tm_clone;
435 new_node->icf_merged = icf_merged;
436 new_node->merged = merged;
438 new_node->clone.tree_map = NULL;
439 new_node->clone.args_to_skip = args_to_skip;
440 new_node->split_part = split_part;
441 if (!args_to_skip)
442 new_node->clone.combined_args_to_skip = clone.combined_args_to_skip;
443 else if (clone.combined_args_to_skip)
445 new_node->clone.combined_args_to_skip = BITMAP_GGC_ALLOC ();
446 bitmap_ior (new_node->clone.combined_args_to_skip,
447 clone.combined_args_to_skip, args_to_skip);
449 else
450 new_node->clone.combined_args_to_skip = args_to_skip;
452 if (count)
454 if (new_node->count > count)
455 count_scale = REG_BR_PROB_BASE;
456 else
457 count_scale = GCOV_COMPUTE_SCALE (new_node->count, count);
459 else
460 count_scale = 0;
461 if (update_original)
463 count -= gcov_count;
464 if (count < 0)
465 count = 0;
468 FOR_EACH_VEC_ELT (redirect_callers, i, e)
470 /* Redirect calls to the old version node to point to its new
471 version. The only exception is when the edge was proved to
472 be unreachable during the clonning procedure. */
473 if (!e->callee
474 || DECL_BUILT_IN_CLASS (e->callee->decl) != BUILT_IN_NORMAL
475 || DECL_FUNCTION_CODE (e->callee->decl) != BUILT_IN_UNREACHABLE)
476 e->redirect_callee_duplicating_thunks (new_node);
478 new_node->expand_all_artificial_thunks ();
480 for (e = callees;e; e=e->next_callee)
481 e->clone (new_node, e->call_stmt, e->lto_stmt_uid, count_scale,
482 freq, update_original);
484 for (e = indirect_calls; e; e = e->next_callee)
485 e->clone (new_node, e->call_stmt, e->lto_stmt_uid,
486 count_scale, freq, update_original);
487 new_node->clone_references (this);
489 new_node->next_sibling_clone = clones;
490 if (clones)
491 clones->prev_sibling_clone = new_node;
492 clones = new_node;
493 new_node->clone_of = this;
495 if (call_duplication_hook)
496 symtab->call_cgraph_duplication_hooks (this, new_node);
497 return new_node;
500 static GTY(()) unsigned int clone_fn_id_num;
502 /* Return a new assembler name for a clone with SUFFIX of a decl named
503 NAME. */
505 tree
506 clone_function_name_1 (const char *name, const char *suffix)
508 size_t len = strlen (name);
509 char *tmp_name, *prefix;
511 prefix = XALLOCAVEC (char, len + strlen (suffix) + 2);
512 memcpy (prefix, name, len);
513 strcpy (prefix + len + 1, suffix);
514 #ifndef NO_DOT_IN_LABEL
515 prefix[len] = '.';
516 #elif !defined NO_DOLLAR_IN_LABEL
517 prefix[len] = '$';
518 #else
519 prefix[len] = '_';
520 #endif
521 ASM_FORMAT_PRIVATE_NAME (tmp_name, prefix, clone_fn_id_num++);
522 return get_identifier (tmp_name);
525 /* Return a new assembler name for a clone of DECL with SUFFIX. */
527 tree
528 clone_function_name (tree decl, const char *suffix)
530 tree name = DECL_ASSEMBLER_NAME (decl);
531 return clone_function_name_1 (IDENTIFIER_POINTER (name), suffix);
535 /* Create callgraph node clone with new declaration. The actual body will
536 be copied later at compilation stage.
538 TODO: after merging in ipa-sra use function call notes instead of args_to_skip
539 bitmap interface.
541 cgraph_node *
542 cgraph_node::create_virtual_clone (vec<cgraph_edge *> redirect_callers,
543 vec<ipa_replace_map *, va_gc> *tree_map,
544 bitmap args_to_skip, const char * suffix)
546 tree old_decl = decl;
547 cgraph_node *new_node = NULL;
548 tree new_decl;
549 size_t len, i;
550 ipa_replace_map *map;
551 char *name;
553 gcc_checking_assert (local.versionable);
554 gcc_assert (local.can_change_signature || !args_to_skip);
556 /* Make a new FUNCTION_DECL tree node */
557 if (!args_to_skip)
558 new_decl = copy_node (old_decl);
559 else
560 new_decl = build_function_decl_skip_args (old_decl, args_to_skip, false);
562 /* These pointers represent function body and will be populated only when clone
563 is materialized. */
564 gcc_assert (new_decl != old_decl);
565 DECL_STRUCT_FUNCTION (new_decl) = NULL;
566 DECL_ARGUMENTS (new_decl) = NULL;
567 DECL_INITIAL (new_decl) = NULL;
568 DECL_RESULT (new_decl) = NULL;
569 /* We can not do DECL_RESULT (new_decl) = NULL; here because of LTO partitioning
570 sometimes storing only clone decl instead of original. */
572 /* Generate a new name for the new version. */
573 len = IDENTIFIER_LENGTH (DECL_NAME (old_decl));
574 name = XALLOCAVEC (char, len + strlen (suffix) + 2);
575 memcpy (name, IDENTIFIER_POINTER (DECL_NAME (old_decl)), len);
576 strcpy (name + len + 1, suffix);
577 name[len] = '.';
578 DECL_NAME (new_decl) = get_identifier (name);
579 SET_DECL_ASSEMBLER_NAME (new_decl, clone_function_name (old_decl, suffix));
580 SET_DECL_RTL (new_decl, NULL);
582 new_node = create_clone (new_decl, count, CGRAPH_FREQ_BASE, false,
583 redirect_callers, false, NULL, args_to_skip);
585 /* Update the properties.
586 Make clone visible only within this translation unit. Make sure
587 that is not weak also.
588 ??? We cannot use COMDAT linkage because there is no
589 ABI support for this. */
590 set_new_clone_decl_and_node_flags (new_node);
591 new_node->clone.tree_map = tree_map;
592 if (!implicit_section)
593 new_node->set_section (get_section ());
595 /* Clones of global symbols or symbols with unique names are unique. */
596 if ((TREE_PUBLIC (old_decl)
597 && !DECL_EXTERNAL (old_decl)
598 && !DECL_WEAK (old_decl)
599 && !DECL_COMDAT (old_decl))
600 || in_lto_p)
601 new_node->unique_name = true;
602 FOR_EACH_VEC_SAFE_ELT (tree_map, i, map)
603 new_node->maybe_create_reference (map->new_tree, IPA_REF_ADDR, NULL);
605 if (ipa_transforms_to_apply.exists ())
606 new_node->ipa_transforms_to_apply
607 = ipa_transforms_to_apply.copy ();
609 symtab->call_cgraph_duplication_hooks (this, new_node);
611 return new_node;
614 /* callgraph node being removed from symbol table; see if its entry can be
615 replaced by other inline clone. */
616 cgraph_node *
617 cgraph_node::find_replacement (void)
619 cgraph_node *next_inline_clone, *replacement;
621 for (next_inline_clone = clones;
622 next_inline_clone
623 && next_inline_clone->decl != decl;
624 next_inline_clone = next_inline_clone->next_sibling_clone)
627 /* If there is inline clone of the node being removed, we need
628 to put it into the position of removed node and reorganize all
629 other clones to be based on it. */
630 if (next_inline_clone)
632 cgraph_node *n;
633 cgraph_node *new_clones;
635 replacement = next_inline_clone;
637 /* Unlink inline clone from the list of clones of removed node. */
638 if (next_inline_clone->next_sibling_clone)
639 next_inline_clone->next_sibling_clone->prev_sibling_clone
640 = next_inline_clone->prev_sibling_clone;
641 if (next_inline_clone->prev_sibling_clone)
643 gcc_assert (clones != next_inline_clone);
644 next_inline_clone->prev_sibling_clone->next_sibling_clone
645 = next_inline_clone->next_sibling_clone;
647 else
649 gcc_assert (clones == next_inline_clone);
650 clones = next_inline_clone->next_sibling_clone;
653 new_clones = clones;
654 clones = NULL;
656 /* Copy clone info. */
657 next_inline_clone->clone = clone;
659 /* Now place it into clone tree at same level at NODE. */
660 next_inline_clone->clone_of = clone_of;
661 next_inline_clone->prev_sibling_clone = NULL;
662 next_inline_clone->next_sibling_clone = NULL;
663 if (clone_of)
665 if (clone_of->clones)
666 clone_of->clones->prev_sibling_clone = next_inline_clone;
667 next_inline_clone->next_sibling_clone = clone_of->clones;
668 clone_of->clones = next_inline_clone;
671 /* Merge the clone list. */
672 if (new_clones)
674 if (!next_inline_clone->clones)
675 next_inline_clone->clones = new_clones;
676 else
678 n = next_inline_clone->clones;
679 while (n->next_sibling_clone)
680 n = n->next_sibling_clone;
681 n->next_sibling_clone = new_clones;
682 new_clones->prev_sibling_clone = n;
686 /* Update clone_of pointers. */
687 n = new_clones;
688 while (n)
690 n->clone_of = next_inline_clone;
691 n = n->next_sibling_clone;
693 return replacement;
695 else
696 return NULL;
699 /* Like cgraph_set_call_stmt but walk the clone tree and update all
700 clones sharing the same function body.
701 When WHOLE_SPECULATIVE_EDGES is true, all three components of
702 speculative edge gets updated. Otherwise we update only direct
703 call. */
705 void
706 cgraph_node::set_call_stmt_including_clones (gimple *old_stmt,
707 gcall *new_stmt,
708 bool update_speculative)
710 cgraph_node *node;
711 cgraph_edge *edge = get_edge (old_stmt);
713 if (edge)
714 edge->set_call_stmt (new_stmt, update_speculative);
716 node = clones;
717 if (node)
718 while (node != this)
720 cgraph_edge *edge = node->get_edge (old_stmt);
721 if (edge)
723 edge->set_call_stmt (new_stmt, update_speculative);
724 /* If UPDATE_SPECULATIVE is false, it means that we are turning
725 speculative call into a real code sequence. Update the
726 callgraph edges. */
727 if (edge->speculative && !update_speculative)
729 cgraph_edge *direct, *indirect;
730 ipa_ref *ref;
732 gcc_assert (!edge->indirect_unknown_callee);
733 edge->speculative_call_info (direct, indirect, ref);
734 direct->speculative = false;
735 indirect->speculative = false;
736 ref->speculative = false;
739 if (node->clones)
740 node = node->clones;
741 else if (node->next_sibling_clone)
742 node = node->next_sibling_clone;
743 else
745 while (node != this && !node->next_sibling_clone)
746 node = node->clone_of;
747 if (node != this)
748 node = node->next_sibling_clone;
753 /* Like cgraph_create_edge walk the clone tree and update all clones sharing
754 same function body. If clones already have edge for OLD_STMT; only
755 update the edge same way as cgraph_set_call_stmt_including_clones does.
757 TODO: COUNT and LOOP_DEPTH should be properly distributed based on relative
758 frequencies of the clones. */
760 void
761 cgraph_node::create_edge_including_clones (cgraph_node *callee,
762 gimple *old_stmt, gcall *stmt,
763 gcov_type count,
764 int freq,
765 cgraph_inline_failed_t reason)
767 cgraph_node *node;
768 cgraph_edge *edge;
770 if (!get_edge (stmt))
772 edge = create_edge (callee, stmt, count, freq);
773 edge->inline_failed = reason;
776 node = clones;
777 if (node)
778 while (node != this)
780 cgraph_edge *edge = node->get_edge (old_stmt);
782 /* It is possible that clones already contain the edge while
783 master didn't. Either we promoted indirect call into direct
784 call in the clone or we are processing clones of unreachable
785 master where edges has been removed. */
786 if (edge)
787 edge->set_call_stmt (stmt);
788 else if (! node->get_edge (stmt))
790 edge = node->create_edge (callee, stmt, count, freq);
791 edge->inline_failed = reason;
794 if (node->clones)
795 node = node->clones;
796 else if (node->next_sibling_clone)
797 node = node->next_sibling_clone;
798 else
800 while (node != this && !node->next_sibling_clone)
801 node = node->clone_of;
802 if (node != this)
803 node = node->next_sibling_clone;
808 /* Remove the node from cgraph and all inline clones inlined into it.
809 Skip however removal of FORBIDDEN_NODE and return true if it needs to be
810 removed. This allows to call the function from outer loop walking clone
811 tree. */
813 bool
814 cgraph_node::remove_symbol_and_inline_clones (cgraph_node *forbidden_node)
816 cgraph_edge *e, *next;
817 bool found = false;
819 if (this == forbidden_node)
821 callers->remove ();
822 return true;
824 for (e = callees; e; e = next)
826 next = e->next_callee;
827 if (!e->inline_failed)
828 found |= e->callee->remove_symbol_and_inline_clones (forbidden_node);
830 remove ();
831 return found;
834 /* The edges representing the callers of the NEW_VERSION node were
835 fixed by cgraph_function_versioning (), now the call_expr in their
836 respective tree code should be updated to call the NEW_VERSION. */
838 static void
839 update_call_expr (cgraph_node *new_version)
841 cgraph_edge *e;
843 gcc_assert (new_version);
845 /* Update the call expr on the edges to call the new version. */
846 for (e = new_version->callers; e; e = e->next_caller)
848 function *inner_function = DECL_STRUCT_FUNCTION (e->caller->decl);
849 gimple_call_set_fndecl (e->call_stmt, new_version->decl);
850 maybe_clean_eh_stmt_fn (inner_function, e->call_stmt);
855 /* Create a new cgraph node which is the new version of
856 callgraph node. REDIRECT_CALLERS holds the callers
857 edges which should be redirected to point to
858 NEW_VERSION. ALL the callees edges of the node
859 are cloned to the new version node. Return the new
860 version node.
862 If non-NULL BLOCK_TO_COPY determine what basic blocks
863 was copied to prevent duplications of calls that are dead
864 in the clone. */
866 cgraph_node *
867 cgraph_node::create_version_clone (tree new_decl,
868 vec<cgraph_edge *> redirect_callers,
869 bitmap bbs_to_copy)
871 cgraph_node *new_version;
872 cgraph_edge *e;
873 unsigned i;
875 new_version = cgraph_node::create (new_decl);
877 new_version->analyzed = analyzed;
878 new_version->definition = definition;
879 new_version->local = local;
880 new_version->externally_visible = false;
881 new_version->no_reorder = no_reorder;
882 new_version->local.local = new_version->definition;
883 new_version->global = global;
884 new_version->rtl = rtl;
885 new_version->count = count;
887 for (e = callees; e; e=e->next_callee)
888 if (!bbs_to_copy
889 || bitmap_bit_p (bbs_to_copy, gimple_bb (e->call_stmt)->index))
890 e->clone (new_version, e->call_stmt,
891 e->lto_stmt_uid, REG_BR_PROB_BASE,
892 CGRAPH_FREQ_BASE,
893 true);
894 for (e = indirect_calls; e; e=e->next_callee)
895 if (!bbs_to_copy
896 || bitmap_bit_p (bbs_to_copy, gimple_bb (e->call_stmt)->index))
897 e->clone (new_version, e->call_stmt,
898 e->lto_stmt_uid, REG_BR_PROB_BASE,
899 CGRAPH_FREQ_BASE,
900 true);
901 FOR_EACH_VEC_ELT (redirect_callers, i, e)
903 /* Redirect calls to the old version node to point to its new
904 version. */
905 e->redirect_callee (new_version);
908 symtab->call_cgraph_duplication_hooks (this, new_version);
910 return new_version;
913 /* Perform function versioning.
914 Function versioning includes copying of the tree and
915 a callgraph update (creating a new cgraph node and updating
916 its callees and callers).
918 REDIRECT_CALLERS varray includes the edges to be redirected
919 to the new version.
921 TREE_MAP is a mapping of tree nodes we want to replace with
922 new ones (according to results of prior analysis).
924 If non-NULL ARGS_TO_SKIP determine function parameters to remove
925 from new version.
926 If SKIP_RETURN is true, the new version will return void.
927 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
928 If non_NULL NEW_ENTRY determine new entry BB of the clone.
930 Return the new version's cgraph node. */
932 cgraph_node *
933 cgraph_node::create_version_clone_with_body
934 (vec<cgraph_edge *> redirect_callers,
935 vec<ipa_replace_map *, va_gc> *tree_map, bitmap args_to_skip,
936 bool skip_return, bitmap bbs_to_copy, basic_block new_entry_block,
937 const char *clone_name)
939 tree old_decl = decl;
940 cgraph_node *new_version_node = NULL;
941 tree new_decl;
943 if (!tree_versionable_function_p (old_decl))
944 return NULL;
946 gcc_assert (local.can_change_signature || !args_to_skip);
948 /* Make a new FUNCTION_DECL tree node for the new version. */
949 if (!args_to_skip && !skip_return)
950 new_decl = copy_node (old_decl);
951 else
952 new_decl
953 = build_function_decl_skip_args (old_decl, args_to_skip, skip_return);
955 /* Generate a new name for the new version. */
956 DECL_NAME (new_decl) = clone_function_name (old_decl, clone_name);
957 SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
958 SET_DECL_RTL (new_decl, NULL);
960 /* When the old decl was a con-/destructor make sure the clone isn't. */
961 DECL_STATIC_CONSTRUCTOR (new_decl) = 0;
962 DECL_STATIC_DESTRUCTOR (new_decl) = 0;
964 /* Create the new version's call-graph node.
965 and update the edges of the new node. */
966 new_version_node = create_version_clone (new_decl, redirect_callers,
967 bbs_to_copy);
969 if (ipa_transforms_to_apply.exists ())
970 new_version_node->ipa_transforms_to_apply
971 = ipa_transforms_to_apply.copy ();
972 /* Copy the OLD_VERSION_NODE function tree to the new version. */
973 tree_function_versioning (old_decl, new_decl, tree_map, false, args_to_skip,
974 skip_return, bbs_to_copy, new_entry_block);
976 /* Update the new version's properties.
977 Make The new version visible only within this translation unit. Make sure
978 that is not weak also.
979 ??? We cannot use COMDAT linkage because there is no
980 ABI support for this. */
981 new_version_node->make_decl_local ();
982 DECL_VIRTUAL_P (new_version_node->decl) = 0;
983 new_version_node->externally_visible = 0;
984 new_version_node->local.local = 1;
985 new_version_node->lowered = true;
986 if (!implicit_section)
987 new_version_node->set_section (get_section ());
988 /* Clones of global symbols or symbols with unique names are unique. */
989 if ((TREE_PUBLIC (old_decl)
990 && !DECL_EXTERNAL (old_decl)
991 && !DECL_WEAK (old_decl)
992 && !DECL_COMDAT (old_decl))
993 || in_lto_p)
994 new_version_node->unique_name = true;
996 /* Update the call_expr on the edges to call the new version node. */
997 update_call_expr (new_version_node);
999 symtab->call_cgraph_insertion_hooks (this);
1000 return new_version_node;
1003 /* Given virtual clone, turn it into actual clone. */
1005 static void
1006 cgraph_materialize_clone (cgraph_node *node)
1008 bitmap_obstack_initialize (NULL);
1009 node->former_clone_of = node->clone_of->decl;
1010 if (node->clone_of->former_clone_of)
1011 node->former_clone_of = node->clone_of->former_clone_of;
1012 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1013 tree_function_versioning (node->clone_of->decl, node->decl,
1014 node->clone.tree_map, true,
1015 node->clone.args_to_skip, false,
1016 NULL, NULL);
1017 if (symtab->dump_file)
1019 dump_function_to_file (node->clone_of->decl, symtab->dump_file,
1020 dump_flags);
1021 dump_function_to_file (node->decl, symtab->dump_file, dump_flags);
1024 /* Function is no longer clone. */
1025 if (node->next_sibling_clone)
1026 node->next_sibling_clone->prev_sibling_clone = node->prev_sibling_clone;
1027 if (node->prev_sibling_clone)
1028 node->prev_sibling_clone->next_sibling_clone = node->next_sibling_clone;
1029 else
1030 node->clone_of->clones = node->next_sibling_clone;
1031 node->next_sibling_clone = NULL;
1032 node->prev_sibling_clone = NULL;
1033 if (!node->clone_of->analyzed && !node->clone_of->clones)
1035 node->clone_of->release_body ();
1036 node->clone_of->remove_callees ();
1037 node->clone_of->remove_all_references ();
1039 node->clone_of = NULL;
1040 bitmap_obstack_release (NULL);
1043 /* Once all functions from compilation unit are in memory, produce all clones
1044 and update all calls. We might also do this on demand if we don't want to
1045 bring all functions to memory prior compilation, but current WHOPR
1046 implementation does that and it is a bit easier to keep everything right in
1047 this order. */
1049 void
1050 symbol_table::materialize_all_clones (void)
1052 cgraph_node *node;
1053 bool stabilized = false;
1056 if (symtab->dump_file)
1057 fprintf (symtab->dump_file, "Materializing clones\n");
1059 cgraph_node::checking_verify_cgraph_nodes ();
1061 /* We can also do topological order, but number of iterations should be
1062 bounded by number of IPA passes since single IPA pass is probably not
1063 going to create clones of clones it created itself. */
1064 while (!stabilized)
1066 stabilized = true;
1067 FOR_EACH_FUNCTION (node)
1069 if (node->clone_of && node->decl != node->clone_of->decl
1070 && !gimple_has_body_p (node->decl))
1072 if (!node->clone_of->clone_of)
1073 node->clone_of->get_untransformed_body ();
1074 if (gimple_has_body_p (node->clone_of->decl))
1076 if (symtab->dump_file)
1078 fprintf (symtab->dump_file, "cloning %s to %s\n",
1079 xstrdup_for_dump (node->clone_of->name ()),
1080 xstrdup_for_dump (node->name ()));
1081 if (node->clone.tree_map)
1083 unsigned int i;
1084 fprintf (symtab->dump_file, " replace map: ");
1085 for (i = 0;
1086 i < vec_safe_length (node->clone.tree_map);
1087 i++)
1089 ipa_replace_map *replace_info;
1090 replace_info = (*node->clone.tree_map)[i];
1091 print_generic_expr (symtab->dump_file, replace_info->old_tree, 0);
1092 fprintf (symtab->dump_file, " -> ");
1093 print_generic_expr (symtab->dump_file, replace_info->new_tree, 0);
1094 fprintf (symtab->dump_file, "%s%s;",
1095 replace_info->replace_p ? "(replace)":"",
1096 replace_info->ref_p ? "(ref)":"");
1098 fprintf (symtab->dump_file, "\n");
1100 if (node->clone.args_to_skip)
1102 fprintf (symtab->dump_file, " args_to_skip: ");
1103 dump_bitmap (symtab->dump_file,
1104 node->clone.args_to_skip);
1106 if (node->clone.args_to_skip)
1108 fprintf (symtab->dump_file, " combined_args_to_skip:");
1109 dump_bitmap (symtab->dump_file, node->clone.combined_args_to_skip);
1112 cgraph_materialize_clone (node);
1113 stabilized = false;
1118 FOR_EACH_FUNCTION (node)
1119 if (!node->analyzed && node->callees)
1121 node->remove_callees ();
1122 node->remove_all_references ();
1124 else
1125 node->clear_stmts_in_references ();
1126 if (symtab->dump_file)
1127 fprintf (symtab->dump_file, "Materialization Call site updates done.\n");
1129 cgraph_node::checking_verify_cgraph_nodes ();
1131 symtab->remove_unreachable_nodes (symtab->dump_file);
1134 #include "gt-cgraphclones.h"