/* Output the STRING constant to the string
table in OB. Then put the index onto the INDEX_STREAM. */
-static void
-output_string_cst (struct output_block *ob,
- struct lto_output_stream *index_stream,
- tree string)
+void
+streamer_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,
+ string ? TREE_STRING_POINTER (string)
+ : NULL,
+ string ? TREE_STRING_LENGTH (string) : 0,
+ true);
}
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);
}
else
bp_pack_value (bp, 0, 1);
/* We write debug info two times, do not confuse the second one. */
- bp_pack_value (bp, TYPE_P (expr) ? 0 : TREE_ASM_WRITTEN (expr), 1);
+ bp_pack_value (bp, ((TYPE_P (expr) || TREE_CODE (expr) == TYPE_DECL)
+ ? 0 : TREE_ASM_WRITTEN (expr)), 1);
if (TYPE_P (expr))
bp_pack_value (bp, TYPE_ARTIFICIAL (expr), 1);
else
bp_pack_value (bp, TREE_PROTECTED (expr), 1);
bp_pack_value (bp, TREE_DEPRECATED (expr), 1);
if (TYPE_P (expr))
- bp_pack_value (bp, TYPE_SATURATING (expr), 1);
+ {
+ bp_pack_value (bp, TYPE_SATURATING (expr), 1);
+ bp_pack_value (bp, TYPE_ADDR_SPACE (expr), 8);
+ }
else if (TREE_CODE (expr) == SSA_NAME)
bp_pack_value (bp, SSA_NAME_IS_DEFAULT_DEF (expr), 1);
else
{
/* 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));
bp_pack_value (bp, TYPE_NEEDS_CONSTRUCTING (expr), 1);
if (RECORD_OR_UNION_TYPE_P (expr))
bp_pack_value (bp, TYPE_TRANSPARENT_AGGR (expr), 1);
+ else if (TREE_CODE (expr) == ARRAY_TYPE)
+ bp_pack_value (bp, TYPE_NONALIASED_COMPONENT (expr), 1);
bp_pack_value (bp, TYPE_PACKED (expr), 1);
bp_pack_value (bp, TYPE_RESTRICT (expr), 1);
bp_pack_value (bp, TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr), 2);
{
}
-/* 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;
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))
{
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);
}
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;
saved_chain = TREE_CHAIN (t);
TREE_CHAIN (t) = NULL_TREE;
- stream_write_tree (ob, t, ref_p);
+ /* We avoid outputting external vars or functions by reference
+ to the global decls section as we do not want to have them
+ enter decl merging. This is, of course, only for the call
+ for streaming BLOCK_VARS, but other callers are safe. */
+ if (VAR_OR_FUNCTION_DECL_P (t)
+ && DECL_EXTERNAL (t))
+ stream_write_tree_shallow_non_ref (ob, t, ref_p);
+ else
+ stream_write_tree (ob, t, ref_p);
TREE_CHAIN (t) = saved_chain;
t = TREE_CHAIN (t);
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);
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);
}
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);
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);
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);
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)
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)
{
stream_write_tree (ob, DECL_ARGUMENTS (expr), ref_p);
stream_write_tree (ob, DECL_RESULT (expr), ref_p);
}
+ else if (TREE_CODE (expr) == TYPE_DECL)
+ stream_write_tree (ob, DECL_ORIGINAL_TYPE (expr), ref_p);
stream_write_tree (ob, DECL_VINDEX (expr), ref_p);
}
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))
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_BIT_FIELD_REPRESENTATIVE (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);
}
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? */
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);
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);
else if (TREE_CODE (expr) == ARRAY_TYPE)
stream_write_tree (ob, TYPE_DOMAIN (expr), ref_p);
else if (RECORD_OR_UNION_TYPE_P (expr))
- stream_write_tree (ob, TYPE_FIELDS (expr), ref_p);
+ streamer_write_chain (ob, TYPE_FIELDS (expr), ref_p);
else if (TREE_CODE (expr) == FUNCTION_TYPE
|| TREE_CODE (expr) == METHOD_TYPE)
stream_write_tree (ob, TYPE_ARG_TYPES (expr), ref_p);
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);
}
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);
}
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));
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
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);
stream_write_tree (ob, BINFO_OFFSET (expr), ref_p);
stream_write_tree (ob, BINFO_VTABLE (expr), ref_p);
- /* BINFO_VIRTUALS is used to drive type based devirtualizatoin. It often links
- together large portions of programs making it harder to partition. Becuase
- devirtualization is interesting before inlining, only, there is no real
- need to ship it into ltrans partition. */
- 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);
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);
/* 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;
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_OPTIMIZATION tree in EXPR to OB. */
+
+static void
+write_ts_optimization (struct output_block *ob, tree expr)
+{
+ struct cl_optimization *t = TREE_OPTIMIZATION (expr);
+ struct bitpack_d bp;
+ unsigned i, len;
+
+ /* The cl_optimization is generated by the options
+ awk script, so we just recreate a byte-by-byte copy here. */
+
+ bp = bitpack_create (ob->main_stream);
+ len = sizeof (struct cl_optimization);
+ for (i = 0; i < len; i++)
+ bp_pack_value (&bp, ((unsigned char *)t)[i], 8);
+ /* Catch struct size mismatches between reader and writer. */
+ bp_pack_value (&bp, 0x12345678, 32);
+ 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_OPTIMIZATION))
+ write_ts_optimization (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);
}
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;
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
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);
+ streamer_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));
}
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));
}
OSDN Git Service
