#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 input_cgraph_opt_summary (VEC (cgraph_node_ptr, heap) * nodes);
/* Number of LDPR values known to GCC. */
-#define LDPR_NUM_KNOWN (LDPR_RESOLVED_DYN + 1)
+#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. */
struct bitpack_d bp;
if (edge->indirect_unknown_callee)
- lto_output_enum (ob->main_stream, LTO_cgraph_tags, LTO_cgraph_last_tag,
- LTO_cgraph_indirect_edge);
+ streamer_write_enum (ob->main_stream, LTO_cgraph_tags, LTO_cgraph_last_tag,
+ LTO_cgraph_indirect_edge);
else
- lto_output_enum (ob->main_stream, LTO_cgraph_tags, LTO_cgraph_last_tag,
- 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)
| ECF_LEAF
| ECF_NOVOPS)));
}
- lto_output_bitpack (&bp);
+ streamer_write_bitpack (&bp);
}
/* Return if LIST contain references from other partitions. */
else
tag = LTO_cgraph_unavail_node;
- lto_output_enum (ob->main_stream, LTO_cgraph_tags, LTO_cgraph_last_tag, 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)
{
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.versionable, 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->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);
+ /* 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);
+ 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);
- lto_output_bitpack (&bp);
+ streamer_write_bitpack (&bp);
if (node->thunk.thunk_p && !boundary_p)
{
- lto_output_uleb128_stream
+ streamer_write_uhwi_stream
(ob->main_stream,
1 + (node->thunk.this_adjusting != 0) * 2
+ (node->thunk.virtual_offset_p != 0) * 4);
- lto_output_uleb128_stream (ob->main_stream,
- node->thunk.fixed_offset);
- lto_output_uleb128_stream (ob->main_stream,
- node->thunk.virtual_value);
- lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
- node->thunk.alias);
+ streamer_write_uhwi_stream (ob->main_stream, node->thunk.fixed_offset);
+ streamer_write_uhwi_stream (ob->main_stream, node->thunk.virtual_value);
}
-
- if (node->same_body)
+ if ((node->alias || node->thunk.thunk_p)
+ && (!boundary_p || (node->alias && DECL_EXTERNAL (node->decl))))
{
- 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);
- lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
- alias->thunk.alias);
- gcc_assert (cgraph_get_node (alias->thunk.alias) == node);
- lto_output_enum (ob->main_stream, ld_plugin_symbol_resolution,
- LDPR_NUM_KNOWN, alias->resolution);
- alias = alias->previous;
- }
- while (alias);
+ 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_enum (ob->main_stream, ld_plugin_symbol_resolution,
- LDPR_NUM_KNOWN, 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_enum (ob->main_stream, ld_plugin_symbol_resolution,
- LDPR_NUM_KNOWN, 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);
}
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.versionable = 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->needed = 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->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);
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
struct bitpack_d bp;
unsigned decl_index;
int ref = LCC_NOT_FOUND, ref2 = LCC_NOT_FOUND;
- unsigned long same_body_count = 0;
int clone_ref;
+ 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)
else
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;
+
+ node->count = streamer_read_hwi (ib);
+ node->count_materialization_scale = streamer_read_hwi (ib);
if (tag == LTO_cgraph_analyzed_node)
- ref = lto_input_sleb128 (ib);
+ 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);
+ 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. */
if (node->thunk.thunk_p)
{
- int type = lto_input_uleb128 (ib);
- HOST_WIDE_INT fixed_offset = lto_input_uleb128 (ib);
- HOST_WIDE_INT virtual_value = lto_input_uleb128 (ib);
- tree real_alias;
+ int type = streamer_read_uhwi (ib);
+ HOST_WIDE_INT fixed_offset = streamer_read_uhwi (ib);
+ HOST_WIDE_INT virtual_value = streamer_read_uhwi (ib);
- decl_index = lto_input_uleb128 (ib);
- real_alias = lto_file_decl_data_get_fn_decl (file_data, decl_index);
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);
- node->thunk.alias = real_alias;
}
-
- same_body_count = lto_input_uleb128 (ib);
- while (same_body_count-- > 0)
+ if (node->thunk.thunk_p || node->alias)
{
- tree alias_decl, real_alias;
- struct cgraph_node *alias;
-
- decl_index = lto_input_uleb128 (ib);
- alias_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
- decl_index = lto_input_uleb128 (ib);
- real_alias = lto_file_decl_data_get_fn_decl (file_data, decl_index);
- alias = cgraph_same_body_alias (node, alias_decl, real_alias);
- gcc_assert (alias);
- alias->resolution = lto_input_enum (ib, ld_plugin_symbol_resolution,
- LDPR_NUM_KNOWN);
+ if (streamer_read_hwi_in_range (ib, "alias nonzero flag", 0, 1))
+ {
+ decl_index = streamer_read_uhwi (ib);
+ node->thunk.alias = lto_file_decl_data_get_fn_decl (file_data,
+ decl_index);
+ }
}
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 = lto_input_enum (ib, ld_plugin_symbol_resolution,
- LDPR_NUM_KNOWN);
- 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 = lto_input_enum (ib, ld_plugin_symbol_resolution,
- LDPR_NUM_KNOWN);
- }
+ 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);
}
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);
+ 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);
VEC(cgraph_node_ptr, heap) *nodes = NULL;
struct cgraph_node *node;
unsigned i;
- unsigned HOST_WIDE_INT len;
- tag = lto_input_enum (ib, LTO_cgraph_tags, LTO_cgraph_last_tag);
+ 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 = lto_input_enum (ib, LTO_cgraph_tags, LTO_cgraph_last_tag);
+ 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);
+ file_data->profile_info.sum_max = streamer_read_uhwi (ib);
}
}
/* 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);
}