1/* Read the GIMPLE representation from a file stream.
2
3 Copyright (C) 2009-2017 Free Software Foundation, Inc.
4 Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
5 Re-implemented by Diego Novillo <dnovillo@google.com>
6
7This file is part of GCC.
8
9GCC is free software; you can redistribute it and/or modify it under
10the terms of the GNU General Public License as published by the Free
11Software Foundation; either version 3, or (at your option) any later
12version.
13
14GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15WARRANTY; without even the implied warranty of MERCHANTABILITY or
16FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17for more details.
18
19You should have received a copy of the GNU General Public License
20along with GCC; see the file COPYING3. If not see
21<http://www.gnu.org/licenses/>. */
22
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"
44#include "debug.h"
45
46
47struct freeing_string_slot_hasher : string_slot_hasher
48{
49 static inline void remove (value_type *);
50};
51
52inline void
53freeing_string_slot_hasher::remove (value_type *v)
54{
55 free (v);
56}
57
58/* The table to hold the file names. */
59static hash_table<freeing_string_slot_hasher> *file_name_hash_table;
60
61
62/* Check that tag ACTUAL has one of the given values. NUM_TAGS is the
63 number of valid tag values to check. */
64
65void
66lto_tag_check_set (enum LTO_tags actual, int ntags, ...)
67{
68 va_list ap;
69 int i;
70
71 va_start (ap, ntags);
72 for (i = 0; i < ntags; i++)
73 if ((unsigned) actual == va_arg (ap, unsigned))
74 {
75 va_end (ap);
76 return;
77 }
78
79 va_end (ap);
80 internal_error ("bytecode stream: unexpected tag %s", lto_tag_name (actual));
81}
82
83
84/* Read LENGTH bytes from STREAM to ADDR. */
85
86void
87lto_input_data_block (struct lto_input_block *ib, void *addr, size_t length)
88{
89 size_t i;
90 unsigned char *const buffer = (unsigned char *) addr;
91
92 for (i = 0; i < length; i++)
93 buffer[i] = streamer_read_uchar (ib);
94}
95
96
97/* Lookup STRING in file_name_hash_table. If found, return the existing
98 string, otherwise insert STRING as the canonical version. */
99
100static const char *
101canon_file_name (const char *string)
102{
103 string_slot **slot;
104 struct string_slot s_slot;
105 size_t len = strlen (string);
106
107 s_slot.s = string;
108 s_slot.len = len;
109
110 slot = file_name_hash_table->find_slot (&s_slot, INSERT);
111 if (*slot == NULL)
112 {
113 char *saved_string;
114 struct string_slot *new_slot;
115
116 saved_string = (char *) xmalloc (len + 1);
117 new_slot = XCNEW (struct string_slot);
118 memcpy (saved_string, string, len + 1);
119 new_slot->s = saved_string;
120 new_slot->len = len;
121 *slot = new_slot;
122 return saved_string;
123 }
124 else
125 {
126 struct string_slot *old_slot = *slot;
127 return old_slot->s;
128 }
129}
130
131/* Pointer to currently alive instance of lto_location_cache. */
132
133lto_location_cache *lto_location_cache::current_cache;
134
135/* Sort locations in source order. Start with file from last application. */
136
137int
138lto_location_cache::cmp_loc (const void *pa, const void *pb)
139{
140 const cached_location *a = ((const cached_location *)pa);
141 const cached_location *b = ((const cached_location *)pb);
142 const char *current_file = current_cache->current_file;
143 int current_line = current_cache->current_line;
144
145 if (a->file == current_file && b->file != current_file)
146 return -1;
147 if (a->file != current_file && b->file == current_file)
148 return 1;
149 if (a->file == current_file && b->file == current_file)
150 {
151 if (a->line == current_line && b->line != current_line)
152 return -1;
153 if (a->line != current_line && b->line == current_line)
154 return 1;
155 }
156 if (a->file != b->file)
157 return strcmp (a->file, b->file);
158 if (a->sysp != b->sysp)
159 return a->sysp ? 1 : -1;
160 if (a->line != b->line)
161 return a->line - b->line;
162 return a->col - b->col;
163}
164
165/* Apply all changes in location cache. Add locations into linemap and patch
166 trees. */
167
168bool
169lto_location_cache::apply_location_cache ()
170{
171 static const char *prev_file;
172 if (!loc_cache.length ())
173 return false;
174 if (loc_cache.length () > 1)
175 loc_cache.qsort (cmp_loc);
176
177 for (unsigned int i = 0; i < loc_cache.length (); i++)
178 {
179 struct cached_location loc = loc_cache[i];
180
181 if (current_file != loc.file)
182 linemap_add (line_table, prev_file ? LC_RENAME : LC_ENTER,
183 loc.sysp, loc.file, loc.line);
184 else if (current_line != loc.line)
185 {
186 int max = loc.col;
187
188 for (unsigned int j = i + 1; j < loc_cache.length (); j++)
189 if (loc.file != loc_cache[j].file
190 || loc.line != loc_cache[j].line)
191 break;
192 else if (max < loc_cache[j].col)
193 max = loc_cache[j].col;
194 linemap_line_start (line_table, loc.line, max + 1);
195 }
196 gcc_assert (*loc.loc == BUILTINS_LOCATION + 1);
197 if (current_file == loc.file && current_line == loc.line
198 && current_col == loc.col)
199 *loc.loc = current_loc;
200 else
201 current_loc = *loc.loc = linemap_position_for_column (line_table,
202 loc.col);
203 current_line = loc.line;
204 prev_file = current_file = loc.file;
205 current_col = loc.col;
206 }
207 loc_cache.truncate (0);
208 accepted_length = 0;
209 return true;
210}
211
212/* Tree merging did not suceed; mark all changes in the cache as accepted. */
213
214void
215lto_location_cache::accept_location_cache ()
216{
217 gcc_assert (current_cache == this);
218 accepted_length = loc_cache.length ();
219}
220
221/* Tree merging did suceed; throw away recent changes. */
222
223void
224lto_location_cache::revert_location_cache ()
225{
226 loc_cache.truncate (accepted_length);
227}
228
229/* Read a location bitpack from input block IB and either update *LOC directly
230 or add it to the location cache.
231 It is neccesary to call apply_location_cache to get *LOC updated. */
232
233void
234lto_location_cache::input_location (location_t *loc, struct bitpack_d *bp,
235 struct data_in *data_in)
236{
237 static const char *stream_file;
238 static int stream_line;
239 static int stream_col;
240 static bool stream_sysp;
241 bool file_change, line_change, column_change;
242
243 gcc_assert (current_cache == this);
244
245 *loc = bp_unpack_int_in_range (bp, "location", 0, RESERVED_LOCATION_COUNT);
246
247 if (*loc < RESERVED_LOCATION_COUNT)
248 return;
249
250 /* Keep value RESERVED_LOCATION_COUNT in *loc as linemap lookups will
251 ICE on it. */
252
253 file_change = bp_unpack_value (bp, 1);
254 line_change = bp_unpack_value (bp, 1);
255 column_change = bp_unpack_value (bp, 1);
256
257 if (file_change)
258 {
259 stream_file = canon_file_name (bp_unpack_string (data_in, bp));
260 stream_sysp = bp_unpack_value (bp, 1);
261 }
262
263 if (line_change)
264 stream_line = bp_unpack_var_len_unsigned (bp);
265
266 if (column_change)
267 stream_col = bp_unpack_var_len_unsigned (bp);
268
269 /* This optimization saves location cache operations druing gimple
270 streaming. */
271
272 if (current_file == stream_file && current_line == stream_line
273 && current_col == stream_col && current_sysp == stream_sysp)
274 {
275 *loc = current_loc;
276 return;
277 }
278
279 struct cached_location entry
280 = {stream_file, loc, stream_line, stream_col, stream_sysp};
281 loc_cache.safe_push (entry);
282}
283
284/* Read a location bitpack from input block IB and either update *LOC directly
285 or add it to the location cache.
286 It is neccesary to call apply_location_cache to get *LOC updated. */
287
288void
289lto_input_location (location_t *loc, struct bitpack_d *bp,
290 struct data_in *data_in)
291{
292 data_in->location_cache.input_location (loc, bp, data_in);
293}
294
295/* Read location and return it instead of going through location caching.
296 This should be used only when the resulting location is not going to be
297 discarded. */
298
299location_t
300stream_input_location_now (struct bitpack_d *bp, struct data_in *data_in)
301{
302 location_t loc;
303 stream_input_location (&loc, bp, data_in);
304 data_in->location_cache.apply_location_cache ();
305 return loc;
306}
307
308/* Read a reference to a tree node from DATA_IN using input block IB.
309 TAG is the expected node that should be found in IB, if TAG belongs
310 to one of the indexable trees, expect to read a reference index to
311 be looked up in one of the symbol tables, otherwise read the pysical
312 representation of the tree using stream_read_tree. FN is the
313 function scope for the read tree. */
314
315tree
316lto_input_tree_ref (struct lto_input_block *ib, struct data_in *data_in,
317 struct function *fn, enum LTO_tags tag)
318{
319 unsigned HOST_WIDE_INT ix_u;
320 tree result = NULL_TREE;
321
322 lto_tag_check_range (tag, LTO_field_decl_ref, LTO_namelist_decl_ref);
323
324 switch (tag)
325 {
326 case LTO_type_ref:
327 ix_u = streamer_read_uhwi (ib);
328 result = lto_file_decl_data_get_type (data_in->file_data, ix_u);
329 break;
330
331 case LTO_ssa_name_ref:
332 ix_u = streamer_read_uhwi (ib);
333 result = (*SSANAMES (fn))[ix_u];
334 break;
335
336 case LTO_field_decl_ref:
337 ix_u = streamer_read_uhwi (ib);
338 result = lto_file_decl_data_get_field_decl (data_in->file_data, ix_u);
339 break;
340
341 case LTO_function_decl_ref:
342 ix_u = streamer_read_uhwi (ib);
343 result = lto_file_decl_data_get_fn_decl (data_in->file_data, ix_u);
344 break;
345
346 case LTO_type_decl_ref:
347 ix_u = streamer_read_uhwi (ib);
348 result = lto_file_decl_data_get_type_decl (data_in->file_data, ix_u);
349 break;
350
351 case LTO_namespace_decl_ref:
352 ix_u = streamer_read_uhwi (ib);
353 result = lto_file_decl_data_get_namespace_decl (data_in->file_data, ix_u);
354 break;
355
356 case LTO_global_decl_ref:
357 case LTO_result_decl_ref:
358 case LTO_const_decl_ref:
359 case LTO_imported_decl_ref:
360 case LTO_label_decl_ref:
361 case LTO_translation_unit_decl_ref:
362 case LTO_namelist_decl_ref:
363 if (!data_in->file_data->current_decl_state)
364 printf("tag %d\n", tag);
365 ix_u = streamer_read_uhwi (ib);
366 result = lto_file_decl_data_get_var_decl (data_in->file_data, ix_u);
367 break;
368
369 default:
370 gcc_unreachable ();
371 }
372
373 gcc_assert (result);
374
375 return result;
376}
377
378
379/* Read and return a double-linked list of catch handlers from input
380 block IB, using descriptors in DATA_IN. */
381
382static struct eh_catch_d *
383lto_input_eh_catch_list (struct lto_input_block *ib, struct data_in *data_in,
384 eh_catch *last_p)
385{
386 eh_catch first;
387 enum LTO_tags tag;
388
389 *last_p = first = NULL;
390 tag = streamer_read_record_start (ib);
391 while (tag)
392 {
393 tree list;
394 eh_catch n;
395
396 lto_tag_check_range (tag, LTO_eh_catch, LTO_eh_catch);
397
398 /* Read the catch node. */
399 n = ggc_cleared_alloc<eh_catch_d> ();
400 n->type_list = stream_read_tree (ib, data_in);
401 n->filter_list = stream_read_tree (ib, data_in);
402 n->label = stream_read_tree (ib, data_in);
403
404 /* Register all the types in N->FILTER_LIST. */
405 for (list = n->filter_list; list; list = TREE_CHAIN (list))
406 add_type_for_runtime (TREE_VALUE (list));
407
408 /* Chain N to the end of the list. */
409 if (*last_p)
410 (*last_p)->next_catch = n;
411 n->prev_catch = *last_p;
412 *last_p = n;
413
414 /* Set the head of the list the first time through the loop. */
415 if (first == NULL)
416 first = n;
417
418 tag = streamer_read_record_start (ib);
419 }
420
421 return first;
422}
423
424
425/* Read and return EH region IX from input block IB, using descriptors
426 in DATA_IN. */
427
428static eh_region
429input_eh_region (struct lto_input_block *ib, struct data_in *data_in, int ix)
430{
431 enum LTO_tags tag;
432 eh_region r;
433
434 /* Read the region header. */
435 tag = streamer_read_record_start (ib);
436 if (tag == LTO_null)
437 return NULL;
438
439 r = ggc_cleared_alloc<eh_region_d> ();
440 r->index = streamer_read_hwi (ib);
441
442 gcc_assert (r->index == ix);
443
444 /* Read all the region pointers as region numbers. We'll fix up
445 the pointers once the whole array has been read. */
446 r->outer = (eh_region) (intptr_t) streamer_read_hwi (ib);
447 r->inner = (eh_region) (intptr_t) streamer_read_hwi (ib);
448 r->next_peer = (eh_region) (intptr_t) streamer_read_hwi (ib);
449
450 switch (tag)
451 {
452 case LTO_ert_cleanup:
453 r->type = ERT_CLEANUP;
454 break;
455
456 case LTO_ert_try:
457 {
458 struct eh_catch_d *last_catch;
459 r->type = ERT_TRY;
460 r->u.eh_try.first_catch = lto_input_eh_catch_list (ib, data_in,
461 &last_catch);
462 r->u.eh_try.last_catch = last_catch;
463 break;
464 }
465
466 case LTO_ert_allowed_exceptions:
467 {
468 tree l;
469
470 r->type = ERT_ALLOWED_EXCEPTIONS;
471 r->u.allowed.type_list = stream_read_tree (ib, data_in);
472 r->u.allowed.label = stream_read_tree (ib, data_in);
473 r->u.allowed.filter = streamer_read_uhwi (ib);
474
475 for (l = r->u.allowed.type_list; l ; l = TREE_CHAIN (l))
476 add_type_for_runtime (TREE_VALUE (l));
477 }
478 break;
479
480 case LTO_ert_must_not_throw:
481 {
482 r->type = ERT_MUST_NOT_THROW;
483 r->u.must_not_throw.failure_decl = stream_read_tree (ib, data_in);
484 bitpack_d bp = streamer_read_bitpack (ib);
485 r->u.must_not_throw.failure_loc
486 = stream_input_location_now (&bp, data_in);
487 }
488 break;
489
490 default:
491 gcc_unreachable ();
492 }
493
494 r->landing_pads = (eh_landing_pad) (intptr_t) streamer_read_hwi (ib);
495
496 return r;
497}
498
499
500/* Read and return EH landing pad IX from input block IB, using descriptors
501 in DATA_IN. */
502
503static eh_landing_pad
504input_eh_lp (struct lto_input_block *ib, struct data_in *data_in, int ix)
505{
506 enum LTO_tags tag;
507 eh_landing_pad lp;
508
509 /* Read the landing pad header. */
510 tag = streamer_read_record_start (ib);
511 if (tag == LTO_null)
512 return NULL;
513
514 lto_tag_check_range (tag, LTO_eh_landing_pad, LTO_eh_landing_pad);
515
516 lp = ggc_cleared_alloc<eh_landing_pad_d> ();
517 lp->index = streamer_read_hwi (ib);
518 gcc_assert (lp->index == ix);
519 lp->next_lp = (eh_landing_pad) (intptr_t) streamer_read_hwi (ib);
520 lp->region = (eh_region) (intptr_t) streamer_read_hwi (ib);
521 lp->post_landing_pad = stream_read_tree (ib, data_in);
522
523 return lp;
524}
525
526
527/* After reading the EH regions, pointers to peer and children regions
528 are region numbers. This converts all these region numbers into
529 real pointers into the rematerialized regions for FN. ROOT_REGION
530 is the region number for the root EH region in FN. */
531
532static void
533fixup_eh_region_pointers (struct function *fn, HOST_WIDE_INT root_region)
534{
535 unsigned i;
536 vec<eh_region, va_gc> *eh_array = fn->eh->region_array;
537 vec<eh_landing_pad, va_gc> *lp_array = fn->eh->lp_array;
538 eh_region r;
539 eh_landing_pad lp;
540
541 gcc_assert (eh_array && lp_array);
542
543 gcc_assert (root_region >= 0);
544 fn->eh->region_tree = (*eh_array)[root_region];
545
546#define FIXUP_EH_REGION(r) (r) = (*eh_array)[(HOST_WIDE_INT) (intptr_t) (r)]
547#define FIXUP_EH_LP(p) (p) = (*lp_array)[(HOST_WIDE_INT) (intptr_t) (p)]
548
549 /* Convert all the index numbers stored in pointer fields into
550 pointers to the corresponding slots in the EH region array. */
551 FOR_EACH_VEC_ELT (*eh_array, i, r)
552 {
553 /* The array may contain NULL regions. */
554 if (r == NULL)
555 continue;
556
557 gcc_assert (i == (unsigned) r->index);
558 FIXUP_EH_REGION (r->outer);
559 FIXUP_EH_REGION (r->inner);
560 FIXUP_EH_REGION (r->next_peer);
561 FIXUP_EH_LP (r->landing_pads);
562 }
563
564 /* Convert all the index numbers stored in pointer fields into
565 pointers to the corresponding slots in the EH landing pad array. */
566 FOR_EACH_VEC_ELT (*lp_array, i, lp)
567 {
568 /* The array may contain NULL landing pads. */
569 if (lp == NULL)
570 continue;
571
572 gcc_assert (i == (unsigned) lp->index);
573 FIXUP_EH_LP (lp->next_lp);
574 FIXUP_EH_REGION (lp->region);
575 }
576
577#undef FIXUP_EH_REGION
578#undef FIXUP_EH_LP
579}
580
581
582/* Initialize EH support. */
583
584void
585lto_init_eh (void)
586{
587 static bool eh_initialized_p = false;
588
589 if (eh_initialized_p)
590 return;
591
592 /* Contrary to most other FEs, we only initialize EH support when at
593 least one of the files in the set contains exception regions in
594 it. Since this happens much later than the call to init_eh in
595 lang_dependent_init, we have to set flag_exceptions and call
596 init_eh again to initialize the EH tables. */
597 flag_exceptions = 1;
598 init_eh ();
599
600 eh_initialized_p = true;
601}
602
603
604/* Read the exception table for FN from IB using the data descriptors
605 in DATA_IN. */
606
607static void
608input_eh_regions (struct lto_input_block *ib, struct data_in *data_in,
609 struct function *fn)
610{
611 HOST_WIDE_INT i, root_region, len;
612 enum LTO_tags tag;
613
614 tag = streamer_read_record_start (ib);
615 if (tag == LTO_null)
616 return;
617
618 lto_tag_check_range (tag, LTO_eh_table, LTO_eh_table);
619
620 /* If the file contains EH regions, then it was compiled with
621 -fexceptions. In that case, initialize the backend EH
622 machinery. */
623 lto_init_eh ();
624
625 gcc_assert (fn->eh);
626
627 root_region = streamer_read_hwi (ib);
628 gcc_assert (root_region == (int) root_region);
629
630 /* Read the EH region array. */
631 len = streamer_read_hwi (ib);
632 gcc_assert (len == (int) len);
633 if (len > 0)
634 {
635 vec_safe_grow_cleared (fn->eh->region_array, len);
636 for (i = 0; i < len; i++)
637 {
638 eh_region r = input_eh_region (ib, data_in, i);
639 (*fn->eh->region_array)[i] = r;
640 }
641 }
642
643 /* Read the landing pads. */
644 len = streamer_read_hwi (ib);
645 gcc_assert (len == (int) len);
646 if (len > 0)
647 {
648 vec_safe_grow_cleared (fn->eh->lp_array, len);
649 for (i = 0; i < len; i++)
650 {
651 eh_landing_pad lp = input_eh_lp (ib, data_in, i);
652 (*fn->eh->lp_array)[i] = lp;
653 }
654 }
655
656 /* Read the runtime type data. */
657 len = streamer_read_hwi (ib);
658 gcc_assert (len == (int) len);
659 if (len > 0)
660 {
661 vec_safe_grow_cleared (fn->eh->ttype_data, len);
662 for (i = 0; i < len; i++)
663 {
664 tree ttype = stream_read_tree (ib, data_in);
665 (*fn->eh->ttype_data)[i] = ttype;
666 }
667 }
668
669 /* Read the table of action chains. */
670 len = streamer_read_hwi (ib);
671 gcc_assert (len == (int) len);
672 if (len > 0)
673 {
674 if (targetm.arm_eabi_unwinder)
675 {
676 vec_safe_grow_cleared (fn->eh->ehspec_data.arm_eabi, len);
677 for (i = 0; i < len; i++)
678 {
679 tree t = stream_read_tree (ib, data_in);
680 (*fn->eh->ehspec_data.arm_eabi)[i] = t;
681 }
682 }
683 else
684 {
685 vec_safe_grow_cleared (fn->eh->ehspec_data.other, len);
686 for (i = 0; i < len; i++)
687 {
688 uchar c = streamer_read_uchar (ib);
689 (*fn->eh->ehspec_data.other)[i] = c;
690 }
691 }
692 }
693
694 /* Reconstruct the EH region tree by fixing up the peer/children
695 pointers. */
696 fixup_eh_region_pointers (fn, root_region);
697
698 tag = streamer_read_record_start (ib);
699 lto_tag_check_range (tag, LTO_null, LTO_null);
700}
701
702
703/* Make a new basic block with index INDEX in function FN. */
704
705static basic_block
706make_new_block (struct function *fn, unsigned int index)
707{
708 basic_block bb = alloc_block ();
709 bb->index = index;
710 SET_BASIC_BLOCK_FOR_FN (fn, index, bb);
711 n_basic_blocks_for_fn (fn)++;
712 return bb;
713}
714
715
716/* Read the CFG for function FN from input block IB. */
717
718static void
719input_cfg (struct lto_input_block *ib, struct data_in *data_in,
720 struct function *fn)
721{
722 unsigned int bb_count;
723 basic_block p_bb;
724 unsigned int i;
725 int index;
726
727 init_empty_tree_cfg_for_function (fn);
728 init_ssa_operands (fn);
729
730 profile_status_for_fn (fn) = streamer_read_enum (ib, profile_status_d,
731 PROFILE_LAST);
732
733 bb_count = streamer_read_uhwi (ib);
734
735 last_basic_block_for_fn (fn) = bb_count;
736 if (bb_count > basic_block_info_for_fn (fn)->length ())
737 vec_safe_grow_cleared (basic_block_info_for_fn (fn), bb_count);
738
739 if (bb_count > label_to_block_map_for_fn (fn)->length ())
740 vec_safe_grow_cleared (label_to_block_map_for_fn (fn), bb_count);
741
742 index = streamer_read_hwi (ib);
743 while (index != -1)
744 {
745 basic_block bb = BASIC_BLOCK_FOR_FN (fn, index);
746 unsigned int edge_count;
747
748 if (bb == NULL)
749 bb = make_new_block (fn, index);
750
751 edge_count = streamer_read_uhwi (ib);
752
753 /* Connect up the CFG. */
754 for (i = 0; i < edge_count; i++)
755 {
756 unsigned int dest_index;
757 unsigned int edge_flags;
758 basic_block dest;
759 profile_probability probability;
760 edge e;
761
762 dest_index = streamer_read_uhwi (ib);
763 probability = profile_probability::stream_in (ib);
764 edge_flags = streamer_read_uhwi (ib);
765
766 dest = BASIC_BLOCK_FOR_FN (fn, dest_index);
767
768 if (dest == NULL)
769 dest = make_new_block (fn, dest_index);
770
771 e = make_edge (bb, dest, edge_flags);
772 e->probability = probability;
773 }
774
775 index = streamer_read_hwi (ib);
776 }
777
778 p_bb = ENTRY_BLOCK_PTR_FOR_FN (fn);
779 index = streamer_read_hwi (ib);
780 while (index != -1)
781 {
782 basic_block bb = BASIC_BLOCK_FOR_FN (fn, index);
783 bb->prev_bb = p_bb;
784 p_bb->next_bb = bb;
785 p_bb = bb;
786 index = streamer_read_hwi (ib);
787 }
788
789 /* ??? The cfgloop interface is tied to cfun. */
790 gcc_assert (cfun == fn);
791
792 /* Input the loop tree. */
793 unsigned n_loops = streamer_read_uhwi (ib);
794 if (n_loops == 0)
795 return;
796
797 struct loops *loops = ggc_cleared_alloc<struct loops> ();
798 init_loops_structure (fn, loops, n_loops);
799 set_loops_for_fn (fn, loops);
800
801 /* Input each loop and associate it with its loop header so
802 flow_loops_find can rebuild the loop tree. */
803 for (unsigned i = 1; i < n_loops; ++i)
804 {
805 int header_index = streamer_read_hwi (ib);
806 if (header_index == -1)
807 {
808 loops->larray->quick_push (NULL);
809 continue;
810 }
811
812 struct loop *loop = alloc_loop ();
813 loop->header = BASIC_BLOCK_FOR_FN (fn, header_index);
814 loop->header->loop_father = loop;
815
816 /* Read everything copy_loop_info copies. */
817 loop->estimate_state = streamer_read_enum (ib, loop_estimation, EST_LAST);
818 loop->any_upper_bound = streamer_read_hwi (ib);
819 if (loop->any_upper_bound)
820 loop->nb_iterations_upper_bound = streamer_read_widest_int (ib);
821 loop->any_likely_upper_bound = streamer_read_hwi (ib);
822 if (loop->any_likely_upper_bound)
823 loop->nb_iterations_likely_upper_bound = streamer_read_widest_int (ib);
824 loop->any_estimate = streamer_read_hwi (ib);
825 if (loop->any_estimate)
826 loop->nb_iterations_estimate = streamer_read_widest_int (ib);
827
828 /* Read OMP SIMD related info. */
829 loop->safelen = streamer_read_hwi (ib);
830 loop->unroll = streamer_read_hwi (ib);
831 loop->dont_vectorize = streamer_read_hwi (ib);
832 loop->force_vectorize = streamer_read_hwi (ib);
833 loop->simduid = stream_read_tree (ib, data_in);
834
835 place_new_loop (fn, loop);
836
837 /* flow_loops_find doesn't like loops not in the tree, hook them
838 all as siblings of the tree root temporarily. */
839 flow_loop_tree_node_add (loops->tree_root, loop);
840 }
841
842 /* Rebuild the loop tree. */
843 flow_loops_find (loops);
844}
845
846
847/* Read the SSA names array for function FN from DATA_IN using input
848 block IB. */
849
850static void
851input_ssa_names (struct lto_input_block *ib, struct data_in *data_in,
852 struct function *fn)
853{
854 unsigned int i, size;
855
856 size = streamer_read_uhwi (ib);
857 init_ssanames (fn, size);
858
859 i = streamer_read_uhwi (ib);
860 while (i)
861 {
862 tree ssa_name, name;
863 bool is_default_def;
864
865 /* Skip over the elements that had been freed. */
866 while (SSANAMES (fn)->length () < i)
867 SSANAMES (fn)->quick_push (NULL_TREE);
868
869 is_default_def = (streamer_read_uchar (ib) != 0);
870 name = stream_read_tree (ib, data_in);
871 ssa_name = make_ssa_name_fn (fn, name, NULL);
872
873 if (is_default_def)
874 {
875 set_ssa_default_def (cfun, SSA_NAME_VAR (ssa_name), ssa_name);
876 SSA_NAME_DEF_STMT (ssa_name) = gimple_build_nop ();
877 }
878
879 i = streamer_read_uhwi (ib);
880 }
881}
882
883
884/* Go through all NODE edges and fixup call_stmt pointers
885 so they point to STMTS. */
886
887static void
888fixup_call_stmt_edges_1 (struct cgraph_node *node, gimple **stmts,
889 struct function *fn)
890{
891#define STMT_UID_NOT_IN_RANGE(uid) \
892 (gimple_stmt_max_uid (fn) < uid || uid == 0)
893
894 struct cgraph_edge *cedge;
895 struct ipa_ref *ref = NULL;
896 unsigned int i;
897
898 for (cedge = node->callees; cedge; cedge = cedge->next_callee)
899 {
900 if (STMT_UID_NOT_IN_RANGE (cedge->lto_stmt_uid))
901 fatal_error (input_location,
902 "Cgraph edge statement index out of range");
903 cedge->call_stmt = as_a <gcall *> (stmts[cedge->lto_stmt_uid - 1]);
904 if (!cedge->call_stmt)
905 fatal_error (input_location,
906 "Cgraph edge statement index not found");
907 }
908 for (cedge = node->indirect_calls; cedge; cedge = cedge->next_callee)
909 {
910 if (STMT_UID_NOT_IN_RANGE (cedge->lto_stmt_uid))
911 fatal_error (input_location,
912 "Cgraph edge statement index out of range");
913 cedge->call_stmt = as_a <gcall *> (stmts[cedge->lto_stmt_uid - 1]);
914 if (!cedge->call_stmt)
915 fatal_error (input_location, "Cgraph edge statement index not found");
916 }
917 for (i = 0; node->iterate_reference (i, ref); i++)
918 if (ref->lto_stmt_uid)
919 {
920 if (STMT_UID_NOT_IN_RANGE (ref->lto_stmt_uid))
921 fatal_error (input_location,
922 "Reference statement index out of range");
923 ref->stmt = stmts[ref->lto_stmt_uid - 1];
924 if (!ref->stmt)
925 fatal_error (input_location, "Reference statement index not found");
926 }
927}
928
929
930/* Fixup call_stmt pointers in NODE and all clones. */
931
932static void
933fixup_call_stmt_edges (struct cgraph_node *orig, gimple **stmts)
934{
935 struct cgraph_node *node;
936 struct function *fn;
937
938 while (orig->clone_of)
939 orig = orig->clone_of;
940 fn = DECL_STRUCT_FUNCTION (orig->decl);
941
942 if (!orig->thunk.thunk_p)
943 fixup_call_stmt_edges_1 (orig, stmts, fn);
944 if (orig->clones)
945 for (node = orig->clones; node != orig;)
946 {
947 if (!node->thunk.thunk_p)
948 fixup_call_stmt_edges_1 (node, stmts, fn);
949 if (node->clones)
950 node = node->clones;
951 else if (node->next_sibling_clone)
952 node = node->next_sibling_clone;
953 else
954 {
955 while (node != orig && !node->next_sibling_clone)
956 node = node->clone_of;
957 if (node != orig)
958 node = node->next_sibling_clone;
959 }
960 }
961}
962
963
964/* Input the base body of struct function FN from DATA_IN
965 using input block IB. */
966
967static void
968input_struct_function_base (struct function *fn, struct data_in *data_in,
969 struct lto_input_block *ib)
970{
971 struct bitpack_d bp;
972 int len;
973
974 /* Read the static chain and non-local goto save area. */
975 fn->static_chain_decl = stream_read_tree (ib, data_in);
976 fn->nonlocal_goto_save_area = stream_read_tree (ib, data_in);
977
978 /* Read all the local symbols. */
979 len = streamer_read_hwi (ib);
980 if (len > 0)
981 {
982 int i;
983 vec_safe_grow_cleared (fn->local_decls, len);
984 for (i = 0; i < len; i++)
985 {
986 tree t = stream_read_tree (ib, data_in);
987 (*fn->local_decls)[i] = t;
988 }
989 }
990
991 /* Input the current IL state of the function. */
992 fn->curr_properties = streamer_read_uhwi (ib);
993
994 /* Read all the attributes for FN. */
995 bp = streamer_read_bitpack (ib);
996 fn->is_thunk = bp_unpack_value (&bp, 1);
997 fn->has_local_explicit_reg_vars = bp_unpack_value (&bp, 1);
998 fn->returns_pcc_struct = bp_unpack_value (&bp, 1);
999 fn->returns_struct = bp_unpack_value (&bp, 1);
1000 fn->can_throw_non_call_exceptions = bp_unpack_value (&bp, 1);
1001 fn->can_delete_dead_exceptions = bp_unpack_value (&bp, 1);
1002 fn->always_inline_functions_inlined = bp_unpack_value (&bp, 1);
1003 fn->after_inlining = bp_unpack_value (&bp, 1);
1004 fn->stdarg = bp_unpack_value (&bp, 1);
1005 fn->has_nonlocal_label = bp_unpack_value (&bp, 1);
1006 fn->has_forced_label_in_static = bp_unpack_value (&bp, 1);
1007 fn->calls_alloca = bp_unpack_value (&bp, 1);
1008 fn->calls_setjmp = bp_unpack_value (&bp, 1);
1009 fn->has_force_vectorize_loops = bp_unpack_value (&bp, 1);
1010 fn->has_simduid_loops = bp_unpack_value (&bp, 1);
1011 fn->va_list_fpr_size = bp_unpack_value (&bp, 8);
1012 fn->va_list_gpr_size = bp_unpack_value (&bp, 8);
1013 fn->last_clique = bp_unpack_value (&bp, sizeof (short) * 8);
1014
1015 /* Input the function start and end loci. */
1016 fn->function_start_locus = stream_input_location_now (&bp, data_in);
1017 fn->function_end_locus = stream_input_location_now (&bp, data_in);
1018}
1019
1020
1021/* Read the body of function FN_DECL from DATA_IN using input block IB. */
1022
1023static void
1024input_function (tree fn_decl, struct data_in *data_in,
1025 struct lto_input_block *ib, struct lto_input_block *ib_cfg)
1026{
1027 struct function *fn;
1028 enum LTO_tags tag;
1029 gimple **stmts;
1030 basic_block bb;
1031 struct cgraph_node *node;
1032
1033 tag = streamer_read_record_start (ib);
1034 lto_tag_check (tag, LTO_function);
1035
1036 /* Read decls for parameters and args. */
1037 DECL_RESULT (fn_decl) = stream_read_tree (ib, data_in);
1038 DECL_ARGUMENTS (fn_decl) = streamer_read_chain (ib, data_in);
1039
1040 /* Read debug args if available. */
1041 unsigned n_debugargs = streamer_read_uhwi (ib);
1042 if (n_debugargs)
1043 {
1044 vec<tree, va_gc> **debugargs = decl_debug_args_insert (fn_decl);
1045 vec_safe_grow (*debugargs, n_debugargs);
1046 for (unsigned i = 0; i < n_debugargs; ++i)
1047 (**debugargs)[i] = stream_read_tree (ib, data_in);
1048 }
1049
1050 /* Read the tree of lexical scopes for the function. */
1051 DECL_INITIAL (fn_decl) = stream_read_tree (ib, data_in);
1052 unsigned block_leaf_count = streamer_read_uhwi (ib);
1053 while (block_leaf_count--)
1054 stream_read_tree (ib, data_in);
1055
1056 if (!streamer_read_uhwi (ib))
1057 return;
1058
1059 push_struct_function (fn_decl);
1060 fn = DECL_STRUCT_FUNCTION (fn_decl);
1061 init_tree_ssa (fn);
1062 /* We input IL in SSA form. */
1063 cfun->gimple_df->in_ssa_p = true;
1064
1065 gimple_register_cfg_hooks ();
1066
1067 node = cgraph_node::get (fn_decl);
1068 if (!node)
1069 node = cgraph_node::create (fn_decl);
1070 input_struct_function_base (fn, data_in, ib);
1071 input_cfg (ib_cfg, data_in, fn);
1072
1073 /* Read all the SSA names. */
1074 input_ssa_names (ib, data_in, fn);
1075
1076 /* Read the exception handling regions in the function. */
1077 input_eh_regions (ib, data_in, fn);
1078
1079 gcc_assert (DECL_INITIAL (fn_decl));
1080 DECL_SAVED_TREE (fn_decl) = NULL_TREE;
1081
1082 /* Read all the basic blocks. */
1083 tag = streamer_read_record_start (ib);
1084 while (tag)
1085 {
1086 input_bb (ib, tag, data_in, fn,
1087 node->count_materialization_scale);
1088 tag = streamer_read_record_start (ib);
1089 }
1090
1091 /* Fix up the call statements that are mentioned in the callgraph
1092 edges. */
1093 set_gimple_stmt_max_uid (cfun, 0);
1094 FOR_ALL_BB_FN (bb, cfun)
1095 {
1096 gimple_stmt_iterator gsi;
1097 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1098 {
1099 gimple *stmt = gsi_stmt (gsi);
1100 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
1101 }
1102 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1103 {
1104 gimple *stmt = gsi_stmt (gsi);
1105 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
1106 }
1107 }
1108 stmts = (gimple **) xcalloc (gimple_stmt_max_uid (fn), sizeof (gimple *));
1109 FOR_ALL_BB_FN (bb, cfun)
1110 {
1111 gimple_stmt_iterator bsi = gsi_start_phis (bb);
1112 while (!gsi_end_p (bsi))
1113 {
1114 gimple *stmt = gsi_stmt (bsi);
1115 gsi_next (&bsi);
1116 stmts[gimple_uid (stmt)] = stmt;
1117 }
1118 bsi = gsi_start_bb (bb);
1119 while (!gsi_end_p (bsi))
1120 {
1121 gimple *stmt = gsi_stmt (bsi);
1122 bool remove = false;
1123 /* If we're recompiling LTO objects with debug stmts but
1124 we're not supposed to have debug stmts, remove them now.
1125 We can't remove them earlier because this would cause uid
1126 mismatches in fixups, but we can do it at this point, as
1127 long as debug stmts don't require fixups.
1128 Similarly remove all IFN_*SAN_* internal calls */
1129 if (!flag_wpa)
1130 {
1131 if (is_gimple_debug (stmt)
1132 && (gimple_debug_nonbind_marker_p (stmt)
1133 ? !MAY_HAVE_DEBUG_MARKER_STMTS
1134 : !MAY_HAVE_DEBUG_BIND_STMTS))
1135 remove = true;
1136 if (is_gimple_call (stmt)
1137 && gimple_call_internal_p (stmt))
1138 {
1139 switch (gimple_call_internal_fn (stmt))
1140 {
1141 case IFN_UBSAN_NULL:
1142 if ((flag_sanitize
1143 & (SANITIZE_NULL | SANITIZE_ALIGNMENT)) == 0)
1144 remove = true;
1145 break;
1146 case IFN_UBSAN_BOUNDS:
1147 if ((flag_sanitize & SANITIZE_BOUNDS) == 0)
1148 remove = true;
1149 break;
1150 case IFN_UBSAN_VPTR:
1151 if ((flag_sanitize & SANITIZE_VPTR) == 0)
1152 remove = true;
1153 break;
1154 case IFN_UBSAN_OBJECT_SIZE:
1155 if ((flag_sanitize & SANITIZE_OBJECT_SIZE) == 0)
1156 remove = true;
1157 break;
1158 case IFN_UBSAN_PTR:
1159 if ((flag_sanitize & SANITIZE_POINTER_OVERFLOW) == 0)
1160 remove = true;
1161 break;
1162 case IFN_ASAN_MARK:
1163 if ((flag_sanitize & SANITIZE_ADDRESS) == 0)
1164 remove = true;
1165 break;
1166 case IFN_TSAN_FUNC_EXIT:
1167 if ((flag_sanitize & SANITIZE_THREAD) == 0)
1168 remove = true;
1169 break;
1170 default:
1171 break;
1172 }
1173 gcc_assert (!remove || gimple_call_lhs (stmt) == NULL_TREE);
1174 }
1175 }
1176 if (remove)
1177 {
1178 gimple_stmt_iterator gsi = bsi;
1179 gsi_next (&bsi);
1180 unlink_stmt_vdef (stmt);
1181 release_defs (stmt);
1182 gsi_remove (&gsi, true);
1183 }
1184 else
1185 {
1186 gsi_next (&bsi);
1187 stmts[gimple_uid (stmt)] = stmt;
1188
1189 /* Remember that the input function has begin stmt
1190 markers, so that we know to expect them when emitting
1191 debug info. */
1192 if (!cfun->debug_nonbind_markers
1193 && gimple_debug_nonbind_marker_p (stmt))
1194 cfun->debug_nonbind_markers = true;
1195 }
1196 }
1197 }
1198
1199 /* Set the gimple body to the statement sequence in the entry
1200 basic block. FIXME lto, this is fairly hacky. The existence
1201 of a gimple body is used by the cgraph routines, but we should
1202 really use the presence of the CFG. */
1203 {
1204 edge_iterator ei = ei_start (ENTRY_BLOCK_PTR_FOR_FN (cfun)->succs);
1205 gimple_set_body (fn_decl, bb_seq (ei_edge (ei)->dest));
1206 }
1207
1208 update_max_bb_count ();
1209 fixup_call_stmt_edges (node, stmts);
1210 execute_all_ipa_stmt_fixups (node, stmts);
1211
1212 update_ssa (TODO_update_ssa_only_virtuals);
1213 free_dominance_info (CDI_DOMINATORS);
1214 free_dominance_info (CDI_POST_DOMINATORS);
1215 free (stmts);
1216 pop_cfun ();
1217}
1218
1219/* Read the body of function FN_DECL from DATA_IN using input block IB. */
1220
1221static void
1222input_constructor (tree var, struct data_in *data_in,
1223 struct lto_input_block *ib)
1224{
1225 DECL_INITIAL (var) = stream_read_tree (ib, data_in);
1226}
1227
1228
1229/* Read the body from DATA for function NODE and fill it in.
1230 FILE_DATA are the global decls and types. SECTION_TYPE is either
1231 LTO_section_function_body or LTO_section_static_initializer. If
1232 section type is LTO_section_function_body, FN must be the decl for
1233 that function. */
1234
1235static void
1236lto_read_body_or_constructor (struct lto_file_decl_data *file_data, struct symtab_node *node,
1237 const char *data, enum lto_section_type section_type)
1238{
1239 const struct lto_function_header *header;
1240 struct data_in *data_in;
1241 int cfg_offset;
1242 int main_offset;
1243 int string_offset;
1244 tree fn_decl = node->decl;
1245
1246 header = (const struct lto_function_header *) data;
1247 if (TREE_CODE (node->decl) == FUNCTION_DECL)
1248 {
1249 cfg_offset = sizeof (struct lto_function_header);
1250 main_offset = cfg_offset + header->cfg_size;
1251 string_offset = main_offset + header->main_size;
1252 }
1253 else
1254 {
1255 main_offset = sizeof (struct lto_function_header);
1256 string_offset = main_offset + header->main_size;
1257 }
1258
1259 data_in = lto_data_in_create (file_data, data + string_offset,
1260 header->string_size, vNULL);
1261
1262 if (section_type == LTO_section_function_body)
1263 {
1264 struct lto_in_decl_state *decl_state;
1265 unsigned from;
1266
1267 gcc_checking_assert (node);
1268
1269 /* Use the function's decl state. */
1270 decl_state = lto_get_function_in_decl_state (file_data, fn_decl);
1271 gcc_assert (decl_state);
1272 file_data->current_decl_state = decl_state;
1273
1274
1275 /* Set up the struct function. */
1276 from = data_in->reader_cache->nodes.length ();
1277 lto_input_block ib_main (data + main_offset, header->main_size,
1278 file_data->mode_table);
1279 if (TREE_CODE (node->decl) == FUNCTION_DECL)
1280 {
1281 lto_input_block ib_cfg (data + cfg_offset, header->cfg_size,
1282 file_data->mode_table);
1283 input_function (fn_decl, data_in, &ib_main, &ib_cfg);
1284 }
1285 else
1286 input_constructor (fn_decl, data_in, &ib_main);
1287 data_in->location_cache.apply_location_cache ();
1288 /* And fixup types we streamed locally. */
1289 {
1290 struct streamer_tree_cache_d *cache = data_in->reader_cache;
1291 unsigned len = cache->nodes.length ();
1292 unsigned i;
1293 for (i = len; i-- > from;)
1294 {
1295 tree t = streamer_tree_cache_get_tree (cache, i);
1296 if (t == NULL_TREE)
1297 continue;
1298
1299 if (TYPE_P (t))
1300 {
1301 gcc_assert (TYPE_CANONICAL (t) == NULL_TREE);
1302 if (type_with_alias_set_p (t)
1303 && canonical_type_used_p (t))
1304 TYPE_CANONICAL (t) = TYPE_MAIN_VARIANT (t);
1305 if (TYPE_MAIN_VARIANT (t) != t)
1306 {
1307 gcc_assert (TYPE_NEXT_VARIANT (t) == NULL_TREE);
1308 TYPE_NEXT_VARIANT (t)
1309 = TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t));
1310 TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t)) = t;
1311 }
1312 }
1313 }
1314 }
1315
1316 /* Restore decl state */
1317 file_data->current_decl_state = file_data->global_decl_state;
1318 }
1319
1320 lto_data_in_delete (data_in);
1321}
1322
1323
1324/* Read the body of NODE using DATA. FILE_DATA holds the global
1325 decls and types. */
1326
1327void
1328lto_input_function_body (struct lto_file_decl_data *file_data,
1329 struct cgraph_node *node, const char *data)
1330{
1331 lto_read_body_or_constructor (file_data, node, data, LTO_section_function_body);
1332}
1333
1334/* Read the body of NODE using DATA. FILE_DATA holds the global
1335 decls and types. */
1336
1337void
1338lto_input_variable_constructor (struct lto_file_decl_data *file_data,
1339 struct varpool_node *node, const char *data)
1340{
1341 lto_read_body_or_constructor (file_data, node, data, LTO_section_function_body);
1342}
1343
1344
1345/* Queue of acummulated decl -> DIE mappings. Similar to locations those
1346 are only applied to prevailing tree nodes during tree merging. */
1347vec<dref_entry> dref_queue;
1348
1349/* Read the physical representation of a tree node EXPR from
1350 input block IB using the per-file context in DATA_IN. */
1351
1352static void
1353lto_read_tree_1 (struct lto_input_block *ib, struct data_in *data_in, tree expr)
1354{
1355 /* Read all the bitfield values in EXPR. Note that for LTO, we
1356 only write language-independent bitfields, so no more unpacking is
1357 needed. */
1358 streamer_read_tree_bitfields (ib, data_in, expr);
1359
1360 /* Read all the pointer fields in EXPR. */
1361 streamer_read_tree_body (ib, data_in, expr);
1362
1363 /* Read any LTO-specific data not read by the tree streamer. */
1364 if (DECL_P (expr)
1365 && TREE_CODE (expr) != FUNCTION_DECL
1366 && TREE_CODE (expr) != TRANSLATION_UNIT_DECL)
1367 DECL_INITIAL (expr) = stream_read_tree (ib, data_in);
1368
1369 /* Stream references to early generated DIEs. Keep in sync with the
1370 trees handled in dwarf2out_register_external_die. */
1371 if ((DECL_P (expr)
1372 && TREE_CODE (expr) != FIELD_DECL
1373 && TREE_CODE (expr) != DEBUG_EXPR_DECL
1374 && TREE_CODE (expr) != TYPE_DECL)
1375 || TREE_CODE (expr) == BLOCK)
1376 {
1377 const char *str = streamer_read_string (data_in, ib);
1378 if (str)
1379 {
1380 unsigned HOST_WIDE_INT off = streamer_read_uhwi (ib);
1381 dref_entry e = { expr, str, off };
1382 dref_queue.safe_push (e);
1383 }
1384 }
1385}
1386
1387/* Read the physical representation of a tree node with tag TAG from
1388 input block IB using the per-file context in DATA_IN. */
1389
1390static tree
1391lto_read_tree (struct lto_input_block *ib, struct data_in *data_in,
1392 enum LTO_tags tag, hashval_t hash)
1393{
1394 /* Instantiate a new tree node. */
1395 tree result = streamer_alloc_tree (ib, data_in, tag);
1396
1397 /* Enter RESULT in the reader cache. This will make RESULT
1398 available so that circular references in the rest of the tree
1399 structure can be resolved in subsequent calls to stream_read_tree. */
1400 streamer_tree_cache_append (data_in->reader_cache, result, hash);
1401
1402 lto_read_tree_1 (ib, data_in, result);
1403
1404 /* end_marker = */ streamer_read_uchar (ib);
1405
1406 return result;
1407}
1408
1409
1410/* Populate the reader cache with trees materialized from the SCC
1411 following in the IB, DATA_IN stream. */
1412
1413hashval_t
1414lto_input_scc (struct lto_input_block *ib, struct data_in *data_in,
1415 unsigned *len, unsigned *entry_len)
1416{
1417 /* A blob of unnamed tree nodes, fill the cache from it and
1418 recurse. */
1419 unsigned size = streamer_read_uhwi (ib);
1420 hashval_t scc_hash = streamer_read_uhwi (ib);
1421 unsigned scc_entry_len = 1;
1422
1423 if (size == 1)
1424 {
1425 enum LTO_tags tag = streamer_read_record_start (ib);
1426 lto_input_tree_1 (ib, data_in, tag, scc_hash);
1427 }
1428 else
1429 {
1430 unsigned int first = data_in->reader_cache->nodes.length ();
1431 tree result;
1432
1433 scc_entry_len = streamer_read_uhwi (ib);
1434
1435 /* Materialize size trees by reading their headers. */
1436 for (unsigned i = 0; i < size; ++i)
1437 {
1438 enum LTO_tags tag = streamer_read_record_start (ib);
1439 if (tag == LTO_null
1440 || (tag >= LTO_field_decl_ref && tag <= LTO_global_decl_ref)
1441 || tag == LTO_tree_pickle_reference
1442 || tag == LTO_integer_cst
1443 || tag == LTO_tree_scc)
1444 gcc_unreachable ();
1445
1446 result = streamer_alloc_tree (ib, data_in, tag);
1447 streamer_tree_cache_append (data_in->reader_cache, result, 0);
1448 }
1449
1450 /* Read the tree bitpacks and references. */
1451 for (unsigned i = 0; i < size; ++i)
1452 {
1453 result = streamer_tree_cache_get_tree (data_in->reader_cache,
1454 first + i);
1455 lto_read_tree_1 (ib, data_in, result);
1456 /* end_marker = */ streamer_read_uchar (ib);
1457 }
1458 }
1459
1460 *len = size;
1461 *entry_len = scc_entry_len;
1462 return scc_hash;
1463}
1464
1465
1466/* Read a tree from input block IB using the per-file context in
1467 DATA_IN. This context is used, for example, to resolve references
1468 to previously read nodes. */
1469
1470tree
1471lto_input_tree_1 (struct lto_input_block *ib, struct data_in *data_in,
1472 enum LTO_tags tag, hashval_t hash)
1473{
1474 tree result;
1475
1476 gcc_assert ((unsigned) tag < (unsigned) LTO_NUM_TAGS);
1477
1478 if (tag == LTO_null)
1479 result = NULL_TREE;
1480 else if (tag >= LTO_field_decl_ref && tag <= LTO_namelist_decl_ref)
1481 {
1482 /* If TAG is a reference to an indexable tree, the next value
1483 in IB is the index into the table where we expect to find
1484 that tree. */
1485 result = lto_input_tree_ref (ib, data_in, cfun, tag);
1486 }
1487 else if (tag == LTO_tree_pickle_reference)
1488 {
1489 /* If TAG is a reference to a previously read tree, look it up in
1490 the reader cache. */
1491 result = streamer_get_pickled_tree (ib, data_in);
1492 }
1493 else if (tag == LTO_integer_cst)
1494 {
1495 /* For shared integer constants in singletons we can use the
1496 existing tree integer constant merging code. */
1497 tree type = stream_read_tree (ib, data_in);
1498 unsigned HOST_WIDE_INT len = streamer_read_uhwi (ib);
1499 unsigned HOST_WIDE_INT i;
1500 HOST_WIDE_INT a[WIDE_INT_MAX_ELTS];
1501
1502 for (i = 0; i < len; i++)
1503 a[i] = streamer_read_hwi (ib);
1504 gcc_assert (TYPE_PRECISION (type) <= MAX_BITSIZE_MODE_ANY_INT);
1505 result = wide_int_to_tree (type, wide_int::from_array
1506 (a, len, TYPE_PRECISION (type)));
1507 streamer_tree_cache_append (data_in->reader_cache, result, hash);
1508 }
1509 else if (tag == LTO_tree_scc)
1510 gcc_unreachable ();
1511 else
1512 {
1513 /* Otherwise, materialize a new node from IB. */
1514 result = lto_read_tree (ib, data_in, tag, hash);
1515 }
1516
1517 return result;
1518}
1519
1520tree
1521lto_input_tree (struct lto_input_block *ib, struct data_in *data_in)
1522{
1523 enum LTO_tags tag;
1524
1525 /* Input and skip SCCs. */
1526 while ((tag = streamer_read_record_start (ib)) == LTO_tree_scc)
1527 {
1528 unsigned len, entry_len;
1529 lto_input_scc (ib, data_in, &len, &entry_len);
1530
1531 /* Register DECLs with the debuginfo machinery. */
1532 while (!dref_queue.is_empty ())
1533 {
1534 dref_entry e = dref_queue.pop ();
1535 debug_hooks->register_external_die (e.decl, e.sym, e.off);
1536 }
1537 }
1538 return lto_input_tree_1 (ib, data_in, tag, 0);
1539}
1540
1541
1542/* Input toplevel asms. */
1543
1544void
1545lto_input_toplevel_asms (struct lto_file_decl_data *file_data, int order_base)
1546{
1547 size_t len;
1548 const char *data = lto_get_section_data (file_data, LTO_section_asm,
1549 NULL, &len);
1550 const struct lto_simple_header_with_strings *header
1551 = (const struct lto_simple_header_with_strings *) data;
1552 int string_offset;
1553 struct data_in *data_in;
1554 tree str;
1555
1556 if (! data)
1557 return;
1558
1559 string_offset = sizeof (*header) + header->main_size;
1560
1561 lto_input_block ib (data + sizeof (*header), header->main_size,
1562 file_data->mode_table);
1563
1564 data_in = lto_data_in_create (file_data, data + string_offset,
1565 header->string_size, vNULL);
1566
1567 while ((str = streamer_read_string_cst (data_in, &ib)))
1568 {
1569 asm_node *node = symtab->finalize_toplevel_asm (str);
1570 node->order = streamer_read_hwi (&ib) + order_base;
1571 if (node->order >= symtab->order)
1572 symtab->order = node->order + 1;
1573 }
1574
1575 lto_data_in_delete (data_in);
1576
1577 lto_free_section_data (file_data, LTO_section_asm, NULL, data, len);
1578}
1579
1580
1581/* Input mode table. */
1582
1583void
1584lto_input_mode_table (struct lto_file_decl_data *file_data)
1585{
1586 size_t len;
1587 const char *data = lto_get_section_data (file_data, LTO_section_mode_table,
1588 NULL, &len);
1589 if (! data)
1590 {
1591 internal_error ("cannot read LTO mode table from %s",
1592 file_data->file_name);
1593 return;
1594 }
1595
1596 unsigned char *table = ggc_cleared_vec_alloc<unsigned char> (1 << 8);
1597 file_data->mode_table = table;
1598 const struct lto_simple_header_with_strings *header
1599 = (const struct lto_simple_header_with_strings *) data;
1600 int string_offset;
1601 struct data_in *data_in;
1602 string_offset = sizeof (*header) + header->main_size;
1603
1604 lto_input_block ib (data + sizeof (*header), header->main_size, NULL);
1605 data_in = lto_data_in_create (file_data, data + string_offset,
1606 header->string_size, vNULL);
1607 bitpack_d bp = streamer_read_bitpack (&ib);
1608
1609 table[VOIDmode] = VOIDmode;
1610 table[BLKmode] = BLKmode;
1611 unsigned int m;
1612 while ((m = bp_unpack_value (&bp, 8)) != VOIDmode)
1613 {
1614 enum mode_class mclass
1615 = bp_unpack_enum (&bp, mode_class, MAX_MODE_CLASS);
1616 unsigned int size = bp_unpack_value (&bp, 8);
1617 unsigned int prec = bp_unpack_value (&bp, 16);
1618 machine_mode inner = (machine_mode) bp_unpack_value (&bp, 8);
1619 unsigned int nunits = bp_unpack_value (&bp, 8);
1620 unsigned int ibit = 0, fbit = 0;
1621 unsigned int real_fmt_len = 0;
1622 const char *real_fmt_name = NULL;
1623 switch (mclass)
1624 {
1625 case MODE_FRACT:
1626 case MODE_UFRACT:
1627 case MODE_ACCUM:
1628 case MODE_UACCUM:
1629 ibit = bp_unpack_value (&bp, 8);
1630 fbit = bp_unpack_value (&bp, 8);
1631 break;
1632 case MODE_FLOAT:
1633 case MODE_DECIMAL_FLOAT:
1634 real_fmt_name = bp_unpack_indexed_string (data_in, &bp,
1635 &real_fmt_len);
1636 break;
1637 default:
1638 break;
1639 }
1640 /* First search just the GET_CLASS_NARROWEST_MODE to wider modes,
1641 if not found, fallback to all modes. */
1642 int pass;
1643 for (pass = 0; pass < 2; pass++)
1644 for (machine_mode mr = pass ? VOIDmode
1645 : GET_CLASS_NARROWEST_MODE (mclass);
1646 pass ? mr < MAX_MACHINE_MODE : mr != VOIDmode;
1647 pass ? mr = (machine_mode) (mr + 1)
1648 : mr = GET_MODE_WIDER_MODE (mr).else_void ())
1649 if (GET_MODE_CLASS (mr) != mclass
1650 || GET_MODE_SIZE (mr) != size
1651 || GET_MODE_PRECISION (mr) != prec
1652 || (inner == m
1653 ? GET_MODE_INNER (mr) != mr
1654 : GET_MODE_INNER (mr) != table[(int) inner])
1655 || GET_MODE_IBIT (mr) != ibit
1656 || GET_MODE_FBIT (mr) != fbit
1657 || GET_MODE_NUNITS (mr) != nunits)
1658 continue;
1659 else if ((mclass == MODE_FLOAT || mclass == MODE_DECIMAL_FLOAT)
1660 && strcmp (REAL_MODE_FORMAT (mr)->name, real_fmt_name) != 0)
1661 continue;
1662 else
1663 {
1664 table[m] = mr;
1665 pass = 2;
1666 break;
1667 }
1668 unsigned int mname_len;
1669 const char *mname = bp_unpack_indexed_string (data_in, &bp, &mname_len);
1670 if (pass == 2)
1671 {
1672 switch (mclass)
1673 {
1674 case MODE_VECTOR_INT:
1675 case MODE_VECTOR_FLOAT:
1676 case MODE_VECTOR_FRACT:
1677 case MODE_VECTOR_UFRACT:
1678 case MODE_VECTOR_ACCUM:
1679 case MODE_VECTOR_UACCUM:
1680 /* For unsupported vector modes just use BLKmode,
1681 if the scalar mode is supported. */
1682 if (table[(int) inner] != VOIDmode)
1683 {
1684 table[m] = BLKmode;
1685 break;
1686 }
1687 /* FALLTHRU */
1688 default:
1689 fatal_error (UNKNOWN_LOCATION, "unsupported mode %s\n", mname);
1690 break;
1691 }
1692 }
1693 }
1694 lto_data_in_delete (data_in);
1695
1696 lto_free_section_data (file_data, LTO_section_mode_table, NULL, data, len);
1697}
1698
1699
1700/* Initialization for the LTO reader. */
1701
1702void
1703lto_reader_init (void)
1704{
1705 lto_streamer_init ();
1706 file_name_hash_table
1707 = new hash_table<freeing_string_slot_hasher> (37);
1708}
1709
1710
1711/* Create a new data_in object for FILE_DATA. STRINGS is the string
1712 table to use with LEN strings. RESOLUTIONS is the vector of linker
1713 resolutions (NULL if not using a linker plugin). */
1714
1715struct data_in *
1716lto_data_in_create (struct lto_file_decl_data *file_data, const char *strings,
1717 unsigned len,
1718 vec<ld_plugin_symbol_resolution_t> resolutions)
1719{
1720 struct data_in *data_in = new (struct data_in);
1721 data_in->file_data = file_data;
1722 data_in->strings = strings;
1723 data_in->strings_len = len;
1724 data_in->globals_resolution = resolutions;
1725 data_in->reader_cache = streamer_tree_cache_create (false, false, true);
1726 return data_in;
1727}
1728
1729
1730/* Remove DATA_IN. */
1731
1732void
1733lto_data_in_delete (struct data_in *data_in)
1734{
1735 data_in->globals_resolution.release ();
1736 streamer_tree_cache_delete (data_in->reader_cache);
1737 delete data_in;
1738}
1739