> The auto_ptr<> idea sounds invasive (and made me wonder - why not go the > whole way and use std::string?)
That would work for me too :) > > Here's an implementation of the xstrdup_for_dump idea. > > To recap the motivation: > > cgraph*.c and ipa-*.c use xstrdup on strings when dumping them via > fprintf, leaking all of the duplicated buffers. > > We need to duplicate the buffers since: > https://gcc.gnu.org/ml/gcc-patches/2012-04/msg01904.html > > "There is a problem with multiple calls of cgraph_node_name in fprintf > dumps. Please note that C++ uses caching in > cxx_printable_name_internal (aka LANG_HOOKS_DECL_PRINTABLE_NAME), so > when cxx_printable_name_internal is called multiple times from printf > (i.e. fprintf "%s/%i -> %s/%i"), it can happen that the first string > gets evicted by the second call, before fprintf is fully evaluated." > > The xstrdup calls are a memory leak, which is an issue for the JIT, > and it would be ideal to get the other frontends clean under valgrind. > > The simplest solution is to replace them with ggc_strdup calls, so that > the buffers can be reclaimed next time the GC collects, but just doing > that would leave the reason for the ggc_strdup obscure. > > Hence this patch introduces a new function "xstrdup_for_dump", a thin > wrapper around ggc_strdup, so that the intent of the duplication can be > easily determined by a newcomer to the code. > > Successfully bootstrapped & regrtested on x86_64-unknown-linux-gnu > (Fedora 20). > > OK for trunk? OK, thanks for all the work on memory leaks! Honza > > This fixes these leaks seen by valgrind (e.g. in the jit's test-function.c > when enabling GCC_JIT_BOOL_OPTION_DUMP_EVERYTHING): > > 12 bytes in 1 blocks are definitely lost in loss record 11 of 148 > at 0x4A0645D: malloc (in > /usr/lib64/valgrind/vgpreload_memcheck-amd64-linux.so) > by 0x5DED3E7: xmalloc (xmalloc.c:147) > by 0x5DED4D9: xstrdup (xstrdup.c:34) > by 0x5126326: ipa_print_node_jump_functions(_IO_FILE*, cgraph_node*) > (ipa-prop.c:397) > by 0x512657F: ipa_print_all_jump_functions(_IO_FILE*) (ipa-prop.c:443) > by 0x5CE4471: ipcp_driver() (ipa-cp.c:4216) > by 0x5CE46D8: (anonymous namespace)::pass_ipa_cp::execute(function*) > (ipa-cp.c:4315) > by 0x525BF51: execute_one_pass(opt_pass*) (passes.c:2311) > by 0x525CE68: execute_ipa_pass_list(opt_pass*) (passes.c:2708) > by 0x4E5263C: ipa_passes() (cgraphunit.c:2099) > by 0x4E5298C: symbol_table::compile() (cgraphunit.c:2187) > by 0x4E52D22: symbol_table::finalize_compilation_unit() (cgraphunit.c:2340) > > 12 bytes in 1 blocks are definitely lost in loss record 12 of 148 > at 0x4A0645D: malloc (in > /usr/lib64/valgrind/vgpreload_memcheck-amd64-linux.so) > by 0x5DED3E7: xmalloc (xmalloc.c:147) > by 0x5DED4D9: xstrdup (xstrdup.c:34) > by 0x5CF155A: report_inline_failed_reason(cgraph_edge*) (ipa-inline.c:253) > by 0x5CF1C35: can_inline_edge_p(cgraph_edge*, bool, bool) (ipa-inline.c:394) > by 0x5CF4DFC: inline_small_functions() (ipa-inline.c:1651) > by 0x5CF6785: ipa_inline() (ipa-inline.c:2188) > by 0x5CF7358: (anonymous namespace)::pass_ipa_inline::execute(function*) > (ipa-inline.c:2557) > by 0x525BF51: execute_one_pass(opt_pass*) (passes.c:2311) > by 0x525CE68: execute_ipa_pass_list(opt_pass*) (passes.c:2708) > by 0x4E5263C: ipa_passes() (cgraphunit.c:2099) > by 0x4E5298C: symbol_table::compile() (cgraphunit.c:2187) > > 16 bytes in 1 blocks are definitely lost in loss record 16 of 148 > at 0x4A0645D: malloc (in > /usr/lib64/valgrind/vgpreload_memcheck-amd64-linux.so) > by 0x5DED3E7: xmalloc (xmalloc.c:147) > by 0x5DED4D9: xstrdup (xstrdup.c:34) > by 0x5126308: ipa_print_node_jump_functions(_IO_FILE*, cgraph_node*) > (ipa-prop.c:397) > by 0x512657F: ipa_print_all_jump_functions(_IO_FILE*) (ipa-prop.c:443) > by 0x5CE4471: ipcp_driver() (ipa-cp.c:4216) > by 0x5CE46D8: (anonymous namespace)::pass_ipa_cp::execute(function*) > (ipa-cp.c:4315) > by 0x525BF51: execute_one_pass(opt_pass*) (passes.c:2311) > by 0x525CE68: execute_ipa_pass_list(opt_pass*) (passes.c:2708) > by 0x4E5263C: ipa_passes() (cgraphunit.c:2099) > by 0x4E5298C: symbol_table::compile() (cgraphunit.c:2187) > by 0x4E52D22: symbol_table::finalize_compilation_unit() (cgraphunit.c:2340) > > 16 bytes in 1 blocks are definitely lost in loss record 17 of 148 > at 0x4A0645D: malloc (in > /usr/lib64/valgrind/vgpreload_memcheck-amd64-linux.so) > by 0x5DED3E7: xmalloc (xmalloc.c:147) > by 0x5DED4D9: xstrdup (xstrdup.c:34) > by 0x5CF1533: report_inline_failed_reason(cgraph_edge*) (ipa-inline.c:253) > by 0x5CF1C35: can_inline_edge_p(cgraph_edge*, bool, bool) (ipa-inline.c:394) > by 0x5CF4DFC: inline_small_functions() (ipa-inline.c:1651) > by 0x5CF6785: ipa_inline() (ipa-inline.c:2188) > by 0x5CF7358: (anonymous namespace)::pass_ipa_inline::execute(function*) > (ipa-inline.c:2557) > by 0x525BF51: execute_one_pass(opt_pass*) (passes.c:2311) > by 0x525CE68: execute_ipa_pass_list(opt_pass*) (passes.c:2708) > by 0x4E5263C: ipa_passes() (cgraphunit.c:2099) > by 0x4E5298C: symbol_table::compile() (cgraphunit.c:2187) > > gcc/ChangeLog: > PR jit/63854 > * cgraph.h (xstrdup_for_dump): New function. > * cgraph.c (cgraph_node::get_create): Replace use of xstrdup > within fprintf with xstrdup_for_dump. > (cgraph_edge::make_speculative): Likewise. > (cgraph_edge::resolve_speculation): Likewise. > (cgraph_edge::redirect_call_stmt_to_callee): Likewise. > (cgraph_node::dump): Likewise. > * cgraphclones.c (symbol_table::materialize_all_clones): Likewise. > * ipa-cp.c (perhaps_add_new_callers): Likewise. > * ipa-inline.c (report_inline_failed_reason): Likewise. > (want_early_inline_function_p): Likewise. > (edge_badness): Likewise. > (update_edge_key): Likewise. > (flatten_function): Likewise. > (inline_always_inline_functions): Likewise. > * ipa-profile.c (ipa_profile): Likewise. > * ipa-prop.c (ipa_print_node_jump_functions): Likewise. > (ipa_make_edge_direct_to_target): Likewise. > (remove_described_reference): Likewise. > (propagate_controlled_uses): Likewise. > * ipa-utils.c (ipa_merge_profiles): Likewise. > --- > gcc/cgraph.c | 36 ++++++++++++++++++++---------------- > gcc/cgraph.h | 28 ++++++++++++++++++++++++++++ > gcc/cgraphclones.c | 4 ++-- > gcc/ipa-cp.c | 4 ++-- > gcc/ipa-inline.c | 44 ++++++++++++++++++++++---------------------- > gcc/ipa-profile.c | 4 ++-- > gcc/ipa-prop.c | 34 +++++++++++++++++----------------- > gcc/ipa-utils.c | 4 ++-- > 8 files changed, 95 insertions(+), 63 deletions(-) > > diff --git a/gcc/cgraph.c b/gcc/cgraph.c > index 6aecb14..50c7b34 100644 > --- a/gcc/cgraph.c > +++ b/gcc/cgraph.c > @@ -537,11 +537,11 @@ cgraph_node::get_create (tree decl) > if (dump_file) > fprintf (dump_file, "Introduced new external node " > "(%s/%i) and turned into root of the clone tree.\n", > - xstrdup (node->name ()), node->order); > + xstrdup_for_dump (node->name ()), node->order); > } > else if (dump_file) > fprintf (dump_file, "Introduced new external node " > - "(%s/%i).\n", xstrdup (node->name ()), > + "(%s/%i).\n", xstrdup_for_dump (node->name ()), > node->order); > return node; > } > @@ -1070,8 +1070,8 @@ cgraph_edge::make_speculative (cgraph_node *n2, > gcov_type direct_count, > { > fprintf (dump_file, "Indirect call -> speculative call" > " %s/%i => %s/%i\n", > - xstrdup (n->name ()), n->order, > - xstrdup (n2->name ()), n2->order); > + xstrdup_for_dump (n->name ()), n->order, > + xstrdup_for_dump (n2->name ()), n2->order); > } > speculative = true; > e2 = n->create_edge (n2, call_stmt, direct_count, direct_frequency); > @@ -1190,16 +1190,20 @@ cgraph_edge::resolve_speculation (tree callee_decl) > { > fprintf (dump_file, "Speculative indirect call %s/%i => %s/%i has > " > "turned out to have contradicting known target ", > - xstrdup (edge->caller->name ()), edge->caller->order, > - xstrdup (e2->callee->name ()), e2->callee->order); > + xstrdup_for_dump (edge->caller->name ()), > + edge->caller->order, > + xstrdup_for_dump (e2->callee->name ()), > + e2->callee->order); > print_generic_expr (dump_file, callee_decl, 0); > fprintf (dump_file, "\n"); > } > else > { > fprintf (dump_file, "Removing speculative call %s/%i => %s/%i\n", > - xstrdup (edge->caller->name ()), edge->caller->order, > - xstrdup (e2->callee->name ()), e2->callee->order); > + xstrdup_for_dump (edge->caller->name ()), > + edge->caller->order, > + xstrdup_for_dump (e2->callee->name ()), > + e2->callee->order); > } > } > } > @@ -1319,9 +1323,9 @@ cgraph_edge::redirect_call_stmt_to_callee (void) > if (dump_file) > fprintf (dump_file, "Not expanding speculative call of %s/%i -> > %s/%i\n" > "Type mismatch.\n", > - xstrdup (e->caller->name ()), > + xstrdup_for_dump (e->caller->name ()), > e->caller->order, > - xstrdup (e->callee->name ()), > + xstrdup_for_dump (e->callee->name ()), > e->callee->order); > e = e->resolve_speculation (); > /* We are producing the final function body and will throw away the > @@ -1338,9 +1342,9 @@ cgraph_edge::redirect_call_stmt_to_callee (void) > fprintf (dump_file, > "Expanding speculative call of %s/%i -> %s/%i count:" > "%"PRId64"\n", > - xstrdup (e->caller->name ()), > + xstrdup_for_dump (e->caller->name ()), > e->caller->order, > - xstrdup (e->callee->name ()), > + xstrdup_for_dump (e->callee->name ()), > e->callee->order, > (int64_t)e->count); > gcc_assert (e2->speculative); > @@ -1415,8 +1419,8 @@ cgraph_edge::redirect_call_stmt_to_callee (void) > if (symtab->dump_file) > { > fprintf (symtab->dump_file, "updating call of %s/%i -> %s/%i: ", > - xstrdup (e->caller->name ()), e->caller->order, > - xstrdup (e->callee->name ()), e->callee->order); > + xstrdup_for_dump (e->caller->name ()), e->caller->order, > + xstrdup_for_dump (e->callee->name ()), e->callee->order); > print_gimple_stmt (symtab->dump_file, e->call_stmt, 0, dump_flags); > if (e->callee->clone.combined_args_to_skip) > { > @@ -1965,9 +1969,9 @@ cgraph_node::dump (FILE *f) > > if (global.inlined_to) > fprintf (f, " Function %s/%i is inline copy in %s/%i\n", > - xstrdup (name ()), > + xstrdup_for_dump (name ()), > order, > - xstrdup (global.inlined_to->name ()), > + xstrdup_for_dump (global.inlined_to->name ()), > global.inlined_to->order); > if (clone_of) > fprintf (f, " Clone of %s/%i\n", > diff --git a/gcc/cgraph.h b/gcc/cgraph.h > index 04318f5..9303764 100644 > --- a/gcc/cgraph.h > +++ b/gcc/cgraph.h > @@ -2818,4 +2818,32 @@ cgraph_local_p (cgraph_node *node) > return node->local.local && node->instrumented_version->local.local; > } > > +/* When using fprintf (or similar), problems can arise with > + transient generated strings. Many string-generation APIs > + only support one result being alive at once (e.g. by > + returning a pointer to a statically-allocated buffer). > + > + If there is more than one generated string within one > + fprintf call: the first string gets evicted or overwritten > + by the second, before fprintf is fully evaluated. > + See e.g. PR/53136. > + > + This function provides a workaround for this, by providing > + a simple way to create copies of these transient strings, > + without the need to have explicit cleanup: > + > + fprintf (dumpfile, "string 1: %s string 2:%s\n", > + xstrdup_for_dump (EXPR_1), > + xstrdup_for_dump (EXPR_2)); > + > + This is actually a simple wrapper around ggc_strdup, but > + the name documents the intent. We require that no GC can occur > + within the fprintf call. */ > + > +static inline const char * > +xstrdup_for_dump (const char *transient_str) > +{ > + return ggc_strdup (transient_str); > +} > + > #endif /* GCC_CGRAPH_H */ > diff --git a/gcc/cgraphclones.c b/gcc/cgraphclones.c > index 086dd92..ff30bb9 100644 > --- a/gcc/cgraphclones.c > +++ b/gcc/cgraphclones.c > @@ -1074,8 +1074,8 @@ symbol_table::materialize_all_clones (void) > if (symtab->dump_file) > { > fprintf (symtab->dump_file, "cloning %s to %s\n", > - xstrdup (node->clone_of->name ()), > - xstrdup (node->name ())); > + xstrdup_for_dump (node->clone_of->name ()), > + xstrdup_for_dump (node->name ())); > if (node->clone.tree_map) > { > unsigned int i; > diff --git a/gcc/ipa-cp.c b/gcc/ipa-cp.c > index 3baa115..41e4757 100644 > --- a/gcc/ipa-cp.c > +++ b/gcc/ipa-cp.c > @@ -3907,9 +3907,9 @@ perhaps_add_new_callers (cgraph_node *node, > ipcp_value<valtype> *val) > if (dump_file) > fprintf (dump_file, " - adding an extra caller %s/%i" > " of %s/%i\n", > - xstrdup (cs->caller->name ()), > + xstrdup_for_dump (cs->caller->name ()), > cs->caller->order, > - xstrdup (val->spec_node->name ()), > + xstrdup_for_dump (val->spec_node->name ()), > val->spec_node->order); > > cs->redirect_callee (val->spec_node); > diff --git a/gcc/ipa-inline.c b/gcc/ipa-inline.c > index 26335ec..f62760f 100644 > --- a/gcc/ipa-inline.c > +++ b/gcc/ipa-inline.c > @@ -248,8 +248,8 @@ report_inline_failed_reason (struct cgraph_edge *e) > if (dump_file) > { > fprintf (dump_file, " not inlinable: %s/%i -> %s/%i, %s\n", > - xstrdup (e->caller->name ()), e->caller->order, > - xstrdup (e->callee->name ()), e->callee->order, > + xstrdup_for_dump (e->caller->name ()), e->caller->order, > + xstrdup_for_dump (e->callee->name ()), e->callee->order, > cgraph_inline_failed_string (e->inline_failed)); > } > } > @@ -480,9 +480,9 @@ want_early_inline_function_p (struct cgraph_edge *e) > if (dump_file) > fprintf (dump_file, " will not early inline: %s/%i->%s/%i, " > "call is cold and code would grow by %i\n", > - xstrdup (e->caller->name ()), > + xstrdup_for_dump (e->caller->name ()), > e->caller->order, > - xstrdup (callee->name ()), callee->order, > + xstrdup_for_dump (callee->name ()), callee->order, > growth); > want_inline = false; > } > @@ -491,9 +491,9 @@ want_early_inline_function_p (struct cgraph_edge *e) > if (dump_file) > fprintf (dump_file, " will not early inline: %s/%i->%s/%i, " > "growth %i exceeds --param early-inlining-insns\n", > - xstrdup (e->caller->name ()), > + xstrdup_for_dump (e->caller->name ()), > e->caller->order, > - xstrdup (callee->name ()), callee->order, > + xstrdup_for_dump (callee->name ()), callee->order, > growth); > want_inline = false; > } > @@ -504,9 +504,9 @@ want_early_inline_function_p (struct cgraph_edge *e) > fprintf (dump_file, " will not early inline: %s/%i->%s/%i, " > "growth %i exceeds --param early-inlining-insns " > "divided by number of calls\n", > - xstrdup (e->caller->name ()), > + xstrdup_for_dump (e->caller->name ()), > e->caller->order, > - xstrdup (callee->name ()), callee->order, > + xstrdup_for_dump (callee->name ()), callee->order, > growth); > want_inline = false; > } > @@ -925,9 +925,9 @@ edge_badness (struct cgraph_edge *edge, bool dump) > if (dump) > { > fprintf (dump_file, " Badness calculation for %s/%i -> %s/%i\n", > - xstrdup (edge->caller->name ()), > + xstrdup_for_dump (edge->caller->name ()), > edge->caller->order, > - xstrdup (callee->name ()), > + xstrdup_for_dump (callee->name ()), > edge->callee->order); > fprintf (dump_file, " size growth %i, time %i ", > growth, > @@ -1094,9 +1094,9 @@ update_edge_key (edge_heap_t *heap, struct cgraph_edge > *edge) > fprintf (dump_file, > " decreasing badness %s/%i -> %s/%i, %"PRId64 > " to %"PRId64"\n", > - xstrdup (edge->caller->name ()), > + xstrdup_for_dump (edge->caller->name ()), > edge->caller->order, > - xstrdup (edge->callee->name ()), > + xstrdup_for_dump (edge->callee->name ()), > edge->callee->order, > n->get_key ().to_int (), > badness.to_int ()); > @@ -1111,9 +1111,9 @@ update_edge_key (edge_heap_t *heap, struct cgraph_edge > *edge) > { > fprintf (dump_file, > " enqueuing call %s/%i -> %s/%i, badness %"PRId64"\n", > - xstrdup (edge->caller->name ()), > + xstrdup_for_dump (edge->caller->name ()), > edge->caller->order, > - xstrdup (edge->callee->name ()), > + xstrdup_for_dump (edge->callee->name ()), > edge->callee->order, > badness.to_int ()); > } > @@ -1892,8 +1892,8 @@ flatten_function (struct cgraph_node *node, bool early) > if (dump_file) > fprintf (dump_file, > "Not inlining %s into %s to avoid cycle.\n", > - xstrdup (callee->name ()), > - xstrdup (e->caller->name ())); > + xstrdup_for_dump (callee->name ()), > + xstrdup_for_dump (e->caller->name ())); > e->inline_failed = CIF_RECURSIVE_INLINING; > continue; > } > @@ -1933,8 +1933,8 @@ flatten_function (struct cgraph_node *node, bool early) > recursing through the original node if the node was cloned. */ > if (dump_file) > fprintf (dump_file, " Inlining %s into %s.\n", > - xstrdup (callee->name ()), > - xstrdup (e->caller->name ())); > + xstrdup_for_dump (callee->name ()), > + xstrdup_for_dump (e->caller->name ())); > orig_callee = callee; > inline_call (e, true, NULL, NULL, false); > if (e->callee != orig_callee) > @@ -2311,8 +2311,8 @@ inline_always_inline_functions (struct cgraph_node > *node) > > if (dump_file) > fprintf (dump_file, " Inlining %s into %s (always_inline).\n", > - xstrdup (e->callee->name ()), > - xstrdup (e->caller->name ())); > + xstrdup_for_dump (e->callee->name ()), > + xstrdup_for_dump (e->caller->name ())); > inline_call (e, true, NULL, NULL, false); > inlined = true; > } > @@ -2363,8 +2363,8 @@ early_inline_small_functions (struct cgraph_node *node) > > if (dump_file) > fprintf (dump_file, " Inlining %s into %s.\n", > - xstrdup (callee->name ()), > - xstrdup (e->caller->name ())); > + xstrdup_for_dump (callee->name ()), > + xstrdup_for_dump (e->caller->name ())); > inline_call (e, true, NULL, NULL, true); > inlined = true; > } > diff --git a/gcc/ipa-profile.c b/gcc/ipa-profile.c > index 340d033..f540bd6 100644 > --- a/gcc/ipa-profile.c > +++ b/gcc/ipa-profile.c > @@ -607,8 +607,8 @@ ipa_profile (void) > { > fprintf (dump_file, "Indirect call -> direct call from" > " other module %s/%i => %s/%i, prob %3.2f\n", > - xstrdup (n->name ()), n->order, > - xstrdup (n2->name ()), n2->order, > + xstrdup_for_dump (n->name ()), n->order, > + xstrdup_for_dump (n2->name ()), n2->order, > e->indirect_info->common_target_probability > / (float)REG_BR_PROB_BASE); > } > diff --git a/gcc/ipa-prop.c b/gcc/ipa-prop.c > index eb83ae0..843cb99 100644 > --- a/gcc/ipa-prop.c > +++ b/gcc/ipa-prop.c > @@ -401,8 +401,8 @@ ipa_print_node_jump_functions (FILE *f, struct > cgraph_node *node) > continue; > > fprintf (f, " callsite %s/%i -> %s/%i : \n", > - xstrdup (node->name ()), node->order, > - xstrdup (cs->callee->name ()), > + xstrdup_for_dump (node->name ()), node->order, > + xstrdup_for_dump (cs->callee->name ()), > cs->callee->order); > ipa_print_node_jump_functions_for_edge (f, cs); > } > @@ -2656,9 +2656,9 @@ ipa_make_edge_direct_to_target (struct cgraph_edge *ie, > tree target, > if (dump_file) > fprintf (dump_file, "ipa-prop: Discovered call to a known target " > "(%s/%i -> %s/%i) but can not refer to it. Giving up.\n", > - xstrdup (ie->caller->name ()), > + xstrdup_for_dump (ie->caller->name ()), > ie->caller->order, > - xstrdup (ie->callee->name ()), > + xstrdup_for_dump (ie->callee->name ()), > ie->callee->order); > return NULL; > } > @@ -2677,11 +2677,11 @@ ipa_make_edge_direct_to_target (struct cgraph_edge > *ie, tree target, > if (dump_file) > fprintf (dump_file, "ipa-prop: Discovered call to a speculative > target " > "(%s/%i -> %s/%i) but the call is already speculated to > %s/%i. Giving up.\n", > - xstrdup (ie->caller->name ()), > + xstrdup_for_dump (ie->caller->name ()), > ie->caller->order, > - xstrdup (callee->name ()), > + xstrdup_for_dump (callee->name ()), > callee->order, > - xstrdup (e2->callee->name ()), > + xstrdup_for_dump (e2->callee->name ()), > e2->callee->order); > } > else > @@ -2689,9 +2689,9 @@ ipa_make_edge_direct_to_target (struct cgraph_edge *ie, > tree target, > if (dump_file) > fprintf (dump_file, "ipa-prop: Discovered call to a speculative > target " > "(%s/%i -> %s/%i) this agree with previous speculation.\n", > - xstrdup (ie->caller->name ()), > + xstrdup_for_dump (ie->caller->name ()), > ie->caller->order, > - xstrdup (callee->name ()), > + xstrdup_for_dump (callee->name ()), > callee->order); > } > return NULL; > @@ -2712,9 +2712,9 @@ ipa_make_edge_direct_to_target (struct cgraph_edge *ie, > tree target, > "(%s/%i -> %s/%i), for stmt ", > ie->indirect_info->polymorphic ? "a virtual" : "an indirect", > speculative ? "speculative" : "known", > - xstrdup (ie->caller->name ()), > + xstrdup_for_dump (ie->caller->name ()), > ie->caller->order, > - xstrdup (callee->name ()), > + xstrdup_for_dump (callee->name ()), > callee->order); > if (ie->call_stmt) > print_gimple_stmt (dump_file, ie->call_stmt, 2, TDF_SLIM); > @@ -2798,8 +2798,8 @@ remove_described_reference (symtab_node *symbol, struct > ipa_cst_ref_desc *rdesc) > to_del->remove_reference (); > if (dump_file) > fprintf (dump_file, "ipa-prop: Removed a reference from %s/%i to %s.\n", > - xstrdup (origin->caller->name ()), > - origin->caller->order, xstrdup (symbol->name ())); > + xstrdup_for_dump (origin->caller->name ()), > + origin->caller->order, xstrdup_for_dump (symbol->name ())); > return true; > } > > @@ -3213,9 +3213,9 @@ propagate_controlled_uses (struct cgraph_edge *cs) > if (dump_file) > fprintf (dump_file, "ipa-prop: Removing cloning-created " > "reference from %s/%i to %s/%i.\n", > - xstrdup (new_root->name ()), > + xstrdup_for_dump (new_root->name ()), > new_root->order, > - xstrdup (n->name ()), n->order); > + xstrdup_for_dump (n->name ()), n->order); > ref->remove_reference (); > } > } > @@ -3254,9 +3254,9 @@ propagate_controlled_uses (struct cgraph_edge *cs) > fprintf (dump_file, "ipa-prop: Removing " > "cloning-created reference " > "from %s/%i to %s/%i.\n", > - xstrdup (clone->name ()), > + xstrdup_for_dump (clone->name ()), > clone->order, > - xstrdup (n->name ()), > + xstrdup_for_dump (n->name ()), > n->order); > ref->remove_reference (); > } > diff --git a/gcc/ipa-utils.c b/gcc/ipa-utils.c > index 7613205..c158837 100644 > --- a/gcc/ipa-utils.c > +++ b/gcc/ipa-utils.c > @@ -427,8 +427,8 @@ ipa_merge_profiles (struct cgraph_node *dst, > if (symtab->dump_file) > { > fprintf (symtab->dump_file, "Merging profiles of %s/%i to %s/%i\n", > - xstrdup (src->name ()), src->order, > - xstrdup (dst->name ()), dst->order); > + xstrdup_for_dump (src->name ()), src->order, > + xstrdup_for_dump (dst->name ()), dst->order); > } > dst->count += src->count; > > -- > 1.8.5.3