1 /* Read the GIMPLE representation from a file stream.
3 Copyright 2009, 2010 Free Software Foundation, Inc.
4 Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
5 Re-implemented by Diego Novillo <dnovillo@google.com>
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
34 #include "basic-block.h"
35 #include "tree-flow.h"
36 #include "tree-pass.h"
40 #include "diagnostic.h"
47 #include "ipa-utils.h"
48 #include "data-streamer.h"
49 #include "gimple-streamer.h"
50 #include "lto-streamer.h"
51 #include "tree-streamer.h"
52 #include "tree-pass.h"
54 /* The table to hold the file names. */
55 static htab_t file_name_hash_table
;
58 /* Check that tag ACTUAL has one of the given values. NUM_TAGS is the
59 number of valid tag values to check. */
62 lto_tag_check_set (enum LTO_tags actual
, int ntags
, ...)
68 for (i
= 0; i
< ntags
; i
++)
69 if ((unsigned) actual
== va_arg (ap
, unsigned))
76 internal_error ("bytecode stream: unexpected tag %s", lto_tag_name (actual
));
80 /* Read LENGTH bytes from STREAM to ADDR. */
83 lto_input_data_block (struct lto_input_block
*ib
, void *addr
, size_t length
)
86 unsigned char *const buffer
= (unsigned char *const) addr
;
88 for (i
= 0; i
< length
; i
++)
89 buffer
[i
] = streamer_read_uchar (ib
);
93 /* Lookup STRING in file_name_hash_table. If found, return the existing
94 string, otherwise insert STRING as the canonical version. */
97 canon_file_name (const char *string
)
100 struct string_slot s_slot
;
102 s_slot
.len
= strlen (string
);
104 slot
= htab_find_slot (file_name_hash_table
, &s_slot
, INSERT
);
109 struct string_slot
*new_slot
;
111 len
= strlen (string
);
112 saved_string
= (char *) xmalloc (len
+ 1);
113 new_slot
= XCNEW (struct string_slot
);
114 strcpy (saved_string
, string
);
115 new_slot
->s
= saved_string
;
121 struct string_slot
*old_slot
= (struct string_slot
*) *slot
;
127 /* Clear the line info stored in DATA_IN. */
130 clear_line_info (struct data_in
*data_in
)
132 if (data_in
->current_file
)
133 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
134 data_in
->current_file
= NULL
;
135 data_in
->current_line
= 0;
136 data_in
->current_col
= 0;
140 /* Read a location bitpack from input block IB. */
143 lto_input_location_bitpack (struct data_in
*data_in
, struct bitpack_d
*bp
)
145 bool file_change
, line_change
, column_change
;
147 bool prev_file
= data_in
->current_file
!= NULL
;
149 if (bp_unpack_value (bp
, 1))
150 return UNKNOWN_LOCATION
;
152 file_change
= bp_unpack_value (bp
, 1);
154 data_in
->current_file
= canon_file_name
155 (string_for_index (data_in
,
156 bp_unpack_var_len_unsigned (bp
),
159 line_change
= bp_unpack_value (bp
, 1);
161 data_in
->current_line
= bp_unpack_var_len_unsigned (bp
);
163 column_change
= bp_unpack_value (bp
, 1);
165 data_in
->current_col
= bp_unpack_var_len_unsigned (bp
);
170 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
172 linemap_add (line_table
, LC_ENTER
, false, data_in
->current_file
,
173 data_in
->current_line
);
175 else if (line_change
)
176 linemap_line_start (line_table
, data_in
->current_line
, data_in
->current_col
);
178 return linemap_position_for_column (line_table
, data_in
->current_col
);
182 /* Read a location from input block IB. */
185 lto_input_location (struct lto_input_block
*ib
, struct data_in
*data_in
)
189 bp
= streamer_read_bitpack (ib
);
190 return lto_input_location_bitpack (data_in
, &bp
);
194 /* Read a reference to a tree node from DATA_IN using input block IB.
195 TAG is the expected node that should be found in IB, if TAG belongs
196 to one of the indexable trees, expect to read a reference index to
197 be looked up in one of the symbol tables, otherwise read the pysical
198 representation of the tree using stream_read_tree. FN is the
199 function scope for the read tree. */
202 lto_input_tree_ref (struct lto_input_block
*ib
, struct data_in
*data_in
,
203 struct function
*fn
, enum LTO_tags tag
)
205 unsigned HOST_WIDE_INT ix_u
;
206 tree result
= NULL_TREE
;
208 lto_tag_check_range (tag
, LTO_field_decl_ref
, LTO_global_decl_ref
);
213 ix_u
= streamer_read_uhwi (ib
);
214 result
= lto_file_decl_data_get_type (data_in
->file_data
, ix_u
);
217 case LTO_ssa_name_ref
:
218 ix_u
= streamer_read_uhwi (ib
);
219 result
= VEC_index (tree
, SSANAMES (fn
), ix_u
);
222 case LTO_field_decl_ref
:
223 ix_u
= streamer_read_uhwi (ib
);
224 result
= lto_file_decl_data_get_field_decl (data_in
->file_data
, ix_u
);
227 case LTO_function_decl_ref
:
228 ix_u
= streamer_read_uhwi (ib
);
229 result
= lto_file_decl_data_get_fn_decl (data_in
->file_data
, ix_u
);
232 case LTO_type_decl_ref
:
233 ix_u
= streamer_read_uhwi (ib
);
234 result
= lto_file_decl_data_get_type_decl (data_in
->file_data
, ix_u
);
237 case LTO_namespace_decl_ref
:
238 ix_u
= streamer_read_uhwi (ib
);
239 result
= lto_file_decl_data_get_namespace_decl (data_in
->file_data
, ix_u
);
242 case LTO_global_decl_ref
:
243 case LTO_result_decl_ref
:
244 case LTO_const_decl_ref
:
245 case LTO_imported_decl_ref
:
246 case LTO_label_decl_ref
:
247 case LTO_translation_unit_decl_ref
:
248 ix_u
= streamer_read_uhwi (ib
);
249 result
= lto_file_decl_data_get_var_decl (data_in
->file_data
, ix_u
);
262 /* Read and return a double-linked list of catch handlers from input
263 block IB, using descriptors in DATA_IN. */
265 static struct eh_catch_d
*
266 lto_input_eh_catch_list (struct lto_input_block
*ib
, struct data_in
*data_in
,
272 *last_p
= first
= NULL
;
273 tag
= streamer_read_record_start (ib
);
279 lto_tag_check_range (tag
, LTO_eh_catch
, LTO_eh_catch
);
281 /* Read the catch node. */
282 n
= ggc_alloc_cleared_eh_catch_d ();
283 n
->type_list
= stream_read_tree (ib
, data_in
);
284 n
->filter_list
= stream_read_tree (ib
, data_in
);
285 n
->label
= stream_read_tree (ib
, data_in
);
287 /* Register all the types in N->FILTER_LIST. */
288 for (list
= n
->filter_list
; list
; list
= TREE_CHAIN (list
))
289 add_type_for_runtime (TREE_VALUE (list
));
291 /* Chain N to the end of the list. */
293 (*last_p
)->next_catch
= n
;
294 n
->prev_catch
= *last_p
;
297 /* Set the head of the list the first time through the loop. */
301 tag
= streamer_read_record_start (ib
);
308 /* Read and return EH region IX from input block IB, using descriptors
312 input_eh_region (struct lto_input_block
*ib
, struct data_in
*data_in
, int ix
)
317 /* Read the region header. */
318 tag
= streamer_read_record_start (ib
);
322 r
= ggc_alloc_cleared_eh_region_d ();
323 r
->index
= streamer_read_hwi (ib
);
325 gcc_assert (r
->index
== ix
);
327 /* Read all the region pointers as region numbers. We'll fix up
328 the pointers once the whole array has been read. */
329 r
->outer
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
330 r
->inner
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
331 r
->next_peer
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
335 case LTO_ert_cleanup
:
336 r
->type
= ERT_CLEANUP
;
341 struct eh_catch_d
*last_catch
;
343 r
->u
.eh_try
.first_catch
= lto_input_eh_catch_list (ib
, data_in
,
345 r
->u
.eh_try
.last_catch
= last_catch
;
349 case LTO_ert_allowed_exceptions
:
353 r
->type
= ERT_ALLOWED_EXCEPTIONS
;
354 r
->u
.allowed
.type_list
= stream_read_tree (ib
, data_in
);
355 r
->u
.allowed
.label
= stream_read_tree (ib
, data_in
);
356 r
->u
.allowed
.filter
= streamer_read_uhwi (ib
);
358 for (l
= r
->u
.allowed
.type_list
; l
; l
= TREE_CHAIN (l
))
359 add_type_for_runtime (TREE_VALUE (l
));
363 case LTO_ert_must_not_throw
:
364 r
->type
= ERT_MUST_NOT_THROW
;
365 r
->u
.must_not_throw
.failure_decl
= stream_read_tree (ib
, data_in
);
366 r
->u
.must_not_throw
.failure_loc
= lto_input_location (ib
, data_in
);
373 r
->landing_pads
= (eh_landing_pad
) (intptr_t) streamer_read_hwi (ib
);
379 /* Read and return EH landing pad IX from input block IB, using descriptors
382 static eh_landing_pad
383 input_eh_lp (struct lto_input_block
*ib
, struct data_in
*data_in
, int ix
)
388 /* Read the landing pad header. */
389 tag
= streamer_read_record_start (ib
);
393 lto_tag_check_range (tag
, LTO_eh_landing_pad
, LTO_eh_landing_pad
);
395 lp
= ggc_alloc_cleared_eh_landing_pad_d ();
396 lp
->index
= streamer_read_hwi (ib
);
397 gcc_assert (lp
->index
== ix
);
398 lp
->next_lp
= (eh_landing_pad
) (intptr_t) streamer_read_hwi (ib
);
399 lp
->region
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
400 lp
->post_landing_pad
= stream_read_tree (ib
, data_in
);
406 /* After reading the EH regions, pointers to peer and children regions
407 are region numbers. This converts all these region numbers into
408 real pointers into the rematerialized regions for FN. ROOT_REGION
409 is the region number for the root EH region in FN. */
412 fixup_eh_region_pointers (struct function
*fn
, HOST_WIDE_INT root_region
)
415 VEC(eh_region
,gc
) *eh_array
= fn
->eh
->region_array
;
416 VEC(eh_landing_pad
,gc
) *lp_array
= fn
->eh
->lp_array
;
420 gcc_assert (eh_array
&& lp_array
);
422 gcc_assert (root_region
>= 0);
423 fn
->eh
->region_tree
= VEC_index (eh_region
, eh_array
, root_region
);
425 #define FIXUP_EH_REGION(r) (r) = VEC_index (eh_region, eh_array, \
426 (HOST_WIDE_INT) (intptr_t) (r))
427 #define FIXUP_EH_LP(p) (p) = VEC_index (eh_landing_pad, lp_array, \
428 (HOST_WIDE_INT) (intptr_t) (p))
430 /* Convert all the index numbers stored in pointer fields into
431 pointers to the corresponding slots in the EH region array. */
432 FOR_EACH_VEC_ELT (eh_region
, eh_array
, i
, r
)
434 /* The array may contain NULL regions. */
438 gcc_assert (i
== (unsigned) r
->index
);
439 FIXUP_EH_REGION (r
->outer
);
440 FIXUP_EH_REGION (r
->inner
);
441 FIXUP_EH_REGION (r
->next_peer
);
442 FIXUP_EH_LP (r
->landing_pads
);
445 /* Convert all the index numbers stored in pointer fields into
446 pointers to the corresponding slots in the EH landing pad array. */
447 FOR_EACH_VEC_ELT (eh_landing_pad
, lp_array
, i
, lp
)
449 /* The array may contain NULL landing pads. */
453 gcc_assert (i
== (unsigned) lp
->index
);
454 FIXUP_EH_LP (lp
->next_lp
);
455 FIXUP_EH_REGION (lp
->region
);
458 #undef FIXUP_EH_REGION
463 /* Initialize EH support. */
468 static bool eh_initialized_p
= false;
470 if (eh_initialized_p
)
473 /* Contrary to most other FEs, we only initialize EH support when at
474 least one of the files in the set contains exception regions in
475 it. Since this happens much later than the call to init_eh in
476 lang_dependent_init, we have to set flag_exceptions and call
477 init_eh again to initialize the EH tables. */
481 eh_initialized_p
= true;
485 /* Read the exception table for FN from IB using the data descriptors
489 input_eh_regions (struct lto_input_block
*ib
, struct data_in
*data_in
,
492 HOST_WIDE_INT i
, root_region
, len
;
495 tag
= streamer_read_record_start (ib
);
499 lto_tag_check_range (tag
, LTO_eh_table
, LTO_eh_table
);
501 /* If the file contains EH regions, then it was compiled with
502 -fexceptions. In that case, initialize the backend EH
508 root_region
= streamer_read_hwi (ib
);
509 gcc_assert (root_region
== (int) root_region
);
511 /* Read the EH region array. */
512 len
= streamer_read_hwi (ib
);
513 gcc_assert (len
== (int) len
);
516 VEC_safe_grow (eh_region
, gc
, fn
->eh
->region_array
, len
);
517 for (i
= 0; i
< len
; i
++)
519 eh_region r
= input_eh_region (ib
, data_in
, i
);
520 VEC_replace (eh_region
, fn
->eh
->region_array
, i
, r
);
524 /* Read the landing pads. */
525 len
= streamer_read_hwi (ib
);
526 gcc_assert (len
== (int) len
);
529 VEC_safe_grow (eh_landing_pad
, gc
, fn
->eh
->lp_array
, len
);
530 for (i
= 0; i
< len
; i
++)
532 eh_landing_pad lp
= input_eh_lp (ib
, data_in
, i
);
533 VEC_replace (eh_landing_pad
, fn
->eh
->lp_array
, i
, lp
);
537 /* Read the runtime type data. */
538 len
= streamer_read_hwi (ib
);
539 gcc_assert (len
== (int) len
);
542 VEC_safe_grow (tree
, gc
, fn
->eh
->ttype_data
, len
);
543 for (i
= 0; i
< len
; i
++)
545 tree ttype
= stream_read_tree (ib
, data_in
);
546 VEC_replace (tree
, fn
->eh
->ttype_data
, i
, ttype
);
550 /* Read the table of action chains. */
551 len
= streamer_read_hwi (ib
);
552 gcc_assert (len
== (int) len
);
555 if (targetm
.arm_eabi_unwinder
)
557 VEC_safe_grow (tree
, gc
, fn
->eh
->ehspec_data
.arm_eabi
, len
);
558 for (i
= 0; i
< len
; i
++)
560 tree t
= stream_read_tree (ib
, data_in
);
561 VEC_replace (tree
, fn
->eh
->ehspec_data
.arm_eabi
, i
, t
);
566 VEC_safe_grow (uchar
, gc
, fn
->eh
->ehspec_data
.other
, len
);
567 for (i
= 0; i
< len
; i
++)
569 uchar c
= streamer_read_uchar (ib
);
570 VEC_replace (uchar
, fn
->eh
->ehspec_data
.other
, i
, c
);
575 /* Reconstruct the EH region tree by fixing up the peer/children
577 fixup_eh_region_pointers (fn
, root_region
);
579 tag
= streamer_read_record_start (ib
);
580 lto_tag_check_range (tag
, LTO_null
, LTO_null
);
584 /* Make a new basic block with index INDEX in function FN. */
587 make_new_block (struct function
*fn
, unsigned int index
)
589 basic_block bb
= alloc_block ();
591 SET_BASIC_BLOCK_FOR_FUNCTION (fn
, index
, bb
);
592 bb
->il
.gimple
= ggc_alloc_cleared_gimple_bb_info ();
593 n_basic_blocks_for_function (fn
)++;
595 set_bb_seq (bb
, gimple_seq_alloc ());
600 /* Read the CFG for function FN from input block IB. */
603 input_cfg (struct lto_input_block
*ib
, struct function
*fn
,
604 int count_materialization_scale
)
606 unsigned int bb_count
;
611 init_empty_tree_cfg_for_function (fn
);
612 init_ssa_operands ();
614 profile_status_for_function (fn
) = streamer_read_enum (ib
, profile_status_d
,
617 bb_count
= streamer_read_uhwi (ib
);
619 last_basic_block_for_function (fn
) = bb_count
;
620 if (bb_count
> VEC_length (basic_block
, basic_block_info_for_function (fn
)))
621 VEC_safe_grow_cleared (basic_block
, gc
,
622 basic_block_info_for_function (fn
), bb_count
);
624 if (bb_count
> VEC_length (basic_block
, label_to_block_map_for_function (fn
)))
625 VEC_safe_grow_cleared (basic_block
, gc
,
626 label_to_block_map_for_function (fn
), bb_count
);
628 index
= streamer_read_hwi (ib
);
631 basic_block bb
= BASIC_BLOCK_FOR_FUNCTION (fn
, index
);
632 unsigned int edge_count
;
635 bb
= make_new_block (fn
, index
);
637 edge_count
= streamer_read_uhwi (ib
);
639 /* Connect up the CFG. */
640 for (i
= 0; i
< edge_count
; i
++)
642 unsigned int dest_index
;
643 unsigned int edge_flags
;
649 dest_index
= streamer_read_uhwi (ib
);
650 probability
= (int) streamer_read_hwi (ib
);
651 count
= ((gcov_type
) streamer_read_hwi (ib
) * count_materialization_scale
652 + REG_BR_PROB_BASE
/ 2) / REG_BR_PROB_BASE
;
653 edge_flags
= streamer_read_uhwi (ib
);
655 dest
= BASIC_BLOCK_FOR_FUNCTION (fn
, dest_index
);
658 dest
= make_new_block (fn
, dest_index
);
660 e
= make_edge (bb
, dest
, edge_flags
);
661 e
->probability
= probability
;
665 index
= streamer_read_hwi (ib
);
668 p_bb
= ENTRY_BLOCK_PTR_FOR_FUNCTION(fn
);
669 index
= streamer_read_hwi (ib
);
672 basic_block bb
= BASIC_BLOCK_FOR_FUNCTION (fn
, index
);
676 index
= streamer_read_hwi (ib
);
681 /* Read the SSA names array for function FN from DATA_IN using input
685 input_ssa_names (struct lto_input_block
*ib
, struct data_in
*data_in
,
688 unsigned int i
, size
;
690 size
= streamer_read_uhwi (ib
);
691 init_ssanames (fn
, size
);
693 i
= streamer_read_uhwi (ib
);
699 /* Skip over the elements that had been freed. */
700 while (VEC_length (tree
, SSANAMES (fn
)) < i
)
701 VEC_quick_push (tree
, SSANAMES (fn
), NULL_TREE
);
703 is_default_def
= (streamer_read_uchar (ib
) != 0);
704 name
= stream_read_tree (ib
, data_in
);
705 ssa_name
= make_ssa_name_fn (fn
, name
, gimple_build_nop ());
708 set_default_def (SSA_NAME_VAR (ssa_name
), ssa_name
);
710 i
= streamer_read_uhwi (ib
);
715 /* Go through all NODE edges and fixup call_stmt pointers
716 so they point to STMTS. */
719 fixup_call_stmt_edges_1 (struct cgraph_node
*node
, gimple
*stmts
)
721 struct cgraph_edge
*cedge
;
722 for (cedge
= node
->callees
; cedge
; cedge
= cedge
->next_callee
)
723 cedge
->call_stmt
= stmts
[cedge
->lto_stmt_uid
];
724 for (cedge
= node
->indirect_calls
; cedge
; cedge
= cedge
->next_callee
)
725 cedge
->call_stmt
= stmts
[cedge
->lto_stmt_uid
];
728 /* Fixup call_stmt pointers in NODE and all clones. */
731 fixup_call_stmt_edges (struct cgraph_node
*orig
, gimple
*stmts
)
733 struct cgraph_node
*node
;
735 while (orig
->clone_of
)
736 orig
= orig
->clone_of
;
738 fixup_call_stmt_edges_1 (orig
, stmts
);
740 for (node
= orig
->clones
; node
!= orig
;)
742 fixup_call_stmt_edges_1 (node
, stmts
);
745 else if (node
->next_sibling_clone
)
746 node
= node
->next_sibling_clone
;
749 while (node
!= orig
&& !node
->next_sibling_clone
)
750 node
= node
->clone_of
;
752 node
= node
->next_sibling_clone
;
757 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
760 input_function (tree fn_decl
, struct data_in
*data_in
,
761 struct lto_input_block
*ib
)
768 struct cgraph_node
*node
;
769 tree args
, narg
, oarg
;
772 fn
= DECL_STRUCT_FUNCTION (fn_decl
);
773 tag
= streamer_read_record_start (ib
);
774 clear_line_info (data_in
);
776 gimple_register_cfg_hooks ();
777 lto_tag_check (tag
, LTO_function
);
779 /* Read all the attributes for FN. */
780 bp
= streamer_read_bitpack (ib
);
781 fn
->is_thunk
= bp_unpack_value (&bp
, 1);
782 fn
->has_local_explicit_reg_vars
= bp_unpack_value (&bp
, 1);
783 fn
->after_tree_profile
= bp_unpack_value (&bp
, 1);
784 fn
->returns_pcc_struct
= bp_unpack_value (&bp
, 1);
785 fn
->returns_struct
= bp_unpack_value (&bp
, 1);
786 fn
->can_throw_non_call_exceptions
= bp_unpack_value (&bp
, 1);
787 fn
->always_inline_functions_inlined
= bp_unpack_value (&bp
, 1);
788 fn
->after_inlining
= bp_unpack_value (&bp
, 1);
789 fn
->stdarg
= bp_unpack_value (&bp
, 1);
790 fn
->has_nonlocal_label
= bp_unpack_value (&bp
, 1);
791 fn
->calls_alloca
= bp_unpack_value (&bp
, 1);
792 fn
->calls_setjmp
= bp_unpack_value (&bp
, 1);
793 fn
->va_list_fpr_size
= bp_unpack_value (&bp
, 8);
794 fn
->va_list_gpr_size
= bp_unpack_value (&bp
, 8);
796 /* Input the function start and end loci. */
797 fn
->function_start_locus
= lto_input_location (ib
, data_in
);
798 fn
->function_end_locus
= lto_input_location (ib
, data_in
);
800 /* Input the current IL state of the function. */
801 fn
->curr_properties
= streamer_read_uhwi (ib
);
803 /* Read the static chain and non-local goto save area. */
804 fn
->static_chain_decl
= stream_read_tree (ib
, data_in
);
805 fn
->nonlocal_goto_save_area
= stream_read_tree (ib
, data_in
);
807 /* Read all the local symbols. */
808 len
= streamer_read_hwi (ib
);
812 VEC_safe_grow (tree
, gc
, fn
->local_decls
, len
);
813 for (i
= 0; i
< len
; i
++)
815 tree t
= stream_read_tree (ib
, data_in
);
816 VEC_replace (tree
, fn
->local_decls
, i
, t
);
820 /* Read all function arguments. We need to re-map them here to the
821 arguments of the merged function declaration. */
822 args
= stream_read_tree (ib
, data_in
);
823 for (oarg
= args
, narg
= DECL_ARGUMENTS (fn_decl
);
825 oarg
= TREE_CHAIN (oarg
), narg
= TREE_CHAIN (narg
))
829 res
= streamer_tree_cache_lookup (data_in
->reader_cache
, oarg
, &ix
);
831 /* Replace the argument in the streamer cache. */
832 streamer_tree_cache_insert_at (data_in
->reader_cache
, narg
, ix
);
834 gcc_assert (!oarg
&& !narg
);
836 /* Read all the SSA names. */
837 input_ssa_names (ib
, data_in
, fn
);
839 /* Read the exception handling regions in the function. */
840 input_eh_regions (ib
, data_in
, fn
);
842 /* Read the tree of lexical scopes for the function. */
843 DECL_INITIAL (fn_decl
) = stream_read_tree (ib
, data_in
);
844 gcc_assert (DECL_INITIAL (fn_decl
));
845 DECL_SAVED_TREE (fn_decl
) = NULL_TREE
;
846 node
= cgraph_get_create_node (fn_decl
);
848 /* Read all the basic blocks. */
849 tag
= streamer_read_record_start (ib
);
852 input_bb (ib
, tag
, data_in
, fn
,
853 node
->count_materialization_scale
);
854 tag
= streamer_read_record_start (ib
);
857 /* Fix up the call statements that are mentioned in the callgraph
859 set_gimple_stmt_max_uid (cfun
, 0);
862 gimple_stmt_iterator gsi
;
863 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
865 gimple stmt
= gsi_stmt (gsi
);
866 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
869 stmts
= (gimple
*) xcalloc (gimple_stmt_max_uid (fn
), sizeof (gimple
));
872 gimple_stmt_iterator bsi
= gsi_start_bb (bb
);
873 while (!gsi_end_p (bsi
))
875 gimple stmt
= gsi_stmt (bsi
);
876 /* If we're recompiling LTO objects with debug stmts but
877 we're not supposed to have debug stmts, remove them now.
878 We can't remove them earlier because this would cause uid
879 mismatches in fixups, but we can do it at this point, as
880 long as debug stmts don't require fixups. */
881 if (!MAY_HAVE_DEBUG_STMTS
&& is_gimple_debug (stmt
))
883 gimple_stmt_iterator gsi
= bsi
;
885 gsi_remove (&gsi
, true);
890 stmts
[gimple_uid (stmt
)] = stmt
;
895 /* Set the gimple body to the statement sequence in the entry
896 basic block. FIXME lto, this is fairly hacky. The existence
897 of a gimple body is used by the cgraph routines, but we should
898 really use the presence of the CFG. */
900 edge_iterator ei
= ei_start (ENTRY_BLOCK_PTR
->succs
);
901 gimple_set_body (fn_decl
, bb_seq (ei_edge (ei
)->dest
));
904 fixup_call_stmt_edges (node
, stmts
);
905 execute_all_ipa_stmt_fixups (node
, stmts
);
907 update_ssa (TODO_update_ssa_only_virtuals
);
908 free_dominance_info (CDI_DOMINATORS
);
909 free_dominance_info (CDI_POST_DOMINATORS
);
914 /* Read initializer expressions for public statics. DATA_IN is the
915 file being read. IB is the input block used for reading. */
918 input_alias_pairs (struct lto_input_block
*ib
, struct data_in
*data_in
)
922 clear_line_info (data_in
);
924 var
= stream_read_tree (ib
, data_in
);
927 const char *orig_name
, *new_name
;
930 p
= VEC_safe_push (alias_pair
, gc
, alias_pairs
, NULL
);
932 p
->target
= stream_read_tree (ib
, data_in
);
934 /* If the target is a static object, we may have registered a
935 new name for it to avoid clashes between statics coming from
936 different files. In that case, use the new name. */
937 orig_name
= IDENTIFIER_POINTER (p
->target
);
938 new_name
= lto_get_decl_name_mapping (data_in
->file_data
, orig_name
);
939 if (strcmp (orig_name
, new_name
) != 0)
940 p
->target
= get_identifier (new_name
);
942 var
= stream_read_tree (ib
, data_in
);
947 /* Read the body from DATA for function FN_DECL and fill it in.
948 FILE_DATA are the global decls and types. SECTION_TYPE is either
949 LTO_section_function_body or LTO_section_static_initializer. If
950 section type is LTO_section_function_body, FN must be the decl for
954 lto_read_body (struct lto_file_decl_data
*file_data
, tree fn_decl
,
955 const char *data
, enum lto_section_type section_type
)
957 const struct lto_function_header
*header
;
958 struct data_in
*data_in
;
961 int32_t string_offset
;
962 struct lto_input_block ib_cfg
;
963 struct lto_input_block ib_main
;
965 header
= (const struct lto_function_header
*) data
;
966 cfg_offset
= sizeof (struct lto_function_header
);
967 main_offset
= cfg_offset
+ header
->cfg_size
;
968 string_offset
= main_offset
+ header
->main_size
;
970 LTO_INIT_INPUT_BLOCK (ib_cfg
,
975 LTO_INIT_INPUT_BLOCK (ib_main
,
980 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
981 header
->string_size
, NULL
);
983 /* Make sure the file was generated by the exact same compiler. */
984 lto_check_version (header
->lto_header
.major_version
,
985 header
->lto_header
.minor_version
);
987 if (section_type
== LTO_section_function_body
)
989 struct function
*fn
= DECL_STRUCT_FUNCTION (fn_decl
);
990 struct lto_in_decl_state
*decl_state
;
991 struct cgraph_node
*node
= cgraph_get_node (fn_decl
);
993 gcc_checking_assert (node
);
997 /* Use the function's decl state. */
998 decl_state
= lto_get_function_in_decl_state (file_data
, fn_decl
);
999 gcc_assert (decl_state
);
1000 file_data
->current_decl_state
= decl_state
;
1002 input_cfg (&ib_cfg
, fn
, node
->count_materialization_scale
);
1004 /* Set up the struct function. */
1005 input_function (fn_decl
, data_in
, &ib_main
);
1007 /* We should now be in SSA. */
1008 cfun
->gimple_df
->in_ssa_p
= true;
1010 /* Restore decl state */
1011 file_data
->current_decl_state
= file_data
->global_decl_state
;
1017 input_alias_pairs (&ib_main
, data_in
);
1020 clear_line_info (data_in
);
1021 lto_data_in_delete (data_in
);
1025 /* Read the body of FN_DECL using DATA. FILE_DATA holds the global
1029 lto_input_function_body (struct lto_file_decl_data
*file_data
,
1030 tree fn_decl
, const char *data
)
1032 current_function_decl
= fn_decl
;
1033 lto_read_body (file_data
, fn_decl
, data
, LTO_section_function_body
);
1037 /* Read in VAR_DECL using DATA. FILE_DATA holds the global decls and
1041 lto_input_constructors_and_inits (struct lto_file_decl_data
*file_data
,
1044 lto_read_body (file_data
, NULL
, data
, LTO_section_static_initializer
);
1048 /* Read the physical representation of a tree node with tag TAG from
1049 input block IB using the per-file context in DATA_IN. */
1052 lto_read_tree (struct lto_input_block
*ib
, struct data_in
*data_in
,
1055 /* Instantiate a new tree node. */
1056 tree result
= streamer_alloc_tree (ib
, data_in
, tag
);
1058 /* Enter RESULT in the reader cache. This will make RESULT
1059 available so that circular references in the rest of the tree
1060 structure can be resolved in subsequent calls to stream_read_tree. */
1061 streamer_tree_cache_append (data_in
->reader_cache
, result
);
1063 /* Read all the bitfield values in RESULT. Note that for LTO, we
1064 only write language-independent bitfields, so no more unpacking is
1066 streamer_read_tree_bitfields (ib
, result
);
1068 /* Read all the pointer fields in RESULT. */
1069 streamer_read_tree_body (ib
, data_in
, result
);
1071 /* Read any LTO-specific data not read by the tree streamer. */
1073 && TREE_CODE (result
) != FUNCTION_DECL
1074 && TREE_CODE (result
) != TRANSLATION_UNIT_DECL
)
1075 DECL_INITIAL (result
) = stream_read_tree (ib
, data_in
);
1077 /* We should never try to instantiate an MD or NORMAL builtin here. */
1078 if (TREE_CODE (result
) == FUNCTION_DECL
)
1079 gcc_assert (!streamer_handle_as_builtin_p (result
));
1081 /* end_marker = */ streamer_read_uchar (ib
);
1083 #ifdef LTO_STREAMER_DEBUG
1084 /* Remove the mapping to RESULT's original address set by
1085 streamer_alloc_tree. */
1086 lto_orig_address_remove (result
);
1093 /* Read a tree from input block IB using the per-file context in
1094 DATA_IN. This context is used, for example, to resolve references
1095 to previously read nodes. */
1098 lto_input_tree (struct lto_input_block
*ib
, struct data_in
*data_in
)
1103 tag
= streamer_read_record_start (ib
);
1104 gcc_assert ((unsigned) tag
< (unsigned) LTO_NUM_TAGS
);
1106 if (tag
== LTO_null
)
1108 else if (tag
>= LTO_field_decl_ref
&& tag
<= LTO_global_decl_ref
)
1110 /* If TAG is a reference to an indexable tree, the next value
1111 in IB is the index into the table where we expect to find
1113 result
= lto_input_tree_ref (ib
, data_in
, cfun
, tag
);
1115 else if (tag
== LTO_tree_pickle_reference
)
1117 /* If TAG is a reference to a previously read tree, look it up in
1118 the reader cache. */
1119 result
= streamer_get_pickled_tree (ib
, data_in
);
1121 else if (tag
== LTO_builtin_decl
)
1123 /* If we are going to read a built-in function, all we need is
1124 the code and class. */
1125 result
= streamer_get_builtin_tree (ib
, data_in
);
1127 else if (tag
== lto_tree_code_to_tag (INTEGER_CST
))
1129 /* For integer constants we only need the type and its hi/low
1131 result
= streamer_read_integer_cst (ib
, data_in
);
1135 /* Otherwise, materialize a new node from IB. */
1136 result
= lto_read_tree (ib
, data_in
, tag
);
1143 /* Initialization for the LTO reader. */
1146 lto_reader_init (void)
1148 lto_streamer_init ();
1149 file_name_hash_table
= htab_create (37, hash_string_slot_node
,
1150 eq_string_slot_node
, free
);
1154 /* Create a new data_in object for FILE_DATA. STRINGS is the string
1155 table to use with LEN strings. RESOLUTIONS is the vector of linker
1156 resolutions (NULL if not using a linker plugin). */
1159 lto_data_in_create (struct lto_file_decl_data
*file_data
, const char *strings
,
1161 VEC(ld_plugin_symbol_resolution_t
,heap
) *resolutions
)
1163 struct data_in
*data_in
= XCNEW (struct data_in
);
1164 data_in
->file_data
= file_data
;
1165 data_in
->strings
= strings
;
1166 data_in
->strings_len
= len
;
1167 data_in
->globals_resolution
= resolutions
;
1168 data_in
->reader_cache
= streamer_tree_cache_create ();
1174 /* Remove DATA_IN. */
1177 lto_data_in_delete (struct data_in
*data_in
)
1179 VEC_free (ld_plugin_symbol_resolution_t
, heap
, data_in
->globals_resolution
);
1180 streamer_tree_cache_delete (data_in
->reader_cache
);
1181 free (data_in
->labels
);