1 /* Read the GIMPLE representation from a file stream.
3 Copyright (C) 2009-2015 Free Software Foundation, Inc.
4 Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
5 Re-implemented by Diego Novillo <dnovillo@google.com>
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
34 #include "fold-const.h"
36 #include "insn-config.h"
46 #include "internal-fn.h"
47 #include "gimple-iterator.h"
49 #include "tree-into-ssa.h"
52 #include "tree-pass.h"
53 #include "diagnostic.h"
57 #include "ipa-utils.h"
59 #include "gimple-streamer.h"
63 struct freeing_string_slot_hasher
: string_slot_hasher
65 static inline void remove (value_type
*);
69 freeing_string_slot_hasher::remove (value_type
*v
)
74 /* The table to hold the file names. */
75 static hash_table
<freeing_string_slot_hasher
> *file_name_hash_table
;
78 /* Check that tag ACTUAL has one of the given values. NUM_TAGS is the
79 number of valid tag values to check. */
82 lto_tag_check_set (enum LTO_tags actual
, int ntags
, ...)
88 for (i
= 0; i
< ntags
; i
++)
89 if ((unsigned) actual
== va_arg (ap
, unsigned))
96 internal_error ("bytecode stream: unexpected tag %s", lto_tag_name (actual
));
100 /* Read LENGTH bytes from STREAM to ADDR. */
103 lto_input_data_block (struct lto_input_block
*ib
, void *addr
, size_t length
)
106 unsigned char *const buffer
= (unsigned char *const) addr
;
108 for (i
= 0; i
< length
; i
++)
109 buffer
[i
] = streamer_read_uchar (ib
);
113 /* Lookup STRING in file_name_hash_table. If found, return the existing
114 string, otherwise insert STRING as the canonical version. */
117 canon_file_name (const char *string
)
120 struct string_slot s_slot
;
121 size_t len
= strlen (string
);
126 slot
= file_name_hash_table
->find_slot (&s_slot
, INSERT
);
130 struct string_slot
*new_slot
;
132 saved_string
= (char *) xmalloc (len
+ 1);
133 new_slot
= XCNEW (struct string_slot
);
134 memcpy (saved_string
, string
, len
+ 1);
135 new_slot
->s
= saved_string
;
142 struct string_slot
*old_slot
= *slot
;
147 /* Pointer to currently alive instance of lto_location_cache. */
149 lto_location_cache
*lto_location_cache::current_cache
;
151 /* Sort locations in source order. Start with file from last application. */
154 lto_location_cache::cmp_loc (const void *pa
, const void *pb
)
156 const cached_location
*a
= ((const cached_location
*)pa
);
157 const cached_location
*b
= ((const cached_location
*)pb
);
158 const char *current_file
= current_cache
->current_file
;
159 int current_line
= current_cache
->current_line
;
161 if (a
->file
== current_file
&& b
->file
!= current_file
)
163 if (a
->file
!= current_file
&& b
->file
== current_file
)
165 if (a
->file
== current_file
&& b
->file
== current_file
)
167 if (a
->line
== current_line
&& b
->line
!= current_line
)
169 if (a
->line
!= current_line
&& b
->line
== current_line
)
172 if (a
->file
!= b
->file
)
173 return strcmp (a
->file
, b
->file
);
174 if (a
->sysp
!= b
->sysp
)
175 return a
->sysp
? 1 : -1;
176 if (a
->line
!= b
->line
)
177 return a
->line
- b
->line
;
178 return a
->col
- b
->col
;
181 /* Apply all changes in location cache. Add locations into linemap and patch
185 lto_location_cache::apply_location_cache ()
187 static const char *prev_file
;
188 if (!loc_cache
.length ())
190 if (loc_cache
.length () > 1)
191 loc_cache
.qsort (cmp_loc
);
193 for (unsigned int i
= 0; i
< loc_cache
.length (); i
++)
195 struct cached_location loc
= loc_cache
[i
];
197 if (current_file
!= loc
.file
)
198 linemap_add (line_table
, prev_file
? LC_RENAME
: LC_ENTER
,
199 loc
.sysp
, loc
.file
, loc
.line
);
200 else if (current_line
!= loc
.line
)
204 for (unsigned int j
= i
+ 1; j
< loc_cache
.length (); j
++)
205 if (loc
.file
!= loc_cache
[j
].file
206 || loc
.line
!= loc_cache
[j
].line
)
208 else if (max
< loc_cache
[j
].col
)
209 max
= loc_cache
[j
].col
;
210 linemap_line_start (line_table
, loc
.line
, max
+ 1);
212 gcc_assert (*loc
.loc
== BUILTINS_LOCATION
+ 1);
213 if (current_file
== loc
.file
&& current_line
== loc
.line
214 && current_col
== loc
.col
)
215 *loc
.loc
= current_loc
;
217 current_loc
= *loc
.loc
= linemap_position_for_column (line_table
,
219 current_line
= loc
.line
;
220 prev_file
= current_file
= loc
.file
;
221 current_col
= loc
.col
;
223 loc_cache
.truncate (0);
228 /* Tree merging did not suceed; mark all changes in the cache as accepted. */
231 lto_location_cache::accept_location_cache ()
233 gcc_assert (current_cache
== this);
234 accepted_length
= loc_cache
.length ();
237 /* Tree merging did suceed; throw away recent changes. */
240 lto_location_cache::revert_location_cache ()
242 loc_cache
.truncate (accepted_length
);
245 /* Read a location bitpack from input block IB and either update *LOC directly
246 or add it to the location cache.
247 It is neccesary to call apply_location_cache to get *LOC updated. */
250 lto_location_cache::input_location (location_t
*loc
, struct bitpack_d
*bp
,
251 struct data_in
*data_in
)
253 static const char *stream_file
;
254 static int stream_line
;
255 static int stream_col
;
256 static bool stream_sysp
;
257 bool file_change
, line_change
, column_change
;
259 gcc_assert (current_cache
== this);
261 *loc
= bp_unpack_int_in_range (bp
, "location", 0, RESERVED_LOCATION_COUNT
);
263 if (*loc
< RESERVED_LOCATION_COUNT
)
266 /* Keep value RESERVED_LOCATION_COUNT in *loc as linemap lookups will
269 file_change
= bp_unpack_value (bp
, 1);
270 line_change
= bp_unpack_value (bp
, 1);
271 column_change
= bp_unpack_value (bp
, 1);
275 stream_file
= canon_file_name (bp_unpack_string (data_in
, bp
));
276 stream_sysp
= bp_unpack_value (bp
, 1);
280 stream_line
= bp_unpack_var_len_unsigned (bp
);
283 stream_col
= bp_unpack_var_len_unsigned (bp
);
285 /* This optimization saves location cache operations druing gimple
288 if (current_file
== stream_file
&& current_line
== stream_line
289 && current_col
== stream_col
&& current_sysp
== stream_sysp
)
295 struct cached_location entry
296 = {stream_file
, loc
, stream_line
, stream_col
, stream_sysp
};
297 loc_cache
.safe_push (entry
);
300 /* Read a location bitpack from input block IB and either update *LOC directly
301 or add it to the location cache.
302 It is neccesary to call apply_location_cache to get *LOC updated. */
305 lto_input_location (location_t
*loc
, struct bitpack_d
*bp
,
306 struct data_in
*data_in
)
308 data_in
->location_cache
.input_location (loc
, bp
, data_in
);
311 /* Read location and return it instead of going through location caching.
312 This should be used only when the resulting location is not going to be
316 stream_input_location_now (struct bitpack_d
*bp
, struct data_in
*data_in
)
319 stream_input_location (&loc
, bp
, data_in
);
320 data_in
->location_cache
.apply_location_cache ();
324 /* Read a reference to a tree node from DATA_IN using input block IB.
325 TAG is the expected node that should be found in IB, if TAG belongs
326 to one of the indexable trees, expect to read a reference index to
327 be looked up in one of the symbol tables, otherwise read the pysical
328 representation of the tree using stream_read_tree. FN is the
329 function scope for the read tree. */
332 lto_input_tree_ref (struct lto_input_block
*ib
, struct data_in
*data_in
,
333 struct function
*fn
, enum LTO_tags tag
)
335 unsigned HOST_WIDE_INT ix_u
;
336 tree result
= NULL_TREE
;
338 lto_tag_check_range (tag
, LTO_field_decl_ref
, LTO_namelist_decl_ref
);
343 ix_u
= streamer_read_uhwi (ib
);
344 result
= lto_file_decl_data_get_type (data_in
->file_data
, ix_u
);
347 case LTO_ssa_name_ref
:
348 ix_u
= streamer_read_uhwi (ib
);
349 result
= (*SSANAMES (fn
))[ix_u
];
352 case LTO_field_decl_ref
:
353 ix_u
= streamer_read_uhwi (ib
);
354 result
= lto_file_decl_data_get_field_decl (data_in
->file_data
, ix_u
);
357 case LTO_function_decl_ref
:
358 ix_u
= streamer_read_uhwi (ib
);
359 result
= lto_file_decl_data_get_fn_decl (data_in
->file_data
, ix_u
);
362 case LTO_type_decl_ref
:
363 ix_u
= streamer_read_uhwi (ib
);
364 result
= lto_file_decl_data_get_type_decl (data_in
->file_data
, ix_u
);
367 case LTO_namespace_decl_ref
:
368 ix_u
= streamer_read_uhwi (ib
);
369 result
= lto_file_decl_data_get_namespace_decl (data_in
->file_data
, ix_u
);
372 case LTO_global_decl_ref
:
373 case LTO_result_decl_ref
:
374 case LTO_const_decl_ref
:
375 case LTO_imported_decl_ref
:
376 case LTO_label_decl_ref
:
377 case LTO_translation_unit_decl_ref
:
378 case LTO_namelist_decl_ref
:
379 ix_u
= streamer_read_uhwi (ib
);
380 result
= lto_file_decl_data_get_var_decl (data_in
->file_data
, ix_u
);
393 /* Read and return a double-linked list of catch handlers from input
394 block IB, using descriptors in DATA_IN. */
396 static struct eh_catch_d
*
397 lto_input_eh_catch_list (struct lto_input_block
*ib
, struct data_in
*data_in
,
403 *last_p
= first
= NULL
;
404 tag
= streamer_read_record_start (ib
);
410 lto_tag_check_range (tag
, LTO_eh_catch
, LTO_eh_catch
);
412 /* Read the catch node. */
413 n
= ggc_cleared_alloc
<eh_catch_d
> ();
414 n
->type_list
= stream_read_tree (ib
, data_in
);
415 n
->filter_list
= stream_read_tree (ib
, data_in
);
416 n
->label
= stream_read_tree (ib
, data_in
);
418 /* Register all the types in N->FILTER_LIST. */
419 for (list
= n
->filter_list
; list
; list
= TREE_CHAIN (list
))
420 add_type_for_runtime (TREE_VALUE (list
));
422 /* Chain N to the end of the list. */
424 (*last_p
)->next_catch
= n
;
425 n
->prev_catch
= *last_p
;
428 /* Set the head of the list the first time through the loop. */
432 tag
= streamer_read_record_start (ib
);
439 /* Read and return EH region IX from input block IB, using descriptors
443 input_eh_region (struct lto_input_block
*ib
, struct data_in
*data_in
, int ix
)
448 /* Read the region header. */
449 tag
= streamer_read_record_start (ib
);
453 r
= ggc_cleared_alloc
<eh_region_d
> ();
454 r
->index
= streamer_read_hwi (ib
);
456 gcc_assert (r
->index
== ix
);
458 /* Read all the region pointers as region numbers. We'll fix up
459 the pointers once the whole array has been read. */
460 r
->outer
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
461 r
->inner
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
462 r
->next_peer
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
466 case LTO_ert_cleanup
:
467 r
->type
= ERT_CLEANUP
;
472 struct eh_catch_d
*last_catch
;
474 r
->u
.eh_try
.first_catch
= lto_input_eh_catch_list (ib
, data_in
,
476 r
->u
.eh_try
.last_catch
= last_catch
;
480 case LTO_ert_allowed_exceptions
:
484 r
->type
= ERT_ALLOWED_EXCEPTIONS
;
485 r
->u
.allowed
.type_list
= stream_read_tree (ib
, data_in
);
486 r
->u
.allowed
.label
= stream_read_tree (ib
, data_in
);
487 r
->u
.allowed
.filter
= streamer_read_uhwi (ib
);
489 for (l
= r
->u
.allowed
.type_list
; l
; l
= TREE_CHAIN (l
))
490 add_type_for_runtime (TREE_VALUE (l
));
494 case LTO_ert_must_not_throw
:
496 r
->type
= ERT_MUST_NOT_THROW
;
497 r
->u
.must_not_throw
.failure_decl
= stream_read_tree (ib
, data_in
);
498 bitpack_d bp
= streamer_read_bitpack (ib
);
499 r
->u
.must_not_throw
.failure_loc
500 = stream_input_location_now (&bp
, data_in
);
508 r
->landing_pads
= (eh_landing_pad
) (intptr_t) streamer_read_hwi (ib
);
514 /* Read and return EH landing pad IX from input block IB, using descriptors
517 static eh_landing_pad
518 input_eh_lp (struct lto_input_block
*ib
, struct data_in
*data_in
, int ix
)
523 /* Read the landing pad header. */
524 tag
= streamer_read_record_start (ib
);
528 lto_tag_check_range (tag
, LTO_eh_landing_pad
, LTO_eh_landing_pad
);
530 lp
= ggc_cleared_alloc
<eh_landing_pad_d
> ();
531 lp
->index
= streamer_read_hwi (ib
);
532 gcc_assert (lp
->index
== ix
);
533 lp
->next_lp
= (eh_landing_pad
) (intptr_t) streamer_read_hwi (ib
);
534 lp
->region
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
535 lp
->post_landing_pad
= stream_read_tree (ib
, data_in
);
541 /* After reading the EH regions, pointers to peer and children regions
542 are region numbers. This converts all these region numbers into
543 real pointers into the rematerialized regions for FN. ROOT_REGION
544 is the region number for the root EH region in FN. */
547 fixup_eh_region_pointers (struct function
*fn
, HOST_WIDE_INT root_region
)
550 vec
<eh_region
, va_gc
> *eh_array
= fn
->eh
->region_array
;
551 vec
<eh_landing_pad
, va_gc
> *lp_array
= fn
->eh
->lp_array
;
555 gcc_assert (eh_array
&& lp_array
);
557 gcc_assert (root_region
>= 0);
558 fn
->eh
->region_tree
= (*eh_array
)[root_region
];
560 #define FIXUP_EH_REGION(r) (r) = (*eh_array)[(HOST_WIDE_INT) (intptr_t) (r)]
561 #define FIXUP_EH_LP(p) (p) = (*lp_array)[(HOST_WIDE_INT) (intptr_t) (p)]
563 /* Convert all the index numbers stored in pointer fields into
564 pointers to the corresponding slots in the EH region array. */
565 FOR_EACH_VEC_ELT (*eh_array
, i
, r
)
567 /* The array may contain NULL regions. */
571 gcc_assert (i
== (unsigned) r
->index
);
572 FIXUP_EH_REGION (r
->outer
);
573 FIXUP_EH_REGION (r
->inner
);
574 FIXUP_EH_REGION (r
->next_peer
);
575 FIXUP_EH_LP (r
->landing_pads
);
578 /* Convert all the index numbers stored in pointer fields into
579 pointers to the corresponding slots in the EH landing pad array. */
580 FOR_EACH_VEC_ELT (*lp_array
, i
, lp
)
582 /* The array may contain NULL landing pads. */
586 gcc_assert (i
== (unsigned) lp
->index
);
587 FIXUP_EH_LP (lp
->next_lp
);
588 FIXUP_EH_REGION (lp
->region
);
591 #undef FIXUP_EH_REGION
596 /* Initialize EH support. */
601 static bool eh_initialized_p
= false;
603 if (eh_initialized_p
)
606 /* Contrary to most other FEs, we only initialize EH support when at
607 least one of the files in the set contains exception regions in
608 it. Since this happens much later than the call to init_eh in
609 lang_dependent_init, we have to set flag_exceptions and call
610 init_eh again to initialize the EH tables. */
614 eh_initialized_p
= true;
618 /* Read the exception table for FN from IB using the data descriptors
622 input_eh_regions (struct lto_input_block
*ib
, struct data_in
*data_in
,
625 HOST_WIDE_INT i
, root_region
, len
;
628 tag
= streamer_read_record_start (ib
);
632 lto_tag_check_range (tag
, LTO_eh_table
, LTO_eh_table
);
634 /* If the file contains EH regions, then it was compiled with
635 -fexceptions. In that case, initialize the backend EH
641 root_region
= streamer_read_hwi (ib
);
642 gcc_assert (root_region
== (int) root_region
);
644 /* Read the EH region array. */
645 len
= streamer_read_hwi (ib
);
646 gcc_assert (len
== (int) len
);
649 vec_safe_grow_cleared (fn
->eh
->region_array
, len
);
650 for (i
= 0; i
< len
; i
++)
652 eh_region r
= input_eh_region (ib
, data_in
, i
);
653 (*fn
->eh
->region_array
)[i
] = r
;
657 /* Read the landing pads. */
658 len
= streamer_read_hwi (ib
);
659 gcc_assert (len
== (int) len
);
662 vec_safe_grow_cleared (fn
->eh
->lp_array
, len
);
663 for (i
= 0; i
< len
; i
++)
665 eh_landing_pad lp
= input_eh_lp (ib
, data_in
, i
);
666 (*fn
->eh
->lp_array
)[i
] = lp
;
670 /* Read the runtime type data. */
671 len
= streamer_read_hwi (ib
);
672 gcc_assert (len
== (int) len
);
675 vec_safe_grow_cleared (fn
->eh
->ttype_data
, len
);
676 for (i
= 0; i
< len
; i
++)
678 tree ttype
= stream_read_tree (ib
, data_in
);
679 (*fn
->eh
->ttype_data
)[i
] = ttype
;
683 /* Read the table of action chains. */
684 len
= streamer_read_hwi (ib
);
685 gcc_assert (len
== (int) len
);
688 if (targetm
.arm_eabi_unwinder
)
690 vec_safe_grow_cleared (fn
->eh
->ehspec_data
.arm_eabi
, len
);
691 for (i
= 0; i
< len
; i
++)
693 tree t
= stream_read_tree (ib
, data_in
);
694 (*fn
->eh
->ehspec_data
.arm_eabi
)[i
] = t
;
699 vec_safe_grow_cleared (fn
->eh
->ehspec_data
.other
, len
);
700 for (i
= 0; i
< len
; i
++)
702 uchar c
= streamer_read_uchar (ib
);
703 (*fn
->eh
->ehspec_data
.other
)[i
] = c
;
708 /* Reconstruct the EH region tree by fixing up the peer/children
710 fixup_eh_region_pointers (fn
, root_region
);
712 tag
= streamer_read_record_start (ib
);
713 lto_tag_check_range (tag
, LTO_null
, LTO_null
);
717 /* Make a new basic block with index INDEX in function FN. */
720 make_new_block (struct function
*fn
, unsigned int index
)
722 basic_block bb
= alloc_block ();
724 SET_BASIC_BLOCK_FOR_FN (fn
, index
, bb
);
725 n_basic_blocks_for_fn (fn
)++;
730 /* Read a wide-int. */
733 streamer_read_wi (struct lto_input_block
*ib
)
735 HOST_WIDE_INT a
[WIDE_INT_MAX_ELTS
];
737 int prec ATTRIBUTE_UNUSED
= streamer_read_uhwi (ib
);
738 int len
= streamer_read_uhwi (ib
);
739 for (i
= 0; i
< len
; i
++)
740 a
[i
] = streamer_read_hwi (ib
);
741 return widest_int::from_array (a
, len
);
745 /* Read the CFG for function FN from input block IB. */
748 input_cfg (struct lto_input_block
*ib
, struct data_in
*data_in
,
750 int count_materialization_scale
)
752 unsigned int bb_count
;
757 init_empty_tree_cfg_for_function (fn
);
758 init_ssa_operands (fn
);
760 profile_status_for_fn (fn
) = streamer_read_enum (ib
, profile_status_d
,
763 bb_count
= streamer_read_uhwi (ib
);
765 last_basic_block_for_fn (fn
) = bb_count
;
766 if (bb_count
> basic_block_info_for_fn (fn
)->length ())
767 vec_safe_grow_cleared (basic_block_info_for_fn (fn
), bb_count
);
769 if (bb_count
> label_to_block_map_for_fn (fn
)->length ())
770 vec_safe_grow_cleared (label_to_block_map_for_fn (fn
), bb_count
);
772 index
= streamer_read_hwi (ib
);
775 basic_block bb
= BASIC_BLOCK_FOR_FN (fn
, index
);
776 unsigned int edge_count
;
779 bb
= make_new_block (fn
, index
);
781 edge_count
= streamer_read_uhwi (ib
);
783 /* Connect up the CFG. */
784 for (i
= 0; i
< edge_count
; i
++)
786 unsigned int dest_index
;
787 unsigned int edge_flags
;
793 dest_index
= streamer_read_uhwi (ib
);
794 probability
= (int) streamer_read_hwi (ib
);
795 count
= apply_scale ((gcov_type
) streamer_read_gcov_count (ib
),
796 count_materialization_scale
);
797 edge_flags
= streamer_read_uhwi (ib
);
799 dest
= BASIC_BLOCK_FOR_FN (fn
, dest_index
);
802 dest
= make_new_block (fn
, dest_index
);
804 e
= make_edge (bb
, dest
, edge_flags
);
805 e
->probability
= probability
;
809 index
= streamer_read_hwi (ib
);
812 p_bb
= ENTRY_BLOCK_PTR_FOR_FN (fn
);
813 index
= streamer_read_hwi (ib
);
816 basic_block bb
= BASIC_BLOCK_FOR_FN (fn
, index
);
820 index
= streamer_read_hwi (ib
);
823 /* ??? The cfgloop interface is tied to cfun. */
824 gcc_assert (cfun
== fn
);
826 /* Input the loop tree. */
827 unsigned n_loops
= streamer_read_uhwi (ib
);
831 struct loops
*loops
= ggc_cleared_alloc
<struct loops
> ();
832 init_loops_structure (fn
, loops
, n_loops
);
833 set_loops_for_fn (fn
, loops
);
835 /* Input each loop and associate it with its loop header so
836 flow_loops_find can rebuild the loop tree. */
837 for (unsigned i
= 1; i
< n_loops
; ++i
)
839 int header_index
= streamer_read_hwi (ib
);
840 if (header_index
== -1)
842 loops
->larray
->quick_push (NULL
);
846 struct loop
*loop
= alloc_loop ();
847 loop
->header
= BASIC_BLOCK_FOR_FN (fn
, header_index
);
848 loop
->header
->loop_father
= loop
;
850 /* Read everything copy_loop_info copies. */
851 loop
->estimate_state
= streamer_read_enum (ib
, loop_estimation
, EST_LAST
);
852 loop
->any_upper_bound
= streamer_read_hwi (ib
);
853 if (loop
->any_upper_bound
)
854 loop
->nb_iterations_upper_bound
= streamer_read_wi (ib
);
855 loop
->any_estimate
= streamer_read_hwi (ib
);
856 if (loop
->any_estimate
)
857 loop
->nb_iterations_estimate
= streamer_read_wi (ib
);
859 /* Read OMP SIMD related info. */
860 loop
->safelen
= streamer_read_hwi (ib
);
861 loop
->dont_vectorize
= streamer_read_hwi (ib
);
862 loop
->force_vectorize
= streamer_read_hwi (ib
);
863 loop
->simduid
= stream_read_tree (ib
, data_in
);
865 place_new_loop (fn
, loop
);
867 /* flow_loops_find doesn't like loops not in the tree, hook them
868 all as siblings of the tree root temporarily. */
869 flow_loop_tree_node_add (loops
->tree_root
, loop
);
872 /* Rebuild the loop tree. */
873 flow_loops_find (loops
);
877 /* Read the SSA names array for function FN from DATA_IN using input
881 input_ssa_names (struct lto_input_block
*ib
, struct data_in
*data_in
,
884 unsigned int i
, size
;
886 size
= streamer_read_uhwi (ib
);
887 init_ssanames (fn
, size
);
889 i
= streamer_read_uhwi (ib
);
895 /* Skip over the elements that had been freed. */
896 while (SSANAMES (fn
)->length () < i
)
897 SSANAMES (fn
)->quick_push (NULL_TREE
);
899 is_default_def
= (streamer_read_uchar (ib
) != 0);
900 name
= stream_read_tree (ib
, data_in
);
901 ssa_name
= make_ssa_name_fn (fn
, name
, gimple_build_nop ());
904 set_ssa_default_def (cfun
, SSA_NAME_VAR (ssa_name
), ssa_name
);
906 i
= streamer_read_uhwi (ib
);
911 /* Go through all NODE edges and fixup call_stmt pointers
912 so they point to STMTS. */
915 fixup_call_stmt_edges_1 (struct cgraph_node
*node
, gimple
*stmts
,
918 struct cgraph_edge
*cedge
;
919 struct ipa_ref
*ref
= NULL
;
922 for (cedge
= node
->callees
; cedge
; cedge
= cedge
->next_callee
)
924 if (gimple_stmt_max_uid (fn
) < cedge
->lto_stmt_uid
)
925 fatal_error (input_location
,
926 "Cgraph edge statement index out of range");
927 cedge
->call_stmt
= as_a
<gcall
*> (stmts
[cedge
->lto_stmt_uid
- 1]);
928 if (!cedge
->call_stmt
)
929 fatal_error (input_location
,
930 "Cgraph edge statement index not found");
932 for (cedge
= node
->indirect_calls
; cedge
; cedge
= cedge
->next_callee
)
934 if (gimple_stmt_max_uid (fn
) < cedge
->lto_stmt_uid
)
935 fatal_error (input_location
,
936 "Cgraph edge statement index out of range");
937 cedge
->call_stmt
= as_a
<gcall
*> (stmts
[cedge
->lto_stmt_uid
- 1]);
938 if (!cedge
->call_stmt
)
939 fatal_error (input_location
, "Cgraph edge statement index not found");
941 for (i
= 0; node
->iterate_reference (i
, ref
); i
++)
942 if (ref
->lto_stmt_uid
)
944 if (gimple_stmt_max_uid (fn
) < ref
->lto_stmt_uid
)
945 fatal_error (input_location
,
946 "Reference statement index out of range");
947 ref
->stmt
= stmts
[ref
->lto_stmt_uid
- 1];
949 fatal_error (input_location
, "Reference statement index not found");
954 /* Fixup call_stmt pointers in NODE and all clones. */
957 fixup_call_stmt_edges (struct cgraph_node
*orig
, gimple
*stmts
)
959 struct cgraph_node
*node
;
962 while (orig
->clone_of
)
963 orig
= orig
->clone_of
;
964 fn
= DECL_STRUCT_FUNCTION (orig
->decl
);
966 fixup_call_stmt_edges_1 (orig
, stmts
, fn
);
968 for (node
= orig
->clones
; node
!= orig
;)
970 fixup_call_stmt_edges_1 (node
, stmts
, fn
);
973 else if (node
->next_sibling_clone
)
974 node
= node
->next_sibling_clone
;
977 while (node
!= orig
&& !node
->next_sibling_clone
)
978 node
= node
->clone_of
;
980 node
= node
->next_sibling_clone
;
986 /* Input the base body of struct function FN from DATA_IN
987 using input block IB. */
990 input_struct_function_base (struct function
*fn
, struct data_in
*data_in
,
991 struct lto_input_block
*ib
)
996 /* Read the static chain and non-local goto save area. */
997 fn
->static_chain_decl
= stream_read_tree (ib
, data_in
);
998 fn
->nonlocal_goto_save_area
= stream_read_tree (ib
, data_in
);
1000 /* Read all the local symbols. */
1001 len
= streamer_read_hwi (ib
);
1005 vec_safe_grow_cleared (fn
->local_decls
, len
);
1006 for (i
= 0; i
< len
; i
++)
1008 tree t
= stream_read_tree (ib
, data_in
);
1009 (*fn
->local_decls
)[i
] = t
;
1013 /* Input the current IL state of the function. */
1014 fn
->curr_properties
= streamer_read_uhwi (ib
);
1016 /* Read all the attributes for FN. */
1017 bp
= streamer_read_bitpack (ib
);
1018 fn
->is_thunk
= bp_unpack_value (&bp
, 1);
1019 fn
->has_local_explicit_reg_vars
= bp_unpack_value (&bp
, 1);
1020 fn
->returns_pcc_struct
= bp_unpack_value (&bp
, 1);
1021 fn
->returns_struct
= bp_unpack_value (&bp
, 1);
1022 fn
->can_throw_non_call_exceptions
= bp_unpack_value (&bp
, 1);
1023 fn
->can_delete_dead_exceptions
= bp_unpack_value (&bp
, 1);
1024 fn
->always_inline_functions_inlined
= bp_unpack_value (&bp
, 1);
1025 fn
->after_inlining
= bp_unpack_value (&bp
, 1);
1026 fn
->stdarg
= bp_unpack_value (&bp
, 1);
1027 fn
->has_nonlocal_label
= bp_unpack_value (&bp
, 1);
1028 fn
->calls_alloca
= bp_unpack_value (&bp
, 1);
1029 fn
->calls_setjmp
= bp_unpack_value (&bp
, 1);
1030 fn
->has_force_vectorize_loops
= bp_unpack_value (&bp
, 1);
1031 fn
->has_simduid_loops
= bp_unpack_value (&bp
, 1);
1032 fn
->va_list_fpr_size
= bp_unpack_value (&bp
, 8);
1033 fn
->va_list_gpr_size
= bp_unpack_value (&bp
, 8);
1034 fn
->last_clique
= bp_unpack_value (&bp
, sizeof (short) * 8);
1036 /* Input the function start and end loci. */
1037 fn
->function_start_locus
= stream_input_location_now (&bp
, data_in
);
1038 fn
->function_end_locus
= stream_input_location_now (&bp
, data_in
);
1042 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1045 input_function (tree fn_decl
, struct data_in
*data_in
,
1046 struct lto_input_block
*ib
, struct lto_input_block
*ib_cfg
)
1048 struct function
*fn
;
1052 struct cgraph_node
*node
;
1054 tag
= streamer_read_record_start (ib
);
1055 lto_tag_check (tag
, LTO_function
);
1057 /* Read decls for parameters and args. */
1058 DECL_RESULT (fn_decl
) = stream_read_tree (ib
, data_in
);
1059 DECL_ARGUMENTS (fn_decl
) = streamer_read_chain (ib
, data_in
);
1061 /* Read the tree of lexical scopes for the function. */
1062 DECL_INITIAL (fn_decl
) = stream_read_tree (ib
, data_in
);
1064 if (!streamer_read_uhwi (ib
))
1067 push_struct_function (fn_decl
);
1068 fn
= DECL_STRUCT_FUNCTION (fn_decl
);
1070 /* We input IL in SSA form. */
1071 cfun
->gimple_df
->in_ssa_p
= true;
1073 gimple_register_cfg_hooks ();
1075 node
= cgraph_node::get (fn_decl
);
1077 node
= cgraph_node::create (fn_decl
);
1078 input_struct_function_base (fn
, data_in
, ib
);
1079 input_cfg (ib_cfg
, data_in
, fn
, node
->count_materialization_scale
);
1081 /* Read all the SSA names. */
1082 input_ssa_names (ib
, data_in
, fn
);
1084 /* Read the exception handling regions in the function. */
1085 input_eh_regions (ib
, data_in
, fn
);
1087 gcc_assert (DECL_INITIAL (fn_decl
));
1088 DECL_SAVED_TREE (fn_decl
) = NULL_TREE
;
1090 /* Read all the basic blocks. */
1091 tag
= streamer_read_record_start (ib
);
1094 input_bb (ib
, tag
, data_in
, fn
,
1095 node
->count_materialization_scale
);
1096 tag
= streamer_read_record_start (ib
);
1099 /* Fix up the call statements that are mentioned in the callgraph
1101 set_gimple_stmt_max_uid (cfun
, 0);
1102 FOR_ALL_BB_FN (bb
, cfun
)
1104 gimple_stmt_iterator gsi
;
1105 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1107 gimple stmt
= gsi_stmt (gsi
);
1108 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
1110 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1112 gimple stmt
= gsi_stmt (gsi
);
1113 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
1116 stmts
= (gimple
*) xcalloc (gimple_stmt_max_uid (fn
), sizeof (gimple
));
1117 FOR_ALL_BB_FN (bb
, cfun
)
1119 gimple_stmt_iterator bsi
= gsi_start_phis (bb
);
1120 while (!gsi_end_p (bsi
))
1122 gimple stmt
= gsi_stmt (bsi
);
1124 stmts
[gimple_uid (stmt
)] = stmt
;
1126 bsi
= gsi_start_bb (bb
);
1127 while (!gsi_end_p (bsi
))
1129 gimple stmt
= gsi_stmt (bsi
);
1130 /* If we're recompiling LTO objects with debug stmts but
1131 we're not supposed to have debug stmts, remove them now.
1132 We can't remove them earlier because this would cause uid
1133 mismatches in fixups, but we can do it at this point, as
1134 long as debug stmts don't require fixups. */
1135 if (!MAY_HAVE_DEBUG_STMTS
&& !flag_wpa
&& is_gimple_debug (stmt
))
1137 gimple_stmt_iterator gsi
= bsi
;
1139 gsi_remove (&gsi
, true);
1144 stmts
[gimple_uid (stmt
)] = stmt
;
1149 /* Set the gimple body to the statement sequence in the entry
1150 basic block. FIXME lto, this is fairly hacky. The existence
1151 of a gimple body is used by the cgraph routines, but we should
1152 really use the presence of the CFG. */
1154 edge_iterator ei
= ei_start (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
);
1155 gimple_set_body (fn_decl
, bb_seq (ei_edge (ei
)->dest
));
1158 fixup_call_stmt_edges (node
, stmts
);
1159 execute_all_ipa_stmt_fixups (node
, stmts
);
1161 update_ssa (TODO_update_ssa_only_virtuals
);
1162 free_dominance_info (CDI_DOMINATORS
);
1163 free_dominance_info (CDI_POST_DOMINATORS
);
1168 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1171 input_constructor (tree var
, struct data_in
*data_in
,
1172 struct lto_input_block
*ib
)
1174 DECL_INITIAL (var
) = stream_read_tree (ib
, data_in
);
1178 /* Read the body from DATA for function NODE and fill it in.
1179 FILE_DATA are the global decls and types. SECTION_TYPE is either
1180 LTO_section_function_body or LTO_section_static_initializer. If
1181 section type is LTO_section_function_body, FN must be the decl for
1185 lto_read_body_or_constructor (struct lto_file_decl_data
*file_data
, struct symtab_node
*node
,
1186 const char *data
, enum lto_section_type section_type
)
1188 const struct lto_function_header
*header
;
1189 struct data_in
*data_in
;
1193 tree fn_decl
= node
->decl
;
1195 header
= (const struct lto_function_header
*) data
;
1196 if (TREE_CODE (node
->decl
) == FUNCTION_DECL
)
1198 cfg_offset
= sizeof (struct lto_function_header
);
1199 main_offset
= cfg_offset
+ header
->cfg_size
;
1200 string_offset
= main_offset
+ header
->main_size
;
1204 main_offset
= sizeof (struct lto_function_header
);
1205 string_offset
= main_offset
+ header
->main_size
;
1208 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
1209 header
->string_size
, vNULL
);
1211 if (section_type
== LTO_section_function_body
)
1213 struct lto_in_decl_state
*decl_state
;
1216 gcc_checking_assert (node
);
1218 /* Use the function's decl state. */
1219 decl_state
= lto_get_function_in_decl_state (file_data
, fn_decl
);
1220 gcc_assert (decl_state
);
1221 file_data
->current_decl_state
= decl_state
;
1224 /* Set up the struct function. */
1225 from
= data_in
->reader_cache
->nodes
.length ();
1226 lto_input_block
ib_main (data
+ main_offset
, header
->main_size
,
1227 file_data
->mode_table
);
1228 if (TREE_CODE (node
->decl
) == FUNCTION_DECL
)
1230 lto_input_block
ib_cfg (data
+ cfg_offset
, header
->cfg_size
,
1231 file_data
->mode_table
);
1232 input_function (fn_decl
, data_in
, &ib_main
, &ib_cfg
);
1235 input_constructor (fn_decl
, data_in
, &ib_main
);
1236 data_in
->location_cache
.apply_location_cache ();
1237 /* And fixup types we streamed locally. */
1239 struct streamer_tree_cache_d
*cache
= data_in
->reader_cache
;
1240 unsigned len
= cache
->nodes
.length ();
1242 for (i
= len
; i
-- > from
;)
1244 tree t
= streamer_tree_cache_get_tree (cache
, i
);
1250 gcc_assert (TYPE_CANONICAL (t
) == NULL_TREE
);
1251 TYPE_CANONICAL (t
) = TYPE_MAIN_VARIANT (t
);
1252 if (TYPE_MAIN_VARIANT (t
) != t
)
1254 gcc_assert (TYPE_NEXT_VARIANT (t
) == NULL_TREE
);
1255 TYPE_NEXT_VARIANT (t
)
1256 = TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t
));
1257 TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t
)) = t
;
1263 /* Restore decl state */
1264 file_data
->current_decl_state
= file_data
->global_decl_state
;
1267 lto_data_in_delete (data_in
);
1271 /* Read the body of NODE using DATA. FILE_DATA holds the global
1275 lto_input_function_body (struct lto_file_decl_data
*file_data
,
1276 struct cgraph_node
*node
, const char *data
)
1278 lto_read_body_or_constructor (file_data
, node
, data
, LTO_section_function_body
);
1281 /* Read the body of NODE using DATA. FILE_DATA holds the global
1285 lto_input_variable_constructor (struct lto_file_decl_data
*file_data
,
1286 struct varpool_node
*node
, const char *data
)
1288 lto_read_body_or_constructor (file_data
, node
, data
, LTO_section_function_body
);
1292 /* Read the physical representation of a tree node EXPR from
1293 input block IB using the per-file context in DATA_IN. */
1296 lto_read_tree_1 (struct lto_input_block
*ib
, struct data_in
*data_in
, tree expr
)
1298 /* Read all the bitfield values in EXPR. Note that for LTO, we
1299 only write language-independent bitfields, so no more unpacking is
1301 streamer_read_tree_bitfields (ib
, data_in
, expr
);
1303 /* Read all the pointer fields in EXPR. */
1304 streamer_read_tree_body (ib
, data_in
, expr
);
1306 /* Read any LTO-specific data not read by the tree streamer. */
1308 && TREE_CODE (expr
) != FUNCTION_DECL
1309 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
1310 DECL_INITIAL (expr
) = stream_read_tree (ib
, data_in
);
1312 /* We should never try to instantiate an MD or NORMAL builtin here. */
1313 if (TREE_CODE (expr
) == FUNCTION_DECL
)
1314 gcc_assert (!streamer_handle_as_builtin_p (expr
));
1316 #ifdef LTO_STREAMER_DEBUG
1317 /* Remove the mapping to RESULT's original address set by
1318 streamer_alloc_tree. */
1319 lto_orig_address_remove (expr
);
1323 /* Read the physical representation of a tree node with tag TAG from
1324 input block IB using the per-file context in DATA_IN. */
1327 lto_read_tree (struct lto_input_block
*ib
, struct data_in
*data_in
,
1328 enum LTO_tags tag
, hashval_t hash
)
1330 /* Instantiate a new tree node. */
1331 tree result
= streamer_alloc_tree (ib
, data_in
, tag
);
1333 /* Enter RESULT in the reader cache. This will make RESULT
1334 available so that circular references in the rest of the tree
1335 structure can be resolved in subsequent calls to stream_read_tree. */
1336 streamer_tree_cache_append (data_in
->reader_cache
, result
, hash
);
1338 lto_read_tree_1 (ib
, data_in
, result
);
1340 /* end_marker = */ streamer_read_uchar (ib
);
1346 /* Populate the reader cache with trees materialized from the SCC
1347 following in the IB, DATA_IN stream. */
1350 lto_input_scc (struct lto_input_block
*ib
, struct data_in
*data_in
,
1351 unsigned *len
, unsigned *entry_len
)
1353 /* A blob of unnamed tree nodes, fill the cache from it and
1355 unsigned size
= streamer_read_uhwi (ib
);
1356 hashval_t scc_hash
= streamer_read_uhwi (ib
);
1357 unsigned scc_entry_len
= 1;
1361 enum LTO_tags tag
= streamer_read_record_start (ib
);
1362 lto_input_tree_1 (ib
, data_in
, tag
, scc_hash
);
1366 unsigned int first
= data_in
->reader_cache
->nodes
.length ();
1369 scc_entry_len
= streamer_read_uhwi (ib
);
1371 /* Materialize size trees by reading their headers. */
1372 for (unsigned i
= 0; i
< size
; ++i
)
1374 enum LTO_tags tag
= streamer_read_record_start (ib
);
1376 || (tag
>= LTO_field_decl_ref
&& tag
<= LTO_global_decl_ref
)
1377 || tag
== LTO_tree_pickle_reference
1378 || tag
== LTO_builtin_decl
1379 || tag
== LTO_integer_cst
1380 || tag
== LTO_tree_scc
)
1383 result
= streamer_alloc_tree (ib
, data_in
, tag
);
1384 streamer_tree_cache_append (data_in
->reader_cache
, result
, 0);
1387 /* Read the tree bitpacks and references. */
1388 for (unsigned i
= 0; i
< size
; ++i
)
1390 result
= streamer_tree_cache_get_tree (data_in
->reader_cache
,
1392 lto_read_tree_1 (ib
, data_in
, result
);
1393 /* end_marker = */ streamer_read_uchar (ib
);
1398 *entry_len
= scc_entry_len
;
1403 /* Read a tree from input block IB using the per-file context in
1404 DATA_IN. This context is used, for example, to resolve references
1405 to previously read nodes. */
1408 lto_input_tree_1 (struct lto_input_block
*ib
, struct data_in
*data_in
,
1409 enum LTO_tags tag
, hashval_t hash
)
1413 gcc_assert ((unsigned) tag
< (unsigned) LTO_NUM_TAGS
);
1415 if (tag
== LTO_null
)
1417 else if (tag
>= LTO_field_decl_ref
&& tag
<= LTO_namelist_decl_ref
)
1419 /* If TAG is a reference to an indexable tree, the next value
1420 in IB is the index into the table where we expect to find
1422 result
= lto_input_tree_ref (ib
, data_in
, cfun
, tag
);
1424 else if (tag
== LTO_tree_pickle_reference
)
1426 /* If TAG is a reference to a previously read tree, look it up in
1427 the reader cache. */
1428 result
= streamer_get_pickled_tree (ib
, data_in
);
1430 else if (tag
== LTO_builtin_decl
)
1432 /* If we are going to read a built-in function, all we need is
1433 the code and class. */
1434 result
= streamer_get_builtin_tree (ib
, data_in
);
1436 else if (tag
== LTO_integer_cst
)
1438 /* For shared integer constants in singletons we can use the
1439 existing tree integer constant merging code. */
1440 tree type
= stream_read_tree (ib
, data_in
);
1441 unsigned HOST_WIDE_INT len
= streamer_read_uhwi (ib
);
1442 unsigned HOST_WIDE_INT i
;
1443 HOST_WIDE_INT a
[WIDE_INT_MAX_ELTS
];
1445 for (i
= 0; i
< len
; i
++)
1446 a
[i
] = streamer_read_hwi (ib
);
1447 gcc_assert (TYPE_PRECISION (type
) <= MAX_BITSIZE_MODE_ANY_INT
);
1448 result
= wide_int_to_tree (type
, wide_int::from_array
1449 (a
, len
, TYPE_PRECISION (type
)));
1450 streamer_tree_cache_append (data_in
->reader_cache
, result
, hash
);
1452 else if (tag
== LTO_tree_scc
)
1456 /* Otherwise, materialize a new node from IB. */
1457 result
= lto_read_tree (ib
, data_in
, tag
, hash
);
1464 lto_input_tree (struct lto_input_block
*ib
, struct data_in
*data_in
)
1468 /* Input and skip SCCs. */
1469 while ((tag
= streamer_read_record_start (ib
)) == LTO_tree_scc
)
1471 unsigned len
, entry_len
;
1472 lto_input_scc (ib
, data_in
, &len
, &entry_len
);
1474 return lto_input_tree_1 (ib
, data_in
, tag
, 0);
1478 /* Input toplevel asms. */
1481 lto_input_toplevel_asms (struct lto_file_decl_data
*file_data
, int order_base
)
1484 const char *data
= lto_get_section_data (file_data
, LTO_section_asm
,
1486 const struct lto_simple_header_with_strings
*header
1487 = (const struct lto_simple_header_with_strings
*) data
;
1489 struct data_in
*data_in
;
1495 string_offset
= sizeof (*header
) + header
->main_size
;
1497 lto_input_block
ib (data
+ sizeof (*header
), header
->main_size
,
1498 file_data
->mode_table
);
1500 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
1501 header
->string_size
, vNULL
);
1503 while ((str
= streamer_read_string_cst (data_in
, &ib
)))
1505 asm_node
*node
= symtab
->finalize_toplevel_asm (str
);
1506 node
->order
= streamer_read_hwi (&ib
) + order_base
;
1507 if (node
->order
>= symtab
->order
)
1508 symtab
->order
= node
->order
+ 1;
1511 lto_data_in_delete (data_in
);
1513 lto_free_section_data (file_data
, LTO_section_asm
, NULL
, data
, len
);
1517 /* Input mode table. */
1520 lto_input_mode_table (struct lto_file_decl_data
*file_data
)
1523 const char *data
= lto_get_section_data (file_data
, LTO_section_mode_table
,
1527 internal_error ("cannot read LTO mode table from %s",
1528 file_data
->file_name
);
1532 unsigned char *table
= ggc_cleared_vec_alloc
<unsigned char> (1 << 8);
1533 file_data
->mode_table
= table
;
1534 const struct lto_simple_header_with_strings
*header
1535 = (const struct lto_simple_header_with_strings
*) data
;
1537 struct data_in
*data_in
;
1538 string_offset
= sizeof (*header
) + header
->main_size
;
1540 lto_input_block
ib (data
+ sizeof (*header
), header
->main_size
, NULL
);
1541 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
1542 header
->string_size
, vNULL
);
1543 bitpack_d bp
= streamer_read_bitpack (&ib
);
1545 table
[VOIDmode
] = VOIDmode
;
1546 table
[BLKmode
] = BLKmode
;
1548 while ((m
= bp_unpack_value (&bp
, 8)) != VOIDmode
)
1550 enum mode_class mclass
1551 = bp_unpack_enum (&bp
, mode_class
, MAX_MODE_CLASS
);
1552 unsigned int size
= bp_unpack_value (&bp
, 8);
1553 unsigned int prec
= bp_unpack_value (&bp
, 16);
1554 machine_mode inner
= (machine_mode
) bp_unpack_value (&bp
, 8);
1555 unsigned int nunits
= bp_unpack_value (&bp
, 8);
1556 unsigned int ibit
= 0, fbit
= 0;
1557 unsigned int real_fmt_len
= 0;
1558 const char *real_fmt_name
= NULL
;
1565 ibit
= bp_unpack_value (&bp
, 8);
1566 fbit
= bp_unpack_value (&bp
, 8);
1569 case MODE_DECIMAL_FLOAT
:
1570 real_fmt_name
= bp_unpack_indexed_string (data_in
, &bp
,
1576 /* First search just the GET_CLASS_NARROWEST_MODE to wider modes,
1577 if not found, fallback to all modes. */
1579 for (pass
= 0; pass
< 2; pass
++)
1580 for (machine_mode mr
= pass
? VOIDmode
1581 : GET_CLASS_NARROWEST_MODE (mclass
);
1582 pass
? mr
< MAX_MACHINE_MODE
: mr
!= VOIDmode
;
1583 pass
? mr
= (machine_mode
) (mr
+ 1)
1584 : mr
= GET_MODE_WIDER_MODE (mr
))
1585 if (GET_MODE_CLASS (mr
) != mclass
1586 || GET_MODE_SIZE (mr
) != size
1587 || GET_MODE_PRECISION (mr
) != prec
1589 ? GET_MODE_INNER (mr
) != mr
1590 : GET_MODE_INNER (mr
) != table
[(int) inner
])
1591 || GET_MODE_IBIT (mr
) != ibit
1592 || GET_MODE_FBIT (mr
) != fbit
1593 || GET_MODE_NUNITS (mr
) != nunits
)
1595 else if ((mclass
== MODE_FLOAT
|| mclass
== MODE_DECIMAL_FLOAT
)
1596 && strcmp (REAL_MODE_FORMAT (mr
)->name
, real_fmt_name
) != 0)
1604 unsigned int mname_len
;
1605 const char *mname
= bp_unpack_indexed_string (data_in
, &bp
, &mname_len
);
1610 case MODE_VECTOR_INT
:
1611 case MODE_VECTOR_FLOAT
:
1612 case MODE_VECTOR_FRACT
:
1613 case MODE_VECTOR_UFRACT
:
1614 case MODE_VECTOR_ACCUM
:
1615 case MODE_VECTOR_UACCUM
:
1616 /* For unsupported vector modes just use BLKmode,
1617 if the scalar mode is supported. */
1618 if (table
[(int) inner
] != VOIDmode
)
1625 fatal_error (UNKNOWN_LOCATION
, "unsupported mode %s\n", mname
);
1630 lto_data_in_delete (data_in
);
1632 lto_free_section_data (file_data
, LTO_section_mode_table
, NULL
, data
, len
);
1636 /* Initialization for the LTO reader. */
1639 lto_reader_init (void)
1641 lto_streamer_init ();
1642 file_name_hash_table
1643 = new hash_table
<freeing_string_slot_hasher
> (37);
1647 /* Create a new data_in object for FILE_DATA. STRINGS is the string
1648 table to use with LEN strings. RESOLUTIONS is the vector of linker
1649 resolutions (NULL if not using a linker plugin). */
1652 lto_data_in_create (struct lto_file_decl_data
*file_data
, const char *strings
,
1654 vec
<ld_plugin_symbol_resolution_t
> resolutions
)
1656 struct data_in
*data_in
= new (struct data_in
);
1657 data_in
->file_data
= file_data
;
1658 data_in
->strings
= strings
;
1659 data_in
->strings_len
= len
;
1660 data_in
->globals_resolution
= resolutions
;
1661 data_in
->reader_cache
= streamer_tree_cache_create (false, false, true);
1666 /* Remove DATA_IN. */
1669 lto_data_in_delete (struct data_in
*data_in
)
1671 data_in
->globals_resolution
.release ();
1672 streamer_tree_cache_delete (data_in
->reader_cache
);