ada-tree.h (union lang_tree_node): Check for TS_COMMON before calling TREE_CHAIN.
[gcc.git] / gcc / lto-streamer-in.c
1 /* Read the GIMPLE representation from a file stream.
2
3 Copyright 2009, 2010 Free Software Foundation, Inc.
4 Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
5 Re-implemented by Diego Novillo <dnovillo@google.com>
6
7 This file is part of GCC.
8
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.
13
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.
18
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/>. */
22
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "tm.h"
27 #include "toplev.h"
28 #include "tree.h"
29 #include "expr.h"
30 #include "flags.h"
31 #include "params.h"
32 #include "input.h"
33 #include "hashtab.h"
34 #include "basic-block.h"
35 #include "tree-flow.h"
36 #include "tree-pass.h"
37 #include "cgraph.h"
38 #include "function.h"
39 #include "ggc.h"
40 #include "diagnostic.h"
41 #include "libfuncs.h"
42 #include "except.h"
43 #include "debug.h"
44 #include "vec.h"
45 #include "timevar.h"
46 #include "output.h"
47 #include "ipa-utils.h"
48 #include "lto-streamer.h"
49 #include "tree-pass.h"
50
51 /* Data structure used to hash file names in the source_location field. */
52 struct string_slot
53 {
54 const char *s;
55 unsigned int slot_num;
56 };
57
58 /* The table to hold the file names. */
59 static htab_t 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
65 static void
66 lto_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 /* Check that tag ACTUAL is in the range [TAG1, TAG2]. */
85
86 static void
87 lto_tag_check_range (enum LTO_tags actual, enum LTO_tags tag1,
88 enum LTO_tags tag2)
89 {
90 if (actual < tag1 || actual > tag2)
91 internal_error ("bytecode stream: tag %s is not in the expected range "
92 "[%s, %s]",
93 lto_tag_name (actual),
94 lto_tag_name (tag1),
95 lto_tag_name (tag2));
96 }
97
98
99 /* Check that tag ACTUAL == EXPECTED. */
100
101 static void
102 lto_tag_check (enum LTO_tags actual, enum LTO_tags expected)
103 {
104 if (actual != expected)
105 internal_error ("bytecode stream: expected tag %s instead of %s",
106 lto_tag_name (expected), lto_tag_name (actual));
107 }
108
109
110 /* Return a hash code for P. */
111
112 static hashval_t
113 hash_string_slot_node (const void *p)
114 {
115 const struct string_slot *ds = (const struct string_slot *) p;
116 return (hashval_t) htab_hash_string (ds->s);
117 }
118
119
120 /* Returns nonzero if P1 and P2 are equal. */
121
122 static int
123 eq_string_slot_node (const void *p1, const void *p2)
124 {
125 const struct string_slot *ds1 = (const struct string_slot *) p1;
126 const struct string_slot *ds2 = (const struct string_slot *) p2;
127 return strcmp (ds1->s, ds2->s) == 0;
128 }
129
130
131 /* Read a string from the string table in DATA_IN using input block
132 IB. Write the length to RLEN. */
133
134 static const char *
135 input_string_internal (struct data_in *data_in, struct lto_input_block *ib,
136 unsigned int *rlen)
137 {
138 struct lto_input_block str_tab;
139 unsigned int len;
140 unsigned int loc;
141 const char *result;
142
143 /* Read the location of the string from IB. */
144 loc = lto_input_uleb128 (ib);
145
146 /* Get the string stored at location LOC in DATA_IN->STRINGS. */
147 LTO_INIT_INPUT_BLOCK (str_tab, data_in->strings, loc, data_in->strings_len);
148 len = lto_input_uleb128 (&str_tab);
149 *rlen = len;
150
151 if (str_tab.p + len > data_in->strings_len)
152 internal_error ("bytecode stream: string too long for the string table");
153
154 result = (const char *)(data_in->strings + str_tab.p);
155
156 return result;
157 }
158
159
160 /* Read a STRING_CST from the string table in DATA_IN using input
161 block IB. */
162
163 static tree
164 input_string_cst (struct data_in *data_in, struct lto_input_block *ib)
165 {
166 unsigned int len;
167 const char * ptr;
168 unsigned int is_null;
169
170 is_null = lto_input_uleb128 (ib);
171 if (is_null)
172 return NULL;
173
174 ptr = input_string_internal (data_in, ib, &len);
175 return build_string (len, ptr);
176 }
177
178
179 /* Read an IDENTIFIER from the string table in DATA_IN using input
180 block IB. */
181
182 static tree
183 input_identifier (struct data_in *data_in, struct lto_input_block *ib)
184 {
185 unsigned int len;
186 const char *ptr;
187 unsigned int is_null;
188
189 is_null = lto_input_uleb128 (ib);
190 if (is_null)
191 return NULL;
192
193 ptr = input_string_internal (data_in, ib, &len);
194 return get_identifier_with_length (ptr, len);
195 }
196
197
198 /* Read LENGTH bytes from STREAM to ADDR. */
199
200 void
201 lto_input_data_block (struct lto_input_block *ib, void *addr, size_t length)
202 {
203 size_t i;
204 unsigned char *const buffer = (unsigned char *const) addr;
205
206 for (i = 0; i < length; i++)
207 buffer[i] = lto_input_1_unsigned (ib);
208 }
209
210
211 /* Read a NULL terminated string from the string table in DATA_IN. */
212
213 const char *
214 lto_input_string (struct data_in *data_in, struct lto_input_block *ib)
215 {
216 unsigned int len;
217 const char *ptr;
218 unsigned int is_null;
219
220 is_null = lto_input_uleb128 (ib);
221 if (is_null)
222 return NULL;
223
224 ptr = input_string_internal (data_in, ib, &len);
225 if (ptr[len - 1] != '\0')
226 internal_error ("bytecode stream: found non-null terminated string");
227
228 return ptr;
229 }
230
231
232 /* Return the next tag in the input block IB. */
233
234 static enum LTO_tags
235 input_record_start (struct lto_input_block *ib)
236 {
237 enum LTO_tags tag = (enum LTO_tags) lto_input_uleb128 (ib);
238 return tag;
239 }
240
241
242 /* Lookup STRING in file_name_hash_table. If found, return the existing
243 string, otherwise insert STRING as the canonical version. */
244
245 static const char *
246 canon_file_name (const char *string)
247 {
248 void **slot;
249 struct string_slot s_slot;
250 s_slot.s = string;
251
252 slot = htab_find_slot (file_name_hash_table, &s_slot, INSERT);
253 if (*slot == NULL)
254 {
255 size_t len;
256 char *saved_string;
257 struct string_slot *new_slot;
258
259 len = strlen (string);
260 saved_string = (char *) xmalloc (len + 1);
261 new_slot = XCNEW (struct string_slot);
262 strcpy (saved_string, string);
263 new_slot->s = saved_string;
264 *slot = new_slot;
265 return saved_string;
266 }
267 else
268 {
269 struct string_slot *old_slot = (struct string_slot *) *slot;
270 return old_slot->s;
271 }
272 }
273
274
275 /* Clear the line info stored in DATA_IN. */
276
277 static void
278 clear_line_info (struct data_in *data_in)
279 {
280 if (data_in->current_file)
281 linemap_add (line_table, LC_LEAVE, false, NULL, 0);
282 data_in->current_file = NULL;
283 data_in->current_line = 0;
284 data_in->current_col = 0;
285 }
286
287
288 /* Read a location from input block IB. */
289
290 static location_t
291 lto_input_location (struct lto_input_block *ib, struct data_in *data_in)
292 {
293 expanded_location xloc;
294
295 xloc.file = lto_input_string (data_in, ib);
296 if (xloc.file == NULL)
297 return UNKNOWN_LOCATION;
298
299 xloc.file = canon_file_name (xloc.file);
300 xloc.line = lto_input_sleb128 (ib);
301 xloc.column = lto_input_sleb128 (ib);
302 xloc.sysp = lto_input_sleb128 (ib);
303
304 if (data_in->current_file != xloc.file)
305 {
306 if (data_in->current_file)
307 linemap_add (line_table, LC_LEAVE, false, NULL, 0);
308
309 linemap_add (line_table, LC_ENTER, xloc.sysp, xloc.file, xloc.line);
310 }
311 else if (data_in->current_line != xloc.line)
312 linemap_line_start (line_table, xloc.line, xloc.column);
313
314 data_in->current_file = xloc.file;
315 data_in->current_line = xloc.line;
316 data_in->current_col = xloc.column;
317
318 return linemap_position_for_column (line_table, xloc.column);
319 }
320
321
322 /* Read a reference to a tree node from DATA_IN using input block IB.
323 TAG is the expected node that should be found in IB, if TAG belongs
324 to one of the indexable trees, expect to read a reference index to
325 be looked up in one of the symbol tables, otherwise read the pysical
326 representation of the tree using lto_input_tree. FN is the
327 function scope for the read tree. */
328
329 static tree
330 lto_input_tree_ref (struct lto_input_block *ib, struct data_in *data_in,
331 struct function *fn, enum LTO_tags tag)
332 {
333 unsigned HOST_WIDE_INT ix_u;
334 tree result = NULL_TREE;
335
336 lto_tag_check_range (tag, LTO_field_decl_ref, LTO_global_decl_ref);
337
338 switch (tag)
339 {
340 case LTO_type_ref:
341 ix_u = lto_input_uleb128 (ib);
342 result = lto_file_decl_data_get_type (data_in->file_data, ix_u);
343 break;
344
345 case LTO_ssa_name_ref:
346 ix_u = lto_input_uleb128 (ib);
347 result = VEC_index (tree, SSANAMES (fn), ix_u);
348 break;
349
350 case LTO_field_decl_ref:
351 ix_u = lto_input_uleb128 (ib);
352 result = lto_file_decl_data_get_field_decl (data_in->file_data, ix_u);
353 break;
354
355 case LTO_function_decl_ref:
356 ix_u = lto_input_uleb128 (ib);
357 result = lto_file_decl_data_get_fn_decl (data_in->file_data, ix_u);
358 break;
359
360 case LTO_type_decl_ref:
361 ix_u = lto_input_uleb128 (ib);
362 result = lto_file_decl_data_get_type_decl (data_in->file_data, ix_u);
363 break;
364
365 case LTO_namespace_decl_ref:
366 ix_u = lto_input_uleb128 (ib);
367 result = lto_file_decl_data_get_namespace_decl (data_in->file_data, ix_u);
368 break;
369
370 case LTO_global_decl_ref:
371 case LTO_result_decl_ref:
372 case LTO_const_decl_ref:
373 case LTO_imported_decl_ref:
374 case LTO_label_decl_ref:
375 case LTO_translation_unit_decl_ref:
376 ix_u = lto_input_uleb128 (ib);
377 result = lto_file_decl_data_get_var_decl (data_in->file_data, ix_u);
378 break;
379
380 default:
381 gcc_unreachable ();
382 }
383
384 gcc_assert (result);
385
386 return result;
387 }
388
389
390 /* Read a chain of tree nodes from input block IB. DATA_IN contains
391 tables and descriptors for the file being read. */
392
393 static tree
394 lto_input_chain (struct lto_input_block *ib, struct data_in *data_in)
395 {
396 int i, count;
397 tree first, prev, curr;
398
399 first = prev = NULL_TREE;
400 count = lto_input_sleb128 (ib);
401 for (i = 0; i < count; i++)
402 {
403 curr = lto_input_tree (ib, data_in);
404 if (prev)
405 TREE_CHAIN (prev) = curr;
406 else
407 first = curr;
408
409 TREE_CHAIN (curr) = NULL_TREE;
410 prev = curr;
411 }
412
413 return first;
414 }
415
416
417 /* Read and return a double-linked list of catch handlers from input
418 block IB, using descriptors in DATA_IN. */
419
420 static struct eh_catch_d *
421 lto_input_eh_catch_list (struct lto_input_block *ib, struct data_in *data_in,
422 eh_catch *last_p)
423 {
424 eh_catch first;
425 enum LTO_tags tag;
426
427 *last_p = first = NULL;
428 tag = input_record_start (ib);
429 while (tag)
430 {
431 tree list;
432 eh_catch n;
433
434 lto_tag_check_range (tag, LTO_eh_catch, LTO_eh_catch);
435
436 /* Read the catch node. */
437 n = ggc_alloc_cleared_eh_catch_d ();
438 n->type_list = lto_input_tree (ib, data_in);
439 n->filter_list = lto_input_tree (ib, data_in);
440 n->label = lto_input_tree (ib, data_in);
441
442 /* Register all the types in N->FILTER_LIST. */
443 for (list = n->filter_list; list; list = TREE_CHAIN (list))
444 add_type_for_runtime (TREE_VALUE (list));
445
446 /* Chain N to the end of the list. */
447 if (*last_p)
448 (*last_p)->next_catch = n;
449 n->prev_catch = *last_p;
450 *last_p = n;
451
452 /* Set the head of the list the first time through the loop. */
453 if (first == NULL)
454 first = n;
455
456 tag = input_record_start (ib);
457 }
458
459 return first;
460 }
461
462
463 /* Read and return EH region IX from input block IB, using descriptors
464 in DATA_IN. */
465
466 static eh_region
467 input_eh_region (struct lto_input_block *ib, struct data_in *data_in, int ix)
468 {
469 enum LTO_tags tag;
470 eh_region r;
471
472 /* Read the region header. */
473 tag = input_record_start (ib);
474 if (tag == LTO_null)
475 return NULL;
476
477 r = ggc_alloc_cleared_eh_region_d ();
478 r->index = lto_input_sleb128 (ib);
479
480 gcc_assert (r->index == ix);
481
482 /* Read all the region pointers as region numbers. We'll fix up
483 the pointers once the whole array has been read. */
484 r->outer = (eh_region) (intptr_t) lto_input_sleb128 (ib);
485 r->inner = (eh_region) (intptr_t) lto_input_sleb128 (ib);
486 r->next_peer = (eh_region) (intptr_t) lto_input_sleb128 (ib);
487
488 switch (tag)
489 {
490 case LTO_ert_cleanup:
491 r->type = ERT_CLEANUP;
492 break;
493
494 case LTO_ert_try:
495 {
496 struct eh_catch_d *last_catch;
497 r->type = ERT_TRY;
498 r->u.eh_try.first_catch = lto_input_eh_catch_list (ib, data_in,
499 &last_catch);
500 r->u.eh_try.last_catch = last_catch;
501 break;
502 }
503
504 case LTO_ert_allowed_exceptions:
505 {
506 tree l;
507
508 r->type = ERT_ALLOWED_EXCEPTIONS;
509 r->u.allowed.type_list = lto_input_tree (ib, data_in);
510 r->u.allowed.label = lto_input_tree (ib, data_in);
511 r->u.allowed.filter = lto_input_uleb128 (ib);
512
513 for (l = r->u.allowed.type_list; l ; l = TREE_CHAIN (l))
514 add_type_for_runtime (TREE_VALUE (l));
515 }
516 break;
517
518 case LTO_ert_must_not_throw:
519 r->type = ERT_MUST_NOT_THROW;
520 r->u.must_not_throw.failure_decl = lto_input_tree (ib, data_in);
521 r->u.must_not_throw.failure_loc = lto_input_location (ib, data_in);
522 break;
523
524 default:
525 gcc_unreachable ();
526 }
527
528 r->landing_pads = (eh_landing_pad) (intptr_t) lto_input_sleb128 (ib);
529
530 return r;
531 }
532
533
534 /* Read and return EH landing pad IX from input block IB, using descriptors
535 in DATA_IN. */
536
537 static eh_landing_pad
538 input_eh_lp (struct lto_input_block *ib, struct data_in *data_in, int ix)
539 {
540 enum LTO_tags tag;
541 eh_landing_pad lp;
542
543 /* Read the landing pad header. */
544 tag = input_record_start (ib);
545 if (tag == LTO_null)
546 return NULL;
547
548 lto_tag_check_range (tag, LTO_eh_landing_pad, LTO_eh_landing_pad);
549
550 lp = ggc_alloc_cleared_eh_landing_pad_d ();
551 lp->index = lto_input_sleb128 (ib);
552 gcc_assert (lp->index == ix);
553 lp->next_lp = (eh_landing_pad) (intptr_t) lto_input_sleb128 (ib);
554 lp->region = (eh_region) (intptr_t) lto_input_sleb128 (ib);
555 lp->post_landing_pad = lto_input_tree (ib, data_in);
556
557 return lp;
558 }
559
560
561 /* After reading the EH regions, pointers to peer and children regions
562 are region numbers. This converts all these region numbers into
563 real pointers into the rematerialized regions for FN. ROOT_REGION
564 is the region number for the root EH region in FN. */
565
566 static void
567 fixup_eh_region_pointers (struct function *fn, HOST_WIDE_INT root_region)
568 {
569 unsigned i;
570 VEC(eh_region,gc) *eh_array = fn->eh->region_array;
571 VEC(eh_landing_pad,gc) *lp_array = fn->eh->lp_array;
572 eh_region r;
573 eh_landing_pad lp;
574
575 gcc_assert (eh_array && lp_array);
576
577 gcc_assert (root_region >= 0);
578 fn->eh->region_tree = VEC_index (eh_region, eh_array, root_region);
579
580 #define FIXUP_EH_REGION(r) (r) = VEC_index (eh_region, eh_array, \
581 (HOST_WIDE_INT) (intptr_t) (r))
582 #define FIXUP_EH_LP(p) (p) = VEC_index (eh_landing_pad, lp_array, \
583 (HOST_WIDE_INT) (intptr_t) (p))
584
585 /* Convert all the index numbers stored in pointer fields into
586 pointers to the corresponding slots in the EH region array. */
587 FOR_EACH_VEC_ELT (eh_region, eh_array, i, r)
588 {
589 /* The array may contain NULL regions. */
590 if (r == NULL)
591 continue;
592
593 gcc_assert (i == (unsigned) r->index);
594 FIXUP_EH_REGION (r->outer);
595 FIXUP_EH_REGION (r->inner);
596 FIXUP_EH_REGION (r->next_peer);
597 FIXUP_EH_LP (r->landing_pads);
598 }
599
600 /* Convert all the index numbers stored in pointer fields into
601 pointers to the corresponding slots in the EH landing pad array. */
602 FOR_EACH_VEC_ELT (eh_landing_pad, lp_array, i, lp)
603 {
604 /* The array may contain NULL landing pads. */
605 if (lp == NULL)
606 continue;
607
608 gcc_assert (i == (unsigned) lp->index);
609 FIXUP_EH_LP (lp->next_lp);
610 FIXUP_EH_REGION (lp->region);
611 }
612
613 #undef FIXUP_EH_REGION
614 #undef FIXUP_EH_LP
615 }
616
617
618 /* Initialize EH support. */
619
620 static void
621 lto_init_eh (void)
622 {
623 static bool eh_initialized_p = false;
624
625 if (eh_initialized_p)
626 return;
627
628 /* Contrary to most other FEs, we only initialize EH support when at
629 least one of the files in the set contains exception regions in
630 it. Since this happens much later than the call to init_eh in
631 lang_dependent_init, we have to set flag_exceptions and call
632 init_eh again to initialize the EH tables. */
633 flag_exceptions = 1;
634 init_eh ();
635
636 /* Initialize dwarf2 tables. Since dwarf2out_do_frame() returns
637 true only when exceptions are enabled, this initialization is
638 never done during lang_dependent_init. */
639 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
640 if (dwarf2out_do_frame ())
641 dwarf2out_frame_init ();
642 #endif
643
644 eh_initialized_p = true;
645 }
646
647
648 /* Read the exception table for FN from IB using the data descriptors
649 in DATA_IN. */
650
651 static void
652 input_eh_regions (struct lto_input_block *ib, struct data_in *data_in,
653 struct function *fn)
654 {
655 HOST_WIDE_INT i, root_region, len;
656 enum LTO_tags tag;
657
658 tag = input_record_start (ib);
659 if (tag == LTO_null)
660 return;
661
662 lto_tag_check_range (tag, LTO_eh_table, LTO_eh_table);
663
664 /* If the file contains EH regions, then it was compiled with
665 -fexceptions. In that case, initialize the backend EH
666 machinery. */
667 lto_init_eh ();
668
669 gcc_assert (fn->eh);
670
671 root_region = lto_input_sleb128 (ib);
672 gcc_assert (root_region == (int) root_region);
673
674 /* Read the EH region array. */
675 len = lto_input_sleb128 (ib);
676 gcc_assert (len == (int) len);
677 if (len > 0)
678 {
679 VEC_safe_grow (eh_region, gc, fn->eh->region_array, len);
680 for (i = 0; i < len; i++)
681 {
682 eh_region r = input_eh_region (ib, data_in, i);
683 VEC_replace (eh_region, fn->eh->region_array, i, r);
684 }
685 }
686
687 /* Read the landing pads. */
688 len = lto_input_sleb128 (ib);
689 gcc_assert (len == (int) len);
690 if (len > 0)
691 {
692 VEC_safe_grow (eh_landing_pad, gc, fn->eh->lp_array, len);
693 for (i = 0; i < len; i++)
694 {
695 eh_landing_pad lp = input_eh_lp (ib, data_in, i);
696 VEC_replace (eh_landing_pad, fn->eh->lp_array, i, lp);
697 }
698 }
699
700 /* Read the runtime type data. */
701 len = lto_input_sleb128 (ib);
702 gcc_assert (len == (int) len);
703 if (len > 0)
704 {
705 VEC_safe_grow (tree, gc, fn->eh->ttype_data, len);
706 for (i = 0; i < len; i++)
707 {
708 tree ttype = lto_input_tree (ib, data_in);
709 VEC_replace (tree, fn->eh->ttype_data, i, ttype);
710 }
711 }
712
713 /* Read the table of action chains. */
714 len = lto_input_sleb128 (ib);
715 gcc_assert (len == (int) len);
716 if (len > 0)
717 {
718 if (targetm.arm_eabi_unwinder)
719 {
720 VEC_safe_grow (tree, gc, fn->eh->ehspec_data.arm_eabi, len);
721 for (i = 0; i < len; i++)
722 {
723 tree t = lto_input_tree (ib, data_in);
724 VEC_replace (tree, fn->eh->ehspec_data.arm_eabi, i, t);
725 }
726 }
727 else
728 {
729 VEC_safe_grow (uchar, gc, fn->eh->ehspec_data.other, len);
730 for (i = 0; i < len; i++)
731 {
732 uchar c = lto_input_1_unsigned (ib);
733 VEC_replace (uchar, fn->eh->ehspec_data.other, i, c);
734 }
735 }
736 }
737
738 /* Reconstruct the EH region tree by fixing up the peer/children
739 pointers. */
740 fixup_eh_region_pointers (fn, root_region);
741
742 tag = input_record_start (ib);
743 lto_tag_check_range (tag, LTO_null, LTO_null);
744 }
745
746
747 /* Make a new basic block with index INDEX in function FN. */
748
749 static basic_block
750 make_new_block (struct function *fn, unsigned int index)
751 {
752 basic_block bb = alloc_block ();
753 bb->index = index;
754 SET_BASIC_BLOCK_FOR_FUNCTION (fn, index, bb);
755 bb->il.gimple = ggc_alloc_cleared_gimple_bb_info ();
756 n_basic_blocks_for_function (fn)++;
757 bb->flags = 0;
758 set_bb_seq (bb, gimple_seq_alloc ());
759 return bb;
760 }
761
762
763 /* Read the CFG for function FN from input block IB. */
764
765 static void
766 input_cfg (struct lto_input_block *ib, struct function *fn,
767 int count_materialization_scale)
768 {
769 unsigned int bb_count;
770 basic_block p_bb;
771 unsigned int i;
772 int index;
773
774 init_empty_tree_cfg_for_function (fn);
775 init_ssa_operands ();
776
777 profile_status_for_function (fn) =
778 (enum profile_status_d) lto_input_uleb128 (ib);
779
780 bb_count = lto_input_uleb128 (ib);
781
782 last_basic_block_for_function (fn) = bb_count;
783 if (bb_count > VEC_length (basic_block, basic_block_info_for_function (fn)))
784 VEC_safe_grow_cleared (basic_block, gc,
785 basic_block_info_for_function (fn), bb_count);
786
787 if (bb_count > VEC_length (basic_block, label_to_block_map_for_function (fn)))
788 VEC_safe_grow_cleared (basic_block, gc,
789 label_to_block_map_for_function (fn), bb_count);
790
791 index = lto_input_sleb128 (ib);
792 while (index != -1)
793 {
794 basic_block bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
795 unsigned int edge_count;
796
797 if (bb == NULL)
798 bb = make_new_block (fn, index);
799
800 edge_count = lto_input_uleb128 (ib);
801
802 /* Connect up the CFG. */
803 for (i = 0; i < edge_count; i++)
804 {
805 unsigned int dest_index;
806 unsigned int edge_flags;
807 basic_block dest;
808 int probability;
809 gcov_type count;
810 edge e;
811
812 dest_index = lto_input_uleb128 (ib);
813 probability = (int) lto_input_sleb128 (ib);
814 count = ((gcov_type) lto_input_sleb128 (ib) * count_materialization_scale
815 + REG_BR_PROB_BASE / 2) / REG_BR_PROB_BASE;
816 edge_flags = lto_input_uleb128 (ib);
817
818 dest = BASIC_BLOCK_FOR_FUNCTION (fn, dest_index);
819
820 if (dest == NULL)
821 dest = make_new_block (fn, dest_index);
822
823 e = make_edge (bb, dest, edge_flags);
824 e->probability = probability;
825 e->count = count;
826 }
827
828 index = lto_input_sleb128 (ib);
829 }
830
831 p_bb = ENTRY_BLOCK_PTR_FOR_FUNCTION(fn);
832 index = lto_input_sleb128 (ib);
833 while (index != -1)
834 {
835 basic_block bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
836 bb->prev_bb = p_bb;
837 p_bb->next_bb = bb;
838 p_bb = bb;
839 index = lto_input_sleb128 (ib);
840 }
841 }
842
843
844 /* Read a PHI function for basic block BB in function FN. DATA_IN is
845 the file being read. IB is the input block to use for reading. */
846
847 static gimple
848 input_phi (struct lto_input_block *ib, basic_block bb, struct data_in *data_in,
849 struct function *fn)
850 {
851 unsigned HOST_WIDE_INT ix;
852 tree phi_result;
853 int i, len;
854 gimple result;
855
856 ix = lto_input_uleb128 (ib);
857 phi_result = VEC_index (tree, SSANAMES (fn), ix);
858 len = EDGE_COUNT (bb->preds);
859 result = create_phi_node (phi_result, bb);
860 SSA_NAME_DEF_STMT (phi_result) = result;
861
862 /* We have to go through a lookup process here because the preds in the
863 reconstructed graph are generally in a different order than they
864 were in the original program. */
865 for (i = 0; i < len; i++)
866 {
867 tree def = lto_input_tree (ib, data_in);
868 int src_index = lto_input_uleb128 (ib);
869 location_t arg_loc = lto_input_location (ib, data_in);
870 basic_block sbb = BASIC_BLOCK_FOR_FUNCTION (fn, src_index);
871
872 edge e = NULL;
873 int j;
874
875 for (j = 0; j < len; j++)
876 if (EDGE_PRED (bb, j)->src == sbb)
877 {
878 e = EDGE_PRED (bb, j);
879 break;
880 }
881
882 add_phi_arg (result, def, e, arg_loc);
883 }
884
885 return result;
886 }
887
888
889 /* Read the SSA names array for function FN from DATA_IN using input
890 block IB. */
891
892 static void
893 input_ssa_names (struct lto_input_block *ib, struct data_in *data_in,
894 struct function *fn)
895 {
896 unsigned int i, size;
897
898 size = lto_input_uleb128 (ib);
899 init_ssanames (fn, size);
900
901 i = lto_input_uleb128 (ib);
902 while (i)
903 {
904 tree ssa_name, name;
905 bool is_default_def;
906
907 /* Skip over the elements that had been freed. */
908 while (VEC_length (tree, SSANAMES (fn)) < i)
909 VEC_quick_push (tree, SSANAMES (fn), NULL_TREE);
910
911 is_default_def = (lto_input_1_unsigned (ib) != 0);
912 name = lto_input_tree (ib, data_in);
913 ssa_name = make_ssa_name_fn (fn, name, gimple_build_nop ());
914
915 if (is_default_def)
916 set_default_def (SSA_NAME_VAR (ssa_name), ssa_name);
917
918 i = lto_input_uleb128 (ib);
919 }
920 }
921
922 /* Read a statement with tag TAG in function FN from block IB using
923 descriptors in DATA_IN. */
924
925 static gimple
926 input_gimple_stmt (struct lto_input_block *ib, struct data_in *data_in,
927 struct function *fn, enum LTO_tags tag)
928 {
929 gimple stmt;
930 enum gimple_code code;
931 unsigned HOST_WIDE_INT num_ops;
932 size_t i;
933 struct bitpack_d bp;
934
935 code = lto_tag_to_gimple_code (tag);
936
937 /* Read the tuple header. */
938 bp = lto_input_bitpack (ib);
939 num_ops = bp_unpack_value (&bp, sizeof (unsigned) * 8);
940 stmt = gimple_alloc (code, num_ops);
941 stmt->gsbase.no_warning = bp_unpack_value (&bp, 1);
942 if (is_gimple_assign (stmt))
943 stmt->gsbase.nontemporal_move = bp_unpack_value (&bp, 1);
944 stmt->gsbase.has_volatile_ops = bp_unpack_value (&bp, 1);
945 stmt->gsbase.subcode = bp_unpack_value (&bp, 16);
946
947 /* Read location information. */
948 gimple_set_location (stmt, lto_input_location (ib, data_in));
949
950 /* Read lexical block reference. */
951 gimple_set_block (stmt, lto_input_tree (ib, data_in));
952
953 /* Read in all the operands. */
954 switch (code)
955 {
956 case GIMPLE_RESX:
957 gimple_resx_set_region (stmt, lto_input_sleb128 (ib));
958 break;
959
960 case GIMPLE_EH_MUST_NOT_THROW:
961 gimple_eh_must_not_throw_set_fndecl (stmt, lto_input_tree (ib, data_in));
962 break;
963
964 case GIMPLE_EH_DISPATCH:
965 gimple_eh_dispatch_set_region (stmt, lto_input_sleb128 (ib));
966 break;
967
968 case GIMPLE_ASM:
969 {
970 /* FIXME lto. Move most of this into a new gimple_asm_set_string(). */
971 tree str;
972 stmt->gimple_asm.ni = lto_input_uleb128 (ib);
973 stmt->gimple_asm.no = lto_input_uleb128 (ib);
974 stmt->gimple_asm.nc = lto_input_uleb128 (ib);
975 stmt->gimple_asm.nl = lto_input_uleb128 (ib);
976 str = input_string_cst (data_in, ib);
977 stmt->gimple_asm.string = TREE_STRING_POINTER (str);
978 }
979 /* Fallthru */
980
981 case GIMPLE_ASSIGN:
982 case GIMPLE_CALL:
983 case GIMPLE_RETURN:
984 case GIMPLE_SWITCH:
985 case GIMPLE_LABEL:
986 case GIMPLE_COND:
987 case GIMPLE_GOTO:
988 case GIMPLE_DEBUG:
989 for (i = 0; i < num_ops; i++)
990 {
991 tree op = lto_input_tree (ib, data_in);
992 gimple_set_op (stmt, i, op);
993 if (!op)
994 continue;
995
996 /* Fixup FIELD_DECLs in COMPONENT_REFs, they are not handled
997 by decl merging. */
998 if (TREE_CODE (op) == ADDR_EXPR)
999 op = TREE_OPERAND (op, 0);
1000 while (handled_component_p (op))
1001 {
1002 if (TREE_CODE (op) == COMPONENT_REF)
1003 {
1004 tree field, type, tem;
1005 tree closest_match = NULL_TREE;
1006 field = TREE_OPERAND (op, 1);
1007 type = DECL_CONTEXT (field);
1008 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1009 {
1010 if (tem == field)
1011 break;
1012 if (DECL_NONADDRESSABLE_P (tem)
1013 == DECL_NONADDRESSABLE_P (field)
1014 && gimple_compare_field_offset (tem, field))
1015 {
1016 if (types_compatible_p (TREE_TYPE (tem),
1017 TREE_TYPE (field)))
1018 break;
1019 else
1020 closest_match = tem;
1021 }
1022 }
1023 /* In case of type mismatches across units we can fail
1024 to unify some types and thus not find a proper
1025 field-decl here. */
1026 if (tem == NULL_TREE)
1027 {
1028 /* Thus, emit a ODR violation warning. */
1029 if (warning_at (gimple_location (stmt), 0,
1030 "use of type %<%E%> with two mismatching "
1031 "declarations at field %<%E%>",
1032 type, TREE_OPERAND (op, 1)))
1033 {
1034 if (TYPE_FIELDS (type))
1035 inform (DECL_SOURCE_LOCATION (TYPE_FIELDS (type)),
1036 "original type declared here");
1037 inform (DECL_SOURCE_LOCATION (TREE_OPERAND (op, 1)),
1038 "field in mismatching type declared here");
1039 if (TYPE_NAME (TREE_TYPE (field))
1040 && (TREE_CODE (TYPE_NAME (TREE_TYPE (field)))
1041 == TYPE_DECL))
1042 inform (DECL_SOURCE_LOCATION
1043 (TYPE_NAME (TREE_TYPE (field))),
1044 "type of field declared here");
1045 if (closest_match
1046 && TYPE_NAME (TREE_TYPE (closest_match))
1047 && (TREE_CODE (TYPE_NAME
1048 (TREE_TYPE (closest_match))) == TYPE_DECL))
1049 inform (DECL_SOURCE_LOCATION
1050 (TYPE_NAME (TREE_TYPE (closest_match))),
1051 "type of mismatching field declared here");
1052 }
1053 /* And finally fixup the types. */
1054 TREE_OPERAND (op, 0)
1055 = build1 (VIEW_CONVERT_EXPR, type,
1056 TREE_OPERAND (op, 0));
1057 }
1058 else
1059 TREE_OPERAND (op, 1) = tem;
1060 }
1061
1062 op = TREE_OPERAND (op, 0);
1063 }
1064 }
1065 if (is_gimple_call (stmt))
1066 gimple_call_set_fntype (stmt, lto_input_tree (ib, data_in));
1067 break;
1068
1069 case GIMPLE_NOP:
1070 case GIMPLE_PREDICT:
1071 break;
1072
1073 default:
1074 internal_error ("bytecode stream: unknown GIMPLE statement tag %s",
1075 lto_tag_name (tag));
1076 }
1077
1078 /* Update the properties of symbols, SSA names and labels associated
1079 with STMT. */
1080 if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
1081 {
1082 tree lhs = gimple_get_lhs (stmt);
1083 if (lhs && TREE_CODE (lhs) == SSA_NAME)
1084 SSA_NAME_DEF_STMT (lhs) = stmt;
1085 }
1086 else if (code == GIMPLE_LABEL)
1087 gcc_assert (emit_label_in_global_context_p (gimple_label_label (stmt))
1088 || DECL_CONTEXT (gimple_label_label (stmt)) == fn->decl);
1089 else if (code == GIMPLE_ASM)
1090 {
1091 unsigned i;
1092
1093 for (i = 0; i < gimple_asm_noutputs (stmt); i++)
1094 {
1095 tree op = TREE_VALUE (gimple_asm_output_op (stmt, i));
1096 if (TREE_CODE (op) == SSA_NAME)
1097 SSA_NAME_DEF_STMT (op) = stmt;
1098 }
1099 }
1100
1101 /* Reset alias information. */
1102 if (code == GIMPLE_CALL)
1103 gimple_call_reset_alias_info (stmt);
1104
1105 /* Mark the statement modified so its operand vectors can be filled in. */
1106 gimple_set_modified (stmt, true);
1107
1108 return stmt;
1109 }
1110
1111
1112 /* Read a basic block with tag TAG from DATA_IN using input block IB.
1113 FN is the function being processed. */
1114
1115 static void
1116 input_bb (struct lto_input_block *ib, enum LTO_tags tag,
1117 struct data_in *data_in, struct function *fn,
1118 int count_materialization_scale)
1119 {
1120 unsigned int index;
1121 basic_block bb;
1122 gimple_stmt_iterator bsi;
1123
1124 /* This routine assumes that CFUN is set to FN, as it needs to call
1125 basic GIMPLE routines that use CFUN. */
1126 gcc_assert (cfun == fn);
1127
1128 index = lto_input_uleb128 (ib);
1129 bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
1130
1131 bb->count = (lto_input_sleb128 (ib) * count_materialization_scale
1132 + REG_BR_PROB_BASE / 2) / REG_BR_PROB_BASE;
1133 bb->loop_depth = lto_input_sleb128 (ib);
1134 bb->frequency = lto_input_sleb128 (ib);
1135 bb->flags = lto_input_sleb128 (ib);
1136
1137 /* LTO_bb1 has statements. LTO_bb0 does not. */
1138 if (tag == LTO_bb0)
1139 return;
1140
1141 bsi = gsi_start_bb (bb);
1142 tag = input_record_start (ib);
1143 while (tag)
1144 {
1145 gimple stmt = input_gimple_stmt (ib, data_in, fn, tag);
1146 if (!is_gimple_debug (stmt))
1147 find_referenced_vars_in (stmt);
1148 gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
1149
1150 /* After the statement, expect a 0 delimiter or the EH region
1151 that the previous statement belongs to. */
1152 tag = input_record_start (ib);
1153 lto_tag_check_set (tag, 2, LTO_eh_region, LTO_null);
1154
1155 if (tag == LTO_eh_region)
1156 {
1157 HOST_WIDE_INT region = lto_input_sleb128 (ib);
1158 gcc_assert (region == (int) region);
1159 add_stmt_to_eh_lp (stmt, region);
1160 }
1161
1162 tag = input_record_start (ib);
1163 }
1164
1165 tag = input_record_start (ib);
1166 while (tag)
1167 {
1168 gimple phi = input_phi (ib, bb, data_in, fn);
1169 find_referenced_vars_in (phi);
1170 tag = input_record_start (ib);
1171 }
1172 }
1173
1174 /* Go through all NODE edges and fixup call_stmt pointers
1175 so they point to STMTS. */
1176
1177 static void
1178 fixup_call_stmt_edges_1 (struct cgraph_node *node, gimple *stmts)
1179 {
1180 struct cgraph_edge *cedge;
1181 for (cedge = node->callees; cedge; cedge = cedge->next_callee)
1182 cedge->call_stmt = stmts[cedge->lto_stmt_uid];
1183 for (cedge = node->indirect_calls; cedge; cedge = cedge->next_callee)
1184 cedge->call_stmt = stmts[cedge->lto_stmt_uid];
1185 }
1186
1187 /* Fixup call_stmt pointers in NODE and all clones. */
1188
1189 static void
1190 fixup_call_stmt_edges (struct cgraph_node *orig, gimple *stmts)
1191 {
1192 struct cgraph_node *node;
1193
1194 while (orig->clone_of)
1195 orig = orig->clone_of;
1196
1197 fixup_call_stmt_edges_1 (orig, stmts);
1198 if (orig->clones)
1199 for (node = orig->clones; node != orig;)
1200 {
1201 fixup_call_stmt_edges_1 (node, stmts);
1202 if (node->clones)
1203 node = node->clones;
1204 else if (node->next_sibling_clone)
1205 node = node->next_sibling_clone;
1206 else
1207 {
1208 while (node != orig && !node->next_sibling_clone)
1209 node = node->clone_of;
1210 if (node != orig)
1211 node = node->next_sibling_clone;
1212 }
1213 }
1214 }
1215
1216 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1217
1218 static void
1219 input_function (tree fn_decl, struct data_in *data_in,
1220 struct lto_input_block *ib)
1221 {
1222 struct function *fn;
1223 enum LTO_tags tag;
1224 gimple *stmts;
1225 basic_block bb;
1226 struct bitpack_d bp;
1227 struct cgraph_node *node;
1228 tree args, narg, oarg;
1229 int len;
1230
1231 fn = DECL_STRUCT_FUNCTION (fn_decl);
1232 tag = input_record_start (ib);
1233 clear_line_info (data_in);
1234
1235 gimple_register_cfg_hooks ();
1236 lto_tag_check (tag, LTO_function);
1237
1238 /* Read all the attributes for FN. */
1239 bp = lto_input_bitpack (ib);
1240 fn->is_thunk = bp_unpack_value (&bp, 1);
1241 fn->has_local_explicit_reg_vars = bp_unpack_value (&bp, 1);
1242 fn->after_tree_profile = bp_unpack_value (&bp, 1);
1243 fn->returns_pcc_struct = bp_unpack_value (&bp, 1);
1244 fn->returns_struct = bp_unpack_value (&bp, 1);
1245 fn->can_throw_non_call_exceptions = bp_unpack_value (&bp, 1);
1246 fn->always_inline_functions_inlined = bp_unpack_value (&bp, 1);
1247 fn->after_inlining = bp_unpack_value (&bp, 1);
1248 fn->dont_save_pending_sizes_p = bp_unpack_value (&bp, 1);
1249 fn->stdarg = bp_unpack_value (&bp, 1);
1250 fn->has_nonlocal_label = bp_unpack_value (&bp, 1);
1251 fn->calls_alloca = bp_unpack_value (&bp, 1);
1252 fn->calls_setjmp = bp_unpack_value (&bp, 1);
1253 fn->va_list_fpr_size = bp_unpack_value (&bp, 8);
1254 fn->va_list_gpr_size = bp_unpack_value (&bp, 8);
1255
1256 /* Input the function start and end loci. */
1257 fn->function_start_locus = lto_input_location (ib, data_in);
1258 fn->function_end_locus = lto_input_location (ib, data_in);
1259
1260 /* Input the current IL state of the function. */
1261 fn->curr_properties = lto_input_uleb128 (ib);
1262
1263 /* Read the static chain and non-local goto save area. */
1264 fn->static_chain_decl = lto_input_tree (ib, data_in);
1265 fn->nonlocal_goto_save_area = lto_input_tree (ib, data_in);
1266
1267 /* Read all the local symbols. */
1268 len = lto_input_sleb128 (ib);
1269 if (len > 0)
1270 {
1271 int i;
1272 VEC_safe_grow (tree, gc, fn->local_decls, len);
1273 for (i = 0; i < len; i++)
1274 {
1275 tree t = lto_input_tree (ib, data_in);
1276 VEC_replace (tree, fn->local_decls, i, t);
1277 }
1278 }
1279
1280 /* Read all function arguments. We need to re-map them here to the
1281 arguments of the merged function declaration. */
1282 args = lto_input_tree (ib, data_in);
1283 for (oarg = args, narg = DECL_ARGUMENTS (fn_decl);
1284 oarg && narg;
1285 oarg = TREE_CHAIN (oarg), narg = TREE_CHAIN (narg))
1286 {
1287 unsigned ix;
1288 bool res;
1289 res = lto_streamer_cache_lookup (data_in->reader_cache, oarg, &ix);
1290 gcc_assert (res);
1291 /* Replace the argument in the streamer cache. */
1292 lto_streamer_cache_insert_at (data_in->reader_cache, narg, ix);
1293 }
1294 gcc_assert (!oarg && !narg);
1295
1296 /* Read all the SSA names. */
1297 input_ssa_names (ib, data_in, fn);
1298
1299 /* Read the exception handling regions in the function. */
1300 input_eh_regions (ib, data_in, fn);
1301
1302 /* Read the tree of lexical scopes for the function. */
1303 DECL_INITIAL (fn_decl) = lto_input_tree (ib, data_in);
1304 gcc_assert (DECL_INITIAL (fn_decl));
1305 DECL_SAVED_TREE (fn_decl) = NULL_TREE;
1306 node = cgraph_get_create_node (fn_decl);
1307
1308 /* Read all the basic blocks. */
1309 tag = input_record_start (ib);
1310 while (tag)
1311 {
1312 input_bb (ib, tag, data_in, fn,
1313 node->count_materialization_scale);
1314 tag = input_record_start (ib);
1315 }
1316
1317 /* Fix up the call statements that are mentioned in the callgraph
1318 edges. */
1319 set_gimple_stmt_max_uid (cfun, 0);
1320 FOR_ALL_BB (bb)
1321 {
1322 gimple_stmt_iterator gsi;
1323 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1324 {
1325 gimple stmt = gsi_stmt (gsi);
1326 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
1327 }
1328 }
1329 stmts = (gimple *) xcalloc (gimple_stmt_max_uid (fn), sizeof (gimple));
1330 FOR_ALL_BB (bb)
1331 {
1332 gimple_stmt_iterator bsi = gsi_start_bb (bb);
1333 while (!gsi_end_p (bsi))
1334 {
1335 gimple stmt = gsi_stmt (bsi);
1336 /* If we're recompiling LTO objects with debug stmts but
1337 we're not supposed to have debug stmts, remove them now.
1338 We can't remove them earlier because this would cause uid
1339 mismatches in fixups, but we can do it at this point, as
1340 long as debug stmts don't require fixups. */
1341 if (!MAY_HAVE_DEBUG_STMTS && is_gimple_debug (stmt))
1342 {
1343 gimple_stmt_iterator gsi = bsi;
1344 gsi_next (&bsi);
1345 gsi_remove (&gsi, true);
1346 }
1347 else
1348 {
1349 gsi_next (&bsi);
1350 stmts[gimple_uid (stmt)] = stmt;
1351 }
1352 }
1353 }
1354
1355 /* Set the gimple body to the statement sequence in the entry
1356 basic block. FIXME lto, this is fairly hacky. The existence
1357 of a gimple body is used by the cgraph routines, but we should
1358 really use the presence of the CFG. */
1359 {
1360 edge_iterator ei = ei_start (ENTRY_BLOCK_PTR->succs);
1361 gimple_set_body (fn_decl, bb_seq (ei_edge (ei)->dest));
1362 }
1363
1364 fixup_call_stmt_edges (node, stmts);
1365 execute_all_ipa_stmt_fixups (node, stmts);
1366
1367 update_ssa (TODO_update_ssa_only_virtuals);
1368 free_dominance_info (CDI_DOMINATORS);
1369 free_dominance_info (CDI_POST_DOMINATORS);
1370 free (stmts);
1371 }
1372
1373
1374 /* Read initializer expressions for public statics. DATA_IN is the
1375 file being read. IB is the input block used for reading. */
1376
1377 static void
1378 input_alias_pairs (struct lto_input_block *ib, struct data_in *data_in)
1379 {
1380 tree var;
1381
1382 clear_line_info (data_in);
1383
1384 var = lto_input_tree (ib, data_in);
1385 while (var)
1386 {
1387 const char *orig_name, *new_name;
1388 alias_pair *p;
1389
1390 p = VEC_safe_push (alias_pair, gc, alias_pairs, NULL);
1391 p->decl = var;
1392 p->target = lto_input_tree (ib, data_in);
1393
1394 /* If the target is a static object, we may have registered a
1395 new name for it to avoid clashes between statics coming from
1396 different files. In that case, use the new name. */
1397 orig_name = IDENTIFIER_POINTER (p->target);
1398 new_name = lto_get_decl_name_mapping (data_in->file_data, orig_name);
1399 if (strcmp (orig_name, new_name) != 0)
1400 p->target = get_identifier (new_name);
1401
1402 var = lto_input_tree (ib, data_in);
1403 }
1404 }
1405
1406
1407 /* Read the body from DATA for function FN_DECL and fill it in.
1408 FILE_DATA are the global decls and types. SECTION_TYPE is either
1409 LTO_section_function_body or LTO_section_static_initializer. If
1410 section type is LTO_section_function_body, FN must be the decl for
1411 that function. */
1412
1413 static void
1414 lto_read_body (struct lto_file_decl_data *file_data, tree fn_decl,
1415 const char *data, enum lto_section_type section_type)
1416 {
1417 const struct lto_function_header *header;
1418 struct data_in *data_in;
1419 int32_t cfg_offset;
1420 int32_t main_offset;
1421 int32_t string_offset;
1422 struct lto_input_block ib_cfg;
1423 struct lto_input_block ib_main;
1424
1425 header = (const struct lto_function_header *) data;
1426 cfg_offset = sizeof (struct lto_function_header);
1427 main_offset = cfg_offset + header->cfg_size;
1428 string_offset = main_offset + header->main_size;
1429
1430 LTO_INIT_INPUT_BLOCK (ib_cfg,
1431 data + cfg_offset,
1432 0,
1433 header->cfg_size);
1434
1435 LTO_INIT_INPUT_BLOCK (ib_main,
1436 data + main_offset,
1437 0,
1438 header->main_size);
1439
1440 data_in = lto_data_in_create (file_data, data + string_offset,
1441 header->string_size, NULL);
1442
1443 /* Make sure the file was generated by the exact same compiler. */
1444 lto_check_version (header->lto_header.major_version,
1445 header->lto_header.minor_version);
1446
1447 if (section_type == LTO_section_function_body)
1448 {
1449 struct function *fn = DECL_STRUCT_FUNCTION (fn_decl);
1450 struct lto_in_decl_state *decl_state;
1451 struct cgraph_node *node = cgraph_get_node (fn_decl);
1452
1453 gcc_checking_assert (node);
1454 push_cfun (fn);
1455 init_tree_ssa (fn);
1456
1457 /* Use the function's decl state. */
1458 decl_state = lto_get_function_in_decl_state (file_data, fn_decl);
1459 gcc_assert (decl_state);
1460 file_data->current_decl_state = decl_state;
1461
1462 input_cfg (&ib_cfg, fn, node->count_materialization_scale);
1463
1464 /* Set up the struct function. */
1465 input_function (fn_decl, data_in, &ib_main);
1466
1467 /* We should now be in SSA. */
1468 cfun->gimple_df->in_ssa_p = true;
1469
1470 /* Restore decl state */
1471 file_data->current_decl_state = file_data->global_decl_state;
1472
1473 pop_cfun ();
1474 }
1475 else
1476 {
1477 input_alias_pairs (&ib_main, data_in);
1478 }
1479
1480 clear_line_info (data_in);
1481 lto_data_in_delete (data_in);
1482 }
1483
1484
1485 /* Read the body of FN_DECL using DATA. FILE_DATA holds the global
1486 decls and types. */
1487
1488 void
1489 lto_input_function_body (struct lto_file_decl_data *file_data,
1490 tree fn_decl, const char *data)
1491 {
1492 current_function_decl = fn_decl;
1493 lto_read_body (file_data, fn_decl, data, LTO_section_function_body);
1494 }
1495
1496
1497 /* Read in VAR_DECL using DATA. FILE_DATA holds the global decls and
1498 types. */
1499
1500 void
1501 lto_input_constructors_and_inits (struct lto_file_decl_data *file_data,
1502 const char *data)
1503 {
1504 lto_read_body (file_data, NULL, data, LTO_section_static_initializer);
1505 }
1506
1507
1508 /* Return the resolution for the decl with index INDEX from DATA_IN. */
1509
1510 static enum ld_plugin_symbol_resolution
1511 get_resolution (struct data_in *data_in, unsigned index)
1512 {
1513 if (data_in->globals_resolution)
1514 {
1515 ld_plugin_symbol_resolution_t ret;
1516 /* We can have references to not emitted functions in
1517 DECL_FUNCTION_PERSONALITY at least. So we can and have
1518 to indeed return LDPR_UNKNOWN in some cases. */
1519 if (VEC_length (ld_plugin_symbol_resolution_t,
1520 data_in->globals_resolution) <= index)
1521 return LDPR_UNKNOWN;
1522 ret = VEC_index (ld_plugin_symbol_resolution_t,
1523 data_in->globals_resolution,
1524 index);
1525 return ret;
1526 }
1527 else
1528 /* Delay resolution finding until decl merging. */
1529 return LDPR_UNKNOWN;
1530 }
1531
1532
1533 /* Unpack all the non-pointer fields of the TS_BASE structure of
1534 expression EXPR from bitpack BP. */
1535
1536 static void
1537 unpack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
1538 {
1539 /* Note that the code for EXPR has already been unpacked to create EXPR in
1540 lto_materialize_tree. */
1541 if (!TYPE_P (expr))
1542 {
1543 TREE_SIDE_EFFECTS (expr) = (unsigned) bp_unpack_value (bp, 1);
1544 TREE_CONSTANT (expr) = (unsigned) bp_unpack_value (bp, 1);
1545 TREE_READONLY (expr) = (unsigned) bp_unpack_value (bp, 1);
1546
1547 /* TREE_PUBLIC is used on types to indicate that the type
1548 has a TYPE_CACHED_VALUES vector. This is not streamed out,
1549 so we skip it here. */
1550 TREE_PUBLIC (expr) = (unsigned) bp_unpack_value (bp, 1);
1551 }
1552 else
1553 bp_unpack_value (bp, 4);
1554 TREE_ADDRESSABLE (expr) = (unsigned) bp_unpack_value (bp, 1);
1555 TREE_THIS_VOLATILE (expr) = (unsigned) bp_unpack_value (bp, 1);
1556 if (DECL_P (expr))
1557 DECL_UNSIGNED (expr) = (unsigned) bp_unpack_value (bp, 1);
1558 else if (TYPE_P (expr))
1559 TYPE_UNSIGNED (expr) = (unsigned) bp_unpack_value (bp, 1);
1560 else
1561 bp_unpack_value (bp, 1);
1562 TREE_ASM_WRITTEN (expr) = (unsigned) bp_unpack_value (bp, 1);
1563 TREE_NO_WARNING (expr) = (unsigned) bp_unpack_value (bp, 1);
1564 TREE_USED (expr) = (unsigned) bp_unpack_value (bp, 1);
1565 TREE_NOTHROW (expr) = (unsigned) bp_unpack_value (bp, 1);
1566 TREE_STATIC (expr) = (unsigned) bp_unpack_value (bp, 1);
1567 TREE_PRIVATE (expr) = (unsigned) bp_unpack_value (bp, 1);
1568 TREE_PROTECTED (expr) = (unsigned) bp_unpack_value (bp, 1);
1569 TREE_DEPRECATED (expr) = (unsigned) bp_unpack_value (bp, 1);
1570 if (TYPE_P (expr))
1571 TYPE_SATURATING (expr) = (unsigned) bp_unpack_value (bp, 1);
1572 else if (TREE_CODE (expr) == SSA_NAME)
1573 SSA_NAME_IS_DEFAULT_DEF (expr) = (unsigned) bp_unpack_value (bp, 1);
1574 else
1575 bp_unpack_value (bp, 1);
1576 }
1577
1578
1579 /* Unpack all the non-pointer fields of the TS_REAL_CST structure of
1580 expression EXPR from bitpack BP. */
1581
1582 static void
1583 unpack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
1584 {
1585 unsigned i;
1586 REAL_VALUE_TYPE r;
1587 REAL_VALUE_TYPE *rp;
1588
1589 r.cl = (unsigned) bp_unpack_value (bp, 2);
1590 r.decimal = (unsigned) bp_unpack_value (bp, 1);
1591 r.sign = (unsigned) bp_unpack_value (bp, 1);
1592 r.signalling = (unsigned) bp_unpack_value (bp, 1);
1593 r.canonical = (unsigned) bp_unpack_value (bp, 1);
1594 r.uexp = (unsigned) bp_unpack_value (bp, EXP_BITS);
1595 for (i = 0; i < SIGSZ; i++)
1596 r.sig[i] = (unsigned long) bp_unpack_value (bp, HOST_BITS_PER_LONG);
1597
1598 rp = ggc_alloc_real_value ();
1599 memcpy (rp, &r, sizeof (REAL_VALUE_TYPE));
1600 TREE_REAL_CST_PTR (expr) = rp;
1601 }
1602
1603
1604 /* Unpack all the non-pointer fields of the TS_FIXED_CST structure of
1605 expression EXPR from bitpack BP. */
1606
1607 static void
1608 unpack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr)
1609 {
1610 struct fixed_value fv;
1611
1612 fv.data.low = (HOST_WIDE_INT) bp_unpack_value (bp, HOST_BITS_PER_WIDE_INT);
1613 fv.data.high = (HOST_WIDE_INT) bp_unpack_value (bp, HOST_BITS_PER_WIDE_INT);
1614 fv.mode = (enum machine_mode) bp_unpack_value (bp, HOST_BITS_PER_INT);
1615 TREE_FIXED_CST (expr) = fv;
1616 }
1617
1618
1619 /* Unpack all the non-pointer fields of the TS_DECL_COMMON structure
1620 of expression EXPR from bitpack BP. */
1621
1622 static void
1623 unpack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr)
1624 {
1625 DECL_MODE (expr) = (enum machine_mode) bp_unpack_value (bp, 8);
1626 DECL_NONLOCAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1627 DECL_VIRTUAL_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1628 DECL_IGNORED_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1629 DECL_ABSTRACT (expr) = (unsigned) bp_unpack_value (bp, 1);
1630 DECL_ARTIFICIAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1631 DECL_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1);
1632 DECL_PRESERVE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1633 DECL_DEBUG_EXPR_IS_FROM (expr) = (unsigned) bp_unpack_value (bp, 1);
1634 DECL_EXTERNAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1635 DECL_GIMPLE_REG_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1636 DECL_ALIGN (expr) = (unsigned) bp_unpack_value (bp, HOST_BITS_PER_INT);
1637
1638 if (TREE_CODE (expr) == LABEL_DECL)
1639 {
1640 DECL_ERROR_ISSUED (expr) = (unsigned) bp_unpack_value (bp, 1);
1641 EH_LANDING_PAD_NR (expr) = (int) bp_unpack_value (bp, HOST_BITS_PER_INT);
1642
1643 /* Always assume an initial value of -1 for LABEL_DECL_UID to
1644 force gimple_set_bb to recreate label_to_block_map. */
1645 LABEL_DECL_UID (expr) = -1;
1646 }
1647
1648 if (TREE_CODE (expr) == FIELD_DECL)
1649 {
1650 unsigned HOST_WIDE_INT off_align;
1651 DECL_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
1652 DECL_NONADDRESSABLE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1653 off_align = (unsigned HOST_WIDE_INT) bp_unpack_value (bp, 8);
1654 SET_DECL_OFFSET_ALIGN (expr, off_align);
1655 }
1656
1657 if (TREE_CODE (expr) == RESULT_DECL
1658 || TREE_CODE (expr) == PARM_DECL
1659 || TREE_CODE (expr) == VAR_DECL)
1660 {
1661 DECL_BY_REFERENCE (expr) = (unsigned) bp_unpack_value (bp, 1);
1662 if (TREE_CODE (expr) == VAR_DECL
1663 || TREE_CODE (expr) == PARM_DECL)
1664 DECL_HAS_VALUE_EXPR_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1665 DECL_RESTRICTED_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1666 }
1667 }
1668
1669
1670 /* Unpack all the non-pointer fields of the TS_DECL_WRTL structure
1671 of expression EXPR from bitpack BP. */
1672
1673 static void
1674 unpack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
1675 {
1676 DECL_REGISTER (expr) = (unsigned) bp_unpack_value (bp, 1);
1677 }
1678
1679
1680 /* Unpack all the non-pointer fields of the TS_DECL_WITH_VIS structure
1681 of expression EXPR from bitpack BP. */
1682
1683 static void
1684 unpack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
1685 {
1686 DECL_DEFER_OUTPUT (expr) = (unsigned) bp_unpack_value (bp, 1);
1687 DECL_COMMON (expr) = (unsigned) bp_unpack_value (bp, 1);
1688 DECL_DLLIMPORT_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1689 DECL_WEAK (expr) = (unsigned) bp_unpack_value (bp, 1);
1690 DECL_SEEN_IN_BIND_EXPR_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1691 DECL_COMDAT (expr) = (unsigned) bp_unpack_value (bp, 1);
1692 DECL_VISIBILITY (expr) = (enum symbol_visibility) bp_unpack_value (bp, 2);
1693 DECL_VISIBILITY_SPECIFIED (expr) = (unsigned) bp_unpack_value (bp, 1);
1694
1695 if (TREE_CODE (expr) == VAR_DECL)
1696 {
1697 DECL_HARD_REGISTER (expr) = (unsigned) bp_unpack_value (bp, 1);
1698 DECL_IN_TEXT_SECTION (expr) = (unsigned) bp_unpack_value (bp, 1);
1699 DECL_IN_CONSTANT_POOL (expr) = (unsigned) bp_unpack_value (bp, 1);
1700 DECL_TLS_MODEL (expr) = (enum tls_model) bp_unpack_value (bp, 3);
1701 }
1702
1703 if (VAR_OR_FUNCTION_DECL_P (expr))
1704 {
1705 priority_type p;
1706 p = (priority_type) bp_unpack_value (bp, HOST_BITS_PER_SHORT);
1707 SET_DECL_INIT_PRIORITY (expr, p);
1708 }
1709 }
1710
1711
1712 /* Unpack all the non-pointer fields of the TS_FUNCTION_DECL structure
1713 of expression EXPR from bitpack BP. */
1714
1715 static void
1716 unpack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
1717 {
1718 DECL_FUNCTION_CODE (expr) = (enum built_in_function) bp_unpack_value (bp, 11);
1719 DECL_BUILT_IN_CLASS (expr) = (enum built_in_class) bp_unpack_value (bp, 2);
1720 DECL_STATIC_CONSTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
1721 DECL_STATIC_DESTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
1722 DECL_UNINLINABLE (expr) = (unsigned) bp_unpack_value (bp, 1);
1723 DECL_POSSIBLY_INLINED (expr) = (unsigned) bp_unpack_value (bp, 1);
1724 DECL_IS_NOVOPS (expr) = (unsigned) bp_unpack_value (bp, 1);
1725 DECL_IS_RETURNS_TWICE (expr) = (unsigned) bp_unpack_value (bp, 1);
1726 DECL_IS_MALLOC (expr) = (unsigned) bp_unpack_value (bp, 1);
1727 DECL_IS_OPERATOR_NEW (expr) = (unsigned) bp_unpack_value (bp, 1);
1728 DECL_DECLARED_INLINE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1729 DECL_STATIC_CHAIN (expr) = (unsigned) bp_unpack_value (bp, 1);
1730 DECL_NO_INLINE_WARNING_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1731 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr)
1732 = (unsigned) bp_unpack_value (bp, 1);
1733 DECL_NO_LIMIT_STACK (expr) = (unsigned) bp_unpack_value (bp, 1);
1734 DECL_DISREGARD_INLINE_LIMITS (expr) = (unsigned) bp_unpack_value (bp, 1);
1735 DECL_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1736 DECL_LOOPING_CONST_OR_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1737 if (DECL_STATIC_DESTRUCTOR (expr))
1738 {
1739 priority_type p = (priority_type) bp_unpack_value (bp, HOST_BITS_PER_SHORT);
1740 SET_DECL_FINI_PRIORITY (expr, p);
1741 }
1742 }
1743
1744
1745 /* Unpack all the non-pointer fields of the TS_TYPE structure
1746 of expression EXPR from bitpack BP. */
1747
1748 static void
1749 unpack_ts_type_value_fields (struct bitpack_d *bp, tree expr)
1750 {
1751 enum machine_mode mode;
1752
1753 TYPE_PRECISION (expr) = (unsigned) bp_unpack_value (bp, 10);
1754 mode = (enum machine_mode) bp_unpack_value (bp, 8);
1755 SET_TYPE_MODE (expr, mode);
1756 TYPE_STRING_FLAG (expr) = (unsigned) bp_unpack_value (bp, 1);
1757 TYPE_NO_FORCE_BLK (expr) = (unsigned) bp_unpack_value (bp, 1);
1758 TYPE_NEEDS_CONSTRUCTING (expr) = (unsigned) bp_unpack_value (bp, 1);
1759 if (RECORD_OR_UNION_TYPE_P (expr))
1760 TYPE_TRANSPARENT_AGGR (expr) = (unsigned) bp_unpack_value (bp, 1);
1761 TYPE_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
1762 TYPE_RESTRICT (expr) = (unsigned) bp_unpack_value (bp, 1);
1763 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr)
1764 = (unsigned) bp_unpack_value (bp, 2);
1765 TYPE_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1);
1766 TYPE_READONLY (expr) = (unsigned) bp_unpack_value (bp, 1);
1767 TYPE_ALIGN (expr) = (unsigned) bp_unpack_value (bp, HOST_BITS_PER_INT);
1768 TYPE_ALIAS_SET (expr) = bp_unpack_value (bp, HOST_BITS_PER_INT);
1769 }
1770
1771
1772 /* Unpack all the non-pointer fields of the TS_BLOCK structure
1773 of expression EXPR from bitpack BP. */
1774
1775 static void
1776 unpack_ts_block_value_fields (struct bitpack_d *bp, tree expr)
1777 {
1778 BLOCK_ABSTRACT (expr) = (unsigned) bp_unpack_value (bp, 1);
1779 BLOCK_NUMBER (expr) = (unsigned) bp_unpack_value (bp, 31);
1780 }
1781
1782 /* Unpack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL
1783 structure of expression EXPR from bitpack BP. */
1784
1785 static void
1786 unpack_ts_translation_unit_decl_value_fields (struct bitpack_d *bp ATTRIBUTE_UNUSED, tree expr ATTRIBUTE_UNUSED)
1787 {
1788 }
1789
1790 /* Unpack all the non-pointer fields in EXPR into a bit pack. */
1791
1792 static void
1793 unpack_value_fields (struct bitpack_d *bp, tree expr)
1794 {
1795 enum tree_code code;
1796
1797 code = TREE_CODE (expr);
1798
1799 /* Note that all these functions are highly sensitive to changes in
1800 the types and sizes of each of the fields being packed. */
1801 unpack_ts_base_value_fields (bp, expr);
1802
1803 if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
1804 unpack_ts_real_cst_value_fields (bp, expr);
1805
1806 if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
1807 unpack_ts_fixed_cst_value_fields (bp, expr);
1808
1809 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
1810 unpack_ts_decl_common_value_fields (bp, expr);
1811
1812 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
1813 unpack_ts_decl_wrtl_value_fields (bp, expr);
1814
1815 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
1816 unpack_ts_decl_with_vis_value_fields (bp, expr);
1817
1818 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
1819 unpack_ts_function_decl_value_fields (bp, expr);
1820
1821 if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
1822 unpack_ts_type_value_fields (bp, expr);
1823
1824 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
1825 unpack_ts_block_value_fields (bp, expr);
1826
1827 if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
1828 {
1829 /* We only stream the version number of SSA names. */
1830 gcc_unreachable ();
1831 }
1832
1833 if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
1834 {
1835 /* This is only used by GENERIC. */
1836 gcc_unreachable ();
1837 }
1838
1839 if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
1840 {
1841 /* This is only used by High GIMPLE. */
1842 gcc_unreachable ();
1843 }
1844
1845 if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
1846 unpack_ts_translation_unit_decl_value_fields (bp, expr);
1847 }
1848
1849
1850 /* Materialize a new tree from input block IB using descriptors in
1851 DATA_IN. The code for the new tree should match TAG. Store in
1852 *IX_P the index into the reader cache where the new tree is stored. */
1853
1854 static tree
1855 lto_materialize_tree (struct lto_input_block *ib, struct data_in *data_in,
1856 enum LTO_tags tag)
1857 {
1858 struct bitpack_d bp;
1859 enum tree_code code;
1860 tree result;
1861 #ifdef LTO_STREAMER_DEBUG
1862 HOST_WIDEST_INT orig_address_in_writer;
1863 #endif
1864
1865 result = NULL_TREE;
1866
1867 #ifdef LTO_STREAMER_DEBUG
1868 /* Read the word representing the memory address for the tree
1869 as it was written by the writer. This is useful when
1870 debugging differences between the writer and reader. */
1871 orig_address_in_writer = lto_input_sleb128 (ib);
1872 gcc_assert ((intptr_t) orig_address_in_writer == orig_address_in_writer);
1873 #endif
1874
1875 code = lto_tag_to_tree_code (tag);
1876
1877 /* We should never see an SSA_NAME tree. Only the version numbers of
1878 SSA names are ever written out. See input_ssa_names. */
1879 gcc_assert (code != SSA_NAME);
1880
1881 /* Instantiate a new tree using the header data. */
1882 if (CODE_CONTAINS_STRUCT (code, TS_STRING))
1883 result = input_string_cst (data_in, ib);
1884 else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
1885 result = input_identifier (data_in, ib);
1886 else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1887 {
1888 HOST_WIDE_INT len = lto_input_sleb128 (ib);
1889 result = make_tree_vec (len);
1890 }
1891 else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1892 {
1893 unsigned HOST_WIDE_INT len = lto_input_uleb128 (ib);
1894 result = make_tree_binfo (len);
1895 }
1896 else
1897 {
1898 /* All other nodes can be materialized with a raw make_node call. */
1899 result = make_node (code);
1900 }
1901
1902 #ifdef LTO_STREAMER_DEBUG
1903 /* Store the original address of the tree as seen by the writer
1904 in RESULT's aux field. This is useful when debugging streaming
1905 problems. This way, a debugging session can be started on
1906 both writer and reader with a breakpoint using this address
1907 value in both. */
1908 lto_orig_address_map (result, (intptr_t) orig_address_in_writer);
1909 #endif
1910
1911 /* Read the bitpack of non-pointer values from IB. */
1912 bp = lto_input_bitpack (ib);
1913
1914 /* The first word in BP contains the code of the tree that we
1915 are about to read. */
1916 code = (enum tree_code) bp_unpack_value (&bp, 16);
1917 lto_tag_check (lto_tree_code_to_tag (code), tag);
1918
1919 /* Unpack all the value fields from BP. */
1920 unpack_value_fields (&bp, result);
1921
1922 /* Enter RESULT in the reader cache. This will make RESULT
1923 available so that circular references in the rest of the tree
1924 structure can be resolved in subsequent calls to lto_input_tree. */
1925 lto_streamer_cache_append (data_in->reader_cache, result);
1926
1927 return result;
1928 }
1929
1930
1931 /* Read all pointer fields in the TS_COMMON structure of EXPR from input
1932 block IB. DATA_IN contains tables and descriptors for the
1933 file being read. */
1934
1935
1936 static void
1937 lto_input_ts_common_tree_pointers (struct lto_input_block *ib,
1938 struct data_in *data_in, tree expr)
1939 {
1940 if (TREE_CODE (expr) != IDENTIFIER_NODE)
1941 TREE_TYPE (expr) = lto_input_tree (ib, data_in);
1942 }
1943
1944
1945 /* Read all pointer fields in the TS_VECTOR structure of EXPR from input
1946 block IB. DATA_IN contains tables and descriptors for the
1947 file being read. */
1948
1949 static void
1950 lto_input_ts_vector_tree_pointers (struct lto_input_block *ib,
1951 struct data_in *data_in, tree expr)
1952 {
1953 TREE_VECTOR_CST_ELTS (expr) = lto_input_chain (ib, data_in);
1954 }
1955
1956
1957 /* Read all pointer fields in the TS_COMPLEX structure of EXPR from input
1958 block IB. DATA_IN contains tables and descriptors for the
1959 file being read. */
1960
1961 static void
1962 lto_input_ts_complex_tree_pointers (struct lto_input_block *ib,
1963 struct data_in *data_in, tree expr)
1964 {
1965 TREE_REALPART (expr) = lto_input_tree (ib, data_in);
1966 TREE_IMAGPART (expr) = lto_input_tree (ib, data_in);
1967 }
1968
1969
1970 /* Read all pointer fields in the TS_DECL_MINIMAL structure of EXPR
1971 from input block IB. DATA_IN contains tables and descriptors for the
1972 file being read. */
1973
1974 static void
1975 lto_input_ts_decl_minimal_tree_pointers (struct lto_input_block *ib,
1976 struct data_in *data_in, tree expr)
1977 {
1978 DECL_NAME (expr) = lto_input_tree (ib, data_in);
1979 DECL_CONTEXT (expr) = lto_input_tree (ib, data_in);
1980 DECL_SOURCE_LOCATION (expr) = lto_input_location (ib, data_in);
1981 }
1982
1983
1984 /* Read all pointer fields in the TS_DECL_COMMON structure of EXPR from
1985 input block IB. DATA_IN contains tables and descriptors for the
1986 file being read. */
1987
1988 static void
1989 lto_input_ts_decl_common_tree_pointers (struct lto_input_block *ib,
1990 struct data_in *data_in, tree expr)
1991 {
1992 DECL_SIZE (expr) = lto_input_tree (ib, data_in);
1993 DECL_SIZE_UNIT (expr) = lto_input_tree (ib, data_in);
1994
1995 if (TREE_CODE (expr) != FUNCTION_DECL
1996 && TREE_CODE (expr) != TRANSLATION_UNIT_DECL)
1997 DECL_INITIAL (expr) = lto_input_tree (ib, data_in);
1998
1999 DECL_ATTRIBUTES (expr) = lto_input_tree (ib, data_in);
2000 /* Do not stream DECL_ABSTRACT_ORIGIN. We cannot handle debug information
2001 for early inlining so drop it on the floor instead of ICEing in
2002 dwarf2out.c. */
2003
2004 if (TREE_CODE (expr) == PARM_DECL)
2005 TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
2006
2007 if ((TREE_CODE (expr) == VAR_DECL
2008 || TREE_CODE (expr) == PARM_DECL)
2009 && DECL_HAS_VALUE_EXPR_P (expr))
2010 SET_DECL_VALUE_EXPR (expr, lto_input_tree (ib, data_in));
2011
2012 if (TREE_CODE (expr) == VAR_DECL)
2013 {
2014 tree dexpr = lto_input_tree (ib, data_in);
2015 if (dexpr)
2016 SET_DECL_DEBUG_EXPR (expr, dexpr);
2017 }
2018 }
2019
2020
2021 /* Read all pointer fields in the TS_DECL_NON_COMMON structure of
2022 EXPR from input block IB. DATA_IN contains tables and descriptors for the
2023 file being read. */
2024
2025 static void
2026 lto_input_ts_decl_non_common_tree_pointers (struct lto_input_block *ib,
2027 struct data_in *data_in, tree expr)
2028 {
2029 if (TREE_CODE (expr) == FUNCTION_DECL)
2030 {
2031 DECL_ARGUMENTS (expr) = lto_input_tree (ib, data_in);
2032 DECL_RESULT (expr) = lto_input_tree (ib, data_in);
2033 }
2034 DECL_VINDEX (expr) = lto_input_tree (ib, data_in);
2035 }
2036
2037
2038 /* Read all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
2039 from input block IB. DATA_IN contains tables and descriptors for the
2040 file being read. */
2041
2042 static void
2043 lto_input_ts_decl_with_vis_tree_pointers (struct lto_input_block *ib,
2044 struct data_in *data_in, tree expr)
2045 {
2046 tree id;
2047
2048 id = lto_input_tree (ib, data_in);
2049 if (id)
2050 {
2051 gcc_assert (TREE_CODE (id) == IDENTIFIER_NODE);
2052 SET_DECL_ASSEMBLER_NAME (expr, id);
2053 }
2054
2055 DECL_SECTION_NAME (expr) = lto_input_tree (ib, data_in);
2056 DECL_COMDAT_GROUP (expr) = lto_input_tree (ib, data_in);
2057 }
2058
2059
2060 /* Read all pointer fields in the TS_FIELD_DECL structure of EXPR from
2061 input block IB. DATA_IN contains tables and descriptors for the
2062 file being read. */
2063
2064 static void
2065 lto_input_ts_field_decl_tree_pointers (struct lto_input_block *ib,
2066 struct data_in *data_in, tree expr)
2067 {
2068 DECL_FIELD_OFFSET (expr) = lto_input_tree (ib, data_in);
2069 DECL_BIT_FIELD_TYPE (expr) = lto_input_tree (ib, data_in);
2070 DECL_QUALIFIER (expr) = lto_input_tree (ib, data_in);
2071 DECL_FIELD_BIT_OFFSET (expr) = lto_input_tree (ib, data_in);
2072 DECL_FCONTEXT (expr) = lto_input_tree (ib, data_in);
2073 TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
2074 }
2075
2076
2077 /* Read all pointer fields in the TS_FUNCTION_DECL structure of EXPR
2078 from input block IB. DATA_IN contains tables and descriptors for the
2079 file being read. */
2080
2081 static void
2082 lto_input_ts_function_decl_tree_pointers (struct lto_input_block *ib,
2083 struct data_in *data_in, tree expr)
2084 {
2085 /* DECL_STRUCT_FUNCTION is handled by lto_input_function. FIXME lto,
2086 maybe it should be handled here? */
2087 DECL_FUNCTION_PERSONALITY (expr) = lto_input_tree (ib, data_in);
2088 DECL_FUNCTION_SPECIFIC_TARGET (expr) = lto_input_tree (ib, data_in);
2089 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr) = lto_input_tree (ib, data_in);
2090
2091 /* If the file contains a function with an EH personality set,
2092 then it was compiled with -fexceptions. In that case, initialize
2093 the backend EH machinery. */
2094 if (DECL_FUNCTION_PERSONALITY (expr))
2095 lto_init_eh ();
2096 }
2097
2098
2099 /* Read all pointer fields in the TS_TYPE structure of EXPR from input
2100 block IB. DATA_IN contains tables and descriptors for the
2101 file being read. */
2102
2103 static void
2104 lto_input_ts_type_tree_pointers (struct lto_input_block *ib,
2105 struct data_in *data_in, tree expr)
2106 {
2107 if (TREE_CODE (expr) == ENUMERAL_TYPE)
2108 TYPE_VALUES (expr) = lto_input_tree (ib, data_in);
2109 else if (TREE_CODE (expr) == ARRAY_TYPE)
2110 TYPE_DOMAIN (expr) = lto_input_tree (ib, data_in);
2111 else if (RECORD_OR_UNION_TYPE_P (expr))
2112 TYPE_FIELDS (expr) = lto_input_tree (ib, data_in);
2113 else if (TREE_CODE (expr) == FUNCTION_TYPE
2114 || TREE_CODE (expr) == METHOD_TYPE)
2115 TYPE_ARG_TYPES (expr) = lto_input_tree (ib, data_in);
2116
2117 TYPE_SIZE (expr) = lto_input_tree (ib, data_in);
2118 TYPE_SIZE_UNIT (expr) = lto_input_tree (ib, data_in);
2119 TYPE_ATTRIBUTES (expr) = lto_input_tree (ib, data_in);
2120 TYPE_NAME (expr) = lto_input_tree (ib, data_in);
2121 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO nor
2122 TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. */
2123 if (!POINTER_TYPE_P (expr))
2124 TYPE_MINVAL (expr) = lto_input_tree (ib, data_in);
2125 TYPE_MAXVAL (expr) = lto_input_tree (ib, data_in);
2126 TYPE_MAIN_VARIANT (expr) = lto_input_tree (ib, data_in);
2127 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
2128 during fixup. */
2129 if (RECORD_OR_UNION_TYPE_P (expr))
2130 TYPE_BINFO (expr) = lto_input_tree (ib, data_in);
2131 TYPE_CONTEXT (expr) = lto_input_tree (ib, data_in);
2132 /* TYPE_CANONICAL gets re-computed during type merging. */
2133 TYPE_CANONICAL (expr) = NULL_TREE;
2134 TYPE_STUB_DECL (expr) = lto_input_tree (ib, data_in);
2135 }
2136
2137
2138 /* Read all pointer fields in the TS_LIST structure of EXPR from input
2139 block IB. DATA_IN contains tables and descriptors for the
2140 file being read. */
2141
2142 static void
2143 lto_input_ts_list_tree_pointers (struct lto_input_block *ib,
2144 struct data_in *data_in, tree expr)
2145 {
2146 TREE_PURPOSE (expr) = lto_input_tree (ib, data_in);
2147 TREE_VALUE (expr) = lto_input_tree (ib, data_in);
2148 TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
2149 }
2150
2151
2152 /* Read all pointer fields in the TS_VEC structure of EXPR from input
2153 block IB. DATA_IN contains tables and descriptors for the
2154 file being read. */
2155
2156 static void
2157 lto_input_ts_vec_tree_pointers (struct lto_input_block *ib,
2158 struct data_in *data_in, tree expr)
2159 {
2160 int i;
2161
2162 /* Note that TREE_VEC_LENGTH was read by lto_materialize_tree to
2163 instantiate EXPR. */
2164 for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
2165 TREE_VEC_ELT (expr, i) = lto_input_tree (ib, data_in);
2166 }
2167
2168
2169 /* Read all pointer fields in the TS_EXP structure of EXPR from input
2170 block IB. DATA_IN contains tables and descriptors for the
2171 file being read. */
2172
2173
2174 static void
2175 lto_input_ts_exp_tree_pointers (struct lto_input_block *ib,
2176 struct data_in *data_in, tree expr)
2177 {
2178 int i, length;
2179 location_t loc;
2180
2181 length = lto_input_sleb128 (ib);
2182 gcc_assert (length == TREE_OPERAND_LENGTH (expr));
2183
2184 for (i = 0; i < length; i++)
2185 TREE_OPERAND (expr, i) = lto_input_tree (ib, data_in);
2186
2187 loc = lto_input_location (ib, data_in);
2188 SET_EXPR_LOCATION (expr, loc);
2189 TREE_BLOCK (expr) = lto_input_tree (ib, data_in);
2190 }
2191
2192
2193 /* Read all pointer fields in the TS_BLOCK structure of EXPR from input
2194 block IB. DATA_IN contains tables and descriptors for the
2195 file being read. */
2196
2197 static void
2198 lto_input_ts_block_tree_pointers (struct lto_input_block *ib,
2199 struct data_in *data_in, tree expr)
2200 {
2201 /* Do not stream BLOCK_SOURCE_LOCATION. We cannot handle debug information
2202 for early inlining so drop it on the floor instead of ICEing in
2203 dwarf2out.c. */
2204 BLOCK_VARS (expr) = lto_input_chain (ib, data_in);
2205
2206 /* Do not stream BLOCK_NONLOCALIZED_VARS. We cannot handle debug information
2207 for early inlining so drop it on the floor instead of ICEing in
2208 dwarf2out.c. */
2209
2210 BLOCK_SUPERCONTEXT (expr) = lto_input_tree (ib, data_in);
2211 /* Do not stream BLOCK_ABSTRACT_ORIGIN. We cannot handle debug information
2212 for early inlining so drop it on the floor instead of ICEing in
2213 dwarf2out.c. */
2214 BLOCK_FRAGMENT_ORIGIN (expr) = lto_input_tree (ib, data_in);
2215 BLOCK_FRAGMENT_CHAIN (expr) = lto_input_tree (ib, data_in);
2216 /* We re-compute BLOCK_SUBBLOCKS of our parent here instead
2217 of streaming it. For non-BLOCK BLOCK_SUPERCONTEXTs we still
2218 stream the child relationship explicitly. */
2219 if (BLOCK_SUPERCONTEXT (expr)
2220 && TREE_CODE (BLOCK_SUPERCONTEXT (expr)) == BLOCK)
2221 {
2222 BLOCK_CHAIN (expr) = BLOCK_SUBBLOCKS (BLOCK_SUPERCONTEXT (expr));
2223 BLOCK_SUBBLOCKS (BLOCK_SUPERCONTEXT (expr)) = expr;
2224 }
2225 /* The global block is rooted at the TU decl. Hook it here to
2226 avoid the need to stream in this block during WPA time. */
2227 else if (BLOCK_SUPERCONTEXT (expr)
2228 && TREE_CODE (BLOCK_SUPERCONTEXT (expr)) == TRANSLATION_UNIT_DECL)
2229 DECL_INITIAL (BLOCK_SUPERCONTEXT (expr)) = expr;
2230 /* The function-level block is connected at the time we read in
2231 function bodies for the same reason. */
2232 }
2233
2234
2235 /* Read all pointer fields in the TS_BINFO structure of EXPR from input
2236 block IB. DATA_IN contains tables and descriptors for the
2237 file being read. */
2238
2239 static void
2240 lto_input_ts_binfo_tree_pointers (struct lto_input_block *ib,
2241 struct data_in *data_in, tree expr)
2242 {
2243 unsigned i, len;
2244 tree t;
2245
2246 /* Note that the number of slots in EXPR was read in
2247 lto_materialize_tree when instantiating EXPR. However, the
2248 vector is empty so we cannot rely on VEC_length to know how many
2249 elements to read. So, this list is emitted as a 0-terminated
2250 list on the writer side. */
2251 do
2252 {
2253 t = lto_input_tree (ib, data_in);
2254 if (t)
2255 VEC_quick_push (tree, BINFO_BASE_BINFOS (expr), t);
2256 }
2257 while (t);
2258
2259 BINFO_OFFSET (expr) = lto_input_tree (ib, data_in);
2260 BINFO_VTABLE (expr) = lto_input_tree (ib, data_in);
2261 BINFO_VIRTUALS (expr) = lto_input_tree (ib, data_in);
2262 BINFO_VPTR_FIELD (expr) = lto_input_tree (ib, data_in);
2263
2264 len = lto_input_uleb128 (ib);
2265 if (len > 0)
2266 {
2267 VEC_reserve_exact (tree, gc, BINFO_BASE_ACCESSES (expr), len);
2268 for (i = 0; i < len; i++)
2269 {
2270 tree a = lto_input_tree (ib, data_in);
2271 VEC_quick_push (tree, BINFO_BASE_ACCESSES (expr), a);
2272 }
2273 }
2274
2275 BINFO_INHERITANCE_CHAIN (expr) = lto_input_tree (ib, data_in);
2276 BINFO_SUBVTT_INDEX (expr) = lto_input_tree (ib, data_in);
2277 BINFO_VPTR_INDEX (expr) = lto_input_tree (ib, data_in);
2278 }
2279
2280
2281 /* Read all pointer fields in the TS_CONSTRUCTOR structure of EXPR from
2282 input block IB. DATA_IN contains tables and descriptors for the
2283 file being read. */
2284
2285 static void
2286 lto_input_ts_constructor_tree_pointers (struct lto_input_block *ib,
2287 struct data_in *data_in, tree expr)
2288 {
2289 unsigned i, len;
2290
2291 len = lto_input_uleb128 (ib);
2292 for (i = 0; i < len; i++)
2293 {
2294 tree index, value;
2295
2296 index = lto_input_tree (ib, data_in);
2297 value = lto_input_tree (ib, data_in);
2298 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (expr), index, value);
2299 }
2300 }
2301
2302
2303 /* Input a TS_TARGET_OPTION tree from IB into EXPR. */
2304
2305 static void
2306 lto_input_ts_target_option (struct lto_input_block *ib, tree expr)
2307 {
2308 unsigned i, len;
2309 struct bitpack_d bp;
2310 struct cl_target_option *t = TREE_TARGET_OPTION (expr);
2311
2312 bp = lto_input_bitpack (ib);
2313 len = sizeof (struct cl_target_option);
2314 for (i = 0; i < len; i++)
2315 ((unsigned char *)t)[i] = bp_unpack_value (&bp, 8);
2316 if (bp_unpack_value (&bp, 32) != 0x12345678)
2317 fatal_error ("cl_target_option size mismatch in LTO reader and writer");
2318 }
2319
2320 /* Input a TS_TRANSLATION_UNIT_DECL tree from IB and DATA_IN into EXPR. */
2321
2322 static void
2323 lto_input_ts_translation_unit_decl_tree_pointers (struct lto_input_block *ib,
2324 struct data_in *data_in,
2325 tree expr)
2326 {
2327 TRANSLATION_UNIT_LANGUAGE (expr) = xstrdup (lto_input_string (data_in, ib));
2328 VEC_safe_push (tree, gc, all_translation_units, expr);
2329 }
2330
2331 /* Helper for lto_input_tree. Read all pointer fields in EXPR from
2332 input block IB. DATA_IN contains tables and descriptors for the
2333 file being read. */
2334
2335 static void
2336 lto_input_tree_pointers (struct lto_input_block *ib, struct data_in *data_in,
2337 tree expr)
2338 {
2339 enum tree_code code;
2340
2341 code = TREE_CODE (expr);
2342
2343 if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
2344 lto_input_ts_common_tree_pointers (ib, data_in, expr);
2345
2346 if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
2347 lto_input_ts_vector_tree_pointers (ib, data_in, expr);
2348
2349 if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
2350 lto_input_ts_complex_tree_pointers (ib, data_in, expr);
2351
2352 if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
2353 lto_input_ts_decl_minimal_tree_pointers (ib, data_in, expr);
2354
2355 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
2356 lto_input_ts_decl_common_tree_pointers (ib, data_in, expr);
2357
2358 if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
2359 lto_input_ts_decl_non_common_tree_pointers (ib, data_in, expr);
2360
2361 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
2362 lto_input_ts_decl_with_vis_tree_pointers (ib, data_in, expr);
2363
2364 if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
2365 lto_input_ts_field_decl_tree_pointers (ib, data_in, expr);
2366
2367 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
2368 lto_input_ts_function_decl_tree_pointers (ib, data_in, expr);
2369
2370 if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
2371 lto_input_ts_type_tree_pointers (ib, data_in, expr);
2372
2373 if (CODE_CONTAINS_STRUCT (code, TS_LIST))
2374 lto_input_ts_list_tree_pointers (ib, data_in, expr);
2375
2376 if (CODE_CONTAINS_STRUCT (code, TS_VEC))
2377 lto_input_ts_vec_tree_pointers (ib, data_in, expr);
2378
2379 if (CODE_CONTAINS_STRUCT (code, TS_EXP))
2380 lto_input_ts_exp_tree_pointers (ib, data_in, expr);
2381
2382 if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
2383 {
2384 /* We only stream the version number of SSA names. */
2385 gcc_unreachable ();
2386 }
2387
2388 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
2389 lto_input_ts_block_tree_pointers (ib, data_in, expr);
2390
2391 if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
2392 lto_input_ts_binfo_tree_pointers (ib, data_in, expr);
2393
2394 if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
2395 {
2396 /* This should only appear in GENERIC. */
2397 gcc_unreachable ();
2398 }
2399
2400 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
2401 lto_input_ts_constructor_tree_pointers (ib, data_in, expr);
2402
2403 if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
2404 {
2405 /* This should only appear in High GIMPLE. */
2406 gcc_unreachable ();
2407 }
2408
2409 if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
2410 {
2411 sorry ("optimization options not supported yet");
2412 }
2413
2414 if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
2415 lto_input_ts_target_option (ib, expr);
2416
2417 if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
2418 lto_input_ts_translation_unit_decl_tree_pointers (ib, data_in, expr);
2419 }
2420
2421
2422 /* Register DECL with the global symbol table and change its
2423 name if necessary to avoid name clashes for static globals across
2424 different files. */
2425
2426 static void
2427 lto_register_var_decl_in_symtab (struct data_in *data_in, tree decl)
2428 {
2429 tree context;
2430
2431 /* Variable has file scope, not local. Need to ensure static variables
2432 between different files don't clash unexpectedly. */
2433 if (!TREE_PUBLIC (decl)
2434 && !((context = decl_function_context (decl))
2435 && auto_var_in_fn_p (decl, context)))
2436 {
2437 /* ??? We normally pre-mangle names before we serialize them
2438 out. Here, in lto1, we do not know the language, and
2439 thus cannot do the mangling again. Instead, we just
2440 append a suffix to the mangled name. The resulting name,
2441 however, is not a properly-formed mangled name, and will
2442 confuse any attempt to unmangle it. */
2443 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2444 char *label;
2445
2446 ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
2447 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
2448 rest_of_decl_compilation (decl, 1, 0);
2449
2450 VEC_safe_push (tree, gc, lto_global_var_decls, decl);
2451 }
2452
2453 /* If this variable has already been declared, queue the
2454 declaration for merging. */
2455 if (TREE_PUBLIC (decl))
2456 {
2457 unsigned ix;
2458 if (!lto_streamer_cache_lookup (data_in->reader_cache, decl, &ix))
2459 gcc_unreachable ();
2460 lto_symtab_register_decl (decl, get_resolution (data_in, ix),
2461 data_in->file_data);
2462 }
2463 }
2464
2465
2466
2467 /* Register DECL with the global symbol table and change its
2468 name if necessary to avoid name clashes for static globals across
2469 different files. DATA_IN contains descriptors and tables for the
2470 file being read. */
2471
2472 static void
2473 lto_register_function_decl_in_symtab (struct data_in *data_in, tree decl)
2474 {
2475 /* Need to ensure static entities between different files
2476 don't clash unexpectedly. */
2477 if (!TREE_PUBLIC (decl))
2478 {
2479 /* We must not use the DECL_ASSEMBLER_NAME macro here, as it
2480 may set the assembler name where it was previously empty. */
2481 tree old_assembler_name = decl->decl_with_vis.assembler_name;
2482
2483 /* FIXME lto: We normally pre-mangle names before we serialize
2484 them out. Here, in lto1, we do not know the language, and
2485 thus cannot do the mangling again. Instead, we just append a
2486 suffix to the mangled name. The resulting name, however, is
2487 not a properly-formed mangled name, and will confuse any
2488 attempt to unmangle it. */
2489 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2490 char *label;
2491
2492 ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
2493 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
2494
2495 /* We may arrive here with the old assembler name not set
2496 if the function body is not needed, e.g., it has been
2497 inlined away and does not appear in the cgraph. */
2498 if (old_assembler_name)
2499 {
2500 tree new_assembler_name = DECL_ASSEMBLER_NAME (decl);
2501
2502 /* Make the original assembler name available for later use.
2503 We may have used it to indicate the section within its
2504 object file where the function body may be found.
2505 FIXME lto: Find a better way to maintain the function decl
2506 to body section mapping so we don't need this hack. */
2507 lto_record_renamed_decl (data_in->file_data,
2508 IDENTIFIER_POINTER (old_assembler_name),
2509 IDENTIFIER_POINTER (new_assembler_name));
2510
2511 /* Also register the reverse mapping so that we can find the
2512 new name given to an existing assembler name (used when
2513 restoring alias pairs in input_constructors_or_inits. */
2514 lto_record_renamed_decl (data_in->file_data,
2515 IDENTIFIER_POINTER (new_assembler_name),
2516 IDENTIFIER_POINTER (old_assembler_name));
2517 }
2518 }
2519
2520 /* If this variable has already been declared, queue the
2521 declaration for merging. */
2522 if (TREE_PUBLIC (decl) && !DECL_ABSTRACT (decl))
2523 {
2524 unsigned ix;
2525 if (!lto_streamer_cache_lookup (data_in->reader_cache, decl, &ix))
2526 gcc_unreachable ();
2527 lto_symtab_register_decl (decl, get_resolution (data_in, ix),
2528 data_in->file_data);
2529 }
2530 }
2531
2532
2533 /* Read an index IX from input block IB and return the tree node at
2534 DATA_IN->FILE_DATA->GLOBALS_INDEX[IX]. */
2535
2536 static tree
2537 lto_get_pickled_tree (struct lto_input_block *ib, struct data_in *data_in)
2538 {
2539 unsigned HOST_WIDE_INT ix;
2540 tree result;
2541 enum LTO_tags expected_tag;
2542
2543 ix = lto_input_uleb128 (ib);
2544 expected_tag = (enum LTO_tags) lto_input_uleb128 (ib);
2545
2546 result = lto_streamer_cache_get (data_in->reader_cache, ix);
2547 gcc_assert (result
2548 && TREE_CODE (result) == lto_tag_to_tree_code (expected_tag));
2549
2550 return result;
2551 }
2552
2553
2554 /* Read a code and class from input block IB and return the
2555 corresponding builtin. DATA_IN is as in lto_input_tree. */
2556
2557 static tree
2558 lto_get_builtin_tree (struct lto_input_block *ib, struct data_in *data_in)
2559 {
2560 enum built_in_class fclass;
2561 enum built_in_function fcode;
2562 const char *asmname;
2563 tree result;
2564
2565 fclass = (enum built_in_class) lto_input_uleb128 (ib);
2566 gcc_assert (fclass == BUILT_IN_NORMAL || fclass == BUILT_IN_MD);
2567
2568 fcode = (enum built_in_function) lto_input_uleb128 (ib);
2569
2570 if (fclass == BUILT_IN_NORMAL)
2571 {
2572 gcc_assert (fcode < END_BUILTINS);
2573 result = built_in_decls[fcode];
2574 gcc_assert (result);
2575 }
2576 else if (fclass == BUILT_IN_MD)
2577 {
2578 result = targetm.builtin_decl (fcode, true);
2579 if (!result || result == error_mark_node)
2580 fatal_error ("target specific builtin not available");
2581 }
2582 else
2583 gcc_unreachable ();
2584
2585 asmname = lto_input_string (data_in, ib);
2586 if (asmname)
2587 set_builtin_user_assembler_name (result, asmname);
2588
2589 lto_streamer_cache_append (data_in->reader_cache, result);
2590
2591 return result;
2592 }
2593
2594
2595 /* Read the physical representation of a tree node with tag TAG from
2596 input block IB using the per-file context in DATA_IN. */
2597
2598 static tree
2599 lto_read_tree (struct lto_input_block *ib, struct data_in *data_in,
2600 enum LTO_tags tag)
2601 {
2602 tree result;
2603
2604 result = lto_materialize_tree (ib, data_in, tag);
2605
2606 /* Read all the pointer fields in RESULT. */
2607 lto_input_tree_pointers (ib, data_in, result);
2608
2609 /* We should never try to instantiate an MD or NORMAL builtin here. */
2610 if (TREE_CODE (result) == FUNCTION_DECL)
2611 gcc_assert (!lto_stream_as_builtin_p (result));
2612
2613 if (TREE_CODE (result) == VAR_DECL)
2614 lto_register_var_decl_in_symtab (data_in, result);
2615 else if (TREE_CODE (result) == FUNCTION_DECL && !DECL_BUILT_IN (result))
2616 lto_register_function_decl_in_symtab (data_in, result);
2617
2618 /* end_marker = */ lto_input_1_unsigned (ib);
2619
2620 #ifdef LTO_STREAMER_DEBUG
2621 /* Remove the mapping to RESULT's original address set by
2622 lto_materialize_tree. */
2623 lto_orig_address_remove (result);
2624 #endif
2625
2626 return result;
2627 }
2628
2629
2630 /* Read and INTEGER_CST node from input block IB using the per-file
2631 context in DATA_IN. */
2632
2633 static tree
2634 lto_input_integer_cst (struct lto_input_block *ib, struct data_in *data_in)
2635 {
2636 tree result, type;
2637 HOST_WIDE_INT low, high;
2638 bool overflow_p;
2639
2640 type = lto_input_tree (ib, data_in);
2641 overflow_p = (lto_input_1_unsigned (ib) != 0);
2642 low = lto_input_uleb128 (ib);
2643 high = lto_input_uleb128 (ib);
2644 result = build_int_cst_wide (type, low, high);
2645
2646 /* If the original constant had overflown, build a replica of RESULT to
2647 avoid modifying the shared constant returned by build_int_cst_wide. */
2648 if (overflow_p)
2649 {
2650 result = copy_node (result);
2651 TREE_OVERFLOW (result) = 1;
2652 }
2653
2654 return result;
2655 }
2656
2657
2658 /* Read a tree from input block IB using the per-file context in
2659 DATA_IN. This context is used, for example, to resolve references
2660 to previously read nodes. */
2661
2662 tree
2663 lto_input_tree (struct lto_input_block *ib, struct data_in *data_in)
2664 {
2665 enum LTO_tags tag;
2666 tree result;
2667
2668 tag = input_record_start (ib);
2669 gcc_assert ((unsigned) tag < (unsigned) LTO_NUM_TAGS);
2670
2671 if (tag == LTO_null)
2672 result = NULL_TREE;
2673 else if (tag >= LTO_field_decl_ref && tag <= LTO_global_decl_ref)
2674 {
2675 /* If TAG is a reference to an indexable tree, the next value
2676 in IB is the index into the table where we expect to find
2677 that tree. */
2678 result = lto_input_tree_ref (ib, data_in, cfun, tag);
2679 }
2680 else if (tag == LTO_tree_pickle_reference)
2681 {
2682 /* If TAG is a reference to a previously read tree, look it up in
2683 the reader cache. */
2684 result = lto_get_pickled_tree (ib, data_in);
2685 }
2686 else if (tag == LTO_builtin_decl)
2687 {
2688 /* If we are going to read a built-in function, all we need is
2689 the code and class. */
2690 result = lto_get_builtin_tree (ib, data_in);
2691 }
2692 else if (tag == lto_tree_code_to_tag (INTEGER_CST))
2693 {
2694 /* For integer constants we only need the type and its hi/low
2695 words. */
2696 result = lto_input_integer_cst (ib, data_in);
2697 }
2698 else
2699 {
2700 /* Otherwise, materialize a new node from IB. */
2701 result = lto_read_tree (ib, data_in, tag);
2702 }
2703
2704 return result;
2705 }
2706
2707
2708 /* Initialization for the LTO reader. */
2709
2710 void
2711 lto_init_reader (void)
2712 {
2713 lto_streamer_init ();
2714
2715 memset (&lto_stats, 0, sizeof (lto_stats));
2716 bitmap_obstack_initialize (NULL);
2717
2718 file_name_hash_table = htab_create (37, hash_string_slot_node,
2719 eq_string_slot_node, free);
2720
2721 gimple_register_cfg_hooks ();
2722 }
2723
2724
2725 /* Create a new data_in object for FILE_DATA. STRINGS is the string
2726 table to use with LEN strings. RESOLUTIONS is the vector of linker
2727 resolutions (NULL if not using a linker plugin). */
2728
2729 struct data_in *
2730 lto_data_in_create (struct lto_file_decl_data *file_data, const char *strings,
2731 unsigned len,
2732 VEC(ld_plugin_symbol_resolution_t,heap) *resolutions)
2733 {
2734 struct data_in *data_in = XCNEW (struct data_in);
2735 data_in->file_data = file_data;
2736 data_in->strings = strings;
2737 data_in->strings_len = len;
2738 data_in->globals_resolution = resolutions;
2739 data_in->reader_cache = lto_streamer_cache_create ();
2740
2741 return data_in;
2742 }
2743
2744
2745 /* Remove DATA_IN. */
2746
2747 void
2748 lto_data_in_delete (struct data_in *data_in)
2749 {
2750 VEC_free (ld_plugin_symbol_resolution_t, heap, data_in->globals_resolution);
2751 lto_streamer_cache_delete (data_in->reader_cache);
2752 free (data_in->labels);
2753 free (data_in);
2754 }