Simplify tree streaming.

this patch cleans up tree streaming.  The code is prepared to stream nested
trees, but we only handle flat trees. As a result we have quite heavy function
to stream in/out tree reference which is used many times and shows up in
profile.

This patch adds stream_write_tree_ref/stream_read_tree_ref which is used to
stream references to trees that are required to exist in the cache or be
indexable.

The actual implementation is just a first cut.  I would like to make it more
compact. We used to stream 2 byte tag (as UHWI) + UHWI representing the index.
Now we stream one UHWI that represent type of reference + index for references
to cache, but still two integers for references to global stream.  This is
becaue the abstraction is not very helpful here and I want to clean this up
incrementally.

I would also like to get rid of the ref_p parameters which seems unnecessary for
flat streams.

This reduces around 7% of global stream, 3% when compressed.
More reduction will happen once the format is sanitized a bit.

from
[WPA] read 4597161 unshared trees
[WPA] read 2937414 mergeable SCCs of average size 1.364280
[WPA] 8604617 tree bodies read in total
[WPA] tree SCC table: size 524287, 247507 elements, collision ratio: 0.377468
[WPA] tree SCC max chain length 2 (size 1)
[WPA] Compared 2689907 SCCs, 184 collisions (0.000068)
[WPA] Merged 2689890 SCCs
[WPA] Merged 3722677 tree bodies
[WPA] Merged 632040 types
...
[WPA] Compression: 88124141 input bytes, 234906430 uncompressed bytes (ratio: 2.665631)
[WPA] Size of mmap'd section decls: 88124141 bytes
...
[WPA] Compression: 113758813 input bytes, 316149514 uncompressed bytes (ratio: 2.779121)
[WPA] Size of mmap'd section decls: 88124141 bytes
[WPA] Size of mmap'd section function_body: 14485721 bytes

to

[WPA] read 4597174 unshared trees
[WPA] read 2937413 mergeable SCCs of average size 1.364280
[WPA] 8604629 tree bodies read in total
[WPA] tree SCC table: size 524287, 247509 elements, collision ratio: 0.377458
[WPA] tree SCC max chain length 2 (size 1)
[WPA] Compared 2689904 SCCs, 183 collisions (0.000068)
[WPA] Merged 2689888 SCCs
[WPA] Merged 3722675 tree bodies
[WPA] Merged 632041 types
....
[WPA] Size of mmap'd section decls: 86177293 bytes
[WPA] Compression: 86177293 input bytes, 217625095 uncompressed bytes (ratio: 2.525318)
....
[WPA] Compression: 111682269 input bytes, 297228756 uncompressed bytes (ratio: 2.661378)
[WPA] Size of mmap'd section decls: 86177293 bytes
[WPA] Size of mmap'd section function_body: 14349032 bytes

