procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

lto-streamer.c (cached_bp): Remove.

Browse source 
2010-06-14  Richard Guenther  <rguenther@suse.de>

	* lto-streamer.c (cached_bp): Remove.
	(bitpack_delete): Likewise.
	(bitpack_create): Likewise.
	(bp_get_next_word): Likewise.
	(bp_pack_value, bp_unpack_value): Move ...
	* lto-streamer.h (bp_pack_value, bp_unpack_value): ... here.
	Re-implement.
	(struct bitpack_d): Likewise.
	(bitpack_create, lto_output_bitpack, lto_input_bitpack):
	New inline functions.
	* lto-streamer-out.c (lto_output_bitpack): Remove.
	(pack_ts_base_value_fields): Adjust.  Avoid conditional
	bitpacking.
	(pack_value_fields): Adjust.
	(lto_write_tree): Likewise.
	(output_gimple_stmt): Likewise.
	(output_function): Likewise.
	* lto-streamer-in.c (input_gimple_stmt): Adjust.
	(input_function): Likewise.
	(unpack_ts_base_value_fields): Adjust.  Avoid conditional
	bitpacking.
	(lto_input_bitpack): Remove.
	(lto_materialize_tree): Adjust.
	* Makefile.in (ipa-prop.o): Add $(LTO_STREAMER_H) dependency.
	* lto-cgraph.c (lto_output_edge): Adjust.
	(lto_output_node): Likewise.
	(lto_output_varpool_node): Likewise.
	(lto_output_ref): Likewise.
	(input_node): Likewise.
	(input_varpool_node): Likewise.
	(input_ref): Likewise.
	(input_edge): Likewise.
	(output_node_opt_summary): Likewise.
	(input_node_opt_summary): Likewise.
	* ipa-pure-const.c (pure_const_write_summary): Likewise.
	(pure_const_read_summary): Likewise.
	* ipa-prop.c (ipa_write_indirect_edge_info): Likewise.
	(ipa_read_indirect_edge_info): Likewise.
	(ipa_write_node_info): Likewise.
	(ipa_read_node_info): Likewise.

From-SVN: r160760
This commit is contained in:
Richard Guenther 2010-06-14 18:54:17 +00:00 • committed by Richard Biener
parent 808081b47f
commit 2465dcc257
9 changed files with 328 additions and 406 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

43
gcc/ChangeLog
View file

@ -1,3 +1,46 @@
2010-06-14 Richard Guenther <rguenther@suse.de>
* lto-streamer.c (cached_bp): Remove.
(bitpack_delete): Likewise.
(bitpack_create): Likewise.
(bp_get_next_word): Likewise.
(bp_pack_value, bp_unpack_value): Move ...
* lto-streamer.h (bp_pack_value, bp_unpack_value): ... here.
Re-implement.
(struct bitpack_d): Likewise.
(bitpack_create, lto_output_bitpack, lto_input_bitpack):
New inline functions.
* lto-streamer-out.c (lto_output_bitpack): Remove.
(pack_ts_base_value_fields): Adjust. Avoid conditional
bitpacking.
(pack_value_fields): Adjust.
(lto_write_tree): Likewise.
(output_gimple_stmt): Likewise.
(output_function): Likewise.
* lto-streamer-in.c (input_gimple_stmt): Adjust.
(input_function): Likewise.
(unpack_ts_base_value_fields): Adjust. Avoid conditional
bitpacking.
(lto_input_bitpack): Remove.
(lto_materialize_tree): Adjust.
* Makefile.in (ipa-prop.o): Add $(LTO_STREAMER_H) dependency.
* lto-cgraph.c (lto_output_edge): Adjust.
(lto_output_node): Likewise.
(lto_output_varpool_node): Likewise.
(lto_output_ref): Likewise.
(input_node): Likewise.
(input_varpool_node): Likewise.
(input_ref): Likewise.
(input_edge): Likewise.
(output_node_opt_summary): Likewise.
(input_node_opt_summary): Likewise.
* ipa-pure-const.c (pure_const_write_summary): Likewise.
(pure_const_read_summary): Likewise.
* ipa-prop.c (ipa_write_indirect_edge_info): Likewise.
(ipa_read_indirect_edge_info): Likewise.
(ipa_write_node_info): Likewise.
(ipa_read_node_info): Likewise.
2010-06-14 H.J. Lu <hongjiu.lu@intel.com>
PR target/44534

2
gcc/Makefile.in
View file

@ -2995,7 +2995,7 @@ ipa-prop.o : ipa-prop.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \
langhooks.h $(GGC_H) $(TARGET_H) $(CGRAPH_H) $(IPA_PROP_H) $(DIAGNOSTIC_H) \
$(TREE_FLOW_H) $(TM_H) $(TREE_PASS_H) $(FLAGS_H) $(TREE_H) \
$(TREE_INLINE_H) $(GIMPLE_H) $(GIMPLE_FOLD_H) $(TIMEVAR_H) \
tree-pretty-print.h gimple-pretty-print.h
tree-pretty-print.h gimple-pretty-print.h $(LTO_STREAMER_H)
ipa-ref.o : ipa-ref.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \
langhooks.h $(GGC_H) $(TARGET_H) $(CGRAPH_H) $(TREE_H) $(TARGET_H) \
$(TREE_FLOW_H) $(TM_H) $(TREE_PASS_H) $(FLAGS_H) $(TREE_H) $(GGC_H)

40
gcc/ipa-prop.c
View file

