1 /* Read the GIMPLE representation from a file stream.
3 Copyright (C) 2009-2016 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"
46 struct freeing_string_slot_hasher
: string_slot_hasher
48 static inline void remove (value_type
*);
52 freeing_string_slot_hasher::remove (value_type
*v
)
57 /* The table to hold the file names. */
58 static hash_table
<freeing_string_slot_hasher
> *file_name_hash_table
;
61 /* Check that tag ACTUAL has one of the given values. NUM_TAGS is the
62 number of valid tag values to check. */
65 lto_tag_check_set (enum LTO_tags actual
, int ntags
, ...)
71 for (i
= 0; i
< ntags
; i
++)
72 if ((unsigned) actual
== va_arg (ap
, unsigned))
79 internal_error ("bytecode stream: unexpected tag %s", lto_tag_name (actual
));
83 /* Read LENGTH bytes from STREAM to ADDR. */
86 lto_input_data_block (struct lto_input_block
*ib
, void *addr
, size_t length
)
89 unsigned char *const buffer
= (unsigned char *const) addr
;
91 for (i
= 0; i
< length
; i
++)
92 buffer
[i
] = streamer_read_uchar (ib
);
96 /* Lookup STRING in file_name_hash_table. If found, return the existing
97 string, otherwise insert STRING as the canonical version. */
100 canon_file_name (const char *string
)
103 struct string_slot s_slot
;
104 size_t len
= strlen (string
);
109 slot
= file_name_hash_table
->find_slot (&s_slot
, INSERT
);
113 struct string_slot
*new_slot
;
115 saved_string
= (char *) xmalloc (len
+ 1);
116 new_slot
= XCNEW (struct string_slot
);
117 memcpy (saved_string
, string
, len
+ 1);
118 new_slot
->s
= saved_string
;
125 struct string_slot
*old_slot
= *slot
;
130 /* Pointer to currently alive instance of lto_location_cache. */
132 lto_location_cache
*lto_location_cache::current_cache
;
134 /* Sort locations in source order. Start with file from last application. */
137 lto_location_cache::cmp_loc (const void *pa
, const void *pb
)
139 const cached_location
*a
= ((const cached_location
*)pa
);
140 const cached_location
*b
= ((const cached_location
*)pb
);
141 const char *current_file
= current_cache
->current_file
;
142 int current_line
= current_cache
->current_line
;
144 if (a
->file
== current_file
&& b
->file
!= current_file
)
146 if (a
->file
!= current_file
&& b
->file
== current_file
)
148 if (a
->file
== current_file
&& b
->file
== current_file
)
150 if (a
->line
== current_line
&& b
->line
!= current_line
)
152 if (a
->line
!= current_line
&& b
->line
== current_line
)
155 if (a
->file
!= b
->file
)
156 return strcmp (a
->file
, b
->file
);
157 if (a
->sysp
!= b
->sysp
)
158 return a
->sysp
? 1 : -1;
159 if (a
->line
!= b
->line
)
160 return a
->line
- b
->line
;
161 return a
->col
- b
->col
;
164 /* Apply all changes in location cache. Add locations into linemap and patch
168 lto_location_cache::apply_location_cache ()
170 static const char *prev_file
;
171 if (!loc_cache
.length ())
173 if (loc_cache
.length () > 1)
174 loc_cache
.qsort (cmp_loc
);
176 for (unsigned int i
= 0; i
< loc_cache
.length (); i
++)
178 struct cached_location loc
= loc_cache
[i
];
180 if (current_file
!= loc
.file
)
181 linemap_add (line_table
, prev_file
? LC_RENAME
: LC_ENTER
,
182 loc
.sysp
, loc
.file
, loc
.line
);
183 else if (current_line
!= loc
.line
)
187 for (unsigned int j
= i
+ 1; j
< loc_cache
.length (); j
++)
188 if (loc
.file
!= loc_cache
[j
].file
189 || loc
.line
!= loc_cache
[j
].line
)
191 else if (max
< loc_cache
[j
].col
)
192 max
= loc_cache
[j
].col
;
193 linemap_line_start (line_table
, loc
.line
, max
+ 1);
195 gcc_assert (*loc
.loc
== BUILTINS_LOCATION
+ 1);
196 if (current_file
== loc
.file
&& current_line
== loc
.line
197 && current_col
== loc
.col
)
198 *loc
.loc
= current_loc
;
200 current_loc
= *loc
.loc
= linemap_position_for_column (line_table
,
202 current_line
= loc
.line
;
203 prev_file
= current_file
= loc
.file
;
204 current_col
= loc
.col
;
206 loc_cache
.truncate (0);
211 /* Tree merging did not suceed; mark all changes in the cache as accepted. */
214 lto_location_cache::accept_location_cache ()
216 gcc_assert (current_cache
== this);
217 accepted_length
= loc_cache
.length ();
220 /* Tree merging did suceed; throw away recent changes. */
223 lto_location_cache::revert_location_cache ()
225 loc_cache
.truncate (accepted_length
);
228 /* Read a location bitpack from input block IB and either update *LOC directly
229 or add it to the location cache.
230 It is neccesary to call apply_location_cache to get *LOC updated. */
233 lto_location_cache::input_location (location_t
*loc
, struct bitpack_d
*bp
,
234 struct data_in
*data_in
)
236 static const char *stream_file
;
237 static int stream_line
;
238 static int stream_col
;
239 static bool stream_sysp
;
240 bool file_change
, line_change
, column_change
;
242 gcc_assert (current_cache
== this);
244 *loc
= bp_unpack_int_in_range (bp
, "location", 0, RESERVED_LOCATION_COUNT
);
246 if (*loc
< RESERVED_LOCATION_COUNT
)
249 /* Keep value RESERVED_LOCATION_COUNT in *loc as linemap lookups will
252 file_change
= bp_unpack_value (bp
, 1);
253 line_change
= bp_unpack_value (bp
, 1);
254 column_change
= bp_unpack_value (bp
, 1);
258 stream_file
= canon_file_name (bp_unpack_string (data_in
, bp
));
259 stream_sysp
= bp_unpack_value (bp
, 1);
263 stream_line
= bp_unpack_var_len_unsigned (bp
);
266 stream_col
= bp_unpack_var_len_unsigned (bp
);
268 /* This optimization saves location cache operations druing gimple
271 if (current_file
== stream_file
&& current_line
== stream_line
272 && current_col
== stream_col
&& current_sysp
== stream_sysp
)
278 struct cached_location entry
279 = {stream_file
, loc
, stream_line
, stream_col
, stream_sysp
};
280 loc_cache
.safe_push (entry
);
283 /* Read a location bitpack from input block IB and either update *LOC directly
284 or add it to the location cache.
285 It is neccesary to call apply_location_cache to get *LOC updated. */
288 lto_input_location (location_t
*loc
, struct bitpack_d
*bp
,
289 struct data_in
*data_in
)
291 data_in
->location_cache
.input_location (loc
, bp
, data_in
);
294 /* Read location and return it instead of going through location caching.
295 This should be used only when the resulting location is not going to be
299 stream_input_location_now (struct bitpack_d
*bp
, struct data_in
*data_in
)
302 stream_input_location (&loc
, bp
, data_in
);
303 data_in
->location_cache
.apply_location_cache ();
307 /* Read a reference to a tree node from DATA_IN using input block IB.
308 TAG is the expected node that should be found in IB, if TAG belongs
309 to one of the indexable trees, expect to read a reference index to
310 be looked up in one of the symbol tables, otherwise read the pysical
311 representation of the tree using stream_read_tree. FN is the
312 function scope for the read tree. */
315 lto_input_tree_ref (struct lto_input_block
*ib
, struct data_in
*data_in
,
316 struct function
*fn
, enum LTO_tags tag
)
318 unsigned HOST_WIDE_INT ix_u
;
319 tree result
= NULL_TREE
;
321 lto_tag_check_range (tag
, LTO_field_decl_ref
, LTO_namelist_decl_ref
);
326 ix_u
= streamer_read_uhwi (ib
);
327 result
= lto_file_decl_data_get_type (data_in
->file_data
, ix_u
);
330 case LTO_ssa_name_ref
:
331 ix_u
= streamer_read_uhwi (ib
);
332 result
= (*SSANAMES (fn
))[ix_u
];
335 case LTO_field_decl_ref
:
336 ix_u
= streamer_read_uhwi (ib
);
337 result
= lto_file_decl_data_get_field_decl (data_in
->file_data
, ix_u
);
340 case LTO_function_decl_ref
:
341 ix_u
= streamer_read_uhwi (ib
);
342 result
= lto_file_decl_data_get_fn_decl (data_in
->file_data
, ix_u
);
345 case LTO_type_decl_ref
:
346 ix_u
= streamer_read_uhwi (ib
);
347 result
= lto_file_decl_data_get_type_decl (data_in
->file_data
, ix_u
);
350 case LTO_namespace_decl_ref
:
351 ix_u
= streamer_read_uhwi (ib
);
352 result
= lto_file_decl_data_get_namespace_decl (data_in
->file_data
, ix_u
);
355 case LTO_global_decl_ref
:
356 case LTO_result_decl_ref
:
357 case LTO_const_decl_ref
:
358 case LTO_imported_decl_ref
:
359 case LTO_label_decl_ref
:
360 case LTO_translation_unit_decl_ref
:
361 case LTO_namelist_decl_ref
:
362 ix_u
= streamer_read_uhwi (ib
);
363 result
= lto_file_decl_data_get_var_decl (data_in
->file_data
, ix_u
);
376 /* Read and return a double-linked list of catch handlers from input
377 block IB, using descriptors in DATA_IN. */
379 static struct eh_catch_d
*
380 lto_input_eh_catch_list (struct lto_input_block
*ib
, struct data_in
*data_in
,
386 *last_p
= first
= NULL
;
387 tag
= streamer_read_record_start (ib
);
393 lto_tag_check_range (tag
, LTO_eh_catch
, LTO_eh_catch
);
395 /* Read the catch node. */
396 n
= ggc_cleared_alloc
<eh_catch_d
> ();
397 n
->type_list
= stream_read_tree (ib
, data_in
);
398 n
->filter_list
= stream_read_tree (ib
, data_in
);
399 n
->label
= stream_read_tree (ib
, data_in
);
401 /* Register all the types in N->FILTER_LIST. */
402 for (list
= n
->filter_list
; list
; list
= TREE_CHAIN (list
))
403 add_type_for_runtime (TREE_VALUE (list
));
405 /* Chain N to the end of the list. */
407 (*last_p
)->next_catch
= n
;
408 n
->prev_catch
= *last_p
;
411 /* Set the head of the list the first time through the loop. */
415 tag
= streamer_read_record_start (ib
);
422 /* Read and return EH region IX from input block IB, using descriptors
426 input_eh_region (struct lto_input_block
*ib
, struct data_in
*data_in
, int ix
)
431 /* Read the region header. */
432 tag
= streamer_read_record_start (ib
);
436 r
= ggc_cleared_alloc
<eh_region_d
> ();
437 r
->index
= streamer_read_hwi (ib
);
439 gcc_assert (r
->index
== ix
);
441 /* Read all the region pointers as region numbers. We'll fix up
442 the pointers once the whole array has been read. */
443 r
->outer
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
444 r
->inner
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
445 r
->next_peer
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
449 case LTO_ert_cleanup
:
450 r
->type
= ERT_CLEANUP
;
455 struct eh_catch_d
*last_catch
;
457 r
->u
.eh_try
.first_catch
= lto_input_eh_catch_list (ib
, data_in
,
459 r
->u
.eh_try
.last_catch
= last_catch
;
463 case LTO_ert_allowed_exceptions
:
467 r
->type
= ERT_ALLOWED_EXCEPTIONS
;
468 r
->u
.allowed
.type_list
= stream_read_tree (ib
, data_in
);
469 r
->u
.allowed
.label
= stream_read_tree (ib
, data_in
);
470 r
->u
.allowed
.filter
= streamer_read_uhwi (ib
);
472 for (l
= r
->u
.allowed
.type_list
; l
; l
= TREE_CHAIN (l
))
473 add_type_for_runtime (TREE_VALUE (l
));
477 case LTO_ert_must_not_throw
:
479 r
->type
= ERT_MUST_NOT_THROW
;
480 r
->u
.must_not_throw
.failure_decl
= stream_read_tree (ib
, data_in
);
481 bitpack_d bp
= streamer_read_bitpack (ib
);
482 r
->u
.must_not_throw
.failure_loc
483 = stream_input_location_now (&bp
, data_in
);
491 r
->landing_pads
= (eh_landing_pad
) (intptr_t) streamer_read_hwi (ib
);
497 /* Read and return EH landing pad IX from input block IB, using descriptors
500 static eh_landing_pad
501 input_eh_lp (struct lto_input_block
*ib
, struct data_in
*data_in
, int ix
)
506 /* Read the landing pad header. */
507 tag
= streamer_read_record_start (ib
);
511 lto_tag_check_range (tag
, LTO_eh_landing_pad
, LTO_eh_landing_pad
);
513 lp
= ggc_cleared_alloc
<eh_landing_pad_d
> ();
514 lp
->index
= streamer_read_hwi (ib
);
515 gcc_assert (lp
->index
== ix
);
516 lp
->next_lp
= (eh_landing_pad
) (intptr_t) streamer_read_hwi (ib
);
517 lp
->region
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
518 lp
->post_landing_pad
= stream_read_tree (ib
, data_in
);
524 /* After reading the EH regions, pointers to peer and children regions
525 are region numbers. This converts all these region numbers into
526 real pointers into the rematerialized regions for FN. ROOT_REGION
527 is the region number for the root EH region in FN. */
530 fixup_eh_region_pointers (struct function
*fn
, HOST_WIDE_INT root_region
)
533 vec
<eh_region
, va_gc
> *eh_array
= fn
->eh
->region_array
;
534 vec
<eh_landing_pad
, va_gc
> *lp_array
= fn
->eh
->lp_array
;
538 gcc_assert (eh_array
&& lp_array
);
540 gcc_assert (root_region
>= 0);
541 fn
->eh
->region_tree
= (*eh_array
)[root_region
];
543 #define FIXUP_EH_REGION(r) (r) = (*eh_array)[(HOST_WIDE_INT) (intptr_t) (r)]
544 #define FIXUP_EH_LP(p) (p) = (*lp_array)[(HOST_WIDE_INT) (intptr_t) (p)]
546 /* Convert all the index numbers stored in pointer fields into
547 pointers to the corresponding slots in the EH region array. */
548 FOR_EACH_VEC_ELT (*eh_array
, i
, r
)
550 /* The array may contain NULL regions. */
554 gcc_assert (i
== (unsigned) r
->index
);
555 FIXUP_EH_REGION (r
->outer
);
556 FIXUP_EH_REGION (r
->inner
);
557 FIXUP_EH_REGION (r
->next_peer
);
558 FIXUP_EH_LP (r
->landing_pads
);
561 /* Convert all the index numbers stored in pointer fields into
562 pointers to the corresponding slots in the EH landing pad array. */
563 FOR_EACH_VEC_ELT (*lp_array
, i
, lp
)
565 /* The array may contain NULL landing pads. */
569 gcc_assert (i
== (unsigned) lp
->index
);
570 FIXUP_EH_LP (lp
->next_lp
);
571 FIXUP_EH_REGION (lp
->region
);
574 #undef FIXUP_EH_REGION
579 /* Initialize EH support. */
584 static bool eh_initialized_p
= false;
586 if (eh_initialized_p
)
589 /* Contrary to most other FEs, we only initialize EH support when at
590 least one of the files in the set contains exception regions in
591 it. Since this happens much later than the call to init_eh in
592 lang_dependent_init, we have to set flag_exceptions and call
593 init_eh again to initialize the EH tables. */
597 eh_initialized_p
= true;
601 /* Read the exception table for FN from IB using the data descriptors
605 input_eh_regions (struct lto_input_block
*ib
, struct data_in
*data_in
,
608 HOST_WIDE_INT i
, root_region
, len
;
611 tag
= streamer_read_record_start (ib
);
615 lto_tag_check_range (tag
, LTO_eh_table
, LTO_eh_table
);
617 /* If the file contains EH regions, then it was compiled with
618 -fexceptions. In that case, initialize the backend EH
624 root_region
= streamer_read_hwi (ib
);
625 gcc_assert (root_region
== (int) root_region
);
627 /* Read the EH region array. */
628 len
= streamer_read_hwi (ib
);
629 gcc_assert (len
== (int) len
);
632 vec_safe_grow_cleared (fn
->eh
->region_array
, len
);
633 for (i
= 0; i
< len
; i
++)
635 eh_region r
= input_eh_region (ib
, data_in
, i
);
636 (*fn
->eh
->region_array
)[i
] = r
;
640 /* Read the landing pads. */
641 len
= streamer_read_hwi (ib
);
642 gcc_assert (len
== (int) len
);
645 vec_safe_grow_cleared (fn
->eh
->lp_array
, len
);
646 for (i
= 0; i
< len
; i
++)
648 eh_landing_pad lp
= input_eh_lp (ib
, data_in
, i
);
649 (*fn
->eh
->lp_array
)[i
] = lp
;
653 /* Read the runtime type data. */
654 len
= streamer_read_hwi (ib
);
655 gcc_assert (len
== (int) len
);
658 vec_safe_grow_cleared (fn
->eh
->ttype_data
, len
);
659 for (i
= 0; i
< len
; i
++)
661 tree ttype
= stream_read_tree (ib
, data_in
);
662 (*fn
->eh
->ttype_data
)[i
] = ttype
;
666 /* Read the table of action chains. */
667 len
= streamer_read_hwi (ib
);
668 gcc_assert (len
== (int) len
);
671 if (targetm
.arm_eabi_unwinder
)
673 vec_safe_grow_cleared (fn
->eh
->ehspec_data
.arm_eabi
, len
);
674 for (i
= 0; i
< len
; i
++)
676 tree t
= stream_read_tree (ib
, data_in
);
677 (*fn
->eh
->ehspec_data
.arm_eabi
)[i
] = t
;
682 vec_safe_grow_cleared (fn
->eh
->ehspec_data
.other
, len
);
683 for (i
= 0; i
< len
; i
++)
685 uchar c
= streamer_read_uchar (ib
);
686 (*fn
->eh
->ehspec_data
.other
)[i
] = c
;
691 /* Reconstruct the EH region tree by fixing up the peer/children
693 fixup_eh_region_pointers (fn
, root_region
);
695 tag
= streamer_read_record_start (ib
);
696 lto_tag_check_range (tag
, LTO_null
, LTO_null
);
700 /* Make a new basic block with index INDEX in function FN. */
703 make_new_block (struct function
*fn
, unsigned int index
)
705 basic_block bb
= alloc_block ();
707 SET_BASIC_BLOCK_FOR_FN (fn
, index
, bb
);
708 n_basic_blocks_for_fn (fn
)++;
713 /* Read a wide-int. */
716 streamer_read_wi (struct lto_input_block
*ib
)
718 HOST_WIDE_INT a
[WIDE_INT_MAX_ELTS
];
720 int prec ATTRIBUTE_UNUSED
= streamer_read_uhwi (ib
);
721 int len
= streamer_read_uhwi (ib
);
722 for (i
= 0; i
< len
; i
++)
723 a
[i
] = streamer_read_hwi (ib
);
724 return widest_int::from_array (a
, len
);
728 /* Read the CFG for function FN from input block IB. */
731 input_cfg (struct lto_input_block
*ib
, struct data_in
*data_in
,
733 int count_materialization_scale
)
735 unsigned int bb_count
;
740 init_empty_tree_cfg_for_function (fn
);
741 init_ssa_operands (fn
);
743 profile_status_for_fn (fn
) = streamer_read_enum (ib
, profile_status_d
,
746 bb_count
= streamer_read_uhwi (ib
);
748 last_basic_block_for_fn (fn
) = bb_count
;
749 if (bb_count
> basic_block_info_for_fn (fn
)->length ())
750 vec_safe_grow_cleared (basic_block_info_for_fn (fn
), bb_count
);
752 if (bb_count
> label_to_block_map_for_fn (fn
)->length ())
753 vec_safe_grow_cleared (label_to_block_map_for_fn (fn
), bb_count
);
755 index
= streamer_read_hwi (ib
);
758 basic_block bb
= BASIC_BLOCK_FOR_FN (fn
, index
);
759 unsigned int edge_count
;
762 bb
= make_new_block (fn
, index
);
764 edge_count
= streamer_read_uhwi (ib
);
766 /* Connect up the CFG. */
767 for (i
= 0; i
< edge_count
; i
++)
769 unsigned int dest_index
;
770 unsigned int edge_flags
;
776 dest_index
= streamer_read_uhwi (ib
);
777 probability
= (int) streamer_read_hwi (ib
);
778 count
= apply_scale ((gcov_type
) streamer_read_gcov_count (ib
),
779 count_materialization_scale
);
780 edge_flags
= streamer_read_uhwi (ib
);
782 dest
= BASIC_BLOCK_FOR_FN (fn
, dest_index
);
785 dest
= make_new_block (fn
, dest_index
);
787 e
= make_edge (bb
, dest
, edge_flags
);
788 e
->probability
= probability
;
792 index
= streamer_read_hwi (ib
);
795 p_bb
= ENTRY_BLOCK_PTR_FOR_FN (fn
);
796 index
= streamer_read_hwi (ib
);
799 basic_block bb
= BASIC_BLOCK_FOR_FN (fn
, index
);
803 index
= streamer_read_hwi (ib
);
806 /* ??? The cfgloop interface is tied to cfun. */
807 gcc_assert (cfun
== fn
);
809 /* Input the loop tree. */
810 unsigned n_loops
= streamer_read_uhwi (ib
);
814 struct loops
*loops
= ggc_cleared_alloc
<struct loops
> ();
815 init_loops_structure (fn
, loops
, n_loops
);
816 set_loops_for_fn (fn
, loops
);
818 /* Input each loop and associate it with its loop header so
819 flow_loops_find can rebuild the loop tree. */
820 for (unsigned i
= 1; i
< n_loops
; ++i
)
822 int header_index
= streamer_read_hwi (ib
);
823 if (header_index
== -1)
825 loops
->larray
->quick_push (NULL
);
829 struct loop
*loop
= alloc_loop ();
830 loop
->header
= BASIC_BLOCK_FOR_FN (fn
, header_index
);
831 loop
->header
->loop_father
= loop
;
833 /* Read everything copy_loop_info copies. */
834 loop
->estimate_state
= streamer_read_enum (ib
, loop_estimation
, EST_LAST
);
835 loop
->any_upper_bound
= streamer_read_hwi (ib
);
836 if (loop
->any_upper_bound
)
837 loop
->nb_iterations_upper_bound
= streamer_read_wi (ib
);
838 loop
->any_likely_upper_bound
= streamer_read_hwi (ib
);
839 if (loop
->any_likely_upper_bound
)
840 loop
->nb_iterations_likely_upper_bound
= streamer_read_wi (ib
);
841 loop
->any_estimate
= streamer_read_hwi (ib
);
842 if (loop
->any_estimate
)
843 loop
->nb_iterations_estimate
= streamer_read_wi (ib
);
845 /* Read OMP SIMD related info. */
846 loop
->safelen
= streamer_read_hwi (ib
);
847 loop
->dont_vectorize
= streamer_read_hwi (ib
);
848 loop
->force_vectorize
= streamer_read_hwi (ib
);
849 loop
->simduid
= stream_read_tree (ib
, data_in
);
851 place_new_loop (fn
, loop
);
853 /* flow_loops_find doesn't like loops not in the tree, hook them
854 all as siblings of the tree root temporarily. */
855 flow_loop_tree_node_add (loops
->tree_root
, loop
);
858 /* Rebuild the loop tree. */
859 flow_loops_find (loops
);
863 /* Read the SSA names array for function FN from DATA_IN using input
867 input_ssa_names (struct lto_input_block
*ib
, struct data_in
*data_in
,
870 unsigned int i
, size
;
872 size
= streamer_read_uhwi (ib
);
873 init_ssanames (fn
, size
);
875 i
= streamer_read_uhwi (ib
);
881 /* Skip over the elements that had been freed. */
882 while (SSANAMES (fn
)->length () < i
)
883 SSANAMES (fn
)->quick_push (NULL_TREE
);
885 is_default_def
= (streamer_read_uchar (ib
) != 0);
886 name
= stream_read_tree (ib
, data_in
);
887 ssa_name
= make_ssa_name_fn (fn
, name
, NULL
);
891 set_ssa_default_def (cfun
, SSA_NAME_VAR (ssa_name
), ssa_name
);
892 SSA_NAME_DEF_STMT (ssa_name
) = gimple_build_nop ();
895 i
= streamer_read_uhwi (ib
);
900 /* Go through all NODE edges and fixup call_stmt pointers
901 so they point to STMTS. */
904 fixup_call_stmt_edges_1 (struct cgraph_node
*node
, gimple
**stmts
,
907 struct cgraph_edge
*cedge
;
908 struct ipa_ref
*ref
= NULL
;
911 for (cedge
= node
->callees
; cedge
; cedge
= cedge
->next_callee
)
913 if (gimple_stmt_max_uid (fn
) < cedge
->lto_stmt_uid
)
914 fatal_error (input_location
,
915 "Cgraph edge statement index out of range");
916 cedge
->call_stmt
= as_a
<gcall
*> (stmts
[cedge
->lto_stmt_uid
- 1]);
917 if (!cedge
->call_stmt
)
918 fatal_error (input_location
,
919 "Cgraph edge statement index not found");
921 for (cedge
= node
->indirect_calls
; cedge
; cedge
= cedge
->next_callee
)
923 if (gimple_stmt_max_uid (fn
) < cedge
->lto_stmt_uid
)
924 fatal_error (input_location
,
925 "Cgraph edge statement index out of range");
926 cedge
->call_stmt
= as_a
<gcall
*> (stmts
[cedge
->lto_stmt_uid
- 1]);
927 if (!cedge
->call_stmt
)
928 fatal_error (input_location
, "Cgraph edge statement index not found");
930 for (i
= 0; node
->iterate_reference (i
, ref
); i
++)
931 if (ref
->lto_stmt_uid
)
933 if (gimple_stmt_max_uid (fn
) < ref
->lto_stmt_uid
)
934 fatal_error (input_location
,
935 "Reference statement index out of range");
936 ref
->stmt
= stmts
[ref
->lto_stmt_uid
- 1];
938 fatal_error (input_location
, "Reference statement index not found");
943 /* Fixup call_stmt pointers in NODE and all clones. */
946 fixup_call_stmt_edges (struct cgraph_node
*orig
, gimple
**stmts
)
948 struct cgraph_node
*node
;
951 while (orig
->clone_of
)
952 orig
= orig
->clone_of
;
953 fn
= DECL_STRUCT_FUNCTION (orig
->decl
);
955 fixup_call_stmt_edges_1 (orig
, stmts
, fn
);
957 for (node
= orig
->clones
; node
!= orig
;)
959 if (!node
->thunk
.thunk_p
)
960 fixup_call_stmt_edges_1 (node
, stmts
, fn
);
963 else if (node
->next_sibling_clone
)
964 node
= node
->next_sibling_clone
;
967 while (node
!= orig
&& !node
->next_sibling_clone
)
968 node
= node
->clone_of
;
970 node
= node
->next_sibling_clone
;
976 /* Input the base body of struct function FN from DATA_IN
977 using input block IB. */
980 input_struct_function_base (struct function
*fn
, struct data_in
*data_in
,
981 struct lto_input_block
*ib
)
986 /* Read the static chain and non-local goto save area. */
987 fn
->static_chain_decl
= stream_read_tree (ib
, data_in
);
988 fn
->nonlocal_goto_save_area
= stream_read_tree (ib
, data_in
);
990 /* Read all the local symbols. */
991 len
= streamer_read_hwi (ib
);
995 vec_safe_grow_cleared (fn
->local_decls
, len
);
996 for (i
= 0; i
< len
; i
++)
998 tree t
= stream_read_tree (ib
, data_in
);
999 (*fn
->local_decls
)[i
] = t
;
1003 /* Input the current IL state of the function. */
1004 fn
->curr_properties
= streamer_read_uhwi (ib
);
1006 /* Read all the attributes for FN. */
1007 bp
= streamer_read_bitpack (ib
);
1008 fn
->is_thunk
= bp_unpack_value (&bp
, 1);
1009 fn
->has_local_explicit_reg_vars
= bp_unpack_value (&bp
, 1);
1010 fn
->returns_pcc_struct
= bp_unpack_value (&bp
, 1);
1011 fn
->returns_struct
= bp_unpack_value (&bp
, 1);
1012 fn
->can_throw_non_call_exceptions
= bp_unpack_value (&bp
, 1);
1013 fn
->can_delete_dead_exceptions
= bp_unpack_value (&bp
, 1);
1014 fn
->always_inline_functions_inlined
= bp_unpack_value (&bp
, 1);
1015 fn
->after_inlining
= bp_unpack_value (&bp
, 1);
1016 fn
->stdarg
= bp_unpack_value (&bp
, 1);
1017 fn
->has_nonlocal_label
= bp_unpack_value (&bp
, 1);
1018 fn
->has_forced_label_in_static
= bp_unpack_value (&bp
, 1);
1019 fn
->calls_alloca
= bp_unpack_value (&bp
, 1);
1020 fn
->calls_setjmp
= bp_unpack_value (&bp
, 1);
1021 fn
->has_force_vectorize_loops
= bp_unpack_value (&bp
, 1);
1022 fn
->has_simduid_loops
= bp_unpack_value (&bp
, 1);
1023 fn
->va_list_fpr_size
= bp_unpack_value (&bp
, 8);
1024 fn
->va_list_gpr_size
= bp_unpack_value (&bp
, 8);
1025 fn
->last_clique
= bp_unpack_value (&bp
, sizeof (short) * 8);
1027 /* Input the function start and end loci. */
1028 fn
->function_start_locus
= stream_input_location_now (&bp
, data_in
);
1029 fn
->function_end_locus
= stream_input_location_now (&bp
, data_in
);
1033 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1036 input_function (tree fn_decl
, struct data_in
*data_in
,
1037 struct lto_input_block
*ib
, struct lto_input_block
*ib_cfg
)
1039 struct function
*fn
;
1043 struct cgraph_node
*node
;
1045 tag
= streamer_read_record_start (ib
);
1046 lto_tag_check (tag
, LTO_function
);
1048 /* Read decls for parameters and args. */
1049 DECL_RESULT (fn_decl
) = stream_read_tree (ib
, data_in
);
1050 DECL_ARGUMENTS (fn_decl
) = streamer_read_chain (ib
, data_in
);
1052 /* Read the tree of lexical scopes for the function. */
1053 DECL_INITIAL (fn_decl
) = stream_read_tree (ib
, data_in
);
1055 if (!streamer_read_uhwi (ib
))
1058 push_struct_function (fn_decl
);
1059 fn
= DECL_STRUCT_FUNCTION (fn_decl
);
1061 /* We input IL in SSA form. */
1062 cfun
->gimple_df
->in_ssa_p
= true;
1064 gimple_register_cfg_hooks ();
1066 node
= cgraph_node::get (fn_decl
);
1068 node
= cgraph_node::create (fn_decl
);
1069 input_struct_function_base (fn
, data_in
, ib
);
1070 input_cfg (ib_cfg
, data_in
, fn
, node
->count_materialization_scale
);
1072 /* Read all the SSA names. */
1073 input_ssa_names (ib
, data_in
, fn
);
1075 /* Read the exception handling regions in the function. */
1076 input_eh_regions (ib
, data_in
, fn
);
1078 gcc_assert (DECL_INITIAL (fn_decl
));
1079 DECL_SAVED_TREE (fn_decl
) = NULL_TREE
;
1081 /* Read all the basic blocks. */
1082 tag
= streamer_read_record_start (ib
);
1085 input_bb (ib
, tag
, data_in
, fn
,
1086 node
->count_materialization_scale
);
1087 tag
= streamer_read_record_start (ib
);
1090 /* Fix up the call statements that are mentioned in the callgraph
1092 set_gimple_stmt_max_uid (cfun
, 0);
1093 FOR_ALL_BB_FN (bb
, cfun
)
1095 gimple_stmt_iterator gsi
;
1096 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1098 gimple
*stmt
= gsi_stmt (gsi
);
1099 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
1101 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1103 gimple
*stmt
= gsi_stmt (gsi
);
1104 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
1107 stmts
= (gimple
**) xcalloc (gimple_stmt_max_uid (fn
), sizeof (gimple
*));
1108 FOR_ALL_BB_FN (bb
, cfun
)
1110 gimple_stmt_iterator bsi
= gsi_start_phis (bb
);
1111 while (!gsi_end_p (bsi
))
1113 gimple
*stmt
= gsi_stmt (bsi
);
1115 stmts
[gimple_uid (stmt
)] = stmt
;
1117 bsi
= gsi_start_bb (bb
);
1118 while (!gsi_end_p (bsi
))
1120 gimple
*stmt
= gsi_stmt (bsi
);
1121 /* If we're recompiling LTO objects with debug stmts but
1122 we're not supposed to have debug stmts, remove them now.
1123 We can't remove them earlier because this would cause uid
1124 mismatches in fixups, but we can do it at this point, as
1125 long as debug stmts don't require fixups. */
1126 if (!MAY_HAVE_DEBUG_STMTS
&& !flag_wpa
&& is_gimple_debug (stmt
))
1128 gimple_stmt_iterator gsi
= bsi
;
1130 gsi_remove (&gsi
, true);
1135 stmts
[gimple_uid (stmt
)] = stmt
;
1140 /* Set the gimple body to the statement sequence in the entry
1141 basic block. FIXME lto, this is fairly hacky. The existence
1142 of a gimple body is used by the cgraph routines, but we should
1143 really use the presence of the CFG. */
1145 edge_iterator ei
= ei_start (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
);
1146 gimple_set_body (fn_decl
, bb_seq (ei_edge (ei
)->dest
));
1149 fixup_call_stmt_edges (node
, stmts
);
1150 execute_all_ipa_stmt_fixups (node
, stmts
);
1152 update_ssa (TODO_update_ssa_only_virtuals
);
1153 free_dominance_info (CDI_DOMINATORS
);
1154 free_dominance_info (CDI_POST_DOMINATORS
);
1159 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1162 input_constructor (tree var
, struct data_in
*data_in
,
1163 struct lto_input_block
*ib
)
1165 DECL_INITIAL (var
) = stream_read_tree (ib
, data_in
);
1169 /* Read the body from DATA for function NODE and fill it in.
1170 FILE_DATA are the global decls and types. SECTION_TYPE is either
1171 LTO_section_function_body or LTO_section_static_initializer. If
1172 section type is LTO_section_function_body, FN must be the decl for
1176 lto_read_body_or_constructor (struct lto_file_decl_data
*file_data
, struct symtab_node
*node
,
1177 const char *data
, enum lto_section_type section_type
)
1179 const struct lto_function_header
*header
;
1180 struct data_in
*data_in
;
1184 tree fn_decl
= node
->decl
;
1186 header
= (const struct lto_function_header
*) data
;
1187 if (TREE_CODE (node
->decl
) == FUNCTION_DECL
)
1189 cfg_offset
= sizeof (struct lto_function_header
);
1190 main_offset
= cfg_offset
+ header
->cfg_size
;
1191 string_offset
= main_offset
+ header
->main_size
;
1195 main_offset
= sizeof (struct lto_function_header
);
1196 string_offset
= main_offset
+ header
->main_size
;
1199 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
1200 header
->string_size
, vNULL
);
1202 if (section_type
== LTO_section_function_body
)
1204 struct lto_in_decl_state
*decl_state
;
1207 gcc_checking_assert (node
);
1209 /* Use the function's decl state. */
1210 decl_state
= lto_get_function_in_decl_state (file_data
, fn_decl
);
1211 gcc_assert (decl_state
);
1212 file_data
->current_decl_state
= decl_state
;
1215 /* Set up the struct function. */
1216 from
= data_in
->reader_cache
->nodes
.length ();
1217 lto_input_block
ib_main (data
+ main_offset
, header
->main_size
,
1218 file_data
->mode_table
);
1219 if (TREE_CODE (node
->decl
) == FUNCTION_DECL
)
1221 lto_input_block
ib_cfg (data
+ cfg_offset
, header
->cfg_size
,
1222 file_data
->mode_table
);
1223 input_function (fn_decl
, data_in
, &ib_main
, &ib_cfg
);
1226 input_constructor (fn_decl
, data_in
, &ib_main
);
1227 data_in
->location_cache
.apply_location_cache ();
1228 /* And fixup types we streamed locally. */
1230 struct streamer_tree_cache_d
*cache
= data_in
->reader_cache
;
1231 unsigned len
= cache
->nodes
.length ();
1233 for (i
= len
; i
-- > from
;)
1235 tree t
= streamer_tree_cache_get_tree (cache
, i
);
1241 gcc_assert (TYPE_CANONICAL (t
) == NULL_TREE
);
1242 if (type_with_alias_set_p (t
)
1243 && canonical_type_used_p (t
))
1244 TYPE_CANONICAL (t
) = TYPE_MAIN_VARIANT (t
);
1245 if (TYPE_MAIN_VARIANT (t
) != t
)
1247 gcc_assert (TYPE_NEXT_VARIANT (t
) == NULL_TREE
);
1248 TYPE_NEXT_VARIANT (t
)
1249 = TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t
));
1250 TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t
)) = t
;
1256 /* Restore decl state */
1257 file_data
->current_decl_state
= file_data
->global_decl_state
;
1260 lto_data_in_delete (data_in
);
1264 /* Read the body of NODE using DATA. FILE_DATA holds the global
1268 lto_input_function_body (struct lto_file_decl_data
*file_data
,
1269 struct cgraph_node
*node
, const char *data
)
1271 lto_read_body_or_constructor (file_data
, node
, data
, LTO_section_function_body
);
1274 /* Read the body of NODE using DATA. FILE_DATA holds the global
1278 lto_input_variable_constructor (struct lto_file_decl_data
*file_data
,
1279 struct varpool_node
*node
, const char *data
)
1281 lto_read_body_or_constructor (file_data
, node
, data
, LTO_section_function_body
);
1285 /* Read the physical representation of a tree node EXPR from
1286 input block IB using the per-file context in DATA_IN. */
1289 lto_read_tree_1 (struct lto_input_block
*ib
, struct data_in
*data_in
, tree expr
)
1291 /* Read all the bitfield values in EXPR. Note that for LTO, we
1292 only write language-independent bitfields, so no more unpacking is
1294 streamer_read_tree_bitfields (ib
, data_in
, expr
);
1296 /* Read all the pointer fields in EXPR. */
1297 streamer_read_tree_body (ib
, data_in
, expr
);
1299 /* Read any LTO-specific data not read by the tree streamer. */
1301 && TREE_CODE (expr
) != FUNCTION_DECL
1302 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
1303 DECL_INITIAL (expr
) = stream_read_tree (ib
, data_in
);
1305 /* We should never try to instantiate an MD or NORMAL builtin here. */
1306 if (TREE_CODE (expr
) == FUNCTION_DECL
)
1307 gcc_assert (!streamer_handle_as_builtin_p (expr
));
1309 #ifdef LTO_STREAMER_DEBUG
1310 /* Remove the mapping to RESULT's original address set by
1311 streamer_alloc_tree. */
1312 lto_orig_address_remove (expr
);
1316 /* Read the physical representation of a tree node with tag TAG from
1317 input block IB using the per-file context in DATA_IN. */
1320 lto_read_tree (struct lto_input_block
*ib
, struct data_in
*data_in
,
1321 enum LTO_tags tag
, hashval_t hash
)
1323 /* Instantiate a new tree node. */
1324 tree result
= streamer_alloc_tree (ib
, data_in
, tag
);
1326 /* Enter RESULT in the reader cache. This will make RESULT
1327 available so that circular references in the rest of the tree
1328 structure can be resolved in subsequent calls to stream_read_tree. */
1329 streamer_tree_cache_append (data_in
->reader_cache
, result
, hash
);
1331 lto_read_tree_1 (ib
, data_in
, result
);
1333 /* end_marker = */ streamer_read_uchar (ib
);
1339 /* Populate the reader cache with trees materialized from the SCC
1340 following in the IB, DATA_IN stream. */
1343 lto_input_scc (struct lto_input_block
*ib
, struct data_in
*data_in
,
1344 unsigned *len
, unsigned *entry_len
)
1346 /* A blob of unnamed tree nodes, fill the cache from it and
1348 unsigned size
= streamer_read_uhwi (ib
);
1349 hashval_t scc_hash
= streamer_read_uhwi (ib
);
1350 unsigned scc_entry_len
= 1;
1354 enum LTO_tags tag
= streamer_read_record_start (ib
);
1355 lto_input_tree_1 (ib
, data_in
, tag
, scc_hash
);
1359 unsigned int first
= data_in
->reader_cache
->nodes
.length ();
1362 scc_entry_len
= streamer_read_uhwi (ib
);
1364 /* Materialize size trees by reading their headers. */
1365 for (unsigned i
= 0; i
< size
; ++i
)
1367 enum LTO_tags tag
= streamer_read_record_start (ib
);
1369 || (tag
>= LTO_field_decl_ref
&& tag
<= LTO_global_decl_ref
)
1370 || tag
== LTO_tree_pickle_reference
1371 || tag
== LTO_builtin_decl
1372 || tag
== LTO_integer_cst
1373 || tag
== LTO_tree_scc
)
1376 result
= streamer_alloc_tree (ib
, data_in
, tag
);
1377 streamer_tree_cache_append (data_in
->reader_cache
, result
, 0);
1380 /* Read the tree bitpacks and references. */
1381 for (unsigned i
= 0; i
< size
; ++i
)
1383 result
= streamer_tree_cache_get_tree (data_in
->reader_cache
,
1385 lto_read_tree_1 (ib
, data_in
, result
);
1386 /* end_marker = */ streamer_read_uchar (ib
);
1391 *entry_len
= scc_entry_len
;
1396 /* Read a tree from input block IB using the per-file context in
1397 DATA_IN. This context is used, for example, to resolve references
1398 to previously read nodes. */
1401 lto_input_tree_1 (struct lto_input_block
*ib
, struct data_in
*data_in
,
1402 enum LTO_tags tag
, hashval_t hash
)
1406 gcc_assert ((unsigned) tag
< (unsigned) LTO_NUM_TAGS
);
1408 if (tag
== LTO_null
)
1410 else if (tag
>= LTO_field_decl_ref
&& tag
<= LTO_namelist_decl_ref
)
1412 /* If TAG is a reference to an indexable tree, the next value
1413 in IB is the index into the table where we expect to find
1415 result
= lto_input_tree_ref (ib
, data_in
, cfun
, tag
);
1417 else if (tag
== LTO_tree_pickle_reference
)
1419 /* If TAG is a reference to a previously read tree, look it up in
1420 the reader cache. */
1421 result
= streamer_get_pickled_tree (ib
, data_in
);
1423 else if (tag
== LTO_builtin_decl
)
1425 /* If we are going to read a built-in function, all we need is
1426 the code and class. */
1427 result
= streamer_get_builtin_tree (ib
, data_in
);
1429 else if (tag
== LTO_integer_cst
)
1431 /* For shared integer constants in singletons we can use the
1432 existing tree integer constant merging code. */
1433 tree type
= stream_read_tree (ib
, data_in
);
1434 unsigned HOST_WIDE_INT len
= streamer_read_uhwi (ib
);
1435 unsigned HOST_WIDE_INT i
;
1436 HOST_WIDE_INT a
[WIDE_INT_MAX_ELTS
];
1438 for (i
= 0; i
< len
; i
++)
1439 a
[i
] = streamer_read_hwi (ib
);
1440 gcc_assert (TYPE_PRECISION (type
) <= MAX_BITSIZE_MODE_ANY_INT
);
1441 result
= wide_int_to_tree (type
, wide_int::from_array
1442 (a
, len
, TYPE_PRECISION (type
)));
1443 streamer_tree_cache_append (data_in
->reader_cache
, result
, hash
);
1445 else if (tag
== LTO_tree_scc
)
1449 /* Otherwise, materialize a new node from IB. */
1450 result
= lto_read_tree (ib
, data_in
, tag
, hash
);
1457 lto_input_tree (struct lto_input_block
*ib
, struct data_in
*data_in
)
1461 /* Input and skip SCCs. */
1462 while ((tag
= streamer_read_record_start (ib
)) == LTO_tree_scc
)
1464 unsigned len
, entry_len
;
1465 lto_input_scc (ib
, data_in
, &len
, &entry_len
);
1467 return lto_input_tree_1 (ib
, data_in
, tag
, 0);
1471 /* Input toplevel asms. */
1474 lto_input_toplevel_asms (struct lto_file_decl_data
*file_data
, int order_base
)
1477 const char *data
= lto_get_section_data (file_data
, LTO_section_asm
,
1479 const struct lto_simple_header_with_strings
*header
1480 = (const struct lto_simple_header_with_strings
*) data
;
1482 struct data_in
*data_in
;
1488 string_offset
= sizeof (*header
) + header
->main_size
;
1490 lto_input_block
ib (data
+ sizeof (*header
), header
->main_size
,
1491 file_data
->mode_table
);
1493 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
1494 header
->string_size
, vNULL
);
1496 while ((str
= streamer_read_string_cst (data_in
, &ib
)))
1498 asm_node
*node
= symtab
->finalize_toplevel_asm (str
);
1499 node
->order
= streamer_read_hwi (&ib
) + order_base
;
1500 if (node
->order
>= symtab
->order
)
1501 symtab
->order
= node
->order
+ 1;
1504 lto_data_in_delete (data_in
);
1506 lto_free_section_data (file_data
, LTO_section_asm
, NULL
, data
, len
);
1510 /* Input mode table. */
1513 lto_input_mode_table (struct lto_file_decl_data
*file_data
)
1516 const char *data
= lto_get_section_data (file_data
, LTO_section_mode_table
,
1520 internal_error ("cannot read LTO mode table from %s",
1521 file_data
->file_name
);
1525 unsigned char *table
= ggc_cleared_vec_alloc
<unsigned char> (1 << 8);
1526 file_data
->mode_table
= table
;
1527 const struct lto_simple_header_with_strings
*header
1528 = (const struct lto_simple_header_with_strings
*) data
;
1530 struct data_in
*data_in
;
1531 string_offset
= sizeof (*header
) + header
->main_size
;
1533 lto_input_block
ib (data
+ sizeof (*header
), header
->main_size
, NULL
);
1534 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
1535 header
->string_size
, vNULL
);
1536 bitpack_d bp
= streamer_read_bitpack (&ib
);
1538 table
[VOIDmode
] = VOIDmode
;
1539 table
[BLKmode
] = BLKmode
;
1541 while ((m
= bp_unpack_value (&bp
, 8)) != VOIDmode
)
1543 enum mode_class mclass
1544 = bp_unpack_enum (&bp
, mode_class
, MAX_MODE_CLASS
);
1545 unsigned int size
= bp_unpack_value (&bp
, 8);
1546 unsigned int prec
= bp_unpack_value (&bp
, 16);
1547 machine_mode inner
= (machine_mode
) bp_unpack_value (&bp
, 8);
1548 unsigned int nunits
= bp_unpack_value (&bp
, 8);
1549 unsigned int ibit
= 0, fbit
= 0;
1550 unsigned int real_fmt_len
= 0;
1551 const char *real_fmt_name
= NULL
;
1558 ibit
= bp_unpack_value (&bp
, 8);
1559 fbit
= bp_unpack_value (&bp
, 8);
1562 case MODE_DECIMAL_FLOAT
:
1563 real_fmt_name
= bp_unpack_indexed_string (data_in
, &bp
,
1569 /* First search just the GET_CLASS_NARROWEST_MODE to wider modes,
1570 if not found, fallback to all modes. */
1572 for (pass
= 0; pass
< 2; pass
++)
1573 for (machine_mode mr
= pass
? VOIDmode
1574 : GET_CLASS_NARROWEST_MODE (mclass
);
1575 pass
? mr
< MAX_MACHINE_MODE
: mr
!= VOIDmode
;
1576 pass
? mr
= (machine_mode
) (mr
+ 1)
1577 : mr
= GET_MODE_WIDER_MODE (mr
))
1578 if (GET_MODE_CLASS (mr
) != mclass
1579 || GET_MODE_SIZE (mr
) != size
1580 || GET_MODE_PRECISION (mr
) != prec
1582 ? GET_MODE_INNER (mr
) != mr
1583 : GET_MODE_INNER (mr
) != table
[(int) inner
])
1584 || GET_MODE_IBIT (mr
) != ibit
1585 || GET_MODE_FBIT (mr
) != fbit
1586 || GET_MODE_NUNITS (mr
) != nunits
)
1588 else if ((mclass
== MODE_FLOAT
|| mclass
== MODE_DECIMAL_FLOAT
)
1589 && strcmp (REAL_MODE_FORMAT (mr
)->name
, real_fmt_name
) != 0)
1597 unsigned int mname_len
;
1598 const char *mname
= bp_unpack_indexed_string (data_in
, &bp
, &mname_len
);
1603 case MODE_VECTOR_INT
:
1604 case MODE_VECTOR_FLOAT
:
1605 case MODE_VECTOR_FRACT
:
1606 case MODE_VECTOR_UFRACT
:
1607 case MODE_VECTOR_ACCUM
:
1608 case MODE_VECTOR_UACCUM
:
1609 /* For unsupported vector modes just use BLKmode,
1610 if the scalar mode is supported. */
1611 if (table
[(int) inner
] != VOIDmode
)
1618 fatal_error (UNKNOWN_LOCATION
, "unsupported mode %s\n", mname
);
1623 lto_data_in_delete (data_in
);
1625 lto_free_section_data (file_data
, LTO_section_mode_table
, NULL
, data
, len
);
1629 /* Initialization for the LTO reader. */
1632 lto_reader_init (void)
1634 lto_streamer_init ();
1635 file_name_hash_table
1636 = new hash_table
<freeing_string_slot_hasher
> (37);
1640 /* Create a new data_in object for FILE_DATA. STRINGS is the string
1641 table to use with LEN strings. RESOLUTIONS is the vector of linker
1642 resolutions (NULL if not using a linker plugin). */
1645 lto_data_in_create (struct lto_file_decl_data
*file_data
, const char *strings
,
1647 vec
<ld_plugin_symbol_resolution_t
> resolutions
)
1649 struct data_in
*data_in
= new (struct data_in
);
1650 data_in
->file_data
= file_data
;
1651 data_in
->strings
= strings
;
1652 data_in
->strings_len
= len
;
1653 data_in
->globals_resolution
= resolutions
;
1654 data_in
->reader_cache
= streamer_tree_cache_create (false, false, true);
1659 /* Remove DATA_IN. */
1662 lto_data_in_delete (struct data_in
*data_in
)
1664 data_in
->globals_resolution
.release ();
1665 streamer_tree_cache_delete (data_in
->reader_cache
);