* data-streamer.h (streamer_write_zero): Rename from output_zero.

 	(streamer_write_uhwi): Rename from lto_output_uleb128.
 	(streamer_write_hwi): Rename from output_sleb128.
 	(streamer_write_string): Rename from lto_output_string.
 	(streamer_string_index): Rename from lto_string_index.
 	(streamer_write_string_with_length): Rename from
 	lto_output_string_with_length.
 	(streamer_write_uhwi_stream): Rename from lto_output_uleb128_stream.
 	(streamer_write_hwi_stream): Rename from lto_output_sleb128_stream.
 	(streamer_read_string): Rename from lto_input_string.
 	(streamer_read_indexed_string): Rename from input_string_internal.
 	(streamer_read_uhwi): Rename from lto_input_uleb128.
 	(streamer_read_hwi): Rename from lto_input_sleb128.
 	(streamer_write_hwi_in_range): Rename from lto_output_int_in_range.
 	(streamer_read_hwi_in_range): Rename from lto_input_int_in_range.
 	(streamer_write_enum): Rename from lto_output_enum.
 	(streamer_read_enum): Rename from lto_input_enum.
 	(streamer_write_record_start): Rename from output_record_start.
 	(streamer_read_record_start): Rename from input_record_start.
 	(streamer_write_bitpack): Rename from lto_output_bitpack.
 	(streamer_read_bitpack): Rename from lto_input_bitpack.
 	(streamer_write_char_stream): Rename from lto_output_1_stream.
 	(streamer_read_uchar): Rename from lto_input_1_unsigned.
 	* tree-streamer.h (streamer_cache_d): Rename from lto_streamer_cache_d.
 	(streamer_handle_as_builtin_p): Rename from lto_stream_as_builtin_p.
 	(streamer_read_string_cst): Rename from input_string_cst.
 	(streamer_read_chain): Rename from lto_input_chain.
 	(streamer_alloc_tree): Rename from lto_materialize_tree.
 	(streamer_read_tree_body): Rename from lto_input_tree_pointers.
 	(streamer_get_pickled_tree): Rename from lto_get_pickled_tree.
 	(streamer_get_builtin_tree): Rename from lto_get_builtin_tree.
 	(streamer_read_integer_cst): Rename from lto_input_integer_cst.
 	(streamer_read_tree_bitfields): Rename from tree_read_bitfields.
 	(streamer_write_chain): Rename from lto_output_chain.
 	(streamer_write_tree_header): Rename from lto_output_tree_header.
 	(streamer_pack_tree_bitfields): Rename from pack_value_fields.
 	(streamer_write_tree_body): Rename from lto_output_tree_pointers.
 	(streamer_write_integer_cst): Rename from lto_output_integer_cst.
 	(streamer_write_builtin): Rename from lto_output_builtin_tree.
 	(streamer_check_handled_ts_structures): Rename from
 	check_handled_ts_structures.
 	(streamer_tree_cache_insert): Rename from lto_streamer_cache_insert.
 	(streamer_tree_cache_insert_at): Rename from
 	lto_streamer_cache_insert_at.
 	(streamer_tree_cache_append): Rename from lto_streamer_cache_append.
 	(streamer_tree_cache_lookup): Rename from lto_streamer_cache_lookup.
 	(streamer_tree_cache_get): Rename from lto_streamer_cache_get.
 	(streamer_tree_cache_create): Rename from lto_streamer_cache_create.
 	(streamer_tree_cache_delete): Rename from lto_streamer_cache_delete.
 	* tree-streamer-out.c (write_string_cst): Rename from output_string_cst.
 	(write_identifier): Rename from output_identifier.
 	(write_ts_common_tree_pointers): Rename from
 	lto_output_ts_common_tree_pointers.
 	(write_ts_vector_tree_pointers): Rename from
 	lto_output_ts_vector_tree_pointers.
 	(write_ts_complex_tree_pointers): Rename from
 	lto_output_ts_complex_tree_pointers.
 	(write_ts_decl_minimal_tree_pointers): Rename from
 	lto_output_ts_decl_minimal_tree_pointers.
 	(write_ts_decl_common_tree_pointers): Rename from
 	lto_output_ts_decl_common_tree_pointers.
 	(write_ts_decl_non_common_tree_pointers): Rename from
 	lto_output_ts_decl_non_common_tree_pointers.
 	(write_ts_decl_with_vis_tree_pointers): Rename from
 	lto_output_ts_decl_with_vis_tree_pointers.
 	(write_ts_field_decl_tree_pointers): Rename from
 	lto_output_ts_field_decl_tree_pointers.
 	(write_ts_function_decl_tree_pointers): Rename from
 	lto_output_ts_function_decl_tree_pointers.
 	(write_ts_type_common_tree_pointers): Rename from
 	lto_output_ts_type_common_tree_pointers.
 	(write_ts_type_non_common_tree_pointers): Rename from
 	lto_output_ts_type_non_common_tree_pointers.
 	(write_ts_list_tree_pointers): Rename from
 	lto_output_ts_list_tree_pointers.
 	(write_ts_vec_tree_pointers): Rename from
 	lto_output_ts_vec_tree_pointers.
 	(write_ts_exp_tree_pointers): Rename from
 	lto_output_ts_exp_tree_pointers.
 	(write_ts_block_tree_pointers): Rename from
 	lto_output_ts_block_tree_pointers.
 	(write_ts_binfo_tree_pointers): Rename from
 	lto_output_ts_binfo_tree_pointers.
 	(write_ts_constructor_tree_pointers): Rename from
 	lto_output_ts_constructor_tree_pointers.
 	(write_ts_target_option): Rename from
 	lto_output_ts_target_option.
 	(write_ts_translation_unit_decl_tree_pointers): Rename from
 	lto_output_ts_translation_unit_decl_tree_pointers.
 	* tree-streamer.c (streamer_tree_cache_add_to_node_array):
 	Rename from lto_streamer_cache_add_to_node_array.
 	(streamer_tree_cache_insert_1): Rename from lto_streamer_cache_insert_1.
 	(record_common_node): Rename from lto_record_common_node.

	* streamer-hooks.h (bitpack_d, lto_streamer_cache_d): Remove forward
	declarations.
	* data-streamer-in.c (lto_input_widest_uint_uleb128): Remove unused
	function.
	* data-streamer-out.c (lto_output_widest_uint_uleb128_stream): Remove
	unused function.
	* Makefile.in (lto-section-out.o): Add dependency on DATA_STREAMER_H.
	(ipa-reference.o): Likewise.
	* lto-section-out.c: Include data-streamer.h.
	* ipa-reference.c: Include data-streamer.h.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@177704 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 107 insertions, 109 deletions