@ -2403,14 +2403,13 @@ ipa_write_indirect_edge_info (struct output_block *ob,
struct cgraph_edge *cs)
{
struct cgraph_indirect_call_info *ii = cs->indirect_info;
struct bitpack_d *bp;
struct bitpack_d bp;
lto_output_sleb128_stream (ob->main_stream, ii->param_index);
lto_output_sleb128_stream (ob->main_stream, ii->anc_offset);
bp = bitpack_create ();
bp_pack_value (bp, ii->polymorphic, 1);
lto_output_bitpack (ob->main_stream, bp);
bitpack_delete (bp);
bp = bitpack_create (ob->main_stream);
bp_pack_value (&bp, ii->polymorphic, 1);
lto_output_bitpack (&bp);
if (ii->polymorphic)
{
@ -2428,13 +2427,12 @@ ipa_read_indirect_edge_info (struct lto_input_block *ib,
struct cgraph_edge *cs)
{
struct cgraph_indirect_call_info *ii = cs->indirect_info;
struct bitpack_d *bp;
struct bitpack_d bp;
ii->param_index = (int) lto_input_sleb128 (ib);
ii->anc_offset = (HOST_WIDE_INT) lto_input_sleb128 (ib);
bp = lto_input_bitpack (ib);
ii->polymorphic = bp_unpack_value (bp, 1);
bitpack_delete (bp);
ii->polymorphic = bp_unpack_value (&bp, 1);
if (ii->polymorphic)
{
ii->otr_token = (HOST_WIDE_INT) lto_input_sleb128 (ib);
@ -2452,26 +2450,25 @@ ipa_write_node_info (struct output_block *ob, struct cgraph_node *node)
struct ipa_node_params *info = IPA_NODE_REF (node);
int j;
struct cgraph_edge *e;
struct bitpack_d *bp;
struct bitpack_d bp;
encoder = ob->decl_state->cgraph_node_encoder;
node_ref = lto_cgraph_encoder_encode (encoder, node);
lto_output_uleb128_stream (ob->main_stream, node_ref);
bp = bitpack_create ();
bp_pack_value (bp, info->called_with_var_arguments, 1);
bp_pack_value (bp, info->uses_analysis_done, 1);
bp = bitpack_create (ob->main_stream);
bp_pack_value (&bp, info->called_with_var_arguments, 1);
bp_pack_value (&bp, info->uses_analysis_done, 1);
gcc_assert (info->modification_analysis_done
|| ipa_get_param_count (info) == 0);
gcc_assert (!info->node_enqueued);
gcc_assert (!info->ipcp_orig_node);
for (j = 0; j < ipa_get_param_count (info); j++)
{
bp_pack_value (bp, info->params[j].modified, 1);
bp_pack_value (bp, info->params[j].used, 1);
bp_pack_value (&bp, info->params[j].modified, 1);
bp_pack_value (&bp, info->params[j].used, 1);
}
lto_output_bitpack (ob->main_stream, bp);
bitpack_delete (bp);
lto_output_bitpack (&bp);
for (e = node->callees; e; e = e->next_callee)
{
struct ipa_edge_args *args = IPA_EDGE_REF (e);
@ -2494,13 +2491,13 @@ ipa_read_node_info (struct lto_input_block *ib, struct cgraph_node *node,
struct ipa_node_params *info = IPA_NODE_REF (node);
int k;
struct cgraph_edge *e;
struct bitpack_d *bp;
struct bitpack_d bp;
ipa_initialize_node_params (node);
bp = lto_input_bitpack (ib);
info->called_with_var_arguments = bp_unpack_value (bp, 1);
info->uses_analysis_done = bp_unpack_value (bp, 1);
info->called_with_var_arguments = bp_unpack_value (&bp, 1);
info->uses_analysis_done = bp_unpack_value (&bp, 1);
if (ipa_get_param_count (info) != 0)
{
info->modification_analysis_done = true;
@ -2509,10 +2506,9 @@ ipa_read_node_info (struct lto_input_block *ib, struct cgraph_node *node,
info->node_enqueued = false;
for (k = 0; k < ipa_get_param_count (info); k++)
{
info->params[k].modified = bp_unpack_value (bp, 1);
info->params[k].used = bp_unpack_value (bp, 1);
info->params[k].modified = bp_unpack_value (&bp, 1);
info->params[k].used = bp_unpack_value (&bp, 1);
}
bitpack_delete (bp);
for (e = node->callees; e; e = e->next_callee)
{
struct ipa_edge_args *args = IPA_EDGE_REF (e);

30
gcc/ipa-pure-const.c
View file

@ -943,7 +943,7 @@ pure_const_write_summary (cgraph_node_set set,
node = csi_node (csi);
if (node->analyzed && has_function_state (node))
{
struct bitpack_d *bp;
struct bitpack_d bp;
funct_state fs;
int node_ref;
lto_cgraph_encoder_t encoder;
@ -956,14 +956,13 @@ pure_const_write_summary (cgraph_node_set set,
/* Note that flags will need to be read in the opposite
order as we are pushing the bitflags into FLAGS. */
bp = bitpack_create ();
bp_pack_value (bp, fs->pure_const_state, 2);
bp_pack_value (bp, fs->state_previously_known, 2);
bp_pack_value (bp, fs->looping_previously_known, 1);
bp_pack_value (bp, fs->looping, 1);
bp_pack_value (bp, fs->can_throw, 1);
lto_output_bitpack (ob->main_stream, bp);
bitpack_delete (bp);
bp = bitpack_create (ob->main_stream);
bp_pack_value (&bp, fs->pure_const_state, 2);
bp_pack_value (&bp, fs->state_previously_known, 2);
bp_pack_value (&bp, fs->looping_previously_known, 1);
bp_pack_value (&bp, fs->looping, 1);
bp_pack_value (&bp, fs->can_throw, 1);
lto_output_bitpack (&bp);
}
}
@ -998,7 +997,7 @@ pure_const_read_summary (void)
{
unsigned int index;
struct cgraph_node *node;
struct bitpack_d *bp;
struct bitpack_d bp;
funct_state fs;
lto_cgraph_encoder_t encoder;
@ -1013,12 +1012,12 @@ pure_const_read_summary (void)
pushed into FLAGS). */
bp = lto_input_bitpack (ib);
fs->pure_const_state
= (enum pure_const_state_e) bp_unpack_value (bp, 2);
= (enum pure_const_state_e) bp_unpack_value (&bp, 2);
fs->state_previously_known
= (enum pure_const_state_e) bp_unpack_value (bp, 2);
fs->looping_previously_known = bp_unpack_value (bp, 1);
fs->looping = bp_unpack_value (bp, 1);
fs->can_throw = bp_unpack_value (bp, 1);
= (enum pure_const_state_e) bp_unpack_value (&bp, 2);
fs->looping_previously_known = bp_unpack_value (&bp, 1);
fs->looping = bp_unpack_value (&bp, 1);
fs->can_throw = bp_unpack_value (&bp, 1);
if (dump_file)
{
int flags = flags_from_decl_or_type (node->decl);
@ -1042,7 +1041,6 @@ pure_const_read_summary (void)
if (fs->can_throw)
fprintf (dump_file," function is locally throwing\n");
}
bitpack_delete (bp);
}
lto_destroy_simple_input_block (file_data,

197
gcc/lto-cgraph.c
View file

@ -260,7 +260,7 @@ lto_output_edge (struct lto_simple_output_block *ob, struct cgraph_edge *edge,
{
unsigned int uid;
intptr_t ref;
struct bitpack_d *bp;
struct bitpack_d bp;
if (edge->indirect_unknown_callee)
lto_output_uleb128_stream (ob->main_stream, LTO_cgraph_indirect_edge);
@ -280,32 +280,31 @@ lto_output_edge (struct lto_simple_output_block *ob, struct cgraph_edge *edge,
lto_output_sleb128_stream (ob->main_stream, edge->count);
bp = bitpack_create ();
bp = bitpack_create (ob->main_stream);
uid = flag_wpa ? 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_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);
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_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);
if (edge->indirect_unknown_callee)
{
int flags = edge->indirect_info->ecf_flags;
bp_pack_value (bp, (flags & ECF_CONST) != 0, 1);
bp_pack_value (bp, (flags & ECF_PURE) != 0, 1);
bp_pack_value (bp, (flags & ECF_NORETURN) != 0, 1);
bp_pack_value (bp, (flags & ECF_MALLOC) != 0, 1);
bp_pack_value (bp, (flags & ECF_NOTHROW) != 0, 1);
bp_pack_value (bp, (flags & ECF_RETURNS_TWICE) != 0, 1);
bp_pack_value (&bp, (flags & ECF_CONST) != 0, 1);
bp_pack_value (&bp, (flags & ECF_PURE) != 0, 1);
bp_pack_value (&bp, (flags & ECF_NORETURN) != 0, 1);
bp_pack_value (&bp, (flags & ECF_MALLOC) != 0, 1);
bp_pack_value (&bp, (flags & ECF_NOTHROW) != 0, 1);
bp_pack_value (&bp, (flags & ECF_RETURNS_TWICE) != 0, 1);
/* Flags that should not appear on indirect calls. */
gcc_assert (!(flags & (ECF_LOOPING_CONST_OR_PURE
| ECF_MAY_BE_ALLOCA
| ECF_SIBCALL
| ECF_NOVOPS)));
}
lto_output_bitpack (ob->main_stream, bp);
bitpack_delete (bp);
lto_output_bitpack (&bp);
}
/* Return if LIST contain references from other partitions. */
@ -404,7 +403,7 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
varpool_node_set vset)
{
unsigned int tag;
struct bitpack_d *bp;
struct bitpack_d bp;
bool boundary_p;
intptr_t ref;
bool in_other_partition = false;
@ -458,30 +457,6 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
lto_output_fn_decl_index (ob->decl_state, ob->main_stream, node->decl);
lto_output_sleb128_stream (ob->main_stream, node->count);
bp = bitpack_create ();
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.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);
bp_pack_value (bp, tag == LTO_cgraph_analyzed_node
&& !DECL_EXTERNAL (node->decl)
&& (reachable_from_other_partition_p (node, set)
|| 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);
bp_pack_value (bp, node->frequency, 2);
lto_output_bitpack (ob->main_stream, bp);
bitpack_delete (bp);
if (tag == LTO_cgraph_analyzed_node)
{
lto_output_sleb128_stream (ob->main_stream,
@ -514,6 +489,29 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
ref = LCC_NOT_FOUND;
lto_output_sleb128_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.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);
bp_pack_value (&bp, tag == LTO_cgraph_analyzed_node
&& !DECL_EXTERNAL (node->decl)
&& (reachable_from_other_partition_p (node, set)
|| 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);
bp_pack_value (&bp, node->frequency, 2);
lto_output_bitpack (&bp);
if (node->same_body)
{
struct cgraph_node *alias;
@ -561,17 +559,17 @@ lto_output_varpool_node (struct lto_simple_output_block *ob, struct varpool_node
cgraph_node_set set, varpool_node_set vset)
{
bool boundary_p = !varpool_node_in_set_p (node, vset) && node->analyzed;
struct bitpack_d *bp;
struct bitpack_d bp;
struct varpool_node *alias;
int count = 0;
int ref;
lto_output_var_decl_index (ob->decl_state, ob->main_stream, node->decl);
bp = bitpack_create ();
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);
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);
gcc_assert (node->finalized || !node->analyzed);
gcc_assert (node->needed);
@ -580,22 +578,21 @@ lto_output_varpool_node (struct lto_simple_output_block *ob, struct varpool_node
labels and share them across LTRANS partitions. */
if (DECL_IN_CONSTANT_POOL (node->decl))
{
bp_pack_value (bp, 0, 1); /* used_from_other_parition. */
bp_pack_value (bp, 0, 1); /* in_other_partition. */
bp_pack_value (&bp, 0, 1); /* used_from_other_parition. */
bp_pack_value (&bp, 0, 1); /* in_other_partition. */
}
else
{
bp_pack_value (bp, node->analyzed
bp_pack_value (&bp, node->analyzed
&& referenced_from_other_partition_p (&node->ref_list,
set, vset), 1);
bp_pack_value (bp, boundary_p, 1); /* in_other_partition. */
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 (ob->main_stream, bp);
bitpack_delete (bp);
bp_pack_value (&bp, count != 0, 1);
lto_output_bitpack (&bp);
if (node->same_comdat_group && !boundary_p)
{
ref = lto_varpool_encoder_lookup (varpool_encoder, node->same_comdat_group);
@ -621,11 +618,11 @@ 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);
struct bitpack_d bp;
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);
if (ref->refered_type == IPA_REF_CGRAPH)
{
int nref = lto_cgraph_encoder_lookup (encoder, ipa_ref_node (ref));
@ -981,7 +978,7 @@ input_node (struct lto_file_decl_data *file_data,
{
tree fn_decl;
struct cgraph_node *node;
struct bitpack_d *bp;
struct bitpack_d bp;
int stack_size = 0;
unsigned decl_index;
int ref = LCC_NOT_FOUND, ref2 = LCC_NOT_FOUND;
@ -1006,7 +1003,6 @@ input_node (struct lto_file_decl_data *file_data,
node = cgraph_node (fn_decl);
node->count = lto_input_sleb128 (ib);
bp = lto_input_bitpack (ib);
if (tag == LTO_cgraph_analyzed_node)
{
@ -1020,7 +1016,6 @@ input_node (struct lto_file_decl_data *file_data,
}
ref2 = lto_input_sleb128 (ib);
same_body_count = lto_input_uleb128 (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'
@ -1030,10 +1025,10 @@ input_node (struct lto_file_decl_data *file_data,
internal_error ("bytecode stream: found multiple instances of cgraph "
"node %d", node->uid);
input_overwrite_node (file_data, node, tag, bp, stack_size, self_time,
bp = lto_input_bitpack (ib);
input_overwrite_node (file_data, node, tag, &bp, stack_size, self_time,
time_inlining_benefit, self_size,
size_inlining_benefit);
bitpack_delete (bp);
/* Store a reference for now, and fix up later to be a pointer. */
node->global.inlined_to = (cgraph_node_ptr) (intptr_t) ref;
@ -1041,6 +1036,7 @@ input_node (struct lto_file_decl_data *file_data,
/* 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)
{
tree alias_decl;
@ -1081,7 +1077,7 @@ input_varpool_node (struct lto_file_decl_data *file_data,
int decl_index;
tree var_decl;
struct varpool_node *node;
struct bitpack_d *bp;
struct bitpack_d bp;
bool aliases_p;
int count;
int ref = LCC_NOT_FOUND;
@ -1092,17 +1088,16 @@ input_varpool_node (struct lto_file_decl_data *file_data,
node->lto_file_data = file_data;
bp = lto_input_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);
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->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);
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);
if (node->finalized)
varpool_mark_needed_node (node);
bitpack_delete (bp);
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;
@ -1131,14 +1126,13 @@ input_ref (struct lto_input_block *ib,
{
struct cgraph_node *node = NULL;
struct varpool_node *varpool_node = NULL;
struct bitpack_d *bp;
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);
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));
else
@ -1163,7 +1157,7 @@ input_edge (struct lto_input_block *ib, VEC(cgraph_node_ptr, heap) *nodes,
int freq;
unsigned int nest;
cgraph_inline_failed_t inline_failed;
struct bitpack_d *bp;
struct bitpack_d bp;
enum ld_plugin_symbol_resolution caller_resolution;
int ecf_flags = 0;
@ -1183,11 +1177,11 @@ input_edge (struct lto_input_block *ib, VEC(cgraph_node_ptr, heap) *nodes,
count = (gcov_type) lto_input_sleb128 (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,
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);
freq = (int) bp_unpack_value (&bp, HOST_BITS_PER_INT);
nest = (unsigned) bp_unpack_value (&bp, 30);
/* If the caller was preempted, don't create the edge.
??? Should we ever have edges from a preempted caller? */
@ -1201,28 +1195,27 @@ input_edge (struct lto_input_block *ib, VEC(cgraph_node_ptr, heap) *nodes,
else
edge = cgraph_create_edge (caller, callee, NULL, count, freq, nest);
edge->indirect_inlining_edge = bp_unpack_value (bp, 1);
edge->indirect_inlining_edge = bp_unpack_value (&bp, 1);
edge->lto_stmt_uid = stmt_id;
edge->inline_failed = inline_failed;
edge->call_stmt_cannot_inline_p = bp_unpack_value (bp, 1);
edge->can_throw_external = bp_unpack_value (bp, 1);
edge->call_stmt_cannot_inline_p = bp_unpack_value (&bp, 1);
edge->can_throw_external = bp_unpack_value (&bp, 1);
if (indirect)
{
if (bp_unpack_value (bp, 1))
if (bp_unpack_value (&bp, 1))
ecf_flags |= ECF_CONST;
if (bp_unpack_value (bp, 1))
if (bp_unpack_value (&bp, 1))
ecf_flags |= ECF_PURE;
if (bp_unpack_value (bp, 1))
if (bp_unpack_value (&bp, 1))
ecf_flags |= ECF_NORETURN;
if (bp_unpack_value (bp, 1))
if (bp_unpack_value (&bp, 1))
ecf_flags |= ECF_MALLOC;
if (bp_unpack_value (bp, 1))
if (bp_unpack_value (&bp, 1))
ecf_flags |= ECF_NOTHROW;
if (bp_unpack_value (bp, 1))
if (bp_unpack_value (&bp, 1))
ecf_flags |= ECF_RETURNS_TWICE;
edge->indirect_info->ecf_flags = ecf_flags;
}
bitpack_delete (bp);
}
@ -1470,7 +1463,7 @@ output_node_opt_summary (struct output_block *ob,
unsigned int index;
bitmap_iterator bi;
struct ipa_replace_map *map;
struct bitpack_d *bp;
struct bitpack_d bp;
int i;
lto_output_uleb128_stream (ob->main_stream,
@ -1497,11 +1490,10 @@ output_node_opt_summary (struct output_block *ob,
gcc_assert (parm);
lto_output_uleb128_stream (ob->main_stream, parm_num);
lto_output_tree (ob, map->new_tree, true);
bp = bitpack_create ();
bp_pack_value (bp, map->replace_p, 1);
bp_pack_value (bp, map->ref_p, 1);
lto_output_bitpack (ob->main_stream, bp);
bitpack_delete (bp);
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);
}
}
@ -1547,7 +1539,7 @@ input_node_opt_summary (struct cgraph_node *node,
int i;
int count;
int bit;
struct bitpack_d *bp;
struct bitpack_d bp;
count = lto_input_uleb128 (ib_main);
if (count)
@ -1580,9 +1572,8 @@ input_node_opt_summary (struct cgraph_node *node,
map->old_tree = NULL;
map->new_tree = lto_input_tree (ib_main, data_in);
bp = lto_input_bitpack (ib_main);
map->replace_p = bp_unpack_value (bp, 1);
map->ref_p = bp_unpack_value (bp, 1);
bitpack_delete (bp);
map->replace_p = bp_unpack_value (&bp, 1);
map->ref_p = bp_unpack_value (&bp, 1);
}
}

87
gcc/lto-streamer-in.c
View file

@ -1001,20 +1001,19 @@ input_gimple_stmt (struct lto_input_block *ib, struct data_in *data_in,
enum gimple_code code;
unsigned HOST_WIDE_INT num_ops;
size_t i;
struct bitpack_d *bp;
struct bitpack_d bp;
code = lto_tag_to_gimple_code (tag);
/* Read the tuple header. */
bp = lto_input_bitpack (ib);
num_ops = bp_unpack_value (bp, sizeof (unsigned) * 8);
num_ops = bp_unpack_value (&bp, sizeof (unsigned) * 8);
stmt = gimple_alloc (code, num_ops);
stmt->gsbase.no_warning = bp_unpack_value (bp, 1);
stmt->gsbase.no_warning = bp_unpack_value (&bp, 1);
if (is_gimple_assign (stmt))
stmt->gsbase.nontemporal_move = bp_unpack_value (bp, 1);
stmt->gsbase.has_volatile_ops = bp_unpack_value (bp, 1);
stmt->gsbase.subcode = bp_unpack_value (bp, 16);
bitpack_delete (bp);
stmt->gsbase.nontemporal_move = bp_unpack_value (&bp, 1);
stmt->gsbase.has_volatile_ops = bp_unpack_value (&bp, 1);
stmt->gsbase.subcode = bp_unpack_value (&bp, 16);
/* Read location information. */
gimple_set_location (stmt, lto_input_location (ib, data_in));
@ -1291,7 +1290,7 @@ input_function (tree fn_decl, struct data_in *data_in,
enum LTO_tags tag;
gimple *stmts;
basic_block bb;
struct bitpack_d *bp;
struct bitpack_d bp;
struct cgraph_node *node;
tree args, narg, oarg;
@ -1304,22 +1303,21 @@ input_function (tree fn_decl, struct data_in *data_in,
/* Read all the attributes for FN. */
bp = lto_input_bitpack (ib);
fn->is_thunk = bp_unpack_value (bp, 1);
fn->has_local_explicit_reg_vars = bp_unpack_value (bp, 1);
fn->after_tree_profile = bp_unpack_value (bp, 1);
fn->returns_pcc_struct = bp_unpack_value (bp, 1);
fn->returns_struct = bp_unpack_value (bp, 1);
fn->can_throw_non_call_exceptions = bp_unpack_value (bp, 1);
fn->always_inline_functions_inlined = bp_unpack_value (bp, 1);
fn->after_inlining = bp_unpack_value (bp, 1);
fn->dont_save_pending_sizes_p = bp_unpack_value (bp, 1);
fn->stdarg = bp_unpack_value (bp, 1);
fn->has_nonlocal_label = bp_unpack_value (bp, 1);
fn->calls_alloca = bp_unpack_value (bp, 1);
fn->calls_setjmp = bp_unpack_value (bp, 1);
fn->va_list_fpr_size = bp_unpack_value (bp, 8);
fn->va_list_gpr_size = bp_unpack_value (bp, 8);
bitpack_delete (bp);
fn->is_thunk = bp_unpack_value (&bp, 1);
fn->has_local_explicit_reg_vars = bp_unpack_value (&bp, 1);
fn->after_tree_profile = bp_unpack_value (&bp, 1);
fn->returns_pcc_struct = bp_unpack_value (&bp, 1);
fn->returns_struct = bp_unpack_value (&bp, 1);
fn->can_throw_non_call_exceptions = bp_unpack_value (&bp, 1);
fn->always_inline_functions_inlined = bp_unpack_value (&bp, 1);
fn->after_inlining = bp_unpack_value (&bp, 1);
fn->dont_save_pending_sizes_p = bp_unpack_value (&bp, 1);
fn->stdarg = bp_unpack_value (&bp, 1);
fn->has_nonlocal_label = bp_unpack_value (&bp, 1);
fn->calls_alloca = bp_unpack_value (&bp, 1);
fn->calls_setjmp = bp_unpack_value (&bp, 1);
fn->va_list_fpr_size = bp_unpack_value (&bp, 8);
fn->va_list_gpr_size = bp_unpack_value (&bp, 8);
/* Input the current IL state of the function. */
fn->curr_properties = lto_input_uleb128 (ib);
@ -1581,12 +1579,16 @@ unpack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
so we skip it here. */
TREE_PUBLIC (expr) = (unsigned) bp_unpack_value (bp, 1);
}
else
bp_unpack_value (bp, 4);
TREE_ADDRESSABLE (expr) = (unsigned) bp_unpack_value (bp, 1);
TREE_THIS_VOLATILE (expr) = (unsigned) bp_unpack_value (bp, 1);
if (DECL_P (expr))
DECL_UNSIGNED (expr) = (unsigned) bp_unpack_value (bp, 1);
else if (TYPE_P (expr))
TYPE_UNSIGNED (expr) = (unsigned) bp_unpack_value (bp, 1);
else
bp_unpack_value (bp, 1);
TREE_ASM_WRITTEN (expr) = (unsigned) bp_unpack_value (bp, 1);
TREE_NO_WARNING (expr) = (unsigned) bp_unpack_value (bp, 1);
TREE_USED (expr) = (unsigned) bp_unpack_value (bp, 1);
@ -1597,8 +1599,10 @@ unpack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
TREE_DEPRECATED (expr) = (unsigned) bp_unpack_value (bp, 1);
if (TYPE_P (expr))
TYPE_SATURATING (expr) = (unsigned) bp_unpack_value (bp, 1);
if (TREE_CODE (expr) == SSA_NAME)
else if (TREE_CODE (expr) == SSA_NAME)
SSA_NAME_IS_DEFAULT_DEF (expr) = (unsigned) bp_unpack_value (bp, 1);
else
bp_unpack_value (bp, 1);
}
@ -1858,32 +1862,6 @@ unpack_value_fields (struct bitpack_d *bp, tree expr)
}
/* Read a bitpack from input block IB. */
struct bitpack_d *
lto_input_bitpack (struct lto_input_block *ib)
{
unsigned i, num_words;
struct bitpack_d *bp;
bp = bitpack_create ();
/* If we are about to read more than a handful of words, something
is wrong. This check is overly strict, but it acts as an early
warning. No streamed object has hundreds of bits in its fields. */
num_words = lto_input_uleb128 (ib);
gcc_assert (num_words < 20);
for (i = 0; i < num_words; i++)
{
bitpack_word_t w = lto_input_uleb128 (ib);
VEC_safe_push (bitpack_word_t, heap, bp->values, w);
}
return bp;
}
/* Materialize a new tree from input block IB using descriptors in
DATA_IN. The code for the new tree should match TAG. Store in
*IX_P the index into the reader cache where the new tree is stored. */
@ -1892,7 +1870,7 @@ static tree
lto_materialize_tree (struct lto_input_block *ib, struct data_in *data_in,
enum LTO_tags tag, int *ix_p)
{
struct bitpack_d *bp;
struct bitpack_d bp;
enum tree_code code;
tree result;
#ifdef LTO_STREAMER_DEBUG
@ -1957,12 +1935,11 @@ lto_materialize_tree (struct lto_input_block *ib, struct data_in *data_in,
/* The first word in BP contains the code of the tree that we
are about to read. */
code = (enum tree_code) bp_unpack_value (bp, 16);
code = (enum tree_code) bp_unpack_value (&bp, 16);
lto_tag_check (lto_tree_code_to_tag (code), tag);
/* Unpack all the value fields from BP. */
unpack_value_fields (bp, result);
bitpack_delete (bp);
unpack_value_fields (&bp, result);
/* Enter RESULT in the reader cache. This will make RESULT
available so that circular references in the rest of the tree

92
gcc/lto-streamer-out.c
View file

@ -151,20 +151,6 @@ destroy_output_block (struct output_block *ob)
}
/* Output bitpack BP to output stream S. */
void
lto_output_bitpack (struct lto_output_stream *s, struct bitpack_d *bp)
{
unsigned i;
bitpack_word_t v;
lto_output_uleb128_stream (s, VEC_length (bitpack_word_t, bp->values));
for (i = 0; VEC_iterate (bitpack_word_t, bp->values, i, v); i++)
lto_output_uleb128_stream (s, v);
}
/* Output STRING of LEN characters to the string
table in OB. The string might or might not include a trailing '\0'.
Then put the index onto the INDEX_STREAM. */
@ -335,12 +321,16 @@ pack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
so we skip it here. */
bp_pack_value (bp, TREE_PUBLIC (expr), 1);
}
else
bp_pack_value (bp, 0, 4);
bp_pack_value (bp, TREE_ADDRESSABLE (expr), 1);
bp_pack_value (bp, TREE_THIS_VOLATILE (expr), 1);
if (DECL_P (expr))
bp_pack_value (bp, DECL_UNSIGNED (expr), 1);
else if (TYPE_P (expr))
bp_pack_value (bp, TYPE_UNSIGNED (expr), 1);
else
bp_pack_value (bp, 0, 1);
/* We write debug info two times, do not confuse the second one. */
bp_pack_value (bp, TYPE_P (expr) ? 0 : TREE_ASM_WRITTEN (expr), 1);
bp_pack_value (bp, TREE_NO_WARNING (expr), 1);
@ -352,8 +342,10 @@ pack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
bp_pack_value (bp, TREE_DEPRECATED (expr), 1);
if (TYPE_P (expr))
bp_pack_value (bp, TYPE_SATURATING (expr), 1);
if (TREE_CODE (expr) == SSA_NAME)
else if (TREE_CODE (expr) == SSA_NAME)
bp_pack_value (bp, SSA_NAME_IS_DEFAULT_DEF (expr), 1);
else
bp_pack_value (bp, 0, 1);
}
@ -544,14 +536,12 @@ pack_ts_block_value_fields (struct bitpack_d *bp, tree expr)
/* Pack all the non-pointer fields in EXPR into a bit pack. */
static struct bitpack_d *
pack_value_fields (tree expr)
static void
pack_value_fields (struct bitpack_d *bp, tree expr)
{
enum tree_code code;
struct bitpack_d *bp;
code = TREE_CODE (expr);
bp = bitpack_create ();
/* Note that all these functions are highly sensitive to changes in
the types and sizes of each of the fields being packed. */
@ -598,8 +588,6 @@ pack_value_fields (tree expr)
/* This is only used by High GIMPLE. */
gcc_unreachable ();
}
return bp;
}
@ -1294,7 +1282,7 @@ lto_output_builtin_tree (struct output_block *ob, tree expr, int ix)
static void
lto_write_tree (struct output_block *ob, tree expr, bool ref_p, int ix)
{
struct bitpack_d *bp;
struct bitpack_d bp;
/* Write the header, containing everything needed to materialize
EXPR on the reading side. */
@ -1302,9 +1290,9 @@ lto_write_tree (struct output_block *ob, tree expr, bool ref_p, int ix)
/* Pack all the non-pointer fields in EXPR into a bitpack and write
the resulting bitpack. */
bp = pack_value_fields (expr);
lto_output_bitpack (ob->main_stream, bp);
bitpack_delete (bp);
bp = bitpack_create (ob->main_stream);
pack_value_fields (&bp, expr);
lto_output_bitpack (&bp);
/* Write all the pointer fields in EXPR. */
lto_output_tree_pointers (ob, expr, ref_p);
@ -1661,7 +1649,7 @@ output_gimple_stmt (struct output_block *ob, gimple stmt)
unsigned i;
enum gimple_code code;
enum LTO_tags tag;
struct bitpack_d *bp;
struct bitpack_d bp;
/* Emit identifying tag. */
code = gimple_code (stmt);
@ -1669,15 +1657,14 @@ output_gimple_stmt (struct output_block *ob, gimple stmt)
output_record_start (ob, tag);
/* Emit the tuple header. */
bp = bitpack_create ();
bp_pack_value (bp, gimple_num_ops (stmt), sizeof (unsigned) * 8);
bp_pack_value (bp, gimple_no_warning_p (stmt), 1);
bp = bitpack_create (ob->main_stream);
bp_pack_value (&bp, gimple_num_ops (stmt), sizeof (unsigned) * 8);
bp_pack_value (&bp, gimple_no_warning_p (stmt), 1);
if (is_gimple_assign (stmt))
bp_pack_value (bp, gimple_assign_nontemporal_move_p (stmt), 1);
bp_pack_value (bp, gimple_has_volatile_ops (stmt), 1);
bp_pack_value (bp, stmt->gsbase.subcode, 16);
lto_output_bitpack (ob->main_stream, bp);
bitpack_delete (bp);
bp_pack_value (&bp, gimple_assign_nontemporal_move_p (stmt), 1);
bp_pack_value (&bp, gimple_has_volatile_ops (stmt), 1);
bp_pack_value (&bp, stmt->gsbase.subcode, 16);
lto_output_bitpack (&bp);
/* Emit location information for the statement. */
lto_output_location (ob, gimple_location (stmt));
@ -1848,7 +1835,7 @@ produce_asm (struct output_block *ob, tree fn)
static void
output_function (struct cgraph_node *node)
{
struct bitpack_d *bp;
struct bitpack_d bp;
tree function;
struct function *fn;
basic_block bb;
@ -1873,24 +1860,23 @@ output_function (struct cgraph_node *node)
output_record_start (ob, LTO_function);
/* Write all the attributes for FN. */
bp = bitpack_create ();
bp_pack_value (bp, fn->is_thunk, 1);
bp_pack_value (bp, fn->has_local_explicit_reg_vars, 1);
bp_pack_value (bp, fn->after_tree_profile, 1);
bp_pack_value (bp, fn->returns_pcc_struct, 1);
bp_pack_value (bp, fn->returns_struct, 1);
bp_pack_value (bp, fn->can_throw_non_call_exceptions, 1);
bp_pack_value (bp, fn->always_inline_functions_inlined, 1);
bp_pack_value (bp, fn->after_inlining, 1);
bp_pack_value (bp, fn->dont_save_pending_sizes_p, 1);
bp_pack_value (bp, fn->stdarg, 1);
bp_pack_value (bp, fn->has_nonlocal_label, 1);
bp_pack_value (bp, fn->calls_alloca, 1);
bp_pack_value (bp, fn->calls_setjmp, 1);
bp_pack_value (bp, fn->va_list_fpr_size, 8);
bp_pack_value (bp, fn->va_list_gpr_size, 8);
lto_output_bitpack (ob->main_stream, bp);
bitpack_delete (bp);
bp = bitpack_create (ob->main_stream);
bp_pack_value (&bp, fn->is_thunk, 1);
bp_pack_value (&bp, fn->has_local_explicit_reg_vars, 1);
bp_pack_value (&bp, fn->after_tree_profile, 1);
bp_pack_value (&bp, fn->returns_pcc_struct, 1);
bp_pack_value (&bp, fn->returns_struct, 1);
bp_pack_value (&bp, fn->can_throw_non_call_exceptions, 1);
bp_pack_value (&bp, fn->always_inline_functions_inlined, 1);
bp_pack_value (&bp, fn->after_inlining, 1);
bp_pack_value (&bp, fn->dont_save_pending_sizes_p, 1);
bp_pack_value (&bp, fn->stdarg, 1);
bp_pack_value (&bp, fn->has_nonlocal_label, 1);
bp_pack_value (&bp, fn->calls_alloca, 1);
bp_pack_value (&bp, fn->calls_setjmp, 1);
bp_pack_value (&bp, fn->va_list_fpr_size, 8);
bp_pack_value (&bp, fn->va_list_gpr_size, 8);
lto_output_bitpack (&bp);
/* Output current IL state of the function. */
output_uleb128 (ob, fn->curr_properties);

141
gcc/lto-streamer.c
View file

@ -266,147 +266,6 @@ print_lto_report (void)
lto_section_name[i], lto_stats.section_size[i]);
}
/* We cache a single bitpack assuming that usually at most one is
life. This saves repeated re-allocations. */
static struct bitpack_d *cached_bp;
/* Create a new bitpack. */
struct bitpack_d *
bitpack_create (void)
{
if (cached_bp)
{
struct bitpack_d *bp = cached_bp;
cached_bp = NULL;
return bp;
}
return XCNEW (struct bitpack_d);
}
/* Free the memory used by bitpack BP. */
void
bitpack_delete (struct bitpack_d *bp)
{
if (!cached_bp)
{
bp->num_bits = 0;
bp->first_unused_bit = 0;
VEC_truncate (bitpack_word_t, bp->values, 0);
cached_bp = bp;
return;
}
VEC_free (bitpack_word_t, heap, bp->values);
free (bp);
}
/* Return an index to the word in bitpack BP that contains the
next NBITS. */
static inline unsigned
bp_get_next_word (struct bitpack_d *bp, unsigned nbits)
{
unsigned last, ix;
/* In principle, the next word to use is determined by the
number of bits already processed in BP. */
ix = bp->num_bits / BITS_PER_BITPACK_WORD;
/* All the encoded bit patterns in BP are contiguous, therefore if
the next NBITS would straddle over two different words, move the
index to the next word and update the number of encoded bits
by adding up the hole of unused bits created by this move. */
bp->first_unused_bit %= BITS_PER_BITPACK_WORD;
last = bp->first_unused_bit + nbits - 1;
if (last >= BITS_PER_BITPACK_WORD)
{
ix++;
bp->num_bits += (BITS_PER_BITPACK_WORD - bp->first_unused_bit);
bp->first_unused_bit = 0;
}
return ix;
}
/* Pack NBITS of value VAL into bitpack BP. */
void
bp_pack_value (struct bitpack_d *bp, bitpack_word_t val, unsigned nbits)
{
unsigned ix;
bitpack_word_t word;
/* We cannot encode more bits than BITS_PER_BITPACK_WORD. */
#ifdef ENABLE_CHECKING
gcc_assert (nbits > 0 && nbits <= BITS_PER_BITPACK_WORD);
#endif
/* Compute which word will contain the next NBITS. */
ix = bp_get_next_word (bp, nbits);
if (ix >= VEC_length (bitpack_word_t, bp->values))
{
/* If there is no room left in the last word of the values
array, add a new word. Additionally, we should only
need to add a single word, since every pack operation cannot
use more bits than fit in a single word. */
VEC_safe_push (bitpack_word_t, heap, bp->values, 0);
}
/* Grab the last word to pack VAL into. */
word = VEC_index (bitpack_word_t, bp->values, ix);
/* To fit VAL in WORD, we need to shift VAL to the left to
skip the bottom BP->FIRST_UNUSED_BIT bits. */
val <<= bp->first_unused_bit;
/* Update WORD with VAL. */
word |= val;
/* Update BP. */
VEC_replace (bitpack_word_t, bp->values, ix, word);
bp->num_bits += nbits;
bp->first_unused_bit += nbits;
}
/* Unpack the next NBITS from bitpack BP. */
bitpack_word_t
bp_unpack_value (struct bitpack_d *bp, unsigned nbits)
{
bitpack_word_t val, word, mask;
unsigned ix;
/* We cannot decode more bits than BITS_PER_BITPACK_WORD. */
gcc_checking_assert (nbits > 0 && nbits <= BITS_PER_BITPACK_WORD);
/* Compute which word contains the next NBITS. */
ix = bp_get_next_word (bp, nbits);
word = VEC_index (bitpack_word_t, bp->values, ix);
/* Compute the mask to get NBITS from WORD. */
mask = (nbits == BITS_PER_BITPACK_WORD)
? (bitpack_word_t) -1
: ((bitpack_word_t) 1 << nbits) - 1;
/* Shift WORD to the right to skip over the bits already decoded
in word. */
word >>= bp->first_unused_bit;
/* Apply the mask to obtain the requested value. */
val = word & mask;
/* Update BP->NUM_BITS for the next unpack operation. */
bp->num_bits += nbits;
bp->first_unused_bit += nbits;
return val;
}
/* Check that all the TS_* structures handled by the lto_output_* and
lto_input_* routines are exactly ALL the structures defined in

102
gcc/lto-streamer.h
View file

@ -156,17 +156,14 @@ DEF_VEC_ALLOC_I(bitpack_word_t, heap);
struct bitpack_d
{
/* Total number of bits packed/unpacked so far. */
size_t num_bits;
/* The position of the first unused or unconsumed bit in the word. */
unsigned pos;
/* Values are stored contiguously, so there may be internal
fragmentation (words with unused bits). Therefore, we need to
keep track of the first available bit in the last word of the
bitpack. */
size_t first_unused_bit;
/* The current word we are (un)packing. */
bitpack_word_t word;
/* Vector of words holding the packed values. */
VEC(bitpack_word_t, heap) *values;
/* The lto_output_stream or the lto_input_block we are streaming to/from. */
void *stream;
};
/* Tags representing the various IL objects written to the bytecode file
@ -820,10 +817,6 @@ extern bitmap lto_bitmap_alloc (void);
extern void lto_bitmap_free (bitmap);
extern char *lto_get_section_name (int, const char *);
extern void print_lto_report (void);
extern struct bitpack_d *bitpack_create (void);
extern void bitpack_delete (struct bitpack_d *);
extern void bp_pack_value (struct bitpack_d *, bitpack_word_t, unsigned);
extern bitpack_word_t bp_unpack_value (struct bitpack_d *, unsigned);
extern bool lto_streamer_cache_insert (struct lto_streamer_cache_d *, tree,
int *, unsigned *);
extern bool lto_streamer_cache_insert_at (struct lto_streamer_cache_d *, tree,
@ -851,7 +844,6 @@ extern void lto_input_function_body (struct lto_file_decl_data *, tree,
const char *);
extern void lto_input_constructors_and_inits (struct lto_file_decl_data *,
const char *);
extern struct bitpack_d *lto_input_bitpack (struct lto_input_block *);
extern void lto_init_reader (void);
extern struct data_in *lto_data_in_create (struct lto_file_decl_data *,
const char *, unsigned,
@ -864,7 +856,6 @@ extern void lto_register_decl_definition (tree, struct lto_file_decl_data *);
extern struct output_block *create_output_block (enum lto_section_type);
extern void destroy_output_block (struct output_block *);
extern void lto_output_tree (struct output_block *, tree, bool);
extern void lto_output_bitpack (struct lto_output_stream *, struct bitpack_d *);
extern void produce_asm (struct output_block *ob, tree fn);
@ -1077,4 +1068,85 @@ DEFINE_DECL_STREAM_FUNCS (TYPE_DECL, type_decl)
DEFINE_DECL_STREAM_FUNCS (NAMESPACE_DECL, namespace_decl)
DEFINE_DECL_STREAM_FUNCS (LABEL_DECL, label_decl)
/* Returns a new bit-packing context for bit-packing into S. */
static inline struct bitpack_d
bitpack_create (struct lto_output_stream *s)
{
struct bitpack_d bp;
bp.pos = 0;
bp.word = 0;
bp.stream = (void *)s;
return bp;
}
/* Pack the NBITS bit sized value VAL into the bit-packing context BP. */
static inline void
bp_pack_value (struct bitpack_d *bp, bitpack_word_t val, unsigned nbits)
{
bitpack_word_t word = bp->word;
int pos = bp->pos;
/* If val does not fit into the current bitpack word switch to the
next one. */
if (pos + nbits > BITS_PER_BITPACK_WORD)
{
lto_output_uleb128_stream ((struct lto_output_stream *) bp->stream, word);
word = val;
pos = nbits;
}
else
{
word |= val << pos;
pos += nbits;
}
bp->word = word;
bp->pos = pos;
}
/* Finishes bit-packing of BP. */
static inline void
lto_output_bitpack (struct bitpack_d *bp)
{
lto_output_uleb128_stream ((struct lto_output_stream *) bp->stream,
bp->word);
bp->word = 0;
bp->pos = 0;
}
/* Returns a new bit-packing context for bit-unpacking from IB. */
static inline struct bitpack_d
lto_input_bitpack (struct lto_input_block *ib)
{
struct bitpack_d bp;
bp.word = lto_input_uleb128 (ib);
bp.pos = 0;
bp.stream = (void *)ib;
return bp;
}
/* Unpacks NBITS bits from the bit-packing context BP and returns them. */
static inline bitpack_word_t
bp_unpack_value (struct bitpack_d *bp, unsigned nbits)
{
bitpack_word_t mask, val;
int pos = bp->pos;
mask = (nbits == BITS_PER_BITPACK_WORD
? (bitpack_word_t) -1
: ((bitpack_word_t) 1 << nbits) - 1);
/* If there are not continuous nbits in the current bitpack word
switch to the next one. */
if (pos + nbits > BITS_PER_BITPACK_WORD)
{
bp->word = val = lto_input_uleb128 ((struct lto_input_block *)bp->stream);
bp->pos = nbits;
return val & mask;
}
val = bp->word;
val >>= pos;
bp->pos = pos + nbits;
return val & mask;
}
#endif /* GCC_LTO_STREAMER_H */