1 /* Read the GIMPLE representation from a file stream.
3 Copyright (C) 2009-2013 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"
36 #include "gimple-ssa.h"
38 #include "tree-ssanames.h"
39 #include "tree-into-ssa.h"
42 #include "tree-pass.h"
45 #include "diagnostic.h"
49 #include "ipa-utils.h"
50 #include "data-streamer.h"
51 #include "gimple-streamer.h"
52 #include "lto-streamer.h"
53 #include "tree-streamer.h"
54 #include "tree-pass.h"
55 #include "streamer-hooks.h"
59 struct freeing_string_slot_hasher
: string_slot_hasher
61 static inline void remove (value_type
*);
65 freeing_string_slot_hasher::remove (value_type
*v
)
70 /* The table to hold the file names. */
71 static hash_table
<freeing_string_slot_hasher
> file_name_hash_table
;
74 /* Check that tag ACTUAL has one of the given values. NUM_TAGS is the
75 number of valid tag values to check. */
78 lto_tag_check_set (enum LTO_tags actual
, int ntags
, ...)
84 for (i
= 0; i
< ntags
; i
++)
85 if ((unsigned) actual
== va_arg (ap
, unsigned))
92 internal_error ("bytecode stream: unexpected tag %s", lto_tag_name (actual
));
96 /* Read LENGTH bytes from STREAM to ADDR. */
99 lto_input_data_block (struct lto_input_block
*ib
, void *addr
, size_t length
)
102 unsigned char *const buffer
= (unsigned char *const) addr
;
104 for (i
= 0; i
< length
; i
++)
105 buffer
[i
] = streamer_read_uchar (ib
);
109 /* Lookup STRING in file_name_hash_table. If found, return the existing
110 string, otherwise insert STRING as the canonical version. */
113 canon_file_name (const char *string
)
116 struct string_slot s_slot
;
117 size_t len
= strlen (string
);
122 slot
= file_name_hash_table
.find_slot (&s_slot
, INSERT
);
126 struct string_slot
*new_slot
;
128 saved_string
= (char *) xmalloc (len
+ 1);
129 new_slot
= XCNEW (struct string_slot
);
130 memcpy (saved_string
, string
, len
+ 1);
131 new_slot
->s
= saved_string
;
138 struct string_slot
*old_slot
= *slot
;
144 /* Read a location bitpack from input block IB. */
147 lto_input_location (struct bitpack_d
*bp
, struct data_in
*data_in
)
149 static const char *current_file
;
150 static int current_line
;
151 static int current_col
;
152 bool file_change
, line_change
, column_change
;
154 bool prev_file
= current_file
!= NULL
;
156 if (bp_unpack_value (bp
, 1))
157 return UNKNOWN_LOCATION
;
159 file_change
= bp_unpack_value (bp
, 1);
160 line_change
= bp_unpack_value (bp
, 1);
161 column_change
= bp_unpack_value (bp
, 1);
164 current_file
= canon_file_name
165 (string_for_index (data_in
,
166 bp_unpack_var_len_unsigned (bp
),
170 current_line
= bp_unpack_var_len_unsigned (bp
);
173 current_col
= bp_unpack_var_len_unsigned (bp
);
178 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
180 linemap_add (line_table
, LC_ENTER
, false, current_file
, current_line
);
182 else if (line_change
)
183 linemap_line_start (line_table
, current_line
, current_col
);
185 return linemap_position_for_column (line_table
, current_col
);
189 /* Read a reference to a tree node from DATA_IN using input block IB.
190 TAG is the expected node that should be found in IB, if TAG belongs
191 to one of the indexable trees, expect to read a reference index to
192 be looked up in one of the symbol tables, otherwise read the pysical
193 representation of the tree using stream_read_tree. FN is the
194 function scope for the read tree. */
197 lto_input_tree_ref (struct lto_input_block
*ib
, struct data_in
*data_in
,
198 struct function
*fn
, enum LTO_tags tag
)
200 unsigned HOST_WIDE_INT ix_u
;
201 tree result
= NULL_TREE
;
203 lto_tag_check_range (tag
, LTO_field_decl_ref
, LTO_global_decl_ref
);
208 ix_u
= streamer_read_uhwi (ib
);
209 result
= lto_file_decl_data_get_type (data_in
->file_data
, ix_u
);
212 case LTO_ssa_name_ref
:
213 ix_u
= streamer_read_uhwi (ib
);
214 result
= (*SSANAMES (fn
))[ix_u
];
217 case LTO_field_decl_ref
:
218 ix_u
= streamer_read_uhwi (ib
);
219 result
= lto_file_decl_data_get_field_decl (data_in
->file_data
, ix_u
);
222 case LTO_function_decl_ref
:
223 ix_u
= streamer_read_uhwi (ib
);
224 result
= lto_file_decl_data_get_fn_decl (data_in
->file_data
, ix_u
);
227 case LTO_type_decl_ref
:
228 ix_u
= streamer_read_uhwi (ib
);
229 result
= lto_file_decl_data_get_type_decl (data_in
->file_data
, ix_u
);
232 case LTO_namespace_decl_ref
:
233 ix_u
= streamer_read_uhwi (ib
);
234 result
= lto_file_decl_data_get_namespace_decl (data_in
->file_data
, ix_u
);
237 case LTO_global_decl_ref
:
238 case LTO_result_decl_ref
:
239 case LTO_const_decl_ref
:
240 case LTO_imported_decl_ref
:
241 case LTO_label_decl_ref
:
242 case LTO_translation_unit_decl_ref
:
243 ix_u
= streamer_read_uhwi (ib
);
244 result
= lto_file_decl_data_get_var_decl (data_in
->file_data
, ix_u
);
257 /* Read and return a double-linked list of catch handlers from input
258 block IB, using descriptors in DATA_IN. */
260 static struct eh_catch_d
*
261 lto_input_eh_catch_list (struct lto_input_block
*ib
, struct data_in
*data_in
,
267 *last_p
= first
= NULL
;
268 tag
= streamer_read_record_start (ib
);
274 lto_tag_check_range (tag
, LTO_eh_catch
, LTO_eh_catch
);
276 /* Read the catch node. */
277 n
= ggc_alloc_cleared_eh_catch_d ();
278 n
->type_list
= stream_read_tree (ib
, data_in
);
279 n
->filter_list
= stream_read_tree (ib
, data_in
);
280 n
->label
= stream_read_tree (ib
, data_in
);
282 /* Register all the types in N->FILTER_LIST. */
283 for (list
= n
->filter_list
; list
; list
= TREE_CHAIN (list
))
284 add_type_for_runtime (TREE_VALUE (list
));
286 /* Chain N to the end of the list. */
288 (*last_p
)->next_catch
= n
;
289 n
->prev_catch
= *last_p
;
292 /* Set the head of the list the first time through the loop. */
296 tag
= streamer_read_record_start (ib
);
303 /* Read and return EH region IX from input block IB, using descriptors
307 input_eh_region (struct lto_input_block
*ib
, struct data_in
*data_in
, int ix
)
312 /* Read the region header. */
313 tag
= streamer_read_record_start (ib
);
317 r
= ggc_alloc_cleared_eh_region_d ();
318 r
->index
= streamer_read_hwi (ib
);
320 gcc_assert (r
->index
== ix
);
322 /* Read all the region pointers as region numbers. We'll fix up
323 the pointers once the whole array has been read. */
324 r
->outer
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
325 r
->inner
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
326 r
->next_peer
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
330 case LTO_ert_cleanup
:
331 r
->type
= ERT_CLEANUP
;
336 struct eh_catch_d
*last_catch
;
338 r
->u
.eh_try
.first_catch
= lto_input_eh_catch_list (ib
, data_in
,
340 r
->u
.eh_try
.last_catch
= last_catch
;
344 case LTO_ert_allowed_exceptions
:
348 r
->type
= ERT_ALLOWED_EXCEPTIONS
;
349 r
->u
.allowed
.type_list
= stream_read_tree (ib
, data_in
);
350 r
->u
.allowed
.label
= stream_read_tree (ib
, data_in
);
351 r
->u
.allowed
.filter
= streamer_read_uhwi (ib
);
353 for (l
= r
->u
.allowed
.type_list
; l
; l
= TREE_CHAIN (l
))
354 add_type_for_runtime (TREE_VALUE (l
));
358 case LTO_ert_must_not_throw
:
360 r
->type
= ERT_MUST_NOT_THROW
;
361 r
->u
.must_not_throw
.failure_decl
= stream_read_tree (ib
, data_in
);
362 bitpack_d bp
= streamer_read_bitpack (ib
);
363 r
->u
.must_not_throw
.failure_loc
364 = stream_input_location (&bp
, data_in
);
372 r
->landing_pads
= (eh_landing_pad
) (intptr_t) streamer_read_hwi (ib
);
378 /* Read and return EH landing pad IX from input block IB, using descriptors
381 static eh_landing_pad
382 input_eh_lp (struct lto_input_block
*ib
, struct data_in
*data_in
, int ix
)
387 /* Read the landing pad header. */
388 tag
= streamer_read_record_start (ib
);
392 lto_tag_check_range (tag
, LTO_eh_landing_pad
, LTO_eh_landing_pad
);
394 lp
= ggc_alloc_cleared_eh_landing_pad_d ();
395 lp
->index
= streamer_read_hwi (ib
);
396 gcc_assert (lp
->index
== ix
);
397 lp
->next_lp
= (eh_landing_pad
) (intptr_t) streamer_read_hwi (ib
);
398 lp
->region
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
399 lp
->post_landing_pad
= stream_read_tree (ib
, data_in
);
405 /* After reading the EH regions, pointers to peer and children regions
406 are region numbers. This converts all these region numbers into
407 real pointers into the rematerialized regions for FN. ROOT_REGION
408 is the region number for the root EH region in FN. */
411 fixup_eh_region_pointers (struct function
*fn
, HOST_WIDE_INT root_region
)
414 vec
<eh_region
, va_gc
> *eh_array
= fn
->eh
->region_array
;
415 vec
<eh_landing_pad
, va_gc
> *lp_array
= fn
->eh
->lp_array
;
419 gcc_assert (eh_array
&& lp_array
);
421 gcc_assert (root_region
>= 0);
422 fn
->eh
->region_tree
= (*eh_array
)[root_region
];
424 #define FIXUP_EH_REGION(r) (r) = (*eh_array)[(HOST_WIDE_INT) (intptr_t) (r)]
425 #define FIXUP_EH_LP(p) (p) = (*lp_array)[(HOST_WIDE_INT) (intptr_t) (p)]
427 /* Convert all the index numbers stored in pointer fields into
428 pointers to the corresponding slots in the EH region array. */
429 FOR_EACH_VEC_ELT (*eh_array
, i
, r
)
431 /* The array may contain NULL regions. */
435 gcc_assert (i
== (unsigned) r
->index
);
436 FIXUP_EH_REGION (r
->outer
);
437 FIXUP_EH_REGION (r
->inner
);
438 FIXUP_EH_REGION (r
->next_peer
);
439 FIXUP_EH_LP (r
->landing_pads
);
442 /* Convert all the index numbers stored in pointer fields into
443 pointers to the corresponding slots in the EH landing pad array. */
444 FOR_EACH_VEC_ELT (*lp_array
, i
, lp
)
446 /* The array may contain NULL landing pads. */
450 gcc_assert (i
== (unsigned) lp
->index
);
451 FIXUP_EH_LP (lp
->next_lp
);
452 FIXUP_EH_REGION (lp
->region
);
455 #undef FIXUP_EH_REGION
460 /* Initialize EH support. */
465 static bool eh_initialized_p
= false;
467 if (eh_initialized_p
)
470 /* Contrary to most other FEs, we only initialize EH support when at
471 least one of the files in the set contains exception regions in
472 it. Since this happens much later than the call to init_eh in
473 lang_dependent_init, we have to set flag_exceptions and call
474 init_eh again to initialize the EH tables. */
478 eh_initialized_p
= true;
482 /* Read the exception table for FN from IB using the data descriptors
486 input_eh_regions (struct lto_input_block
*ib
, struct data_in
*data_in
,
489 HOST_WIDE_INT i
, root_region
, len
;
492 tag
= streamer_read_record_start (ib
);
496 lto_tag_check_range (tag
, LTO_eh_table
, LTO_eh_table
);
498 /* If the file contains EH regions, then it was compiled with
499 -fexceptions. In that case, initialize the backend EH
505 root_region
= streamer_read_hwi (ib
);
506 gcc_assert (root_region
== (int) root_region
);
508 /* Read the EH region array. */
509 len
= streamer_read_hwi (ib
);
510 gcc_assert (len
== (int) len
);
513 vec_safe_grow_cleared (fn
->eh
->region_array
, len
);
514 for (i
= 0; i
< len
; i
++)
516 eh_region r
= input_eh_region (ib
, data_in
, i
);
517 (*fn
->eh
->region_array
)[i
] = r
;
521 /* Read the landing pads. */
522 len
= streamer_read_hwi (ib
);
523 gcc_assert (len
== (int) len
);
526 vec_safe_grow_cleared (fn
->eh
->lp_array
, len
);
527 for (i
= 0; i
< len
; i
++)
529 eh_landing_pad lp
= input_eh_lp (ib
, data_in
, i
);
530 (*fn
->eh
->lp_array
)[i
] = lp
;
534 /* Read the runtime type data. */
535 len
= streamer_read_hwi (ib
);
536 gcc_assert (len
== (int) len
);
539 vec_safe_grow_cleared (fn
->eh
->ttype_data
, len
);
540 for (i
= 0; i
< len
; i
++)
542 tree ttype
= stream_read_tree (ib
, data_in
);
543 (*fn
->eh
->ttype_data
)[i
] = ttype
;
547 /* Read the table of action chains. */
548 len
= streamer_read_hwi (ib
);
549 gcc_assert (len
== (int) len
);
552 if (targetm
.arm_eabi_unwinder
)
554 vec_safe_grow_cleared (fn
->eh
->ehspec_data
.arm_eabi
, len
);
555 for (i
= 0; i
< len
; i
++)
557 tree t
= stream_read_tree (ib
, data_in
);
558 (*fn
->eh
->ehspec_data
.arm_eabi
)[i
] = t
;
563 vec_safe_grow_cleared (fn
->eh
->ehspec_data
.other
, len
);
564 for (i
= 0; i
< len
; i
++)
566 uchar c
= streamer_read_uchar (ib
);
567 (*fn
->eh
->ehspec_data
.other
)[i
] = c
;
572 /* Reconstruct the EH region tree by fixing up the peer/children
574 fixup_eh_region_pointers (fn
, root_region
);
576 tag
= streamer_read_record_start (ib
);
577 lto_tag_check_range (tag
, LTO_null
, LTO_null
);
581 /* Make a new basic block with index INDEX in function FN. */
584 make_new_block (struct function
*fn
, unsigned int index
)
586 basic_block bb
= alloc_block ();
588 SET_BASIC_BLOCK_FOR_FUNCTION (fn
, index
, bb
);
589 n_basic_blocks_for_function (fn
)++;
594 /* Read the CFG for function FN from input block IB. */
597 input_cfg (struct lto_input_block
*ib
, struct function
*fn
,
598 int count_materialization_scale
)
600 unsigned int bb_count
;
605 init_empty_tree_cfg_for_function (fn
);
606 init_ssa_operands (fn
);
608 profile_status_for_function (fn
) = streamer_read_enum (ib
, profile_status_d
,
611 bb_count
= streamer_read_uhwi (ib
);
613 last_basic_block_for_function (fn
) = bb_count
;
614 if (bb_count
> basic_block_info_for_function (fn
)->length ())
615 vec_safe_grow_cleared (basic_block_info_for_function (fn
), bb_count
);
617 if (bb_count
> label_to_block_map_for_function (fn
)->length ())
618 vec_safe_grow_cleared (label_to_block_map_for_function (fn
), bb_count
);
620 index
= streamer_read_hwi (ib
);
623 basic_block bb
= BASIC_BLOCK_FOR_FUNCTION (fn
, index
);
624 unsigned int edge_count
;
627 bb
= make_new_block (fn
, index
);
629 edge_count
= streamer_read_uhwi (ib
);
631 /* Connect up the CFG. */
632 for (i
= 0; i
< edge_count
; i
++)
634 unsigned int dest_index
;
635 unsigned int edge_flags
;
641 dest_index
= streamer_read_uhwi (ib
);
642 probability
= (int) streamer_read_hwi (ib
);
643 count
= apply_scale ((gcov_type
) streamer_read_gcov_count (ib
),
644 count_materialization_scale
);
645 edge_flags
= streamer_read_uhwi (ib
);
647 dest
= BASIC_BLOCK_FOR_FUNCTION (fn
, dest_index
);
650 dest
= make_new_block (fn
, dest_index
);
652 e
= make_edge (bb
, dest
, edge_flags
);
653 e
->probability
= probability
;
657 index
= streamer_read_hwi (ib
);
660 p_bb
= ENTRY_BLOCK_PTR_FOR_FUNCTION (fn
);
661 index
= streamer_read_hwi (ib
);
664 basic_block bb
= BASIC_BLOCK_FOR_FUNCTION (fn
, index
);
668 index
= streamer_read_hwi (ib
);
671 /* ??? The cfgloop interface is tied to cfun. */
672 gcc_assert (cfun
== fn
);
674 /* Input the loop tree. */
675 unsigned n_loops
= streamer_read_uhwi (ib
);
679 struct loops
*loops
= ggc_alloc_cleared_loops ();
680 init_loops_structure (fn
, loops
, n_loops
);
681 set_loops_for_fn (fn
, loops
);
683 /* Input each loop and associate it with its loop header so
684 flow_loops_find can rebuild the loop tree. */
685 for (unsigned i
= 1; i
< n_loops
; ++i
)
687 int header_index
= streamer_read_hwi (ib
);
688 if (header_index
== -1)
690 loops
->larray
->quick_push (NULL
);
694 struct loop
*loop
= alloc_loop ();
695 loop
->header
= BASIC_BLOCK_FOR_FUNCTION (fn
, header_index
);
696 loop
->header
->loop_father
= loop
;
698 /* Read everything copy_loop_info copies. */
699 loop
->estimate_state
= streamer_read_enum (ib
, loop_estimation
, EST_LAST
);
700 loop
->any_upper_bound
= streamer_read_hwi (ib
);
701 if (loop
->any_upper_bound
)
703 loop
->nb_iterations_upper_bound
.low
= streamer_read_uhwi (ib
);
704 loop
->nb_iterations_upper_bound
.high
= streamer_read_hwi (ib
);
706 loop
->any_estimate
= streamer_read_hwi (ib
);
707 if (loop
->any_estimate
)
709 loop
->nb_iterations_estimate
.low
= streamer_read_uhwi (ib
);
710 loop
->nb_iterations_estimate
.high
= streamer_read_hwi (ib
);
713 place_new_loop (fn
, loop
);
715 /* flow_loops_find doesn't like loops not in the tree, hook them
716 all as siblings of the tree root temporarily. */
717 flow_loop_tree_node_add (loops
->tree_root
, loop
);
720 /* Rebuild the loop tree. */
721 flow_loops_find (loops
);
725 /* Read the SSA names array for function FN from DATA_IN using input
729 input_ssa_names (struct lto_input_block
*ib
, struct data_in
*data_in
,
732 unsigned int i
, size
;
734 size
= streamer_read_uhwi (ib
);
735 init_ssanames (fn
, size
);
737 i
= streamer_read_uhwi (ib
);
743 /* Skip over the elements that had been freed. */
744 while (SSANAMES (fn
)->length () < i
)
745 SSANAMES (fn
)->quick_push (NULL_TREE
);
747 is_default_def
= (streamer_read_uchar (ib
) != 0);
748 name
= stream_read_tree (ib
, data_in
);
749 ssa_name
= make_ssa_name_fn (fn
, name
, gimple_build_nop ());
752 set_ssa_default_def (cfun
, SSA_NAME_VAR (ssa_name
), ssa_name
);
754 i
= streamer_read_uhwi (ib
);
759 /* Go through all NODE edges and fixup call_stmt pointers
760 so they point to STMTS. */
763 fixup_call_stmt_edges_1 (struct cgraph_node
*node
, gimple
*stmts
,
766 struct cgraph_edge
*cedge
;
770 for (cedge
= node
->callees
; cedge
; cedge
= cedge
->next_callee
)
772 if (gimple_stmt_max_uid (fn
) < cedge
->lto_stmt_uid
)
773 fatal_error ("Cgraph edge statement index out of range");
774 cedge
->call_stmt
= stmts
[cedge
->lto_stmt_uid
- 1];
775 if (!cedge
->call_stmt
)
776 fatal_error ("Cgraph edge statement index not found");
778 for (cedge
= node
->indirect_calls
; cedge
; cedge
= cedge
->next_callee
)
780 if (gimple_stmt_max_uid (fn
) < cedge
->lto_stmt_uid
)
781 fatal_error ("Cgraph edge statement index out of range");
782 cedge
->call_stmt
= stmts
[cedge
->lto_stmt_uid
- 1];
783 if (!cedge
->call_stmt
)
784 fatal_error ("Cgraph edge statement index not found");
787 ipa_ref_list_reference_iterate (&node
->ref_list
, i
, ref
);
789 if (ref
->lto_stmt_uid
)
791 if (gimple_stmt_max_uid (fn
) < ref
->lto_stmt_uid
)
792 fatal_error ("Reference statement index out of range");
793 ref
->stmt
= stmts
[ref
->lto_stmt_uid
- 1];
795 fatal_error ("Reference statement index not found");
800 /* Fixup call_stmt pointers in NODE and all clones. */
803 fixup_call_stmt_edges (struct cgraph_node
*orig
, gimple
*stmts
)
805 struct cgraph_node
*node
;
808 while (orig
->clone_of
)
809 orig
= orig
->clone_of
;
810 fn
= DECL_STRUCT_FUNCTION (orig
->decl
);
812 fixup_call_stmt_edges_1 (orig
, stmts
, fn
);
814 for (node
= orig
->clones
; node
!= orig
;)
816 fixup_call_stmt_edges_1 (node
, stmts
, fn
);
819 else if (node
->next_sibling_clone
)
820 node
= node
->next_sibling_clone
;
823 while (node
!= orig
&& !node
->next_sibling_clone
)
824 node
= node
->clone_of
;
826 node
= node
->next_sibling_clone
;
832 /* Input the base body of struct function FN from DATA_IN
833 using input block IB. */
836 input_struct_function_base (struct function
*fn
, struct data_in
*data_in
,
837 struct lto_input_block
*ib
)
842 /* Read the static chain and non-local goto save area. */
843 fn
->static_chain_decl
= stream_read_tree (ib
, data_in
);
844 fn
->nonlocal_goto_save_area
= stream_read_tree (ib
, data_in
);
846 /* Read all the local symbols. */
847 len
= streamer_read_hwi (ib
);
851 vec_safe_grow_cleared (fn
->local_decls
, len
);
852 for (i
= 0; i
< len
; i
++)
854 tree t
= stream_read_tree (ib
, data_in
);
855 (*fn
->local_decls
)[i
] = t
;
859 /* Input the current IL state of the function. */
860 fn
->curr_properties
= streamer_read_uhwi (ib
);
862 /* Read all the attributes for FN. */
863 bp
= streamer_read_bitpack (ib
);
864 fn
->is_thunk
= bp_unpack_value (&bp
, 1);
865 fn
->has_local_explicit_reg_vars
= bp_unpack_value (&bp
, 1);
866 fn
->returns_pcc_struct
= bp_unpack_value (&bp
, 1);
867 fn
->returns_struct
= bp_unpack_value (&bp
, 1);
868 fn
->can_throw_non_call_exceptions
= bp_unpack_value (&bp
, 1);
869 fn
->can_delete_dead_exceptions
= bp_unpack_value (&bp
, 1);
870 fn
->always_inline_functions_inlined
= bp_unpack_value (&bp
, 1);
871 fn
->after_inlining
= bp_unpack_value (&bp
, 1);
872 fn
->stdarg
= bp_unpack_value (&bp
, 1);
873 fn
->has_nonlocal_label
= bp_unpack_value (&bp
, 1);
874 fn
->calls_alloca
= bp_unpack_value (&bp
, 1);
875 fn
->calls_setjmp
= bp_unpack_value (&bp
, 1);
876 fn
->va_list_fpr_size
= bp_unpack_value (&bp
, 8);
877 fn
->va_list_gpr_size
= bp_unpack_value (&bp
, 8);
879 /* Input the function start and end loci. */
880 fn
->function_start_locus
= stream_input_location (&bp
, data_in
);
881 fn
->function_end_locus
= stream_input_location (&bp
, data_in
);
885 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
888 input_function (tree fn_decl
, struct data_in
*data_in
,
889 struct lto_input_block
*ib
, struct lto_input_block
*ib_cfg
)
895 struct cgraph_node
*node
;
897 tag
= streamer_read_record_start (ib
);
898 lto_tag_check (tag
, LTO_function
);
900 /* Read decls for parameters and args. */
901 DECL_RESULT (fn_decl
) = stream_read_tree (ib
, data_in
);
902 DECL_ARGUMENTS (fn_decl
) = streamer_read_chain (ib
, data_in
);
904 /* Read the tree of lexical scopes for the function. */
905 DECL_INITIAL (fn_decl
) = stream_read_tree (ib
, data_in
);
907 if (!streamer_read_uhwi (ib
))
910 push_struct_function (fn_decl
);
911 fn
= DECL_STRUCT_FUNCTION (fn_decl
);
913 /* We input IL in SSA form. */
914 cfun
->gimple_df
->in_ssa_p
= true;
916 gimple_register_cfg_hooks ();
918 node
= cgraph_get_create_node (fn_decl
);
919 input_struct_function_base (fn
, data_in
, ib
);
920 input_cfg (ib_cfg
, fn
, node
->count_materialization_scale
);
922 /* Read all the SSA names. */
923 input_ssa_names (ib
, data_in
, fn
);
925 /* Read the exception handling regions in the function. */
926 input_eh_regions (ib
, data_in
, fn
);
928 gcc_assert (DECL_INITIAL (fn_decl
));
929 DECL_SAVED_TREE (fn_decl
) = NULL_TREE
;
931 /* Read all the basic blocks. */
932 tag
= streamer_read_record_start (ib
);
935 input_bb (ib
, tag
, data_in
, fn
,
936 node
->count_materialization_scale
);
937 tag
= streamer_read_record_start (ib
);
940 /* Fix up the call statements that are mentioned in the callgraph
942 set_gimple_stmt_max_uid (cfun
, 0);
945 gimple_stmt_iterator gsi
;
946 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
948 gimple stmt
= gsi_stmt (gsi
);
949 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
951 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
953 gimple stmt
= gsi_stmt (gsi
);
954 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
957 stmts
= (gimple
*) xcalloc (gimple_stmt_max_uid (fn
), sizeof (gimple
));
960 gimple_stmt_iterator bsi
= gsi_start_phis (bb
);
961 while (!gsi_end_p (bsi
))
963 gimple stmt
= gsi_stmt (bsi
);
965 stmts
[gimple_uid (stmt
)] = stmt
;
967 bsi
= gsi_start_bb (bb
);
968 while (!gsi_end_p (bsi
))
970 gimple stmt
= gsi_stmt (bsi
);
971 /* If we're recompiling LTO objects with debug stmts but
972 we're not supposed to have debug stmts, remove them now.
973 We can't remove them earlier because this would cause uid
974 mismatches in fixups, but we can do it at this point, as
975 long as debug stmts don't require fixups. */
976 if (!MAY_HAVE_DEBUG_STMTS
&& is_gimple_debug (stmt
))
978 gimple_stmt_iterator gsi
= bsi
;
980 gsi_remove (&gsi
, true);
985 stmts
[gimple_uid (stmt
)] = stmt
;
990 /* Set the gimple body to the statement sequence in the entry
991 basic block. FIXME lto, this is fairly hacky. The existence
992 of a gimple body is used by the cgraph routines, but we should
993 really use the presence of the CFG. */
995 edge_iterator ei
= ei_start (ENTRY_BLOCK_PTR
->succs
);
996 gimple_set_body (fn_decl
, bb_seq (ei_edge (ei
)->dest
));
999 fixup_call_stmt_edges (node
, stmts
);
1000 execute_all_ipa_stmt_fixups (node
, stmts
);
1002 update_ssa (TODO_update_ssa_only_virtuals
);
1003 free_dominance_info (CDI_DOMINATORS
);
1004 free_dominance_info (CDI_POST_DOMINATORS
);
1010 /* Read the body from DATA for function NODE and fill it in.
1011 FILE_DATA are the global decls and types. SECTION_TYPE is either
1012 LTO_section_function_body or LTO_section_static_initializer. If
1013 section type is LTO_section_function_body, FN must be the decl for
1017 lto_read_body (struct lto_file_decl_data
*file_data
, struct cgraph_node
*node
,
1018 const char *data
, enum lto_section_type section_type
)
1020 const struct lto_function_header
*header
;
1021 struct data_in
*data_in
;
1025 struct lto_input_block ib_cfg
;
1026 struct lto_input_block ib_main
;
1027 tree fn_decl
= node
->decl
;
1029 header
= (const struct lto_function_header
*) data
;
1030 cfg_offset
= sizeof (struct lto_function_header
);
1031 main_offset
= cfg_offset
+ header
->cfg_size
;
1032 string_offset
= main_offset
+ header
->main_size
;
1034 LTO_INIT_INPUT_BLOCK (ib_cfg
,
1039 LTO_INIT_INPUT_BLOCK (ib_main
,
1044 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
1045 header
->string_size
, vNULL
);
1047 /* Make sure the file was generated by the exact same compiler. */
1048 lto_check_version (header
->lto_header
.major_version
,
1049 header
->lto_header
.minor_version
);
1051 if (section_type
== LTO_section_function_body
)
1053 struct lto_in_decl_state
*decl_state
;
1056 gcc_checking_assert (node
);
1058 /* Use the function's decl state. */
1059 decl_state
= lto_get_function_in_decl_state (file_data
, fn_decl
);
1060 gcc_assert (decl_state
);
1061 file_data
->current_decl_state
= decl_state
;
1064 /* Set up the struct function. */
1065 from
= data_in
->reader_cache
->nodes
.length ();
1066 input_function (fn_decl
, data_in
, &ib_main
, &ib_cfg
);
1067 /* And fixup types we streamed locally. */
1069 struct streamer_tree_cache_d
*cache
= data_in
->reader_cache
;
1070 unsigned len
= cache
->nodes
.length ();
1072 for (i
= len
; i
-- > from
;)
1074 tree t
= streamer_tree_cache_get_tree (cache
, i
);
1080 gcc_assert (TYPE_CANONICAL (t
) == NULL_TREE
);
1081 TYPE_CANONICAL (t
) = TYPE_MAIN_VARIANT (t
);
1082 if (TYPE_MAIN_VARIANT (t
) != t
)
1084 gcc_assert (TYPE_NEXT_VARIANT (t
) == NULL_TREE
);
1085 TYPE_NEXT_VARIANT (t
)
1086 = TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t
));
1087 TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t
)) = t
;
1093 /* Restore decl state */
1094 file_data
->current_decl_state
= file_data
->global_decl_state
;
1097 lto_data_in_delete (data_in
);
1101 /* Read the body of NODE using DATA. FILE_DATA holds the global
1105 lto_input_function_body (struct lto_file_decl_data
*file_data
,
1106 struct cgraph_node
*node
, const char *data
)
1108 lto_read_body (file_data
, node
, data
, LTO_section_function_body
);
1112 /* Read the physical representation of a tree node EXPR from
1113 input block IB using the per-file context in DATA_IN. */
1116 lto_read_tree_1 (struct lto_input_block
*ib
, struct data_in
*data_in
, tree expr
)
1118 /* Read all the bitfield values in EXPR. Note that for LTO, we
1119 only write language-independent bitfields, so no more unpacking is
1121 streamer_read_tree_bitfields (ib
, data_in
, expr
);
1123 /* Read all the pointer fields in EXPR. */
1124 streamer_read_tree_body (ib
, data_in
, expr
);
1126 /* Read any LTO-specific data not read by the tree streamer. */
1128 && TREE_CODE (expr
) != FUNCTION_DECL
1129 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
1130 DECL_INITIAL (expr
) = stream_read_tree (ib
, data_in
);
1132 /* We should never try to instantiate an MD or NORMAL builtin here. */
1133 if (TREE_CODE (expr
) == FUNCTION_DECL
)
1134 gcc_assert (!streamer_handle_as_builtin_p (expr
));
1136 #ifdef LTO_STREAMER_DEBUG
1137 /* Remove the mapping to RESULT's original address set by
1138 streamer_alloc_tree. */
1139 lto_orig_address_remove (expr
);
1143 /* Read the physical representation of a tree node with tag TAG from
1144 input block IB using the per-file context in DATA_IN. */
1147 lto_read_tree (struct lto_input_block
*ib
, struct data_in
*data_in
,
1148 enum LTO_tags tag
, hashval_t hash
)
1150 /* Instantiate a new tree node. */
1151 tree result
= streamer_alloc_tree (ib
, data_in
, tag
);
1153 /* Enter RESULT in the reader cache. This will make RESULT
1154 available so that circular references in the rest of the tree
1155 structure can be resolved in subsequent calls to stream_read_tree. */
1156 streamer_tree_cache_append (data_in
->reader_cache
, result
, hash
);
1158 lto_read_tree_1 (ib
, data_in
, result
);
1160 /* end_marker = */ streamer_read_uchar (ib
);
1166 /* Populate the reader cache with trees materialized from the SCC
1167 following in the IB, DATA_IN stream. */
1170 lto_input_scc (struct lto_input_block
*ib
, struct data_in
*data_in
,
1171 unsigned *len
, unsigned *entry_len
)
1173 /* A blob of unnamed tree nodes, fill the cache from it and
1175 unsigned size
= streamer_read_uhwi (ib
);
1176 hashval_t scc_hash
= streamer_read_uhwi (ib
);
1177 unsigned scc_entry_len
= 1;
1181 enum LTO_tags tag
= streamer_read_record_start (ib
);
1182 lto_input_tree_1 (ib
, data_in
, tag
, scc_hash
);
1186 unsigned int first
= data_in
->reader_cache
->nodes
.length ();
1189 scc_entry_len
= streamer_read_uhwi (ib
);
1191 /* Materialize size trees by reading their headers. */
1192 for (unsigned i
= 0; i
< size
; ++i
)
1194 enum LTO_tags tag
= streamer_read_record_start (ib
);
1196 || (tag
>= LTO_field_decl_ref
&& tag
<= LTO_global_decl_ref
)
1197 || tag
== LTO_tree_pickle_reference
1198 || tag
== LTO_builtin_decl
1199 || tag
== LTO_integer_cst
1200 || tag
== LTO_tree_scc
)
1203 result
= streamer_alloc_tree (ib
, data_in
, tag
);
1204 streamer_tree_cache_append (data_in
->reader_cache
, result
, 0);
1207 /* Read the tree bitpacks and references. */
1208 for (unsigned i
= 0; i
< size
; ++i
)
1210 result
= streamer_tree_cache_get_tree (data_in
->reader_cache
,
1212 lto_read_tree_1 (ib
, data_in
, result
);
1213 /* end_marker = */ streamer_read_uchar (ib
);
1218 *entry_len
= scc_entry_len
;
1223 /* Read a tree from input block IB using the per-file context in
1224 DATA_IN. This context is used, for example, to resolve references
1225 to previously read nodes. */
1228 lto_input_tree_1 (struct lto_input_block
*ib
, struct data_in
*data_in
,
1229 enum LTO_tags tag
, hashval_t hash
)
1233 gcc_assert ((unsigned) tag
< (unsigned) LTO_NUM_TAGS
);
1235 if (tag
== LTO_null
)
1237 else if (tag
>= LTO_field_decl_ref
&& tag
<= LTO_global_decl_ref
)
1239 /* If TAG is a reference to an indexable tree, the next value
1240 in IB is the index into the table where we expect to find
1242 result
= lto_input_tree_ref (ib
, data_in
, cfun
, tag
);
1244 else if (tag
== LTO_tree_pickle_reference
)
1246 /* If TAG is a reference to a previously read tree, look it up in
1247 the reader cache. */
1248 result
= streamer_get_pickled_tree (ib
, data_in
);
1250 else if (tag
== LTO_builtin_decl
)
1252 /* If we are going to read a built-in function, all we need is
1253 the code and class. */
1254 result
= streamer_get_builtin_tree (ib
, data_in
);
1256 else if (tag
== LTO_integer_cst
)
1258 /* For shared integer constants in singletons we can use the existing
1259 tree integer constant merging code. */
1260 tree type
= stream_read_tree (ib
, data_in
);
1261 unsigned HOST_WIDE_INT low
= streamer_read_uhwi (ib
);
1262 HOST_WIDE_INT high
= streamer_read_hwi (ib
);
1263 result
= build_int_cst_wide (type
, low
, high
);
1264 streamer_tree_cache_append (data_in
->reader_cache
, result
, hash
);
1266 else if (tag
== LTO_tree_scc
)
1268 unsigned len
, entry_len
;
1270 /* Input and skip the SCC. */
1271 lto_input_scc (ib
, data_in
, &len
, &entry_len
);
1274 return lto_input_tree (ib
, data_in
);
1278 /* Otherwise, materialize a new node from IB. */
1279 result
= lto_read_tree (ib
, data_in
, tag
, hash
);
1286 lto_input_tree (struct lto_input_block
*ib
, struct data_in
*data_in
)
1288 return lto_input_tree_1 (ib
, data_in
, streamer_read_record_start (ib
), 0);
1292 /* Input toplevel asms. */
1295 lto_input_toplevel_asms (struct lto_file_decl_data
*file_data
, int order_base
)
1298 const char *data
= lto_get_section_data (file_data
, LTO_section_asm
,
1300 const struct lto_asm_header
*header
= (const struct lto_asm_header
*) data
;
1302 struct data_in
*data_in
;
1303 struct lto_input_block ib
;
1309 string_offset
= sizeof (*header
) + header
->main_size
;
1311 LTO_INIT_INPUT_BLOCK (ib
,
1312 data
+ sizeof (*header
),
1316 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
1317 header
->string_size
, vNULL
);
1319 /* Make sure the file was generated by the exact same compiler. */
1320 lto_check_version (header
->lto_header
.major_version
,
1321 header
->lto_header
.minor_version
);
1323 while ((str
= streamer_read_string_cst (data_in
, &ib
)))
1325 struct asm_node
*node
= add_asm_node (str
);
1326 node
->order
= streamer_read_hwi (&ib
) + order_base
;
1327 if (node
->order
>= symtab_order
)
1328 symtab_order
= node
->order
+ 1;
1331 lto_data_in_delete (data_in
);
1333 lto_free_section_data (file_data
, LTO_section_asm
, NULL
, data
, len
);
1337 /* Initialization for the LTO reader. */
1340 lto_reader_init (void)
1342 lto_streamer_init ();
1343 file_name_hash_table
.create (37);
1347 /* Create a new data_in object for FILE_DATA. STRINGS is the string
1348 table to use with LEN strings. RESOLUTIONS is the vector of linker
1349 resolutions (NULL if not using a linker plugin). */
1352 lto_data_in_create (struct lto_file_decl_data
*file_data
, const char *strings
,
1354 vec
<ld_plugin_symbol_resolution_t
> resolutions
)
1356 struct data_in
*data_in
= XCNEW (struct data_in
);
1357 data_in
->file_data
= file_data
;
1358 data_in
->strings
= strings
;
1359 data_in
->strings_len
= len
;
1360 data_in
->globals_resolution
= resolutions
;
1361 data_in
->reader_cache
= streamer_tree_cache_create (false, false);
1367 /* Remove DATA_IN. */
1370 lto_data_in_delete (struct data_in
*data_in
)
1372 data_in
->globals_resolution
.release ();
1373 streamer_tree_cache_delete (data_in
->reader_cache
);
1374 free (data_in
->labels
);