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 case LTO_translation_unit_decl_ref:
359 ix_u = lto_input_uleb128 (ib);
360 result = lto_file_decl_data_get_var_decl (data_in->file_data, ix_u);
373 /* Read and return a double-linked list of catch handlers from input
374 block IB, using descriptors in DATA_IN. */
376 static struct eh_catch_d *
377 lto_input_eh_catch_list (struct lto_input_block *ib, struct data_in *data_in,
383 *last_p = first = NULL;
384 tag = input_record_start (ib);
390 lto_tag_check_range (tag, LTO_eh_catch, LTO_eh_catch);
392 /* Read the catch node. */
393 n = ggc_alloc_cleared_eh_catch_d ();
394 n->type_list = lto_input_tree (ib, data_in);
395 n->filter_list = lto_input_tree (ib, data_in);
396 n->label = lto_input_tree (ib, data_in);
398 /* Register all the types in N->FILTER_LIST. */
399 for (list = n->filter_list; list; list = TREE_CHAIN (list))
400 add_type_for_runtime (TREE_VALUE (list));
402 /* Chain N to the end of the list. */
404 (*last_p)->next_catch = n;
405 n->prev_catch = *last_p;
408 /* Set the head of the list the first time through the loop. */
412 tag = input_record_start (ib);
419 /* Read and return EH region IX from input block IB, using descriptors
423 input_eh_region (struct lto_input_block *ib, struct data_in *data_in, int ix)
428 /* Read the region header. */
429 tag = input_record_start (ib);
433 r = ggc_alloc_cleared_eh_region_d ();
434 r->index = lto_input_sleb128 (ib);
436 gcc_assert (r->index == ix);
438 /* Read all the region pointers as region numbers. We'll fix up
439 the pointers once the whole array has been read. */
440 r->outer = (eh_region) (intptr_t) lto_input_sleb128 (ib);
441 r->inner = (eh_region) (intptr_t) lto_input_sleb128 (ib);
442 r->next_peer = (eh_region) (intptr_t) lto_input_sleb128 (ib);
446 case LTO_ert_cleanup:
447 r->type = ERT_CLEANUP;
452 struct eh_catch_d *last_catch;
454 r->u.eh_try.first_catch = lto_input_eh_catch_list (ib, data_in,
456 r->u.eh_try.last_catch = last_catch;
460 case LTO_ert_allowed_exceptions:
464 r->type = ERT_ALLOWED_EXCEPTIONS;
465 r->u.allowed.type_list = lto_input_tree (ib, data_in);
466 r->u.allowed.label = lto_input_tree (ib, data_in);
467 r->u.allowed.filter = lto_input_uleb128 (ib);
469 for (l = r->u.allowed.type_list; l ; l = TREE_CHAIN (l))
470 add_type_for_runtime (TREE_VALUE (l));
474 case LTO_ert_must_not_throw:
475 r->type = ERT_MUST_NOT_THROW;
476 r->u.must_not_throw.failure_decl = lto_input_tree (ib, data_in);
477 r->u.must_not_throw.failure_loc = lto_input_location (ib, data_in);
484 r->landing_pads = (eh_landing_pad) (intptr_t) lto_input_sleb128 (ib);
490 /* Read and return EH landing pad IX from input block IB, using descriptors
493 static eh_landing_pad
494 input_eh_lp (struct lto_input_block *ib, struct data_in *data_in, int ix)
499 /* Read the landing pad header. */
500 tag = input_record_start (ib);
504 lto_tag_check_range (tag, LTO_eh_landing_pad, LTO_eh_landing_pad);
506 lp = ggc_alloc_cleared_eh_landing_pad_d ();
507 lp->index = lto_input_sleb128 (ib);
508 gcc_assert (lp->index == ix);
509 lp->next_lp = (eh_landing_pad) (intptr_t) lto_input_sleb128 (ib);
510 lp->region = (eh_region) (intptr_t) lto_input_sleb128 (ib);
511 lp->post_landing_pad = lto_input_tree (ib, data_in);
517 /* After reading the EH regions, pointers to peer and children regions
518 are region numbers. This converts all these region numbers into
519 real pointers into the rematerialized regions for FN. ROOT_REGION
520 is the region number for the root EH region in FN. */
523 fixup_eh_region_pointers (struct function *fn, HOST_WIDE_INT root_region)
526 VEC(eh_region,gc) *eh_array = fn->eh->region_array;
527 VEC(eh_landing_pad,gc) *lp_array = fn->eh->lp_array;
531 gcc_assert (eh_array && lp_array);
533 gcc_assert (root_region >= 0);
534 fn->eh->region_tree = VEC_index (eh_region, eh_array, root_region);
536 #define FIXUP_EH_REGION(r) (r) = VEC_index (eh_region, eh_array, \
537 (HOST_WIDE_INT) (intptr_t) (r))
538 #define FIXUP_EH_LP(p) (p) = VEC_index (eh_landing_pad, lp_array, \
539 (HOST_WIDE_INT) (intptr_t) (p))
541 /* Convert all the index numbers stored in pointer fields into
542 pointers to the corresponding slots in the EH region array. */
543 FOR_EACH_VEC_ELT (eh_region, eh_array, i, r)
545 /* The array may contain NULL regions. */
549 gcc_assert (i == (unsigned) r->index);
550 FIXUP_EH_REGION (r->outer);
551 FIXUP_EH_REGION (r->inner);
552 FIXUP_EH_REGION (r->next_peer);
553 FIXUP_EH_LP (r->landing_pads);
556 /* Convert all the index numbers stored in pointer fields into
557 pointers to the corresponding slots in the EH landing pad array. */
558 FOR_EACH_VEC_ELT (eh_landing_pad, lp_array, i, lp)
560 /* The array may contain NULL landing pads. */
564 gcc_assert (i == (unsigned) lp->index);
565 FIXUP_EH_LP (lp->next_lp);
566 FIXUP_EH_REGION (lp->region);
569 #undef FIXUP_EH_REGION
574 /* Initialize EH support. */
579 static bool eh_initialized_p = false;
581 if (eh_initialized_p)
584 /* Contrary to most other FEs, we only initialize EH support when at
585 least one of the files in the set contains exception regions in
586 it. Since this happens much later than the call to init_eh in
587 lang_dependent_init, we have to set flag_exceptions and call
588 init_eh again to initialize the EH tables. */
592 /* Initialize dwarf2 tables. Since dwarf2out_do_frame() returns
593 true only when exceptions are enabled, this initialization is
594 never done during lang_dependent_init. */
595 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
596 if (dwarf2out_do_frame ())
597 dwarf2out_frame_init ();
600 eh_initialized_p = true;
604 /* Read the exception table for FN from IB using the data descriptors
608 input_eh_regions (struct lto_input_block *ib, struct data_in *data_in,
611 HOST_WIDE_INT i, root_region, len;
614 tag = input_record_start (ib);
618 lto_tag_check_range (tag, LTO_eh_table, LTO_eh_table);
620 /* If the file contains EH regions, then it was compiled with
621 -fexceptions. In that case, initialize the backend EH
627 root_region = lto_input_sleb128 (ib);
628 gcc_assert (root_region == (int) root_region);
630 /* Read the EH region array. */
631 len = lto_input_sleb128 (ib);
632 gcc_assert (len == (int) len);
635 VEC_safe_grow (eh_region, gc, fn->eh->region_array, len);
636 for (i = 0; i < len; i++)
638 eh_region r = input_eh_region (ib, data_in, i);
639 VEC_replace (eh_region, fn->eh->region_array, i, r);
643 /* Read the landing pads. */
644 len = lto_input_sleb128 (ib);
645 gcc_assert (len == (int) len);
648 VEC_safe_grow (eh_landing_pad, gc, fn->eh->lp_array, len);
649 for (i = 0; i < len; i++)
651 eh_landing_pad lp = input_eh_lp (ib, data_in, i);
652 VEC_replace (eh_landing_pad, fn->eh->lp_array, i, lp);
656 /* Read the runtime type data. */
657 len = lto_input_sleb128 (ib);
658 gcc_assert (len == (int) len);
661 VEC_safe_grow (tree, gc, fn->eh->ttype_data, len);
662 for (i = 0; i < len; i++)
664 tree ttype = lto_input_tree (ib, data_in);
665 VEC_replace (tree, fn->eh->ttype_data, i, ttype);
669 /* Read the table of action chains. */
670 len = lto_input_sleb128 (ib);
671 gcc_assert (len == (int) len);
674 if (targetm.arm_eabi_unwinder)
676 VEC_safe_grow (tree, gc, fn->eh->ehspec_data.arm_eabi, len);
677 for (i = 0; i < len; i++)
679 tree t = lto_input_tree (ib, data_in);
680 VEC_replace (tree, fn->eh->ehspec_data.arm_eabi, i, t);
685 VEC_safe_grow (uchar, gc, fn->eh->ehspec_data.other, len);
686 for (i = 0; i < len; i++)
688 uchar c = lto_input_1_unsigned (ib);
689 VEC_replace (uchar, fn->eh->ehspec_data.other, i, c);
694 /* Reconstruct the EH region tree by fixing up the peer/children
696 fixup_eh_region_pointers (fn, root_region);
698 tag = input_record_start (ib);
699 lto_tag_check_range (tag, LTO_null, LTO_null);
703 /* Make a new basic block with index INDEX in function FN. */
706 make_new_block (struct function *fn, unsigned int index)
708 basic_block bb = alloc_block ();
710 SET_BASIC_BLOCK_FOR_FUNCTION (fn, index, bb);
711 bb->il.gimple = ggc_alloc_cleared_gimple_bb_info ();
712 n_basic_blocks_for_function (fn)++;
714 set_bb_seq (bb, gimple_seq_alloc ());
719 /* Read the CFG for function FN from input block IB. */
722 input_cfg (struct lto_input_block *ib, struct function *fn,
723 int count_materialization_scale)
725 unsigned int bb_count;
730 init_empty_tree_cfg_for_function (fn);
731 init_ssa_operands ();
733 profile_status_for_function (fn) =
734 (enum profile_status_d) lto_input_uleb128 (ib);
736 bb_count = lto_input_uleb128 (ib);
738 last_basic_block_for_function (fn) = bb_count;
739 if (bb_count > VEC_length (basic_block, basic_block_info_for_function (fn)))
740 VEC_safe_grow_cleared (basic_block, gc,
741 basic_block_info_for_function (fn), bb_count);
743 if (bb_count > VEC_length (basic_block, label_to_block_map_for_function (fn)))
744 VEC_safe_grow_cleared (basic_block, gc,
745 label_to_block_map_for_function (fn), bb_count);
747 index = lto_input_sleb128 (ib);
750 basic_block bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
751 unsigned int edge_count;
754 bb = make_new_block (fn, index);
756 edge_count = lto_input_uleb128 (ib);
758 /* Connect up the CFG. */
759 for (i = 0; i < edge_count; i++)
761 unsigned int dest_index;
762 unsigned int edge_flags;
768 dest_index = lto_input_uleb128 (ib);
769 probability = (int) lto_input_sleb128 (ib);
770 count = ((gcov_type) lto_input_sleb128 (ib) * count_materialization_scale
771 + REG_BR_PROB_BASE / 2) / REG_BR_PROB_BASE;
772 edge_flags = lto_input_uleb128 (ib);
774 dest = BASIC_BLOCK_FOR_FUNCTION (fn, dest_index);
777 dest = make_new_block (fn, dest_index);
779 e = make_edge (bb, dest, edge_flags);
780 e->probability = probability;
784 index = lto_input_sleb128 (ib);
787 p_bb = ENTRY_BLOCK_PTR_FOR_FUNCTION(fn);
788 index = lto_input_sleb128 (ib);
791 basic_block bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
795 index = lto_input_sleb128 (ib);
800 /* Read a PHI function for basic block BB in function FN. DATA_IN is
801 the file being read. IB is the input block to use for reading. */
804 input_phi (struct lto_input_block *ib, basic_block bb, struct data_in *data_in,
807 unsigned HOST_WIDE_INT ix;
812 ix = lto_input_uleb128 (ib);
813 phi_result = VEC_index (tree, SSANAMES (fn), ix);
814 len = EDGE_COUNT (bb->preds);
815 result = create_phi_node (phi_result, bb);
816 SSA_NAME_DEF_STMT (phi_result) = result;
818 /* We have to go through a lookup process here because the preds in the
819 reconstructed graph are generally in a different order than they
820 were in the original program. */
821 for (i = 0; i < len; i++)
823 tree def = lto_input_tree (ib, data_in);
824 int src_index = lto_input_uleb128 (ib);
825 location_t arg_loc = lto_input_location (ib, data_in);
826 basic_block sbb = BASIC_BLOCK_FOR_FUNCTION (fn, src_index);
831 for (j = 0; j < len; j++)
832 if (EDGE_PRED (bb, j)->src == sbb)
834 e = EDGE_PRED (bb, j);
838 add_phi_arg (result, def, e, arg_loc);
845 /* Read the SSA names array for function FN from DATA_IN using input
849 input_ssa_names (struct lto_input_block *ib, struct data_in *data_in,
852 unsigned int i, size;
854 size = lto_input_uleb128 (ib);
855 init_ssanames (fn, size);
857 i = lto_input_uleb128 (ib);
863 /* Skip over the elements that had been freed. */
864 while (VEC_length (tree, SSANAMES (fn)) < i)
865 VEC_quick_push (tree, SSANAMES (fn), NULL_TREE);
867 is_default_def = (lto_input_1_unsigned (ib) != 0);
868 name = lto_input_tree (ib, data_in);
869 ssa_name = make_ssa_name_fn (fn, name, gimple_build_nop ());
872 set_default_def (SSA_NAME_VAR (ssa_name), ssa_name);
874 i = lto_input_uleb128 (ib);
878 /* Read a statement with tag TAG in function FN from block IB using
879 descriptors in DATA_IN. */
882 input_gimple_stmt (struct lto_input_block *ib, struct data_in *data_in,
883 struct function *fn, enum LTO_tags tag)
886 enum gimple_code code;
887 unsigned HOST_WIDE_INT num_ops;
891 code = lto_tag_to_gimple_code (tag);
893 /* Read the tuple header. */
894 bp = lto_input_bitpack (ib);
895 num_ops = bp_unpack_value (&bp, sizeof (unsigned) * 8);
896 stmt = gimple_alloc (code, num_ops);
897 stmt->gsbase.no_warning = bp_unpack_value (&bp, 1);
898 if (is_gimple_assign (stmt))
899 stmt->gsbase.nontemporal_move = bp_unpack_value (&bp, 1);
900 stmt->gsbase.has_volatile_ops = bp_unpack_value (&bp, 1);
901 stmt->gsbase.subcode = bp_unpack_value (&bp, 16);
903 /* Read location information. */
904 gimple_set_location (stmt, lto_input_location (ib, data_in));
906 /* Read lexical block reference. */
907 gimple_set_block (stmt, lto_input_tree (ib, data_in));
909 /* Read in all the operands. */
913 gimple_resx_set_region (stmt, lto_input_sleb128 (ib));
916 case GIMPLE_EH_MUST_NOT_THROW:
917 gimple_eh_must_not_throw_set_fndecl (stmt, lto_input_tree (ib, data_in));
920 case GIMPLE_EH_DISPATCH:
921 gimple_eh_dispatch_set_region (stmt, lto_input_sleb128 (ib));
926 /* FIXME lto. Move most of this into a new gimple_asm_set_string(). */
928 stmt->gimple_asm.ni = lto_input_uleb128 (ib);
929 stmt->gimple_asm.no = lto_input_uleb128 (ib);
930 stmt->gimple_asm.nc = lto_input_uleb128 (ib);
931 stmt->gimple_asm.nl = lto_input_uleb128 (ib);
932 str = input_string_cst (data_in, ib);
933 stmt->gimple_asm.string = TREE_STRING_POINTER (str);
945 for (i = 0; i < num_ops; i++)
947 tree op = lto_input_tree (ib, data_in);
948 gimple_set_op (stmt, i, op);
952 /* Fixup FIELD_DECLs in COMPONENT_REFs, they are not handled
954 if (TREE_CODE (op) == ADDR_EXPR)
955 op = TREE_OPERAND (op, 0);
956 while (handled_component_p (op))
958 if (TREE_CODE (op) == COMPONENT_REF)
960 tree field, type, tem;
961 tree closest_match = NULL_TREE;
962 field = TREE_OPERAND (op, 1);
963 type = DECL_CONTEXT (field);
964 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
968 if (DECL_NONADDRESSABLE_P (tem)
969 == DECL_NONADDRESSABLE_P (field)
970 && gimple_compare_field_offset (tem, field))
972 if (types_compatible_p (TREE_TYPE (tem),
979 /* In case of type mismatches across units we can fail
980 to unify some types and thus not find a proper
982 if (tem == NULL_TREE)
984 /* Thus, emit a ODR violation warning. */
985 if (warning_at (gimple_location (stmt), 0,
986 "use of type %<%E%> with two mismatching "
987 "declarations at field %<%E%>",
988 type, TREE_OPERAND (op, 1)))
990 if (TYPE_FIELDS (type))
991 inform (DECL_SOURCE_LOCATION (TYPE_FIELDS (type)),
992 "original type declared here");
993 inform (DECL_SOURCE_LOCATION (TREE_OPERAND (op, 1)),
994 "field in mismatching type declared here");
995 if (TYPE_NAME (TREE_TYPE (field))
996 && (TREE_CODE (TYPE_NAME (TREE_TYPE (field)))
998 inform (DECL_SOURCE_LOCATION
999 (TYPE_NAME (TREE_TYPE (field))),
1000 "type of field declared here");
1002 && TYPE_NAME (TREE_TYPE (closest_match))
1003 && (TREE_CODE (TYPE_NAME
1004 (TREE_TYPE (closest_match))) == TYPE_DECL))
1005 inform (DECL_SOURCE_LOCATION
1006 (TYPE_NAME (TREE_TYPE (closest_match))),
1007 "type of mismatching field declared here");
1009 /* And finally fixup the types. */
1010 TREE_OPERAND (op, 0)
1011 = build1 (VIEW_CONVERT_EXPR, type,
1012 TREE_OPERAND (op, 0));
1015 TREE_OPERAND (op, 1) = tem;
1018 op = TREE_OPERAND (op, 0);
1024 case GIMPLE_PREDICT:
1028 internal_error ("bytecode stream: unknown GIMPLE statement tag %s",
1029 lto_tag_name (tag));
1032 /* Update the properties of symbols, SSA names and labels associated
1034 if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
1036 tree lhs = gimple_get_lhs (stmt);
1037 if (lhs && TREE_CODE (lhs) == SSA_NAME)
1038 SSA_NAME_DEF_STMT (lhs) = stmt;
1040 else if (code == GIMPLE_LABEL)
1041 gcc_assert (emit_label_in_global_context_p (gimple_label_label (stmt))
1042 || DECL_CONTEXT (gimple_label_label (stmt)) == fn->decl);
1043 else if (code == GIMPLE_ASM)
1047 for (i = 0; i < gimple_asm_noutputs (stmt); i++)
1049 tree op = TREE_VALUE (gimple_asm_output_op (stmt, i));
1050 if (TREE_CODE (op) == SSA_NAME)
1051 SSA_NAME_DEF_STMT (op) = stmt;
1055 /* Reset alias information. */
1056 if (code == GIMPLE_CALL)
1057 gimple_call_reset_alias_info (stmt);
1059 /* Mark the statement modified so its operand vectors can be filled in. */
1060 gimple_set_modified (stmt, true);
1066 /* Read a basic block with tag TAG from DATA_IN using input block IB.
1067 FN is the function being processed. */
1070 input_bb (struct lto_input_block *ib, enum LTO_tags tag,
1071 struct data_in *data_in, struct function *fn,
1072 int count_materialization_scale)
1076 gimple_stmt_iterator bsi;
1078 /* This routine assumes that CFUN is set to FN, as it needs to call
1079 basic GIMPLE routines that use CFUN. */
1080 gcc_assert (cfun == fn);
1082 index = lto_input_uleb128 (ib);
1083 bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
1085 bb->count = (lto_input_sleb128 (ib) * count_materialization_scale
1086 + REG_BR_PROB_BASE / 2) / REG_BR_PROB_BASE;
1087 bb->loop_depth = lto_input_sleb128 (ib);
1088 bb->frequency = lto_input_sleb128 (ib);
1089 bb->flags = lto_input_sleb128 (ib);
1091 /* LTO_bb1 has statements. LTO_bb0 does not. */
1095 bsi = gsi_start_bb (bb);
1096 tag = input_record_start (ib);
1099 gimple stmt = input_gimple_stmt (ib, data_in, fn, tag);
1101 find_referenced_vars_in (stmt);
1102 gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
1104 /* After the statement, expect a 0 delimiter or the EH region
1105 that the previous statement belongs to. */
1106 tag = input_record_start (ib);
1107 lto_tag_check_set (tag, 2, LTO_eh_region, LTO_null);
1109 if (tag == LTO_eh_region)
1111 HOST_WIDE_INT region = lto_input_sleb128 (ib);
1112 gcc_assert (region == (int) region);
1113 add_stmt_to_eh_lp (stmt, region);
1116 tag = input_record_start (ib);
1119 tag = input_record_start (ib);
1122 gimple phi = input_phi (ib, bb, data_in, fn);
1123 find_referenced_vars_in (phi);
1124 tag = input_record_start (ib);
1128 /* Go through all NODE edges and fixup call_stmt pointers
1129 so they point to STMTS. */
1132 fixup_call_stmt_edges_1 (struct cgraph_node *node, gimple *stmts)
1134 struct cgraph_edge *cedge;
1135 for (cedge = node->callees; cedge; cedge = cedge->next_callee)
1136 cedge->call_stmt = stmts[cedge->lto_stmt_uid];
1137 for (cedge = node->indirect_calls; cedge; cedge = cedge->next_callee)
1138 cedge->call_stmt = stmts[cedge->lto_stmt_uid];
1141 /* Fixup call_stmt pointers in NODE and all clones. */
1144 fixup_call_stmt_edges (struct cgraph_node *orig, gimple *stmts)
1146 struct cgraph_node *node;
1148 while (orig->clone_of)
1149 orig = orig->clone_of;
1151 fixup_call_stmt_edges_1 (orig, stmts);
1153 for (node = orig->clones; node != orig;)
1155 fixup_call_stmt_edges_1 (node, stmts);
1157 node = node->clones;
1158 else if (node->next_sibling_clone)
1159 node = node->next_sibling_clone;
1162 while (node != orig && !node->next_sibling_clone)
1163 node = node->clone_of;
1165 node = node->next_sibling_clone;
1170 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1173 input_function (tree fn_decl, struct data_in *data_in,
1174 struct lto_input_block *ib)
1176 struct function *fn;
1180 struct bitpack_d bp;
1181 struct cgraph_node *node;
1182 tree args, narg, oarg;
1185 fn = DECL_STRUCT_FUNCTION (fn_decl);
1186 tag = input_record_start (ib);
1187 clear_line_info (data_in);
1189 gimple_register_cfg_hooks ();
1190 lto_tag_check (tag, LTO_function);
1192 /* Read all the attributes for FN. */
1193 bp = lto_input_bitpack (ib);
1194 fn->is_thunk = bp_unpack_value (&bp, 1);
1195 fn->has_local_explicit_reg_vars = bp_unpack_value (&bp, 1);
1196 fn->after_tree_profile = bp_unpack_value (&bp, 1);
1197 fn->returns_pcc_struct = bp_unpack_value (&bp, 1);
1198 fn->returns_struct = bp_unpack_value (&bp, 1);
1199 fn->can_throw_non_call_exceptions = bp_unpack_value (&bp, 1);
1200 fn->always_inline_functions_inlined = bp_unpack_value (&bp, 1);
1201 fn->after_inlining = bp_unpack_value (&bp, 1);
1202 fn->dont_save_pending_sizes_p = bp_unpack_value (&bp, 1);
1203 fn->stdarg = bp_unpack_value (&bp, 1);
1204 fn->has_nonlocal_label = bp_unpack_value (&bp, 1);
1205 fn->calls_alloca = bp_unpack_value (&bp, 1);
1206 fn->calls_setjmp = bp_unpack_value (&bp, 1);
1207 fn->va_list_fpr_size = bp_unpack_value (&bp, 8);
1208 fn->va_list_gpr_size = bp_unpack_value (&bp, 8);
1210 /* Input the function start and end loci. */
1211 fn->function_start_locus = lto_input_location (ib, data_in);
1212 fn->function_end_locus = lto_input_location (ib, data_in);
1214 /* Input the current IL state of the function. */
1215 fn->curr_properties = lto_input_uleb128 (ib);
1217 /* Read the static chain and non-local goto save area. */
1218 fn->static_chain_decl = lto_input_tree (ib, data_in);
1219 fn->nonlocal_goto_save_area = lto_input_tree (ib, data_in);
1221 /* Read all the local symbols. */
1222 len = lto_input_sleb128 (ib);
1226 VEC_safe_grow (tree, gc, fn->local_decls, len);
1227 for (i = 0; i < len; i++)
1229 tree t = lto_input_tree (ib, data_in);
1230 VEC_replace (tree, fn->local_decls, i, t);
1234 /* Read all function arguments. We need to re-map them here to the
1235 arguments of the merged function declaration. */
1236 args = lto_input_tree (ib, data_in);
1237 for (oarg = args, narg = DECL_ARGUMENTS (fn_decl);
1239 oarg = TREE_CHAIN (oarg), narg = TREE_CHAIN (narg))
1243 res = lto_streamer_cache_lookup (data_in->reader_cache, oarg, &ix);
1245 /* Replace the argument in the streamer cache. */
1246 lto_streamer_cache_insert_at (data_in->reader_cache, narg, ix);
1248 gcc_assert (!oarg && !narg);
1250 /* Read all the SSA names. */
1251 input_ssa_names (ib, data_in, fn);
1253 /* Read the exception handling regions in the function. */
1254 input_eh_regions (ib, data_in, fn);
1256 /* Read the tree of lexical scopes for the function. */
1257 DECL_INITIAL (fn_decl) = lto_input_tree (ib, data_in);
1258 gcc_assert (DECL_INITIAL (fn_decl));
1259 DECL_SAVED_TREE (fn_decl) = NULL_TREE;
1260 node = cgraph_node (fn_decl);
1262 /* Read all the basic blocks. */
1263 tag = input_record_start (ib);
1266 input_bb (ib, tag, data_in, fn,
1267 node->count_materialization_scale);
1268 tag = input_record_start (ib);
1271 /* Fix up the call statements that are mentioned in the callgraph
1273 renumber_gimple_stmt_uids ();
1274 stmts = (gimple *) xcalloc (gimple_stmt_max_uid (fn), sizeof (gimple));
1277 gimple_stmt_iterator bsi = gsi_start_bb (bb);
1278 while (!gsi_end_p (bsi))
1280 gimple stmt = gsi_stmt (bsi);
1281 /* If we're recompiling LTO objects with debug stmts but
1282 we're not supposed to have debug stmts, remove them now.
1283 We can't remove them earlier because this would cause uid
1284 mismatches in fixups, but we can do it at this point, as
1285 long as debug stmts don't require fixups. */
1286 if (!MAY_HAVE_DEBUG_STMTS && is_gimple_debug (stmt))
1288 gimple_stmt_iterator gsi = bsi;
1290 gsi_remove (&gsi, true);
1295 stmts[gimple_uid (stmt)] = stmt;
1300 /* Set the gimple body to the statement sequence in the entry
1301 basic block. FIXME lto, this is fairly hacky. The existence
1302 of a gimple body is used by the cgraph routines, but we should
1303 really use the presence of the CFG. */
1305 edge_iterator ei = ei_start (ENTRY_BLOCK_PTR->succs);
1306 gimple_set_body (fn_decl, bb_seq (ei_edge (ei)->dest));
1309 fixup_call_stmt_edges (node, stmts);
1310 execute_all_ipa_stmt_fixups (node, stmts);
1312 update_ssa (TODO_update_ssa_only_virtuals);
1313 free_dominance_info (CDI_DOMINATORS);
1314 free_dominance_info (CDI_POST_DOMINATORS);
1319 /* Read initializer expressions for public statics. DATA_IN is the
1320 file being read. IB is the input block used for reading. */
1323 input_alias_pairs (struct lto_input_block *ib, struct data_in *data_in)
1327 clear_line_info (data_in);
1329 /* Skip over all the unreferenced globals. */
1331 var = lto_input_tree (ib, data_in);
1334 var = lto_input_tree (ib, data_in);
1337 const char *orig_name, *new_name;
1340 p = VEC_safe_push (alias_pair, gc, alias_pairs, NULL);
1342 p->target = lto_input_tree (ib, data_in);
1344 /* If the target is a static object, we may have registered a
1345 new name for it to avoid clashes between statics coming from
1346 different files. In that case, use the new name. */
1347 orig_name = IDENTIFIER_POINTER (p->target);
1348 new_name = lto_get_decl_name_mapping (data_in->file_data, orig_name);
1349 if (strcmp (orig_name, new_name) != 0)
1350 p->target = get_identifier (new_name);
1352 var = lto_input_tree (ib, data_in);
1357 /* Read the body from DATA for function FN_DECL and fill it in.
1358 FILE_DATA are the global decls and types. SECTION_TYPE is either
1359 LTO_section_function_body or LTO_section_static_initializer. If
1360 section type is LTO_section_function_body, FN must be the decl for
1364 lto_read_body (struct lto_file_decl_data *file_data, tree fn_decl,
1365 const char *data, enum lto_section_type section_type)
1367 const struct lto_function_header *header;
1368 struct data_in *data_in;
1370 int32_t main_offset;
1371 int32_t string_offset;
1372 struct lto_input_block ib_cfg;
1373 struct lto_input_block ib_main;
1375 header = (const struct lto_function_header *) data;
1376 cfg_offset = sizeof (struct lto_function_header);
1377 main_offset = cfg_offset + header->cfg_size;
1378 string_offset = main_offset + header->main_size;
1380 LTO_INIT_INPUT_BLOCK (ib_cfg,
1385 LTO_INIT_INPUT_BLOCK (ib_main,
1390 data_in = lto_data_in_create (file_data, data + string_offset,
1391 header->string_size, NULL);
1393 /* Make sure the file was generated by the exact same compiler. */
1394 lto_check_version (header->lto_header.major_version,
1395 header->lto_header.minor_version);
1397 if (section_type == LTO_section_function_body)
1399 struct function *fn = DECL_STRUCT_FUNCTION (fn_decl);
1400 struct lto_in_decl_state *decl_state;
1401 struct cgraph_node *node = cgraph_node (fn_decl);
1406 /* Use the function's decl state. */
1407 decl_state = lto_get_function_in_decl_state (file_data, fn_decl);
1408 gcc_assert (decl_state);
1409 file_data->current_decl_state = decl_state;
1411 input_cfg (&ib_cfg, fn, node->count_materialization_scale);
1413 /* Set up the struct function. */
1414 input_function (fn_decl, data_in, &ib_main);
1416 /* We should now be in SSA. */
1417 cfun->gimple_df->in_ssa_p = true;
1419 /* Restore decl state */
1420 file_data->current_decl_state = file_data->global_decl_state;
1426 input_alias_pairs (&ib_main, data_in);
1429 clear_line_info (data_in);
1430 lto_data_in_delete (data_in);
1434 /* Read the body of FN_DECL using DATA. FILE_DATA holds the global
1438 lto_input_function_body (struct lto_file_decl_data *file_data,
1439 tree fn_decl, const char *data)
1441 current_function_decl = fn_decl;
1442 lto_read_body (file_data, fn_decl, data, LTO_section_function_body);
1446 /* Read in VAR_DECL using DATA. FILE_DATA holds the global decls and
1450 lto_input_constructors_and_inits (struct lto_file_decl_data *file_data,
1453 lto_read_body (file_data, NULL, data, LTO_section_static_initializer);
1457 /* Return the resolution for the decl with index INDEX from DATA_IN. */
1459 static enum ld_plugin_symbol_resolution
1460 get_resolution (struct data_in *data_in, unsigned index)
1462 if (data_in->globals_resolution)
1464 ld_plugin_symbol_resolution_t ret;
1465 /* We can have references to not emitted functions in
1466 DECL_FUNCTION_PERSONALITY at least. So we can and have
1467 to indeed return LDPR_UNKNOWN in some cases. */
1468 if (VEC_length (ld_plugin_symbol_resolution_t,
1469 data_in->globals_resolution) <= index)
1470 return LDPR_UNKNOWN;
1471 ret = VEC_index (ld_plugin_symbol_resolution_t,
1472 data_in->globals_resolution,
1477 /* Delay resolution finding until decl merging. */
1478 return LDPR_UNKNOWN;
1482 /* Unpack all the non-pointer fields of the TS_BASE structure of
1483 expression EXPR from bitpack BP. */
1486 unpack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
1488 /* Note that the code for EXPR has already been unpacked to create EXPR in
1489 lto_materialize_tree. */
1492 TREE_SIDE_EFFECTS (expr) = (unsigned) bp_unpack_value (bp, 1);
1493 TREE_CONSTANT (expr) = (unsigned) bp_unpack_value (bp, 1);
1494 TREE_READONLY (expr) = (unsigned) bp_unpack_value (bp, 1);
1496 /* TREE_PUBLIC is used on types to indicate that the type
1497 has a TYPE_CACHED_VALUES vector. This is not streamed out,
1498 so we skip it here. */
1499 TREE_PUBLIC (expr) = (unsigned) bp_unpack_value (bp, 1);
1502 bp_unpack_value (bp, 4);
1503 TREE_ADDRESSABLE (expr) = (unsigned) bp_unpack_value (bp, 1);
1504 TREE_THIS_VOLATILE (expr) = (unsigned) bp_unpack_value (bp, 1);
1506 DECL_UNSIGNED (expr) = (unsigned) bp_unpack_value (bp, 1);
1507 else if (TYPE_P (expr))
1508 TYPE_UNSIGNED (expr) = (unsigned) bp_unpack_value (bp, 1);
1510 bp_unpack_value (bp, 1);
1511 TREE_ASM_WRITTEN (expr) = (unsigned) bp_unpack_value (bp, 1);
1512 TREE_NO_WARNING (expr) = (unsigned) bp_unpack_value (bp, 1);
1513 TREE_USED (expr) = (unsigned) bp_unpack_value (bp, 1);
1514 TREE_NOTHROW (expr) = (unsigned) bp_unpack_value (bp, 1);
1515 TREE_STATIC (expr) = (unsigned) bp_unpack_value (bp, 1);
1516 TREE_PRIVATE (expr) = (unsigned) bp_unpack_value (bp, 1);
1517 TREE_PROTECTED (expr) = (unsigned) bp_unpack_value (bp, 1);
1518 TREE_DEPRECATED (expr) = (unsigned) bp_unpack_value (bp, 1);
1520 TYPE_SATURATING (expr) = (unsigned) bp_unpack_value (bp, 1);
1521 else if (TREE_CODE (expr) == SSA_NAME)
1522 SSA_NAME_IS_DEFAULT_DEF (expr) = (unsigned) bp_unpack_value (bp, 1);
1524 bp_unpack_value (bp, 1);
1528 /* Unpack all the non-pointer fields of the TS_REAL_CST structure of
1529 expression EXPR from bitpack BP. */
1532 unpack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
1536 REAL_VALUE_TYPE *rp;
1538 r.cl = (unsigned) bp_unpack_value (bp, 2);
1539 r.decimal = (unsigned) bp_unpack_value (bp, 1);
1540 r.sign = (unsigned) bp_unpack_value (bp, 1);
1541 r.signalling = (unsigned) bp_unpack_value (bp, 1);
1542 r.canonical = (unsigned) bp_unpack_value (bp, 1);
1543 r.uexp = (unsigned) bp_unpack_value (bp, EXP_BITS);
1544 for (i = 0; i < SIGSZ; i++)
1545 r.sig[i] = (unsigned long) bp_unpack_value (bp, HOST_BITS_PER_LONG);
1547 rp = ggc_alloc_real_value ();
1548 memcpy (rp, &r, sizeof (REAL_VALUE_TYPE));
1549 TREE_REAL_CST_PTR (expr) = rp;
1553 /* Unpack all the non-pointer fields of the TS_FIXED_CST structure of
1554 expression EXPR from bitpack BP. */
1557 unpack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr)
1559 struct fixed_value fv;
1561 fv.data.low = (HOST_WIDE_INT) bp_unpack_value (bp, HOST_BITS_PER_WIDE_INT);
1562 fv.data.high = (HOST_WIDE_INT) bp_unpack_value (bp, HOST_BITS_PER_WIDE_INT);
1563 fv.mode = (enum machine_mode) bp_unpack_value (bp, HOST_BITS_PER_INT);
1564 TREE_FIXED_CST (expr) = fv;
1568 /* Unpack all the non-pointer fields of the TS_DECL_COMMON structure
1569 of expression EXPR from bitpack BP. */
1572 unpack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr)
1574 DECL_MODE (expr) = (enum machine_mode) bp_unpack_value (bp, 8);
1575 DECL_NONLOCAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1576 DECL_VIRTUAL_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1577 DECL_IGNORED_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1578 DECL_ABSTRACT (expr) = (unsigned) bp_unpack_value (bp, 1);
1579 DECL_ARTIFICIAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1580 DECL_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1);
1581 DECL_PRESERVE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1582 DECL_DEBUG_EXPR_IS_FROM (expr) = (unsigned) bp_unpack_value (bp, 1);
1583 DECL_EXTERNAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1584 DECL_GIMPLE_REG_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1585 DECL_ALIGN (expr) = (unsigned) bp_unpack_value (bp, HOST_BITS_PER_INT);
1587 if (TREE_CODE (expr) == LABEL_DECL)
1589 DECL_ERROR_ISSUED (expr) = (unsigned) bp_unpack_value (bp, 1);
1590 EH_LANDING_PAD_NR (expr) = (int) bp_unpack_value (bp, HOST_BITS_PER_INT);
1592 /* Always assume an initial value of -1 for LABEL_DECL_UID to
1593 force gimple_set_bb to recreate label_to_block_map. */
1594 LABEL_DECL_UID (expr) = -1;
1597 if (TREE_CODE (expr) == FIELD_DECL)
1599 unsigned HOST_WIDE_INT off_align;
1600 DECL_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
1601 DECL_NONADDRESSABLE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1602 off_align = (unsigned HOST_WIDE_INT) bp_unpack_value (bp, 8);
1603 SET_DECL_OFFSET_ALIGN (expr, off_align);
1606 if (TREE_CODE (expr) == RESULT_DECL
1607 || TREE_CODE (expr) == PARM_DECL
1608 || TREE_CODE (expr) == VAR_DECL)
1610 DECL_BY_REFERENCE (expr) = (unsigned) bp_unpack_value (bp, 1);
1611 if (TREE_CODE (expr) == VAR_DECL
1612 || TREE_CODE (expr) == PARM_DECL)
1613 DECL_HAS_VALUE_EXPR_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1614 DECL_RESTRICTED_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1619 /* Unpack all the non-pointer fields of the TS_DECL_WRTL structure
1620 of expression EXPR from bitpack BP. */
1623 unpack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
1625 DECL_REGISTER (expr) = (unsigned) bp_unpack_value (bp, 1);
1629 /* Unpack all the non-pointer fields of the TS_DECL_WITH_VIS structure
1630 of expression EXPR from bitpack BP. */
1633 unpack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
1635 DECL_DEFER_OUTPUT (expr) = (unsigned) bp_unpack_value (bp, 1);
1636 DECL_COMMON (expr) = (unsigned) bp_unpack_value (bp, 1);
1637 DECL_DLLIMPORT_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1638 DECL_WEAK (expr) = (unsigned) bp_unpack_value (bp, 1);
1639 DECL_SEEN_IN_BIND_EXPR_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1640 DECL_COMDAT (expr) = (unsigned) bp_unpack_value (bp, 1);
1641 DECL_VISIBILITY (expr) = (enum symbol_visibility) bp_unpack_value (bp, 2);
1642 DECL_VISIBILITY_SPECIFIED (expr) = (unsigned) bp_unpack_value (bp, 1);
1644 if (TREE_CODE (expr) == VAR_DECL)
1646 DECL_HARD_REGISTER (expr) = (unsigned) bp_unpack_value (bp, 1);
1647 DECL_IN_TEXT_SECTION (expr) = (unsigned) bp_unpack_value (bp, 1);
1648 DECL_IN_CONSTANT_POOL (expr) = (unsigned) bp_unpack_value (bp, 1);
1649 DECL_TLS_MODEL (expr) = (enum tls_model) bp_unpack_value (bp, 3);
1652 if (VAR_OR_FUNCTION_DECL_P (expr))
1655 p = (priority_type) bp_unpack_value (bp, HOST_BITS_PER_SHORT);
1656 SET_DECL_INIT_PRIORITY (expr, p);
1661 /* Unpack all the non-pointer fields of the TS_FUNCTION_DECL structure
1662 of expression EXPR from bitpack BP. */
1665 unpack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
1667 DECL_FUNCTION_CODE (expr) = (enum built_in_function) bp_unpack_value (bp, 11);
1668 DECL_BUILT_IN_CLASS (expr) = (enum built_in_class) bp_unpack_value (bp, 2);
1669 DECL_STATIC_CONSTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
1670 DECL_STATIC_DESTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
1671 DECL_UNINLINABLE (expr) = (unsigned) bp_unpack_value (bp, 1);
1672 DECL_POSSIBLY_INLINED (expr) = (unsigned) bp_unpack_value (bp, 1);
1673 DECL_IS_NOVOPS (expr) = (unsigned) bp_unpack_value (bp, 1);
1674 DECL_IS_RETURNS_TWICE (expr) = (unsigned) bp_unpack_value (bp, 1);
1675 DECL_IS_MALLOC (expr) = (unsigned) bp_unpack_value (bp, 1);
1676 DECL_IS_OPERATOR_NEW (expr) = (unsigned) bp_unpack_value (bp, 1);
1677 DECL_DECLARED_INLINE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1678 DECL_STATIC_CHAIN (expr) = (unsigned) bp_unpack_value (bp, 1);
1679 DECL_NO_INLINE_WARNING_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1680 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr)
1681 = (unsigned) bp_unpack_value (bp, 1);
1682 DECL_NO_LIMIT_STACK (expr) = (unsigned) bp_unpack_value (bp, 1);
1683 DECL_DISREGARD_INLINE_LIMITS (expr) = (unsigned) bp_unpack_value (bp, 1);
1684 DECL_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1685 DECL_LOOPING_CONST_OR_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1686 if (DECL_STATIC_DESTRUCTOR (expr))
1688 priority_type p = (priority_type) bp_unpack_value (bp, HOST_BITS_PER_SHORT);
1689 SET_DECL_FINI_PRIORITY (expr, p);
1694 /* Unpack all the non-pointer fields of the TS_TYPE structure
1695 of expression EXPR from bitpack BP. */
1698 unpack_ts_type_value_fields (struct bitpack_d *bp, tree expr)
1700 enum machine_mode mode;
1702 TYPE_PRECISION (expr) = (unsigned) bp_unpack_value (bp, 10);
1703 mode = (enum machine_mode) bp_unpack_value (bp, 8);
1704 SET_TYPE_MODE (expr, mode);
1705 TYPE_STRING_FLAG (expr) = (unsigned) bp_unpack_value (bp, 1);
1706 TYPE_NO_FORCE_BLK (expr) = (unsigned) bp_unpack_value (bp, 1);
1707 TYPE_NEEDS_CONSTRUCTING (expr) = (unsigned) bp_unpack_value (bp, 1);
1708 if (RECORD_OR_UNION_TYPE_P (expr))
1709 TYPE_TRANSPARENT_AGGR (expr) = (unsigned) bp_unpack_value (bp, 1);
1710 TYPE_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
1711 TYPE_RESTRICT (expr) = (unsigned) bp_unpack_value (bp, 1);
1712 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr)
1713 = (unsigned) bp_unpack_value (bp, 2);
1714 TYPE_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1);
1715 TYPE_READONLY (expr) = (unsigned) bp_unpack_value (bp, 1);
1716 TYPE_ALIGN (expr) = (unsigned) bp_unpack_value (bp, HOST_BITS_PER_INT);
1717 TYPE_ALIAS_SET (expr) = bp_unpack_value (bp, HOST_BITS_PER_INT);
1721 /* Unpack all the non-pointer fields of the TS_BLOCK structure
1722 of expression EXPR from bitpack BP. */
1725 unpack_ts_block_value_fields (struct bitpack_d *bp, tree expr)
1727 BLOCK_ABSTRACT (expr) = (unsigned) bp_unpack_value (bp, 1);
1728 BLOCK_NUMBER (expr) = (unsigned) bp_unpack_value (bp, 31);
1731 /* Unpack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL
1732 structure of expression EXPR from bitpack BP. */
1735 unpack_ts_translation_unit_decl_value_fields (struct bitpack_d *bp ATTRIBUTE_UNUSED, tree expr ATTRIBUTE_UNUSED)
1739 /* Unpack all the non-pointer fields in EXPR into a bit pack. */
1742 unpack_value_fields (struct bitpack_d *bp, tree expr)
1744 enum tree_code code;
1746 code = TREE_CODE (expr);
1748 /* Note that all these functions are highly sensitive to changes in
1749 the types and sizes of each of the fields being packed. */
1750 unpack_ts_base_value_fields (bp, expr);
1752 if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
1753 unpack_ts_real_cst_value_fields (bp, expr);
1755 if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
1756 unpack_ts_fixed_cst_value_fields (bp, expr);
1758 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
1759 unpack_ts_decl_common_value_fields (bp, expr);
1761 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
1762 unpack_ts_decl_wrtl_value_fields (bp, expr);
1764 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
1765 unpack_ts_decl_with_vis_value_fields (bp, expr);
1767 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
1768 unpack_ts_function_decl_value_fields (bp, expr);
1770 if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
1771 unpack_ts_type_value_fields (bp, expr);
1773 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
1774 unpack_ts_block_value_fields (bp, expr);
1776 if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
1778 /* We only stream the version number of SSA names. */
1782 if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
1784 /* This is only used by GENERIC. */
1788 if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
1790 /* This is only used by High GIMPLE. */
1794 if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
1795 unpack_ts_translation_unit_decl_value_fields (bp, expr);
1799 /* Materialize a new tree from input block IB using descriptors in
1800 DATA_IN. The code for the new tree should match TAG. Store in
1801 *IX_P the index into the reader cache where the new tree is stored. */
1804 lto_materialize_tree (struct lto_input_block *ib, struct data_in *data_in,
1805 enum LTO_tags tag, int *ix_p)
1807 struct bitpack_d bp;
1808 enum tree_code code;
1810 #ifdef LTO_STREAMER_DEBUG
1811 HOST_WIDEST_INT orig_address_in_writer;
1817 /* Read the header of the node we are about to create. */
1818 ix = lto_input_sleb128 (ib);
1819 gcc_assert ((int) ix == ix);
1822 #ifdef LTO_STREAMER_DEBUG
1823 /* Read the word representing the memory address for the tree
1824 as it was written by the writer. This is useful when
1825 debugging differences between the writer and reader. */
1826 orig_address_in_writer = lto_input_sleb128 (ib);
1827 gcc_assert ((intptr_t) orig_address_in_writer == orig_address_in_writer);
1830 code = lto_tag_to_tree_code (tag);
1832 /* We should never see an SSA_NAME tree. Only the version numbers of
1833 SSA names are ever written out. See input_ssa_names. */
1834 gcc_assert (code != SSA_NAME);
1836 /* Instantiate a new tree using the header data. */
1837 if (CODE_CONTAINS_STRUCT (code, TS_STRING))
1838 result = input_string_cst (data_in, ib);
1839 else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
1840 result = input_identifier (data_in, ib);
1841 else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1843 HOST_WIDE_INT len = lto_input_sleb128 (ib);
1844 result = make_tree_vec (len);
1846 else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1848 unsigned HOST_WIDE_INT len = lto_input_uleb128 (ib);
1849 result = make_tree_binfo (len);
1853 /* All other nodes can be materialized with a raw make_node
1855 result = make_node (code);
1858 #ifdef LTO_STREAMER_DEBUG
1859 /* Store the original address of the tree as seen by the writer
1860 in RESULT's aux field. This is useful when debugging streaming
1861 problems. This way, a debugging session can be started on
1862 both writer and reader with a breakpoint using this address
1864 lto_orig_address_map (result, (intptr_t) orig_address_in_writer);
1867 /* Read the bitpack of non-pointer values from IB. */
1868 bp = lto_input_bitpack (ib);
1870 /* The first word in BP contains the code of the tree that we
1871 are about to read. */
1872 code = (enum tree_code) bp_unpack_value (&bp, 16);
1873 lto_tag_check (lto_tree_code_to_tag (code), tag);
1875 /* Unpack all the value fields from BP. */
1876 unpack_value_fields (&bp, result);
1878 /* Enter RESULT in the reader cache. This will make RESULT
1879 available so that circular references in the rest of the tree
1880 structure can be resolved in subsequent calls to lto_input_tree. */
1881 lto_streamer_cache_insert_at (data_in->reader_cache, result, ix);
1887 /* Read a chain of tree nodes from input block IB. DATA_IN contains
1888 tables and descriptors for the file being read. */
1891 lto_input_chain (struct lto_input_block *ib, struct data_in *data_in)
1894 tree first, prev, curr;
1896 first = prev = NULL_TREE;
1897 count = lto_input_sleb128 (ib);
1898 for (i = 0; i < count; i++)
1900 curr = lto_input_tree (ib, data_in);
1902 TREE_CHAIN (prev) = curr;
1906 TREE_CHAIN (curr) = NULL_TREE;
1914 /* Read all pointer fields in the TS_COMMON structure of EXPR from input
1915 block IB. DATA_IN contains tables and descriptors for the
1920 lto_input_ts_common_tree_pointers (struct lto_input_block *ib,
1921 struct data_in *data_in, tree expr)
1923 if (TREE_CODE (expr) != IDENTIFIER_NODE)
1924 TREE_TYPE (expr) = lto_input_tree (ib, data_in);
1928 /* Read all pointer fields in the TS_VECTOR structure of EXPR from input
1929 block IB. DATA_IN contains tables and descriptors for the
1933 lto_input_ts_vector_tree_pointers (struct lto_input_block *ib,
1934 struct data_in *data_in, tree expr)
1936 TREE_VECTOR_CST_ELTS (expr) = lto_input_chain (ib, data_in);
1940 /* Read all pointer fields in the TS_COMPLEX structure of EXPR from input
1941 block IB. DATA_IN contains tables and descriptors for the
1945 lto_input_ts_complex_tree_pointers (struct lto_input_block *ib,
1946 struct data_in *data_in, tree expr)
1948 TREE_REALPART (expr) = lto_input_tree (ib, data_in);
1949 TREE_IMAGPART (expr) = lto_input_tree (ib, data_in);
1953 /* Read all pointer fields in the TS_DECL_MINIMAL structure of EXPR
1954 from input block IB. DATA_IN contains tables and descriptors for the
1958 lto_input_ts_decl_minimal_tree_pointers (struct lto_input_block *ib,
1959 struct data_in *data_in, tree expr)
1961 DECL_NAME (expr) = lto_input_tree (ib, data_in);
1962 DECL_CONTEXT (expr) = lto_input_tree (ib, data_in);
1963 /* We do not stream BLOCK_VARS but lazily construct it here. */
1964 if (DECL_CONTEXT (expr)
1965 && TREE_CODE (DECL_CONTEXT (expr)) == BLOCK)
1967 TREE_CHAIN (expr) = BLOCK_VARS (DECL_CONTEXT (expr));
1968 BLOCK_VARS (DECL_CONTEXT (expr)) = expr;
1970 DECL_SOURCE_LOCATION (expr) = lto_input_location (ib, data_in);
1974 /* Read all pointer fields in the TS_DECL_COMMON structure of EXPR from
1975 input block IB. DATA_IN contains tables and descriptors for the
1979 lto_input_ts_decl_common_tree_pointers (struct lto_input_block *ib,
1980 struct data_in *data_in, tree expr)
1982 DECL_SIZE (expr) = lto_input_tree (ib, data_in);
1983 DECL_SIZE_UNIT (expr) = lto_input_tree (ib, data_in);
1985 if (TREE_CODE (expr) != FUNCTION_DECL)
1986 DECL_INITIAL (expr) = lto_input_tree (ib, data_in);
1988 DECL_ATTRIBUTES (expr) = lto_input_tree (ib, data_in);
1989 DECL_ABSTRACT_ORIGIN (expr) = lto_input_tree (ib, data_in);
1991 if (TREE_CODE (expr) == PARM_DECL)
1992 TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
1994 if ((TREE_CODE (expr) == VAR_DECL
1995 || TREE_CODE (expr) == PARM_DECL)
1996 && DECL_HAS_VALUE_EXPR_P (expr))
1997 SET_DECL_VALUE_EXPR (expr, lto_input_tree (ib, data_in));
1999 if (TREE_CODE (expr) == VAR_DECL)
2001 tree dexpr = lto_input_tree (ib, data_in);
2003 SET_DECL_DEBUG_EXPR (expr, dexpr);
2008 /* Read all pointer fields in the TS_DECL_NON_COMMON structure of
2009 EXPR from input block IB. DATA_IN contains tables and descriptors for the
2013 lto_input_ts_decl_non_common_tree_pointers (struct lto_input_block *ib,
2014 struct data_in *data_in, tree expr)
2016 if (TREE_CODE (expr) == FUNCTION_DECL)
2018 DECL_ARGUMENTS (expr) = lto_input_tree (ib, data_in);
2019 DECL_RESULT (expr) = lto_input_tree (ib, data_in);
2021 DECL_VINDEX (expr) = lto_input_tree (ib, data_in);
2025 /* Read all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
2026 from input block IB. DATA_IN contains tables and descriptors for the
2030 lto_input_ts_decl_with_vis_tree_pointers (struct lto_input_block *ib,
2031 struct data_in *data_in, tree expr)
2035 id = lto_input_tree (ib, data_in);
2038 gcc_assert (TREE_CODE (id) == IDENTIFIER_NODE);
2039 SET_DECL_ASSEMBLER_NAME (expr, id);
2042 DECL_SECTION_NAME (expr) = lto_input_tree (ib, data_in);
2043 DECL_COMDAT_GROUP (expr) = lto_input_tree (ib, data_in);
2047 /* Read all pointer fields in the TS_FIELD_DECL structure of EXPR from
2048 input block IB. DATA_IN contains tables and descriptors for the
2052 lto_input_ts_field_decl_tree_pointers (struct lto_input_block *ib,
2053 struct data_in *data_in, tree expr)
2055 DECL_FIELD_OFFSET (expr) = lto_input_tree (ib, data_in);
2056 DECL_BIT_FIELD_TYPE (expr) = lto_input_tree (ib, data_in);
2057 DECL_QUALIFIER (expr) = lto_input_tree (ib, data_in);
2058 DECL_FIELD_BIT_OFFSET (expr) = lto_input_tree (ib, data_in);
2059 DECL_FCONTEXT (expr) = lto_input_tree (ib, data_in);
2060 TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
2064 /* Read all pointer fields in the TS_FUNCTION_DECL structure of EXPR
2065 from input block IB. DATA_IN contains tables and descriptors for the
2069 lto_input_ts_function_decl_tree_pointers (struct lto_input_block *ib,
2070 struct data_in *data_in, tree expr)
2072 /* DECL_STRUCT_FUNCTION is handled by lto_input_function. FIXME lto,
2073 maybe it should be handled here? */
2074 DECL_FUNCTION_PERSONALITY (expr) = lto_input_tree (ib, data_in);
2075 DECL_FUNCTION_SPECIFIC_TARGET (expr) = lto_input_tree (ib, data_in);
2076 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr) = lto_input_tree (ib, data_in);
2078 /* If the file contains a function with an EH personality set,
2079 then it was compiled with -fexceptions. In that case, initialize
2080 the backend EH machinery. */
2081 if (DECL_FUNCTION_PERSONALITY (expr))
2086 /* Read all pointer fields in the TS_TYPE structure of EXPR from input
2087 block IB. DATA_IN contains tables and descriptors for the
2091 lto_input_ts_type_tree_pointers (struct lto_input_block *ib,
2092 struct data_in *data_in, tree expr)
2094 if (TREE_CODE (expr) == ENUMERAL_TYPE)
2095 TYPE_VALUES (expr) = lto_input_tree (ib, data_in);
2096 else if (TREE_CODE (expr) == ARRAY_TYPE)
2097 TYPE_DOMAIN (expr) = lto_input_tree (ib, data_in);
2098 else if (RECORD_OR_UNION_TYPE_P (expr))
2099 TYPE_FIELDS (expr) = lto_input_tree (ib, data_in);
2100 else if (TREE_CODE (expr) == FUNCTION_TYPE
2101 || TREE_CODE (expr) == METHOD_TYPE)
2102 TYPE_ARG_TYPES (expr) = lto_input_tree (ib, data_in);
2104 TYPE_SIZE (expr) = lto_input_tree (ib, data_in);
2105 TYPE_SIZE_UNIT (expr) = lto_input_tree (ib, data_in);
2106 TYPE_ATTRIBUTES (expr) = lto_input_tree (ib, data_in);
2107 TYPE_NAME (expr) = lto_input_tree (ib, data_in);
2108 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO nor
2109 TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. */
2110 if (!POINTER_TYPE_P (expr))
2111 TYPE_MINVAL (expr) = lto_input_tree (ib, data_in);
2112 TYPE_MAXVAL (expr) = lto_input_tree (ib, data_in);
2113 TYPE_MAIN_VARIANT (expr) = lto_input_tree (ib, data_in);
2114 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
2116 if (RECORD_OR_UNION_TYPE_P (expr))
2117 TYPE_BINFO (expr) = lto_input_tree (ib, data_in);
2118 TYPE_CONTEXT (expr) = lto_input_tree (ib, data_in);
2119 /* TYPE_CANONICAL gets re-computed during type merging. */
2120 TYPE_CANONICAL (expr) = NULL_TREE;
2121 TYPE_STUB_DECL (expr) = lto_input_tree (ib, data_in);
2125 /* Read all pointer fields in the TS_LIST structure of EXPR from input
2126 block IB. DATA_IN contains tables and descriptors for the
2130 lto_input_ts_list_tree_pointers (struct lto_input_block *ib,
2131 struct data_in *data_in, tree expr)
2133 TREE_PURPOSE (expr) = lto_input_tree (ib, data_in);
2134 TREE_VALUE (expr) = lto_input_tree (ib, data_in);
2135 TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
2139 /* Read all pointer fields in the TS_VEC structure of EXPR from input
2140 block IB. DATA_IN contains tables and descriptors for the
2144 lto_input_ts_vec_tree_pointers (struct lto_input_block *ib,
2145 struct data_in *data_in, tree expr)
2149 /* Note that TREE_VEC_LENGTH was read by lto_materialize_tree to
2150 instantiate EXPR. */
2151 for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
2152 TREE_VEC_ELT (expr, i) = lto_input_tree (ib, data_in);
2156 /* Read all pointer fields in the TS_EXP structure of EXPR from input
2157 block IB. DATA_IN contains tables and descriptors for the
2162 lto_input_ts_exp_tree_pointers (struct lto_input_block *ib,
2163 struct data_in *data_in, tree expr)
2168 length = lto_input_sleb128 (ib);
2169 gcc_assert (length == TREE_OPERAND_LENGTH (expr));
2171 for (i = 0; i < length; i++)
2172 TREE_OPERAND (expr, i) = lto_input_tree (ib, data_in);
2174 loc = lto_input_location (ib, data_in);
2175 SET_EXPR_LOCATION (expr, loc);
2176 TREE_BLOCK (expr) = lto_input_tree (ib, data_in);
2180 /* Read all pointer fields in the TS_BLOCK structure of EXPR from input
2181 block IB. DATA_IN contains tables and descriptors for the
2185 lto_input_ts_block_tree_pointers (struct lto_input_block *ib,
2186 struct data_in *data_in, tree expr)
2190 BLOCK_SOURCE_LOCATION (expr) = lto_input_location (ib, data_in);
2191 /* We do not stream BLOCK_VARS but lazily construct it when reading
2194 len = lto_input_uleb128 (ib);
2197 VEC_reserve_exact (tree, gc, BLOCK_NONLOCALIZED_VARS (expr), len);
2198 for (i = 0; i < len; i++)
2200 tree t = lto_input_tree (ib, data_in);
2201 VEC_quick_push (tree, BLOCK_NONLOCALIZED_VARS (expr), t);
2205 BLOCK_SUPERCONTEXT (expr) = lto_input_tree (ib, data_in);
2206 BLOCK_ABSTRACT_ORIGIN (expr) = lto_input_tree (ib, data_in);
2207 BLOCK_FRAGMENT_ORIGIN (expr) = lto_input_tree (ib, data_in);
2208 BLOCK_FRAGMENT_CHAIN (expr) = lto_input_tree (ib, data_in);
2209 /* We re-compute BLOCK_SUBBLOCKS of our parent here instead
2210 of streaming it. For non-BLOCK BLOCK_SUPERCONTEXTs we still
2211 stream the child relationship explicitly. */
2212 if (BLOCK_SUPERCONTEXT (expr)
2213 && TREE_CODE (BLOCK_SUPERCONTEXT (expr)) == BLOCK)
2215 BLOCK_CHAIN (expr) = BLOCK_SUBBLOCKS (BLOCK_SUPERCONTEXT (expr));
2216 BLOCK_SUBBLOCKS (BLOCK_SUPERCONTEXT (expr)) = expr;
2221 /* Read all pointer fields in the TS_BINFO structure of EXPR from input
2222 block IB. DATA_IN contains tables and descriptors for the
2226 lto_input_ts_binfo_tree_pointers (struct lto_input_block *ib,
2227 struct data_in *data_in, tree expr)
2232 /* Note that the number of slots in EXPR was read in
2233 lto_materialize_tree when instantiating EXPR. However, the
2234 vector is empty so we cannot rely on VEC_length to know how many
2235 elements to read. So, this list is emitted as a 0-terminated
2236 list on the writer side. */
2239 t = lto_input_tree (ib, data_in);
2241 VEC_quick_push (tree, BINFO_BASE_BINFOS (expr), t);
2245 BINFO_OFFSET (expr) = lto_input_tree (ib, data_in);
2246 BINFO_VTABLE (expr) = lto_input_tree (ib, data_in);
2247 BINFO_VIRTUALS (expr) = lto_input_tree (ib, data_in);
2248 BINFO_VPTR_FIELD (expr) = lto_input_tree (ib, data_in);
2250 len = lto_input_uleb128 (ib);
2253 VEC_reserve_exact (tree, gc, BINFO_BASE_ACCESSES (expr), len);
2254 for (i = 0; i < len; i++)
2256 tree a = lto_input_tree (ib, data_in);
2257 VEC_quick_push (tree, BINFO_BASE_ACCESSES (expr), a);
2261 BINFO_INHERITANCE_CHAIN (expr) = lto_input_tree (ib, data_in);
2262 BINFO_SUBVTT_INDEX (expr) = lto_input_tree (ib, data_in);
2263 BINFO_VPTR_INDEX (expr) = lto_input_tree (ib, data_in);
2267 /* Read all pointer fields in the TS_CONSTRUCTOR structure of EXPR from
2268 input block IB. DATA_IN contains tables and descriptors for the
2272 lto_input_ts_constructor_tree_pointers (struct lto_input_block *ib,
2273 struct data_in *data_in, tree expr)
2277 len = lto_input_uleb128 (ib);
2278 for (i = 0; i < len; i++)
2282 index = lto_input_tree (ib, data_in);
2283 value = lto_input_tree (ib, data_in);
2284 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (expr), index, value);
2289 /* Input a TS_TARGET_OPTION tree from IB into EXPR. */
2292 lto_input_ts_target_option (struct lto_input_block *ib, tree expr)
2295 struct bitpack_d bp;
2296 struct cl_target_option *t = TREE_TARGET_OPTION (expr);
2298 bp = lto_input_bitpack (ib);
2299 len = sizeof (struct cl_target_option);
2300 for (i = 0; i < len; i++)
2301 ((unsigned char *)t)[i] = bp_unpack_value (&bp, 8);
2302 if (bp_unpack_value (&bp, 32) != 0x12345678)
2303 fatal_error ("cl_target_option size mismatch in LTO reader and writer");
2306 /* Input a TS_TRANSLATION_UNIT_DECL tree from IB and DATA_IN into EXPR. */
2309 lto_input_ts_translation_unit_decl_tree_pointers (struct lto_input_block *ib,
2310 struct data_in *data_in,
2313 TRANSLATION_UNIT_LANGUAGE (expr) = xstrdup (input_string (data_in, ib));
2314 VEC_safe_push (tree, gc, all_translation_units, expr);
2317 /* Helper for lto_input_tree. Read all pointer fields in EXPR from
2318 input block IB. DATA_IN contains tables and descriptors for the
2322 lto_input_tree_pointers (struct lto_input_block *ib, struct data_in *data_in,
2325 enum tree_code code;
2327 code = TREE_CODE (expr);
2329 if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
2330 lto_input_ts_common_tree_pointers (ib, data_in, expr);
2332 if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
2333 lto_input_ts_vector_tree_pointers (ib, data_in, expr);
2335 if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
2336 lto_input_ts_complex_tree_pointers (ib, data_in, expr);
2338 if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
2339 lto_input_ts_decl_minimal_tree_pointers (ib, data_in, expr);
2341 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
2342 lto_input_ts_decl_common_tree_pointers (ib, data_in, expr);
2344 if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
2345 lto_input_ts_decl_non_common_tree_pointers (ib, data_in, expr);
2347 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
2348 lto_input_ts_decl_with_vis_tree_pointers (ib, data_in, expr);
2350 if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
2351 lto_input_ts_field_decl_tree_pointers (ib, data_in, expr);
2353 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
2354 lto_input_ts_function_decl_tree_pointers (ib, data_in, expr);
2356 if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
2357 lto_input_ts_type_tree_pointers (ib, data_in, expr);
2359 if (CODE_CONTAINS_STRUCT (code, TS_LIST))
2360 lto_input_ts_list_tree_pointers (ib, data_in, expr);
2362 if (CODE_CONTAINS_STRUCT (code, TS_VEC))
2363 lto_input_ts_vec_tree_pointers (ib, data_in, expr);
2365 if (CODE_CONTAINS_STRUCT (code, TS_EXP))
2366 lto_input_ts_exp_tree_pointers (ib, data_in, expr);
2368 if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
2370 /* We only stream the version number of SSA names. */
2374 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
2375 lto_input_ts_block_tree_pointers (ib, data_in, expr);
2377 if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
2378 lto_input_ts_binfo_tree_pointers (ib, data_in, expr);
2380 if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
2382 /* This should only appear in GENERIC. */
2386 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
2387 lto_input_ts_constructor_tree_pointers (ib, data_in, expr);
2389 if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
2391 /* This should only appear in High GIMPLE. */
2395 if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
2397 sorry ("optimization options not supported yet");
2400 if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
2401 lto_input_ts_target_option (ib, expr);
2403 if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
2404 lto_input_ts_translation_unit_decl_tree_pointers (ib, data_in, expr);
2408 /* Register DECL with the global symbol table and change its
2409 name if necessary to avoid name clashes for static globals across
2413 lto_register_var_decl_in_symtab (struct data_in *data_in, tree decl)
2417 /* Variable has file scope, not local. Need to ensure static variables
2418 between different files don't clash unexpectedly. */
2419 if (!TREE_PUBLIC (decl)
2420 && !((context = decl_function_context (decl))
2421 && auto_var_in_fn_p (decl, context)))
2423 /* ??? We normally pre-mangle names before we serialize them
2424 out. Here, in lto1, we do not know the language, and
2425 thus cannot do the mangling again. Instead, we just
2426 append a suffix to the mangled name. The resulting name,
2427 however, is not a properly-formed mangled name, and will
2428 confuse any attempt to unmangle it. */
2429 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2432 ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
2433 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
2434 rest_of_decl_compilation (decl, 1, 0);
2437 /* If this variable has already been declared, queue the
2438 declaration for merging. */
2439 if (TREE_PUBLIC (decl))
2442 if (!lto_streamer_cache_lookup (data_in->reader_cache, decl, &ix))
2444 lto_symtab_register_decl (decl, get_resolution (data_in, ix),
2445 data_in->file_data);
2451 /* Register DECL with the global symbol table and change its
2452 name if necessary to avoid name clashes for static globals across
2453 different files. DATA_IN contains descriptors and tables for the
2457 lto_register_function_decl_in_symtab (struct data_in *data_in, tree decl)
2459 /* Need to ensure static entities between different files
2460 don't clash unexpectedly. */
2461 if (!TREE_PUBLIC (decl))
2463 /* We must not use the DECL_ASSEMBLER_NAME macro here, as it
2464 may set the assembler name where it was previously empty. */
2465 tree old_assembler_name = decl->decl_with_vis.assembler_name;
2467 /* FIXME lto: We normally pre-mangle names before we serialize
2468 them out. Here, in lto1, we do not know the language, and
2469 thus cannot do the mangling again. Instead, we just append a
2470 suffix to the mangled name. The resulting name, however, is
2471 not a properly-formed mangled name, and will confuse any
2472 attempt to unmangle it. */
2473 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2476 ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
2477 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
2479 /* We may arrive here with the old assembler name not set
2480 if the function body is not needed, e.g., it has been
2481 inlined away and does not appear in the cgraph. */
2482 if (old_assembler_name)
2484 tree new_assembler_name = DECL_ASSEMBLER_NAME (decl);
2486 /* Make the original assembler name available for later use.
2487 We may have used it to indicate the section within its
2488 object file where the function body may be found.
2489 FIXME lto: Find a better way to maintain the function decl
2490 to body section mapping so we don't need this hack. */
2491 lto_record_renamed_decl (data_in->file_data,
2492 IDENTIFIER_POINTER (old_assembler_name),
2493 IDENTIFIER_POINTER (new_assembler_name));
2495 /* Also register the reverse mapping so that we can find the
2496 new name given to an existing assembler name (used when
2497 restoring alias pairs in input_constructors_or_inits. */
2498 lto_record_renamed_decl (data_in->file_data,
2499 IDENTIFIER_POINTER (new_assembler_name),
2500 IDENTIFIER_POINTER (old_assembler_name));
2504 /* If this variable has already been declared, queue the
2505 declaration for merging. */
2506 if (TREE_PUBLIC (decl) && !DECL_ABSTRACT (decl))
2509 if (!lto_streamer_cache_lookup (data_in->reader_cache, decl, &ix))
2511 lto_symtab_register_decl (decl, get_resolution (data_in, ix),
2512 data_in->file_data);
2517 /* Read an index IX from input block IB and return the tree node at
2518 DATA_IN->FILE_DATA->GLOBALS_INDEX[IX]. */
2521 lto_get_pickled_tree (struct lto_input_block *ib, struct data_in *data_in)
2525 enum LTO_tags expected_tag;
2526 unsigned HOST_WIDE_INT orig_offset;
2528 ix = lto_input_sleb128 (ib);
2529 expected_tag = (enum LTO_tags) lto_input_uleb128 (ib);
2531 orig_offset = lto_input_uleb128 (ib);
2532 gcc_assert (orig_offset == (unsigned) orig_offset);
2534 result = lto_streamer_cache_get (data_in->reader_cache, ix);
2535 if (result == NULL_TREE)
2537 /* We have not yet read the cache slot IX. Go to the offset
2538 in the stream where the physical tree node is, and materialize
2540 struct lto_input_block fwd_ib;
2542 /* If we are trying to go back in the stream, something is wrong.
2543 We should've read the node at the earlier position already. */
2544 if (ib->p >= orig_offset)
2545 internal_error ("bytecode stream: tried to jump backwards in the "
2548 LTO_INIT_INPUT_BLOCK (fwd_ib, ib->data, orig_offset, ib->len);
2549 result = lto_input_tree (&fwd_ib, data_in);
2553 && TREE_CODE (result) == lto_tag_to_tree_code (expected_tag));
2559 /* Read a code and class from input block IB and return the
2560 corresponding builtin. DATA_IN is as in lto_input_tree. */
2563 lto_get_builtin_tree (struct lto_input_block *ib, struct data_in *data_in)
2565 enum built_in_class fclass;
2566 enum built_in_function fcode;
2567 const char *asmname;
2571 fclass = (enum built_in_class) lto_input_uleb128 (ib);
2572 gcc_assert (fclass == BUILT_IN_NORMAL || fclass == BUILT_IN_MD);
2574 fcode = (enum built_in_function) lto_input_uleb128 (ib);
2576 ix = lto_input_sleb128 (ib);
2577 gcc_assert (ix == (int) ix);
2579 if (fclass == BUILT_IN_NORMAL)
2581 gcc_assert (fcode < END_BUILTINS);
2582 result = built_in_decls[fcode];
2583 gcc_assert (result);
2585 else if (fclass == BUILT_IN_MD)
2587 result = targetm.builtin_decl (fcode, true);
2588 if (!result || result == error_mark_node)
2589 fatal_error ("target specific builtin not available");
2594 asmname = input_string (data_in, ib);
2596 set_builtin_user_assembler_name (result, asmname);
2598 lto_streamer_cache_insert_at (data_in->reader_cache, result, ix);
2604 /* Read the physical representation of a tree node with tag TAG from
2605 input block IB using the per-file context in DATA_IN. */
2608 lto_read_tree (struct lto_input_block *ib, struct data_in *data_in,
2614 result = lto_materialize_tree (ib, data_in, tag, &ix);
2616 /* Read all the pointer fields in RESULT. */
2617 lto_input_tree_pointers (ib, data_in, result);
2619 /* We should never try to instantiate an MD or NORMAL builtin here. */
2620 if (TREE_CODE (result) == FUNCTION_DECL)
2621 gcc_assert (!lto_stream_as_builtin_p (result));
2623 if (TREE_CODE (result) == VAR_DECL)
2624 lto_register_var_decl_in_symtab (data_in, result);
2625 else if (TREE_CODE (result) == FUNCTION_DECL && !DECL_BUILT_IN (result))
2626 lto_register_function_decl_in_symtab (data_in, result);
2628 /* end_marker = */ lto_input_1_unsigned (ib);
2630 #ifdef LTO_STREAMER_DEBUG
2631 /* Remove the mapping to RESULT's original address set by
2632 lto_materialize_tree. */
2633 lto_orig_address_remove (result);
2640 /* Read and INTEGER_CST node from input block IB using the per-file
2641 context in DATA_IN. */
2644 lto_input_integer_cst (struct lto_input_block *ib, struct data_in *data_in)
2647 HOST_WIDE_INT low, high;
2650 type = lto_input_tree (ib, data_in);
2651 overflow_p = (lto_input_1_unsigned (ib) != 0);
2652 low = lto_input_uleb128 (ib);
2653 high = lto_input_uleb128 (ib);
2654 result = build_int_cst_wide (type, low, high);
2656 /* If the original constant had overflown, build a replica of RESULT to
2657 avoid modifying the shared constant returned by build_int_cst_wide. */
2660 result = copy_node (result);
2661 TREE_OVERFLOW (result) = 1;
2668 /* Read a tree from input block IB using the per-file context in
2669 DATA_IN. This context is used, for example, to resolve references
2670 to previously read nodes. */
2673 lto_input_tree (struct lto_input_block *ib, struct data_in *data_in)
2678 tag = input_record_start (ib);
2679 gcc_assert ((unsigned) tag < (unsigned) LTO_NUM_TAGS);
2681 if (tag == LTO_null)
2683 else if (tag >= LTO_field_decl_ref && tag <= LTO_global_decl_ref)
2685 /* If TAG is a reference to an indexable tree, the next value
2686 in IB is the index into the table where we expect to find
2688 result = lto_input_tree_ref (ib, data_in, cfun, tag);
2690 else if (tag == LTO_tree_pickle_reference)
2692 /* If TAG is a reference to a previously read tree, look it up in
2693 the reader cache. */
2694 result = lto_get_pickled_tree (ib, data_in);
2696 else if (tag == LTO_builtin_decl)
2698 /* If we are going to read a built-in function, all we need is
2699 the code and class. */
2700 result = lto_get_builtin_tree (ib, data_in);
2702 else if (tag == lto_tree_code_to_tag (INTEGER_CST))
2704 /* For integer constants we only need the type and its hi/low
2706 result = lto_input_integer_cst (ib, data_in);
2710 /* Otherwise, materialize a new node from IB. */
2711 result = lto_read_tree (ib, data_in, tag);
2718 /* Initialization for the LTO reader. */
2721 lto_init_reader (void)
2723 lto_streamer_init ();
2725 memset (<o_stats, 0, sizeof (lto_stats));
2726 bitmap_obstack_initialize (NULL);
2728 file_name_hash_table = htab_create (37, hash_string_slot_node,
2729 eq_string_slot_node, free);
2731 gimple_register_cfg_hooks ();
2735 /* Create a new data_in object for FILE_DATA. STRINGS is the string
2736 table to use with LEN strings. RESOLUTIONS is the vector of linker
2737 resolutions (NULL if not using a linker plugin). */
2740 lto_data_in_create (struct lto_file_decl_data *file_data, const char *strings,
2742 VEC(ld_plugin_symbol_resolution_t,heap) *resolutions)
2744 struct data_in *data_in = XCNEW (struct data_in);
2745 data_in->file_data = file_data;
2746 data_in->strings = strings;
2747 data_in->strings_len = len;
2748 data_in->globals_resolution = resolutions;
2749 data_in->reader_cache = lto_streamer_cache_create ();
2755 /* Remove DATA_IN. */
2758 lto_data_in_delete (struct data_in *data_in)
2760 VEC_free (ld_plugin_symbol_resolution_t, heap, data_in->globals_resolution);
2761 lto_streamer_cache_delete (data_in->reader_cache);
2762 free (data_in->labels);