#include "lto-streamer.h"
#include "gcov-io.h"
+/* Cgraph streaming is organized as set of record whose type
+ is indicated by a tag. */
+enum LTO_cgraph_tags
+{
+ /* Must leave 0 for the stopper. */
+
+ /* Cgraph node without body available. */
+ LTO_cgraph_unavail_node = 1,
+ /* Cgraph node with function body. */
+ LTO_cgraph_analyzed_node,
+ /* Cgraph edges. */
+ LTO_cgraph_edge,
+ LTO_cgraph_indirect_edge
+};
+
/* Create a new cgraph encoder. */
lto_cgraph_encoder_t
return ref;
}
+#define LCC_NOT_FOUND (-1)
/* Look up NODE in encoder. Return NODE's reference if it has been encoded
or LCC_NOT_FOUND if it is not there. */
{
unsigned int tag;
struct bitpack_d *bp;
- 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));
- switch (cgraph_function_body_availability (node))
- {
- case AVAIL_NOT_AVAILABLE:
- tag = LTO_cgraph_unavail_node;
- break;
-
- case AVAIL_AVAILABLE:
- case AVAIL_LOCAL:
- tag = LTO_cgraph_avail_node;
- break;
-
- case AVAIL_OVERWRITABLE:
- tag = LTO_cgraph_overwritable_node;
- break;
-
- default:
- gcc_unreachable ();
- }
-
- if (boundary_p)
+ if (node->analyzed && !boundary_p)
+ tag = LTO_cgraph_analyzed_node;
+ else
tag = LTO_cgraph_unavail_node;
lto_output_uleb128_stream (ob->main_stream, tag);
- local = node->local.local;
- externally_visible = node->local.externally_visible;
- inlinable = node->local.inlinable;
- analyzed = node->analyzed;
-
/* In WPA mode, we only output part of the call-graph. Also, we
fake cgraph node attributes. There are two cases that we care.
Cherry-picked nodes: These are nodes we pulled from other
translation units into SET during IPA-inlining. We make them as
local static nodes to prevent clashes with other local statics. */
- if (boundary_p)
+ if (boundary_p && node->analyzed)
{
/* Inline clones can not be part of boundary.
gcc_assert (!node->global.inlined_to);
needs a bit extra work and will be promplty done by cgraph_remove_node
after reading back. */
in_other_partition = 1;
- analyzed = 0;
}
lto_output_uleb128_stream (ob->main_stream, wrote_decl_p);
lto_output_sleb128_stream (ob->main_stream, node->count);
bp = bitpack_create ();
- bp_pack_value (bp, local, 1);
- bp_pack_value (bp, externally_visible, 1);
+ bp_pack_value (bp, node->local.local, 1);
+ bp_pack_value (bp, node->local.externally_visible, 1);
bp_pack_value (bp, node->local.finalized, 1);
- bp_pack_value (bp, inlinable, 1);
+ bp_pack_value (bp, node->local.inlinable, 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.for_functions_valid, 1);
bp_pack_value (bp, node->local.vtable_method, 1);
bp_pack_value (bp, node->needed, 1);
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, tag == LTO_cgraph_analyzed_node
+ && 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);
bp_pack_value (bp, node->frequency, 2);
lto_output_bitpack (ob->main_stream, bp);
bitpack_delete (bp);
- if (tag != LTO_cgraph_unavail_node)
+ if (tag == LTO_cgraph_analyzed_node)
{
lto_output_sleb128_stream (ob->main_stream,
node->local.inline_summary.estimated_self_stack_size);
node->local.inline_summary.self_time);
lto_output_sleb128_stream (ob->main_stream,
node->local.inline_summary.time_inlining_benefit);
- }
+ if (node->global.inlined_to)
+ {
+ ref = lto_cgraph_encoder_lookup (encoder, node->global.inlined_to);
+ gcc_assert (ref != LCC_NOT_FOUND);
+ }
+ else
+ ref = LCC_NOT_FOUND;
- /* FIXME lto: Outputting global info is not neccesary until after
- inliner was run. Global structure holds results of propagation
- done by inliner. */
- lto_output_sleb128_stream (ob->main_stream,
- node->global.estimated_stack_size);
- lto_output_sleb128_stream (ob->main_stream,
- node->global.stack_frame_offset);
- if (node->global.inlined_to && !boundary_p)
- {
- ref = lto_cgraph_encoder_lookup (encoder, node->global.inlined_to);
- gcc_assert (ref != LCC_NOT_FOUND);
+ lto_output_sleb128_stream (ob->main_stream, ref);
}
- else
- ref = LCC_NOT_FOUND;
- lto_output_sleb128_stream (ob->main_stream, ref);
- lto_output_sleb128_stream (ob->main_stream, node->global.time);
- lto_output_sleb128_stream (ob->main_stream, node->global.size);
- 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 && !boundary_p)
{
ref = lto_cgraph_encoder_lookup (encoder, node->same_comdat_group);
node->local.inline_summary.size_inlining_benefit = size_inlining_benefit;
node->global.time = self_time;
node->global.size = self_size;
+ node->global.estimated_stack_size = stack_size;
+ node->global.estimated_growth = INT_MIN;
node->local.lto_file_data = file_data;
node->local.local = bp_unpack_value (bp, 1);
node->local.inlinable = 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.for_functions_valid = bp_unpack_value (bp, 1);
node->local.vtable_method = bp_unpack_value (bp, 1);
node->needed = bp_unpack_value (bp, 1);
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->analyzed = tag == LTO_cgraph_analyzed_node;
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);
node->frequency = (enum node_frequency)bp_unpack_value (bp, 2);
int stack_size = 0;
unsigned decl_index;
bool clone_p;
- int estimated_stack_size = 0;
- int stack_frame_offset = 0;
int ref = LCC_NOT_FOUND, ref2 = LCC_NOT_FOUND;
- int estimated_growth = 0;
- int time = 0;
- int size = 0;
int self_time = 0;
int self_size = 0;
int time_inlining_benefit = 0;
int size_inlining_benefit = 0;
unsigned long same_body_count = 0;
- bool inlined = false;
clone_p = (lto_input_uleb128 (ib) != 0);
node->count = lto_input_sleb128 (ib);
bp = lto_input_bitpack (ib);
- if (tag != LTO_cgraph_unavail_node)
+ if (tag == LTO_cgraph_analyzed_node)
{
stack_size = lto_input_sleb128 (ib);
self_size = lto_input_sleb128 (ib);
size_inlining_benefit = lto_input_sleb128 (ib);
self_time = lto_input_sleb128 (ib);
time_inlining_benefit = lto_input_sleb128 (ib);
+
+ ref = lto_input_sleb128 (ib);
}
- estimated_stack_size = lto_input_sleb128 (ib);
- stack_frame_offset = lto_input_sleb128 (ib);
- ref = lto_input_sleb128 (ib);
- time = lto_input_sleb128 (ib);
- 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);
size_inlining_benefit);
bitpack_delete (bp);
- node->global.estimated_stack_size = estimated_stack_size;
- node->global.stack_frame_offset = stack_frame_offset;
- node->global.time = time;
- node->global.size = size;
-
/* Store a reference for now, and fix up later to be a pointer. */
node->global.inlined_to = (cgraph_node_ptr) (intptr_t) ref;
- 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;