From b9393656725809539d9a31c268df6230ed8d6691 Mon Sep 17 00:00:00 2001 From: Diego Novillo Date: Thu, 11 Aug 2011 08:02:34 -0400 Subject: tree-streamer-out.c (lto_output_ts_decl_with_vis_tree_pointers): Call stream_write_tree instead of output_record_start. * 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. * streamer-hooks.h (stream_write_tree): Move from tree-streamer.h. Convert it to a macro. (stream_read_tree): Likewise. * lto-streamer.h (lto_stream_as_builtin_p): Move ... * tree-streamer.h (lto_stream_as_builtin_p): ... here. * 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. * 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. From-SVN: r177661 --- gcc/tree-streamer.c | 62 ++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 61 insertions(+), 1 deletion(-) (limited to 'gcc/tree-streamer.c') diff --git a/gcc/tree-streamer.c b/gcc/tree-streamer.c index d5fe93a..0517441 100644 --- a/gcc/tree-streamer.c +++ b/gcc/tree-streamer.c @@ -245,6 +245,66 @@ lto_streamer_cache_get (struct lto_streamer_cache_d *cache, unsigned ix) return VEC_index (tree, cache->nodes, ix); } + +/* Record NODE in CACHE. */ + +static void +lto_record_common_node (struct lto_streamer_cache_d *cache, tree node) +{ + /* We have to make sure to fill exactly the same number of + elements for all frontends. That can include NULL trees. + As our hash table can't deal with zero entries we'll simply stream + a random other tree. A NULL tree never will be looked up so it + doesn't matter which tree we replace it with, just to be sure + use error_mark_node. */ + if (!node) + node = error_mark_node; + + lto_streamer_cache_append (cache, node); + + if (POINTER_TYPE_P (node) + || TREE_CODE (node) == COMPLEX_TYPE + || TREE_CODE (node) == ARRAY_TYPE) + lto_record_common_node (cache, TREE_TYPE (node)); + else if (TREE_CODE (node) == RECORD_TYPE) + { + /* The FIELD_DECLs of structures should be shared, so that every + COMPONENT_REF uses the same tree node when referencing a field. + Pointer equality between FIELD_DECLs is used by the alias + machinery to compute overlapping memory references (See + nonoverlapping_component_refs_p). */ + tree f; + for (f = TYPE_FIELDS (node); f; f = TREE_CHAIN (f)) + lto_record_common_node (cache, f); + } +} + + +/* Preload common nodes into CACHE and make sure they are merged + properly according to the gimple type table. */ + +static void +preload_common_nodes (struct lto_streamer_cache_d *cache) +{ + unsigned i; + + for (i = 0; i < itk_none; i++) + /* Skip itk_char. char_type_node is dependent on -f[un]signed-char. */ + if (i != itk_char) + lto_record_common_node (cache, integer_types[i]); + + for (i = 0; i < TYPE_KIND_LAST; i++) + lto_record_common_node (cache, sizetype_tab[i]); + + for (i = 0; i < TI_MAX; i++) + /* Skip boolean type and constants, they are frontend dependent. */ + if (i != TI_BOOLEAN_TYPE + && i != TI_BOOLEAN_FALSE + && i != TI_BOOLEAN_TRUE) + lto_record_common_node (cache, global_trees[i]); +} + + /* Create a cache of pickled nodes. */ struct lto_streamer_cache_d * @@ -259,7 +319,7 @@ lto_streamer_cache_create (void) /* Load all the well-known tree nodes that are always created by the compiler on startup. This prevents writing them out unnecessarily. */ - streamer_hooks.preload_common_nodes (cache); + preload_common_nodes (cache); return cache; } -- cgit v1.1