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
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
34 #include "basic-block.h"
35 #include "tree-flow.h"
36 #include "tree-pass.h"
40 #include "diagnostic.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. */
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. */
66 lto_tag_check_set (enum LTO_tags actual, int ntags, ...)
72 for (i = 0; i < ntags; i++)
73 if ((unsigned) actual == va_arg (ap, unsigned))
80 internal_error ("bytecode stream: unexpected tag %s", lto_tag_name (actual));
84 /* Check that tag ACTUAL is in the range [TAG1, TAG2]. */
87 lto_tag_check_range (enum LTO_tags actual, enum LTO_tags tag1,
90 if (actual < tag1 || actual > tag2)
91 internal_error ("bytecode stream: tag %s is not in the expected range "
93 lto_tag_name (actual),
99 /* Check that tag ACTUAL == EXPECTED. */
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. */
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. */
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. */
135 input_string_internal (struct data_in *data_in, struct lto_input_block *ib,
138 struct lto_input_block str_tab;
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);
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);
157 /* Read a STRING_CST from the string table in DATA_IN using input
161 input_string_cst (struct data_in *data_in, struct lto_input_block *ib)
165 unsigned int is_null;
167 is_null = lto_input_uleb128 (ib);
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
180 input_identifier (struct data_in *data_in, struct lto_input_block *ib)
184 unsigned int is_null;
186 is_null = lto_input_uleb128 (ib);
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. */
197 input_string (struct data_in *data_in, struct lto_input_block *ib)
201 unsigned int is_null;
203 is_null = lto_input_uleb128 (ib);
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");
215 /* Return the next tag in the input block IB. */
218 input_record_start (struct lto_input_block *ib)
220 enum LTO_tags tag = (enum LTO_tags) lto_input_uleb128 (ib);
225 /* Lookup STRING in file_name_hash_table. If found, return the existing
226 string, otherwise insert STRING as the canonical version. */
229 canon_file_name (const char *string)
232 struct string_slot s_slot;
235 slot = htab_find_slot (file_name_hash_table, &s_slot, INSERT);
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;
252 struct string_slot *old_slot = (struct string_slot *) *slot;
258 /* Clear the line info stored in DATA_IN. */
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. */
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. */
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);
324 ix_u = lto_input_uleb128 (ib);
325 result = lto_file_decl_data_get_type (data_in->file_data, ix_u);
328 case LTO_ssa_name_ref:
329 ix_u = lto_input_uleb128 (ib);
330 result = VEC_index (tree, SSANAMES (fn), ix_u);
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);
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);
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);
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);
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);
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,
382 *last_p = first = NULL;
383 tag = input_record_start (ib);
389 lto_tag_check_range (tag, LTO_eh_catch, LTO_eh_catch);
391 /* Read the catch node. */
392 n = GGC_CNEW (struct 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. */
403 (*last_p)->next_catch = n;
404 n->prev_catch = *last_p;
407 /* Set the head of the list the first time through the loop. */
411 tag = input_record_start (ib);
418 /* Read and return EH region IX from input block IB, using descriptors
422 input_eh_region (struct lto_input_block *ib, struct data_in *data_in, int ix)
427 /* Read the region header. */
428 tag = input_record_start (ib);
432 r = GGC_CNEW (struct 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);
445 case LTO_ert_cleanup:
446 r->type = ERT_CLEANUP;
451 struct eh_catch_d *last_catch;
453 r->u.eh_try.first_catch = lto_input_eh_catch_list (ib, data_in,
455 r->u.eh_try.last_catch = last_catch;
459 case LTO_ert_allowed_exceptions:
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));
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);
483 r->landing_pads = (eh_landing_pad) (intptr_t) lto_input_sleb128 (ib);
489 /* Read and return EH landing pad IX from input block IB, using descriptors
492 static eh_landing_pad
493 input_eh_lp (struct lto_input_block *ib, struct data_in *data_in, int ix)
498 /* Read the landing pad header. */
499 tag = input_record_start (ib);
503 lto_tag_check_range (tag, LTO_eh_landing_pad, LTO_eh_landing_pad);
505 lp = GGC_CNEW (struct 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);
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. */
522 fixup_eh_region_pointers (struct function *fn, HOST_WIDE_INT root_region)
525 VEC(eh_region,gc) *eh_array = fn->eh->region_array;
526 VEC(eh_landing_pad,gc) *lp_array = fn->eh->lp_array;
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. */
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. */
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
573 /* Initialize EH support. */
578 static bool eh_initialized_p = false;
580 if (eh_initialized_p)
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. */
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 ();
599 eh_initialized_p = true;
603 /* Read the exception table for FN from IB using the data descriptors
607 input_eh_regions (struct lto_input_block *ib, struct data_in *data_in,
610 HOST_WIDE_INT i, root_region, len;
613 tag = input_record_start (ib);
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
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);
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);
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);
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);
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);
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
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. */
705 make_new_block (struct function *fn, unsigned int index)
707 basic_block bb = alloc_block ();
709 SET_BASIC_BLOCK_FOR_FUNCTION (fn, index, bb);
710 bb->il.gimple = GGC_CNEW (struct gimple_bb_info);
711 n_basic_blocks_for_function (fn)++;
713 set_bb_seq (bb, gimple_seq_alloc ());
718 /* Read the CFG for function FN from input block IB. */
721 input_cfg (struct lto_input_block *ib, struct function *fn)
723 unsigned int bb_count;
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);
748 basic_block bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
749 unsigned int edge_count;
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;
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);
774 dest = make_new_block (fn, dest_index);
776 e = make_edge (bb, dest, edge_flags);
777 e->probability = probability;
781 index = lto_input_sleb128 (ib);
784 p_bb = ENTRY_BLOCK_PTR_FOR_FUNCTION(fn);
785 index = lto_input_sleb128 (ib);
788 basic_block bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
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. */
801 input_phi (struct lto_input_block *ib, basic_block bb, struct data_in *data_in,
804 unsigned HOST_WIDE_INT ix;
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);
828 for (j = 0; j < len; j++)
829 if (EDGE_PRED (bb, j)->src == sbb)
831 e = EDGE_PRED (bb, j);
835 add_phi_arg (result, def, e, arg_loc);
842 /* Read the SSA names array for function FN from DATA_IN using input
846 input_ssa_names (struct lto_input_block *ib, struct data_in *data_in,
849 unsigned int i, size;
851 size = lto_input_uleb128 (ib);
852 init_ssanames (fn, size);
854 i = lto_input_uleb128 (ib);
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 ());
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
880 maybe_fixup_handled_component (tree op)
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)
890 decl_type = TREE_TYPE (TREE_OPERAND (op, 0));
892 switch (TREE_CODE (op))
895 /* The DECL_CONTEXT of the field-decl is the record type we look for. */
896 wanted_type = DECL_CONTEXT (TREE_OPERAND (op, 1));
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))))
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);
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))))
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);
922 case VIEW_CONVERT_EXPR:
923 /* Very nice - nothing to do. */
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))))
933 wanted_type = build_complex_type (TREE_TYPE (op));
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. */
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),
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. */
997 input_gimple_stmt (struct lto_input_block *ib, struct data_in *data_in,
998 struct function *fn, enum LTO_tags tag)
1001 enum gimple_code code;
1002 unsigned HOST_WIDE_INT num_ops;
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);
1017 bitpack_delete (bp);
1019 /* Read location information. */
1020 gimple_set_location (stmt, lto_input_location (ib, data_in));
1022 /* Read lexical block reference. */
1023 gimple_set_block (stmt, lto_input_tree (ib, data_in));
1025 /* Read in all the operands. */
1029 gimple_resx_set_region (stmt, lto_input_sleb128 (ib));
1032 case GIMPLE_EH_MUST_NOT_THROW:
1033 gimple_eh_must_not_throw_set_fndecl (stmt, lto_input_tree (ib, data_in));
1036 case GIMPLE_EH_DISPATCH:
1037 gimple_eh_dispatch_set_region (stmt, lto_input_sleb128 (ib));
1042 /* FIXME lto. Move most of this into a new gimple_asm_set_string(). */
1044 stmt->gimple_asm.ni = lto_input_uleb128 (ib);
1045 stmt->gimple_asm.no = lto_input_uleb128 (ib);
1046 stmt->gimple_asm.nc = lto_input_uleb128 (ib);
1047 stmt->gimple_asm.nl = lto_input_uleb128 (ib);
1048 str = input_string_cst (data_in, ib);
1049 stmt->gimple_asm.string = TREE_STRING_POINTER (str);
1061 for (i = 0; i < num_ops; i++)
1063 tree op = lto_input_tree (ib, data_in);
1064 gimple_set_op (stmt, i, op);
1068 /* Fixup reference tree operands for substituted prevailing decls
1069 with mismatched types. For plain VAR_DECLs we need to look
1070 at context to determine the wanted type - we do that below
1071 after the stmt is completed. */
1072 if (TREE_CODE (op) == ADDR_EXPR
1073 && TREE_CODE (TREE_OPERAND (op, 0)) == VAR_DECL
1074 && !useless_type_conversion_p (TREE_TYPE (TREE_TYPE (op)),
1077 TREE_OPERAND (op, 0)
1078 = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (TREE_TYPE (op)),
1079 TREE_OPERAND (op, 0));
1083 /* Fixup FIELD_DECLs in COMPONENT_REFs, they are not handled
1085 if (TREE_CODE (op) == ADDR_EXPR)
1086 op = TREE_OPERAND (op, 0);
1087 while (handled_component_p (op))
1089 if (TREE_CODE (op) == COMPONENT_REF)
1091 tree field, type, tem;
1092 field = TREE_OPERAND (op, 1);
1093 type = DECL_CONTEXT (field);
1094 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1097 || (TREE_TYPE (tem) == TREE_TYPE (field)
1098 && DECL_NONADDRESSABLE_P (tem)
1099 == DECL_NONADDRESSABLE_P (field)
1100 && gimple_compare_field_offset (tem, field)))
1103 /* In case of type mismatches across units we can fail
1104 to unify some types and thus not find a proper
1105 field-decl here. So only assert here if checking
1107 #ifdef ENABLE_CHECKING
1108 gcc_assert (tem != NULL_TREE);
1110 if (tem != NULL_TREE)
1111 TREE_OPERAND (op, 1) = tem;
1114 /* Preserve the last handled component for the fixup of
1115 its operand below. */
1116 if (!handled_component_p (TREE_OPERAND (op, 0)))
1118 op = TREE_OPERAND (op, 0);
1121 /* Fixup reference tree operands for substituted prevailing decls
1122 with mismatched types. */
1123 if (handled_component_p (op))
1124 maybe_fixup_handled_component (op);
1129 case GIMPLE_PREDICT:
1133 internal_error ("bytecode stream: unknown GIMPLE statement tag %s",
1134 lto_tag_name (tag));
1137 /* Update the properties of symbols, SSA names and labels associated
1139 if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
1141 tree lhs = gimple_get_lhs (stmt);
1142 if (lhs && TREE_CODE (lhs) == SSA_NAME)
1143 SSA_NAME_DEF_STMT (lhs) = stmt;
1145 else if (code == GIMPLE_LABEL)
1146 gcc_assert (emit_label_in_global_context_p (gimple_label_label (stmt))
1147 || DECL_CONTEXT (gimple_label_label (stmt)) == fn->decl);
1148 else if (code == GIMPLE_ASM)
1152 for (i = 0; i < gimple_asm_noutputs (stmt); i++)
1154 tree op = TREE_VALUE (gimple_asm_output_op (stmt, i));
1155 if (TREE_CODE (op) == SSA_NAME)
1156 SSA_NAME_DEF_STMT (op) = stmt;
1160 /* Reset alias information. */
1161 if (code == GIMPLE_CALL)
1162 gimple_call_reset_alias_info (stmt);
1164 /* Fixup reference tree operands for substituted prevailing decls
1165 with mismatched types. */
1166 maybe_fixup_decls (stmt);
1168 /* Mark the statement modified so its operand vectors can be filled in. */
1169 gimple_set_modified (stmt, true);
1175 /* Read a basic block with tag TAG from DATA_IN using input block IB.
1176 FN is the function being processed. */
1179 input_bb (struct lto_input_block *ib, enum LTO_tags tag,
1180 struct data_in *data_in, struct function *fn)
1184 gimple_stmt_iterator bsi;
1186 /* This routine assumes that CFUN is set to FN, as it needs to call
1187 basic GIMPLE routines that use CFUN. */
1188 gcc_assert (cfun == fn);
1190 index = lto_input_uleb128 (ib);
1191 bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
1193 bb->count = lto_input_sleb128 (ib);
1194 bb->loop_depth = lto_input_sleb128 (ib);
1195 bb->frequency = lto_input_sleb128 (ib);
1196 bb->flags = lto_input_sleb128 (ib);
1198 /* LTO_bb1 has statements. LTO_bb0 does not. */
1202 bsi = gsi_start_bb (bb);
1203 tag = input_record_start (ib);
1206 gimple stmt = input_gimple_stmt (ib, data_in, fn, tag);
1208 /* Change debug stmts to nops on-the-fly if we do not have VTA enabled.
1209 This allows us to build for example static libs with debugging
1210 enabled and do the final link without. */
1211 if (!MAY_HAVE_DEBUG_STMTS
1212 && is_gimple_debug (stmt))
1213 stmt = gimple_build_nop ();
1215 find_referenced_vars_in (stmt);
1216 gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
1218 /* After the statement, expect a 0 delimiter or the EH region
1219 that the previous statement belongs to. */
1220 tag = input_record_start (ib);
1221 lto_tag_check_set (tag, 2, LTO_eh_region, LTO_null);
1223 if (tag == LTO_eh_region)
1225 HOST_WIDE_INT region = lto_input_sleb128 (ib);
1226 gcc_assert (region == (int) region);
1227 add_stmt_to_eh_lp (stmt, region);
1230 tag = input_record_start (ib);
1233 tag = input_record_start (ib);
1236 gimple phi = input_phi (ib, bb, data_in, fn);
1237 find_referenced_vars_in (phi);
1238 tag = input_record_start (ib);
1242 /* Go through all NODE edges and fixup call_stmt pointers
1243 so they point to STMTS. */
1246 fixup_call_stmt_edges_1 (struct cgraph_node *node, gimple *stmts)
1248 struct cgraph_edge *cedge;
1249 for (cedge = node->callees; cedge; cedge = cedge->next_callee)
1250 cedge->call_stmt = stmts[cedge->lto_stmt_uid];
1251 for (cedge = node->indirect_calls; cedge; cedge = cedge->next_callee)
1252 cedge->call_stmt = stmts[cedge->lto_stmt_uid];
1255 /* Fixup call_stmt pointers in NODE and all clones. */
1258 fixup_call_stmt_edges (struct cgraph_node *orig, gimple *stmts)
1260 struct cgraph_node *node;
1262 while (orig->clone_of)
1263 orig = orig->clone_of;
1265 fixup_call_stmt_edges_1 (orig, stmts);
1267 for (node = orig->clones; node != orig;)
1269 fixup_call_stmt_edges_1 (node, stmts);
1271 node = node->clones;
1272 else if (node->next_sibling_clone)
1273 node = node->next_sibling_clone;
1276 while (node != orig && !node->next_sibling_clone)
1277 node = node->clone_of;
1279 node = node->next_sibling_clone;
1284 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1287 input_function (tree fn_decl, struct data_in *data_in,
1288 struct lto_input_block *ib)
1290 struct function *fn;
1294 struct bitpack_d *bp;
1295 struct cgraph_node *node;
1296 tree args, narg, oarg;
1298 fn = DECL_STRUCT_FUNCTION (fn_decl);
1299 tag = input_record_start (ib);
1300 clear_line_info (data_in);
1302 gimple_register_cfg_hooks ();
1303 lto_tag_check (tag, LTO_function);
1305 /* Read all the attributes for FN. */
1306 bp = lto_input_bitpack (ib);
1307 fn->is_thunk = bp_unpack_value (bp, 1);
1308 fn->has_local_explicit_reg_vars = bp_unpack_value (bp, 1);
1309 fn->after_tree_profile = bp_unpack_value (bp, 1);
1310 fn->returns_pcc_struct = bp_unpack_value (bp, 1);
1311 fn->returns_struct = bp_unpack_value (bp, 1);
1312 fn->always_inline_functions_inlined = bp_unpack_value (bp, 1);
1313 fn->after_inlining = bp_unpack_value (bp, 1);
1314 fn->dont_save_pending_sizes_p = bp_unpack_value (bp, 1);
1315 fn->stdarg = bp_unpack_value (bp, 1);
1316 fn->has_nonlocal_label = bp_unpack_value (bp, 1);
1317 fn->calls_alloca = bp_unpack_value (bp, 1);
1318 fn->calls_setjmp = bp_unpack_value (bp, 1);
1319 fn->va_list_fpr_size = bp_unpack_value (bp, 8);
1320 fn->va_list_gpr_size = bp_unpack_value (bp, 8);
1321 bitpack_delete (bp);
1323 /* Input the current IL state of the function. */
1324 fn->curr_properties = lto_input_uleb128 (ib);
1326 /* Read the static chain and non-local goto save area. */
1327 fn->static_chain_decl = lto_input_tree (ib, data_in);
1328 fn->nonlocal_goto_save_area = lto_input_tree (ib, data_in);
1330 /* Read all the local symbols. */
1331 fn->local_decls = lto_input_tree (ib, data_in);
1333 /* Read all function arguments. We need to re-map them here to the
1334 arguments of the merged function declaration. */
1335 args = lto_input_tree (ib, data_in);
1336 for (oarg = args, narg = DECL_ARGUMENTS (fn_decl);
1338 oarg = TREE_CHAIN (oarg), narg = TREE_CHAIN (narg))
1342 res = lto_streamer_cache_lookup (data_in->reader_cache, oarg, &ix);
1344 /* Replace the argument in the streamer cache. */
1345 lto_streamer_cache_insert_at (data_in->reader_cache, narg, ix);
1347 gcc_assert (!oarg && !narg);
1349 /* Read all the SSA names. */
1350 input_ssa_names (ib, data_in, fn);
1352 /* Read the exception handling regions in the function. */
1353 input_eh_regions (ib, data_in, fn);
1355 /* Read the tree of lexical scopes for the function. */
1356 DECL_INITIAL (fn_decl) = lto_input_tree (ib, data_in);
1357 gcc_assert (DECL_INITIAL (fn_decl));
1358 DECL_SAVED_TREE (fn_decl) = NULL_TREE;
1360 /* Read all the basic blocks. */
1361 tag = input_record_start (ib);
1364 input_bb (ib, tag, data_in, fn);
1365 tag = input_record_start (ib);
1368 /* Fix up the call statements that are mentioned in the callgraph
1370 renumber_gimple_stmt_uids ();
1371 stmts = (gimple *) xcalloc (gimple_stmt_max_uid (fn), sizeof (gimple));
1374 gimple_stmt_iterator bsi;
1375 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
1377 gimple stmt = gsi_stmt (bsi);
1378 stmts[gimple_uid (stmt)] = stmt;
1382 /* Set the gimple body to the statement sequence in the entry
1383 basic block. FIXME lto, this is fairly hacky. The existence
1384 of a gimple body is used by the cgraph routines, but we should
1385 really use the presence of the CFG. */
1387 edge_iterator ei = ei_start (ENTRY_BLOCK_PTR->succs);
1388 gimple_set_body (fn_decl, bb_seq (ei_edge (ei)->dest));
1391 node = cgraph_node (fn_decl);
1392 fixup_call_stmt_edges (node, stmts);
1393 execute_all_ipa_stmt_fixups (node, stmts);
1395 update_ssa (TODO_update_ssa_only_virtuals);
1396 free_dominance_info (CDI_DOMINATORS);
1397 free_dominance_info (CDI_POST_DOMINATORS);
1402 /* Read initializer expressions for public statics. DATA_IN is the
1403 file being read. IB is the input block used for reading. */
1406 input_alias_pairs (struct lto_input_block *ib, struct data_in *data_in)
1410 clear_line_info (data_in);
1412 /* Skip over all the unreferenced globals. */
1414 var = lto_input_tree (ib, data_in);
1417 var = lto_input_tree (ib, data_in);
1420 const char *orig_name, *new_name;
1423 p = VEC_safe_push (alias_pair, gc, alias_pairs, NULL);
1425 p->target = lto_input_tree (ib, data_in);
1427 /* If the target is a static object, we may have registered a
1428 new name for it to avoid clashes between statics coming from
1429 different files. In that case, use the new name. */
1430 orig_name = IDENTIFIER_POINTER (p->target);
1431 new_name = lto_get_decl_name_mapping (data_in->file_data, orig_name);
1432 if (strcmp (orig_name, new_name) != 0)
1433 p->target = get_identifier (new_name);
1435 var = lto_input_tree (ib, data_in);
1440 /* Read the body from DATA for function FN_DECL and fill it in.
1441 FILE_DATA are the global decls and types. SECTION_TYPE is either
1442 LTO_section_function_body or LTO_section_static_initializer. If
1443 section type is LTO_section_function_body, FN must be the decl for
1447 lto_read_body (struct lto_file_decl_data *file_data, tree fn_decl,
1448 const char *data, enum lto_section_type section_type)
1450 const struct lto_function_header *header;
1451 struct data_in *data_in;
1453 int32_t main_offset;
1454 int32_t string_offset;
1455 struct lto_input_block ib_cfg;
1456 struct lto_input_block ib_main;
1458 header = (const struct lto_function_header *) data;
1459 cfg_offset = sizeof (struct lto_function_header);
1460 main_offset = cfg_offset + header->cfg_size;
1461 string_offset = main_offset + header->main_size;
1463 LTO_INIT_INPUT_BLOCK (ib_cfg,
1468 LTO_INIT_INPUT_BLOCK (ib_main,
1473 data_in = lto_data_in_create (file_data, data + string_offset,
1474 header->string_size, NULL);
1476 /* Make sure the file was generated by the exact same compiler. */
1477 lto_check_version (header->lto_header.major_version,
1478 header->lto_header.minor_version);
1480 if (section_type == LTO_section_function_body)
1482 struct function *fn = DECL_STRUCT_FUNCTION (fn_decl);
1483 struct lto_in_decl_state *decl_state;
1488 /* Use the function's decl state. */
1489 decl_state = lto_get_function_in_decl_state (file_data, fn_decl);
1490 gcc_assert (decl_state);
1491 file_data->current_decl_state = decl_state;
1493 input_cfg (&ib_cfg, fn);
1495 /* Set up the struct function. */
1496 input_function (fn_decl, data_in, &ib_main);
1498 /* We should now be in SSA. */
1499 cfun->gimple_df->in_ssa_p = true;
1501 /* Restore decl state */
1502 file_data->current_decl_state = file_data->global_decl_state;
1508 input_alias_pairs (&ib_main, data_in);
1511 clear_line_info (data_in);
1512 lto_data_in_delete (data_in);
1516 /* Read the body of FN_DECL using DATA. FILE_DATA holds the global
1520 lto_input_function_body (struct lto_file_decl_data *file_data,
1521 tree fn_decl, const char *data)
1523 current_function_decl = fn_decl;
1524 lto_read_body (file_data, fn_decl, data, LTO_section_function_body);
1528 /* Read in VAR_DECL using DATA. FILE_DATA holds the global decls and
1532 lto_input_constructors_and_inits (struct lto_file_decl_data *file_data,
1535 lto_read_body (file_data, NULL, data, LTO_section_static_initializer);
1539 /* Return the resolution for the decl with index INDEX from DATA_IN. */
1541 static enum ld_plugin_symbol_resolution
1542 get_resolution (struct data_in *data_in, unsigned index)
1544 if (data_in->globals_resolution)
1546 ld_plugin_symbol_resolution_t ret;
1547 /* We can have references to not emitted functions in
1548 DECL_FUNCTION_PERSONALITY at least. So we can and have
1549 to indeed return LDPR_UNKNOWN in some cases. */
1550 if (VEC_length (ld_plugin_symbol_resolution_t,
1551 data_in->globals_resolution) <= index)
1552 return LDPR_UNKNOWN;
1553 ret = VEC_index (ld_plugin_symbol_resolution_t,
1554 data_in->globals_resolution,
1559 /* Delay resolution finding until decl merging. */
1560 return LDPR_UNKNOWN;
1564 /* Unpack all the non-pointer fields of the TS_BASE structure of
1565 expression EXPR from bitpack BP. */
1568 unpack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
1570 /* Note that the code for EXPR has already been unpacked to create EXPR in
1571 lto_materialize_tree. */
1574 TREE_SIDE_EFFECTS (expr) = (unsigned) bp_unpack_value (bp, 1);
1575 TREE_CONSTANT (expr) = (unsigned) bp_unpack_value (bp, 1);
1576 TREE_READONLY (expr) = (unsigned) bp_unpack_value (bp, 1);
1578 /* TREE_PUBLIC is used on types to indicate that the type
1579 has a TYPE_CACHED_VALUES vector. This is not streamed out,
1580 so we skip it here. */
1581 TREE_PUBLIC (expr) = (unsigned) bp_unpack_value (bp, 1);
1583 TREE_ADDRESSABLE (expr) = (unsigned) bp_unpack_value (bp, 1);
1584 TREE_THIS_VOLATILE (expr) = (unsigned) bp_unpack_value (bp, 1);
1586 DECL_UNSIGNED (expr) = (unsigned) bp_unpack_value (bp, 1);
1587 else if (TYPE_P (expr))
1588 TYPE_UNSIGNED (expr) = (unsigned) bp_unpack_value (bp, 1);
1589 TREE_ASM_WRITTEN (expr) = (unsigned) bp_unpack_value (bp, 1);
1590 TREE_NO_WARNING (expr) = (unsigned) bp_unpack_value (bp, 1);
1591 TREE_USED (expr) = (unsigned) bp_unpack_value (bp, 1);
1592 TREE_NOTHROW (expr) = (unsigned) bp_unpack_value (bp, 1);
1593 TREE_STATIC (expr) = (unsigned) bp_unpack_value (bp, 1);
1594 TREE_PRIVATE (expr) = (unsigned) bp_unpack_value (bp, 1);
1595 TREE_PROTECTED (expr) = (unsigned) bp_unpack_value (bp, 1);
1596 TREE_DEPRECATED (expr) = (unsigned) bp_unpack_value (bp, 1);
1598 TYPE_SATURATING (expr) = (unsigned) bp_unpack_value (bp, 1);
1599 if (TREE_CODE (expr) == SSA_NAME)
1600 SSA_NAME_IS_DEFAULT_DEF (expr) = (unsigned) bp_unpack_value (bp, 1);
1604 /* Unpack all the non-pointer fields of the TS_REAL_CST structure of
1605 expression EXPR from bitpack BP. */
1608 unpack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
1612 REAL_VALUE_TYPE *rp;
1614 r.cl = (unsigned) bp_unpack_value (bp, 2);
1615 r.decimal = (unsigned) bp_unpack_value (bp, 1);
1616 r.sign = (unsigned) bp_unpack_value (bp, 1);
1617 r.signalling = (unsigned) bp_unpack_value (bp, 1);
1618 r.canonical = (unsigned) bp_unpack_value (bp, 1);
1619 r.uexp = (unsigned) bp_unpack_value (bp, EXP_BITS);
1620 for (i = 0; i < SIGSZ; i++)
1621 r.sig[i] = (unsigned long) bp_unpack_value (bp, HOST_BITS_PER_LONG);
1623 rp = GGC_NEW (REAL_VALUE_TYPE);
1624 memcpy (rp, &r, sizeof (REAL_VALUE_TYPE));
1625 TREE_REAL_CST_PTR (expr) = rp;
1629 /* Unpack all the non-pointer fields of the TS_FIXED_CST structure of
1630 expression EXPR from bitpack BP. */
1633 unpack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr)
1635 struct fixed_value fv;
1637 fv.data.low = (HOST_WIDE_INT) bp_unpack_value (bp, HOST_BITS_PER_WIDE_INT);
1638 fv.data.high = (HOST_WIDE_INT) bp_unpack_value (bp, HOST_BITS_PER_WIDE_INT);
1639 TREE_FIXED_CST (expr) = fv;
1643 /* Unpack all the non-pointer fields of the TS_DECL_COMMON structure
1644 of expression EXPR from bitpack BP. */
1647 unpack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr)
1649 DECL_MODE (expr) = (enum machine_mode) bp_unpack_value (bp, 8);
1650 DECL_NONLOCAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1651 DECL_VIRTUAL_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1652 DECL_IGNORED_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1653 DECL_ABSTRACT (expr) = (unsigned) bp_unpack_value (bp, 1);
1654 DECL_ARTIFICIAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1655 DECL_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1);
1656 DECL_PRESERVE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1657 DECL_DEBUG_EXPR_IS_FROM (expr) = (unsigned) bp_unpack_value (bp, 1);
1658 DECL_EXTERNAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1659 DECL_GIMPLE_REG_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1660 DECL_ALIGN (expr) = (unsigned) bp_unpack_value (bp, HOST_BITS_PER_INT);
1662 if (TREE_CODE (expr) == LABEL_DECL)
1664 DECL_ERROR_ISSUED (expr) = (unsigned) bp_unpack_value (bp, 1);
1665 EH_LANDING_PAD_NR (expr) = (int) bp_unpack_value (bp, HOST_BITS_PER_INT);
1667 /* Always assume an initial value of -1 for LABEL_DECL_UID to
1668 force gimple_set_bb to recreate label_to_block_map. */
1669 LABEL_DECL_UID (expr) = -1;
1672 if (TREE_CODE (expr) == FIELD_DECL)
1674 unsigned HOST_WIDE_INT off_align;
1675 DECL_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
1676 DECL_NONADDRESSABLE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1677 off_align = (unsigned HOST_WIDE_INT) bp_unpack_value (bp, 8);
1678 SET_DECL_OFFSET_ALIGN (expr, off_align);
1681 if (TREE_CODE (expr) == RESULT_DECL
1682 || TREE_CODE (expr) == PARM_DECL
1683 || TREE_CODE (expr) == VAR_DECL)
1685 DECL_BY_REFERENCE (expr) = (unsigned) bp_unpack_value (bp, 1);
1686 if (TREE_CODE (expr) == VAR_DECL
1687 || TREE_CODE (expr) == PARM_DECL)
1688 DECL_HAS_VALUE_EXPR_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1689 DECL_RESTRICTED_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1694 /* Unpack all the non-pointer fields of the TS_DECL_WRTL structure
1695 of expression EXPR from bitpack BP. */
1698 unpack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
1700 DECL_REGISTER (expr) = (unsigned) bp_unpack_value (bp, 1);
1704 /* Unpack all the non-pointer fields of the TS_DECL_WITH_VIS structure
1705 of expression EXPR from bitpack BP. */
1708 unpack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
1710 DECL_DEFER_OUTPUT (expr) = (unsigned) bp_unpack_value (bp, 1);
1711 DECL_COMMON (expr) = (unsigned) bp_unpack_value (bp, 1);
1712 DECL_DLLIMPORT_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1713 DECL_WEAK (expr) = (unsigned) bp_unpack_value (bp, 1);
1714 DECL_SEEN_IN_BIND_EXPR_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1715 DECL_COMDAT (expr) = (unsigned) bp_unpack_value (bp, 1);
1716 DECL_VISIBILITY (expr) = (enum symbol_visibility) bp_unpack_value (bp, 2);
1717 DECL_VISIBILITY_SPECIFIED (expr) = (unsigned) bp_unpack_value (bp, 1);
1719 if (TREE_CODE (expr) == VAR_DECL)
1721 DECL_HARD_REGISTER (expr) = (unsigned) bp_unpack_value (bp, 1);
1722 DECL_IN_TEXT_SECTION (expr) = (unsigned) bp_unpack_value (bp, 1);
1723 DECL_IN_CONSTANT_POOL (expr) = (unsigned) bp_unpack_value (bp, 1);
1724 DECL_TLS_MODEL (expr) = (enum tls_model) bp_unpack_value (bp, 3);
1727 if (VAR_OR_FUNCTION_DECL_P (expr))
1730 p = (priority_type) bp_unpack_value (bp, HOST_BITS_PER_SHORT);
1731 SET_DECL_INIT_PRIORITY (expr, p);
1736 /* Unpack all the non-pointer fields of the TS_FUNCTION_DECL structure
1737 of expression EXPR from bitpack BP. */
1740 unpack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
1742 DECL_FUNCTION_CODE (expr) = (enum built_in_function) bp_unpack_value (bp, 11);
1743 DECL_BUILT_IN_CLASS (expr) = (enum built_in_class) bp_unpack_value (bp, 2);
1744 DECL_STATIC_CONSTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
1745 DECL_STATIC_DESTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
1746 DECL_UNINLINABLE (expr) = (unsigned) bp_unpack_value (bp, 1);
1747 DECL_POSSIBLY_INLINED (expr) = (unsigned) bp_unpack_value (bp, 1);
1748 DECL_IS_NOVOPS (expr) = (unsigned) bp_unpack_value (bp, 1);
1749 DECL_IS_RETURNS_TWICE (expr) = (unsigned) bp_unpack_value (bp, 1);
1750 DECL_IS_MALLOC (expr) = (unsigned) bp_unpack_value (bp, 1);
1751 DECL_IS_OPERATOR_NEW (expr) = (unsigned) bp_unpack_value (bp, 1);
1752 DECL_DECLARED_INLINE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1753 DECL_STATIC_CHAIN (expr) = (unsigned) bp_unpack_value (bp, 1);
1754 DECL_NO_INLINE_WARNING_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1755 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr)
1756 = (unsigned) bp_unpack_value (bp, 1);
1757 DECL_NO_LIMIT_STACK (expr) = (unsigned) bp_unpack_value (bp, 1);
1758 DECL_DISREGARD_INLINE_LIMITS (expr) = (unsigned) bp_unpack_value (bp, 1);
1759 DECL_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1760 DECL_LOOPING_CONST_OR_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1764 /* Unpack all the non-pointer fields of the TS_TYPE structure
1765 of expression EXPR from bitpack BP. */
1768 unpack_ts_type_value_fields (struct bitpack_d *bp, tree expr)
1770 enum machine_mode mode;
1772 TYPE_PRECISION (expr) = (unsigned) bp_unpack_value (bp, 9);
1773 mode = (enum machine_mode) bp_unpack_value (bp, 7);
1774 SET_TYPE_MODE (expr, mode);
1775 TYPE_STRING_FLAG (expr) = (unsigned) bp_unpack_value (bp, 1);
1776 TYPE_NO_FORCE_BLK (expr) = (unsigned) bp_unpack_value (bp, 1);
1777 TYPE_NEEDS_CONSTRUCTING (expr) = (unsigned) bp_unpack_value (bp, 1);
1778 if (RECORD_OR_UNION_TYPE_P (expr))
1779 TYPE_TRANSPARENT_AGGR (expr) = (unsigned) bp_unpack_value (bp, 1);
1780 TYPE_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
1781 TYPE_RESTRICT (expr) = (unsigned) bp_unpack_value (bp, 1);
1782 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr)
1783 = (unsigned) bp_unpack_value (bp, 2);
1784 TYPE_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1);
1785 TYPE_READONLY (expr) = (unsigned) bp_unpack_value (bp, 1);
1786 TYPE_ALIGN (expr) = (unsigned) bp_unpack_value (bp, HOST_BITS_PER_INT);
1787 TYPE_ALIAS_SET (expr) = bp_unpack_value (bp, HOST_BITS_PER_INT);
1791 /* Unpack all the non-pointer fields of the TS_BLOCK structure
1792 of expression EXPR from bitpack BP. */
1795 unpack_ts_block_value_fields (struct bitpack_d *bp, tree expr)
1797 BLOCK_ABSTRACT (expr) = (unsigned) bp_unpack_value (bp, 1);
1798 BLOCK_NUMBER (expr) = (unsigned) bp_unpack_value (bp, 31);
1802 /* Unpack all the non-pointer fields in EXPR into a bit pack. */
1805 unpack_value_fields (struct bitpack_d *bp, tree expr)
1807 enum tree_code code;
1809 code = TREE_CODE (expr);
1811 /* Note that all these functions are highly sensitive to changes in
1812 the types and sizes of each of the fields being packed. */
1813 unpack_ts_base_value_fields (bp, expr);
1815 if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
1816 unpack_ts_real_cst_value_fields (bp, expr);
1818 if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
1819 unpack_ts_fixed_cst_value_fields (bp, expr);
1821 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
1822 unpack_ts_decl_common_value_fields (bp, expr);
1824 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
1825 unpack_ts_decl_wrtl_value_fields (bp, expr);
1827 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
1828 unpack_ts_decl_with_vis_value_fields (bp, expr);
1830 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
1831 unpack_ts_function_decl_value_fields (bp, expr);
1833 if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
1834 unpack_ts_type_value_fields (bp, expr);
1836 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
1837 unpack_ts_block_value_fields (bp, expr);
1839 if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
1841 /* We only stream the version number of SSA names. */
1845 if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
1847 /* This is only used by GENERIC. */
1851 if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
1853 /* This is only used by High GIMPLE. */
1859 /* Read a bitpack from input block IB. */
1862 lto_input_bitpack (struct lto_input_block *ib)
1864 unsigned i, num_words;
1865 struct bitpack_d *bp;
1867 bp = bitpack_create ();
1869 /* If we are about to read more than a handful of words, something
1870 is wrong. This check is overly strict, but it acts as an early
1871 warning. No streamed object has hundreds of bits in its fields. */
1872 num_words = lto_input_uleb128 (ib);
1873 gcc_assert (num_words < 20);
1875 for (i = 0; i < num_words; i++)
1877 bitpack_word_t w = lto_input_uleb128 (ib);
1878 VEC_safe_push (bitpack_word_t, heap, bp->values, w);
1885 /* Materialize a new tree from input block IB using descriptors in
1886 DATA_IN. The code for the new tree should match TAG. Store in
1887 *IX_P the index into the reader cache where the new tree is stored. */
1890 lto_materialize_tree (struct lto_input_block *ib, struct data_in *data_in,
1891 enum LTO_tags tag, int *ix_p)
1893 struct bitpack_d *bp;
1894 enum tree_code code;
1896 #ifdef LTO_STREAMER_DEBUG
1897 HOST_WIDEST_INT orig_address_in_writer;
1903 /* Read the header of the node we are about to create. */
1904 ix = lto_input_sleb128 (ib);
1905 gcc_assert ((int) ix == ix);
1908 #ifdef LTO_STREAMER_DEBUG
1909 /* Read the word representing the memory address for the tree
1910 as it was written by the writer. This is useful when
1911 debugging differences between the writer and reader. */
1912 orig_address_in_writer = lto_input_sleb128 (ib);
1913 gcc_assert ((intptr_t) orig_address_in_writer == orig_address_in_writer);
1916 code = lto_tag_to_tree_code (tag);
1918 /* We should never see an SSA_NAME tree. Only the version numbers of
1919 SSA names are ever written out. See input_ssa_names. */
1920 gcc_assert (code != SSA_NAME);
1922 /* Instantiate a new tree using the header data. */
1923 if (CODE_CONTAINS_STRUCT (code, TS_STRING))
1924 result = input_string_cst (data_in, ib);
1925 else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
1926 result = input_identifier (data_in, ib);
1927 else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1929 HOST_WIDE_INT len = lto_input_sleb128 (ib);
1930 result = make_tree_vec (len);
1932 else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1934 unsigned HOST_WIDE_INT len = lto_input_uleb128 (ib);
1935 result = make_tree_binfo (len);
1939 /* All other nodes can be materialized with a raw make_node
1941 result = make_node (code);
1944 #ifdef LTO_STREAMER_DEBUG
1945 /* Store the original address of the tree as seen by the writer
1946 in RESULT's aux field. This is useful when debugging streaming
1947 problems. This way, a debugging session can be started on
1948 both writer and reader with a breakpoint using this address
1950 lto_orig_address_map (result, (intptr_t) orig_address_in_writer);
1953 /* Read the bitpack of non-pointer values from IB. */
1954 bp = lto_input_bitpack (ib);
1956 /* The first word in BP contains the code of the tree that we
1957 are about to read. */
1958 code = (enum tree_code) bp_unpack_value (bp, 16);
1959 lto_tag_check (lto_tree_code_to_tag (code), tag);
1961 /* Unpack all the value fields from BP. */
1962 unpack_value_fields (bp, result);
1963 bitpack_delete (bp);
1965 /* Enter RESULT in the reader cache. This will make RESULT
1966 available so that circular references in the rest of the tree
1967 structure can be resolved in subsequent calls to lto_input_tree. */
1968 lto_streamer_cache_insert_at (data_in->reader_cache, result, ix);
1974 /* Read a chain of tree nodes from input block IB. DATA_IN contains
1975 tables and descriptors for the file being read. */
1978 lto_input_chain (struct lto_input_block *ib, struct data_in *data_in)
1981 tree first, prev, curr;
1983 first = prev = NULL_TREE;
1984 count = lto_input_sleb128 (ib);
1985 for (i = 0; i < count; i++)
1987 curr = lto_input_tree (ib, data_in);
1989 TREE_CHAIN (prev) = curr;
1993 TREE_CHAIN (curr) = NULL_TREE;
2001 /* Read all pointer fields in the TS_COMMON structure of EXPR from input
2002 block IB. DATA_IN contains tables and descriptors for the
2007 lto_input_ts_common_tree_pointers (struct lto_input_block *ib,
2008 struct data_in *data_in, tree expr)
2010 TREE_TYPE (expr) = lto_input_tree (ib, data_in);
2014 /* Read all pointer fields in the TS_VECTOR structure of EXPR from input
2015 block IB. DATA_IN contains tables and descriptors for the
2019 lto_input_ts_vector_tree_pointers (struct lto_input_block *ib,
2020 struct data_in *data_in, tree expr)
2022 TREE_VECTOR_CST_ELTS (expr) = lto_input_chain (ib, data_in);
2026 /* Read all pointer fields in the TS_COMPLEX structure of EXPR from input
2027 block IB. DATA_IN contains tables and descriptors for the
2031 lto_input_ts_complex_tree_pointers (struct lto_input_block *ib,
2032 struct data_in *data_in, tree expr)
2034 TREE_REALPART (expr) = lto_input_tree (ib, data_in);
2035 TREE_IMAGPART (expr) = lto_input_tree (ib, data_in);
2039 /* Read all pointer fields in the TS_DECL_MINIMAL structure of EXPR
2040 from input block IB. DATA_IN contains tables and descriptors for the
2044 lto_input_ts_decl_minimal_tree_pointers (struct lto_input_block *ib,
2045 struct data_in *data_in, tree expr)
2047 DECL_NAME (expr) = lto_input_tree (ib, data_in);
2048 DECL_CONTEXT (expr) = lto_input_tree (ib, data_in);
2049 DECL_SOURCE_LOCATION (expr) = lto_input_location (ib, data_in);
2053 /* Read all pointer fields in the TS_DECL_COMMON structure of EXPR from
2054 input block IB. DATA_IN contains tables and descriptors for the
2058 lto_input_ts_decl_common_tree_pointers (struct lto_input_block *ib,
2059 struct data_in *data_in, tree expr)
2061 DECL_SIZE (expr) = lto_input_tree (ib, data_in);
2062 DECL_SIZE_UNIT (expr) = lto_input_tree (ib, data_in);
2064 if (TREE_CODE (expr) != FUNCTION_DECL)
2065 DECL_INITIAL (expr) = lto_input_tree (ib, data_in);
2067 DECL_ATTRIBUTES (expr) = lto_input_tree (ib, data_in);
2068 DECL_ABSTRACT_ORIGIN (expr) = lto_input_tree (ib, data_in);
2070 if (TREE_CODE (expr) == PARM_DECL)
2071 TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
2073 if ((TREE_CODE (expr) == VAR_DECL
2074 || TREE_CODE (expr) == PARM_DECL)
2075 && DECL_HAS_VALUE_EXPR_P (expr))
2076 SET_DECL_VALUE_EXPR (expr, lto_input_tree (ib, data_in));
2080 /* Read all pointer fields in the TS_DECL_NON_COMMON structure of
2081 EXPR from input block IB. DATA_IN contains tables and descriptors for the
2085 lto_input_ts_decl_non_common_tree_pointers (struct lto_input_block *ib,
2086 struct data_in *data_in, tree expr)
2088 if (TREE_CODE (expr) == FUNCTION_DECL)
2090 DECL_ARGUMENTS (expr) = lto_input_tree (ib, data_in);
2091 DECL_RESULT (expr) = lto_input_tree (ib, data_in);
2093 DECL_VINDEX (expr) = lto_input_tree (ib, data_in);
2097 /* Read all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
2098 from input block IB. DATA_IN contains tables and descriptors for the
2102 lto_input_ts_decl_with_vis_tree_pointers (struct lto_input_block *ib,
2103 struct data_in *data_in, tree expr)
2107 id = lto_input_tree (ib, data_in);
2110 gcc_assert (TREE_CODE (id) == IDENTIFIER_NODE);
2111 SET_DECL_ASSEMBLER_NAME (expr, id);
2114 DECL_SECTION_NAME (expr) = lto_input_tree (ib, data_in);
2115 DECL_COMDAT_GROUP (expr) = lto_input_tree (ib, data_in);
2119 /* Read all pointer fields in the TS_FIELD_DECL structure of EXPR from
2120 input block IB. DATA_IN contains tables and descriptors for the
2124 lto_input_ts_field_decl_tree_pointers (struct lto_input_block *ib,
2125 struct data_in *data_in, tree expr)
2127 DECL_FIELD_OFFSET (expr) = lto_input_tree (ib, data_in);
2128 DECL_BIT_FIELD_TYPE (expr) = lto_input_tree (ib, data_in);
2129 DECL_QUALIFIER (expr) = lto_input_tree (ib, data_in);
2130 DECL_FIELD_BIT_OFFSET (expr) = lto_input_tree (ib, data_in);
2131 DECL_FCONTEXT (expr) = lto_input_tree (ib, data_in);
2132 TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
2136 /* Read all pointer fields in the TS_FUNCTION_DECL structure of EXPR
2137 from input block IB. DATA_IN contains tables and descriptors for the
2141 lto_input_ts_function_decl_tree_pointers (struct lto_input_block *ib,
2142 struct data_in *data_in, tree expr)
2144 /* DECL_STRUCT_FUNCTION is handled by lto_input_function. FIXME lto,
2145 maybe it should be handled here? */
2146 DECL_FUNCTION_PERSONALITY (expr) = lto_input_tree (ib, data_in);
2147 DECL_FUNCTION_SPECIFIC_TARGET (expr) = lto_input_tree (ib, data_in);
2148 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr) = lto_input_tree (ib, data_in);
2150 /* If the file contains a function with an EH personality set,
2151 then it was compiled with -fexceptions. In that case, initialize
2152 the backend EH machinery. */
2153 if (DECL_FUNCTION_PERSONALITY (expr))
2158 /* Read all pointer fields in the TS_TYPE structure of EXPR from input
2159 block IB. DATA_IN contains tables and descriptors for the
2163 lto_input_ts_type_tree_pointers (struct lto_input_block *ib,
2164 struct data_in *data_in, tree expr)
2166 if (TREE_CODE (expr) == ENUMERAL_TYPE)
2167 TYPE_VALUES (expr) = lto_input_tree (ib, data_in);
2168 else if (TREE_CODE (expr) == ARRAY_TYPE)
2169 TYPE_DOMAIN (expr) = lto_input_tree (ib, data_in);
2170 else if (RECORD_OR_UNION_TYPE_P (expr))
2171 TYPE_FIELDS (expr) = lto_input_tree (ib, data_in);
2172 else if (TREE_CODE (expr) == FUNCTION_TYPE
2173 || TREE_CODE (expr) == METHOD_TYPE)
2174 TYPE_ARG_TYPES (expr) = lto_input_tree (ib, data_in);
2175 else if (TREE_CODE (expr) == VECTOR_TYPE)
2176 TYPE_DEBUG_REPRESENTATION_TYPE (expr) = lto_input_tree (ib, data_in);
2178 TYPE_SIZE (expr) = lto_input_tree (ib, data_in);
2179 TYPE_SIZE_UNIT (expr) = lto_input_tree (ib, data_in);
2180 TYPE_ATTRIBUTES (expr) = lto_input_tree (ib, data_in);
2181 TYPE_NAME (expr) = lto_input_tree (ib, data_in);
2182 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO nor
2183 TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. */
2184 if (!POINTER_TYPE_P (expr))
2185 TYPE_MINVAL (expr) = lto_input_tree (ib, data_in);
2186 TYPE_MAXVAL (expr) = lto_input_tree (ib, data_in);
2187 TYPE_MAIN_VARIANT (expr) = lto_input_tree (ib, data_in);
2188 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
2190 if (RECORD_OR_UNION_TYPE_P (expr))
2191 TYPE_BINFO (expr) = lto_input_tree (ib, data_in);
2192 TYPE_CONTEXT (expr) = lto_input_tree (ib, data_in);
2193 TYPE_CANONICAL (expr) = lto_input_tree (ib, data_in);
2194 TYPE_STUB_DECL (expr) = lto_input_tree (ib, data_in);
2198 /* Read all pointer fields in the TS_LIST structure of EXPR from input
2199 block IB. DATA_IN contains tables and descriptors for the
2203 lto_input_ts_list_tree_pointers (struct lto_input_block *ib,
2204 struct data_in *data_in, tree expr)
2206 TREE_PURPOSE (expr) = lto_input_tree (ib, data_in);
2207 TREE_VALUE (expr) = lto_input_tree (ib, data_in);
2208 TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
2212 /* Read all pointer fields in the TS_VEC structure of EXPR from input
2213 block IB. DATA_IN contains tables and descriptors for the
2217 lto_input_ts_vec_tree_pointers (struct lto_input_block *ib,
2218 struct data_in *data_in, tree expr)
2222 /* Note that TREE_VEC_LENGTH was read by lto_materialize_tree to
2223 instantiate EXPR. */
2224 for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
2225 TREE_VEC_ELT (expr, i) = lto_input_tree (ib, data_in);
2229 /* Read all pointer fields in the TS_EXP structure of EXPR from input
2230 block IB. DATA_IN contains tables and descriptors for the
2235 lto_input_ts_exp_tree_pointers (struct lto_input_block *ib,
2236 struct data_in *data_in, tree expr)
2241 length = lto_input_sleb128 (ib);
2242 gcc_assert (length == TREE_OPERAND_LENGTH (expr));
2244 for (i = 0; i < length; i++)
2245 TREE_OPERAND (expr, i) = lto_input_tree (ib, data_in);
2247 loc = lto_input_location (ib, data_in);
2248 SET_EXPR_LOCATION (expr, loc);
2249 TREE_BLOCK (expr) = lto_input_tree (ib, data_in);
2253 /* Read all pointer fields in the TS_BLOCK structure of EXPR from input
2254 block IB. DATA_IN contains tables and descriptors for the
2258 lto_input_ts_block_tree_pointers (struct lto_input_block *ib,
2259 struct data_in *data_in, tree expr)
2263 BLOCK_SOURCE_LOCATION (expr) = lto_input_location (ib, data_in);
2264 BLOCK_VARS (expr) = lto_input_chain (ib, data_in);
2266 len = lto_input_uleb128 (ib);
2267 for (i = 0; i < len; i++)
2269 tree t = lto_input_tree (ib, data_in);
2270 VEC_safe_push (tree, gc, BLOCK_NONLOCALIZED_VARS (expr), t);
2273 BLOCK_SUPERCONTEXT (expr) = lto_input_tree (ib, data_in);
2274 BLOCK_ABSTRACT_ORIGIN (expr) = lto_input_tree (ib, data_in);
2275 BLOCK_FRAGMENT_ORIGIN (expr) = lto_input_tree (ib, data_in);
2276 BLOCK_FRAGMENT_CHAIN (expr) = lto_input_tree (ib, data_in);
2277 BLOCK_SUBBLOCKS (expr) = lto_input_chain (ib, data_in);
2281 /* Read all pointer fields in the TS_BINFO structure of EXPR from input
2282 block IB. DATA_IN contains tables and descriptors for the
2286 lto_input_ts_binfo_tree_pointers (struct lto_input_block *ib,
2287 struct data_in *data_in, tree expr)
2292 /* Note that the number of slots in EXPR was read in
2293 lto_materialize_tree when instantiating EXPR. However, the
2294 vector is empty so we cannot rely on VEC_length to know how many
2295 elements to read. So, this list is emitted as a 0-terminated
2296 list on the writer side. */
2299 t = lto_input_tree (ib, data_in);
2301 VEC_quick_push (tree, BINFO_BASE_BINFOS (expr), t);
2305 BINFO_OFFSET (expr) = lto_input_tree (ib, data_in);
2306 BINFO_VTABLE (expr) = lto_input_tree (ib, data_in);
2307 BINFO_VIRTUALS (expr) = lto_input_tree (ib, data_in);
2308 BINFO_VPTR_FIELD (expr) = lto_input_tree (ib, data_in);
2310 len = lto_input_uleb128 (ib);
2311 for (i = 0; i < len; i++)
2313 tree a = lto_input_tree (ib, data_in);
2314 VEC_safe_push (tree, gc, BINFO_BASE_ACCESSES (expr), a);
2317 BINFO_INHERITANCE_CHAIN (expr) = lto_input_tree (ib, data_in);
2318 BINFO_SUBVTT_INDEX (expr) = lto_input_tree (ib, data_in);
2319 BINFO_VPTR_INDEX (expr) = lto_input_tree (ib, data_in);
2323 /* Read all pointer fields in the TS_CONSTRUCTOR structure of EXPR from
2324 input block IB. DATA_IN contains tables and descriptors for the
2328 lto_input_ts_constructor_tree_pointers (struct lto_input_block *ib,
2329 struct data_in *data_in, tree expr)
2333 len = lto_input_uleb128 (ib);
2334 for (i = 0; i < len; i++)
2338 index = lto_input_tree (ib, data_in);
2339 value = lto_input_tree (ib, data_in);
2340 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (expr), index, value);
2345 /* Helper for lto_input_tree. Read all pointer fields in EXPR from
2346 input block IB. DATA_IN contains tables and descriptors for the
2350 lto_input_tree_pointers (struct lto_input_block *ib, struct data_in *data_in,
2353 enum tree_code code;
2355 code = TREE_CODE (expr);
2357 if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
2358 lto_input_ts_common_tree_pointers (ib, data_in, expr);
2360 if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
2361 lto_input_ts_vector_tree_pointers (ib, data_in, expr);
2363 if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
2364 lto_input_ts_complex_tree_pointers (ib, data_in, expr);
2366 if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
2367 lto_input_ts_decl_minimal_tree_pointers (ib, data_in, expr);
2369 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
2370 lto_input_ts_decl_common_tree_pointers (ib, data_in, expr);
2372 if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
2373 lto_input_ts_decl_non_common_tree_pointers (ib, data_in, expr);
2375 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
2376 lto_input_ts_decl_with_vis_tree_pointers (ib, data_in, expr);
2378 if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
2379 lto_input_ts_field_decl_tree_pointers (ib, data_in, expr);
2381 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
2382 lto_input_ts_function_decl_tree_pointers (ib, data_in, expr);
2384 if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
2385 lto_input_ts_type_tree_pointers (ib, data_in, expr);
2387 if (CODE_CONTAINS_STRUCT (code, TS_LIST))
2388 lto_input_ts_list_tree_pointers (ib, data_in, expr);
2390 if (CODE_CONTAINS_STRUCT (code, TS_VEC))
2391 lto_input_ts_vec_tree_pointers (ib, data_in, expr);
2393 if (CODE_CONTAINS_STRUCT (code, TS_EXP))
2394 lto_input_ts_exp_tree_pointers (ib, data_in, expr);
2396 if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
2398 /* We only stream the version number of SSA names. */
2402 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
2403 lto_input_ts_block_tree_pointers (ib, data_in, expr);
2405 if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
2406 lto_input_ts_binfo_tree_pointers (ib, data_in, expr);
2408 if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
2410 /* This should only appear in GENERIC. */
2414 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
2415 lto_input_ts_constructor_tree_pointers (ib, data_in, expr);
2417 if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
2419 /* This should only appear in High GIMPLE. */
2423 if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
2425 sorry ("optimization options not supported yet");
2428 if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
2430 sorry ("target optimization options not supported yet");
2435 /* Register DECL with the global symbol table and change its
2436 name if necessary to avoid name clashes for static globals across
2440 lto_register_var_decl_in_symtab (struct data_in *data_in, tree decl)
2442 /* Register symbols with file or global scope to mark what input
2443 file has their definition. */
2444 if (decl_function_context (decl) == NULL_TREE)
2446 /* Variable has file scope, not local. Need to ensure static variables
2447 between different files don't clash unexpectedly. */
2448 if (!TREE_PUBLIC (decl))
2450 /* ??? We normally pre-mangle names before we serialize them
2451 out. Here, in lto1, we do not know the language, and
2452 thus cannot do the mangling again. Instead, we just
2453 append a suffix to the mangled name. The resulting name,
2454 however, is not a properly-formed mangled name, and will
2455 confuse any attempt to unmangle it. */
2456 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2459 ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
2460 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
2461 rest_of_decl_compilation (decl, 1, 0);
2465 /* If this variable has already been declared, queue the
2466 declaration for merging. */
2467 if (TREE_PUBLIC (decl))
2470 if (!lto_streamer_cache_lookup (data_in->reader_cache, decl, &ix))
2472 lto_symtab_register_decl (decl, get_resolution (data_in, ix),
2473 data_in->file_data);
2479 /* Register DECL with the global symbol table and change its
2480 name if necessary to avoid name clashes for static globals across
2481 different files. DATA_IN contains descriptors and tables for the
2485 lto_register_function_decl_in_symtab (struct data_in *data_in, tree decl)
2487 /* Need to ensure static entities between different files
2488 don't clash unexpectedly. */
2489 if (!TREE_PUBLIC (decl))
2491 /* We must not use the DECL_ASSEMBLER_NAME macro here, as it
2492 may set the assembler name where it was previously empty. */
2493 tree old_assembler_name = decl->decl_with_vis.assembler_name;
2495 /* FIXME lto: We normally pre-mangle names before we serialize
2496 them out. Here, in lto1, we do not know the language, and
2497 thus cannot do the mangling again. Instead, we just append a
2498 suffix to the mangled name. The resulting name, however, is
2499 not a properly-formed mangled name, and will confuse any
2500 attempt to unmangle it. */
2501 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2504 ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
2505 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
2507 /* We may arrive here with the old assembler name not set
2508 if the function body is not needed, e.g., it has been
2509 inlined away and does not appear in the cgraph. */
2510 if (old_assembler_name)
2512 tree new_assembler_name = DECL_ASSEMBLER_NAME (decl);
2514 /* Make the original assembler name available for later use.
2515 We may have used it to indicate the section within its
2516 object file where the function body may be found.
2517 FIXME lto: Find a better way to maintain the function decl
2518 to body section mapping so we don't need this hack. */
2519 lto_record_renamed_decl (data_in->file_data,
2520 IDENTIFIER_POINTER (old_assembler_name),
2521 IDENTIFIER_POINTER (new_assembler_name));
2523 /* Also register the reverse mapping so that we can find the
2524 new name given to an existing assembler name (used when
2525 restoring alias pairs in input_constructors_or_inits. */
2526 lto_record_renamed_decl (data_in->file_data,
2527 IDENTIFIER_POINTER (new_assembler_name),
2528 IDENTIFIER_POINTER (old_assembler_name));
2532 /* If this variable has already been declared, queue the
2533 declaration for merging. */
2534 if (TREE_PUBLIC (decl) && !DECL_ABSTRACT (decl))
2537 if (!lto_streamer_cache_lookup (data_in->reader_cache, decl, &ix))
2539 lto_symtab_register_decl (decl, get_resolution (data_in, ix),
2540 data_in->file_data);
2545 /* Read an index IX from input block IB and return the tree node at
2546 DATA_IN->FILE_DATA->GLOBALS_INDEX[IX]. */
2549 lto_get_pickled_tree (struct lto_input_block *ib, struct data_in *data_in)
2553 enum LTO_tags expected_tag;
2554 unsigned HOST_WIDE_INT orig_offset;
2556 ix = lto_input_sleb128 (ib);
2557 expected_tag = (enum LTO_tags) lto_input_uleb128 (ib);
2559 orig_offset = lto_input_uleb128 (ib);
2560 gcc_assert (orig_offset == (unsigned) orig_offset);
2562 result = lto_streamer_cache_get (data_in->reader_cache, ix);
2563 if (result == NULL_TREE)
2565 /* We have not yet read the cache slot IX. Go to the offset
2566 in the stream where the physical tree node is, and materialize
2568 struct lto_input_block fwd_ib;
2570 /* If we are trying to go back in the stream, something is wrong.
2571 We should've read the node at the earlier position already. */
2572 if (ib->p >= orig_offset)
2573 internal_error ("bytecode stream: tried to jump backwards in the "
2576 LTO_INIT_INPUT_BLOCK (fwd_ib, ib->data, orig_offset, ib->len);
2577 result = lto_input_tree (&fwd_ib, data_in);
2581 && TREE_CODE (result) == lto_tag_to_tree_code (expected_tag));
2587 /* Read a code and class from input block IB and return the
2588 corresponding builtin. DATA_IN is as in lto_input_tree. */
2591 lto_get_builtin_tree (struct lto_input_block *ib, struct data_in *data_in)
2593 enum built_in_class fclass;
2594 enum built_in_function fcode;
2595 const char *asmname;
2599 fclass = (enum built_in_class) lto_input_uleb128 (ib);
2600 gcc_assert (fclass == BUILT_IN_NORMAL || fclass == BUILT_IN_MD);
2602 fcode = (enum built_in_function) lto_input_uleb128 (ib);
2604 ix = lto_input_sleb128 (ib);
2605 gcc_assert (ix == (int) ix);
2607 if (fclass == BUILT_IN_NORMAL)
2609 gcc_assert (fcode < END_BUILTINS);
2610 result = built_in_decls[fcode];
2611 gcc_assert (result);
2613 else if (fclass == BUILT_IN_MD)
2615 result = targetm.builtin_decl (fcode, true);
2616 if (!result || result == error_mark_node)
2617 fatal_error ("target specific builtin not available");
2622 asmname = input_string (data_in, ib);
2624 set_builtin_user_assembler_name (result, asmname);
2626 lto_streamer_cache_insert_at (data_in->reader_cache, result, ix);
2632 /* Read the physical representation of a tree node with tag TAG from
2633 input block IB using the per-file context in DATA_IN. */
2636 lto_read_tree (struct lto_input_block *ib, struct data_in *data_in,
2642 result = lto_materialize_tree (ib, data_in, tag, &ix);
2644 /* Read all the pointer fields in RESULT. */
2645 lto_input_tree_pointers (ib, data_in, result);
2647 /* We should never try to instantiate an MD or NORMAL builtin here. */
2648 if (TREE_CODE (result) == FUNCTION_DECL)
2649 gcc_assert (!lto_stream_as_builtin_p (result));
2651 if (TREE_CODE (result) == VAR_DECL)
2652 lto_register_var_decl_in_symtab (data_in, result);
2653 else if (TREE_CODE (result) == FUNCTION_DECL && !DECL_BUILT_IN (result))
2654 lto_register_function_decl_in_symtab (data_in, result);
2656 /* end_marker = */ lto_input_1_unsigned (ib);
2658 #ifdef LTO_STREAMER_DEBUG
2659 /* Remove the mapping to RESULT's original address set by
2660 lto_materialize_tree. */
2661 lto_orig_address_remove (result);
2668 /* Read and INTEGER_CST node from input block IB using the per-file
2669 context in DATA_IN. */
2672 lto_input_integer_cst (struct lto_input_block *ib, struct data_in *data_in)
2675 HOST_WIDE_INT low, high;
2678 type = lto_input_tree (ib, data_in);
2679 overflow_p = (lto_input_1_unsigned (ib) != 0);
2680 low = lto_input_uleb128 (ib);
2681 high = lto_input_uleb128 (ib);
2682 result = build_int_cst_wide (type, low, high);
2684 /* If the original constant had overflown, build a replica of RESULT to
2685 avoid modifying the shared constant returned by build_int_cst_wide. */
2688 result = copy_node (result);
2689 TREE_OVERFLOW (result) = 1;
2696 /* Read a tree from input block IB using the per-file context in
2697 DATA_IN. This context is used, for example, to resolve references
2698 to previously read nodes. */
2701 lto_input_tree (struct lto_input_block *ib, struct data_in *data_in)
2706 tag = input_record_start (ib);
2707 gcc_assert ((unsigned) tag < (unsigned) LTO_NUM_TAGS);
2709 if (tag == LTO_null)
2711 else if (tag >= LTO_field_decl_ref && tag <= LTO_global_decl_ref)
2713 /* If TAG is a reference to an indexable tree, the next value
2714 in IB is the index into the table where we expect to find
2716 result = lto_input_tree_ref (ib, data_in, cfun, tag);
2718 else if (tag == LTO_tree_pickle_reference)
2720 /* If TAG is a reference to a previously read tree, look it up in
2721 the reader cache. */
2722 result = lto_get_pickled_tree (ib, data_in);
2724 else if (tag == LTO_builtin_decl)
2726 /* If we are going to read a built-in function, all we need is
2727 the code and class. */
2728 result = lto_get_builtin_tree (ib, data_in);
2730 else if (tag == lto_tree_code_to_tag (INTEGER_CST))
2732 /* For integer constants we only need the type and its hi/low
2734 result = lto_input_integer_cst (ib, data_in);
2738 /* Otherwise, materialize a new node from IB. */
2739 result = lto_read_tree (ib, data_in, tag);
2746 /* Initialization for the LTO reader. */
2749 lto_init_reader (void)
2751 lto_streamer_init ();
2753 memset (<o_stats, 0, sizeof (lto_stats));
2754 bitmap_obstack_initialize (NULL);
2756 file_name_hash_table = htab_create (37, hash_string_slot_node,
2757 eq_string_slot_node, free);
2759 gimple_register_cfg_hooks ();
2763 /* Create a new data_in object for FILE_DATA. STRINGS is the string
2764 table to use with LEN strings. RESOLUTIONS is the vector of linker
2765 resolutions (NULL if not using a linker plugin). */
2768 lto_data_in_create (struct lto_file_decl_data *file_data, const char *strings,
2770 VEC(ld_plugin_symbol_resolution_t,heap) *resolutions)
2772 struct data_in *data_in = XCNEW (struct data_in);
2773 data_in->file_data = file_data;
2774 data_in->strings = strings;
2775 data_in->strings_len = len;
2776 data_in->globals_resolution = resolutions;
2777 data_in->reader_cache = lto_streamer_cache_create ();
2783 /* Remove DATA_IN. */
2786 lto_data_in_delete (struct data_in *data_in)
2788 VEC_free (ld_plugin_symbol_resolution_t, heap, data_in->globals_resolution);
2789 lto_streamer_cache_delete (data_in->reader_cache);
2790 free (data_in->labels);