diff --git a/gcc/ChangeLog b/gcc/ChangeLog index a3ae40d6821..dfe39b431f4 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,41 @@ +2012-10-10 Richard Biener + + * lto-streamer-in.c (lto_input_location_bitpack): Rename to ... + (lto_input_location): ... this. Kill original. + (input_eh_region): Adjust. + (input_struct_function_base): Likewise. + (lto_read_tree): Likewise. + * lto-streamer-out.c (lto_output_location_bitpack): Rename to ... + (lto_output_location): ... this. Kill original. + (lto_write_tree): Adjust. + (output_eh_region): Likewise. + (output_struct_function_base): Likewise. + * lto-streamer.c (lto_streamer_hooks_init): Initialize location + hooks. + * lto-streamer.h (lto_input_location): Adjust prototype. + (lto_output_location): Likewise. + * streamer-hooks.h (struct streamer_hooks): Adjust prototype + of input_location and output_location hooks. + (stream_input_location): New define. + (stream_output_location): Likewise. + * tree-streamer-in.c (unpack_ts_block_value_fields): Adjust. + (unpack_value_fields): Likewise. + (streamer_read_tree_bitfields): Likewise. + (lto_input_ts_decl_minimal_tree_pointers): Likewise. + (lto_input_ts_exp_tree_pointers): Likewise. + (lto_input_ts_block_tree_pointers): Likewise. + * tree-streamer-out.c (pack_ts_block_value_fields): Adjust. + (streamer_pack_tree_bitfields): Likewise. + (write_ts_decl_minimal_tree_pointers): Likewise. + (write_ts_exp_tree_pointers): Likewise. + (write_ts_block_tree_pointers): Likewise. + * gimple-streamer-in.c (input_phi): Adjust. + (input_gimple_stmt): Likewise. + * gimple-streamer-out.c (output_phi): Adjust. + (output_gimple_stmt): Likewise. + * tree-streamer.h (streamer_read_tree_bitfields): Adjust prototype. + (streamer_pack_tree_bitfields): Likewise. + 2012-10-10 Michael Meissner * config/rs6000/rs6000.c (altivec_expand_dst_builtin): Fix signed diff --git a/gcc/gimple-streamer-in.c b/gcc/gimple-streamer-in.c index e2934c7fa8d..0ad0fb1acfa 100644 --- a/gcc/gimple-streamer-in.c +++ b/gcc/gimple-streamer-in.c @@ -53,7 +53,8 @@ input_phi (struct lto_input_block *ib, basic_block bb, struct data_in *data_in, { tree def = stream_read_tree (ib, data_in); int src_index = streamer_read_uhwi (ib); - location_t arg_loc = lto_input_location (ib, data_in); + bitpack_d bp = streamer_read_bitpack (ib); + location_t arg_loc = stream_input_location (&bp, data_in); basic_block sbb = BASIC_BLOCK_FOR_FUNCTION (fn, src_index); edge e = NULL; @@ -99,7 +100,7 @@ input_gimple_stmt (struct lto_input_block *ib, struct data_in *data_in, stmt->gsbase.subcode = bp_unpack_var_len_unsigned (&bp); /* Read location information. */ - gimple_set_location (stmt, lto_input_location (ib, data_in)); + gimple_set_location (stmt, stream_input_location (&bp, data_in)); /* Read lexical block reference. */ gimple_set_block (stmt, stream_read_tree (ib, data_in)); diff --git a/gcc/gimple-streamer-out.c b/gcc/gimple-streamer-out.c index 22bcbca8d17..e49400b34de 100644 --- a/gcc/gimple-streamer-out.c +++ b/gcc/gimple-streamer-out.c @@ -43,7 +43,9 @@ output_phi (struct output_block *ob, gimple phi) { stream_write_tree (ob, gimple_phi_arg_def (phi, i), true); streamer_write_uhwi (ob, gimple_phi_arg_edge (phi, i)->src->index); - lto_output_location (ob, gimple_phi_arg_location (phi, i)); + bitpack_d bp = bitpack_create (ob->main_stream); + stream_output_location (ob, &bp, gimple_phi_arg_location (phi, i)); + streamer_write_bitpack (&bp); } } @@ -71,10 +73,10 @@ output_gimple_stmt (struct output_block *ob, gimple stmt) bp_pack_value (&bp, gimple_assign_nontemporal_move_p (stmt), 1); bp_pack_value (&bp, gimple_has_volatile_ops (stmt), 1); bp_pack_var_len_unsigned (&bp, stmt->gsbase.subcode); - streamer_write_bitpack (&bp); /* Emit location information for the statement. */ - lto_output_location (ob, LOCATION_LOCUS (gimple_location (stmt))); + stream_output_location (ob, &bp, LOCATION_LOCUS (gimple_location (stmt))); + streamer_write_bitpack (&bp); /* Emit the lexical block holding STMT. */ stream_write_tree (ob, gimple_block (stmt), true); diff --git a/gcc/lto-streamer-in.c b/gcc/lto-streamer-in.c index 91215216f9d..a5d13eec5ff 100644 --- a/gcc/lto-streamer-in.c +++ b/gcc/lto-streamer-in.c @@ -138,8 +138,8 @@ clear_line_info (struct data_in *data_in) /* Read a location bitpack from input block IB. */ -static location_t -lto_input_location_bitpack (struct data_in *data_in, struct bitpack_d *bp) +location_t +lto_input_location (struct bitpack_d *bp, struct data_in *data_in) { bool file_change, line_change, column_change; unsigned len; @@ -178,26 +178,6 @@ lto_input_location_bitpack (struct data_in *data_in, struct bitpack_d *bp) } -/* Read a location from input block IB. - If the input_location streamer hook exists, call it. - Otherwise, proceed with reading the location from the - expanded location bitpack. */ - -location_t -lto_input_location (struct lto_input_block *ib, struct data_in *data_in) -{ - if (streamer_hooks.input_location) - return streamer_hooks.input_location (ib, data_in); - else - { - struct bitpack_d bp; - - bp = streamer_read_bitpack (ib); - return lto_input_location_bitpack (data_in, &bp); - } -} - - /* Read a reference to a tree node from DATA_IN using input block IB. TAG is the expected node that should be found in IB, if TAG belongs to one of the indexable trees, expect to read a reference index to @@ -368,9 +348,13 @@ input_eh_region (struct lto_input_block *ib, struct data_in *data_in, int ix) break; case LTO_ert_must_not_throw: - r->type = ERT_MUST_NOT_THROW; - r->u.must_not_throw.failure_decl = stream_read_tree (ib, data_in); - r->u.must_not_throw.failure_loc = lto_input_location (ib, data_in); + { + r->type = ERT_MUST_NOT_THROW; + r->u.must_not_throw.failure_decl = stream_read_tree (ib, data_in); + bitpack_d bp = streamer_read_bitpack (ib); + r->u.must_not_throw.failure_loc + = stream_input_location (&bp, data_in); + } break; default: @@ -786,10 +770,6 @@ input_struct_function_base (struct function *fn, struct data_in *data_in, } } - /* Input the function start and end loci. */ - fn->function_start_locus = lto_input_location (ib, data_in); - fn->function_end_locus = lto_input_location (ib, data_in); - /* Input the current IL state of the function. */ fn->curr_properties = streamer_read_uhwi (ib); @@ -809,6 +789,10 @@ input_struct_function_base (struct function *fn, struct data_in *data_in, fn->calls_setjmp = bp_unpack_value (&bp, 1); fn->va_list_fpr_size = bp_unpack_value (&bp, 8); fn->va_list_gpr_size = bp_unpack_value (&bp, 8); + + /* Input the function start and end loci. */ + fn->function_start_locus = stream_input_location (&bp, data_in); + fn->function_end_locus = stream_input_location (&bp, data_in); } @@ -1041,7 +1025,7 @@ lto_read_tree (struct lto_input_block *ib, struct data_in *data_in, /* Read all the bitfield values in RESULT. Note that for LTO, we only write language-independent bitfields, so no more unpacking is needed. */ - streamer_read_tree_bitfields (ib, result); + streamer_read_tree_bitfields (ib, data_in, result); /* Read all the pointer fields in RESULT. */ streamer_read_tree_body (ib, data_in, result); diff --git a/gcc/lto-streamer-out.c b/gcc/lto-streamer-out.c index 083db74f911..55a20dd134b 100644 --- a/gcc/lto-streamer-out.c +++ b/gcc/lto-streamer-out.c @@ -148,10 +148,9 @@ tree_is_indexable (tree t) After outputting bitpack, lto_output_location_data has to be done to output actual data. */ -static inline void -lto_output_location_bitpack (struct bitpack_d *bp, - struct output_block *ob, - location_t loc) +void +lto_output_location (struct output_block *ob, struct bitpack_d *bp, + location_t loc) { expanded_location xloc; @@ -182,25 +181,6 @@ lto_output_location_bitpack (struct bitpack_d *bp, } -/* Emit location LOC to output block OB. - If the output_location streamer hook exists, call it. - Otherwise, when bitpack is handy, it is more space efficient to call - lto_output_location_bitpack with existing bitpack. */ - -void -lto_output_location (struct output_block *ob, location_t loc) -{ - if (streamer_hooks.output_location) - streamer_hooks.output_location (ob, loc); - else - { - struct bitpack_d bp = bitpack_create (ob->main_stream); - lto_output_location_bitpack (&bp, ob, loc); - streamer_write_bitpack (&bp); - } -} - - /* If EXPR is an indexable tree node, output a reference to it to output block OB. Otherwise, output the physical representation of EXPR to OB. */ @@ -333,7 +313,7 @@ lto_write_tree (struct output_block *ob, tree expr, bool ref_p) /* Pack all the non-pointer fields in EXPR into a bitpack and write the resulting bitpack. */ bp = bitpack_create (ob->main_stream); - streamer_pack_tree_bitfields (&bp, expr); + streamer_pack_tree_bitfields (ob, &bp, expr); streamer_write_bitpack (&bp); /* Write all the pointer fields in EXPR. */ @@ -505,7 +485,9 @@ output_eh_region (struct output_block *ob, eh_region r) else if (r->type == ERT_MUST_NOT_THROW) { stream_write_tree (ob, r->u.must_not_throw.failure_decl, true); - lto_output_location (ob, r->u.must_not_throw.failure_loc); + bitpack_d bp = bitpack_create (ob->main_stream); + stream_output_location (ob, &bp, r->u.must_not_throw.failure_loc); + streamer_write_bitpack (&bp); } if (r->landing_pads) @@ -751,10 +733,6 @@ output_struct_function_base (struct output_block *ob, struct function *fn) FOR_EACH_VEC_ELT (tree, fn->local_decls, i, t) stream_write_tree (ob, t, true); - /* Output the function start and end loci. */ - lto_output_location (ob, fn->function_start_locus); - lto_output_location (ob, fn->function_end_locus); - /* Output current IL state of the function. */ streamer_write_uhwi (ob, fn->curr_properties); @@ -774,6 +752,11 @@ output_struct_function_base (struct output_block *ob, struct function *fn) bp_pack_value (&bp, fn->calls_setjmp, 1); bp_pack_value (&bp, fn->va_list_fpr_size, 8); bp_pack_value (&bp, fn->va_list_gpr_size, 8); + + /* Output the function start and end loci. */ + stream_output_location (ob, &bp, fn->function_start_locus); + stream_output_location (ob, &bp, fn->function_end_locus); + streamer_write_bitpack (&bp); } diff --git a/gcc/lto-streamer.c b/gcc/lto-streamer.c index 51c6658ec92..a338df0f28c 100644 --- a/gcc/lto-streamer.c +++ b/gcc/lto-streamer.c @@ -387,4 +387,6 @@ lto_streamer_hooks_init (void) streamer_hooks_init (); streamer_hooks.write_tree = lto_output_tree; streamer_hooks.read_tree = lto_input_tree; + streamer_hooks.input_location = lto_input_location; + streamer_hooks.output_location = lto_output_location; } diff --git a/gcc/lto-streamer.h b/gcc/lto-streamer.h index b2f8d30ff63..c7b7ef94871 100644 --- a/gcc/lto-streamer.h +++ b/gcc/lto-streamer.h @@ -809,7 +809,7 @@ extern struct data_in *lto_data_in_create (struct lto_file_decl_data *, VEC(ld_plugin_symbol_resolution_t,heap) *); extern void lto_data_in_delete (struct data_in *); extern void lto_input_data_block (struct lto_input_block *, void *, size_t); -location_t lto_input_location (struct lto_input_block *, struct data_in *); +location_t lto_input_location (struct bitpack_d *, struct data_in *); tree lto_input_tree_ref (struct lto_input_block *, struct data_in *, struct function *, enum LTO_tags); void lto_tag_check_set (enum LTO_tags, int, ...); @@ -829,7 +829,7 @@ void lto_output_decl_state_streams (struct output_block *, void lto_output_decl_state_refs (struct output_block *, struct lto_output_stream *, struct lto_out_decl_state *); -void lto_output_location (struct output_block *, location_t); +void lto_output_location (struct output_block *, struct bitpack_d *, location_t); /* In lto-cgraph.c */ diff --git a/gcc/streamer-hooks.h b/gcc/streamer-hooks.h index d23d130cd3e..03de155d2dc 100644 --- a/gcc/streamer-hooks.h +++ b/gcc/streamer-hooks.h @@ -53,15 +53,11 @@ struct streamer_hooks { tree instantiated from the stream. */ tree (*read_tree) (struct lto_input_block *, struct data_in *); - /* [OPT] Called by lto_input_location to retrieve the source location of the - tree currently being read. If this hook returns NULL, lto_input_location - defaults to calling lto_input_location_bitpack. */ - location_t (*input_location) (struct lto_input_block *, struct data_in *); + /* [REQ] Called by every streaming routine that needs to read a location. */ + location_t (*input_location) (struct bitpack_d *, struct data_in *); - /* [OPT] Called by lto_output_location to write the source_location of the - tree currently being written. If this hook returns NULL, - lto_output_location defaults to calling lto_output_location_bitpack. */ - void (*output_location) (struct output_block *, location_t); + /* [REQ] Called by every streaming routine that needs to write a location. */ + void (*output_location) (struct output_block *, struct bitpack_d *, location_t); }; #define stream_write_tree(OB, EXPR, REF_P) \ @@ -73,6 +69,12 @@ struct streamer_hooks { #define stream_read_tree(IB, DATA_IN) \ streamer_hooks.read_tree(IB, DATA_IN) +#define stream_input_location(BP, DATA_IN) \ + streamer_hooks.input_location(BP, DATA_IN) + +#define stream_output_location(OB, BP, LOC) \ + streamer_hooks.output_location(OB, BP, LOC) + /* Streamer hooks. */ extern struct streamer_hooks streamer_hooks; diff --git a/gcc/tree-streamer-in.c b/gcc/tree-streamer-in.c index fc6984583e8..cfaaf4538b7 100644 --- a/gcc/tree-streamer-in.c +++ b/gcc/tree-streamer-in.c @@ -179,7 +179,6 @@ unpack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr) TREE_FIXED_CST_PTR (expr) = fp; } - /* Unpack all the non-pointer fields of the TS_DECL_COMMON structure of expression EXPR from bitpack BP. */ @@ -355,10 +354,12 @@ unpack_ts_type_common_value_fields (struct bitpack_d *bp, tree expr) of expression EXPR from bitpack BP. */ static void -unpack_ts_block_value_fields (struct bitpack_d *bp, tree expr) +unpack_ts_block_value_fields (struct data_in *data_in, + struct bitpack_d *bp, tree expr) { BLOCK_ABSTRACT (expr) = (unsigned) bp_unpack_value (bp, 1); /* BLOCK_NUMBER is recomputed. */ + BLOCK_SOURCE_LOCATION (expr) = stream_input_location (bp, data_in); } /* Unpack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL @@ -372,7 +373,7 @@ unpack_ts_translation_unit_decl_value_fields (struct bitpack_d *bp ATTRIBUTE_UNU /* Unpack all the non-pointer fields in EXPR into a bit pack. */ static void -unpack_value_fields (struct bitpack_d *bp, tree expr) +unpack_value_fields (struct data_in *data_in, struct bitpack_d *bp, tree expr) { enum tree_code code; @@ -388,6 +389,9 @@ unpack_value_fields (struct bitpack_d *bp, tree expr) if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST)) unpack_ts_fixed_cst_value_fields (bp, expr); + if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL)) + DECL_SOURCE_LOCATION (expr) = stream_input_location (bp, data_in); + if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) unpack_ts_decl_common_value_fields (bp, expr); @@ -403,8 +407,11 @@ unpack_value_fields (struct bitpack_d *bp, tree expr) if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON)) unpack_ts_type_common_value_fields (bp, expr); + if (CODE_CONTAINS_STRUCT (code, TS_EXP)) + SET_EXPR_LOCATION (expr, stream_input_location (bp, data_in)); + if (CODE_CONTAINS_STRUCT (code, TS_BLOCK)) - unpack_ts_block_value_fields (bp, expr); + unpack_ts_block_value_fields (data_in, bp, expr); if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL)) unpack_ts_translation_unit_decl_value_fields (bp, expr); @@ -416,7 +423,8 @@ unpack_value_fields (struct bitpack_d *bp, tree expr) bitfield values that the writer may have written. */ struct bitpack_d -streamer_read_tree_bitfields (struct lto_input_block *ib, tree expr) +streamer_read_tree_bitfields (struct lto_input_block *ib, + struct data_in *data_in, tree expr) { enum tree_code code; struct bitpack_d bp; @@ -431,7 +439,7 @@ streamer_read_tree_bitfields (struct lto_input_block *ib, tree expr) lto_tree_code_to_tag (TREE_CODE (expr))); /* Unpack all the value fields from BP. */ - unpack_value_fields (&bp, expr); + unpack_value_fields (data_in, &bp, expr); return bp; } @@ -563,7 +571,6 @@ lto_input_ts_decl_minimal_tree_pointers (struct lto_input_block *ib, { DECL_NAME (expr) = stream_read_tree (ib, data_in); DECL_CONTEXT (expr) = stream_read_tree (ib, data_in); - DECL_SOURCE_LOCATION (expr) = lto_input_location (ib, data_in); } @@ -770,7 +777,6 @@ lto_input_ts_exp_tree_pointers (struct lto_input_block *ib, struct data_in *data_in, tree expr) { int i, length; - location_t loc; length = streamer_read_hwi (ib); gcc_assert (length == TREE_OPERAND_LENGTH (expr)); @@ -778,8 +784,6 @@ lto_input_ts_exp_tree_pointers (struct lto_input_block *ib, for (i = 0; i < length; i++) TREE_OPERAND (expr, i) = stream_read_tree (ib, data_in); - loc = lto_input_location (ib, data_in); - SET_EXPR_LOCATION (expr, loc); TREE_SET_BLOCK (expr, stream_read_tree (ib, data_in)); } @@ -801,7 +805,6 @@ lto_input_ts_block_tree_pointers (struct lto_input_block *ib, function scopes. For the rest them on the floor instead of ICEing in dwarf2out.c. */ BLOCK_ABSTRACT_ORIGIN (expr) = stream_read_tree (ib, data_in); - BLOCK_SOURCE_LOCATION (expr) = lto_input_location (ib, data_in); /* Do not stream BLOCK_NONLOCALIZED_VARS. We cannot handle debug information for early inlined BLOCKs so drop it on the floor instead of ICEing in dwarf2out.c. */ diff --git a/gcc/tree-streamer-out.c b/gcc/tree-streamer-out.c index 4fccd7720d2..73ffb301fda 100644 --- a/gcc/tree-streamer-out.c +++ b/gcc/tree-streamer-out.c @@ -145,7 +145,6 @@ pack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr) bp_pack_var_len_int (bp, fv.data.high); } - /* Pack all the non-pointer fields of the TS_DECL_COMMON structure of expression EXPR into bitpack BP. */ @@ -299,10 +298,18 @@ pack_ts_type_common_value_fields (struct bitpack_d *bp, tree expr) of expression EXPR into bitpack BP. */ static void -pack_ts_block_value_fields (struct bitpack_d *bp, tree expr) +pack_ts_block_value_fields (struct output_block *ob, + struct bitpack_d *bp, tree expr) { bp_pack_value (bp, BLOCK_ABSTRACT (expr), 1); /* BLOCK_NUMBER is recomputed. */ + /* Stream BLOCK_SOURCE_LOCATION for the limited cases we can handle - those + that represent inlined function scopes. + For the rest them on the floor instead of ICEing in dwarf2out.c. */ + if (inlined_function_outer_scope_p (expr)) + stream_output_location (ob, bp, BLOCK_SOURCE_LOCATION (expr)); + else + stream_output_location (ob, bp, UNKNOWN_LOCATION); } /* Pack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL structure @@ -317,7 +324,8 @@ pack_ts_translation_unit_decl_value_fields (struct bitpack_d *bp ATTRIBUTE_UNUSE /* Pack all the bitfields in EXPR into a bit pack. */ void -streamer_pack_tree_bitfields (struct bitpack_d *bp, tree expr) +streamer_pack_tree_bitfields (struct output_block *ob, + struct bitpack_d *bp, tree expr) { enum tree_code code; @@ -333,6 +341,9 @@ streamer_pack_tree_bitfields (struct bitpack_d *bp, tree expr) if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST)) pack_ts_fixed_cst_value_fields (bp, expr); + if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL)) + stream_output_location (ob, bp, DECL_SOURCE_LOCATION (expr)); + if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) pack_ts_decl_common_value_fields (bp, expr); @@ -348,8 +359,11 @@ streamer_pack_tree_bitfields (struct bitpack_d *bp, tree expr) if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON)) pack_ts_type_common_value_fields (bp, expr); + if (CODE_CONTAINS_STRUCT (code, TS_EXP)) + stream_output_location (ob, bp, EXPR_LOCATION (expr)); + if (CODE_CONTAINS_STRUCT (code, TS_BLOCK)) - pack_ts_block_value_fields (bp, expr); + pack_ts_block_value_fields (ob, bp, expr); if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL)) pack_ts_translation_unit_decl_value_fields (bp, expr); @@ -476,7 +490,6 @@ write_ts_decl_minimal_tree_pointers (struct output_block *ob, tree expr, { stream_write_tree (ob, DECL_NAME (expr), ref_p); stream_write_tree (ob, DECL_CONTEXT (expr), ref_p); - lto_output_location (ob, LOCATION_LOCUS (DECL_SOURCE_LOCATION (expr))); } @@ -673,7 +686,6 @@ write_ts_exp_tree_pointers (struct output_block *ob, tree expr, bool ref_p) 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, LOCATION_LOCUS (EXPR_LOCATION (expr))); stream_write_tree (ob, TREE_BLOCK (expr), ref_p); } @@ -689,21 +701,16 @@ write_ts_block_tree_pointers (struct output_block *ob, tree expr, bool ref_p) stream_write_tree (ob, BLOCK_SUPERCONTEXT (expr), ref_p); - /* Stream BLOCK_ABSTRACT_ORIGIN and BLOCK_SOURCE_LOCATION for - the limited cases we can handle - those that represent inlined - function scopes. For the rest them on the floor instead of ICEing in - dwarf2out.c. */ + /* Stream BLOCK_ABSTRACT_ORIGIN for the limited cases we can handle - those + that represent inlined function scopes. + For the rest them on the floor instead of ICEing in dwarf2out.c. */ if (inlined_function_outer_scope_p (expr)) { tree ultimate_origin = block_ultimate_origin (expr); stream_write_tree (ob, ultimate_origin, ref_p); - lto_output_location (ob, BLOCK_SOURCE_LOCATION (expr)); } else - { - stream_write_tree (ob, NULL_TREE, ref_p); - lto_output_location (ob, UNKNOWN_LOCATION); - } + stream_write_tree (ob, NULL_TREE, ref_p); /* Do not stream BLOCK_NONLOCALIZED_VARS. We cannot handle debug information for early inlined BLOCKs so drop it on the floor instead of ICEing in dwarf2out.c. */ diff --git a/gcc/tree-streamer.h b/gcc/tree-streamer.h index be0b1a3f95d..778712b3e20 100644 --- a/gcc/tree-streamer.h +++ b/gcc/tree-streamer.h @@ -72,14 +72,16 @@ void streamer_read_tree_body (struct lto_input_block *, struct data_in *, tree); tree streamer_get_pickled_tree (struct lto_input_block *, struct data_in *); tree streamer_get_builtin_tree (struct lto_input_block *, struct data_in *); tree streamer_read_integer_cst (struct lto_input_block *, struct data_in *); -struct bitpack_d streamer_read_tree_bitfields (struct lto_input_block *, tree); +struct bitpack_d streamer_read_tree_bitfields (struct lto_input_block *, + struct data_in *, tree); /* In tree-streamer-out.c. */ void streamer_write_string_cst (struct output_block *, struct lto_output_stream *, tree); void streamer_write_chain (struct output_block *, tree, bool); void streamer_write_tree_header (struct output_block *, tree); -void streamer_pack_tree_bitfields (struct bitpack_d *, tree); +void streamer_pack_tree_bitfields (struct output_block *, struct bitpack_d *, + tree); void streamer_write_tree_body (struct output_block *, tree, bool); void streamer_write_integer_cst (struct output_block *, tree, bool); void streamer_write_builtin (struct output_block *, tree);