/* Write and read the cgraph to the memory mapped representation of a
.o file.
- Copyright 2009, 2010 Free Software Foundation, Inc.
+ Copyright 2009, 2010, 2011 Free Software Foundation, Inc.
Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
This file is part of GCC.
#include "output.h"
#include "pointer-set.h"
#include "lto-streamer.h"
+#include "data-streamer.h"
+#include "tree-streamer.h"
#include "gcov-io.h"
static void output_varpool (cgraph_node_set, varpool_node_set);
static void output_cgraph_opt_summary (cgraph_node_set set);
static void input_cgraph_opt_summary (VEC (cgraph_node_ptr, heap) * nodes);
+/* Number of LDPR values known to GCC. */
+#define LDPR_NUM_KNOWN (LDPR_PREVAILING_DEF_IRONLY_EXP + 1)
+
+/* All node orders are ofsetted by ORDER_BASE. */
+static int order_base;
/* Cgraph streaming is organized as set of record whose type
is indicated by a tag. */
LTO_cgraph_analyzed_node,
/* Cgraph edges. */
LTO_cgraph_edge,
- LTO_cgraph_indirect_edge
+ LTO_cgraph_indirect_edge,
+ LTO_cgraph_last_tag
};
/* Create a new cgraph encoder. */
struct bitpack_d bp;
if (edge->indirect_unknown_callee)
- lto_output_uleb128_stream (ob->main_stream, LTO_cgraph_indirect_edge);
+ streamer_write_enum (ob->main_stream, LTO_cgraph_tags, LTO_cgraph_last_tag,
+ LTO_cgraph_indirect_edge);
else
- lto_output_uleb128_stream (ob->main_stream, LTO_cgraph_edge);
+ streamer_write_enum (ob->main_stream, LTO_cgraph_tags, LTO_cgraph_last_tag,
+ LTO_cgraph_edge);
ref = lto_cgraph_encoder_lookup (encoder, edge->caller);
gcc_assert (ref != LCC_NOT_FOUND);
- lto_output_sleb128_stream (ob->main_stream, ref);
+ streamer_write_hwi_stream (ob->main_stream, ref);
if (!edge->indirect_unknown_callee)
{
ref = lto_cgraph_encoder_lookup (encoder, edge->callee);
gcc_assert (ref != LCC_NOT_FOUND);
- lto_output_sleb128_stream (ob->main_stream, ref);
+ streamer_write_hwi_stream (ob->main_stream, ref);
}
- lto_output_sleb128_stream (ob->main_stream, edge->count);
+ streamer_write_hwi_stream (ob->main_stream, edge->count);
bp = bitpack_create (ob->main_stream);
uid = (!gimple_has_body_p (edge->caller->decl)
? edge->lto_stmt_uid : gimple_uid (edge->call_stmt));
- bp_pack_value (&bp, uid, HOST_BITS_PER_INT);
- bp_pack_value (&bp, edge->inline_failed, HOST_BITS_PER_INT);
- bp_pack_value (&bp, edge->frequency, HOST_BITS_PER_INT);
- bp_pack_value (&bp, edge->loop_nest, 30);
+ bp_pack_enum (&bp, cgraph_inline_failed_enum,
+ CIF_N_REASONS, edge->inline_failed);
+ bp_pack_var_len_unsigned (&bp, uid);
+ bp_pack_var_len_unsigned (&bp, edge->frequency);
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);
| ECF_LEAF
| ECF_NOVOPS)));
}
- lto_output_bitpack (&bp);
+ streamer_write_bitpack (&bp);
}
/* Return if LIST contain references from other partitions. */
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;
else
tag = LTO_cgraph_unavail_node;
- lto_output_uleb128_stream (ob->main_stream, tag);
+ streamer_write_enum (ob->main_stream, LTO_cgraph_tags, LTO_cgraph_last_tag,
+ tag);
+ streamer_write_hwi_stream (ob->main_stream, node->order);
/* In WPA mode, we only output part of the call-graph. Also, we
fake cgraph node attributes. There are two cases that we care.
if (LTO_cgraph_analyzed_node)
gcc_assert (clone_of || !node->clone_of);
if (!clone_of)
- lto_output_sleb128_stream (ob->main_stream, LCC_NOT_FOUND);
+ streamer_write_hwi_stream (ob->main_stream, LCC_NOT_FOUND);
else
- lto_output_sleb128_stream (ob->main_stream, ref);
+ streamer_write_hwi_stream (ob->main_stream, ref);
lto_output_fn_decl_index (ob->decl_state, ob->main_stream, node->decl);
- lto_output_sleb128_stream (ob->main_stream, node->count);
- lto_output_sleb128_stream (ob->main_stream, node->count_materialization_scale);
+ streamer_write_hwi_stream (ob->main_stream, node->count);
+ streamer_write_hwi_stream (ob->main_stream, node->count_materialization_scale);
if (tag == LTO_cgraph_analyzed_node)
{
- lto_output_sleb128_stream (ob->main_stream,
- node->local.inline_summary.estimated_self_stack_size);
- lto_output_sleb128_stream (ob->main_stream,
- node->local.inline_summary.self_size);
- lto_output_sleb128_stream (ob->main_stream,
- node->local.inline_summary.size_inlining_benefit);
- lto_output_sleb128_stream (ob->main_stream,
- 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);
else
ref = LCC_NOT_FOUND;
- lto_output_sleb128_stream (ob->main_stream, ref);
+ streamer_write_hwi_stream (ob->main_stream, ref);
}
if (node->same_comdat_group && !boundary_p)
}
else
ref = LCC_NOT_FOUND;
- lto_output_sleb128_stream (ob->main_stream, ref);
+ streamer_write_hwi_stream (ob->main_stream, ref);
bp = bitpack_create (ob->main_stream);
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, 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.can_change_signature, 1);
bp_pack_value (&bp, node->local.redefined_extern_inline, 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);
|| referenced_from_other_partition_p (&node->ref_list, set, vset)), 1);
bp_pack_value (&bp, node->lowered, 1);
bp_pack_value (&bp, in_other_partition, 1);
- bp_pack_value (&bp, node->alias, 1);
- bp_pack_value (&bp, node->finalized_by_frontend, 1);
+ /* Real aliases in a boundary become non-aliases. However we still stream
+ alias info on weakrefs.
+ TODO: We lose a bit of information here - when we know that variable is
+ defined in other unit, we may use the info on aliases to resolve
+ symbol1 != symbol2 type tests that we can do only for locally defined objects
+ otherwise. */
+ bp_pack_value (&bp, node->alias && (!boundary_p || DECL_EXTERNAL (node->decl)), 1);
bp_pack_value (&bp, node->frequency, 2);
bp_pack_value (&bp, node->only_called_at_startup, 1);
bp_pack_value (&bp, node->only_called_at_exit, 1);
- lto_output_bitpack (&bp);
- lto_output_uleb128_stream (ob->main_stream, node->resolution);
+ bp_pack_value (&bp, node->tm_clone, 1);
+ bp_pack_value (&bp, node->thunk.thunk_p && !boundary_p, 1);
+ bp_pack_enum (&bp, ld_plugin_symbol_resolution,
+ LDPR_NUM_KNOWN, node->resolution);
+ streamer_write_bitpack (&bp);
- if (node->same_body)
+ if (node->thunk.thunk_p && !boundary_p)
{
- struct cgraph_node *alias;
- unsigned long alias_count = 1;
- for (alias = node->same_body; alias->next; alias = alias->next)
- alias_count++;
- lto_output_uleb128_stream (ob->main_stream, alias_count);
- do
- {
- lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
- alias->decl);
- if (alias->thunk.thunk_p)
- {
- lto_output_uleb128_stream
- (ob->main_stream,
- 1 + (alias->thunk.this_adjusting != 0) * 2
- + (alias->thunk.virtual_offset_p != 0) * 4);
- lto_output_uleb128_stream (ob->main_stream,
- alias->thunk.fixed_offset);
- lto_output_uleb128_stream (ob->main_stream,
- alias->thunk.virtual_value);
- lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
- alias->thunk.alias);
- }
- else
- {
- lto_output_uleb128_stream (ob->main_stream, 0);
- lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
- alias->thunk.alias);
- }
- lto_output_uleb128_stream (ob->main_stream, alias->resolution);
- alias = alias->previous;
- }
- while (alias);
+ streamer_write_uhwi_stream
+ (ob->main_stream,
+ 1 + (node->thunk.this_adjusting != 0) * 2
+ + (node->thunk.virtual_offset_p != 0) * 4);
+ streamer_write_uhwi_stream (ob->main_stream, node->thunk.fixed_offset);
+ streamer_write_uhwi_stream (ob->main_stream, node->thunk.virtual_value);
+ }
+ if ((node->alias || node->thunk.thunk_p)
+ && (!boundary_p || (node->alias && DECL_EXTERNAL (node->decl))))
+ {
+ streamer_write_hwi_in_range (ob->main_stream, 0, 1,
+ node->thunk.alias != NULL);
+ if (node->thunk.alias != NULL)
+ lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
+ node->thunk.alias);
}
- else
- lto_output_uleb128_stream (ob->main_stream, 0);
}
/* Output the varpool NODE to OB.
{
bool boundary_p = !varpool_node_in_set_p (node, vset) && node->analyzed;
struct bitpack_d bp;
- struct varpool_node *alias;
- int count = 0;
int ref;
+ streamer_write_hwi_stream (ob->main_stream, node->order);
lto_output_var_decl_index (ob->decl_state, ob->main_stream, node->decl);
bp = bitpack_create (ob->main_stream);
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);
+ bp_pack_value (&bp, node->alias_of != NULL, 1);
gcc_assert (node->finalized || !node->analyzed);
gcc_assert (node->needed);
/* Constant pool initializers can be de-unified into individual ltrans units.
set, vset), 1);
bp_pack_value (&bp, boundary_p, 1); /* in_other_partition. */
}
- /* Also emit any extra name aliases. */
- for (alias = node->extra_name; alias; alias = alias->next)
- count++;
- bp_pack_value (&bp, count != 0, 1);
- lto_output_bitpack (&bp);
+ streamer_write_bitpack (&bp);
+ if (node->alias_of)
+ lto_output_var_decl_index (ob->decl_state, ob->main_stream, node->alias_of);
if (node->same_comdat_group && !boundary_p)
{
ref = lto_varpool_encoder_lookup (varpool_encoder, node->same_comdat_group);
}
else
ref = LCC_NOT_FOUND;
- lto_output_sleb128_stream (ob->main_stream, ref);
- lto_output_uleb128_stream (ob->main_stream, node->resolution);
-
- if (count)
- {
- lto_output_uleb128_stream (ob->main_stream, count);
- for (alias = node->extra_name; alias; alias = alias->next)
- {
- lto_output_var_decl_index (ob->decl_state, ob->main_stream, alias->decl);
- lto_output_uleb128_stream (ob->main_stream, alias->resolution);
- }
- }
+ streamer_write_hwi_stream (ob->main_stream, ref);
+ streamer_write_enum (ob->main_stream, ld_plugin_symbol_resolution,
+ LDPR_NUM_KNOWN, node->resolution);
}
/* Output the varpool NODE to OB.
bp = bitpack_create (ob->main_stream);
bp_pack_value (&bp, ref->refered_type, 1);
bp_pack_value (&bp, ref->use, 2);
- lto_output_bitpack (&bp);
+ streamer_write_bitpack (&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);
+ streamer_write_hwi_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);
+ streamer_write_hwi_stream (ob->main_stream, nref);
}
}
GCC profile feedback and they are difficult to merge from multiple
units. */
gcc_assert (profile_info->runs);
- lto_output_uleb128_stream (ob->main_stream, profile_info->runs);
- lto_output_uleb128_stream (ob->main_stream, profile_info->sum_max);
+ streamer_write_uhwi_stream (ob->main_stream, profile_info->runs);
+ streamer_write_uhwi_stream (ob->main_stream, profile_info->sum_max);
}
else
- lto_output_uleb128_stream (ob->main_stream, 0);
+ streamer_write_uhwi_stream (ob->main_stream, 0);
}
/* Add NODE into encoder as well as nodes it is cloned from.
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,
+ streamer_write_uhwi_stream (ob->main_stream, count);
+ streamer_write_uhwi_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);
+ streamer_write_uhwi_stream (ob->main_stream, 0);
for (vsi = vsi_start (vset); !vsi_end_p (vsi); vsi_next (&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,
+ streamer_write_uhwi_stream (ob->main_stream, count);
+ streamer_write_uhwi_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_uleb128_stream (ob->main_stream, 0);
+ streamer_write_uhwi_stream (ob->main_stream, 0);
lto_destroy_simple_output_block (ob);
}
for (vsi = vsi_start (vset); !vsi_end_p (vsi); vsi_next (&vsi))
{
struct varpool_node *vnode = vsi_node (vsi);
- gcc_assert (!vnode->alias);
+ gcc_assert (!vnode->alias || vnode->alias_of);
lto_varpool_encoder_encode (varpool_encoder, vnode);
lto_set_varpool_encoder_encode_initializer (varpool_encoder, vnode);
add_references (encoder, varpool_encoder, &vnode->ref_list);
int i, n_nodes;
lto_cgraph_encoder_t encoder;
lto_varpool_encoder_t varpool_encoder;
- struct cgraph_asm_node *can;
static bool asm_nodes_output = false;
if (flag_wpa)
output_outgoing_cgraph_edges (node->indirect_calls, ob, encoder);
}
- lto_output_uleb128_stream (ob->main_stream, 0);
+ streamer_write_uhwi_stream (ob->main_stream, 0);
+
+ lto_destroy_simple_output_block (ob);
/* Emit toplevel asms.
When doing WPA we must output every asm just once. Since we do not partition asm
if (!asm_nodes_output)
{
asm_nodes_output = true;
- for (can = cgraph_asm_nodes; can; can = can->next)
- {
- int len = TREE_STRING_LENGTH (can->asm_str);
- lto_output_uleb128_stream (ob->main_stream, len);
- for (i = 0; i < len; ++i)
- lto_output_1_stream (ob->main_stream,
- TREE_STRING_POINTER (can->asm_str)[i]);
- }
+ lto_output_toplevel_asms ();
}
- 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);
}
input_overwrite_node (struct lto_file_decl_data *file_data,
struct cgraph_node *node,
enum LTO_cgraph_tags tag,
- struct bitpack_d *bp,
- unsigned int stack_size,
- unsigned int self_time,
- unsigned int time_inlining_benefit,
- unsigned int self_size,
- unsigned int size_inlining_benefit,
- enum ld_plugin_symbol_resolution resolution)
+ struct bitpack_d *bp)
{
node->aux = (void *) tag;
- node->local.inline_summary.estimated_self_stack_size = stack_size;
- node->local.inline_summary.self_time = self_time;
- node->local.inline_summary.time_inlining_benefit = time_inlining_benefit;
- node->local.inline_summary.self_size = self_size;
- 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.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.can_change_signature = bp_unpack_value (bp, 1);
node->local.redefined_extern_inline = 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);
TREE_STATIC (node->decl) = 0;
}
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);
node->only_called_at_startup = bp_unpack_value (bp, 1);
node->only_called_at_exit = bp_unpack_value (bp, 1);
- node->resolution = resolution;
+ node->tm_clone = bp_unpack_value (bp, 1);
+ node->thunk.thunk_p = bp_unpack_value (bp, 1);
+ node->resolution = bp_unpack_enum (bp, ld_plugin_symbol_resolution,
+ LDPR_NUM_KNOWN);
}
/* Output the part of the cgraph in SET. */
lto_varpool_encoder_t varpool_encoder = ob->decl_state->varpool_node_encoder;
int len = lto_varpool_encoder_size (varpool_encoder), i;
- lto_output_uleb128_stream (ob->main_stream, len);
+ streamer_write_uhwi_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
tree fn_decl;
struct cgraph_node *node;
struct bitpack_d bp;
- int stack_size = 0;
unsigned decl_index;
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;
- enum ld_plugin_symbol_resolution resolution;
+ int order;
- clone_ref = lto_input_sleb128 (ib);
+ order = streamer_read_hwi (ib) + order_base;
+ clone_ref = streamer_read_hwi (ib);
- decl_index = lto_input_uleb128 (ib);
+ decl_index = streamer_read_uhwi (ib);
fn_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
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);
+ 0, CGRAPH_FREQ_BASE, false, NULL, false);
}
else
- node = cgraph_node (fn_decl);
+ node = cgraph_get_create_node (fn_decl);
- node->count = lto_input_sleb128 (ib);
- node->count_materialization_scale = lto_input_sleb128 (ib);
+ node->order = order;
+ if (order >= cgraph_order)
+ cgraph_order = order + 1;
- 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);
+ node->count = streamer_read_hwi (ib);
+ node->count_materialization_scale = streamer_read_hwi (ib);
- ref = lto_input_sleb128 (ib);
- }
+ if (tag == LTO_cgraph_analyzed_node)
+ ref = streamer_read_hwi (ib);
- ref2 = lto_input_sleb128 (ib);
+ ref2 = streamer_read_hwi (ib);
/* Make sure that we have not read this node before. Nodes that
have already been read will have their tag stored in the 'aux'
field. Since built-in functions can be referenced in multiple
functions, they are expected to be read more than once. */
- if (node->aux && !DECL_IS_BUILTIN (node->decl))
+ if (node->aux && !DECL_BUILT_IN (node->decl))
internal_error ("bytecode stream: found multiple instances of cgraph "
"node %d", node->uid);
- bp = lto_input_bitpack (ib);
- resolution = (enum ld_plugin_symbol_resolution)lto_input_uleb128 (ib);
- input_overwrite_node (file_data, node, tag, &bp, stack_size, self_time,
- time_inlining_benefit, self_size,
- size_inlining_benefit, resolution);
+ bp = streamer_read_bitpack (ib);
+ input_overwrite_node (file_data, node, tag, &bp);
/* Store a reference for now, and fix up later to be a pointer. */
node->global.inlined_to = (cgraph_node_ptr) (intptr_t) ref;
/* Store a reference for now, and fix up later to be a pointer. */
node->same_comdat_group = (cgraph_node_ptr) (intptr_t) ref2;
- same_body_count = lto_input_uleb128 (ib);
- while (same_body_count-- > 0)
+ if (node->thunk.thunk_p)
+ {
+ int type = streamer_read_uhwi (ib);
+ HOST_WIDE_INT fixed_offset = streamer_read_uhwi (ib);
+ HOST_WIDE_INT virtual_value = streamer_read_uhwi (ib);
+
+ node->thunk.fixed_offset = fixed_offset;
+ node->thunk.this_adjusting = (type & 2);
+ node->thunk.virtual_value = virtual_value;
+ node->thunk.virtual_offset_p = (type & 4);
+ }
+ if (node->thunk.thunk_p || node->alias)
{
- tree alias_decl;
- int type;
- struct cgraph_node *alias;
- decl_index = lto_input_uleb128 (ib);
- alias_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
- type = lto_input_uleb128 (ib);
- if (!type)
+ if (streamer_read_hwi_in_range (ib, "alias nonzero flag", 0, 1))
{
- tree real_alias;
- decl_index = lto_input_uleb128 (ib);
- real_alias = lto_file_decl_data_get_fn_decl (file_data, decl_index);
- alias = cgraph_same_body_alias (alias_decl, real_alias);
+ decl_index = streamer_read_uhwi (ib);
+ node->thunk.alias = lto_file_decl_data_get_fn_decl (file_data,
+ decl_index);
}
- else
- {
- HOST_WIDE_INT fixed_offset = lto_input_uleb128 (ib);
- HOST_WIDE_INT virtual_value = lto_input_uleb128 (ib);
- tree real_alias;
- decl_index = lto_input_uleb128 (ib);
- real_alias = lto_file_decl_data_get_fn_decl (file_data, decl_index);
- alias = cgraph_add_thunk (alias_decl, fn_decl, type & 2, fixed_offset,
- virtual_value,
- (type & 4) ? size_int (virtual_value) : NULL_TREE,
- real_alias);
- }
- alias->resolution = (enum ld_plugin_symbol_resolution)lto_input_uleb128 (ib);
}
return node;
}
tree var_decl;
struct varpool_node *node;
struct bitpack_d bp;
- bool aliases_p;
- int count;
int ref = LCC_NOT_FOUND;
+ bool non_null_aliasof;
+ int order;
- decl_index = lto_input_uleb128 (ib);
+ order = streamer_read_hwi (ib) + order_base;
+ decl_index = streamer_read_uhwi (ib);
var_decl = lto_file_decl_data_get_var_decl (file_data, decl_index);
node = varpool_node (var_decl);
+ node->order = order;
+ if (order >= cgraph_order)
+ cgraph_order = order + 1;
node->lto_file_data = file_data;
- bp = lto_input_bitpack (ib);
+ bp = streamer_read_bitpack (ib);
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);
+ non_null_aliasof = bp_unpack_value (&bp, 1);
node->analyzed = node->finalized;
node->used_from_other_partition = bp_unpack_value (&bp, 1);
node->in_other_partition = bp_unpack_value (&bp, 1);
DECL_EXTERNAL (node->decl) = 1;
TREE_STATIC (node->decl) = 0;
}
- aliases_p = bp_unpack_value (&bp, 1);
if (node->finalized)
varpool_mark_needed_node (node);
- ref = lto_input_sleb128 (ib);
- /* Store a reference for now, and fix up later to be a pointer. */
- node->same_comdat_group = (struct varpool_node *) (intptr_t) ref;
- node->resolution = (enum ld_plugin_symbol_resolution)lto_input_uleb128 (ib);
- if (aliases_p)
+ if (non_null_aliasof)
{
- count = lto_input_uleb128 (ib);
- for (; count > 0; count --)
- {
- tree decl = lto_file_decl_data_get_var_decl (file_data,
- lto_input_uleb128 (ib));
- struct varpool_node *alias;
- alias = varpool_extra_name_alias (decl, var_decl);
- alias->resolution = (enum ld_plugin_symbol_resolution)lto_input_uleb128 (ib);
- }
+ decl_index = streamer_read_uhwi (ib);
+ node->alias_of = lto_file_decl_data_get_var_decl (file_data, decl_index);
}
+ ref = streamer_read_hwi (ib);
+ /* Store a reference for now, and fix up later to be a pointer. */
+ node->same_comdat_group = (struct varpool_node *) (intptr_t) ref;
+ node->resolution = streamer_read_enum (ib, ld_plugin_symbol_resolution,
+ LDPR_NUM_KNOWN);
+
return node;
}
enum ipa_ref_type type;
enum ipa_ref_use use;
- bp = lto_input_bitpack (ib);
+ bp = streamer_read_bitpack (ib);
type = (enum ipa_ref_type) bp_unpack_value (&bp, 1);
use = (enum ipa_ref_use) bp_unpack_value (&bp, 2);
if (type == IPA_REF_CGRAPH)
- node = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
+ node = VEC_index (cgraph_node_ptr, nodes, streamer_read_hwi (ib));
else
- varpool_node = VEC_index (varpool_node_ptr, varpool_nodes, lto_input_sleb128 (ib));
+ varpool_node = VEC_index (varpool_node_ptr, varpool_nodes,
+ streamer_read_hwi (ib));
ipa_record_reference (refering_node, refering_varpool_node,
node, varpool_node, use, NULL);
}
unsigned int stmt_id;
gcov_type count;
int freq;
- unsigned int nest;
cgraph_inline_failed_t inline_failed;
struct bitpack_d bp;
int ecf_flags = 0;
- caller = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
+ caller = VEC_index (cgraph_node_ptr, nodes, streamer_read_hwi (ib));
if (caller == NULL || caller->decl == NULL_TREE)
internal_error ("bytecode stream: no caller found while reading edge");
if (!indirect)
{
- callee = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
+ callee = VEC_index (cgraph_node_ptr, nodes, streamer_read_hwi (ib));
if (callee == NULL || callee->decl == NULL_TREE)
internal_error ("bytecode stream: no callee found while reading edge");
}
else
callee = NULL;
- count = (gcov_type) lto_input_sleb128 (ib);
+ count = (gcov_type) streamer_read_hwi (ib);
- bp = lto_input_bitpack (ib);
- stmt_id = (unsigned int) bp_unpack_value (&bp, HOST_BITS_PER_INT);
- inline_failed = (cgraph_inline_failed_t) bp_unpack_value (&bp,
- HOST_BITS_PER_INT);
- freq = (int) bp_unpack_value (&bp, HOST_BITS_PER_INT);
- nest = (unsigned) bp_unpack_value (&bp, 30);
+ bp = streamer_read_bitpack (ib);
+ inline_failed = bp_unpack_enum (&bp, cgraph_inline_failed_enum, CIF_N_REASONS);
+ stmt_id = bp_unpack_var_len_unsigned (&bp);
+ freq = (int) bp_unpack_var_len_unsigned (&bp);
if (indirect)
- edge = cgraph_create_indirect_edge (caller, NULL, 0, count, freq, nest);
+ edge = cgraph_create_indirect_edge (caller, NULL, 0, count, freq);
else
- edge = cgraph_create_edge (caller, callee, NULL, count, freq, nest);
+ edge = cgraph_create_edge (caller, callee, NULL, count, freq);
edge->indirect_inlining_edge = bp_unpack_value (&bp, 1);
edge->lto_stmt_uid = stmt_id;
VEC(cgraph_node_ptr, heap) *nodes = NULL;
struct cgraph_node *node;
unsigned i;
- unsigned HOST_WIDE_INT len;
- tag = (enum LTO_cgraph_tags) lto_input_uleb128 (ib);
+ tag = streamer_read_enum (ib, LTO_cgraph_tags, LTO_cgraph_last_tag);
+ order_base = cgraph_order;
while (tag)
{
if (tag == LTO_cgraph_edge)
lto_cgraph_encoder_encode (file_data->cgraph_node_encoder, node);
}
- tag = (enum LTO_cgraph_tags) lto_input_uleb128 (ib);
+ tag = streamer_read_enum (ib, LTO_cgraph_tags, LTO_cgraph_last_tag);
}
- /* Input toplevel asms. */
- len = lto_input_uleb128 (ib);
- while (len)
- {
- char *str = (char *)xmalloc (len + 1);
- for (i = 0; i < len; ++i)
- str[i] = lto_input_1_unsigned (ib);
- cgraph_add_asm_node (build_string (len, str));
- free (str);
+ lto_input_toplevel_asms (file_data, order_base);
- len = lto_input_uleb128 (ib);
- }
/* AUX pointers should be all non-zero for nodes read from the stream. */
#ifdef ENABLE_CHECKING
FOR_EACH_VEC_ELT (cgraph_node_ptr, nodes, i, node)
int i;
struct varpool_node *node;
- len = lto_input_uleb128 (ib);
+ len = streamer_read_uhwi (ib);
while (len)
{
VEC_safe_push (varpool_node_ptr, heap, varpool,
while (true)
{
struct cgraph_node *node;
- count = lto_input_uleb128 (ib);
+ count = streamer_read_uhwi (ib);
if (!count)
break;
- idx = lto_input_uleb128 (ib);
+ idx = streamer_read_uhwi (ib);
node = VEC_index (cgraph_node_ptr, nodes, idx);
while (count)
{
while (true)
{
struct varpool_node *node;
- count = lto_input_uleb128 (ib);
+ count = streamer_read_uhwi (ib);
if (!count)
break;
- node = VEC_index (varpool_node_ptr, varpool, lto_input_uleb128 (ib));
+ node = VEC_index (varpool_node_ptr, varpool,
+ streamer_read_uhwi (ib));
while (count)
{
input_ref (ib, NULL, node, nodes, varpool);
input_profile_summary (struct lto_input_block *ib,
struct lto_file_decl_data *file_data)
{
- unsigned int runs = lto_input_uleb128 (ib);
+ unsigned int runs = streamer_read_uhwi (ib);
if (runs)
{
file_data->profile_info.runs = runs;
- file_data->profile_info.sum_max = lto_input_uleb128 (ib);
- if (runs > file_data->profile_info.sum_max)
- fatal_error ("Corrupted profile info in %s: sum_max is smaller than runs",
- file_data->file_name);
+ file_data->profile_info.sum_max = streamer_read_uhwi (ib);
}
}
During LTRANS we already have values of count_materialization_scale
computed, so just update them. */
for (node = cgraph_nodes; node; node = node->next)
- if (node->local.lto_file_data->profile_info.runs)
+ if (node->local.lto_file_data
+ && node->local.lto_file_data->profile_info.runs)
{
int scale;
VEC_free (cgraph_node_ptr, heap, nodes);
VEC_free (varpool_node_ptr, heap, varpool);
}
+
merge_profile_summaries (file_data_vec);
-
/* Clear out the aux field that was used to store enough state to
tell which nodes should be overwritten. */
/* True when we need optimization summary for NODE. */
static int
-output_cgraph_opt_summary_p (struct cgraph_node *node, cgraph_node_set set)
+output_cgraph_opt_summary_p (struct cgraph_node *node,
+ cgraph_node_set set ATTRIBUTE_UNUSED)
{
- struct cgraph_edge *e;
-
- if (cgraph_node_in_set_p (node, set))
- {
- for (e = node->callees; e; e = e->next_callee)
- if (e->indirect_info
- && e->indirect_info->thunk_delta != 0)
- return true;
-
- for (e = node->indirect_calls; e; e = e->next_callee)
- if (e->indirect_info->thunk_delta != 0)
- return true;
- }
-
return (node->clone_of
&& (node->clone.tree_map
|| node->clone.args_to_skip
/* Output optimization summary for EDGE to OB. */
static void
-output_edge_opt_summary (struct output_block *ob,
- struct cgraph_edge *edge)
+output_edge_opt_summary (struct output_block *ob ATTRIBUTE_UNUSED,
+ struct cgraph_edge *edge ATTRIBUTE_UNUSED)
{
- if (edge->indirect_info)
- lto_output_sleb128_stream (ob->main_stream,
- edge->indirect_info->thunk_delta);
- else
- lto_output_sleb128_stream (ob->main_stream, 0);
}
/* Output optimization summary for NODE to OB. */
int i;
struct cgraph_edge *e;
- 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));
+ if (node->clone.args_to_skip)
+ {
+ streamer_write_uhwi (ob, bitmap_count_bits (node->clone.args_to_skip));
+ EXECUTE_IF_SET_IN_BITMAP (node->clone.args_to_skip, 0, index, bi)
+ streamer_write_uhwi (ob, index);
+ }
+ else
+ streamer_write_uhwi (ob, 0);
+ if (node->clone.combined_args_to_skip)
+ {
+ streamer_write_uhwi (ob, bitmap_count_bits (node->clone.combined_args_to_skip));
+ EXECUTE_IF_SET_IN_BITMAP (node->clone.combined_args_to_skip, 0, index, bi)
+ streamer_write_uhwi (ob, index);
+ }
+ else
+ streamer_write_uhwi (ob, 0);
+ streamer_write_uhwi (ob, VEC_length (ipa_replace_map_p,
+ node->clone.tree_map));
FOR_EACH_VEC_ELT (ipa_replace_map_p, node->clone.tree_map, i, map)
{
int parm_num;
/* 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);
+ streamer_write_uhwi (ob, parm_num);
+ stream_write_tree (ob, map->new_tree, true);
bp = bitpack_create (ob->main_stream);
bp_pack_value (&bp, map->replace_p, 1);
bp_pack_value (&bp, map->ref_p, 1);
- lto_output_bitpack (&bp);
+ streamer_write_bitpack (&bp);
}
if (cgraph_node_in_set_p (node, set))
if (output_cgraph_opt_summary_p (lto_cgraph_encoder_deref (encoder, i),
set))
count++;
- lto_output_uleb128_stream (ob->main_stream, count);
+ streamer_write_uhwi (ob, count);
for (i = 0; i < n_nodes; i++)
{
node = lto_cgraph_encoder_deref (encoder, i);
if (output_cgraph_opt_summary_p (node, set))
{
- lto_output_uleb128_stream (ob->main_stream, i);
+ streamer_write_uhwi (ob, i);
output_node_opt_summary (ob, node, set);
}
}
/* Input optimisation summary of EDGE. */
static void
-input_edge_opt_summary (struct cgraph_edge *edge,
- struct lto_input_block *ib_main)
+input_edge_opt_summary (struct cgraph_edge *edge ATTRIBUTE_UNUSED,
+ struct lto_input_block *ib_main ATTRIBUTE_UNUSED)
{
- HOST_WIDE_INT thunk_delta;
- thunk_delta = lto_input_sleb128 (ib_main);
- if (thunk_delta != 0)
- {
- gcc_assert (!edge->indirect_info);
- edge->indirect_info = cgraph_allocate_init_indirect_info ();
- edge->indirect_info->thunk_delta = thunk_delta;
- }
}
/* Input optimisation summary of NODE. */
struct bitpack_d bp;
struct cgraph_edge *e;
- count = lto_input_uleb128 (ib_main);
+ count = streamer_read_uhwi (ib_main);
if (count)
node->clone.args_to_skip = BITMAP_GGC_ALLOC ();
for (i = 0; i < count; i++)
{
- bit = lto_input_uleb128 (ib_main);
+ bit = streamer_read_uhwi (ib_main);
bitmap_set_bit (node->clone.args_to_skip, bit);
}
- count = lto_input_uleb128 (ib_main);
+ count = streamer_read_uhwi (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);
+ bit = streamer_read_uhwi (ib_main);
bitmap_set_bit (node->clone.combined_args_to_skip, bit);
}
- count = lto_input_uleb128 (ib_main);
+ count = streamer_read_uhwi (ib_main);
for (i = 0; i < count; i++)
{
int parm_num;
for (parm_num = 0, parm = DECL_ARGUMENTS (node->decl); parm_num;
parm = DECL_CHAIN (parm))
parm_num --;
- map->parm_num = lto_input_uleb128 (ib_main);
+ map->parm_num = streamer_read_uhwi (ib_main);
map->old_tree = NULL;
- map->new_tree = lto_input_tree (ib_main, data_in);
- bp = lto_input_bitpack (ib_main);
+ map->new_tree = stream_read_tree (ib_main, data_in);
+ bp = streamer_read_bitpack (ib_main);
map->replace_p = bp_unpack_value (&bp, 1);
map->ref_p = bp_unpack_value (&bp, 1);
}
{
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;
+ const int cfg_offset = sizeof (struct lto_function_header);
+ const int main_offset = cfg_offset + header->cfg_size;
+ const int string_offset = main_offset + header->main_size;
struct data_in *data_in;
struct lto_input_block ib_main;
unsigned int i;
data_in =
lto_data_in_create (file_data, (const char *) data + string_offset,
header->string_size, NULL);
- count = lto_input_uleb128 (&ib_main);
+ count = streamer_read_uhwi (&ib_main);
for (i = 0; i < count; i++)
{
- int ref = lto_input_uleb128 (&ib_main);
+ int ref = streamer_read_uhwi (&ib_main);
input_node_opt_summary (VEC_index (cgraph_node_ptr, nodes, ref),
&ib_main, data_in);
}
OSDN Git Service
