[lto] Remove most streamer hooks. (issue4863041)

This implements step #4 from my streamer refactoring series at
http://gcc.gnu.org/ml/gcc-patches/2011-08/msg00765.html
(I skipped steps #2 and #3 for now, because I needed this change in
the PPH branch).

This patch opens up the generic tree streamer interface so that
streamers can use them independently.  With this, I started pushing
LTO-specific bits into lto-streamer*.

There are zero functional changes for LTO.  This simply moves some
functions to tree-streamer* and makes them external, so they can be
called from lto-streamer*.

The main changes are:

1- struct streamer_hooks is reduced to 4 callbacks: read_tree,
   write_tree, input_location and output_location.
   Both read_tree and write_tree change their semantics.  Before, they
   were called *after* the generic code had handled all the
   language-independent parts of the tree.  Now they are the main
   entry point, so each streamer is responsible for writing and
   reading the whole tree.

   The API in the tree streamer offers functions to read/write the
   tree header and the body, a streamer cache and everything that
   used to be inside the LTO streamer.  This makes no difference to
   LTO, since it simply means that some formerly static functions are
   now extern functions in tree-streamer*.

   The only big change for LTO is mechanical.  The low-level
   pickling/unpickling routines in the tree streamer need to call the
   write_tree and read_tree hooks instead of
   lto_output_tree/lto_input_tree.  So, the bulk of this patch are
   calls to stream_write_tree and stream_read_tree (two macros that
   expand to streamer_hooks.write_tree and streamer_hooks.read_tree).

2- Removed lto_output_tree_or_ref.  We now have a single entry point
   to the routine that's supposed to handle a tree.  So,
   lto_output_tree now checks if the caller wants a reference and the
   tree is indexable before trying to pickle it.

3- Separated the materialization of read trees from their insertion
   into the streamer cache and the streaming of bitfield values.  We
   were previously doing all this in one routine, but PPH needs to
   handle its own pickle cache, and it needs to read
   language-dependent bitfields.

4- Remove LTO-specific checks from lto_preload_common_nodes.  There
   were some checks done on main_identifier_node, fileptr_type_node,
   etc that only make sense for LTO.  We were doing those checks in
   lto_init, anyway.

5- Handle CALL_EXPR in lto_materialize_tree.  Despite the name this is
   a generic tree streaming function (the renaming patch will come
   in the next few days).  Handling CALL_EXPR does not
   affect LTO (since those nodes are never allowed), but it is a
   generic tree code so it makes more sense to handle it here.

6- Fix erroneous use of output_record_start when emitting NULL trees.
   In a couple of low-level pickling routines, we were calling
   output_record_start (ob, LTO_null) to indicate a NULL tree.  For
   LTO, this doesn't matter, but PPH implements its own tree
   delimiters (because of how the pickle cache works), so writing an
   LTO_null tag is not the same as writing a NULL tree.  For LTO, this
   just means an extra call to lto_output_tree (which will write the
   LTO_null) tag.

I was sorely tempted to start doing some renaming, but this patch
shifts quite a bit of code around.  I didn't want to make it harder
to review.

I have tested this patch with an LTO profiledbootstrap on x86_64.  The
patch is against the PPH branch, but right now the branch is very
close to trunk, so it will apply with little/no changes.

I expect some more further cleanups separating the generic and
LTO-specific parts.  But this is a good first step for PPH.

OK for trunk?

