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"
35 #include "basic-block.h"
36 #include "tree-ssa-alias.h"
37 #include "internal-fn.h"
38 #include "gimple-expr.h"
41 #include "gimple-iterator.h"
42 #include "gimple-ssa.h"
44 #include "tree-ssanames.h"
45 #include "tree-into-ssa.h"
48 #include "tree-pass.h"
50 #include "diagnostic.h"
53 #include "ipa-utils.h"
54 #include "data-streamer.h"
55 #include "gimple-streamer.h"
56 #include "lto-streamer.h"
57 #include "tree-streamer.h"
58 #include "tree-pass.h"
59 #include "streamer-hooks.h"
63 struct freeing_string_slot_hasher
: string_slot_hasher
65 static inline void remove (value_type
*);
69 freeing_string_slot_hasher::remove (value_type
*v
)
74 /* The table to hold the file names. */
75 static hash_table
<freeing_string_slot_hasher
> *file_name_hash_table
;
78 /* Check that tag ACTUAL has one of the given values. NUM_TAGS is the
79 number of valid tag values to check. */
82 lto_tag_check_set (enum LTO_tags actual
, int ntags
, ...)
88 for (i
= 0; i
< ntags
; i
++)
89 if ((unsigned) actual
== va_arg (ap
, unsigned))
96 internal_error ("bytecode stream: unexpected tag %s", lto_tag_name (actual
));
100 /* Read LENGTH bytes from STREAM to ADDR. */
103 lto_input_data_block (struct lto_input_block
*ib
, void *addr
, size_t length
)
106 unsigned char *const buffer
= (unsigned char *const) addr
;
108 for (i
= 0; i
< length
; i
++)
109 buffer
[i
] = streamer_read_uchar (ib
);
113 /* Lookup STRING in file_name_hash_table. If found, return the existing
114 string, otherwise insert STRING as the canonical version. */
117 canon_file_name (const char *string
)
120 struct string_slot s_slot
;
121 size_t len
= strlen (string
);
126 slot
= file_name_hash_table
->find_slot (&s_slot
, INSERT
);
130 struct string_slot
*new_slot
;
132 saved_string
= (char *) xmalloc (len
+ 1);
133 new_slot
= XCNEW (struct string_slot
);
134 memcpy (saved_string
, string
, len
+ 1);
135 new_slot
->s
= saved_string
;
142 struct string_slot
*old_slot
= *slot
;
148 /* Read a location bitpack from input block IB. */
151 lto_input_location (struct bitpack_d
*bp
, struct data_in
*data_in
)
153 static const char *current_file
;
154 static int current_line
;
155 static int current_col
;
156 bool file_change
, line_change
, column_change
;
158 bool prev_file
= current_file
!= NULL
;
160 if (bp_unpack_value (bp
, 1))
161 return UNKNOWN_LOCATION
;
163 file_change
= bp_unpack_value (bp
, 1);
164 line_change
= bp_unpack_value (bp
, 1);
165 column_change
= bp_unpack_value (bp
, 1);
168 current_file
= canon_file_name
169 (string_for_index (data_in
,
170 bp_unpack_var_len_unsigned (bp
),
174 current_line
= bp_unpack_var_len_unsigned (bp
);
177 current_col
= bp_unpack_var_len_unsigned (bp
);
182 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
184 linemap_add (line_table
, LC_ENTER
, false, current_file
, current_line
);
186 else if (line_change
)
187 linemap_line_start (line_table
, current_line
, current_col
);
189 return linemap_position_for_column (line_table
, current_col
);
193 /* Read a reference to a tree node from DATA_IN using input block IB.
194 TAG is the expected node that should be found in IB, if TAG belongs
195 to one of the indexable trees, expect to read a reference index to
196 be looked up in one of the symbol tables, otherwise read the pysical
197 representation of the tree using stream_read_tree. FN is the
198 function scope for the read tree. */
201 lto_input_tree_ref (struct lto_input_block
*ib
, struct data_in
*data_in
,
202 struct function
*fn
, enum LTO_tags tag
)
204 unsigned HOST_WIDE_INT ix_u
;
205 tree result
= NULL_TREE
;
207 lto_tag_check_range (tag
, LTO_field_decl_ref
, LTO_namelist_decl_ref
);
212 ix_u
= streamer_read_uhwi (ib
);
213 result
= lto_file_decl_data_get_type (data_in
->file_data
, ix_u
);
216 case LTO_ssa_name_ref
:
217 ix_u
= streamer_read_uhwi (ib
);
218 result
= (*SSANAMES (fn
))[ix_u
];
221 case LTO_field_decl_ref
:
222 ix_u
= streamer_read_uhwi (ib
);
223 result
= lto_file_decl_data_get_field_decl (data_in
->file_data
, ix_u
);
226 case LTO_function_decl_ref
:
227 ix_u
= streamer_read_uhwi (ib
);
228 result
= lto_file_decl_data_get_fn_decl (data_in
->file_data
, ix_u
);
231 case LTO_type_decl_ref
:
232 ix_u
= streamer_read_uhwi (ib
);
233 result
= lto_file_decl_data_get_type_decl (data_in
->file_data
, ix_u
);
236 case LTO_namespace_decl_ref
:
237 ix_u
= streamer_read_uhwi (ib
);
238 result
= lto_file_decl_data_get_namespace_decl (data_in
->file_data
, ix_u
);
241 case LTO_global_decl_ref
:
242 case LTO_result_decl_ref
:
243 case LTO_const_decl_ref
:
244 case LTO_imported_decl_ref
:
245 case LTO_label_decl_ref
:
246 case LTO_translation_unit_decl_ref
:
247 case LTO_namelist_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_cleared_alloc
<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_cleared_alloc
<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
:
365 r
->type
= ERT_MUST_NOT_THROW
;
366 r
->u
.must_not_throw
.failure_decl
= stream_read_tree (ib
, data_in
);
367 bitpack_d bp
= streamer_read_bitpack (ib
);
368 r
->u
.must_not_throw
.failure_loc
369 = stream_input_location (&bp
, data_in
);
377 r
->landing_pads
= (eh_landing_pad
) (intptr_t) streamer_read_hwi (ib
);
383 /* Read and return EH landing pad IX from input block IB, using descriptors
386 static eh_landing_pad
387 input_eh_lp (struct lto_input_block
*ib
, struct data_in
*data_in
, int ix
)
392 /* Read the landing pad header. */
393 tag
= streamer_read_record_start (ib
);
397 lto_tag_check_range (tag
, LTO_eh_landing_pad
, LTO_eh_landing_pad
);
399 lp
= ggc_cleared_alloc
<eh_landing_pad_d
> ();
400 lp
->index
= streamer_read_hwi (ib
);
401 gcc_assert (lp
->index
== ix
);
402 lp
->next_lp
= (eh_landing_pad
) (intptr_t) streamer_read_hwi (ib
);
403 lp
->region
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
404 lp
->post_landing_pad
= stream_read_tree (ib
, data_in
);
410 /* After reading the EH regions, pointers to peer and children regions
411 are region numbers. This converts all these region numbers into
412 real pointers into the rematerialized regions for FN. ROOT_REGION
413 is the region number for the root EH region in FN. */
416 fixup_eh_region_pointers (struct function
*fn
, HOST_WIDE_INT root_region
)
419 vec
<eh_region
, va_gc
> *eh_array
= fn
->eh
->region_array
;
420 vec
<eh_landing_pad
, va_gc
> *lp_array
= fn
->eh
->lp_array
;
424 gcc_assert (eh_array
&& lp_array
);
426 gcc_assert (root_region
>= 0);
427 fn
->eh
->region_tree
= (*eh_array
)[root_region
];
429 #define FIXUP_EH_REGION(r) (r) = (*eh_array)[(HOST_WIDE_INT) (intptr_t) (r)]
430 #define FIXUP_EH_LP(p) (p) = (*lp_array)[(HOST_WIDE_INT) (intptr_t) (p)]
432 /* Convert all the index numbers stored in pointer fields into
433 pointers to the corresponding slots in the EH region array. */
434 FOR_EACH_VEC_ELT (*eh_array
, i
, r
)
436 /* The array may contain NULL regions. */
440 gcc_assert (i
== (unsigned) r
->index
);
441 FIXUP_EH_REGION (r
->outer
);
442 FIXUP_EH_REGION (r
->inner
);
443 FIXUP_EH_REGION (r
->next_peer
);
444 FIXUP_EH_LP (r
->landing_pads
);
447 /* Convert all the index numbers stored in pointer fields into
448 pointers to the corresponding slots in the EH landing pad array. */
449 FOR_EACH_VEC_ELT (*lp_array
, i
, lp
)
451 /* The array may contain NULL landing pads. */
455 gcc_assert (i
== (unsigned) lp
->index
);
456 FIXUP_EH_LP (lp
->next_lp
);
457 FIXUP_EH_REGION (lp
->region
);
460 #undef FIXUP_EH_REGION
465 /* Initialize EH support. */
470 static bool eh_initialized_p
= false;
472 if (eh_initialized_p
)
475 /* Contrary to most other FEs, we only initialize EH support when at
476 least one of the files in the set contains exception regions in
477 it. Since this happens much later than the call to init_eh in
478 lang_dependent_init, we have to set flag_exceptions and call
479 init_eh again to initialize the EH tables. */
483 eh_initialized_p
= true;
487 /* Read the exception table for FN from IB using the data descriptors
491 input_eh_regions (struct lto_input_block
*ib
, struct data_in
*data_in
,
494 HOST_WIDE_INT i
, root_region
, len
;
497 tag
= streamer_read_record_start (ib
);
501 lto_tag_check_range (tag
, LTO_eh_table
, LTO_eh_table
);
503 /* If the file contains EH regions, then it was compiled with
504 -fexceptions. In that case, initialize the backend EH
510 root_region
= streamer_read_hwi (ib
);
511 gcc_assert (root_region
== (int) root_region
);
513 /* Read the EH region array. */
514 len
= streamer_read_hwi (ib
);
515 gcc_assert (len
== (int) len
);
518 vec_safe_grow_cleared (fn
->eh
->region_array
, len
);
519 for (i
= 0; i
< len
; i
++)
521 eh_region r
= input_eh_region (ib
, data_in
, i
);
522 (*fn
->eh
->region_array
)[i
] = r
;
526 /* Read the landing pads. */
527 len
= streamer_read_hwi (ib
);
528 gcc_assert (len
== (int) len
);
531 vec_safe_grow_cleared (fn
->eh
->lp_array
, len
);
532 for (i
= 0; i
< len
; i
++)
534 eh_landing_pad lp
= input_eh_lp (ib
, data_in
, i
);
535 (*fn
->eh
->lp_array
)[i
] = lp
;
539 /* Read the runtime type data. */
540 len
= streamer_read_hwi (ib
);
541 gcc_assert (len
== (int) len
);
544 vec_safe_grow_cleared (fn
->eh
->ttype_data
, len
);
545 for (i
= 0; i
< len
; i
++)
547 tree ttype
= stream_read_tree (ib
, data_in
);
548 (*fn
->eh
->ttype_data
)[i
] = ttype
;
552 /* Read the table of action chains. */
553 len
= streamer_read_hwi (ib
);
554 gcc_assert (len
== (int) len
);
557 if (targetm
.arm_eabi_unwinder
)
559 vec_safe_grow_cleared (fn
->eh
->ehspec_data
.arm_eabi
, len
);
560 for (i
= 0; i
< len
; i
++)
562 tree t
= stream_read_tree (ib
, data_in
);
563 (*fn
->eh
->ehspec_data
.arm_eabi
)[i
] = t
;
568 vec_safe_grow_cleared (fn
->eh
->ehspec_data
.other
, len
);
569 for (i
= 0; i
< len
; i
++)
571 uchar c
= streamer_read_uchar (ib
);
572 (*fn
->eh
->ehspec_data
.other
)[i
] = c
;
577 /* Reconstruct the EH region tree by fixing up the peer/children
579 fixup_eh_region_pointers (fn
, root_region
);
581 tag
= streamer_read_record_start (ib
);
582 lto_tag_check_range (tag
, LTO_null
, LTO_null
);
586 /* Make a new basic block with index INDEX in function FN. */
589 make_new_block (struct function
*fn
, unsigned int index
)
591 basic_block bb
= alloc_block ();
593 SET_BASIC_BLOCK_FOR_FN (fn
, index
, bb
);
594 n_basic_blocks_for_fn (fn
)++;
599 /* Read a wide-int. */
602 streamer_read_wi (struct lto_input_block
*ib
)
604 HOST_WIDE_INT a
[WIDE_INT_MAX_ELTS
];
606 int prec ATTRIBUTE_UNUSED
= streamer_read_uhwi (ib
);
607 int len
= streamer_read_uhwi (ib
);
608 for (i
= 0; i
< len
; i
++)
609 a
[i
] = streamer_read_hwi (ib
);
610 return widest_int::from_array (a
, len
);
614 /* Read the CFG for function FN from input block IB. */
617 input_cfg (struct lto_input_block
*ib
, struct data_in
*data_in
,
619 int count_materialization_scale
)
621 unsigned int bb_count
;
626 init_empty_tree_cfg_for_function (fn
);
627 init_ssa_operands (fn
);
629 profile_status_for_fn (fn
) = streamer_read_enum (ib
, profile_status_d
,
632 bb_count
= streamer_read_uhwi (ib
);
634 last_basic_block_for_fn (fn
) = bb_count
;
635 if (bb_count
> basic_block_info_for_fn (fn
)->length ())
636 vec_safe_grow_cleared (basic_block_info_for_fn (fn
), bb_count
);
638 if (bb_count
> label_to_block_map_for_fn (fn
)->length ())
639 vec_safe_grow_cleared (label_to_block_map_for_fn (fn
), bb_count
);
641 index
= streamer_read_hwi (ib
);
644 basic_block bb
= BASIC_BLOCK_FOR_FN (fn
, index
);
645 unsigned int edge_count
;
648 bb
= make_new_block (fn
, index
);
650 edge_count
= streamer_read_uhwi (ib
);
652 /* Connect up the CFG. */
653 for (i
= 0; i
< edge_count
; i
++)
655 unsigned int dest_index
;
656 unsigned int edge_flags
;
662 dest_index
= streamer_read_uhwi (ib
);
663 probability
= (int) streamer_read_hwi (ib
);
664 count
= apply_scale ((gcov_type
) streamer_read_gcov_count (ib
),
665 count_materialization_scale
);
666 edge_flags
= streamer_read_uhwi (ib
);
668 dest
= BASIC_BLOCK_FOR_FN (fn
, dest_index
);
671 dest
= make_new_block (fn
, dest_index
);
673 e
= make_edge (bb
, dest
, edge_flags
);
674 e
->probability
= probability
;
678 index
= streamer_read_hwi (ib
);
681 p_bb
= ENTRY_BLOCK_PTR_FOR_FN (fn
);
682 index
= streamer_read_hwi (ib
);
685 basic_block bb
= BASIC_BLOCK_FOR_FN (fn
, index
);
689 index
= streamer_read_hwi (ib
);
692 /* ??? The cfgloop interface is tied to cfun. */
693 gcc_assert (cfun
== fn
);
695 /* Input the loop tree. */
696 unsigned n_loops
= streamer_read_uhwi (ib
);
700 struct loops
*loops
= ggc_cleared_alloc
<struct loops
> ();
701 init_loops_structure (fn
, loops
, n_loops
);
702 set_loops_for_fn (fn
, loops
);
704 /* Input each loop and associate it with its loop header so
705 flow_loops_find can rebuild the loop tree. */
706 for (unsigned i
= 1; i
< n_loops
; ++i
)
708 int header_index
= streamer_read_hwi (ib
);
709 if (header_index
== -1)
711 loops
->larray
->quick_push (NULL
);
715 struct loop
*loop
= alloc_loop ();
716 loop
->header
= BASIC_BLOCK_FOR_FN (fn
, header_index
);
717 loop
->header
->loop_father
= loop
;
719 /* Read everything copy_loop_info copies. */
720 loop
->estimate_state
= streamer_read_enum (ib
, loop_estimation
, EST_LAST
);
721 loop
->any_upper_bound
= streamer_read_hwi (ib
);
722 if (loop
->any_upper_bound
)
723 loop
->nb_iterations_upper_bound
= streamer_read_wi (ib
);
724 loop
->any_estimate
= streamer_read_hwi (ib
);
725 if (loop
->any_estimate
)
726 loop
->nb_iterations_estimate
= streamer_read_wi (ib
);
728 /* Read OMP SIMD related info. */
729 loop
->safelen
= streamer_read_hwi (ib
);
730 loop
->dont_vectorize
= streamer_read_hwi (ib
);
731 loop
->force_vectorize
= streamer_read_hwi (ib
);
732 loop
->simduid
= stream_read_tree (ib
, data_in
);
734 place_new_loop (fn
, loop
);
736 /* flow_loops_find doesn't like loops not in the tree, hook them
737 all as siblings of the tree root temporarily. */
738 flow_loop_tree_node_add (loops
->tree_root
, loop
);
741 /* Rebuild the loop tree. */
742 flow_loops_find (loops
);
746 /* Read the SSA names array for function FN from DATA_IN using input
750 input_ssa_names (struct lto_input_block
*ib
, struct data_in
*data_in
,
753 unsigned int i
, size
;
755 size
= streamer_read_uhwi (ib
);
756 init_ssanames (fn
, size
);
758 i
= streamer_read_uhwi (ib
);
764 /* Skip over the elements that had been freed. */
765 while (SSANAMES (fn
)->length () < i
)
766 SSANAMES (fn
)->quick_push (NULL_TREE
);
768 is_default_def
= (streamer_read_uchar (ib
) != 0);
769 name
= stream_read_tree (ib
, data_in
);
770 ssa_name
= make_ssa_name_fn (fn
, name
, gimple_build_nop ());
773 set_ssa_default_def (cfun
, SSA_NAME_VAR (ssa_name
), ssa_name
);
775 i
= streamer_read_uhwi (ib
);
780 /* Go through all NODE edges and fixup call_stmt pointers
781 so they point to STMTS. */
784 fixup_call_stmt_edges_1 (struct cgraph_node
*node
, gimple
*stmts
,
787 struct cgraph_edge
*cedge
;
788 struct ipa_ref
*ref
= NULL
;
791 for (cedge
= node
->callees
; cedge
; cedge
= cedge
->next_callee
)
793 if (gimple_stmt_max_uid (fn
) < cedge
->lto_stmt_uid
)
794 fatal_error ("Cgraph edge statement index out of range");
795 cedge
->call_stmt
= stmts
[cedge
->lto_stmt_uid
- 1];
796 if (!cedge
->call_stmt
)
797 fatal_error ("Cgraph edge statement index not found");
799 for (cedge
= node
->indirect_calls
; cedge
; cedge
= cedge
->next_callee
)
801 if (gimple_stmt_max_uid (fn
) < cedge
->lto_stmt_uid
)
802 fatal_error ("Cgraph edge statement index out of range");
803 cedge
->call_stmt
= stmts
[cedge
->lto_stmt_uid
- 1];
804 if (!cedge
->call_stmt
)
805 fatal_error ("Cgraph edge statement index not found");
807 for (i
= 0; node
->iterate_reference (i
, ref
); i
++)
808 if (ref
->lto_stmt_uid
)
810 if (gimple_stmt_max_uid (fn
) < ref
->lto_stmt_uid
)
811 fatal_error ("Reference statement index out of range");
812 ref
->stmt
= stmts
[ref
->lto_stmt_uid
- 1];
814 fatal_error ("Reference statement index not found");
819 /* Fixup call_stmt pointers in NODE and all clones. */
822 fixup_call_stmt_edges (struct cgraph_node
*orig
, gimple
*stmts
)
824 struct cgraph_node
*node
;
827 while (orig
->clone_of
)
828 orig
= orig
->clone_of
;
829 fn
= DECL_STRUCT_FUNCTION (orig
->decl
);
831 fixup_call_stmt_edges_1 (orig
, stmts
, fn
);
833 for (node
= orig
->clones
; node
!= orig
;)
835 fixup_call_stmt_edges_1 (node
, stmts
, fn
);
838 else if (node
->next_sibling_clone
)
839 node
= node
->next_sibling_clone
;
842 while (node
!= orig
&& !node
->next_sibling_clone
)
843 node
= node
->clone_of
;
845 node
= node
->next_sibling_clone
;
851 /* Input the base body of struct function FN from DATA_IN
852 using input block IB. */
855 input_struct_function_base (struct function
*fn
, struct data_in
*data_in
,
856 struct lto_input_block
*ib
)
861 /* Read the static chain and non-local goto save area. */
862 fn
->static_chain_decl
= stream_read_tree (ib
, data_in
);
863 fn
->nonlocal_goto_save_area
= stream_read_tree (ib
, data_in
);
865 /* Read all the local symbols. */
866 len
= streamer_read_hwi (ib
);
870 vec_safe_grow_cleared (fn
->local_decls
, len
);
871 for (i
= 0; i
< len
; i
++)
873 tree t
= stream_read_tree (ib
, data_in
);
874 (*fn
->local_decls
)[i
] = t
;
878 /* Input the current IL state of the function. */
879 fn
->curr_properties
= streamer_read_uhwi (ib
);
881 /* Read all the attributes for FN. */
882 bp
= streamer_read_bitpack (ib
);
883 fn
->is_thunk
= bp_unpack_value (&bp
, 1);
884 fn
->has_local_explicit_reg_vars
= bp_unpack_value (&bp
, 1);
885 fn
->returns_pcc_struct
= bp_unpack_value (&bp
, 1);
886 fn
->returns_struct
= bp_unpack_value (&bp
, 1);
887 fn
->can_throw_non_call_exceptions
= bp_unpack_value (&bp
, 1);
888 fn
->can_delete_dead_exceptions
= bp_unpack_value (&bp
, 1);
889 fn
->always_inline_functions_inlined
= bp_unpack_value (&bp
, 1);
890 fn
->after_inlining
= bp_unpack_value (&bp
, 1);
891 fn
->stdarg
= bp_unpack_value (&bp
, 1);
892 fn
->has_nonlocal_label
= bp_unpack_value (&bp
, 1);
893 fn
->calls_alloca
= bp_unpack_value (&bp
, 1);
894 fn
->calls_setjmp
= bp_unpack_value (&bp
, 1);
895 fn
->has_force_vectorize_loops
= bp_unpack_value (&bp
, 1);
896 fn
->has_simduid_loops
= bp_unpack_value (&bp
, 1);
897 fn
->va_list_fpr_size
= bp_unpack_value (&bp
, 8);
898 fn
->va_list_gpr_size
= bp_unpack_value (&bp
, 8);
900 /* Input the function start and end loci. */
901 fn
->function_start_locus
= stream_input_location (&bp
, data_in
);
902 fn
->function_end_locus
= stream_input_location (&bp
, data_in
);
906 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
909 input_function (tree fn_decl
, struct data_in
*data_in
,
910 struct lto_input_block
*ib
, struct lto_input_block
*ib_cfg
)
916 struct cgraph_node
*node
;
918 tag
= streamer_read_record_start (ib
);
919 lto_tag_check (tag
, LTO_function
);
921 /* Read decls for parameters and args. */
922 DECL_RESULT (fn_decl
) = stream_read_tree (ib
, data_in
);
923 DECL_ARGUMENTS (fn_decl
) = streamer_read_chain (ib
, data_in
);
925 /* Read the tree of lexical scopes for the function. */
926 DECL_INITIAL (fn_decl
) = stream_read_tree (ib
, data_in
);
928 if (!streamer_read_uhwi (ib
))
931 push_struct_function (fn_decl
);
932 fn
= DECL_STRUCT_FUNCTION (fn_decl
);
934 /* We input IL in SSA form. */
935 cfun
->gimple_df
->in_ssa_p
= true;
937 gimple_register_cfg_hooks ();
939 node
= cgraph_node::get (fn_decl
);
941 node
= cgraph_node::create (fn_decl
);
942 input_struct_function_base (fn
, data_in
, ib
);
943 input_cfg (ib_cfg
, data_in
, fn
, node
->count_materialization_scale
);
945 /* Read all the SSA names. */
946 input_ssa_names (ib
, data_in
, fn
);
948 /* Read the exception handling regions in the function. */
949 input_eh_regions (ib
, data_in
, fn
);
951 gcc_assert (DECL_INITIAL (fn_decl
));
952 DECL_SAVED_TREE (fn_decl
) = NULL_TREE
;
954 /* Read all the basic blocks. */
955 tag
= streamer_read_record_start (ib
);
958 input_bb (ib
, tag
, data_in
, fn
,
959 node
->count_materialization_scale
);
960 tag
= streamer_read_record_start (ib
);
963 /* Fix up the call statements that are mentioned in the callgraph
965 set_gimple_stmt_max_uid (cfun
, 0);
966 FOR_ALL_BB_FN (bb
, cfun
)
968 gimple_stmt_iterator gsi
;
969 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
971 gimple stmt
= gsi_stmt (gsi
);
972 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
974 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
976 gimple stmt
= gsi_stmt (gsi
);
977 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
980 stmts
= (gimple
*) xcalloc (gimple_stmt_max_uid (fn
), sizeof (gimple
));
981 FOR_ALL_BB_FN (bb
, cfun
)
983 gimple_stmt_iterator bsi
= gsi_start_phis (bb
);
984 while (!gsi_end_p (bsi
))
986 gimple stmt
= gsi_stmt (bsi
);
988 stmts
[gimple_uid (stmt
)] = stmt
;
990 bsi
= gsi_start_bb (bb
);
991 while (!gsi_end_p (bsi
))
993 gimple stmt
= gsi_stmt (bsi
);
994 /* If we're recompiling LTO objects with debug stmts but
995 we're not supposed to have debug stmts, remove them now.
996 We can't remove them earlier because this would cause uid
997 mismatches in fixups, but we can do it at this point, as
998 long as debug stmts don't require fixups. */
999 if (!MAY_HAVE_DEBUG_STMTS
&& !flag_wpa
&& is_gimple_debug (stmt
))
1001 gimple_stmt_iterator gsi
= bsi
;
1003 gsi_remove (&gsi
, true);
1008 stmts
[gimple_uid (stmt
)] = stmt
;
1013 /* Set the gimple body to the statement sequence in the entry
1014 basic block. FIXME lto, this is fairly hacky. The existence
1015 of a gimple body is used by the cgraph routines, but we should
1016 really use the presence of the CFG. */
1018 edge_iterator ei
= ei_start (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
);
1019 gimple_set_body (fn_decl
, bb_seq (ei_edge (ei
)->dest
));
1022 fixup_call_stmt_edges (node
, stmts
);
1023 execute_all_ipa_stmt_fixups (node
, stmts
);
1025 update_ssa (TODO_update_ssa_only_virtuals
);
1026 free_dominance_info (CDI_DOMINATORS
);
1027 free_dominance_info (CDI_POST_DOMINATORS
);
1032 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1035 input_constructor (tree var
, struct data_in
*data_in
,
1036 struct lto_input_block
*ib
)
1038 DECL_INITIAL (var
) = stream_read_tree (ib
, data_in
);
1042 /* Read the body from DATA for function NODE and fill it in.
1043 FILE_DATA are the global decls and types. SECTION_TYPE is either
1044 LTO_section_function_body or LTO_section_static_initializer. If
1045 section type is LTO_section_function_body, FN must be the decl for
1049 lto_read_body_or_constructor (struct lto_file_decl_data
*file_data
, struct symtab_node
*node
,
1050 const char *data
, enum lto_section_type section_type
)
1052 const struct lto_function_header
*header
;
1053 struct data_in
*data_in
;
1057 struct lto_input_block ib_cfg
;
1058 struct lto_input_block ib_main
;
1059 tree fn_decl
= node
->decl
;
1061 header
= (const struct lto_function_header
*) data
;
1062 if (TREE_CODE (node
->decl
) == FUNCTION_DECL
)
1064 cfg_offset
= sizeof (struct lto_function_header
);
1065 main_offset
= cfg_offset
+ header
->cfg_size
;
1066 string_offset
= main_offset
+ header
->main_size
;
1068 LTO_INIT_INPUT_BLOCK (ib_cfg
,
1073 LTO_INIT_INPUT_BLOCK (ib_main
,
1080 main_offset
= sizeof (struct lto_function_header
);
1081 string_offset
= main_offset
+ header
->main_size
;
1083 LTO_INIT_INPUT_BLOCK (ib_main
,
1089 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
1090 header
->string_size
, vNULL
);
1092 if (section_type
== LTO_section_function_body
)
1094 struct lto_in_decl_state
*decl_state
;
1097 gcc_checking_assert (node
);
1099 /* Use the function's decl state. */
1100 decl_state
= lto_get_function_in_decl_state (file_data
, fn_decl
);
1101 gcc_assert (decl_state
);
1102 file_data
->current_decl_state
= decl_state
;
1105 /* Set up the struct function. */
1106 from
= data_in
->reader_cache
->nodes
.length ();
1107 if (TREE_CODE (node
->decl
) == FUNCTION_DECL
)
1108 input_function (fn_decl
, data_in
, &ib_main
, &ib_cfg
);
1110 input_constructor (fn_decl
, data_in
, &ib_main
);
1111 /* And fixup types we streamed locally. */
1113 struct streamer_tree_cache_d
*cache
= data_in
->reader_cache
;
1114 unsigned len
= cache
->nodes
.length ();
1116 for (i
= len
; i
-- > from
;)
1118 tree t
= streamer_tree_cache_get_tree (cache
, i
);
1124 gcc_assert (TYPE_CANONICAL (t
) == NULL_TREE
);
1125 TYPE_CANONICAL (t
) = TYPE_MAIN_VARIANT (t
);
1126 if (TYPE_MAIN_VARIANT (t
) != t
)
1128 gcc_assert (TYPE_NEXT_VARIANT (t
) == NULL_TREE
);
1129 TYPE_NEXT_VARIANT (t
)
1130 = TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t
));
1131 TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t
)) = t
;
1137 /* Restore decl state */
1138 file_data
->current_decl_state
= file_data
->global_decl_state
;
1141 lto_data_in_delete (data_in
);
1145 /* Read the body of NODE using DATA. FILE_DATA holds the global
1149 lto_input_function_body (struct lto_file_decl_data
*file_data
,
1150 struct cgraph_node
*node
, const char *data
)
1152 lto_read_body_or_constructor (file_data
, node
, data
, LTO_section_function_body
);
1155 /* Read the body of NODE using DATA. FILE_DATA holds the global
1159 lto_input_variable_constructor (struct lto_file_decl_data
*file_data
,
1160 struct varpool_node
*node
, const char *data
)
1162 lto_read_body_or_constructor (file_data
, node
, data
, LTO_section_function_body
);
1166 /* Read the physical representation of a tree node EXPR from
1167 input block IB using the per-file context in DATA_IN. */
1170 lto_read_tree_1 (struct lto_input_block
*ib
, struct data_in
*data_in
, tree expr
)
1172 /* Read all the bitfield values in EXPR. Note that for LTO, we
1173 only write language-independent bitfields, so no more unpacking is
1175 streamer_read_tree_bitfields (ib
, data_in
, expr
);
1177 /* Read all the pointer fields in EXPR. */
1178 streamer_read_tree_body (ib
, data_in
, expr
);
1180 /* Read any LTO-specific data not read by the tree streamer. */
1182 && TREE_CODE (expr
) != FUNCTION_DECL
1183 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
1184 DECL_INITIAL (expr
) = stream_read_tree (ib
, data_in
);
1186 /* We should never try to instantiate an MD or NORMAL builtin here. */
1187 if (TREE_CODE (expr
) == FUNCTION_DECL
)
1188 gcc_assert (!streamer_handle_as_builtin_p (expr
));
1190 #ifdef LTO_STREAMER_DEBUG
1191 /* Remove the mapping to RESULT's original address set by
1192 streamer_alloc_tree. */
1193 lto_orig_address_remove (expr
);
1197 /* Read the physical representation of a tree node with tag TAG from
1198 input block IB using the per-file context in DATA_IN. */
1201 lto_read_tree (struct lto_input_block
*ib
, struct data_in
*data_in
,
1202 enum LTO_tags tag
, hashval_t hash
)
1204 /* Instantiate a new tree node. */
1205 tree result
= streamer_alloc_tree (ib
, data_in
, tag
);
1207 /* Enter RESULT in the reader cache. This will make RESULT
1208 available so that circular references in the rest of the tree
1209 structure can be resolved in subsequent calls to stream_read_tree. */
1210 streamer_tree_cache_append (data_in
->reader_cache
, result
, hash
);
1212 lto_read_tree_1 (ib
, data_in
, result
);
1214 /* end_marker = */ streamer_read_uchar (ib
);
1220 /* Populate the reader cache with trees materialized from the SCC
1221 following in the IB, DATA_IN stream. */
1224 lto_input_scc (struct lto_input_block
*ib
, struct data_in
*data_in
,
1225 unsigned *len
, unsigned *entry_len
)
1227 /* A blob of unnamed tree nodes, fill the cache from it and
1229 unsigned size
= streamer_read_uhwi (ib
);
1230 hashval_t scc_hash
= streamer_read_uhwi (ib
);
1231 unsigned scc_entry_len
= 1;
1235 enum LTO_tags tag
= streamer_read_record_start (ib
);
1236 lto_input_tree_1 (ib
, data_in
, tag
, scc_hash
);
1240 unsigned int first
= data_in
->reader_cache
->nodes
.length ();
1243 scc_entry_len
= streamer_read_uhwi (ib
);
1245 /* Materialize size trees by reading their headers. */
1246 for (unsigned i
= 0; i
< size
; ++i
)
1248 enum LTO_tags tag
= streamer_read_record_start (ib
);
1250 || (tag
>= LTO_field_decl_ref
&& tag
<= LTO_global_decl_ref
)
1251 || tag
== LTO_tree_pickle_reference
1252 || tag
== LTO_builtin_decl
1253 || tag
== LTO_integer_cst
1254 || tag
== LTO_tree_scc
)
1257 result
= streamer_alloc_tree (ib
, data_in
, tag
);
1258 streamer_tree_cache_append (data_in
->reader_cache
, result
, 0);
1261 /* Read the tree bitpacks and references. */
1262 for (unsigned i
= 0; i
< size
; ++i
)
1264 result
= streamer_tree_cache_get_tree (data_in
->reader_cache
,
1266 lto_read_tree_1 (ib
, data_in
, result
);
1267 /* end_marker = */ streamer_read_uchar (ib
);
1272 *entry_len
= scc_entry_len
;
1277 /* Read a tree from input block IB using the per-file context in
1278 DATA_IN. This context is used, for example, to resolve references
1279 to previously read nodes. */
1282 lto_input_tree_1 (struct lto_input_block
*ib
, struct data_in
*data_in
,
1283 enum LTO_tags tag
, hashval_t hash
)
1287 gcc_assert ((unsigned) tag
< (unsigned) LTO_NUM_TAGS
);
1289 if (tag
== LTO_null
)
1291 else if (tag
>= LTO_field_decl_ref
&& tag
<= LTO_namelist_decl_ref
)
1293 /* If TAG is a reference to an indexable tree, the next value
1294 in IB is the index into the table where we expect to find
1296 result
= lto_input_tree_ref (ib
, data_in
, cfun
, tag
);
1298 else if (tag
== LTO_tree_pickle_reference
)
1300 /* If TAG is a reference to a previously read tree, look it up in
1301 the reader cache. */
1302 result
= streamer_get_pickled_tree (ib
, data_in
);
1304 else if (tag
== LTO_builtin_decl
)
1306 /* If we are going to read a built-in function, all we need is
1307 the code and class. */
1308 result
= streamer_get_builtin_tree (ib
, data_in
);
1310 else if (tag
== LTO_integer_cst
)
1312 /* For shared integer constants in singletons we can use the
1313 existing tree integer constant merging code. */
1314 tree type
= stream_read_tree (ib
, data_in
);
1315 unsigned HOST_WIDE_INT len
= streamer_read_uhwi (ib
);
1316 unsigned HOST_WIDE_INT i
;
1317 HOST_WIDE_INT a
[WIDE_INT_MAX_ELTS
];
1319 for (i
= 0; i
< len
; i
++)
1320 a
[i
] = streamer_read_hwi (ib
);
1321 gcc_assert (TYPE_PRECISION (type
) <= MAX_BITSIZE_MODE_ANY_INT
);
1322 result
= wide_int_to_tree (type
, wide_int::from_array
1323 (a
, len
, TYPE_PRECISION (type
)));
1324 streamer_tree_cache_append (data_in
->reader_cache
, result
, hash
);
1326 else if (tag
== LTO_tree_scc
)
1328 unsigned len
, entry_len
;
1330 /* Input and skip the SCC. */
1331 lto_input_scc (ib
, data_in
, &len
, &entry_len
);
1334 return lto_input_tree (ib
, data_in
);
1338 /* Otherwise, materialize a new node from IB. */
1339 result
= lto_read_tree (ib
, data_in
, tag
, hash
);
1346 lto_input_tree (struct lto_input_block
*ib
, struct data_in
*data_in
)
1348 return lto_input_tree_1 (ib
, data_in
, streamer_read_record_start (ib
), 0);
1352 /* Input toplevel asms. */
1355 lto_input_toplevel_asms (struct lto_file_decl_data
*file_data
, int order_base
)
1358 const char *data
= lto_get_section_data (file_data
, LTO_section_asm
,
1360 const struct lto_asm_header
*header
= (const struct lto_asm_header
*) data
;
1362 struct data_in
*data_in
;
1363 struct lto_input_block ib
;
1369 string_offset
= sizeof (*header
) + header
->main_size
;
1371 LTO_INIT_INPUT_BLOCK (ib
,
1372 data
+ sizeof (*header
),
1376 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
1377 header
->string_size
, vNULL
);
1379 while ((str
= streamer_read_string_cst (data_in
, &ib
)))
1381 struct asm_node
*node
= add_asm_node (str
);
1382 node
->order
= streamer_read_hwi (&ib
) + order_base
;
1383 if (node
->order
>= symtab_order
)
1384 symtab_order
= node
->order
+ 1;
1387 lto_data_in_delete (data_in
);
1389 lto_free_section_data (file_data
, LTO_section_asm
, NULL
, data
, len
);
1393 /* Initialization for the LTO reader. */
1396 lto_reader_init (void)
1398 lto_streamer_init ();
1399 file_name_hash_table
1400 = new hash_table
<freeing_string_slot_hasher
> (37);
1404 /* Create a new data_in object for FILE_DATA. STRINGS is the string
1405 table to use with LEN strings. RESOLUTIONS is the vector of linker
1406 resolutions (NULL if not using a linker plugin). */
1409 lto_data_in_create (struct lto_file_decl_data
*file_data
, const char *strings
,
1411 vec
<ld_plugin_symbol_resolution_t
> resolutions
)
1413 struct data_in
*data_in
= XCNEW (struct data_in
);
1414 data_in
->file_data
= file_data
;
1415 data_in
->strings
= strings
;
1416 data_in
->strings_len
= len
;
1417 data_in
->globals_resolution
= resolutions
;
1418 data_in
->reader_cache
= streamer_tree_cache_create (false, false, true);
1423 /* Remove DATA_IN. */
1426 lto_data_in_delete (struct data_in
*data_in
)
1428 data_in
->globals_resolution
.release ();
1429 streamer_tree_cache_delete (data_in
->reader_cache
);