This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Re: LTO/WHOPR summary streaming fixes
Hi,
sorry for replying this late but I haven't managed to read the patch
earlier. OTOH, I only have one question and two rather minor
comments.
On Thu, Oct 22, 2009 at 02:39:00AM +0200, Jan Hubicka wrote:
> Index: ipa-cp.c
> ===================================================================
> *** ipa-cp.c (revision 152974)
> --- ipa-cp.c (working copy)
...
> *************** ipcp_propagate_stage (void)
> *** 696,702 ****
> struct ipa_node_params *callee_info = IPA_NODE_REF (cs->callee);
> struct ipa_edge_args *args = IPA_EDGE_REF (cs);
>
> ! if (ipa_is_called_with_var_arguments (callee_info))
> continue;
>
> count = ipa_get_cs_argument_count (args);
> --- 698,706 ----
> struct ipa_node_params *callee_info = IPA_NODE_REF (cs->callee);
> struct ipa_edge_args *args = IPA_EDGE_REF (cs);
>
> ! if (ipa_is_called_with_var_arguments (callee_info)
> ! || !cs->callee->analyzed
> ! || ipa_is_called_with_var_arguments (callee_info))
> continue;
ipa_is_called_with_var_arguments is tested twice which does not make
any sense, I'll try to remember to clean this up when I get to
modifying the file.
>
> count = ipa_get_cs_argument_count (args);
...
> Index: ipa-prop.c
> ===================================================================
> *** ipa-prop.c (revision 152974)
> --- ipa-prop.c (working copy)
...
> *************** ipa_dump_param_adjustments (FILE *file,
> *** 1875,1877 ****
> --- 1891,2173 ----
> VEC_free (tree, heap, parms);
> }
>
> + /* Stream out jump function JUMP_FUNC to OB. */
> +
> + static void
> + ipa_write_jump_function (struct output_block *ob,
> + struct ipa_jump_func *jump_func)
> + {
> + lto_output_uleb128_stream (ob->main_stream,
> + jump_func->type);
> +
> + switch (jump_func->type)
> + {
> + case IPA_JF_UNKNOWN:
> + break;
> + case IPA_JF_CONST:
> + lto_output_tree (ob, jump_func->value.constant, true);
> + break;
> + case IPA_JF_PASS_THROUGH:
> + lto_output_tree (ob, jump_func->value.pass_through.operand, true);
> + lto_output_uleb128_stream (ob->main_stream,
> + jump_func->value.pass_through.formal_id);
> + lto_output_uleb128_stream (ob->main_stream,
> + jump_func->value.pass_through.operation);
> + break;
> + case IPA_JF_ANCESTOR:
> + lto_output_uleb128_stream (ob->main_stream,
> + jump_func->value.ancestor.offset);
> + lto_output_tree (ob, jump_func->value.ancestor.type, true);
> + lto_output_uleb128_stream (ob->main_stream,
> + jump_func->value.ancestor.formal_id);
> + break;
> + case IPA_JF_CONST_MEMBER_PTR:
> + lto_output_tree (ob, jump_func->value.member_cst.pfn, true);
> + lto_output_tree (ob, jump_func->value.member_cst.delta, false);
> + break;
> + }
> + }
> +
> + /* Read in jump function JUMP_FUNC from IB. */
> +
> + static void
> + ipa_read_jump_function (struct lto_input_block *ib,
> + struct ipa_jump_func *jump_func,
> + struct data_in *data_in)
> + {
> + jump_func->type = (enum jump_func_type) lto_input_uleb128 (ib);
> +
> + switch (jump_func->type)
> + {
> + case IPA_JF_UNKNOWN:
> + break;
> + case IPA_JF_CONST:
> + jump_func->value.constant = lto_input_tree (ib, data_in);
> + break;
> + case IPA_JF_PASS_THROUGH:
> + jump_func->value.pass_through.operand = lto_input_tree (ib, data_in);
> + jump_func->value.pass_through.formal_id = lto_input_uleb128 (ib);
> + jump_func->value.pass_through.operation = (enum tree_code) lto_input_uleb128 (ib);
> + break;
> + case IPA_JF_ANCESTOR:
> + jump_func->value.ancestor.offset = lto_input_uleb128 (ib);
> + jump_func->value.ancestor.type = lto_input_tree (ib, data_in);
> + jump_func->value.ancestor.formal_id = lto_input_uleb128 (ib);
> + break;
> + case IPA_JF_CONST_MEMBER_PTR:
> + jump_func->value.member_cst.pfn = lto_input_tree (ib, data_in);
> + jump_func->value.member_cst.delta = lto_input_tree (ib, data_in);
> + break;
> + }
> + }
> +
> + /* Stream out NODE info to OB. */
> +
> + static void
> + ipa_write_node_info (struct output_block *ob, struct cgraph_node *node)
> + {
> + int node_ref;
> + lto_cgraph_encoder_t encoder;
> + struct ipa_node_params *info = IPA_NODE_REF (node);
> + int j;
> + struct cgraph_edge *e;
> + struct bitpack_d *bp;
> +
> + encoder = ob->decl_state->cgraph_node_encoder;
> + node_ref = lto_cgraph_encoder_encode (encoder, node);
> + lto_output_uleb128_stream (ob->main_stream, node_ref);
> +
> + /* Note that flags will need to be read in the opposite
> + order as we are pushing the bitflags into FLAGS. */
> + bp = bitpack_create ();
> + bp_pack_value (bp, info->called_with_var_arguments, 1);
> + gcc_assert (info->modification_analysis_done || ipa_get_param_count (info) == 0);
> + gcc_assert (info->uses_analysis_done || ipa_get_param_count (info) == 0);
> + gcc_assert (!info->node_enqueued);
> + gcc_assert (!info->ipcp_orig_node);
> + for (j = 0; j < ipa_get_param_count (info); j++)
> + {
> + bp_pack_value (bp, info->params[j].modified, 1);
> + bp_pack_value (bp, info->params[j].called, 1);
> + }
> + lto_output_bitpack (ob->main_stream, bp);
> + bitpack_delete (bp);
> + for (e = node->callees; e; e = e->next_callee)
> + {
> + struct ipa_edge_args *args = IPA_EDGE_REF (e);
> +
> + lto_output_uleb128_stream (ob->main_stream, ipa_get_cs_argument_count (args));
> + for (j = 0; j < ipa_get_cs_argument_count (args); j++)
> + ipa_write_jump_function (ob, ipa_get_ith_jump_func (args, j));
> + }
> + }
> +
> + /* Srtream in NODE info from IB. */
> +
> + static void
> + ipa_read_node_info (struct lto_input_block *ib, struct cgraph_node *node,
> + struct data_in *data_in)
> + {
> + struct ipa_node_params *info = IPA_NODE_REF (node);
> + int k;
> + struct cgraph_edge *e;
> + struct bitpack_d *bp;
> +
> + ipa_initialize_node_params (node);
> +
> + /* Note that the flags must be read in the opposite
> + order in which they were written (the bitflags were
> + pushed into FLAGS). */
I am puzzled by this comment (and the corresponding one in the
previous function). No matter for how long I stare at the code I
don't see what is read "in the opposite order." All corresponding
loops loop in the same direction, modified and called flags are also
read in the same order... What is it?
> + bp = lto_input_bitpack (ib);
> + info->called_with_var_arguments = bp_unpack_value (bp, 1);
> + if (ipa_get_param_count (info) != 0)
> + {
> + info->modification_analysis_done = true;
> + info->uses_analysis_done = true;
> + }
> + info->node_enqueued = false;
> + for (k = 0; k < ipa_get_param_count (info); k++)
> + {
> + info->params[k].modified = bp_unpack_value (bp, 1);
> + info->params[k].called = bp_unpack_value (bp, 1);
> + }
> + bitpack_delete (bp);
> + for (e = node->callees; e; e = e->next_callee)
> + {
> + struct ipa_edge_args *args = IPA_EDGE_REF (e);
> + int count = lto_input_uleb128 (ib);
> +
> + if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector)
> + <= (unsigned) cgraph_edge_max_uid)
> + VEC_safe_grow_cleared (ipa_edge_args_t, gc,
> + ipa_edge_args_vector, cgraph_edge_max_uid + 1);
This vector growth is either unnecessary or wrong. My guess is that
it is unnecessary as I don't see anything later in the loop which can
create new edges. If I am wrong and it is necessary then 1) calling
ipa_check_create_edge_args() would probably be nicer, and more
importantly 2) the local variable args must be initialized after the
vector is grown because it is invalidated if the vector gets
relocated. So which is it?
Otherwise, thanks a lot for demonstrating how the streaming works (and
making it work in the first place!),
Martin
> + ipa_set_cs_argument_count (args, count);
> + if (!count)
> + continue;
> +
> + args->jump_functions = GGC_CNEWVEC (struct ipa_jump_func,
> + ipa_get_cs_argument_count (args));
> + for (k = 0; k < ipa_get_cs_argument_count (args); k++)
> + ipa_read_jump_function (ib, ipa_get_ith_jump_func (args, k), data_in);
> + }
> + }
> +
> + /* Write jump functions for nodes in SET. */
> +
> + void
> + ipa_prop_write_jump_functions (cgraph_node_set set)
> + {
> + struct cgraph_node *node;
> + struct output_block *ob = create_output_block (LTO_section_jump_functions);
> + unsigned int count = 0;
> + cgraph_node_set_iterator csi;
> +
> + ob->cgraph_node = NULL;
> +
> + for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
> + {
> + node = csi_node (csi);
> + if (node->analyzed && IPA_NODE_REF (node) != NULL)
> + count++;
> + }
> +
> + lto_output_uleb128_stream (ob->main_stream, count);
> +
> + /* Process all of the functions. */
> + for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
> + {
> + node = csi_node (csi);
> + if (node->analyzed && IPA_NODE_REF (node) != NULL)
> + ipa_write_node_info (ob, node);
> + }
> + lto_output_1_stream (ob->main_stream, 0);
> + produce_asm (ob, NULL);
> + destroy_output_block (ob);
> + }
> +
> + /* Read section in file FILE_DATA of length LEN with data DATA. */
> +
> + static void
> + ipa_prop_read_section (struct lto_file_decl_data *file_data, const char *data,
> + size_t len)
> + {
> + const struct lto_function_header *header =
> + (const struct lto_function_header *) data;
> + const int32_t cfg_offset = sizeof (struct lto_function_header);
> + const int32_t main_offset = cfg_offset + header->cfg_size;
> + const int32_t string_offset = main_offset + header->main_size;
> + struct data_in *data_in;
> + struct lto_input_block ib_main;
> + unsigned int i;
> + unsigned int count;
> +
> + LTO_INIT_INPUT_BLOCK (ib_main, (const char *) data + main_offset, 0,
> + header->main_size);
> +
> + data_in =
> + lto_data_in_create (file_data, (const char *) data + string_offset,
> + header->string_size, NULL);
> + count = lto_input_uleb128 (&ib_main);
> +
> + for (i = 0; i < count; i++)
> + {
> + unsigned int index;
> + struct cgraph_node *node;
> + lto_cgraph_encoder_t encoder;
> +
> + index = lto_input_uleb128 (&ib_main);
> + encoder = file_data->cgraph_node_encoder;
> + node = lto_cgraph_encoder_deref (encoder, index);
> + ipa_read_node_info (&ib_main, node, data_in);
> + }
> + lto_free_section_data (file_data, LTO_section_jump_functions, NULL, data,
> + len);
> + lto_data_in_delete (data_in);
> + }
> +
> + /* Read ipcp jump functions. */
> +
> + void
> + ipa_prop_read_jump_functions (void)
> + {
> + struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
> + struct lto_file_decl_data *file_data;
> + unsigned int j = 0;
> +
> + ipa_check_create_node_params ();
> + ipa_check_create_edge_args ();
> + ipa_register_cgraph_hooks ();
> +
> + while ((file_data = file_data_vec[j++]))
> + {
> + size_t len;
> + const char *data = lto_get_section_data (file_data, LTO_section_jump_functions, NULL, &len);
> +
> + if (data)
> + ipa_prop_read_section (file_data, data, len);
> + }
> + }
> +
> + /* After merging units, we can get mismatch in argument counts.
> + Also decl merging might've rendered parameter lists obsolette.
> + Also compute called_with_variable_arg info. */
> +
> + void
> + ipa_update_after_lto_read (void)
> + {
> + struct cgraph_node *node;
> + struct cgraph_edge *cs;
> +
> + for (node = cgraph_nodes; node; node = node->next)
> + {
> + if (!node->analyzed)
> + continue;
> + ipa_populate_param_decls (node, IPA_NODE_REF (node));
> + for (cs = node->callees; cs; cs = cs->next_callee)
> + {
> + if (ipa_get_cs_argument_count (IPA_EDGE_REF (cs))
> + != ipa_get_param_count (IPA_NODE_REF (cs->callee)))
> + ipa_set_called_with_variable_arg (IPA_NODE_REF (cs->callee));
> + }
> + }
> + }
> Index: ipa-prop.h
> ===================================================================
> *** ipa-prop.h (revision 152974)
> --- ipa-prop.h (working copy)
> *************** enum ipa_lattice_type
> *** 72,78 ****
>
> /* Structure holding data required to describe a pass-through jump function. */
>
> ! struct ipa_pass_through_data
> {
> /* If an operation is to be performed on the original parameter, this is the
> second (constant) operand. */
> --- 72,78 ----
>
> /* Structure holding data required to describe a pass-through jump function. */
>
> ! struct GTY(()) ipa_pass_through_data
> {
> /* If an operation is to be performed on the original parameter, this is the
> second (constant) operand. */
> *************** struct ipa_pass_through_data
> *** 89,95 ****
> /* Structure holding data required to describe and ancestor pass throu
> funkci. */
>
> ! struct ipa_ancestor_jf_data
> {
> /* Offset of the field representing the ancestor. */
> HOST_WIDE_INT offset;
> --- 89,95 ----
> /* Structure holding data required to describe and ancestor pass throu
> funkci. */
>
> ! struct GTY(()) ipa_ancestor_jf_data
> {
> /* Offset of the field representing the ancestor. */
> HOST_WIDE_INT offset;
> *************** struct ipa_ancestor_jf_data
> *** 101,130 ****
>
> /* Structure holding a C++ member pointer constant. Holds a pointer to the
> method and delta offset. */
> ! struct ipa_member_ptr_cst
> {
> tree pfn;
> tree delta;
> };
>
> - /* Represents a value of a jump function. pass_through is used only in jump
> - function context. constant represents the actual constant in constant jump
> - functions and member_cst holds constant c++ member functions. */
> - union jump_func_value
> - {
> - tree constant;
> - struct ipa_pass_through_data pass_through;
> - struct ipa_ancestor_jf_data ancestor;
> - struct ipa_member_ptr_cst member_cst;
> - };
> -
> /* A jump function for a callsite represents the values passed as actual
> arguments of the callsite. See enum jump_func_type for the various
> types of jump functions supported. */
> ! struct ipa_jump_func
> {
> enum jump_func_type type;
> ! union jump_func_value value;
> };
>
> /* All formal parameters in the program have a cval computed by
> --- 101,128 ----
>
> /* Structure holding a C++ member pointer constant. Holds a pointer to the
> method and delta offset. */
> ! struct GTY(()) ipa_member_ptr_cst
> {
> tree pfn;
> tree delta;
> };
>
> /* A jump function for a callsite represents the values passed as actual
> arguments of the callsite. See enum jump_func_type for the various
> types of jump functions supported. */
> ! struct GTY (()) ipa_jump_func
> {
> enum jump_func_type type;
> ! /* Represents a value of a jump function. pass_through is used only in jump
> ! function context. constant represents the actual constant in constant jump
> ! functions and member_cst holds constant c++ member functions. */
> ! union jump_func_value
> ! {
> ! tree GTY ((tag ("IPA_JF_CONST"))) constant;
> ! struct ipa_pass_through_data GTY ((tag ("IPA_JF_PASS_THROUGH"))) pass_through;
> ! struct ipa_ancestor_jf_data GTY ((tag ("IPA_JF_ANCESTOR"))) ancestor;
> ! struct ipa_member_ptr_cst GTY ((tag ("IPA_JF_CONST_MEMBER_PTR"))) member_cst;
> ! } GTY ((desc ("%1.type"))) value;
> };
>
> /* All formal parameters in the program have a cval computed by
> *************** ipa_is_called_with_var_arguments (struct
> *** 280,294 ****
> /* ipa_edge_args stores information related to a callsite and particularly
> its arguments. It is pointed to by a field in the
> callsite's corresponding cgraph_edge. */
> ! struct ipa_edge_args
> {
> /* Number of actual arguments in this callsite. When set to 0,
> this callsite's parameters would not be analyzed by the different
> stages of IPA CP. */
> int argument_count;
> /* Array of the callsite's jump function of each parameter. */
> ! struct ipa_jump_func *jump_functions;
> ! };
>
> /* ipa_edge_args access functions. Please use these to access fields that
> are or will be shared among various passes. */
> --- 278,292 ----
> /* ipa_edge_args stores information related to a callsite and particularly
> its arguments. It is pointed to by a field in the
> callsite's corresponding cgraph_edge. */
> ! typedef struct GTY(()) ipa_edge_args
> {
> /* Number of actual arguments in this callsite. When set to 0,
> this callsite's parameters would not be analyzed by the different
> stages of IPA CP. */
> int argument_count;
> /* Array of the callsite's jump function of each parameter. */
> ! struct ipa_jump_func GTY ((length ("%h.argument_count"))) *jump_functions;
> ! } ipa_edge_args_t;
>
> /* ipa_edge_args access functions. Please use these to access fields that
> are or will be shared among various passes. */
> *************** ipa_get_ith_jump_func (struct ipa_edge_a
> *** 321,338 ****
>
> /* Vectors need to have typedefs of structures. */
> typedef struct ipa_node_params ipa_node_params_t;
> - typedef struct ipa_edge_args ipa_edge_args_t;
>
> /* Types of vectors holding the infos. */
> DEF_VEC_O (ipa_node_params_t);
> DEF_VEC_ALLOC_O (ipa_node_params_t, heap);
> DEF_VEC_O (ipa_edge_args_t);
> ! DEF_VEC_ALLOC_O (ipa_edge_args_t, heap);
>
> /* Vector where the parameter infos are actually stored. */
> extern VEC (ipa_node_params_t, heap) *ipa_node_params_vector;
> /* Vector where the parameter infos are actually stored. */
> ! extern VEC (ipa_edge_args_t, heap) *ipa_edge_args_vector;
>
> /* Return the associated parameter/argument info corresponding to the given
> node/edge. */
> --- 319,335 ----
>
> /* Vectors need to have typedefs of structures. */
> typedef struct ipa_node_params ipa_node_params_t;
>
> /* Types of vectors holding the infos. */
> DEF_VEC_O (ipa_node_params_t);
> DEF_VEC_ALLOC_O (ipa_node_params_t, heap);
> DEF_VEC_O (ipa_edge_args_t);
> ! DEF_VEC_ALLOC_O (ipa_edge_args_t, gc);
>
> /* Vector where the parameter infos are actually stored. */
> extern VEC (ipa_node_params_t, heap) *ipa_node_params_vector;
> /* Vector where the parameter infos are actually stored. */
> ! extern GTY(()) VEC (ipa_edge_args_t, gc) *ipa_edge_args_vector;
>
> /* Return the associated parameter/argument info corresponding to the given
> node/edge. */
> *************** static inline void
> *** 378,389 ****
> ipa_check_create_edge_args (void)
> {
> if (!ipa_edge_args_vector)
> ! ipa_edge_args_vector = VEC_alloc (ipa_edge_args_t, heap,
> cgraph_edge_max_uid);
>
> if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector)
> <= (unsigned) cgraph_edge_max_uid)
> ! VEC_safe_grow_cleared (ipa_edge_args_t, heap, ipa_edge_args_vector,
> cgraph_edge_max_uid + 1);
> }
>
> --- 375,386 ----
> ipa_check_create_edge_args (void)
> {
> if (!ipa_edge_args_vector)
> ! ipa_edge_args_vector = VEC_alloc (ipa_edge_args_t, gc,
> cgraph_edge_max_uid);
>
> if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector)
> <= (unsigned) cgraph_edge_max_uid)
> ! VEC_safe_grow_cleared (ipa_edge_args_t, gc, ipa_edge_args_vector,
> cgraph_edge_max_uid + 1);
> }
>
> *************** ipa_parm_adjustment_vec ipa_combine_adju
> *** 508,513 ****
> --- 505,514 ----
> ipa_parm_adjustment_vec);
> void ipa_dump_param_adjustments (FILE *, ipa_parm_adjustment_vec, tree);
>
> + void ipa_prop_write_jump_functions (cgraph_node_set set);
> + void ipa_prop_read_jump_functions (void);
> + void ipa_update_after_lto_read (void);
> +
> /* From tree-sra.c: */
> bool build_ref_for_offset (tree *, tree, HOST_WIDE_INT, tree, bool);
>
> Index: Makefile.in
> ===================================================================
> *** Makefile.in (revision 152974)
> --- Makefile.in (working copy)
> *************** GTFILES = $(CPP_ID_DATA_H) $(srcdir)/inp
> *** 3585,3590 ****
> --- 3585,3591 ----
> $(srcdir)/tree-ssa-structalias.c \
> $(srcdir)/lto-symtab.c \
> $(srcdir)/tree-ssa-alias.h \
> + $(srcdir)/ipa-prop.h \
> @all_gtfiles@
>
> # Compute the list of GT header files from the corresponding C sources,
> Index: passes.c
> ===================================================================
> *** passes.c (revision 152974)
> --- passes.c (working copy)
> *************** ipa_write_summaries_1 (cgraph_node_set s
> *** 1618,1624 ****
> struct lto_out_decl_state *state = lto_new_out_decl_state ();
> lto_push_out_decl_state (state);
>
> ! ipa_write_summaries_2 (all_regular_ipa_passes, set, state);
> ipa_write_summaries_2 (all_lto_gen_passes, set, state);
>
> gcc_assert (lto_get_out_decl_state () == state);
> --- 1618,1625 ----
> struct lto_out_decl_state *state = lto_new_out_decl_state ();
> lto_push_out_decl_state (state);
>
> ! if (!flag_wpa)
> ! ipa_write_summaries_2 (all_regular_ipa_passes, set, state);
> ipa_write_summaries_2 (all_lto_gen_passes, set, state);
>
> gcc_assert (lto_get_out_decl_state () == state);
> *************** ipa_read_summaries_1 (struct opt_pass *p
> *** 1712,1718 ****
> void
> ipa_read_summaries (void)
> {
> ! ipa_read_summaries_1 (all_regular_ipa_passes);
> ipa_read_summaries_1 (all_lto_gen_passes);
> }
>
> --- 1713,1720 ----
> void
> ipa_read_summaries (void)
> {
> ! if (!flag_ltrans)
> ! ipa_read_summaries_1 (all_regular_ipa_passes);
> ipa_read_summaries_1 (all_lto_gen_passes);
> }
>
> Index: lto-streamer.c
> ===================================================================
> *** lto-streamer.c (revision 152974)
> --- lto-streamer.c (working copy)
> *************** lto_get_section_name (int section_type,
> *** 157,162 ****
> --- 157,165 ----
> case LTO_section_cgraph:
> return concat (LTO_SECTION_NAME_PREFIX, ".cgraph", NULL);
>
> + case LTO_section_jump_functions:
> + return concat (LTO_SECTION_NAME_PREFIX, ".jmpfuncs", NULL);
> +
> case LTO_section_ipa_pure_const:
> return concat (LTO_SECTION_NAME_PREFIX, ".pureconst", NULL);
>
> Index: lto-streamer.h
> ===================================================================
> *** lto-streamer.h (revision 152974)
> --- lto-streamer.h (working copy)
> *************** enum lto_section_type
> *** 256,261 ****
> --- 256,262 ----
> LTO_section_function_body,
> LTO_section_static_initializer,
> LTO_section_cgraph,
> + LTO_section_jump_functions,
> LTO_section_ipa_pure_const,
> LTO_section_ipa_reference,
> LTO_section_symtab,
> *************** extern struct output_block *create_outpu
> *** 827,832 ****
> --- 828,834 ----
> extern void destroy_output_block (struct output_block *);
> extern void lto_output_tree (struct output_block *, tree, bool);
> extern void lto_output_bitpack (struct lto_output_stream *, struct bitpack_d *);
> + extern void produce_asm (struct output_block *ob, tree fn);
>
>
> /* In lto-cgraph.c */