2010-07-02 Julian Brown <julian@codesourcery.com>
[official-gcc.git] / gcc / lto-streamer-in.c
blob635cff4d3f53c18684e34bec780cafb9c60e8df4
1 /* Read the GIMPLE representation from a file stream.
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>
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
12 version.
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "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"
51 /* Data structure used to hash file names in the source_location field. */
52 struct string_slot
54 const char *s;
55 unsigned int slot_num;
58 /* The table to hold the file names. */
59 static htab_t file_name_hash_table;
62 /* Check that tag ACTUAL has one of the given values. NUM_TAGS is the
63 number of valid tag values to check. */
65 static void
66 lto_tag_check_set (enum LTO_tags actual, int ntags, ...)
68 va_list ap;
69 int i;
71 va_start (ap, ntags);
72 for (i = 0; i < ntags; i++)
73 if ((unsigned) actual == va_arg (ap, unsigned))
75 va_end (ap);
76 return;
79 va_end (ap);
80 internal_error ("bytecode stream: unexpected tag %s", lto_tag_name (actual));
84 /* Check that tag ACTUAL is in the range [TAG1, TAG2]. */
86 static void
87 lto_tag_check_range (enum LTO_tags actual, enum LTO_tags tag1,
88 enum LTO_tags tag2)
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));
99 /* Check that tag ACTUAL == EXPECTED. */
101 static void
102 lto_tag_check (enum LTO_tags actual, enum LTO_tags expected)
104 if (actual != expected)
105 internal_error ("bytecode stream: expected tag %s instead of %s",
106 lto_tag_name (expected), lto_tag_name (actual));
110 /* Return a hash code for P. */
112 static hashval_t
113 hash_string_slot_node (const void *p)
115 const struct string_slot *ds = (const struct string_slot *) p;
116 return (hashval_t) htab_hash_string (ds->s);
120 /* Returns nonzero if P1 and P2 are equal. */
122 static int
123 eq_string_slot_node (const void *p1, const void *p2)
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;
131 /* Read a string from the string table in DATA_IN using input block
132 IB. Write the length to RLEN. */
134 static const char *
135 input_string_internal (struct data_in *data_in, struct lto_input_block *ib,
136 unsigned int *rlen)
138 struct lto_input_block str_tab;
139 unsigned int len;
140 unsigned int loc;
141 const char *result;
143 loc = lto_input_uleb128 (ib);
144 LTO_INIT_INPUT_BLOCK (str_tab, data_in->strings, loc, data_in->strings_len);
145 len = lto_input_uleb128 (&str_tab);
146 *rlen = len;
148 if (str_tab.p + len > data_in->strings_len)
149 internal_error ("bytecode stream: string too long for the string table");
151 result = (const char *)(data_in->strings + str_tab.p);
153 return result;
157 /* Read a STRING_CST from the string table in DATA_IN using input
158 block IB. */
160 static tree
161 input_string_cst (struct data_in *data_in, struct lto_input_block *ib)
163 unsigned int len;
164 const char * ptr;
165 unsigned int is_null;
167 is_null = lto_input_uleb128 (ib);
168 if (is_null)
169 return NULL;
171 ptr = input_string_internal (data_in, ib, &len);
172 return build_string (len, ptr);
176 /* Read an IDENTIFIER from the string table in DATA_IN using input
177 block IB. */
179 static tree
180 input_identifier (struct data_in *data_in, struct lto_input_block *ib)
182 unsigned int len;
183 const char *ptr;
184 unsigned int is_null;
186 is_null = lto_input_uleb128 (ib);
187 if (is_null)
188 return NULL;
190 ptr = input_string_internal (data_in, ib, &len);
191 return get_identifier_with_length (ptr, len);
194 /* Read a NULL terminated string from the string table in DATA_IN. */
196 static const char *
197 input_string (struct data_in *data_in, struct lto_input_block *ib)
199 unsigned int len;
200 const char *ptr;
201 unsigned int is_null;
203 is_null = lto_input_uleb128 (ib);
204 if (is_null)
205 return NULL;
207 ptr = input_string_internal (data_in, ib, &len);
208 if (ptr[len - 1] != '\0')
209 internal_error ("bytecode stream: found non-null terminated string");
211 return ptr;
215 /* Return the next tag in the input block IB. */
217 static enum LTO_tags
218 input_record_start (struct lto_input_block *ib)
220 enum LTO_tags tag = (enum LTO_tags) lto_input_uleb128 (ib);
221 return tag;
225 /* Lookup STRING in file_name_hash_table. If found, return the existing
226 string, otherwise insert STRING as the canonical version. */
228 static const char *
229 canon_file_name (const char *string)
231 void **slot;
232 struct string_slot s_slot;
233 s_slot.s = string;
235 slot = htab_find_slot (file_name_hash_table, &s_slot, INSERT);
236 if (*slot == NULL)
238 size_t len;
239 char *saved_string;
240 struct string_slot *new_slot;
242 len = strlen (string);
243 saved_string = (char *) xmalloc (len + 1);
244 new_slot = XCNEW (struct string_slot);
245 strcpy (saved_string, string);
246 new_slot->s = saved_string;
247 *slot = new_slot;
248 return saved_string;
250 else
252 struct string_slot *old_slot = (struct string_slot *) *slot;
253 return old_slot->s;
258 /* Clear the line info stored in DATA_IN. */
260 static void
261 clear_line_info (struct data_in *data_in)
263 if (data_in->current_file)
264 linemap_add (line_table, LC_LEAVE, false, NULL, 0);
265 data_in->current_file = NULL;
266 data_in->current_line = 0;
267 data_in->current_col = 0;
271 /* Read a location from input block IB. */
273 static location_t
274 lto_input_location (struct lto_input_block *ib, struct data_in *data_in)
276 expanded_location xloc;
278 xloc.file = input_string (data_in, ib);
279 if (xloc.file == NULL)
280 return UNKNOWN_LOCATION;
282 xloc.file = canon_file_name (xloc.file);
283 xloc.line = lto_input_sleb128 (ib);
284 xloc.column = lto_input_sleb128 (ib);
285 xloc.sysp = lto_input_sleb128 (ib);
287 if (data_in->current_file != xloc.file)
289 if (data_in->current_file)
290 linemap_add (line_table, LC_LEAVE, false, NULL, 0);
292 linemap_add (line_table, LC_ENTER, xloc.sysp, xloc.file, xloc.line);
294 else if (data_in->current_line != xloc.line)
295 linemap_line_start (line_table, xloc.line, xloc.column);
297 data_in->current_file = xloc.file;
298 data_in->current_line = xloc.line;
299 data_in->current_col = xloc.column;
301 return linemap_position_for_column (line_table, xloc.column);
305 /* Read a reference to a tree node from DATA_IN using input block IB.
306 TAG is the expected node that should be found in IB, if TAG belongs
307 to one of the indexable trees, expect to read a reference index to
308 be looked up in one of the symbol tables, otherwise read the pysical
309 representation of the tree using lto_input_tree. FN is the
310 function scope for the read tree. */
312 static tree
313 lto_input_tree_ref (struct lto_input_block *ib, struct data_in *data_in,
314 struct function *fn, enum LTO_tags tag)
316 unsigned HOST_WIDE_INT ix_u;
317 tree result = NULL_TREE;
319 lto_tag_check_range (tag, LTO_field_decl_ref, LTO_global_decl_ref);
321 switch (tag)
323 case LTO_type_ref:
324 ix_u = lto_input_uleb128 (ib);
325 result = lto_file_decl_data_get_type (data_in->file_data, ix_u);
326 break;
328 case LTO_ssa_name_ref:
329 ix_u = lto_input_uleb128 (ib);
330 result = VEC_index (tree, SSANAMES (fn), ix_u);
331 break;
333 case LTO_field_decl_ref:
334 ix_u = lto_input_uleb128 (ib);
335 result = lto_file_decl_data_get_field_decl (data_in->file_data, ix_u);
336 break;
338 case LTO_function_decl_ref:
339 ix_u = lto_input_uleb128 (ib);
340 result = lto_file_decl_data_get_fn_decl (data_in->file_data, ix_u);
341 break;
343 case LTO_type_decl_ref:
344 ix_u = lto_input_uleb128 (ib);
345 result = lto_file_decl_data_get_type_decl (data_in->file_data, ix_u);
346 break;
348 case LTO_namespace_decl_ref:
349 ix_u = lto_input_uleb128 (ib);
350 result = lto_file_decl_data_get_namespace_decl (data_in->file_data, ix_u);
351 break;
353 case LTO_global_decl_ref:
354 case LTO_result_decl_ref:
355 case LTO_const_decl_ref:
356 case LTO_imported_decl_ref:
357 case LTO_label_decl_ref:
358 ix_u = lto_input_uleb128 (ib);
359 result = lto_file_decl_data_get_var_decl (data_in->file_data, ix_u);
360 break;
362 default:
363 gcc_unreachable ();
366 gcc_assert (result);
368 return result;
372 /* Read and return a double-linked list of catch handlers from input
373 block IB, using descriptors in DATA_IN. */
375 static struct eh_catch_d *
376 lto_input_eh_catch_list (struct lto_input_block *ib, struct data_in *data_in,
377 eh_catch *last_p)
379 eh_catch first;
380 enum LTO_tags tag;
382 *last_p = first = NULL;
383 tag = input_record_start (ib);
384 while (tag)
386 tree list;
387 eh_catch n;
389 lto_tag_check_range (tag, LTO_eh_catch, LTO_eh_catch);
391 /* Read the catch node. */
392 n = ggc_alloc_cleared_eh_catch_d ();
393 n->type_list = lto_input_tree (ib, data_in);
394 n->filter_list = lto_input_tree (ib, data_in);
395 n->label = lto_input_tree (ib, data_in);
397 /* Register all the types in N->FILTER_LIST. */
398 for (list = n->filter_list; list; list = TREE_CHAIN (list))
399 add_type_for_runtime (TREE_VALUE (list));
401 /* Chain N to the end of the list. */
402 if (*last_p)
403 (*last_p)->next_catch = n;
404 n->prev_catch = *last_p;
405 *last_p = n;
407 /* Set the head of the list the first time through the loop. */
408 if (first == NULL)
409 first = n;
411 tag = input_record_start (ib);
414 return first;
418 /* Read and return EH region IX from input block IB, using descriptors
419 in DATA_IN. */
421 static eh_region
422 input_eh_region (struct lto_input_block *ib, struct data_in *data_in, int ix)
424 enum LTO_tags tag;
425 eh_region r;
427 /* Read the region header. */
428 tag = input_record_start (ib);
429 if (tag == LTO_null)
430 return NULL;
432 r = ggc_alloc_cleared_eh_region_d ();
433 r->index = lto_input_sleb128 (ib);
435 gcc_assert (r->index == ix);
437 /* Read all the region pointers as region numbers. We'll fix up
438 the pointers once the whole array has been read. */
439 r->outer = (eh_region) (intptr_t) lto_input_sleb128 (ib);
440 r->inner = (eh_region) (intptr_t) lto_input_sleb128 (ib);
441 r->next_peer = (eh_region) (intptr_t) lto_input_sleb128 (ib);
443 switch (tag)
445 case LTO_ert_cleanup:
446 r->type = ERT_CLEANUP;
447 break;
449 case LTO_ert_try:
451 struct eh_catch_d *last_catch;
452 r->type = ERT_TRY;
453 r->u.eh_try.first_catch = lto_input_eh_catch_list (ib, data_in,
454 &last_catch);
455 r->u.eh_try.last_catch = last_catch;
456 break;
459 case LTO_ert_allowed_exceptions:
461 tree l;
463 r->type = ERT_ALLOWED_EXCEPTIONS;
464 r->u.allowed.type_list = lto_input_tree (ib, data_in);
465 r->u.allowed.label = lto_input_tree (ib, data_in);
466 r->u.allowed.filter = lto_input_uleb128 (ib);
468 for (l = r->u.allowed.type_list; l ; l = TREE_CHAIN (l))
469 add_type_for_runtime (TREE_VALUE (l));
471 break;
473 case LTO_ert_must_not_throw:
474 r->type = ERT_MUST_NOT_THROW;
475 r->u.must_not_throw.failure_decl = lto_input_tree (ib, data_in);
476 r->u.must_not_throw.failure_loc = lto_input_location (ib, data_in);
477 break;
479 default:
480 gcc_unreachable ();
483 r->landing_pads = (eh_landing_pad) (intptr_t) lto_input_sleb128 (ib);
485 return r;
489 /* Read and return EH landing pad IX from input block IB, using descriptors
490 in DATA_IN. */
492 static eh_landing_pad
493 input_eh_lp (struct lto_input_block *ib, struct data_in *data_in, int ix)
495 enum LTO_tags tag;
496 eh_landing_pad lp;
498 /* Read the landing pad header. */
499 tag = input_record_start (ib);
500 if (tag == LTO_null)
501 return NULL;
503 lto_tag_check_range (tag, LTO_eh_landing_pad, LTO_eh_landing_pad);
505 lp = ggc_alloc_cleared_eh_landing_pad_d ();
506 lp->index = lto_input_sleb128 (ib);
507 gcc_assert (lp->index == ix);
508 lp->next_lp = (eh_landing_pad) (intptr_t) lto_input_sleb128 (ib);
509 lp->region = (eh_region) (intptr_t) lto_input_sleb128 (ib);
510 lp->post_landing_pad = lto_input_tree (ib, data_in);
512 return lp;
516 /* After reading the EH regions, pointers to peer and children regions
517 are region numbers. This converts all these region numbers into
518 real pointers into the rematerialized regions for FN. ROOT_REGION
519 is the region number for the root EH region in FN. */
521 static void
522 fixup_eh_region_pointers (struct function *fn, HOST_WIDE_INT root_region)
524 unsigned i;
525 VEC(eh_region,gc) *eh_array = fn->eh->region_array;
526 VEC(eh_landing_pad,gc) *lp_array = fn->eh->lp_array;
527 eh_region r;
528 eh_landing_pad lp;
530 gcc_assert (eh_array && lp_array);
532 gcc_assert (root_region >= 0);
533 fn->eh->region_tree = VEC_index (eh_region, eh_array, root_region);
535 #define FIXUP_EH_REGION(r) (r) = VEC_index (eh_region, eh_array, \
536 (HOST_WIDE_INT) (intptr_t) (r))
537 #define FIXUP_EH_LP(p) (p) = VEC_index (eh_landing_pad, lp_array, \
538 (HOST_WIDE_INT) (intptr_t) (p))
540 /* Convert all the index numbers stored in pointer fields into
541 pointers to the corresponding slots in the EH region array. */
542 for (i = 0; VEC_iterate (eh_region, eh_array, i, r); i++)
544 /* The array may contain NULL regions. */
545 if (r == NULL)
546 continue;
548 gcc_assert (i == (unsigned) r->index);
549 FIXUP_EH_REGION (r->outer);
550 FIXUP_EH_REGION (r->inner);
551 FIXUP_EH_REGION (r->next_peer);
552 FIXUP_EH_LP (r->landing_pads);
555 /* Convert all the index numbers stored in pointer fields into
556 pointers to the corresponding slots in the EH landing pad array. */
557 for (i = 0; VEC_iterate (eh_landing_pad, lp_array, i, lp); i++)
559 /* The array may contain NULL landing pads. */
560 if (lp == NULL)
561 continue;
563 gcc_assert (i == (unsigned) lp->index);
564 FIXUP_EH_LP (lp->next_lp);
565 FIXUP_EH_REGION (lp->region);
568 #undef FIXUP_EH_REGION
569 #undef FIXUP_EH_LP
573 /* Initialize EH support. */
575 static void
576 lto_init_eh (void)
578 static bool eh_initialized_p = false;
580 if (eh_initialized_p)
581 return;
583 /* Contrary to most other FEs, we only initialize EH support when at
584 least one of the files in the set contains exception regions in
585 it. Since this happens much later than the call to init_eh in
586 lang_dependent_init, we have to set flag_exceptions and call
587 init_eh again to initialize the EH tables. */
588 flag_exceptions = 1;
589 init_eh ();
591 /* Initialize dwarf2 tables. Since dwarf2out_do_frame() returns
592 true only when exceptions are enabled, this initialization is
593 never done during lang_dependent_init. */
594 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
595 if (dwarf2out_do_frame ())
596 dwarf2out_frame_init ();
597 #endif
599 eh_initialized_p = true;
603 /* Read the exception table for FN from IB using the data descriptors
604 in DATA_IN. */
606 static void
607 input_eh_regions (struct lto_input_block *ib, struct data_in *data_in,
608 struct function *fn)
610 HOST_WIDE_INT i, root_region, len;
611 enum LTO_tags tag;
613 tag = input_record_start (ib);
614 if (tag == LTO_null)
615 return;
617 lto_tag_check_range (tag, LTO_eh_table, LTO_eh_table);
619 /* If the file contains EH regions, then it was compiled with
620 -fexceptions. In that case, initialize the backend EH
621 machinery. */
622 lto_init_eh ();
624 gcc_assert (fn->eh);
626 root_region = lto_input_sleb128 (ib);
627 gcc_assert (root_region == (int) root_region);
629 /* Read the EH region array. */
630 len = lto_input_sleb128 (ib);
631 gcc_assert (len == (int) len);
632 if (len > 0)
634 VEC_safe_grow (eh_region, gc, fn->eh->region_array, len);
635 for (i = 0; i < len; i++)
637 eh_region r = input_eh_region (ib, data_in, i);
638 VEC_replace (eh_region, fn->eh->region_array, i, r);
642 /* Read the landing pads. */
643 len = lto_input_sleb128 (ib);
644 gcc_assert (len == (int) len);
645 if (len > 0)
647 VEC_safe_grow (eh_landing_pad, gc, fn->eh->lp_array, len);
648 for (i = 0; i < len; i++)
650 eh_landing_pad lp = input_eh_lp (ib, data_in, i);
651 VEC_replace (eh_landing_pad, fn->eh->lp_array, i, lp);
655 /* Read the runtime type data. */
656 len = lto_input_sleb128 (ib);
657 gcc_assert (len == (int) len);
658 if (len > 0)
660 VEC_safe_grow (tree, gc, fn->eh->ttype_data, len);
661 for (i = 0; i < len; i++)
663 tree ttype = lto_input_tree (ib, data_in);
664 VEC_replace (tree, fn->eh->ttype_data, i, ttype);
668 /* Read the table of action chains. */
669 len = lto_input_sleb128 (ib);
670 gcc_assert (len == (int) len);
671 if (len > 0)
673 if (targetm.arm_eabi_unwinder)
675 VEC_safe_grow (tree, gc, fn->eh->ehspec_data.arm_eabi, len);
676 for (i = 0; i < len; i++)
678 tree t = lto_input_tree (ib, data_in);
679 VEC_replace (tree, fn->eh->ehspec_data.arm_eabi, i, t);
682 else
684 VEC_safe_grow (uchar, gc, fn->eh->ehspec_data.other, len);
685 for (i = 0; i < len; i++)
687 uchar c = lto_input_1_unsigned (ib);
688 VEC_replace (uchar, fn->eh->ehspec_data.other, i, c);
693 /* Reconstruct the EH region tree by fixing up the peer/children
694 pointers. */
695 fixup_eh_region_pointers (fn, root_region);
697 tag = input_record_start (ib);
698 lto_tag_check_range (tag, LTO_null, LTO_null);
702 /* Make a new basic block with index INDEX in function FN. */
704 static basic_block
705 make_new_block (struct function *fn, unsigned int index)
707 basic_block bb = alloc_block ();
708 bb->index = index;
709 SET_BASIC_BLOCK_FOR_FUNCTION (fn, index, bb);
710 bb->il.gimple = ggc_alloc_cleared_gimple_bb_info ();
711 n_basic_blocks_for_function (fn)++;
712 bb->flags = 0;
713 set_bb_seq (bb, gimple_seq_alloc ());
714 return bb;
718 /* Read the CFG for function FN from input block IB. */
720 static void
721 input_cfg (struct lto_input_block *ib, struct function *fn)
723 unsigned int bb_count;
724 basic_block p_bb;
725 unsigned int i;
726 int index;
728 init_empty_tree_cfg_for_function (fn);
729 init_ssa_operands ();
731 profile_status_for_function (fn) =
732 (enum profile_status_d) lto_input_uleb128 (ib);
734 bb_count = lto_input_uleb128 (ib);
736 last_basic_block_for_function (fn) = bb_count;
737 if (bb_count > VEC_length (basic_block, basic_block_info_for_function (fn)))
738 VEC_safe_grow_cleared (basic_block, gc,
739 basic_block_info_for_function (fn), bb_count);
741 if (bb_count > VEC_length (basic_block, label_to_block_map_for_function (fn)))
742 VEC_safe_grow_cleared (basic_block, gc,
743 label_to_block_map_for_function (fn), bb_count);
745 index = lto_input_sleb128 (ib);
746 while (index != -1)
748 basic_block bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
749 unsigned int edge_count;
751 if (bb == NULL)
752 bb = make_new_block (fn, index);
754 edge_count = lto_input_uleb128 (ib);
756 /* Connect up the CFG. */
757 for (i = 0; i < edge_count; i++)
759 unsigned int dest_index;
760 unsigned int edge_flags;
761 basic_block dest;
762 int probability;
763 gcov_type count;
764 edge e;
766 dest_index = lto_input_uleb128 (ib);
767 probability = (int) lto_input_sleb128 (ib);
768 count = (gcov_type) lto_input_sleb128 (ib);
769 edge_flags = lto_input_uleb128 (ib);
771 dest = BASIC_BLOCK_FOR_FUNCTION (fn, dest_index);
773 if (dest == NULL)
774 dest = make_new_block (fn, dest_index);
776 e = make_edge (bb, dest, edge_flags);
777 e->probability = probability;
778 e->count = count;
781 index = lto_input_sleb128 (ib);
784 p_bb = ENTRY_BLOCK_PTR_FOR_FUNCTION(fn);
785 index = lto_input_sleb128 (ib);
786 while (index != -1)
788 basic_block bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
789 bb->prev_bb = p_bb;
790 p_bb->next_bb = bb;
791 p_bb = bb;
792 index = lto_input_sleb128 (ib);
797 /* Read a PHI function for basic block BB in function FN. DATA_IN is
798 the file being read. IB is the input block to use for reading. */
800 static gimple
801 input_phi (struct lto_input_block *ib, basic_block bb, struct data_in *data_in,
802 struct function *fn)
804 unsigned HOST_WIDE_INT ix;
805 tree phi_result;
806 int i, len;
807 gimple result;
809 ix = lto_input_uleb128 (ib);
810 phi_result = VEC_index (tree, SSANAMES (fn), ix);
811 len = EDGE_COUNT (bb->preds);
812 result = create_phi_node (phi_result, bb);
813 SSA_NAME_DEF_STMT (phi_result) = result;
815 /* We have to go through a lookup process here because the preds in the
816 reconstructed graph are generally in a different order than they
817 were in the original program. */
818 for (i = 0; i < len; i++)
820 tree def = lto_input_tree (ib, data_in);
821 int src_index = lto_input_uleb128 (ib);
822 location_t arg_loc = lto_input_location (ib, data_in);
823 basic_block sbb = BASIC_BLOCK_FOR_FUNCTION (fn, src_index);
825 edge e = NULL;
826 int j;
828 for (j = 0; j < len; j++)
829 if (EDGE_PRED (bb, j)->src == sbb)
831 e = EDGE_PRED (bb, j);
832 break;
835 add_phi_arg (result, def, e, arg_loc);
838 return result;
842 /* Read the SSA names array for function FN from DATA_IN using input
843 block IB. */
845 static void
846 input_ssa_names (struct lto_input_block *ib, struct data_in *data_in,
847 struct function *fn)
849 unsigned int i, size;
851 size = lto_input_uleb128 (ib);
852 init_ssanames (fn, size);
854 i = lto_input_uleb128 (ib);
855 while (i)
857 tree ssa_name, name;
858 bool is_default_def;
860 /* Skip over the elements that had been freed. */
861 while (VEC_length (tree, SSANAMES (fn)) < i)
862 VEC_quick_push (tree, SSANAMES (fn), NULL_TREE);
864 is_default_def = (lto_input_1_unsigned (ib) != 0);
865 name = lto_input_tree (ib, data_in);
866 ssa_name = make_ssa_name_fn (fn, name, gimple_build_nop ());
868 if (is_default_def)
869 set_default_def (SSA_NAME_VAR (ssa_name), ssa_name);
871 i = lto_input_uleb128 (ib);
876 /* Fixup the reference tree OP for replaced VAR_DECLs with mismatched
877 types. */
879 static void
880 maybe_fixup_handled_component (tree op)
882 tree decl_type;
883 tree wanted_type;
885 while (handled_component_p (TREE_OPERAND (op, 0)))
886 op = TREE_OPERAND (op, 0);
887 if (TREE_CODE (TREE_OPERAND (op, 0)) != VAR_DECL)
888 return;
890 decl_type = TREE_TYPE (TREE_OPERAND (op, 0));
892 switch (TREE_CODE (op))
894 case COMPONENT_REF:
895 /* The DECL_CONTEXT of the field-decl is the record type we look for. */
896 wanted_type = DECL_CONTEXT (TREE_OPERAND (op, 1));
897 break;
899 case ARRAY_REF:
900 if (TREE_CODE (decl_type) == ARRAY_TYPE
901 && (TREE_TYPE (decl_type) == TREE_TYPE (op)
902 || useless_type_conversion_p (TREE_TYPE (op),
903 TREE_TYPE (decl_type))))
904 return;
905 /* An unknown size array type should be ok. But we do not
906 lower the lower bound in all cases - ugh. */
907 wanted_type = build_array_type (TREE_TYPE (op), NULL_TREE);
908 break;
910 case ARRAY_RANGE_REF:
911 if (TREE_CODE (decl_type) == ARRAY_TYPE
912 && (TREE_TYPE (decl_type) == TREE_TYPE (TREE_TYPE (op))
913 || useless_type_conversion_p (TREE_TYPE (TREE_TYPE (op)),
914 TREE_TYPE (decl_type))))
915 return;
916 /* An unknown size array type should be ok. But we do not
917 lower the lower bound in all cases - ugh. */
918 wanted_type = build_array_type (TREE_TYPE (TREE_TYPE (op)), NULL_TREE);
919 break;
921 case BIT_FIELD_REF:
922 case VIEW_CONVERT_EXPR:
923 /* Very nice - nothing to do. */
924 return;
926 case REALPART_EXPR:
927 case IMAGPART_EXPR:
928 if (TREE_CODE (decl_type) == COMPLEX_TYPE
929 && (TREE_TYPE (decl_type) == TREE_TYPE (op)
930 || useless_type_conversion_p (TREE_TYPE (op),
931 TREE_TYPE (decl_type))))
932 return;
933 wanted_type = build_complex_type (TREE_TYPE (op));
934 break;
936 default:
937 gcc_unreachable ();
940 if (!useless_type_conversion_p (wanted_type, decl_type))
941 TREE_OPERAND (op, 0) = build1 (VIEW_CONVERT_EXPR, wanted_type,
942 TREE_OPERAND (op, 0));
945 /* Fixup reference tree operands for substituted prevailing decls
946 with mismatched types in STMT. This handles plain DECLs where
947 we need the stmt for context to lookup the required type. */
949 static void
950 maybe_fixup_decls (gimple stmt)
952 /* We have to fixup replaced decls here in case there were
953 inter-TU type mismatches. Catch the most common cases
954 for now - this way we'll get testcases for the rest as
955 the type verifier will complain. */
956 if (gimple_assign_single_p (stmt))
958 tree lhs = gimple_assign_lhs (stmt);
959 tree rhs = gimple_assign_rhs1 (stmt);
961 /* First catch loads and aggregate copies by adjusting the rhs. */
962 if (TREE_CODE (rhs) == VAR_DECL)
964 if (!useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (rhs)))
965 gimple_assign_set_rhs1 (stmt, build1 (VIEW_CONVERT_EXPR,
966 TREE_TYPE (lhs), rhs));
968 /* Then catch scalar stores. */
969 else if (TREE_CODE (lhs) == VAR_DECL)
971 if (!useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (rhs)))
972 gimple_assign_set_lhs (stmt, build1 (VIEW_CONVERT_EXPR,
973 TREE_TYPE (rhs), lhs));
976 else if (is_gimple_call (stmt))
978 tree lhs = gimple_call_lhs (stmt);
980 if (lhs && TREE_CODE (lhs) == VAR_DECL)
982 if (!useless_type_conversion_p (TREE_TYPE (lhs),
983 gimple_call_return_type (stmt)))
984 gimple_call_set_lhs (stmt, build1 (VIEW_CONVERT_EXPR,
985 gimple_call_return_type (stmt),
986 lhs));
989 /* Arguments, especially for varargs functions will be funny... */
993 /* Read a statement with tag TAG in function FN from block IB using
994 descriptors in DATA_IN. */
996 static gimple
997 input_gimple_stmt (struct lto_input_block *ib, struct data_in *data_in,
998 struct function *fn, enum LTO_tags tag)
1000 gimple stmt;
1001 enum gimple_code code;
1002 unsigned HOST_WIDE_INT num_ops;
1003 size_t i;
1004 struct bitpack_d bp;
1006 code = lto_tag_to_gimple_code (tag);
1008 /* Read the tuple header. */
1009 bp = lto_input_bitpack (ib);
1010 num_ops = bp_unpack_value (&bp, sizeof (unsigned) * 8);
1011 stmt = gimple_alloc (code, num_ops);
1012 stmt->gsbase.no_warning = bp_unpack_value (&bp, 1);
1013 if (is_gimple_assign (stmt))
1014 stmt->gsbase.nontemporal_move = bp_unpack_value (&bp, 1);
1015 stmt->gsbase.has_volatile_ops = bp_unpack_value (&bp, 1);
1016 stmt->gsbase.subcode = bp_unpack_value (&bp, 16);
1018 /* Read location information. */
1019 gimple_set_location (stmt, lto_input_location (ib, data_in));
1021 /* Read lexical block reference. */
1022 gimple_set_block (stmt, lto_input_tree (ib, data_in));
1024 /* Read in all the operands. */
1025 switch (code)
1027 case GIMPLE_RESX:
1028 gimple_resx_set_region (stmt, lto_input_sleb128 (ib));
1029 break;
1031 case GIMPLE_EH_MUST_NOT_THROW:
1032 gimple_eh_must_not_throw_set_fndecl (stmt, lto_input_tree (ib, data_in));
1033 break;
1035 case GIMPLE_EH_DISPATCH:
1036 gimple_eh_dispatch_set_region (stmt, lto_input_sleb128 (ib));
1037 break;
1039 case GIMPLE_ASM:
1041 /* FIXME lto. Move most of this into a new gimple_asm_set_string(). */
1042 tree str;
1043 stmt->gimple_asm.ni = lto_input_uleb128 (ib);
1044 stmt->gimple_asm.no = lto_input_uleb128 (ib);
1045 stmt->gimple_asm.nc = lto_input_uleb128 (ib);
1046 stmt->gimple_asm.nl = lto_input_uleb128 (ib);
1047 str = input_string_cst (data_in, ib);
1048 stmt->gimple_asm.string = TREE_STRING_POINTER (str);
1050 /* Fallthru */
1052 case GIMPLE_ASSIGN:
1053 case GIMPLE_CALL:
1054 case GIMPLE_RETURN:
1055 case GIMPLE_SWITCH:
1056 case GIMPLE_LABEL:
1057 case GIMPLE_COND:
1058 case GIMPLE_GOTO:
1059 case GIMPLE_DEBUG:
1060 for (i = 0; i < num_ops; i++)
1062 tree op = lto_input_tree (ib, data_in);
1063 gimple_set_op (stmt, i, op);
1064 if (!op)
1065 continue;
1067 /* Fixup reference tree operands for substituted prevailing decls
1068 with mismatched types. For plain VAR_DECLs we need to look
1069 at context to determine the wanted type - we do that below
1070 after the stmt is completed. */
1071 if (TREE_CODE (op) == ADDR_EXPR
1072 && TREE_CODE (TREE_OPERAND (op, 0)) == VAR_DECL
1073 && !useless_type_conversion_p (TREE_TYPE (TREE_TYPE (op)),
1074 TREE_TYPE (TREE_OPERAND (op, 0))))
1076 TREE_OPERAND (op, 0)
1077 = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (TREE_TYPE (op)),
1078 TREE_OPERAND (op, 0));
1079 continue;
1082 /* Fixup FIELD_DECLs in COMPONENT_REFs, they are not handled
1083 by decl merging. */
1084 if (TREE_CODE (op) == ADDR_EXPR)
1085 op = TREE_OPERAND (op, 0);
1086 while (handled_component_p (op))
1088 if (TREE_CODE (op) == COMPONENT_REF)
1090 tree field, type, tem;
1091 field = TREE_OPERAND (op, 1);
1092 type = DECL_CONTEXT (field);
1093 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1095 if (tem == field
1096 || (TREE_TYPE (tem) == TREE_TYPE (field)
1097 && DECL_NONADDRESSABLE_P (tem)
1098 == DECL_NONADDRESSABLE_P (field)
1099 && gimple_compare_field_offset (tem, field)))
1100 break;
1102 /* In case of type mismatches across units we can fail
1103 to unify some types and thus not find a proper
1104 field-decl here. So only assert here if checking
1105 is enabled. */
1106 #ifdef ENABLE_CHECKING
1107 gcc_assert (tem != NULL_TREE);
1108 #endif
1109 if (tem != NULL_TREE)
1110 TREE_OPERAND (op, 1) = tem;
1113 /* Preserve the last handled component for the fixup of
1114 its operand below. */
1115 if (!handled_component_p (TREE_OPERAND (op, 0)))
1116 break;
1117 op = TREE_OPERAND (op, 0);
1120 /* Fixup reference tree operands for substituted prevailing decls
1121 with mismatched types. */
1122 if (handled_component_p (op))
1123 maybe_fixup_handled_component (op);
1125 break;
1127 case GIMPLE_NOP:
1128 case GIMPLE_PREDICT:
1129 break;
1131 default:
1132 internal_error ("bytecode stream: unknown GIMPLE statement tag %s",
1133 lto_tag_name (tag));
1136 /* Update the properties of symbols, SSA names and labels associated
1137 with STMT. */
1138 if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
1140 tree lhs = gimple_get_lhs (stmt);
1141 if (lhs && TREE_CODE (lhs) == SSA_NAME)
1142 SSA_NAME_DEF_STMT (lhs) = stmt;
1144 else if (code == GIMPLE_LABEL)
1145 gcc_assert (emit_label_in_global_context_p (gimple_label_label (stmt))
1146 || DECL_CONTEXT (gimple_label_label (stmt)) == fn->decl);
1147 else if (code == GIMPLE_ASM)
1149 unsigned i;
1151 for (i = 0; i < gimple_asm_noutputs (stmt); i++)
1153 tree op = TREE_VALUE (gimple_asm_output_op (stmt, i));
1154 if (TREE_CODE (op) == SSA_NAME)
1155 SSA_NAME_DEF_STMT (op) = stmt;
1159 /* Reset alias information. */
1160 if (code == GIMPLE_CALL)
1161 gimple_call_reset_alias_info (stmt);
1163 /* Fixup reference tree operands for substituted prevailing decls
1164 with mismatched types. */
1165 maybe_fixup_decls (stmt);
1167 /* Mark the statement modified so its operand vectors can be filled in. */
1168 gimple_set_modified (stmt, true);
1170 return stmt;
1174 /* Read a basic block with tag TAG from DATA_IN using input block IB.
1175 FN is the function being processed. */
1177 static void
1178 input_bb (struct lto_input_block *ib, enum LTO_tags tag,
1179 struct data_in *data_in, struct function *fn)
1181 unsigned int index;
1182 basic_block bb;
1183 gimple_stmt_iterator bsi;
1185 /* This routine assumes that CFUN is set to FN, as it needs to call
1186 basic GIMPLE routines that use CFUN. */
1187 gcc_assert (cfun == fn);
1189 index = lto_input_uleb128 (ib);
1190 bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
1192 bb->count = lto_input_sleb128 (ib);
1193 bb->loop_depth = lto_input_sleb128 (ib);
1194 bb->frequency = lto_input_sleb128 (ib);
1195 bb->flags = lto_input_sleb128 (ib);
1197 /* LTO_bb1 has statements. LTO_bb0 does not. */
1198 if (tag == LTO_bb0)
1199 return;
1201 bsi = gsi_start_bb (bb);
1202 tag = input_record_start (ib);
1203 while (tag)
1205 gimple stmt = input_gimple_stmt (ib, data_in, fn, tag);
1207 find_referenced_vars_in (stmt);
1208 gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
1210 /* After the statement, expect a 0 delimiter or the EH region
1211 that the previous statement belongs to. */
1212 tag = input_record_start (ib);
1213 lto_tag_check_set (tag, 2, LTO_eh_region, LTO_null);
1215 if (tag == LTO_eh_region)
1217 HOST_WIDE_INT region = lto_input_sleb128 (ib);
1218 gcc_assert (region == (int) region);
1219 add_stmt_to_eh_lp (stmt, region);
1222 tag = input_record_start (ib);
1225 tag = input_record_start (ib);
1226 while (tag)
1228 gimple phi = input_phi (ib, bb, data_in, fn);
1229 find_referenced_vars_in (phi);
1230 tag = input_record_start (ib);
1234 /* Go through all NODE edges and fixup call_stmt pointers
1235 so they point to STMTS. */
1237 static void
1238 fixup_call_stmt_edges_1 (struct cgraph_node *node, gimple *stmts)
1240 struct cgraph_edge *cedge;
1241 for (cedge = node->callees; cedge; cedge = cedge->next_callee)
1242 cedge->call_stmt = stmts[cedge->lto_stmt_uid];
1243 for (cedge = node->indirect_calls; cedge; cedge = cedge->next_callee)
1244 cedge->call_stmt = stmts[cedge->lto_stmt_uid];
1247 /* Fixup call_stmt pointers in NODE and all clones. */
1249 static void
1250 fixup_call_stmt_edges (struct cgraph_node *orig, gimple *stmts)
1252 struct cgraph_node *node;
1254 while (orig->clone_of)
1255 orig = orig->clone_of;
1257 fixup_call_stmt_edges_1 (orig, stmts);
1258 if (orig->clones)
1259 for (node = orig->clones; node != orig;)
1261 fixup_call_stmt_edges_1 (node, stmts);
1262 if (node->clones)
1263 node = node->clones;
1264 else if (node->next_sibling_clone)
1265 node = node->next_sibling_clone;
1266 else
1268 while (node != orig && !node->next_sibling_clone)
1269 node = node->clone_of;
1270 if (node != orig)
1271 node = node->next_sibling_clone;
1276 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1278 static void
1279 input_function (tree fn_decl, struct data_in *data_in,
1280 struct lto_input_block *ib)
1282 struct function *fn;
1283 enum LTO_tags tag;
1284 gimple *stmts;
1285 basic_block bb;
1286 struct bitpack_d bp;
1287 struct cgraph_node *node;
1288 tree args, narg, oarg;
1290 fn = DECL_STRUCT_FUNCTION (fn_decl);
1291 tag = input_record_start (ib);
1292 clear_line_info (data_in);
1294 gimple_register_cfg_hooks ();
1295 lto_tag_check (tag, LTO_function);
1297 /* Read all the attributes for FN. */
1298 bp = lto_input_bitpack (ib);
1299 fn->is_thunk = bp_unpack_value (&bp, 1);
1300 fn->has_local_explicit_reg_vars = bp_unpack_value (&bp, 1);
1301 fn->after_tree_profile = bp_unpack_value (&bp, 1);
1302 fn->returns_pcc_struct = bp_unpack_value (&bp, 1);
1303 fn->returns_struct = bp_unpack_value (&bp, 1);
1304 fn->can_throw_non_call_exceptions = bp_unpack_value (&bp, 1);
1305 fn->always_inline_functions_inlined = bp_unpack_value (&bp, 1);
1306 fn->after_inlining = bp_unpack_value (&bp, 1);
1307 fn->dont_save_pending_sizes_p = bp_unpack_value (&bp, 1);
1308 fn->stdarg = bp_unpack_value (&bp, 1);
1309 fn->has_nonlocal_label = bp_unpack_value (&bp, 1);
1310 fn->calls_alloca = bp_unpack_value (&bp, 1);
1311 fn->calls_setjmp = bp_unpack_value (&bp, 1);
1312 fn->va_list_fpr_size = bp_unpack_value (&bp, 8);
1313 fn->va_list_gpr_size = bp_unpack_value (&bp, 8);
1315 /* Input the current IL state of the function. */
1316 fn->curr_properties = lto_input_uleb128 (ib);
1318 /* Read the static chain and non-local goto save area. */
1319 fn->static_chain_decl = lto_input_tree (ib, data_in);
1320 fn->nonlocal_goto_save_area = lto_input_tree (ib, data_in);
1322 /* Read all the local symbols. */
1323 fn->local_decls = lto_input_tree (ib, data_in);
1325 /* Read all function arguments. We need to re-map them here to the
1326 arguments of the merged function declaration. */
1327 args = lto_input_tree (ib, data_in);
1328 for (oarg = args, narg = DECL_ARGUMENTS (fn_decl);
1329 oarg && narg;
1330 oarg = TREE_CHAIN (oarg), narg = TREE_CHAIN (narg))
1332 int ix;
1333 bool res;
1334 res = lto_streamer_cache_lookup (data_in->reader_cache, oarg, &ix);
1335 gcc_assert (res);
1336 /* Replace the argument in the streamer cache. */
1337 lto_streamer_cache_insert_at (data_in->reader_cache, narg, ix);
1339 gcc_assert (!oarg && !narg);
1341 /* Read all the SSA names. */
1342 input_ssa_names (ib, data_in, fn);
1344 /* Read the exception handling regions in the function. */
1345 input_eh_regions (ib, data_in, fn);
1347 /* Read the tree of lexical scopes for the function. */
1348 DECL_INITIAL (fn_decl) = lto_input_tree (ib, data_in);
1349 gcc_assert (DECL_INITIAL (fn_decl));
1350 DECL_SAVED_TREE (fn_decl) = NULL_TREE;
1352 /* Read all the basic blocks. */
1353 tag = input_record_start (ib);
1354 while (tag)
1356 input_bb (ib, tag, data_in, fn);
1357 tag = input_record_start (ib);
1360 /* Fix up the call statements that are mentioned in the callgraph
1361 edges. */
1362 renumber_gimple_stmt_uids ();
1363 stmts = (gimple *) xcalloc (gimple_stmt_max_uid (fn), sizeof (gimple));
1364 FOR_ALL_BB (bb)
1366 gimple_stmt_iterator bsi = gsi_start_bb (bb);
1367 while (!gsi_end_p (bsi))
1369 gimple stmt = gsi_stmt (bsi);
1370 /* If we're recompiling LTO objects with debug stmts but
1371 we're not supposed to have debug stmts, remove them now.
1372 We can't remove them earlier because this would cause uid
1373 mismatches in fixups, but we can do it at this point, as
1374 long as debug stmts don't require fixups. */
1375 if (!MAY_HAVE_DEBUG_STMTS && is_gimple_debug (stmt))
1377 gimple_stmt_iterator gsi = bsi;
1378 gsi_next (&bsi);
1379 gsi_remove (&gsi, true);
1381 else
1383 gsi_next (&bsi);
1384 stmts[gimple_uid (stmt)] = stmt;
1389 /* Set the gimple body to the statement sequence in the entry
1390 basic block. FIXME lto, this is fairly hacky. The existence
1391 of a gimple body is used by the cgraph routines, but we should
1392 really use the presence of the CFG. */
1394 edge_iterator ei = ei_start (ENTRY_BLOCK_PTR->succs);
1395 gimple_set_body (fn_decl, bb_seq (ei_edge (ei)->dest));
1398 node = cgraph_node (fn_decl);
1399 fixup_call_stmt_edges (node, stmts);
1400 execute_all_ipa_stmt_fixups (node, stmts);
1402 update_ssa (TODO_update_ssa_only_virtuals);
1403 free_dominance_info (CDI_DOMINATORS);
1404 free_dominance_info (CDI_POST_DOMINATORS);
1405 free (stmts);
1409 /* Read initializer expressions for public statics. DATA_IN is the
1410 file being read. IB is the input block used for reading. */
1412 static void
1413 input_alias_pairs (struct lto_input_block *ib, struct data_in *data_in)
1415 tree var;
1417 clear_line_info (data_in);
1419 /* Skip over all the unreferenced globals. */
1421 var = lto_input_tree (ib, data_in);
1422 while (var);
1424 var = lto_input_tree (ib, data_in);
1425 while (var)
1427 const char *orig_name, *new_name;
1428 alias_pair *p;
1430 p = VEC_safe_push (alias_pair, gc, alias_pairs, NULL);
1431 p->decl = var;
1432 p->target = lto_input_tree (ib, data_in);
1434 /* If the target is a static object, we may have registered a
1435 new name for it to avoid clashes between statics coming from
1436 different files. In that case, use the new name. */
1437 orig_name = IDENTIFIER_POINTER (p->target);
1438 new_name = lto_get_decl_name_mapping (data_in->file_data, orig_name);
1439 if (strcmp (orig_name, new_name) != 0)
1440 p->target = get_identifier (new_name);
1442 var = lto_input_tree (ib, data_in);
1447 /* Read the body from DATA for function FN_DECL and fill it in.
1448 FILE_DATA are the global decls and types. SECTION_TYPE is either
1449 LTO_section_function_body or LTO_section_static_initializer. If
1450 section type is LTO_section_function_body, FN must be the decl for
1451 that function. */
1453 static void
1454 lto_read_body (struct lto_file_decl_data *file_data, tree fn_decl,
1455 const char *data, enum lto_section_type section_type)
1457 const struct lto_function_header *header;
1458 struct data_in *data_in;
1459 int32_t cfg_offset;
1460 int32_t main_offset;
1461 int32_t string_offset;
1462 struct lto_input_block ib_cfg;
1463 struct lto_input_block ib_main;
1465 header = (const struct lto_function_header *) data;
1466 cfg_offset = sizeof (struct lto_function_header);
1467 main_offset = cfg_offset + header->cfg_size;
1468 string_offset = main_offset + header->main_size;
1470 LTO_INIT_INPUT_BLOCK (ib_cfg,
1471 data + cfg_offset,
1473 header->cfg_size);
1475 LTO_INIT_INPUT_BLOCK (ib_main,
1476 data + main_offset,
1478 header->main_size);
1480 data_in = lto_data_in_create (file_data, data + string_offset,
1481 header->string_size, NULL);
1483 /* Make sure the file was generated by the exact same compiler. */
1484 lto_check_version (header->lto_header.major_version,
1485 header->lto_header.minor_version);
1487 if (section_type == LTO_section_function_body)
1489 struct function *fn = DECL_STRUCT_FUNCTION (fn_decl);
1490 struct lto_in_decl_state *decl_state;
1492 push_cfun (fn);
1493 init_tree_ssa (fn);
1495 /* Use the function's decl state. */
1496 decl_state = lto_get_function_in_decl_state (file_data, fn_decl);
1497 gcc_assert (decl_state);
1498 file_data->current_decl_state = decl_state;
1500 input_cfg (&ib_cfg, fn);
1502 /* Set up the struct function. */
1503 input_function (fn_decl, data_in, &ib_main);
1505 /* We should now be in SSA. */
1506 cfun->gimple_df->in_ssa_p = true;
1508 /* Restore decl state */
1509 file_data->current_decl_state = file_data->global_decl_state;
1511 pop_cfun ();
1513 else
1515 input_alias_pairs (&ib_main, data_in);
1518 clear_line_info (data_in);
1519 lto_data_in_delete (data_in);
1523 /* Read the body of FN_DECL using DATA. FILE_DATA holds the global
1524 decls and types. */
1526 void
1527 lto_input_function_body (struct lto_file_decl_data *file_data,
1528 tree fn_decl, const char *data)
1530 current_function_decl = fn_decl;
1531 lto_read_body (file_data, fn_decl, data, LTO_section_function_body);
1535 /* Read in VAR_DECL using DATA. FILE_DATA holds the global decls and
1536 types. */
1538 void
1539 lto_input_constructors_and_inits (struct lto_file_decl_data *file_data,
1540 const char *data)
1542 lto_read_body (file_data, NULL, data, LTO_section_static_initializer);
1546 /* Return the resolution for the decl with index INDEX from DATA_IN. */
1548 static enum ld_plugin_symbol_resolution
1549 get_resolution (struct data_in *data_in, unsigned index)
1551 if (data_in->globals_resolution)
1553 ld_plugin_symbol_resolution_t ret;
1554 /* We can have references to not emitted functions in
1555 DECL_FUNCTION_PERSONALITY at least. So we can and have
1556 to indeed return LDPR_UNKNOWN in some cases. */
1557 if (VEC_length (ld_plugin_symbol_resolution_t,
1558 data_in->globals_resolution) <= index)
1559 return LDPR_UNKNOWN;
1560 ret = VEC_index (ld_plugin_symbol_resolution_t,
1561 data_in->globals_resolution,
1562 index);
1563 return ret;
1565 else
1566 /* Delay resolution finding until decl merging. */
1567 return LDPR_UNKNOWN;
1571 /* Unpack all the non-pointer fields of the TS_BASE structure of
1572 expression EXPR from bitpack BP. */
1574 static void
1575 unpack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
1577 /* Note that the code for EXPR has already been unpacked to create EXPR in
1578 lto_materialize_tree. */
1579 if (!TYPE_P (expr))
1581 TREE_SIDE_EFFECTS (expr) = (unsigned) bp_unpack_value (bp, 1);
1582 TREE_CONSTANT (expr) = (unsigned) bp_unpack_value (bp, 1);
1583 TREE_READONLY (expr) = (unsigned) bp_unpack_value (bp, 1);
1585 /* TREE_PUBLIC is used on types to indicate that the type
1586 has a TYPE_CACHED_VALUES vector. This is not streamed out,
1587 so we skip it here. */
1588 TREE_PUBLIC (expr) = (unsigned) bp_unpack_value (bp, 1);
1590 else
1591 bp_unpack_value (bp, 4);
1592 TREE_ADDRESSABLE (expr) = (unsigned) bp_unpack_value (bp, 1);
1593 TREE_THIS_VOLATILE (expr) = (unsigned) bp_unpack_value (bp, 1);
1594 if (DECL_P (expr))
1595 DECL_UNSIGNED (expr) = (unsigned) bp_unpack_value (bp, 1);
1596 else if (TYPE_P (expr))
1597 TYPE_UNSIGNED (expr) = (unsigned) bp_unpack_value (bp, 1);
1598 else
1599 bp_unpack_value (bp, 1);
1600 TREE_ASM_WRITTEN (expr) = (unsigned) bp_unpack_value (bp, 1);
1601 TREE_NO_WARNING (expr) = (unsigned) bp_unpack_value (bp, 1);
1602 TREE_USED (expr) = (unsigned) bp_unpack_value (bp, 1);
1603 TREE_NOTHROW (expr) = (unsigned) bp_unpack_value (bp, 1);
1604 TREE_STATIC (expr) = (unsigned) bp_unpack_value (bp, 1);
1605 TREE_PRIVATE (expr) = (unsigned) bp_unpack_value (bp, 1);
1606 TREE_PROTECTED (expr) = (unsigned) bp_unpack_value (bp, 1);
1607 TREE_DEPRECATED (expr) = (unsigned) bp_unpack_value (bp, 1);
1608 if (TYPE_P (expr))
1609 TYPE_SATURATING (expr) = (unsigned) bp_unpack_value (bp, 1);
1610 else if (TREE_CODE (expr) == SSA_NAME)
1611 SSA_NAME_IS_DEFAULT_DEF (expr) = (unsigned) bp_unpack_value (bp, 1);
1612 else
1613 bp_unpack_value (bp, 1);
1617 /* Unpack all the non-pointer fields of the TS_REAL_CST structure of
1618 expression EXPR from bitpack BP. */
1620 static void
1621 unpack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
1623 unsigned i;
1624 REAL_VALUE_TYPE r;
1625 REAL_VALUE_TYPE *rp;
1627 r.cl = (unsigned) bp_unpack_value (bp, 2);
1628 r.decimal = (unsigned) bp_unpack_value (bp, 1);
1629 r.sign = (unsigned) bp_unpack_value (bp, 1);
1630 r.signalling = (unsigned) bp_unpack_value (bp, 1);
1631 r.canonical = (unsigned) bp_unpack_value (bp, 1);
1632 r.uexp = (unsigned) bp_unpack_value (bp, EXP_BITS);
1633 for (i = 0; i < SIGSZ; i++)
1634 r.sig[i] = (unsigned long) bp_unpack_value (bp, HOST_BITS_PER_LONG);
1636 rp = ggc_alloc_real_value ();
1637 memcpy (rp, &r, sizeof (REAL_VALUE_TYPE));
1638 TREE_REAL_CST_PTR (expr) = rp;
1642 /* Unpack all the non-pointer fields of the TS_FIXED_CST structure of
1643 expression EXPR from bitpack BP. */
1645 static void
1646 unpack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr)
1648 struct fixed_value fv;
1650 fv.data.low = (HOST_WIDE_INT) bp_unpack_value (bp, HOST_BITS_PER_WIDE_INT);
1651 fv.data.high = (HOST_WIDE_INT) bp_unpack_value (bp, HOST_BITS_PER_WIDE_INT);
1652 fv.mode = (enum machine_mode) bp_unpack_value (bp, HOST_BITS_PER_INT);
1653 TREE_FIXED_CST (expr) = fv;
1657 /* Unpack all the non-pointer fields of the TS_DECL_COMMON structure
1658 of expression EXPR from bitpack BP. */
1660 static void
1661 unpack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr)
1663 DECL_MODE (expr) = (enum machine_mode) bp_unpack_value (bp, 8);
1664 DECL_NONLOCAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1665 DECL_VIRTUAL_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1666 DECL_IGNORED_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1667 DECL_ABSTRACT (expr) = (unsigned) bp_unpack_value (bp, 1);
1668 DECL_ARTIFICIAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1669 DECL_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1);
1670 DECL_PRESERVE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1671 DECL_DEBUG_EXPR_IS_FROM (expr) = (unsigned) bp_unpack_value (bp, 1);
1672 DECL_EXTERNAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1673 DECL_GIMPLE_REG_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1674 DECL_ALIGN (expr) = (unsigned) bp_unpack_value (bp, HOST_BITS_PER_INT);
1676 if (TREE_CODE (expr) == LABEL_DECL)
1678 DECL_ERROR_ISSUED (expr) = (unsigned) bp_unpack_value (bp, 1);
1679 EH_LANDING_PAD_NR (expr) = (int) bp_unpack_value (bp, HOST_BITS_PER_INT);
1681 /* Always assume an initial value of -1 for LABEL_DECL_UID to
1682 force gimple_set_bb to recreate label_to_block_map. */
1683 LABEL_DECL_UID (expr) = -1;
1686 if (TREE_CODE (expr) == FIELD_DECL)
1688 unsigned HOST_WIDE_INT off_align;
1689 DECL_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
1690 DECL_NONADDRESSABLE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1691 off_align = (unsigned HOST_WIDE_INT) bp_unpack_value (bp, 8);
1692 SET_DECL_OFFSET_ALIGN (expr, off_align);
1695 if (TREE_CODE (expr) == RESULT_DECL
1696 || TREE_CODE (expr) == PARM_DECL
1697 || TREE_CODE (expr) == VAR_DECL)
1699 DECL_BY_REFERENCE (expr) = (unsigned) bp_unpack_value (bp, 1);
1700 if (TREE_CODE (expr) == VAR_DECL
1701 || TREE_CODE (expr) == PARM_DECL)
1702 DECL_HAS_VALUE_EXPR_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1703 DECL_RESTRICTED_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1708 /* Unpack all the non-pointer fields of the TS_DECL_WRTL structure
1709 of expression EXPR from bitpack BP. */
1711 static void
1712 unpack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
1714 DECL_REGISTER (expr) = (unsigned) bp_unpack_value (bp, 1);
1718 /* Unpack all the non-pointer fields of the TS_DECL_WITH_VIS structure
1719 of expression EXPR from bitpack BP. */
1721 static void
1722 unpack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
1724 DECL_DEFER_OUTPUT (expr) = (unsigned) bp_unpack_value (bp, 1);
1725 DECL_COMMON (expr) = (unsigned) bp_unpack_value (bp, 1);
1726 DECL_DLLIMPORT_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1727 DECL_WEAK (expr) = (unsigned) bp_unpack_value (bp, 1);
1728 DECL_SEEN_IN_BIND_EXPR_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1729 DECL_COMDAT (expr) = (unsigned) bp_unpack_value (bp, 1);
1730 DECL_VISIBILITY (expr) = (enum symbol_visibility) bp_unpack_value (bp, 2);
1731 DECL_VISIBILITY_SPECIFIED (expr) = (unsigned) bp_unpack_value (bp, 1);
1733 if (TREE_CODE (expr) == VAR_DECL)
1735 DECL_HARD_REGISTER (expr) = (unsigned) bp_unpack_value (bp, 1);
1736 DECL_IN_TEXT_SECTION (expr) = (unsigned) bp_unpack_value (bp, 1);
1737 DECL_IN_CONSTANT_POOL (expr) = (unsigned) bp_unpack_value (bp, 1);
1738 DECL_TLS_MODEL (expr) = (enum tls_model) bp_unpack_value (bp, 3);
1741 if (VAR_OR_FUNCTION_DECL_P (expr))
1743 priority_type p;
1744 p = (priority_type) bp_unpack_value (bp, HOST_BITS_PER_SHORT);
1745 SET_DECL_INIT_PRIORITY (expr, p);
1750 /* Unpack all the non-pointer fields of the TS_FUNCTION_DECL structure
1751 of expression EXPR from bitpack BP. */
1753 static void
1754 unpack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
1756 DECL_FUNCTION_CODE (expr) = (enum built_in_function) bp_unpack_value (bp, 11);
1757 DECL_BUILT_IN_CLASS (expr) = (enum built_in_class) bp_unpack_value (bp, 2);
1758 DECL_STATIC_CONSTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
1759 DECL_STATIC_DESTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
1760 DECL_UNINLINABLE (expr) = (unsigned) bp_unpack_value (bp, 1);
1761 DECL_POSSIBLY_INLINED (expr) = (unsigned) bp_unpack_value (bp, 1);
1762 DECL_IS_NOVOPS (expr) = (unsigned) bp_unpack_value (bp, 1);
1763 DECL_IS_RETURNS_TWICE (expr) = (unsigned) bp_unpack_value (bp, 1);
1764 DECL_IS_MALLOC (expr) = (unsigned) bp_unpack_value (bp, 1);
1765 DECL_IS_OPERATOR_NEW (expr) = (unsigned) bp_unpack_value (bp, 1);
1766 DECL_DECLARED_INLINE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1767 DECL_STATIC_CHAIN (expr) = (unsigned) bp_unpack_value (bp, 1);
1768 DECL_NO_INLINE_WARNING_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1769 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr)
1770 = (unsigned) bp_unpack_value (bp, 1);
1771 DECL_NO_LIMIT_STACK (expr) = (unsigned) bp_unpack_value (bp, 1);
1772 DECL_DISREGARD_INLINE_LIMITS (expr) = (unsigned) bp_unpack_value (bp, 1);
1773 DECL_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1774 DECL_LOOPING_CONST_OR_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1778 /* Unpack all the non-pointer fields of the TS_TYPE structure
1779 of expression EXPR from bitpack BP. */
1781 static void
1782 unpack_ts_type_value_fields (struct bitpack_d *bp, tree expr)
1784 enum machine_mode mode;
1786 TYPE_PRECISION (expr) = (unsigned) bp_unpack_value (bp, 10);
1787 mode = (enum machine_mode) bp_unpack_value (bp, 8);
1788 SET_TYPE_MODE (expr, mode);
1789 TYPE_STRING_FLAG (expr) = (unsigned) bp_unpack_value (bp, 1);
1790 TYPE_NO_FORCE_BLK (expr) = (unsigned) bp_unpack_value (bp, 1);
1791 TYPE_NEEDS_CONSTRUCTING (expr) = (unsigned) bp_unpack_value (bp, 1);
1792 if (RECORD_OR_UNION_TYPE_P (expr))
1793 TYPE_TRANSPARENT_AGGR (expr) = (unsigned) bp_unpack_value (bp, 1);
1794 TYPE_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
1795 TYPE_RESTRICT (expr) = (unsigned) bp_unpack_value (bp, 1);
1796 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr)
1797 = (unsigned) bp_unpack_value (bp, 2);
1798 TYPE_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1);
1799 TYPE_READONLY (expr) = (unsigned) bp_unpack_value (bp, 1);
1800 TYPE_ALIGN (expr) = (unsigned) bp_unpack_value (bp, HOST_BITS_PER_INT);
1801 TYPE_ALIAS_SET (expr) = bp_unpack_value (bp, HOST_BITS_PER_INT);
1805 /* Unpack all the non-pointer fields of the TS_BLOCK structure
1806 of expression EXPR from bitpack BP. */
1808 static void
1809 unpack_ts_block_value_fields (struct bitpack_d *bp, tree expr)
1811 BLOCK_ABSTRACT (expr) = (unsigned) bp_unpack_value (bp, 1);
1812 BLOCK_NUMBER (expr) = (unsigned) bp_unpack_value (bp, 31);
1816 /* Unpack all the non-pointer fields in EXPR into a bit pack. */
1818 static void
1819 unpack_value_fields (struct bitpack_d *bp, tree expr)
1821 enum tree_code code;
1823 code = TREE_CODE (expr);
1825 /* Note that all these functions are highly sensitive to changes in
1826 the types and sizes of each of the fields being packed. */
1827 unpack_ts_base_value_fields (bp, expr);
1829 if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
1830 unpack_ts_real_cst_value_fields (bp, expr);
1832 if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
1833 unpack_ts_fixed_cst_value_fields (bp, expr);
1835 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
1836 unpack_ts_decl_common_value_fields (bp, expr);
1838 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
1839 unpack_ts_decl_wrtl_value_fields (bp, expr);
1841 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
1842 unpack_ts_decl_with_vis_value_fields (bp, expr);
1844 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
1845 unpack_ts_function_decl_value_fields (bp, expr);
1847 if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
1848 unpack_ts_type_value_fields (bp, expr);
1850 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
1851 unpack_ts_block_value_fields (bp, expr);
1853 if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
1855 /* We only stream the version number of SSA names. */
1856 gcc_unreachable ();
1859 if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
1861 /* This is only used by GENERIC. */
1862 gcc_unreachable ();
1865 if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
1867 /* This is only used by High GIMPLE. */
1868 gcc_unreachable ();
1873 /* Materialize a new tree from input block IB using descriptors in
1874 DATA_IN. The code for the new tree should match TAG. Store in
1875 *IX_P the index into the reader cache where the new tree is stored. */
1877 static tree
1878 lto_materialize_tree (struct lto_input_block *ib, struct data_in *data_in,
1879 enum LTO_tags tag, int *ix_p)
1881 struct bitpack_d bp;
1882 enum tree_code code;
1883 tree result;
1884 #ifdef LTO_STREAMER_DEBUG
1885 HOST_WIDEST_INT orig_address_in_writer;
1886 #endif
1887 HOST_WIDE_INT ix;
1889 result = NULL_TREE;
1891 /* Read the header of the node we are about to create. */
1892 ix = lto_input_sleb128 (ib);
1893 gcc_assert ((int) ix == ix);
1894 *ix_p = (int) ix;
1896 #ifdef LTO_STREAMER_DEBUG
1897 /* Read the word representing the memory address for the tree
1898 as it was written by the writer. This is useful when
1899 debugging differences between the writer and reader. */
1900 orig_address_in_writer = lto_input_sleb128 (ib);
1901 gcc_assert ((intptr_t) orig_address_in_writer == orig_address_in_writer);
1902 #endif
1904 code = lto_tag_to_tree_code (tag);
1906 /* We should never see an SSA_NAME tree. Only the version numbers of
1907 SSA names are ever written out. See input_ssa_names. */
1908 gcc_assert (code != SSA_NAME);
1910 /* Instantiate a new tree using the header data. */
1911 if (CODE_CONTAINS_STRUCT (code, TS_STRING))
1912 result = input_string_cst (data_in, ib);
1913 else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
1914 result = input_identifier (data_in, ib);
1915 else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1917 HOST_WIDE_INT len = lto_input_sleb128 (ib);
1918 result = make_tree_vec (len);
1920 else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1922 unsigned HOST_WIDE_INT len = lto_input_uleb128 (ib);
1923 result = make_tree_binfo (len);
1925 else
1927 /* All other nodes can be materialized with a raw make_node
1928 call. */
1929 result = make_node (code);
1932 #ifdef LTO_STREAMER_DEBUG
1933 /* Store the original address of the tree as seen by the writer
1934 in RESULT's aux field. This is useful when debugging streaming
1935 problems. This way, a debugging session can be started on
1936 both writer and reader with a breakpoint using this address
1937 value in both. */
1938 lto_orig_address_map (result, (intptr_t) orig_address_in_writer);
1939 #endif
1941 /* Read the bitpack of non-pointer values from IB. */
1942 bp = lto_input_bitpack (ib);
1944 /* The first word in BP contains the code of the tree that we
1945 are about to read. */
1946 code = (enum tree_code) bp_unpack_value (&bp, 16);
1947 lto_tag_check (lto_tree_code_to_tag (code), tag);
1949 /* Unpack all the value fields from BP. */
1950 unpack_value_fields (&bp, result);
1952 /* Enter RESULT in the reader cache. This will make RESULT
1953 available so that circular references in the rest of the tree
1954 structure can be resolved in subsequent calls to lto_input_tree. */
1955 lto_streamer_cache_insert_at (data_in->reader_cache, result, ix);
1957 return result;
1961 /* Read a chain of tree nodes from input block IB. DATA_IN contains
1962 tables and descriptors for the file being read. */
1964 static tree
1965 lto_input_chain (struct lto_input_block *ib, struct data_in *data_in)
1967 int i, count;
1968 tree first, prev, curr;
1970 first = prev = NULL_TREE;
1971 count = lto_input_sleb128 (ib);
1972 for (i = 0; i < count; i++)
1974 curr = lto_input_tree (ib, data_in);
1975 if (prev)
1976 TREE_CHAIN (prev) = curr;
1977 else
1978 first = curr;
1980 TREE_CHAIN (curr) = NULL_TREE;
1981 prev = curr;
1984 return first;
1988 /* Read all pointer fields in the TS_COMMON structure of EXPR from input
1989 block IB. DATA_IN contains tables and descriptors for the
1990 file being read. */
1993 static void
1994 lto_input_ts_common_tree_pointers (struct lto_input_block *ib,
1995 struct data_in *data_in, tree expr)
1997 TREE_TYPE (expr) = lto_input_tree (ib, data_in);
2001 /* Read all pointer fields in the TS_VECTOR structure of EXPR from input
2002 block IB. DATA_IN contains tables and descriptors for the
2003 file being read. */
2005 static void
2006 lto_input_ts_vector_tree_pointers (struct lto_input_block *ib,
2007 struct data_in *data_in, tree expr)
2009 TREE_VECTOR_CST_ELTS (expr) = lto_input_chain (ib, data_in);
2013 /* Read all pointer fields in the TS_COMPLEX structure of EXPR from input
2014 block IB. DATA_IN contains tables and descriptors for the
2015 file being read. */
2017 static void
2018 lto_input_ts_complex_tree_pointers (struct lto_input_block *ib,
2019 struct data_in *data_in, tree expr)
2021 TREE_REALPART (expr) = lto_input_tree (ib, data_in);
2022 TREE_IMAGPART (expr) = lto_input_tree (ib, data_in);
2026 /* Read all pointer fields in the TS_DECL_MINIMAL structure of EXPR
2027 from input block IB. DATA_IN contains tables and descriptors for the
2028 file being read. */
2030 static void
2031 lto_input_ts_decl_minimal_tree_pointers (struct lto_input_block *ib,
2032 struct data_in *data_in, tree expr)
2034 DECL_NAME (expr) = lto_input_tree (ib, data_in);
2035 DECL_CONTEXT (expr) = lto_input_tree (ib, data_in);
2036 DECL_SOURCE_LOCATION (expr) = lto_input_location (ib, data_in);
2040 /* Read all pointer fields in the TS_DECL_COMMON structure of EXPR from
2041 input block IB. DATA_IN contains tables and descriptors for the
2042 file being read. */
2044 static void
2045 lto_input_ts_decl_common_tree_pointers (struct lto_input_block *ib,
2046 struct data_in *data_in, tree expr)
2048 DECL_SIZE (expr) = lto_input_tree (ib, data_in);
2049 DECL_SIZE_UNIT (expr) = lto_input_tree (ib, data_in);
2051 if (TREE_CODE (expr) != FUNCTION_DECL)
2052 DECL_INITIAL (expr) = lto_input_tree (ib, data_in);
2054 DECL_ATTRIBUTES (expr) = lto_input_tree (ib, data_in);
2055 DECL_ABSTRACT_ORIGIN (expr) = lto_input_tree (ib, data_in);
2057 if (TREE_CODE (expr) == PARM_DECL)
2058 TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
2060 if ((TREE_CODE (expr) == VAR_DECL
2061 || TREE_CODE (expr) == PARM_DECL)
2062 && DECL_HAS_VALUE_EXPR_P (expr))
2063 SET_DECL_VALUE_EXPR (expr, lto_input_tree (ib, data_in));
2067 /* Read all pointer fields in the TS_DECL_NON_COMMON structure of
2068 EXPR from input block IB. DATA_IN contains tables and descriptors for the
2069 file being read. */
2071 static void
2072 lto_input_ts_decl_non_common_tree_pointers (struct lto_input_block *ib,
2073 struct data_in *data_in, tree expr)
2075 if (TREE_CODE (expr) == FUNCTION_DECL)
2077 DECL_ARGUMENTS (expr) = lto_input_tree (ib, data_in);
2078 DECL_RESULT (expr) = lto_input_tree (ib, data_in);
2080 DECL_VINDEX (expr) = lto_input_tree (ib, data_in);
2084 /* Read all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
2085 from input block IB. DATA_IN contains tables and descriptors for the
2086 file being read. */
2088 static void
2089 lto_input_ts_decl_with_vis_tree_pointers (struct lto_input_block *ib,
2090 struct data_in *data_in, tree expr)
2092 tree id;
2094 id = lto_input_tree (ib, data_in);
2095 if (id)
2097 gcc_assert (TREE_CODE (id) == IDENTIFIER_NODE);
2098 SET_DECL_ASSEMBLER_NAME (expr, id);
2101 DECL_SECTION_NAME (expr) = lto_input_tree (ib, data_in);
2102 DECL_COMDAT_GROUP (expr) = lto_input_tree (ib, data_in);
2106 /* Read all pointer fields in the TS_FIELD_DECL structure of EXPR from
2107 input block IB. DATA_IN contains tables and descriptors for the
2108 file being read. */
2110 static void
2111 lto_input_ts_field_decl_tree_pointers (struct lto_input_block *ib,
2112 struct data_in *data_in, tree expr)
2114 DECL_FIELD_OFFSET (expr) = lto_input_tree (ib, data_in);
2115 DECL_BIT_FIELD_TYPE (expr) = lto_input_tree (ib, data_in);
2116 DECL_QUALIFIER (expr) = lto_input_tree (ib, data_in);
2117 DECL_FIELD_BIT_OFFSET (expr) = lto_input_tree (ib, data_in);
2118 DECL_FCONTEXT (expr) = lto_input_tree (ib, data_in);
2119 TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
2123 /* Read all pointer fields in the TS_FUNCTION_DECL structure of EXPR
2124 from input block IB. DATA_IN contains tables and descriptors for the
2125 file being read. */
2127 static void
2128 lto_input_ts_function_decl_tree_pointers (struct lto_input_block *ib,
2129 struct data_in *data_in, tree expr)
2131 /* DECL_STRUCT_FUNCTION is handled by lto_input_function. FIXME lto,
2132 maybe it should be handled here? */
2133 DECL_FUNCTION_PERSONALITY (expr) = lto_input_tree (ib, data_in);
2134 DECL_FUNCTION_SPECIFIC_TARGET (expr) = lto_input_tree (ib, data_in);
2135 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr) = lto_input_tree (ib, data_in);
2137 /* If the file contains a function with an EH personality set,
2138 then it was compiled with -fexceptions. In that case, initialize
2139 the backend EH machinery. */
2140 if (DECL_FUNCTION_PERSONALITY (expr))
2141 lto_init_eh ();
2145 /* Read all pointer fields in the TS_TYPE structure of EXPR from input
2146 block IB. DATA_IN contains tables and descriptors for the
2147 file being read. */
2149 static void
2150 lto_input_ts_type_tree_pointers (struct lto_input_block *ib,
2151 struct data_in *data_in, tree expr)
2153 if (TREE_CODE (expr) == ENUMERAL_TYPE)
2154 TYPE_VALUES (expr) = lto_input_tree (ib, data_in);
2155 else if (TREE_CODE (expr) == ARRAY_TYPE)
2156 TYPE_DOMAIN (expr) = lto_input_tree (ib, data_in);
2157 else if (RECORD_OR_UNION_TYPE_P (expr))
2158 TYPE_FIELDS (expr) = lto_input_tree (ib, data_in);
2159 else if (TREE_CODE (expr) == FUNCTION_TYPE
2160 || TREE_CODE (expr) == METHOD_TYPE)
2161 TYPE_ARG_TYPES (expr) = lto_input_tree (ib, data_in);
2162 else if (TREE_CODE (expr) == VECTOR_TYPE)
2163 TYPE_DEBUG_REPRESENTATION_TYPE (expr) = lto_input_tree (ib, data_in);
2165 TYPE_SIZE (expr) = lto_input_tree (ib, data_in);
2166 TYPE_SIZE_UNIT (expr) = lto_input_tree (ib, data_in);
2167 TYPE_ATTRIBUTES (expr) = lto_input_tree (ib, data_in);
2168 TYPE_NAME (expr) = lto_input_tree (ib, data_in);
2169 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO nor
2170 TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. */
2171 if (!POINTER_TYPE_P (expr))
2172 TYPE_MINVAL (expr) = lto_input_tree (ib, data_in);
2173 TYPE_MAXVAL (expr) = lto_input_tree (ib, data_in);
2174 TYPE_MAIN_VARIANT (expr) = lto_input_tree (ib, data_in);
2175 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
2176 during fixup. */
2177 if (RECORD_OR_UNION_TYPE_P (expr))
2178 TYPE_BINFO (expr) = lto_input_tree (ib, data_in);
2179 TYPE_CONTEXT (expr) = lto_input_tree (ib, data_in);
2180 /* TYPE_CANONICAL gets re-computed during type merging. */
2181 TYPE_CANONICAL (expr) = NULL_TREE;
2182 TYPE_STUB_DECL (expr) = lto_input_tree (ib, data_in);
2186 /* Read all pointer fields in the TS_LIST structure of EXPR from input
2187 block IB. DATA_IN contains tables and descriptors for the
2188 file being read. */
2190 static void
2191 lto_input_ts_list_tree_pointers (struct lto_input_block *ib,
2192 struct data_in *data_in, tree expr)
2194 TREE_PURPOSE (expr) = lto_input_tree (ib, data_in);
2195 TREE_VALUE (expr) = lto_input_tree (ib, data_in);
2196 TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
2200 /* Read all pointer fields in the TS_VEC structure of EXPR from input
2201 block IB. DATA_IN contains tables and descriptors for the
2202 file being read. */
2204 static void
2205 lto_input_ts_vec_tree_pointers (struct lto_input_block *ib,
2206 struct data_in *data_in, tree expr)
2208 int i;
2210 /* Note that TREE_VEC_LENGTH was read by lto_materialize_tree to
2211 instantiate EXPR. */
2212 for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
2213 TREE_VEC_ELT (expr, i) = lto_input_tree (ib, data_in);
2217 /* Read all pointer fields in the TS_EXP structure of EXPR from input
2218 block IB. DATA_IN contains tables and descriptors for the
2219 file being read. */
2222 static void
2223 lto_input_ts_exp_tree_pointers (struct lto_input_block *ib,
2224 struct data_in *data_in, tree expr)
2226 int i, length;
2227 location_t loc;
2229 length = lto_input_sleb128 (ib);
2230 gcc_assert (length == TREE_OPERAND_LENGTH (expr));
2232 for (i = 0; i < length; i++)
2233 TREE_OPERAND (expr, i) = lto_input_tree (ib, data_in);
2235 loc = lto_input_location (ib, data_in);
2236 SET_EXPR_LOCATION (expr, loc);
2237 TREE_BLOCK (expr) = lto_input_tree (ib, data_in);
2241 /* Read all pointer fields in the TS_BLOCK structure of EXPR from input
2242 block IB. DATA_IN contains tables and descriptors for the
2243 file being read. */
2245 static void
2246 lto_input_ts_block_tree_pointers (struct lto_input_block *ib,
2247 struct data_in *data_in, tree expr)
2249 unsigned i, len;
2251 BLOCK_SOURCE_LOCATION (expr) = lto_input_location (ib, data_in);
2252 BLOCK_VARS (expr) = lto_input_chain (ib, data_in);
2254 len = lto_input_uleb128 (ib);
2255 for (i = 0; i < len; i++)
2257 tree t = lto_input_tree (ib, data_in);
2258 VEC_safe_push (tree, gc, BLOCK_NONLOCALIZED_VARS (expr), t);
2261 BLOCK_SUPERCONTEXT (expr) = lto_input_tree (ib, data_in);
2262 BLOCK_ABSTRACT_ORIGIN (expr) = lto_input_tree (ib, data_in);
2263 BLOCK_FRAGMENT_ORIGIN (expr) = lto_input_tree (ib, data_in);
2264 BLOCK_FRAGMENT_CHAIN (expr) = lto_input_tree (ib, data_in);
2265 BLOCK_SUBBLOCKS (expr) = lto_input_chain (ib, data_in);
2269 /* Read all pointer fields in the TS_BINFO structure of EXPR from input
2270 block IB. DATA_IN contains tables and descriptors for the
2271 file being read. */
2273 static void
2274 lto_input_ts_binfo_tree_pointers (struct lto_input_block *ib,
2275 struct data_in *data_in, tree expr)
2277 unsigned i, len;
2278 tree t;
2280 /* Note that the number of slots in EXPR was read in
2281 lto_materialize_tree when instantiating EXPR. However, the
2282 vector is empty so we cannot rely on VEC_length to know how many
2283 elements to read. So, this list is emitted as a 0-terminated
2284 list on the writer side. */
2287 t = lto_input_tree (ib, data_in);
2288 if (t)
2289 VEC_quick_push (tree, BINFO_BASE_BINFOS (expr), t);
2291 while (t);
2293 BINFO_OFFSET (expr) = lto_input_tree (ib, data_in);
2294 BINFO_VTABLE (expr) = lto_input_tree (ib, data_in);
2295 BINFO_VIRTUALS (expr) = lto_input_tree (ib, data_in);
2296 BINFO_VPTR_FIELD (expr) = lto_input_tree (ib, data_in);
2298 len = lto_input_uleb128 (ib);
2299 for (i = 0; i < len; i++)
2301 tree a = lto_input_tree (ib, data_in);
2302 VEC_safe_push (tree, gc, BINFO_BASE_ACCESSES (expr), a);
2305 BINFO_INHERITANCE_CHAIN (expr) = lto_input_tree (ib, data_in);
2306 BINFO_SUBVTT_INDEX (expr) = lto_input_tree (ib, data_in);
2307 BINFO_VPTR_INDEX (expr) = lto_input_tree (ib, data_in);
2311 /* Read all pointer fields in the TS_CONSTRUCTOR structure of EXPR from
2312 input block IB. DATA_IN contains tables and descriptors for the
2313 file being read. */
2315 static void
2316 lto_input_ts_constructor_tree_pointers (struct lto_input_block *ib,
2317 struct data_in *data_in, tree expr)
2319 unsigned i, len;
2321 len = lto_input_uleb128 (ib);
2322 for (i = 0; i < len; i++)
2324 tree index, value;
2326 index = lto_input_tree (ib, data_in);
2327 value = lto_input_tree (ib, data_in);
2328 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (expr), index, value);
2333 /* Helper for lto_input_tree. Read all pointer fields in EXPR from
2334 input block IB. DATA_IN contains tables and descriptors for the
2335 file being read. */
2337 static void
2338 lto_input_tree_pointers (struct lto_input_block *ib, struct data_in *data_in,
2339 tree expr)
2341 enum tree_code code;
2343 code = TREE_CODE (expr);
2345 if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
2346 lto_input_ts_common_tree_pointers (ib, data_in, expr);
2348 if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
2349 lto_input_ts_vector_tree_pointers (ib, data_in, expr);
2351 if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
2352 lto_input_ts_complex_tree_pointers (ib, data_in, expr);
2354 if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
2355 lto_input_ts_decl_minimal_tree_pointers (ib, data_in, expr);
2357 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
2358 lto_input_ts_decl_common_tree_pointers (ib, data_in, expr);
2360 if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
2361 lto_input_ts_decl_non_common_tree_pointers (ib, data_in, expr);
2363 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
2364 lto_input_ts_decl_with_vis_tree_pointers (ib, data_in, expr);
2366 if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
2367 lto_input_ts_field_decl_tree_pointers (ib, data_in, expr);
2369 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
2370 lto_input_ts_function_decl_tree_pointers (ib, data_in, expr);
2372 if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
2373 lto_input_ts_type_tree_pointers (ib, data_in, expr);
2375 if (CODE_CONTAINS_STRUCT (code, TS_LIST))
2376 lto_input_ts_list_tree_pointers (ib, data_in, expr);
2378 if (CODE_CONTAINS_STRUCT (code, TS_VEC))
2379 lto_input_ts_vec_tree_pointers (ib, data_in, expr);
2381 if (CODE_CONTAINS_STRUCT (code, TS_EXP))
2382 lto_input_ts_exp_tree_pointers (ib, data_in, expr);
2384 if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
2386 /* We only stream the version number of SSA names. */
2387 gcc_unreachable ();
2390 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
2391 lto_input_ts_block_tree_pointers (ib, data_in, expr);
2393 if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
2394 lto_input_ts_binfo_tree_pointers (ib, data_in, expr);
2396 if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
2398 /* This should only appear in GENERIC. */
2399 gcc_unreachable ();
2402 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
2403 lto_input_ts_constructor_tree_pointers (ib, data_in, expr);
2405 if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
2407 /* This should only appear in High GIMPLE. */
2408 gcc_unreachable ();
2411 if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
2413 sorry ("optimization options not supported yet");
2416 if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
2418 sorry ("target optimization options not supported yet");
2423 /* Register DECL with the global symbol table and change its
2424 name if necessary to avoid name clashes for static globals across
2425 different files. */
2427 static void
2428 lto_register_var_decl_in_symtab (struct data_in *data_in, tree decl)
2430 /* Register symbols with file or global scope to mark what input
2431 file has their definition. */
2432 if (decl_function_context (decl) == NULL_TREE)
2434 /* Variable has file scope, not local. Need to ensure static variables
2435 between different files don't clash unexpectedly. */
2436 if (!TREE_PUBLIC (decl))
2438 /* ??? We normally pre-mangle names before we serialize them
2439 out. Here, in lto1, we do not know the language, and
2440 thus cannot do the mangling again. Instead, we just
2441 append a suffix to the mangled name. The resulting name,
2442 however, is not a properly-formed mangled name, and will
2443 confuse any attempt to unmangle it. */
2444 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2445 char *label;
2447 ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
2448 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
2449 rest_of_decl_compilation (decl, 1, 0);
2453 /* If this variable has already been declared, queue the
2454 declaration for merging. */
2455 if (TREE_PUBLIC (decl))
2457 int 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);
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. */
2472 static void
2473 lto_register_function_decl_in_symtab (struct data_in *data_in, tree decl)
2475 /* Need to ensure static entities between different files
2476 don't clash unexpectedly. */
2477 if (!TREE_PUBLIC (decl))
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;
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;
2492 ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
2493 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
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)
2500 tree new_assembler_name = DECL_ASSEMBLER_NAME (decl);
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));
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));
2520 /* If this variable has already been declared, queue the
2521 declaration for merging. */
2522 if (TREE_PUBLIC (decl) && !DECL_ABSTRACT (decl))
2524 int 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);
2533 /* Read an index IX from input block IB and return the tree node at
2534 DATA_IN->FILE_DATA->GLOBALS_INDEX[IX]. */
2536 static tree
2537 lto_get_pickled_tree (struct lto_input_block *ib, struct data_in *data_in)
2539 HOST_WIDE_INT ix;
2540 tree result;
2541 enum LTO_tags expected_tag;
2542 unsigned HOST_WIDE_INT orig_offset;
2544 ix = lto_input_sleb128 (ib);
2545 expected_tag = (enum LTO_tags) lto_input_uleb128 (ib);
2547 orig_offset = lto_input_uleb128 (ib);
2548 gcc_assert (orig_offset == (unsigned) orig_offset);
2550 result = lto_streamer_cache_get (data_in->reader_cache, ix);
2551 if (result == NULL_TREE)
2553 /* We have not yet read the cache slot IX. Go to the offset
2554 in the stream where the physical tree node is, and materialize
2555 it from there. */
2556 struct lto_input_block fwd_ib;
2558 /* If we are trying to go back in the stream, something is wrong.
2559 We should've read the node at the earlier position already. */
2560 if (ib->p >= orig_offset)
2561 internal_error ("bytecode stream: tried to jump backwards in the "
2562 "stream");
2564 LTO_INIT_INPUT_BLOCK (fwd_ib, ib->data, orig_offset, ib->len);
2565 result = lto_input_tree (&fwd_ib, data_in);
2568 gcc_assert (result
2569 && TREE_CODE (result) == lto_tag_to_tree_code (expected_tag));
2571 return result;
2575 /* Read a code and class from input block IB and return the
2576 corresponding builtin. DATA_IN is as in lto_input_tree. */
2578 static tree
2579 lto_get_builtin_tree (struct lto_input_block *ib, struct data_in *data_in)
2581 enum built_in_class fclass;
2582 enum built_in_function fcode;
2583 const char *asmname;
2584 tree result;
2585 int ix;
2587 fclass = (enum built_in_class) lto_input_uleb128 (ib);
2588 gcc_assert (fclass == BUILT_IN_NORMAL || fclass == BUILT_IN_MD);
2590 fcode = (enum built_in_function) lto_input_uleb128 (ib);
2592 ix = lto_input_sleb128 (ib);
2593 gcc_assert (ix == (int) ix);
2595 if (fclass == BUILT_IN_NORMAL)
2597 gcc_assert (fcode < END_BUILTINS);
2598 result = built_in_decls[fcode];
2599 gcc_assert (result);
2601 else if (fclass == BUILT_IN_MD)
2603 result = targetm.builtin_decl (fcode, true);
2604 if (!result || result == error_mark_node)
2605 fatal_error ("target specific builtin not available");
2607 else
2608 gcc_unreachable ();
2610 asmname = input_string (data_in, ib);
2611 if (asmname)
2612 set_builtin_user_assembler_name (result, asmname);
2614 lto_streamer_cache_insert_at (data_in->reader_cache, result, ix);
2616 return result;
2620 /* Read the physical representation of a tree node with tag TAG from
2621 input block IB using the per-file context in DATA_IN. */
2623 static tree
2624 lto_read_tree (struct lto_input_block *ib, struct data_in *data_in,
2625 enum LTO_tags tag)
2627 tree result;
2628 int ix;
2630 result = lto_materialize_tree (ib, data_in, tag, &ix);
2632 /* Read all the pointer fields in RESULT. */
2633 lto_input_tree_pointers (ib, data_in, result);
2635 /* We should never try to instantiate an MD or NORMAL builtin here. */
2636 if (TREE_CODE (result) == FUNCTION_DECL)
2637 gcc_assert (!lto_stream_as_builtin_p (result));
2639 if (TREE_CODE (result) == VAR_DECL)
2640 lto_register_var_decl_in_symtab (data_in, result);
2641 else if (TREE_CODE (result) == FUNCTION_DECL && !DECL_BUILT_IN (result))
2642 lto_register_function_decl_in_symtab (data_in, result);
2644 /* end_marker = */ lto_input_1_unsigned (ib);
2646 #ifdef LTO_STREAMER_DEBUG
2647 /* Remove the mapping to RESULT's original address set by
2648 lto_materialize_tree. */
2649 lto_orig_address_remove (result);
2650 #endif
2652 return result;
2656 /* Read and INTEGER_CST node from input block IB using the per-file
2657 context in DATA_IN. */
2659 static tree
2660 lto_input_integer_cst (struct lto_input_block *ib, struct data_in *data_in)
2662 tree result, type;
2663 HOST_WIDE_INT low, high;
2664 bool overflow_p;
2666 type = lto_input_tree (ib, data_in);
2667 overflow_p = (lto_input_1_unsigned (ib) != 0);
2668 low = lto_input_uleb128 (ib);
2669 high = lto_input_uleb128 (ib);
2670 result = build_int_cst_wide (type, low, high);
2672 /* If the original constant had overflown, build a replica of RESULT to
2673 avoid modifying the shared constant returned by build_int_cst_wide. */
2674 if (overflow_p)
2676 result = copy_node (result);
2677 TREE_OVERFLOW (result) = 1;
2680 return result;
2684 /* Read a tree from input block IB using the per-file context in
2685 DATA_IN. This context is used, for example, to resolve references
2686 to previously read nodes. */
2688 tree
2689 lto_input_tree (struct lto_input_block *ib, struct data_in *data_in)
2691 enum LTO_tags tag;
2692 tree result;
2694 tag = input_record_start (ib);
2695 gcc_assert ((unsigned) tag < (unsigned) LTO_NUM_TAGS);
2697 if (tag == LTO_null)
2698 result = NULL_TREE;
2699 else if (tag >= LTO_field_decl_ref && tag <= LTO_global_decl_ref)
2701 /* If TAG is a reference to an indexable tree, the next value
2702 in IB is the index into the table where we expect to find
2703 that tree. */
2704 result = lto_input_tree_ref (ib, data_in, cfun, tag);
2706 else if (tag == LTO_tree_pickle_reference)
2708 /* If TAG is a reference to a previously read tree, look it up in
2709 the reader cache. */
2710 result = lto_get_pickled_tree (ib, data_in);
2712 else if (tag == LTO_builtin_decl)
2714 /* If we are going to read a built-in function, all we need is
2715 the code and class. */
2716 result = lto_get_builtin_tree (ib, data_in);
2718 else if (tag == lto_tree_code_to_tag (INTEGER_CST))
2720 /* For integer constants we only need the type and its hi/low
2721 words. */
2722 result = lto_input_integer_cst (ib, data_in);
2724 else
2726 /* Otherwise, materialize a new node from IB. */
2727 result = lto_read_tree (ib, data_in, tag);
2730 return result;
2734 /* Initialization for the LTO reader. */
2736 void
2737 lto_init_reader (void)
2739 lto_streamer_init ();
2741 memset (&lto_stats, 0, sizeof (lto_stats));
2742 bitmap_obstack_initialize (NULL);
2744 file_name_hash_table = htab_create (37, hash_string_slot_node,
2745 eq_string_slot_node, free);
2747 gimple_register_cfg_hooks ();
2751 /* Create a new data_in object for FILE_DATA. STRINGS is the string
2752 table to use with LEN strings. RESOLUTIONS is the vector of linker
2753 resolutions (NULL if not using a linker plugin). */
2755 struct data_in *
2756 lto_data_in_create (struct lto_file_decl_data *file_data, const char *strings,
2757 unsigned len,
2758 VEC(ld_plugin_symbol_resolution_t,heap) *resolutions)
2760 struct data_in *data_in = XCNEW (struct data_in);
2761 data_in->file_data = file_data;
2762 data_in->strings = strings;
2763 data_in->strings_len = len;
2764 data_in->globals_resolution = resolutions;
2765 data_in->reader_cache = lto_streamer_cache_create ();
2767 return data_in;
2771 /* Remove DATA_IN. */
2773 void
2774 lto_data_in_delete (struct data_in *data_in)
2776 VEC_free (ld_plugin_symbol_resolution_t, heap, data_in->globals_resolution);
2777 lto_streamer_cache_delete (data_in->reader_cache);
2778 free (data_in->labels);
2779 free (data_in);