gcc/ChangeLog:

	* lto-streamer-in.c (streamer_read_chain): Move here from
	tree-streamer-in.c.
	(stream_read_tree_ref): New.
	(lto_input_tree_1): Simplify.
	* lto-streamer-out.c (stream_write_tree_ref): New.
	(lto_write_tree_1): Simplify.
	(lto_output_tree_1): Simplify.
	(DFS::DFS_write_tree): Simplify.
	(streamer_write_chain): Move here from tree-stremaer-out.c.
	* lto-streamer.h (lto_output_tree_ref): Update prototype.
	(stream_read_tree_ref): Declare
	(stream_write_tree_ref): Declare
	* tree-streamer-in.c (streamer_read_chain): Update to use
	stream_read_tree_ref.
	(lto_input_ts_common_tree_pointers): Likewise.
	(lto_input_ts_vector_tree_pointers): Likewise.
	(lto_input_ts_poly_tree_pointers): Likewise.
	(lto_input_ts_complex_tree_pointers): Likewise.
	(lto_input_ts_decl_minimal_tree_pointers): Likewise.
	(lto_input_ts_decl_common_tree_pointers): Likewise.
	(lto_input_ts_decl_with_vis_tree_pointers): Likewise.
	(lto_input_ts_field_decl_tree_pointers): Likewise.
	(lto_input_ts_function_decl_tree_pointers): Likewise.
	(lto_input_ts_type_common_tree_pointers): Likewise.
	(lto_input_ts_type_non_common_tree_pointers): Likewise.
	(lto_input_ts_list_tree_pointers): Likewise.
	(lto_input_ts_vec_tree_pointers): Likewise.
	(lto_input_ts_exp_tree_pointers): Likewise.
	(lto_input_ts_block_tree_pointers): Likewise.
	(lto_input_ts_binfo_tree_pointers): Likewise.
	(lto_input_ts_constructor_tree_pointers): Likewise.
	(lto_input_ts_omp_clause_tree_pointers): Likewise.
	* tree-streamer-out.c (streamer_write_chain): Update to use
	stream_write_tree_ref.
	(write_ts_common_tree_pointers): Likewise.
	(write_ts_vector_tree_pointers): Likewise.
	(write_ts_poly_tree_pointers): Likewise.
	(write_ts_complex_tree_pointers): Likewise.
	(write_ts_decl_minimal_tree_pointers): Likewise.
	(write_ts_decl_common_tree_pointers): Likewise.
	(write_ts_decl_non_common_tree_pointers): Likewise.
	(write_ts_decl_with_vis_tree_pointers): Likewise.
	(write_ts_field_decl_tree_pointers): Likewise.
	(write_ts_function_decl_tree_pointers): Likewise.
	(write_ts_type_common_tree_pointers): Likewise.
	(write_ts_type_non_common_tree_pointers): Likewise.
	(write_ts_list_tree_pointers): Likewise.
	(write_ts_vec_tree_pointers): Likewise.
	(write_ts_exp_tree_pointers): Likewise.
	(write_ts_block_tree_pointers): Likewise.
	(write_ts_binfo_tree_pointers): Likewise.
	(write_ts_constructor_tree_pointers): Likewise.
	(write_ts_omp_clause_tree_pointers): Likewise.
	(streamer_write_tree_body): Likewise.
	(streamer_write_integer_cst): Likewise.
	* tree-streamer.h (streamer_read_chain):Declare.
	(streamer_write_chain):Declare.
	(streamer_write_tree_body): Update prototype.
	(streamer_write_integer_cst): Update prototype.

1 files changed, 51 insertions, 50 deletions

diff --git a/gcc/tree-streamer-in.c b/gcc/tree-streamer-in.c
index d2e45e33554..447a3110e82 100644
--- a/gcc/tree-streamer-in.c
+++ b/gcc/tree-streamer-in.c
@@ -69,10 +69,10 @@ input_identifier (class data_in *data_in, class lto_input_block *ib)
 }
 
 
-/* Read a chain of tree nodes from input block IB. DATA_IN contains
+/* Read a chain of tree nodes from input block IB.  DATA_IN contains
    tables and descriptors for the file being read.  */
 