diff --git a/gcc/lto-cgraph.c b/gcc/lto-cgraph.c
index 126ba5a01d8..5bcc342d83f 100644
--- a/gcc/lto-cgraph.c
+++ b/gcc/lto-cgraph.c
@@ -267,24 +267,24 @@ lto_output_edge (struct lto_simple_output_block *ob, struct cgraph_edge *edge,
   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)
@@ -312,7 +312,7 @@ lto_output_edge (struct lto_simple_output_block *ob, struct cgraph_edge *edge,
 			     | ECF_LEAF
 			     | ECF_NOVOPS)));
     }
-  lto_output_bitpack (&bp);
+  streamer_write_bitpack (&bp);
 }
 
 /* Return if LIST contain references from other partitions.  */
@@ -423,7 +423,8 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
   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);
 
   /* In WPA mode, we only output part of the call-graph.  Also, we
      fake cgraph node attributes.  There are two cases that we care.
@@ -459,14 +460,14 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
   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)
     {
@@ -478,7 +479,7 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *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)
@@ -488,7 +489,7 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
     }
   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);
@@ -513,23 +514,21 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
   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);
+      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)
     {
-      lto_output_int_in_range (ob->main_stream, 0, 1,
-			       node->thunk.alias != NULL);
+      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);
@@ -573,7 +572,7 @@ lto_output_varpool_node (struct lto_simple_output_block *ob, struct varpool_node
 							   set, vset), 1);
       bp_pack_value (&bp, boundary_p, 1);  /* in_other_partition.  */
     }
-  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)
@@ -583,9 +582,9 @@ lto_output_varpool_node (struct lto_simple_output_block *ob, struct varpool_node
     }
   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);
