1 /* Read the GIMPLE representation from a file stream.
3 Copyright (C) 2009-2014 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"
29 #include "stringpool.h"
39 #include "hard-reg-set.h"
41 #include "dominance.h"
43 #include "basic-block.h"
44 #include "tree-ssa-alias.h"
45 #include "internal-fn.h"
46 #include "gimple-expr.h"
49 #include "gimple-iterator.h"
50 #include "gimple-ssa.h"
52 #include "tree-ssanames.h"
53 #include "tree-into-ssa.h"
56 #include "tree-pass.h"
57 #include "diagnostic.h"
61 #include "plugin-api.h"
64 #include "ipa-utils.h"
65 #include "data-streamer.h"
66 #include "gimple-streamer.h"
67 #include "lto-streamer.h"
68 #include "tree-streamer.h"
69 #include "tree-pass.h"
70 #include "streamer-hooks.h"
74 struct freeing_string_slot_hasher
: string_slot_hasher
76 static inline void remove (value_type
*);
80 freeing_string_slot_hasher::remove (value_type
*v
)
85 /* The table to hold the file names. */
86 static hash_table
<freeing_string_slot_hasher
> *file_name_hash_table
;
89 /* Check that tag ACTUAL has one of the given values. NUM_TAGS is the
90 number of valid tag values to check. */
93 lto_tag_check_set (enum LTO_tags actual
, int ntags
, ...)
99 for (i
= 0; i
< ntags
; i
++)
100 if ((unsigned) actual
== va_arg (ap
, unsigned))
107 internal_error ("bytecode stream: unexpected tag %s", lto_tag_name (actual
));
111 /* Read LENGTH bytes from STREAM to ADDR. */
114 lto_input_data_block (struct lto_input_block
*ib
, void *addr
, size_t length
)
117 unsigned char *const buffer
= (unsigned char *const) addr
;
119 for (i
= 0; i
< length
; i
++)
120 buffer
[i
] = streamer_read_uchar (ib
);
124 /* Lookup STRING in file_name_hash_table. If found, return the existing
125 string, otherwise insert STRING as the canonical version. */
128 canon_file_name (const char *string
)
131 struct string_slot s_slot
;
132 size_t len
= strlen (string
);
137 slot
= file_name_hash_table
->find_slot (&s_slot
, INSERT
);
141 struct string_slot
*new_slot
;
143 saved_string
= (char *) xmalloc (len
+ 1);
144 new_slot
= XCNEW (struct string_slot
);
145 memcpy (saved_string
, string
, len
+ 1);
146 new_slot
->s
= saved_string
;
153 struct string_slot
*old_slot
= *slot
;
159 /* Read a location bitpack from input block IB. */
162 lto_input_location (struct bitpack_d
*bp
, struct data_in
*data_in
)
164 static const char *current_file
;
165 static int current_line
;
166 static int current_col
;
167 bool file_change
, line_change
, column_change
;
168 bool prev_file
= current_file
!= NULL
;
170 if (bp_unpack_value (bp
, 1))
171 return UNKNOWN_LOCATION
;
173 file_change
= bp_unpack_value (bp
, 1);
174 line_change
= bp_unpack_value (bp
, 1);
175 column_change
= bp_unpack_value (bp
, 1);
178 current_file
= canon_file_name (bp_unpack_string (data_in
, bp
));
181 current_line
= bp_unpack_var_len_unsigned (bp
);
184 current_col
= bp_unpack_var_len_unsigned (bp
);
189 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
191 linemap_add (line_table
, LC_ENTER
, false, current_file
, current_line
);
193 else if (line_change
)
194 linemap_line_start (line_table
, current_line
, current_col
);
196 return linemap_position_for_column (line_table
, current_col
);
200 /* Read a reference to a tree node from DATA_IN using input block IB.
201 TAG is the expected node that should be found in IB, if TAG belongs
202 to one of the indexable trees, expect to read a reference index to
203 be looked up in one of the symbol tables, otherwise read the pysical
204 representation of the tree using stream_read_tree. FN is the
205 function scope for the read tree. */
208 lto_input_tree_ref (struct lto_input_block
*ib
, struct data_in
*data_in
,
209 struct function
*fn
, enum LTO_tags tag
)
211 unsigned HOST_WIDE_INT ix_u
;
212 tree result
= NULL_TREE
;
214 lto_tag_check_range (tag
, LTO_field_decl_ref
, LTO_namelist_decl_ref
);
219 ix_u
= streamer_read_uhwi (ib
);
220 result
= lto_file_decl_data_get_type (data_in
->file_data
, ix_u
);
223 case LTO_ssa_name_ref
:
224 ix_u
= streamer_read_uhwi (ib
);
225 result
= (*SSANAMES (fn
))[ix_u
];
228 case LTO_field_decl_ref
:
229 ix_u
= streamer_read_uhwi (ib
);
230 result
= lto_file_decl_data_get_field_decl (data_in
->file_data
, ix_u
);
233 case LTO_function_decl_ref
:
234 ix_u
= streamer_read_uhwi (ib
);
235 result
= lto_file_decl_data_get_fn_decl (data_in
->file_data
, ix_u
);
238 case LTO_type_decl_ref
:
239 ix_u
= streamer_read_uhwi (ib
);
240 result
= lto_file_decl_data_get_type_decl (data_in
->file_data
, ix_u
);
243 case LTO_namespace_decl_ref
:
244 ix_u
= streamer_read_uhwi (ib
);
245 result
= lto_file_decl_data_get_namespace_decl (data_in
->file_data
, ix_u
);
248 case LTO_global_decl_ref
:
249 case LTO_result_decl_ref
:
250 case LTO_const_decl_ref
:
251 case LTO_imported_decl_ref
:
252 case LTO_label_decl_ref
:
253 case LTO_translation_unit_decl_ref
:
254 case LTO_namelist_decl_ref
:
255 ix_u
= streamer_read_uhwi (ib
);
256 result
= lto_file_decl_data_get_var_decl (data_in
->file_data
, ix_u
);
269 /* Read and return a double-linked list of catch handlers from input
270 block IB, using descriptors in DATA_IN. */
272 static struct eh_catch_d
*
273 lto_input_eh_catch_list (struct lto_input_block
*ib
, struct data_in
*data_in
,
279 *last_p
= first
= NULL
;
280 tag
= streamer_read_record_start (ib
);
286 lto_tag_check_range (tag
, LTO_eh_catch
, LTO_eh_catch
);
288 /* Read the catch node. */
289 n
= ggc_cleared_alloc
<eh_catch_d
> ();
290 n
->type_list
= stream_read_tree (ib
, data_in
);
291 n
->filter_list
= stream_read_tree (ib
, data_in
);
292 n
->label
= stream_read_tree (ib
, data_in
);
294 /* Register all the types in N->FILTER_LIST. */
295 for (list
= n
->filter_list
; list
; list
= TREE_CHAIN (list
))
296 add_type_for_runtime (TREE_VALUE (list
));
298 /* Chain N to the end of the list. */
300 (*last_p
)->next_catch
= n
;
301 n
->prev_catch
= *last_p
;
304 /* Set the head of the list the first time through the loop. */
308 tag
= streamer_read_record_start (ib
);
315 /* Read and return EH region IX from input block IB, using descriptors
319 input_eh_region (struct lto_input_block
*ib
, struct data_in
*data_in
, int ix
)
324 /* Read the region header. */
325 tag
= streamer_read_record_start (ib
);
329 r
= ggc_cleared_alloc
<eh_region_d
> ();
330 r
->index
= streamer_read_hwi (ib
);
332 gcc_assert (r
->index
== ix
);
334 /* Read all the region pointers as region numbers. We'll fix up
335 the pointers once the whole array has been read. */
336 r
->outer
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
337 r
->inner
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
338 r
->next_peer
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
342 case LTO_ert_cleanup
:
343 r
->type
= ERT_CLEANUP
;
348 struct eh_catch_d
*last_catch
;
350 r
->u
.eh_try
.first_catch
= lto_input_eh_catch_list (ib
, data_in
,
352 r
->u
.eh_try
.last_catch
= last_catch
;
356 case LTO_ert_allowed_exceptions
:
360 r
->type
= ERT_ALLOWED_EXCEPTIONS
;
361 r
->u
.allowed
.type_list
= stream_read_tree (ib
, data_in
);
362 r
->u
.allowed
.label
= stream_read_tree (ib
, data_in
);
363 r
->u
.allowed
.filter
= streamer_read_uhwi (ib
);
365 for (l
= r
->u
.allowed
.type_list
; l
; l
= TREE_CHAIN (l
))
366 add_type_for_runtime (TREE_VALUE (l
));
370 case LTO_ert_must_not_throw
:
372 r
->type
= ERT_MUST_NOT_THROW
;
373 r
->u
.must_not_throw
.failure_decl
= stream_read_tree (ib
, data_in
);
374 bitpack_d bp
= streamer_read_bitpack (ib
);
375 r
->u
.must_not_throw
.failure_loc
376 = stream_input_location (&bp
, data_in
);
384 r
->landing_pads
= (eh_landing_pad
) (intptr_t) streamer_read_hwi (ib
);
390 /* Read and return EH landing pad IX from input block IB, using descriptors
393 static eh_landing_pad
394 input_eh_lp (struct lto_input_block
*ib
, struct data_in
*data_in
, int ix
)
399 /* Read the landing pad header. */
400 tag
= streamer_read_record_start (ib
);
404 lto_tag_check_range (tag
, LTO_eh_landing_pad
, LTO_eh_landing_pad
);
406 lp
= ggc_cleared_alloc
<eh_landing_pad_d
> ();
407 lp
->index
= streamer_read_hwi (ib
);
408 gcc_assert (lp
->index
== ix
);
409 lp
->next_lp
= (eh_landing_pad
) (intptr_t) streamer_read_hwi (ib
);
410 lp
->region
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
411 lp
->post_landing_pad
= stream_read_tree (ib
, data_in
);
417 /* After reading the EH regions, pointers to peer and children regions
418 are region numbers. This converts all these region numbers into
419 real pointers into the rematerialized regions for FN. ROOT_REGION
420 is the region number for the root EH region in FN. */
423 fixup_eh_region_pointers (struct function
*fn
, HOST_WIDE_INT root_region
)
426 vec
<eh_region
, va_gc
> *eh_array
= fn
->eh
->region_array
;
427 vec
<eh_landing_pad
, va_gc
> *lp_array
= fn
->eh
->lp_array
;
431 gcc_assert (eh_array
&& lp_array
);
433 gcc_assert (root_region
>= 0);
434 fn
->eh
->region_tree
= (*eh_array
)[root_region
];
436 #define FIXUP_EH_REGION(r) (r) = (*eh_array)[(HOST_WIDE_INT) (intptr_t) (r)]
437 #define FIXUP_EH_LP(p) (p) = (*lp_array)[(HOST_WIDE_INT) (intptr_t) (p)]
439 /* Convert all the index numbers stored in pointer fields into
440 pointers to the corresponding slots in the EH region array. */
441 FOR_EACH_VEC_ELT (*eh_array
, i
, r
)
443 /* The array may contain NULL regions. */
447 gcc_assert (i
== (unsigned) r
->index
);
448 FIXUP_EH_REGION (r
->outer
);
449 FIXUP_EH_REGION (r
->inner
);
450 FIXUP_EH_REGION (r
->next_peer
);
451 FIXUP_EH_LP (r
->landing_pads
);
454 /* Convert all the index numbers stored in pointer fields into
455 pointers to the corresponding slots in the EH landing pad array. */
456 FOR_EACH_VEC_ELT (*lp_array
, i
, lp
)
458 /* The array may contain NULL landing pads. */
462 gcc_assert (i
== (unsigned) lp
->index
);
463 FIXUP_EH_LP (lp
->next_lp
);
464 FIXUP_EH_REGION (lp
->region
);
467 #undef FIXUP_EH_REGION
472 /* Initialize EH support. */
477 static bool eh_initialized_p
= false;
479 if (eh_initialized_p
)
482 /* Contrary to most other FEs, we only initialize EH support when at
483 least one of the files in the set contains exception regions in
484 it. Since this happens much later than the call to init_eh in
485 lang_dependent_init, we have to set flag_exceptions and call
486 init_eh again to initialize the EH tables. */
490 eh_initialized_p
= true;
494 /* Read the exception table for FN from IB using the data descriptors
498 input_eh_regions (struct lto_input_block
*ib
, struct data_in
*data_in
,
501 HOST_WIDE_INT i
, root_region
, len
;
504 tag
= streamer_read_record_start (ib
);
508 lto_tag_check_range (tag
, LTO_eh_table
, LTO_eh_table
);
510 /* If the file contains EH regions, then it was compiled with
511 -fexceptions. In that case, initialize the backend EH
517 root_region
= streamer_read_hwi (ib
);
518 gcc_assert (root_region
== (int) root_region
);
520 /* Read the EH region array. */
521 len
= streamer_read_hwi (ib
);
522 gcc_assert (len
== (int) len
);
525 vec_safe_grow_cleared (fn
->eh
->region_array
, len
);
526 for (i
= 0; i
< len
; i
++)
528 eh_region r
= input_eh_region (ib
, data_in
, i
);
529 (*fn
->eh
->region_array
)[i
] = r
;
533 /* Read the landing pads. */
534 len
= streamer_read_hwi (ib
);
535 gcc_assert (len
== (int) len
);
538 vec_safe_grow_cleared (fn
->eh
->lp_array
, len
);
539 for (i
= 0; i
< len
; i
++)
541 eh_landing_pad lp
= input_eh_lp (ib
, data_in
, i
);
542 (*fn
->eh
->lp_array
)[i
] = lp
;
546 /* Read the runtime type data. */
547 len
= streamer_read_hwi (ib
);
548 gcc_assert (len
== (int) len
);
551 vec_safe_grow_cleared (fn
->eh
->ttype_data
, len
);
552 for (i
= 0; i
< len
; i
++)
554 tree ttype
= stream_read_tree (ib
, data_in
);
555 (*fn
->eh
->ttype_data
)[i
] = ttype
;
559 /* Read the table of action chains. */
560 len
= streamer_read_hwi (ib
);
561 gcc_assert (len
== (int) len
);
564 if (targetm
.arm_eabi_unwinder
)
566 vec_safe_grow_cleared (fn
->eh
->ehspec_data
.arm_eabi
, len
);
567 for (i
= 0; i
< len
; i
++)
569 tree t
= stream_read_tree (ib
, data_in
);
570 (*fn
->eh
->ehspec_data
.arm_eabi
)[i
] = t
;
575 vec_safe_grow_cleared (fn
->eh
->ehspec_data
.other
, len
);
576 for (i
= 0; i
< len
; i
++)
578 uchar c
= streamer_read_uchar (ib
);
579 (*fn
->eh
->ehspec_data
.other
)[i
] = c
;
584 /* Reconstruct the EH region tree by fixing up the peer/children
586 fixup_eh_region_pointers (fn
, root_region
);
588 tag
= streamer_read_record_start (ib
);
589 lto_tag_check_range (tag
, LTO_null
, LTO_null
);
593 /* Make a new basic block with index INDEX in function FN. */
596 make_new_block (struct function
*fn
, unsigned int index
)
598 basic_block bb
= alloc_block ();
600 SET_BASIC_BLOCK_FOR_FN (fn
, index
, bb
);
601 n_basic_blocks_for_fn (fn
)++;
606 /* Read a wide-int. */
609 streamer_read_wi (struct lto_input_block
*ib
)
611 HOST_WIDE_INT a
[WIDE_INT_MAX_ELTS
];
613 int prec ATTRIBUTE_UNUSED
= streamer_read_uhwi (ib
);
614 int len
= streamer_read_uhwi (ib
);
615 for (i
= 0; i
< len
; i
++)
616 a
[i
] = streamer_read_hwi (ib
);
617 return widest_int::from_array (a
, len
);
621 /* Read the CFG for function FN from input block IB. */
624 input_cfg (struct lto_input_block
*ib
, struct data_in
*data_in
,
626 int count_materialization_scale
)
628 unsigned int bb_count
;
633 init_empty_tree_cfg_for_function (fn
);
634 init_ssa_operands (fn
);
636 profile_status_for_fn (fn
) = streamer_read_enum (ib
, profile_status_d
,
639 bb_count
= streamer_read_uhwi (ib
);
641 last_basic_block_for_fn (fn
) = bb_count
;
642 if (bb_count
> basic_block_info_for_fn (fn
)->length ())
643 vec_safe_grow_cleared (basic_block_info_for_fn (fn
), bb_count
);
645 if (bb_count
> label_to_block_map_for_fn (fn
)->length ())
646 vec_safe_grow_cleared (label_to_block_map_for_fn (fn
), bb_count
);
648 index
= streamer_read_hwi (ib
);
651 basic_block bb
= BASIC_BLOCK_FOR_FN (fn
, index
);
652 unsigned int edge_count
;
655 bb
= make_new_block (fn
, index
);
657 edge_count
= streamer_read_uhwi (ib
);
659 /* Connect up the CFG. */
660 for (i
= 0; i
< edge_count
; i
++)
662 unsigned int dest_index
;
663 unsigned int edge_flags
;
669 dest_index
= streamer_read_uhwi (ib
);
670 probability
= (int) streamer_read_hwi (ib
);
671 count
= apply_scale ((gcov_type
) streamer_read_gcov_count (ib
),
672 count_materialization_scale
);
673 edge_flags
= streamer_read_uhwi (ib
);
675 dest
= BASIC_BLOCK_FOR_FN (fn
, dest_index
);
678 dest
= make_new_block (fn
, dest_index
);
680 e
= make_edge (bb
, dest
, edge_flags
);
681 e
->probability
= probability
;
685 index
= streamer_read_hwi (ib
);
688 p_bb
= ENTRY_BLOCK_PTR_FOR_FN (fn
);
689 index
= streamer_read_hwi (ib
);
692 basic_block bb
= BASIC_BLOCK_FOR_FN (fn
, index
);
696 index
= streamer_read_hwi (ib
);
699 /* ??? The cfgloop interface is tied to cfun. */
700 gcc_assert (cfun
== fn
);
702 /* Input the loop tree. */
703 unsigned n_loops
= streamer_read_uhwi (ib
);
707 struct loops
*loops
= ggc_cleared_alloc
<struct loops
> ();
708 init_loops_structure (fn
, loops
, n_loops
);
709 set_loops_for_fn (fn
, loops
);
711 /* Input each loop and associate it with its loop header so
712 flow_loops_find can rebuild the loop tree. */
713 for (unsigned i
= 1; i
< n_loops
; ++i
)
715 int header_index
= streamer_read_hwi (ib
);
716 if (header_index
== -1)
718 loops
->larray
->quick_push (NULL
);
722 struct loop
*loop
= alloc_loop ();
723 loop
->header
= BASIC_BLOCK_FOR_FN (fn
, header_index
);
724 loop
->header
->loop_father
= loop
;
726 /* Read everything copy_loop_info copies. */
727 loop
->estimate_state
= streamer_read_enum (ib
, loop_estimation
, EST_LAST
);
728 loop
->any_upper_bound
= streamer_read_hwi (ib
);
729 if (loop
->any_upper_bound
)
730 loop
->nb_iterations_upper_bound
= streamer_read_wi (ib
);
731 loop
->any_estimate
= streamer_read_hwi (ib
);
732 if (loop
->any_estimate
)
733 loop
->nb_iterations_estimate
= streamer_read_wi (ib
);
735 /* Read OMP SIMD related info. */
736 loop
->safelen
= streamer_read_hwi (ib
);
737 loop
->dont_vectorize
= streamer_read_hwi (ib
);
738 loop
->force_vectorize
= streamer_read_hwi (ib
);
739 loop
->simduid
= stream_read_tree (ib
, data_in
);
741 place_new_loop (fn
, loop
);
743 /* flow_loops_find doesn't like loops not in the tree, hook them
744 all as siblings of the tree root temporarily. */
745 flow_loop_tree_node_add (loops
->tree_root
, loop
);
748 /* Rebuild the loop tree. */
749 flow_loops_find (loops
);
753 /* Read the SSA names array for function FN from DATA_IN using input
757 input_ssa_names (struct lto_input_block
*ib
, struct data_in
*data_in
,
760 unsigned int i
, size
;
762 size
= streamer_read_uhwi (ib
);
763 init_ssanames (fn
, size
);
765 i
= streamer_read_uhwi (ib
);
771 /* Skip over the elements that had been freed. */
772 while (SSANAMES (fn
)->length () < i
)
773 SSANAMES (fn
)->quick_push (NULL_TREE
);
775 is_default_def
= (streamer_read_uchar (ib
) != 0);
776 name
= stream_read_tree (ib
, data_in
);
777 ssa_name
= make_ssa_name_fn (fn
, name
, gimple_build_nop ());
780 set_ssa_default_def (cfun
, SSA_NAME_VAR (ssa_name
), ssa_name
);
782 i
= streamer_read_uhwi (ib
);
787 /* Go through all NODE edges and fixup call_stmt pointers
788 so they point to STMTS. */
791 fixup_call_stmt_edges_1 (struct cgraph_node
*node
, gimple
*stmts
,
794 struct cgraph_edge
*cedge
;
795 struct ipa_ref
*ref
= NULL
;
798 for (cedge
= node
->callees
; cedge
; cedge
= cedge
->next_callee
)
800 if (gimple_stmt_max_uid (fn
) < cedge
->lto_stmt_uid
)
801 fatal_error ("Cgraph edge statement index out of range");
802 cedge
->call_stmt
= as_a
<gcall
*> (stmts
[cedge
->lto_stmt_uid
- 1]);
803 if (!cedge
->call_stmt
)
804 fatal_error ("Cgraph edge statement index not found");
806 for (cedge
= node
->indirect_calls
; cedge
; cedge
= cedge
->next_callee
)
808 if (gimple_stmt_max_uid (fn
) < cedge
->lto_stmt_uid
)
809 fatal_error ("Cgraph edge statement index out of range");
810 cedge
->call_stmt
= as_a
<gcall
*> (stmts
[cedge
->lto_stmt_uid
- 1]);
811 if (!cedge
->call_stmt
)
812 fatal_error ("Cgraph edge statement index not found");
814 for (i
= 0; node
->iterate_reference (i
, ref
); i
++)
815 if (ref
->lto_stmt_uid
)
817 if (gimple_stmt_max_uid (fn
) < ref
->lto_stmt_uid
)
818 fatal_error ("Reference statement index out of range");
819 ref
->stmt
= stmts
[ref
->lto_stmt_uid
- 1];
821 fatal_error ("Reference statement index not found");
826 /* Fixup call_stmt pointers in NODE and all clones. */
829 fixup_call_stmt_edges (struct cgraph_node
*orig
, gimple
*stmts
)
831 struct cgraph_node
*node
;
834 while (orig
->clone_of
)
835 orig
= orig
->clone_of
;
836 fn
= DECL_STRUCT_FUNCTION (orig
->decl
);
838 fixup_call_stmt_edges_1 (orig
, stmts
, fn
);
840 for (node
= orig
->clones
; node
!= orig
;)
842 fixup_call_stmt_edges_1 (node
, stmts
, fn
);
845 else if (node
->next_sibling_clone
)
846 node
= node
->next_sibling_clone
;
849 while (node
!= orig
&& !node
->next_sibling_clone
)
850 node
= node
->clone_of
;
852 node
= node
->next_sibling_clone
;
858 /* Input the base body of struct function FN from DATA_IN
859 using input block IB. */
862 input_struct_function_base (struct function
*fn
, struct data_in
*data_in
,
863 struct lto_input_block
*ib
)
868 /* Read the static chain and non-local goto save area. */
869 fn
->static_chain_decl
= stream_read_tree (ib
, data_in
);
870 fn
->nonlocal_goto_save_area
= stream_read_tree (ib
, data_in
);
872 /* Read all the local symbols. */
873 len
= streamer_read_hwi (ib
);
877 vec_safe_grow_cleared (fn
->local_decls
, len
);
878 for (i
= 0; i
< len
; i
++)
880 tree t
= stream_read_tree (ib
, data_in
);
881 (*fn
->local_decls
)[i
] = t
;
885 /* Input the current IL state of the function. */
886 fn
->curr_properties
= streamer_read_uhwi (ib
);
888 /* Read all the attributes for FN. */
889 bp
= streamer_read_bitpack (ib
);
890 fn
->is_thunk
= bp_unpack_value (&bp
, 1);
891 fn
->has_local_explicit_reg_vars
= bp_unpack_value (&bp
, 1);
892 fn
->returns_pcc_struct
= bp_unpack_value (&bp
, 1);
893 fn
->returns_struct
= bp_unpack_value (&bp
, 1);
894 fn
->can_throw_non_call_exceptions
= bp_unpack_value (&bp
, 1);
895 fn
->can_delete_dead_exceptions
= bp_unpack_value (&bp
, 1);
896 fn
->always_inline_functions_inlined
= bp_unpack_value (&bp
, 1);
897 fn
->after_inlining
= bp_unpack_value (&bp
, 1);
898 fn
->stdarg
= bp_unpack_value (&bp
, 1);
899 fn
->has_nonlocal_label
= bp_unpack_value (&bp
, 1);
900 fn
->calls_alloca
= bp_unpack_value (&bp
, 1);
901 fn
->calls_setjmp
= bp_unpack_value (&bp
, 1);
902 fn
->has_force_vectorize_loops
= bp_unpack_value (&bp
, 1);
903 fn
->has_simduid_loops
= bp_unpack_value (&bp
, 1);
904 fn
->va_list_fpr_size
= bp_unpack_value (&bp
, 8);
905 fn
->va_list_gpr_size
= bp_unpack_value (&bp
, 8);
907 /* Input the function start and end loci. */
908 fn
->function_start_locus
= stream_input_location (&bp
, data_in
);
909 fn
->function_end_locus
= stream_input_location (&bp
, data_in
);
913 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
916 input_function (tree fn_decl
, struct data_in
*data_in
,
917 struct lto_input_block
*ib
, struct lto_input_block
*ib_cfg
)
923 struct cgraph_node
*node
;
925 tag
= streamer_read_record_start (ib
);
926 lto_tag_check (tag
, LTO_function
);
928 /* Read decls for parameters and args. */
929 DECL_RESULT (fn_decl
) = stream_read_tree (ib
, data_in
);
930 DECL_ARGUMENTS (fn_decl
) = streamer_read_chain (ib
, data_in
);
932 /* Read the tree of lexical scopes for the function. */
933 DECL_INITIAL (fn_decl
) = stream_read_tree (ib
, data_in
);
935 if (!streamer_read_uhwi (ib
))
938 push_struct_function (fn_decl
);
939 fn
= DECL_STRUCT_FUNCTION (fn_decl
);
941 /* We input IL in SSA form. */
942 cfun
->gimple_df
->in_ssa_p
= true;
944 gimple_register_cfg_hooks ();
946 node
= cgraph_node::get (fn_decl
);
948 node
= cgraph_node::create (fn_decl
);
949 input_struct_function_base (fn
, data_in
, ib
);
950 input_cfg (ib_cfg
, data_in
, fn
, node
->count_materialization_scale
);
952 /* Read all the SSA names. */
953 input_ssa_names (ib
, data_in
, fn
);
955 /* Read the exception handling regions in the function. */
956 input_eh_regions (ib
, data_in
, fn
);
958 gcc_assert (DECL_INITIAL (fn_decl
));
959 DECL_SAVED_TREE (fn_decl
) = NULL_TREE
;
961 /* Read all the basic blocks. */
962 tag
= streamer_read_record_start (ib
);
965 input_bb (ib
, tag
, data_in
, fn
,
966 node
->count_materialization_scale
);
967 tag
= streamer_read_record_start (ib
);
970 /* Fix up the call statements that are mentioned in the callgraph
972 set_gimple_stmt_max_uid (cfun
, 0);
973 FOR_ALL_BB_FN (bb
, cfun
)
975 gimple_stmt_iterator gsi
;
976 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
978 gimple stmt
= gsi_stmt (gsi
);
979 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
981 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
983 gimple stmt
= gsi_stmt (gsi
);
984 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
987 stmts
= (gimple
*) xcalloc (gimple_stmt_max_uid (fn
), sizeof (gimple
));
988 FOR_ALL_BB_FN (bb
, cfun
)
990 gimple_stmt_iterator bsi
= gsi_start_phis (bb
);
991 while (!gsi_end_p (bsi
))
993 gimple stmt
= gsi_stmt (bsi
);
995 stmts
[gimple_uid (stmt
)] = stmt
;
997 bsi
= gsi_start_bb (bb
);
998 while (!gsi_end_p (bsi
))
1000 gimple stmt
= gsi_stmt (bsi
);
1001 /* If we're recompiling LTO objects with debug stmts but
1002 we're not supposed to have debug stmts, remove them now.
1003 We can't remove them earlier because this would cause uid
1004 mismatches in fixups, but we can do it at this point, as
1005 long as debug stmts don't require fixups. */
1006 if (!MAY_HAVE_DEBUG_STMTS
&& !flag_wpa
&& is_gimple_debug (stmt
))
1008 gimple_stmt_iterator gsi
= bsi
;
1010 gsi_remove (&gsi
, true);
1015 stmts
[gimple_uid (stmt
)] = stmt
;
1020 /* Set the gimple body to the statement sequence in the entry
1021 basic block. FIXME lto, this is fairly hacky. The existence
1022 of a gimple body is used by the cgraph routines, but we should
1023 really use the presence of the CFG. */
1025 edge_iterator ei
= ei_start (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
);
1026 gimple_set_body (fn_decl
, bb_seq (ei_edge (ei
)->dest
));
1029 fixup_call_stmt_edges (node
, stmts
);
1030 execute_all_ipa_stmt_fixups (node
, stmts
);
1032 update_ssa (TODO_update_ssa_only_virtuals
);
1033 free_dominance_info (CDI_DOMINATORS
);
1034 free_dominance_info (CDI_POST_DOMINATORS
);
1039 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1042 input_constructor (tree var
, struct data_in
*data_in
,
1043 struct lto_input_block
*ib
)
1045 DECL_INITIAL (var
) = stream_read_tree (ib
, data_in
);
1049 /* Read the body from DATA for function NODE and fill it in.
1050 FILE_DATA are the global decls and types. SECTION_TYPE is either
1051 LTO_section_function_body or LTO_section_static_initializer. If
1052 section type is LTO_section_function_body, FN must be the decl for
1056 lto_read_body_or_constructor (struct lto_file_decl_data
*file_data
, struct symtab_node
*node
,
1057 const char *data
, enum lto_section_type section_type
)
1059 const struct lto_function_header
*header
;
1060 struct data_in
*data_in
;
1064 tree fn_decl
= node
->decl
;
1066 header
= (const struct lto_function_header
*) data
;
1067 if (TREE_CODE (node
->decl
) == FUNCTION_DECL
)
1069 cfg_offset
= sizeof (struct lto_function_header
);
1070 main_offset
= cfg_offset
+ header
->cfg_size
;
1071 string_offset
= main_offset
+ header
->main_size
;
1075 main_offset
= sizeof (struct lto_function_header
);
1076 string_offset
= main_offset
+ header
->main_size
;
1079 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
1080 header
->string_size
, vNULL
);
1082 if (section_type
== LTO_section_function_body
)
1084 struct lto_in_decl_state
*decl_state
;
1087 gcc_checking_assert (node
);
1089 /* Use the function's decl state. */
1090 decl_state
= lto_get_function_in_decl_state (file_data
, fn_decl
);
1091 gcc_assert (decl_state
);
1092 file_data
->current_decl_state
= decl_state
;
1095 /* Set up the struct function. */
1096 from
= data_in
->reader_cache
->nodes
.length ();
1097 lto_input_block
ib_main (data
+ main_offset
, header
->main_size
);
1098 if (TREE_CODE (node
->decl
) == FUNCTION_DECL
)
1100 lto_input_block
ib_cfg (data
+ cfg_offset
, header
->cfg_size
);
1101 input_function (fn_decl
, data_in
, &ib_main
, &ib_cfg
);
1104 input_constructor (fn_decl
, data_in
, &ib_main
);
1105 /* And fixup types we streamed locally. */
1107 struct streamer_tree_cache_d
*cache
= data_in
->reader_cache
;
1108 unsigned len
= cache
->nodes
.length ();
1110 for (i
= len
; i
-- > from
;)
1112 tree t
= streamer_tree_cache_get_tree (cache
, i
);
1118 gcc_assert (TYPE_CANONICAL (t
) == NULL_TREE
);
1119 TYPE_CANONICAL (t
) = TYPE_MAIN_VARIANT (t
);
1120 if (TYPE_MAIN_VARIANT (t
) != t
)
1122 gcc_assert (TYPE_NEXT_VARIANT (t
) == NULL_TREE
);
1123 TYPE_NEXT_VARIANT (t
)
1124 = TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t
));
1125 TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t
)) = t
;
1131 /* Restore decl state */
1132 file_data
->current_decl_state
= file_data
->global_decl_state
;
1135 lto_data_in_delete (data_in
);
1139 /* Read the body of NODE using DATA. FILE_DATA holds the global
1143 lto_input_function_body (struct lto_file_decl_data
*file_data
,
1144 struct cgraph_node
*node
, const char *data
)
1146 lto_read_body_or_constructor (file_data
, node
, data
, LTO_section_function_body
);
1149 /* Read the body of NODE using DATA. FILE_DATA holds the global
1153 lto_input_variable_constructor (struct lto_file_decl_data
*file_data
,
1154 struct varpool_node
*node
, const char *data
)
1156 lto_read_body_or_constructor (file_data
, node
, data
, LTO_section_function_body
);
1160 /* Read the physical representation of a tree node EXPR from
1161 input block IB using the per-file context in DATA_IN. */
1164 lto_read_tree_1 (struct lto_input_block
*ib
, struct data_in
*data_in
, tree expr
)
1166 /* Read all the bitfield values in EXPR. Note that for LTO, we
1167 only write language-independent bitfields, so no more unpacking is
1169 streamer_read_tree_bitfields (ib
, data_in
, expr
);
1171 /* Read all the pointer fields in EXPR. */
1172 streamer_read_tree_body (ib
, data_in
, expr
);
1174 /* Read any LTO-specific data not read by the tree streamer. */
1176 && TREE_CODE (expr
) != FUNCTION_DECL
1177 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
1178 DECL_INITIAL (expr
) = stream_read_tree (ib
, data_in
);
1180 /* We should never try to instantiate an MD or NORMAL builtin here. */
1181 if (TREE_CODE (expr
) == FUNCTION_DECL
)
1182 gcc_assert (!streamer_handle_as_builtin_p (expr
));
1184 #ifdef LTO_STREAMER_DEBUG
1185 /* Remove the mapping to RESULT's original address set by
1186 streamer_alloc_tree. */
1187 lto_orig_address_remove (expr
);
1191 /* Read the physical representation of a tree node with tag TAG from
1192 input block IB using the per-file context in DATA_IN. */
1195 lto_read_tree (struct lto_input_block
*ib
, struct data_in
*data_in
,
1196 enum LTO_tags tag
, hashval_t hash
)
1198 /* Instantiate a new tree node. */
1199 tree result
= streamer_alloc_tree (ib
, data_in
, tag
);
1201 /* Enter RESULT in the reader cache. This will make RESULT
1202 available so that circular references in the rest of the tree
1203 structure can be resolved in subsequent calls to stream_read_tree. */
1204 streamer_tree_cache_append (data_in
->reader_cache
, result
, hash
);
1206 lto_read_tree_1 (ib
, data_in
, result
);
1208 /* end_marker = */ streamer_read_uchar (ib
);
1214 /* Populate the reader cache with trees materialized from the SCC
1215 following in the IB, DATA_IN stream. */
1218 lto_input_scc (struct lto_input_block
*ib
, struct data_in
*data_in
,
1219 unsigned *len
, unsigned *entry_len
)
1221 /* A blob of unnamed tree nodes, fill the cache from it and
1223 unsigned size
= streamer_read_uhwi (ib
);
1224 hashval_t scc_hash
= streamer_read_uhwi (ib
);
1225 unsigned scc_entry_len
= 1;
1229 enum LTO_tags tag
= streamer_read_record_start (ib
);
1230 lto_input_tree_1 (ib
, data_in
, tag
, scc_hash
);
1234 unsigned int first
= data_in
->reader_cache
->nodes
.length ();
1237 scc_entry_len
= streamer_read_uhwi (ib
);
1239 /* Materialize size trees by reading their headers. */
1240 for (unsigned i
= 0; i
< size
; ++i
)
1242 enum LTO_tags tag
= streamer_read_record_start (ib
);
1244 || (tag
>= LTO_field_decl_ref
&& tag
<= LTO_global_decl_ref
)
1245 || tag
== LTO_tree_pickle_reference
1246 || tag
== LTO_builtin_decl
1247 || tag
== LTO_integer_cst
1248 || tag
== LTO_tree_scc
)
1251 result
= streamer_alloc_tree (ib
, data_in
, tag
);
1252 streamer_tree_cache_append (data_in
->reader_cache
, result
, 0);
1255 /* Read the tree bitpacks and references. */
1256 for (unsigned i
= 0; i
< size
; ++i
)
1258 result
= streamer_tree_cache_get_tree (data_in
->reader_cache
,
1260 lto_read_tree_1 (ib
, data_in
, result
);
1261 /* end_marker = */ streamer_read_uchar (ib
);
1266 *entry_len
= scc_entry_len
;
1271 /* Read a tree from input block IB using the per-file context in
1272 DATA_IN. This context is used, for example, to resolve references
1273 to previously read nodes. */
1276 lto_input_tree_1 (struct lto_input_block
*ib
, struct data_in
*data_in
,
1277 enum LTO_tags tag
, hashval_t hash
)
1281 gcc_assert ((unsigned) tag
< (unsigned) LTO_NUM_TAGS
);
1283 if (tag
== LTO_null
)
1285 else if (tag
>= LTO_field_decl_ref
&& tag
<= LTO_namelist_decl_ref
)
1287 /* If TAG is a reference to an indexable tree, the next value
1288 in IB is the index into the table where we expect to find
1290 result
= lto_input_tree_ref (ib
, data_in
, cfun
, tag
);
1292 else if (tag
== LTO_tree_pickle_reference
)
1294 /* If TAG is a reference to a previously read tree, look it up in
1295 the reader cache. */
1296 result
= streamer_get_pickled_tree (ib
, data_in
);
1298 else if (tag
== LTO_builtin_decl
)
1300 /* If we are going to read a built-in function, all we need is
1301 the code and class. */
1302 result
= streamer_get_builtin_tree (ib
, data_in
);
1304 else if (tag
== LTO_integer_cst
)
1306 /* For shared integer constants in singletons we can use the
1307 existing tree integer constant merging code. */
1308 tree type
= stream_read_tree (ib
, data_in
);
1309 unsigned HOST_WIDE_INT len
= streamer_read_uhwi (ib
);
1310 unsigned HOST_WIDE_INT i
;
1311 HOST_WIDE_INT a
[WIDE_INT_MAX_ELTS
];
1313 for (i
= 0; i
< len
; i
++)
1314 a
[i
] = streamer_read_hwi (ib
);
1315 gcc_assert (TYPE_PRECISION (type
) <= MAX_BITSIZE_MODE_ANY_INT
);
1316 result
= wide_int_to_tree (type
, wide_int::from_array
1317 (a
, len
, TYPE_PRECISION (type
)));
1318 streamer_tree_cache_append (data_in
->reader_cache
, result
, hash
);
1320 else if (tag
== LTO_tree_scc
)
1324 /* Otherwise, materialize a new node from IB. */
1325 result
= lto_read_tree (ib
, data_in
, tag
, hash
);
1332 lto_input_tree (struct lto_input_block
*ib
, struct data_in
*data_in
)
1336 /* Input and skip SCCs. */
1337 while ((tag
= streamer_read_record_start (ib
)) == LTO_tree_scc
)
1339 unsigned len
, entry_len
;
1340 lto_input_scc (ib
, data_in
, &len
, &entry_len
);
1342 return lto_input_tree_1 (ib
, data_in
, tag
, 0);
1346 /* Input toplevel asms. */
1349 lto_input_toplevel_asms (struct lto_file_decl_data
*file_data
, int order_base
)
1352 const char *data
= lto_get_section_data (file_data
, LTO_section_asm
,
1354 const struct lto_simple_header_with_strings
*header
1355 = (const struct lto_simple_header_with_strings
*) data
;
1357 struct data_in
*data_in
;
1363 string_offset
= sizeof (*header
) + header
->main_size
;
1365 lto_input_block
ib (data
+ sizeof (*header
), header
->main_size
);
1367 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
1368 header
->string_size
, vNULL
);
1370 while ((str
= streamer_read_string_cst (data_in
, &ib
)))
1372 asm_node
*node
= symtab
->finalize_toplevel_asm (str
);
1373 node
->order
= streamer_read_hwi (&ib
) + order_base
;
1374 if (node
->order
>= symtab
->order
)
1375 symtab
->order
= node
->order
+ 1;
1378 lto_data_in_delete (data_in
);
1380 lto_free_section_data (file_data
, LTO_section_asm
, NULL
, data
, len
);
1384 /* Initialization for the LTO reader. */
1387 lto_reader_init (void)
1389 lto_streamer_init ();
1390 file_name_hash_table
1391 = new hash_table
<freeing_string_slot_hasher
> (37);
1395 /* Create a new data_in object for FILE_DATA. STRINGS is the string
1396 table to use with LEN strings. RESOLUTIONS is the vector of linker
1397 resolutions (NULL if not using a linker plugin). */
1400 lto_data_in_create (struct lto_file_decl_data
*file_data
, const char *strings
,
1402 vec
<ld_plugin_symbol_resolution_t
> resolutions
)
1404 struct data_in
*data_in
= XCNEW (struct data_in
);
1405 data_in
->file_data
= file_data
;
1406 data_in
->strings
= strings
;
1407 data_in
->strings_len
= len
;
1408 data_in
->globals_resolution
= resolutions
;
1409 data_in
->reader_cache
= streamer_tree_cache_create (false, false, true);
1414 /* Remove DATA_IN. */
1417 lto_data_in_delete (struct data_in
*data_in
)
1419 data_in
->globals_resolution
.release ();
1420 streamer_tree_cache_delete (data_in
->reader_cache
);