#include "gcov-io.h"
static void output_varpool (cgraph_node_set, varpool_node_set);
+static void output_cgraph_opt_summary (void);
+static void input_cgraph_opt_summary (VEC (cgraph_node_ptr, heap) * nodes);
+
/* Cgraph streaming is organized as set of record whose type
is indicated by a tag. */
lto_cgraph_encoder_t encoder = XCNEW (struct lto_cgraph_encoder_d);
encoder->map = pointer_map_create ();
encoder->nodes = NULL;
+ encoder->body = pointer_set_create ();
return encoder;
}
{
VEC_free (cgraph_node_ptr, heap, encoder->nodes);
pointer_map_destroy (encoder->map);
+ pointer_set_destroy (encoder->body);
free (encoder);
}
}
-/* Return number of encoded nodes in ENCODER. */
+/* Return TRUE if we should encode initializer of NODE (if any). */
-static int
-lto_cgraph_encoder_size (lto_cgraph_encoder_t encoder)
+bool
+lto_cgraph_encoder_encode_body_p (lto_cgraph_encoder_t encoder,
+ struct cgraph_node *node)
{
- return VEC_length (cgraph_node_ptr, encoder->nodes);
+ return pointer_set_contains (encoder->body, node);
+}
+
+/* Return TRUE if we should encode body of NODE (if any). */
+
+static void
+lto_set_cgraph_encoder_encode_body (lto_cgraph_encoder_t encoder,
+ struct cgraph_node *node)
+{
+ pointer_set_insert (encoder->body, node);
}
/* Create a new varpool encoder. */
bp_pack_value (bp, edge->indirect_inlining_edge, 1);
bp_pack_value (bp, edge->call_stmt_cannot_inline_p, 1);
bp_pack_value (bp, edge->can_throw_external, 1);
+ if (edge->indirect_unknown_callee)
+ {
+ int flags = edge->indirect_info->ecf_flags;
+ bp_pack_value (bp, (flags & ECF_CONST) != 0, 1);
+ bp_pack_value (bp, (flags & ECF_PURE) != 0, 1);
+ bp_pack_value (bp, (flags & ECF_NORETURN) != 0, 1);
+ bp_pack_value (bp, (flags & ECF_MALLOC) != 0, 1);
+ bp_pack_value (bp, (flags & ECF_NOTHROW) != 0, 1);
+ bp_pack_value (bp, (flags & ECF_RETURNS_TWICE) != 0, 1);
+ /* Flags that should not appear on indirect calls. */
+ gcc_assert (!(flags & (ECF_LOOPING_CONST_OR_PURE
+ | ECF_MAY_BE_ALLOCA
+ | ECF_SIBCALL
+ | ECF_NOVOPS)));
+ }
lto_output_bitpack (ob->main_stream, bp);
bitpack_delete (bp);
}
/* Return if LIST contain references from other partitions. */
+
bool
referenced_from_other_partition_p (struct ipa_ref_list *list, cgraph_node_set set,
varpool_node_set vset)
return false;
}
+/* Return if LIST contain references from other partitions. */
+
+bool
+referenced_from_this_partition_p (struct ipa_ref_list *list, cgraph_node_set set,
+ varpool_node_set vset)
+{
+ int i;
+ struct ipa_ref *ref;
+ for (i = 0; ipa_ref_list_refering_iterate (list, i, ref); i++)
+ {
+ if (ref->refering_type == IPA_REF_CGRAPH)
+ {
+ if (cgraph_node_in_set_p (ipa_ref_refering_node (ref), set))
+ return true;
+ }
+ else
+ {
+ if (varpool_node_in_set_p (ipa_ref_refering_varpool_node (ref),
+ vset))
+ return true;
+ }
+ }
+ return false;
+}
+
+/* Return true when node is reachable from other partition. */
+
+bool
+reachable_from_this_partition_p (struct cgraph_node *node, cgraph_node_set set)
+{
+ struct cgraph_edge *e;
+ if (!node->analyzed)
+ return false;
+ if (node->global.inlined_to)
+ return false;
+ for (e = node->callers; e; e = e->next_caller)
+ if (cgraph_node_in_set_p (e->caller, set))
+ return true;
+ return false;
+}
+
/* Output the cgraph NODE to OB. ENCODER is used to find the
reference number of NODE->inlined_to. SET is the set of nodes we
are writing to the current file. If NODE is not in SET, then NODE
static void
lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
lto_cgraph_encoder_t encoder, cgraph_node_set set,
- varpool_node_set vset,
- bitmap written_decls)
+ varpool_node_set vset)
{
unsigned int tag;
struct bitpack_d *bp;
- bool boundary_p, wrote_decl_p;
+ bool boundary_p;
intptr_t ref;
bool in_other_partition = false;
+ struct cgraph_node *clone_of;
boundary_p = !cgraph_node_in_set_p (node, set);
- wrote_decl_p = bitmap_bit_p (written_decls, DECL_UID (node->decl));
if (node->analyzed && !boundary_p)
tag = LTO_cgraph_analyzed_node;
in_other_partition = 1;
}
- lto_output_uleb128_stream (ob->main_stream, wrote_decl_p);
+ clone_of = node->clone_of;
+ while (clone_of
+ && (ref = lto_cgraph_encoder_lookup (encoder, node->clone_of)) == LCC_NOT_FOUND)
+ if (clone_of->prev_sibling_clone)
+ clone_of = clone_of->prev_sibling_clone;
+ else
+ clone_of = clone_of->clone_of;
+ if (!clone_of)
+ lto_output_sleb128_stream (ob->main_stream, LCC_NOT_FOUND);
+ else
+ lto_output_sleb128_stream (ob->main_stream, ref);
- if (!wrote_decl_p)
- bitmap_set_bit (written_decls, DECL_UID (node->decl));
lto_output_fn_decl_index (ob->decl_state, ob->main_stream, node->decl);
lto_output_sleb128_stream (ob->main_stream, node->count);
bp_pack_value (bp, node->local.externally_visible, 1);
bp_pack_value (bp, node->local.finalized, 1);
bp_pack_value (bp, node->local.inlinable, 1);
+ bp_pack_value (bp, node->local.versionable, 1);
bp_pack_value (bp, node->local.disregard_inline_limits, 1);
bp_pack_value (bp, node->local.redefined_extern_inline, 1);
bp_pack_value (bp, node->local.vtable_method, 1);
/* Add NODE into encoder as well as nodes it is cloned from.
Do it in a way so clones appear first. */
+
static void
-add_node_to (lto_cgraph_encoder_t encoder, struct cgraph_node *node)
+add_node_to (lto_cgraph_encoder_t encoder, struct cgraph_node *node,
+ bool include_body)
{
if (node->clone_of)
- add_node_to (encoder, node->clone_of);
+ add_node_to (encoder, node->clone_of, include_body);
+ else if (include_body)
+ lto_set_cgraph_encoder_encode_body (encoder, node);
lto_cgraph_encoder_encode (encoder, node);
}
struct ipa_ref *ref;
for (i = 0; ipa_ref_list_reference_iterate (list, i, ref); i++)
if (ref->refered_type == IPA_REF_CGRAPH)
- add_node_to (encoder, ipa_ref_node (ref));
+ add_node_to (encoder, ipa_ref_node (ref), false);
else
{
struct varpool_node *vnode = ipa_ref_varpool_node (ref);
lto_destroy_simple_output_block (ob);
}
-
-/* Output the part of the cgraph in SET. */
-
+/* Find out all cgraph and varpool nodes we want to encode in current unit
+ and insert them to encoders. */
void
-output_cgraph (cgraph_node_set set, varpool_node_set vset)
+compute_ltrans_boundary (struct lto_out_decl_state *state,
+ cgraph_node_set set, varpool_node_set vset)
{
struct cgraph_node *node;
- struct lto_simple_output_block *ob;
cgraph_node_set_iterator csi;
varpool_node_set_iterator vsi;
struct cgraph_edge *edge;
- int i, n_nodes;
- bitmap written_decls;
+ int i;
lto_cgraph_encoder_t encoder;
lto_varpool_encoder_t varpool_encoder;
- struct cgraph_asm_node *can;
-
- ob = lto_create_simple_output_block (LTO_section_cgraph);
-
- output_profile_summary (ob);
-
- /* An encoder for cgraph nodes should have been created by
- ipa_write_summaries_1. */
- gcc_assert (ob->decl_state->cgraph_node_encoder);
- gcc_assert (ob->decl_state->varpool_node_encoder);
- encoder = ob->decl_state->cgraph_node_encoder;
- varpool_encoder = ob->decl_state->varpool_node_encoder;
- /* The FUNCTION_DECLs for which we have written a node. The first
- node found is written as the "original" node, the remaining nodes
- are considered its clones. */
- written_decls = lto_bitmap_alloc ();
+ encoder = state->cgraph_node_encoder = lto_cgraph_encoder_new ();
+ varpool_encoder = state->varpool_node_encoder = lto_varpool_encoder_new ();
/* Go over all the nodes in SET and assign references. */
for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
{
node = csi_node (csi);
- add_node_to (encoder, node);
+ add_node_to (encoder, node, true);
add_references (encoder, varpool_encoder, &node->ref_list);
}
for (vsi = vsi_start (vset); !vsi_end_p (vsi); vsi_next (&vsi))
{
/* We should have moved all the inlines. */
gcc_assert (!callee->global.inlined_to);
- add_node_to (encoder, callee);
+ add_node_to (encoder, callee, false);
}
}
}
+}
+
+/* Output the part of the cgraph in SET. */
+
+void
+output_cgraph (cgraph_node_set set, varpool_node_set vset)
+{
+ struct cgraph_node *node;
+ struct lto_simple_output_block *ob;
+ cgraph_node_set_iterator csi;
+ int i, n_nodes;
+ lto_cgraph_encoder_t encoder;
+ lto_varpool_encoder_t varpool_encoder;
+ struct cgraph_asm_node *can;
+
+ if (flag_wpa)
+ output_cgraph_opt_summary ();
+
+ ob = lto_create_simple_output_block (LTO_section_cgraph);
+
+ output_profile_summary (ob);
+
+ /* An encoder for cgraph nodes should have been created by
+ ipa_write_summaries_1. */
+ gcc_assert (ob->decl_state->cgraph_node_encoder);
+ gcc_assert (ob->decl_state->varpool_node_encoder);
+ encoder = ob->decl_state->cgraph_node_encoder;
+ varpool_encoder = ob->decl_state->varpool_node_encoder;
/* Write out the nodes. We must first output a node and then its clones,
otherwise at a time reading back the node there would be nothing to clone
for (i = 0; i < n_nodes; i++)
{
node = lto_cgraph_encoder_deref (encoder, i);
- lto_output_node (ob, node, encoder, set, vset, written_decls);
+ lto_output_node (ob, node, encoder, set, vset);
}
- lto_bitmap_free (written_decls);
-
/* Go over the nodes in SET again to write edges. */
for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
{
node->local.externally_visible = bp_unpack_value (bp, 1);
node->local.finalized = bp_unpack_value (bp, 1);
node->local.inlinable = bp_unpack_value (bp, 1);
+ node->local.versionable = bp_unpack_value (bp, 1);
node->local.disregard_inline_limits = bp_unpack_value (bp, 1);
node->local.redefined_extern_inline = bp_unpack_value (bp, 1);
node->local.vtable_method = bp_unpack_value (bp, 1);
static struct cgraph_node *
input_node (struct lto_file_decl_data *file_data,
struct lto_input_block *ib,
- enum LTO_cgraph_tags tag)
+ enum LTO_cgraph_tags tag,
+ VEC(cgraph_node_ptr, heap) *nodes)
{
tree fn_decl;
struct cgraph_node *node;
struct bitpack_d *bp;
int stack_size = 0;
unsigned decl_index;
- bool clone_p;
int ref = LCC_NOT_FOUND, ref2 = LCC_NOT_FOUND;
int self_time = 0;
int self_size = 0;
int time_inlining_benefit = 0;
int size_inlining_benefit = 0;
unsigned long same_body_count = 0;
+ int clone_ref;
- clone_p = (lto_input_uleb128 (ib) != 0);
+ clone_ref = lto_input_sleb128 (ib);
decl_index = lto_input_uleb128 (ib);
fn_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
- if (clone_p)
- node = cgraph_clone_node (cgraph_node (fn_decl), 0,
- CGRAPH_FREQ_BASE, 0, false, NULL);
-
+ if (clone_ref != LCC_NOT_FOUND)
+ {
+ node = cgraph_clone_node (VEC_index (cgraph_node_ptr, nodes, clone_ref), fn_decl,
+ 0, CGRAPH_FREQ_BASE, 0, false, NULL);
+ }
else
node = cgraph_node (fn_decl);
cgraph_inline_failed_t inline_failed;
struct bitpack_d *bp;
enum ld_plugin_symbol_resolution caller_resolution;
+ int ecf_flags = 0;
caller = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
if (caller == NULL || caller->decl == NULL_TREE)
return;
if (indirect)
- edge = cgraph_create_indirect_edge (caller, NULL, count, freq, nest);
+ edge = cgraph_create_indirect_edge (caller, NULL, 0, count, freq, nest);
else
edge = cgraph_create_edge (caller, callee, NULL, count, freq, nest);
edge->inline_failed = inline_failed;
edge->call_stmt_cannot_inline_p = bp_unpack_value (bp, 1);
edge->can_throw_external = bp_unpack_value (bp, 1);
+ if (indirect)
+ {
+ if (bp_unpack_value (bp, 1))
+ ecf_flags |= ECF_CONST;
+ if (bp_unpack_value (bp, 1))
+ ecf_flags |= ECF_PURE;
+ if (bp_unpack_value (bp, 1))
+ ecf_flags |= ECF_NORETURN;
+ if (bp_unpack_value (bp, 1))
+ ecf_flags |= ECF_MALLOC;
+ if (bp_unpack_value (bp, 1))
+ ecf_flags |= ECF_NOTHROW;
+ if (bp_unpack_value (bp, 1))
+ ecf_flags |= ECF_RETURNS_TWICE;
+ edge->indirect_info->ecf_flags = ecf_flags;
+ }
bitpack_delete (bp);
}
input_edge (ib, nodes, true);
else
{
- node = input_node (file_data, ib, tag);
+ node = input_node (file_data, ib, tag,nodes);
if (node == NULL || node->decl == NULL_TREE)
internal_error ("bytecode stream: found empty cgraph node");
VEC_safe_push (cgraph_node_ptr, heap, nodes, node);
input_refs (ib, nodes, varpool);
lto_destroy_simple_input_block (file_data, LTO_section_refs,
ib, data, len);
+ if (flag_ltrans)
+ input_cgraph_opt_summary (nodes);
VEC_free (cgraph_node_ptr, heap, nodes);
VEC_free (varpool_node_ptr, heap, varpool);
}
node->aux = NULL;
}
}
+
+/* True when we need optimization summary for NODE. */
+
+static int
+output_cgraph_opt_summary_p (struct cgraph_node *node)
+{
+ if (!node->clone_of)
+ return false;
+ return (node->clone.tree_map
+ || node->clone.args_to_skip
+ || node->clone.combined_args_to_skip);
+}
+
+/* Output optimization summary for NODE to OB. */
+
+static void
+output_node_opt_summary (struct output_block *ob,
+ struct cgraph_node *node)
+{
+ unsigned int index;
+ bitmap_iterator bi;
+ struct ipa_replace_map *map;
+ struct bitpack_d *bp;
+ int i;
+
+ lto_output_uleb128_stream (ob->main_stream,
+ bitmap_count_bits (node->clone.args_to_skip));
+ EXECUTE_IF_SET_IN_BITMAP (node->clone.args_to_skip, 0, index, bi)
+ lto_output_uleb128_stream (ob->main_stream, index);
+ lto_output_uleb128_stream (ob->main_stream,
+ bitmap_count_bits (node->clone.combined_args_to_skip));
+ EXECUTE_IF_SET_IN_BITMAP (node->clone.combined_args_to_skip, 0, index, bi)
+ lto_output_uleb128_stream (ob->main_stream, index);
+ lto_output_uleb128_stream (ob->main_stream,
+ VEC_length (ipa_replace_map_p, node->clone.tree_map));
+ for (i = 0; VEC_iterate (ipa_replace_map_p, node->clone.tree_map, i, map); i++)
+ {
+ int parm_num;
+ tree parm;
+
+ for (parm_num = 0, parm = DECL_ARGUMENTS (node->decl); parm;
+ parm = TREE_CHAIN (parm), parm_num++)
+ if (map->old_tree == parm)
+ break;
+ /* At the moment we assume all old trees to be PARM_DECLs, because we have no
+ mechanism to store function local declarations into summaries. */
+ gcc_assert (parm);
+ lto_output_uleb128_stream (ob->main_stream, parm_num);
+ lto_output_tree (ob, map->new_tree, true);
+ bp = bitpack_create ();
+ bp_pack_value (bp, map->replace_p, 1);
+ bp_pack_value (bp, map->ref_p, 1);
+ lto_output_bitpack (ob->main_stream, bp);
+ bitpack_delete (bp);
+ }
+}
+
+/* Output optimization summaries stored in callgraph.
+ At the moment it is the clone info structure. */
+
+static void
+output_cgraph_opt_summary (void)
+{
+ struct cgraph_node *node;
+ int i, n_nodes;
+ lto_cgraph_encoder_t encoder;
+ struct output_block *ob = create_output_block (LTO_section_cgraph_opt_sum);
+ unsigned count = 0;
+
+ ob->cgraph_node = NULL;
+ encoder = ob->decl_state->cgraph_node_encoder;
+ n_nodes = lto_cgraph_encoder_size (encoder);
+ for (i = 0; i < n_nodes; i++)
+ if (output_cgraph_opt_summary_p (lto_cgraph_encoder_deref (encoder, i)))
+ count++;
+ lto_output_uleb128_stream (ob->main_stream, count);
+ for (i = 0; i < n_nodes; i++)
+ {
+ node = lto_cgraph_encoder_deref (encoder, i);
+ if (output_cgraph_opt_summary_p (node))
+ {
+ lto_output_uleb128_stream (ob->main_stream, i);
+ output_node_opt_summary (ob, node);
+ }
+ }
+ produce_asm (ob, NULL);
+ destroy_output_block (ob);
+}
+
+/* Input optimiation summary of NODE. */
+
+static void
+input_node_opt_summary (struct cgraph_node *node,
+ struct lto_input_block *ib_main,
+ struct data_in *data_in)
+{
+ int i;
+ int count;
+ int bit;
+ struct bitpack_d *bp;
+
+ count = lto_input_uleb128 (ib_main);
+ if (count)
+ node->clone.args_to_skip = BITMAP_GGC_ALLOC ();
+ for (i = 0; i < count; i++)
+ {
+ bit = lto_input_uleb128 (ib_main);
+ bitmap_set_bit (node->clone.args_to_skip, bit);
+ }
+ count = lto_input_uleb128 (ib_main);
+ if (count)
+ node->clone.combined_args_to_skip = BITMAP_GGC_ALLOC ();
+ for (i = 0; i < count; i++)
+ {
+ bit = lto_input_uleb128 (ib_main);
+ bitmap_set_bit (node->clone.combined_args_to_skip, bit);
+ }
+ count = lto_input_uleb128 (ib_main);
+ for (i = 0; i < count; i++)
+ {
+ int parm_num;
+ tree parm;
+ struct ipa_replace_map *map = GGC_NEW (struct ipa_replace_map);
+
+ VEC_safe_push (ipa_replace_map_p, gc, node->clone.tree_map, map);
+ for (parm_num = 0, parm = DECL_ARGUMENTS (node->decl); parm_num;
+ parm = TREE_CHAIN (parm))
+ parm_num --;
+ map->parm_num = lto_input_uleb128 (ib_main);
+ map->old_tree = NULL;
+ map->new_tree = lto_input_tree (ib_main, data_in);
+ bp = lto_input_bitpack (ib_main);
+ map->replace_p = bp_unpack_value (bp, 1);
+ map->ref_p = bp_unpack_value (bp, 1);
+ bitpack_delete (bp);
+ }
+}
+
+/* Read section in file FILE_DATA of length LEN with data DATA. */
+
+static void
+input_cgraph_opt_section (struct lto_file_decl_data *file_data,
+ const char *data, size_t len, VEC (cgraph_node_ptr,
+ heap) * nodes)
+{
+ 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++)
+ {
+ int ref = lto_input_uleb128 (&ib_main);
+ input_node_opt_summary (VEC_index (cgraph_node_ptr, nodes, ref),
+ &ib_main, data_in);
+ }
+ lto_free_section_data (file_data, LTO_section_jump_functions, NULL, data,
+ len);
+ lto_data_in_delete (data_in);
+}
+
+/* Input optimization summary of cgraph. */
+
+static void
+input_cgraph_opt_summary (VEC (cgraph_node_ptr, heap) * nodes)
+{
+ struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
+ struct lto_file_decl_data *file_data;
+ unsigned int j = 0;
+
+ while ((file_data = file_data_vec[j++]))
+ {
+ size_t len;
+ const char *data =
+ lto_get_section_data (file_data, LTO_section_cgraph_opt_sum, NULL,
+ &len);
+
+ if (data)
+ input_cgraph_opt_section (file_data, data, len, nodes);
+ }
+}
OSDN Git Service