+  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. 
@@ -600,19 +599,19 @@ lto_output_ref (struct lto_simple_output_block *ob, struct ipa_ref *ref,
   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);
     }
 }
 
@@ -627,11 +626,11 @@ output_profile_summary (struct lto_simple_output_block *ob)
 	 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.
@@ -709,15 +708,15 @@ output_refs (cgraph_node_set set, varpool_node_set vset,
       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))
     {
@@ -726,8 +725,8 @@ output_refs (cgraph_node_set set, varpool_node_set vset,
       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++)
@@ -735,7 +734,7 @@ output_refs (cgraph_node_set set, varpool_node_set vset,
 	}
     }
 
-  lto_output_uleb128_stream (ob->main_stream, 0);
+  streamer_write_uhwi_stream (ob->main_stream, 0);
 
   lto_destroy_simple_output_block (ob);
 }
@@ -852,7 +851,7 @@ output_cgraph (cgraph_node_set set, varpool_node_set vset)
       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);
 
   /* Emit toplevel asms.
      When doing WPA we must output every asm just once.  Since we do not partition asm
@@ -864,14 +863,14 @@ output_cgraph (cgraph_node_set set, varpool_node_set vset)
       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);
+	  streamer_write_uhwi_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]);
+	    streamer_write_char_stream (ob->main_stream,
+					TREE_STRING_POINTER (can->asm_str)[i]);
 	}
     }
 
-  lto_output_uleb128_stream (ob->main_stream, 0);
+  streamer_write_uhwi_stream (ob->main_stream, 0);
 
   lto_destroy_simple_output_block (ob);
   output_varpool (set, vset);
@@ -938,7 +937,7 @@ output_varpool (cgraph_node_set set, varpool_node_set vset)
   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
@@ -969,9 +968,9 @@ input_node (struct lto_file_decl_data *file_data,
   int ref = LCC_NOT_FOUND, ref2 = LCC_NOT_FOUND;
   int clone_ref;
 
-  clone_ref = lto_input_sleb128 (ib);
+  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)
@@ -982,13 +981,13 @@ input_node (struct lto_file_decl_data *file_data,
   else
     node = cgraph_get_create_node (fn_decl);
 
-  node->count = lto_input_sleb128 (ib);
-  node->count_materialization_scale = lto_input_sleb128 (ib);
+  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'
@@ -998,7 +997,7 @@ input_node (struct lto_file_decl_data *file_data,
     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.  */
@@ -1009,9 +1008,9 @@ input_node (struct lto_file_decl_data *file_data,
 
   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);
