#include "lto-streamer.h"
#include "gcov-io.h"
-static void output_varpool (cgraph_node_set, varpool_node_set);
-
/* Cgraph streaming is organized as set of record whose type
is indicated by a tag. */
enum LTO_cgraph_tags
return VEC_length (cgraph_node_ptr, encoder->nodes);
}
-/* Create a new varpool encoder. */
-
-lto_varpool_encoder_t
-lto_varpool_encoder_new (void)
-{
- lto_varpool_encoder_t encoder = XCNEW (struct lto_varpool_encoder_d);
- encoder->map = pointer_map_create ();
- encoder->initializer = pointer_set_create ();
- encoder->nodes = NULL;
- return encoder;
-}
-
-
-/* Delete ENCODER and its components. */
-
-void
-lto_varpool_encoder_delete (lto_varpool_encoder_t encoder)
-{
- VEC_free (varpool_node_ptr, heap, encoder->nodes);
- pointer_map_destroy (encoder->map);
- pointer_set_destroy (encoder->initializer);
- free (encoder);
-}
-
-
-/* Return the existing reference number of NODE in the varpool encoder in
- output block OB. Assign a new reference if this is the first time
- NODE is encoded. */
-
-int
-lto_varpool_encoder_encode (lto_varpool_encoder_t encoder,
- struct varpool_node *node)
-{
- int ref;
- void **slot;
-
- slot = pointer_map_contains (encoder->map, node);
- if (!slot)
- {
- ref = VEC_length (varpool_node_ptr, encoder->nodes);
- slot = pointer_map_insert (encoder->map, node);
- *slot = (void *) (intptr_t) ref;
- VEC_safe_push (varpool_node_ptr, heap, encoder->nodes, node);
- }
- else
- ref = (int) (intptr_t) *slot;
-
- return ref;
-}
-
-/* Look up NODE in encoder. Return NODE's reference if it has been encoded
- or LCC_NOT_FOUND if it is not there. */
-
-int
-lto_varpool_encoder_lookup (lto_varpool_encoder_t encoder,
- struct varpool_node *node)
-{
- void **slot = pointer_map_contains (encoder->map, node);
- return (slot ? (int) (intptr_t) *slot : LCC_NOT_FOUND);
-}
-
-
-/* Return the varpool node corresponding to REF using ENCODER. */
-
-struct varpool_node *
-lto_varpool_encoder_deref (lto_varpool_encoder_t encoder, int ref)
-{
- if (ref == LCC_NOT_FOUND)
- return NULL;
-
- return VEC_index (varpool_node_ptr, encoder->nodes, ref);
-}
-
-
-/* Return number of encoded nodes in ENCODER. */
-
-static int
-lto_varpool_encoder_size (lto_varpool_encoder_t encoder)
-{
- return VEC_length (varpool_node_ptr, encoder->nodes);
-}
-
-/* Return TRUE if we should encode initializer of NODE (if any). */
-
-bool
-lto_varpool_encoder_encode_initializer_p (lto_varpool_encoder_t encoder,
- struct varpool_node *node)
-{
- return pointer_set_contains (encoder->initializer, node);
-}
-
-/* Return TRUE if we should encode initializer of NODE (if any). */
-
-static void
-lto_set_varpool_encoder_encode_initializer (lto_varpool_encoder_t encoder,
- struct varpool_node *node)
-{
- pointer_set_insert (encoder->initializer, node);
-}
/* Output the cgraph EDGE to OB using ENCODER. */
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)
-{
- 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. */
static bool
static void
lto_output_varpool_node (struct lto_simple_output_block *ob, struct varpool_node *node,
- cgraph_node_set set, varpool_node_set vset)
+ varpool_node_set set)
{
- bool boundary_p = !varpool_node_in_set_p (node, vset) && node->analyzed;
+ bool boundary_p = !varpool_node_in_set_p (node, set) && node->analyzed;
struct bitpack_d *bp;
struct varpool_node *alias;
int count = 0;
bp_pack_value (bp, node->externally_visible, 1);
bp_pack_value (bp, node->force_output, 1);
bp_pack_value (bp, node->finalized, 1);
- bp_pack_value (bp, node->alias, 1);
- gcc_assert (!node->alias || !node->extra_name);
gcc_assert (node->finalized || !node->analyzed);
gcc_assert (node->needed);
+ gcc_assert (!node->alias);
/* Constant pool initializers can be de-unified into individual ltrans units.
FIXME: Alternatively at -Os we may want to avoid generating for them the local
labels and share them across LTRANS partitions. */
}
else
{
- bp_pack_value (bp, node->analyzed
- && referenced_from_other_partition_p (&node->ref_list,
- set, vset), 1);
+ /* FIXME: We have no idea how we move references around. For moment assume that
+ everything is used externally. */
+ bp_pack_value (bp, flag_wpa, 1); /* used_from_other_parition. */
bp_pack_value (bp, boundary_p, 1); /* in_other_partition. */
}
/* Also emit any extra name aliases. */
}
}
-/* Output the varpool NODE to OB.
- If NODE is not in SET, then NODE is a boundary. */
-
-static void
-lto_output_ref (struct lto_simple_output_block *ob, struct ipa_ref *ref,
- lto_cgraph_encoder_t encoder,
- lto_varpool_encoder_t varpool_encoder)
-{
- struct bitpack_d *bp = bitpack_create ();
- bp_pack_value (bp, ref->refered_type, 1);
- bp_pack_value (bp, ref->use, 2);
- lto_output_bitpack (ob->main_stream, bp);
- bitpack_delete (bp);
- if (ref->refered_type == IPA_REF_CGRAPH)
- {
- int nref = lto_cgraph_encoder_lookup (encoder, ipa_ref_node (ref));
- gcc_assert (nref != LCC_NOT_FOUND);
- lto_output_sleb128_stream (ob->main_stream, nref);
- }
- else
- {
- int nref = lto_varpool_encoder_lookup (varpool_encoder,
- ipa_ref_varpool_node (ref));
- gcc_assert (nref != LCC_NOT_FOUND);
- lto_output_sleb128_stream (ob->main_stream, nref);
- }
-}
-
/* Stream out profile_summary to OB. */
static void
lto_cgraph_encoder_encode (encoder, node);
}
-/* Add all references in LIST to encoders. */
-
-static void
-add_references (lto_cgraph_encoder_t encoder,
- lto_varpool_encoder_t varpool_encoder,
- struct ipa_ref_list *list)
-{
- int i;
- 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));
- else
- {
- struct varpool_node *vnode = ipa_ref_varpool_node (ref);
- lto_varpool_encoder_encode (varpool_encoder, vnode);
- }
-}
-
/* Output all callees or indirect outgoing edges. EDGE must be the first such
edge. */
/* Output the part of the cgraph in SET. */
-static void
-output_refs (cgraph_node_set set, varpool_node_set vset,
- lto_cgraph_encoder_t encoder,
- lto_varpool_encoder_t varpool_encoder)
-{
- cgraph_node_set_iterator csi;
- varpool_node_set_iterator vsi;
- struct lto_simple_output_block *ob;
- int count;
- struct ipa_ref *ref;
- int i;
-
- ob = lto_create_simple_output_block (LTO_section_refs);
-
- for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
- {
- struct cgraph_node *node = csi_node (csi);
-
- count = ipa_ref_list_nreferences (&node->ref_list);
- if (count)
- {
- lto_output_uleb128_stream (ob->main_stream, count);
- lto_output_uleb128_stream (ob->main_stream,
- lto_cgraph_encoder_lookup (encoder, node));
- for (i = 0; ipa_ref_list_reference_iterate (&node->ref_list, i, ref); i++)
- lto_output_ref (ob, ref, encoder, varpool_encoder);
- }
- }
-
- lto_output_uleb128_stream (ob->main_stream, 0);
-
- for (vsi = vsi_start (vset); !vsi_end_p (vsi); vsi_next (&vsi))
- {
- struct varpool_node *node = vsi_node (vsi);
-
- count = ipa_ref_list_nreferences (&node->ref_list);
- if (count)
- {
- lto_output_uleb128_stream (ob->main_stream, count);
- lto_output_uleb128_stream (ob->main_stream,
- lto_varpool_encoder_lookup (varpool_encoder,
- node));
- for (i = 0; ipa_ref_list_reference_iterate (&node->ref_list, i, ref); i++)
- lto_output_ref (ob, ref, encoder, varpool_encoder);
- }
- }
-
- lto_output_uleb128_stream (ob->main_stream, 0);
-
- lto_destroy_simple_output_block (ob);
-}
-
-
-/* Output the part of the cgraph in SET. */
-
void
-output_cgraph (cgraph_node_set set, varpool_node_set vset)
+output_cgraph (cgraph_node_set set)
{
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;
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);
/* 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
{
node = csi_node (csi);
add_node_to (encoder, node);
- add_references (encoder, varpool_encoder, &node->ref_list);
- }
- for (vsi = vsi_start (vset); !vsi_end_p (vsi); vsi_next (&vsi))
- {
- struct varpool_node *vnode = vsi_node (vsi);
- gcc_assert (!vnode->alias);
- lto_varpool_encoder_encode (varpool_encoder, vnode);
- lto_set_varpool_encoder_encode_initializer (varpool_encoder, vnode);
- add_references (encoder, varpool_encoder, &vnode->ref_list);
- }
- /* Pickle in also the initializer of all referenced readonly variables
- to help folding. Constant pool variables are not shared, so we must
- pickle those too. */
- for (i = 0; i < lto_varpool_encoder_size (varpool_encoder); i++)
- {
- struct varpool_node *vnode = lto_varpool_encoder_deref (varpool_encoder, i);
- if (DECL_INITIAL (vnode->decl)
- && !lto_varpool_encoder_encode_initializer_p (varpool_encoder,
- vnode)
- && (DECL_IN_CONSTANT_POOL (vnode->decl)
- || TREE_READONLY (vnode->decl)))
- {
- lto_set_varpool_encoder_encode_initializer (varpool_encoder, vnode);
- add_references (encoder, varpool_encoder, &vnode->ref_list);
- }
}
/* Go over all the nodes again to include callees that are not in
lto_output_uleb128_stream (ob->main_stream, 0);
lto_destroy_simple_output_block (ob);
- output_varpool (set, vset);
- output_refs (set, vset, encoder, varpool_encoder);
}
/* Overwrite the information in NODE based on FILE_DATA, TAG, FLAGS,
/* Output the part of the cgraph in SET. */
-static void
-output_varpool (cgraph_node_set set, varpool_node_set vset)
+void
+output_varpool (varpool_node_set set)
{
- struct lto_simple_output_block *ob = lto_create_simple_output_block (LTO_section_varpool);
- lto_varpool_encoder_t varpool_encoder = ob->decl_state->varpool_node_encoder;
- int len = lto_varpool_encoder_size (varpool_encoder), i;
+ struct varpool_node *node;
+ struct lto_simple_output_block *ob;
+ int len = 0;
+
+ ob = lto_create_simple_output_block (LTO_section_varpool);
+
+ for (node = varpool_nodes; node; node = node->next)
+ if (node->needed && node->analyzed)
+ len++;
lto_output_uleb128_stream (ob->main_stream, len);
/* 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
from. */
- for (i = 0; i < len; i++)
- {
- lto_output_varpool_node (ob, lto_varpool_encoder_deref (varpool_encoder, i),
- set, vset);
- }
+ for (node = varpool_nodes; node; node = node->next)
+ if (node->needed && node->analyzed)
+ lto_output_varpool_node (ob, node, set);
lto_destroy_simple_output_block (ob);
}
node->externally_visible = bp_unpack_value (bp, 1);
node->force_output = bp_unpack_value (bp, 1);
node->finalized = bp_unpack_value (bp, 1);
- node->alias = bp_unpack_value (bp, 1);
- node->analyzed = node->finalized;
+ node->analyzed = 1;
node->used_from_other_partition = bp_unpack_value (bp, 1);
node->in_other_partition = bp_unpack_value (bp, 1);
aliases_p = bp_unpack_value (bp, 1);
return node;
}
-/* Read a node from input_block IB. TAG is the node's tag just read.
- Return the node read or overwriten. */
-
-static void
-input_ref (struct lto_input_block *ib,
- struct cgraph_node *refering_node,
- struct varpool_node *refering_varpool_node,
- VEC(cgraph_node_ptr, heap) *nodes,
- VEC(varpool_node_ptr, heap) *varpool_nodes)
-{
- struct cgraph_node *node = NULL;
- struct varpool_node *varpool_node = NULL;
- struct bitpack_d *bp;
- enum ipa_ref_type type;
- enum ipa_ref_use use;
-
- bp = lto_input_bitpack (ib);
- type = (enum ipa_ref_type) bp_unpack_value (bp, 1);
- use = (enum ipa_ref_use) bp_unpack_value (bp, 2);
- bitpack_delete (bp);
- if (type == IPA_REF_CGRAPH)
- node = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
- else
- varpool_node = VEC_index (varpool_node_ptr, varpool_nodes, lto_input_sleb128 (ib));
- ipa_record_reference (refering_node, refering_varpool_node,
- node, varpool_node, use, NULL);
-}
/* Read an edge from IB. NODES points to a vector of previously read nodes for
decoding caller and callee of the edge to be read. If INDIRECT is true, the
/* Read a cgraph from IB using the info in FILE_DATA. */
-static VEC(cgraph_node_ptr, heap) *
+static void
input_cgraph_1 (struct lto_file_decl_data *file_data,
struct lto_input_block *ib)
{
else
node->same_comdat_group = NULL;
}
- return nodes;
+
+ VEC_free (cgraph_node_ptr, heap, nodes);
}
/* Read a varpool from IB using the info in FILE_DATA. */
-static VEC(varpool_node_ptr, heap) *
+static void
input_varpool_1 (struct lto_file_decl_data *file_data,
struct lto_input_block *ib)
{
unsigned HOST_WIDE_INT len;
- VEC(varpool_node_ptr, heap) *varpool = NULL;
len = lto_input_uleb128 (ib);
while (len)
{
- VEC_safe_push (varpool_node_ptr, heap, varpool,
- input_varpool_node (file_data, ib));
+ input_varpool_node (file_data, ib);
len--;
}
- return varpool;
-}
-
-/* Input ipa_refs. */
-
-static void
-input_refs (struct lto_input_block *ib,
- VEC(cgraph_node_ptr, heap) *nodes,
- VEC(varpool_node_ptr, heap) *varpool)
-{
- int count;
- int idx;
- while (true)
- {
- struct cgraph_node *node;
- count = lto_input_uleb128 (ib);
- if (!count)
- break;
- idx = lto_input_uleb128 (ib);
- node = VEC_index (cgraph_node_ptr, nodes, idx);
- while (count)
- {
- input_ref (ib, node, NULL, nodes, varpool);
- count--;
- }
- }
- while (true)
- {
- struct varpool_node *node;
- count = lto_input_uleb128 (ib);
- if (!count)
- break;
- node = VEC_index (varpool_node_ptr, varpool, lto_input_uleb128 (ib));
- while (count)
- {
- input_ref (ib, NULL, node, nodes, varpool);
- count--;
- }
- }
}
-
static struct gcov_ctr_summary lto_gcov_summary;
const char *data;
size_t len;
struct lto_input_block *ib;
- VEC(cgraph_node_ptr, heap) *nodes;
- VEC(varpool_node_ptr, heap) *varpool;
ib = lto_create_simple_input_block (file_data, LTO_section_cgraph,
&data, &len);
input_profile_summary (ib);
file_data->cgraph_node_encoder = lto_cgraph_encoder_new ();
- nodes = input_cgraph_1 (file_data, ib);
+ input_cgraph_1 (file_data, ib);
lto_destroy_simple_input_block (file_data, LTO_section_cgraph,
ib, data, len);
ib = lto_create_simple_input_block (file_data, LTO_section_varpool,
&data, &len);
- varpool = input_varpool_1 (file_data, ib);
+ input_varpool_1 (file_data, ib);
lto_destroy_simple_input_block (file_data, LTO_section_varpool,
ib, data, len);
- ib = lto_create_simple_input_block (file_data, LTO_section_refs,
- &data, &len);
- input_refs (ib, nodes, varpool);
- lto_destroy_simple_input_block (file_data, LTO_section_refs,
- ib, data, len);
- VEC_free (cgraph_node_ptr, heap, nodes);
- VEC_free (varpool_node_ptr, heap, varpool);
+ /* Assume that every file read needs to be processed by LTRANS. */
+ if (flag_wpa)
+ lto_mark_file_for_ltrans (file_data);
}
/* Clear out the aux field that was used to store enough state to
OSDN Git Service
