Do not fixup edges for a thunk in LTRANS (PR lto/78049)
[official-gcc.git] / gcc / lto-streamer-in.c
blob1f39e6b98767743c4f154a5d2a610e56a9597fe8
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
12 version.
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
17 for more details.
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/>. */
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "backend.h"
27 #include "target.h"
28 #include "rtl.h"
29 #include "tree.h"
30 #include "gimple.h"
31 #include "cfghooks.h"
32 #include "tree-pass.h"
33 #include "ssa.h"
34 #include "gimple-streamer.h"
35 #include "toplev.h"
36 #include "gimple-iterator.h"
37 #include "tree-cfg.h"
38 #include "tree-into-ssa.h"
39 #include "tree-dfa.h"
40 #include "tree-ssa.h"
41 #include "except.h"
42 #include "cgraph.h"
43 #include "cfgloop.h"
46 struct freeing_string_slot_hasher : string_slot_hasher
48 static inline void remove (value_type *);
51 inline void
52 freeing_string_slot_hasher::remove (value_type *v)
54 free (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. */
64 void
65 lto_tag_check_set (enum LTO_tags actual, int ntags, ...)
67 va_list ap;
68 int i;
70 va_start (ap, ntags);
71 for (i = 0; i < ntags; i++)
72 if ((unsigned) actual == va_arg (ap, unsigned))
74 va_end (ap);
75 return;
78 va_end (ap);
79 internal_error ("bytecode stream: unexpected tag %s", lto_tag_name (actual));
83 /* Read LENGTH bytes from STREAM to ADDR. */
85 void
86 lto_input_data_block (struct lto_input_block *ib, void *addr, size_t length)
88 size_t i;
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. */
99 static const char *
100 canon_file_name (const char *string)
102 string_slot **slot;
103 struct string_slot s_slot;
104 size_t len = strlen (string);
106 s_slot.s = string;
107 s_slot.len = len;
109 slot = file_name_hash_table->find_slot (&s_slot, INSERT);
110 if (*slot == NULL)
112 char *saved_string;
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;
119 new_slot->len = len;
120 *slot = new_slot;
121 return saved_string;
123 else
125 struct string_slot *old_slot = *slot;
126 return old_slot->s;
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)
145 return -1;
146 if (a->file != current_file && b->file == current_file)
147 return 1;
148 if (a->file == current_file && b->file == current_file)
150 if (a->line == current_line && b->line != current_line)
151 return -1;
152 if (a->line != current_line && b->line == current_line)
153 return 1;
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
165 trees. */
167 bool
168 lto_location_cache::apply_location_cache ()
170 static const char *prev_file;
171 if (!loc_cache.length ())
172 return false;
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)
185 int max = loc.col;
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)
190 break;
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;
199 else
200 current_loc = *loc.loc = linemap_position_for_column (line_table,
201 loc.col);
202 current_line = loc.line;
203 prev_file = current_file = loc.file;
204 current_col = loc.col;
206 loc_cache.truncate (0);
207 accepted_length = 0;
208 return true;
211 /* Tree merging did not suceed; mark all changes in the cache as accepted. */
213 void
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. */
222 void
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. */
232 void
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)
247 return;
249 /* Keep value RESERVED_LOCATION_COUNT in *loc as linemap lookups will
250 ICE on it. */
252 file_change = bp_unpack_value (bp, 1);
253 line_change = bp_unpack_value (bp, 1);
254 column_change = bp_unpack_value (bp, 1);
256 if (file_change)
258 stream_file = canon_file_name (bp_unpack_string (data_in, bp));
259 stream_sysp = bp_unpack_value (bp, 1);
262 if (line_change)
263 stream_line = bp_unpack_var_len_unsigned (bp);
265 if (column_change)
266 stream_col = bp_unpack_var_len_unsigned (bp);
268 /* This optimization saves location cache operations druing gimple
269 streaming. */
271 if (current_file == stream_file && current_line == stream_line
272 && current_col == stream_col && current_sysp == stream_sysp)
274 *loc = current_loc;
275 return;
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. */
287 void
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
296 discarded. */
298 location_t
299 stream_input_location_now (struct bitpack_d *bp, struct data_in *data_in)
301 location_t loc;
302 stream_input_location (&loc, bp, data_in);
303 data_in->location_cache.apply_location_cache ();
304 return loc;
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. */
314 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);
323 switch (tag)
325 case LTO_type_ref:
326 ix_u = streamer_read_uhwi (ib);
327 result = lto_file_decl_data_get_type (data_in->file_data, ix_u);
328 break;
330 case LTO_ssa_name_ref:
331 ix_u = streamer_read_uhwi (ib);
332 result = (*SSANAMES (fn))[ix_u];
333 break;
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);
338 break;
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);
343 break;
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);
348 break;
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);
353 break;
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);
364 break;
366 default:
367 gcc_unreachable ();
370 gcc_assert (result);
372 return result;
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,
381 eh_catch *last_p)
383 eh_catch first;
384 enum LTO_tags tag;
386 *last_p = first = NULL;
387 tag = streamer_read_record_start (ib);
388 while (tag)
390 tree list;
391 eh_catch n;
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. */
406 if (*last_p)
407 (*last_p)->next_catch = n;
408 n->prev_catch = *last_p;
409 *last_p = n;
411 /* Set the head of the list the first time through the loop. */
412 if (first == NULL)
413 first = n;
415 tag = streamer_read_record_start (ib);
418 return first;
422 /* Read and return EH region IX from input block IB, using descriptors
423 in DATA_IN. */
425 static eh_region
426 input_eh_region (struct lto_input_block *ib, struct data_in *data_in, int ix)
428 enum LTO_tags tag;
429 eh_region r;
431 /* Read the region header. */
432 tag = streamer_read_record_start (ib);
433 if (tag == LTO_null)
434 return NULL;
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);
447 switch (tag)
449 case LTO_ert_cleanup:
450 r->type = ERT_CLEANUP;
451 break;
453 case LTO_ert_try:
455 struct eh_catch_d *last_catch;
456 r->type = ERT_TRY;
457 r->u.eh_try.first_catch = lto_input_eh_catch_list (ib, data_in,
458 &last_catch);
459 r->u.eh_try.last_catch = last_catch;
460 break;
463 case LTO_ert_allowed_exceptions:
465 tree l;
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));
475 break;
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);
485 break;
487 default:
488 gcc_unreachable ();
491 r->landing_pads = (eh_landing_pad) (intptr_t) streamer_read_hwi (ib);
493 return r;
497 /* Read and return EH landing pad IX from input block IB, using descriptors
498 in DATA_IN. */
500 static eh_landing_pad
501 input_eh_lp (struct lto_input_block *ib, struct data_in *data_in, int ix)
503 enum LTO_tags tag;
504 eh_landing_pad lp;
506 /* Read the landing pad header. */
507 tag = streamer_read_record_start (ib);
508 if (tag == LTO_null)
509 return NULL;
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);
520 return lp;
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. */
529 static void
530 fixup_eh_region_pointers (struct function *fn, HOST_WIDE_INT root_region)
532 unsigned i;
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;
535 eh_region r;
536 eh_landing_pad lp;
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. */
551 if (r == NULL)
552 continue;
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. */
566 if (lp == NULL)
567 continue;
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
575 #undef FIXUP_EH_LP
579 /* Initialize EH support. */
581 void
582 lto_init_eh (void)
584 static bool eh_initialized_p = false;
586 if (eh_initialized_p)
587 return;
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. */
594 flag_exceptions = 1;
595 init_eh ();
597 eh_initialized_p = true;
601 /* Read the exception table for FN from IB using the data descriptors
602 in DATA_IN. */
604 static void
605 input_eh_regions (struct lto_input_block *ib, struct data_in *data_in,
606 struct function *fn)
608 HOST_WIDE_INT i, root_region, len;
609 enum LTO_tags tag;
611 tag = streamer_read_record_start (ib);
612 if (tag == LTO_null)
613 return;
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
619 machinery. */
620 lto_init_eh ();
622 gcc_assert (fn->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);
630 if (len > 0)
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);
643 if (len > 0)
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);
656 if (len > 0)
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);
669 if (len > 0)
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;
680 else
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
692 pointers. */
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. */
702 static basic_block
703 make_new_block (struct function *fn, unsigned int index)
705 basic_block bb = alloc_block ();
706 bb->index = index;
707 SET_BASIC_BLOCK_FOR_FN (fn, index, bb);
708 n_basic_blocks_for_fn (fn)++;
709 return bb;
713 /* Read the CFG for function FN from input block IB. */
715 static void
716 input_cfg (struct lto_input_block *ib, struct data_in *data_in,
717 struct function *fn,
718 int count_materialization_scale)
720 unsigned int bb_count;
721 basic_block p_bb;
722 unsigned int i;
723 int index;
725 init_empty_tree_cfg_for_function (fn);
726 init_ssa_operands (fn);
728 profile_status_for_fn (fn) = streamer_read_enum (ib, profile_status_d,
729 PROFILE_LAST);
731 bb_count = streamer_read_uhwi (ib);
733 last_basic_block_for_fn (fn) = bb_count;
734 if (bb_count > basic_block_info_for_fn (fn)->length ())
735 vec_safe_grow_cleared (basic_block_info_for_fn (fn), bb_count);
737 if (bb_count > label_to_block_map_for_fn (fn)->length ())
738 vec_safe_grow_cleared (label_to_block_map_for_fn (fn), bb_count);
740 index = streamer_read_hwi (ib);
741 while (index != -1)
743 basic_block bb = BASIC_BLOCK_FOR_FN (fn, index);
744 unsigned int edge_count;
746 if (bb == NULL)
747 bb = make_new_block (fn, index);
749 edge_count = streamer_read_uhwi (ib);
751 /* Connect up the CFG. */
752 for (i = 0; i < edge_count; i++)
754 unsigned int dest_index;
755 unsigned int edge_flags;
756 basic_block dest;
757 int probability;
758 gcov_type count;
759 edge e;
761 dest_index = streamer_read_uhwi (ib);
762 probability = (int) streamer_read_hwi (ib);
763 count = apply_scale ((gcov_type) streamer_read_gcov_count (ib),
764 count_materialization_scale);
765 edge_flags = streamer_read_uhwi (ib);
767 dest = BASIC_BLOCK_FOR_FN (fn, dest_index);
769 if (dest == NULL)
770 dest = make_new_block (fn, dest_index);
772 e = make_edge (bb, dest, edge_flags);
773 e->probability = probability;
774 e->count = count;
777 index = streamer_read_hwi (ib);
780 p_bb = ENTRY_BLOCK_PTR_FOR_FN (fn);
781 index = streamer_read_hwi (ib);
782 while (index != -1)
784 basic_block bb = BASIC_BLOCK_FOR_FN (fn, index);
785 bb->prev_bb = p_bb;
786 p_bb->next_bb = bb;
787 p_bb = bb;
788 index = streamer_read_hwi (ib);
791 /* ??? The cfgloop interface is tied to cfun. */
792 gcc_assert (cfun == fn);
794 /* Input the loop tree. */
795 unsigned n_loops = streamer_read_uhwi (ib);
796 if (n_loops == 0)
797 return;
799 struct loops *loops = ggc_cleared_alloc<struct loops> ();
800 init_loops_structure (fn, loops, n_loops);
801 set_loops_for_fn (fn, loops);
803 /* Input each loop and associate it with its loop header so
804 flow_loops_find can rebuild the loop tree. */
805 for (unsigned i = 1; i < n_loops; ++i)
807 int header_index = streamer_read_hwi (ib);
808 if (header_index == -1)
810 loops->larray->quick_push (NULL);
811 continue;
814 struct loop *loop = alloc_loop ();
815 loop->header = BASIC_BLOCK_FOR_FN (fn, header_index);
816 loop->header->loop_father = loop;
818 /* Read everything copy_loop_info copies. */
819 loop->estimate_state = streamer_read_enum (ib, loop_estimation, EST_LAST);
820 loop->any_upper_bound = streamer_read_hwi (ib);
821 if (loop->any_upper_bound)
822 loop->nb_iterations_upper_bound = streamer_read_widest_int (ib);
823 loop->any_likely_upper_bound = streamer_read_hwi (ib);
824 if (loop->any_likely_upper_bound)
825 loop->nb_iterations_likely_upper_bound = streamer_read_widest_int (ib);
826 loop->any_estimate = streamer_read_hwi (ib);
827 if (loop->any_estimate)
828 loop->nb_iterations_estimate = streamer_read_widest_int (ib);
830 /* Read OMP SIMD related info. */
831 loop->safelen = streamer_read_hwi (ib);
832 loop->dont_vectorize = streamer_read_hwi (ib);
833 loop->force_vectorize = streamer_read_hwi (ib);
834 loop->simduid = stream_read_tree (ib, data_in);
836 place_new_loop (fn, loop);
838 /* flow_loops_find doesn't like loops not in the tree, hook them
839 all as siblings of the tree root temporarily. */
840 flow_loop_tree_node_add (loops->tree_root, loop);
843 /* Rebuild the loop tree. */
844 flow_loops_find (loops);
848 /* Read the SSA names array for function FN from DATA_IN using input
849 block IB. */
851 static void
852 input_ssa_names (struct lto_input_block *ib, struct data_in *data_in,
853 struct function *fn)
855 unsigned int i, size;
857 size = streamer_read_uhwi (ib);
858 init_ssanames (fn, size);
860 i = streamer_read_uhwi (ib);
861 while (i)
863 tree ssa_name, name;
864 bool is_default_def;
866 /* Skip over the elements that had been freed. */
867 while (SSANAMES (fn)->length () < i)
868 SSANAMES (fn)->quick_push (NULL_TREE);
870 is_default_def = (streamer_read_uchar (ib) != 0);
871 name = stream_read_tree (ib, data_in);
872 ssa_name = make_ssa_name_fn (fn, name, NULL);
874 if (is_default_def)
876 set_ssa_default_def (cfun, SSA_NAME_VAR (ssa_name), ssa_name);
877 SSA_NAME_DEF_STMT (ssa_name) = gimple_build_nop ();
880 i = streamer_read_uhwi (ib);
885 /* Go through all NODE edges and fixup call_stmt pointers
886 so they point to STMTS. */
888 static void
889 fixup_call_stmt_edges_1 (struct cgraph_node *node, gimple **stmts,
890 struct function *fn)
892 #define STMT_UID_NOT_IN_RANGE(uid) \
893 (gimple_stmt_max_uid (fn) < uid || uid == 0)
895 struct cgraph_edge *cedge;
896 struct ipa_ref *ref = NULL;
897 unsigned int i;
899 for (cedge = node->callees; cedge; cedge = cedge->next_callee)
901 if (STMT_UID_NOT_IN_RANGE (cedge->lto_stmt_uid))
902 fatal_error (input_location,
903 "Cgraph edge statement index out of range");
904 cedge->call_stmt = as_a <gcall *> (stmts[cedge->lto_stmt_uid - 1]);
905 if (!cedge->call_stmt)
906 fatal_error (input_location,
907 "Cgraph edge statement index not found");
909 for (cedge = node->indirect_calls; cedge; cedge = cedge->next_callee)
911 if (STMT_UID_NOT_IN_RANGE (cedge->lto_stmt_uid))
912 fatal_error (input_location,
913 "Cgraph edge statement index out of range");
914 cedge->call_stmt = as_a <gcall *> (stmts[cedge->lto_stmt_uid - 1]);
915 if (!cedge->call_stmt)
916 fatal_error (input_location, "Cgraph edge statement index not found");
918 for (i = 0; node->iterate_reference (i, ref); i++)
919 if (ref->lto_stmt_uid)
921 if (STMT_UID_NOT_IN_RANGE (ref->lto_stmt_uid))
922 fatal_error (input_location,
923 "Reference statement index out of range");
924 ref->stmt = stmts[ref->lto_stmt_uid - 1];
925 if (!ref->stmt)
926 fatal_error (input_location, "Reference statement index not found");
931 /* Fixup call_stmt pointers in NODE and all clones. */
933 static void
934 fixup_call_stmt_edges (struct cgraph_node *orig, gimple **stmts)
936 struct cgraph_node *node;
937 struct function *fn;
939 while (orig->clone_of)
940 orig = orig->clone_of;
941 fn = DECL_STRUCT_FUNCTION (orig->decl);
943 if (!orig->thunk.thunk_p)
944 fixup_call_stmt_edges_1 (orig, stmts, fn);
945 if (orig->clones)
946 for (node = orig->clones; node != orig;)
948 if (!node->thunk.thunk_p)
949 fixup_call_stmt_edges_1 (node, stmts, fn);
950 if (node->clones)
951 node = node->clones;
952 else if (node->next_sibling_clone)
953 node = node->next_sibling_clone;
954 else
956 while (node != orig && !node->next_sibling_clone)
957 node = node->clone_of;
958 if (node != orig)
959 node = node->next_sibling_clone;
965 /* Input the base body of struct function FN from DATA_IN
966 using input block IB. */
968 static void
969 input_struct_function_base (struct function *fn, struct data_in *data_in,
970 struct lto_input_block *ib)
972 struct bitpack_d bp;
973 int len;
975 /* Read the static chain and non-local goto save area. */
976 fn->static_chain_decl = stream_read_tree (ib, data_in);
977 fn->nonlocal_goto_save_area = stream_read_tree (ib, data_in);
979 /* Read all the local symbols. */
980 len = streamer_read_hwi (ib);
981 if (len > 0)
983 int i;
984 vec_safe_grow_cleared (fn->local_decls, len);
985 for (i = 0; i < len; i++)
987 tree t = stream_read_tree (ib, data_in);
988 (*fn->local_decls)[i] = t;
992 /* Input the current IL state of the function. */
993 fn->curr_properties = streamer_read_uhwi (ib);
995 /* Read all the attributes for FN. */
996 bp = streamer_read_bitpack (ib);
997 fn->is_thunk = bp_unpack_value (&bp, 1);
998 fn->has_local_explicit_reg_vars = bp_unpack_value (&bp, 1);
999 fn->returns_pcc_struct = bp_unpack_value (&bp, 1);
1000 fn->returns_struct = bp_unpack_value (&bp, 1);
1001 fn->can_throw_non_call_exceptions = bp_unpack_value (&bp, 1);
1002 fn->can_delete_dead_exceptions = bp_unpack_value (&bp, 1);
1003 fn->always_inline_functions_inlined = bp_unpack_value (&bp, 1);
1004 fn->after_inlining = bp_unpack_value (&bp, 1);
1005 fn->stdarg = bp_unpack_value (&bp, 1);
1006 fn->has_nonlocal_label = bp_unpack_value (&bp, 1);
1007 fn->has_forced_label_in_static = bp_unpack_value (&bp, 1);
1008 fn->calls_alloca = bp_unpack_value (&bp, 1);
1009 fn->calls_setjmp = bp_unpack_value (&bp, 1);
1010 fn->has_force_vectorize_loops = bp_unpack_value (&bp, 1);
1011 fn->has_simduid_loops = bp_unpack_value (&bp, 1);
1012 fn->va_list_fpr_size = bp_unpack_value (&bp, 8);
1013 fn->va_list_gpr_size = bp_unpack_value (&bp, 8);
1014 fn->last_clique = bp_unpack_value (&bp, sizeof (short) * 8);
1016 /* Input the function start and end loci. */
1017 fn->function_start_locus = stream_input_location_now (&bp, data_in);
1018 fn->function_end_locus = stream_input_location_now (&bp, data_in);
1022 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1024 static void
1025 input_function (tree fn_decl, struct data_in *data_in,
1026 struct lto_input_block *ib, struct lto_input_block *ib_cfg)
1028 struct function *fn;
1029 enum LTO_tags tag;
1030 gimple **stmts;
1031 basic_block bb;
1032 struct cgraph_node *node;
1034 tag = streamer_read_record_start (ib);
1035 lto_tag_check (tag, LTO_function);
1037 /* Read decls for parameters and args. */
1038 DECL_RESULT (fn_decl) = stream_read_tree (ib, data_in);
1039 DECL_ARGUMENTS (fn_decl) = streamer_read_chain (ib, data_in);
1041 /* Read the tree of lexical scopes for the function. */
1042 DECL_INITIAL (fn_decl) = stream_read_tree (ib, data_in);
1043 unsigned block_leaf_count = streamer_read_uhwi (ib);
1044 while (block_leaf_count--)
1045 stream_read_tree (ib, data_in);
1047 if (!streamer_read_uhwi (ib))
1048 return;
1050 push_struct_function (fn_decl);
1051 fn = DECL_STRUCT_FUNCTION (fn_decl);
1052 init_tree_ssa (fn);
1053 /* We input IL in SSA form. */
1054 cfun->gimple_df->in_ssa_p = true;
1056 gimple_register_cfg_hooks ();
1058 node = cgraph_node::get (fn_decl);
1059 if (!node)
1060 node = cgraph_node::create (fn_decl);
1061 input_struct_function_base (fn, data_in, ib);
1062 input_cfg (ib_cfg, data_in, fn, node->count_materialization_scale);
1064 /* Read all the SSA names. */
1065 input_ssa_names (ib, data_in, fn);
1067 /* Read the exception handling regions in the function. */
1068 input_eh_regions (ib, data_in, fn);
1070 gcc_assert (DECL_INITIAL (fn_decl));
1071 DECL_SAVED_TREE (fn_decl) = NULL_TREE;
1073 /* Read all the basic blocks. */
1074 tag = streamer_read_record_start (ib);
1075 while (tag)
1077 input_bb (ib, tag, data_in, fn,
1078 node->count_materialization_scale);
1079 tag = streamer_read_record_start (ib);
1082 /* Fix up the call statements that are mentioned in the callgraph
1083 edges. */
1084 set_gimple_stmt_max_uid (cfun, 0);
1085 FOR_ALL_BB_FN (bb, cfun)
1087 gimple_stmt_iterator gsi;
1088 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1090 gimple *stmt = gsi_stmt (gsi);
1091 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
1093 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1095 gimple *stmt = gsi_stmt (gsi);
1096 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
1099 stmts = (gimple **) xcalloc (gimple_stmt_max_uid (fn), sizeof (gimple *));
1100 FOR_ALL_BB_FN (bb, cfun)
1102 gimple_stmt_iterator bsi = gsi_start_phis (bb);
1103 while (!gsi_end_p (bsi))
1105 gimple *stmt = gsi_stmt (bsi);
1106 gsi_next (&bsi);
1107 stmts[gimple_uid (stmt)] = stmt;
1109 bsi = gsi_start_bb (bb);
1110 while (!gsi_end_p (bsi))
1112 gimple *stmt = gsi_stmt (bsi);
1113 /* If we're recompiling LTO objects with debug stmts but
1114 we're not supposed to have debug stmts, remove them now.
1115 We can't remove them earlier because this would cause uid
1116 mismatches in fixups, but we can do it at this point, as
1117 long as debug stmts don't require fixups. */
1118 if (!MAY_HAVE_DEBUG_STMTS && !flag_wpa && is_gimple_debug (stmt))
1120 gimple_stmt_iterator gsi = bsi;
1121 gsi_next (&bsi);
1122 gsi_remove (&gsi, true);
1124 else
1126 gsi_next (&bsi);
1127 stmts[gimple_uid (stmt)] = stmt;
1132 /* Set the gimple body to the statement sequence in the entry
1133 basic block. FIXME lto, this is fairly hacky. The existence
1134 of a gimple body is used by the cgraph routines, but we should
1135 really use the presence of the CFG. */
1137 edge_iterator ei = ei_start (ENTRY_BLOCK_PTR_FOR_FN (cfun)->succs);
1138 gimple_set_body (fn_decl, bb_seq (ei_edge (ei)->dest));
1141 fixup_call_stmt_edges (node, stmts);
1142 execute_all_ipa_stmt_fixups (node, stmts);
1144 update_ssa (TODO_update_ssa_only_virtuals);
1145 free_dominance_info (CDI_DOMINATORS);
1146 free_dominance_info (CDI_POST_DOMINATORS);
1147 free (stmts);
1148 pop_cfun ();
1151 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1153 static void
1154 input_constructor (tree var, struct data_in *data_in,
1155 struct lto_input_block *ib)
1157 DECL_INITIAL (var) = stream_read_tree (ib, data_in);
1161 /* Read the body from DATA for function NODE and fill it in.
1162 FILE_DATA are the global decls and types. SECTION_TYPE is either
1163 LTO_section_function_body or LTO_section_static_initializer. If
1164 section type is LTO_section_function_body, FN must be the decl for
1165 that function. */
1167 static void
1168 lto_read_body_or_constructor (struct lto_file_decl_data *file_data, struct symtab_node *node,
1169 const char *data, enum lto_section_type section_type)
1171 const struct lto_function_header *header;
1172 struct data_in *data_in;
1173 int cfg_offset;
1174 int main_offset;
1175 int string_offset;
1176 tree fn_decl = node->decl;
1178 header = (const struct lto_function_header *) data;
1179 if (TREE_CODE (node->decl) == FUNCTION_DECL)
1181 cfg_offset = sizeof (struct lto_function_header);
1182 main_offset = cfg_offset + header->cfg_size;
1183 string_offset = main_offset + header->main_size;
1185 else
1187 main_offset = sizeof (struct lto_function_header);
1188 string_offset = main_offset + header->main_size;
1191 data_in = lto_data_in_create (file_data, data + string_offset,
1192 header->string_size, vNULL);
1194 if (section_type == LTO_section_function_body)
1196 struct lto_in_decl_state *decl_state;
1197 unsigned from;
1199 gcc_checking_assert (node);
1201 /* Use the function's decl state. */
1202 decl_state = lto_get_function_in_decl_state (file_data, fn_decl);
1203 gcc_assert (decl_state);
1204 file_data->current_decl_state = decl_state;
1207 /* Set up the struct function. */
1208 from = data_in->reader_cache->nodes.length ();
1209 lto_input_block ib_main (data + main_offset, header->main_size,
1210 file_data->mode_table);
1211 if (TREE_CODE (node->decl) == FUNCTION_DECL)
1213 lto_input_block ib_cfg (data + cfg_offset, header->cfg_size,
1214 file_data->mode_table);
1215 input_function (fn_decl, data_in, &ib_main, &ib_cfg);
1217 else
1218 input_constructor (fn_decl, data_in, &ib_main);
1219 data_in->location_cache.apply_location_cache ();
1220 /* And fixup types we streamed locally. */
1222 struct streamer_tree_cache_d *cache = data_in->reader_cache;
1223 unsigned len = cache->nodes.length ();
1224 unsigned i;
1225 for (i = len; i-- > from;)
1227 tree t = streamer_tree_cache_get_tree (cache, i);
1228 if (t == NULL_TREE)
1229 continue;
1231 if (TYPE_P (t))
1233 gcc_assert (TYPE_CANONICAL (t) == NULL_TREE);
1234 if (type_with_alias_set_p (t)
1235 && canonical_type_used_p (t))
1236 TYPE_CANONICAL (t) = TYPE_MAIN_VARIANT (t);
1237 if (TYPE_MAIN_VARIANT (t) != t)
1239 gcc_assert (TYPE_NEXT_VARIANT (t) == NULL_TREE);
1240 TYPE_NEXT_VARIANT (t)
1241 = TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t));
1242 TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t)) = t;
1248 /* Restore decl state */
1249 file_data->current_decl_state = file_data->global_decl_state;
1252 lto_data_in_delete (data_in);
1256 /* Read the body of NODE using DATA. FILE_DATA holds the global
1257 decls and types. */
1259 void
1260 lto_input_function_body (struct lto_file_decl_data *file_data,
1261 struct cgraph_node *node, const char *data)
1263 lto_read_body_or_constructor (file_data, node, data, LTO_section_function_body);
1266 /* Read the body of NODE using DATA. FILE_DATA holds the global
1267 decls and types. */
1269 void
1270 lto_input_variable_constructor (struct lto_file_decl_data *file_data,
1271 struct varpool_node *node, const char *data)
1273 lto_read_body_or_constructor (file_data, node, data, LTO_section_function_body);
1277 /* Read the physical representation of a tree node EXPR from
1278 input block IB using the per-file context in DATA_IN. */
1280 static void
1281 lto_read_tree_1 (struct lto_input_block *ib, struct data_in *data_in, tree expr)
1283 /* Read all the bitfield values in EXPR. Note that for LTO, we
1284 only write language-independent bitfields, so no more unpacking is
1285 needed. */
1286 streamer_read_tree_bitfields (ib, data_in, expr);
1288 /* Read all the pointer fields in EXPR. */
1289 streamer_read_tree_body (ib, data_in, expr);
1291 /* Read any LTO-specific data not read by the tree streamer. */
1292 if (DECL_P (expr)
1293 && TREE_CODE (expr) != FUNCTION_DECL
1294 && TREE_CODE (expr) != TRANSLATION_UNIT_DECL)
1295 DECL_INITIAL (expr) = stream_read_tree (ib, data_in);
1297 #ifdef LTO_STREAMER_DEBUG
1298 /* Remove the mapping to RESULT's original address set by
1299 streamer_alloc_tree. */
1300 lto_orig_address_remove (expr);
1301 #endif
1304 /* Read the physical representation of a tree node with tag TAG from
1305 input block IB using the per-file context in DATA_IN. */
1307 static tree
1308 lto_read_tree (struct lto_input_block *ib, struct data_in *data_in,
1309 enum LTO_tags tag, hashval_t hash)
1311 /* Instantiate a new tree node. */
1312 tree result = streamer_alloc_tree (ib, data_in, tag);
1314 /* Enter RESULT in the reader cache. This will make RESULT
1315 available so that circular references in the rest of the tree
1316 structure can be resolved in subsequent calls to stream_read_tree. */
1317 streamer_tree_cache_append (data_in->reader_cache, result, hash);
1319 lto_read_tree_1 (ib, data_in, result);
1321 /* end_marker = */ streamer_read_uchar (ib);
1323 return result;
1327 /* Populate the reader cache with trees materialized from the SCC
1328 following in the IB, DATA_IN stream. */
1330 hashval_t
1331 lto_input_scc (struct lto_input_block *ib, struct data_in *data_in,
1332 unsigned *len, unsigned *entry_len)
1334 /* A blob of unnamed tree nodes, fill the cache from it and
1335 recurse. */
1336 unsigned size = streamer_read_uhwi (ib);
1337 hashval_t scc_hash = streamer_read_uhwi (ib);
1338 unsigned scc_entry_len = 1;
1340 if (size == 1)
1342 enum LTO_tags tag = streamer_read_record_start (ib);
1343 lto_input_tree_1 (ib, data_in, tag, scc_hash);
1345 else
1347 unsigned int first = data_in->reader_cache->nodes.length ();
1348 tree result;
1350 scc_entry_len = streamer_read_uhwi (ib);
1352 /* Materialize size trees by reading their headers. */
1353 for (unsigned i = 0; i < size; ++i)
1355 enum LTO_tags tag = streamer_read_record_start (ib);
1356 if (tag == LTO_null
1357 || (tag >= LTO_field_decl_ref && tag <= LTO_global_decl_ref)
1358 || tag == LTO_tree_pickle_reference
1359 || tag == LTO_integer_cst
1360 || tag == LTO_tree_scc)
1361 gcc_unreachable ();
1363 result = streamer_alloc_tree (ib, data_in, tag);
1364 streamer_tree_cache_append (data_in->reader_cache, result, 0);
1367 /* Read the tree bitpacks and references. */
1368 for (unsigned i = 0; i < size; ++i)
1370 result = streamer_tree_cache_get_tree (data_in->reader_cache,
1371 first + i);
1372 lto_read_tree_1 (ib, data_in, result);
1373 /* end_marker = */ streamer_read_uchar (ib);
1377 *len = size;
1378 *entry_len = scc_entry_len;
1379 return scc_hash;
1383 /* Read a tree from input block IB using the per-file context in
1384 DATA_IN. This context is used, for example, to resolve references
1385 to previously read nodes. */
1387 tree
1388 lto_input_tree_1 (struct lto_input_block *ib, struct data_in *data_in,
1389 enum LTO_tags tag, hashval_t hash)
1391 tree result;
1393 gcc_assert ((unsigned) tag < (unsigned) LTO_NUM_TAGS);
1395 if (tag == LTO_null)
1396 result = NULL_TREE;
1397 else if (tag >= LTO_field_decl_ref && tag <= LTO_namelist_decl_ref)
1399 /* If TAG is a reference to an indexable tree, the next value
1400 in IB is the index into the table where we expect to find
1401 that tree. */
1402 result = lto_input_tree_ref (ib, data_in, cfun, tag);
1404 else if (tag == LTO_tree_pickle_reference)
1406 /* If TAG is a reference to a previously read tree, look it up in
1407 the reader cache. */
1408 result = streamer_get_pickled_tree (ib, data_in);
1410 else if (tag == LTO_integer_cst)
1412 /* For shared integer constants in singletons we can use the
1413 existing tree integer constant merging code. */
1414 tree type = stream_read_tree (ib, data_in);
1415 unsigned HOST_WIDE_INT len = streamer_read_uhwi (ib);
1416 unsigned HOST_WIDE_INT i;
1417 HOST_WIDE_INT a[WIDE_INT_MAX_ELTS];
1419 for (i = 0; i < len; i++)
1420 a[i] = streamer_read_hwi (ib);
1421 gcc_assert (TYPE_PRECISION (type) <= MAX_BITSIZE_MODE_ANY_INT);
1422 result = wide_int_to_tree (type, wide_int::from_array
1423 (a, len, TYPE_PRECISION (type)));
1424 streamer_tree_cache_append (data_in->reader_cache, result, hash);
1426 else if (tag == LTO_tree_scc)
1427 gcc_unreachable ();
1428 else
1430 /* Otherwise, materialize a new node from IB. */
1431 result = lto_read_tree (ib, data_in, tag, hash);
1434 return result;
1437 tree
1438 lto_input_tree (struct lto_input_block *ib, struct data_in *data_in)
1440 enum LTO_tags tag;
1442 /* Input and skip SCCs. */
1443 while ((tag = streamer_read_record_start (ib)) == LTO_tree_scc)
1445 unsigned len, entry_len;
1446 lto_input_scc (ib, data_in, &len, &entry_len);
1448 return lto_input_tree_1 (ib, data_in, tag, 0);
1452 /* Input toplevel asms. */
1454 void
1455 lto_input_toplevel_asms (struct lto_file_decl_data *file_data, int order_base)
1457 size_t len;
1458 const char *data = lto_get_section_data (file_data, LTO_section_asm,
1459 NULL, &len);
1460 const struct lto_simple_header_with_strings *header
1461 = (const struct lto_simple_header_with_strings *) data;
1462 int string_offset;
1463 struct data_in *data_in;
1464 tree str;
1466 if (! data)
1467 return;
1469 string_offset = sizeof (*header) + header->main_size;
1471 lto_input_block ib (data + sizeof (*header), header->main_size,
1472 file_data->mode_table);
1474 data_in = lto_data_in_create (file_data, data + string_offset,
1475 header->string_size, vNULL);
1477 while ((str = streamer_read_string_cst (data_in, &ib)))
1479 asm_node *node = symtab->finalize_toplevel_asm (str);
1480 node->order = streamer_read_hwi (&ib) + order_base;
1481 if (node->order >= symtab->order)
1482 symtab->order = node->order + 1;
1485 lto_data_in_delete (data_in);
1487 lto_free_section_data (file_data, LTO_section_asm, NULL, data, len);
1491 /* Input mode table. */
1493 void
1494 lto_input_mode_table (struct lto_file_decl_data *file_data)
1496 size_t len;
1497 const char *data = lto_get_section_data (file_data, LTO_section_mode_table,
1498 NULL, &len);
1499 if (! data)
1501 internal_error ("cannot read LTO mode table from %s",
1502 file_data->file_name);
1503 return;
1506 unsigned char *table = ggc_cleared_vec_alloc<unsigned char> (1 << 8);
1507 file_data->mode_table = table;
1508 const struct lto_simple_header_with_strings *header
1509 = (const struct lto_simple_header_with_strings *) data;
1510 int string_offset;
1511 struct data_in *data_in;
1512 string_offset = sizeof (*header) + header->main_size;
1514 lto_input_block ib (data + sizeof (*header), header->main_size, NULL);
1515 data_in = lto_data_in_create (file_data, data + string_offset,
1516 header->string_size, vNULL);
1517 bitpack_d bp = streamer_read_bitpack (&ib);
1519 table[VOIDmode] = VOIDmode;
1520 table[BLKmode] = BLKmode;
1521 unsigned int m;
1522 while ((m = bp_unpack_value (&bp, 8)) != VOIDmode)
1524 enum mode_class mclass
1525 = bp_unpack_enum (&bp, mode_class, MAX_MODE_CLASS);
1526 unsigned int size = bp_unpack_value (&bp, 8);
1527 unsigned int prec = bp_unpack_value (&bp, 16);
1528 machine_mode inner = (machine_mode) bp_unpack_value (&bp, 8);
1529 unsigned int nunits = bp_unpack_value (&bp, 8);
1530 unsigned int ibit = 0, fbit = 0;
1531 unsigned int real_fmt_len = 0;
1532 const char *real_fmt_name = NULL;
1533 switch (mclass)
1535 case MODE_FRACT:
1536 case MODE_UFRACT:
1537 case MODE_ACCUM:
1538 case MODE_UACCUM:
1539 ibit = bp_unpack_value (&bp, 8);
1540 fbit = bp_unpack_value (&bp, 8);
1541 break;
1542 case MODE_FLOAT:
1543 case MODE_DECIMAL_FLOAT:
1544 real_fmt_name = bp_unpack_indexed_string (data_in, &bp,
1545 &real_fmt_len);
1546 break;
1547 default:
1548 break;
1550 /* First search just the GET_CLASS_NARROWEST_MODE to wider modes,
1551 if not found, fallback to all modes. */
1552 int pass;
1553 for (pass = 0; pass < 2; pass++)
1554 for (machine_mode mr = pass ? VOIDmode
1555 : GET_CLASS_NARROWEST_MODE (mclass);
1556 pass ? mr < MAX_MACHINE_MODE : mr != VOIDmode;
1557 pass ? mr = (machine_mode) (mr + 1)
1558 : mr = GET_MODE_WIDER_MODE (mr))
1559 if (GET_MODE_CLASS (mr) != mclass
1560 || GET_MODE_SIZE (mr) != size
1561 || GET_MODE_PRECISION (mr) != prec
1562 || (inner == m
1563 ? GET_MODE_INNER (mr) != mr
1564 : GET_MODE_INNER (mr) != table[(int) inner])
1565 || GET_MODE_IBIT (mr) != ibit
1566 || GET_MODE_FBIT (mr) != fbit
1567 || GET_MODE_NUNITS (mr) != nunits)
1568 continue;
1569 else if ((mclass == MODE_FLOAT || mclass == MODE_DECIMAL_FLOAT)
1570 && strcmp (REAL_MODE_FORMAT (mr)->name, real_fmt_name) != 0)
1571 continue;
1572 else
1574 table[m] = mr;
1575 pass = 2;
1576 break;
1578 unsigned int mname_len;
1579 const char *mname = bp_unpack_indexed_string (data_in, &bp, &mname_len);
1580 if (pass == 2)
1582 switch (mclass)
1584 case MODE_VECTOR_INT:
1585 case MODE_VECTOR_FLOAT:
1586 case MODE_VECTOR_FRACT:
1587 case MODE_VECTOR_UFRACT:
1588 case MODE_VECTOR_ACCUM:
1589 case MODE_VECTOR_UACCUM:
1590 /* For unsupported vector modes just use BLKmode,
1591 if the scalar mode is supported. */
1592 if (table[(int) inner] != VOIDmode)
1594 table[m] = BLKmode;
1595 break;
1597 /* FALLTHRU */
1598 default:
1599 fatal_error (UNKNOWN_LOCATION, "unsupported mode %s\n", mname);
1600 break;
1604 lto_data_in_delete (data_in);
1606 lto_free_section_data (file_data, LTO_section_mode_table, NULL, data, len);
1610 /* Initialization for the LTO reader. */
1612 void
1613 lto_reader_init (void)
1615 lto_streamer_init ();
1616 file_name_hash_table
1617 = new hash_table<freeing_string_slot_hasher> (37);
1621 /* Create a new data_in object for FILE_DATA. STRINGS is the string
1622 table to use with LEN strings. RESOLUTIONS is the vector of linker
1623 resolutions (NULL if not using a linker plugin). */
1625 struct data_in *
1626 lto_data_in_create (struct lto_file_decl_data *file_data, const char *strings,
1627 unsigned len,
1628 vec<ld_plugin_symbol_resolution_t> resolutions)
1630 struct data_in *data_in = new (struct data_in);
1631 data_in->file_data = file_data;
1632 data_in->strings = strings;
1633 data_in->strings_len = len;
1634 data_in->globals_resolution = resolutions;
1635 data_in->reader_cache = streamer_tree_cache_create (false, false, true);
1636 return data_in;
1640 /* Remove DATA_IN. */
1642 void
1643 lto_data_in_delete (struct data_in *data_in)
1645 data_in->globals_resolution.release ();
1646 streamer_tree_cache_delete (data_in->reader_cache);
1647 delete data_in;