+      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);
@@ -1020,9 +1019,9 @@ input_node (struct lto_file_decl_data *file_data,
     }
   if (node->thunk.thunk_p || node->alias)
     {
-      if (lto_input_int_in_range (ib, "alias nonzero flag", 0, 1))
+      if (streamer_read_hwi_in_range (ib, "alias nonzero flag", 0, 1))
 	{
-          decl_index = lto_input_uleb128 (ib);
+          decl_index = streamer_read_uhwi (ib);
           node->thunk.alias = lto_file_decl_data_get_fn_decl (file_data,
 							      decl_index);
 	}
@@ -1044,12 +1043,12 @@ input_varpool_node (struct lto_file_decl_data *file_data,
   int ref = LCC_NOT_FOUND;
   bool non_null_aliasof;
 
-  decl_index = lto_input_uleb128 (ib);
+  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->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);
@@ -1067,14 +1066,14 @@ input_varpool_node (struct lto_file_decl_data *file_data,
     varpool_mark_needed_node (node);
   if (non_null_aliasof)
     {
-      decl_index = 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 = lto_input_sleb128 (ib);
+  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 = lto_input_enum (ib, ld_plugin_symbol_resolution,
-				     LDPR_NUM_KNOWN);
+  node->resolution = streamer_read_enum (ib, ld_plugin_symbol_resolution,
+					 LDPR_NUM_KNOWN);
 
   return node;
 }
@@ -1095,13 +1094,14 @@ input_ref (struct lto_input_block *ib,
   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);
 }
@@ -1124,22 +1124,22 @@ input_edge (struct lto_input_block *ib, VEC(cgraph_node_ptr, heap) *nodes,
   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);
@@ -1185,7 +1185,7 @@ input_cgraph_1 (struct lto_file_decl_data *file_data,
   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);
   while (tag)
     {
       if (tag == LTO_cgraph_edge)
@@ -1201,20 +1201,20 @@ input_cgraph_1 (struct lto_file_decl_data *file_data,
 	  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);
+  len = streamer_read_uhwi (ib);
   while (len)
     {
       char *str = (char *)xmalloc (len + 1);
       for (i = 0; i < len; ++i)
-	str[i] = lto_input_1_unsigned (ib);
+	str[i] = streamer_read_uchar (ib);
       cgraph_add_asm_node (build_string (len, str));
       free (str);
 
-      len = lto_input_uleb128 (ib);
+      len = streamer_read_uhwi (ib);
     }
   /* AUX pointers should be all non-zero for nodes read from the stream.  */
 #ifdef ENABLE_CHECKING
@@ -1260,7 +1260,7 @@ input_varpool_1 (struct lto_file_decl_data *file_data,
   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,
@@ -1302,10 +1302,10 @@ input_refs (struct lto_input_block *ib,
   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)
 	{
@@ -1316,10 +1316,11 @@ input_refs (struct lto_input_block *ib,
   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);
@@ -1336,11 +1337,11 @@ static void
 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);
     }
 
 }
@@ -1528,10 +1529,9 @@ output_edge_opt_summary (struct output_block *ob,
 			 struct cgraph_edge *edge)
 {
   if (edge->indirect_info)
-    lto_output_sleb128_stream (ob->main_stream,
-			       edge->indirect_info->thunk_delta);
+    streamer_write_hwi (ob, edge->indirect_info->thunk_delta);
   else
-    lto_output_sleb128_stream (ob->main_stream, 0);
+    streamer_write_hwi (ob, 0);
 }
 
 /* Output optimization summary for NODE to OB.  */
@@ -1550,24 +1550,22 @@ output_node_opt_summary (struct output_block *ob,
 
   if (node->clone.args_to_skip)
     {
-      lto_output_uleb128_stream (ob->main_stream,
-				 bitmap_count_bits (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)
-	lto_output_uleb128_stream (ob->main_stream, index);
+	streamer_write_uhwi (ob, index);
     }
   else
-    lto_output_uleb128_stream (ob->main_stream, 0);
+    streamer_write_uhwi (ob, 0);
   if (node->clone.combined_args_to_skip)
     {
-      lto_output_uleb128_stream (ob->main_stream,
-				 bitmap_count_bits (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)
-	lto_output_uleb128_stream (ob->main_stream, index);
+	streamer_write_uhwi (ob, index);
     }
   else
-    lto_output_uleb128_stream (ob->main_stream, 0);
-  lto_output_uleb128_stream (ob->main_stream,
-		             VEC_length (ipa_replace_map_p, node->clone.tree_map));
+    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;
@@ -1580,12 +1578,12 @@ output_node_opt_summary (struct output_block *ob,
       /* 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);
+      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))
@@ -1616,13 +1614,13 @@ output_cgraph_opt_summary (cgraph_node_set 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);
 	}
     }
@@ -1637,7 +1635,7 @@ input_edge_opt_summary (struct cgraph_edge *edge,
 			struct lto_input_block *ib_main)
 {
   HOST_WIDE_INT thunk_delta;
-  thunk_delta = lto_input_sleb128 (ib_main);
+  thunk_delta = streamer_read_hwi (ib_main);
   if (thunk_delta != 0)
     {
       gcc_assert (!edge->indirect_info);
@@ -1659,23 +1657,23 @@ input_node_opt_summary (struct cgraph_node *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;
@@ -1686,10 +1684,10 @@ input_node_opt_summary (struct cgraph_node *node,
       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 = stream_read_tree (ib_main, data_in);
-      bp = lto_input_bitpack (ib_main);
+      bp = streamer_read_bitpack (ib_main);
       map->replace_p = bp_unpack_value (&bp, 1);
       map->ref_p = bp_unpack_value (&bp, 1);
     }
@@ -1722,11 +1720,11 @@ input_cgraph_opt_section (struct lto_file_decl_data *file_data,
   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);
     }