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"
50 #include "tree-pass.h"
52 /* Data structure used to hash file names in the source_location field. */
56 unsigned int slot_num;
59 /* The table to hold the file names. */
60 static htab_t file_name_hash_table;
63 /* Check that tag ACTUAL has one of the given values. NUM_TAGS is the
64 number of valid tag values to check. */
67 lto_tag_check_set (enum LTO_tags actual, int ntags, ...)
73 for (i = 0; i < ntags; i++)
74 if ((unsigned) actual == va_arg (ap, unsigned))
81 internal_error ("bytecode stream: unexpected tag %s", lto_tag_name (actual));
85 /* Check that tag ACTUAL is in the range [TAG1, TAG2]. */
88 lto_tag_check_range (enum LTO_tags actual, enum LTO_tags tag1,
91 if (actual < tag1 || actual > tag2)
92 internal_error ("bytecode stream: tag %s is not in the expected range "
94 lto_tag_name (actual),
100 /* Check that tag ACTUAL == EXPECTED. */
103 lto_tag_check (enum LTO_tags actual, enum LTO_tags expected)
105 if (actual != expected)
106 internal_error ("bytecode stream: expected tag %s instead of %s",
107 lto_tag_name (expected), lto_tag_name (actual));
111 /* Return a hash code for P. */
114 hash_string_slot_node (const void *p)
116 const struct string_slot *ds = (const struct string_slot *) p;
117 return (hashval_t) htab_hash_string (ds->s);
121 /* Returns nonzero if P1 and P2 are equal. */
124 eq_string_slot_node (const void *p1, const void *p2)
126 const struct string_slot *ds1 = (const struct string_slot *) p1;
127 const struct string_slot *ds2 = (const struct string_slot *) p2;
128 return strcmp (ds1->s, ds2->s) == 0;
132 /* Read a string from the string table in DATA_IN using input block
133 IB. Write the length to RLEN. */
136 input_string_internal (struct data_in *data_in, struct lto_input_block *ib,
139 struct lto_input_block str_tab;
144 loc = lto_input_uleb128 (ib);
145 LTO_INIT_INPUT_BLOCK (str_tab, data_in->strings, loc, data_in->strings_len);
146 len = lto_input_uleb128 (&str_tab);
149 if (str_tab.p + len > data_in->strings_len)
150 internal_error ("bytecode stream: string too long for the string table");
152 result = (const char *)(data_in->strings + str_tab.p);
158 /* Read a STRING_CST from the string table in DATA_IN using input
162 input_string_cst (struct data_in *data_in, struct lto_input_block *ib)
166 unsigned int is_null;
168 is_null = lto_input_uleb128 (ib);
172 ptr = input_string_internal (data_in, ib, &len);
173 return build_string (len, ptr);
177 /* Read an IDENTIFIER from the string table in DATA_IN using input
181 input_identifier (struct data_in *data_in, struct lto_input_block *ib)
185 unsigned int is_null;
187 is_null = lto_input_uleb128 (ib);
191 ptr = input_string_internal (data_in, ib, &len);
192 return get_identifier_with_length (ptr, len);
195 /* Read a NULL terminated string from the string table in DATA_IN. */
198 input_string (struct data_in *data_in, struct lto_input_block *ib)
202 unsigned int is_null;
204 is_null = lto_input_uleb128 (ib);
208 ptr = input_string_internal (data_in, ib, &len);
209 if (ptr[len - 1] != '\0')
210 internal_error ("bytecode stream: found non-null terminated string");
216 /* Return the next tag in the input block IB. */
219 input_record_start (struct lto_input_block *ib)
221 enum LTO_tags tag = (enum LTO_tags) lto_input_uleb128 (ib);
226 /* Lookup STRING in file_name_hash_table. If found, return the existing
227 string, otherwise insert STRING as the canonical version. */
230 canon_file_name (const char *string)
233 struct string_slot s_slot;
236 slot = htab_find_slot (file_name_hash_table, &s_slot, INSERT);
241 struct string_slot *new_slot;
243 len = strlen (string);
244 saved_string = (char *) xmalloc (len + 1);
245 new_slot = XCNEW (struct string_slot);
246 strcpy (saved_string, string);
247 new_slot->s = saved_string;
253 struct string_slot *old_slot = (struct string_slot *) *slot;
259 /* Clear the line info stored in DATA_IN. */
262 clear_line_info (struct data_in *data_in)
264 if (data_in->current_file)
265 linemap_add (line_table, LC_LEAVE, false, NULL, 0);
266 data_in->current_file = NULL;
267 data_in->current_line = 0;
268 data_in->current_col = 0;
272 /* Read a location from input block IB. */
275 lto_input_location (struct lto_input_block *ib, struct data_in *data_in)
277 expanded_location xloc;
279 xloc.file = input_string (data_in, ib);
280 if (xloc.file == NULL)
281 return UNKNOWN_LOCATION;
283 xloc.file = canon_file_name (xloc.file);
284 xloc.line = lto_input_sleb128 (ib);
285 xloc.column = lto_input_sleb128 (ib);
286 xloc.sysp = lto_input_sleb128 (ib);
288 if (data_in->current_file != xloc.file)
290 if (data_in->current_file)
291 linemap_add (line_table, LC_LEAVE, false, NULL, 0);
293 linemap_add (line_table, LC_ENTER, xloc.sysp, xloc.file, xloc.line);
295 else if (data_in->current_line != xloc.line)
296 linemap_line_start (line_table, xloc.line, xloc.column);
298 data_in->current_file = xloc.file;
299 data_in->current_line = xloc.line;
300 data_in->current_col = xloc.column;
302 return linemap_position_for_column (line_table, xloc.column);
306 /* Read a reference to a tree node from DATA_IN using input block IB.
307 TAG is the expected node that should be found in IB, if TAG belongs
308 to one of the indexable trees, expect to read a reference index to
309 be looked up in one of the symbol tables, otherwise read the pysical
310 representation of the tree using lto_input_tree. FN is the
311 function scope for the read tree. */
314 lto_input_tree_ref (struct lto_input_block *ib, struct data_in *data_in,
315 struct function *fn, enum LTO_tags tag)
317 unsigned HOST_WIDE_INT ix_u;
318 tree result = NULL_TREE;
320 lto_tag_check_range (tag, LTO_field_decl_ref, LTO_global_decl_ref);
325 ix_u = lto_input_uleb128 (ib);
326 result = lto_file_decl_data_get_type (data_in->file_data, ix_u);
329 case LTO_ssa_name_ref:
330 ix_u = lto_input_uleb128 (ib);
331 result = VEC_index (tree, SSANAMES (fn), ix_u);
334 case LTO_field_decl_ref:
335 ix_u = lto_input_uleb128 (ib);
336 result = lto_file_decl_data_get_field_decl (data_in->file_data, ix_u);
339 case LTO_function_decl_ref:
340 ix_u = lto_input_uleb128 (ib);
341 result = lto_file_decl_data_get_fn_decl (data_in->file_data, ix_u);
344 case LTO_type_decl_ref:
345 ix_u = lto_input_uleb128 (ib);
346 result = lto_file_decl_data_get_type_decl (data_in->file_data, ix_u);
349 case LTO_namespace_decl_ref:
350 ix_u = lto_input_uleb128 (ib);
351 result = lto_file_decl_data_get_namespace_decl (data_in->file_data, ix_u);
354 case LTO_global_decl_ref:
355 case LTO_result_decl_ref:
356 case LTO_const_decl_ref:
357 case LTO_imported_decl_ref:
358 case LTO_label_decl_ref:
359 ix_u = lto_input_uleb128 (ib);
360 result = lto_file_decl_data_get_var_decl (data_in->file_data, ix_u);
361 if (tag == LTO_global_decl_ref)
362 varpool_mark_needed_node (varpool_node (result));
375 /* Read and return a double-linked list of catch handlers from input
376 block IB, using descriptors in DATA_IN. */
378 static struct eh_catch_d *
379 lto_input_eh_catch_list (struct lto_input_block *ib, struct data_in *data_in,
385 *last_p = first = NULL;
386 tag = input_record_start (ib);
392 lto_tag_check_range (tag, LTO_eh_catch, LTO_eh_catch);
394 /* Read the catch node. */
395 n = GGC_CNEW (struct eh_catch_d);
396 n->type_list = lto_input_tree (ib, data_in);
397 n->filter_list = lto_input_tree (ib, data_in);
398 n->label = lto_input_tree (ib, data_in);
400 /* Register all the types in N->FILTER_LIST. */
401 for (list = n->filter_list; list; list = TREE_CHAIN (list))
402 add_type_for_runtime (TREE_VALUE (list));
404 /* Chain N to the end of the list. */
406 (*last_p)->next_catch = n;
407 n->prev_catch = *last_p;
410 /* Set the head of the list the first time through the loop. */
414 tag = input_record_start (ib);
421 /* Read and return EH region IX from input block IB, using descriptors
425 input_eh_region (struct lto_input_block *ib, struct data_in *data_in, int ix)
430 /* Read the region header. */
431 tag = input_record_start (ib);
435 r = GGC_CNEW (struct eh_region_d);
436 r->index = lto_input_sleb128 (ib);
438 gcc_assert (r->index == ix);
440 /* Read all the region pointers as region numbers. We'll fix up
441 the pointers once the whole array has been read. */
442 r->outer = (eh_region) (intptr_t) lto_input_sleb128 (ib);
443 r->inner = (eh_region) (intptr_t) lto_input_sleb128 (ib);
444 r->next_peer = (eh_region) (intptr_t) lto_input_sleb128 (ib);
448 case LTO_ert_cleanup:
449 r->type = ERT_CLEANUP;
454 struct eh_catch_d *last_catch;
456 r->u.eh_try.first_catch = lto_input_eh_catch_list (ib, data_in,
458 r->u.eh_try.last_catch = last_catch;
462 case LTO_ert_allowed_exceptions:
466 r->type = ERT_ALLOWED_EXCEPTIONS;
467 r->u.allowed.type_list = lto_input_tree (ib, data_in);
468 r->u.allowed.label = lto_input_tree (ib, data_in);
469 r->u.allowed.filter = lto_input_uleb128 (ib);
471 for (l = r->u.allowed.type_list; l ; l = TREE_CHAIN (l))
472 add_type_for_runtime (TREE_VALUE (l));
476 case LTO_ert_must_not_throw:
477 r->type = ERT_MUST_NOT_THROW;
478 r->u.must_not_throw.failure_decl = lto_input_tree (ib, data_in);
479 r->u.must_not_throw.failure_loc = lto_input_location (ib, data_in);
486 r->landing_pads = (eh_landing_pad) (intptr_t) lto_input_sleb128 (ib);
492 /* Read and return EH landing pad IX from input block IB, using descriptors
495 static eh_landing_pad
496 input_eh_lp (struct lto_input_block *ib, struct data_in *data_in, int ix)
501 /* Read the landing pad header. */
502 tag = input_record_start (ib);
506 lto_tag_check_range (tag, LTO_eh_landing_pad, LTO_eh_landing_pad);
508 lp = GGC_CNEW (struct eh_landing_pad_d);
509 lp->index = lto_input_sleb128 (ib);
510 gcc_assert (lp->index == ix);
511 lp->next_lp = (eh_landing_pad) (intptr_t) lto_input_sleb128 (ib);
512 lp->region = (eh_region) (intptr_t) lto_input_sleb128 (ib);
513 lp->post_landing_pad = lto_input_tree (ib, data_in);
519 /* After reading the EH regions, pointers to peer and children regions
520 are region numbers. This converts all these region numbers into
521 real pointers into the rematerialized regions for FN. ROOT_REGION
522 is the region number for the root EH region in FN. */
525 fixup_eh_region_pointers (struct function *fn, HOST_WIDE_INT root_region)
528 VEC(eh_region,gc) *eh_array = fn->eh->region_array;
529 VEC(eh_landing_pad,gc) *lp_array = fn->eh->lp_array;
533 gcc_assert (eh_array && lp_array);
535 gcc_assert (root_region >= 0);
536 fn->eh->region_tree = VEC_index (eh_region, eh_array, root_region);
538 #define FIXUP_EH_REGION(r) (r) = VEC_index (eh_region, eh_array, \
539 (HOST_WIDE_INT) (intptr_t) (r))
540 #define FIXUP_EH_LP(p) (p) = VEC_index (eh_landing_pad, lp_array, \
541 (HOST_WIDE_INT) (intptr_t) (p))
543 /* Convert all the index numbers stored in pointer fields into
544 pointers to the corresponding slots in the EH region array. */
545 for (i = 0; VEC_iterate (eh_region, eh_array, i, r); i++)
547 /* The array may contain NULL regions. */
551 gcc_assert (i == (unsigned) r->index);
552 FIXUP_EH_REGION (r->outer);
553 FIXUP_EH_REGION (r->inner);
554 FIXUP_EH_REGION (r->next_peer);
555 FIXUP_EH_LP (r->landing_pads);
558 /* Convert all the index numbers stored in pointer fields into
559 pointers to the corresponding slots in the EH landing pad array. */
560 for (i = 0; VEC_iterate (eh_landing_pad, lp_array, i, lp); i++)
562 /* The array may contain NULL landing pads. */
566 gcc_assert (i == (unsigned) lp->index);
567 FIXUP_EH_LP (lp->next_lp);
568 FIXUP_EH_REGION (lp->region);
571 #undef FIXUP_EH_REGION
576 /* Initialize EH support. */
581 /* Contrary to most other FEs, we only initialize EH support when at
582 least one of the files in the set contains exception regions in
583 it. Since this happens much later than the call to init_eh in
584 lang_dependent_init, we have to set flag_exceptions and call
585 init_eh again to initialize the EH tables. */
589 /* Initialize dwarf2 tables. Since dwarf2out_do_frame() returns
590 true only when exceptions are enabled, this initialization is
591 never done during lang_dependent_init. */
592 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
593 if (dwarf2out_do_frame ())
594 dwarf2out_frame_init ();
599 /* Read the exception table for FN from IB using the data descriptors
603 input_eh_regions (struct lto_input_block *ib, struct data_in *data_in,
606 HOST_WIDE_INT i, root_region, len;
608 static bool eh_initialized_p = false;
610 tag = input_record_start (ib);
614 lto_tag_check_range (tag, LTO_eh_table, LTO_eh_table);
616 /* If the file contains EH regions, then it was compiled with
617 -fexceptions. In that case, initialize the backend EH
619 if (!eh_initialized_p)
622 eh_initialized_p = true;
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_CNEW (struct 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)
724 unsigned int bb_count;
729 init_empty_tree_cfg_for_function (fn);
730 init_ssa_operands ();
732 profile_status_for_function (fn) =
733 (enum profile_status_d) lto_input_uleb128 (ib);
735 bb_count = lto_input_uleb128 (ib);
737 last_basic_block_for_function (fn) = bb_count;
738 if (bb_count > VEC_length (basic_block, basic_block_info_for_function (fn)))
739 VEC_safe_grow_cleared (basic_block, gc,
740 basic_block_info_for_function (fn), bb_count);
742 if (bb_count > VEC_length (basic_block, label_to_block_map_for_function (fn)))
743 VEC_safe_grow_cleared (basic_block, gc,
744 label_to_block_map_for_function (fn), bb_count);
746 index = lto_input_sleb128 (ib);
749 basic_block bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
750 unsigned int edge_count;
753 bb = make_new_block (fn, index);
755 edge_count = lto_input_uleb128 (ib);
757 /* Connect up the CFG. */
758 for (i = 0; i < edge_count; i++)
760 unsigned int dest_index;
761 unsigned int edge_flags;
767 dest_index = lto_input_uleb128 (ib);
768 probability = (int) lto_input_sleb128 (ib);
769 count = (gcov_type) lto_input_sleb128 (ib);
770 edge_flags = lto_input_uleb128 (ib);
772 dest = BASIC_BLOCK_FOR_FUNCTION (fn, dest_index);
775 dest = make_new_block (fn, dest_index);
777 e = make_edge (bb, dest, edge_flags);
778 e->probability = probability;
782 index = lto_input_sleb128 (ib);
785 p_bb = ENTRY_BLOCK_PTR_FOR_FUNCTION(fn);
786 index = lto_input_sleb128 (ib);
789 basic_block bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
793 index = lto_input_sleb128 (ib);
798 /* Read a PHI function for basic block BB in function FN. DATA_IN is
799 the file being read. IB is the input block to use for reading. */
802 input_phi (struct lto_input_block *ib, basic_block bb, struct data_in *data_in,
805 unsigned HOST_WIDE_INT ix;
810 ix = lto_input_uleb128 (ib);
811 phi_result = VEC_index (tree, SSANAMES (fn), ix);
812 len = EDGE_COUNT (bb->preds);
813 result = create_phi_node (phi_result, bb);
814 SSA_NAME_DEF_STMT (phi_result) = result;
816 /* We have to go through a lookup process here because the preds in the
817 reconstructed graph are generally in a different order than they
818 were in the original program. */
819 for (i = 0; i < len; i++)
821 tree def = lto_input_tree (ib, data_in);
822 int src_index = lto_input_uleb128 (ib);
823 location_t arg_loc = lto_input_location (ib, data_in);
824 basic_block sbb = BASIC_BLOCK_FOR_FUNCTION (fn, src_index);
829 for (j = 0; j < len; j++)
830 if (EDGE_PRED (bb, j)->src == sbb)
832 e = EDGE_PRED (bb, j);
836 add_phi_arg (result, def, e, arg_loc);
843 /* Read the SSA names array for function FN from DATA_IN using input
847 input_ssa_names (struct lto_input_block *ib, struct data_in *data_in,
850 unsigned int i, size;
852 size = lto_input_uleb128 (ib);
853 init_ssanames (fn, size);
855 i = lto_input_uleb128 (ib);
861 /* Skip over the elements that had been freed. */
862 while (VEC_length (tree, SSANAMES (fn)) < i)
863 VEC_quick_push (tree, SSANAMES (fn), NULL_TREE);
865 is_default_def = (lto_input_1_unsigned (ib) != 0);
866 name = lto_input_tree (ib, data_in);
867 ssa_name = make_ssa_name_fn (fn, name, gimple_build_nop ());
870 set_default_def (SSA_NAME_VAR (ssa_name), ssa_name);
872 i = lto_input_uleb128 (ib);
877 /* Fixup the reference tree OP for replaced VAR_DECLs with mismatched
881 maybe_fixup_handled_component (tree op)
886 while (handled_component_p (TREE_OPERAND (op, 0)))
887 op = TREE_OPERAND (op, 0);
888 if (TREE_CODE (TREE_OPERAND (op, 0)) != VAR_DECL)
891 decl_type = TREE_TYPE (TREE_OPERAND (op, 0));
893 switch (TREE_CODE (op))
896 /* The DECL_CONTEXT of the field-decl is the record type we look for. */
897 wanted_type = DECL_CONTEXT (TREE_OPERAND (op, 1));
901 if (TREE_CODE (decl_type) == ARRAY_TYPE
902 && (TREE_TYPE (decl_type) == TREE_TYPE (op)
903 || useless_type_conversion_p (TREE_TYPE (op),
904 TREE_TYPE (decl_type))))
906 /* An unknown size array type should be ok. But we do not
907 lower the lower bound in all cases - ugh. */
908 wanted_type = build_array_type (TREE_TYPE (op), NULL_TREE);
911 case ARRAY_RANGE_REF:
912 if (TREE_CODE (decl_type) == ARRAY_TYPE
913 && (TREE_TYPE (decl_type) == TREE_TYPE (TREE_TYPE (op))
914 || useless_type_conversion_p (TREE_TYPE (TREE_TYPE (op)),
915 TREE_TYPE (decl_type))))
917 /* An unknown size array type should be ok. But we do not
918 lower the lower bound in all cases - ugh. */
919 wanted_type = build_array_type (TREE_TYPE (TREE_TYPE (op)), NULL_TREE);
923 case VIEW_CONVERT_EXPR:
924 /* Very nice - nothing to do. */
929 if (TREE_CODE (decl_type) == COMPLEX_TYPE
930 && (TREE_TYPE (decl_type) == TREE_TYPE (op)
931 || useless_type_conversion_p (TREE_TYPE (op),
932 TREE_TYPE (decl_type))))
934 wanted_type = build_complex_type (TREE_TYPE (op));
941 if (!useless_type_conversion_p (wanted_type, decl_type))
942 TREE_OPERAND (op, 0) = build1 (VIEW_CONVERT_EXPR, wanted_type,
943 TREE_OPERAND (op, 0));
946 /* Fixup reference tree operands for substituted prevailing decls
947 with mismatched types in STMT. */
950 maybe_fixup_decls (gimple stmt)
952 /* We have to fixup replaced decls here in case there were
953 inter-TU type mismatches. Catch the most common cases
954 for now - this way we'll get testcases for the rest as
955 the type verifier will complain. */
956 if (gimple_assign_single_p (stmt))
958 tree lhs = gimple_assign_lhs (stmt);
959 tree rhs = gimple_assign_rhs1 (stmt);
961 /* First catch loads and aggregate copies by adjusting the rhs. */
962 if (TREE_CODE (rhs) == VAR_DECL)
964 if (!useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (rhs)))
965 gimple_assign_set_rhs1 (stmt, build1 (VIEW_CONVERT_EXPR,
966 TREE_TYPE (lhs), rhs));
968 else if (handled_component_p (rhs))
969 maybe_fixup_handled_component (rhs);
970 /* Then catch scalar stores. */
971 else if (TREE_CODE (lhs) == VAR_DECL)
973 if (!useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (rhs)))
974 gimple_assign_set_lhs (stmt, build1 (VIEW_CONVERT_EXPR,
975 TREE_TYPE (rhs), lhs));
977 else if (handled_component_p (lhs))
978 maybe_fixup_handled_component (lhs);
980 else if (is_gimple_call (stmt))
982 tree lhs = gimple_call_lhs (stmt);
984 if (lhs && TREE_CODE (lhs) == VAR_DECL)
986 if (!useless_type_conversion_p (TREE_TYPE (lhs),
987 gimple_call_return_type (stmt)))
988 gimple_call_set_lhs (stmt, build1 (VIEW_CONVERT_EXPR,
989 gimple_call_return_type (stmt),
992 else if (lhs && handled_component_p (lhs))
993 maybe_fixup_handled_component (lhs);
995 /* Arguments, especially for varargs functions will be funny... */
999 /* Read a statement with tag TAG in function FN from block IB using
1000 descriptors in DATA_IN. */
1003 input_gimple_stmt (struct lto_input_block *ib, struct data_in *data_in,
1004 struct function *fn, enum LTO_tags tag)
1007 enum gimple_code code;
1008 unsigned HOST_WIDE_INT num_ops;
1010 struct bitpack_d *bp;
1012 code = lto_tag_to_gimple_code (tag);
1014 /* Read the tuple header. */
1015 bp = lto_input_bitpack (ib);
1016 num_ops = bp_unpack_value (bp, sizeof (unsigned) * 8);
1017 stmt = gimple_alloc (code, num_ops);
1018 stmt->gsbase.no_warning = bp_unpack_value (bp, 1);
1019 if (is_gimple_assign (stmt))
1020 stmt->gsbase.nontemporal_move = bp_unpack_value (bp, 1);
1021 stmt->gsbase.has_volatile_ops = bp_unpack_value (bp, 1);
1022 stmt->gsbase.subcode = bp_unpack_value (bp, 16);
1023 bitpack_delete (bp);
1025 /* Read location information. */
1026 gimple_set_location (stmt, lto_input_location (ib, data_in));
1028 /* Read lexical block reference. */
1029 gimple_set_block (stmt, lto_input_tree (ib, data_in));
1031 /* Read in all the operands. */
1035 gimple_resx_set_region (stmt, lto_input_sleb128 (ib));
1038 case GIMPLE_EH_MUST_NOT_THROW:
1039 gimple_eh_must_not_throw_set_fndecl (stmt, lto_input_tree (ib, data_in));
1042 case GIMPLE_EH_DISPATCH:
1043 gimple_eh_dispatch_set_region (stmt, lto_input_sleb128 (ib));
1048 /* FIXME lto. Move most of this into a new gimple_asm_set_string(). */
1050 stmt->gimple_asm.ni = lto_input_uleb128 (ib);
1051 stmt->gimple_asm.no = lto_input_uleb128 (ib);
1052 stmt->gimple_asm.nc = lto_input_uleb128 (ib);
1053 str = input_string_cst (data_in, ib);
1054 stmt->gimple_asm.string = TREE_STRING_POINTER (str);
1066 for (i = 0; i < num_ops; i++)
1068 tree op = lto_input_tree (ib, data_in);
1069 gimple_set_op (stmt, i, op);
1071 /* Fixup FIELD_DECLs. */
1072 while (op && handled_component_p (op))
1074 if (TREE_CODE (op) == COMPONENT_REF)
1076 tree field, type, tem;
1077 field = TREE_OPERAND (op, 1);
1078 type = DECL_CONTEXT (field);
1079 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1082 || (TREE_TYPE (tem) == TREE_TYPE (field)
1083 && (DECL_FIELD_OFFSET (tem)
1084 == DECL_FIELD_OFFSET (field))
1085 && (DECL_FIELD_BIT_OFFSET (tem)
1086 == DECL_FIELD_BIT_OFFSET (field))
1087 && (DECL_OFFSET_ALIGN (tem)
1088 == DECL_OFFSET_ALIGN (field))))
1091 /* In case of type mismatches across units we can fail
1092 to unify some types and thus not find a proper
1093 field-decl here. Just do nothing in this case. */
1094 if (tem != NULL_TREE)
1095 TREE_OPERAND (op, 1) = tem;
1098 op = TREE_OPERAND (op, 0);
1104 case GIMPLE_PREDICT:
1108 internal_error ("bytecode stream: unknown GIMPLE statement tag %s",
1109 lto_tag_name (tag));
1112 /* Update the properties of symbols, SSA names and labels associated
1114 if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
1116 tree lhs = gimple_get_lhs (stmt);
1117 if (lhs && TREE_CODE (lhs) == SSA_NAME)
1118 SSA_NAME_DEF_STMT (lhs) = stmt;
1120 else if (code == GIMPLE_LABEL)
1121 gcc_assert (emit_label_in_global_context_p (gimple_label_label (stmt))
1122 || DECL_CONTEXT (gimple_label_label (stmt)) == fn->decl);
1123 else if (code == GIMPLE_ASM)
1127 for (i = 0; i < gimple_asm_noutputs (stmt); i++)
1129 tree op = TREE_VALUE (gimple_asm_output_op (stmt, i));
1130 if (TREE_CODE (op) == SSA_NAME)
1131 SSA_NAME_DEF_STMT (op) = stmt;
1135 /* Fixup reference tree operands for substituted prevailing decls
1136 with mismatched types. */
1137 maybe_fixup_decls (stmt);
1139 /* Mark the statement modified so its operand vectors can be filled in. */
1140 gimple_set_modified (stmt, true);
1146 /* Read a basic block with tag TAG from DATA_IN using input block IB.
1147 FN is the function being processed. */
1150 input_bb (struct lto_input_block *ib, enum LTO_tags tag,
1151 struct data_in *data_in, struct function *fn)
1155 gimple_stmt_iterator bsi;
1157 /* This routine assumes that CFUN is set to FN, as it needs to call
1158 basic GIMPLE routines that use CFUN. */
1159 gcc_assert (cfun == fn);
1161 index = lto_input_uleb128 (ib);
1162 bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
1164 bb->count = lto_input_sleb128 (ib);
1165 bb->loop_depth = lto_input_sleb128 (ib);
1166 bb->frequency = lto_input_sleb128 (ib);
1167 bb->flags = lto_input_sleb128 (ib);
1169 /* LTO_bb1 has statements. LTO_bb0 does not. */
1173 bsi = gsi_start_bb (bb);
1174 tag = input_record_start (ib);
1177 gimple stmt = input_gimple_stmt (ib, data_in, fn, tag);
1179 /* Change debug stmts to nops on-the-fly if we do not have VTA enabled.
1180 This allows us to build for example static libs with debugging
1181 enabled and do the final link without. */
1182 if (!MAY_HAVE_DEBUG_STMTS
1183 && is_gimple_debug (stmt))
1184 stmt = gimple_build_nop ();
1186 find_referenced_vars_in (stmt);
1187 gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
1189 /* After the statement, expect a 0 delimiter or the EH region
1190 that the previous statement belongs to. */
1191 tag = input_record_start (ib);
1192 lto_tag_check_set (tag, 2, LTO_eh_region, LTO_null);
1194 if (tag == LTO_eh_region)
1196 HOST_WIDE_INT region = lto_input_sleb128 (ib);
1197 gcc_assert (region == (int) region);
1198 add_stmt_to_eh_lp (stmt, region);
1201 tag = input_record_start (ib);
1204 tag = input_record_start (ib);
1207 gimple phi = input_phi (ib, bb, data_in, fn);
1208 find_referenced_vars_in (phi);
1209 tag = input_record_start (ib);
1213 /* Go through all NODE edges and fixup call_stmt pointers
1214 so they point to STMTS. */
1217 fixup_call_stmt_edges_1 (struct cgraph_node *node, gimple *stmts)
1219 struct cgraph_edge *cedge;
1220 for (cedge = node->callees; cedge; cedge = cedge->next_callee)
1221 cedge->call_stmt = stmts[cedge->lto_stmt_uid];
1224 /* Fixup call_stmt pointers in NODE and all clones. */
1227 fixup_call_stmt_edges (struct cgraph_node *orig, gimple *stmts)
1229 struct cgraph_node *node;
1231 while (orig->clone_of)
1232 orig = orig->clone_of;
1234 fixup_call_stmt_edges_1 (orig, stmts);
1236 for (node = orig->clones; node != orig;)
1238 fixup_call_stmt_edges_1 (node, stmts);
1240 node = node->clones;
1241 else if (node->next_sibling_clone)
1242 node = node->next_sibling_clone;
1245 while (node != orig && !node->next_sibling_clone)
1246 node = node->clone_of;
1248 node = node->next_sibling_clone;
1253 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1256 input_function (tree fn_decl, struct data_in *data_in,
1257 struct lto_input_block *ib)
1259 struct function *fn;
1263 struct bitpack_d *bp;
1264 struct cgraph_node *node;
1265 tree args, narg, oarg;
1267 fn = DECL_STRUCT_FUNCTION (fn_decl);
1268 tag = input_record_start (ib);
1269 clear_line_info (data_in);
1271 gimple_register_cfg_hooks ();
1272 lto_tag_check (tag, LTO_function);
1274 /* Read all the attributes for FN. */
1275 bp = lto_input_bitpack (ib);
1276 fn->is_thunk = bp_unpack_value (bp, 1);
1277 fn->has_local_explicit_reg_vars = bp_unpack_value (bp, 1);
1278 fn->after_tree_profile = bp_unpack_value (bp, 1);
1279 fn->returns_pcc_struct = bp_unpack_value (bp, 1);
1280 fn->returns_struct = bp_unpack_value (bp, 1);
1281 fn->always_inline_functions_inlined = bp_unpack_value (bp, 1);
1282 fn->after_inlining = bp_unpack_value (bp, 1);
1283 fn->dont_save_pending_sizes_p = bp_unpack_value (bp, 1);
1284 fn->stdarg = bp_unpack_value (bp, 1);
1285 fn->has_nonlocal_label = bp_unpack_value (bp, 1);
1286 fn->calls_alloca = bp_unpack_value (bp, 1);
1287 fn->calls_setjmp = bp_unpack_value (bp, 1);
1288 fn->function_frequency = (enum function_frequency) bp_unpack_value (bp, 2);
1289 fn->va_list_fpr_size = bp_unpack_value (bp, 8);
1290 fn->va_list_gpr_size = bp_unpack_value (bp, 8);
1291 bitpack_delete (bp);
1293 /* Read the static chain and non-local goto save area. */
1294 fn->static_chain_decl = lto_input_tree (ib, data_in);
1295 fn->nonlocal_goto_save_area = lto_input_tree (ib, data_in);
1297 /* Read all the local symbols. */
1298 fn->local_decls = lto_input_tree (ib, data_in);
1300 /* Read all function arguments. We need to re-map them here to the
1301 arguments of the merged function declaration. */
1302 args = lto_input_tree (ib, data_in);
1303 for (oarg = args, narg = DECL_ARGUMENTS (fn_decl);
1305 oarg = TREE_CHAIN (oarg), narg = TREE_CHAIN (narg))
1309 res = lto_streamer_cache_lookup (data_in->reader_cache, oarg, &ix);
1311 /* Replace the argument in the streamer cache. */
1312 lto_streamer_cache_insert_at (data_in->reader_cache, narg, ix);
1314 gcc_assert (!oarg && !narg);
1316 /* Read all the SSA names. */
1317 input_ssa_names (ib, data_in, fn);
1319 /* Read the exception handling regions in the function. */
1320 input_eh_regions (ib, data_in, fn);
1322 /* Read the tree of lexical scopes for the function. */
1323 DECL_INITIAL (fn_decl) = lto_input_tree (ib, data_in);
1324 gcc_assert (DECL_INITIAL (fn_decl));
1325 DECL_SAVED_TREE (fn_decl) = NULL_TREE;
1327 /* Read all the basic blocks. */
1328 tag = input_record_start (ib);
1331 input_bb (ib, tag, data_in, fn);
1332 tag = input_record_start (ib);
1335 /* Fix up the call statements that are mentioned in the callgraph
1337 renumber_gimple_stmt_uids ();
1338 stmts = (gimple *) xcalloc (gimple_stmt_max_uid (fn), sizeof (gimple));
1341 gimple_stmt_iterator bsi;
1342 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
1344 gimple stmt = gsi_stmt (bsi);
1345 stmts[gimple_uid (stmt)] = stmt;
1349 /* Set the gimple body to the statement sequence in the entry
1350 basic block. FIXME lto, this is fairly hacky. The existence
1351 of a gimple body is used by the cgraph routines, but we should
1352 really use the presence of the CFG. */
1354 edge_iterator ei = ei_start (ENTRY_BLOCK_PTR->succs);
1355 gimple_set_body (fn_decl, bb_seq (ei_edge (ei)->dest));
1358 node = cgraph_node (fn_decl);
1359 fixup_call_stmt_edges (node, stmts);
1360 execute_all_ipa_stmt_fixups (node, stmts);
1362 update_ssa (TODO_update_ssa_only_virtuals);
1363 free_dominance_info (CDI_DOMINATORS);
1364 free_dominance_info (CDI_POST_DOMINATORS);
1369 /* Read initializer expressions for public statics. DATA_IN is the
1370 file being read. IB is the input block used for reading. */
1373 input_alias_pairs (struct lto_input_block *ib, struct data_in *data_in)
1377 clear_line_info (data_in);
1379 /* Skip over all the unreferenced globals. */
1381 var = lto_input_tree (ib, data_in);
1384 var = lto_input_tree (ib, data_in);
1387 const char *orig_name, *new_name;
1390 p = VEC_safe_push (alias_pair, gc, alias_pairs, NULL);
1392 p->target = lto_input_tree (ib, data_in);
1394 /* If the target is a static object, we may have registered a
1395 new name for it to avoid clashes between statics coming from
1396 different files. In that case, use the new name. */
1397 orig_name = IDENTIFIER_POINTER (p->target);
1398 new_name = lto_get_decl_name_mapping (data_in->file_data, orig_name);
1399 if (strcmp (orig_name, new_name) != 0)
1400 p->target = get_identifier (new_name);
1402 var = lto_input_tree (ib, data_in);
1407 /* Read the body from DATA for function FN_DECL and fill it in.
1408 FILE_DATA are the global decls and types. SECTION_TYPE is either
1409 LTO_section_function_body or LTO_section_static_initializer. If
1410 section type is LTO_section_function_body, FN must be the decl for
1414 lto_read_body (struct lto_file_decl_data *file_data, tree fn_decl,
1415 const char *data, enum lto_section_type section_type)
1417 const struct lto_function_header *header;
1418 struct data_in *data_in;
1420 int32_t main_offset;
1421 int32_t string_offset;
1422 struct lto_input_block ib_cfg;
1423 struct lto_input_block ib_main;
1425 header = (const struct lto_function_header *) data;
1426 cfg_offset = sizeof (struct lto_function_header);
1427 main_offset = cfg_offset + header->cfg_size;
1428 string_offset = main_offset + header->main_size;
1430 LTO_INIT_INPUT_BLOCK (ib_cfg,
1435 LTO_INIT_INPUT_BLOCK (ib_main,
1440 data_in = lto_data_in_create (file_data, data + string_offset,
1441 header->string_size, NULL);
1443 /* Make sure the file was generated by the exact same compiler. */
1444 lto_check_version (header->lto_header.major_version,
1445 header->lto_header.minor_version);
1447 if (section_type == LTO_section_function_body)
1449 struct function *fn = DECL_STRUCT_FUNCTION (fn_decl);
1450 struct lto_in_decl_state *decl_state;
1455 /* Use the function's decl state. */
1456 decl_state = lto_get_function_in_decl_state (file_data, fn_decl);
1457 gcc_assert (decl_state);
1458 file_data->current_decl_state = decl_state;
1460 input_cfg (&ib_cfg, fn);
1462 /* Set up the struct function. */
1463 input_function (fn_decl, data_in, &ib_main);
1465 /* We should now be in SSA. */
1466 cfun->gimple_df->in_ssa_p = true;
1468 /* Fill in properties we know hold for the rebuilt CFG. */
1469 cfun->curr_properties = PROP_ssa
1474 | PROP_referenced_vars;
1476 /* Restore decl state */
1477 file_data->current_decl_state = file_data->global_decl_state;
1479 /* FIXME: ipa_transforms_to_apply holds list of passes that have optimization
1480 summaries computed and needs to apply changes. At the moment WHOPR only
1481 supports inlining, so we can push it here by hand. In future we need to stream
1482 this field into ltrans compilation. This will also need to move the field
1483 from struct function into cgraph node where it belongs. */
1484 if (flag_ltrans && !cgraph_node (fn_decl)->global.inlined_to)
1485 VEC_safe_push (ipa_opt_pass, heap,
1486 cfun->ipa_transforms_to_apply,
1487 (ipa_opt_pass)&pass_ipa_inline);
1492 input_alias_pairs (&ib_main, data_in);
1495 clear_line_info (data_in);
1496 lto_data_in_delete (data_in);
1500 /* Read the body of FN_DECL using DATA. FILE_DATA holds the global
1504 lto_input_function_body (struct lto_file_decl_data *file_data,
1505 tree fn_decl, const char *data)
1507 current_function_decl = fn_decl;
1508 lto_read_body (file_data, fn_decl, data, LTO_section_function_body);
1512 /* Read in VAR_DECL using DATA. FILE_DATA holds the global decls and
1516 lto_input_constructors_and_inits (struct lto_file_decl_data *file_data,
1519 lto_read_body (file_data, NULL, data, LTO_section_static_initializer);
1523 /* Return the resolution for the decl with index INDEX from DATA_IN. */
1525 static enum ld_plugin_symbol_resolution
1526 get_resolution (struct data_in *data_in, unsigned index)
1528 if (data_in->globals_resolution)
1530 ld_plugin_symbol_resolution_t ret;
1531 gcc_assert (index < VEC_length (ld_plugin_symbol_resolution_t,
1532 data_in->globals_resolution));
1533 ret = VEC_index (ld_plugin_symbol_resolution_t,
1534 data_in->globals_resolution,
1536 gcc_assert (ret != LDPR_UNKNOWN);
1540 /* Delay resolution finding until decl merging. */
1541 return LDPR_UNKNOWN;
1545 /* Unpack all the non-pointer fields of the TS_BASE structure of
1546 expression EXPR from bitpack BP. */
1549 unpack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
1551 /* Note that the code for EXPR has already been unpacked to create EXPR in
1552 lto_materialize_tree. */
1555 TREE_SIDE_EFFECTS (expr) = (unsigned) bp_unpack_value (bp, 1);
1556 TREE_CONSTANT (expr) = (unsigned) bp_unpack_value (bp, 1);
1557 TREE_READONLY (expr) = (unsigned) bp_unpack_value (bp, 1);
1559 /* TREE_PUBLIC is used on types to indicate that the type
1560 has a TYPE_CACHED_VALUES vector. This is not streamed out,
1561 so we skip it here. */
1562 TREE_PUBLIC (expr) = (unsigned) bp_unpack_value (bp, 1);
1564 TREE_ADDRESSABLE (expr) = (unsigned) bp_unpack_value (bp, 1);
1565 TREE_THIS_VOLATILE (expr) = (unsigned) bp_unpack_value (bp, 1);
1567 DECL_UNSIGNED (expr) = (unsigned) bp_unpack_value (bp, 1);
1568 else if (TYPE_P (expr))
1569 TYPE_UNSIGNED (expr) = (unsigned) bp_unpack_value (bp, 1);
1570 TREE_ASM_WRITTEN (expr) = (unsigned) bp_unpack_value (bp, 1);
1571 TREE_NO_WARNING (expr) = (unsigned) bp_unpack_value (bp, 1);
1572 TREE_USED (expr) = (unsigned) bp_unpack_value (bp, 1);
1573 TREE_NOTHROW (expr) = (unsigned) bp_unpack_value (bp, 1);
1574 TREE_STATIC (expr) = (unsigned) bp_unpack_value (bp, 1);
1575 TREE_PRIVATE (expr) = (unsigned) bp_unpack_value (bp, 1);
1576 TREE_PROTECTED (expr) = (unsigned) bp_unpack_value (bp, 1);
1577 TREE_DEPRECATED (expr) = (unsigned) bp_unpack_value (bp, 1);
1579 TYPE_SATURATING (expr) = (unsigned) bp_unpack_value (bp, 1);
1580 if (TREE_CODE (expr) == SSA_NAME)
1581 SSA_NAME_IS_DEFAULT_DEF (expr) = (unsigned) bp_unpack_value (bp, 1);
1585 /* Unpack all the non-pointer fields of the TS_REAL_CST structure of
1586 expression EXPR from bitpack BP. */
1589 unpack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
1593 REAL_VALUE_TYPE *rp;
1595 r.cl = (unsigned) bp_unpack_value (bp, 2);
1596 r.decimal = (unsigned) bp_unpack_value (bp, 1);
1597 r.sign = (unsigned) bp_unpack_value (bp, 1);
1598 r.signalling = (unsigned) bp_unpack_value (bp, 1);
1599 r.canonical = (unsigned) bp_unpack_value (bp, 1);
1600 r.uexp = (unsigned) bp_unpack_value (bp, EXP_BITS);
1601 for (i = 0; i < SIGSZ; i++)
1602 r.sig[i] = (unsigned long) bp_unpack_value (bp, HOST_BITS_PER_LONG);
1604 rp = GGC_NEW (REAL_VALUE_TYPE);
1605 memcpy (rp, &r, sizeof (REAL_VALUE_TYPE));
1606 TREE_REAL_CST_PTR (expr) = rp;
1610 /* Unpack all the non-pointer fields of the TS_FIXED_CST structure of
1611 expression EXPR from bitpack BP. */
1614 unpack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr)
1616 struct fixed_value fv;
1618 fv.data.low = (HOST_WIDE_INT) bp_unpack_value (bp, HOST_BITS_PER_WIDE_INT);
1619 fv.data.high = (HOST_WIDE_INT) bp_unpack_value (bp, HOST_BITS_PER_WIDE_INT);
1620 TREE_FIXED_CST (expr) = fv;
1624 /* Unpack all the non-pointer fields of the TS_DECL_COMMON structure
1625 of expression EXPR from bitpack BP. */
1628 unpack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr)
1630 DECL_MODE (expr) = (enum machine_mode) bp_unpack_value (bp, 8);
1631 DECL_NONLOCAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1632 DECL_VIRTUAL_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1633 DECL_IGNORED_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1634 DECL_ABSTRACT (expr) = (unsigned) bp_unpack_value (bp, 1);
1635 DECL_ARTIFICIAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1636 DECL_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1);
1637 DECL_PRESERVE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1638 DECL_DEBUG_EXPR_IS_FROM (expr) = (unsigned) bp_unpack_value (bp, 1);
1639 DECL_EXTERNAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1640 DECL_GIMPLE_REG_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1641 DECL_ALIGN (expr) = (unsigned) bp_unpack_value (bp, HOST_BITS_PER_INT);
1643 if (TREE_CODE (expr) == LABEL_DECL)
1645 DECL_ERROR_ISSUED (expr) = (unsigned) bp_unpack_value (bp, 1);
1646 EH_LANDING_PAD_NR (expr) = (int) bp_unpack_value (bp, HOST_BITS_PER_INT);
1648 /* Always assume an initial value of -1 for LABEL_DECL_UID to
1649 force gimple_set_bb to recreate label_to_block_map. */
1650 LABEL_DECL_UID (expr) = -1;
1653 if (TREE_CODE (expr) == FIELD_DECL)
1655 unsigned HOST_WIDE_INT off_align;
1656 DECL_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
1657 DECL_NONADDRESSABLE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1658 off_align = (unsigned HOST_WIDE_INT) bp_unpack_value (bp, 8);
1659 SET_DECL_OFFSET_ALIGN (expr, off_align);
1662 if (TREE_CODE (expr) == RESULT_DECL
1663 || TREE_CODE (expr) == PARM_DECL
1664 || TREE_CODE (expr) == VAR_DECL)
1666 DECL_BY_REFERENCE (expr) = (unsigned) bp_unpack_value (bp, 1);
1667 if (TREE_CODE (expr) == VAR_DECL
1668 || TREE_CODE (expr) == PARM_DECL)
1669 DECL_HAS_VALUE_EXPR_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1670 DECL_RESTRICTED_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1675 /* Unpack all the non-pointer fields of the TS_DECL_WRTL structure
1676 of expression EXPR from bitpack BP. */
1679 unpack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
1681 DECL_REGISTER (expr) = (unsigned) bp_unpack_value (bp, 1);
1685 /* Unpack all the non-pointer fields of the TS_DECL_WITH_VIS structure
1686 of expression EXPR from bitpack BP. */
1689 unpack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
1691 DECL_DEFER_OUTPUT (expr) = (unsigned) bp_unpack_value (bp, 1);
1692 DECL_COMMON (expr) = (unsigned) bp_unpack_value (bp, 1);
1693 DECL_DLLIMPORT_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1694 DECL_WEAK (expr) = (unsigned) bp_unpack_value (bp, 1);
1695 DECL_SEEN_IN_BIND_EXPR_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1696 DECL_COMDAT (expr) = (unsigned) bp_unpack_value (bp, 1);
1697 DECL_VISIBILITY (expr) = (enum symbol_visibility) bp_unpack_value (bp, 2);
1698 DECL_VISIBILITY_SPECIFIED (expr) = (unsigned) bp_unpack_value (bp, 1);
1700 if (TREE_CODE (expr) == VAR_DECL)
1702 DECL_HARD_REGISTER (expr) = (unsigned) bp_unpack_value (bp, 1);
1703 DECL_IN_TEXT_SECTION (expr) = (unsigned) bp_unpack_value (bp, 1);
1704 DECL_TLS_MODEL (expr) = (enum tls_model) bp_unpack_value (bp, 3);
1707 if (VAR_OR_FUNCTION_DECL_P (expr))
1710 p = (priority_type) bp_unpack_value (bp, HOST_BITS_PER_SHORT);
1711 SET_DECL_INIT_PRIORITY (expr, p);
1716 /* Unpack all the non-pointer fields of the TS_FUNCTION_DECL structure
1717 of expression EXPR from bitpack BP. */
1720 unpack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
1722 DECL_FUNCTION_CODE (expr) = (enum built_in_function) bp_unpack_value (bp, 11);
1723 DECL_BUILT_IN_CLASS (expr) = (enum built_in_class) bp_unpack_value (bp, 2);
1724 DECL_STATIC_CONSTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
1725 DECL_STATIC_DESTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
1726 DECL_UNINLINABLE (expr) = (unsigned) bp_unpack_value (bp, 1);
1727 DECL_POSSIBLY_INLINED (expr) = (unsigned) bp_unpack_value (bp, 1);
1728 DECL_IS_NOVOPS (expr) = (unsigned) bp_unpack_value (bp, 1);
1729 DECL_IS_RETURNS_TWICE (expr) = (unsigned) bp_unpack_value (bp, 1);
1730 DECL_IS_MALLOC (expr) = (unsigned) bp_unpack_value (bp, 1);
1731 DECL_IS_OPERATOR_NEW (expr) = (unsigned) bp_unpack_value (bp, 1);
1732 DECL_DECLARED_INLINE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1733 DECL_STATIC_CHAIN (expr) = (unsigned) bp_unpack_value (bp, 1);
1734 DECL_NO_INLINE_WARNING_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1735 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr)
1736 = (unsigned) bp_unpack_value (bp, 1);
1737 DECL_NO_LIMIT_STACK (expr) = (unsigned) bp_unpack_value (bp, 1);
1738 DECL_DISREGARD_INLINE_LIMITS (expr) = (unsigned) bp_unpack_value (bp, 1);
1739 DECL_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1740 DECL_LOOPING_CONST_OR_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1744 /* Unpack all the non-pointer fields of the TS_TYPE structure
1745 of expression EXPR from bitpack BP. */
1748 unpack_ts_type_value_fields (struct bitpack_d *bp, tree expr)
1750 enum machine_mode mode;
1752 TYPE_PRECISION (expr) = (unsigned) bp_unpack_value (bp, 9);
1753 mode = (enum machine_mode) bp_unpack_value (bp, 7);
1754 SET_TYPE_MODE (expr, mode);
1755 TYPE_STRING_FLAG (expr) = (unsigned) bp_unpack_value (bp, 1);
1756 TYPE_NO_FORCE_BLK (expr) = (unsigned) bp_unpack_value (bp, 1);
1757 TYPE_NEEDS_CONSTRUCTING(expr) = (unsigned) bp_unpack_value (bp, 1);
1758 if (TREE_CODE (expr) == UNION_TYPE)
1759 TYPE_TRANSPARENT_UNION (expr) = (unsigned) bp_unpack_value (bp, 1);
1760 TYPE_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
1761 TYPE_RESTRICT (expr) = (unsigned) bp_unpack_value (bp, 1);
1762 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr)
1763 = (unsigned) bp_unpack_value (bp, 2);
1764 TYPE_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1);
1765 TYPE_READONLY (expr) = (unsigned) bp_unpack_value (bp, 1);
1766 TYPE_ALIGN (expr) = (unsigned) bp_unpack_value (bp, HOST_BITS_PER_INT);
1767 TYPE_ALIAS_SET (expr) = bp_unpack_value (bp, HOST_BITS_PER_INT);
1771 /* Unpack all the non-pointer fields of the TS_BLOCK structure
1772 of expression EXPR from bitpack BP. */
1775 unpack_ts_block_value_fields (struct bitpack_d *bp, tree expr)
1777 BLOCK_ABSTRACT (expr) = (unsigned) bp_unpack_value (bp, 1);
1778 BLOCK_NUMBER (expr) = (unsigned) bp_unpack_value (bp, 31);
1782 /* Unpack all the non-pointer fields in EXPR into a bit pack. */
1785 unpack_value_fields (struct bitpack_d *bp, tree expr)
1787 enum tree_code code;
1789 code = TREE_CODE (expr);
1791 /* Note that all these functions are highly sensitive to changes in
1792 the types and sizes of each of the fields being packed. */
1793 unpack_ts_base_value_fields (bp, expr);
1795 if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
1796 unpack_ts_real_cst_value_fields (bp, expr);
1798 if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
1799 unpack_ts_fixed_cst_value_fields (bp, expr);
1801 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
1802 unpack_ts_decl_common_value_fields (bp, expr);
1804 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
1805 unpack_ts_decl_wrtl_value_fields (bp, expr);
1807 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
1808 unpack_ts_decl_with_vis_value_fields (bp, expr);
1810 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
1811 unpack_ts_function_decl_value_fields (bp, expr);
1813 if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
1814 unpack_ts_type_value_fields (bp, expr);
1816 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
1817 unpack_ts_block_value_fields (bp, expr);
1819 if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
1821 /* We only stream the version number of SSA names. */
1825 if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
1827 /* This is only used by GENERIC. */
1831 if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
1833 /* This is only used by High GIMPLE. */
1839 /* Read a bitpack from input block IB. */
1842 lto_input_bitpack (struct lto_input_block *ib)
1844 unsigned i, num_words;
1845 struct bitpack_d *bp;
1847 bp = bitpack_create ();
1849 /* If we are about to read more than a handful of words, something
1850 is wrong. This check is overly strict, but it acts as an early
1851 warning. No streamed object has hundreds of bits in its fields. */
1852 num_words = lto_input_uleb128 (ib);
1853 gcc_assert (num_words < 20);
1855 for (i = 0; i < num_words; i++)
1857 bitpack_word_t w = lto_input_uleb128 (ib);
1858 VEC_safe_push (bitpack_word_t, heap, bp->values, w);
1865 /* Materialize a new tree from input block IB using descriptors in
1866 DATA_IN. The code for the new tree should match TAG. Store in
1867 *IX_P the index into the reader cache where the new tree is stored. */
1870 lto_materialize_tree (struct lto_input_block *ib, struct data_in *data_in,
1871 enum LTO_tags tag, int *ix_p)
1873 struct bitpack_d *bp;
1874 enum tree_code code;
1876 #ifdef LTO_STREAMER_DEBUG
1877 HOST_WIDEST_INT orig_address_in_writer;
1883 /* Read the header of the node we are about to create. */
1884 ix = lto_input_sleb128 (ib);
1885 gcc_assert ((int) ix == ix);
1888 #ifdef LTO_STREAMER_DEBUG
1889 /* Read the word representing the memory address for the tree
1890 as it was written by the writer. This is useful when
1891 debugging differences between the writer and reader. */
1892 orig_address_in_writer = lto_input_sleb128 (ib);
1893 gcc_assert ((intptr_t) orig_address_in_writer == orig_address_in_writer);
1896 code = lto_tag_to_tree_code (tag);
1898 /* We should never see an SSA_NAME tree. Only the version numbers of
1899 SSA names are ever written out. See input_ssa_names. */
1900 gcc_assert (code != SSA_NAME);
1902 /* Instantiate a new tree using the header data. */
1903 if (CODE_CONTAINS_STRUCT (code, TS_STRING))
1904 result = input_string_cst (data_in, ib);
1905 else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
1906 result = input_identifier (data_in, ib);
1907 else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1909 HOST_WIDE_INT len = lto_input_sleb128 (ib);
1910 result = make_tree_vec (len);
1912 else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1914 unsigned HOST_WIDE_INT len = lto_input_uleb128 (ib);
1915 result = make_tree_binfo (len);
1919 /* All other nodes can be materialized with a raw make_node
1921 result = make_node (code);
1924 #ifdef LTO_STREAMER_DEBUG
1925 /* Store the original address of the tree as seen by the writer
1926 in RESULT's aux field. This is useful when debugging streaming
1927 problems. This way, a debugging session can be started on
1928 both writer and reader with a breakpoint using this address
1930 lto_orig_address_map (result, (intptr_t) orig_address_in_writer);
1933 /* Read the bitpack of non-pointer values from IB. */
1934 bp = lto_input_bitpack (ib);
1936 /* The first word in BP contains the code of the tree that we
1937 are about to read. */
1938 code = (enum tree_code) bp_unpack_value (bp, 16);
1939 lto_tag_check (lto_tree_code_to_tag (code), tag);
1941 /* Unpack all the value fields from BP. */
1942 unpack_value_fields (bp, result);
1943 bitpack_delete (bp);
1945 /* Enter RESULT in the reader cache. This will make RESULT
1946 available so that circular references in the rest of the tree
1947 structure can be resolved in subsequent calls to lto_input_tree. */
1948 lto_streamer_cache_insert_at (data_in->reader_cache, result, ix);
1954 /* Read a chain of tree nodes from input block IB. DATA_IN contains
1955 tables and descriptors for the file being read. */
1958 lto_input_chain (struct lto_input_block *ib, struct data_in *data_in)
1961 tree first, prev, curr;
1963 first = prev = NULL_TREE;
1964 count = lto_input_sleb128 (ib);
1965 for (i = 0; i < count; i++)
1967 curr = lto_input_tree (ib, data_in);
1969 TREE_CHAIN (prev) = curr;
1973 TREE_CHAIN (curr) = NULL_TREE;
1981 /* Read all pointer fields in the TS_COMMON structure of EXPR from input
1982 block IB. DATA_IN contains tables and descriptors for the
1987 lto_input_ts_common_tree_pointers (struct lto_input_block *ib,
1988 struct data_in *data_in, tree expr)
1990 TREE_TYPE (expr) = lto_input_tree (ib, data_in);
1994 /* Read all pointer fields in the TS_VECTOR structure of EXPR from input
1995 block IB. DATA_IN contains tables and descriptors for the
1999 lto_input_ts_vector_tree_pointers (struct lto_input_block *ib,
2000 struct data_in *data_in, tree expr)
2002 TREE_VECTOR_CST_ELTS (expr) = lto_input_chain (ib, data_in);
2006 /* Read all pointer fields in the TS_COMPLEX structure of EXPR from input
2007 block IB. DATA_IN contains tables and descriptors for the
2011 lto_input_ts_complex_tree_pointers (struct lto_input_block *ib,
2012 struct data_in *data_in, tree expr)
2014 TREE_REALPART (expr) = lto_input_tree (ib, data_in);
2015 TREE_IMAGPART (expr) = lto_input_tree (ib, data_in);
2019 /* Read all pointer fields in the TS_DECL_MINIMAL structure of EXPR
2020 from input block IB. DATA_IN contains tables and descriptors for the
2024 lto_input_ts_decl_minimal_tree_pointers (struct lto_input_block *ib,
2025 struct data_in *data_in, tree expr)
2027 DECL_NAME (expr) = lto_input_tree (ib, data_in);
2028 DECL_CONTEXT (expr) = lto_input_tree (ib, data_in);
2029 DECL_SOURCE_LOCATION (expr) = lto_input_location (ib, data_in);
2033 /* Read all pointer fields in the TS_DECL_COMMON structure of EXPR from
2034 input block IB. DATA_IN contains tables and descriptors for the
2038 lto_input_ts_decl_common_tree_pointers (struct lto_input_block *ib,
2039 struct data_in *data_in, tree expr)
2041 DECL_SIZE (expr) = lto_input_tree (ib, data_in);
2042 DECL_SIZE_UNIT (expr) = lto_input_tree (ib, data_in);
2044 if (TREE_CODE (expr) != FUNCTION_DECL)
2045 DECL_INITIAL (expr) = lto_input_tree (ib, data_in);
2047 DECL_ATTRIBUTES (expr) = lto_input_tree (ib, data_in);
2048 DECL_ABSTRACT_ORIGIN (expr) = lto_input_tree (ib, data_in);
2050 if (TREE_CODE (expr) == PARM_DECL)
2051 TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
2055 /* Read all pointer fields in the TS_DECL_NON_COMMON structure of
2056 EXPR from input block IB. DATA_IN contains tables and descriptors for the
2060 lto_input_ts_decl_non_common_tree_pointers (struct lto_input_block *ib,
2061 struct data_in *data_in, tree expr)
2063 if (TREE_CODE (expr) == FUNCTION_DECL)
2065 DECL_ARGUMENTS (expr) = lto_input_tree (ib, data_in);
2066 DECL_RESULT (expr) = lto_input_tree (ib, data_in);
2068 DECL_VINDEX (expr) = lto_input_tree (ib, data_in);
2072 /* Read all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
2073 from input block IB. DATA_IN contains tables and descriptors for the
2077 lto_input_ts_decl_with_vis_tree_pointers (struct lto_input_block *ib,
2078 struct data_in *data_in, tree expr)
2082 id = lto_input_tree (ib, data_in);
2085 gcc_assert (TREE_CODE (id) == IDENTIFIER_NODE);
2086 SET_DECL_ASSEMBLER_NAME (expr, id);
2089 DECL_SECTION_NAME (expr) = lto_input_tree (ib, data_in);
2090 DECL_COMDAT_GROUP (expr) = lto_input_tree (ib, data_in);
2094 /* Read all pointer fields in the TS_FIELD_DECL structure of EXPR from
2095 input block IB. DATA_IN contains tables and descriptors for the
2099 lto_input_ts_field_decl_tree_pointers (struct lto_input_block *ib,
2100 struct data_in *data_in, tree expr)
2102 DECL_FIELD_OFFSET (expr) = lto_input_tree (ib, data_in);
2103 DECL_BIT_FIELD_TYPE (expr) = lto_input_tree (ib, data_in);
2104 DECL_QUALIFIER (expr) = lto_input_tree (ib, data_in);
2105 DECL_FIELD_BIT_OFFSET (expr) = lto_input_tree (ib, data_in);
2106 DECL_FCONTEXT (expr) = lto_input_tree (ib, data_in);
2107 TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
2111 /* Read all pointer fields in the TS_FUNCTION_DECL structure of EXPR
2112 from input block IB. DATA_IN contains tables and descriptors for the
2116 lto_input_ts_function_decl_tree_pointers (struct lto_input_block *ib,
2117 struct data_in *data_in, tree expr)
2119 /* DECL_STRUCT_FUNCTION is handled by lto_input_function. FIXME lto,
2120 maybe it should be handled here? */
2121 DECL_FUNCTION_PERSONALITY (expr) = lto_input_tree (ib, data_in);
2122 DECL_FUNCTION_SPECIFIC_TARGET (expr) = lto_input_tree (ib, data_in);
2123 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr) = lto_input_tree (ib, data_in);
2127 /* Read all pointer fields in the TS_TYPE structure of EXPR from input
2128 block IB. DATA_IN contains tables and descriptors for the
2132 lto_input_ts_type_tree_pointers (struct lto_input_block *ib,
2133 struct data_in *data_in, tree expr)
2135 if (TREE_CODE (expr) == ENUMERAL_TYPE)
2136 TYPE_VALUES (expr) = lto_input_tree (ib, data_in);
2137 else if (TREE_CODE (expr) == ARRAY_TYPE)
2138 TYPE_DOMAIN (expr) = lto_input_tree (ib, data_in);
2139 else if (TREE_CODE (expr) == RECORD_TYPE || TREE_CODE (expr) == UNION_TYPE)
2140 TYPE_FIELDS (expr) = lto_input_tree (ib, data_in);
2141 else if (TREE_CODE (expr) == FUNCTION_TYPE || TREE_CODE (expr) == METHOD_TYPE)
2142 TYPE_ARG_TYPES (expr) = lto_input_tree (ib, data_in);
2143 else if (TREE_CODE (expr) == VECTOR_TYPE)
2144 TYPE_DEBUG_REPRESENTATION_TYPE (expr) = lto_input_tree (ib, data_in);
2146 TYPE_SIZE (expr) = lto_input_tree (ib, data_in);
2147 TYPE_SIZE_UNIT (expr) = lto_input_tree (ib, data_in);
2148 TYPE_ATTRIBUTES (expr) = lto_input_tree (ib, data_in);
2149 TYPE_NAME (expr) = lto_input_tree (ib, data_in);
2150 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO nor
2151 TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. */
2152 if (!POINTER_TYPE_P (expr))
2153 TYPE_MINVAL (expr) = lto_input_tree (ib, data_in);
2154 TYPE_MAXVAL (expr) = lto_input_tree (ib, data_in);
2155 TYPE_MAIN_VARIANT (expr) = lto_input_tree (ib, data_in);
2156 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
2158 if (RECORD_OR_UNION_TYPE_P (expr))
2159 TYPE_BINFO (expr) = lto_input_tree (ib, data_in);
2160 TYPE_CONTEXT (expr) = lto_input_tree (ib, data_in);
2161 TYPE_CANONICAL (expr) = lto_input_tree (ib, data_in);
2165 /* Read all pointer fields in the TS_LIST structure of EXPR from input
2166 block IB. DATA_IN contains tables and descriptors for the
2170 lto_input_ts_list_tree_pointers (struct lto_input_block *ib,
2171 struct data_in *data_in, tree expr)
2173 TREE_PURPOSE (expr) = lto_input_tree (ib, data_in);
2174 TREE_VALUE (expr) = lto_input_tree (ib, data_in);
2175 TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
2179 /* Read all pointer fields in the TS_VEC structure of EXPR from input
2180 block IB. DATA_IN contains tables and descriptors for the
2184 lto_input_ts_vec_tree_pointers (struct lto_input_block *ib,
2185 struct data_in *data_in, tree expr)
2189 /* Note that TREE_VEC_LENGTH was read by lto_materialize_tree to
2190 instantiate EXPR. */
2191 for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
2192 TREE_VEC_ELT (expr, i) = lto_input_tree (ib, data_in);
2196 /* Read all pointer fields in the TS_EXP structure of EXPR from input
2197 block IB. DATA_IN contains tables and descriptors for the
2202 lto_input_ts_exp_tree_pointers (struct lto_input_block *ib,
2203 struct data_in *data_in, tree expr)
2208 length = lto_input_sleb128 (ib);
2209 gcc_assert (length == TREE_OPERAND_LENGTH (expr));
2211 for (i = 0; i < length; i++)
2212 TREE_OPERAND (expr, i) = lto_input_tree (ib, data_in);
2214 loc = lto_input_location (ib, data_in);
2215 SET_EXPR_LOCATION (expr, loc);
2216 TREE_BLOCK (expr) = lto_input_tree (ib, data_in);
2220 /* Read all pointer fields in the TS_BLOCK structure of EXPR from input
2221 block IB. DATA_IN contains tables and descriptors for the
2225 lto_input_ts_block_tree_pointers (struct lto_input_block *ib,
2226 struct data_in *data_in, tree expr)
2230 BLOCK_SOURCE_LOCATION (expr) = lto_input_location (ib, data_in);
2231 BLOCK_VARS (expr) = lto_input_chain (ib, data_in);
2233 len = lto_input_uleb128 (ib);
2234 for (i = 0; i < len; i++)
2236 tree t = lto_input_tree (ib, data_in);
2237 VEC_safe_push (tree, gc, BLOCK_NONLOCALIZED_VARS (expr), t);
2240 BLOCK_SUPERCONTEXT (expr) = lto_input_tree (ib, data_in);
2241 BLOCK_ABSTRACT_ORIGIN (expr) = lto_input_tree (ib, data_in);
2242 BLOCK_FRAGMENT_ORIGIN (expr) = lto_input_tree (ib, data_in);
2243 BLOCK_FRAGMENT_CHAIN (expr) = lto_input_tree (ib, data_in);
2244 BLOCK_SUBBLOCKS (expr) = lto_input_chain (ib, data_in);
2248 /* Read all pointer fields in the TS_BINFO structure of EXPR from input
2249 block IB. DATA_IN contains tables and descriptors for the
2253 lto_input_ts_binfo_tree_pointers (struct lto_input_block *ib,
2254 struct data_in *data_in, tree expr)
2259 /* Note that the number of slots in EXPR was read in
2260 lto_materialize_tree when instantiating EXPR. However, the
2261 vector is empty so we cannot rely on VEC_length to know how many
2262 elements to read. So, this list is emitted as a 0-terminated
2263 list on the writer side. */
2266 t = lto_input_tree (ib, data_in);
2268 VEC_quick_push (tree, BINFO_BASE_BINFOS (expr), t);
2272 BINFO_OFFSET (expr) = lto_input_tree (ib, data_in);
2273 BINFO_VTABLE (expr) = lto_input_tree (ib, data_in);
2274 BINFO_VIRTUALS (expr) = lto_input_tree (ib, data_in);
2275 BINFO_VPTR_FIELD (expr) = lto_input_tree (ib, data_in);
2277 len = lto_input_uleb128 (ib);
2278 for (i = 0; i < len; i++)
2280 tree a = lto_input_tree (ib, data_in);
2281 VEC_safe_push (tree, gc, BINFO_BASE_ACCESSES (expr), a);
2284 BINFO_INHERITANCE_CHAIN (expr) = lto_input_tree (ib, data_in);
2285 BINFO_SUBVTT_INDEX (expr) = lto_input_tree (ib, data_in);
2286 BINFO_VPTR_INDEX (expr) = lto_input_tree (ib, data_in);
2290 /* Read all pointer fields in the TS_CONSTRUCTOR structure of EXPR from
2291 input block IB. DATA_IN contains tables and descriptors for the
2295 lto_input_ts_constructor_tree_pointers (struct lto_input_block *ib,
2296 struct data_in *data_in, tree expr)
2300 len = lto_input_uleb128 (ib);
2301 for (i = 0; i < len; i++)
2305 index = lto_input_tree (ib, data_in);
2306 value = lto_input_tree (ib, data_in);
2307 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (expr), index, value);
2312 /* Helper for lto_input_tree. Read all pointer fields in EXPR from
2313 input block IB. DATA_IN contains tables and descriptors for the
2317 lto_input_tree_pointers (struct lto_input_block *ib, struct data_in *data_in,
2320 enum tree_code code;
2322 code = TREE_CODE (expr);
2324 if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
2325 lto_input_ts_common_tree_pointers (ib, data_in, expr);
2327 if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
2328 lto_input_ts_vector_tree_pointers (ib, data_in, expr);
2330 if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
2331 lto_input_ts_complex_tree_pointers (ib, data_in, expr);
2333 if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
2334 lto_input_ts_decl_minimal_tree_pointers (ib, data_in, expr);
2336 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
2337 lto_input_ts_decl_common_tree_pointers (ib, data_in, expr);
2339 if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
2340 lto_input_ts_decl_non_common_tree_pointers (ib, data_in, expr);
2342 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
2343 lto_input_ts_decl_with_vis_tree_pointers (ib, data_in, expr);
2345 if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
2346 lto_input_ts_field_decl_tree_pointers (ib, data_in, expr);
2348 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
2349 lto_input_ts_function_decl_tree_pointers (ib, data_in, expr);
2351 if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
2352 lto_input_ts_type_tree_pointers (ib, data_in, expr);
2354 if (CODE_CONTAINS_STRUCT (code, TS_LIST))
2355 lto_input_ts_list_tree_pointers (ib, data_in, expr);
2357 if (CODE_CONTAINS_STRUCT (code, TS_VEC))
2358 lto_input_ts_vec_tree_pointers (ib, data_in, expr);
2360 if (CODE_CONTAINS_STRUCT (code, TS_EXP))
2361 lto_input_ts_exp_tree_pointers (ib, data_in, expr);
2363 if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
2365 /* We only stream the version number of SSA names. */
2369 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
2370 lto_input_ts_block_tree_pointers (ib, data_in, expr);
2372 if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
2373 lto_input_ts_binfo_tree_pointers (ib, data_in, expr);
2375 if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
2377 /* This should only appear in GENERIC. */
2381 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
2382 lto_input_ts_constructor_tree_pointers (ib, data_in, expr);
2384 if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
2386 /* This should only appear in High GIMPLE. */
2390 if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
2392 sorry ("optimization options not supported yet");
2395 if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
2397 sorry ("target optimization options not supported yet");
2402 /* Register DECL with the global symbol table and change its
2403 name if necessary to avoid name clashes for static globals across
2407 lto_register_var_decl_in_symtab (struct data_in *data_in, tree decl)
2409 /* Register symbols with file or global scope to mark what input
2410 file has their definition. */
2411 if (decl_function_context (decl) == NULL_TREE)
2413 /* Variable has file scope, not local. Need to ensure static variables
2414 between different files don't clash unexpectedly. */
2415 if (!TREE_PUBLIC (decl))
2417 /* ??? We normally pre-mangle names before we serialize them
2418 out. Here, in lto1, we do not know the language, and
2419 thus cannot do the mangling again. Instead, we just
2420 append a suffix to the mangled name. The resulting name,
2421 however, is not a properly-formed mangled name, and will
2422 confuse any attempt to unmangle it. */
2423 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2426 ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
2427 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
2428 rest_of_decl_compilation (decl, 1, 0);
2432 /* If this variable has already been declared, queue the
2433 declaration for merging. */
2434 if (TREE_PUBLIC (decl))
2437 if (!lto_streamer_cache_lookup (data_in->reader_cache, decl, &ix))
2439 lto_symtab_register_decl (decl, get_resolution (data_in, ix),
2440 data_in->file_data);
2446 /* Register DECL with the global symbol table and change its
2447 name if necessary to avoid name clashes for static globals across
2448 different files. DATA_IN contains descriptors and tables for the
2452 lto_register_function_decl_in_symtab (struct data_in *data_in, tree decl)
2454 /* Need to ensure static entities between different files
2455 don't clash unexpectedly. */
2456 if (!TREE_PUBLIC (decl))
2458 /* We must not use the DECL_ASSEMBLER_NAME macro here, as it
2459 may set the assembler name where it was previously empty. */
2460 tree old_assembler_name = decl->decl_with_vis.assembler_name;
2462 /* FIXME lto: We normally pre-mangle names before we serialize
2463 them out. Here, in lto1, we do not know the language, and
2464 thus cannot do the mangling again. Instead, we just append a
2465 suffix to the mangled name. The resulting name, however, is
2466 not a properly-formed mangled name, and will confuse any
2467 attempt to unmangle it. */
2468 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2471 ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
2472 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
2474 /* We may arrive here with the old assembler name not set
2475 if the function body is not needed, e.g., it has been
2476 inlined away and does not appear in the cgraph. */
2477 if (old_assembler_name)
2479 tree new_assembler_name = DECL_ASSEMBLER_NAME (decl);
2481 /* Make the original assembler name available for later use.
2482 We may have used it to indicate the section within its
2483 object file where the function body may be found.
2484 FIXME lto: Find a better way to maintain the function decl
2485 to body section mapping so we don't need this hack. */
2486 lto_record_renamed_decl (data_in->file_data,
2487 IDENTIFIER_POINTER (old_assembler_name),
2488 IDENTIFIER_POINTER (new_assembler_name));
2490 /* Also register the reverse mapping so that we can find the
2491 new name given to an existing assembler name (used when
2492 restoring alias pairs in input_constructors_or_inits. */
2493 lto_record_renamed_decl (data_in->file_data,
2494 IDENTIFIER_POINTER (new_assembler_name),
2495 IDENTIFIER_POINTER (old_assembler_name));
2499 /* If this variable has already been declared, queue the
2500 declaration for merging. */
2501 if (TREE_PUBLIC (decl) && !DECL_ABSTRACT (decl))
2504 if (!lto_streamer_cache_lookup (data_in->reader_cache, decl, &ix))
2506 lto_symtab_register_decl (decl, get_resolution (data_in, ix),
2507 data_in->file_data);
2512 /* Read an index IX from input block IB and return the tree node at
2513 DATA_IN->FILE_DATA->GLOBALS_INDEX[IX]. */
2516 lto_get_pickled_tree (struct lto_input_block *ib, struct data_in *data_in)
2520 enum LTO_tags expected_tag;
2521 unsigned HOST_WIDE_INT orig_offset;
2523 ix = lto_input_sleb128 (ib);
2524 expected_tag = (enum LTO_tags) lto_input_uleb128 (ib);
2526 orig_offset = lto_input_uleb128 (ib);
2527 gcc_assert (orig_offset == (unsigned) orig_offset);
2529 result = lto_streamer_cache_get (data_in->reader_cache, ix);
2530 if (result == NULL_TREE)
2532 /* We have not yet read the cache slot IX. Go to the offset
2533 in the stream where the physical tree node is, and materialize
2535 struct lto_input_block fwd_ib;
2537 /* If we are trying to go back in the stream, something is wrong.
2538 We should've read the node at the earlier position already. */
2539 if (ib->p >= orig_offset)
2540 internal_error ("bytecode stream: tried to jump backwards in the "
2543 LTO_INIT_INPUT_BLOCK (fwd_ib, ib->data, orig_offset, ib->len);
2544 result = lto_input_tree (&fwd_ib, data_in);
2548 && TREE_CODE (result) == lto_tag_to_tree_code (expected_tag));
2554 /* Read a code and class from input block IB and return the
2555 corresponding builtin. DATA_IN is as in lto_input_tree. */
2558 lto_get_builtin_tree (struct lto_input_block *ib, struct data_in *data_in)
2560 enum built_in_class fclass;
2561 enum built_in_function fcode;
2562 const char *asmname;
2566 fclass = (enum built_in_class) lto_input_uleb128 (ib);
2567 gcc_assert (fclass == BUILT_IN_NORMAL || fclass == BUILT_IN_MD);
2569 fcode = (enum built_in_function) lto_input_uleb128 (ib);
2571 ix = lto_input_sleb128 (ib);
2572 gcc_assert (ix == (int) ix);
2574 if (fclass == BUILT_IN_NORMAL)
2576 gcc_assert (fcode < END_BUILTINS);
2577 result = built_in_decls[fcode];
2578 gcc_assert (result);
2580 else if (fclass == BUILT_IN_MD)
2582 result = targetm.builtin_decl (fcode, true);
2583 if (!result || result == error_mark_node)
2584 fatal_error ("target specific builtin not available");
2587 asmname = input_string (data_in, ib);
2589 set_builtin_user_assembler_name (result, asmname);
2591 lto_streamer_cache_insert_at (data_in->reader_cache, result, ix);
2597 /* Read the physical representation of a tree node with tag TAG from
2598 input block IB using the per-file context in DATA_IN. */
2601 lto_read_tree (struct lto_input_block *ib, struct data_in *data_in,
2608 result = lto_materialize_tree (ib, data_in, tag, &ix);
2610 /* Read all the pointer fields in RESULT. */
2611 lto_input_tree_pointers (ib, data_in, result);
2613 /* We should never try to instantiate an MD or NORMAL builtin here. */
2614 if (TREE_CODE (result) == FUNCTION_DECL)
2615 gcc_assert (!lto_stream_as_builtin_p (result));
2617 if (TREE_CODE (result) == VAR_DECL)
2618 lto_register_var_decl_in_symtab (data_in, result);
2619 else if (TREE_CODE (result) == FUNCTION_DECL && !DECL_BUILT_IN (result))
2620 lto_register_function_decl_in_symtab (data_in, result);
2622 end_marker = lto_input_1_unsigned (ib);
2624 #ifdef LTO_STREAMER_DEBUG
2625 /* Remove the mapping to RESULT's original address set by
2626 lto_materialize_tree. */
2627 lto_orig_address_remove (result);
2634 /* Read and INTEGER_CST node from input block IB using the per-file
2635 context in DATA_IN. */
2638 lto_input_integer_cst (struct lto_input_block *ib, struct data_in *data_in)
2641 HOST_WIDE_INT low, high;
2644 type = lto_input_tree (ib, data_in);
2645 overflow_p = (lto_input_1_unsigned (ib) != 0);
2646 low = lto_input_uleb128 (ib);
2647 high = lto_input_uleb128 (ib);
2648 result = build_int_cst_wide (type, low, high);
2650 /* If the original constant had overflown, build a replica of RESULT to
2651 avoid modifying the shared constant returned by build_int_cst_wide. */
2654 result = copy_node (result);
2655 TREE_OVERFLOW (result) = 1;
2662 /* Read a tree from input block IB using the per-file context in
2663 DATA_IN. This context is used, for example, to resolve references
2664 to previously read nodes. */
2667 lto_input_tree (struct lto_input_block *ib, struct data_in *data_in)
2672 tag = input_record_start (ib);
2673 gcc_assert ((unsigned) tag < (unsigned) LTO_NUM_TAGS);
2675 if (tag == LTO_null)
2677 else if (tag >= LTO_field_decl_ref && tag <= LTO_global_decl_ref)
2679 /* If TAG is a reference to an indexable tree, the next value
2680 in IB is the index into the table where we expect to find
2682 result = lto_input_tree_ref (ib, data_in, cfun, tag);
2684 else if (tag == LTO_tree_pickle_reference)
2686 /* If TAG is a reference to a previously read tree, look it up in
2687 the reader cache. */
2688 result = lto_get_pickled_tree (ib, data_in);
2690 else if (tag == LTO_builtin_decl)
2692 /* If we are going to read a built-in function, all we need is
2693 the code and class. */
2694 result = lto_get_builtin_tree (ib, data_in);
2696 else if (tag == lto_tree_code_to_tag (INTEGER_CST))
2698 /* For integer constants we only need the type and its hi/low
2700 result = lto_input_integer_cst (ib, data_in);
2704 /* Otherwise, materialize a new node from IB. */
2705 result = lto_read_tree (ib, data_in, tag);
2712 /* Initialization for the LTO reader. */
2715 lto_init_reader (void)
2717 lto_streamer_init ();
2719 memset (<o_stats, 0, sizeof (lto_stats));
2720 bitmap_obstack_initialize (NULL);
2722 file_name_hash_table = htab_create (37, hash_string_slot_node,
2723 eq_string_slot_node, free);
2725 gimple_register_cfg_hooks ();
2729 /* Create a new data_in object for FILE_DATA. STRINGS is the string
2730 table to use with LEN strings. RESOLUTIONS is the vector of linker
2731 resolutions (NULL if not using a linker plugin). */
2734 lto_data_in_create (struct lto_file_decl_data *file_data, const char *strings,
2736 VEC(ld_plugin_symbol_resolution_t,heap) *resolutions)
2738 struct data_in *data_in = XCNEW (struct data_in);
2739 data_in->file_data = file_data;
2740 data_in->strings = strings;
2741 data_in->strings_len = len;
2742 data_in->globals_resolution = resolutions;
2743 data_in->reader_cache = lto_streamer_cache_create ();
2749 /* Remove DATA_IN. */
2752 lto_data_in_delete (struct data_in *data_in)
2754 VEC_free (ld_plugin_symbol_resolution_t, heap, data_in->globals_resolution);
2755 lto_streamer_cache_delete (data_in->reader_cache);
2756 free (data_in->labels);