1 /* Read the GIMPLE representation from a file stream.
3 Copyright (C) 2009-2020 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"
32 #include "tree-pass.h"
34 #include "gimple-streamer.h"
36 #include "gimple-iterator.h"
38 #include "tree-into-ssa.h"
45 #include "alloc-pool.h"
47 /* Allocator used to hold string slot entries for line map streaming. */
48 static struct object_allocator
<struct string_slot
> *string_slot_allocator
;
50 /* The table to hold the file names. */
51 static hash_table
<string_slot_hasher
> *file_name_hash_table
;
53 /* This obstack holds file names used in locators. Line map datastructures
54 points here and thus it needs to be kept allocated as long as linemaps
56 static struct obstack file_name_obstack
;
59 /* Check that tag ACTUAL has one of the given values. NUM_TAGS is the
60 number of valid tag values to check. */
63 lto_tag_check_set (enum LTO_tags actual
, int ntags
, ...)
69 for (i
= 0; i
< ntags
; i
++)
70 if ((unsigned) actual
== va_arg (ap
, unsigned))
77 internal_error ("bytecode stream: unexpected tag %s", lto_tag_name (actual
));
81 /* Read LENGTH bytes from STREAM to ADDR. */
84 lto_input_data_block (class lto_input_block
*ib
, void *addr
, size_t length
)
87 unsigned char *const buffer
= (unsigned char *) addr
;
89 for (i
= 0; i
< length
; i
++)
90 buffer
[i
] = streamer_read_uchar (ib
);
94 /* Lookup STRING in file_name_hash_table. If found, return the existing
95 string, otherwise insert STRING as the canonical version. */
98 canon_file_name (const char *string
)
101 struct string_slot s_slot
;
102 size_t len
= strlen (string
);
107 slot
= file_name_hash_table
->find_slot (&s_slot
, INSERT
);
111 struct string_slot
*new_slot
;
113 saved_string
= XOBNEWVEC (&file_name_obstack
, char, len
+ 1);
114 new_slot
= string_slot_allocator
->allocate ();
115 memcpy (saved_string
, string
, len
+ 1);
116 new_slot
->s
= saved_string
;
123 struct string_slot
*old_slot
= *slot
;
128 /* Pointer to currently alive instance of lto_location_cache. */
130 lto_location_cache
*lto_location_cache::current_cache
;
132 /* Sort locations in source order. Start with file from last application. */
135 lto_location_cache::cmp_loc (const void *pa
, const void *pb
)
137 const cached_location
*a
= ((const cached_location
*)pa
);
138 const cached_location
*b
= ((const cached_location
*)pb
);
139 const char *current_file
= current_cache
->current_file
;
140 int current_line
= current_cache
->current_line
;
142 if (a
->file
== current_file
&& b
->file
!= current_file
)
144 if (a
->file
!= current_file
&& b
->file
== current_file
)
146 if (a
->file
== current_file
&& b
->file
== current_file
)
148 if (a
->line
== current_line
&& b
->line
!= current_line
)
150 if (a
->line
!= current_line
&& b
->line
== current_line
)
153 if (a
->file
!= b
->file
)
154 return strcmp (a
->file
, b
->file
);
155 if (a
->sysp
!= b
->sysp
)
156 return a
->sysp
? 1 : -1;
157 if (a
->line
!= b
->line
)
158 return a
->line
- b
->line
;
159 return a
->col
- b
->col
;
162 /* Apply all changes in location cache. Add locations into linemap and patch
166 lto_location_cache::apply_location_cache ()
168 static const char *prev_file
;
169 if (!loc_cache
.length ())
171 if (loc_cache
.length () > 1)
172 loc_cache
.qsort (cmp_loc
);
174 for (unsigned int i
= 0; i
< loc_cache
.length (); i
++)
176 struct cached_location loc
= loc_cache
[i
];
178 if (current_file
!= loc
.file
)
179 linemap_add (line_table
, prev_file
? LC_RENAME
: LC_ENTER
,
180 loc
.sysp
, loc
.file
, loc
.line
);
181 else if (current_line
!= loc
.line
)
185 for (unsigned int j
= i
+ 1; j
< loc_cache
.length (); j
++)
186 if (loc
.file
!= loc_cache
[j
].file
187 || loc
.line
!= loc_cache
[j
].line
)
189 else if (max
< loc_cache
[j
].col
)
190 max
= loc_cache
[j
].col
;
191 linemap_line_start (line_table
, loc
.line
, max
+ 1);
193 gcc_assert (*loc
.loc
== BUILTINS_LOCATION
+ 1);
194 if (current_file
== loc
.file
&& current_line
== loc
.line
195 && current_col
== loc
.col
)
196 *loc
.loc
= current_loc
;
198 current_loc
= *loc
.loc
= linemap_position_for_column (line_table
,
200 current_line
= loc
.line
;
201 prev_file
= current_file
= loc
.file
;
202 current_col
= loc
.col
;
204 loc_cache
.truncate (0);
209 /* Tree merging did not suceed; mark all changes in the cache as accepted. */
212 lto_location_cache::accept_location_cache ()
214 gcc_assert (current_cache
== this);
215 accepted_length
= loc_cache
.length ();
218 /* Tree merging did suceed; throw away recent changes. */
221 lto_location_cache::revert_location_cache ()
223 loc_cache
.truncate (accepted_length
);
226 /* Read a location bitpack from input block IB and either update *LOC directly
227 or add it to the location cache.
228 It is neccesary to call apply_location_cache to get *LOC updated. */
231 lto_location_cache::input_location (location_t
*loc
, struct bitpack_d
*bp
,
232 class data_in
*data_in
)
234 static const char *stream_file
;
235 static int stream_line
;
236 static int stream_col
;
237 static bool stream_sysp
;
238 bool file_change
, line_change
, column_change
;
240 gcc_assert (current_cache
== this);
242 *loc
= bp_unpack_int_in_range (bp
, "location", 0, RESERVED_LOCATION_COUNT
);
244 if (*loc
< RESERVED_LOCATION_COUNT
)
247 /* Keep value RESERVED_LOCATION_COUNT in *loc as linemap lookups will
250 file_change
= bp_unpack_value (bp
, 1);
251 line_change
= bp_unpack_value (bp
, 1);
252 column_change
= bp_unpack_value (bp
, 1);
256 stream_file
= canon_file_name (bp_unpack_string (data_in
, bp
));
257 stream_sysp
= bp_unpack_value (bp
, 1);
261 stream_line
= bp_unpack_var_len_unsigned (bp
);
264 stream_col
= bp_unpack_var_len_unsigned (bp
);
266 /* This optimization saves location cache operations druing gimple
269 if (current_file
== stream_file
&& current_line
== stream_line
270 && current_col
== stream_col
&& current_sysp
== stream_sysp
)
276 struct cached_location entry
277 = {stream_file
, loc
, stream_line
, stream_col
, stream_sysp
};
278 loc_cache
.safe_push (entry
);
281 /* Read a location bitpack from input block IB and either update *LOC directly
282 or add it to the location cache.
283 It is neccesary to call apply_location_cache to get *LOC updated. */
286 lto_input_location (location_t
*loc
, struct bitpack_d
*bp
,
287 class data_in
*data_in
)
289 data_in
->location_cache
.input_location (loc
, bp
, data_in
);
292 /* Read location and return it instead of going through location caching.
293 This should be used only when the resulting location is not going to be
297 stream_input_location_now (struct bitpack_d
*bp
, class data_in
*data_in
)
300 stream_input_location (&loc
, bp
, data_in
);
301 data_in
->location_cache
.apply_location_cache ();
305 /* Read a reference to a tree node from DATA_IN using input block IB.
306 TAG is the expected node that should be found in IB, if TAG belongs
307 to one of the indexable trees, expect to read a reference index to
308 be looked up in one of the symbol tables, otherwise read the pysical
309 representation of the tree using stream_read_tree. FN is the
310 function scope for the read tree. */
313 lto_input_tree_ref (class lto_input_block
*ib
, class data_in
*data_in
,
314 struct function
*fn
, enum LTO_tags tag
)
316 unsigned HOST_WIDE_INT ix_u
;
317 tree result
= NULL_TREE
;
319 lto_tag_check_range (tag
, LTO_field_decl_ref
, LTO_namelist_decl_ref
);
324 ix_u
= streamer_read_uhwi (ib
);
325 result
= lto_file_decl_data_get_type (data_in
->file_data
, ix_u
);
328 case LTO_ssa_name_ref
:
329 ix_u
= streamer_read_uhwi (ib
);
330 result
= (*SSANAMES (fn
))[ix_u
];
333 case LTO_field_decl_ref
:
334 ix_u
= streamer_read_uhwi (ib
);
335 result
= lto_file_decl_data_get_field_decl (data_in
->file_data
, ix_u
);
338 case LTO_function_decl_ref
:
339 ix_u
= streamer_read_uhwi (ib
);
340 result
= lto_file_decl_data_get_fn_decl (data_in
->file_data
, ix_u
);
343 case LTO_type_decl_ref
:
344 ix_u
= streamer_read_uhwi (ib
);
345 result
= lto_file_decl_data_get_type_decl (data_in
->file_data
, ix_u
);
348 case LTO_namespace_decl_ref
:
349 ix_u
= streamer_read_uhwi (ib
);
350 result
= lto_file_decl_data_get_namespace_decl (data_in
->file_data
, ix_u
);
353 case LTO_global_decl_ref
:
354 case LTO_result_decl_ref
:
355 case LTO_const_decl_ref
:
356 case LTO_imported_decl_ref
:
357 case LTO_label_decl_ref
:
358 case LTO_translation_unit_decl_ref
:
359 case LTO_namelist_decl_ref
:
360 ix_u
= streamer_read_uhwi (ib
);
361 result
= lto_file_decl_data_get_var_decl (data_in
->file_data
, ix_u
);
374 /* Read and return a double-linked list of catch handlers from input
375 block IB, using descriptors in DATA_IN. */
377 static struct eh_catch_d
*
378 lto_input_eh_catch_list (class lto_input_block
*ib
, class data_in
*data_in
,
384 *last_p
= first
= NULL
;
385 tag
= streamer_read_record_start (ib
);
391 lto_tag_check_range (tag
, LTO_eh_catch
, LTO_eh_catch
);
393 /* Read the catch node. */
394 n
= ggc_cleared_alloc
<eh_catch_d
> ();
395 n
->type_list
= stream_read_tree (ib
, data_in
);
396 n
->filter_list
= stream_read_tree (ib
, data_in
);
397 n
->label
= stream_read_tree (ib
, data_in
);
399 /* Register all the types in N->FILTER_LIST. */
400 for (list
= n
->filter_list
; list
; list
= TREE_CHAIN (list
))
401 add_type_for_runtime (TREE_VALUE (list
));
403 /* Chain N to the end of the list. */
405 (*last_p
)->next_catch
= n
;
406 n
->prev_catch
= *last_p
;
409 /* Set the head of the list the first time through the loop. */
413 tag
= streamer_read_record_start (ib
);
420 /* Read and return EH region IX from input block IB, using descriptors
424 input_eh_region (class lto_input_block
*ib
, class data_in
*data_in
, int ix
)
429 /* Read the region header. */
430 tag
= streamer_read_record_start (ib
);
434 r
= ggc_cleared_alloc
<eh_region_d
> ();
435 r
->index
= streamer_read_hwi (ib
);
437 gcc_assert (r
->index
== ix
);
439 /* Read all the region pointers as region numbers. We'll fix up
440 the pointers once the whole array has been read. */
441 r
->outer
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
442 r
->inner
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
443 r
->next_peer
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
447 case LTO_ert_cleanup
:
448 r
->type
= ERT_CLEANUP
;
453 struct eh_catch_d
*last_catch
;
455 r
->u
.eh_try
.first_catch
= lto_input_eh_catch_list (ib
, data_in
,
457 r
->u
.eh_try
.last_catch
= last_catch
;
461 case LTO_ert_allowed_exceptions
:
465 r
->type
= ERT_ALLOWED_EXCEPTIONS
;
466 r
->u
.allowed
.type_list
= stream_read_tree (ib
, data_in
);
467 r
->u
.allowed
.label
= stream_read_tree (ib
, data_in
);
468 r
->u
.allowed
.filter
= streamer_read_uhwi (ib
);
470 for (l
= r
->u
.allowed
.type_list
; l
; l
= TREE_CHAIN (l
))
471 add_type_for_runtime (TREE_VALUE (l
));
475 case LTO_ert_must_not_throw
:
477 r
->type
= ERT_MUST_NOT_THROW
;
478 r
->u
.must_not_throw
.failure_decl
= stream_read_tree (ib
, data_in
);
479 bitpack_d bp
= streamer_read_bitpack (ib
);
480 r
->u
.must_not_throw
.failure_loc
481 = stream_input_location_now (&bp
, data_in
);
489 r
->landing_pads
= (eh_landing_pad
) (intptr_t) streamer_read_hwi (ib
);
495 /* Read and return EH landing pad IX from input block IB, using descriptors
498 static eh_landing_pad
499 input_eh_lp (class lto_input_block
*ib
, class data_in
*data_in
, int ix
)
504 /* Read the landing pad header. */
505 tag
= streamer_read_record_start (ib
);
509 lto_tag_check_range (tag
, LTO_eh_landing_pad
, LTO_eh_landing_pad
);
511 lp
= ggc_cleared_alloc
<eh_landing_pad_d
> ();
512 lp
->index
= streamer_read_hwi (ib
);
513 gcc_assert (lp
->index
== ix
);
514 lp
->next_lp
= (eh_landing_pad
) (intptr_t) streamer_read_hwi (ib
);
515 lp
->region
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
516 lp
->post_landing_pad
= stream_read_tree (ib
, data_in
);
522 /* After reading the EH regions, pointers to peer and children regions
523 are region numbers. This converts all these region numbers into
524 real pointers into the rematerialized regions for FN. ROOT_REGION
525 is the region number for the root EH region in FN. */
528 fixup_eh_region_pointers (struct function
*fn
, HOST_WIDE_INT root_region
)
531 vec
<eh_region
, va_gc
> *eh_array
= fn
->eh
->region_array
;
532 vec
<eh_landing_pad
, va_gc
> *lp_array
= fn
->eh
->lp_array
;
536 gcc_assert (eh_array
&& lp_array
);
538 gcc_assert (root_region
>= 0);
539 fn
->eh
->region_tree
= (*eh_array
)[root_region
];
541 #define FIXUP_EH_REGION(r) (r) = (*eh_array)[(HOST_WIDE_INT) (intptr_t) (r)]
542 #define FIXUP_EH_LP(p) (p) = (*lp_array)[(HOST_WIDE_INT) (intptr_t) (p)]
544 /* Convert all the index numbers stored in pointer fields into
545 pointers to the corresponding slots in the EH region array. */
546 FOR_EACH_VEC_ELT (*eh_array
, i
, r
)
548 /* The array may contain NULL regions. */
552 gcc_assert (i
== (unsigned) r
->index
);
553 FIXUP_EH_REGION (r
->outer
);
554 FIXUP_EH_REGION (r
->inner
);
555 FIXUP_EH_REGION (r
->next_peer
);
556 FIXUP_EH_LP (r
->landing_pads
);
559 /* Convert all the index numbers stored in pointer fields into
560 pointers to the corresponding slots in the EH landing pad array. */
561 FOR_EACH_VEC_ELT (*lp_array
, i
, lp
)
563 /* The array may contain NULL landing pads. */
567 gcc_assert (i
== (unsigned) lp
->index
);
568 FIXUP_EH_LP (lp
->next_lp
);
569 FIXUP_EH_REGION (lp
->region
);
572 #undef FIXUP_EH_REGION
577 /* Initialize EH support. */
582 static bool eh_initialized_p
= false;
584 if (eh_initialized_p
)
587 /* Contrary to most other FEs, we only initialize EH support when at
588 least one of the files in the set contains exception regions in
589 it. Since this happens much later than the call to init_eh in
590 lang_dependent_init, we have to set flag_exceptions and call
591 init_eh again to initialize the EH tables. */
595 eh_initialized_p
= true;
599 /* Read the exception table for FN from IB using the data descriptors
603 input_eh_regions (class lto_input_block
*ib
, class data_in
*data_in
,
606 HOST_WIDE_INT i
, root_region
, len
;
609 tag
= streamer_read_record_start (ib
);
613 lto_tag_check_range (tag
, LTO_eh_table
, LTO_eh_table
);
617 root_region
= streamer_read_hwi (ib
);
618 gcc_assert (root_region
== (int) root_region
);
620 /* Read the EH region array. */
621 len
= streamer_read_hwi (ib
);
622 gcc_assert (len
== (int) len
);
625 vec_safe_grow_cleared (fn
->eh
->region_array
, len
);
626 for (i
= 0; i
< len
; i
++)
628 eh_region r
= input_eh_region (ib
, data_in
, i
);
629 (*fn
->eh
->region_array
)[i
] = r
;
633 /* Read the landing pads. */
634 len
= streamer_read_hwi (ib
);
635 gcc_assert (len
== (int) len
);
638 vec_safe_grow_cleared (fn
->eh
->lp_array
, len
);
639 for (i
= 0; i
< len
; i
++)
641 eh_landing_pad lp
= input_eh_lp (ib
, data_in
, i
);
642 (*fn
->eh
->lp_array
)[i
] = lp
;
646 /* Read the runtime type data. */
647 len
= streamer_read_hwi (ib
);
648 gcc_assert (len
== (int) len
);
651 vec_safe_grow_cleared (fn
->eh
->ttype_data
, len
);
652 for (i
= 0; i
< len
; i
++)
654 tree ttype
= stream_read_tree (ib
, data_in
);
655 (*fn
->eh
->ttype_data
)[i
] = ttype
;
659 /* Read the table of action chains. */
660 len
= streamer_read_hwi (ib
);
661 gcc_assert (len
== (int) len
);
664 if (targetm
.arm_eabi_unwinder
)
666 vec_safe_grow_cleared (fn
->eh
->ehspec_data
.arm_eabi
, len
);
667 for (i
= 0; i
< len
; i
++)
669 tree t
= stream_read_tree (ib
, data_in
);
670 (*fn
->eh
->ehspec_data
.arm_eabi
)[i
] = t
;
675 vec_safe_grow_cleared (fn
->eh
->ehspec_data
.other
, len
);
676 for (i
= 0; i
< len
; i
++)
678 uchar c
= streamer_read_uchar (ib
);
679 (*fn
->eh
->ehspec_data
.other
)[i
] = c
;
684 /* Reconstruct the EH region tree by fixing up the peer/children
686 fixup_eh_region_pointers (fn
, root_region
);
688 tag
= streamer_read_record_start (ib
);
689 lto_tag_check_range (tag
, LTO_null
, LTO_null
);
693 /* Make a new basic block with index INDEX in function FN. */
696 make_new_block (struct function
*fn
, unsigned int index
)
698 basic_block bb
= alloc_block ();
700 SET_BASIC_BLOCK_FOR_FN (fn
, index
, bb
);
701 n_basic_blocks_for_fn (fn
)++;
706 /* Read the CFG for function FN from input block IB. */
709 input_cfg (class lto_input_block
*ib
, class data_in
*data_in
,
712 unsigned int bb_count
;
717 init_empty_tree_cfg_for_function (fn
);
718 init_ssa_operands (fn
);
720 profile_status_for_fn (fn
) = streamer_read_enum (ib
, profile_status_d
,
723 bb_count
= streamer_read_uhwi (ib
);
725 last_basic_block_for_fn (fn
) = bb_count
;
726 if (bb_count
> basic_block_info_for_fn (fn
)->length ())
727 vec_safe_grow_cleared (basic_block_info_for_fn (fn
), bb_count
);
729 if (bb_count
> label_to_block_map_for_fn (fn
)->length ())
730 vec_safe_grow_cleared (label_to_block_map_for_fn (fn
), bb_count
);
732 index
= streamer_read_hwi (ib
);
735 basic_block bb
= BASIC_BLOCK_FOR_FN (fn
, index
);
736 unsigned int edge_count
;
739 bb
= make_new_block (fn
, index
);
741 edge_count
= streamer_read_uhwi (ib
);
743 /* Connect up the CFG. */
744 for (i
= 0; i
< edge_count
; i
++)
746 unsigned int dest_index
;
747 unsigned int edge_flags
;
749 profile_probability probability
;
752 dest_index
= streamer_read_uhwi (ib
);
753 probability
= profile_probability::stream_in (ib
);
754 edge_flags
= streamer_read_uhwi (ib
);
756 dest
= BASIC_BLOCK_FOR_FN (fn
, dest_index
);
759 dest
= make_new_block (fn
, dest_index
);
761 e
= make_edge (bb
, dest
, edge_flags
);
762 e
->probability
= probability
;
765 index
= streamer_read_hwi (ib
);
768 p_bb
= ENTRY_BLOCK_PTR_FOR_FN (fn
);
769 index
= streamer_read_hwi (ib
);
772 basic_block bb
= BASIC_BLOCK_FOR_FN (fn
, index
);
776 index
= streamer_read_hwi (ib
);
779 /* ??? The cfgloop interface is tied to cfun. */
780 gcc_assert (cfun
== fn
);
782 /* Input the loop tree. */
783 unsigned n_loops
= streamer_read_uhwi (ib
);
787 struct loops
*loops
= ggc_cleared_alloc
<struct loops
> ();
788 init_loops_structure (fn
, loops
, n_loops
);
789 set_loops_for_fn (fn
, loops
);
791 /* Input each loop and associate it with its loop header so
792 flow_loops_find can rebuild the loop tree. */
793 for (unsigned i
= 1; i
< n_loops
; ++i
)
795 int header_index
= streamer_read_hwi (ib
);
796 if (header_index
== -1)
798 loops
->larray
->quick_push (NULL
);
802 class loop
*loop
= alloc_loop ();
803 loop
->header
= BASIC_BLOCK_FOR_FN (fn
, header_index
);
804 loop
->header
->loop_father
= loop
;
806 /* Read everything copy_loop_info copies. */
807 loop
->estimate_state
= streamer_read_enum (ib
, loop_estimation
, EST_LAST
);
808 loop
->any_upper_bound
= streamer_read_hwi (ib
);
809 if (loop
->any_upper_bound
)
810 loop
->nb_iterations_upper_bound
= streamer_read_widest_int (ib
);
811 loop
->any_likely_upper_bound
= streamer_read_hwi (ib
);
812 if (loop
->any_likely_upper_bound
)
813 loop
->nb_iterations_likely_upper_bound
= streamer_read_widest_int (ib
);
814 loop
->any_estimate
= streamer_read_hwi (ib
);
815 if (loop
->any_estimate
)
816 loop
->nb_iterations_estimate
= streamer_read_widest_int (ib
);
818 /* Read OMP SIMD related info. */
819 loop
->safelen
= streamer_read_hwi (ib
);
820 loop
->unroll
= streamer_read_hwi (ib
);
821 loop
->owned_clique
= streamer_read_hwi (ib
);
822 loop
->dont_vectorize
= streamer_read_hwi (ib
);
823 loop
->force_vectorize
= streamer_read_hwi (ib
);
824 loop
->finite_p
= streamer_read_hwi (ib
);
825 loop
->simduid
= stream_read_tree (ib
, data_in
);
827 place_new_loop (fn
, loop
);
829 /* flow_loops_find doesn't like loops not in the tree, hook them
830 all as siblings of the tree root temporarily. */
831 flow_loop_tree_node_add (loops
->tree_root
, loop
);
834 /* Rebuild the loop tree. */
835 flow_loops_find (loops
);
839 /* Read the SSA names array for function FN from DATA_IN using input
843 input_ssa_names (class lto_input_block
*ib
, class data_in
*data_in
,
846 unsigned int i
, size
;
848 size
= streamer_read_uhwi (ib
);
849 init_ssanames (fn
, size
);
851 i
= streamer_read_uhwi (ib
);
857 /* Skip over the elements that had been freed. */
858 while (SSANAMES (fn
)->length () < i
)
859 SSANAMES (fn
)->quick_push (NULL_TREE
);
861 is_default_def
= (streamer_read_uchar (ib
) != 0);
862 name
= stream_read_tree (ib
, data_in
);
863 ssa_name
= make_ssa_name_fn (fn
, name
, NULL
);
867 set_ssa_default_def (cfun
, SSA_NAME_VAR (ssa_name
), ssa_name
);
868 SSA_NAME_DEF_STMT (ssa_name
) = gimple_build_nop ();
871 i
= streamer_read_uhwi (ib
);
876 /* Go through all NODE edges and fixup call_stmt pointers
877 so they point to STMTS. */
880 fixup_call_stmt_edges_1 (struct cgraph_node
*node
, gimple
**stmts
,
883 #define STMT_UID_NOT_IN_RANGE(uid) \
884 (gimple_stmt_max_uid (fn) < uid || uid == 0)
886 struct cgraph_edge
*cedge
;
887 struct ipa_ref
*ref
= NULL
;
890 for (cedge
= node
->callees
; cedge
; cedge
= cedge
->next_callee
)
892 if (STMT_UID_NOT_IN_RANGE (cedge
->lto_stmt_uid
))
893 fatal_error (input_location
,
894 "Cgraph edge statement index out of range");
895 cedge
->call_stmt
= as_a
<gcall
*> (stmts
[cedge
->lto_stmt_uid
- 1]);
896 cedge
->lto_stmt_uid
= 0;
897 if (!cedge
->call_stmt
)
898 fatal_error (input_location
,
899 "Cgraph edge statement index not found");
901 for (cedge
= node
->indirect_calls
; cedge
; cedge
= cedge
->next_callee
)
903 if (STMT_UID_NOT_IN_RANGE (cedge
->lto_stmt_uid
))
904 fatal_error (input_location
,
905 "Cgraph edge statement index out of range");
906 cedge
->call_stmt
= as_a
<gcall
*> (stmts
[cedge
->lto_stmt_uid
- 1]);
907 cedge
->lto_stmt_uid
= 0;
908 if (!cedge
->call_stmt
)
909 fatal_error (input_location
, "Cgraph edge statement index not found");
911 for (i
= 0; node
->iterate_reference (i
, ref
); i
++)
912 if (ref
->lto_stmt_uid
)
914 if (STMT_UID_NOT_IN_RANGE (ref
->lto_stmt_uid
))
915 fatal_error (input_location
,
916 "Reference statement index out of range");
917 ref
->stmt
= stmts
[ref
->lto_stmt_uid
- 1];
918 ref
->lto_stmt_uid
= 0;
920 fatal_error (input_location
, "Reference statement index not found");
925 /* Fixup call_stmt pointers in NODE and all clones. */
928 fixup_call_stmt_edges (struct cgraph_node
*orig
, gimple
**stmts
)
930 struct cgraph_node
*node
;
933 while (orig
->clone_of
)
934 orig
= orig
->clone_of
;
935 fn
= DECL_STRUCT_FUNCTION (orig
->decl
);
937 if (!orig
->thunk
.thunk_p
)
938 fixup_call_stmt_edges_1 (orig
, stmts
, fn
);
940 for (node
= orig
->clones
; node
!= orig
;)
942 if (!node
->thunk
.thunk_p
)
943 fixup_call_stmt_edges_1 (node
, stmts
, fn
);
946 else if (node
->next_sibling_clone
)
947 node
= node
->next_sibling_clone
;
950 while (node
!= orig
&& !node
->next_sibling_clone
)
951 node
= node
->clone_of
;
953 node
= node
->next_sibling_clone
;
959 /* Input the base body of struct function FN from DATA_IN
960 using input block IB. */
963 input_struct_function_base (struct function
*fn
, class data_in
*data_in
,
964 class lto_input_block
*ib
)
969 /* Read the static chain and non-local goto save area. */
970 fn
->static_chain_decl
= stream_read_tree (ib
, data_in
);
971 fn
->nonlocal_goto_save_area
= stream_read_tree (ib
, data_in
);
973 /* Read all the local symbols. */
974 len
= streamer_read_hwi (ib
);
978 vec_safe_grow_cleared (fn
->local_decls
, len
);
979 for (i
= 0; i
< len
; i
++)
981 tree t
= stream_read_tree (ib
, data_in
);
982 (*fn
->local_decls
)[i
] = t
;
986 /* Input the current IL state of the function. */
987 fn
->curr_properties
= streamer_read_uhwi (ib
);
989 /* Read all the attributes for FN. */
990 bp
= streamer_read_bitpack (ib
);
991 fn
->is_thunk
= bp_unpack_value (&bp
, 1);
992 fn
->has_local_explicit_reg_vars
= bp_unpack_value (&bp
, 1);
993 fn
->returns_pcc_struct
= bp_unpack_value (&bp
, 1);
994 fn
->returns_struct
= bp_unpack_value (&bp
, 1);
995 fn
->can_throw_non_call_exceptions
= bp_unpack_value (&bp
, 1);
996 fn
->can_delete_dead_exceptions
= bp_unpack_value (&bp
, 1);
997 fn
->always_inline_functions_inlined
= bp_unpack_value (&bp
, 1);
998 fn
->after_inlining
= bp_unpack_value (&bp
, 1);
999 fn
->stdarg
= bp_unpack_value (&bp
, 1);
1000 fn
->has_nonlocal_label
= bp_unpack_value (&bp
, 1);
1001 fn
->has_forced_label_in_static
= bp_unpack_value (&bp
, 1);
1002 fn
->calls_alloca
= bp_unpack_value (&bp
, 1);
1003 fn
->calls_setjmp
= bp_unpack_value (&bp
, 1);
1004 fn
->calls_eh_return
= bp_unpack_value (&bp
, 1);
1005 fn
->has_force_vectorize_loops
= bp_unpack_value (&bp
, 1);
1006 fn
->has_simduid_loops
= bp_unpack_value (&bp
, 1);
1007 fn
->va_list_fpr_size
= bp_unpack_value (&bp
, 8);
1008 fn
->va_list_gpr_size
= bp_unpack_value (&bp
, 8);
1009 fn
->last_clique
= bp_unpack_value (&bp
, sizeof (short) * 8);
1011 /* Input the function start and end loci. */
1012 fn
->function_start_locus
= stream_input_location_now (&bp
, data_in
);
1013 fn
->function_end_locus
= stream_input_location_now (&bp
, data_in
);
1015 /* Restore the instance discriminators if present. */
1016 int instance_number
= bp_unpack_value (&bp
, 1);
1017 if (instance_number
)
1019 instance_number
= bp_unpack_value (&bp
, sizeof (int) * CHAR_BIT
);
1020 maybe_create_decl_to_instance_map ()->put (fn
->decl
, instance_number
);
1025 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1028 input_function (tree fn_decl
, class data_in
*data_in
,
1029 class lto_input_block
*ib
, class lto_input_block
*ib_cfg
,
1032 struct function
*fn
;
1037 tag
= streamer_read_record_start (ib
);
1038 lto_tag_check (tag
, LTO_function
);
1040 /* Read decls for parameters and args. */
1041 DECL_RESULT (fn_decl
) = stream_read_tree (ib
, data_in
);
1042 DECL_ARGUMENTS (fn_decl
) = streamer_read_chain (ib
, data_in
);
1044 /* Read debug args if available. */
1045 unsigned n_debugargs
= streamer_read_uhwi (ib
);
1048 vec
<tree
, va_gc
> **debugargs
= decl_debug_args_insert (fn_decl
);
1049 vec_safe_grow (*debugargs
, n_debugargs
);
1050 for (unsigned i
= 0; i
< n_debugargs
; ++i
)
1051 (**debugargs
)[i
] = stream_read_tree (ib
, data_in
);
1054 /* Read the tree of lexical scopes for the function. */
1055 DECL_INITIAL (fn_decl
) = stream_read_tree (ib
, data_in
);
1056 unsigned block_leaf_count
= streamer_read_uhwi (ib
);
1057 while (block_leaf_count
--)
1058 stream_read_tree (ib
, data_in
);
1060 if (!streamer_read_uhwi (ib
))
1063 push_struct_function (fn_decl
);
1064 fn
= DECL_STRUCT_FUNCTION (fn_decl
);
1066 /* We input IL in SSA form. */
1067 cfun
->gimple_df
->in_ssa_p
= true;
1069 gimple_register_cfg_hooks ();
1071 input_struct_function_base (fn
, data_in
, ib
);
1072 input_cfg (ib_cfg
, data_in
, fn
);
1074 /* Read all the SSA names. */
1075 input_ssa_names (ib
, data_in
, fn
);
1077 /* Read the exception handling regions in the function. */
1078 input_eh_regions (ib
, data_in
, fn
);
1080 gcc_assert (DECL_INITIAL (fn_decl
));
1081 DECL_SAVED_TREE (fn_decl
) = NULL_TREE
;
1083 /* Read all the basic blocks. */
1084 tag
= streamer_read_record_start (ib
);
1087 input_bb (ib
, tag
, data_in
, fn
,
1088 node
->count_materialization_scale
);
1089 tag
= streamer_read_record_start (ib
);
1092 /* Fix up the call statements that are mentioned in the callgraph
1094 set_gimple_stmt_max_uid (cfun
, 0);
1095 FOR_ALL_BB_FN (bb
, cfun
)
1097 gimple_stmt_iterator gsi
;
1098 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1100 gimple
*stmt
= gsi_stmt (gsi
);
1101 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
1103 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1105 gimple
*stmt
= gsi_stmt (gsi
);
1106 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
1109 stmts
= (gimple
**) xcalloc (gimple_stmt_max_uid (fn
), sizeof (gimple
*));
1110 FOR_ALL_BB_FN (bb
, cfun
)
1112 gimple_stmt_iterator bsi
= gsi_start_phis (bb
);
1113 while (!gsi_end_p (bsi
))
1115 gimple
*stmt
= gsi_stmt (bsi
);
1117 stmts
[gimple_uid (stmt
)] = stmt
;
1119 bsi
= gsi_start_bb (bb
);
1120 while (!gsi_end_p (bsi
))
1122 gimple
*stmt
= gsi_stmt (bsi
);
1123 bool remove
= false;
1124 /* If we're recompiling LTO objects with debug stmts but
1125 we're not supposed to have debug stmts, remove them now.
1126 We can't remove them earlier because this would cause uid
1127 mismatches in fixups, but we can do it at this point, as
1128 long as debug stmts don't require fixups.
1129 Similarly remove all IFN_*SAN_* internal calls */
1132 if (is_gimple_debug (stmt
)
1133 && (gimple_debug_nonbind_marker_p (stmt
)
1134 ? !MAY_HAVE_DEBUG_MARKER_STMTS
1135 : !MAY_HAVE_DEBUG_BIND_STMTS
))
1137 /* In case the linemap overflows locations can be dropped
1138 to zero. Thus do not keep nonsensical inline entry markers
1139 we'd later ICE on. */
1141 if (gimple_debug_inline_entry_p (stmt
)
1142 && (((block
= gimple_block (stmt
))
1143 && !inlined_function_outer_scope_p (block
))
1144 || !debug_inline_points
))
1146 if (is_gimple_call (stmt
)
1147 && gimple_call_internal_p (stmt
))
1149 bool replace
= false;
1150 switch (gimple_call_internal_fn (stmt
))
1152 case IFN_UBSAN_NULL
:
1154 & (SANITIZE_NULL
| SANITIZE_ALIGNMENT
)) == 0)
1157 case IFN_UBSAN_BOUNDS
:
1158 if ((flag_sanitize
& SANITIZE_BOUNDS
) == 0)
1161 case IFN_UBSAN_VPTR
:
1162 if ((flag_sanitize
& SANITIZE_VPTR
) == 0)
1165 case IFN_UBSAN_OBJECT_SIZE
:
1166 if ((flag_sanitize
& SANITIZE_OBJECT_SIZE
) == 0)
1170 if ((flag_sanitize
& SANITIZE_POINTER_OVERFLOW
) == 0)
1174 if ((flag_sanitize
& SANITIZE_ADDRESS
) == 0)
1177 case IFN_TSAN_FUNC_EXIT
:
1178 if ((flag_sanitize
& SANITIZE_THREAD
) == 0)
1186 gimple_call_set_internal_fn (as_a
<gcall
*> (stmt
),
1194 gimple_stmt_iterator gsi
= bsi
;
1196 unlink_stmt_vdef (stmt
);
1197 release_defs (stmt
);
1198 gsi_remove (&gsi
, true);
1203 stmts
[gimple_uid (stmt
)] = stmt
;
1205 /* Remember that the input function has begin stmt
1206 markers, so that we know to expect them when emitting
1208 if (!cfun
->debug_nonbind_markers
1209 && gimple_debug_nonbind_marker_p (stmt
))
1210 cfun
->debug_nonbind_markers
= true;
1215 /* Set the gimple body to the statement sequence in the entry
1216 basic block. FIXME lto, this is fairly hacky. The existence
1217 of a gimple body is used by the cgraph routines, but we should
1218 really use the presence of the CFG. */
1220 edge_iterator ei
= ei_start (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
);
1221 gimple_set_body (fn_decl
, bb_seq (ei_edge (ei
)->dest
));
1224 update_max_bb_count ();
1225 fixup_call_stmt_edges (node
, stmts
);
1226 execute_all_ipa_stmt_fixups (node
, stmts
);
1228 free_dominance_info (CDI_DOMINATORS
);
1229 free_dominance_info (CDI_POST_DOMINATORS
);
1234 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1237 input_constructor (tree var
, class data_in
*data_in
,
1238 class lto_input_block
*ib
)
1240 DECL_INITIAL (var
) = stream_read_tree (ib
, data_in
);
1244 /* Read the body from DATA for function NODE and fill it in.
1245 FILE_DATA are the global decls and types. SECTION_TYPE is either
1246 LTO_section_function_body or LTO_section_static_initializer. If
1247 section type is LTO_section_function_body, FN must be the decl for
1251 lto_read_body_or_constructor (struct lto_file_decl_data
*file_data
, struct symtab_node
*node
,
1252 const char *data
, enum lto_section_type section_type
)
1254 const struct lto_function_header
*header
;
1255 class data_in
*data_in
;
1259 tree fn_decl
= node
->decl
;
1261 header
= (const struct lto_function_header
*) data
;
1262 if (TREE_CODE (node
->decl
) == FUNCTION_DECL
)
1264 cfg_offset
= sizeof (struct lto_function_header
);
1265 main_offset
= cfg_offset
+ header
->cfg_size
;
1266 string_offset
= main_offset
+ header
->main_size
;
1270 main_offset
= sizeof (struct lto_function_header
);
1271 string_offset
= main_offset
+ header
->main_size
;
1274 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
1275 header
->string_size
, vNULL
);
1277 if (section_type
== LTO_section_function_body
)
1279 struct lto_in_decl_state
*decl_state
;
1282 gcc_checking_assert (node
);
1284 /* Use the function's decl state. */
1285 decl_state
= lto_get_function_in_decl_state (file_data
, fn_decl
);
1286 gcc_assert (decl_state
);
1287 file_data
->current_decl_state
= decl_state
;
1290 /* Set up the struct function. */
1291 from
= data_in
->reader_cache
->nodes
.length ();
1292 lto_input_block
ib_main (data
+ main_offset
, header
->main_size
,
1293 file_data
->mode_table
);
1294 if (TREE_CODE (node
->decl
) == FUNCTION_DECL
)
1296 lto_input_block
ib_cfg (data
+ cfg_offset
, header
->cfg_size
,
1297 file_data
->mode_table
);
1298 input_function (fn_decl
, data_in
, &ib_main
, &ib_cfg
,
1299 dyn_cast
<cgraph_node
*>(node
));
1302 input_constructor (fn_decl
, data_in
, &ib_main
);
1303 data_in
->location_cache
.apply_location_cache ();
1304 /* And fixup types we streamed locally. */
1306 struct streamer_tree_cache_d
*cache
= data_in
->reader_cache
;
1307 unsigned len
= cache
->nodes
.length ();
1309 for (i
= len
; i
-- > from
;)
1311 tree t
= streamer_tree_cache_get_tree (cache
, i
);
1317 gcc_assert (TYPE_CANONICAL (t
) == NULL_TREE
);
1318 if (type_with_alias_set_p (t
)
1319 && canonical_type_used_p (t
))
1320 TYPE_CANONICAL (t
) = TYPE_MAIN_VARIANT (t
);
1321 if (TYPE_MAIN_VARIANT (t
) != t
)
1323 gcc_assert (TYPE_NEXT_VARIANT (t
) == NULL_TREE
);
1324 TYPE_NEXT_VARIANT (t
)
1325 = TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t
));
1326 TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t
)) = t
;
1332 /* Restore decl state */
1333 file_data
->current_decl_state
= file_data
->global_decl_state
;
1336 lto_data_in_delete (data_in
);
1340 /* Read the body of NODE using DATA. FILE_DATA holds the global
1344 lto_input_function_body (struct lto_file_decl_data
*file_data
,
1345 struct cgraph_node
*node
, const char *data
)
1347 lto_read_body_or_constructor (file_data
, node
, data
, LTO_section_function_body
);
1350 /* Read the body of NODE using DATA. FILE_DATA holds the global
1354 lto_input_variable_constructor (struct lto_file_decl_data
*file_data
,
1355 struct varpool_node
*node
, const char *data
)
1357 lto_read_body_or_constructor (file_data
, node
, data
, LTO_section_function_body
);
1361 /* Queue of acummulated decl -> DIE mappings. Similar to locations those
1362 are only applied to prevailing tree nodes during tree merging. */
1363 vec
<dref_entry
> dref_queue
;
1365 /* Read the physical representation of a tree node EXPR from
1366 input block IB using the per-file context in DATA_IN. */
1369 lto_read_tree_1 (class lto_input_block
*ib
, class data_in
*data_in
, tree expr
)
1371 /* Read all the bitfield values in EXPR. Note that for LTO, we
1372 only write language-independent bitfields, so no more unpacking is
1374 streamer_read_tree_bitfields (ib
, data_in
, expr
);
1376 /* Read all the pointer fields in EXPR. */
1377 streamer_read_tree_body (ib
, data_in
, expr
);
1379 /* Read any LTO-specific data not read by the tree streamer. */
1381 && TREE_CODE (expr
) != FUNCTION_DECL
1382 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
1383 DECL_INITIAL (expr
) = stream_read_tree (ib
, data_in
);
1385 /* Stream references to early generated DIEs. Keep in sync with the
1386 trees handled in dwarf2out_register_external_die. */
1388 && TREE_CODE (expr
) != FIELD_DECL
1389 && TREE_CODE (expr
) != DEBUG_EXPR_DECL
1390 && TREE_CODE (expr
) != TYPE_DECL
)
1391 || TREE_CODE (expr
) == BLOCK
)
1393 const char *str
= streamer_read_string (data_in
, ib
);
1396 unsigned HOST_WIDE_INT off
= streamer_read_uhwi (ib
);
1397 dref_entry e
= { expr
, str
, off
};
1398 dref_queue
.safe_push (e
);
1403 /* Read the physical representation of a tree node with tag TAG from
1404 input block IB using the per-file context in DATA_IN. */
1407 lto_read_tree (class lto_input_block
*ib
, class data_in
*data_in
,
1408 enum LTO_tags tag
, hashval_t hash
)
1410 /* Instantiate a new tree node. */
1411 tree result
= streamer_alloc_tree (ib
, data_in
, tag
);
1413 /* Enter RESULT in the reader cache. This will make RESULT
1414 available so that circular references in the rest of the tree
1415 structure can be resolved in subsequent calls to stream_read_tree. */
1416 streamer_tree_cache_append (data_in
->reader_cache
, result
, hash
);
1418 lto_read_tree_1 (ib
, data_in
, result
);
1420 /* end_marker = */ streamer_read_uchar (ib
);
1426 /* Populate the reader cache with trees materialized from the SCC
1427 following in the IB, DATA_IN stream.
1428 If SHARED_SCC is true we input LTO_tree_scc. */
1431 lto_input_scc (class lto_input_block
*ib
, class data_in
*data_in
,
1432 unsigned *len
, unsigned *entry_len
, bool shared_scc
)
1434 /* A blob of unnamed tree nodes, fill the cache from it and
1436 unsigned size
= streamer_read_uhwi (ib
);
1437 hashval_t scc_hash
= shared_scc
? streamer_read_uhwi (ib
) : 0;
1438 unsigned scc_entry_len
= 1;
1442 enum LTO_tags tag
= streamer_read_record_start (ib
);
1443 lto_input_tree_1 (ib
, data_in
, tag
, scc_hash
);
1447 unsigned int first
= data_in
->reader_cache
->nodes
.length ();
1450 scc_entry_len
= streamer_read_uhwi (ib
);
1452 /* Materialize size trees by reading their headers. */
1453 for (unsigned i
= 0; i
< size
; ++i
)
1455 enum LTO_tags tag
= streamer_read_record_start (ib
);
1457 || (tag
>= LTO_field_decl_ref
&& tag
<= LTO_global_decl_ref
)
1458 || tag
== LTO_tree_pickle_reference
1459 || tag
== LTO_integer_cst
1460 || tag
== LTO_tree_scc
1461 || tag
== LTO_trees
)
1464 result
= streamer_alloc_tree (ib
, data_in
, tag
);
1465 streamer_tree_cache_append (data_in
->reader_cache
, result
, 0);
1468 /* Read the tree bitpacks and references. */
1469 for (unsigned i
= 0; i
< size
; ++i
)
1471 result
= streamer_tree_cache_get_tree (data_in
->reader_cache
,
1473 lto_read_tree_1 (ib
, data_in
, result
);
1474 /* end_marker = */ streamer_read_uchar (ib
);
1479 *entry_len
= scc_entry_len
;
1484 /* Read a tree from input block IB using the per-file context in
1485 DATA_IN. This context is used, for example, to resolve references
1486 to previously read nodes. */
1489 lto_input_tree_1 (class lto_input_block
*ib
, class data_in
*data_in
,
1490 enum LTO_tags tag
, hashval_t hash
)
1494 gcc_assert ((unsigned) tag
< (unsigned) LTO_NUM_TAGS
);
1496 if (tag
== LTO_null
)
1498 else if (tag
>= LTO_field_decl_ref
&& tag
<= LTO_namelist_decl_ref
)
1500 /* If TAG is a reference to an indexable tree, the next value
1501 in IB is the index into the table where we expect to find
1503 result
= lto_input_tree_ref (ib
, data_in
, cfun
, tag
);
1505 else if (tag
== LTO_tree_pickle_reference
)
1507 /* If TAG is a reference to a previously read tree, look it up in
1508 the reader cache. */
1509 result
= streamer_get_pickled_tree (ib
, data_in
);
1511 else if (tag
== LTO_integer_cst
)
1513 /* For shared integer constants in singletons we can use the
1514 existing tree integer constant merging code. */
1515 tree type
= stream_read_tree (ib
, data_in
);
1516 unsigned HOST_WIDE_INT len
= streamer_read_uhwi (ib
);
1517 unsigned HOST_WIDE_INT i
;
1518 HOST_WIDE_INT a
[WIDE_INT_MAX_ELTS
];
1520 for (i
= 0; i
< len
; i
++)
1521 a
[i
] = streamer_read_hwi (ib
);
1522 gcc_assert (TYPE_PRECISION (type
) <= MAX_BITSIZE_MODE_ANY_INT
);
1523 result
= wide_int_to_tree (type
, wide_int::from_array
1524 (a
, len
, TYPE_PRECISION (type
)));
1525 streamer_tree_cache_append (data_in
->reader_cache
, result
, hash
);
1527 else if (tag
== LTO_tree_scc
|| tag
== LTO_trees
)
1531 /* Otherwise, materialize a new node from IB. */
1532 result
= lto_read_tree (ib
, data_in
, tag
, hash
);
1539 lto_input_tree (class lto_input_block
*ib
, class data_in
*data_in
)
1543 /* Input pickled trees needed to stream in the reference. */
1544 while ((tag
= streamer_read_record_start (ib
)) == LTO_trees
)
1546 unsigned len
, entry_len
;
1547 lto_input_scc (ib
, data_in
, &len
, &entry_len
, false);
1549 /* Register DECLs with the debuginfo machinery. */
1550 while (!dref_queue
.is_empty ())
1552 dref_entry e
= dref_queue
.pop ();
1553 debug_hooks
->register_external_die (e
.decl
, e
.sym
, e
.off
);
1556 tree t
= lto_input_tree_1 (ib
, data_in
, tag
, 0);
1558 if (!dref_queue
.is_empty ())
1560 dref_entry e
= dref_queue
.pop ();
1561 debug_hooks
->register_external_die (e
.decl
, e
.sym
, e
.off
);
1562 gcc_checking_assert (dref_queue
.is_empty ());
1568 /* Input toplevel asms. */
1571 lto_input_toplevel_asms (struct lto_file_decl_data
*file_data
, int order_base
)
1575 = lto_get_summary_section_data (file_data
, LTO_section_asm
, &len
);
1576 const struct lto_simple_header_with_strings
*header
1577 = (const struct lto_simple_header_with_strings
*) data
;
1579 class data_in
*data_in
;
1585 string_offset
= sizeof (*header
) + header
->main_size
;
1587 lto_input_block
ib (data
+ sizeof (*header
), header
->main_size
,
1588 file_data
->mode_table
);
1590 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
1591 header
->string_size
, vNULL
);
1593 while ((str
= streamer_read_string_cst (data_in
, &ib
)))
1595 asm_node
*node
= symtab
->finalize_toplevel_asm (str
);
1596 node
->order
= streamer_read_hwi (&ib
) + order_base
;
1597 if (node
->order
>= symtab
->order
)
1598 symtab
->order
= node
->order
+ 1;
1601 lto_data_in_delete (data_in
);
1603 lto_free_section_data (file_data
, LTO_section_asm
, NULL
, data
, len
);
1607 /* Input mode table. */
1610 lto_input_mode_table (struct lto_file_decl_data
*file_data
)
1614 = lto_get_summary_section_data (file_data
, LTO_section_mode_table
, &len
);
1617 internal_error ("cannot read LTO mode table from %s",
1618 file_data
->file_name
);
1622 unsigned char *table
= ggc_cleared_vec_alloc
<unsigned char> (1 << 8);
1623 file_data
->mode_table
= table
;
1624 const struct lto_simple_header_with_strings
*header
1625 = (const struct lto_simple_header_with_strings
*) data
;
1627 class data_in
*data_in
;
1628 string_offset
= sizeof (*header
) + header
->main_size
;
1630 lto_input_block
ib (data
+ sizeof (*header
), header
->main_size
, NULL
);
1631 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
1632 header
->string_size
, vNULL
);
1633 bitpack_d bp
= streamer_read_bitpack (&ib
);
1635 table
[VOIDmode
] = VOIDmode
;
1636 table
[BLKmode
] = BLKmode
;
1638 while ((m
= bp_unpack_value (&bp
, 8)) != VOIDmode
)
1640 enum mode_class mclass
1641 = bp_unpack_enum (&bp
, mode_class
, MAX_MODE_CLASS
);
1642 poly_uint16 size
= bp_unpack_poly_value (&bp
, 16);
1643 poly_uint16 prec
= bp_unpack_poly_value (&bp
, 16);
1644 machine_mode inner
= (machine_mode
) bp_unpack_value (&bp
, 8);
1645 poly_uint16 nunits
= bp_unpack_poly_value (&bp
, 16);
1646 unsigned int ibit
= 0, fbit
= 0;
1647 unsigned int real_fmt_len
= 0;
1648 const char *real_fmt_name
= NULL
;
1655 ibit
= bp_unpack_value (&bp
, 8);
1656 fbit
= bp_unpack_value (&bp
, 8);
1659 case MODE_DECIMAL_FLOAT
:
1660 real_fmt_name
= bp_unpack_indexed_string (data_in
, &bp
,
1666 /* First search just the GET_CLASS_NARROWEST_MODE to wider modes,
1667 if not found, fallback to all modes. */
1669 for (pass
= 0; pass
< 2; pass
++)
1670 for (machine_mode mr
= pass
? VOIDmode
1671 : GET_CLASS_NARROWEST_MODE (mclass
);
1672 pass
? mr
< MAX_MACHINE_MODE
: mr
!= VOIDmode
;
1673 pass
? mr
= (machine_mode
) (mr
+ 1)
1674 : mr
= GET_MODE_WIDER_MODE (mr
).else_void ())
1675 if (GET_MODE_CLASS (mr
) != mclass
1676 || maybe_ne (GET_MODE_SIZE (mr
), size
)
1677 || maybe_ne (GET_MODE_PRECISION (mr
), prec
)
1679 ? GET_MODE_INNER (mr
) != mr
1680 : GET_MODE_INNER (mr
) != table
[(int) inner
])
1681 || GET_MODE_IBIT (mr
) != ibit
1682 || GET_MODE_FBIT (mr
) != fbit
1683 || maybe_ne (GET_MODE_NUNITS (mr
), nunits
))
1685 else if ((mclass
== MODE_FLOAT
|| mclass
== MODE_DECIMAL_FLOAT
)
1686 && strcmp (REAL_MODE_FORMAT (mr
)->name
, real_fmt_name
) != 0)
1694 unsigned int mname_len
;
1695 const char *mname
= bp_unpack_indexed_string (data_in
, &bp
, &mname_len
);
1700 case MODE_VECTOR_BOOL
:
1701 case MODE_VECTOR_INT
:
1702 case MODE_VECTOR_FLOAT
:
1703 case MODE_VECTOR_FRACT
:
1704 case MODE_VECTOR_UFRACT
:
1705 case MODE_VECTOR_ACCUM
:
1706 case MODE_VECTOR_UACCUM
:
1707 /* For unsupported vector modes just use BLKmode,
1708 if the scalar mode is supported. */
1709 if (table
[(int) inner
] != VOIDmode
)
1716 /* This is only used for offloading-target compilations and
1717 is a user-facing error. Give a better error message for
1718 the common modes; see also mode-classes.def. */
1719 if (mclass
== MODE_FLOAT
)
1720 fatal_error (UNKNOWN_LOCATION
,
1721 "%s - %u-bit-precision floating-point numbers "
1722 "unsupported (mode %qs)", TARGET_MACHINE
,
1723 prec
.to_constant (), mname
);
1724 else if (mclass
== MODE_DECIMAL_FLOAT
)
1725 fatal_error (UNKNOWN_LOCATION
,
1726 "%s - %u-bit-precision decimal floating-point "
1727 "numbers unsupported (mode %qs)", TARGET_MACHINE
,
1728 prec
.to_constant (), mname
);
1729 else if (mclass
== MODE_COMPLEX_FLOAT
)
1730 fatal_error (UNKNOWN_LOCATION
,
1731 "%s - %u-bit-precision complex floating-point "
1732 "numbers unsupported (mode %qs)", TARGET_MACHINE
,
1733 prec
.to_constant (), mname
);
1734 else if (mclass
== MODE_INT
)
1735 fatal_error (UNKNOWN_LOCATION
,
1736 "%s - %u-bit integer numbers unsupported (mode "
1737 "%qs)", TARGET_MACHINE
, prec
.to_constant (), mname
);
1739 fatal_error (UNKNOWN_LOCATION
, "%s - unsupported mode %qs",
1740 TARGET_MACHINE
, mname
);
1745 lto_data_in_delete (data_in
);
1747 lto_free_section_data (file_data
, LTO_section_mode_table
, NULL
, data
, len
);
1751 /* Initialization for the LTO reader. */
1754 lto_reader_init (void)
1756 lto_streamer_init ();
1757 file_name_hash_table
1758 = new hash_table
<string_slot_hasher
> (37);
1759 string_slot_allocator
= new object_allocator
<struct string_slot
>
1760 ("line map file name hash");
1761 gcc_obstack_init (&file_name_obstack
);
1764 /* Free hash table used to stream in location file names. */
1767 lto_free_file_name_hash (void)
1769 delete file_name_hash_table
;
1770 file_name_hash_table
= NULL
;
1771 delete string_slot_allocator
;
1772 string_slot_allocator
= NULL
;
1773 /* file_name_obstack must stay allocated since it is referred to by
1778 /* Create a new data_in object for FILE_DATA. STRINGS is the string
1779 table to use with LEN strings. RESOLUTIONS is the vector of linker
1780 resolutions (NULL if not using a linker plugin). */
1783 lto_data_in_create (struct lto_file_decl_data
*file_data
, const char *strings
,
1785 vec
<ld_plugin_symbol_resolution_t
> resolutions
)
1787 class data_in
*data_in
= new (class data_in
);
1788 data_in
->file_data
= file_data
;
1789 data_in
->strings
= strings
;
1790 data_in
->strings_len
= len
;
1791 data_in
->globals_resolution
= resolutions
;
1792 data_in
->reader_cache
= streamer_tree_cache_create (false, false, true);
1797 /* Remove DATA_IN. */
1800 lto_data_in_delete (class data_in
*data_in
)
1802 data_in
->globals_resolution
.release ();
1803 streamer_tree_cache_delete (data_in
->reader_cache
);