Fix ICE in lto_symtab_merge_symbols_1 (PR lto/88004).
[official-gcc.git] / gcc / cgraphclones.c
blob0fbc7a919bde3be70010e35fc2fee13ebcd8456a
1 /* Callgraph clones
2 Copyright (C) 2003-2018 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 "dumpfile.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 profile_count num, profile_count den,
90 bool update_original)
92 cgraph_edge *new_edge;
93 profile_count::adjust_for_ipa_scaling (&num, &den);
94 profile_count prof_count = count.apply_scale (num, den);
96 if (indirect_unknown_callee)
98 tree decl;
100 if (call_stmt && (decl = gimple_call_fndecl (call_stmt))
101 /* When the call is speculative, we need to resolve it
102 via cgraph_resolve_speculation and not here. */
103 && !speculative)
105 cgraph_node *callee = cgraph_node::get (decl);
106 gcc_checking_assert (callee);
107 new_edge = n->create_edge (callee, call_stmt, prof_count);
109 else
111 new_edge = n->create_indirect_edge (call_stmt,
112 indirect_info->ecf_flags,
113 prof_count, false);
114 *new_edge->indirect_info = *indirect_info;
117 else
119 new_edge = n->create_edge (callee, call_stmt, prof_count);
120 if (indirect_info)
122 new_edge->indirect_info
123 = ggc_cleared_alloc<cgraph_indirect_call_info> ();
124 *new_edge->indirect_info = *indirect_info;
128 new_edge->inline_failed = inline_failed;
129 new_edge->indirect_inlining_edge = indirect_inlining_edge;
130 new_edge->lto_stmt_uid = stmt_uid;
131 /* Clone flags that depend on call_stmt availability manually. */
132 new_edge->can_throw_external = can_throw_external;
133 new_edge->call_stmt_cannot_inline_p = call_stmt_cannot_inline_p;
134 new_edge->speculative = speculative;
135 new_edge->in_polymorphic_cdtor = in_polymorphic_cdtor;
137 /* Update IPA profile. Local profiles need no updating in original. */
138 if (update_original)
139 count = count.combine_with_ipa_count (count.ipa ()
140 - new_edge->count.ipa ());
141 symtab->call_edge_duplication_hooks (this, new_edge);
142 return new_edge;
145 /* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP and the
146 return value if SKIP_RETURN is true. */
148 tree
149 cgraph_build_function_type_skip_args (tree orig_type, bitmap args_to_skip,
150 bool skip_return)
152 tree new_type = NULL;
153 tree args, new_args = NULL;
154 tree new_reversed;
155 int i = 0;
157 for (args = TYPE_ARG_TYPES (orig_type); args && args != void_list_node;
158 args = TREE_CHAIN (args), i++)
159 if (!args_to_skip || !bitmap_bit_p (args_to_skip, i))
160 new_args = tree_cons (NULL_TREE, TREE_VALUE (args), new_args);
162 new_reversed = nreverse (new_args);
163 if (args)
165 if (new_reversed)
166 TREE_CHAIN (new_args) = void_list_node;
167 else
168 new_reversed = void_list_node;
171 /* Use copy_node to preserve as much as possible from original type
172 (debug info, attribute lists etc.)
173 Exception is METHOD_TYPEs must have THIS argument.
174 When we are asked to remove it, we need to build new FUNCTION_TYPE
175 instead. */
176 if (TREE_CODE (orig_type) != METHOD_TYPE
177 || !args_to_skip
178 || !bitmap_bit_p (args_to_skip, 0))
180 new_type = build_distinct_type_copy (orig_type);
181 TYPE_ARG_TYPES (new_type) = new_reversed;
183 else
185 new_type
186 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type),
187 new_reversed));
188 TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type);
191 if (skip_return)
192 TREE_TYPE (new_type) = void_type_node;
194 return new_type;
197 /* Build variant of function decl ORIG_DECL skipping ARGS_TO_SKIP and the
198 return value if SKIP_RETURN is true.
200 Arguments from DECL_ARGUMENTS list can't be removed now, since they are
201 linked by TREE_CHAIN directly. The caller is responsible for eliminating
202 them when they are being duplicated (i.e. copy_arguments_for_versioning). */
204 static tree
205 build_function_decl_skip_args (tree orig_decl, bitmap args_to_skip,
206 bool skip_return)
208 tree new_decl = copy_node (orig_decl);
209 tree new_type;
211 new_type = TREE_TYPE (orig_decl);
212 if (prototype_p (new_type)
213 || (skip_return && !VOID_TYPE_P (TREE_TYPE (new_type))))
214 new_type
215 = cgraph_build_function_type_skip_args (new_type, args_to_skip,
216 skip_return);
217 TREE_TYPE (new_decl) = new_type;
219 /* For declarations setting DECL_VINDEX (i.e. methods)
220 we expect first argument to be THIS pointer. */
221 if (args_to_skip && bitmap_bit_p (args_to_skip, 0))
222 DECL_VINDEX (new_decl) = NULL_TREE;
224 /* When signature changes, we need to clear builtin info. */
225 if (fndecl_built_in_p (new_decl)
226 && args_to_skip
227 && !bitmap_empty_p (args_to_skip))
229 DECL_BUILT_IN_CLASS (new_decl) = NOT_BUILT_IN;
230 DECL_FUNCTION_CODE (new_decl) = (enum built_in_function) 0;
232 /* The FE might have information and assumptions about the other
233 arguments. */
234 DECL_LANG_SPECIFIC (new_decl) = NULL;
235 return new_decl;
238 /* Set flags of NEW_NODE and its decl. NEW_NODE is a newly created private
239 clone or its thunk. */
241 static void
242 set_new_clone_decl_and_node_flags (cgraph_node *new_node)
244 DECL_EXTERNAL (new_node->decl) = 0;
245 TREE_PUBLIC (new_node->decl) = 0;
246 DECL_COMDAT (new_node->decl) = 0;
247 DECL_WEAK (new_node->decl) = 0;
248 DECL_VIRTUAL_P (new_node->decl) = 0;
249 DECL_STATIC_CONSTRUCTOR (new_node->decl) = 0;
250 DECL_STATIC_DESTRUCTOR (new_node->decl) = 0;
252 new_node->externally_visible = 0;
253 new_node->local.local = 1;
254 new_node->lowered = true;
257 /* Duplicate thunk THUNK if necessary but make it to refer to NODE.
258 ARGS_TO_SKIP, if non-NULL, determines which parameters should be omitted.
259 Function can return NODE if no thunk is necessary, which can happen when
260 thunk is this_adjusting but we are removing this parameter. */
262 static cgraph_node *
263 duplicate_thunk_for_node (cgraph_node *thunk, cgraph_node *node)
265 cgraph_node *new_thunk, *thunk_of;
266 thunk_of = thunk->callees->callee->ultimate_alias_target ();
268 if (thunk_of->thunk.thunk_p)
269 node = duplicate_thunk_for_node (thunk_of, node);
271 if (!DECL_ARGUMENTS (thunk->decl))
272 thunk->get_untransformed_body ();
274 cgraph_edge *cs;
275 for (cs = node->callers; cs; cs = cs->next_caller)
276 if (cs->caller->thunk.thunk_p
277 && cs->caller->thunk.fixed_offset == thunk->thunk.fixed_offset
278 && cs->caller->thunk.virtual_value == thunk->thunk.virtual_value
279 && cs->caller->thunk.indirect_offset == thunk->thunk.indirect_offset
280 && cs->caller->thunk.this_adjusting == thunk->thunk.this_adjusting
281 && cs->caller->thunk.virtual_offset_p == thunk->thunk.virtual_offset_p)
282 return cs->caller;
284 tree new_decl;
285 if (!node->clone.args_to_skip)
286 new_decl = copy_node (thunk->decl);
287 else
289 /* We do not need to duplicate this_adjusting thunks if we have removed
290 this. */
291 if (thunk->thunk.this_adjusting
292 && bitmap_bit_p (node->clone.args_to_skip, 0))
293 return node;
295 new_decl = build_function_decl_skip_args (thunk->decl,
296 node->clone.args_to_skip,
297 false);
300 tree *link = &DECL_ARGUMENTS (new_decl);
301 int i = 0;
302 for (tree pd = DECL_ARGUMENTS (thunk->decl); pd; pd = DECL_CHAIN (pd), i++)
304 if (!node->clone.args_to_skip
305 || !bitmap_bit_p (node->clone.args_to_skip, i))
307 tree nd = copy_node (pd);
308 DECL_CONTEXT (nd) = new_decl;
309 *link = nd;
310 link = &DECL_CHAIN (nd);
313 *link = NULL_TREE;
315 gcc_checking_assert (!DECL_STRUCT_FUNCTION (new_decl));
316 gcc_checking_assert (!DECL_INITIAL (new_decl));
317 gcc_checking_assert (!DECL_RESULT (new_decl));
318 gcc_checking_assert (!DECL_RTL_SET_P (new_decl));
320 DECL_NAME (new_decl) = clone_function_name_numbered (thunk->decl,
321 "artificial_thunk");
322 SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
324 /* We need to force DECL_IGNORED_P because the new thunk is created after
325 early debug was run. */
326 DECL_IGNORED_P (new_decl) = 1;
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->local.can_change_signature = node->local.can_change_signature;
332 new_thunk->thunk = thunk->thunk;
333 new_thunk->unique_name = in_lto_p;
334 new_thunk->former_clone_of = thunk->decl;
335 new_thunk->clone.args_to_skip = node->clone.args_to_skip;
336 new_thunk->clone.combined_args_to_skip = node->clone.combined_args_to_skip;
338 cgraph_edge *e = new_thunk->create_edge (node, NULL, new_thunk->count);
339 symtab->call_edge_duplication_hooks (thunk->callees, e);
340 symtab->call_cgraph_duplication_hooks (thunk, new_thunk);
341 return new_thunk;
344 /* If E does not lead to a thunk, simply redirect it to N. Otherwise create
345 one or more equivalent thunks for N and redirect E to the first in the
346 chain. Note that it is then necessary to call
347 n->expand_all_artificial_thunks once all callers are redirected. */
349 void
350 cgraph_edge::redirect_callee_duplicating_thunks (cgraph_node *n)
352 cgraph_node *orig_to = callee->ultimate_alias_target ();
353 if (orig_to->thunk.thunk_p)
354 n = duplicate_thunk_for_node (orig_to, n);
356 redirect_callee (n);
359 /* Call expand_thunk on all callers that are thunks and if analyze those nodes
360 that were expanded. */
362 void
363 cgraph_node::expand_all_artificial_thunks ()
365 cgraph_edge *e;
366 for (e = callers; e;)
367 if (e->caller->thunk.thunk_p)
369 cgraph_node *thunk = e->caller;
371 e = e->next_caller;
372 if (thunk->expand_thunk (false, false))
374 thunk->thunk.thunk_p = false;
375 thunk->analyze ();
377 thunk->expand_all_artificial_thunks ();
379 else
380 e = e->next_caller;
383 void
384 dump_callgraph_transformation (const cgraph_node *original,
385 const cgraph_node *clone,
386 const char *suffix)
388 if (symtab->ipa_clones_dump_file)
390 fprintf (symtab->ipa_clones_dump_file,
391 "Callgraph clone;%s;%d;%s;%d;%d;%s;%d;%s;%d;%d;%s\n",
392 original->asm_name (), original->order,
393 DECL_SOURCE_FILE (original->decl),
394 DECL_SOURCE_LINE (original->decl),
395 DECL_SOURCE_COLUMN (original->decl), clone->asm_name (),
396 clone->order, DECL_SOURCE_FILE (clone->decl),
397 DECL_SOURCE_LINE (clone->decl), DECL_SOURCE_COLUMN (clone->decl),
398 suffix);
400 symtab->cloned_nodes.add (original);
401 symtab->cloned_nodes.add (clone);
405 /* Create node representing clone of N executed COUNT times. Decrease
406 the execution counts from original node too.
407 The new clone will have decl set to DECL that may or may not be the same
408 as decl of N.
410 When UPDATE_ORIGINAL is true, the counts are subtracted from the original
411 function's profile to reflect the fact that part of execution is handled
412 by node.
413 When CALL_DUPLICATOIN_HOOK is true, the ipa passes are acknowledged about
414 the new clone. Otherwise the caller is responsible for doing so later.
416 If the new node is being inlined into another one, NEW_INLINED_TO should be
417 the outline function the new one is (even indirectly) inlined to. All hooks
418 will see this in node's global.inlined_to, when invoked. Can be NULL if the
419 node is not inlined. */
421 cgraph_node *
422 cgraph_node::create_clone (tree new_decl, profile_count prof_count,
423 bool update_original,
424 vec<cgraph_edge *> redirect_callers,
425 bool call_duplication_hook,
426 cgraph_node *new_inlined_to,
427 bitmap args_to_skip, const char *suffix)
429 cgraph_node *new_node = symtab->create_empty ();
430 cgraph_edge *e;
431 unsigned i;
432 profile_count old_count = count;
434 if (new_inlined_to)
435 dump_callgraph_transformation (this, new_inlined_to, "inlining to");
437 /* When inlining we scale precisely to prof_count, when cloning we can
438 preserve local profile. */
439 if (!new_inlined_to)
440 prof_count = count.combine_with_ipa_count (prof_count);
441 new_node->count = prof_count;
443 /* Update IPA profile. Local profiles need no updating in original. */
444 if (update_original)
445 count = count.combine_with_ipa_count (count.ipa () - prof_count.ipa ());
446 new_node->decl = new_decl;
447 new_node->register_symbol ();
448 new_node->origin = origin;
449 new_node->lto_file_data = lto_file_data;
450 if (new_node->origin)
452 new_node->next_nested = new_node->origin->nested;
453 new_node->origin->nested = new_node;
455 new_node->analyzed = analyzed;
456 new_node->definition = definition;
457 new_node->local = local;
458 new_node->externally_visible = false;
459 new_node->no_reorder = no_reorder;
460 new_node->local.local = true;
461 new_node->global = global;
462 new_node->global.inlined_to = new_inlined_to;
463 new_node->rtl = rtl;
464 new_node->frequency = frequency;
465 new_node->tp_first_run = tp_first_run;
466 new_node->tm_clone = tm_clone;
467 new_node->icf_merged = icf_merged;
468 new_node->merged_comdat = merged_comdat;
469 new_node->thunk = thunk;
471 new_node->clone.tree_map = NULL;
472 new_node->clone.args_to_skip = args_to_skip;
473 new_node->split_part = split_part;
474 if (!args_to_skip)
475 new_node->clone.combined_args_to_skip = clone.combined_args_to_skip;
476 else if (clone.combined_args_to_skip)
478 new_node->clone.combined_args_to_skip = BITMAP_GGC_ALLOC ();
479 bitmap_ior (new_node->clone.combined_args_to_skip,
480 clone.combined_args_to_skip, args_to_skip);
482 else
483 new_node->clone.combined_args_to_skip = args_to_skip;
485 FOR_EACH_VEC_ELT (redirect_callers, i, e)
487 /* Redirect calls to the old version node to point to its new
488 version. The only exception is when the edge was proved to
489 be unreachable during the clonning procedure. */
490 if (!e->callee
491 || !fndecl_built_in_p (e->callee->decl, BUILT_IN_UNREACHABLE))
492 e->redirect_callee_duplicating_thunks (new_node);
494 new_node->expand_all_artificial_thunks ();
496 for (e = callees;e; e=e->next_callee)
497 e->clone (new_node, e->call_stmt, e->lto_stmt_uid, new_node->count, old_count,
498 update_original);
500 for (e = indirect_calls; e; e = e->next_callee)
501 e->clone (new_node, e->call_stmt, e->lto_stmt_uid,
502 new_node->count, old_count, update_original);
503 new_node->clone_references (this);
505 new_node->next_sibling_clone = clones;
506 if (clones)
507 clones->prev_sibling_clone = new_node;
508 clones = new_node;
509 new_node->clone_of = this;
511 if (call_duplication_hook)
512 symtab->call_cgraph_duplication_hooks (this, new_node);
514 if (!new_inlined_to)
515 dump_callgraph_transformation (this, new_node, suffix);
517 return new_node;
520 static GTY(()) unsigned int clone_fn_id_num;
522 /* Return a new assembler name for a clone of decl named NAME. Apart
523 from the string SUFFIX, the new name will end with a unique (for
524 each NAME) unspecified number. If clone numbering is not needed
525 then the two argument clone_function_name should be used instead.
526 Should not be called directly except for by
527 lto-partition.c:privatize_symbol_name_1. */
529 tree
530 clone_function_name_numbered (const char *name, const char *suffix)
532 return clone_function_name (name, suffix, clone_fn_id_num++);
535 /* Return a new assembler name for a clone of DECL. Apart from string
536 SUFFIX, the new name will end with a unique (for each DECL
537 assembler name) unspecified number. If clone numbering is not
538 needed then the two argument clone_function_name should be used
539 instead. */
541 tree
542 clone_function_name_numbered (tree decl, const char *suffix)
544 tree name = DECL_ASSEMBLER_NAME (decl);
545 return clone_function_name_numbered (IDENTIFIER_POINTER (name),
546 suffix);
549 /* Return a new assembler name for a clone of decl named NAME. Apart
550 from the string SUFFIX, the new name will end with the specified
551 NUMBER. If clone numbering is not needed then the two argument
552 clone_function_name should be used instead. */
554 tree
555 clone_function_name (const char *name, const char *suffix,
556 unsigned long number)
558 size_t len = strlen (name);
559 char *tmp_name, *prefix;
561 prefix = XALLOCAVEC (char, len + strlen (suffix) + 2);
562 memcpy (prefix, name, len);
563 strcpy (prefix + len + 1, suffix);
564 prefix[len] = symbol_table::symbol_suffix_separator ();
565 ASM_FORMAT_PRIVATE_NAME (tmp_name, prefix, number);
566 return get_identifier (tmp_name);
569 /* Return a new assembler name ending with the string SUFFIX for a
570 clone of DECL. */
572 tree
573 clone_function_name (tree decl, const char *suffix)
575 tree identifier = DECL_ASSEMBLER_NAME (decl);
576 /* For consistency this needs to behave the same way as
577 ASM_FORMAT_PRIVATE_NAME does, but without the final number
578 suffix. */
579 char *separator = XALLOCAVEC (char, 2);
580 separator[0] = symbol_table::symbol_suffix_separator ();
581 separator[1] = 0;
582 #if defined (NO_DOT_IN_LABEL) && defined (NO_DOLLAR_IN_LABEL)
583 const char *prefix = "__";
584 #else
585 const char *prefix = "";
586 #endif
587 char *result = ACONCAT ((prefix,
588 IDENTIFIER_POINTER (identifier),
589 separator,
590 suffix,
591 (char*)0));
592 return get_identifier (result);
596 /* Create callgraph node clone with new declaration. The actual body will
597 be copied later at compilation stage.
599 TODO: after merging in ipa-sra use function call notes instead of args_to_skip
600 bitmap interface.
602 cgraph_node *
603 cgraph_node::create_virtual_clone (vec<cgraph_edge *> redirect_callers,
604 vec<ipa_replace_map *, va_gc> *tree_map,
605 bitmap args_to_skip, const char * suffix)
607 tree old_decl = decl;
608 cgraph_node *new_node = NULL;
609 tree new_decl;
610 size_t len, i;
611 ipa_replace_map *map;
612 char *name;
614 gcc_checking_assert (local.versionable);
615 gcc_assert (local.can_change_signature || !args_to_skip);
617 /* Make a new FUNCTION_DECL tree node */
618 if (!args_to_skip)
619 new_decl = copy_node (old_decl);
620 else
621 new_decl = build_function_decl_skip_args (old_decl, args_to_skip, false);
623 /* These pointers represent function body and will be populated only when clone
624 is materialized. */
625 gcc_assert (new_decl != old_decl);
626 DECL_STRUCT_FUNCTION (new_decl) = NULL;
627 DECL_ARGUMENTS (new_decl) = NULL;
628 DECL_INITIAL (new_decl) = NULL;
629 DECL_RESULT (new_decl) = NULL;
630 /* We can not do DECL_RESULT (new_decl) = NULL; here because of LTO partitioning
631 sometimes storing only clone decl instead of original. */
633 /* Generate a new name for the new version. */
634 len = IDENTIFIER_LENGTH (DECL_NAME (old_decl));
635 name = XALLOCAVEC (char, len + strlen (suffix) + 2);
636 memcpy (name, IDENTIFIER_POINTER (DECL_NAME (old_decl)), len);
637 strcpy (name + len + 1, suffix);
638 name[len] = '.';
639 DECL_NAME (new_decl) = get_identifier (name);
640 SET_DECL_ASSEMBLER_NAME (new_decl, clone_function_name_numbered (old_decl,
641 suffix));
642 SET_DECL_RTL (new_decl, NULL);
644 new_node = create_clone (new_decl, count, false,
645 redirect_callers, false, NULL, args_to_skip, suffix);
647 /* Update the properties.
648 Make clone visible only within this translation unit. Make sure
649 that is not weak also.
650 ??? We cannot use COMDAT linkage because there is no
651 ABI support for this. */
652 set_new_clone_decl_and_node_flags (new_node);
653 new_node->clone.tree_map = tree_map;
654 if (!implicit_section)
655 new_node->set_section (get_section ());
657 /* Clones of global symbols or symbols with unique names are unique. */
658 if ((TREE_PUBLIC (old_decl)
659 && !DECL_EXTERNAL (old_decl)
660 && !DECL_WEAK (old_decl)
661 && !DECL_COMDAT (old_decl))
662 || in_lto_p)
663 new_node->unique_name = true;
664 FOR_EACH_VEC_SAFE_ELT (tree_map, i, map)
665 new_node->maybe_create_reference (map->new_tree, NULL);
667 if (ipa_transforms_to_apply.exists ())
668 new_node->ipa_transforms_to_apply
669 = ipa_transforms_to_apply.copy ();
671 symtab->call_cgraph_duplication_hooks (this, new_node);
673 return new_node;
676 /* callgraph node being removed from symbol table; see if its entry can be
677 replaced by other inline clone. */
678 cgraph_node *
679 cgraph_node::find_replacement (void)
681 cgraph_node *next_inline_clone, *replacement;
683 for (next_inline_clone = clones;
684 next_inline_clone
685 && next_inline_clone->decl != decl;
686 next_inline_clone = next_inline_clone->next_sibling_clone)
689 /* If there is inline clone of the node being removed, we need
690 to put it into the position of removed node and reorganize all
691 other clones to be based on it. */
692 if (next_inline_clone)
694 cgraph_node *n;
695 cgraph_node *new_clones;
697 replacement = next_inline_clone;
699 /* Unlink inline clone from the list of clones of removed node. */
700 if (next_inline_clone->next_sibling_clone)
701 next_inline_clone->next_sibling_clone->prev_sibling_clone
702 = next_inline_clone->prev_sibling_clone;
703 if (next_inline_clone->prev_sibling_clone)
705 gcc_assert (clones != next_inline_clone);
706 next_inline_clone->prev_sibling_clone->next_sibling_clone
707 = next_inline_clone->next_sibling_clone;
709 else
711 gcc_assert (clones == next_inline_clone);
712 clones = next_inline_clone->next_sibling_clone;
715 new_clones = clones;
716 clones = NULL;
718 /* Copy clone info. */
719 next_inline_clone->clone = clone;
721 /* Now place it into clone tree at same level at NODE. */
722 next_inline_clone->clone_of = clone_of;
723 next_inline_clone->prev_sibling_clone = NULL;
724 next_inline_clone->next_sibling_clone = NULL;
725 if (clone_of)
727 if (clone_of->clones)
728 clone_of->clones->prev_sibling_clone = next_inline_clone;
729 next_inline_clone->next_sibling_clone = clone_of->clones;
730 clone_of->clones = next_inline_clone;
733 /* Merge the clone list. */
734 if (new_clones)
736 if (!next_inline_clone->clones)
737 next_inline_clone->clones = new_clones;
738 else
740 n = next_inline_clone->clones;
741 while (n->next_sibling_clone)
742 n = n->next_sibling_clone;
743 n->next_sibling_clone = new_clones;
744 new_clones->prev_sibling_clone = n;
748 /* Update clone_of pointers. */
749 n = new_clones;
750 while (n)
752 n->clone_of = next_inline_clone;
753 n = n->next_sibling_clone;
755 return replacement;
757 else
758 return NULL;
761 /* Like cgraph_set_call_stmt but walk the clone tree and update all
762 clones sharing the same function body.
763 When WHOLE_SPECULATIVE_EDGES is true, all three components of
764 speculative edge gets updated. Otherwise we update only direct
765 call. */
767 void
768 cgraph_node::set_call_stmt_including_clones (gimple *old_stmt,
769 gcall *new_stmt,
770 bool update_speculative)
772 cgraph_node *node;
773 cgraph_edge *edge = get_edge (old_stmt);
775 if (edge)
776 edge->set_call_stmt (new_stmt, update_speculative);
778 node = clones;
779 if (node)
780 while (node != this)
782 cgraph_edge *edge = node->get_edge (old_stmt);
783 if (edge)
785 edge->set_call_stmt (new_stmt, update_speculative);
786 /* If UPDATE_SPECULATIVE is false, it means that we are turning
787 speculative call into a real code sequence. Update the
788 callgraph edges. */
789 if (edge->speculative && !update_speculative)
791 cgraph_edge *direct, *indirect;
792 ipa_ref *ref;
794 gcc_assert (!edge->indirect_unknown_callee);
795 edge->speculative_call_info (direct, indirect, ref);
796 direct->speculative = false;
797 indirect->speculative = false;
798 ref->speculative = false;
801 if (node->clones)
802 node = node->clones;
803 else if (node->next_sibling_clone)
804 node = node->next_sibling_clone;
805 else
807 while (node != this && !node->next_sibling_clone)
808 node = node->clone_of;
809 if (node != this)
810 node = node->next_sibling_clone;
815 /* Like cgraph_create_edge walk the clone tree and update all clones sharing
816 same function body. If clones already have edge for OLD_STMT; only
817 update the edge same way as cgraph_set_call_stmt_including_clones does.
819 TODO: COUNT and LOOP_DEPTH should be properly distributed based on relative
820 frequencies of the clones. */
822 void
823 cgraph_node::create_edge_including_clones (cgraph_node *callee,
824 gimple *old_stmt, gcall *stmt,
825 profile_count count,
826 cgraph_inline_failed_t reason)
828 cgraph_node *node;
829 cgraph_edge *edge;
831 if (!get_edge (stmt))
833 edge = create_edge (callee, stmt, count);
834 edge->inline_failed = reason;
837 node = clones;
838 if (node)
839 while (node != this)
840 /* Thunk clones do not get updated while copying inline function body. */
841 if (!node->thunk.thunk_p)
843 cgraph_edge *edge = node->get_edge (old_stmt);
845 /* It is possible that clones already contain the edge while
846 master didn't. Either we promoted indirect call into direct
847 call in the clone or we are processing clones of unreachable
848 master where edges has been removed. */
849 if (edge)
850 edge->set_call_stmt (stmt);
851 else if (! node->get_edge (stmt))
853 edge = node->create_edge (callee, stmt, count);
854 edge->inline_failed = reason;
857 if (node->clones)
858 node = node->clones;
859 else if (node->next_sibling_clone)
860 node = node->next_sibling_clone;
861 else
863 while (node != this && !node->next_sibling_clone)
864 node = node->clone_of;
865 if (node != this)
866 node = node->next_sibling_clone;
871 /* Remove the node from cgraph and all inline clones inlined into it.
872 Skip however removal of FORBIDDEN_NODE and return true if it needs to be
873 removed. This allows to call the function from outer loop walking clone
874 tree. */
876 bool
877 cgraph_node::remove_symbol_and_inline_clones (cgraph_node *forbidden_node)
879 cgraph_edge *e, *next;
880 bool found = false;
882 if (this == forbidden_node)
884 callers->remove ();
885 return true;
887 for (e = callees; e; e = next)
889 next = e->next_callee;
890 if (!e->inline_failed)
891 found |= e->callee->remove_symbol_and_inline_clones (forbidden_node);
893 remove ();
894 return found;
897 /* The edges representing the callers of the NEW_VERSION node were
898 fixed by cgraph_function_versioning (), now the call_expr in their
899 respective tree code should be updated to call the NEW_VERSION. */
901 static void
902 update_call_expr (cgraph_node *new_version)
904 cgraph_edge *e;
906 gcc_assert (new_version);
908 /* Update the call expr on the edges to call the new version. */
909 for (e = new_version->callers; e; e = e->next_caller)
911 function *inner_function = DECL_STRUCT_FUNCTION (e->caller->decl);
912 gimple_call_set_fndecl (e->call_stmt, new_version->decl);
913 maybe_clean_eh_stmt_fn (inner_function, e->call_stmt);
918 /* Create a new cgraph node which is the new version of
919 callgraph node. REDIRECT_CALLERS holds the callers
920 edges which should be redirected to point to
921 NEW_VERSION. ALL the callees edges of the node
922 are cloned to the new version node. Return the new
923 version node.
925 If non-NULL BLOCK_TO_COPY determine what basic blocks
926 was copied to prevent duplications of calls that are dead
927 in the clone. */
929 cgraph_node *
930 cgraph_node::create_version_clone (tree new_decl,
931 vec<cgraph_edge *> redirect_callers,
932 bitmap bbs_to_copy,
933 const char *suffix)
935 cgraph_node *new_version;
936 cgraph_edge *e;
937 unsigned i;
939 new_version = cgraph_node::create (new_decl);
941 new_version->analyzed = analyzed;
942 new_version->definition = definition;
943 new_version->local = local;
944 new_version->externally_visible = false;
945 new_version->no_reorder = no_reorder;
946 new_version->local.local = new_version->definition;
947 new_version->global = global;
948 new_version->rtl = rtl;
949 new_version->count = count;
951 for (e = callees; e; e=e->next_callee)
952 if (!bbs_to_copy
953 || bitmap_bit_p (bbs_to_copy, gimple_bb (e->call_stmt)->index))
954 e->clone (new_version, e->call_stmt,
955 e->lto_stmt_uid, count, count,
956 true);
957 for (e = indirect_calls; e; e=e->next_callee)
958 if (!bbs_to_copy
959 || bitmap_bit_p (bbs_to_copy, gimple_bb (e->call_stmt)->index))
960 e->clone (new_version, e->call_stmt,
961 e->lto_stmt_uid, count, count,
962 true);
963 FOR_EACH_VEC_ELT (redirect_callers, i, e)
965 /* Redirect calls to the old version node to point to its new
966 version. */
967 e->redirect_callee (new_version);
970 symtab->call_cgraph_duplication_hooks (this, new_version);
972 dump_callgraph_transformation (this, new_version, suffix);
974 return new_version;
977 /* Perform function versioning.
978 Function versioning includes copying of the tree and
979 a callgraph update (creating a new cgraph node and updating
980 its callees and callers).
982 REDIRECT_CALLERS varray includes the edges to be redirected
983 to the new version.
985 TREE_MAP is a mapping of tree nodes we want to replace with
986 new ones (according to results of prior analysis).
988 If non-NULL ARGS_TO_SKIP determine function parameters to remove
989 from new version.
990 If SKIP_RETURN is true, the new version will return void.
991 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
992 If non_NULL NEW_ENTRY determine new entry BB of the clone.
994 Return the new version's cgraph node. */
996 cgraph_node *
997 cgraph_node::create_version_clone_with_body
998 (vec<cgraph_edge *> redirect_callers,
999 vec<ipa_replace_map *, va_gc> *tree_map, bitmap args_to_skip,
1000 bool skip_return, bitmap bbs_to_copy, basic_block new_entry_block,
1001 const char *suffix)
1003 tree old_decl = decl;
1004 cgraph_node *new_version_node = NULL;
1005 tree new_decl;
1007 if (!tree_versionable_function_p (old_decl))
1008 return NULL;
1010 gcc_assert (local.can_change_signature || !args_to_skip);
1012 /* Make a new FUNCTION_DECL tree node for the new version. */
1013 if (!args_to_skip && !skip_return)
1014 new_decl = copy_node (old_decl);
1015 else
1016 new_decl
1017 = build_function_decl_skip_args (old_decl, args_to_skip, skip_return);
1019 /* Generate a new name for the new version. */
1020 DECL_NAME (new_decl) = clone_function_name_numbered (old_decl, suffix);
1021 SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
1022 SET_DECL_RTL (new_decl, NULL);
1024 DECL_VIRTUAL_P (new_decl) = 0;
1026 /* When the old decl was a con-/destructor make sure the clone isn't. */
1027 DECL_STATIC_CONSTRUCTOR (new_decl) = 0;
1028 DECL_STATIC_DESTRUCTOR (new_decl) = 0;
1030 /* Create the new version's call-graph node.
1031 and update the edges of the new node. */
1032 new_version_node = create_version_clone (new_decl, redirect_callers,
1033 bbs_to_copy, suffix);
1035 if (ipa_transforms_to_apply.exists ())
1036 new_version_node->ipa_transforms_to_apply
1037 = ipa_transforms_to_apply.copy ();
1038 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1039 tree_function_versioning (old_decl, new_decl, tree_map, false, args_to_skip,
1040 skip_return, bbs_to_copy, new_entry_block);
1042 /* Update the new version's properties.
1043 Make The new version visible only within this translation unit. Make sure
1044 that is not weak also.
1045 ??? We cannot use COMDAT linkage because there is no
1046 ABI support for this. */
1047 new_version_node->make_decl_local ();
1048 DECL_VIRTUAL_P (new_version_node->decl) = 0;
1049 new_version_node->externally_visible = 0;
1050 new_version_node->local.local = 1;
1051 new_version_node->lowered = true;
1052 if (!implicit_section)
1053 new_version_node->set_section (get_section ());
1054 /* Clones of global symbols or symbols with unique names are unique. */
1055 if ((TREE_PUBLIC (old_decl)
1056 && !DECL_EXTERNAL (old_decl)
1057 && !DECL_WEAK (old_decl)
1058 && !DECL_COMDAT (old_decl))
1059 || in_lto_p)
1060 new_version_node->unique_name = true;
1062 /* Update the call_expr on the edges to call the new version node. */
1063 update_call_expr (new_version_node);
1065 symtab->call_cgraph_insertion_hooks (new_version_node);
1066 return new_version_node;
1069 /* Given virtual clone, turn it into actual clone. */
1071 static void
1072 cgraph_materialize_clone (cgraph_node *node)
1074 bitmap_obstack_initialize (NULL);
1075 node->former_clone_of = node->clone_of->decl;
1076 if (node->clone_of->former_clone_of)
1077 node->former_clone_of = node->clone_of->former_clone_of;
1078 /* Copy the OLD_VERSION_NODE function tree to the new version. */
1079 tree_function_versioning (node->clone_of->decl, node->decl,
1080 node->clone.tree_map, true,
1081 node->clone.args_to_skip, false,
1082 NULL, NULL);
1083 if (symtab->dump_file)
1085 dump_function_to_file (node->clone_of->decl, symtab->dump_file,
1086 dump_flags);
1087 dump_function_to_file (node->decl, symtab->dump_file, dump_flags);
1090 /* Function is no longer clone. */
1091 if (node->next_sibling_clone)
1092 node->next_sibling_clone->prev_sibling_clone = node->prev_sibling_clone;
1093 if (node->prev_sibling_clone)
1094 node->prev_sibling_clone->next_sibling_clone = node->next_sibling_clone;
1095 else
1096 node->clone_of->clones = node->next_sibling_clone;
1097 node->next_sibling_clone = NULL;
1098 node->prev_sibling_clone = NULL;
1099 if (!node->clone_of->analyzed && !node->clone_of->clones)
1101 node->clone_of->release_body ();
1102 node->clone_of->remove_callees ();
1103 node->clone_of->remove_all_references ();
1105 node->clone_of = NULL;
1106 bitmap_obstack_release (NULL);
1109 /* Once all functions from compilation unit are in memory, produce all clones
1110 and update all calls. We might also do this on demand if we don't want to
1111 bring all functions to memory prior compilation, but current WHOPR
1112 implementation does that and it is a bit easier to keep everything right in
1113 this order. */
1115 void
1116 symbol_table::materialize_all_clones (void)
1118 cgraph_node *node;
1119 bool stabilized = false;
1122 if (symtab->dump_file)
1123 fprintf (symtab->dump_file, "Materializing clones\n");
1125 cgraph_node::checking_verify_cgraph_nodes ();
1127 /* We can also do topological order, but number of iterations should be
1128 bounded by number of IPA passes since single IPA pass is probably not
1129 going to create clones of clones it created itself. */
1130 while (!stabilized)
1132 stabilized = true;
1133 FOR_EACH_FUNCTION (node)
1135 if (node->clone_of && node->decl != node->clone_of->decl
1136 && !gimple_has_body_p (node->decl))
1138 if (!node->clone_of->clone_of)
1139 node->clone_of->get_untransformed_body ();
1140 if (gimple_has_body_p (node->clone_of->decl))
1142 if (symtab->dump_file)
1144 fprintf (symtab->dump_file, "cloning %s to %s\n",
1145 xstrdup_for_dump (node->clone_of->name ()),
1146 xstrdup_for_dump (node->name ()));
1147 if (node->clone.tree_map)
1149 unsigned int i;
1150 fprintf (symtab->dump_file, " replace map: ");
1151 for (i = 0;
1152 i < vec_safe_length (node->clone.tree_map);
1153 i++)
1155 ipa_replace_map *replace_info;
1156 replace_info = (*node->clone.tree_map)[i];
1157 print_generic_expr (symtab->dump_file,
1158 replace_info->old_tree);
1159 fprintf (symtab->dump_file, " -> ");
1160 print_generic_expr (symtab->dump_file,
1161 replace_info->new_tree);
1162 fprintf (symtab->dump_file, "%s%s;",
1163 replace_info->replace_p ? "(replace)":"",
1164 replace_info->ref_p ? "(ref)":"");
1166 fprintf (symtab->dump_file, "\n");
1168 if (node->clone.args_to_skip)
1170 fprintf (symtab->dump_file, " args_to_skip: ");
1171 dump_bitmap (symtab->dump_file,
1172 node->clone.args_to_skip);
1174 if (node->clone.args_to_skip)
1176 fprintf (symtab->dump_file, " combined_args_to_skip:");
1177 dump_bitmap (symtab->dump_file, node->clone.combined_args_to_skip);
1180 cgraph_materialize_clone (node);
1181 stabilized = false;
1186 FOR_EACH_FUNCTION (node)
1187 if (!node->analyzed && node->callees)
1189 node->remove_callees ();
1190 node->remove_all_references ();
1192 else
1193 node->clear_stmts_in_references ();
1194 if (symtab->dump_file)
1195 fprintf (symtab->dump_file, "Materialization Call site updates done.\n");
1197 cgraph_node::checking_verify_cgraph_nodes ();
1199 symtab->remove_unreachable_nodes (symtab->dump_file);
1202 #include "gt-cgraphclones.h"