[PATCH] PR jit/63854: Introduce xstrdup_for_dump
Jan Hubicka
hubicka@ucw.cz
Thu Dec 4 23:23:00 GMT 2014
> 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
More information about the Gcc-patches
mailing list