1 /* Read the GIMPLE representation from a file stream.
3 Copyright (C) 2009-2017 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"
47 struct freeing_string_slot_hasher
: string_slot_hasher
49 static inline void remove (value_type
*);
53 freeing_string_slot_hasher::remove (value_type
*v
)
58 /* The table to hold the file names. */
59 static hash_table
<freeing_string_slot_hasher
> *file_name_hash_table
;
62 /* Check that tag ACTUAL has one of the given values. NUM_TAGS is the
63 number of valid tag values to check. */
66 lto_tag_check_set (enum LTO_tags actual
, int ntags
, ...)
72 for (i
= 0; i
< ntags
; i
++)
73 if ((unsigned) actual
== va_arg (ap
, unsigned))
80 internal_error ("bytecode stream: unexpected tag %s", lto_tag_name (actual
));
84 /* Read LENGTH bytes from STREAM to ADDR. */
87 lto_input_data_block (struct lto_input_block
*ib
, void *addr
, size_t length
)
90 unsigned char *const buffer
= (unsigned char *) addr
;
92 for (i
= 0; i
< length
; i
++)
93 buffer
[i
] = streamer_read_uchar (ib
);
97 /* Lookup STRING in file_name_hash_table. If found, return the existing
98 string, otherwise insert STRING as the canonical version. */
101 canon_file_name (const char *string
)
104 struct string_slot s_slot
;
105 size_t len
= strlen (string
);
110 slot
= file_name_hash_table
->find_slot (&s_slot
, INSERT
);
114 struct string_slot
*new_slot
;
116 saved_string
= (char *) xmalloc (len
+ 1);
117 new_slot
= XCNEW (struct string_slot
);
118 memcpy (saved_string
, string
, len
+ 1);
119 new_slot
->s
= saved_string
;
126 struct string_slot
*old_slot
= *slot
;
131 /* Pointer to currently alive instance of lto_location_cache. */
133 lto_location_cache
*lto_location_cache::current_cache
;
135 /* Sort locations in source order. Start with file from last application. */
138 lto_location_cache::cmp_loc (const void *pa
, const void *pb
)
140 const cached_location
*a
= ((const cached_location
*)pa
);
141 const cached_location
*b
= ((const cached_location
*)pb
);
142 const char *current_file
= current_cache
->current_file
;
143 int current_line
= current_cache
->current_line
;
145 if (a
->file
== current_file
&& b
->file
!= current_file
)
147 if (a
->file
!= current_file
&& b
->file
== current_file
)
149 if (a
->file
== current_file
&& b
->file
== current_file
)
151 if (a
->line
== current_line
&& b
->line
!= current_line
)
153 if (a
->line
!= current_line
&& b
->line
== current_line
)
156 if (a
->file
!= b
->file
)
157 return strcmp (a
->file
, b
->file
);
158 if (a
->sysp
!= b
->sysp
)
159 return a
->sysp
? 1 : -1;
160 if (a
->line
!= b
->line
)
161 return a
->line
- b
->line
;
162 return a
->col
- b
->col
;
165 /* Apply all changes in location cache. Add locations into linemap and patch
169 lto_location_cache::apply_location_cache ()
171 static const char *prev_file
;
172 if (!loc_cache
.length ())
174 if (loc_cache
.length () > 1)
175 loc_cache
.qsort (cmp_loc
);
177 for (unsigned int i
= 0; i
< loc_cache
.length (); i
++)
179 struct cached_location loc
= loc_cache
[i
];
181 if (current_file
!= loc
.file
)
182 linemap_add (line_table
, prev_file
? LC_RENAME
: LC_ENTER
,
183 loc
.sysp
, loc
.file
, loc
.line
);
184 else if (current_line
!= loc
.line
)
188 for (unsigned int j
= i
+ 1; j
< loc_cache
.length (); j
++)
189 if (loc
.file
!= loc_cache
[j
].file
190 || loc
.line
!= loc_cache
[j
].line
)
192 else if (max
< loc_cache
[j
].col
)
193 max
= loc_cache
[j
].col
;
194 linemap_line_start (line_table
, loc
.line
, max
+ 1);
196 gcc_assert (*loc
.loc
== BUILTINS_LOCATION
+ 1);
197 if (current_file
== loc
.file
&& current_line
== loc
.line
198 && current_col
== loc
.col
)
199 *loc
.loc
= current_loc
;
201 current_loc
= *loc
.loc
= linemap_position_for_column (line_table
,
203 current_line
= loc
.line
;
204 prev_file
= current_file
= loc
.file
;
205 current_col
= loc
.col
;
207 loc_cache
.truncate (0);
212 /* Tree merging did not suceed; mark all changes in the cache as accepted. */
215 lto_location_cache::accept_location_cache ()
217 gcc_assert (current_cache
== this);
218 accepted_length
= loc_cache
.length ();
221 /* Tree merging did suceed; throw away recent changes. */
224 lto_location_cache::revert_location_cache ()
226 loc_cache
.truncate (accepted_length
);
229 /* Read a location bitpack from input block IB and either update *LOC directly
230 or add it to the location cache.
231 It is neccesary to call apply_location_cache to get *LOC updated. */
234 lto_location_cache::input_location (location_t
*loc
, struct bitpack_d
*bp
,
235 struct data_in
*data_in
)
237 static const char *stream_file
;
238 static int stream_line
;
239 static int stream_col
;
240 static bool stream_sysp
;
241 bool file_change
, line_change
, column_change
;
243 gcc_assert (current_cache
== this);
245 *loc
= bp_unpack_int_in_range (bp
, "location", 0, RESERVED_LOCATION_COUNT
);
247 if (*loc
< RESERVED_LOCATION_COUNT
)
250 /* Keep value RESERVED_LOCATION_COUNT in *loc as linemap lookups will
253 file_change
= bp_unpack_value (bp
, 1);
254 line_change
= bp_unpack_value (bp
, 1);
255 column_change
= bp_unpack_value (bp
, 1);
259 stream_file
= canon_file_name (bp_unpack_string (data_in
, bp
));
260 stream_sysp
= bp_unpack_value (bp
, 1);
264 stream_line
= bp_unpack_var_len_unsigned (bp
);
267 stream_col
= bp_unpack_var_len_unsigned (bp
);
269 /* This optimization saves location cache operations druing gimple
272 if (current_file
== stream_file
&& current_line
== stream_line
273 && current_col
== stream_col
&& current_sysp
== stream_sysp
)
279 struct cached_location entry
280 = {stream_file
, loc
, stream_line
, stream_col
, stream_sysp
};
281 loc_cache
.safe_push (entry
);
284 /* Read a location bitpack from input block IB and either update *LOC directly
285 or add it to the location cache.
286 It is neccesary to call apply_location_cache to get *LOC updated. */
289 lto_input_location (location_t
*loc
, struct bitpack_d
*bp
,
290 struct data_in
*data_in
)
292 data_in
->location_cache
.input_location (loc
, bp
, data_in
);
295 /* Read location and return it instead of going through location caching.
296 This should be used only when the resulting location is not going to be
300 stream_input_location_now (struct bitpack_d
*bp
, struct data_in
*data_in
)
303 stream_input_location (&loc
, bp
, data_in
);
304 data_in
->location_cache
.apply_location_cache ();
308 /* Read a reference to a tree node from DATA_IN using input block IB.
309 TAG is the expected node that should be found in IB, if TAG belongs
310 to one of the indexable trees, expect to read a reference index to
311 be looked up in one of the symbol tables, otherwise read the pysical
312 representation of the tree using stream_read_tree. FN is the
313 function scope for the read tree. */
316 lto_input_tree_ref (struct lto_input_block
*ib
, struct data_in
*data_in
,
317 struct function
*fn
, enum LTO_tags tag
)
319 unsigned HOST_WIDE_INT ix_u
;
320 tree result
= NULL_TREE
;
322 lto_tag_check_range (tag
, LTO_field_decl_ref
, LTO_namelist_decl_ref
);
327 ix_u
= streamer_read_uhwi (ib
);
328 result
= lto_file_decl_data_get_type (data_in
->file_data
, ix_u
);
331 case LTO_ssa_name_ref
:
332 ix_u
= streamer_read_uhwi (ib
);
333 result
= (*SSANAMES (fn
))[ix_u
];
336 case LTO_field_decl_ref
:
337 ix_u
= streamer_read_uhwi (ib
);
338 result
= lto_file_decl_data_get_field_decl (data_in
->file_data
, ix_u
);
341 case LTO_function_decl_ref
:
342 ix_u
= streamer_read_uhwi (ib
);
343 result
= lto_file_decl_data_get_fn_decl (data_in
->file_data
, ix_u
);
346 case LTO_type_decl_ref
:
347 ix_u
= streamer_read_uhwi (ib
);
348 result
= lto_file_decl_data_get_type_decl (data_in
->file_data
, ix_u
);
351 case LTO_namespace_decl_ref
:
352 ix_u
= streamer_read_uhwi (ib
);
353 result
= lto_file_decl_data_get_namespace_decl (data_in
->file_data
, ix_u
);
356 case LTO_global_decl_ref
:
357 case LTO_result_decl_ref
:
358 case LTO_const_decl_ref
:
359 case LTO_imported_decl_ref
:
360 case LTO_label_decl_ref
:
361 case LTO_translation_unit_decl_ref
:
362 case LTO_namelist_decl_ref
:
363 if (!data_in
->file_data
->current_decl_state
)
364 printf("tag %d\n", tag
);
365 ix_u
= streamer_read_uhwi (ib
);
366 result
= lto_file_decl_data_get_var_decl (data_in
->file_data
, ix_u
);
379 /* Read and return a double-linked list of catch handlers from input
380 block IB, using descriptors in DATA_IN. */
382 static struct eh_catch_d
*
383 lto_input_eh_catch_list (struct lto_input_block
*ib
, struct data_in
*data_in
,
389 *last_p
= first
= NULL
;
390 tag
= streamer_read_record_start (ib
);
396 lto_tag_check_range (tag
, LTO_eh_catch
, LTO_eh_catch
);
398 /* Read the catch node. */
399 n
= ggc_cleared_alloc
<eh_catch_d
> ();
400 n
->type_list
= stream_read_tree (ib
, data_in
);
401 n
->filter_list
= stream_read_tree (ib
, data_in
);
402 n
->label
= stream_read_tree (ib
, data_in
);
404 /* Register all the types in N->FILTER_LIST. */
405 for (list
= n
->filter_list
; list
; list
= TREE_CHAIN (list
))
406 add_type_for_runtime (TREE_VALUE (list
));
408 /* Chain N to the end of the list. */
410 (*last_p
)->next_catch
= n
;
411 n
->prev_catch
= *last_p
;
414 /* Set the head of the list the first time through the loop. */
418 tag
= streamer_read_record_start (ib
);
425 /* Read and return EH region IX from input block IB, using descriptors
429 input_eh_region (struct lto_input_block
*ib
, struct data_in
*data_in
, int ix
)
434 /* Read the region header. */
435 tag
= streamer_read_record_start (ib
);
439 r
= ggc_cleared_alloc
<eh_region_d
> ();
440 r
->index
= streamer_read_hwi (ib
);
442 gcc_assert (r
->index
== ix
);
444 /* Read all the region pointers as region numbers. We'll fix up
445 the pointers once the whole array has been read. */
446 r
->outer
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
447 r
->inner
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
448 r
->next_peer
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
452 case LTO_ert_cleanup
:
453 r
->type
= ERT_CLEANUP
;
458 struct eh_catch_d
*last_catch
;
460 r
->u
.eh_try
.first_catch
= lto_input_eh_catch_list (ib
, data_in
,
462 r
->u
.eh_try
.last_catch
= last_catch
;
466 case LTO_ert_allowed_exceptions
:
470 r
->type
= ERT_ALLOWED_EXCEPTIONS
;
471 r
->u
.allowed
.type_list
= stream_read_tree (ib
, data_in
);
472 r
->u
.allowed
.label
= stream_read_tree (ib
, data_in
);
473 r
->u
.allowed
.filter
= streamer_read_uhwi (ib
);
475 for (l
= r
->u
.allowed
.type_list
; l
; l
= TREE_CHAIN (l
))
476 add_type_for_runtime (TREE_VALUE (l
));
480 case LTO_ert_must_not_throw
:
482 r
->type
= ERT_MUST_NOT_THROW
;
483 r
->u
.must_not_throw
.failure_decl
= stream_read_tree (ib
, data_in
);
484 bitpack_d bp
= streamer_read_bitpack (ib
);
485 r
->u
.must_not_throw
.failure_loc
486 = stream_input_location_now (&bp
, data_in
);
494 r
->landing_pads
= (eh_landing_pad
) (intptr_t) streamer_read_hwi (ib
);
500 /* Read and return EH landing pad IX from input block IB, using descriptors
503 static eh_landing_pad
504 input_eh_lp (struct lto_input_block
*ib
, struct data_in
*data_in
, int ix
)
509 /* Read the landing pad header. */
510 tag
= streamer_read_record_start (ib
);
514 lto_tag_check_range (tag
, LTO_eh_landing_pad
, LTO_eh_landing_pad
);
516 lp
= ggc_cleared_alloc
<eh_landing_pad_d
> ();
517 lp
->index
= streamer_read_hwi (ib
);
518 gcc_assert (lp
->index
== ix
);
519 lp
->next_lp
= (eh_landing_pad
) (intptr_t) streamer_read_hwi (ib
);
520 lp
->region
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
521 lp
->post_landing_pad
= stream_read_tree (ib
, data_in
);
527 /* After reading the EH regions, pointers to peer and children regions
528 are region numbers. This converts all these region numbers into
529 real pointers into the rematerialized regions for FN. ROOT_REGION
530 is the region number for the root EH region in FN. */
533 fixup_eh_region_pointers (struct function
*fn
, HOST_WIDE_INT root_region
)
536 vec
<eh_region
, va_gc
> *eh_array
= fn
->eh
->region_array
;
537 vec
<eh_landing_pad
, va_gc
> *lp_array
= fn
->eh
->lp_array
;
541 gcc_assert (eh_array
&& lp_array
);
543 gcc_assert (root_region
>= 0);
544 fn
->eh
->region_tree
= (*eh_array
)[root_region
];
546 #define FIXUP_EH_REGION(r) (r) = (*eh_array)[(HOST_WIDE_INT) (intptr_t) (r)]
547 #define FIXUP_EH_LP(p) (p) = (*lp_array)[(HOST_WIDE_INT) (intptr_t) (p)]
549 /* Convert all the index numbers stored in pointer fields into
550 pointers to the corresponding slots in the EH region array. */
551 FOR_EACH_VEC_ELT (*eh_array
, i
, r
)
553 /* The array may contain NULL regions. */
557 gcc_assert (i
== (unsigned) r
->index
);
558 FIXUP_EH_REGION (r
->outer
);
559 FIXUP_EH_REGION (r
->inner
);
560 FIXUP_EH_REGION (r
->next_peer
);
561 FIXUP_EH_LP (r
->landing_pads
);
564 /* Convert all the index numbers stored in pointer fields into
565 pointers to the corresponding slots in the EH landing pad array. */
566 FOR_EACH_VEC_ELT (*lp_array
, i
, lp
)
568 /* The array may contain NULL landing pads. */
572 gcc_assert (i
== (unsigned) lp
->index
);
573 FIXUP_EH_LP (lp
->next_lp
);
574 FIXUP_EH_REGION (lp
->region
);
577 #undef FIXUP_EH_REGION
582 /* Initialize EH support. */
587 static bool eh_initialized_p
= false;
589 if (eh_initialized_p
)
592 /* Contrary to most other FEs, we only initialize EH support when at
593 least one of the files in the set contains exception regions in
594 it. Since this happens much later than the call to init_eh in
595 lang_dependent_init, we have to set flag_exceptions and call
596 init_eh again to initialize the EH tables. */
600 eh_initialized_p
= true;
604 /* Read the exception table for FN from IB using the data descriptors
608 input_eh_regions (struct lto_input_block
*ib
, struct data_in
*data_in
,
611 HOST_WIDE_INT i
, root_region
, len
;
614 tag
= streamer_read_record_start (ib
);
618 lto_tag_check_range (tag
, LTO_eh_table
, LTO_eh_table
);
620 /* If the file contains EH regions, then it was compiled with
621 -fexceptions. In that case, initialize the backend EH
627 root_region
= streamer_read_hwi (ib
);
628 gcc_assert (root_region
== (int) root_region
);
630 /* Read the EH region array. */
631 len
= streamer_read_hwi (ib
);
632 gcc_assert (len
== (int) len
);
635 vec_safe_grow_cleared (fn
->eh
->region_array
, len
);
636 for (i
= 0; i
< len
; i
++)
638 eh_region r
= input_eh_region (ib
, data_in
, i
);
639 (*fn
->eh
->region_array
)[i
] = r
;
643 /* Read the landing pads. */
644 len
= streamer_read_hwi (ib
);
645 gcc_assert (len
== (int) len
);
648 vec_safe_grow_cleared (fn
->eh
->lp_array
, len
);
649 for (i
= 0; i
< len
; i
++)
651 eh_landing_pad lp
= input_eh_lp (ib
, data_in
, i
);
652 (*fn
->eh
->lp_array
)[i
] = lp
;
656 /* Read the runtime type data. */
657 len
= streamer_read_hwi (ib
);
658 gcc_assert (len
== (int) len
);
661 vec_safe_grow_cleared (fn
->eh
->ttype_data
, len
);
662 for (i
= 0; i
< len
; i
++)
664 tree ttype
= stream_read_tree (ib
, data_in
);
665 (*fn
->eh
->ttype_data
)[i
] = ttype
;
669 /* Read the table of action chains. */
670 len
= streamer_read_hwi (ib
);
671 gcc_assert (len
== (int) len
);
674 if (targetm
.arm_eabi_unwinder
)
676 vec_safe_grow_cleared (fn
->eh
->ehspec_data
.arm_eabi
, len
);
677 for (i
= 0; i
< len
; i
++)
679 tree t
= stream_read_tree (ib
, data_in
);
680 (*fn
->eh
->ehspec_data
.arm_eabi
)[i
] = t
;
685 vec_safe_grow_cleared (fn
->eh
->ehspec_data
.other
, len
);
686 for (i
= 0; i
< len
; i
++)
688 uchar c
= streamer_read_uchar (ib
);
689 (*fn
->eh
->ehspec_data
.other
)[i
] = c
;
694 /* Reconstruct the EH region tree by fixing up the peer/children
696 fixup_eh_region_pointers (fn
, root_region
);
698 tag
= streamer_read_record_start (ib
);
699 lto_tag_check_range (tag
, LTO_null
, LTO_null
);
703 /* Make a new basic block with index INDEX in function FN. */
706 make_new_block (struct function
*fn
, unsigned int index
)
708 basic_block bb
= alloc_block ();
710 SET_BASIC_BLOCK_FOR_FN (fn
, index
, bb
);
711 n_basic_blocks_for_fn (fn
)++;
716 /* Read the CFG for function FN from input block IB. */
719 input_cfg (struct lto_input_block
*ib
, struct data_in
*data_in
,
722 unsigned int bb_count
;
727 init_empty_tree_cfg_for_function (fn
);
728 init_ssa_operands (fn
);
730 profile_status_for_fn (fn
) = streamer_read_enum (ib
, profile_status_d
,
733 bb_count
= streamer_read_uhwi (ib
);
735 last_basic_block_for_fn (fn
) = bb_count
;
736 if (bb_count
> basic_block_info_for_fn (fn
)->length ())
737 vec_safe_grow_cleared (basic_block_info_for_fn (fn
), bb_count
);
739 if (bb_count
> label_to_block_map_for_fn (fn
)->length ())
740 vec_safe_grow_cleared (label_to_block_map_for_fn (fn
), bb_count
);
742 index
= streamer_read_hwi (ib
);
745 basic_block bb
= BASIC_BLOCK_FOR_FN (fn
, index
);
746 unsigned int edge_count
;
749 bb
= make_new_block (fn
, index
);
751 edge_count
= streamer_read_uhwi (ib
);
753 /* Connect up the CFG. */
754 for (i
= 0; i
< edge_count
; i
++)
756 unsigned int dest_index
;
757 unsigned int edge_flags
;
759 profile_probability probability
;
762 dest_index
= streamer_read_uhwi (ib
);
763 probability
= profile_probability::stream_in (ib
);
764 edge_flags
= streamer_read_uhwi (ib
);
766 dest
= BASIC_BLOCK_FOR_FN (fn
, dest_index
);
769 dest
= make_new_block (fn
, dest_index
);
771 e
= make_edge (bb
, dest
, edge_flags
);
772 e
->probability
= probability
;
775 index
= streamer_read_hwi (ib
);
778 p_bb
= ENTRY_BLOCK_PTR_FOR_FN (fn
);
779 index
= streamer_read_hwi (ib
);
782 basic_block bb
= BASIC_BLOCK_FOR_FN (fn
, index
);
786 index
= streamer_read_hwi (ib
);
789 /* ??? The cfgloop interface is tied to cfun. */
790 gcc_assert (cfun
== fn
);
792 /* Input the loop tree. */
793 unsigned n_loops
= streamer_read_uhwi (ib
);
797 struct loops
*loops
= ggc_cleared_alloc
<struct loops
> ();
798 init_loops_structure (fn
, loops
, n_loops
);
799 set_loops_for_fn (fn
, loops
);
801 /* Input each loop and associate it with its loop header so
802 flow_loops_find can rebuild the loop tree. */
803 for (unsigned i
= 1; i
< n_loops
; ++i
)
805 int header_index
= streamer_read_hwi (ib
);
806 if (header_index
== -1)
808 loops
->larray
->quick_push (NULL
);
812 struct loop
*loop
= alloc_loop ();
813 loop
->header
= BASIC_BLOCK_FOR_FN (fn
, header_index
);
814 loop
->header
->loop_father
= loop
;
816 /* Read everything copy_loop_info copies. */
817 loop
->estimate_state
= streamer_read_enum (ib
, loop_estimation
, EST_LAST
);
818 loop
->any_upper_bound
= streamer_read_hwi (ib
);
819 if (loop
->any_upper_bound
)
820 loop
->nb_iterations_upper_bound
= streamer_read_widest_int (ib
);
821 loop
->any_likely_upper_bound
= streamer_read_hwi (ib
);
822 if (loop
->any_likely_upper_bound
)
823 loop
->nb_iterations_likely_upper_bound
= streamer_read_widest_int (ib
);
824 loop
->any_estimate
= streamer_read_hwi (ib
);
825 if (loop
->any_estimate
)
826 loop
->nb_iterations_estimate
= streamer_read_widest_int (ib
);
828 /* Read OMP SIMD related info. */
829 loop
->safelen
= streamer_read_hwi (ib
);
830 loop
->unroll
= streamer_read_hwi (ib
);
831 loop
->dont_vectorize
= streamer_read_hwi (ib
);
832 loop
->force_vectorize
= streamer_read_hwi (ib
);
833 loop
->simduid
= stream_read_tree (ib
, data_in
);
835 place_new_loop (fn
, loop
);
837 /* flow_loops_find doesn't like loops not in the tree, hook them
838 all as siblings of the tree root temporarily. */
839 flow_loop_tree_node_add (loops
->tree_root
, loop
);
842 /* Rebuild the loop tree. */
843 flow_loops_find (loops
);
847 /* Read the SSA names array for function FN from DATA_IN using input
851 input_ssa_names (struct lto_input_block
*ib
, struct data_in
*data_in
,
854 unsigned int i
, size
;
856 size
= streamer_read_uhwi (ib
);
857 init_ssanames (fn
, size
);
859 i
= streamer_read_uhwi (ib
);
865 /* Skip over the elements that had been freed. */
866 while (SSANAMES (fn
)->length () < i
)
867 SSANAMES (fn
)->quick_push (NULL_TREE
);
869 is_default_def
= (streamer_read_uchar (ib
) != 0);
870 name
= stream_read_tree (ib
, data_in
);
871 ssa_name
= make_ssa_name_fn (fn
, name
, NULL
);
875 set_ssa_default_def (cfun
, SSA_NAME_VAR (ssa_name
), ssa_name
);
876 SSA_NAME_DEF_STMT (ssa_name
) = gimple_build_nop ();
879 i
= streamer_read_uhwi (ib
);
884 /* Go through all NODE edges and fixup call_stmt pointers
885 so they point to STMTS. */
888 fixup_call_stmt_edges_1 (struct cgraph_node
*node
, gimple
**stmts
,
891 #define STMT_UID_NOT_IN_RANGE(uid) \
892 (gimple_stmt_max_uid (fn) < uid || uid == 0)
894 struct cgraph_edge
*cedge
;
895 struct ipa_ref
*ref
= NULL
;
898 for (cedge
= node
->callees
; cedge
; cedge
= cedge
->next_callee
)
900 if (STMT_UID_NOT_IN_RANGE (cedge
->lto_stmt_uid
))
901 fatal_error (input_location
,
902 "Cgraph edge statement index out of range");
903 cedge
->call_stmt
= as_a
<gcall
*> (stmts
[cedge
->lto_stmt_uid
- 1]);
904 if (!cedge
->call_stmt
)
905 fatal_error (input_location
,
906 "Cgraph edge statement index not found");
908 for (cedge
= node
->indirect_calls
; cedge
; cedge
= cedge
->next_callee
)
910 if (STMT_UID_NOT_IN_RANGE (cedge
->lto_stmt_uid
))
911 fatal_error (input_location
,
912 "Cgraph edge statement index out of range");
913 cedge
->call_stmt
= as_a
<gcall
*> (stmts
[cedge
->lto_stmt_uid
- 1]);
914 if (!cedge
->call_stmt
)
915 fatal_error (input_location
, "Cgraph edge statement index not found");
917 for (i
= 0; node
->iterate_reference (i
, ref
); i
++)
918 if (ref
->lto_stmt_uid
)
920 if (STMT_UID_NOT_IN_RANGE (ref
->lto_stmt_uid
))
921 fatal_error (input_location
,
922 "Reference statement index out of range");
923 ref
->stmt
= stmts
[ref
->lto_stmt_uid
- 1];
925 fatal_error (input_location
, "Reference statement index not found");
930 /* Fixup call_stmt pointers in NODE and all clones. */
933 fixup_call_stmt_edges (struct cgraph_node
*orig
, gimple
**stmts
)
935 struct cgraph_node
*node
;
938 while (orig
->clone_of
)
939 orig
= orig
->clone_of
;
940 fn
= DECL_STRUCT_FUNCTION (orig
->decl
);
942 if (!orig
->thunk
.thunk_p
)
943 fixup_call_stmt_edges_1 (orig
, stmts
, fn
);
945 for (node
= orig
->clones
; node
!= orig
;)
947 if (!node
->thunk
.thunk_p
)
948 fixup_call_stmt_edges_1 (node
, stmts
, fn
);
951 else if (node
->next_sibling_clone
)
952 node
= node
->next_sibling_clone
;
955 while (node
!= orig
&& !node
->next_sibling_clone
)
956 node
= node
->clone_of
;
958 node
= node
->next_sibling_clone
;
964 /* Input the base body of struct function FN from DATA_IN
965 using input block IB. */
968 input_struct_function_base (struct function
*fn
, struct data_in
*data_in
,
969 struct lto_input_block
*ib
)
974 /* Read the static chain and non-local goto save area. */
975 fn
->static_chain_decl
= stream_read_tree (ib
, data_in
);
976 fn
->nonlocal_goto_save_area
= stream_read_tree (ib
, data_in
);
978 /* Read all the local symbols. */
979 len
= streamer_read_hwi (ib
);
983 vec_safe_grow_cleared (fn
->local_decls
, len
);
984 for (i
= 0; i
< len
; i
++)
986 tree t
= stream_read_tree (ib
, data_in
);
987 (*fn
->local_decls
)[i
] = t
;
991 /* Input the current IL state of the function. */
992 fn
->curr_properties
= streamer_read_uhwi (ib
);
994 /* Read all the attributes for FN. */
995 bp
= streamer_read_bitpack (ib
);
996 fn
->is_thunk
= bp_unpack_value (&bp
, 1);
997 fn
->has_local_explicit_reg_vars
= bp_unpack_value (&bp
, 1);
998 fn
->returns_pcc_struct
= bp_unpack_value (&bp
, 1);
999 fn
->returns_struct
= bp_unpack_value (&bp
, 1);
1000 fn
->can_throw_non_call_exceptions
= bp_unpack_value (&bp
, 1);
1001 fn
->can_delete_dead_exceptions
= bp_unpack_value (&bp
, 1);
1002 fn
->always_inline_functions_inlined
= bp_unpack_value (&bp
, 1);
1003 fn
->after_inlining
= bp_unpack_value (&bp
, 1);
1004 fn
->stdarg
= bp_unpack_value (&bp
, 1);
1005 fn
->has_nonlocal_label
= bp_unpack_value (&bp
, 1);
1006 fn
->has_forced_label_in_static
= bp_unpack_value (&bp
, 1);
1007 fn
->calls_alloca
= bp_unpack_value (&bp
, 1);
1008 fn
->calls_setjmp
= bp_unpack_value (&bp
, 1);
1009 fn
->has_force_vectorize_loops
= bp_unpack_value (&bp
, 1);
1010 fn
->has_simduid_loops
= bp_unpack_value (&bp
, 1);
1011 fn
->va_list_fpr_size
= bp_unpack_value (&bp
, 8);
1012 fn
->va_list_gpr_size
= bp_unpack_value (&bp
, 8);
1013 fn
->last_clique
= bp_unpack_value (&bp
, sizeof (short) * 8);
1015 /* Input the function start and end loci. */
1016 fn
->function_start_locus
= stream_input_location_now (&bp
, data_in
);
1017 fn
->function_end_locus
= stream_input_location_now (&bp
, data_in
);
1021 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1024 input_function (tree fn_decl
, struct data_in
*data_in
,
1025 struct lto_input_block
*ib
, struct lto_input_block
*ib_cfg
)
1027 struct function
*fn
;
1031 struct cgraph_node
*node
;
1033 tag
= streamer_read_record_start (ib
);
1034 lto_tag_check (tag
, LTO_function
);
1036 /* Read decls for parameters and args. */
1037 DECL_RESULT (fn_decl
) = stream_read_tree (ib
, data_in
);
1038 DECL_ARGUMENTS (fn_decl
) = streamer_read_chain (ib
, data_in
);
1040 /* Read debug args if available. */
1041 unsigned n_debugargs
= streamer_read_uhwi (ib
);
1044 vec
<tree
, va_gc
> **debugargs
= decl_debug_args_insert (fn_decl
);
1045 vec_safe_grow (*debugargs
, n_debugargs
);
1046 for (unsigned i
= 0; i
< n_debugargs
; ++i
)
1047 (**debugargs
)[i
] = stream_read_tree (ib
, data_in
);
1050 /* Read the tree of lexical scopes for the function. */
1051 DECL_INITIAL (fn_decl
) = stream_read_tree (ib
, data_in
);
1052 unsigned block_leaf_count
= streamer_read_uhwi (ib
);
1053 while (block_leaf_count
--)
1054 stream_read_tree (ib
, data_in
);
1056 if (!streamer_read_uhwi (ib
))
1059 push_struct_function (fn_decl
);
1060 fn
= DECL_STRUCT_FUNCTION (fn_decl
);
1062 /* We input IL in SSA form. */
1063 cfun
->gimple_df
->in_ssa_p
= true;
1065 gimple_register_cfg_hooks ();
1067 node
= cgraph_node::get (fn_decl
);
1069 node
= cgraph_node::create (fn_decl
);
1070 input_struct_function_base (fn
, data_in
, ib
);
1071 input_cfg (ib_cfg
, data_in
, fn
);
1073 /* Read all the SSA names. */
1074 input_ssa_names (ib
, data_in
, fn
);
1076 /* Read the exception handling regions in the function. */
1077 input_eh_regions (ib
, data_in
, fn
);
1079 gcc_assert (DECL_INITIAL (fn_decl
));
1080 DECL_SAVED_TREE (fn_decl
) = NULL_TREE
;
1082 /* Read all the basic blocks. */
1083 tag
= streamer_read_record_start (ib
);
1086 input_bb (ib
, tag
, data_in
, fn
,
1087 node
->count_materialization_scale
);
1088 tag
= streamer_read_record_start (ib
);
1091 /* Fix up the call statements that are mentioned in the callgraph
1093 set_gimple_stmt_max_uid (cfun
, 0);
1094 FOR_ALL_BB_FN (bb
, cfun
)
1096 gimple_stmt_iterator gsi
;
1097 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1099 gimple
*stmt
= gsi_stmt (gsi
);
1100 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
1102 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1104 gimple
*stmt
= gsi_stmt (gsi
);
1105 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
1108 stmts
= (gimple
**) xcalloc (gimple_stmt_max_uid (fn
), sizeof (gimple
*));
1109 FOR_ALL_BB_FN (bb
, cfun
)
1111 gimple_stmt_iterator bsi
= gsi_start_phis (bb
);
1112 while (!gsi_end_p (bsi
))
1114 gimple
*stmt
= gsi_stmt (bsi
);
1116 stmts
[gimple_uid (stmt
)] = stmt
;
1118 bsi
= gsi_start_bb (bb
);
1119 while (!gsi_end_p (bsi
))
1121 gimple
*stmt
= gsi_stmt (bsi
);
1122 bool remove
= false;
1123 /* If we're recompiling LTO objects with debug stmts but
1124 we're not supposed to have debug stmts, remove them now.
1125 We can't remove them earlier because this would cause uid
1126 mismatches in fixups, but we can do it at this point, as
1127 long as debug stmts don't require fixups.
1128 Similarly remove all IFN_*SAN_* internal calls */
1131 if (is_gimple_debug (stmt
)
1132 && (gimple_debug_nonbind_marker_p (stmt
)
1133 ? !MAY_HAVE_DEBUG_MARKER_STMTS
1134 : !MAY_HAVE_DEBUG_BIND_STMTS
))
1136 if (is_gimple_call (stmt
)
1137 && gimple_call_internal_p (stmt
))
1139 bool replace
= false;
1140 switch (gimple_call_internal_fn (stmt
))
1142 case IFN_UBSAN_NULL
:
1144 & (SANITIZE_NULL
| SANITIZE_ALIGNMENT
)) == 0)
1147 case IFN_UBSAN_BOUNDS
:
1148 if ((flag_sanitize
& SANITIZE_BOUNDS
) == 0)
1151 case IFN_UBSAN_VPTR
:
1152 if ((flag_sanitize
& SANITIZE_VPTR
) == 0)
1155 case IFN_UBSAN_OBJECT_SIZE
:
1156 if ((flag_sanitize
& SANITIZE_OBJECT_SIZE
) == 0)
1160 if ((flag_sanitize
& SANITIZE_POINTER_OVERFLOW
) == 0)
1164 if ((flag_sanitize
& SANITIZE_ADDRESS
) == 0)
1167 case IFN_TSAN_FUNC_EXIT
:
1168 if ((flag_sanitize
& SANITIZE_THREAD
) == 0)
1176 gimple_call_set_internal_fn (as_a
<gcall
*> (stmt
),
1184 gimple_stmt_iterator gsi
= bsi
;
1186 unlink_stmt_vdef (stmt
);
1187 release_defs (stmt
);
1188 gsi_remove (&gsi
, true);
1193 stmts
[gimple_uid (stmt
)] = stmt
;
1195 /* Remember that the input function has begin stmt
1196 markers, so that we know to expect them when emitting
1198 if (!cfun
->debug_nonbind_markers
1199 && gimple_debug_nonbind_marker_p (stmt
))
1200 cfun
->debug_nonbind_markers
= true;
1205 /* Set the gimple body to the statement sequence in the entry
1206 basic block. FIXME lto, this is fairly hacky. The existence
1207 of a gimple body is used by the cgraph routines, but we should
1208 really use the presence of the CFG. */
1210 edge_iterator ei
= ei_start (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
);
1211 gimple_set_body (fn_decl
, bb_seq (ei_edge (ei
)->dest
));
1214 update_max_bb_count ();
1215 fixup_call_stmt_edges (node
, stmts
);
1216 execute_all_ipa_stmt_fixups (node
, stmts
);
1218 update_ssa (TODO_update_ssa_only_virtuals
);
1219 free_dominance_info (CDI_DOMINATORS
);
1220 free_dominance_info (CDI_POST_DOMINATORS
);
1225 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1228 input_constructor (tree var
, struct data_in
*data_in
,
1229 struct lto_input_block
*ib
)
1231 DECL_INITIAL (var
) = stream_read_tree (ib
, data_in
);
1235 /* Read the body from DATA for function NODE and fill it in.
1236 FILE_DATA are the global decls and types. SECTION_TYPE is either
1237 LTO_section_function_body or LTO_section_static_initializer. If
1238 section type is LTO_section_function_body, FN must be the decl for
1242 lto_read_body_or_constructor (struct lto_file_decl_data
*file_data
, struct symtab_node
*node
,
1243 const char *data
, enum lto_section_type section_type
)
1245 const struct lto_function_header
*header
;
1246 struct data_in
*data_in
;
1250 tree fn_decl
= node
->decl
;
1252 header
= (const struct lto_function_header
*) data
;
1253 if (TREE_CODE (node
->decl
) == FUNCTION_DECL
)
1255 cfg_offset
= sizeof (struct lto_function_header
);
1256 main_offset
= cfg_offset
+ header
->cfg_size
;
1257 string_offset
= main_offset
+ header
->main_size
;
1261 main_offset
= sizeof (struct lto_function_header
);
1262 string_offset
= main_offset
+ header
->main_size
;
1265 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
1266 header
->string_size
, vNULL
);
1268 if (section_type
== LTO_section_function_body
)
1270 struct lto_in_decl_state
*decl_state
;
1273 gcc_checking_assert (node
);
1275 /* Use the function's decl state. */
1276 decl_state
= lto_get_function_in_decl_state (file_data
, fn_decl
);
1277 gcc_assert (decl_state
);
1278 file_data
->current_decl_state
= decl_state
;
1281 /* Set up the struct function. */
1282 from
= data_in
->reader_cache
->nodes
.length ();
1283 lto_input_block
ib_main (data
+ main_offset
, header
->main_size
,
1284 file_data
->mode_table
);
1285 if (TREE_CODE (node
->decl
) == FUNCTION_DECL
)
1287 lto_input_block
ib_cfg (data
+ cfg_offset
, header
->cfg_size
,
1288 file_data
->mode_table
);
1289 input_function (fn_decl
, data_in
, &ib_main
, &ib_cfg
);
1292 input_constructor (fn_decl
, data_in
, &ib_main
);
1293 data_in
->location_cache
.apply_location_cache ();
1294 /* And fixup types we streamed locally. */
1296 struct streamer_tree_cache_d
*cache
= data_in
->reader_cache
;
1297 unsigned len
= cache
->nodes
.length ();
1299 for (i
= len
; i
-- > from
;)
1301 tree t
= streamer_tree_cache_get_tree (cache
, i
);
1307 gcc_assert (TYPE_CANONICAL (t
) == NULL_TREE
);
1308 if (type_with_alias_set_p (t
)
1309 && canonical_type_used_p (t
))
1310 TYPE_CANONICAL (t
) = TYPE_MAIN_VARIANT (t
);
1311 if (TYPE_MAIN_VARIANT (t
) != t
)
1313 gcc_assert (TYPE_NEXT_VARIANT (t
) == NULL_TREE
);
1314 TYPE_NEXT_VARIANT (t
)
1315 = TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t
));
1316 TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t
)) = t
;
1322 /* Restore decl state */
1323 file_data
->current_decl_state
= file_data
->global_decl_state
;
1326 lto_data_in_delete (data_in
);
1330 /* Read the body of NODE using DATA. FILE_DATA holds the global
1334 lto_input_function_body (struct lto_file_decl_data
*file_data
,
1335 struct cgraph_node
*node
, const char *data
)
1337 lto_read_body_or_constructor (file_data
, node
, data
, LTO_section_function_body
);
1340 /* Read the body of NODE using DATA. FILE_DATA holds the global
1344 lto_input_variable_constructor (struct lto_file_decl_data
*file_data
,
1345 struct varpool_node
*node
, const char *data
)
1347 lto_read_body_or_constructor (file_data
, node
, data
, LTO_section_function_body
);
1351 /* Queue of acummulated decl -> DIE mappings. Similar to locations those
1352 are only applied to prevailing tree nodes during tree merging. */
1353 vec
<dref_entry
> dref_queue
;
1355 /* Read the physical representation of a tree node EXPR from
1356 input block IB using the per-file context in DATA_IN. */
1359 lto_read_tree_1 (struct lto_input_block
*ib
, struct data_in
*data_in
, tree expr
)
1361 /* Read all the bitfield values in EXPR. Note that for LTO, we
1362 only write language-independent bitfields, so no more unpacking is
1364 streamer_read_tree_bitfields (ib
, data_in
, expr
);
1366 /* Read all the pointer fields in EXPR. */
1367 streamer_read_tree_body (ib
, data_in
, expr
);
1369 /* Read any LTO-specific data not read by the tree streamer. */
1371 && TREE_CODE (expr
) != FUNCTION_DECL
1372 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
1373 DECL_INITIAL (expr
) = stream_read_tree (ib
, data_in
);
1375 /* Stream references to early generated DIEs. Keep in sync with the
1376 trees handled in dwarf2out_register_external_die. */
1378 && TREE_CODE (expr
) != FIELD_DECL
1379 && TREE_CODE (expr
) != DEBUG_EXPR_DECL
1380 && TREE_CODE (expr
) != TYPE_DECL
)
1381 || TREE_CODE (expr
) == BLOCK
)
1383 const char *str
= streamer_read_string (data_in
, ib
);
1386 unsigned HOST_WIDE_INT off
= streamer_read_uhwi (ib
);
1387 dref_entry e
= { expr
, str
, off
};
1388 dref_queue
.safe_push (e
);
1393 /* Read the physical representation of a tree node with tag TAG from
1394 input block IB using the per-file context in DATA_IN. */
1397 lto_read_tree (struct lto_input_block
*ib
, struct data_in
*data_in
,
1398 enum LTO_tags tag
, hashval_t hash
)
1400 /* Instantiate a new tree node. */
1401 tree result
= streamer_alloc_tree (ib
, data_in
, tag
);
1403 /* Enter RESULT in the reader cache. This will make RESULT
1404 available so that circular references in the rest of the tree
1405 structure can be resolved in subsequent calls to stream_read_tree. */
1406 streamer_tree_cache_append (data_in
->reader_cache
, result
, hash
);
1408 lto_read_tree_1 (ib
, data_in
, result
);
1410 /* end_marker = */ streamer_read_uchar (ib
);
1416 /* Populate the reader cache with trees materialized from the SCC
1417 following in the IB, DATA_IN stream. */
1420 lto_input_scc (struct lto_input_block
*ib
, struct data_in
*data_in
,
1421 unsigned *len
, unsigned *entry_len
)
1423 /* A blob of unnamed tree nodes, fill the cache from it and
1425 unsigned size
= streamer_read_uhwi (ib
);
1426 hashval_t scc_hash
= streamer_read_uhwi (ib
);
1427 unsigned scc_entry_len
= 1;
1431 enum LTO_tags tag
= streamer_read_record_start (ib
);
1432 lto_input_tree_1 (ib
, data_in
, tag
, scc_hash
);
1436 unsigned int first
= data_in
->reader_cache
->nodes
.length ();
1439 scc_entry_len
= streamer_read_uhwi (ib
);
1441 /* Materialize size trees by reading their headers. */
1442 for (unsigned i
= 0; i
< size
; ++i
)
1444 enum LTO_tags tag
= streamer_read_record_start (ib
);
1446 || (tag
>= LTO_field_decl_ref
&& tag
<= LTO_global_decl_ref
)
1447 || tag
== LTO_tree_pickle_reference
1448 || tag
== LTO_integer_cst
1449 || tag
== LTO_tree_scc
)
1452 result
= streamer_alloc_tree (ib
, data_in
, tag
);
1453 streamer_tree_cache_append (data_in
->reader_cache
, result
, 0);
1456 /* Read the tree bitpacks and references. */
1457 for (unsigned i
= 0; i
< size
; ++i
)
1459 result
= streamer_tree_cache_get_tree (data_in
->reader_cache
,
1461 lto_read_tree_1 (ib
, data_in
, result
);
1462 /* end_marker = */ streamer_read_uchar (ib
);
1467 *entry_len
= scc_entry_len
;
1472 /* Read a tree from input block IB using the per-file context in
1473 DATA_IN. This context is used, for example, to resolve references
1474 to previously read nodes. */
1477 lto_input_tree_1 (struct lto_input_block
*ib
, struct data_in
*data_in
,
1478 enum LTO_tags tag
, hashval_t hash
)
1482 gcc_assert ((unsigned) tag
< (unsigned) LTO_NUM_TAGS
);
1484 if (tag
== LTO_null
)
1486 else if (tag
>= LTO_field_decl_ref
&& tag
<= LTO_namelist_decl_ref
)
1488 /* If TAG is a reference to an indexable tree, the next value
1489 in IB is the index into the table where we expect to find
1491 result
= lto_input_tree_ref (ib
, data_in
, cfun
, tag
);
1493 else if (tag
== LTO_tree_pickle_reference
)
1495 /* If TAG is a reference to a previously read tree, look it up in
1496 the reader cache. */
1497 result
= streamer_get_pickled_tree (ib
, data_in
);
1499 else if (tag
== LTO_integer_cst
)
1501 /* For shared integer constants in singletons we can use the
1502 existing tree integer constant merging code. */
1503 tree type
= stream_read_tree (ib
, data_in
);
1504 unsigned HOST_WIDE_INT len
= streamer_read_uhwi (ib
);
1505 unsigned HOST_WIDE_INT i
;
1506 HOST_WIDE_INT a
[WIDE_INT_MAX_ELTS
];
1508 for (i
= 0; i
< len
; i
++)
1509 a
[i
] = streamer_read_hwi (ib
);
1510 gcc_assert (TYPE_PRECISION (type
) <= MAX_BITSIZE_MODE_ANY_INT
);
1511 result
= wide_int_to_tree (type
, wide_int::from_array
1512 (a
, len
, TYPE_PRECISION (type
)));
1513 streamer_tree_cache_append (data_in
->reader_cache
, result
, hash
);
1515 else if (tag
== LTO_tree_scc
)
1519 /* Otherwise, materialize a new node from IB. */
1520 result
= lto_read_tree (ib
, data_in
, tag
, hash
);
1527 lto_input_tree (struct lto_input_block
*ib
, struct data_in
*data_in
)
1531 /* Input and skip SCCs. */
1532 while ((tag
= streamer_read_record_start (ib
)) == LTO_tree_scc
)
1534 unsigned len
, entry_len
;
1535 lto_input_scc (ib
, data_in
, &len
, &entry_len
);
1537 /* Register DECLs with the debuginfo machinery. */
1538 while (!dref_queue
.is_empty ())
1540 dref_entry e
= dref_queue
.pop ();
1541 debug_hooks
->register_external_die (e
.decl
, e
.sym
, e
.off
);
1544 return lto_input_tree_1 (ib
, data_in
, tag
, 0);
1548 /* Input toplevel asms. */
1551 lto_input_toplevel_asms (struct lto_file_decl_data
*file_data
, int order_base
)
1554 const char *data
= lto_get_section_data (file_data
, LTO_section_asm
,
1556 const struct lto_simple_header_with_strings
*header
1557 = (const struct lto_simple_header_with_strings
*) data
;
1559 struct data_in
*data_in
;
1565 string_offset
= sizeof (*header
) + header
->main_size
;
1567 lto_input_block
ib (data
+ sizeof (*header
), header
->main_size
,
1568 file_data
->mode_table
);
1570 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
1571 header
->string_size
, vNULL
);
1573 while ((str
= streamer_read_string_cst (data_in
, &ib
)))
1575 asm_node
*node
= symtab
->finalize_toplevel_asm (str
);
1576 node
->order
= streamer_read_hwi (&ib
) + order_base
;
1577 if (node
->order
>= symtab
->order
)
1578 symtab
->order
= node
->order
+ 1;
1581 lto_data_in_delete (data_in
);
1583 lto_free_section_data (file_data
, LTO_section_asm
, NULL
, data
, len
);
1587 /* Input mode table. */
1590 lto_input_mode_table (struct lto_file_decl_data
*file_data
)
1593 const char *data
= lto_get_section_data (file_data
, LTO_section_mode_table
,
1597 internal_error ("cannot read LTO mode table from %s",
1598 file_data
->file_name
);
1602 unsigned char *table
= ggc_cleared_vec_alloc
<unsigned char> (1 << 8);
1603 file_data
->mode_table
= table
;
1604 const struct lto_simple_header_with_strings
*header
1605 = (const struct lto_simple_header_with_strings
*) data
;
1607 struct data_in
*data_in
;
1608 string_offset
= sizeof (*header
) + header
->main_size
;
1610 lto_input_block
ib (data
+ sizeof (*header
), header
->main_size
, NULL
);
1611 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
1612 header
->string_size
, vNULL
);
1613 bitpack_d bp
= streamer_read_bitpack (&ib
);
1615 table
[VOIDmode
] = VOIDmode
;
1616 table
[BLKmode
] = BLKmode
;
1618 while ((m
= bp_unpack_value (&bp
, 8)) != VOIDmode
)
1620 enum mode_class mclass
1621 = bp_unpack_enum (&bp
, mode_class
, MAX_MODE_CLASS
);
1622 unsigned int size
= bp_unpack_value (&bp
, 8);
1623 unsigned int prec
= bp_unpack_value (&bp
, 16);
1624 machine_mode inner
= (machine_mode
) bp_unpack_value (&bp
, 8);
1625 unsigned int nunits
= bp_unpack_value (&bp
, 8);
1626 unsigned int ibit
= 0, fbit
= 0;
1627 unsigned int real_fmt_len
= 0;
1628 const char *real_fmt_name
= NULL
;
1635 ibit
= bp_unpack_value (&bp
, 8);
1636 fbit
= bp_unpack_value (&bp
, 8);
1639 case MODE_DECIMAL_FLOAT
:
1640 real_fmt_name
= bp_unpack_indexed_string (data_in
, &bp
,
1646 /* First search just the GET_CLASS_NARROWEST_MODE to wider modes,
1647 if not found, fallback to all modes. */
1649 for (pass
= 0; pass
< 2; pass
++)
1650 for (machine_mode mr
= pass
? VOIDmode
1651 : GET_CLASS_NARROWEST_MODE (mclass
);
1652 pass
? mr
< MAX_MACHINE_MODE
: mr
!= VOIDmode
;
1653 pass
? mr
= (machine_mode
) (mr
+ 1)
1654 : mr
= GET_MODE_WIDER_MODE (mr
).else_void ())
1655 if (GET_MODE_CLASS (mr
) != mclass
1656 || GET_MODE_SIZE (mr
) != size
1657 || GET_MODE_PRECISION (mr
) != prec
1659 ? GET_MODE_INNER (mr
) != mr
1660 : GET_MODE_INNER (mr
) != table
[(int) inner
])
1661 || GET_MODE_IBIT (mr
) != ibit
1662 || GET_MODE_FBIT (mr
) != fbit
1663 || GET_MODE_NUNITS (mr
) != nunits
)
1665 else if ((mclass
== MODE_FLOAT
|| mclass
== MODE_DECIMAL_FLOAT
)
1666 && strcmp (REAL_MODE_FORMAT (mr
)->name
, real_fmt_name
) != 0)
1674 unsigned int mname_len
;
1675 const char *mname
= bp_unpack_indexed_string (data_in
, &bp
, &mname_len
);
1680 case MODE_VECTOR_INT
:
1681 case MODE_VECTOR_FLOAT
:
1682 case MODE_VECTOR_FRACT
:
1683 case MODE_VECTOR_UFRACT
:
1684 case MODE_VECTOR_ACCUM
:
1685 case MODE_VECTOR_UACCUM
:
1686 /* For unsupported vector modes just use BLKmode,
1687 if the scalar mode is supported. */
1688 if (table
[(int) inner
] != VOIDmode
)
1695 fatal_error (UNKNOWN_LOCATION
, "unsupported mode %s\n", mname
);
1700 lto_data_in_delete (data_in
);
1702 lto_free_section_data (file_data
, LTO_section_mode_table
, NULL
, data
, len
);
1706 /* Initialization for the LTO reader. */
1709 lto_reader_init (void)
1711 lto_streamer_init ();
1712 file_name_hash_table
1713 = new hash_table
<freeing_string_slot_hasher
> (37);
1717 /* Create a new data_in object for FILE_DATA. STRINGS is the string
1718 table to use with LEN strings. RESOLUTIONS is the vector of linker
1719 resolutions (NULL if not using a linker plugin). */
1722 lto_data_in_create (struct lto_file_decl_data
*file_data
, const char *strings
,
1724 vec
<ld_plugin_symbol_resolution_t
> resolutions
)
1726 struct data_in
*data_in
= new (struct data_in
);
1727 data_in
->file_data
= file_data
;
1728 data_in
->strings
= strings
;
1729 data_in
->strings_len
= len
;
1730 data_in
->globals_resolution
= resolutions
;
1731 data_in
->reader_cache
= streamer_tree_cache_create (false, false, true);
1736 /* Remove DATA_IN. */
1739 lto_data_in_delete (struct data_in
*data_in
)
1741 data_in
->globals_resolution
.release ();
1742 streamer_tree_cache_delete (data_in
->reader_cache
);