Diego.

	* Makefile.in (TREE_STREAMER_H): Add STREAMER_HOOKS_H.
 	(gimple-streamer-in.o): Add dependency on TREE_STREAMER_H.
 	* tree-streamer.h (stream_read_tree): New.  Replace all calls
 	to lto_input_tree with it.
 	(stream_write_tree): New.  Replace all calls to lto_output_tree,
 	lto_output_tree_ref and lto_output_tree_or_ref with it.
 	* lto-streamer-in.c (lto_read_tree): Inline code from
 	lto_streamer_read_tree.
 	(lto_input_tree): Move from tree-streamer-in.c.
 	* lto-streamer-out.c (lto_output_tree_ref): Make static.
 	Remove handling of NULL values for EXPR.
 	Do not handle EXPRs that are not indexable.
 	(lto_write_tree): Move from tree-streamer-out.c.
 	Inline lto_streamer_write_tree.
 	(lto_output_tree): Move from tree-streamer-out.c.
 	If REF_P is true and EXPR is indexable, call lto_output_tree_ref.
 	* lto-streamer.c (lto_record_common_node): Move to tree-streamer.c.
 	(lto_preload_common_nodes): Likewise.
 	Remove assertions and adjustments for nodes
 	main_identifier_node, ptrdiff_type_node and fileptr_type_node.
 	(lto_streamer_hooks_init): Set streamer_hooks.write_tree to
 	lto_output_tree and streamer_hooks.read_tree to
 	lto_input_tree.
 	* lto-streamer.h (lto_input_tree): Declare.
 	(lto_output_tree_ref): Remove.
 	* streamer-hooks.h (struct streamer_hooks): Remove fields
 	preload_common_nodes, indexable_with_decls_p,
 	pack_value_fields, unpack_value_fields, output_tree_header and
 	has_unique_integer_csts_p.
 	Update all users.
 	* tree-streamer-in.c (lto_materialize_tree): Make extern.
 	(lto_input_tree_pointers): Likewise.
 	(lto_read_tree): Move to lto-streamer-in.c.
 	(lto_input_integer_cst): Make extern.
 	(lto_get_pickled_tree): Likewise.
 	(lto_get_builtin_tree): Likewise.
 	(lto_input_tree): Move to lto-streamer-in.c.
 	* tree-streamer-out.c (pack_value_fields): Make extern.
 	(lto_output_tree_or_ref): Remove.  Replace all callers with
 	calls to stream_write_tree.
 	(lto_output_builtin_tree): Make extern.
 	(lto_streamer_write_tree): Inline into lto_write_tree.
 	(lto_output_tree_pointers): Make extern.
 	(lto_output_tree_header): Likewise.
 	(lto_output_integer_cst): Likewise.
 	(lto_write_tree): Move to lto-streamer-out.c.
 	(lto_output_tree): Likewise.
 	* tree-streamer.c (lto_record_common_node): Move from
 	lto-streamer.c
 	(preload_common_nodes): Likewise.
 	(lto_streamer_cache_create): Call it.
 	* tree-streamer.h: Include streamer-hooks.h.
 	(stream_write_tree): New.
 	(stream_read_tree): New.
 	(lto_input_tree): Remove.
 	(lto_materialize_tree): Declare.
 	(lto_input_tree_pointers): Declare.
 	(lto_get_pickled_tree): Declare.
 	(lto_get_builtin_tree): Declare.
 	(lto_input_integer_cst): Declare.
 	(lto_output_tree_header): Declare.
 	(pack_value_fields): Declare.
 	(lto_output_tree_pointers): Declare.
 	(lto_output_integer_cst): Declare.
 	(lto_output_builtin_tree): Declare.

	* lto-streamer-in.c (lto_read_tree): Call lto_streamer_cache_append
	and tree_read_bitfields.
	* lto-streamer-out.c (lto_is_streamable): Move from lto-streamer.c
	(lto_write_tree): Call it.
	* lto-streamer.c (lto_is_streamable): Move to lto-streamer-out.c
	* streamer-hooks.h (struct streamer_hooks): Remove fields
	name, is_streamable and alloc_tree. Update all users.
	* tree-streamer-in.c (tree_read_bitfields): Factor out of ...
	(lto_materialize_tree): ... here.
	Handle CALL_EXPR codes.
	Remove call to lto_streamer_cache_append.
	* tree-streamer-out.c (lto_output_tree_header): Handle
	CALL_EXPR nodes.
	* tree-streamer.h (tree_read_bitfields): Declare.

	* lto-streamer.h (lto_stream_as_builtin_p): Move ...
	* tree-streamer.h (lto_stream_as_builtin_p): ... here.

	* streamer-hooks.h (stream_write_tree): Move from tree-streamer.h.
	Convert it to a macro.
	(stream_read_tree): Likewise.

	* tree-streamer-out.c (lto_output_ts_decl_with_vis_tree_pointers):
	Call stream_write_tree instead of output_record_start.
	(lto_output_ts_binfo_tree_pointers): Likewise.
---
 gcc/ChangeLog.pph         |  102 +++++++++++++++
 gcc/Makefile.in           |    5 +-
 gcc/gimple-streamer-in.c  |   10 +-
 gcc/gimple-streamer-out.c |   11 +-
 gcc/ipa-inline-analysis.c |    4 +-
 gcc/ipa-prop.c            |   28 ++--
 gcc/lto-cgraph.c          |    4 +-
 gcc/lto-streamer-in.c     |  138 ++++++++++++++++-----
 gcc/lto-streamer-out.c    |  218 +++++++++++++++++++++++++--------
 gcc/lto-streamer.c        |  113 +----------------
 gcc/lto-streamer.h        |   13 +--
 gcc/lto/lto-lang.c        |    1 +
 gcc/lto/lto.c             |    2 +-
 gcc/streamer-hooks.h      |   90 +++-----------
 gcc/tree-streamer-in.c    |  279 +++++++++++++++--------------------------
 gcc/tree-streamer-out.c   |  304 +++++++++++----------------------------------
 gcc/tree-streamer.c       |   62 +++++++++-
 gcc/tree-streamer.h       |   27 ++++-
 18 files changed, 688 insertions(+), 723 deletions(-)

[lto] Remove most streamer hooks. (issue4863041)

Commit Message

Comments

Patch