1 | /* Callgraph clones |
2 | Copyright (C) 2003-2024 Free Software Foundation, Inc. |
3 | Contributed by Jan Hubicka |
4 | |
5 | This file is part of GCC. |
6 | |
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. |
11 | |
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. |
16 | |
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/>. */ |
20 | |
21 | /* This module provide facilities for cloning functions. I.e. creating |
22 | new functions based on existing functions with simple modifications, |
23 | such as replacement of parameters. |
24 | |
25 | To allow whole program optimization without actual presence of function |
26 | bodies, an additional infrastructure is provided for so-called virtual |
27 | clones |
28 | |
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). |
32 | |
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. |
38 | |
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. |
42 | |
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. |
50 | |
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. |
54 | |
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. |
61 | |
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. */ |
66 | |
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 "attribs.h" |
82 | #include "dumpfile.h" |
83 | #include "gimple-pretty-print.h" |
84 | #include "alloc-pool.h" |
85 | #include "symbol-summary.h" |
86 | #include "tree-vrp.h" |
87 | #include "sreal.h" |
88 | #include "ipa-cp.h" |
89 | #include "ipa-prop.h" |
90 | #include "ipa-fnsummary.h" |
91 | #include "symtab-thunks.h" |
92 | #include "symtab-clones.h" |
93 | |
94 | /* Create clone of edge in the node N represented by CALL_EXPR |
95 | the callgraph. */ |
96 | |
97 | cgraph_edge * |
98 | cgraph_edge::clone (cgraph_node *n, gcall *call_stmt, unsigned stmt_uid, |
99 | profile_count num, profile_count den, |
100 | bool update_original) |
101 | { |
102 | cgraph_edge *new_edge; |
103 | profile_count::adjust_for_ipa_scaling (num: &num, den: &den); |
104 | profile_count prof_count = count.apply_scale (num, den); |
105 | |
106 | if (indirect_unknown_callee) |
107 | { |
108 | tree decl; |
109 | |
110 | if (call_stmt && (decl = gimple_call_fndecl (gs: call_stmt)) |
111 | /* When the call is speculative, we need to resolve it |
112 | via cgraph_resolve_speculation and not here. */ |
113 | && !speculative) |
114 | { |
115 | cgraph_node *callee = cgraph_node::get (decl); |
116 | gcc_checking_assert (callee); |
117 | new_edge = n->create_edge (callee, call_stmt, count: prof_count, cloning_p: true); |
118 | } |
119 | else |
120 | { |
121 | new_edge = n->create_indirect_edge (call_stmt, |
122 | ecf_flags: indirect_info->ecf_flags, |
123 | count: prof_count, cloning_p: true); |
124 | *new_edge->indirect_info = *indirect_info; |
125 | } |
126 | } |
127 | else |
128 | { |
129 | new_edge = n->create_edge (callee, call_stmt, count: prof_count, cloning_p: true); |
130 | if (indirect_info) |
131 | { |
132 | new_edge->indirect_info |
133 | = ggc_cleared_alloc<cgraph_indirect_call_info> (); |
134 | *new_edge->indirect_info = *indirect_info; |
135 | } |
136 | } |
137 | |
138 | new_edge->inline_failed = inline_failed; |
139 | new_edge->indirect_inlining_edge = indirect_inlining_edge; |
140 | if (!call_stmt) |
141 | new_edge->lto_stmt_uid = stmt_uid; |
142 | new_edge->speculative_id = speculative_id; |
143 | /* Clone flags that depend on call_stmt availability manually. */ |
144 | new_edge->can_throw_external = can_throw_external; |
145 | new_edge->call_stmt_cannot_inline_p = call_stmt_cannot_inline_p; |
146 | new_edge->speculative = speculative; |
147 | new_edge->in_polymorphic_cdtor = in_polymorphic_cdtor; |
148 | |
149 | /* Update IPA profile. Local profiles need no updating in original. */ |
150 | if (update_original) |
151 | count = count.combine_with_ipa_count_within (ipa: count.ipa () |
152 | - new_edge->count.ipa (), |
153 | ipa2: caller->count); |
154 | symtab->call_edge_duplication_hooks (cs1: this, cs2: new_edge); |
155 | return new_edge; |
156 | } |
157 | |
158 | /* Set flags of NEW_NODE and its decl. NEW_NODE is a newly created private |
159 | clone or its thunk. */ |
160 | |
161 | static void |
162 | set_new_clone_decl_and_node_flags (cgraph_node *new_node) |
163 | { |
164 | DECL_EXTERNAL (new_node->decl) = 0; |
165 | TREE_PUBLIC (new_node->decl) = 0; |
166 | DECL_COMDAT (new_node->decl) = 0; |
167 | DECL_WEAK (new_node->decl) = 0; |
168 | DECL_VIRTUAL_P (new_node->decl) = 0; |
169 | DECL_STATIC_CONSTRUCTOR (new_node->decl) = 0; |
170 | DECL_STATIC_DESTRUCTOR (new_node->decl) = 0; |
171 | DECL_SET_IS_OPERATOR_NEW (new_node->decl, 0); |
172 | DECL_SET_IS_OPERATOR_DELETE (new_node->decl, 0); |
173 | DECL_IS_REPLACEABLE_OPERATOR (new_node->decl) = 0; |
174 | |
175 | new_node->externally_visible = 0; |
176 | new_node->local = 1; |
177 | new_node->lowered = true; |
178 | new_node->semantic_interposition = 0; |
179 | } |
180 | |
181 | /* Duplicate thunk THUNK if necessary but make it to refer to NODE. |
182 | ARGS_TO_SKIP, if non-NULL, determines which parameters should be omitted. |
183 | Function can return NODE if no thunk is necessary, which can happen when |
184 | thunk is this_adjusting but we are removing this parameter. */ |
185 | |
186 | static cgraph_node * |
187 | duplicate_thunk_for_node (cgraph_node *thunk, cgraph_node *node) |
188 | { |
189 | cgraph_node *new_thunk, *thunk_of; |
190 | thunk_of = thunk->callees->callee->ultimate_alias_target (); |
191 | |
192 | if (thunk_of->thunk) |
193 | node = duplicate_thunk_for_node (thunk: thunk_of, node); |
194 | |
195 | if (!DECL_ARGUMENTS (thunk->decl)) |
196 | thunk->get_untransformed_body (); |
197 | |
198 | thunk_info *i = thunk_info::get (node: thunk); |
199 | cgraph_edge *cs; |
200 | for (cs = node->callers; cs; cs = cs->next_caller) |
201 | if (cs->caller->thunk) |
202 | { |
203 | thunk_info *i2 = thunk_info::get (node: cs->caller); |
204 | if (*i2 == *i) |
205 | return cs->caller; |
206 | } |
207 | |
208 | tree new_decl; |
209 | clone_info *info = clone_info::get (node); |
210 | if (info && info->param_adjustments) |
211 | { |
212 | /* We do not need to duplicate this_adjusting thunks if we have removed |
213 | this. */ |
214 | if (i->this_adjusting |
215 | && !info->param_adjustments->first_param_intact_p ()) |
216 | return node; |
217 | |
218 | new_decl = copy_node (thunk->decl); |
219 | ipa_param_body_adjustments body_adj (info->param_adjustments, |
220 | new_decl); |
221 | body_adj.modify_formal_parameters (); |
222 | } |
223 | else |
224 | { |
225 | new_decl = copy_node (thunk->decl); |
226 | for (tree *arg = &DECL_ARGUMENTS (new_decl); |
227 | *arg; arg = &DECL_CHAIN (*arg)) |
228 | { |
229 | tree next = DECL_CHAIN (*arg); |
230 | *arg = copy_node (*arg); |
231 | DECL_CONTEXT (*arg) = new_decl; |
232 | DECL_CHAIN (*arg) = next; |
233 | } |
234 | } |
235 | |
236 | gcc_checking_assert (!DECL_STRUCT_FUNCTION (new_decl)); |
237 | gcc_checking_assert (!DECL_INITIAL (new_decl)); |
238 | gcc_checking_assert (!DECL_RESULT (new_decl)); |
239 | gcc_checking_assert (!DECL_RTL_SET_P (new_decl)); |
240 | |
241 | DECL_NAME (new_decl) = clone_function_name_numbered (decl: thunk->decl, |
242 | suffix: "artificial_thunk" ); |
243 | SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl)); |
244 | |
245 | /* We need to force DECL_IGNORED_P because the new thunk is created after |
246 | early debug was run. */ |
247 | DECL_IGNORED_P (new_decl) = 1; |
248 | |
249 | new_thunk = cgraph_node::create (decl: new_decl); |
250 | set_new_clone_decl_and_node_flags (new_thunk); |
251 | new_thunk->definition = true; |
252 | new_thunk->can_change_signature = node->can_change_signature; |
253 | new_thunk->thunk = thunk->thunk; |
254 | new_thunk->unique_name = in_lto_p; |
255 | new_thunk->former_clone_of = thunk->decl; |
256 | if (info && info->param_adjustments) |
257 | clone_info::get_create (node: new_thunk)->param_adjustments |
258 | = info->param_adjustments; |
259 | new_thunk->unit_id = thunk->unit_id; |
260 | new_thunk->merged_comdat = thunk->merged_comdat; |
261 | new_thunk->merged_extern_inline = thunk->merged_extern_inline; |
262 | |
263 | cgraph_edge *e = new_thunk->create_edge (callee: node, NULL, count: new_thunk->count); |
264 | symtab->call_edge_duplication_hooks (cs1: thunk->callees, cs2: e); |
265 | symtab->call_cgraph_duplication_hooks (node: thunk, node2: new_thunk); |
266 | return new_thunk; |
267 | } |
268 | |
269 | /* If E does not lead to a thunk, simply redirect it to N. Otherwise create |
270 | one or more equivalent thunks for N and redirect E to the first in the |
271 | chain. Note that it is then necessary to call |
272 | n->expand_all_artificial_thunks once all callers are redirected. */ |
273 | |
274 | void |
275 | cgraph_edge::redirect_callee_duplicating_thunks (cgraph_node *n) |
276 | { |
277 | cgraph_node *orig_to = callee->ultimate_alias_target (); |
278 | if (orig_to->thunk) |
279 | n = duplicate_thunk_for_node (thunk: orig_to, node: n); |
280 | |
281 | redirect_callee (n); |
282 | } |
283 | |
284 | /* Call expand_thunk on all callers that are thunks and if analyze those nodes |
285 | that were expanded. */ |
286 | |
287 | void |
288 | cgraph_node::expand_all_artificial_thunks () |
289 | { |
290 | cgraph_edge *e; |
291 | for (e = callers; e;) |
292 | if (e->caller->thunk) |
293 | { |
294 | cgraph_node *thunk = e->caller; |
295 | |
296 | e = e->next_caller; |
297 | if (expand_thunk (thunk, false, false)) |
298 | { |
299 | thunk->thunk = false; |
300 | thunk->analyze (); |
301 | ipa_analyze_node (thunk); |
302 | inline_analyze_function (node: thunk); |
303 | } |
304 | thunk->expand_all_artificial_thunks (); |
305 | } |
306 | else |
307 | e = e->next_caller; |
308 | } |
309 | |
310 | void |
311 | dump_callgraph_transformation (const cgraph_node *original, |
312 | const cgraph_node *clone, |
313 | const char *suffix) |
314 | { |
315 | if (symtab->ipa_clones_dump_file) |
316 | { |
317 | fprintf (stream: symtab->ipa_clones_dump_file, |
318 | format: "Callgraph clone;%s;%d;%s;%d;%d;%s;%d;%s;%d;%d;%s\n" , |
319 | original->asm_name (), original->order, |
320 | DECL_SOURCE_FILE (original->decl), |
321 | DECL_SOURCE_LINE (original->decl), |
322 | DECL_SOURCE_COLUMN (original->decl), clone->asm_name (), |
323 | clone->order, DECL_SOURCE_FILE (clone->decl), |
324 | DECL_SOURCE_LINE (clone->decl), DECL_SOURCE_COLUMN (clone->decl), |
325 | suffix); |
326 | |
327 | symtab->cloned_nodes.add (k: original); |
328 | symtab->cloned_nodes.add (k: clone); |
329 | } |
330 | } |
331 | |
332 | /* Turn profile of N to local profile. */ |
333 | |
334 | static void |
335 | localize_profile (cgraph_node *n) |
336 | { |
337 | n->count = n->count.guessed_local (); |
338 | for (cgraph_edge *e = n->callees; e; e=e->next_callee) |
339 | { |
340 | e->count = e->count.guessed_local (); |
341 | if (!e->inline_failed) |
342 | localize_profile (n: e->callee); |
343 | } |
344 | for (cgraph_edge *e = n->indirect_calls; e; e=e->next_callee) |
345 | e->count = e->count.guessed_local (); |
346 | } |
347 | |
348 | /* Create node representing clone of N executed COUNT times. Decrease |
349 | the execution counts from original node too. |
350 | The new clone will have decl set to DECL that may or may not be the same |
351 | as decl of N. |
352 | |
353 | When UPDATE_ORIGINAL is true, the counts are subtracted from the original |
354 | function's profile to reflect the fact that part of execution is handled |
355 | by node. |
356 | When CALL_DUPLICATION_HOOK is true, the ipa passes are acknowledged about |
357 | the new clone. Otherwise the caller is responsible for doing so later. |
358 | |
359 | If the new node is being inlined into another one, NEW_INLINED_TO should be |
360 | the outline function the new one is (even indirectly) inlined to. All hooks |
361 | will see this in node's inlined_to, when invoked. Can be NULL if the |
362 | node is not inlined. |
363 | |
364 | If PARAM_ADJUSTMENTS is non-NULL, the parameter manipulation information |
365 | will be overwritten by the new structure. Otherwise the new node will |
366 | share parameter manipulation information with the original node. */ |
367 | |
368 | cgraph_node * |
369 | cgraph_node::create_clone (tree new_decl, profile_count prof_count, |
370 | bool update_original, |
371 | vec<cgraph_edge *> redirect_callers, |
372 | bool call_duplication_hook, |
373 | cgraph_node *new_inlined_to, |
374 | ipa_param_adjustments *param_adjustments, |
375 | const char *suffix) |
376 | { |
377 | cgraph_node *new_node = symtab->create_empty (); |
378 | cgraph_edge *e; |
379 | unsigned i; |
380 | profile_count old_count = count; |
381 | bool nonzero = count.ipa ().nonzero_p (); |
382 | |
383 | if (new_inlined_to) |
384 | dump_callgraph_transformation (original: this, clone: new_inlined_to, suffix: "inlining to" ); |
385 | |
386 | /* When inlining we scale precisely to prof_count, when cloning we can |
387 | preserve local profile. */ |
388 | if (!new_inlined_to) |
389 | prof_count = count.combine_with_ipa_count (ipa: prof_count); |
390 | new_node->count = prof_count; |
391 | new_node->calls_declare_variant_alt = this->calls_declare_variant_alt; |
392 | |
393 | /* Update IPA profile. Local profiles need no updating in original. */ |
394 | if (update_original) |
395 | { |
396 | if (inlined_to) |
397 | count = count.combine_with_ipa_count_within (ipa: count.ipa () |
398 | - prof_count.ipa (), |
399 | ipa2: inlined_to->count); |
400 | else |
401 | count = count.combine_with_ipa_count (ipa: count.ipa () - prof_count.ipa ()); |
402 | } |
403 | new_node->decl = new_decl; |
404 | new_node->register_symbol (); |
405 | new_node->lto_file_data = lto_file_data; |
406 | new_node->analyzed = analyzed; |
407 | new_node->definition = definition; |
408 | new_node->versionable = versionable; |
409 | new_node->can_change_signature = can_change_signature; |
410 | new_node->redefined_extern_inline = redefined_extern_inline; |
411 | new_node->semantic_interposition = semantic_interposition; |
412 | new_node->tm_may_enter_irr = tm_may_enter_irr; |
413 | new_node->externally_visible = false; |
414 | new_node->no_reorder = no_reorder; |
415 | new_node->local = true; |
416 | new_node->inlined_to = new_inlined_to; |
417 | new_node->rtl = rtl; |
418 | new_node->frequency = frequency; |
419 | new_node->tp_first_run = tp_first_run; |
420 | new_node->tm_clone = tm_clone; |
421 | new_node->icf_merged = icf_merged; |
422 | new_node->thunk = thunk; |
423 | new_node->unit_id = unit_id; |
424 | new_node->merged_comdat = merged_comdat; |
425 | new_node->merged_extern_inline = merged_extern_inline; |
426 | clone_info *info = clone_info::get (node: this); |
427 | |
428 | if (param_adjustments) |
429 | clone_info::get_create (node: new_node)->param_adjustments = param_adjustments; |
430 | else if (info && info->param_adjustments) |
431 | clone_info::get_create (node: new_node)->param_adjustments |
432 | = info->param_adjustments; |
433 | new_node->split_part = split_part; |
434 | |
435 | FOR_EACH_VEC_ELT (redirect_callers, i, e) |
436 | { |
437 | /* Redirect calls to the old version node to point to its new |
438 | version. The only exception is when the edge was proved to |
439 | be unreachable during the cloning procedure. */ |
440 | if (!e->callee |
441 | || !fndecl_built_in_p (node: e->callee->decl, name1: BUILT_IN_UNREACHABLE, |
442 | names: BUILT_IN_UNREACHABLE_TRAP)) |
443 | e->redirect_callee_duplicating_thunks (n: new_node); |
444 | } |
445 | new_node->expand_all_artificial_thunks (); |
446 | |
447 | for (e = callees;e; e=e->next_callee) |
448 | e->clone (n: new_node, call_stmt: e->call_stmt, stmt_uid: e->lto_stmt_uid, num: new_node->count, den: old_count, |
449 | update_original); |
450 | |
451 | for (e = indirect_calls; e; e = e->next_callee) |
452 | e->clone (n: new_node, call_stmt: e->call_stmt, stmt_uid: e->lto_stmt_uid, |
453 | num: new_node->count, den: old_count, update_original); |
454 | new_node->clone_references (node: this); |
455 | |
456 | new_node->next_sibling_clone = clones; |
457 | if (clones) |
458 | clones->prev_sibling_clone = new_node; |
459 | clones = new_node; |
460 | new_node->clone_of = this; |
461 | |
462 | if (call_duplication_hook) |
463 | symtab->call_cgraph_duplication_hooks (node: this, node2: new_node); |
464 | /* With partial train run we do not want to assume that original's |
465 | count is zero whenever we redurect all executed edges to clone. |
466 | Simply drop profile to local one in this case. */ |
467 | if (update_original |
468 | && opt_for_fn (decl, flag_profile_partial_training) |
469 | && nonzero |
470 | && count.ipa_p () |
471 | && !count.ipa ().nonzero_p () |
472 | && !inlined_to) |
473 | localize_profile (n: this); |
474 | |
475 | if (!new_inlined_to) |
476 | dump_callgraph_transformation (original: this, clone: new_node, suffix); |
477 | |
478 | return new_node; |
479 | } |
480 | |
481 | static GTY(()) hash_map<const char *, unsigned> *clone_fn_ids; |
482 | |
483 | /* Return a new assembler name for a clone of decl named NAME. Apart |
484 | from the string SUFFIX, the new name will end with a unique (for |
485 | each NAME) unspecified number. If clone numbering is not needed |
486 | then the two argument clone_function_name should be used instead. |
487 | Should not be called directly except for by |
488 | lto-partition.cc:privatize_symbol_name_1. */ |
489 | |
490 | tree |
491 | clone_function_name_numbered (const char *name, const char *suffix) |
492 | { |
493 | /* Initialize the function->counter mapping the first time it's |
494 | needed. */ |
495 | if (!clone_fn_ids) |
496 | clone_fn_ids = hash_map<const char *, unsigned int>::create_ggc (size: 64); |
497 | unsigned int &suffix_counter = clone_fn_ids->get_or_insert ( |
498 | IDENTIFIER_POINTER (get_identifier (name))); |
499 | return clone_function_name (name, suffix, number: suffix_counter++); |
500 | } |
501 | |
502 | /* Return a new assembler name for a clone of DECL. Apart from string |
503 | SUFFIX, the new name will end with a unique (for each DECL |
504 | assembler name) unspecified number. If clone numbering is not |
505 | needed then the two argument clone_function_name should be used |
506 | instead. */ |
507 | |
508 | tree |
509 | clone_function_name_numbered (tree decl, const char *suffix) |
510 | { |
511 | tree name = DECL_ASSEMBLER_NAME (decl); |
512 | return clone_function_name_numbered (IDENTIFIER_POINTER (name), |
513 | suffix); |
514 | } |
515 | |
516 | /* Return a new assembler name for a clone of decl named NAME. Apart |
517 | from the string SUFFIX, the new name will end with the specified |
518 | NUMBER. If clone numbering is not needed then the two argument |
519 | clone_function_name should be used instead. */ |
520 | |
521 | tree |
522 | clone_function_name (const char *name, const char *suffix, |
523 | unsigned long number) |
524 | { |
525 | size_t len = strlen (s: name); |
526 | char *tmp_name, *prefix; |
527 | |
528 | prefix = XALLOCAVEC (char, len + strlen (suffix) + 2); |
529 | memcpy (dest: prefix, src: name, n: len); |
530 | strcpy (dest: prefix + len + 1, src: suffix); |
531 | prefix[len] = symbol_table::symbol_suffix_separator (); |
532 | ASM_FORMAT_PRIVATE_NAME (tmp_name, prefix, number); |
533 | return get_identifier (tmp_name); |
534 | } |
535 | |
536 | /* Return a new assembler name for a clone of DECL. Apart from the |
537 | string SUFFIX, the new name will end with the specified NUMBER. If |
538 | clone numbering is not needed then the two argument |
539 | clone_function_name should be used instead. */ |
540 | |
541 | tree |
542 | clone_function_name (tree decl, const char *suffix, |
543 | unsigned long number) |
544 | { |
545 | return clone_function_name ( |
546 | IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), suffix, number); |
547 | } |
548 | |
549 | /* Return a new assembler name ending with the string SUFFIX for a |
550 | clone of DECL. */ |
551 | |
552 | tree |
553 | clone_function_name (tree decl, const char *suffix) |
554 | { |
555 | tree identifier = DECL_ASSEMBLER_NAME (decl); |
556 | /* For consistency this needs to behave the same way as |
557 | ASM_FORMAT_PRIVATE_NAME does, but without the final number |
558 | suffix. */ |
559 | char *separator = XALLOCAVEC (char, 2); |
560 | separator[0] = symbol_table::symbol_suffix_separator (); |
561 | separator[1] = 0; |
562 | #if defined (NO_DOT_IN_LABEL) && defined (NO_DOLLAR_IN_LABEL) |
563 | const char *prefix = "__" ; |
564 | #else |
565 | const char *prefix = "" ; |
566 | #endif |
567 | char *result = ACONCAT ((prefix, |
568 | IDENTIFIER_POINTER (identifier), |
569 | separator, |
570 | suffix, |
571 | (char*)0)); |
572 | return get_identifier (result); |
573 | } |
574 | |
575 | |
576 | /* Create callgraph node clone with new declaration. The actual body will be |
577 | copied later at compilation stage. The name of the new clone will be |
578 | constructed from the name of the original node, SUFFIX and NUM_SUFFIX. |
579 | |
580 | TODO: after merging in ipa-sra use function call notes instead of args_to_skip |
581 | bitmap interface. |
582 | */ |
583 | cgraph_node * |
584 | cgraph_node::create_virtual_clone (const vec<cgraph_edge *> &redirect_callers, |
585 | vec<ipa_replace_map *, va_gc> *tree_map, |
586 | ipa_param_adjustments *param_adjustments, |
587 | const char * suffix, unsigned num_suffix) |
588 | { |
589 | tree old_decl = decl; |
590 | cgraph_node *new_node = NULL; |
591 | tree new_decl; |
592 | size_t len, i; |
593 | ipa_replace_map *map; |
594 | char *name; |
595 | |
596 | gcc_checking_assert (versionable); |
597 | /* TODO: It would be nice if we could recognize that param_adjustments do not |
598 | actually perform any changes, but at the moment let's require it simply |
599 | does not exist. */ |
600 | gcc_assert (can_change_signature || !param_adjustments); |
601 | |
602 | /* Make a new FUNCTION_DECL tree node */ |
603 | if (!param_adjustments) |
604 | new_decl = copy_node (old_decl); |
605 | else |
606 | new_decl = param_adjustments->adjust_decl (orig_decl: old_decl); |
607 | |
608 | /* These pointers represent function body and will be populated only when clone |
609 | is materialized. */ |
610 | gcc_assert (new_decl != old_decl); |
611 | DECL_STRUCT_FUNCTION (new_decl) = NULL; |
612 | DECL_ARGUMENTS (new_decl) = NULL; |
613 | DECL_INITIAL (new_decl) = NULL; |
614 | DECL_RESULT (new_decl) = NULL; |
615 | /* We cannot do DECL_RESULT (new_decl) = NULL; here because of LTO partitioning |
616 | sometimes storing only clone decl instead of original. */ |
617 | |
618 | /* Generate a new name for the new version. */ |
619 | len = IDENTIFIER_LENGTH (DECL_NAME (old_decl)); |
620 | name = XALLOCAVEC (char, len + strlen (suffix) + 2); |
621 | memcpy (dest: name, IDENTIFIER_POINTER (DECL_NAME (old_decl)), n: len); |
622 | strcpy (dest: name + len + 1, src: suffix); |
623 | name[len] = '.'; |
624 | DECL_NAME (new_decl) = get_identifier (name); |
625 | SET_DECL_ASSEMBLER_NAME (new_decl, |
626 | clone_function_name (old_decl, suffix, num_suffix)); |
627 | SET_DECL_RTL (new_decl, NULL); |
628 | |
629 | new_node = create_clone (new_decl, prof_count: count, update_original: false, |
630 | redirect_callers, call_duplication_hook: false, NULL, param_adjustments, |
631 | suffix); |
632 | |
633 | /* Update the properties. |
634 | Make clone visible only within this translation unit. Make sure |
635 | that is not weak also. |
636 | ??? We cannot use COMDAT linkage because there is no |
637 | ABI support for this. */ |
638 | set_new_clone_decl_and_node_flags (new_node); |
639 | new_node->ipcp_clone = ipcp_clone; |
640 | if (tree_map) |
641 | clone_info::get_create (node: new_node)->tree_map = tree_map; |
642 | if (!implicit_section) |
643 | new_node->set_section (*this); |
644 | |
645 | /* Clones of global symbols or symbols with unique names are unique. */ |
646 | if ((TREE_PUBLIC (old_decl) |
647 | && !DECL_EXTERNAL (old_decl) |
648 | && !DECL_WEAK (old_decl) |
649 | && !DECL_COMDAT (old_decl)) |
650 | || in_lto_p) |
651 | new_node->unique_name = true; |
652 | FOR_EACH_VEC_SAFE_ELT (tree_map, i, map) |
653 | { |
654 | tree repl = map->new_tree; |
655 | if (map->force_load_ref) |
656 | { |
657 | gcc_assert (TREE_CODE (repl) == ADDR_EXPR); |
658 | repl = get_base_address (TREE_OPERAND (repl, 0)); |
659 | } |
660 | new_node->maybe_create_reference (val: repl, NULL); |
661 | } |
662 | |
663 | if (ipa_transforms_to_apply.exists ()) |
664 | new_node->ipa_transforms_to_apply |
665 | = ipa_transforms_to_apply.copy (); |
666 | |
667 | symtab->call_cgraph_duplication_hooks (node: this, node2: new_node); |
668 | |
669 | return new_node; |
670 | } |
671 | |
672 | /* callgraph node being removed from symbol table; see if its entry can be |
673 | replaced by other inline clone. |
674 | INFO is clone info to attach to the new root. */ |
675 | cgraph_node * |
676 | cgraph_node::find_replacement (clone_info *info) |
677 | { |
678 | cgraph_node *next_inline_clone, *replacement; |
679 | |
680 | for (next_inline_clone = clones; |
681 | next_inline_clone |
682 | && next_inline_clone->decl != decl; |
683 | next_inline_clone = next_inline_clone->next_sibling_clone) |
684 | ; |
685 | |
686 | /* If there is inline clone of the node being removed, we need |
687 | to put it into the position of removed node and reorganize all |
688 | other clones to be based on it. */ |
689 | if (next_inline_clone) |
690 | { |
691 | cgraph_node *n; |
692 | cgraph_node *new_clones; |
693 | |
694 | replacement = next_inline_clone; |
695 | |
696 | /* Unlink inline clone from the list of clones of removed node. */ |
697 | if (next_inline_clone->next_sibling_clone) |
698 | next_inline_clone->next_sibling_clone->prev_sibling_clone |
699 | = next_inline_clone->prev_sibling_clone; |
700 | if (next_inline_clone->prev_sibling_clone) |
701 | { |
702 | gcc_assert (clones != next_inline_clone); |
703 | next_inline_clone->prev_sibling_clone->next_sibling_clone |
704 | = next_inline_clone->next_sibling_clone; |
705 | } |
706 | else |
707 | { |
708 | gcc_assert (clones == next_inline_clone); |
709 | clones = next_inline_clone->next_sibling_clone; |
710 | } |
711 | |
712 | new_clones = clones; |
713 | clones = NULL; |
714 | |
715 | /* Copy clone info. */ |
716 | if (info) |
717 | *clone_info::get_create (node: next_inline_clone) = *info; |
718 | |
719 | /* Now place it into clone tree at same level at NODE. */ |
720 | next_inline_clone->clone_of = clone_of; |
721 | next_inline_clone->prev_sibling_clone = NULL; |
722 | next_inline_clone->next_sibling_clone = NULL; |
723 | if (clone_of) |
724 | { |
725 | if (clone_of->clones) |
726 | clone_of->clones->prev_sibling_clone = next_inline_clone; |
727 | next_inline_clone->next_sibling_clone = clone_of->clones; |
728 | clone_of->clones = next_inline_clone; |
729 | } |
730 | |
731 | /* Merge the clone list. */ |
732 | if (new_clones) |
733 | { |
734 | if (!next_inline_clone->clones) |
735 | next_inline_clone->clones = new_clones; |
736 | else |
737 | { |
738 | n = next_inline_clone->clones; |
739 | while (n->next_sibling_clone) |
740 | n = n->next_sibling_clone; |
741 | n->next_sibling_clone = new_clones; |
742 | new_clones->prev_sibling_clone = n; |
743 | } |
744 | } |
745 | |
746 | /* Update clone_of pointers. */ |
747 | n = new_clones; |
748 | while (n) |
749 | { |
750 | n->clone_of = next_inline_clone; |
751 | n = n->next_sibling_clone; |
752 | } |
753 | |
754 | /* Update order in order to be able to find a LTO section |
755 | with function body. */ |
756 | replacement->order = order; |
757 | |
758 | return replacement; |
759 | } |
760 | else |
761 | return NULL; |
762 | } |
763 | |
764 | /* Like cgraph_set_call_stmt but walk the clone tree and update all |
765 | clones sharing the same function body. |
766 | When WHOLE_SPECULATIVE_EDGES is true, all three components of |
767 | speculative edge gets updated. Otherwise we update only direct |
768 | call. */ |
769 | |
770 | void |
771 | cgraph_node::set_call_stmt_including_clones (gimple *old_stmt, |
772 | gcall *new_stmt, |
773 | bool update_speculative) |
774 | { |
775 | cgraph_node *node; |
776 | cgraph_edge *master_edge = get_edge (call_stmt: old_stmt); |
777 | |
778 | if (master_edge) |
779 | cgraph_edge::set_call_stmt (e: master_edge, new_stmt, update_speculative); |
780 | |
781 | node = clones; |
782 | if (node) |
783 | while (node != this) |
784 | { |
785 | cgraph_edge *edge = node->get_edge (call_stmt: old_stmt); |
786 | if (edge) |
787 | { |
788 | edge = cgraph_edge::set_call_stmt (e: edge, new_stmt, |
789 | update_speculative); |
790 | /* If UPDATE_SPECULATIVE is false, it means that we are turning |
791 | speculative call into a real code sequence. Update the |
792 | callgraph edges. */ |
793 | if (edge->speculative && !update_speculative) |
794 | { |
795 | cgraph_edge *indirect = edge->speculative_call_indirect_edge (); |
796 | |
797 | for (cgraph_edge *next, *direct |
798 | = edge->first_speculative_call_target (); |
799 | direct; |
800 | direct = next) |
801 | { |
802 | next = direct->next_speculative_call_target (); |
803 | direct->speculative_call_target_ref ()->speculative = false; |
804 | direct->speculative = false; |
805 | } |
806 | indirect->speculative = false; |
807 | } |
808 | } |
809 | if (node->clones) |
810 | node = node->clones; |
811 | else if (node->next_sibling_clone) |
812 | node = node->next_sibling_clone; |
813 | else |
814 | { |
815 | while (node != this && !node->next_sibling_clone) |
816 | node = node->clone_of; |
817 | if (node != this) |
818 | node = node->next_sibling_clone; |
819 | } |
820 | } |
821 | } |
822 | |
823 | /* Like cgraph_create_edge walk the clone tree and update all clones sharing |
824 | same function body. If clones already have edge for OLD_STMT; only |
825 | update the edge same way as cgraph_set_call_stmt_including_clones does. |
826 | |
827 | TODO: COUNT and LOOP_DEPTH should be properly distributed based on relative |
828 | frequencies of the clones. */ |
829 | |
830 | void |
831 | cgraph_node::create_edge_including_clones (cgraph_node *callee, |
832 | gimple *old_stmt, gcall *stmt, |
833 | profile_count count, |
834 | cgraph_inline_failed_t reason) |
835 | { |
836 | cgraph_node *node; |
837 | |
838 | if (!get_edge (call_stmt: stmt)) |
839 | { |
840 | cgraph_edge *edge = create_edge (callee, call_stmt: stmt, count); |
841 | edge->inline_failed = reason; |
842 | } |
843 | |
844 | node = clones; |
845 | if (node) |
846 | while (node != this) |
847 | /* Thunk clones do not get updated while copying inline function body. */ |
848 | if (!node->thunk) |
849 | { |
850 | cgraph_edge *edge = node->get_edge (call_stmt: old_stmt); |
851 | |
852 | /* It is possible that clones already contain the edge while |
853 | master didn't. Either we promoted indirect call into direct |
854 | call in the clone or we are processing clones of unreachable |
855 | master where edges has been removed. */ |
856 | if (edge) |
857 | edge = cgraph_edge::set_call_stmt (e: edge, new_stmt: stmt); |
858 | else if (! node->get_edge (call_stmt: stmt)) |
859 | { |
860 | edge = node->create_edge (callee, call_stmt: stmt, count); |
861 | edge->inline_failed = reason; |
862 | } |
863 | |
864 | if (node->clones) |
865 | node = node->clones; |
866 | else if (node->next_sibling_clone) |
867 | node = node->next_sibling_clone; |
868 | else |
869 | { |
870 | while (node != this && !node->next_sibling_clone) |
871 | node = node->clone_of; |
872 | if (node != this) |
873 | node = node->next_sibling_clone; |
874 | } |
875 | } |
876 | } |
877 | |
878 | /* Remove the node from cgraph and all inline clones inlined into it. |
879 | Skip however removal of FORBIDDEN_NODE and return true if it needs to be |
880 | removed. This allows to call the function from outer loop walking clone |
881 | tree. */ |
882 | |
883 | bool |
884 | cgraph_node::remove_symbol_and_inline_clones (cgraph_node *forbidden_node) |
885 | { |
886 | cgraph_edge *e, *next; |
887 | bool found = false; |
888 | |
889 | if (this == forbidden_node) |
890 | { |
891 | cgraph_edge::remove (edge: callers); |
892 | return true; |
893 | } |
894 | for (e = callees; e; e = next) |
895 | { |
896 | next = e->next_callee; |
897 | if (!e->inline_failed) |
898 | found |= e->callee->remove_symbol_and_inline_clones (forbidden_node); |
899 | } |
900 | remove (); |
901 | return found; |
902 | } |
903 | |
904 | /* The edges representing the callers of the NEW_VERSION node were |
905 | fixed by cgraph_function_versioning (), now the call_expr in their |
906 | respective tree code should be updated to call the NEW_VERSION. */ |
907 | |
908 | static void |
909 | update_call_expr (cgraph_node *new_version) |
910 | { |
911 | cgraph_edge *e; |
912 | |
913 | gcc_assert (new_version); |
914 | |
915 | /* Update the call expr on the edges to call the new version. */ |
916 | for (e = new_version->callers; e; e = e->next_caller) |
917 | { |
918 | function *inner_function = DECL_STRUCT_FUNCTION (e->caller->decl); |
919 | gimple_call_set_fndecl (gs: e->call_stmt, decl: new_version->decl); |
920 | maybe_clean_eh_stmt_fn (inner_function, e->call_stmt); |
921 | } |
922 | } |
923 | |
924 | |
925 | /* Create a new cgraph node which is the new version of |
926 | callgraph node. REDIRECT_CALLERS holds the callers |
927 | edges which should be redirected to point to |
928 | NEW_VERSION. ALL the callees edges of the node |
929 | are cloned to the new version node. Return the new |
930 | version node. |
931 | |
932 | If non-NULL BLOCK_TO_COPY determine what basic blocks |
933 | was copied to prevent duplications of calls that are dead |
934 | in the clone. */ |
935 | |
936 | cgraph_node * |
937 | cgraph_node::create_version_clone (tree new_decl, |
938 | vec<cgraph_edge *> redirect_callers, |
939 | bitmap bbs_to_copy, |
940 | const char *suffix) |
941 | { |
942 | cgraph_node *new_version; |
943 | cgraph_edge *e; |
944 | unsigned i; |
945 | |
946 | new_version = cgraph_node::create (decl: new_decl); |
947 | |
948 | new_version->analyzed = analyzed; |
949 | new_version->definition = definition; |
950 | new_version->local = local; |
951 | new_version->externally_visible = false; |
952 | new_version->no_reorder = no_reorder; |
953 | new_version->local = new_version->definition; |
954 | new_version->inlined_to = inlined_to; |
955 | new_version->rtl = rtl; |
956 | new_version->count = count; |
957 | new_version->unit_id = unit_id; |
958 | new_version->merged_comdat = merged_comdat; |
959 | new_version->merged_extern_inline = merged_extern_inline; |
960 | |
961 | for (e = callees; e; e=e->next_callee) |
962 | if (!bbs_to_copy |
963 | || bitmap_bit_p (bbs_to_copy, gimple_bb (g: e->call_stmt)->index)) |
964 | e->clone (n: new_version, call_stmt: e->call_stmt, |
965 | stmt_uid: e->lto_stmt_uid, num: count, den: count, |
966 | update_original: true); |
967 | for (e = indirect_calls; e; e=e->next_callee) |
968 | if (!bbs_to_copy |
969 | || bitmap_bit_p (bbs_to_copy, gimple_bb (g: e->call_stmt)->index)) |
970 | e->clone (n: new_version, call_stmt: e->call_stmt, |
971 | stmt_uid: e->lto_stmt_uid, num: count, den: count, |
972 | update_original: true); |
973 | FOR_EACH_VEC_ELT (redirect_callers, i, e) |
974 | { |
975 | /* Redirect calls to the old version node to point to its new |
976 | version. */ |
977 | e->redirect_callee (n: new_version); |
978 | } |
979 | |
980 | dump_callgraph_transformation (original: this, clone: new_version, suffix); |
981 | |
982 | return new_version; |
983 | } |
984 | |
985 | /* Perform function versioning. |
986 | Function versioning includes copying of the tree and |
987 | a callgraph update (creating a new cgraph node and updating |
988 | its callees and callers). |
989 | |
990 | REDIRECT_CALLERS varray includes the edges to be redirected |
991 | to the new version. |
992 | |
993 | TREE_MAP is a mapping of tree nodes we want to replace with |
994 | new ones (according to results of prior analysis). |
995 | |
996 | If non-NULL ARGS_TO_SKIP determine function parameters to remove |
997 | from new version. |
998 | If SKIP_RETURN is true, the new version will return void. |
999 | If non-NULL BLOCK_TO_COPY determine what basic blocks to copy. |
1000 | If non_NULL NEW_ENTRY determine new entry BB of the clone. |
1001 | |
1002 | If TARGET_ATTRIBUTES is non-null, when creating a new declaration, |
1003 | add the attributes to DECL_ATTRIBUTES. And call valid_attribute_p |
1004 | that will promote value of the attribute DECL_FUNCTION_SPECIFIC_TARGET |
1005 | of the declaration. |
1006 | |
1007 | If VERSION_DECL is set true, use clone_function_name_numbered for the |
1008 | function clone. Otherwise, use clone_function_name. |
1009 | |
1010 | Return the new version's cgraph node. */ |
1011 | |
1012 | cgraph_node * |
1013 | cgraph_node::create_version_clone_with_body |
1014 | (vec<cgraph_edge *> redirect_callers, |
1015 | vec<ipa_replace_map *, va_gc> *tree_map, |
1016 | ipa_param_adjustments *param_adjustments, |
1017 | bitmap bbs_to_copy, basic_block new_entry_block, const char *suffix, |
1018 | tree target_attributes, bool version_decl) |
1019 | { |
1020 | tree old_decl = decl; |
1021 | cgraph_node *new_version_node = NULL; |
1022 | tree new_decl; |
1023 | |
1024 | if (!tree_versionable_function_p (old_decl)) |
1025 | return NULL; |
1026 | |
1027 | /* TODO: Restore an assert that we do not change signature if |
1028 | can_change_signature is false. We cannot just check that |
1029 | param_adjustments is NULL because unfortunately ipa-split removes return |
1030 | values from such functions. */ |
1031 | |
1032 | /* Make a new FUNCTION_DECL tree node for the new version. */ |
1033 | if (param_adjustments) |
1034 | new_decl = param_adjustments->adjust_decl (orig_decl: old_decl); |
1035 | else |
1036 | new_decl = copy_node (old_decl); |
1037 | |
1038 | /* Generate a new name for the new version. */ |
1039 | tree fnname = (version_decl ? clone_function_name_numbered (decl: old_decl, suffix) |
1040 | : clone_function_name (decl: old_decl, suffix)); |
1041 | DECL_NAME (new_decl) = fnname; |
1042 | SET_DECL_ASSEMBLER_NAME (new_decl, fnname); |
1043 | SET_DECL_RTL (new_decl, NULL); |
1044 | |
1045 | DECL_VIRTUAL_P (new_decl) = 0; |
1046 | |
1047 | if (target_attributes) |
1048 | { |
1049 | DECL_ATTRIBUTES (new_decl) = target_attributes; |
1050 | |
1051 | location_t saved_loc = input_location; |
1052 | tree v = TREE_VALUE (target_attributes); |
1053 | input_location = DECL_SOURCE_LOCATION (new_decl); |
1054 | bool r; |
1055 | tree name_id = get_attribute_name (target_attributes); |
1056 | const char *name_str = IDENTIFIER_POINTER (name_id); |
1057 | if (strcmp (s1: name_str, s2: "target" ) == 0) |
1058 | r = targetm.target_option.valid_attribute_p (new_decl, name_id, v, 1); |
1059 | else if (strcmp (s1: name_str, s2: "target_version" ) == 0) |
1060 | r = targetm.target_option.valid_version_attribute_p (new_decl, name_id, |
1061 | v, 1); |
1062 | else |
1063 | gcc_unreachable(); |
1064 | |
1065 | input_location = saved_loc; |
1066 | if (!r) |
1067 | return NULL; |
1068 | } |
1069 | |
1070 | /* When the old decl was a con-/destructor make sure the clone isn't. */ |
1071 | DECL_STATIC_CONSTRUCTOR (new_decl) = 0; |
1072 | DECL_STATIC_DESTRUCTOR (new_decl) = 0; |
1073 | DECL_SET_IS_OPERATOR_NEW (new_decl, 0); |
1074 | DECL_SET_IS_OPERATOR_DELETE (new_decl, 0); |
1075 | DECL_IS_REPLACEABLE_OPERATOR (new_decl) = 0; |
1076 | |
1077 | /* Create the new version's call-graph node. |
1078 | and update the edges of the new node. */ |
1079 | new_version_node = create_version_clone (new_decl, redirect_callers, |
1080 | bbs_to_copy, suffix); |
1081 | |
1082 | if (ipa_transforms_to_apply.exists ()) |
1083 | new_version_node->ipa_transforms_to_apply |
1084 | = ipa_transforms_to_apply.copy (); |
1085 | /* Copy the OLD_VERSION_NODE function tree to the new version. */ |
1086 | tree_function_versioning (old_decl, new_decl, tree_map, param_adjustments, |
1087 | false, bbs_to_copy, new_entry_block); |
1088 | |
1089 | /* Update the new version's properties. |
1090 | Make The new version visible only within this translation unit. Make sure |
1091 | that is not weak also. |
1092 | ??? We cannot use COMDAT linkage because there is no |
1093 | ABI support for this. */ |
1094 | new_version_node->make_decl_local (); |
1095 | DECL_VIRTUAL_P (new_version_node->decl) = 0; |
1096 | new_version_node->externally_visible = 0; |
1097 | new_version_node->local = 1; |
1098 | new_version_node->lowered = true; |
1099 | if (!implicit_section) |
1100 | new_version_node->set_section (*this); |
1101 | /* Clones of global symbols or symbols with unique names are unique. */ |
1102 | if ((TREE_PUBLIC (old_decl) |
1103 | && !DECL_EXTERNAL (old_decl) |
1104 | && !DECL_WEAK (old_decl) |
1105 | && !DECL_COMDAT (old_decl)) |
1106 | || in_lto_p) |
1107 | new_version_node->unique_name = true; |
1108 | |
1109 | /* Update the call_expr on the edges to call the new version node. */ |
1110 | update_call_expr (new_version: new_version_node); |
1111 | |
1112 | symtab->call_cgraph_insertion_hooks (node: new_version_node); |
1113 | return new_version_node; |
1114 | } |
1115 | |
1116 | /* Remove the node from the tree of virtual and inline clones and make it a |
1117 | standalone node - not a clone any more. */ |
1118 | |
1119 | void cgraph_node::remove_from_clone_tree () |
1120 | { |
1121 | if (next_sibling_clone) |
1122 | next_sibling_clone->prev_sibling_clone = prev_sibling_clone; |
1123 | if (prev_sibling_clone) |
1124 | prev_sibling_clone->next_sibling_clone = next_sibling_clone; |
1125 | else |
1126 | clone_of->clones = next_sibling_clone; |
1127 | next_sibling_clone = NULL; |
1128 | prev_sibling_clone = NULL; |
1129 | clone_of = NULL; |
1130 | } |
1131 | |
1132 | /* Given virtual clone, turn it into actual clone. */ |
1133 | |
1134 | void |
1135 | cgraph_node::materialize_clone () |
1136 | { |
1137 | clone_info *info = clone_info::get (node: this); |
1138 | clone_of->get_untransformed_body (); |
1139 | former_clone_of = clone_of->decl; |
1140 | if (clone_of->former_clone_of) |
1141 | former_clone_of = clone_of->former_clone_of; |
1142 | if (symtab->dump_file) |
1143 | { |
1144 | fprintf (stream: symtab->dump_file, format: "cloning %s to %s\n" , |
1145 | clone_of->dump_name (), |
1146 | dump_name ()); |
1147 | if (info && info->tree_map) |
1148 | { |
1149 | fprintf (stream: symtab->dump_file, format: " replace map:" ); |
1150 | for (unsigned int i = 0; |
1151 | i < vec_safe_length (v: info->tree_map); |
1152 | i++) |
1153 | { |
1154 | ipa_replace_map *replace_info; |
1155 | replace_info = (*info->tree_map)[i]; |
1156 | fprintf (stream: symtab->dump_file, format: "%s %i -> " , |
1157 | i ? "," : "" , replace_info->parm_num); |
1158 | print_generic_expr (symtab->dump_file, |
1159 | replace_info->new_tree); |
1160 | } |
1161 | fprintf (stream: symtab->dump_file, format: "\n" ); |
1162 | } |
1163 | if (info && info->param_adjustments) |
1164 | info->param_adjustments->dump (f: symtab->dump_file); |
1165 | } |
1166 | clear_stmts_in_references (); |
1167 | /* Copy the OLD_VERSION_NODE function tree to the new version. */ |
1168 | tree_function_versioning (clone_of->decl, decl, |
1169 | info ? info->tree_map : NULL, |
1170 | info ? info->param_adjustments : NULL, |
1171 | true, NULL, NULL); |
1172 | if (symtab->dump_file) |
1173 | { |
1174 | dump_function_to_file (clone_of->decl, symtab->dump_file, |
1175 | dump_flags); |
1176 | dump_function_to_file (decl, symtab->dump_file, dump_flags); |
1177 | } |
1178 | |
1179 | cgraph_node *this_clone_of = clone_of; |
1180 | /* Function is no longer clone. */ |
1181 | remove_from_clone_tree (); |
1182 | if (!this_clone_of->analyzed && !this_clone_of->clones) |
1183 | this_clone_of->release_body (); |
1184 | } |
1185 | |
1186 | #include "gt-cgraphclones.h" |
1187 | |