1 /* Read the GIMPLE representation from a file stream.
3 Copyright 2009 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"
35 #include "basic-block.h"
36 #include "tree-flow.h"
37 #include "tree-pass.h"
41 #include "diagnostic.h"
48 #include "ipa-utils.h"
49 #include "lto-streamer.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;
279 xloc.file = input_string (data_in, ib);
280 if (xloc.file == NULL)
281 return UNKNOWN_LOCATION;
283 xloc.line = lto_input_sleb128 (ib);
284 xloc.column = lto_input_sleb128 (ib);
286 if (data_in->current_file)
287 linemap_add (line_table, LC_LEAVE, false, NULL, 0);
289 data_in->current_file = canon_file_name (xloc.file);
290 data_in->current_line = xloc.line;
291 data_in->current_col = xloc.column;
293 linemap_add (line_table, LC_ENTER, false, data_in->current_file, xloc.line);
294 LINEMAP_POSITION_FOR_COLUMN (loc, line_table, xloc.column);
300 /* Read a reference to a tree node from DATA_IN using input block IB.
301 TAG is the expected node that should be found in IB, if TAG belongs
302 to one of the indexable trees, expect to read a reference index to
303 be looked up in one of the symbol tables, otherwise read the pysical
304 representation of the tree using lto_input_tree. FN is the
305 function scope for the read tree. */
308 lto_input_tree_ref (struct lto_input_block *ib, struct data_in *data_in,
309 struct function *fn, enum LTO_tags tag)
311 unsigned HOST_WIDE_INT ix_u;
312 tree result = NULL_TREE;
314 lto_tag_check_range (tag, LTO_field_decl_ref, LTO_global_decl_ref);
319 ix_u = lto_input_uleb128 (ib);
320 result = lto_file_decl_data_get_type (data_in->file_data, ix_u);
323 case LTO_ssa_name_ref:
324 ix_u = lto_input_uleb128 (ib);
325 result = VEC_index (tree, SSANAMES (fn), ix_u);
328 case LTO_field_decl_ref:
329 ix_u = lto_input_uleb128 (ib);
330 result = lto_file_decl_data_get_field_decl (data_in->file_data, ix_u);
333 case LTO_function_decl_ref:
334 ix_u = lto_input_uleb128 (ib);
335 result = lto_file_decl_data_get_fn_decl (data_in->file_data, ix_u);
338 case LTO_type_decl_ref:
339 ix_u = lto_input_uleb128 (ib);
340 result = lto_file_decl_data_get_type_decl (data_in->file_data, ix_u);
343 case LTO_namespace_decl_ref:
344 ix_u = lto_input_uleb128 (ib);
345 result = lto_file_decl_data_get_namespace_decl (data_in->file_data, ix_u);
348 case LTO_global_decl_ref:
349 case LTO_result_decl_ref:
350 case LTO_const_decl_ref:
351 case LTO_imported_decl_ref:
352 case LTO_label_decl_ref:
353 ix_u = lto_input_uleb128 (ib);
354 result = lto_file_decl_data_get_var_decl (data_in->file_data, ix_u);
355 if (tag == LTO_global_decl_ref)
356 varpool_mark_needed_node (varpool_node (result));
369 /* Read and return a double-linked list of catch handlers from input
370 block IB, using descriptors in DATA_IN. */
372 static struct eh_catch_d *
373 lto_input_eh_catch_list (struct lto_input_block *ib, struct data_in *data_in,
379 *last_p = first = NULL;
380 tag = input_record_start (ib);
386 lto_tag_check_range (tag, LTO_eh_catch, LTO_eh_catch);
388 /* Read the catch node. */
389 n = GGC_CNEW (struct eh_catch_d);
390 n->type_list = lto_input_tree (ib, data_in);
391 n->filter_list = lto_input_tree (ib, data_in);
392 n->label = lto_input_tree (ib, data_in);
394 /* Register all the types in N->FILTER_LIST. */
395 for (list = n->filter_list; list; list = TREE_CHAIN (list))
396 add_type_for_runtime (TREE_VALUE (list));
398 /* Chain N to the end of the list. */
400 (*last_p)->next_catch = n;
401 n->prev_catch = *last_p;
404 /* Set the head of the list the first time through the loop. */
408 tag = input_record_start (ib);
415 /* Read and return EH region IX from input block IB, using descriptors
419 input_eh_region (struct lto_input_block *ib, struct data_in *data_in, int ix)
424 /* Read the region header. */
425 tag = input_record_start (ib);
429 r = GGC_CNEW (struct eh_region_d);
430 r->index = lto_input_sleb128 (ib);
432 gcc_assert (r->index == ix);
434 /* Read all the region pointers as region numbers. We'll fix up
435 the pointers once the whole array has been read. */
436 r->outer = (eh_region) (intptr_t) lto_input_sleb128 (ib);
437 r->inner = (eh_region) (intptr_t) lto_input_sleb128 (ib);
438 r->next_peer = (eh_region) (intptr_t) lto_input_sleb128 (ib);
442 case LTO_ert_cleanup:
443 r->type = ERT_CLEANUP;
448 struct eh_catch_d *last_catch;
450 r->u.eh_try.first_catch = lto_input_eh_catch_list (ib, data_in,
452 r->u.eh_try.last_catch = last_catch;
456 case LTO_ert_allowed_exceptions:
460 r->type = ERT_ALLOWED_EXCEPTIONS;
461 r->u.allowed.type_list = lto_input_tree (ib, data_in);
462 r->u.allowed.label = lto_input_tree (ib, data_in);
463 r->u.allowed.filter = lto_input_uleb128 (ib);
465 for (l = r->u.allowed.type_list; l ; l = TREE_CHAIN (l))
466 add_type_for_runtime (TREE_VALUE (l));
470 case LTO_ert_must_not_throw:
471 r->type = ERT_MUST_NOT_THROW;
472 r->u.must_not_throw.failure_decl = lto_input_tree (ib, data_in);
473 r->u.must_not_throw.failure_loc = lto_input_location (ib, data_in);
480 r->landing_pads = (eh_landing_pad) (intptr_t) lto_input_sleb128 (ib);
486 /* Read and return EH landing pad IX from input block IB, using descriptors
489 static eh_landing_pad
490 input_eh_lp (struct lto_input_block *ib, struct data_in *data_in, int ix)
495 /* Read the landing pad header. */
496 tag = input_record_start (ib);
500 lto_tag_check_range (tag, LTO_eh_landing_pad, LTO_eh_landing_pad);
502 lp = GGC_CNEW (struct eh_landing_pad_d);
503 lp->index = lto_input_sleb128 (ib);
504 gcc_assert (lp->index == ix);
505 lp->next_lp = (eh_landing_pad) (intptr_t) lto_input_sleb128 (ib);
506 lp->region = (eh_region) (intptr_t) lto_input_sleb128 (ib);
507 lp->post_landing_pad = lto_input_tree (ib, data_in);
513 /* After reading the EH regions, pointers to peer and children regions
514 are region numbers. This converts all these region numbers into
515 real pointers into the rematerialized regions for FN. ROOT_REGION
516 is the region number for the root EH region in FN. */
519 fixup_eh_region_pointers (struct function *fn, HOST_WIDE_INT root_region)
522 VEC(eh_region,gc) *eh_array = fn->eh->region_array;
523 VEC(eh_landing_pad,gc) *lp_array = fn->eh->lp_array;
527 gcc_assert (eh_array && lp_array);
529 gcc_assert (root_region >= 0);
530 fn->eh->region_tree = VEC_index (eh_region, eh_array, root_region);
532 #define FIXUP_EH_REGION(r) (r) = VEC_index (eh_region, eh_array, \
533 (HOST_WIDE_INT) (intptr_t) (r))
534 #define FIXUP_EH_LP(p) (p) = VEC_index (eh_landing_pad, lp_array, \
535 (HOST_WIDE_INT) (intptr_t) (p))
537 /* Convert all the index numbers stored in pointer fields into
538 pointers to the corresponding slots in the EH region array. */
539 for (i = 0; VEC_iterate (eh_region, eh_array, i, r); i++)
541 /* The array may contain NULL regions. */
545 gcc_assert (i == (unsigned) r->index);
546 FIXUP_EH_REGION (r->outer);
547 FIXUP_EH_REGION (r->inner);
548 FIXUP_EH_REGION (r->next_peer);
549 FIXUP_EH_LP (r->landing_pads);
552 /* Convert all the index numbers stored in pointer fields into
553 pointers to the corresponding slots in the EH landing pad array. */
554 for (i = 0; VEC_iterate (eh_landing_pad, lp_array, i, lp); i++)
556 /* The array may contain NULL landing pads. */
560 gcc_assert (i == (unsigned) lp->index);
561 FIXUP_EH_LP (lp->next_lp);
562 FIXUP_EH_REGION (lp->region);
565 #undef FIXUP_EH_REGION
570 /* Initialize EH support. */
575 /* Contrary to most other FEs, we only initialize EH support when at
576 least one of the files in the set contains exception regions in
577 it. Since this happens much later than the call to init_eh in
578 lang_dependent_init, we have to set flag_exceptions and call
579 init_eh again to initialize the EH tables. */
583 /* Initialize dwarf2 tables. Since dwarf2out_do_frame() returns
584 true only when exceptions are enabled, this initialization is
585 never done during lang_dependent_init. */
586 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
587 if (dwarf2out_do_frame ())
588 dwarf2out_frame_init ();
593 /* Read the exception table for FN from IB using the data descriptors
597 input_eh_regions (struct lto_input_block *ib, struct data_in *data_in,
600 HOST_WIDE_INT i, root_region, len;
602 static bool eh_initialized_p = false;
604 tag = input_record_start (ib);
608 lto_tag_check_range (tag, LTO_eh_table, LTO_eh_table);
610 /* If the file contains EH regions, then it was compiled with
611 -fexceptions. In that case, initialize the backend EH
613 if (!eh_initialized_p)
616 eh_initialized_p = true;
621 root_region = lto_input_sleb128 (ib);
622 gcc_assert (root_region == (int) root_region);
624 /* Read the EH region array. */
625 len = lto_input_sleb128 (ib);
626 gcc_assert (len == (int) len);
629 VEC_safe_grow (eh_region, gc, fn->eh->region_array, len);
630 for (i = 0; i < len; i++)
632 eh_region r = input_eh_region (ib, data_in, i);
633 VEC_replace (eh_region, fn->eh->region_array, i, r);
637 /* Read the landing pads. */
638 len = lto_input_sleb128 (ib);
639 gcc_assert (len == (int) len);
642 VEC_safe_grow (eh_landing_pad, gc, fn->eh->lp_array, len);
643 for (i = 0; i < len; i++)
645 eh_landing_pad lp = input_eh_lp (ib, data_in, i);
646 VEC_replace (eh_landing_pad, fn->eh->lp_array, i, lp);
650 /* Read the runtime type data. */
651 len = lto_input_sleb128 (ib);
652 gcc_assert (len == (int) len);
655 VEC_safe_grow (tree, gc, fn->eh->ttype_data, len);
656 for (i = 0; i < len; i++)
658 tree ttype = lto_input_tree (ib, data_in);
659 VEC_replace (tree, fn->eh->ttype_data, i, ttype);
663 /* Read the table of action chains. */
664 len = lto_input_sleb128 (ib);
665 gcc_assert (len == (int) len);
668 if (targetm.arm_eabi_unwinder)
670 VEC_safe_grow (tree, gc, fn->eh->ehspec_data.arm_eabi, len);
671 for (i = 0; i < len; i++)
673 tree t = lto_input_tree (ib, data_in);
674 VEC_replace (tree, fn->eh->ehspec_data.arm_eabi, i, t);
679 VEC_safe_grow (uchar, gc, fn->eh->ehspec_data.other, len);
680 for (i = 0; i < len; i++)
682 uchar c = lto_input_1_unsigned (ib);
683 VEC_replace (uchar, fn->eh->ehspec_data.other, i, c);
688 /* Reconstruct the EH region tree by fixing up the peer/children
690 fixup_eh_region_pointers (fn, root_region);
692 tag = input_record_start (ib);
693 lto_tag_check_range (tag, LTO_null, LTO_null);
697 /* Make a new basic block with index INDEX in function FN. */
700 make_new_block (struct function *fn, unsigned int index)
702 basic_block bb = alloc_block ();
704 SET_BASIC_BLOCK_FOR_FUNCTION (fn, index, bb);
705 bb->il.gimple = GGC_CNEW (struct gimple_bb_info);
706 n_basic_blocks_for_function (fn)++;
708 set_bb_seq (bb, gimple_seq_alloc ());
713 /* Read the CFG for function FN from input block IB. */
716 input_cfg (struct lto_input_block *ib, struct function *fn)
718 unsigned int bb_count;
723 init_empty_tree_cfg_for_function (fn);
724 init_ssa_operands ();
726 profile_status_for_function (fn) =
727 (enum profile_status_d) lto_input_uleb128 (ib);
729 bb_count = lto_input_uleb128 (ib);
731 last_basic_block_for_function (fn) = bb_count;
732 if (bb_count > VEC_length (basic_block, basic_block_info_for_function (fn)))
733 VEC_safe_grow_cleared (basic_block, gc,
734 basic_block_info_for_function (fn), bb_count);
736 if (bb_count > VEC_length (basic_block, label_to_block_map_for_function (fn)))
737 VEC_safe_grow_cleared (basic_block, gc,
738 label_to_block_map_for_function (fn), bb_count);
740 index = lto_input_sleb128 (ib);
743 basic_block bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
744 unsigned int edge_count;
747 bb = make_new_block (fn, index);
749 edge_count = lto_input_uleb128 (ib);
751 /* Connect up the CFG. */
752 for (i = 0; i < edge_count; i++)
754 unsigned int dest_index;
755 unsigned int edge_flags;
761 dest_index = lto_input_uleb128 (ib);
762 probability = (int) lto_input_sleb128 (ib);
763 count = (gcov_type) lto_input_sleb128 (ib);
764 edge_flags = lto_input_uleb128 (ib);
766 dest = BASIC_BLOCK_FOR_FUNCTION (fn, dest_index);
769 dest = make_new_block (fn, dest_index);
771 e = make_edge (bb, dest, edge_flags);
772 e->probability = probability;
776 index = lto_input_sleb128 (ib);
779 p_bb = ENTRY_BLOCK_PTR_FOR_FUNCTION(fn);
780 index = lto_input_sleb128 (ib);
783 basic_block bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
787 index = lto_input_sleb128 (ib);
792 /* Read a PHI function for basic block BB in function FN. DATA_IN is
793 the file being read. IB is the input block to use for reading. */
796 input_phi (struct lto_input_block *ib, basic_block bb, struct data_in *data_in,
799 unsigned HOST_WIDE_INT ix;
804 ix = lto_input_uleb128 (ib);
805 phi_result = VEC_index (tree, SSANAMES (fn), ix);
806 len = EDGE_COUNT (bb->preds);
807 result = create_phi_node (phi_result, bb);
808 SSA_NAME_DEF_STMT (phi_result) = result;
810 /* We have to go through a lookup process here because the preds in the
811 reconstructed graph are generally in a different order than they
812 were in the original program. */
813 for (i = 0; i < len; i++)
815 tree def = lto_input_tree (ib, data_in);
816 int src_index = lto_input_uleb128 (ib);
817 location_t arg_loc = lto_input_location (ib, data_in);
818 basic_block sbb = BASIC_BLOCK_FOR_FUNCTION (fn, src_index);
823 for (j = 0; j < len; j++)
824 if (EDGE_PRED (bb, j)->src == sbb)
826 e = EDGE_PRED (bb, j);
830 add_phi_arg (result, def, e, arg_loc);
837 /* Read the SSA names array for function FN from DATA_IN using input
841 input_ssa_names (struct lto_input_block *ib, struct data_in *data_in,
844 unsigned int i, size;
846 size = lto_input_uleb128 (ib);
847 init_ssanames (fn, size);
849 i = lto_input_uleb128 (ib);
855 /* Skip over the elements that had been freed. */
856 while (VEC_length (tree, SSANAMES (fn)) < i)
857 VEC_quick_push (tree, SSANAMES (fn), NULL_TREE);
859 is_default_def = (lto_input_1_unsigned (ib) != 0);
860 name = lto_input_tree (ib, data_in);
861 ssa_name = make_ssa_name_fn (fn, name, gimple_build_nop ());
864 set_default_def (SSA_NAME_VAR (ssa_name), ssa_name);
866 i = lto_input_uleb128 (ib);
871 /* Read a statement with tag TAG in function FN from block IB using
872 descriptors in DATA_IN. */
875 input_gimple_stmt (struct lto_input_block *ib, struct data_in *data_in,
876 struct function *fn, enum LTO_tags tag)
879 enum gimple_code code;
880 unsigned HOST_WIDE_INT num_ops;
882 struct bitpack_d *bp;
884 code = lto_tag_to_gimple_code (tag);
886 /* Read the tuple header. */
887 bp = lto_input_bitpack (ib);
888 num_ops = bp_unpack_value (bp, sizeof (unsigned) * 8);
889 stmt = gimple_alloc (code, num_ops);
890 stmt->gsbase.no_warning = bp_unpack_value (bp, 1);
891 if (is_gimple_assign (stmt))
892 stmt->gsbase.nontemporal_move = bp_unpack_value (bp, 1);
893 stmt->gsbase.has_volatile_ops = bp_unpack_value (bp, 1);
894 stmt->gsbase.subcode = bp_unpack_value (bp, 16);
897 /* Read location information. */
898 gimple_set_location (stmt, lto_input_location (ib, data_in));
900 /* Read lexical block reference. */
901 gimple_set_block (stmt, lto_input_tree (ib, data_in));
903 /* Read in all the operands. */
907 gimple_resx_set_region (stmt, lto_input_sleb128 (ib));
910 case GIMPLE_EH_MUST_NOT_THROW:
911 gimple_eh_must_not_throw_set_fndecl (stmt, lto_input_tree (ib, data_in));
914 case GIMPLE_EH_DISPATCH:
915 gimple_eh_dispatch_set_region (stmt, lto_input_sleb128 (ib));
920 /* FIXME lto. Move most of this into a new gimple_asm_set_string(). */
922 stmt->gimple_asm.ni = lto_input_uleb128 (ib);
923 stmt->gimple_asm.no = lto_input_uleb128 (ib);
924 stmt->gimple_asm.nc = lto_input_uleb128 (ib);
925 str = input_string_cst (data_in, ib);
926 stmt->gimple_asm.string = TREE_STRING_POINTER (str);
938 for (i = 0; i < num_ops; i++)
940 tree op = lto_input_tree (ib, data_in);
941 gimple_set_op (stmt, i, op);
949 internal_error ("bytecode stream: unknown GIMPLE statement tag %s",
953 /* Update the properties of symbols, SSA names and labels associated
955 if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
957 tree lhs = gimple_get_lhs (stmt);
958 if (lhs && TREE_CODE (lhs) == SSA_NAME)
959 SSA_NAME_DEF_STMT (lhs) = stmt;
961 else if (code == GIMPLE_LABEL)
962 gcc_assert (emit_label_in_global_context_p (gimple_label_label (stmt))
963 || DECL_CONTEXT (gimple_label_label (stmt)) == fn->decl);
964 else if (code == GIMPLE_ASM)
968 for (i = 0; i < gimple_asm_noutputs (stmt); i++)
970 tree op = TREE_VALUE (gimple_asm_output_op (stmt, i));
971 if (TREE_CODE (op) == SSA_NAME)
972 SSA_NAME_DEF_STMT (op) = stmt;
976 /* Mark the statement modified so its operand vectors can be filled in. */
977 gimple_set_modified (stmt, true);
983 /* Read a basic block with tag TAG from DATA_IN using input block IB.
984 FN is the function being processed. */
987 input_bb (struct lto_input_block *ib, enum LTO_tags tag,
988 struct data_in *data_in, struct function *fn)
992 gimple_stmt_iterator bsi;
994 /* This routine assumes that CFUN is set to FN, as it needs to call
995 basic GIMPLE routines that use CFUN. */
996 gcc_assert (cfun == fn);
998 index = lto_input_uleb128 (ib);
999 bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
1001 bb->count = lto_input_sleb128 (ib);
1002 bb->loop_depth = lto_input_sleb128 (ib);
1003 bb->frequency = lto_input_sleb128 (ib);
1004 bb->flags = lto_input_sleb128 (ib);
1006 /* LTO_bb1 has statements. LTO_bb0 does not. */
1010 bsi = gsi_start_bb (bb);
1011 tag = input_record_start (ib);
1014 gimple stmt = input_gimple_stmt (ib, data_in, fn, tag);
1016 /* Drop debug stmts on-the-fly if we do not have VTA enabled.
1017 This allows us to build for example static libs with debugging
1018 enabled and do the final link without. */
1019 if (MAY_HAVE_DEBUG_STMTS
1020 || !is_gimple_debug (stmt))
1022 find_referenced_vars_in (stmt);
1023 gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
1026 /* After the statement, expect a 0 delimiter or the EH region
1027 that the previous statement belongs to. */
1028 tag = input_record_start (ib);
1029 lto_tag_check_set (tag, 2, LTO_eh_region, LTO_null);
1031 if (tag == LTO_eh_region)
1033 HOST_WIDE_INT region = lto_input_sleb128 (ib);
1034 gcc_assert (region == (int) region);
1035 if (MAY_HAVE_DEBUG_STMTS || !is_gimple_debug (stmt))
1036 add_stmt_to_eh_lp (stmt, region);
1039 tag = input_record_start (ib);
1042 tag = input_record_start (ib);
1045 gimple phi = input_phi (ib, bb, data_in, fn);
1046 find_referenced_vars_in (phi);
1047 tag = input_record_start (ib);
1051 /* Go through all NODE edges and fixup call_stmt pointers
1052 so they point to STMTS. */
1055 fixup_call_stmt_edges_1 (struct cgraph_node *node, gimple *stmts)
1057 struct cgraph_edge *cedge;
1058 for (cedge = node->callees; cedge; cedge = cedge->next_callee)
1059 cedge->call_stmt = stmts[cedge->lto_stmt_uid];
1062 /* Fixup call_stmt pointers in NODE and all clones. */
1065 fixup_call_stmt_edges (struct cgraph_node *orig, gimple *stmts)
1067 struct cgraph_node *node;
1069 while (orig->clone_of)
1070 orig = orig->clone_of;
1072 fixup_call_stmt_edges_1 (orig, stmts);
1074 for (node = orig->clones; node != orig;)
1076 fixup_call_stmt_edges_1 (node, stmts);
1078 node = node->clones;
1079 else if (node->next_sibling_clone)
1080 node = node->next_sibling_clone;
1083 while (node != orig && !node->next_sibling_clone)
1084 node = node->clone_of;
1086 node = node->next_sibling_clone;
1091 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1094 input_function (tree fn_decl, struct data_in *data_in,
1095 struct lto_input_block *ib)
1097 struct function *fn;
1101 struct bitpack_d *bp;
1103 fn = DECL_STRUCT_FUNCTION (fn_decl);
1104 tag = input_record_start (ib);
1105 clear_line_info (data_in);
1107 gimple_register_cfg_hooks ();
1108 lto_tag_check (tag, LTO_function);
1110 /* Read all the attributes for FN. */
1111 bp = lto_input_bitpack (ib);
1112 fn->is_thunk = bp_unpack_value (bp, 1);
1113 fn->has_local_explicit_reg_vars = bp_unpack_value (bp, 1);
1114 fn->after_tree_profile = bp_unpack_value (bp, 1);
1115 fn->returns_pcc_struct = bp_unpack_value (bp, 1);
1116 fn->returns_struct = bp_unpack_value (bp, 1);
1117 fn->always_inline_functions_inlined = bp_unpack_value (bp, 1);
1118 fn->after_inlining = bp_unpack_value (bp, 1);
1119 fn->dont_save_pending_sizes_p = bp_unpack_value (bp, 1);
1120 fn->stdarg = bp_unpack_value (bp, 1);
1121 fn->has_nonlocal_label = bp_unpack_value (bp, 1);
1122 fn->calls_alloca = bp_unpack_value (bp, 1);
1123 fn->calls_setjmp = bp_unpack_value (bp, 1);
1124 fn->function_frequency = (enum function_frequency) bp_unpack_value (bp, 2);
1125 fn->va_list_fpr_size = bp_unpack_value (bp, 8);
1126 fn->va_list_gpr_size = bp_unpack_value (bp, 8);
1127 bitpack_delete (bp);
1129 /* Read the static chain and non-local goto save area. */
1130 fn->static_chain_decl = lto_input_tree (ib, data_in);
1131 fn->nonlocal_goto_save_area = lto_input_tree (ib, data_in);
1133 /* Read all the local symbols. */
1134 fn->local_decls = lto_input_tree (ib, data_in);
1136 /* Read all the SSA names. */
1137 input_ssa_names (ib, data_in, fn);
1139 /* Read the exception handling regions in the function. */
1140 input_eh_regions (ib, data_in, fn);
1142 /* Read the tree of lexical scopes for the function. */
1143 DECL_INITIAL (fn_decl) = lto_input_tree (ib, data_in);
1144 gcc_assert (DECL_INITIAL (fn_decl));
1145 DECL_SAVED_TREE (fn_decl) = NULL_TREE;
1147 /* Read all function arguments. */
1148 DECL_ARGUMENTS (fn_decl) = lto_input_tree (ib, data_in);
1150 /* Read all the basic blocks. */
1151 tag = input_record_start (ib);
1154 input_bb (ib, tag, data_in, fn);
1155 tag = input_record_start (ib);
1158 /* Fix up the call statements that are mentioned in the callgraph
1160 renumber_gimple_stmt_uids ();
1161 stmts = (gimple *) xcalloc (gimple_stmt_max_uid (fn), sizeof (gimple));
1164 gimple_stmt_iterator bsi;
1165 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
1167 gimple stmt = gsi_stmt (bsi);
1168 stmts[gimple_uid (stmt)] = stmt;
1172 /* Set the gimple body to the statement sequence in the entry
1173 basic block. FIXME lto, this is fairly hacky. The existence
1174 of a gimple body is used by the cgraph routines, but we should
1175 really use the presence of the CFG. */
1177 edge_iterator ei = ei_start (ENTRY_BLOCK_PTR->succs);
1178 gimple_set_body (fn_decl, bb_seq (ei_edge (ei)->dest));
1181 fixup_call_stmt_edges (cgraph_node (fn_decl), stmts);
1183 update_ssa (TODO_update_ssa_only_virtuals);
1188 /* Read initializer expressions for public statics. DATA_IN is the
1189 file being read. IB is the input block used for reading. */
1192 input_alias_pairs (struct lto_input_block *ib, struct data_in *data_in)
1196 clear_line_info (data_in);
1198 /* Skip over all the unreferenced globals. */
1200 var = lto_input_tree (ib, data_in);
1203 var = lto_input_tree (ib, data_in);
1206 const char *orig_name, *new_name;
1209 p = VEC_safe_push (alias_pair, gc, alias_pairs, NULL);
1211 p->target = lto_input_tree (ib, data_in);
1213 /* If the target is a static object, we may have registered a
1214 new name for it to avoid clashes between statics coming from
1215 different files. In that case, use the new name. */
1216 orig_name = IDENTIFIER_POINTER (p->target);
1217 new_name = lto_get_decl_name_mapping (data_in->file_data, orig_name);
1218 if (strcmp (orig_name, new_name) != 0)
1219 p->target = get_identifier (new_name);
1221 var = lto_input_tree (ib, data_in);
1226 /* Read the body from DATA for function FN_DECL and fill it in.
1227 FILE_DATA are the global decls and types. SECTION_TYPE is either
1228 LTO_section_function_body or LTO_section_static_initializer. If
1229 section type is LTO_section_function_body, FN must be the decl for
1233 lto_read_body (struct lto_file_decl_data *file_data, tree fn_decl,
1234 const char *data, enum lto_section_type section_type)
1236 const struct lto_function_header *header;
1237 struct data_in *data_in;
1239 int32_t main_offset;
1240 int32_t string_offset;
1241 struct lto_input_block ib_cfg;
1242 struct lto_input_block ib_main;
1244 header = (const struct lto_function_header *) data;
1245 cfg_offset = sizeof (struct lto_function_header);
1246 main_offset = cfg_offset + header->cfg_size;
1247 string_offset = main_offset + header->main_size;
1249 LTO_INIT_INPUT_BLOCK (ib_cfg,
1254 LTO_INIT_INPUT_BLOCK (ib_main,
1259 data_in = lto_data_in_create (file_data, data + string_offset,
1260 header->string_size, NULL);
1262 /* Make sure the file was generated by the exact same compiler. */
1263 lto_check_version (header->lto_header.major_version,
1264 header->lto_header.minor_version);
1266 if (section_type == LTO_section_function_body)
1268 struct function *fn = DECL_STRUCT_FUNCTION (fn_decl);
1269 struct lto_in_decl_state *decl_state;
1274 /* Use the function's decl state. */
1275 decl_state = lto_get_function_in_decl_state (file_data, fn_decl);
1276 gcc_assert (decl_state);
1277 file_data->current_decl_state = decl_state;
1279 input_cfg (&ib_cfg, fn);
1281 /* Set up the struct function. */
1282 input_function (fn_decl, data_in, &ib_main);
1284 /* We should now be in SSA. */
1285 cfun->gimple_df->in_ssa_p = true;
1287 /* Fill in properties we know hold for the rebuilt CFG. */
1288 cfun->curr_properties = PROP_ssa
1293 | PROP_referenced_vars;
1295 /* Restore decl state */
1296 file_data->current_decl_state = file_data->global_decl_state;
1302 input_alias_pairs (&ib_main, data_in);
1305 clear_line_info (data_in);
1306 lto_data_in_delete (data_in);
1310 /* Read the body of FN_DECL using DATA. FILE_DATA holds the global
1314 lto_input_function_body (struct lto_file_decl_data *file_data,
1315 tree fn_decl, const char *data)
1317 current_function_decl = fn_decl;
1318 lto_read_body (file_data, fn_decl, data, LTO_section_function_body);
1322 /* Read in VAR_DECL using DATA. FILE_DATA holds the global decls and
1326 lto_input_constructors_and_inits (struct lto_file_decl_data *file_data,
1329 lto_read_body (file_data, NULL, data, LTO_section_static_initializer);
1333 /* Return the resolution for the decl with index INDEX from DATA_IN. */
1335 static enum ld_plugin_symbol_resolution
1336 get_resolution (struct data_in *data_in, unsigned index)
1338 if (data_in->globals_resolution)
1340 ld_plugin_symbol_resolution_t ret;
1341 gcc_assert (index < VEC_length (ld_plugin_symbol_resolution_t,
1342 data_in->globals_resolution));
1343 ret = VEC_index (ld_plugin_symbol_resolution_t,
1344 data_in->globals_resolution,
1346 gcc_assert (ret != LDPR_UNKNOWN);
1351 /* Fake symbol resolution if no resolution file was provided. */
1352 tree t = lto_streamer_cache_get (data_in->reader_cache, index);
1354 gcc_assert (TREE_PUBLIC (t));
1356 /* There should be no DECL_ABSTRACT in the middle end. */
1357 gcc_assert (!DECL_ABSTRACT (t));
1359 /* If T is a weak definition, we select the first one we see to
1360 be the prevailing definition. */
1363 tree prevailing_decl;
1364 if (DECL_EXTERNAL (t))
1365 return LDPR_RESOLVED_IR;
1367 /* If this is the first time we see T, it won't have a
1368 prevailing definition yet. */
1369 prevailing_decl = lto_symtab_prevailing_decl (t);
1370 if (prevailing_decl == t
1371 || prevailing_decl == NULL_TREE
1372 || DECL_EXTERNAL (prevailing_decl))
1373 return LDPR_PREVAILING_DEF;
1375 return LDPR_PREEMPTED_IR;
1379 /* For non-weak definitions, extern declarations are assumed
1380 to be resolved elsewhere (LDPR_RESOLVED_IR), otherwise T
1381 is a prevailing definition. */
1382 if (DECL_EXTERNAL (t))
1383 return LDPR_RESOLVED_IR;
1385 return LDPR_PREVAILING_DEF;
1391 /* Unpack all the non-pointer fields of the TS_BASE structure of
1392 expression EXPR from bitpack BP. */
1395 unpack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
1397 /* Note that the code for EXPR has already been unpacked to create EXPR in
1398 lto_materialize_tree. */
1401 TREE_SIDE_EFFECTS (expr) = (unsigned) bp_unpack_value (bp, 1);
1402 TREE_CONSTANT (expr) = (unsigned) bp_unpack_value (bp, 1);
1403 TREE_READONLY (expr) = (unsigned) bp_unpack_value (bp, 1);
1405 /* TREE_PUBLIC is used on types to indicate that the type
1406 has a TYPE_CACHED_VALUES vector. This is not streamed out,
1407 so we skip it here. */
1408 TREE_PUBLIC (expr) = (unsigned) bp_unpack_value (bp, 1);
1410 TREE_ADDRESSABLE (expr) = (unsigned) bp_unpack_value (bp, 1);
1411 TREE_THIS_VOLATILE (expr) = (unsigned) bp_unpack_value (bp, 1);
1413 DECL_UNSIGNED (expr) = (unsigned) bp_unpack_value (bp, 1);
1414 else if (TYPE_P (expr))
1415 TYPE_UNSIGNED (expr) = (unsigned) bp_unpack_value (bp, 1);
1416 TREE_ASM_WRITTEN (expr) = (unsigned) bp_unpack_value (bp, 1);
1417 TREE_NO_WARNING (expr) = (unsigned) bp_unpack_value (bp, 1);
1418 TREE_USED (expr) = (unsigned) bp_unpack_value (bp, 1);
1419 TREE_NOTHROW (expr) = (unsigned) bp_unpack_value (bp, 1);
1420 TREE_STATIC (expr) = (unsigned) bp_unpack_value (bp, 1);
1421 TREE_PRIVATE (expr) = (unsigned) bp_unpack_value (bp, 1);
1422 TREE_PROTECTED (expr) = (unsigned) bp_unpack_value (bp, 1);
1423 TREE_DEPRECATED (expr) = (unsigned) bp_unpack_value (bp, 1);
1425 TYPE_SATURATING (expr) = (unsigned) bp_unpack_value (bp, 1);
1426 if (TREE_CODE (expr) == SSA_NAME)
1427 SSA_NAME_IS_DEFAULT_DEF (expr) = (unsigned) bp_unpack_value (bp, 1);
1431 /* Unpack all the non-pointer fields of the TS_REAL_CST structure of
1432 expression EXPR from bitpack BP. */
1435 unpack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
1439 REAL_VALUE_TYPE *rp;
1441 r.cl = (unsigned) bp_unpack_value (bp, 2);
1442 r.decimal = (unsigned) bp_unpack_value (bp, 1);
1443 r.sign = (unsigned) bp_unpack_value (bp, 1);
1444 r.signalling = (unsigned) bp_unpack_value (bp, 1);
1445 r.canonical = (unsigned) bp_unpack_value (bp, 1);
1446 r.uexp = (unsigned) bp_unpack_value (bp, EXP_BITS);
1447 for (i = 0; i < SIGSZ; i++)
1448 r.sig[i] = (unsigned long) bp_unpack_value (bp, HOST_BITS_PER_LONG);
1450 rp = GGC_NEW (REAL_VALUE_TYPE);
1451 memcpy (rp, &r, sizeof (REAL_VALUE_TYPE));
1452 TREE_REAL_CST_PTR (expr) = rp;
1456 /* Unpack all the non-pointer fields of the TS_FIXED_CST structure of
1457 expression EXPR from bitpack BP. */
1460 unpack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr)
1462 struct fixed_value fv;
1464 fv.data.low = (HOST_WIDE_INT) bp_unpack_value (bp, HOST_BITS_PER_WIDE_INT);
1465 fv.data.high = (HOST_WIDE_INT) bp_unpack_value (bp, HOST_BITS_PER_WIDE_INT);
1466 TREE_FIXED_CST (expr) = fv;
1470 /* Unpack all the non-pointer fields of the TS_DECL_COMMON structure
1471 of expression EXPR from bitpack BP. */
1474 unpack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr)
1476 DECL_MODE (expr) = (enum machine_mode) bp_unpack_value (bp, 8);
1477 DECL_NONLOCAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1478 DECL_VIRTUAL_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1479 DECL_IGNORED_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1480 DECL_ABSTRACT (expr) = (unsigned) bp_unpack_value (bp, 1);
1481 DECL_ARTIFICIAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1482 DECL_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1);
1483 DECL_PRESERVE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1484 DECL_DEBUG_EXPR_IS_FROM (expr) = (unsigned) bp_unpack_value (bp, 1);
1485 DECL_EXTERNAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1486 DECL_GIMPLE_REG_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1487 DECL_ALIGN (expr) = (unsigned) bp_unpack_value (bp, HOST_BITS_PER_INT);
1489 if (TREE_CODE (expr) == LABEL_DECL)
1491 DECL_ERROR_ISSUED (expr) = (unsigned) bp_unpack_value (bp, 1);
1492 EH_LANDING_PAD_NR (expr) = (int) bp_unpack_value (bp, HOST_BITS_PER_INT);
1494 /* Always assume an initial value of -1 for LABEL_DECL_UID to
1495 force gimple_set_bb to recreate label_to_block_map. */
1496 LABEL_DECL_UID (expr) = -1;
1499 if (TREE_CODE (expr) == FIELD_DECL)
1501 unsigned HOST_WIDE_INT off_align;
1502 DECL_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
1503 DECL_NONADDRESSABLE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1504 off_align = (unsigned HOST_WIDE_INT) bp_unpack_value (bp, 8);
1505 SET_DECL_OFFSET_ALIGN (expr, off_align);
1508 if (TREE_CODE (expr) == RESULT_DECL
1509 || TREE_CODE (expr) == PARM_DECL
1510 || TREE_CODE (expr) == VAR_DECL)
1512 DECL_BY_REFERENCE (expr) = (unsigned) bp_unpack_value (bp, 1);
1513 if (TREE_CODE (expr) == VAR_DECL
1514 || TREE_CODE (expr) == PARM_DECL)
1515 DECL_HAS_VALUE_EXPR_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1520 /* Unpack all the non-pointer fields of the TS_DECL_WRTL structure
1521 of expression EXPR from bitpack BP. */
1524 unpack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
1526 DECL_REGISTER (expr) = (unsigned) bp_unpack_value (bp, 1);
1530 /* Unpack all the non-pointer fields of the TS_DECL_WITH_VIS structure
1531 of expression EXPR from bitpack BP. */
1534 unpack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
1536 DECL_DEFER_OUTPUT (expr) = (unsigned) bp_unpack_value (bp, 1);
1537 DECL_COMMON (expr) = (unsigned) bp_unpack_value (bp, 1);
1538 DECL_DLLIMPORT_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1539 DECL_WEAK (expr) = (unsigned) bp_unpack_value (bp, 1);
1540 DECL_SEEN_IN_BIND_EXPR_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1541 DECL_COMDAT (expr) = (unsigned) bp_unpack_value (bp, 1);
1542 DECL_VISIBILITY (expr) = (enum symbol_visibility) bp_unpack_value (bp, 2);
1543 DECL_VISIBILITY_SPECIFIED (expr) = (unsigned) bp_unpack_value (bp, 1);
1545 if (TREE_CODE (expr) == VAR_DECL)
1547 DECL_HARD_REGISTER (expr) = (unsigned) bp_unpack_value (bp, 1);
1548 DECL_IN_TEXT_SECTION (expr) = (unsigned) bp_unpack_value (bp, 1);
1549 DECL_TLS_MODEL (expr) = (enum tls_model) bp_unpack_value (bp, 3);
1552 if (VAR_OR_FUNCTION_DECL_P (expr))
1555 p = (priority_type) bp_unpack_value (bp, HOST_BITS_PER_SHORT);
1556 SET_DECL_INIT_PRIORITY (expr, p);
1561 /* Unpack all the non-pointer fields of the TS_FUNCTION_DECL structure
1562 of expression EXPR from bitpack BP. */
1565 unpack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
1567 DECL_FUNCTION_CODE (expr) = (enum built_in_function) bp_unpack_value (bp, 11);
1568 DECL_BUILT_IN_CLASS (expr) = (enum built_in_class) bp_unpack_value (bp, 2);
1569 DECL_STATIC_CONSTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
1570 DECL_STATIC_DESTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
1571 DECL_UNINLINABLE (expr) = (unsigned) bp_unpack_value (bp, 1);
1572 DECL_POSSIBLY_INLINED (expr) = (unsigned) bp_unpack_value (bp, 1);
1573 DECL_IS_NOVOPS (expr) = (unsigned) bp_unpack_value (bp, 1);
1574 DECL_IS_RETURNS_TWICE (expr) = (unsigned) bp_unpack_value (bp, 1);
1575 DECL_IS_MALLOC (expr) = (unsigned) bp_unpack_value (bp, 1);
1576 DECL_IS_OPERATOR_NEW (expr) = (unsigned) bp_unpack_value (bp, 1);
1577 DECL_DECLARED_INLINE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1578 DECL_STATIC_CHAIN (expr) = (unsigned) bp_unpack_value (bp, 1);
1579 DECL_NO_INLINE_WARNING_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1580 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr)
1581 = (unsigned) bp_unpack_value (bp, 1);
1582 DECL_NO_LIMIT_STACK (expr) = (unsigned) bp_unpack_value (bp, 1);
1583 DECL_DISREGARD_INLINE_LIMITS (expr) = (unsigned) bp_unpack_value (bp, 1);
1584 DECL_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1585 DECL_LOOPING_CONST_OR_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1589 /* Unpack all the non-pointer fields of the TS_TYPE structure
1590 of expression EXPR from bitpack BP. */
1593 unpack_ts_type_value_fields (struct bitpack_d *bp, tree expr)
1595 enum machine_mode mode;
1597 TYPE_PRECISION (expr) = (unsigned) bp_unpack_value (bp, 9);
1598 mode = (enum machine_mode) bp_unpack_value (bp, 7);
1599 SET_TYPE_MODE (expr, mode);
1600 TYPE_STRING_FLAG (expr) = (unsigned) bp_unpack_value (bp, 1);
1601 TYPE_NO_FORCE_BLK (expr) = (unsigned) bp_unpack_value (bp, 1);
1602 TYPE_NEEDS_CONSTRUCTING(expr) = (unsigned) bp_unpack_value (bp, 1);
1603 if (TREE_CODE (expr) == UNION_TYPE)
1604 TYPE_TRANSPARENT_UNION (expr) = (unsigned) bp_unpack_value (bp, 1);
1605 TYPE_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
1606 TYPE_RESTRICT (expr) = (unsigned) bp_unpack_value (bp, 1);
1607 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr)
1608 = (unsigned) bp_unpack_value (bp, 2);
1609 TYPE_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1);
1610 TYPE_READONLY (expr) = (unsigned) bp_unpack_value (bp, 1);
1611 TYPE_ALIGN (expr) = (unsigned) bp_unpack_value (bp, HOST_BITS_PER_INT);
1612 TYPE_ALIAS_SET (expr) = bp_unpack_value (bp, HOST_BITS_PER_INT);
1616 /* Unpack all the non-pointer fields of the TS_BLOCK structure
1617 of expression EXPR from bitpack BP. */
1620 unpack_ts_block_value_fields (struct bitpack_d *bp, tree expr)
1622 BLOCK_ABSTRACT (expr) = (unsigned) bp_unpack_value (bp, 1);
1623 BLOCK_NUMBER (expr) = (unsigned) bp_unpack_value (bp, 31);
1627 /* Unpack all the non-pointer fields in EXPR into a bit pack. */
1630 unpack_value_fields (struct bitpack_d *bp, tree expr)
1632 enum tree_code code;
1634 code = TREE_CODE (expr);
1636 /* Note that all these functions are highly sensitive to changes in
1637 the types and sizes of each of the fields being packed. */
1638 unpack_ts_base_value_fields (bp, expr);
1640 if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
1641 unpack_ts_real_cst_value_fields (bp, expr);
1643 if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
1644 unpack_ts_fixed_cst_value_fields (bp, expr);
1646 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
1647 unpack_ts_decl_common_value_fields (bp, expr);
1649 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
1650 unpack_ts_decl_wrtl_value_fields (bp, expr);
1652 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
1653 unpack_ts_decl_with_vis_value_fields (bp, expr);
1655 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
1656 unpack_ts_function_decl_value_fields (bp, expr);
1658 if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
1659 unpack_ts_type_value_fields (bp, expr);
1661 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
1662 unpack_ts_block_value_fields (bp, expr);
1664 if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
1666 /* We only stream the version number of SSA names. */
1670 if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
1672 /* This is only used by GENERIC. */
1676 if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
1678 /* This is only used by High GIMPLE. */
1684 /* Read a bitpack from input block IB. */
1687 lto_input_bitpack (struct lto_input_block *ib)
1689 unsigned i, num_words;
1690 struct bitpack_d *bp;
1692 bp = bitpack_create ();
1694 /* If we are about to read more than a handful of words, something
1695 is wrong. This check is overly strict, but it acts as an early
1696 warning. No streamed object has hundreds of bits in its fields. */
1697 num_words = lto_input_uleb128 (ib);
1698 gcc_assert (num_words < 20);
1700 for (i = 0; i < num_words; i++)
1702 bitpack_word_t w = lto_input_uleb128 (ib);
1703 VEC_safe_push (bitpack_word_t, heap, bp->values, w);
1710 /* Materialize a new tree from input block IB using descriptors in
1711 DATA_IN. The code for the new tree should match TAG. Store in
1712 *IX_P the index into the reader cache where the new tree is stored. */
1715 lto_materialize_tree (struct lto_input_block *ib, struct data_in *data_in,
1716 enum LTO_tags tag, int *ix_p)
1718 struct bitpack_d *bp;
1719 enum tree_code code;
1721 #ifdef LTO_STREAMER_DEBUG
1722 HOST_WIDEST_INT orig_address_in_writer;
1728 /* Read the header of the node we are about to create. */
1729 ix = lto_input_sleb128 (ib);
1730 gcc_assert ((int) ix == ix);
1733 #ifdef LTO_STREAMER_DEBUG
1734 /* Read the word representing the memory address for the tree
1735 as it was written by the writer. This is useful when
1736 debugging differences between the writer and reader. */
1737 orig_address_in_writer = lto_input_sleb128 (ib);
1738 gcc_assert ((intptr_t) orig_address_in_writer == orig_address_in_writer);
1741 code = lto_tag_to_tree_code (tag);
1743 /* We should never see an SSA_NAME tree. Only the version numbers of
1744 SSA names are ever written out. See input_ssa_names. */
1745 gcc_assert (code != SSA_NAME);
1747 /* Instantiate a new tree using the header data. */
1748 if (CODE_CONTAINS_STRUCT (code, TS_STRING))
1749 result = input_string_cst (data_in, ib);
1750 else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
1751 result = input_identifier (data_in, ib);
1752 else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1754 HOST_WIDE_INT len = lto_input_sleb128 (ib);
1755 result = make_tree_vec (len);
1757 else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1759 unsigned HOST_WIDE_INT len = lto_input_uleb128 (ib);
1760 result = make_tree_binfo (len);
1764 /* All other nodes can be materialized with a raw make_node
1766 result = make_node (code);
1769 #ifdef LTO_STREAMER_DEBUG
1770 /* Store the original address of the tree as seen by the writer
1771 in RESULT's aux field. This is useful when debugging streaming
1772 problems. This way, a debugging session can be started on
1773 both writer and reader with a breakpoint using this address
1775 lto_orig_address_map (result, (intptr_t) orig_address_in_writer);
1778 /* Read the bitpack of non-pointer values from IB. */
1779 bp = lto_input_bitpack (ib);
1781 /* The first word in BP contains the code of the tree that we
1782 are about to read. */
1783 code = (enum tree_code) bp_unpack_value (bp, 16);
1784 lto_tag_check (lto_tree_code_to_tag (code), tag);
1786 /* Unpack all the value fields from BP. */
1787 unpack_value_fields (bp, result);
1788 bitpack_delete (bp);
1790 /* Enter RESULT in the reader cache. This will make RESULT
1791 available so that circular references in the rest of the tree
1792 structure can be resolved in subsequent calls to lto_input_tree. */
1793 lto_streamer_cache_insert_at (data_in->reader_cache, result, ix);
1799 /* Read a chain of tree nodes from input block IB. DATA_IN contains
1800 tables and descriptors for the file being read. */
1803 lto_input_chain (struct lto_input_block *ib, struct data_in *data_in)
1806 tree first, prev, curr;
1808 first = prev = NULL_TREE;
1809 count = lto_input_sleb128 (ib);
1810 for (i = 0; i < count; i++)
1812 curr = lto_input_tree (ib, data_in);
1814 TREE_CHAIN (prev) = curr;
1818 TREE_CHAIN (curr) = NULL_TREE;
1826 /* Read all pointer fields in the TS_COMMON structure of EXPR from input
1827 block IB. DATA_IN contains tables and descriptors for the
1832 lto_input_ts_common_tree_pointers (struct lto_input_block *ib,
1833 struct data_in *data_in, tree expr)
1835 TREE_TYPE (expr) = lto_input_tree (ib, data_in);
1839 /* Read all pointer fields in the TS_VECTOR structure of EXPR from input
1840 block IB. DATA_IN contains tables and descriptors for the
1844 lto_input_ts_vector_tree_pointers (struct lto_input_block *ib,
1845 struct data_in *data_in, tree expr)
1847 TREE_VECTOR_CST_ELTS (expr) = lto_input_chain (ib, data_in);
1851 /* Read all pointer fields in the TS_COMPLEX structure of EXPR from input
1852 block IB. DATA_IN contains tables and descriptors for the
1856 lto_input_ts_complex_tree_pointers (struct lto_input_block *ib,
1857 struct data_in *data_in, tree expr)
1859 TREE_REALPART (expr) = lto_input_tree (ib, data_in);
1860 TREE_IMAGPART (expr) = lto_input_tree (ib, data_in);
1864 /* Read all pointer fields in the TS_DECL_MINIMAL structure of EXPR
1865 from input block IB. DATA_IN contains tables and descriptors for the
1869 lto_input_ts_decl_minimal_tree_pointers (struct lto_input_block *ib,
1870 struct data_in *data_in, tree expr)
1872 DECL_NAME (expr) = lto_input_tree (ib, data_in);
1873 DECL_CONTEXT (expr) = lto_input_tree (ib, data_in);
1874 DECL_SOURCE_LOCATION (expr) = lto_input_location (ib, data_in);
1878 /* Read all pointer fields in the TS_DECL_COMMON structure of EXPR from
1879 input block IB. DATA_IN contains tables and descriptors for the
1883 lto_input_ts_decl_common_tree_pointers (struct lto_input_block *ib,
1884 struct data_in *data_in, tree expr)
1886 DECL_SIZE (expr) = lto_input_tree (ib, data_in);
1887 DECL_SIZE_UNIT (expr) = lto_input_tree (ib, data_in);
1889 if (TREE_CODE (expr) != FUNCTION_DECL)
1890 DECL_INITIAL (expr) = lto_input_tree (ib, data_in);
1892 DECL_ATTRIBUTES (expr) = lto_input_tree (ib, data_in);
1893 DECL_ABSTRACT_ORIGIN (expr) = lto_input_tree (ib, data_in);
1895 if (TREE_CODE (expr) == PARM_DECL)
1896 TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
1900 /* Read all pointer fields in the TS_DECL_NON_COMMON structure of
1901 EXPR from input block IB. DATA_IN contains tables and descriptors for the
1905 lto_input_ts_decl_non_common_tree_pointers (struct lto_input_block *ib,
1906 struct data_in *data_in, tree expr)
1908 if (TREE_CODE (expr) == FUNCTION_DECL)
1910 DECL_ARGUMENTS (expr) = lto_input_tree (ib, data_in);
1911 DECL_RESULT (expr) = lto_input_tree (ib, data_in);
1913 DECL_VINDEX (expr) = lto_input_tree (ib, data_in);
1917 /* Read all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
1918 from input block IB. DATA_IN contains tables and descriptors for the
1922 lto_input_ts_decl_with_vis_tree_pointers (struct lto_input_block *ib,
1923 struct data_in *data_in, tree expr)
1927 id = lto_input_tree (ib, data_in);
1930 gcc_assert (TREE_CODE (id) == IDENTIFIER_NODE);
1931 SET_DECL_ASSEMBLER_NAME (expr, id);
1934 DECL_SECTION_NAME (expr) = lto_input_tree (ib, data_in);
1935 DECL_COMDAT_GROUP (expr) = lto_input_tree (ib, data_in);
1939 /* Read all pointer fields in the TS_FIELD_DECL structure of EXPR from
1940 input block IB. DATA_IN contains tables and descriptors for the
1944 lto_input_ts_field_decl_tree_pointers (struct lto_input_block *ib,
1945 struct data_in *data_in, tree expr)
1947 DECL_FIELD_OFFSET (expr) = lto_input_tree (ib, data_in);
1948 DECL_BIT_FIELD_TYPE (expr) = lto_input_tree (ib, data_in);
1949 DECL_QUALIFIER (expr) = lto_input_tree (ib, data_in);
1950 DECL_FIELD_BIT_OFFSET (expr) = lto_input_tree (ib, data_in);
1951 DECL_FCONTEXT (expr) = lto_input_tree (ib, data_in);
1952 TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
1956 /* Read all pointer fields in the TS_FUNCTION_DECL structure of EXPR
1957 from input block IB. DATA_IN contains tables and descriptors for the
1961 lto_input_ts_function_decl_tree_pointers (struct lto_input_block *ib,
1962 struct data_in *data_in, tree expr)
1964 /* DECL_STRUCT_FUNCTION is handled by lto_input_function. FIXME lto,
1965 maybe it should be handled here? */
1966 DECL_FUNCTION_PERSONALITY (expr) = lto_input_tree (ib, data_in);
1967 DECL_FUNCTION_SPECIFIC_TARGET (expr) = lto_input_tree (ib, data_in);
1968 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr) = lto_input_tree (ib, data_in);
1972 /* Read all pointer fields in the TS_TYPE structure of EXPR from input
1973 block IB. DATA_IN contains tables and descriptors for the
1977 lto_input_ts_type_tree_pointers (struct lto_input_block *ib,
1978 struct data_in *data_in, tree expr)
1980 if (TREE_CODE (expr) == ENUMERAL_TYPE)
1981 TYPE_VALUES (expr) = lto_input_tree (ib, data_in);
1982 else if (TREE_CODE (expr) == ARRAY_TYPE)
1983 TYPE_DOMAIN (expr) = lto_input_tree (ib, data_in);
1984 else if (TREE_CODE (expr) == RECORD_TYPE || TREE_CODE (expr) == UNION_TYPE)
1985 TYPE_FIELDS (expr) = lto_input_tree (ib, data_in);
1986 else if (TREE_CODE (expr) == FUNCTION_TYPE || TREE_CODE (expr) == METHOD_TYPE)
1987 TYPE_ARG_TYPES (expr) = lto_input_tree (ib, data_in);
1988 else if (TREE_CODE (expr) == VECTOR_TYPE)
1989 TYPE_DEBUG_REPRESENTATION_TYPE (expr) = lto_input_tree (ib, data_in);
1991 TYPE_SIZE (expr) = lto_input_tree (ib, data_in);
1992 TYPE_SIZE_UNIT (expr) = lto_input_tree (ib, data_in);
1993 TYPE_ATTRIBUTES (expr) = lto_input_tree (ib, data_in);
1994 TYPE_NAME (expr) = lto_input_tree (ib, data_in);
1995 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO nor
1996 TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. */
1997 if (!POINTER_TYPE_P (expr))
1998 TYPE_MINVAL (expr) = lto_input_tree (ib, data_in);
1999 TYPE_MAXVAL (expr) = lto_input_tree (ib, data_in);
2000 TYPE_MAIN_VARIANT (expr) = lto_input_tree (ib, data_in);
2001 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
2003 if (RECORD_OR_UNION_TYPE_P (expr))
2004 TYPE_BINFO (expr) = lto_input_tree (ib, data_in);
2005 TYPE_CONTEXT (expr) = lto_input_tree (ib, data_in);
2006 TYPE_CANONICAL (expr) = lto_input_tree (ib, data_in);
2010 /* Read all pointer fields in the TS_LIST structure of EXPR from input
2011 block IB. DATA_IN contains tables and descriptors for the
2015 lto_input_ts_list_tree_pointers (struct lto_input_block *ib,
2016 struct data_in *data_in, tree expr)
2018 TREE_PURPOSE (expr) = lto_input_tree (ib, data_in);
2019 TREE_VALUE (expr) = lto_input_tree (ib, data_in);
2020 TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
2024 /* Read all pointer fields in the TS_VEC structure of EXPR from input
2025 block IB. DATA_IN contains tables and descriptors for the
2029 lto_input_ts_vec_tree_pointers (struct lto_input_block *ib,
2030 struct data_in *data_in, tree expr)
2034 /* Note that TREE_VEC_LENGTH was read by lto_materialize_tree to
2035 instantiate EXPR. */
2036 for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
2037 TREE_VEC_ELT (expr, i) = lto_input_tree (ib, data_in);
2041 /* Read all pointer fields in the TS_EXP structure of EXPR from input
2042 block IB. DATA_IN contains tables and descriptors for the
2047 lto_input_ts_exp_tree_pointers (struct lto_input_block *ib,
2048 struct data_in *data_in, tree expr)
2053 length = lto_input_sleb128 (ib);
2054 gcc_assert (length == TREE_OPERAND_LENGTH (expr));
2056 for (i = 0; i < length; i++)
2057 TREE_OPERAND (expr, i) = lto_input_tree (ib, data_in);
2059 loc = lto_input_location (ib, data_in);
2060 SET_EXPR_LOCATION (expr, loc);
2061 TREE_BLOCK (expr) = lto_input_tree (ib, data_in);
2065 /* Read all pointer fields in the TS_BLOCK structure of EXPR from input
2066 block IB. DATA_IN contains tables and descriptors for the
2070 lto_input_ts_block_tree_pointers (struct lto_input_block *ib,
2071 struct data_in *data_in, tree expr)
2075 BLOCK_SOURCE_LOCATION (expr) = lto_input_location (ib, data_in);
2076 BLOCK_VARS (expr) = lto_input_chain (ib, data_in);
2078 len = lto_input_uleb128 (ib);
2079 for (i = 0; i < len; i++)
2081 tree t = lto_input_tree (ib, data_in);
2082 VEC_safe_push (tree, gc, BLOCK_NONLOCALIZED_VARS (expr), t);
2085 BLOCK_SUPERCONTEXT (expr) = lto_input_tree (ib, data_in);
2086 BLOCK_ABSTRACT_ORIGIN (expr) = lto_input_tree (ib, data_in);
2087 BLOCK_FRAGMENT_ORIGIN (expr) = lto_input_tree (ib, data_in);
2088 BLOCK_FRAGMENT_CHAIN (expr) = lto_input_tree (ib, data_in);
2089 BLOCK_SUBBLOCKS (expr) = lto_input_chain (ib, data_in);
2093 /* Read all pointer fields in the TS_BINFO structure of EXPR from input
2094 block IB. DATA_IN contains tables and descriptors for the
2098 lto_input_ts_binfo_tree_pointers (struct lto_input_block *ib,
2099 struct data_in *data_in, tree expr)
2104 /* Note that the number of slots in EXPR was read in
2105 lto_materialize_tree when instantiating EXPR. However, the
2106 vector is empty so we cannot rely on VEC_length to know how many
2107 elements to read. So, this list is emitted as a 0-terminated
2108 list on the writer side. */
2111 t = lto_input_tree (ib, data_in);
2113 VEC_quick_push (tree, BINFO_BASE_BINFOS (expr), t);
2117 BINFO_OFFSET (expr) = lto_input_tree (ib, data_in);
2118 BINFO_VTABLE (expr) = lto_input_tree (ib, data_in);
2119 BINFO_VIRTUALS (expr) = lto_input_tree (ib, data_in);
2120 BINFO_VPTR_FIELD (expr) = lto_input_tree (ib, data_in);
2122 len = lto_input_uleb128 (ib);
2123 for (i = 0; i < len; i++)
2125 tree a = lto_input_tree (ib, data_in);
2126 VEC_safe_push (tree, gc, BINFO_BASE_ACCESSES (expr), a);
2129 BINFO_INHERITANCE_CHAIN (expr) = lto_input_tree (ib, data_in);
2130 BINFO_SUBVTT_INDEX (expr) = lto_input_tree (ib, data_in);
2131 BINFO_VPTR_INDEX (expr) = lto_input_tree (ib, data_in);
2135 /* Read all pointer fields in the TS_CONSTRUCTOR structure of EXPR from
2136 input block IB. DATA_IN contains tables and descriptors for the
2140 lto_input_ts_constructor_tree_pointers (struct lto_input_block *ib,
2141 struct data_in *data_in, tree expr)
2145 len = lto_input_uleb128 (ib);
2146 for (i = 0; i < len; i++)
2150 index = lto_input_tree (ib, data_in);
2151 value = lto_input_tree (ib, data_in);
2152 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (expr), index, value);
2157 /* Helper for lto_input_tree. Read all pointer fields in EXPR from
2158 input block IB. DATA_IN contains tables and descriptors for the
2162 lto_input_tree_pointers (struct lto_input_block *ib, struct data_in *data_in,
2165 enum tree_code code;
2167 code = TREE_CODE (expr);
2169 if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
2170 lto_input_ts_common_tree_pointers (ib, data_in, expr);
2172 if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
2173 lto_input_ts_vector_tree_pointers (ib, data_in, expr);
2175 if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
2176 lto_input_ts_complex_tree_pointers (ib, data_in, expr);
2178 if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
2179 lto_input_ts_decl_minimal_tree_pointers (ib, data_in, expr);
2181 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
2182 lto_input_ts_decl_common_tree_pointers (ib, data_in, expr);
2184 if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
2185 lto_input_ts_decl_non_common_tree_pointers (ib, data_in, expr);
2187 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
2188 lto_input_ts_decl_with_vis_tree_pointers (ib, data_in, expr);
2190 if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
2191 lto_input_ts_field_decl_tree_pointers (ib, data_in, expr);
2193 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
2194 lto_input_ts_function_decl_tree_pointers (ib, data_in, expr);
2196 if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
2197 lto_input_ts_type_tree_pointers (ib, data_in, expr);
2199 if (CODE_CONTAINS_STRUCT (code, TS_LIST))
2200 lto_input_ts_list_tree_pointers (ib, data_in, expr);
2202 if (CODE_CONTAINS_STRUCT (code, TS_VEC))
2203 lto_input_ts_vec_tree_pointers (ib, data_in, expr);
2205 if (CODE_CONTAINS_STRUCT (code, TS_EXP))
2206 lto_input_ts_exp_tree_pointers (ib, data_in, expr);
2208 if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
2210 /* We only stream the version number of SSA names. */
2214 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
2215 lto_input_ts_block_tree_pointers (ib, data_in, expr);
2217 if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
2218 lto_input_ts_binfo_tree_pointers (ib, data_in, expr);
2220 if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
2222 /* This should only appear in GENERIC. */
2226 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
2227 lto_input_ts_constructor_tree_pointers (ib, data_in, expr);
2229 if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
2231 /* This should only appear in High GIMPLE. */
2235 if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
2237 sorry ("optimization options not supported yet");
2240 if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
2242 sorry ("target optimization options not supported yet");
2246 static VEC(tree, heap) *deferred_global_decls;
2248 /* Register the queued global decls with the symtab. DATA_IN contains
2249 tables and descriptors for the file being read.*/
2252 lto_register_deferred_decls_in_symtab (struct data_in *data_in)
2257 for (i = 0; VEC_iterate (tree, deferred_global_decls, i, decl); ++i)
2259 enum ld_plugin_symbol_resolution resolution;
2262 if (!lto_streamer_cache_lookup (data_in->reader_cache, decl, &ix))
2265 /* Register and adjust the decls type. */
2266 TREE_TYPE (decl) = gimple_register_type (TREE_TYPE (decl));
2268 if (TREE_CODE (decl) == VAR_DECL)
2270 gcc_assert (TREE_PUBLIC (decl));
2271 resolution = get_resolution (data_in, ix);
2272 lto_symtab_merge_var (decl, resolution);
2274 else if (TREE_CODE (decl) == FUNCTION_DECL)
2276 gcc_assert (TREE_PUBLIC (decl) && !DECL_ABSTRACT (decl));
2277 resolution = get_resolution (data_in, ix);
2278 lto_symtab_merge_fn (decl, resolution, data_in->file_data);
2284 VEC_free (tree, heap, deferred_global_decls);
2285 deferred_global_decls = NULL;
2289 /* Register DECL with the global symbol table and change its
2290 name if necessary to avoid name clashes for static globals across
2294 lto_register_var_decl_in_symtab (tree decl)
2296 /* Register symbols with file or global scope to mark what input
2297 file has their definition. */
2298 if (decl_function_context (decl) == NULL_TREE)
2300 /* Variable has file scope, not local. Need to ensure static variables
2301 between different files don't clash unexpectedly. */
2302 if (!TREE_PUBLIC (decl))
2304 /* ??? We normally pre-mangle names before we serialize them
2305 out. Here, in lto1, we do not know the language, and
2306 thus cannot do the mangling again. Instead, we just
2307 append a suffix to the mangled name. The resulting name,
2308 however, is not a properly-formed mangled name, and will
2309 confuse any attempt to unmangle it. */
2310 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2313 ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
2314 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
2315 rest_of_decl_compilation (decl, 1, 0);
2319 /* If this variable has already been declared, queue the
2320 declaration for merging. */
2321 if (TREE_PUBLIC (decl))
2322 VEC_safe_push (tree, heap, deferred_global_decls, decl);
2327 /* Register DECL with the global symbol table and change its
2328 name if necessary to avoid name clashes for static globals across
2329 different files. DATA_IN contains descriptors and tables for the
2333 lto_register_function_decl_in_symtab (struct data_in *data_in, tree decl)
2335 /* Need to ensure static entities between different files
2336 don't clash unexpectedly. */
2337 if (!TREE_PUBLIC (decl))
2339 /* We must not use the DECL_ASSEMBLER_NAME macro here, as it
2340 may set the assembler name where it was previously empty. */
2341 tree old_assembler_name = decl->decl_with_vis.assembler_name;
2343 /* FIXME lto: We normally pre-mangle names before we serialize
2344 them out. Here, in lto1, we do not know the language, and
2345 thus cannot do the mangling again. Instead, we just append a
2346 suffix to the mangled name. The resulting name, however, is
2347 not a properly-formed mangled name, and will confuse any
2348 attempt to unmangle it. */
2349 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2352 ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
2353 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
2355 /* We may arrive here with the old assembler name not set
2356 if the function body is not needed, e.g., it has been
2357 inlined away and does not appear in the cgraph. */
2358 if (old_assembler_name)
2360 tree new_assembler_name = DECL_ASSEMBLER_NAME (decl);
2362 /* Make the original assembler name available for later use.
2363 We may have used it to indicate the section within its
2364 object file where the function body may be found.
2365 FIXME lto: Find a better way to maintain the function decl
2366 to body section mapping so we don't need this hack. */
2367 lto_record_renamed_decl (data_in->file_data,
2368 IDENTIFIER_POINTER (old_assembler_name),
2369 IDENTIFIER_POINTER (new_assembler_name));
2371 /* Also register the reverse mapping so that we can find the
2372 new name given to an existing assembler name (used when
2373 restoring alias pairs in input_constructors_or_inits. */
2374 lto_record_renamed_decl (data_in->file_data,
2375 IDENTIFIER_POINTER (new_assembler_name),
2376 IDENTIFIER_POINTER (old_assembler_name));
2380 /* If this variable has already been declared, queue the
2381 declaration for merging. */
2382 if (TREE_PUBLIC (decl) && !DECL_ABSTRACT (decl))
2383 VEC_safe_push (tree, heap, deferred_global_decls, decl);
2387 /* Read an index IX from input block IB and return the tree node at
2388 DATA_IN->FILE_DATA->GLOBALS_INDEX[IX]. */
2391 lto_get_pickled_tree (struct lto_input_block *ib, struct data_in *data_in)
2395 enum LTO_tags expected_tag;
2396 unsigned HOST_WIDE_INT orig_offset;
2398 ix = lto_input_sleb128 (ib);
2399 expected_tag = (enum LTO_tags) lto_input_uleb128 (ib);
2401 orig_offset = lto_input_uleb128 (ib);
2402 gcc_assert (orig_offset == (unsigned) orig_offset);
2404 result = lto_streamer_cache_get (data_in->reader_cache, ix);
2405 if (result == NULL_TREE)
2407 /* We have not yet read the cache slot IX. Go to the offset
2408 in the stream where the physical tree node is, and materialize
2410 struct lto_input_block fwd_ib;
2412 /* If we are trying to go back in the stream, something is wrong.
2413 We should've read the node at the earlier position already. */
2414 if (ib->p >= orig_offset)
2415 internal_error ("bytecode stream: tried to jump backwards in the "
2418 LTO_INIT_INPUT_BLOCK (fwd_ib, ib->data, orig_offset, ib->len);
2419 result = lto_input_tree (&fwd_ib, data_in);
2423 && TREE_CODE (result) == lto_tag_to_tree_code (expected_tag));
2429 /* Read a code and class from input block IB and return the
2430 corresponding builtin. DATA_IN is as in lto_input_tree. */
2433 lto_get_builtin_tree (struct lto_input_block *ib, struct data_in *data_in)
2435 enum built_in_class fclass;
2436 enum built_in_function fcode;
2437 const char *asmname;
2441 fclass = (enum built_in_class) lto_input_uleb128 (ib);
2442 gcc_assert (fclass == BUILT_IN_NORMAL || fclass == BUILT_IN_MD);
2444 fcode = (enum built_in_function) lto_input_uleb128 (ib);
2445 gcc_assert (fcode < END_BUILTINS);
2447 ix = lto_input_sleb128 (ib);
2448 gcc_assert (ix == (int) ix);
2450 result = built_in_decls[fcode];
2451 gcc_assert (result);
2453 asmname = input_string (data_in, ib);
2455 set_builtin_user_assembler_name (result, asmname);
2457 lto_streamer_cache_insert_at (data_in->reader_cache, result, ix);
2463 /* Read the physical representation of a tree node with tag TAG from
2464 input block IB using the per-file context in DATA_IN. */
2467 lto_read_tree (struct lto_input_block *ib, struct data_in *data_in,
2474 result = lto_materialize_tree (ib, data_in, tag, &ix);
2476 /* Read all the pointer fields in RESULT. */
2477 lto_input_tree_pointers (ib, data_in, result);
2479 /* We should never try to instantiate an MD or NORMAL builtin here. */
2480 if (TREE_CODE (result) == FUNCTION_DECL)
2481 gcc_assert (!lto_stream_as_builtin_p (result));
2483 if (TREE_CODE (result) == VAR_DECL)
2484 lto_register_var_decl_in_symtab (result);
2485 else if (TREE_CODE (result) == FUNCTION_DECL && !DECL_BUILT_IN (result))
2486 lto_register_function_decl_in_symtab (data_in, result);
2488 end_marker = lto_input_1_unsigned (ib);
2490 #ifdef LTO_STREAMER_DEBUG
2491 /* Remove the mapping to RESULT's original address set by
2492 lto_materialize_tree. */
2493 lto_orig_address_remove (result);
2500 /* Read and INTEGER_CST node from input block IB using the per-file
2501 context in DATA_IN. */
2504 lto_input_integer_cst (struct lto_input_block *ib, struct data_in *data_in)
2507 HOST_WIDE_INT low, high;
2510 type = lto_input_tree (ib, data_in);
2511 overflow_p = (lto_input_1_unsigned (ib) != 0);
2512 low = lto_input_uleb128 (ib);
2513 high = lto_input_uleb128 (ib);
2514 result = build_int_cst_wide (type, low, high);
2516 /* If the original constant had overflown, build a replica of RESULT to
2517 avoid modifying the shared constant returned by build_int_cst_wide. */
2520 result = copy_node (result);
2521 TREE_OVERFLOW (result) = 1;
2528 /* Read a tree from input block IB using the per-file context in
2529 DATA_IN. This context is used, for example, to resolve references
2530 to previously read nodes. */
2533 lto_input_tree (struct lto_input_block *ib, struct data_in *data_in)
2538 tag = input_record_start (ib);
2539 gcc_assert ((unsigned) tag < (unsigned) LTO_NUM_TAGS);
2541 if (tag == LTO_null)
2543 else if (tag >= LTO_field_decl_ref && tag <= LTO_global_decl_ref)
2545 /* If TAG is a reference to an indexable tree, the next value
2546 in IB is the index into the table where we expect to find
2548 result = lto_input_tree_ref (ib, data_in, cfun, tag);
2550 else if (tag == LTO_tree_pickle_reference)
2552 /* If TAG is a reference to a previously read tree, look it up in
2553 the reader cache. */
2554 result = lto_get_pickled_tree (ib, data_in);
2556 else if (tag == LTO_builtin_decl)
2558 /* If we are going to read a built-in function, all we need is
2559 the code and class. */
2560 result = lto_get_builtin_tree (ib, data_in);
2562 else if (tag == lto_tree_code_to_tag (INTEGER_CST))
2564 /* For integer constants we only need the type and its hi/low
2566 result = lto_input_integer_cst (ib, data_in);
2570 /* Otherwise, materialize a new node from IB. */
2571 result = lto_read_tree (ib, data_in, tag);
2578 /* Initialization for the LTO reader. */
2581 lto_init_reader (void)
2583 lto_streamer_init ();
2585 memset (<o_stats, 0, sizeof (lto_stats));
2586 bitmap_obstack_initialize (NULL);
2588 file_name_hash_table = htab_create (37, hash_string_slot_node,
2589 eq_string_slot_node, free);
2591 gimple_register_cfg_hooks ();
2595 /* Create a new data_in object for FILE_DATA. STRINGS is the string
2596 table to use with LEN strings. RESOLUTIONS is the vector of linker
2597 resolutions (NULL if not using a linker plugin). */
2600 lto_data_in_create (struct lto_file_decl_data *file_data, const char *strings,
2602 VEC(ld_plugin_symbol_resolution_t,heap) *resolutions)
2604 struct data_in *data_in = XCNEW (struct data_in);
2605 data_in->file_data = file_data;
2606 data_in->strings = strings;
2607 data_in->strings_len = len;
2608 data_in->globals_resolution = resolutions;
2609 data_in->reader_cache = lto_streamer_cache_create ();
2615 /* Remove DATA_IN. */
2618 lto_data_in_delete (struct data_in *data_in)
2620 VEC_free (ld_plugin_symbol_resolution_t, heap, data_in->globals_resolution);
2621 lto_streamer_cache_delete (data_in->reader_cache);
2622 free (data_in->labels);