-tree
+static tree
 streamer_read_chain (class lto_input_block *ib, class data_in *data_in)
 {
   tree first, prev, curr;
@@ -81,7 +81,7 @@ streamer_read_chain (class lto_input_block *ib, class data_in *data_in)
   first = prev = NULL_TREE;
   do
     {
-      curr = stream_read_tree (ib, data_in);
+      curr = stream_read_tree_ref (ib, data_in);
       if (prev)
 	TREE_CHAIN (prev) = curr;
       else
@@ -651,7 +651,7 @@ lto_input_ts_common_tree_pointers (class lto_input_block *ib,
 				   class data_in *data_in, tree expr)
 {
   if (TREE_CODE (expr) != IDENTIFIER_NODE)
-    TREE_TYPE (expr) = stream_read_tree (ib, data_in);
+    TREE_TYPE (expr) = stream_read_tree_ref (ib, data_in);
 }
 
 
@@ -665,7 +665,7 @@ lto_input_ts_vector_tree_pointers (class lto_input_block *ib,
 {
   unsigned int count = vector_cst_encoded_nelts (expr);
   for (unsigned int i = 0; i < count; ++i)
-    VECTOR_CST_ENCODED_ELT (expr, i) = stream_read_tree (ib, data_in);
+    VECTOR_CST_ENCODED_ELT (expr, i) = stream_read_tree_ref (ib, data_in);
 }
 
 
@@ -678,7 +678,7 @@ lto_input_ts_poly_tree_pointers (class lto_input_block *ib,
 				 class data_in *data_in, tree expr)
 {
   for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
-    POLY_INT_CST_COEFF (expr, i) = stream_read_tree (ib, data_in);
+    POLY_INT_CST_COEFF (expr, i) = stream_read_tree_ref (ib, data_in);
 }
 
 
@@ -690,8 +690,8 @@ static void
 lto_input_ts_complex_tree_pointers (class lto_input_block *ib,
 				    class data_in *data_in, tree expr)
 {
-  TREE_REALPART (expr) = stream_read_tree (ib, data_in);
-  TREE_IMAGPART (expr) = stream_read_tree (ib, data_in);
+  TREE_REALPART (expr) = stream_read_tree_ref (ib, data_in);
+  TREE_IMAGPART (expr) = stream_read_tree_ref (ib, data_in);
 }
 
 
@@ -703,8 +703,8 @@ static void
 lto_input_ts_decl_minimal_tree_pointers (class lto_input_block *ib,
 					 class data_in *data_in, tree expr)
 {
-  DECL_NAME (expr) = stream_read_tree (ib, data_in);
-  DECL_CONTEXT (expr) = stream_read_tree (ib, data_in);
+  DECL_NAME (expr) = stream_read_tree_ref (ib, data_in);
+  DECL_CONTEXT (expr) = stream_read_tree_ref (ib, data_in);
 }
 
 
@@ -716,19 +716,19 @@ static void
 lto_input_ts_decl_common_tree_pointers (class lto_input_block *ib,
 					class data_in *data_in, tree expr)
 {
-  DECL_SIZE (expr) = stream_read_tree (ib, data_in);
-  DECL_SIZE_UNIT (expr) = stream_read_tree (ib, data_in);
-  DECL_ATTRIBUTES (expr) = stream_read_tree (ib, data_in);
-  DECL_ABSTRACT_ORIGIN (expr) = stream_read_tree (ib, data_in);
+  DECL_SIZE (expr) = stream_read_tree_ref (ib, data_in);
+  DECL_SIZE_UNIT (expr) = stream_read_tree_ref (ib, data_in);
+  DECL_ATTRIBUTES (expr) = stream_read_tree_ref (ib, data_in);
+  DECL_ABSTRACT_ORIGIN (expr) = stream_read_tree_ref (ib, data_in);
 
   if ((VAR_P (expr) || TREE_CODE (expr) == PARM_DECL)
       && DECL_HAS_VALUE_EXPR_P (expr))
-    SET_DECL_VALUE_EXPR (expr, stream_read_tree (ib, data_in));
+    SET_DECL_VALUE_EXPR (expr, stream_read_tree_ref (ib, data_in));
 
   if (VAR_P (expr)
       && DECL_HAS_DEBUG_EXPR_P (expr))
     {
-      tree dexpr = stream_read_tree (ib, data_in);
+      tree dexpr = stream_read_tree_ref (ib, data_in);
       if (dexpr)
 	SET_DECL_DEBUG_EXPR (expr, dexpr);
     }
@@ -756,7 +756,7 @@ lto_input_ts_decl_with_vis_tree_pointers (class lto_input_block *ib,
 {
   tree id;
 
-  id = stream_read_tree (ib, data_in);
+  id = stream_read_tree_ref (ib, data_in);
   if (id)
     {
       gcc_assert (TREE_CODE (id) == IDENTIFIER_NODE);
@@ -773,10 +773,10 @@ static void
 lto_input_ts_field_decl_tree_pointers (class lto_input_block *ib,
 				       class data_in *data_in, tree expr)
 {
-  DECL_FIELD_OFFSET (expr) = stream_read_tree (ib, data_in);
-  DECL_BIT_FIELD_TYPE (expr) = stream_read_tree (ib, data_in);
-  DECL_BIT_FIELD_REPRESENTATIVE (expr) = stream_read_tree (ib, data_in);
-  DECL_FIELD_BIT_OFFSET (expr) = stream_read_tree (ib, data_in);
+  DECL_FIELD_OFFSET (expr) = stream_read_tree_ref (ib, data_in);
+  DECL_BIT_FIELD_TYPE (expr) = stream_read_tree_ref (ib, data_in);
+  DECL_BIT_FIELD_REPRESENTATIVE (expr) = stream_read_tree_ref (ib, data_in);
+  DECL_FIELD_BIT_OFFSET (expr) = stream_read_tree_ref (ib, data_in);
 }
 
 
@@ -789,11 +789,12 @@ lto_input_ts_function_decl_tree_pointers (class lto_input_block *ib,
 					  class data_in *data_in, tree expr)
 {
   /* DECL_STRUCT_FUNCTION is loaded on demand by cgraph_get_body.  */
-  DECL_FUNCTION_PERSONALITY (expr) = stream_read_tree (ib, data_in);
+  DECL_FUNCTION_PERSONALITY (expr) = stream_read_tree_ref (ib, data_in);
 #ifndef ACCEL_COMPILER
-  DECL_FUNCTION_SPECIFIC_TARGET (expr) = stream_read_tree (ib, data_in);
+  DECL_FUNCTION_SPECIFIC_TARGET (expr) = stream_read_tree_ref (ib, data_in);
 #endif
-  DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr) = stream_read_tree (ib, data_in);
+  DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr)
+    = stream_read_tree_ref (ib, data_in);
 #ifdef ACCEL_COMPILER
   {
     tree opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr);
@@ -819,16 +820,16 @@ static void
 lto_input_ts_type_common_tree_pointers (class lto_input_block *ib,
 					class data_in *data_in, tree expr)
 {
-  TYPE_SIZE (expr) = stream_read_tree (ib, data_in);
-  TYPE_SIZE_UNIT (expr) = stream_read_tree (ib, data_in);
-  TYPE_ATTRIBUTES (expr) = stream_read_tree (ib, data_in);
-  TYPE_NAME (expr) = stream_read_tree (ib, data_in);
+  TYPE_SIZE (expr) = stream_read_tree_ref (ib, data_in);
+  TYPE_SIZE_UNIT (expr) = stream_read_tree_ref (ib, data_in);
+  TYPE_ATTRIBUTES (expr) = stream_read_tree_ref (ib, data_in);
+  TYPE_NAME (expr) = stream_read_tree_ref (ib, data_in);
   /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO.  They will be
      reconstructed during fixup.  */
   /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
      during fixup.  */
-  TYPE_MAIN_VARIANT (expr) = stream_read_tree (ib, data_in);
-  TYPE_CONTEXT (expr) = stream_read_tree (ib, data_in);
+  TYPE_MAIN_VARIANT (expr) = stream_read_tree_ref (ib, data_in);
+  TYPE_CONTEXT (expr) = stream_read_tree_ref (ib, data_in);
   /* TYPE_CANONICAL gets re-computed during type merging.  */
   TYPE_CANONICAL (expr) = NULL_TREE;
 }
@@ -843,18 +844,18 @@ lto_input_ts_type_non_common_tree_pointers (class lto_input_block *ib,
 					    tree expr)
 {
   if (TREE_CODE (expr) == ENUMERAL_TYPE)
-    TYPE_VALUES (expr) = stream_read_tree (ib, data_in);
+    TYPE_VALUES (expr) = stream_read_tree_ref (ib, data_in);
   else if (TREE_CODE (expr) == ARRAY_TYPE)
-    TYPE_DOMAIN (expr) = stream_read_tree (ib, data_in);
+    TYPE_DOMAIN (expr) = stream_read_tree_ref (ib, data_in);
   else if (RECORD_OR_UNION_TYPE_P (expr))
     TYPE_FIELDS (expr) = streamer_read_chain (ib, data_in);
   else if (TREE_CODE (expr) == FUNCTION_TYPE
 	   || TREE_CODE (expr) == METHOD_TYPE)
-    TYPE_ARG_TYPES (expr) = stream_read_tree (ib, data_in);
+    TYPE_ARG_TYPES (expr) = stream_read_tree_ref (ib, data_in);
 
   if (!POINTER_TYPE_P (expr))
-    TYPE_MIN_VALUE_RAW (expr) = stream_read_tree (ib, data_in);
-  TYPE_MAX_VALUE_RAW (expr) = stream_read_tree (ib, data_in);
+    TYPE_MIN_VALUE_RAW (expr) = stream_read_tree_ref (ib, data_in);
+  TYPE_MAX_VALUE_RAW (expr) = stream_read_tree_ref (ib, data_in);
 }
 
 
@@ -866,9 +867,9 @@ static void
 lto_input_ts_list_tree_pointers (class lto_input_block *ib,
 				 class data_in *data_in, tree expr)
 {
-  TREE_PURPOSE (expr) = stream_read_tree (ib, data_in);
-  TREE_VALUE (expr) = stream_read_tree (ib, data_in);
-  TREE_CHAIN (expr) = stream_read_tree (ib, data_in);
+  TREE_PURPOSE (expr) = stream_read_tree_ref (ib, data_in);
+  TREE_VALUE (expr) = stream_read_tree_ref (ib, data_in);
+  TREE_CHAIN (expr) = stream_read_tree_ref (ib, data_in);
 }
 
 
@@ -885,7 +886,7 @@ lto_input_ts_vec_tree_pointers (class lto_input_block *ib,
   /* Note that TREE_VEC_LENGTH was read by streamer_alloc_tree to
      instantiate EXPR.  */
   for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
-    TREE_VEC_ELT (expr, i) = stream_read_tree (ib, data_in);
+    TREE_VEC_ELT (expr, i) = stream_read_tree_ref (ib, data_in);
 }
 
 
@@ -902,9 +903,9 @@ lto_input_ts_exp_tree_pointers (class lto_input_block *ib,
   tree block;
 
   for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
-    TREE_OPERAND (expr, i) = stream_read_tree (ib, data_in);
+    TREE_OPERAND (expr, i) = stream_read_tree_ref (ib, data_in);
 
-  block = stream_read_tree (ib, data_in);
+  block = stream_read_tree_ref (ib, data_in);
 
   /* TODO: Block is stored in the locus information.  It may make more sense to
      to make it go via the location cache.  */
@@ -926,8 +927,8 @@ lto_input_ts_block_tree_pointers (class lto_input_block *ib,
 {
   BLOCK_VARS (expr) = streamer_read_chain (ib, data_in);
 
-  BLOCK_SUPERCONTEXT (expr) = stream_read_tree (ib, data_in);
-  BLOCK_ABSTRACT_ORIGIN (expr) = stream_read_tree (ib, data_in);
+  BLOCK_SUPERCONTEXT (expr) = stream_read_tree_ref (ib, data_in);
+  BLOCK_ABSTRACT_ORIGIN (expr) = stream_read_tree_ref (ib, data_in);
   /* We may end up prevailing a decl with DECL_ORIGIN (t) != t here
      which breaks the invariant that BLOCK_ABSTRACT_ORIGIN is the
      ultimate origin.  Fixup here.
@@ -979,14 +980,14 @@ lto_input_ts_binfo_tree_pointers (class lto_input_block *ib,
      list on the writer side.  */
   do
     {
-      t = stream_read_tree (ib, data_in);
+      t = stream_read_tree_ref (ib, data_in);
       if (t)
 	BINFO_BASE_BINFOS (expr)->quick_push (t);
     }
   while (t);
 
-  BINFO_OFFSET (expr) = stream_read_tree (ib, data_in);
-  BINFO_VTABLE (expr) = stream_read_tree (ib, data_in);
+  BINFO_OFFSET (expr) = stream_read_tree_ref (ib, data_in);
+  BINFO_VTABLE (expr) = stream_read_tree_ref (ib, data_in);
 
   /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX,
      BINFO_BASE_ACCESSES and BINFO_VPTR_INDEX; these are used by C++ FE
@@ -1007,8 +1008,8 @@ lto_input_ts_constructor_tree_pointers (class lto_input_block *ib,
   for (i = 0; i < CONSTRUCTOR_NELTS (expr); i++)
     {
       constructor_elt e;
-      e.index = stream_read_tree (ib, data_in);
-      e.value = stream_read_tree (ib, data_in);
+      e.index = stream_read_tree_ref (ib, data_in);
+      e.value = stream_read_tree_ref (ib, data_in);
       (*CONSTRUCTOR_ELTS (expr))[i] = e;
     }
 }
@@ -1025,8 +1026,8 @@ lto_input_ts_omp_clause_tree_pointers (class lto_input_block *ib,
   int i;
 
   for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (expr)]; i++)
-    OMP_CLAUSE_OPERAND (expr, i) = stream_read_tree (ib, data_in);
-  OMP_CLAUSE_CHAIN (expr) = stream_read_tree (ib, data_in);
+    OMP_CLAUSE_OPERAND (expr, i) = stream_read_tree_ref (ib, data_in);
+  OMP_CLAUSE_CHAIN (expr) = stream_read_tree_ref (ib, data_in);
 }