1 /* Read the GIMPLE representation from a file stream.
3 Copyright (C) 2009-2015 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"
31 #include "double-int.h"
38 #include "fold-const.h"
39 #include "stringpool.h"
45 #include "hard-reg-set.h"
47 #include "dominance.h"
49 #include "basic-block.h"
50 #include "tree-ssa-alias.h"
51 #include "internal-fn.h"
52 #include "gimple-expr.h"
55 #include "gimple-iterator.h"
56 #include "gimple-ssa.h"
58 #include "tree-ssanames.h"
59 #include "tree-into-ssa.h"
62 #include "tree-pass.h"
63 #include "diagnostic.h"
67 #include "plugin-api.h"
70 #include "ipa-utils.h"
71 #include "data-streamer.h"
72 #include "gimple-streamer.h"
73 #include "lto-streamer.h"
74 #include "tree-streamer.h"
75 #include "tree-pass.h"
76 #include "streamer-hooks.h"
80 struct freeing_string_slot_hasher
: string_slot_hasher
82 static inline void remove (value_type
*);
86 freeing_string_slot_hasher::remove (value_type
*v
)
91 /* The table to hold the file names. */
92 static hash_table
<freeing_string_slot_hasher
> *file_name_hash_table
;
95 /* Check that tag ACTUAL has one of the given values. NUM_TAGS is the
96 number of valid tag values to check. */
99 lto_tag_check_set (enum LTO_tags actual
, int ntags
, ...)
104 va_start (ap
, ntags
);
105 for (i
= 0; i
< ntags
; i
++)
106 if ((unsigned) actual
== va_arg (ap
, unsigned))
113 internal_error ("bytecode stream: unexpected tag %s", lto_tag_name (actual
));
117 /* Read LENGTH bytes from STREAM to ADDR. */
120 lto_input_data_block (struct lto_input_block
*ib
, void *addr
, size_t length
)
123 unsigned char *const buffer
= (unsigned char *const) addr
;
125 for (i
= 0; i
< length
; i
++)
126 buffer
[i
] = streamer_read_uchar (ib
);
130 /* Lookup STRING in file_name_hash_table. If found, return the existing
131 string, otherwise insert STRING as the canonical version. */
134 canon_file_name (const char *string
)
137 struct string_slot s_slot
;
138 size_t len
= strlen (string
);
143 slot
= file_name_hash_table
->find_slot (&s_slot
, INSERT
);
147 struct string_slot
*new_slot
;
149 saved_string
= (char *) xmalloc (len
+ 1);
150 new_slot
= XCNEW (struct string_slot
);
151 memcpy (saved_string
, string
, len
+ 1);
152 new_slot
->s
= saved_string
;
159 struct string_slot
*old_slot
= *slot
;
165 /* Read a location bitpack from input block IB. */
168 lto_input_location (struct bitpack_d
*bp
, struct data_in
*data_in
)
170 static const char *current_file
;
171 static int current_line
;
172 static int current_col
;
173 bool file_change
, line_change
, column_change
;
174 bool prev_file
= current_file
!= NULL
;
176 if (bp_unpack_value (bp
, 1))
177 return UNKNOWN_LOCATION
;
179 file_change
= bp_unpack_value (bp
, 1);
180 line_change
= bp_unpack_value (bp
, 1);
181 column_change
= bp_unpack_value (bp
, 1);
184 current_file
= canon_file_name (bp_unpack_string (data_in
, bp
));
187 current_line
= bp_unpack_var_len_unsigned (bp
);
190 current_col
= bp_unpack_var_len_unsigned (bp
);
195 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
197 linemap_add (line_table
, LC_ENTER
, false, current_file
, current_line
);
199 else if (line_change
)
200 linemap_line_start (line_table
, current_line
, current_col
);
202 return linemap_position_for_column (line_table
, current_col
);
206 /* Read a reference to a tree node from DATA_IN using input block IB.
207 TAG is the expected node that should be found in IB, if TAG belongs
208 to one of the indexable trees, expect to read a reference index to
209 be looked up in one of the symbol tables, otherwise read the pysical
210 representation of the tree using stream_read_tree. FN is the
211 function scope for the read tree. */
214 lto_input_tree_ref (struct lto_input_block
*ib
, struct data_in
*data_in
,
215 struct function
*fn
, enum LTO_tags tag
)
217 unsigned HOST_WIDE_INT ix_u
;
218 tree result
= NULL_TREE
;
220 lto_tag_check_range (tag
, LTO_field_decl_ref
, LTO_namelist_decl_ref
);
225 ix_u
= streamer_read_uhwi (ib
);
226 result
= lto_file_decl_data_get_type (data_in
->file_data
, ix_u
);
229 case LTO_ssa_name_ref
:
230 ix_u
= streamer_read_uhwi (ib
);
231 result
= (*SSANAMES (fn
))[ix_u
];
234 case LTO_field_decl_ref
:
235 ix_u
= streamer_read_uhwi (ib
);
236 result
= lto_file_decl_data_get_field_decl (data_in
->file_data
, ix_u
);
239 case LTO_function_decl_ref
:
240 ix_u
= streamer_read_uhwi (ib
);
241 result
= lto_file_decl_data_get_fn_decl (data_in
->file_data
, ix_u
);
244 case LTO_type_decl_ref
:
245 ix_u
= streamer_read_uhwi (ib
);
246 result
= lto_file_decl_data_get_type_decl (data_in
->file_data
, ix_u
);
249 case LTO_namespace_decl_ref
:
250 ix_u
= streamer_read_uhwi (ib
);
251 result
= lto_file_decl_data_get_namespace_decl (data_in
->file_data
, ix_u
);
254 case LTO_global_decl_ref
:
255 case LTO_result_decl_ref
:
256 case LTO_const_decl_ref
:
257 case LTO_imported_decl_ref
:
258 case LTO_label_decl_ref
:
259 case LTO_translation_unit_decl_ref
:
260 case LTO_namelist_decl_ref
:
261 ix_u
= streamer_read_uhwi (ib
);
262 result
= lto_file_decl_data_get_var_decl (data_in
->file_data
, ix_u
);
275 /* Read and return a double-linked list of catch handlers from input
276 block IB, using descriptors in DATA_IN. */
278 static struct eh_catch_d
*
279 lto_input_eh_catch_list (struct lto_input_block
*ib
, struct data_in
*data_in
,
285 *last_p
= first
= NULL
;
286 tag
= streamer_read_record_start (ib
);
292 lto_tag_check_range (tag
, LTO_eh_catch
, LTO_eh_catch
);
294 /* Read the catch node. */
295 n
= ggc_cleared_alloc
<eh_catch_d
> ();
296 n
->type_list
= stream_read_tree (ib
, data_in
);
297 n
->filter_list
= stream_read_tree (ib
, data_in
);
298 n
->label
= stream_read_tree (ib
, data_in
);
300 /* Register all the types in N->FILTER_LIST. */
301 for (list
= n
->filter_list
; list
; list
= TREE_CHAIN (list
))
302 add_type_for_runtime (TREE_VALUE (list
));
304 /* Chain N to the end of the list. */
306 (*last_p
)->next_catch
= n
;
307 n
->prev_catch
= *last_p
;
310 /* Set the head of the list the first time through the loop. */
314 tag
= streamer_read_record_start (ib
);
321 /* Read and return EH region IX from input block IB, using descriptors
325 input_eh_region (struct lto_input_block
*ib
, struct data_in
*data_in
, int ix
)
330 /* Read the region header. */
331 tag
= streamer_read_record_start (ib
);
335 r
= ggc_cleared_alloc
<eh_region_d
> ();
336 r
->index
= streamer_read_hwi (ib
);
338 gcc_assert (r
->index
== ix
);
340 /* Read all the region pointers as region numbers. We'll fix up
341 the pointers once the whole array has been read. */
342 r
->outer
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
343 r
->inner
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
344 r
->next_peer
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
348 case LTO_ert_cleanup
:
349 r
->type
= ERT_CLEANUP
;
354 struct eh_catch_d
*last_catch
;
356 r
->u
.eh_try
.first_catch
= lto_input_eh_catch_list (ib
, data_in
,
358 r
->u
.eh_try
.last_catch
= last_catch
;
362 case LTO_ert_allowed_exceptions
:
366 r
->type
= ERT_ALLOWED_EXCEPTIONS
;
367 r
->u
.allowed
.type_list
= stream_read_tree (ib
, data_in
);
368 r
->u
.allowed
.label
= stream_read_tree (ib
, data_in
);
369 r
->u
.allowed
.filter
= streamer_read_uhwi (ib
);
371 for (l
= r
->u
.allowed
.type_list
; l
; l
= TREE_CHAIN (l
))
372 add_type_for_runtime (TREE_VALUE (l
));
376 case LTO_ert_must_not_throw
:
378 r
->type
= ERT_MUST_NOT_THROW
;
379 r
->u
.must_not_throw
.failure_decl
= stream_read_tree (ib
, data_in
);
380 bitpack_d bp
= streamer_read_bitpack (ib
);
381 r
->u
.must_not_throw
.failure_loc
382 = stream_input_location (&bp
, data_in
);
390 r
->landing_pads
= (eh_landing_pad
) (intptr_t) streamer_read_hwi (ib
);
396 /* Read and return EH landing pad IX from input block IB, using descriptors
399 static eh_landing_pad
400 input_eh_lp (struct lto_input_block
*ib
, struct data_in
*data_in
, int ix
)
405 /* Read the landing pad header. */
406 tag
= streamer_read_record_start (ib
);
410 lto_tag_check_range (tag
, LTO_eh_landing_pad
, LTO_eh_landing_pad
);
412 lp
= ggc_cleared_alloc
<eh_landing_pad_d
> ();
413 lp
->index
= streamer_read_hwi (ib
);
414 gcc_assert (lp
->index
== ix
);
415 lp
->next_lp
= (eh_landing_pad
) (intptr_t) streamer_read_hwi (ib
);
416 lp
->region
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
417 lp
->post_landing_pad
= stream_read_tree (ib
, data_in
);
423 /* After reading the EH regions, pointers to peer and children regions
424 are region numbers. This converts all these region numbers into
425 real pointers into the rematerialized regions for FN. ROOT_REGION
426 is the region number for the root EH region in FN. */
429 fixup_eh_region_pointers (struct function
*fn
, HOST_WIDE_INT root_region
)
432 vec
<eh_region
, va_gc
> *eh_array
= fn
->eh
->region_array
;
433 vec
<eh_landing_pad
, va_gc
> *lp_array
= fn
->eh
->lp_array
;
437 gcc_assert (eh_array
&& lp_array
);
439 gcc_assert (root_region
>= 0);
440 fn
->eh
->region_tree
= (*eh_array
)[root_region
];
442 #define FIXUP_EH_REGION(r) (r) = (*eh_array)[(HOST_WIDE_INT) (intptr_t) (r)]
443 #define FIXUP_EH_LP(p) (p) = (*lp_array)[(HOST_WIDE_INT) (intptr_t) (p)]
445 /* Convert all the index numbers stored in pointer fields into
446 pointers to the corresponding slots in the EH region array. */
447 FOR_EACH_VEC_ELT (*eh_array
, i
, r
)
449 /* The array may contain NULL regions. */
453 gcc_assert (i
== (unsigned) r
->index
);
454 FIXUP_EH_REGION (r
->outer
);
455 FIXUP_EH_REGION (r
->inner
);
456 FIXUP_EH_REGION (r
->next_peer
);
457 FIXUP_EH_LP (r
->landing_pads
);
460 /* Convert all the index numbers stored in pointer fields into
461 pointers to the corresponding slots in the EH landing pad array. */
462 FOR_EACH_VEC_ELT (*lp_array
, i
, lp
)
464 /* The array may contain NULL landing pads. */
468 gcc_assert (i
== (unsigned) lp
->index
);
469 FIXUP_EH_LP (lp
->next_lp
);
470 FIXUP_EH_REGION (lp
->region
);
473 #undef FIXUP_EH_REGION
478 /* Initialize EH support. */
483 static bool eh_initialized_p
= false;
485 if (eh_initialized_p
)
488 /* Contrary to most other FEs, we only initialize EH support when at
489 least one of the files in the set contains exception regions in
490 it. Since this happens much later than the call to init_eh in
491 lang_dependent_init, we have to set flag_exceptions and call
492 init_eh again to initialize the EH tables. */
496 eh_initialized_p
= true;
500 /* Read the exception table for FN from IB using the data descriptors
504 input_eh_regions (struct lto_input_block
*ib
, struct data_in
*data_in
,
507 HOST_WIDE_INT i
, root_region
, len
;
510 tag
= streamer_read_record_start (ib
);
514 lto_tag_check_range (tag
, LTO_eh_table
, LTO_eh_table
);
516 /* If the file contains EH regions, then it was compiled with
517 -fexceptions. In that case, initialize the backend EH
523 root_region
= streamer_read_hwi (ib
);
524 gcc_assert (root_region
== (int) root_region
);
526 /* Read the EH region array. */
527 len
= streamer_read_hwi (ib
);
528 gcc_assert (len
== (int) len
);
531 vec_safe_grow_cleared (fn
->eh
->region_array
, len
);
532 for (i
= 0; i
< len
; i
++)
534 eh_region r
= input_eh_region (ib
, data_in
, i
);
535 (*fn
->eh
->region_array
)[i
] = r
;
539 /* Read the landing pads. */
540 len
= streamer_read_hwi (ib
);
541 gcc_assert (len
== (int) len
);
544 vec_safe_grow_cleared (fn
->eh
->lp_array
, len
);
545 for (i
= 0; i
< len
; i
++)
547 eh_landing_pad lp
= input_eh_lp (ib
, data_in
, i
);
548 (*fn
->eh
->lp_array
)[i
] = lp
;
552 /* Read the runtime type data. */
553 len
= streamer_read_hwi (ib
);
554 gcc_assert (len
== (int) len
);
557 vec_safe_grow_cleared (fn
->eh
->ttype_data
, len
);
558 for (i
= 0; i
< len
; i
++)
560 tree ttype
= stream_read_tree (ib
, data_in
);
561 (*fn
->eh
->ttype_data
)[i
] = ttype
;
565 /* Read the table of action chains. */
566 len
= streamer_read_hwi (ib
);
567 gcc_assert (len
== (int) len
);
570 if (targetm
.arm_eabi_unwinder
)
572 vec_safe_grow_cleared (fn
->eh
->ehspec_data
.arm_eabi
, len
);
573 for (i
= 0; i
< len
; i
++)
575 tree t
= stream_read_tree (ib
, data_in
);
576 (*fn
->eh
->ehspec_data
.arm_eabi
)[i
] = t
;
581 vec_safe_grow_cleared (fn
->eh
->ehspec_data
.other
, len
);
582 for (i
= 0; i
< len
; i
++)
584 uchar c
= streamer_read_uchar (ib
);
585 (*fn
->eh
->ehspec_data
.other
)[i
] = c
;
590 /* Reconstruct the EH region tree by fixing up the peer/children
592 fixup_eh_region_pointers (fn
, root_region
);
594 tag
= streamer_read_record_start (ib
);
595 lto_tag_check_range (tag
, LTO_null
, LTO_null
);
599 /* Make a new basic block with index INDEX in function FN. */
602 make_new_block (struct function
*fn
, unsigned int index
)
604 basic_block bb
= alloc_block ();
606 SET_BASIC_BLOCK_FOR_FN (fn
, index
, bb
);
607 n_basic_blocks_for_fn (fn
)++;
612 /* Read a wide-int. */
615 streamer_read_wi (struct lto_input_block
*ib
)
617 HOST_WIDE_INT a
[WIDE_INT_MAX_ELTS
];
619 int prec ATTRIBUTE_UNUSED
= streamer_read_uhwi (ib
);
620 int len
= streamer_read_uhwi (ib
);
621 for (i
= 0; i
< len
; i
++)
622 a
[i
] = streamer_read_hwi (ib
);
623 return widest_int::from_array (a
, len
);
627 /* Read the CFG for function FN from input block IB. */
630 input_cfg (struct lto_input_block
*ib
, struct data_in
*data_in
,
632 int count_materialization_scale
)
634 unsigned int bb_count
;
639 init_empty_tree_cfg_for_function (fn
);
640 init_ssa_operands (fn
);
642 profile_status_for_fn (fn
) = streamer_read_enum (ib
, profile_status_d
,
645 bb_count
= streamer_read_uhwi (ib
);
647 last_basic_block_for_fn (fn
) = bb_count
;
648 if (bb_count
> basic_block_info_for_fn (fn
)->length ())
649 vec_safe_grow_cleared (basic_block_info_for_fn (fn
), bb_count
);
651 if (bb_count
> label_to_block_map_for_fn (fn
)->length ())
652 vec_safe_grow_cleared (label_to_block_map_for_fn (fn
), bb_count
);
654 index
= streamer_read_hwi (ib
);
657 basic_block bb
= BASIC_BLOCK_FOR_FN (fn
, index
);
658 unsigned int edge_count
;
661 bb
= make_new_block (fn
, index
);
663 edge_count
= streamer_read_uhwi (ib
);
665 /* Connect up the CFG. */
666 for (i
= 0; i
< edge_count
; i
++)
668 unsigned int dest_index
;
669 unsigned int edge_flags
;
675 dest_index
= streamer_read_uhwi (ib
);
676 probability
= (int) streamer_read_hwi (ib
);
677 count
= apply_scale ((gcov_type
) streamer_read_gcov_count (ib
),
678 count_materialization_scale
);
679 edge_flags
= streamer_read_uhwi (ib
);
681 dest
= BASIC_BLOCK_FOR_FN (fn
, dest_index
);
684 dest
= make_new_block (fn
, dest_index
);
686 e
= make_edge (bb
, dest
, edge_flags
);
687 e
->probability
= probability
;
691 index
= streamer_read_hwi (ib
);
694 p_bb
= ENTRY_BLOCK_PTR_FOR_FN (fn
);
695 index
= streamer_read_hwi (ib
);
698 basic_block bb
= BASIC_BLOCK_FOR_FN (fn
, index
);
702 index
= streamer_read_hwi (ib
);
705 /* ??? The cfgloop interface is tied to cfun. */
706 gcc_assert (cfun
== fn
);
708 /* Input the loop tree. */
709 unsigned n_loops
= streamer_read_uhwi (ib
);
713 struct loops
*loops
= ggc_cleared_alloc
<struct loops
> ();
714 init_loops_structure (fn
, loops
, n_loops
);
715 set_loops_for_fn (fn
, loops
);
717 /* Input each loop and associate it with its loop header so
718 flow_loops_find can rebuild the loop tree. */
719 for (unsigned i
= 1; i
< n_loops
; ++i
)
721 int header_index
= streamer_read_hwi (ib
);
722 if (header_index
== -1)
724 loops
->larray
->quick_push (NULL
);
728 struct loop
*loop
= alloc_loop ();
729 loop
->header
= BASIC_BLOCK_FOR_FN (fn
, header_index
);
730 loop
->header
->loop_father
= loop
;
732 /* Read everything copy_loop_info copies. */
733 loop
->estimate_state
= streamer_read_enum (ib
, loop_estimation
, EST_LAST
);
734 loop
->any_upper_bound
= streamer_read_hwi (ib
);
735 if (loop
->any_upper_bound
)
736 loop
->nb_iterations_upper_bound
= streamer_read_wi (ib
);
737 loop
->any_estimate
= streamer_read_hwi (ib
);
738 if (loop
->any_estimate
)
739 loop
->nb_iterations_estimate
= streamer_read_wi (ib
);
741 /* Read OMP SIMD related info. */
742 loop
->safelen
= streamer_read_hwi (ib
);
743 loop
->dont_vectorize
= streamer_read_hwi (ib
);
744 loop
->force_vectorize
= streamer_read_hwi (ib
);
745 loop
->simduid
= stream_read_tree (ib
, data_in
);
747 place_new_loop (fn
, loop
);
749 /* flow_loops_find doesn't like loops not in the tree, hook them
750 all as siblings of the tree root temporarily. */
751 flow_loop_tree_node_add (loops
->tree_root
, loop
);
754 /* Rebuild the loop tree. */
755 flow_loops_find (loops
);
759 /* Read the SSA names array for function FN from DATA_IN using input
763 input_ssa_names (struct lto_input_block
*ib
, struct data_in
*data_in
,
766 unsigned int i
, size
;
768 size
= streamer_read_uhwi (ib
);
769 init_ssanames (fn
, size
);
771 i
= streamer_read_uhwi (ib
);
777 /* Skip over the elements that had been freed. */
778 while (SSANAMES (fn
)->length () < i
)
779 SSANAMES (fn
)->quick_push (NULL_TREE
);
781 is_default_def
= (streamer_read_uchar (ib
) != 0);
782 name
= stream_read_tree (ib
, data_in
);
783 ssa_name
= make_ssa_name_fn (fn
, name
, gimple_build_nop ());
786 set_ssa_default_def (cfun
, SSA_NAME_VAR (ssa_name
), ssa_name
);
788 i
= streamer_read_uhwi (ib
);
793 /* Go through all NODE edges and fixup call_stmt pointers
794 so they point to STMTS. */
797 fixup_call_stmt_edges_1 (struct cgraph_node
*node
, gimple
*stmts
,
800 struct cgraph_edge
*cedge
;
801 struct ipa_ref
*ref
= NULL
;
804 for (cedge
= node
->callees
; cedge
; cedge
= cedge
->next_callee
)
806 if (gimple_stmt_max_uid (fn
) < cedge
->lto_stmt_uid
)
807 fatal_error ("Cgraph edge statement index out of range");
808 cedge
->call_stmt
= as_a
<gcall
*> (stmts
[cedge
->lto_stmt_uid
- 1]);
809 if (!cedge
->call_stmt
)
810 fatal_error ("Cgraph edge statement index not found");
812 for (cedge
= node
->indirect_calls
; cedge
; cedge
= cedge
->next_callee
)
814 if (gimple_stmt_max_uid (fn
) < cedge
->lto_stmt_uid
)
815 fatal_error ("Cgraph edge statement index out of range");
816 cedge
->call_stmt
= as_a
<gcall
*> (stmts
[cedge
->lto_stmt_uid
- 1]);
817 if (!cedge
->call_stmt
)
818 fatal_error ("Cgraph edge statement index not found");
820 for (i
= 0; node
->iterate_reference (i
, ref
); i
++)
821 if (ref
->lto_stmt_uid
)
823 if (gimple_stmt_max_uid (fn
) < ref
->lto_stmt_uid
)
824 fatal_error ("Reference statement index out of range");
825 ref
->stmt
= stmts
[ref
->lto_stmt_uid
- 1];
827 fatal_error ("Reference statement index not found");
832 /* Fixup call_stmt pointers in NODE and all clones. */
835 fixup_call_stmt_edges (struct cgraph_node
*orig
, gimple
*stmts
)
837 struct cgraph_node
*node
;
840 while (orig
->clone_of
)
841 orig
= orig
->clone_of
;
842 fn
= DECL_STRUCT_FUNCTION (orig
->decl
);
844 fixup_call_stmt_edges_1 (orig
, stmts
, fn
);
846 for (node
= orig
->clones
; node
!= orig
;)
848 fixup_call_stmt_edges_1 (node
, stmts
, fn
);
851 else if (node
->next_sibling_clone
)
852 node
= node
->next_sibling_clone
;
855 while (node
!= orig
&& !node
->next_sibling_clone
)
856 node
= node
->clone_of
;
858 node
= node
->next_sibling_clone
;
864 /* Input the base body of struct function FN from DATA_IN
865 using input block IB. */
868 input_struct_function_base (struct function
*fn
, struct data_in
*data_in
,
869 struct lto_input_block
*ib
)
874 /* Read the static chain and non-local goto save area. */
875 fn
->static_chain_decl
= stream_read_tree (ib
, data_in
);
876 fn
->nonlocal_goto_save_area
= stream_read_tree (ib
, data_in
);
878 /* Read all the local symbols. */
879 len
= streamer_read_hwi (ib
);
883 vec_safe_grow_cleared (fn
->local_decls
, len
);
884 for (i
= 0; i
< len
; i
++)
886 tree t
= stream_read_tree (ib
, data_in
);
887 (*fn
->local_decls
)[i
] = t
;
891 /* Input the current IL state of the function. */
892 fn
->curr_properties
= streamer_read_uhwi (ib
);
894 /* Read all the attributes for FN. */
895 bp
= streamer_read_bitpack (ib
);
896 fn
->is_thunk
= bp_unpack_value (&bp
, 1);
897 fn
->has_local_explicit_reg_vars
= bp_unpack_value (&bp
, 1);
898 fn
->returns_pcc_struct
= bp_unpack_value (&bp
, 1);
899 fn
->returns_struct
= bp_unpack_value (&bp
, 1);
900 fn
->can_throw_non_call_exceptions
= bp_unpack_value (&bp
, 1);
901 fn
->can_delete_dead_exceptions
= bp_unpack_value (&bp
, 1);
902 fn
->always_inline_functions_inlined
= bp_unpack_value (&bp
, 1);
903 fn
->after_inlining
= bp_unpack_value (&bp
, 1);
904 fn
->stdarg
= bp_unpack_value (&bp
, 1);
905 fn
->has_nonlocal_label
= bp_unpack_value (&bp
, 1);
906 fn
->calls_alloca
= bp_unpack_value (&bp
, 1);
907 fn
->calls_setjmp
= bp_unpack_value (&bp
, 1);
908 fn
->has_force_vectorize_loops
= bp_unpack_value (&bp
, 1);
909 fn
->has_simduid_loops
= bp_unpack_value (&bp
, 1);
910 fn
->va_list_fpr_size
= bp_unpack_value (&bp
, 8);
911 fn
->va_list_gpr_size
= bp_unpack_value (&bp
, 8);
912 fn
->last_clique
= bp_unpack_value (&bp
, sizeof (short) * 8);
914 /* Input the function start and end loci. */
915 fn
->function_start_locus
= stream_input_location (&bp
, data_in
);
916 fn
->function_end_locus
= stream_input_location (&bp
, data_in
);
920 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
923 input_function (tree fn_decl
, struct data_in
*data_in
,
924 struct lto_input_block
*ib
, struct lto_input_block
*ib_cfg
)
930 struct cgraph_node
*node
;
932 tag
= streamer_read_record_start (ib
);
933 lto_tag_check (tag
, LTO_function
);
935 /* Read decls for parameters and args. */
936 DECL_RESULT (fn_decl
) = stream_read_tree (ib
, data_in
);
937 DECL_ARGUMENTS (fn_decl
) = streamer_read_chain (ib
, data_in
);
939 /* Read the tree of lexical scopes for the function. */
940 DECL_INITIAL (fn_decl
) = stream_read_tree (ib
, data_in
);
942 if (!streamer_read_uhwi (ib
))
945 push_struct_function (fn_decl
);
946 fn
= DECL_STRUCT_FUNCTION (fn_decl
);
948 /* We input IL in SSA form. */
949 cfun
->gimple_df
->in_ssa_p
= true;
951 gimple_register_cfg_hooks ();
953 node
= cgraph_node::get (fn_decl
);
955 node
= cgraph_node::create (fn_decl
);
956 input_struct_function_base (fn
, data_in
, ib
);
957 input_cfg (ib_cfg
, data_in
, fn
, node
->count_materialization_scale
);
959 /* Read all the SSA names. */
960 input_ssa_names (ib
, data_in
, fn
);
962 /* Read the exception handling regions in the function. */
963 input_eh_regions (ib
, data_in
, fn
);
965 gcc_assert (DECL_INITIAL (fn_decl
));
966 DECL_SAVED_TREE (fn_decl
) = NULL_TREE
;
968 /* Read all the basic blocks. */
969 tag
= streamer_read_record_start (ib
);
972 input_bb (ib
, tag
, data_in
, fn
,
973 node
->count_materialization_scale
);
974 tag
= streamer_read_record_start (ib
);
977 /* Fix up the call statements that are mentioned in the callgraph
979 set_gimple_stmt_max_uid (cfun
, 0);
980 FOR_ALL_BB_FN (bb
, cfun
)
982 gimple_stmt_iterator gsi
;
983 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
985 gimple stmt
= gsi_stmt (gsi
);
986 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
988 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
990 gimple stmt
= gsi_stmt (gsi
);
991 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
994 stmts
= (gimple
*) xcalloc (gimple_stmt_max_uid (fn
), sizeof (gimple
));
995 FOR_ALL_BB_FN (bb
, cfun
)
997 gimple_stmt_iterator bsi
= gsi_start_phis (bb
);
998 while (!gsi_end_p (bsi
))
1000 gimple stmt
= gsi_stmt (bsi
);
1002 stmts
[gimple_uid (stmt
)] = stmt
;
1004 bsi
= gsi_start_bb (bb
);
1005 while (!gsi_end_p (bsi
))
1007 gimple stmt
= gsi_stmt (bsi
);
1008 /* If we're recompiling LTO objects with debug stmts but
1009 we're not supposed to have debug stmts, remove them now.
1010 We can't remove them earlier because this would cause uid
1011 mismatches in fixups, but we can do it at this point, as
1012 long as debug stmts don't require fixups. */
1013 if (!MAY_HAVE_DEBUG_STMTS
&& !flag_wpa
&& is_gimple_debug (stmt
))
1015 gimple_stmt_iterator gsi
= bsi
;
1017 gsi_remove (&gsi
, true);
1022 stmts
[gimple_uid (stmt
)] = stmt
;
1027 /* Set the gimple body to the statement sequence in the entry
1028 basic block. FIXME lto, this is fairly hacky. The existence
1029 of a gimple body is used by the cgraph routines, but we should
1030 really use the presence of the CFG. */
1032 edge_iterator ei
= ei_start (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
);
1033 gimple_set_body (fn_decl
, bb_seq (ei_edge (ei
)->dest
));
1036 fixup_call_stmt_edges (node
, stmts
);
1037 execute_all_ipa_stmt_fixups (node
, stmts
);
1039 update_ssa (TODO_update_ssa_only_virtuals
);
1040 free_dominance_info (CDI_DOMINATORS
);
1041 free_dominance_info (CDI_POST_DOMINATORS
);
1046 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1049 input_constructor (tree var
, struct data_in
*data_in
,
1050 struct lto_input_block
*ib
)
1052 DECL_INITIAL (var
) = stream_read_tree (ib
, data_in
);
1056 /* Read the body from DATA for function NODE and fill it in.
1057 FILE_DATA are the global decls and types. SECTION_TYPE is either
1058 LTO_section_function_body or LTO_section_static_initializer. If
1059 section type is LTO_section_function_body, FN must be the decl for
1063 lto_read_body_or_constructor (struct lto_file_decl_data
*file_data
, struct symtab_node
*node
,
1064 const char *data
, enum lto_section_type section_type
)
1066 const struct lto_function_header
*header
;
1067 struct data_in
*data_in
;
1071 tree fn_decl
= node
->decl
;
1073 header
= (const struct lto_function_header
*) data
;
1074 if (TREE_CODE (node
->decl
) == FUNCTION_DECL
)
1076 cfg_offset
= sizeof (struct lto_function_header
);
1077 main_offset
= cfg_offset
+ header
->cfg_size
;
1078 string_offset
= main_offset
+ header
->main_size
;
1082 main_offset
= sizeof (struct lto_function_header
);
1083 string_offset
= main_offset
+ header
->main_size
;
1086 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
1087 header
->string_size
, vNULL
);
1089 if (section_type
== LTO_section_function_body
)
1091 struct lto_in_decl_state
*decl_state
;
1094 gcc_checking_assert (node
);
1096 /* Use the function's decl state. */
1097 decl_state
= lto_get_function_in_decl_state (file_data
, fn_decl
);
1098 gcc_assert (decl_state
);
1099 file_data
->current_decl_state
= decl_state
;
1102 /* Set up the struct function. */
1103 from
= data_in
->reader_cache
->nodes
.length ();
1104 lto_input_block
ib_main (data
+ main_offset
, header
->main_size
);
1105 if (TREE_CODE (node
->decl
) == FUNCTION_DECL
)
1107 lto_input_block
ib_cfg (data
+ cfg_offset
, header
->cfg_size
);
1108 input_function (fn_decl
, data_in
, &ib_main
, &ib_cfg
);
1111 input_constructor (fn_decl
, data_in
, &ib_main
);
1112 /* And fixup types we streamed locally. */
1114 struct streamer_tree_cache_d
*cache
= data_in
->reader_cache
;
1115 unsigned len
= cache
->nodes
.length ();
1117 for (i
= len
; i
-- > from
;)
1119 tree t
= streamer_tree_cache_get_tree (cache
, i
);
1125 gcc_assert (TYPE_CANONICAL (t
) == NULL_TREE
);
1126 TYPE_CANONICAL (t
) = TYPE_MAIN_VARIANT (t
);
1127 if (TYPE_MAIN_VARIANT (t
) != t
)
1129 gcc_assert (TYPE_NEXT_VARIANT (t
) == NULL_TREE
);
1130 TYPE_NEXT_VARIANT (t
)
1131 = TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t
));
1132 TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t
)) = t
;
1138 /* Restore decl state */
1139 file_data
->current_decl_state
= file_data
->global_decl_state
;
1142 lto_data_in_delete (data_in
);
1146 /* Read the body of NODE using DATA. FILE_DATA holds the global
1150 lto_input_function_body (struct lto_file_decl_data
*file_data
,
1151 struct cgraph_node
*node
, const char *data
)
1153 lto_read_body_or_constructor (file_data
, node
, data
, LTO_section_function_body
);
1156 /* Read the body of NODE using DATA. FILE_DATA holds the global
1160 lto_input_variable_constructor (struct lto_file_decl_data
*file_data
,
1161 struct varpool_node
*node
, const char *data
)
1163 lto_read_body_or_constructor (file_data
, node
, data
, LTO_section_function_body
);
1167 /* Read the physical representation of a tree node EXPR from
1168 input block IB using the per-file context in DATA_IN. */
1171 lto_read_tree_1 (struct lto_input_block
*ib
, struct data_in
*data_in
, tree expr
)
1173 /* Read all the bitfield values in EXPR. Note that for LTO, we
1174 only write language-independent bitfields, so no more unpacking is
1176 streamer_read_tree_bitfields (ib
, data_in
, expr
);
1178 /* Read all the pointer fields in EXPR. */
1179 streamer_read_tree_body (ib
, data_in
, expr
);
1181 /* Read any LTO-specific data not read by the tree streamer. */
1183 && TREE_CODE (expr
) != FUNCTION_DECL
1184 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
1185 DECL_INITIAL (expr
) = stream_read_tree (ib
, data_in
);
1187 /* We should never try to instantiate an MD or NORMAL builtin here. */
1188 if (TREE_CODE (expr
) == FUNCTION_DECL
)
1189 gcc_assert (!streamer_handle_as_builtin_p (expr
));
1191 #ifdef LTO_STREAMER_DEBUG
1192 /* Remove the mapping to RESULT's original address set by
1193 streamer_alloc_tree. */
1194 lto_orig_address_remove (expr
);
1198 /* Read the physical representation of a tree node with tag TAG from
1199 input block IB using the per-file context in DATA_IN. */
1202 lto_read_tree (struct lto_input_block
*ib
, struct data_in
*data_in
,
1203 enum LTO_tags tag
, hashval_t hash
)
1205 /* Instantiate a new tree node. */
1206 tree result
= streamer_alloc_tree (ib
, data_in
, tag
);
1208 /* Enter RESULT in the reader cache. This will make RESULT
1209 available so that circular references in the rest of the tree
1210 structure can be resolved in subsequent calls to stream_read_tree. */
1211 streamer_tree_cache_append (data_in
->reader_cache
, result
, hash
);
1213 lto_read_tree_1 (ib
, data_in
, result
);
1215 /* end_marker = */ streamer_read_uchar (ib
);
1221 /* Populate the reader cache with trees materialized from the SCC
1222 following in the IB, DATA_IN stream. */
1225 lto_input_scc (struct lto_input_block
*ib
, struct data_in
*data_in
,
1226 unsigned *len
, unsigned *entry_len
)
1228 /* A blob of unnamed tree nodes, fill the cache from it and
1230 unsigned size
= streamer_read_uhwi (ib
);
1231 hashval_t scc_hash
= streamer_read_uhwi (ib
);
1232 unsigned scc_entry_len
= 1;
1236 enum LTO_tags tag
= streamer_read_record_start (ib
);
1237 lto_input_tree_1 (ib
, data_in
, tag
, scc_hash
);
1241 unsigned int first
= data_in
->reader_cache
->nodes
.length ();
1244 scc_entry_len
= streamer_read_uhwi (ib
);
1246 /* Materialize size trees by reading their headers. */
1247 for (unsigned i
= 0; i
< size
; ++i
)
1249 enum LTO_tags tag
= streamer_read_record_start (ib
);
1251 || (tag
>= LTO_field_decl_ref
&& tag
<= LTO_global_decl_ref
)
1252 || tag
== LTO_tree_pickle_reference
1253 || tag
== LTO_builtin_decl
1254 || tag
== LTO_integer_cst
1255 || tag
== LTO_tree_scc
)
1258 result
= streamer_alloc_tree (ib
, data_in
, tag
);
1259 streamer_tree_cache_append (data_in
->reader_cache
, result
, 0);
1262 /* Read the tree bitpacks and references. */
1263 for (unsigned i
= 0; i
< size
; ++i
)
1265 result
= streamer_tree_cache_get_tree (data_in
->reader_cache
,
1267 lto_read_tree_1 (ib
, data_in
, result
);
1268 /* end_marker = */ streamer_read_uchar (ib
);
1273 *entry_len
= scc_entry_len
;
1278 /* Read a tree from input block IB using the per-file context in
1279 DATA_IN. This context is used, for example, to resolve references
1280 to previously read nodes. */
1283 lto_input_tree_1 (struct lto_input_block
*ib
, struct data_in
*data_in
,
1284 enum LTO_tags tag
, hashval_t hash
)
1288 gcc_assert ((unsigned) tag
< (unsigned) LTO_NUM_TAGS
);
1290 if (tag
== LTO_null
)
1292 else if (tag
>= LTO_field_decl_ref
&& tag
<= LTO_namelist_decl_ref
)
1294 /* If TAG is a reference to an indexable tree, the next value
1295 in IB is the index into the table where we expect to find
1297 result
= lto_input_tree_ref (ib
, data_in
, cfun
, tag
);
1299 else if (tag
== LTO_tree_pickle_reference
)
1301 /* If TAG is a reference to a previously read tree, look it up in
1302 the reader cache. */
1303 result
= streamer_get_pickled_tree (ib
, data_in
);
1305 else if (tag
== LTO_builtin_decl
)
1307 /* If we are going to read a built-in function, all we need is
1308 the code and class. */
1309 result
= streamer_get_builtin_tree (ib
, data_in
);
1311 else if (tag
== LTO_integer_cst
)
1313 /* For shared integer constants in singletons we can use the
1314 existing tree integer constant merging code. */
1315 tree type
= stream_read_tree (ib
, data_in
);
1316 unsigned HOST_WIDE_INT len
= streamer_read_uhwi (ib
);
1317 unsigned HOST_WIDE_INT i
;
1318 HOST_WIDE_INT a
[WIDE_INT_MAX_ELTS
];
1320 for (i
= 0; i
< len
; i
++)
1321 a
[i
] = streamer_read_hwi (ib
);
1322 gcc_assert (TYPE_PRECISION (type
) <= MAX_BITSIZE_MODE_ANY_INT
);
1323 result
= wide_int_to_tree (type
, wide_int::from_array
1324 (a
, len
, TYPE_PRECISION (type
)));
1325 streamer_tree_cache_append (data_in
->reader_cache
, result
, hash
);
1327 else if (tag
== LTO_tree_scc
)
1331 /* Otherwise, materialize a new node from IB. */
1332 result
= lto_read_tree (ib
, data_in
, tag
, hash
);
1339 lto_input_tree (struct lto_input_block
*ib
, struct data_in
*data_in
)
1343 /* Input and skip SCCs. */
1344 while ((tag
= streamer_read_record_start (ib
)) == LTO_tree_scc
)
1346 unsigned len
, entry_len
;
1347 lto_input_scc (ib
, data_in
, &len
, &entry_len
);
1349 return lto_input_tree_1 (ib
, data_in
, tag
, 0);
1353 /* Input toplevel asms. */
1356 lto_input_toplevel_asms (struct lto_file_decl_data
*file_data
, int order_base
)
1359 const char *data
= lto_get_section_data (file_data
, LTO_section_asm
,
1361 const struct lto_simple_header_with_strings
*header
1362 = (const struct lto_simple_header_with_strings
*) data
;
1364 struct data_in
*data_in
;
1370 string_offset
= sizeof (*header
) + header
->main_size
;
1372 lto_input_block
ib (data
+ sizeof (*header
), header
->main_size
);
1374 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
1375 header
->string_size
, vNULL
);
1377 while ((str
= streamer_read_string_cst (data_in
, &ib
)))
1379 asm_node
*node
= symtab
->finalize_toplevel_asm (str
);
1380 node
->order
= streamer_read_hwi (&ib
) + order_base
;
1381 if (node
->order
>= symtab
->order
)
1382 symtab
->order
= node
->order
+ 1;
1385 lto_data_in_delete (data_in
);
1387 lto_free_section_data (file_data
, LTO_section_asm
, NULL
, data
, len
);
1391 /* Initialization for the LTO reader. */
1394 lto_reader_init (void)
1396 lto_streamer_init ();
1397 file_name_hash_table
1398 = new hash_table
<freeing_string_slot_hasher
> (37);
1402 /* Create a new data_in object for FILE_DATA. STRINGS is the string
1403 table to use with LEN strings. RESOLUTIONS is the vector of linker
1404 resolutions (NULL if not using a linker plugin). */
1407 lto_data_in_create (struct lto_file_decl_data
*file_data
, const char *strings
,
1409 vec
<ld_plugin_symbol_resolution_t
> resolutions
)
1411 struct data_in
*data_in
= XCNEW (struct data_in
);
1412 data_in
->file_data
= file_data
;
1413 data_in
->strings
= strings
;
1414 data_in
->strings_len
= len
;
1415 data_in
->globals_resolution
= resolutions
;
1416 data_in
->reader_cache
= streamer_tree_cache_create (false, false, true);
1421 /* Remove DATA_IN. */
1424 lto_data_in_delete (struct data_in
*data_in
)
1426 data_in
->globals_resolution
.release ();
1427 streamer_tree_cache_delete (data_in
->reader_cache
);