bitpack_delete (bp);
}
+/* Return true when node is reachable from other partition. */
+
+static bool
+reachable_from_other_partition_p (struct cgraph_node *node, cgraph_node_set set)
+{
+ struct cgraph_edge *e;
+ if (node->needed)
+ return true;
+ 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
unsigned local, externally_visible, inlinable, analyzed;
bool boundary_p, wrote_decl_p;
intptr_t ref;
+ bool in_other_partition = false;
boundary_p = !cgraph_node_in_set_p (node, set);
wrote_decl_p = bitmap_bit_p (written_decls, DECL_UID (node->decl));
local static nodes to prevent clashes with other local statics. */
if (boundary_p)
{
- /* Inline clones can not be part of boundary. */
- gcc_assert (!node->global.inlined_to);
- local = 0;
- externally_visible = 1;
- inlinable = 0;
+ /* Inline clones can not be part of boundary.
+ gcc_assert (!node->global.inlined_to);
+
+ FIXME: At the moment they can be, when partition contains an inline
+ clone that is clone of inline clone from outside partition. We can
+ reshape the clone tree and make other tree to be the root, but it
+ needs a bit extra work and will be promplty done by cgraph_remove_node
+ after reading back. */
+ in_other_partition = 1;
analyzed = 0;
}
- else if (lto_forced_extern_inline_p (node->decl))
- {
- local = 1;
- externally_visible = 0;
- inlinable = 1;
- }
lto_output_uleb128_stream (ob->main_stream, wrote_decl_p);
bp_pack_value (bp, node->address_taken, 1);
bp_pack_value (bp, node->abstract_and_needed, 1);
bp_pack_value (bp, node->reachable, 1);
+ bp_pack_value (bp, analyzed && reachable_from_other_partition_p (node, set), 1);
bp_pack_value (bp, node->lowered, 1);
bp_pack_value (bp, analyzed, 1);
+ bp_pack_value (bp, in_other_partition, 1);
bp_pack_value (bp, node->process, 1);
bp_pack_value (bp, node->alias, 1);
bp_pack_value (bp, node->finalized_by_frontend, 1);
lto_output_sleb128_stream (ob->main_stream,
node->global.estimated_growth);
lto_output_uleb128_stream (ob->main_stream, node->global.inlined);
+ if (node->same_comdat_group)
+ {
+ ref = lto_cgraph_encoder_lookup (encoder, node->same_comdat_group);
+ gcc_assert (ref != LCC_NOT_FOUND);
+ }
+ else
+ ref = LCC_NOT_FOUND;
+ lto_output_sleb128_stream (ob->main_stream, ref);
+
if (node->same_body)
{
struct cgraph_node *alias;
alias->thunk.alias);
}
else
- lto_output_uleb128_stream (ob->main_stream, 0);
+ {
+ lto_output_uleb128_stream (ob->main_stream, 0);
+ lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
+ alias->thunk.alias);
+ }
alias = alias->previous;
}
while (alias);
lto_output_uleb128_stream (ob->main_stream, 0);
}
+/* 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)
+{
+ if (node->clone_of)
+ add_node_to (encoder, node->clone_of);
+ lto_cgraph_encoder_encode (encoder, node);
+}
/* Output the part of the cgraph in SET. */
for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
{
node = csi_node (csi);
- lto_cgraph_encoder_encode (encoder, node);
+ add_node_to (encoder, node);
}
/* Go over all the nodes again to include callees that are not in
{
/* We should have moved all the inlines. */
gcc_assert (!callee->global.inlined_to);
- lto_cgraph_encoder_encode (encoder, callee);
+ add_node_to (encoder, callee);
+ /* Also with each included function include all other functions
+ in the same comdat group. */
+ if (callee->same_comdat_group)
+ {
+ struct cgraph_node *next;
+ for (next = callee->same_comdat_group;
+ next != callee;
+ next = next->same_comdat_group)
+ if (!cgraph_node_in_set_p (next, set))
+ add_node_to (encoder, next);
+ }
}
}
+ /* Also with each included function include all other functions
+ in the same comdat group. */
+ if (node->same_comdat_group)
+ {
+ struct cgraph_node *next;
+ for (next = node->same_comdat_group;
+ next != node;
+ next = next->same_comdat_group)
+ if (!cgraph_node_in_set_p (next, set))
+ add_node_to (encoder, next);
+ }
}
- /* Write out the nodes. */
+ /* 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. */
n_nodes = lto_cgraph_encoder_size (encoder);
for (i = 0; i < n_nodes; i++)
{
node->address_taken = bp_unpack_value (bp, 1);
node->abstract_and_needed = bp_unpack_value (bp, 1);
node->reachable = bp_unpack_value (bp, 1);
+ node->reachable_from_other_partition = bp_unpack_value (bp, 1);
node->lowered = bp_unpack_value (bp, 1);
node->analyzed = bp_unpack_value (bp, 1);
+ node->in_other_partition = bp_unpack_value (bp, 1);
node->process = bp_unpack_value (bp, 1);
node->alias = bp_unpack_value (bp, 1);
node->finalized_by_frontend = bp_unpack_value (bp, 1);
bool clone_p;
int estimated_stack_size = 0;
int stack_frame_offset = 0;
- int ref = LCC_NOT_FOUND;
+ int ref = LCC_NOT_FOUND, ref2 = LCC_NOT_FOUND;
int estimated_growth = 0;
int time = 0;
int size = 0;
size = lto_input_sleb128 (ib);
estimated_growth = lto_input_sleb128 (ib);
inlined = lto_input_uleb128 (ib);
+ ref2 = lto_input_sleb128 (ib);
same_body_count = lto_input_uleb128 (ib);
/* Make sure that we have not read this node before. Nodes that
node->global.estimated_growth = estimated_growth;
node->global.inlined = inlined;
+ /* Store a reference for now, and fix up later to be a pointer. */
+ node->same_comdat_group = (cgraph_node_ptr) (intptr_t) ref2;
+
while (same_body_count-- > 0)
{
tree alias_decl;
alias_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
type = lto_input_uleb128 (ib);
if (!type)
- cgraph_same_body_alias (alias_decl, fn_decl);
+ {
+ tree real_alias;
+ decl_index = lto_input_uleb128 (ib);
+ real_alias = lto_file_decl_data_get_fn_decl (file_data, decl_index);
+ cgraph_same_body_alias (alias_decl, real_alias);
+ }
else
{
HOST_WIDE_INT fixed_offset = lto_input_uleb128 (ib);
for (i = 0; VEC_iterate (cgraph_node_ptr, nodes, i, node); i++)
{
- const int ref = (int) (intptr_t) node->global.inlined_to;
+ int ref = (int) (intptr_t) node->global.inlined_to;
/* Fixup inlined_to from reference to pointer. */
if (ref != LCC_NOT_FOUND)
node->global.inlined_to = VEC_index (cgraph_node_ptr, nodes, ref);
else
node->global.inlined_to = NULL;
+
+ ref = (int) (intptr_t) node->same_comdat_group;
+
+ /* Fixup same_comdat_group from reference to pointer. */
+ if (ref != LCC_NOT_FOUND)
+ node->same_comdat_group = VEC_index (cgraph_node_ptr, nodes, ref);
+ else
+ node->same_comdat_group = NULL;
}
VEC_free (cgraph_node_ptr, heap, nodes);
OSDN Git Service
