1 /* Read the GIMPLE representation from a file stream.
3 Copyright (C) 2009-2020 Free Software Foundation, Inc.
4 Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
5 Re-implemented by Diego Novillo <dnovillo@google.com>
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
32 #include "tree-pass.h"
34 #include "gimple-streamer.h"
36 #include "gimple-iterator.h"
38 #include "tree-into-ssa.h"
45 #include "alloc-pool.h"
47 /* Allocator used to hold string slot entries for line map streaming. */
48 static struct object_allocator
<struct string_slot
> *string_slot_allocator
;
50 /* The table to hold the file names. */
51 static hash_table
<string_slot_hasher
> *file_name_hash_table
;
53 /* This obstack holds file names used in locators. Line map datastructures
54 points here and thus it needs to be kept allocated as long as linemaps
56 static struct obstack file_name_obstack
;
59 /* Check that tag ACTUAL has one of the given values. NUM_TAGS is the
60 number of valid tag values to check. */
63 lto_tag_check_set (enum LTO_tags actual
, int ntags
, ...)
69 for (i
= 0; i
< ntags
; i
++)
70 if ((unsigned) actual
== va_arg (ap
, unsigned))
77 internal_error ("bytecode stream: unexpected tag %s", lto_tag_name (actual
));
81 /* Read LENGTH bytes from STREAM to ADDR. */
84 lto_input_data_block (class lto_input_block
*ib
, void *addr
, size_t length
)
87 unsigned char *const buffer
= (unsigned char *) addr
;
89 for (i
= 0; i
< length
; i
++)
90 buffer
[i
] = streamer_read_uchar (ib
);
94 /* Lookup STRING in file_name_hash_table. If found, return the existing
95 string, otherwise insert STRING as the canonical version. */
98 canon_file_name (const char *string
)
101 struct string_slot s_slot
;
102 size_t len
= strlen (string
);
107 slot
= file_name_hash_table
->find_slot (&s_slot
, INSERT
);
111 struct string_slot
*new_slot
;
113 saved_string
= XOBNEWVEC (&file_name_obstack
, char, len
+ 1);
114 new_slot
= string_slot_allocator
->allocate ();
115 memcpy (saved_string
, string
, len
+ 1);
116 new_slot
->s
= saved_string
;
123 struct string_slot
*old_slot
= *slot
;
128 /* Pointer to currently alive instance of lto_location_cache. */
130 lto_location_cache
*lto_location_cache::current_cache
;
132 /* Sort locations in source order. Start with file from last application. */
135 lto_location_cache::cmp_loc (const void *pa
, const void *pb
)
137 const cached_location
*a
= ((const cached_location
*)pa
);
138 const cached_location
*b
= ((const cached_location
*)pb
);
139 const char *current_file
= current_cache
->current_file
;
140 int current_line
= current_cache
->current_line
;
142 if (a
->file
== current_file
&& b
->file
!= current_file
)
144 if (a
->file
!= current_file
&& b
->file
== current_file
)
146 if (a
->file
== current_file
&& b
->file
== current_file
)
148 if (a
->line
== current_line
&& b
->line
!= current_line
)
150 if (a
->line
!= current_line
&& b
->line
== current_line
)
153 if (a
->file
!= b
->file
)
154 return strcmp (a
->file
, b
->file
);
155 if (a
->sysp
!= b
->sysp
)
156 return a
->sysp
? 1 : -1;
157 if (a
->line
!= b
->line
)
158 return a
->line
- b
->line
;
159 return a
->col
- b
->col
;
162 /* Apply all changes in location cache. Add locations into linemap and patch
166 lto_location_cache::apply_location_cache ()
168 static const char *prev_file
;
169 if (!loc_cache
.length ())
171 if (loc_cache
.length () > 1)
172 loc_cache
.qsort (cmp_loc
);
174 for (unsigned int i
= 0; i
< loc_cache
.length (); i
++)
176 struct cached_location loc
= loc_cache
[i
];
178 if (current_file
!= loc
.file
)
179 linemap_add (line_table
, prev_file
? LC_RENAME
: LC_ENTER
,
180 loc
.sysp
, loc
.file
, loc
.line
);
181 else if (current_line
!= loc
.line
)
185 for (unsigned int j
= i
+ 1; j
< loc_cache
.length (); j
++)
186 if (loc
.file
!= loc_cache
[j
].file
187 || loc
.line
!= loc_cache
[j
].line
)
189 else if (max
< loc_cache
[j
].col
)
190 max
= loc_cache
[j
].col
;
191 linemap_line_start (line_table
, loc
.line
, max
+ 1);
193 gcc_assert (*loc
.loc
== BUILTINS_LOCATION
+ 1);
194 if (current_file
== loc
.file
&& current_line
== loc
.line
195 && current_col
== loc
.col
)
196 *loc
.loc
= current_loc
;
198 current_loc
= *loc
.loc
= linemap_position_for_column (line_table
,
200 current_line
= loc
.line
;
201 prev_file
= current_file
= loc
.file
;
202 current_col
= loc
.col
;
204 loc_cache
.truncate (0);
209 /* Tree merging did not suceed; mark all changes in the cache as accepted. */
212 lto_location_cache::accept_location_cache ()
214 gcc_assert (current_cache
== this);
215 accepted_length
= loc_cache
.length ();
218 /* Tree merging did suceed; throw away recent changes. */
221 lto_location_cache::revert_location_cache ()
223 loc_cache
.truncate (accepted_length
);
226 /* Read a location bitpack from input block IB and either update *LOC directly
227 or add it to the location cache.
228 It is neccesary to call apply_location_cache to get *LOC updated. */
231 lto_location_cache::input_location (location_t
*loc
, struct bitpack_d
*bp
,
232 class data_in
*data_in
)
234 static const char *stream_file
;
235 static int stream_line
;
236 static int stream_col
;
237 static bool stream_sysp
;
238 bool file_change
, line_change
, column_change
;
240 gcc_assert (current_cache
== this);
242 *loc
= bp_unpack_int_in_range (bp
, "location", 0, RESERVED_LOCATION_COUNT
);
244 if (*loc
< RESERVED_LOCATION_COUNT
)
247 /* Keep value RESERVED_LOCATION_COUNT in *loc as linemap lookups will
250 file_change
= bp_unpack_value (bp
, 1);
251 line_change
= bp_unpack_value (bp
, 1);
252 column_change
= bp_unpack_value (bp
, 1);
256 stream_file
= canon_file_name (bp_unpack_string (data_in
, bp
));
257 stream_sysp
= bp_unpack_value (bp
, 1);
261 stream_line
= bp_unpack_var_len_unsigned (bp
);
264 stream_col
= bp_unpack_var_len_unsigned (bp
);
266 /* This optimization saves location cache operations druing gimple
269 if (current_file
== stream_file
&& current_line
== stream_line
270 && current_col
== stream_col
&& current_sysp
== stream_sysp
)
276 struct cached_location entry
277 = {stream_file
, loc
, stream_line
, stream_col
, stream_sysp
};
278 loc_cache
.safe_push (entry
);
281 /* Read a location bitpack from input block IB and either update *LOC directly
282 or add it to the location cache.
283 It is neccesary to call apply_location_cache to get *LOC updated. */
286 lto_input_location (location_t
*loc
, struct bitpack_d
*bp
,
287 class data_in
*data_in
)
289 data_in
->location_cache
.input_location (loc
, bp
, data_in
);
292 /* Read location and return it instead of going through location caching.
293 This should be used only when the resulting location is not going to be
297 stream_input_location_now (struct bitpack_d
*bp
, class data_in
*data_in
)
300 stream_input_location (&loc
, bp
, data_in
);
301 data_in
->location_cache
.apply_location_cache ();
305 /* Read a reference to a tree node from DATA_IN using input block IB.
306 TAG is the expected node that should be found in IB, if TAG belongs
307 to one of the indexable trees, expect to read a reference index to
308 be looked up in one of the symbol tables, otherwise read the pysical
309 representation of the tree using stream_read_tree. FN is the
310 function scope for the read tree. */
313 lto_input_tree_ref (class lto_input_block
*ib
, class data_in
*data_in
,
314 struct function
*fn
, enum LTO_tags tag
)
316 unsigned HOST_WIDE_INT ix_u
;
317 tree result
= NULL_TREE
;
319 if (tag
== LTO_ssa_name_ref
)
321 ix_u
= streamer_read_uhwi (ib
);
322 result
= (*SSANAMES (fn
))[ix_u
];
326 gcc_checking_assert (tag
== LTO_global_stream_ref
);
327 ix_u
= streamer_read_uhwi (ib
);
328 result
= (*data_in
->file_data
->current_decl_state
329 ->streams
[LTO_DECL_STREAM
])[ix_u
];
337 /* Read VAR_DECL reference to DATA from IB. */
340 lto_input_var_decl_ref (lto_input_block
*ib
, lto_file_decl_data
*file_data
)
342 unsigned int ix_u
= streamer_read_uhwi (ib
);
343 tree result
= (*file_data
->current_decl_state
344 ->streams
[LTO_DECL_STREAM
])[ix_u
];
345 gcc_assert (TREE_CODE (result
) == VAR_DECL
);
349 /* Read VAR_DECL reference to DATA from IB. */
352 lto_input_fn_decl_ref (lto_input_block
*ib
, lto_file_decl_data
*file_data
)
354 unsigned int ix_u
= streamer_read_uhwi (ib
);
355 tree result
= (*file_data
->current_decl_state
356 ->streams
[LTO_DECL_STREAM
])[ix_u
];
357 gcc_assert (TREE_CODE (result
) == FUNCTION_DECL
);
362 /* Read and return a double-linked list of catch handlers from input
363 block IB, using descriptors in DATA_IN. */
365 static struct eh_catch_d
*
366 lto_input_eh_catch_list (class lto_input_block
*ib
, class data_in
*data_in
,
372 *last_p
= first
= NULL
;
373 tag
= streamer_read_record_start (ib
);
379 lto_tag_check_range (tag
, LTO_eh_catch
, LTO_eh_catch
);
381 /* Read the catch node. */
382 n
= ggc_cleared_alloc
<eh_catch_d
> ();
383 n
->type_list
= stream_read_tree (ib
, data_in
);
384 n
->filter_list
= stream_read_tree (ib
, data_in
);
385 n
->label
= stream_read_tree (ib
, data_in
);
387 /* Register all the types in N->FILTER_LIST. */
388 for (list
= n
->filter_list
; list
; list
= TREE_CHAIN (list
))
389 add_type_for_runtime (TREE_VALUE (list
));
391 /* Chain N to the end of the list. */
393 (*last_p
)->next_catch
= n
;
394 n
->prev_catch
= *last_p
;
397 /* Set the head of the list the first time through the loop. */
401 tag
= streamer_read_record_start (ib
);
408 /* Read and return EH region IX from input block IB, using descriptors
412 input_eh_region (class lto_input_block
*ib
, class data_in
*data_in
, int ix
)
417 /* Read the region header. */
418 tag
= streamer_read_record_start (ib
);
422 r
= ggc_cleared_alloc
<eh_region_d
> ();
423 r
->index
= streamer_read_hwi (ib
);
425 gcc_assert (r
->index
== ix
);
427 /* Read all the region pointers as region numbers. We'll fix up
428 the pointers once the whole array has been read. */
429 r
->outer
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
430 r
->inner
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
431 r
->next_peer
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
435 case LTO_ert_cleanup
:
436 r
->type
= ERT_CLEANUP
;
441 struct eh_catch_d
*last_catch
;
443 r
->u
.eh_try
.first_catch
= lto_input_eh_catch_list (ib
, data_in
,
445 r
->u
.eh_try
.last_catch
= last_catch
;
449 case LTO_ert_allowed_exceptions
:
453 r
->type
= ERT_ALLOWED_EXCEPTIONS
;
454 r
->u
.allowed
.type_list
= stream_read_tree (ib
, data_in
);
455 r
->u
.allowed
.label
= stream_read_tree (ib
, data_in
);
456 r
->u
.allowed
.filter
= streamer_read_uhwi (ib
);
458 for (l
= r
->u
.allowed
.type_list
; l
; l
= TREE_CHAIN (l
))
459 add_type_for_runtime (TREE_VALUE (l
));
463 case LTO_ert_must_not_throw
:
465 r
->type
= ERT_MUST_NOT_THROW
;
466 r
->u
.must_not_throw
.failure_decl
= stream_read_tree (ib
, data_in
);
467 bitpack_d bp
= streamer_read_bitpack (ib
);
468 r
->u
.must_not_throw
.failure_loc
469 = stream_input_location_now (&bp
, data_in
);
477 r
->landing_pads
= (eh_landing_pad
) (intptr_t) streamer_read_hwi (ib
);
483 /* Read and return EH landing pad IX from input block IB, using descriptors
486 static eh_landing_pad
487 input_eh_lp (class lto_input_block
*ib
, class data_in
*data_in
, int ix
)
492 /* Read the landing pad header. */
493 tag
= streamer_read_record_start (ib
);
497 lto_tag_check_range (tag
, LTO_eh_landing_pad
, LTO_eh_landing_pad
);
499 lp
= ggc_cleared_alloc
<eh_landing_pad_d
> ();
500 lp
->index
= streamer_read_hwi (ib
);
501 gcc_assert (lp
->index
== ix
);
502 lp
->next_lp
= (eh_landing_pad
) (intptr_t) streamer_read_hwi (ib
);
503 lp
->region
= (eh_region
) (intptr_t) streamer_read_hwi (ib
);
504 lp
->post_landing_pad
= stream_read_tree (ib
, data_in
);
510 /* After reading the EH regions, pointers to peer and children regions
511 are region numbers. This converts all these region numbers into
512 real pointers into the rematerialized regions for FN. ROOT_REGION
513 is the region number for the root EH region in FN. */
516 fixup_eh_region_pointers (struct function
*fn
, HOST_WIDE_INT root_region
)
519 vec
<eh_region
, va_gc
> *eh_array
= fn
->eh
->region_array
;
520 vec
<eh_landing_pad
, va_gc
> *lp_array
= fn
->eh
->lp_array
;
524 gcc_assert (eh_array
&& lp_array
);
526 gcc_assert (root_region
>= 0);
527 fn
->eh
->region_tree
= (*eh_array
)[root_region
];
529 #define FIXUP_EH_REGION(r) (r) = (*eh_array)[(HOST_WIDE_INT) (intptr_t) (r)]
530 #define FIXUP_EH_LP(p) (p) = (*lp_array)[(HOST_WIDE_INT) (intptr_t) (p)]
532 /* Convert all the index numbers stored in pointer fields into
533 pointers to the corresponding slots in the EH region array. */
534 FOR_EACH_VEC_ELT (*eh_array
, i
, r
)
536 /* The array may contain NULL regions. */
540 gcc_assert (i
== (unsigned) r
->index
);
541 FIXUP_EH_REGION (r
->outer
);
542 FIXUP_EH_REGION (r
->inner
);
543 FIXUP_EH_REGION (r
->next_peer
);
544 FIXUP_EH_LP (r
->landing_pads
);
547 /* Convert all the index numbers stored in pointer fields into
548 pointers to the corresponding slots in the EH landing pad array. */
549 FOR_EACH_VEC_ELT (*lp_array
, i
, lp
)
551 /* The array may contain NULL landing pads. */
555 gcc_assert (i
== (unsigned) lp
->index
);
556 FIXUP_EH_LP (lp
->next_lp
);
557 FIXUP_EH_REGION (lp
->region
);
560 #undef FIXUP_EH_REGION
565 /* Initialize EH support. */
570 static bool eh_initialized_p
= false;
572 if (eh_initialized_p
)
575 /* Contrary to most other FEs, we only initialize EH support when at
576 least one of the files in the set contains exception regions in
577 it. Since this happens much later than the call to init_eh in
578 lang_dependent_init, we have to set flag_exceptions and call
579 init_eh again to initialize the EH tables. */
583 eh_initialized_p
= true;
587 /* Read the exception table for FN from IB using the data descriptors
591 input_eh_regions (class lto_input_block
*ib
, class data_in
*data_in
,
594 HOST_WIDE_INT i
, root_region
, len
;
597 tag
= streamer_read_record_start (ib
);
601 lto_tag_check_range (tag
, LTO_eh_table
, LTO_eh_table
);
605 root_region
= streamer_read_hwi (ib
);
606 gcc_assert (root_region
== (int) root_region
);
608 /* Read the EH region array. */
609 len
= streamer_read_hwi (ib
);
610 gcc_assert (len
== (int) len
);
613 vec_safe_grow_cleared (fn
->eh
->region_array
, len
);
614 for (i
= 0; i
< len
; i
++)
616 eh_region r
= input_eh_region (ib
, data_in
, i
);
617 (*fn
->eh
->region_array
)[i
] = r
;
621 /* Read the landing pads. */
622 len
= streamer_read_hwi (ib
);
623 gcc_assert (len
== (int) len
);
626 vec_safe_grow_cleared (fn
->eh
->lp_array
, len
);
627 for (i
= 0; i
< len
; i
++)
629 eh_landing_pad lp
= input_eh_lp (ib
, data_in
, i
);
630 (*fn
->eh
->lp_array
)[i
] = lp
;
634 /* Read the runtime type data. */
635 len
= streamer_read_hwi (ib
);
636 gcc_assert (len
== (int) len
);
639 vec_safe_grow_cleared (fn
->eh
->ttype_data
, len
);
640 for (i
= 0; i
< len
; i
++)
642 tree ttype
= stream_read_tree (ib
, data_in
);
643 (*fn
->eh
->ttype_data
)[i
] = ttype
;
647 /* Read the table of action chains. */
648 len
= streamer_read_hwi (ib
);
649 gcc_assert (len
== (int) len
);
652 if (targetm
.arm_eabi_unwinder
)
654 vec_safe_grow_cleared (fn
->eh
->ehspec_data
.arm_eabi
, len
);
655 for (i
= 0; i
< len
; i
++)
657 tree t
= stream_read_tree (ib
, data_in
);
658 (*fn
->eh
->ehspec_data
.arm_eabi
)[i
] = t
;
663 vec_safe_grow_cleared (fn
->eh
->ehspec_data
.other
, len
);
664 for (i
= 0; i
< len
; i
++)
666 uchar c
= streamer_read_uchar (ib
);
667 (*fn
->eh
->ehspec_data
.other
)[i
] = c
;
672 /* Reconstruct the EH region tree by fixing up the peer/children
674 fixup_eh_region_pointers (fn
, root_region
);
676 tag
= streamer_read_record_start (ib
);
677 lto_tag_check_range (tag
, LTO_null
, LTO_null
);
681 /* Make a new basic block with index INDEX in function FN. */
684 make_new_block (struct function
*fn
, unsigned int index
)
686 basic_block bb
= alloc_block ();
688 SET_BASIC_BLOCK_FOR_FN (fn
, index
, bb
);
689 n_basic_blocks_for_fn (fn
)++;
694 /* Read the CFG for function FN from input block IB. */
697 input_cfg (class lto_input_block
*ib
, class data_in
*data_in
,
700 unsigned int bb_count
;
705 init_empty_tree_cfg_for_function (fn
);
706 init_ssa_operands (fn
);
708 profile_status_for_fn (fn
) = streamer_read_enum (ib
, profile_status_d
,
711 bb_count
= streamer_read_uhwi (ib
);
713 last_basic_block_for_fn (fn
) = bb_count
;
714 if (bb_count
> basic_block_info_for_fn (fn
)->length ())
715 vec_safe_grow_cleared (basic_block_info_for_fn (fn
), bb_count
);
717 if (bb_count
> label_to_block_map_for_fn (fn
)->length ())
718 vec_safe_grow_cleared (label_to_block_map_for_fn (fn
), bb_count
);
720 index
= streamer_read_hwi (ib
);
723 basic_block bb
= BASIC_BLOCK_FOR_FN (fn
, index
);
724 unsigned int edge_count
;
727 bb
= make_new_block (fn
, index
);
729 edge_count
= streamer_read_uhwi (ib
);
731 /* Connect up the CFG. */
732 for (i
= 0; i
< edge_count
; i
++)
734 unsigned int dest_index
;
735 unsigned int edge_flags
;
737 profile_probability probability
;
740 dest_index
= streamer_read_uhwi (ib
);
741 probability
= profile_probability::stream_in (ib
);
742 edge_flags
= streamer_read_uhwi (ib
);
744 dest
= BASIC_BLOCK_FOR_FN (fn
, dest_index
);
747 dest
= make_new_block (fn
, dest_index
);
749 e
= make_edge (bb
, dest
, edge_flags
);
750 e
->probability
= probability
;
753 index
= streamer_read_hwi (ib
);
756 p_bb
= ENTRY_BLOCK_PTR_FOR_FN (fn
);
757 index
= streamer_read_hwi (ib
);
760 basic_block bb
= BASIC_BLOCK_FOR_FN (fn
, index
);
764 index
= streamer_read_hwi (ib
);
767 /* ??? The cfgloop interface is tied to cfun. */
768 gcc_assert (cfun
== fn
);
770 /* Input the loop tree. */
771 unsigned n_loops
= streamer_read_uhwi (ib
);
775 struct loops
*loops
= ggc_cleared_alloc
<struct loops
> ();
776 init_loops_structure (fn
, loops
, n_loops
);
777 set_loops_for_fn (fn
, loops
);
779 /* Input each loop and associate it with its loop header so
780 flow_loops_find can rebuild the loop tree. */
781 for (unsigned i
= 1; i
< n_loops
; ++i
)
783 int header_index
= streamer_read_hwi (ib
);
784 if (header_index
== -1)
786 loops
->larray
->quick_push (NULL
);
790 class loop
*loop
= alloc_loop ();
791 loop
->header
= BASIC_BLOCK_FOR_FN (fn
, header_index
);
792 loop
->header
->loop_father
= loop
;
794 /* Read everything copy_loop_info copies. */
795 loop
->estimate_state
= streamer_read_enum (ib
, loop_estimation
, EST_LAST
);
796 loop
->any_upper_bound
= streamer_read_hwi (ib
);
797 if (loop
->any_upper_bound
)
798 loop
->nb_iterations_upper_bound
= streamer_read_widest_int (ib
);
799 loop
->any_likely_upper_bound
= streamer_read_hwi (ib
);
800 if (loop
->any_likely_upper_bound
)
801 loop
->nb_iterations_likely_upper_bound
= streamer_read_widest_int (ib
);
802 loop
->any_estimate
= streamer_read_hwi (ib
);
803 if (loop
->any_estimate
)
804 loop
->nb_iterations_estimate
= streamer_read_widest_int (ib
);
806 /* Read OMP SIMD related info. */
807 loop
->safelen
= streamer_read_hwi (ib
);
808 loop
->unroll
= streamer_read_hwi (ib
);
809 loop
->owned_clique
= streamer_read_hwi (ib
);
810 loop
->dont_vectorize
= streamer_read_hwi (ib
);
811 loop
->force_vectorize
= streamer_read_hwi (ib
);
812 loop
->finite_p
= streamer_read_hwi (ib
);
813 loop
->simduid
= stream_read_tree (ib
, data_in
);
815 place_new_loop (fn
, loop
);
817 /* flow_loops_find doesn't like loops not in the tree, hook them
818 all as siblings of the tree root temporarily. */
819 flow_loop_tree_node_add (loops
->tree_root
, loop
);
822 /* Rebuild the loop tree. */
823 flow_loops_find (loops
);
827 /* Read the SSA names array for function FN from DATA_IN using input
831 input_ssa_names (class lto_input_block
*ib
, class data_in
*data_in
,
834 unsigned int i
, size
;
836 size
= streamer_read_uhwi (ib
);
837 init_ssanames (fn
, size
);
839 i
= streamer_read_uhwi (ib
);
845 /* Skip over the elements that had been freed. */
846 while (SSANAMES (fn
)->length () < i
)
847 SSANAMES (fn
)->quick_push (NULL_TREE
);
849 is_default_def
= (streamer_read_uchar (ib
) != 0);
850 name
= stream_read_tree (ib
, data_in
);
851 ssa_name
= make_ssa_name_fn (fn
, name
, NULL
);
855 set_ssa_default_def (cfun
, SSA_NAME_VAR (ssa_name
), ssa_name
);
856 SSA_NAME_DEF_STMT (ssa_name
) = gimple_build_nop ();
859 i
= streamer_read_uhwi (ib
);
864 /* Go through all NODE edges and fixup call_stmt pointers
865 so they point to STMTS. */
868 fixup_call_stmt_edges_1 (struct cgraph_node
*node
, gimple
**stmts
,
871 #define STMT_UID_NOT_IN_RANGE(uid) \
872 (gimple_stmt_max_uid (fn) < uid || uid == 0)
874 struct cgraph_edge
*cedge
;
875 struct ipa_ref
*ref
= NULL
;
878 for (cedge
= node
->callees
; cedge
; cedge
= cedge
->next_callee
)
880 if (STMT_UID_NOT_IN_RANGE (cedge
->lto_stmt_uid
))
881 fatal_error (input_location
,
882 "Cgraph edge statement index out of range");
883 cedge
->call_stmt
= as_a
<gcall
*> (stmts
[cedge
->lto_stmt_uid
- 1]);
884 cedge
->lto_stmt_uid
= 0;
885 if (!cedge
->call_stmt
)
886 fatal_error (input_location
,
887 "Cgraph edge statement index not found");
889 for (cedge
= node
->indirect_calls
; cedge
; cedge
= cedge
->next_callee
)
891 if (STMT_UID_NOT_IN_RANGE (cedge
->lto_stmt_uid
))
892 fatal_error (input_location
,
893 "Cgraph edge statement index out of range");
894 cedge
->call_stmt
= as_a
<gcall
*> (stmts
[cedge
->lto_stmt_uid
- 1]);
895 cedge
->lto_stmt_uid
= 0;
896 if (!cedge
->call_stmt
)
897 fatal_error (input_location
, "Cgraph edge statement index not found");
899 for (i
= 0; node
->iterate_reference (i
, ref
); i
++)
900 if (ref
->lto_stmt_uid
)
902 if (STMT_UID_NOT_IN_RANGE (ref
->lto_stmt_uid
))
903 fatal_error (input_location
,
904 "Reference statement index out of range");
905 ref
->stmt
= stmts
[ref
->lto_stmt_uid
- 1];
906 ref
->lto_stmt_uid
= 0;
908 fatal_error (input_location
, "Reference statement index not found");
913 /* Fixup call_stmt pointers in NODE and all clones. */
916 fixup_call_stmt_edges (struct cgraph_node
*orig
, gimple
**stmts
)
918 struct cgraph_node
*node
;
921 while (orig
->clone_of
)
922 orig
= orig
->clone_of
;
923 fn
= DECL_STRUCT_FUNCTION (orig
->decl
);
925 if (!orig
->thunk
.thunk_p
)
926 fixup_call_stmt_edges_1 (orig
, stmts
, fn
);
928 for (node
= orig
->clones
; node
!= orig
;)
930 if (!node
->thunk
.thunk_p
)
931 fixup_call_stmt_edges_1 (node
, stmts
, fn
);
934 else if (node
->next_sibling_clone
)
935 node
= node
->next_sibling_clone
;
938 while (node
!= orig
&& !node
->next_sibling_clone
)
939 node
= node
->clone_of
;
941 node
= node
->next_sibling_clone
;
947 /* Input the base body of struct function FN from DATA_IN
948 using input block IB. */
951 input_struct_function_base (struct function
*fn
, class data_in
*data_in
,
952 class lto_input_block
*ib
)
957 /* Read the static chain and non-local goto save area. */
958 fn
->static_chain_decl
= stream_read_tree (ib
, data_in
);
959 fn
->nonlocal_goto_save_area
= stream_read_tree (ib
, data_in
);
961 /* Read all the local symbols. */
962 len
= streamer_read_hwi (ib
);
966 vec_safe_grow_cleared (fn
->local_decls
, len
);
967 for (i
= 0; i
< len
; i
++)
969 tree t
= stream_read_tree (ib
, data_in
);
970 (*fn
->local_decls
)[i
] = t
;
974 /* Input the current IL state of the function. */
975 fn
->curr_properties
= streamer_read_uhwi (ib
);
977 /* Read all the attributes for FN. */
978 bp
= streamer_read_bitpack (ib
);
979 fn
->is_thunk
= bp_unpack_value (&bp
, 1);
980 fn
->has_local_explicit_reg_vars
= bp_unpack_value (&bp
, 1);
981 fn
->returns_pcc_struct
= bp_unpack_value (&bp
, 1);
982 fn
->returns_struct
= bp_unpack_value (&bp
, 1);
983 fn
->can_throw_non_call_exceptions
= bp_unpack_value (&bp
, 1);
984 fn
->can_delete_dead_exceptions
= bp_unpack_value (&bp
, 1);
985 fn
->always_inline_functions_inlined
= bp_unpack_value (&bp
, 1);
986 fn
->after_inlining
= bp_unpack_value (&bp
, 1);
987 fn
->stdarg
= bp_unpack_value (&bp
, 1);
988 fn
->has_nonlocal_label
= bp_unpack_value (&bp
, 1);
989 fn
->has_forced_label_in_static
= bp_unpack_value (&bp
, 1);
990 fn
->calls_alloca
= bp_unpack_value (&bp
, 1);
991 fn
->calls_setjmp
= bp_unpack_value (&bp
, 1);
992 fn
->calls_eh_return
= bp_unpack_value (&bp
, 1);
993 fn
->has_force_vectorize_loops
= bp_unpack_value (&bp
, 1);
994 fn
->has_simduid_loops
= bp_unpack_value (&bp
, 1);
995 fn
->va_list_fpr_size
= bp_unpack_value (&bp
, 8);
996 fn
->va_list_gpr_size
= bp_unpack_value (&bp
, 8);
997 fn
->last_clique
= bp_unpack_value (&bp
, sizeof (short) * 8);
999 /* Input the function start and end loci. */
1000 fn
->function_start_locus
= stream_input_location_now (&bp
, data_in
);
1001 fn
->function_end_locus
= stream_input_location_now (&bp
, data_in
);
1003 /* Restore the instance discriminators if present. */
1004 int instance_number
= bp_unpack_value (&bp
, 1);
1005 if (instance_number
)
1007 instance_number
= bp_unpack_value (&bp
, sizeof (int) * CHAR_BIT
);
1008 maybe_create_decl_to_instance_map ()->put (fn
->decl
, instance_number
);
1012 /* Read a chain of tree nodes from input block IB. DATA_IN contains
1013 tables and descriptors for the file being read. */
1016 streamer_read_chain (class lto_input_block
*ib
, class data_in
*data_in
)
1018 tree first
, prev
, curr
;
1020 /* The chain is written as NULL terminated list of trees. */
1021 first
= prev
= NULL_TREE
;
1024 curr
= stream_read_tree (ib
, data_in
);
1026 TREE_CHAIN (prev
) = curr
;
1037 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1040 input_function (tree fn_decl
, class data_in
*data_in
,
1041 class lto_input_block
*ib
, class lto_input_block
*ib_cfg
,
1044 struct function
*fn
;
1049 tag
= streamer_read_record_start (ib
);
1050 lto_tag_check (tag
, LTO_function
);
1052 /* Read decls for parameters and args. */
1053 DECL_RESULT (fn_decl
) = stream_read_tree (ib
, data_in
);
1054 DECL_ARGUMENTS (fn_decl
) = streamer_read_chain (ib
, data_in
);
1056 /* Read debug args if available. */
1057 unsigned n_debugargs
= streamer_read_uhwi (ib
);
1060 vec
<tree
, va_gc
> **debugargs
= decl_debug_args_insert (fn_decl
);
1061 vec_safe_grow (*debugargs
, n_debugargs
);
1062 for (unsigned i
= 0; i
< n_debugargs
; ++i
)
1063 (**debugargs
)[i
] = stream_read_tree (ib
, data_in
);
1066 /* Read the tree of lexical scopes for the function. */
1067 DECL_INITIAL (fn_decl
) = stream_read_tree (ib
, data_in
);
1068 unsigned block_leaf_count
= streamer_read_uhwi (ib
);
1069 while (block_leaf_count
--)
1070 stream_read_tree (ib
, data_in
);
1072 if (!streamer_read_uhwi (ib
))
1075 push_struct_function (fn_decl
);
1076 fn
= DECL_STRUCT_FUNCTION (fn_decl
);
1078 /* We input IL in SSA form. */
1079 cfun
->gimple_df
->in_ssa_p
= true;
1081 gimple_register_cfg_hooks ();
1083 input_struct_function_base (fn
, data_in
, ib
);
1084 input_cfg (ib_cfg
, data_in
, fn
);
1086 /* Read all the SSA names. */
1087 input_ssa_names (ib
, data_in
, fn
);
1089 /* Read the exception handling regions in the function. */
1090 input_eh_regions (ib
, data_in
, fn
);
1092 gcc_assert (DECL_INITIAL (fn_decl
));
1093 DECL_SAVED_TREE (fn_decl
) = NULL_TREE
;
1095 /* Read all the basic blocks. */
1096 tag
= streamer_read_record_start (ib
);
1099 input_bb (ib
, tag
, data_in
, fn
,
1100 node
->count_materialization_scale
);
1101 tag
= streamer_read_record_start (ib
);
1104 /* Fix up the call statements that are mentioned in the callgraph
1106 set_gimple_stmt_max_uid (cfun
, 0);
1107 FOR_ALL_BB_FN (bb
, cfun
)
1109 gimple_stmt_iterator gsi
;
1110 for (gsi
= gsi_start_phis (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
));
1115 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1117 gimple
*stmt
= gsi_stmt (gsi
);
1118 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
1121 stmts
= (gimple
**) xcalloc (gimple_stmt_max_uid (fn
), sizeof (gimple
*));
1122 FOR_ALL_BB_FN (bb
, cfun
)
1124 gimple_stmt_iterator bsi
= gsi_start_phis (bb
);
1125 while (!gsi_end_p (bsi
))
1127 gimple
*stmt
= gsi_stmt (bsi
);
1129 stmts
[gimple_uid (stmt
)] = stmt
;
1131 bsi
= gsi_start_bb (bb
);
1132 while (!gsi_end_p (bsi
))
1134 gimple
*stmt
= gsi_stmt (bsi
);
1135 bool remove
= false;
1136 /* If we're recompiling LTO objects with debug stmts but
1137 we're not supposed to have debug stmts, remove them now.
1138 We can't remove them earlier because this would cause uid
1139 mismatches in fixups, but we can do it at this point, as
1140 long as debug stmts don't require fixups.
1141 Similarly remove all IFN_*SAN_* internal calls */
1144 if (is_gimple_debug (stmt
)
1145 && (gimple_debug_nonbind_marker_p (stmt
)
1146 ? !MAY_HAVE_DEBUG_MARKER_STMTS
1147 : !MAY_HAVE_DEBUG_BIND_STMTS
))
1149 /* In case the linemap overflows locations can be dropped
1150 to zero. Thus do not keep nonsensical inline entry markers
1151 we'd later ICE on. */
1153 if (gimple_debug_inline_entry_p (stmt
)
1154 && (((block
= gimple_block (stmt
))
1155 && !inlined_function_outer_scope_p (block
))
1156 || !debug_inline_points
))
1158 if (is_gimple_call (stmt
)
1159 && gimple_call_internal_p (stmt
))
1161 bool replace
= false;
1162 switch (gimple_call_internal_fn (stmt
))
1164 case IFN_UBSAN_NULL
:
1166 & (SANITIZE_NULL
| SANITIZE_ALIGNMENT
)) == 0)
1169 case IFN_UBSAN_BOUNDS
:
1170 if ((flag_sanitize
& SANITIZE_BOUNDS
) == 0)
1173 case IFN_UBSAN_VPTR
:
1174 if ((flag_sanitize
& SANITIZE_VPTR
) == 0)
1177 case IFN_UBSAN_OBJECT_SIZE
:
1178 if ((flag_sanitize
& SANITIZE_OBJECT_SIZE
) == 0)
1182 if ((flag_sanitize
& SANITIZE_POINTER_OVERFLOW
) == 0)
1186 if ((flag_sanitize
& SANITIZE_ADDRESS
) == 0)
1189 case IFN_TSAN_FUNC_EXIT
:
1190 if ((flag_sanitize
& SANITIZE_THREAD
) == 0)
1198 gimple_call_set_internal_fn (as_a
<gcall
*> (stmt
),
1206 gimple_stmt_iterator gsi
= bsi
;
1208 unlink_stmt_vdef (stmt
);
1209 release_defs (stmt
);
1210 gsi_remove (&gsi
, true);
1215 stmts
[gimple_uid (stmt
)] = stmt
;
1217 /* Remember that the input function has begin stmt
1218 markers, so that we know to expect them when emitting
1220 if (!cfun
->debug_nonbind_markers
1221 && gimple_debug_nonbind_marker_p (stmt
))
1222 cfun
->debug_nonbind_markers
= true;
1227 /* Set the gimple body to the statement sequence in the entry
1228 basic block. FIXME lto, this is fairly hacky. The existence
1229 of a gimple body is used by the cgraph routines, but we should
1230 really use the presence of the CFG. */
1232 edge_iterator ei
= ei_start (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
);
1233 gimple_set_body (fn_decl
, bb_seq (ei_edge (ei
)->dest
));
1236 update_max_bb_count ();
1237 fixup_call_stmt_edges (node
, stmts
);
1238 execute_all_ipa_stmt_fixups (node
, stmts
);
1240 free_dominance_info (CDI_DOMINATORS
);
1241 free_dominance_info (CDI_POST_DOMINATORS
);
1246 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1249 input_constructor (tree var
, class data_in
*data_in
,
1250 class lto_input_block
*ib
)
1252 DECL_INITIAL (var
) = stream_read_tree (ib
, data_in
);
1256 /* Read the body from DATA for function NODE and fill it in.
1257 FILE_DATA are the global decls and types. SECTION_TYPE is either
1258 LTO_section_function_body or LTO_section_static_initializer. If
1259 section type is LTO_section_function_body, FN must be the decl for
1263 lto_read_body_or_constructor (struct lto_file_decl_data
*file_data
, struct symtab_node
*node
,
1264 const char *data
, enum lto_section_type section_type
)
1266 const struct lto_function_header
*header
;
1267 class data_in
*data_in
;
1271 tree fn_decl
= node
->decl
;
1273 header
= (const struct lto_function_header
*) data
;
1274 if (TREE_CODE (node
->decl
) == FUNCTION_DECL
)
1276 cfg_offset
= sizeof (struct lto_function_header
);
1277 main_offset
= cfg_offset
+ header
->cfg_size
;
1278 string_offset
= main_offset
+ header
->main_size
;
1282 main_offset
= sizeof (struct lto_function_header
);
1283 string_offset
= main_offset
+ header
->main_size
;
1286 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
1287 header
->string_size
, vNULL
);
1289 if (section_type
== LTO_section_function_body
)
1291 struct lto_in_decl_state
*decl_state
;
1294 gcc_checking_assert (node
);
1296 /* Use the function's decl state. */
1297 decl_state
= lto_get_function_in_decl_state (file_data
, fn_decl
);
1298 gcc_assert (decl_state
);
1299 file_data
->current_decl_state
= decl_state
;
1302 /* Set up the struct function. */
1303 from
= data_in
->reader_cache
->nodes
.length ();
1304 lto_input_block
ib_main (data
+ main_offset
, header
->main_size
,
1305 file_data
->mode_table
);
1306 if (TREE_CODE (node
->decl
) == FUNCTION_DECL
)
1308 lto_input_block
ib_cfg (data
+ cfg_offset
, header
->cfg_size
,
1309 file_data
->mode_table
);
1310 input_function (fn_decl
, data_in
, &ib_main
, &ib_cfg
,
1311 dyn_cast
<cgraph_node
*>(node
));
1314 input_constructor (fn_decl
, data_in
, &ib_main
);
1315 data_in
->location_cache
.apply_location_cache ();
1316 /* And fixup types we streamed locally. */
1318 struct streamer_tree_cache_d
*cache
= data_in
->reader_cache
;
1319 unsigned len
= cache
->nodes
.length ();
1321 for (i
= len
; i
-- > from
;)
1323 tree t
= streamer_tree_cache_get_tree (cache
, i
);
1329 gcc_assert (TYPE_CANONICAL (t
) == NULL_TREE
);
1330 if (type_with_alias_set_p (t
)
1331 && canonical_type_used_p (t
))
1332 TYPE_CANONICAL (t
) = TYPE_MAIN_VARIANT (t
);
1333 if (TYPE_MAIN_VARIANT (t
) != t
)
1335 gcc_assert (TYPE_NEXT_VARIANT (t
) == NULL_TREE
);
1336 TYPE_NEXT_VARIANT (t
)
1337 = TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t
));
1338 TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t
)) = t
;
1344 /* Restore decl state */
1345 file_data
->current_decl_state
= file_data
->global_decl_state
;
1348 lto_data_in_delete (data_in
);
1352 /* Read the body of NODE using DATA. FILE_DATA holds the global
1356 lto_input_function_body (struct lto_file_decl_data
*file_data
,
1357 struct cgraph_node
*node
, const char *data
)
1359 lto_read_body_or_constructor (file_data
, node
, data
, LTO_section_function_body
);
1362 /* Read the body of NODE using DATA. FILE_DATA holds the global
1366 lto_input_variable_constructor (struct lto_file_decl_data
*file_data
,
1367 struct varpool_node
*node
, const char *data
)
1369 lto_read_body_or_constructor (file_data
, node
, data
, LTO_section_function_body
);
1373 /* Queue of acummulated decl -> DIE mappings. Similar to locations those
1374 are only applied to prevailing tree nodes during tree merging. */
1375 vec
<dref_entry
> dref_queue
;
1377 /* Read the physical representation of a tree node EXPR from
1378 input block IB using the per-file context in DATA_IN. */
1381 lto_read_tree_1 (class lto_input_block
*ib
, class data_in
*data_in
, tree expr
)
1383 /* Read all the bitfield values in EXPR. Note that for LTO, we
1384 only write language-independent bitfields, so no more unpacking is
1386 streamer_read_tree_bitfields (ib
, data_in
, expr
);
1388 /* Read all the pointer fields in EXPR. */
1389 streamer_read_tree_body (ib
, data_in
, expr
);
1391 /* Read any LTO-specific data not read by the tree streamer. */
1393 && TREE_CODE (expr
) != FUNCTION_DECL
1394 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
1395 DECL_INITIAL (expr
) = stream_read_tree (ib
, data_in
);
1397 /* Stream references to early generated DIEs. Keep in sync with the
1398 trees handled in dwarf2out_register_external_die. */
1400 && TREE_CODE (expr
) != FIELD_DECL
1401 && TREE_CODE (expr
) != DEBUG_EXPR_DECL
1402 && TREE_CODE (expr
) != TYPE_DECL
)
1403 || TREE_CODE (expr
) == BLOCK
)
1405 const char *str
= streamer_read_string (data_in
, ib
);
1408 unsigned HOST_WIDE_INT off
= streamer_read_uhwi (ib
);
1409 dref_entry e
= { expr
, str
, off
};
1410 dref_queue
.safe_push (e
);
1415 /* Read the physical representation of a tree node with tag TAG from
1416 input block IB using the per-file context in DATA_IN. */
1419 lto_read_tree (class lto_input_block
*ib
, class data_in
*data_in
,
1420 enum LTO_tags tag
, hashval_t hash
)
1422 /* Instantiate a new tree node. */
1423 tree result
= streamer_alloc_tree (ib
, data_in
, tag
);
1425 /* Enter RESULT in the reader cache. This will make RESULT
1426 available so that circular references in the rest of the tree
1427 structure can be resolved in subsequent calls to stream_read_tree. */
1428 streamer_tree_cache_append (data_in
->reader_cache
, result
, hash
);
1430 lto_read_tree_1 (ib
, data_in
, result
);
1436 /* Populate the reader cache with trees materialized from the SCC
1437 following in the IB, DATA_IN stream.
1438 If SHARED_SCC is true we input LTO_tree_scc. */
1441 lto_input_scc (class lto_input_block
*ib
, class data_in
*data_in
,
1442 unsigned *len
, unsigned *entry_len
, bool shared_scc
)
1444 unsigned size
= streamer_read_uhwi (ib
);
1445 hashval_t scc_hash
= 0;
1446 unsigned scc_entry_len
= 1;
1451 scc_entry_len
= streamer_read_uhwi (ib
);
1453 scc_hash
= streamer_read_uhwi (ib
);
1458 enum LTO_tags tag
= streamer_read_record_start (ib
);
1459 lto_input_tree_1 (ib
, data_in
, tag
, scc_hash
);
1463 unsigned int first
= data_in
->reader_cache
->nodes
.length ();
1466 /* Materialize size trees by reading their headers. */
1467 for (unsigned i
= 0; i
< size
; ++i
)
1469 enum LTO_tags tag
= streamer_read_record_start (ib
);
1471 || tag
== LTO_global_stream_ref
1472 || tag
== LTO_tree_pickle_reference
1473 || tag
== LTO_integer_cst
1474 || tag
== LTO_tree_scc
1475 || tag
== LTO_trees
)
1478 result
= streamer_alloc_tree (ib
, data_in
, tag
);
1479 streamer_tree_cache_append (data_in
->reader_cache
, result
, 0);
1482 /* Read the tree bitpacks and references. */
1483 for (unsigned i
= 0; i
< size
; ++i
)
1485 result
= streamer_tree_cache_get_tree (data_in
->reader_cache
,
1487 lto_read_tree_1 (ib
, data_in
, result
);
1492 *entry_len
= scc_entry_len
;
1496 /* Read reference to tree from IB and DATA_IN.
1497 This is used for streaming tree bodies where we know that
1498 the tree is already in cache or is indexable and
1499 must be matched with stream_write_tree_ref. */
1502 stream_read_tree_ref (lto_input_block
*ib
, data_in
*data_in
)
1504 int ix
= streamer_read_hwi (ib
);
1508 return streamer_tree_cache_get_tree (data_in
->reader_cache
, ix
- 1);
1516 ret
= (*data_in
->file_data
->current_decl_state
1517 ->streams
[LTO_DECL_STREAM
])[ix
];
1519 ret
= (*SSANAMES (cfun
))[ix
];
1523 /* Read a tree from input block IB using the per-file context in
1524 DATA_IN. This context is used, for example, to resolve references
1525 to previously read nodes. */
1528 lto_input_tree_1 (class lto_input_block
*ib
, class data_in
*data_in
,
1529 enum LTO_tags tag
, hashval_t hash
)
1533 gcc_assert ((unsigned) tag
< (unsigned) LTO_NUM_TAGS
);
1535 if (tag
== LTO_null
)
1537 else if (tag
== LTO_global_stream_ref
|| tag
== LTO_ssa_name_ref
)
1539 /* If TAG is a reference to an indexable tree, the next value
1540 in IB is the index into the table where we expect to find
1542 result
= lto_input_tree_ref (ib
, data_in
, cfun
, tag
);
1544 else if (tag
== LTO_tree_pickle_reference
)
1546 /* If TAG is a reference to a previously read tree, look it up in
1547 the reader cache. */
1548 result
= streamer_get_pickled_tree (ib
, data_in
);
1550 else if (tag
== LTO_integer_cst
)
1552 /* For shared integer constants in singletons we can use the
1553 existing tree integer constant merging code. */
1554 tree type
= stream_read_tree_ref (ib
, data_in
);
1555 unsigned HOST_WIDE_INT len
= streamer_read_uhwi (ib
);
1556 unsigned HOST_WIDE_INT i
;
1557 HOST_WIDE_INT a
[WIDE_INT_MAX_ELTS
];
1559 for (i
= 0; i
< len
; i
++)
1560 a
[i
] = streamer_read_hwi (ib
);
1561 gcc_assert (TYPE_PRECISION (type
) <= MAX_BITSIZE_MODE_ANY_INT
);
1562 result
= wide_int_to_tree (type
, wide_int::from_array
1563 (a
, len
, TYPE_PRECISION (type
)));
1564 streamer_tree_cache_append (data_in
->reader_cache
, result
, hash
);
1566 else if (tag
== LTO_tree_scc
|| tag
== LTO_trees
)
1570 /* Otherwise, materialize a new node from IB. */
1571 result
= lto_read_tree (ib
, data_in
, tag
, hash
);
1578 lto_input_tree (class lto_input_block
*ib
, class data_in
*data_in
)
1582 /* Input pickled trees needed to stream in the reference. */
1583 while ((tag
= streamer_read_record_start (ib
)) == LTO_trees
)
1585 unsigned len
, entry_len
;
1586 lto_input_scc (ib
, data_in
, &len
, &entry_len
, false);
1588 /* Register DECLs with the debuginfo machinery. */
1589 while (!dref_queue
.is_empty ())
1591 dref_entry e
= dref_queue
.pop ();
1592 debug_hooks
->register_external_die (e
.decl
, e
.sym
, e
.off
);
1595 tree t
= lto_input_tree_1 (ib
, data_in
, tag
, 0);
1597 if (!dref_queue
.is_empty ())
1599 dref_entry e
= dref_queue
.pop ();
1600 debug_hooks
->register_external_die (e
.decl
, e
.sym
, e
.off
);
1601 gcc_checking_assert (dref_queue
.is_empty ());
1607 /* Input toplevel asms. */
1610 lto_input_toplevel_asms (struct lto_file_decl_data
*file_data
, int order_base
)
1614 = lto_get_summary_section_data (file_data
, LTO_section_asm
, &len
);
1615 const struct lto_simple_header_with_strings
*header
1616 = (const struct lto_simple_header_with_strings
*) data
;
1618 class data_in
*data_in
;
1624 string_offset
= sizeof (*header
) + header
->main_size
;
1626 lto_input_block
ib (data
+ sizeof (*header
), header
->main_size
,
1627 file_data
->mode_table
);
1629 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
1630 header
->string_size
, vNULL
);
1632 while ((str
= streamer_read_string_cst (data_in
, &ib
)))
1634 asm_node
*node
= symtab
->finalize_toplevel_asm (str
);
1635 node
->order
= streamer_read_hwi (&ib
) + order_base
;
1636 if (node
->order
>= symtab
->order
)
1637 symtab
->order
= node
->order
+ 1;
1640 lto_data_in_delete (data_in
);
1642 lto_free_section_data (file_data
, LTO_section_asm
, NULL
, data
, len
);
1646 /* Input mode table. */
1649 lto_input_mode_table (struct lto_file_decl_data
*file_data
)
1653 = lto_get_summary_section_data (file_data
, LTO_section_mode_table
, &len
);
1656 internal_error ("cannot read LTO mode table from %s",
1657 file_data
->file_name
);
1661 unsigned char *table
= ggc_cleared_vec_alloc
<unsigned char> (1 << 8);
1662 file_data
->mode_table
= table
;
1663 const struct lto_simple_header_with_strings
*header
1664 = (const struct lto_simple_header_with_strings
*) data
;
1666 class data_in
*data_in
;
1667 string_offset
= sizeof (*header
) + header
->main_size
;
1669 lto_input_block
ib (data
+ sizeof (*header
), header
->main_size
, NULL
);
1670 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
1671 header
->string_size
, vNULL
);
1672 bitpack_d bp
= streamer_read_bitpack (&ib
);
1674 table
[VOIDmode
] = VOIDmode
;
1675 table
[BLKmode
] = BLKmode
;
1677 while ((m
= bp_unpack_value (&bp
, 8)) != VOIDmode
)
1679 enum mode_class mclass
1680 = bp_unpack_enum (&bp
, mode_class
, MAX_MODE_CLASS
);
1681 poly_uint16 size
= bp_unpack_poly_value (&bp
, 16);
1682 poly_uint16 prec
= bp_unpack_poly_value (&bp
, 16);
1683 machine_mode inner
= (machine_mode
) bp_unpack_value (&bp
, 8);
1684 poly_uint16 nunits
= bp_unpack_poly_value (&bp
, 16);
1685 unsigned int ibit
= 0, fbit
= 0;
1686 unsigned int real_fmt_len
= 0;
1687 const char *real_fmt_name
= NULL
;
1694 ibit
= bp_unpack_value (&bp
, 8);
1695 fbit
= bp_unpack_value (&bp
, 8);
1698 case MODE_DECIMAL_FLOAT
:
1699 real_fmt_name
= bp_unpack_indexed_string (data_in
, &bp
,
1705 /* First search just the GET_CLASS_NARROWEST_MODE to wider modes,
1706 if not found, fallback to all modes. */
1708 for (pass
= 0; pass
< 2; pass
++)
1709 for (machine_mode mr
= pass
? VOIDmode
1710 : GET_CLASS_NARROWEST_MODE (mclass
);
1711 pass
? mr
< MAX_MACHINE_MODE
: mr
!= VOIDmode
;
1712 pass
? mr
= (machine_mode
) (mr
+ 1)
1713 : mr
= GET_MODE_WIDER_MODE (mr
).else_void ())
1714 if (GET_MODE_CLASS (mr
) != mclass
1715 || maybe_ne (GET_MODE_SIZE (mr
), size
)
1716 || maybe_ne (GET_MODE_PRECISION (mr
), prec
)
1718 ? GET_MODE_INNER (mr
) != mr
1719 : GET_MODE_INNER (mr
) != table
[(int) inner
])
1720 || GET_MODE_IBIT (mr
) != ibit
1721 || GET_MODE_FBIT (mr
) != fbit
1722 || maybe_ne (GET_MODE_NUNITS (mr
), nunits
))
1724 else if ((mclass
== MODE_FLOAT
|| mclass
== MODE_DECIMAL_FLOAT
)
1725 && strcmp (REAL_MODE_FORMAT (mr
)->name
, real_fmt_name
) != 0)
1733 unsigned int mname_len
;
1734 const char *mname
= bp_unpack_indexed_string (data_in
, &bp
, &mname_len
);
1739 case MODE_VECTOR_BOOL
:
1740 case MODE_VECTOR_INT
:
1741 case MODE_VECTOR_FLOAT
:
1742 case MODE_VECTOR_FRACT
:
1743 case MODE_VECTOR_UFRACT
:
1744 case MODE_VECTOR_ACCUM
:
1745 case MODE_VECTOR_UACCUM
:
1746 /* For unsupported vector modes just use BLKmode,
1747 if the scalar mode is supported. */
1748 if (table
[(int) inner
] != VOIDmode
)
1755 /* This is only used for offloading-target compilations and
1756 is a user-facing error. Give a better error message for
1757 the common modes; see also mode-classes.def. */
1758 if (mclass
== MODE_FLOAT
)
1759 fatal_error (UNKNOWN_LOCATION
,
1760 "%s - %u-bit-precision floating-point numbers "
1761 "unsupported (mode %qs)", TARGET_MACHINE
,
1762 prec
.to_constant (), mname
);
1763 else if (mclass
== MODE_DECIMAL_FLOAT
)
1764 fatal_error (UNKNOWN_LOCATION
,
1765 "%s - %u-bit-precision decimal floating-point "
1766 "numbers unsupported (mode %qs)", TARGET_MACHINE
,
1767 prec
.to_constant (), mname
);
1768 else if (mclass
== MODE_COMPLEX_FLOAT
)
1769 fatal_error (UNKNOWN_LOCATION
,
1770 "%s - %u-bit-precision complex floating-point "
1771 "numbers unsupported (mode %qs)", TARGET_MACHINE
,
1772 prec
.to_constant (), mname
);
1773 else if (mclass
== MODE_INT
)
1774 fatal_error (UNKNOWN_LOCATION
,
1775 "%s - %u-bit integer numbers unsupported (mode "
1776 "%qs)", TARGET_MACHINE
, prec
.to_constant (), mname
);
1778 fatal_error (UNKNOWN_LOCATION
, "%s - unsupported mode %qs",
1779 TARGET_MACHINE
, mname
);
1784 lto_data_in_delete (data_in
);
1786 lto_free_section_data (file_data
, LTO_section_mode_table
, NULL
, data
, len
);
1790 /* Initialization for the LTO reader. */
1793 lto_reader_init (void)
1795 lto_streamer_init ();
1796 file_name_hash_table
1797 = new hash_table
<string_slot_hasher
> (37);
1798 string_slot_allocator
= new object_allocator
<struct string_slot
>
1799 ("line map file name hash");
1800 gcc_obstack_init (&file_name_obstack
);
1803 /* Free hash table used to stream in location file names. */
1806 lto_free_file_name_hash (void)
1808 delete file_name_hash_table
;
1809 file_name_hash_table
= NULL
;
1810 delete string_slot_allocator
;
1811 string_slot_allocator
= NULL
;
1812 /* file_name_obstack must stay allocated since it is referred to by
1817 /* Create a new data_in object for FILE_DATA. STRINGS is the string
1818 table to use with LEN strings. RESOLUTIONS is the vector of linker
1819 resolutions (NULL if not using a linker plugin). */
1822 lto_data_in_create (struct lto_file_decl_data
*file_data
, const char *strings
,
1824 vec
<ld_plugin_symbol_resolution_t
> resolutions
)
1826 class data_in
*data_in
= new (class data_in
);
1827 data_in
->file_data
= file_data
;
1828 data_in
->strings
= strings
;
1829 data_in
->strings_len
= len
;
1830 data_in
->globals_resolution
= resolutions
;
1831 data_in
->reader_cache
= streamer_tree_cache_create (false, false, true);
1836 /* Remove DATA_IN. */
1839 lto_data_in_delete (class data_in
*data_in
)
1841 data_in
->globals_resolution
.release ();
1842 streamer_tree_cache_delete (data_in
->reader_cache
);