* Makefile.in (lto-compress.o): Add dependency on LTO_STREAMER_H.
(cgraph.o): Likewise.
(cgraphunit.o): Likewise.
* cgraphunit.c: Include lto-streamer.h
(cgraph_finalize_compilation_unit): Call lto_streamer_hooks_init
if LTO is enabled.
* lto-streamer-in.c (unpack_value_fields): Call
streamer_hooks.unpack_value_fields if set.
(lto_materialize_tree): For unhandled nodes, first try to
call lto_streamer_hooks.alloc_tree, if it exists.
(lto_input_ts_decl_common_tree_pointers): Move reading of
DECL_INITIAL to lto_streamer_read_tree.
(lto_read_tree): Call lto_streamer_hooks.read_tree if set.
(lto_streamer_read_tree): New.
(lto_reader_init): Rename from lto_init_reader.
Move initialization code to lto/lto.c.
* lto-streamer-out.c (pack_value_fields): Call
streamer_hooks.pack_value_fields if set.
(lto_output_tree_ref): For tree nodes that are not
normally indexable, call streamer_hooks.indexable_with_decls_p
before giving up.
(lto_output_ts_decl_common_tree_pointers): Move handling
for FUNCTION_DECL and TRANSLATION_UNIT_DECL to
lto_streamer_write_tree.
(lto_output_tree_header): Call streamer_hooks.is_streamable
instead of lto_is_streamable.
Call lto_streamer_hooks.output_tree_header if set.
(lto_write_tree): Call lto_streamer_hooks.write_tree if
set.
(lto_streamer_write_tree): New.
(lto_output): Call lto_streamer_init directly.
(lto_writer_init): Remove.
* lto-streamer.c (streamer_hooks): New.
(lto_streamer_cache_create): Call streamer_hooks.preload_common_nodes
instead of lto_preload_common_nodes.
(lto_is_streamable): Move from lto-streamer.h
(lto_streamer_hooks_init): New.
(streamer_hooks): New.
(streamer_hooks_init): New.
* lto-streamer.h (struct output_block): Forward declare.
(struct lto_input_block): Likewise.
(struct data_in): Likewise.
(struct bitpack_d): Likewise.
(struct streamer_hooks): Declare.
(streamer_hooks): Declare.
(lto_streamer_hooks_init): Declare.
(lto_streamer_write_tree): Declare.
(lto_streamer_read_tree): Declare.
(streamer_hooks_init): Declare.
(lto_is_streamable): Move to lto-streamer.c
lto/ChangeLog
* lto.c (lto_init): New.
(lto_main): Call it.
From-SVN: r174709
+2011-06-04 Diego Novillo <dnovillo@google.com>
+
+ * Makefile.in (lto-compress.o): Add dependency on LTO_STREAMER_H.
+ (cgraph.o): Likewise.
+ (cgraphunit.o): Likewise.
+ * cgraphunit.c: Include lto-streamer.h
+ (cgraph_finalize_compilation_unit): Call lto_streamer_hooks_init
+ if LTO is enabled.
+ * lto-streamer-in.c (unpack_value_fields): Call
+ streamer_hooks.unpack_value_fields if set.
+ (lto_materialize_tree): For unhandled nodes, first try to
+ call lto_streamer_hooks.alloc_tree, if it exists.
+ (lto_input_ts_decl_common_tree_pointers): Move reading of
+ DECL_INITIAL to lto_streamer_read_tree.
+ (lto_read_tree): Call lto_streamer_hooks.read_tree if set.
+ (lto_streamer_read_tree): New.
+ (lto_reader_init): Rename from lto_init_reader.
+ Move initialization code to lto/lto.c.
+ * lto-streamer-out.c (pack_value_fields): Call
+ streamer_hooks.pack_value_fields if set.
+ (lto_output_tree_ref): For tree nodes that are not
+ normally indexable, call streamer_hooks.indexable_with_decls_p
+ before giving up.
+ (lto_output_ts_decl_common_tree_pointers): Move handling
+ for FUNCTION_DECL and TRANSLATION_UNIT_DECL to
+ lto_streamer_write_tree.
+ (lto_output_tree_header): Call streamer_hooks.is_streamable
+ instead of lto_is_streamable.
+ Call lto_streamer_hooks.output_tree_header if set.
+ (lto_write_tree): Call lto_streamer_hooks.write_tree if
+ set.
+ (lto_streamer_write_tree): New.
+ (lto_output): Call lto_streamer_init directly.
+ (lto_writer_init): Remove.
+ * lto-streamer.c (streamer_hooks): New.
+ (lto_streamer_cache_create): Call streamer_hooks.preload_common_nodes
+ instead of lto_preload_common_nodes.
+ (lto_is_streamable): Move from lto-streamer.h
+ (lto_streamer_hooks_init): New.
+ (streamer_hooks): New.
+ (streamer_hooks_init): New.
+ * lto-streamer.h (struct output_block): Forward declare.
+ (struct lto_input_block): Likewise.
+ (struct data_in): Likewise.
+ (struct bitpack_d): Likewise.
+ (struct streamer_hooks): Declare.
+ (streamer_hooks): Declare.
+ (lto_streamer_hooks_init): Declare.
+ (lto_streamer_write_tree): Declare.
+ (lto_streamer_read_tree): Declare.
+ (streamer_hooks_init): Declare.
+ (lto_is_streamable): Move to lto-streamer.c
+
2011-06-06 Andreas Krebbel <Andreas.Krebbel@de.ibm.com>
* longlong.h (smul_ppmm): The resulting register pair contains the
# lto-compress.o needs $(ZLIBINC) added to the include flags.
lto-compress.o: lto-compress.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \
- $(TREE_H) langhooks.h $(LTO_HEADER_H) $(LTO_SECTION_H) \
+ $(TREE_H) langhooks.h $(LTO_STREAMER_H) $(LTO_SECTION_H) \
lto-compress.h $(DIAGNOSTIC_CORE_H) $(DIAGNOSTIC_CORE_H)
$(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(ZLIBINC) $< $(OUTPUT_OPTION)
gt-cgraph.h output.h intl.h $(BASIC_BLOCK_H) debug.h $(HASHTAB_H) \
$(TREE_INLINE_H) $(TREE_DUMP_H) $(TREE_FLOW_H) cif-code.def \
value-prof.h $(EXCEPT_H) $(IPA_UTILS_H) $(DIAGNOSTIC_CORE_H) \
- ipa-inline.h
+ ipa-inline.h $(LTO_STREAMER_H)
cgraphunit.o : cgraphunit.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \
$(TREE_H) langhooks.h $(TREE_INLINE_H) toplev.h $(DIAGNOSTIC_CORE_H) $(FLAGS_H) $(GGC_H) \
$(TARGET_H) $(CGRAPH_H) intl.h pointer-set.h $(FUNCTION_H) $(GIMPLE_H) \
$(TREE_FLOW_H) $(TREE_PASS_H) debug.h $(DIAGNOSTIC_H) \
$(FIBHEAP_H) output.h $(PARAMS_H) $(RTL_H) $(TIMEVAR_H) $(IPA_PROP_H) \
gt-cgraphunit.h tree-iterator.h $(COVERAGE_H) $(TREE_DUMP_H) \
- tree-pretty-print.h gimple-pretty-print.h ipa-inline.h $(IPA_UTILS_H)
+ tree-pretty-print.h gimple-pretty-print.h ipa-inline.h $(IPA_UTILS_H) \
+ $(LTO_STREAMER_H)
cgraphbuild.o : cgraphbuild.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \
$(TREE_H) langhooks.h $(CGRAPH_H) intl.h pointer-set.h $(GIMPLE_H) \
$(TREE_FLOW_H) $(TREE_PASS_H) $(IPA_UTILS_H) $(EXCEPT_H) \
#include "plugin.h"
#include "ipa-inline.h"
#include "ipa-utils.h"
+#include "lto-streamer.h"
static void cgraph_expand_all_functions (void);
static void cgraph_mark_functions_to_output (void);
{
timevar_push (TV_CGRAPH);
+ /* If LTO is enabled, initialize the streamer hooks needed by GIMPLE. */
+ if (flag_lto)
+ lto_streamer_hooks_init ();
+
/* If we're here there's no current function anymore. Some frontends
are lazy in clearing these. */
current_function_decl = NULL;
if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
unpack_ts_translation_unit_decl_value_fields (bp, expr);
+
+ if (streamer_hooks.unpack_value_fields)
+ streamer_hooks.unpack_value_fields (bp, expr);
}
}
else
{
- /* All other nodes can be materialized with a raw make_node call. */
- result = make_node (code);
+ /* For all other nodes, see if the streamer knows how to allocate
+ it. */
+ if (streamer_hooks.alloc_tree)
+ result = streamer_hooks.alloc_tree (code, ib, data_in);
+
+ /* If the hook did not handle it, materialize the tree with a raw
+ make_node call. */
+ if (result == NULL_TREE)
+ result = make_node (code);
}
#ifdef LTO_STREAMER_DEBUG
{
DECL_SIZE (expr) = lto_input_tree (ib, data_in);
DECL_SIZE_UNIT (expr) = lto_input_tree (ib, data_in);
-
- if (TREE_CODE (expr) != FUNCTION_DECL
- && TREE_CODE (expr) != TRANSLATION_UNIT_DECL)
- DECL_INITIAL (expr) = lto_input_tree (ib, data_in);
-
DECL_ATTRIBUTES (expr) = lto_input_tree (ib, data_in);
+
/* Do not stream DECL_ABSTRACT_ORIGIN. We cannot handle debug information
for early inlining so drop it on the floor instead of ICEing in
dwarf2out.c. */
/* Read all the pointer fields in RESULT. */
lto_input_tree_pointers (ib, data_in, result);
+ /* Call back into the streaming module to read anything else it
+ may need. */
+ if (streamer_hooks.read_tree)
+ streamer_hooks.read_tree (ib, data_in, result);
+
/* We should never try to instantiate an MD or NORMAL builtin here. */
if (TREE_CODE (result) == FUNCTION_DECL)
gcc_assert (!lto_stream_as_builtin_p (result));
}
+/* LTO streamer hook for reading GIMPLE trees. IB and DATA_IN are as in
+ lto_read_tree. EXPR is the tree was materialized by lto_read_tree and
+ needs GIMPLE specific data to be filled in. */
+
+void
+lto_streamer_read_tree (struct lto_input_block *ib, struct data_in *data_in,
+ tree expr)
+{
+ if (DECL_P (expr)
+ && TREE_CODE (expr) != FUNCTION_DECL
+ && TREE_CODE (expr) != TRANSLATION_UNIT_DECL)
+ DECL_INITIAL (expr) = lto_input_tree (ib, data_in);
+}
+
+
/* Read and INTEGER_CST node from input block IB using the per-file
context in DATA_IN. */
/* Initialization for the LTO reader. */
void
-lto_init_reader (void)
+lto_reader_init (void)
{
lto_streamer_init ();
-
- memset (<o_stats, 0, sizeof (lto_stats));
- bitmap_obstack_initialize (NULL);
-
file_name_hash_table = htab_create (37, hash_string_slot_node,
eq_string_slot_node, free);
-
- gimple_register_cfg_hooks ();
}
if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
pack_ts_translation_unit_decl_value_fields (bp, expr);
+
+ if (streamer_hooks.pack_value_fields)
+ streamer_hooks.pack_value_fields (bp, expr);
}
break;
default:
- /* No other node is indexable, so it should have been handled
- by lto_output_tree. */
- gcc_unreachable ();
+ {
+ /* See if the streamer allows this node to be indexable
+ like other global declarations. */
+ if (streamer_hooks.indexable_with_decls_p
+ && streamer_hooks.indexable_with_decls_p (expr))
+ {
+ output_record_start (ob, LTO_global_decl_ref);
+ lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
+ }
+ else
+ {
+ /* No other node is indexable, so it should have been
+ handled by lto_output_tree. */
+ gcc_unreachable ();
+ }
+ }
}
}
lto_output_tree_or_ref (ob, DECL_SIZE (expr), ref_p);
lto_output_tree_or_ref (ob, DECL_SIZE_UNIT (expr), ref_p);
- if (TREE_CODE (expr) != FUNCTION_DECL
- && TREE_CODE (expr) != TRANSLATION_UNIT_DECL)
- {
- tree initial = DECL_INITIAL (expr);
- if (TREE_CODE (expr) == VAR_DECL
- && (TREE_STATIC (expr) || DECL_EXTERNAL (expr))
- && initial)
- {
- lto_varpool_encoder_t varpool_encoder = ob->decl_state->varpool_node_encoder;
- struct varpool_node *vnode = varpool_get_node (expr);
- if (!vnode)
- initial = error_mark_node;
- else if (!lto_varpool_encoder_encode_initializer_p (varpool_encoder,
- vnode))
- initial = NULL;
- }
-
- lto_output_tree_or_ref (ob, initial, ref_p);
- }
+ /* Note, DECL_INITIAL is not handled here. Since DECL_INITIAL needs
+ special handling in LTO, it must be handled by streamer hooks. */
lto_output_tree_or_ref (ob, DECL_ATTRIBUTES (expr), ref_p);
+
/* Do not stream DECL_ABSTRACT_ORIGIN. We cannot handle debug information
for early inlining so drop it on the floor instead of ICEing in
dwarf2out.c. */
enum LTO_tags tag;
enum tree_code code;
- /* We should not see any non-GIMPLE tree nodes here. */
+ /* We should not see any tree nodes not handled by the streamer. */
code = TREE_CODE (expr);
- if (!lto_is_streamable (expr))
- internal_error ("tree code %qs is not supported in gimple streams",
- tree_code_name[code]);
+ if (!streamer_hooks.is_streamable (expr))
+ internal_error ("tree code %qs is not supported in %s streams",
+ tree_code_name[code], streamer_hooks.name);
/* The header of a tree node consists of its tag, the size of
the node, and any other information needed to instantiate
output_sleb128 (ob, TREE_VEC_LENGTH (expr));
else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
output_uleb128 (ob, BINFO_N_BASE_BINFOS (expr));
+
+ /* Allow the streamer to write any streamer-specific information
+ needed to instantiate the node when reading. */
+ if (streamer_hooks.output_tree_header)
+ streamer_hooks.output_tree_header (ob, expr);
}
/* Write all the pointer fields in EXPR. */
lto_output_tree_pointers (ob, expr, ref_p);
+ /* Call back into the streaming module to see if it needs to write
+ anything that was not written by the common streamer. */
+ if (streamer_hooks.write_tree)
+ streamer_hooks.write_tree (ob, expr, ref_p);
+
/* Mark the end of EXPR. */
output_zero (ob);
}
+/* GIMPLE hook for writing GIMPLE-specific parts of trees. OB, EXPR
+ and REF_P are as in lto_write_tree. */
+
+void
+lto_streamer_write_tree (struct output_block *ob, tree expr, bool ref_p)
+{
+ if (DECL_P (expr)
+ && TREE_CODE (expr) != FUNCTION_DECL
+ && TREE_CODE (expr) != TRANSLATION_UNIT_DECL)
+ {
+ /* Handle DECL_INITIAL for symbols. */
+ tree initial = DECL_INITIAL (expr);
+ if (TREE_CODE (expr) == VAR_DECL
+ && (TREE_STATIC (expr) || DECL_EXTERNAL (expr))
+ && initial)
+ {
+ lto_varpool_encoder_t varpool_encoder;
+ struct varpool_node *vnode;
+
+ varpool_encoder = ob->decl_state->varpool_node_encoder;
+ vnode = varpool_get_node (expr);
+ if (!vnode)
+ initial = error_mark_node;
+ else if (!lto_varpool_encoder_encode_initializer_p (varpool_encoder,
+ vnode))
+ initial = NULL;
+ }
+
+ lto_output_tree_or_ref (ob, initial, ref_p);
+ }
+}
+
+
/* Emit the integer constant CST to output block OB. If REF_P is true,
CST's type will be emitted as a reference. */
}
-/* Initialize the LTO writer. */
-
-static void
-lto_writer_init (void)
-{
- lto_streamer_init ();
-}
-
-
/* Main entry point from the pass manager. */
static void
int i, n_nodes;
lto_cgraph_encoder_t encoder = lto_get_out_decl_state ()->cgraph_node_encoder;
- lto_writer_init ();
+ /* Initialize the streamer. */
+ lto_streamer_init ();
n_nodes = lto_cgraph_encoder_size (encoder);
/* Process only the functions with bodies. */
/* Statistics gathered during LTO, WPA and LTRANS. */
struct lto_stats_d lto_stats;
+/* Streamer hooks. */
+struct streamer_hooks streamer_hooks;
+
/* LTO uses bitmaps with different life-times. So use a seperate
obstack for all LTO bitmaps. */
static bitmap_obstack lto_obstack;
/* Load all the well-known tree nodes that are always created by
the compiler on startup. This prevents writing them out
unnecessarily. */
- lto_preload_common_nodes (cache);
+ streamer_hooks.preload_common_nodes (cache);
return cache;
}
major, minor,
LTO_major_version, LTO_minor_version);
}
+
+
+/* Return true if EXPR is a tree node that can be written to disk. */
+static inline bool
+lto_is_streamable (tree expr)
+{
+ enum tree_code code = TREE_CODE (expr);
+
+ /* Notice that we reject SSA_NAMEs as well. We only emit the SSA
+ name version in lto_output_tree_ref (see output_ssa_names). */
+ return !is_lang_specific (expr)
+ && code != SSA_NAME
+ && code != CALL_EXPR
+ && code != LANG_TYPE
+ && code != MODIFY_EXPR
+ && code != INIT_EXPR
+ && code != TARGET_EXPR
+ && code != BIND_EXPR
+ && code != WITH_CLEANUP_EXPR
+ && code != STATEMENT_LIST
+ && code != OMP_CLAUSE
+ && code != OPTIMIZATION_NODE
+ && (code == CASE_LABEL_EXPR
+ || code == DECL_EXPR
+ || TREE_CODE_CLASS (code) != tcc_statement);
+}
+
+
+/* Initialize all the streamer hooks used for streaming GIMPLE. */
+
+void
+lto_streamer_hooks_init (void)
+{
+ streamer_hooks_init ();
+ streamer_hooks.name = "gimple";
+ streamer_hooks.preload_common_nodes = lto_preload_common_nodes;
+ streamer_hooks.is_streamable = lto_is_streamable;
+ streamer_hooks.write_tree = lto_streamer_write_tree;
+ streamer_hooks.read_tree = lto_streamer_read_tree;
+}
+
+
+/* Initialize the current set of streamer hooks. */
+
+void
+streamer_hooks_init (void)
+{
+ memset (&streamer_hooks, 0, sizeof (streamer_hooks));
+}
#include "alloc-pool.h"
#include "gcov-io.h"
+/* Forward declarations to avoid including unnecessary headers. */
+struct output_block;
+struct lto_input_block;
+struct data_in;
+struct bitpack_d;
+
/* Define when debugging the LTO streamer. This causes the writer
to output the numeric value for the memory address of the tree node
being emitted. When debugging a problem in the reader, check the
};
+/* Streamer hooks. These functions do additional processing as
+ needed by the module. There are two types of callbacks, those that
+ replace the default behavior and those that supplement it.
+
+ Hooks marked [REQ] are required to be set. Those marked [OPT] may
+ be NULL, if the streamer does not need to implement them. */
+struct streamer_hooks {
+ /* [REQ] A string identifying this streamer. */
+ const char *name;
+
+ /* [REQ] Called by lto_streamer_cache_create to instantiate a cache of
+ well-known nodes. These are tree nodes that are always
+ instantiated by the compiler on startup. Additionally, these
+ nodes need to be shared. This function should call
+ lto_streamer_cache_append on every tree node that it wishes to
+ preload in the streamer cache. This way, the writer will only
+ write out a reference to the tree and the reader will instantiate
+ the tree out of this pre-populated cache. */
+ void (*preload_common_nodes) (struct lto_streamer_cache_d *);
+
+ /* [REQ] Return true if the given tree is supported by this streamer. */
+ bool (*is_streamable) (tree);
+
+ /* [OPT] Called by lto_write_tree after writing all the common parts of
+ a tree. If defined, the callback is in charge of writing all
+ the fields that lto_write_tree did not write out. Arguments
+ are as in lto_write_tree.
+
+ The following tree fields are not handled by common code:
+
+ DECL_ABSTRACT_ORIGIN
+ DECL_INITIAL
+ DECL_SAVED_TREE
+
+ Callbacks may choose to ignore or handle them. If handled,
+ the reader should read them in the exact same sequence written
+ by the writer. */
+ void (*write_tree) (struct output_block *, tree, bool);
+
+ /* [OPT] Called by lto_read_tree after reading all the common parts of
+ a tree. If defined, the callback is in charge of reading all
+ the fields that lto_read_tree did not read in. Arguments
+ are as in lto_read_tree. */
+ void (*read_tree) (struct lto_input_block *, struct data_in *, tree);
+
+ /* [OPT] Called by lto_output_tree_ref to determine if the given tree node
+ should be emitted as a reference to the table of declarations
+ (the same table that holds global declarations). */
+ bool (*indexable_with_decls_p) (tree);
+
+ /* [OPT] Called by pack_value_fields to store any non-pointer fields
+ in the tree structure. The arguments are as in pack_value_fields. */
+ void (*pack_value_fields) (struct bitpack_d *, tree);
+
+ /* [OPT] Called by unpack_value_fields to retrieve any non-pointer fields
+ in the tree structure. The arguments are as in unpack_value_fields. */
+ void (*unpack_value_fields) (struct bitpack_d *, tree);
+
+ /* [OPT] Called by lto_materialize_tree for tree nodes that it does not
+ know how to allocate memory for. If defined, this hook should
+ return a new tree node of the given code. The data_in and
+ input_block arguments are passed in case the hook needs to
+ read more data from the stream to allocate the node.
+ If this hook returns NULL, then lto_materialize_tree will attempt
+ to allocate the tree by calling make_node directly. */
+ tree (*alloc_tree) (enum tree_code, struct lto_input_block *,
+ struct data_in *);
+
+ /* [OPT] Called by lto_output_tree_header to write any streamer-specific
+ information needed to allocate the tree. This hook may assume
+ that the basic header data (tree code, etc) has already been
+ written. It should only write any extra data needed to allocate
+ the node (e.g., in the case of CALL_EXPR, this hook would write
+ the number of arguments to the CALL_EXPR). */
+ void (*output_tree_header) (struct output_block *, tree);
+};
+
+/* Streamer hooks. */
+extern struct streamer_hooks streamer_hooks;
+
/* In lto-section-in.c */
extern struct lto_input_block * lto_create_simple_input_block (
struct lto_file_decl_data *,
extern void lto_orig_address_remove (tree);
#endif
extern void lto_check_version (int, int);
-
+extern void lto_streamer_hooks_init (void);
+extern void lto_streamer_write_tree (struct output_block *, tree, bool);
+extern void lto_streamer_read_tree (struct lto_input_block *,
+ struct data_in *, tree);
+extern void streamer_hooks_init (void);
/* In lto-streamer-in.c */
extern void lto_input_cgraph (struct lto_file_decl_data *, const char *);
-extern void lto_init_reader (void);
+extern void lto_reader_init (void);
extern tree lto_input_tree (struct lto_input_block *, struct data_in *);
extern void lto_input_function_body (struct lto_file_decl_data *, tree,
const char *);
extern void lto_input_constructors_and_inits (struct lto_file_decl_data *,
const char *);
-extern void lto_init_reader (void);
extern struct data_in *lto_data_in_create (struct lto_file_decl_data *,
const char *, unsigned,
VEC(ld_plugin_symbol_resolution_t,heap) *);
|| DECL_BUILT_IN_CLASS (expr) == BUILT_IN_MD));
}
-/* Return true if EXPR is a tree node that can be written to disk. */
-static inline bool
-lto_is_streamable (tree expr)
-{
- enum tree_code code = TREE_CODE (expr);
-
- /* Notice that we reject SSA_NAMEs as well. We only emit the SSA
- name version in lto_output_tree_ref (see output_ssa_names). */
- return !is_lang_specific (expr)
- && code != SSA_NAME
- && code != CALL_EXPR
- && code != LANG_TYPE
- && code != MODIFY_EXPR
- && code != INIT_EXPR
- && code != TARGET_EXPR
- && code != BIND_EXPR
- && code != WITH_CLEANUP_EXPR
- && code != STATEMENT_LIST
- && code != OMP_CLAUSE
- && code != OPTIMIZATION_NODE
- && (code == CASE_LABEL_EXPR
- || code == DECL_EXPR
- || TREE_CODE_CLASS (code) != tcc_statement);
-}
-
DEFINE_DECL_STREAM_FUNCS (TYPE, type)
DEFINE_DECL_STREAM_FUNCS (FIELD_DECL, field_decl)
DEFINE_DECL_STREAM_FUNCS (FN_DECL, fn_decl)
+2011-06-04 Diego Novillo <dnovillo@google.com>
+
+ * lto.c (lto_init): New.
+ (lto_main): Call it.
+
2011-06-03 Diego Novillo <dnovillo@google.com>
* lto.c (get_resolution): Move from lto-streamer-in.c.
setproctitle ("lto1-ltrans");
}
+
+/* Initialize the LTO front end. */
+
+static void
+lto_init (void)
+{
+ lto_process_name ();
+ lto_streamer_hooks_init ();
+ lto_reader_init ();
+ memset (<o_stats, 0, sizeof (lto_stats));
+ bitmap_obstack_initialize (NULL);
+ gimple_register_cfg_hooks ();
+}
+
+
/* Main entry point for the GIMPLE front end. This front end has
three main personalities:
void
lto_main (void)
{
- lto_process_name ();
-
- lto_init_reader ();
+ /* Initialize the LTO front end. */
+ lto_init ();
/* Read all the symbols and call graph from all the files in the
command line. */
projects / thirdparty / gcc.git / commitdiff
