* 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, 101 insertions, 106 deletions

diff --git a/gcc/tree-streamer-out.c b/gcc/tree-streamer-out.c
index 8bab9304b74..61e674ab4f7 100644
--- a/gcc/tree-streamer-out.c
+++ b/gcc/tree-streamer-out.c
@@ -32,14 +32,14 @@ along with GCC; see the file COPYING3.  If not see
    table in OB.  Then put the index onto the INDEX_STREAM.  */
 
 static void
-output_string_cst (struct output_block *ob,
+write_string_cst (struct output_block *ob,
 		   struct lto_output_stream *index_stream,
 		   tree string)
 {
-  lto_output_string_with_length (ob, index_stream,
-				 TREE_STRING_POINTER (string),
-				 TREE_STRING_LENGTH (string),
-				 true);
+  streamer_write_string_with_length (ob, index_stream,
+				     TREE_STRING_POINTER (string),
+				     TREE_STRING_LENGTH (string),
+				     true);
 }
 
 
@@ -47,14 +47,14 @@ output_string_cst (struct output_block *ob,
    table in OB.  Then put the index onto the INDEX_STREAM.  */
 
 static void
-output_identifier (struct output_block *ob,
+write_identifier (struct output_block *ob,
 		   struct lto_output_stream *index_stream,
 		   tree id)
 {
-  lto_output_string_with_length (ob, index_stream,
-				 IDENTIFIER_POINTER (id),
-				 IDENTIFIER_LENGTH (id),
-				 true);
+  streamer_write_string_with_length (ob, index_stream,
+				     IDENTIFIER_POINTER (id),
+				     IDENTIFIER_LENGTH (id),
+				     true);
 }
 
 
@@ -235,7 +235,7 @@ pack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
 {
   /* For normal/md builtins we only write the class and code, so they
      should never be handled here.  */
-  gcc_assert (!lto_stream_as_builtin_p (expr));
+  gcc_assert (!streamer_handle_as_builtin_p (expr));
 
   bp_pack_enum (bp, built_in_class, BUILT_IN_LAST,
 		DECL_BUILT_IN_CLASS (expr));
@@ -303,10 +303,11 @@ pack_ts_translation_unit_decl_value_fields (struct bitpack_d *bp ATTRIBUTE_UNUSE
 {
 }
 
-/* Pack all the non-pointer fields in EXPR into a bit pack.  */
+
+/* Pack all the bitfields in EXPR into a bit pack.  */
 
 void
-pack_value_fields (struct bitpack_d *bp, tree expr)
+streamer_pack_tree_bitfields (struct bitpack_d *bp, tree expr)
 {
   enum tree_code code;
 
@@ -349,19 +350,19 @@ pack_value_fields (struct bitpack_d *bp, tree expr)
    the index into the streamer cache where EXPR is stored.*/
 
 void
-lto_output_builtin_tree (struct output_block *ob, tree expr)
+streamer_write_builtin (struct output_block *ob, tree expr)
 {
-  gcc_assert (lto_stream_as_builtin_p (expr));
+  gcc_assert (streamer_handle_as_builtin_p (expr));
 
   if (DECL_BUILT_IN_CLASS (expr) == BUILT_IN_MD
       && !targetm.builtin_decl)
-    sorry ("gimple bytecode streams do not support machine specific builtin "
+    sorry ("tree bytecode streams do not support machine specific builtin "
 	   "functions on this target");
 
-  output_record_start (ob, LTO_builtin_decl);
-  lto_output_enum (ob->main_stream, built_in_class, BUILT_IN_LAST,
-		   DECL_BUILT_IN_CLASS (expr));
-  output_uleb128 (ob, DECL_FUNCTION_CODE (expr));
+  streamer_write_record_start (ob, LTO_builtin_decl);
+  streamer_write_enum (ob->main_stream, built_in_class, BUILT_IN_LAST,
+		       DECL_BUILT_IN_CLASS (expr));
+  streamer_write_uhwi (ob, DECL_FUNCTION_CODE (expr));
 
   if (DECL_ASSEMBLER_NAME_SET_P (expr))
     {
@@ -371,12 +372,12 @@ lto_output_builtin_tree (struct output_block *ob, tree expr)
 	 reader side from adding a second '*', we omit it here.  */
       const char *str = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (expr));
       if (strlen (str) > 1 && str[0] == '*')
-	lto_output_string (ob, ob->main_stream, &str[1], true);
+	streamer_write_string (ob, ob->main_stream, &str[1], true);
       else
-	lto_output_string (ob, ob->main_stream, NULL, true);
+	streamer_write_string (ob, ob->main_stream, NULL, true);
     }
   else
-    lto_output_string (ob, ob->main_stream, NULL, true);
+    streamer_write_string (ob, ob->main_stream, NULL, true);
 }
 
 
@@ -385,12 +386,12 @@ lto_output_builtin_tree (struct output_block *ob, tree expr)
    as references.  */
 
 void
-lto_output_chain (struct output_block *ob, tree t, bool ref_p)
+streamer_write_chain (struct output_block *ob, tree t, bool ref_p)
 {
   int i, count;
 
   count = list_length (t);
-  output_sleb128 (ob, count);
+  streamer_write_hwi (ob, count);
   for (i = 0; i < count; i++)
     {
       tree saved_chain;
@@ -413,8 +414,7 @@ lto_output_chain (struct output_block *ob, tree t, bool ref_p)
    fields.  */
 
 static void
-lto_output_ts_common_tree_pointers (struct output_block *ob, tree expr,
-				    bool ref_p)
+write_ts_common_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 {
   if (TREE_CODE (expr) != IDENTIFIER_NODE)
     stream_write_tree (ob, TREE_TYPE (expr), ref_p);
@@ -426,10 +426,9 @@ lto_output_ts_common_tree_pointers (struct output_block *ob, tree expr,
    fields.  */
 
 static void
-lto_output_ts_vector_tree_pointers (struct output_block *ob, tree expr,
-				    bool ref_p)
+write_ts_vector_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 {
-  lto_output_chain (ob, TREE_VECTOR_CST_ELTS (expr), ref_p);
+  streamer_write_chain (ob, TREE_VECTOR_CST_ELTS (expr), ref_p);
 }
 
 
@@ -438,8 +437,7 @@ lto_output_ts_vector_tree_pointers (struct output_block *ob, tree expr,
    fields.  */
 
 static void
-lto_output_ts_complex_tree_pointers (struct output_block *ob, tree expr,
-				     bool ref_p)
+write_ts_complex_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 {
   stream_write_tree (ob, TREE_REALPART (expr), ref_p);
   stream_write_tree (ob, TREE_IMAGPART (expr), ref_p);
@@ -451,8 +449,8 @@ lto_output_ts_complex_tree_pointers (struct output_block *ob, tree expr,
    pointer fields.  */
 
 static void
-lto_output_ts_decl_minimal_tree_pointers (struct output_block *ob, tree expr,
-					  bool ref_p)
+write_ts_decl_minimal_tree_pointers (struct output_block *ob, tree expr,
+				     bool ref_p)
 {
   stream_write_tree (ob, DECL_NAME (expr), ref_p);
   stream_write_tree (ob, DECL_CONTEXT (expr), ref_p);
@@ -465,8 +463,8 @@ lto_output_ts_decl_minimal_tree_pointers (struct output_block *ob, tree expr,
    pointer fields.  */
 
 static void
-lto_output_ts_decl_common_tree_pointers (struct output_block *ob, tree expr,
-					 bool ref_p)
+write_ts_decl_common_tree_pointers (struct output_block *ob, tree expr,
+				    bool ref_p)
 {
   stream_write_tree (ob, DECL_SIZE (expr), ref_p);
   stream_write_tree (ob, DECL_SIZE_UNIT (expr), ref_p);
@@ -481,7 +479,7 @@ lto_output_ts_decl_common_tree_pointers (struct output_block *ob, tree expr,
      dwarf2out.c.  */
 
   if (TREE_CODE (expr) == PARM_DECL)
-    lto_output_chain (ob, TREE_CHAIN (expr), ref_p);
+    streamer_write_chain (ob, TREE_CHAIN (expr), ref_p);
 
   if ((TREE_CODE (expr) == VAR_DECL
        || TREE_CODE (expr) == PARM_DECL)
@@ -498,8 +496,8 @@ lto_output_ts_decl_common_tree_pointers (struct output_block *ob, tree expr,
    pointer fields.  */
 
 static void
-lto_output_ts_decl_non_common_tree_pointers (struct output_block *ob,
-					     tree expr, bool ref_p)
+write_ts_decl_non_common_tree_pointers (struct output_block *ob, tree expr,
+				        bool ref_p)
 {
   if (TREE_CODE (expr) == FUNCTION_DECL)
     {
@@ -515,8 +513,8 @@ lto_output_ts_decl_non_common_tree_pointers (struct output_block *ob,
    pointer fields.  */
 
 static void
-lto_output_ts_decl_with_vis_tree_pointers (struct output_block *ob, tree expr,
-					   bool ref_p)
+write_ts_decl_with_vis_tree_pointers (struct output_block *ob, tree expr,
+			              bool ref_p)
 {
   /* Make sure we don't inadvertently set the assembler name.  */
   if (DECL_ASSEMBLER_NAME_SET_P (expr))
@@ -534,15 +532,15 @@ lto_output_ts_decl_with_vis_tree_pointers (struct output_block *ob, tree expr,
    pointer fields.  */
 
 static void
-lto_output_ts_field_decl_tree_pointers (struct output_block *ob, tree expr,
-					bool ref_p)
+write_ts_field_decl_tree_pointers (struct output_block *ob, tree expr,
+				   bool ref_p)
 {
   stream_write_tree (ob, DECL_FIELD_OFFSET (expr), ref_p);
   stream_write_tree (ob, DECL_BIT_FIELD_TYPE (expr), ref_p);
   stream_write_tree (ob, DECL_QUALIFIER (expr), ref_p);
   stream_write_tree (ob, DECL_FIELD_BIT_OFFSET (expr), ref_p);
   stream_write_tree (ob, DECL_FCONTEXT (expr), ref_p);
-  lto_output_chain (ob, TREE_CHAIN (expr), ref_p);
+  streamer_write_chain (ob, TREE_CHAIN (expr), ref_p);
 }
 
 
@@ -551,8 +549,8 @@ lto_output_ts_field_decl_tree_pointers (struct output_block *ob, tree expr,
    pointer fields.  */
 
 static void
-lto_output_ts_function_decl_tree_pointers (struct output_block *ob, tree expr,
-					   bool ref_p)
+write_ts_function_decl_tree_pointers (struct output_block *ob, tree expr,
+				      bool ref_p)
 {
   /* DECL_STRUCT_FUNCTION is handled by lto_output_function.  FIXME lto,
      maybe it should be handled here?  */
@@ -567,8 +565,8 @@ lto_output_ts_function_decl_tree_pointers (struct output_block *ob, tree expr,
    pointer fields.  */
 
 static void
-lto_output_ts_type_common_tree_pointers (struct output_block *ob, tree expr,
-					 bool ref_p)
+write_ts_type_common_tree_pointers (struct output_block *ob, tree expr,
+				    bool ref_p)
 {
   stream_write_tree (ob, TYPE_SIZE (expr), ref_p);
   stream_write_tree (ob, TYPE_SIZE_UNIT (expr), ref_p);
@@ -590,8 +588,8 @@ lto_output_ts_type_common_tree_pointers (struct output_block *ob, tree expr,
    pointer fields.  */
 
 static void
-lto_output_ts_type_non_common_tree_pointers (struct output_block *ob,
-					     tree expr, bool ref_p)
+write_ts_type_non_common_tree_pointers (struct output_block *ob, tree expr,
+					bool ref_p)
 {
   if (TREE_CODE (expr) == ENUMERAL_TYPE)
     stream_write_tree (ob, TYPE_VALUES (expr), ref_p);
@@ -616,12 +614,11 @@ lto_output_ts_type_non_common_tree_pointers (struct output_block *ob,
    fields.  */
 
 static void
-lto_output_ts_list_tree_pointers (struct output_block *ob, tree expr,
-				  bool ref_p)
+write_ts_list_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 {
   stream_write_tree (ob, TREE_PURPOSE (expr), ref_p);
   stream_write_tree (ob, TREE_VALUE (expr), ref_p);
-  lto_output_chain (ob, TREE_CHAIN (expr), ref_p);
+  streamer_write_chain (ob, TREE_CHAIN (expr), ref_p);
 }
 
 
@@ -630,12 +627,12 @@ lto_output_ts_list_tree_pointers (struct output_block *ob, tree expr,
    fields.  */
 
 static void
-lto_output_ts_vec_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
+write_ts_vec_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 {
   int i;
 
   /* Note that the number of slots for EXPR has already been emitted
-     in EXPR's header (see lto_output_tree_header).  */
+     in EXPR's header (see streamer_write_tree_header).  */
   for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
     stream_write_tree (ob, TREE_VEC_ELT (expr, i), ref_p);
 }
@@ -646,11 +643,11 @@ lto_output_ts_vec_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
    fields.  */
 
 static void
-lto_output_ts_exp_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
+write_ts_exp_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 {
   int i;
 
-  output_sleb128 (ob, TREE_OPERAND_LENGTH (expr));
+  streamer_write_hwi (ob, TREE_OPERAND_LENGTH (expr));
   for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
     stream_write_tree (ob, TREE_OPERAND (expr, i), ref_p);
   lto_output_location (ob, EXPR_LOCATION (expr));
@@ -663,13 +660,12 @@ lto_output_ts_exp_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
    fields.  */
 
 static void
-lto_output_ts_block_tree_pointers (struct output_block *ob, tree expr,
-				   bool ref_p)
+write_ts_block_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 {
   /* Do not stream BLOCK_SOURCE_LOCATION.  We cannot handle debug information
      for early inlining so drop it on the floor instead of ICEing in
      dwarf2out.c.  */
-  lto_output_chain (ob, BLOCK_VARS (expr), ref_p);
+  streamer_write_chain (ob, BLOCK_VARS (expr), ref_p);
 
   /* Do not stream BLOCK_NONLOCALIZED_VARS.  We cannot handle debug information
      for early inlining so drop it on the floor instead of ICEing in
@@ -691,14 +687,13 @@ lto_output_ts_block_tree_pointers (struct output_block *ob, tree expr,
    fields.  */
 
 static void
-lto_output_ts_binfo_tree_pointers (struct output_block *ob, tree expr,
-				   bool ref_p)
+write_ts_binfo_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
 {
   unsigned i;
   tree t;
 
   /* Note that the number of BINFO slots has already been emitted in
-     EXPR's header (see lto_output_tree_header) because this length
+     EXPR's header (see streamer_write_tree_header) because this length
      is needed to build the empty BINFO node on the reader side.  */
   FOR_EACH_VEC_ELT (tree, BINFO_BASE_BINFOS (expr), i, t)
     stream_write_tree (ob, t, ref_p);
@@ -713,7 +708,7 @@ lto_output_ts_binfo_tree_pointers (struct output_block *ob, tree expr,
   stream_write_tree (ob, flag_wpa ? NULL : BINFO_VIRTUALS (expr), ref_p);
   stream_write_tree (ob, BINFO_VPTR_FIELD (expr), ref_p);
 
-  output_uleb128 (ob, VEC_length (tree, BINFO_BASE_ACCESSES (expr)));
+  streamer_write_uhwi (ob, VEC_length (tree, BINFO_BASE_ACCESSES (expr)));
   FOR_EACH_VEC_ELT (tree, BINFO_BASE_ACCESSES (expr), i, t)
     stream_write_tree (ob, t, ref_p);
 
@@ -728,13 +723,13 @@ lto_output_ts_binfo_tree_pointers (struct output_block *ob, tree expr,
    pointer fields.  */
 
 static void
-lto_output_ts_constructor_tree_pointers (struct output_block *ob, tree expr,
-					 bool ref_p)
+write_ts_constructor_tree_pointers (struct output_block *ob, tree expr,
+				    bool ref_p)
 {
   unsigned i;
   tree index, value;
 
-  output_uleb128 (ob, CONSTRUCTOR_NELTS (expr));
+  streamer_write_uhwi (ob, CONSTRUCTOR_NELTS (expr));
   FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value)
     {
       stream_write_tree (ob, index, ref_p);
@@ -745,7 +740,7 @@ lto_output_ts_constructor_tree_pointers (struct output_block *ob, tree expr,
 /* Write a TS_TARGET_OPTION tree in EXPR to OB.  */
 
 static void
-lto_output_ts_target_option (struct output_block *ob, tree expr)
+write_ts_target_option (struct output_block *ob, tree expr)
 {
   struct cl_target_option *t = TREE_TARGET_OPTION (expr);
   struct bitpack_d bp;
@@ -760,85 +755,85 @@ lto_output_ts_target_option (struct output_block *ob, tree expr)
     bp_pack_value (&bp, ((unsigned char *)t)[i], 8);
   /* Catch struct size mismatches between reader and writer. */
   bp_pack_value (&bp, 0x12345678, 32);
-  lto_output_bitpack (&bp);
+  streamer_write_bitpack (&bp);
 }
 
 /* Write a TS_TRANSLATION_UNIT_DECL tree in EXPR to OB.  */
 
 static void
-lto_output_ts_translation_unit_decl_tree_pointers (struct output_block *ob,
-						   tree expr)
+write_ts_translation_unit_decl_tree_pointers (struct output_block *ob,
+					      tree expr)
 {
-  lto_output_string (ob, ob->main_stream,
-		     TRANSLATION_UNIT_LANGUAGE (expr), true);
+  streamer_write_string (ob, ob->main_stream,
+			 TRANSLATION_UNIT_LANGUAGE (expr), true);
 }
 
 /* Write all pointer fields in EXPR to output block OB.  If REF_P is true,
    the leaves of EXPR are emitted as references.  */
 
 void
-lto_output_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
+streamer_write_tree_body (struct output_block *ob, tree expr, bool ref_p)
 {
   enum tree_code code;
 
   code = TREE_CODE (expr);
 
   if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
-    lto_output_ts_common_tree_pointers (ob, expr, ref_p);
+    write_ts_common_tree_pointers (ob, expr, ref_p);
 
   if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
-    lto_output_ts_vector_tree_pointers (ob, expr, ref_p);
+    write_ts_vector_tree_pointers (ob, expr, ref_p);
 
   if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
-    lto_output_ts_complex_tree_pointers (ob, expr, ref_p);
+    write_ts_complex_tree_pointers (ob, expr, ref_p);
 
   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
-    lto_output_ts_decl_minimal_tree_pointers (ob, expr, ref_p);
+    write_ts_decl_minimal_tree_pointers (ob, expr, ref_p);
 
   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
-    lto_output_ts_decl_common_tree_pointers (ob, expr, ref_p);
+    write_ts_decl_common_tree_pointers (ob, expr, ref_p);
 
   if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
-    lto_output_ts_decl_non_common_tree_pointers (ob, expr, ref_p);
+    write_ts_decl_non_common_tree_pointers (ob, expr, ref_p);
 
   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
-    lto_output_ts_decl_with_vis_tree_pointers (ob, expr, ref_p);
+    write_ts_decl_with_vis_tree_pointers (ob, expr, ref_p);
 
   if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
-    lto_output_ts_field_decl_tree_pointers (ob, expr, ref_p);
+    write_ts_field_decl_tree_pointers (ob, expr, ref_p);
 
   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
-    lto_output_ts_function_decl_tree_pointers (ob, expr, ref_p);
+    write_ts_function_decl_tree_pointers (ob, expr, ref_p);
 
   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
-    lto_output_ts_type_common_tree_pointers (ob, expr, ref_p);
+    write_ts_type_common_tree_pointers (ob, expr, ref_p);
 
   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
-    lto_output_ts_type_non_common_tree_pointers (ob, expr, ref_p);
+    write_ts_type_non_common_tree_pointers (ob, expr, ref_p);
 
   if (CODE_CONTAINS_STRUCT (code, TS_LIST))
-    lto_output_ts_list_tree_pointers (ob, expr, ref_p);
+    write_ts_list_tree_pointers (ob, expr, ref_p);
 
   if (CODE_CONTAINS_STRUCT (code, TS_VEC))
-    lto_output_ts_vec_tree_pointers (ob, expr, ref_p);
+    write_ts_vec_tree_pointers (ob, expr, ref_p);
 
   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
-    lto_output_ts_exp_tree_pointers (ob, expr, ref_p);
+    write_ts_exp_tree_pointers (ob, expr, ref_p);
 
   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
-    lto_output_ts_block_tree_pointers (ob, expr, ref_p);
+    write_ts_block_tree_pointers (ob, expr, ref_p);
 
   if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
-    lto_output_ts_binfo_tree_pointers (ob, expr, ref_p);
+    write_ts_binfo_tree_pointers (ob, expr, ref_p);
 
   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
-    lto_output_ts_constructor_tree_pointers (ob, expr, ref_p);
+    write_ts_constructor_tree_pointers (ob, expr, ref_p);
 
   if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
-    lto_output_ts_target_option (ob, expr);
+    write_ts_target_option (ob, expr);
 
   if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
-    lto_output_ts_translation_unit_decl_tree_pointers (ob, expr);
+    write_ts_translation_unit_decl_tree_pointers (ob, expr);
 }
 
 
@@ -848,7 +843,7 @@ lto_output_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
    where EXPR is stored.  */
 
 void
-lto_output_tree_header (struct output_block *ob, tree expr)
+streamer_write_tree_header (struct output_block *ob, tree expr)
 {
   enum LTO_tags tag;
   enum tree_code code;
@@ -861,7 +856,7 @@ lto_output_tree_header (struct output_block *ob, tree expr)
      EXPR on the reading side (such as the number of slots in
      variable sized nodes).  */
   tag = lto_tree_code_to_tag (code);
-  output_record_start (ob, tag);
+  streamer_write_record_start (ob, tag);
 
   /* The following will cause bootstrap miscomparisons.  Enable with care.  */
 #ifdef LTO_STREAMER_DEBUG
@@ -870,21 +865,21 @@ lto_output_tree_header (struct output_block *ob, tree expr)
      value for EXPR can be used to track down the differences in
      the debugger.  */
   gcc_assert ((HOST_WIDEST_INT) (intptr_t) expr == (intptr_t) expr);
-  output_sleb128 (ob, (HOST_WIDEST_INT) (intptr_t) expr);
+  streamer_write_hwi (ob, (HOST_WIDEST_INT) (intptr_t) expr);
 #endif
 
   /* The text in strings and identifiers are completely emitted in
      the header.  */
   if (CODE_CONTAINS_STRUCT (code, TS_STRING))
-    output_string_cst (ob, ob->main_stream, expr);
+    write_string_cst (ob, ob->main_stream, expr);
   else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
-    output_identifier (ob, ob->main_stream, expr);
+    write_identifier (ob, ob->main_stream, expr);
   else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
-    output_sleb128 (ob, TREE_VEC_LENGTH (expr));
+    streamer_write_hwi (ob, TREE_VEC_LENGTH (expr));
   else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
-    output_uleb128 (ob, BINFO_N_BASE_BINFOS (expr));
+    streamer_write_uhwi (ob, BINFO_N_BASE_BINFOS (expr));
   else if (TREE_CODE (expr) == CALL_EXPR)
-    output_uleb128 (ob, call_expr_nargs (expr));
+    streamer_write_uhwi (ob, call_expr_nargs (expr));
 }
 
 
@@ -892,11 +887,11 @@ lto_output_tree_header (struct output_block *ob, tree expr)
    CST's type will be emitted as a reference.  */
 
 void
-lto_output_integer_cst (struct output_block *ob, tree cst, bool ref_p)
+streamer_write_integer_cst (struct output_block *ob, tree cst, bool ref_p)
 {
-  output_record_start (ob, lto_tree_code_to_tag (INTEGER_CST));
+  streamer_write_record_start (ob, lto_tree_code_to_tag (INTEGER_CST));
   stream_write_tree (ob, TREE_TYPE (cst), ref_p);
-  lto_output_1_stream (ob->main_stream, TREE_OVERFLOW_P (cst));
-  output_uleb128 (ob, TREE_INT_CST_LOW (cst));
-  output_uleb128 (ob, TREE_INT_CST_HIGH (cst));
+  streamer_write_char_stream (ob->main_stream, TREE_OVERFLOW_P (cst));
+  streamer_write_uhwi (ob, TREE_INT_CST_LOW (cst));
+  streamer_write_uhwi (ob, TREE_INT_CST_HIGH (cst));
 }