1 /* Read the GIMPLE representation from a file stream.
3 Copyright 2009, 2010 Free Software Foundation, Inc.
4 Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
5 Re-implemented by Diego Novillo <dnovillo@google.com>
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
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
);
373 /* Read and return a double-linked list of catch handlers from input
374 block IB, using descriptors in DATA_IN. */
376 static struct eh_catch_d
*
377 lto_input_eh_catch_list (struct lto_input_block
*ib
, struct data_in
*data_in
,
383 *last_p
= first
= NULL
;
384 tag
= input_record_start (ib
);
390 lto_tag_check_range (tag
, LTO_eh_catch
, LTO_eh_catch
);
392 /* Read the catch node. */
393 n
= GGC_CNEW (struct eh_catch_d
);
394 n
->type_list
= lto_input_tree (ib
, data_in
);
395 n
->filter_list
= lto_input_tree (ib
, data_in
);
396 n
->label
= lto_input_tree (ib
, data_in
);
398 /* Register all the types in N->FILTER_LIST. */
399 for (list
= n
->filter_list
; list
; list
= TREE_CHAIN (list
))
400 add_type_for_runtime (TREE_VALUE (list
));
402 /* Chain N to the end of the list. */
404 (*last_p
)->next_catch
= n
;
405 n
->prev_catch
= *last_p
;
408 /* Set the head of the list the first time through the loop. */
412 tag
= input_record_start (ib
);
419 /* Read and return EH region IX from input block IB, using descriptors
423 input_eh_region (struct lto_input_block
*ib
, struct data_in
*data_in
, int ix
)
428 /* Read the region header. */
429 tag
= input_record_start (ib
);
433 r
= GGC_CNEW (struct eh_region_d
);
434 r
->index
= lto_input_sleb128 (ib
);
436 gcc_assert (r
->index
== ix
);
438 /* Read all the region pointers as region numbers. We'll fix up
439 the pointers once the whole array has been read. */
440 r
->outer
= (eh_region
) (intptr_t) lto_input_sleb128 (ib
);
441 r
->inner
= (eh_region
) (intptr_t) lto_input_sleb128 (ib
);
442 r
->next_peer
= (eh_region
) (intptr_t) lto_input_sleb128 (ib
);
446 case LTO_ert_cleanup
:
447 r
->type
= ERT_CLEANUP
;
452 struct eh_catch_d
*last_catch
;
454 r
->u
.eh_try
.first_catch
= lto_input_eh_catch_list (ib
, data_in
,
456 r
->u
.eh_try
.last_catch
= last_catch
;
460 case LTO_ert_allowed_exceptions
:
464 r
->type
= ERT_ALLOWED_EXCEPTIONS
;
465 r
->u
.allowed
.type_list
= lto_input_tree (ib
, data_in
);
466 r
->u
.allowed
.label
= lto_input_tree (ib
, data_in
);
467 r
->u
.allowed
.filter
= lto_input_uleb128 (ib
);
469 for (l
= r
->u
.allowed
.type_list
; l
; l
= TREE_CHAIN (l
))
470 add_type_for_runtime (TREE_VALUE (l
));
474 case LTO_ert_must_not_throw
:
475 r
->type
= ERT_MUST_NOT_THROW
;
476 r
->u
.must_not_throw
.failure_decl
= lto_input_tree (ib
, data_in
);
477 r
->u
.must_not_throw
.failure_loc
= lto_input_location (ib
, data_in
);
484 r
->landing_pads
= (eh_landing_pad
) (intptr_t) lto_input_sleb128 (ib
);
490 /* Read and return EH landing pad IX from input block IB, using descriptors
493 static eh_landing_pad
494 input_eh_lp (struct lto_input_block
*ib
, struct data_in
*data_in
, int ix
)
499 /* Read the landing pad header. */
500 tag
= input_record_start (ib
);
504 lto_tag_check_range (tag
, LTO_eh_landing_pad
, LTO_eh_landing_pad
);
506 lp
= GGC_CNEW (struct eh_landing_pad_d
);
507 lp
->index
= lto_input_sleb128 (ib
);
508 gcc_assert (lp
->index
== ix
);
509 lp
->next_lp
= (eh_landing_pad
) (intptr_t) lto_input_sleb128 (ib
);
510 lp
->region
= (eh_region
) (intptr_t) lto_input_sleb128 (ib
);
511 lp
->post_landing_pad
= lto_input_tree (ib
, data_in
);
517 /* After reading the EH regions, pointers to peer and children regions
518 are region numbers. This converts all these region numbers into
519 real pointers into the rematerialized regions for FN. ROOT_REGION
520 is the region number for the root EH region in FN. */
523 fixup_eh_region_pointers (struct function
*fn
, HOST_WIDE_INT root_region
)
526 VEC(eh_region
,gc
) *eh_array
= fn
->eh
->region_array
;
527 VEC(eh_landing_pad
,gc
) *lp_array
= fn
->eh
->lp_array
;
531 gcc_assert (eh_array
&& lp_array
);
533 gcc_assert (root_region
>= 0);
534 fn
->eh
->region_tree
= VEC_index (eh_region
, eh_array
, root_region
);
536 #define FIXUP_EH_REGION(r) (r) = VEC_index (eh_region, eh_array, \
537 (HOST_WIDE_INT) (intptr_t) (r))
538 #define FIXUP_EH_LP(p) (p) = VEC_index (eh_landing_pad, lp_array, \
539 (HOST_WIDE_INT) (intptr_t) (p))
541 /* Convert all the index numbers stored in pointer fields into
542 pointers to the corresponding slots in the EH region array. */
543 for (i
= 0; VEC_iterate (eh_region
, eh_array
, i
, r
); i
++)
545 /* The array may contain NULL regions. */
549 gcc_assert (i
== (unsigned) r
->index
);
550 FIXUP_EH_REGION (r
->outer
);
551 FIXUP_EH_REGION (r
->inner
);
552 FIXUP_EH_REGION (r
->next_peer
);
553 FIXUP_EH_LP (r
->landing_pads
);
556 /* Convert all the index numbers stored in pointer fields into
557 pointers to the corresponding slots in the EH landing pad array. */
558 for (i
= 0; VEC_iterate (eh_landing_pad
, lp_array
, i
, lp
); i
++)
560 /* The array may contain NULL landing pads. */
564 gcc_assert (i
== (unsigned) lp
->index
);
565 FIXUP_EH_LP (lp
->next_lp
);
566 FIXUP_EH_REGION (lp
->region
);
569 #undef FIXUP_EH_REGION
574 /* Initialize EH support. */
579 static bool eh_initialized_p
= false;
581 if (eh_initialized_p
)
584 /* Contrary to most other FEs, we only initialize EH support when at
585 least one of the files in the set contains exception regions in
586 it. Since this happens much later than the call to init_eh in
587 lang_dependent_init, we have to set flag_exceptions and call
588 init_eh again to initialize the EH tables. */
592 /* Initialize dwarf2 tables. Since dwarf2out_do_frame() returns
593 true only when exceptions are enabled, this initialization is
594 never done during lang_dependent_init. */
595 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
596 if (dwarf2out_do_frame ())
597 dwarf2out_frame_init ();
600 eh_initialized_p
= true;
604 /* Read the exception table for FN from IB using the data descriptors
608 input_eh_regions (struct lto_input_block
*ib
, struct data_in
*data_in
,
611 HOST_WIDE_INT i
, root_region
, len
;
614 tag
= input_record_start (ib
);
618 lto_tag_check_range (tag
, LTO_eh_table
, LTO_eh_table
);
620 /* If the file contains EH regions, then it was compiled with
621 -fexceptions. In that case, initialize the backend EH
627 root_region
= lto_input_sleb128 (ib
);
628 gcc_assert (root_region
== (int) root_region
);
630 /* Read the EH region array. */
631 len
= lto_input_sleb128 (ib
);
632 gcc_assert (len
== (int) len
);
635 VEC_safe_grow (eh_region
, gc
, fn
->eh
->region_array
, len
);
636 for (i
= 0; i
< len
; i
++)
638 eh_region r
= input_eh_region (ib
, data_in
, i
);
639 VEC_replace (eh_region
, fn
->eh
->region_array
, i
, r
);
643 /* Read the landing pads. */
644 len
= lto_input_sleb128 (ib
);
645 gcc_assert (len
== (int) len
);
648 VEC_safe_grow (eh_landing_pad
, gc
, fn
->eh
->lp_array
, len
);
649 for (i
= 0; i
< len
; i
++)
651 eh_landing_pad lp
= input_eh_lp (ib
, data_in
, i
);
652 VEC_replace (eh_landing_pad
, fn
->eh
->lp_array
, i
, lp
);
656 /* Read the runtime type data. */
657 len
= lto_input_sleb128 (ib
);
658 gcc_assert (len
== (int) len
);
661 VEC_safe_grow (tree
, gc
, fn
->eh
->ttype_data
, len
);
662 for (i
= 0; i
< len
; i
++)
664 tree ttype
= lto_input_tree (ib
, data_in
);
665 VEC_replace (tree
, fn
->eh
->ttype_data
, i
, ttype
);
669 /* Read the table of action chains. */
670 len
= lto_input_sleb128 (ib
);
671 gcc_assert (len
== (int) len
);
674 if (targetm
.arm_eabi_unwinder
)
676 VEC_safe_grow (tree
, gc
, fn
->eh
->ehspec_data
.arm_eabi
, len
);
677 for (i
= 0; i
< len
; i
++)
679 tree t
= lto_input_tree (ib
, data_in
);
680 VEC_replace (tree
, fn
->eh
->ehspec_data
.arm_eabi
, i
, t
);
685 VEC_safe_grow (uchar
, gc
, fn
->eh
->ehspec_data
.other
, len
);
686 for (i
= 0; i
< len
; i
++)
688 uchar c
= lto_input_1_unsigned (ib
);
689 VEC_replace (uchar
, fn
->eh
->ehspec_data
.other
, i
, c
);
694 /* Reconstruct the EH region tree by fixing up the peer/children
696 fixup_eh_region_pointers (fn
, root_region
);
698 tag
= input_record_start (ib
);
699 lto_tag_check_range (tag
, LTO_null
, LTO_null
);
703 /* Make a new basic block with index INDEX in function FN. */
706 make_new_block (struct function
*fn
, unsigned int index
)
708 basic_block bb
= alloc_block ();
710 SET_BASIC_BLOCK_FOR_FUNCTION (fn
, index
, bb
);
711 bb
->il
.gimple
= GGC_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. This handles plain DECLs where
948 we need the stmt for context to lookup the required type. */
951 maybe_fixup_decls (gimple stmt
)
953 /* We have to fixup replaced decls here in case there were
954 inter-TU type mismatches. Catch the most common cases
955 for now - this way we'll get testcases for the rest as
956 the type verifier will complain. */
957 if (gimple_assign_single_p (stmt
))
959 tree lhs
= gimple_assign_lhs (stmt
);
960 tree rhs
= gimple_assign_rhs1 (stmt
);
962 /* First catch loads and aggregate copies by adjusting the rhs. */
963 if (TREE_CODE (rhs
) == VAR_DECL
)
965 if (!useless_type_conversion_p (TREE_TYPE (lhs
), TREE_TYPE (rhs
)))
966 gimple_assign_set_rhs1 (stmt
, build1 (VIEW_CONVERT_EXPR
,
967 TREE_TYPE (lhs
), rhs
));
969 /* Then catch scalar stores. */
970 else if (TREE_CODE (lhs
) == VAR_DECL
)
972 if (!useless_type_conversion_p (TREE_TYPE (lhs
), TREE_TYPE (rhs
)))
973 gimple_assign_set_lhs (stmt
, build1 (VIEW_CONVERT_EXPR
,
974 TREE_TYPE (rhs
), lhs
));
977 else if (is_gimple_call (stmt
))
979 tree lhs
= gimple_call_lhs (stmt
);
981 if (lhs
&& TREE_CODE (lhs
) == VAR_DECL
)
983 if (!useless_type_conversion_p (TREE_TYPE (lhs
),
984 gimple_call_return_type (stmt
)))
985 gimple_call_set_lhs (stmt
, build1 (VIEW_CONVERT_EXPR
,
986 gimple_call_return_type (stmt
),
990 /* Arguments, especially for varargs functions will be funny... */
994 /* Read a statement with tag TAG in function FN from block IB using
995 descriptors in DATA_IN. */
998 input_gimple_stmt (struct lto_input_block
*ib
, struct data_in
*data_in
,
999 struct function
*fn
, enum LTO_tags tag
)
1002 enum gimple_code code
;
1003 unsigned HOST_WIDE_INT num_ops
;
1005 struct bitpack_d
*bp
;
1007 code
= lto_tag_to_gimple_code (tag
);
1009 /* Read the tuple header. */
1010 bp
= lto_input_bitpack (ib
);
1011 num_ops
= bp_unpack_value (bp
, sizeof (unsigned) * 8);
1012 stmt
= gimple_alloc (code
, num_ops
);
1013 stmt
->gsbase
.no_warning
= bp_unpack_value (bp
, 1);
1014 if (is_gimple_assign (stmt
))
1015 stmt
->gsbase
.nontemporal_move
= bp_unpack_value (bp
, 1);
1016 stmt
->gsbase
.has_volatile_ops
= bp_unpack_value (bp
, 1);
1017 stmt
->gsbase
.subcode
= bp_unpack_value (bp
, 16);
1018 bitpack_delete (bp
);
1020 /* Read location information. */
1021 gimple_set_location (stmt
, lto_input_location (ib
, data_in
));
1023 /* Read lexical block reference. */
1024 gimple_set_block (stmt
, lto_input_tree (ib
, data_in
));
1026 /* Read in all the operands. */
1030 gimple_resx_set_region (stmt
, lto_input_sleb128 (ib
));
1033 case GIMPLE_EH_MUST_NOT_THROW
:
1034 gimple_eh_must_not_throw_set_fndecl (stmt
, lto_input_tree (ib
, data_in
));
1037 case GIMPLE_EH_DISPATCH
:
1038 gimple_eh_dispatch_set_region (stmt
, lto_input_sleb128 (ib
));
1043 /* FIXME lto. Move most of this into a new gimple_asm_set_string(). */
1045 stmt
->gimple_asm
.ni
= lto_input_uleb128 (ib
);
1046 stmt
->gimple_asm
.no
= lto_input_uleb128 (ib
);
1047 stmt
->gimple_asm
.nc
= lto_input_uleb128 (ib
);
1048 str
= input_string_cst (data_in
, ib
);
1049 stmt
->gimple_asm
.string
= TREE_STRING_POINTER (str
);
1061 for (i
= 0; i
< num_ops
; i
++)
1063 tree op
= lto_input_tree (ib
, data_in
);
1064 gimple_set_op (stmt
, i
, op
);
1068 /* Fixup reference tree operands for substituted prevailing decls
1069 with mismatched types. For plain VAR_DECLs we need to look
1070 at context to determine the wanted type - we do that below
1071 after the stmt is completed. */
1072 if (TREE_CODE (op
) == ADDR_EXPR
1073 && TREE_CODE (TREE_OPERAND (op
, 0)) == VAR_DECL
1074 && !useless_type_conversion_p (TREE_TYPE (TREE_TYPE (op
)),
1077 TREE_OPERAND (op
, 0)
1078 = build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (TREE_TYPE (op
)),
1079 TREE_OPERAND (op
, 0));
1083 /* Fixup FIELD_DECLs in COMPONENT_REFs, they are not handled
1085 if (TREE_CODE (op
) == ADDR_EXPR
)
1086 op
= TREE_OPERAND (op
, 0);
1087 while (handled_component_p (op
))
1089 if (TREE_CODE (op
) == COMPONENT_REF
)
1091 tree field
, type
, tem
;
1092 field
= TREE_OPERAND (op
, 1);
1093 type
= DECL_CONTEXT (field
);
1094 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
1097 || (TREE_TYPE (tem
) == TREE_TYPE (field
)
1098 && compare_field_offset (tem
, field
)))
1101 /* In case of type mismatches across units we can fail
1102 to unify some types and thus not find a proper
1103 field-decl here. So only assert here if checking
1105 #ifdef ENABLE_CHECKING
1106 gcc_assert (tem
!= NULL_TREE
);
1108 if (tem
!= NULL_TREE
)
1109 TREE_OPERAND (op
, 1) = tem
;
1112 /* Preserve the last handled component for the fixup of
1113 its operand below. */
1114 if (!handled_component_p (TREE_OPERAND (op
, 0)))
1116 op
= TREE_OPERAND (op
, 0);
1119 /* Fixup reference tree operands for substituted prevailing decls
1120 with mismatched types. */
1121 if (handled_component_p (op
))
1122 maybe_fixup_handled_component (op
);
1127 case GIMPLE_PREDICT
:
1131 internal_error ("bytecode stream: unknown GIMPLE statement tag %s",
1132 lto_tag_name (tag
));
1135 /* Update the properties of symbols, SSA names and labels associated
1137 if (code
== GIMPLE_ASSIGN
|| code
== GIMPLE_CALL
)
1139 tree lhs
= gimple_get_lhs (stmt
);
1140 if (lhs
&& TREE_CODE (lhs
) == SSA_NAME
)
1141 SSA_NAME_DEF_STMT (lhs
) = stmt
;
1143 else if (code
== GIMPLE_LABEL
)
1144 gcc_assert (emit_label_in_global_context_p (gimple_label_label (stmt
))
1145 || DECL_CONTEXT (gimple_label_label (stmt
)) == fn
->decl
);
1146 else if (code
== GIMPLE_ASM
)
1150 for (i
= 0; i
< gimple_asm_noutputs (stmt
); i
++)
1152 tree op
= TREE_VALUE (gimple_asm_output_op (stmt
, i
));
1153 if (TREE_CODE (op
) == SSA_NAME
)
1154 SSA_NAME_DEF_STMT (op
) = stmt
;
1158 /* Reset alias information. */
1159 if (code
== GIMPLE_CALL
)
1160 gimple_call_reset_alias_info (stmt
);
1162 /* Fixup reference tree operands for substituted prevailing decls
1163 with mismatched types. */
1164 maybe_fixup_decls (stmt
);
1166 /* Mark the statement modified so its operand vectors can be filled in. */
1167 gimple_set_modified (stmt
, true);
1173 /* Read a basic block with tag TAG from DATA_IN using input block IB.
1174 FN is the function being processed. */
1177 input_bb (struct lto_input_block
*ib
, enum LTO_tags tag
,
1178 struct data_in
*data_in
, struct function
*fn
)
1182 gimple_stmt_iterator bsi
;
1184 /* This routine assumes that CFUN is set to FN, as it needs to call
1185 basic GIMPLE routines that use CFUN. */
1186 gcc_assert (cfun
== fn
);
1188 index
= lto_input_uleb128 (ib
);
1189 bb
= BASIC_BLOCK_FOR_FUNCTION (fn
, index
);
1191 bb
->count
= lto_input_sleb128 (ib
);
1192 bb
->loop_depth
= lto_input_sleb128 (ib
);
1193 bb
->frequency
= lto_input_sleb128 (ib
);
1194 bb
->flags
= lto_input_sleb128 (ib
);
1196 /* LTO_bb1 has statements. LTO_bb0 does not. */
1200 bsi
= gsi_start_bb (bb
);
1201 tag
= input_record_start (ib
);
1204 gimple stmt
= input_gimple_stmt (ib
, data_in
, fn
, tag
);
1206 /* Change debug stmts to nops on-the-fly if we do not have VTA enabled.
1207 This allows us to build for example static libs with debugging
1208 enabled and do the final link without. */
1209 if (!MAY_HAVE_DEBUG_STMTS
1210 && is_gimple_debug (stmt
))
1211 stmt
= gimple_build_nop ();
1213 find_referenced_vars_in (stmt
);
1214 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1216 /* After the statement, expect a 0 delimiter or the EH region
1217 that the previous statement belongs to. */
1218 tag
= input_record_start (ib
);
1219 lto_tag_check_set (tag
, 2, LTO_eh_region
, LTO_null
);
1221 if (tag
== LTO_eh_region
)
1223 HOST_WIDE_INT region
= lto_input_sleb128 (ib
);
1224 gcc_assert (region
== (int) region
);
1225 add_stmt_to_eh_lp (stmt
, region
);
1228 tag
= input_record_start (ib
);
1231 tag
= input_record_start (ib
);
1234 gimple phi
= input_phi (ib
, bb
, data_in
, fn
);
1235 find_referenced_vars_in (phi
);
1236 tag
= input_record_start (ib
);
1240 /* Go through all NODE edges and fixup call_stmt pointers
1241 so they point to STMTS. */
1244 fixup_call_stmt_edges_1 (struct cgraph_node
*node
, gimple
*stmts
)
1246 struct cgraph_edge
*cedge
;
1247 for (cedge
= node
->callees
; cedge
; cedge
= cedge
->next_callee
)
1248 cedge
->call_stmt
= stmts
[cedge
->lto_stmt_uid
];
1249 for (cedge
= node
->indirect_calls
; cedge
; cedge
= cedge
->next_callee
)
1250 cedge
->call_stmt
= stmts
[cedge
->lto_stmt_uid
];
1253 /* Fixup call_stmt pointers in NODE and all clones. */
1256 fixup_call_stmt_edges (struct cgraph_node
*orig
, gimple
*stmts
)
1258 struct cgraph_node
*node
;
1260 while (orig
->clone_of
)
1261 orig
= orig
->clone_of
;
1263 fixup_call_stmt_edges_1 (orig
, stmts
);
1265 for (node
= orig
->clones
; node
!= orig
;)
1267 fixup_call_stmt_edges_1 (node
, stmts
);
1269 node
= node
->clones
;
1270 else if (node
->next_sibling_clone
)
1271 node
= node
->next_sibling_clone
;
1274 while (node
!= orig
&& !node
->next_sibling_clone
)
1275 node
= node
->clone_of
;
1277 node
= node
->next_sibling_clone
;
1282 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1285 input_function (tree fn_decl
, struct data_in
*data_in
,
1286 struct lto_input_block
*ib
)
1288 struct function
*fn
;
1292 struct bitpack_d
*bp
;
1293 struct cgraph_node
*node
;
1294 tree args
, narg
, oarg
;
1296 fn
= DECL_STRUCT_FUNCTION (fn_decl
);
1297 tag
= input_record_start (ib
);
1298 clear_line_info (data_in
);
1300 gimple_register_cfg_hooks ();
1301 lto_tag_check (tag
, LTO_function
);
1303 /* Read all the attributes for FN. */
1304 bp
= lto_input_bitpack (ib
);
1305 fn
->is_thunk
= bp_unpack_value (bp
, 1);
1306 fn
->has_local_explicit_reg_vars
= bp_unpack_value (bp
, 1);
1307 fn
->after_tree_profile
= bp_unpack_value (bp
, 1);
1308 fn
->returns_pcc_struct
= bp_unpack_value (bp
, 1);
1309 fn
->returns_struct
= bp_unpack_value (bp
, 1);
1310 fn
->always_inline_functions_inlined
= bp_unpack_value (bp
, 1);
1311 fn
->after_inlining
= bp_unpack_value (bp
, 1);
1312 fn
->dont_save_pending_sizes_p
= bp_unpack_value (bp
, 1);
1313 fn
->stdarg
= bp_unpack_value (bp
, 1);
1314 fn
->has_nonlocal_label
= bp_unpack_value (bp
, 1);
1315 fn
->calls_alloca
= bp_unpack_value (bp
, 1);
1316 fn
->calls_setjmp
= bp_unpack_value (bp
, 1);
1317 fn
->va_list_fpr_size
= bp_unpack_value (bp
, 8);
1318 fn
->va_list_gpr_size
= bp_unpack_value (bp
, 8);
1319 bitpack_delete (bp
);
1321 /* Input the current IL state of the function. */
1322 fn
->curr_properties
= lto_input_uleb128 (ib
);
1324 /* Read the static chain and non-local goto save area. */
1325 fn
->static_chain_decl
= lto_input_tree (ib
, data_in
);
1326 fn
->nonlocal_goto_save_area
= lto_input_tree (ib
, data_in
);
1328 /* Read all the local symbols. */
1329 fn
->local_decls
= lto_input_tree (ib
, data_in
);
1331 /* Read all function arguments. We need to re-map them here to the
1332 arguments of the merged function declaration. */
1333 args
= lto_input_tree (ib
, data_in
);
1334 for (oarg
= args
, narg
= DECL_ARGUMENTS (fn_decl
);
1336 oarg
= TREE_CHAIN (oarg
), narg
= TREE_CHAIN (narg
))
1340 res
= lto_streamer_cache_lookup (data_in
->reader_cache
, oarg
, &ix
);
1342 /* Replace the argument in the streamer cache. */
1343 lto_streamer_cache_insert_at (data_in
->reader_cache
, narg
, ix
);
1345 gcc_assert (!oarg
&& !narg
);
1347 /* Read all the SSA names. */
1348 input_ssa_names (ib
, data_in
, fn
);
1350 /* Read the exception handling regions in the function. */
1351 input_eh_regions (ib
, data_in
, fn
);
1353 /* Read the tree of lexical scopes for the function. */
1354 DECL_INITIAL (fn_decl
) = lto_input_tree (ib
, data_in
);
1355 gcc_assert (DECL_INITIAL (fn_decl
));
1356 DECL_SAVED_TREE (fn_decl
) = NULL_TREE
;
1358 /* Read all the basic blocks. */
1359 tag
= input_record_start (ib
);
1362 input_bb (ib
, tag
, data_in
, fn
);
1363 tag
= input_record_start (ib
);
1366 /* Fix up the call statements that are mentioned in the callgraph
1368 renumber_gimple_stmt_uids ();
1369 stmts
= (gimple
*) xcalloc (gimple_stmt_max_uid (fn
), sizeof (gimple
));
1372 gimple_stmt_iterator bsi
;
1373 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
1375 gimple stmt
= gsi_stmt (bsi
);
1376 stmts
[gimple_uid (stmt
)] = stmt
;
1380 /* Set the gimple body to the statement sequence in the entry
1381 basic block. FIXME lto, this is fairly hacky. The existence
1382 of a gimple body is used by the cgraph routines, but we should
1383 really use the presence of the CFG. */
1385 edge_iterator ei
= ei_start (ENTRY_BLOCK_PTR
->succs
);
1386 gimple_set_body (fn_decl
, bb_seq (ei_edge (ei
)->dest
));
1389 node
= cgraph_node (fn_decl
);
1390 fixup_call_stmt_edges (node
, stmts
);
1391 execute_all_ipa_stmt_fixups (node
, stmts
);
1393 update_ssa (TODO_update_ssa_only_virtuals
);
1394 free_dominance_info (CDI_DOMINATORS
);
1395 free_dominance_info (CDI_POST_DOMINATORS
);
1400 /* Read initializer expressions for public statics. DATA_IN is the
1401 file being read. IB is the input block used for reading. */
1404 input_alias_pairs (struct lto_input_block
*ib
, struct data_in
*data_in
)
1408 clear_line_info (data_in
);
1410 /* Skip over all the unreferenced globals. */
1412 var
= lto_input_tree (ib
, data_in
);
1415 var
= lto_input_tree (ib
, data_in
);
1418 const char *orig_name
, *new_name
;
1421 p
= VEC_safe_push (alias_pair
, gc
, alias_pairs
, NULL
);
1423 p
->target
= lto_input_tree (ib
, data_in
);
1425 /* If the target is a static object, we may have registered a
1426 new name for it to avoid clashes between statics coming from
1427 different files. In that case, use the new name. */
1428 orig_name
= IDENTIFIER_POINTER (p
->target
);
1429 new_name
= lto_get_decl_name_mapping (data_in
->file_data
, orig_name
);
1430 if (strcmp (orig_name
, new_name
) != 0)
1431 p
->target
= get_identifier (new_name
);
1433 var
= lto_input_tree (ib
, data_in
);
1438 /* Read the body from DATA for function FN_DECL and fill it in.
1439 FILE_DATA are the global decls and types. SECTION_TYPE is either
1440 LTO_section_function_body or LTO_section_static_initializer. If
1441 section type is LTO_section_function_body, FN must be the decl for
1445 lto_read_body (struct lto_file_decl_data
*file_data
, tree fn_decl
,
1446 const char *data
, enum lto_section_type section_type
)
1448 const struct lto_function_header
*header
;
1449 struct data_in
*data_in
;
1451 int32_t main_offset
;
1452 int32_t string_offset
;
1453 struct lto_input_block ib_cfg
;
1454 struct lto_input_block ib_main
;
1456 header
= (const struct lto_function_header
*) data
;
1457 cfg_offset
= sizeof (struct lto_function_header
);
1458 main_offset
= cfg_offset
+ header
->cfg_size
;
1459 string_offset
= main_offset
+ header
->main_size
;
1461 LTO_INIT_INPUT_BLOCK (ib_cfg
,
1466 LTO_INIT_INPUT_BLOCK (ib_main
,
1471 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
1472 header
->string_size
, NULL
);
1474 /* Make sure the file was generated by the exact same compiler. */
1475 lto_check_version (header
->lto_header
.major_version
,
1476 header
->lto_header
.minor_version
);
1478 if (section_type
== LTO_section_function_body
)
1480 struct function
*fn
= DECL_STRUCT_FUNCTION (fn_decl
);
1481 struct lto_in_decl_state
*decl_state
;
1486 /* Use the function's decl state. */
1487 decl_state
= lto_get_function_in_decl_state (file_data
, fn_decl
);
1488 gcc_assert (decl_state
);
1489 file_data
->current_decl_state
= decl_state
;
1491 input_cfg (&ib_cfg
, fn
);
1493 /* Set up the struct function. */
1494 input_function (fn_decl
, data_in
, &ib_main
);
1496 /* We should now be in SSA. */
1497 cfun
->gimple_df
->in_ssa_p
= true;
1499 /* Restore decl state */
1500 file_data
->current_decl_state
= file_data
->global_decl_state
;
1506 input_alias_pairs (&ib_main
, data_in
);
1509 clear_line_info (data_in
);
1510 lto_data_in_delete (data_in
);
1514 /* Read the body of FN_DECL using DATA. FILE_DATA holds the global
1518 lto_input_function_body (struct lto_file_decl_data
*file_data
,
1519 tree fn_decl
, const char *data
)
1521 current_function_decl
= fn_decl
;
1522 lto_read_body (file_data
, fn_decl
, data
, LTO_section_function_body
);
1526 /* Read in VAR_DECL using DATA. FILE_DATA holds the global decls and
1530 lto_input_constructors_and_inits (struct lto_file_decl_data
*file_data
,
1533 lto_read_body (file_data
, NULL
, data
, LTO_section_static_initializer
);
1537 /* Return the resolution for the decl with index INDEX from DATA_IN. */
1539 static enum ld_plugin_symbol_resolution
1540 get_resolution (struct data_in
*data_in
, unsigned index
)
1542 if (data_in
->globals_resolution
)
1544 ld_plugin_symbol_resolution_t ret
;
1545 /* We can have references to not emitted functions in
1546 DECL_FUNCTION_PERSONALITY at least. So we can and have
1547 to indeed return LDPR_UNKNOWN in some cases. */
1548 if (VEC_length (ld_plugin_symbol_resolution_t
,
1549 data_in
->globals_resolution
) <= index
)
1550 return LDPR_UNKNOWN
;
1551 ret
= VEC_index (ld_plugin_symbol_resolution_t
,
1552 data_in
->globals_resolution
,
1557 /* Delay resolution finding until decl merging. */
1558 return LDPR_UNKNOWN
;
1562 /* Unpack all the non-pointer fields of the TS_BASE structure of
1563 expression EXPR from bitpack BP. */
1566 unpack_ts_base_value_fields (struct bitpack_d
*bp
, tree expr
)
1568 /* Note that the code for EXPR has already been unpacked to create EXPR in
1569 lto_materialize_tree. */
1572 TREE_SIDE_EFFECTS (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1573 TREE_CONSTANT (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1574 TREE_READONLY (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1576 /* TREE_PUBLIC is used on types to indicate that the type
1577 has a TYPE_CACHED_VALUES vector. This is not streamed out,
1578 so we skip it here. */
1579 TREE_PUBLIC (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1581 TREE_ADDRESSABLE (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1582 TREE_THIS_VOLATILE (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1584 DECL_UNSIGNED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1585 else if (TYPE_P (expr
))
1586 TYPE_UNSIGNED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1587 TREE_ASM_WRITTEN (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1588 TREE_NO_WARNING (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1589 TREE_USED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1590 TREE_NOTHROW (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1591 TREE_STATIC (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1592 TREE_PRIVATE (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1593 TREE_PROTECTED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1594 TREE_DEPRECATED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1596 TYPE_SATURATING (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1597 if (TREE_CODE (expr
) == SSA_NAME
)
1598 SSA_NAME_IS_DEFAULT_DEF (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1602 /* Unpack all the non-pointer fields of the TS_REAL_CST structure of
1603 expression EXPR from bitpack BP. */
1606 unpack_ts_real_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
1610 REAL_VALUE_TYPE
*rp
;
1612 r
.cl
= (unsigned) bp_unpack_value (bp
, 2);
1613 r
.decimal
= (unsigned) bp_unpack_value (bp
, 1);
1614 r
.sign
= (unsigned) bp_unpack_value (bp
, 1);
1615 r
.signalling
= (unsigned) bp_unpack_value (bp
, 1);
1616 r
.canonical
= (unsigned) bp_unpack_value (bp
, 1);
1617 r
.uexp
= (unsigned) bp_unpack_value (bp
, EXP_BITS
);
1618 for (i
= 0; i
< SIGSZ
; i
++)
1619 r
.sig
[i
] = (unsigned long) bp_unpack_value (bp
, HOST_BITS_PER_LONG
);
1621 rp
= GGC_NEW (REAL_VALUE_TYPE
);
1622 memcpy (rp
, &r
, sizeof (REAL_VALUE_TYPE
));
1623 TREE_REAL_CST_PTR (expr
) = rp
;
1627 /* Unpack all the non-pointer fields of the TS_FIXED_CST structure of
1628 expression EXPR from bitpack BP. */
1631 unpack_ts_fixed_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
1633 struct fixed_value fv
;
1635 fv
.data
.low
= (HOST_WIDE_INT
) bp_unpack_value (bp
, HOST_BITS_PER_WIDE_INT
);
1636 fv
.data
.high
= (HOST_WIDE_INT
) bp_unpack_value (bp
, HOST_BITS_PER_WIDE_INT
);
1637 TREE_FIXED_CST (expr
) = fv
;
1641 /* Unpack all the non-pointer fields of the TS_DECL_COMMON structure
1642 of expression EXPR from bitpack BP. */
1645 unpack_ts_decl_common_value_fields (struct bitpack_d
*bp
, tree expr
)
1647 DECL_MODE (expr
) = (enum machine_mode
) bp_unpack_value (bp
, 8);
1648 DECL_NONLOCAL (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1649 DECL_VIRTUAL_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1650 DECL_IGNORED_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1651 DECL_ABSTRACT (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1652 DECL_ARTIFICIAL (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1653 DECL_USER_ALIGN (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1654 DECL_PRESERVE_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1655 DECL_DEBUG_EXPR_IS_FROM (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1656 DECL_EXTERNAL (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1657 DECL_GIMPLE_REG_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1658 DECL_ALIGN (expr
) = (unsigned) bp_unpack_value (bp
, HOST_BITS_PER_INT
);
1660 if (TREE_CODE (expr
) == LABEL_DECL
)
1662 DECL_ERROR_ISSUED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1663 EH_LANDING_PAD_NR (expr
) = (int) bp_unpack_value (bp
, HOST_BITS_PER_INT
);
1665 /* Always assume an initial value of -1 for LABEL_DECL_UID to
1666 force gimple_set_bb to recreate label_to_block_map. */
1667 LABEL_DECL_UID (expr
) = -1;
1670 if (TREE_CODE (expr
) == FIELD_DECL
)
1672 unsigned HOST_WIDE_INT off_align
;
1673 DECL_PACKED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1674 DECL_NONADDRESSABLE_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1675 off_align
= (unsigned HOST_WIDE_INT
) bp_unpack_value (bp
, 8);
1676 SET_DECL_OFFSET_ALIGN (expr
, off_align
);
1679 if (TREE_CODE (expr
) == RESULT_DECL
1680 || TREE_CODE (expr
) == PARM_DECL
1681 || TREE_CODE (expr
) == VAR_DECL
)
1683 DECL_BY_REFERENCE (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1684 if (TREE_CODE (expr
) == VAR_DECL
1685 || TREE_CODE (expr
) == PARM_DECL
)
1686 DECL_HAS_VALUE_EXPR_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1687 DECL_RESTRICTED_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1692 /* Unpack all the non-pointer fields of the TS_DECL_WRTL structure
1693 of expression EXPR from bitpack BP. */
1696 unpack_ts_decl_wrtl_value_fields (struct bitpack_d
*bp
, tree expr
)
1698 DECL_REGISTER (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1702 /* Unpack all the non-pointer fields of the TS_DECL_WITH_VIS structure
1703 of expression EXPR from bitpack BP. */
1706 unpack_ts_decl_with_vis_value_fields (struct bitpack_d
*bp
, tree expr
)
1708 DECL_DEFER_OUTPUT (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1709 DECL_COMMON (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1710 DECL_DLLIMPORT_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1711 DECL_WEAK (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1712 DECL_SEEN_IN_BIND_EXPR_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1713 DECL_COMDAT (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1714 DECL_VISIBILITY (expr
) = (enum symbol_visibility
) bp_unpack_value (bp
, 2);
1715 DECL_VISIBILITY_SPECIFIED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1717 if (TREE_CODE (expr
) == VAR_DECL
)
1719 DECL_HARD_REGISTER (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1720 DECL_IN_TEXT_SECTION (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1721 DECL_IN_CONSTANT_POOL (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1722 DECL_TLS_MODEL (expr
) = (enum tls_model
) bp_unpack_value (bp
, 3);
1725 if (VAR_OR_FUNCTION_DECL_P (expr
))
1728 p
= (priority_type
) bp_unpack_value (bp
, HOST_BITS_PER_SHORT
);
1729 SET_DECL_INIT_PRIORITY (expr
, p
);
1734 /* Unpack all the non-pointer fields of the TS_FUNCTION_DECL structure
1735 of expression EXPR from bitpack BP. */
1738 unpack_ts_function_decl_value_fields (struct bitpack_d
*bp
, tree expr
)
1740 DECL_FUNCTION_CODE (expr
) = (enum built_in_function
) bp_unpack_value (bp
, 11);
1741 DECL_BUILT_IN_CLASS (expr
) = (enum built_in_class
) bp_unpack_value (bp
, 2);
1742 DECL_STATIC_CONSTRUCTOR (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1743 DECL_STATIC_DESTRUCTOR (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1744 DECL_UNINLINABLE (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1745 DECL_POSSIBLY_INLINED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1746 DECL_IS_NOVOPS (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1747 DECL_IS_RETURNS_TWICE (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1748 DECL_IS_MALLOC (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1749 DECL_IS_OPERATOR_NEW (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1750 DECL_DECLARED_INLINE_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1751 DECL_STATIC_CHAIN (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1752 DECL_NO_INLINE_WARNING_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1753 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr
)
1754 = (unsigned) bp_unpack_value (bp
, 1);
1755 DECL_NO_LIMIT_STACK (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1756 DECL_DISREGARD_INLINE_LIMITS (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1757 DECL_PURE_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1758 DECL_LOOPING_CONST_OR_PURE_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1762 /* Unpack all the non-pointer fields of the TS_TYPE structure
1763 of expression EXPR from bitpack BP. */
1766 unpack_ts_type_value_fields (struct bitpack_d
*bp
, tree expr
)
1768 enum machine_mode mode
;
1770 TYPE_PRECISION (expr
) = (unsigned) bp_unpack_value (bp
, 9);
1771 mode
= (enum machine_mode
) bp_unpack_value (bp
, 7);
1772 SET_TYPE_MODE (expr
, mode
);
1773 TYPE_STRING_FLAG (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1774 TYPE_NO_FORCE_BLK (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1775 TYPE_NEEDS_CONSTRUCTING (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1776 if (RECORD_OR_UNION_TYPE_P (expr
))
1777 TYPE_TRANSPARENT_AGGR (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1778 TYPE_PACKED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1779 TYPE_RESTRICT (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1780 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr
)
1781 = (unsigned) bp_unpack_value (bp
, 2);
1782 TYPE_USER_ALIGN (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1783 TYPE_READONLY (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1784 TYPE_ALIGN (expr
) = (unsigned) bp_unpack_value (bp
, HOST_BITS_PER_INT
);
1785 TYPE_ALIAS_SET (expr
) = bp_unpack_value (bp
, HOST_BITS_PER_INT
);
1789 /* Unpack all the non-pointer fields of the TS_BLOCK structure
1790 of expression EXPR from bitpack BP. */
1793 unpack_ts_block_value_fields (struct bitpack_d
*bp
, tree expr
)
1795 BLOCK_ABSTRACT (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1796 BLOCK_NUMBER (expr
) = (unsigned) bp_unpack_value (bp
, 31);
1800 /* Unpack all the non-pointer fields in EXPR into a bit pack. */
1803 unpack_value_fields (struct bitpack_d
*bp
, tree expr
)
1805 enum tree_code code
;
1807 code
= TREE_CODE (expr
);
1809 /* Note that all these functions are highly sensitive to changes in
1810 the types and sizes of each of the fields being packed. */
1811 unpack_ts_base_value_fields (bp
, expr
);
1813 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
1814 unpack_ts_real_cst_value_fields (bp
, expr
);
1816 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
1817 unpack_ts_fixed_cst_value_fields (bp
, expr
);
1819 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1820 unpack_ts_decl_common_value_fields (bp
, expr
);
1822 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
1823 unpack_ts_decl_wrtl_value_fields (bp
, expr
);
1825 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1826 unpack_ts_decl_with_vis_value_fields (bp
, expr
);
1828 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1829 unpack_ts_function_decl_value_fields (bp
, expr
);
1831 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE
))
1832 unpack_ts_type_value_fields (bp
, expr
);
1834 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
1835 unpack_ts_block_value_fields (bp
, expr
);
1837 if (CODE_CONTAINS_STRUCT (code
, TS_SSA_NAME
))
1839 /* We only stream the version number of SSA names. */
1843 if (CODE_CONTAINS_STRUCT (code
, TS_STATEMENT_LIST
))
1845 /* This is only used by GENERIC. */
1849 if (CODE_CONTAINS_STRUCT (code
, TS_OMP_CLAUSE
))
1851 /* This is only used by High GIMPLE. */
1857 /* Read a bitpack from input block IB. */
1860 lto_input_bitpack (struct lto_input_block
*ib
)
1862 unsigned i
, num_words
;
1863 struct bitpack_d
*bp
;
1865 bp
= bitpack_create ();
1867 /* If we are about to read more than a handful of words, something
1868 is wrong. This check is overly strict, but it acts as an early
1869 warning. No streamed object has hundreds of bits in its fields. */
1870 num_words
= lto_input_uleb128 (ib
);
1871 gcc_assert (num_words
< 20);
1873 for (i
= 0; i
< num_words
; i
++)
1875 bitpack_word_t w
= lto_input_uleb128 (ib
);
1876 VEC_safe_push (bitpack_word_t
, heap
, bp
->values
, w
);
1883 /* Materialize a new tree from input block IB using descriptors in
1884 DATA_IN. The code for the new tree should match TAG. Store in
1885 *IX_P the index into the reader cache where the new tree is stored. */
1888 lto_materialize_tree (struct lto_input_block
*ib
, struct data_in
*data_in
,
1889 enum LTO_tags tag
, int *ix_p
)
1891 struct bitpack_d
*bp
;
1892 enum tree_code code
;
1894 #ifdef LTO_STREAMER_DEBUG
1895 HOST_WIDEST_INT orig_address_in_writer
;
1901 /* Read the header of the node we are about to create. */
1902 ix
= lto_input_sleb128 (ib
);
1903 gcc_assert ((int) ix
== ix
);
1906 #ifdef LTO_STREAMER_DEBUG
1907 /* Read the word representing the memory address for the tree
1908 as it was written by the writer. This is useful when
1909 debugging differences between the writer and reader. */
1910 orig_address_in_writer
= lto_input_sleb128 (ib
);
1911 gcc_assert ((intptr_t) orig_address_in_writer
== orig_address_in_writer
);
1914 code
= lto_tag_to_tree_code (tag
);
1916 /* We should never see an SSA_NAME tree. Only the version numbers of
1917 SSA names are ever written out. See input_ssa_names. */
1918 gcc_assert (code
!= SSA_NAME
);
1920 /* Instantiate a new tree using the header data. */
1921 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
1922 result
= input_string_cst (data_in
, ib
);
1923 else if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
1924 result
= input_identifier (data_in
, ib
);
1925 else if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1927 HOST_WIDE_INT len
= lto_input_sleb128 (ib
);
1928 result
= make_tree_vec (len
);
1930 else if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1932 unsigned HOST_WIDE_INT len
= lto_input_uleb128 (ib
);
1933 result
= make_tree_binfo (len
);
1937 /* All other nodes can be materialized with a raw make_node
1939 result
= make_node (code
);
1942 #ifdef LTO_STREAMER_DEBUG
1943 /* Store the original address of the tree as seen by the writer
1944 in RESULT's aux field. This is useful when debugging streaming
1945 problems. This way, a debugging session can be started on
1946 both writer and reader with a breakpoint using this address
1948 lto_orig_address_map (result
, (intptr_t) orig_address_in_writer
);
1951 /* Read the bitpack of non-pointer values from IB. */
1952 bp
= lto_input_bitpack (ib
);
1954 /* The first word in BP contains the code of the tree that we
1955 are about to read. */
1956 code
= (enum tree_code
) bp_unpack_value (bp
, 16);
1957 lto_tag_check (lto_tree_code_to_tag (code
), tag
);
1959 /* Unpack all the value fields from BP. */
1960 unpack_value_fields (bp
, result
);
1961 bitpack_delete (bp
);
1963 /* Enter RESULT in the reader cache. This will make RESULT
1964 available so that circular references in the rest of the tree
1965 structure can be resolved in subsequent calls to lto_input_tree. */
1966 lto_streamer_cache_insert_at (data_in
->reader_cache
, result
, ix
);
1972 /* Read a chain of tree nodes from input block IB. DATA_IN contains
1973 tables and descriptors for the file being read. */
1976 lto_input_chain (struct lto_input_block
*ib
, struct data_in
*data_in
)
1979 tree first
, prev
, curr
;
1981 first
= prev
= NULL_TREE
;
1982 count
= lto_input_sleb128 (ib
);
1983 for (i
= 0; i
< count
; i
++)
1985 curr
= lto_input_tree (ib
, data_in
);
1987 TREE_CHAIN (prev
) = curr
;
1991 TREE_CHAIN (curr
) = NULL_TREE
;
1999 /* Read all pointer fields in the TS_COMMON structure of EXPR from input
2000 block IB. DATA_IN contains tables and descriptors for the
2005 lto_input_ts_common_tree_pointers (struct lto_input_block
*ib
,
2006 struct data_in
*data_in
, tree expr
)
2008 TREE_TYPE (expr
) = lto_input_tree (ib
, data_in
);
2012 /* Read all pointer fields in the TS_VECTOR structure of EXPR from input
2013 block IB. DATA_IN contains tables and descriptors for the
2017 lto_input_ts_vector_tree_pointers (struct lto_input_block
*ib
,
2018 struct data_in
*data_in
, tree expr
)
2020 TREE_VECTOR_CST_ELTS (expr
) = lto_input_chain (ib
, data_in
);
2024 /* Read all pointer fields in the TS_COMPLEX structure of EXPR from input
2025 block IB. DATA_IN contains tables and descriptors for the
2029 lto_input_ts_complex_tree_pointers (struct lto_input_block
*ib
,
2030 struct data_in
*data_in
, tree expr
)
2032 TREE_REALPART (expr
) = lto_input_tree (ib
, data_in
);
2033 TREE_IMAGPART (expr
) = lto_input_tree (ib
, data_in
);
2037 /* Read all pointer fields in the TS_DECL_MINIMAL structure of EXPR
2038 from input block IB. DATA_IN contains tables and descriptors for the
2042 lto_input_ts_decl_minimal_tree_pointers (struct lto_input_block
*ib
,
2043 struct data_in
*data_in
, tree expr
)
2045 DECL_NAME (expr
) = lto_input_tree (ib
, data_in
);
2046 DECL_CONTEXT (expr
) = lto_input_tree (ib
, data_in
);
2047 DECL_SOURCE_LOCATION (expr
) = lto_input_location (ib
, data_in
);
2051 /* Read all pointer fields in the TS_DECL_COMMON structure of EXPR from
2052 input block IB. DATA_IN contains tables and descriptors for the
2056 lto_input_ts_decl_common_tree_pointers (struct lto_input_block
*ib
,
2057 struct data_in
*data_in
, tree expr
)
2059 DECL_SIZE (expr
) = lto_input_tree (ib
, data_in
);
2060 DECL_SIZE_UNIT (expr
) = lto_input_tree (ib
, data_in
);
2062 if (TREE_CODE (expr
) != FUNCTION_DECL
)
2063 DECL_INITIAL (expr
) = lto_input_tree (ib
, data_in
);
2065 DECL_ATTRIBUTES (expr
) = lto_input_tree (ib
, data_in
);
2066 DECL_ABSTRACT_ORIGIN (expr
) = lto_input_tree (ib
, data_in
);
2068 if (TREE_CODE (expr
) == PARM_DECL
)
2069 TREE_CHAIN (expr
) = lto_input_chain (ib
, data_in
);
2071 if ((TREE_CODE (expr
) == VAR_DECL
2072 || TREE_CODE (expr
) == PARM_DECL
)
2073 && DECL_HAS_VALUE_EXPR_P (expr
))
2074 SET_DECL_VALUE_EXPR (expr
, lto_input_tree (ib
, data_in
));
2078 /* Read all pointer fields in the TS_DECL_NON_COMMON structure of
2079 EXPR from input block IB. DATA_IN contains tables and descriptors for the
2083 lto_input_ts_decl_non_common_tree_pointers (struct lto_input_block
*ib
,
2084 struct data_in
*data_in
, tree expr
)
2086 if (TREE_CODE (expr
) == FUNCTION_DECL
)
2088 DECL_ARGUMENTS (expr
) = lto_input_tree (ib
, data_in
);
2089 DECL_RESULT (expr
) = lto_input_tree (ib
, data_in
);
2091 DECL_VINDEX (expr
) = lto_input_tree (ib
, data_in
);
2095 /* Read all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
2096 from input block IB. DATA_IN contains tables and descriptors for the
2100 lto_input_ts_decl_with_vis_tree_pointers (struct lto_input_block
*ib
,
2101 struct data_in
*data_in
, tree expr
)
2105 id
= lto_input_tree (ib
, data_in
);
2108 gcc_assert (TREE_CODE (id
) == IDENTIFIER_NODE
);
2109 SET_DECL_ASSEMBLER_NAME (expr
, id
);
2112 DECL_SECTION_NAME (expr
) = lto_input_tree (ib
, data_in
);
2113 DECL_COMDAT_GROUP (expr
) = lto_input_tree (ib
, data_in
);
2117 /* Read all pointer fields in the TS_FIELD_DECL structure of EXPR from
2118 input block IB. DATA_IN contains tables and descriptors for the
2122 lto_input_ts_field_decl_tree_pointers (struct lto_input_block
*ib
,
2123 struct data_in
*data_in
, tree expr
)
2125 DECL_FIELD_OFFSET (expr
) = lto_input_tree (ib
, data_in
);
2126 DECL_BIT_FIELD_TYPE (expr
) = lto_input_tree (ib
, data_in
);
2127 DECL_QUALIFIER (expr
) = lto_input_tree (ib
, data_in
);
2128 DECL_FIELD_BIT_OFFSET (expr
) = lto_input_tree (ib
, data_in
);
2129 DECL_FCONTEXT (expr
) = lto_input_tree (ib
, data_in
);
2130 TREE_CHAIN (expr
) = lto_input_chain (ib
, data_in
);
2134 /* Read all pointer fields in the TS_FUNCTION_DECL structure of EXPR
2135 from input block IB. DATA_IN contains tables and descriptors for the
2139 lto_input_ts_function_decl_tree_pointers (struct lto_input_block
*ib
,
2140 struct data_in
*data_in
, tree expr
)
2142 /* DECL_STRUCT_FUNCTION is handled by lto_input_function. FIXME lto,
2143 maybe it should be handled here? */
2144 DECL_FUNCTION_PERSONALITY (expr
) = lto_input_tree (ib
, data_in
);
2145 DECL_FUNCTION_SPECIFIC_TARGET (expr
) = lto_input_tree (ib
, data_in
);
2146 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr
) = lto_input_tree (ib
, data_in
);
2148 /* If the file contains a function with an EH personality set,
2149 then it was compiled with -fexceptions. In that case, initialize
2150 the backend EH machinery. */
2151 if (DECL_FUNCTION_PERSONALITY (expr
))
2156 /* Read all pointer fields in the TS_TYPE structure of EXPR from input
2157 block IB. DATA_IN contains tables and descriptors for the
2161 lto_input_ts_type_tree_pointers (struct lto_input_block
*ib
,
2162 struct data_in
*data_in
, tree expr
)
2164 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
2165 TYPE_VALUES (expr
) = lto_input_tree (ib
, data_in
);
2166 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
2167 TYPE_DOMAIN (expr
) = lto_input_tree (ib
, data_in
);
2168 else if (RECORD_OR_UNION_TYPE_P (expr
))
2169 TYPE_FIELDS (expr
) = lto_input_tree (ib
, data_in
);
2170 else if (TREE_CODE (expr
) == FUNCTION_TYPE
2171 || TREE_CODE (expr
) == METHOD_TYPE
)
2172 TYPE_ARG_TYPES (expr
) = lto_input_tree (ib
, data_in
);
2173 else if (TREE_CODE (expr
) == VECTOR_TYPE
)
2174 TYPE_DEBUG_REPRESENTATION_TYPE (expr
) = lto_input_tree (ib
, data_in
);
2176 TYPE_SIZE (expr
) = lto_input_tree (ib
, data_in
);
2177 TYPE_SIZE_UNIT (expr
) = lto_input_tree (ib
, data_in
);
2178 TYPE_ATTRIBUTES (expr
) = lto_input_tree (ib
, data_in
);
2179 TYPE_NAME (expr
) = lto_input_tree (ib
, data_in
);
2180 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO nor
2181 TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. */
2182 if (!POINTER_TYPE_P (expr
))
2183 TYPE_MINVAL (expr
) = lto_input_tree (ib
, data_in
);
2184 TYPE_MAXVAL (expr
) = lto_input_tree (ib
, data_in
);
2185 TYPE_MAIN_VARIANT (expr
) = lto_input_tree (ib
, data_in
);
2186 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
2188 if (RECORD_OR_UNION_TYPE_P (expr
))
2189 TYPE_BINFO (expr
) = lto_input_tree (ib
, data_in
);
2190 TYPE_CONTEXT (expr
) = lto_input_tree (ib
, data_in
);
2191 TYPE_CANONICAL (expr
) = lto_input_tree (ib
, data_in
);
2192 TYPE_STUB_DECL (expr
) = lto_input_tree (ib
, data_in
);
2196 /* Read all pointer fields in the TS_LIST structure of EXPR from input
2197 block IB. DATA_IN contains tables and descriptors for the
2201 lto_input_ts_list_tree_pointers (struct lto_input_block
*ib
,
2202 struct data_in
*data_in
, tree expr
)
2204 TREE_PURPOSE (expr
) = lto_input_tree (ib
, data_in
);
2205 TREE_VALUE (expr
) = lto_input_tree (ib
, data_in
);
2206 TREE_CHAIN (expr
) = lto_input_chain (ib
, data_in
);
2210 /* Read all pointer fields in the TS_VEC structure of EXPR from input
2211 block IB. DATA_IN contains tables and descriptors for the
2215 lto_input_ts_vec_tree_pointers (struct lto_input_block
*ib
,
2216 struct data_in
*data_in
, tree expr
)
2220 /* Note that TREE_VEC_LENGTH was read by lto_materialize_tree to
2221 instantiate EXPR. */
2222 for (i
= 0; i
< TREE_VEC_LENGTH (expr
); i
++)
2223 TREE_VEC_ELT (expr
, i
) = lto_input_tree (ib
, data_in
);
2227 /* Read all pointer fields in the TS_EXP structure of EXPR from input
2228 block IB. DATA_IN contains tables and descriptors for the
2233 lto_input_ts_exp_tree_pointers (struct lto_input_block
*ib
,
2234 struct data_in
*data_in
, tree expr
)
2239 length
= lto_input_sleb128 (ib
);
2240 gcc_assert (length
== TREE_OPERAND_LENGTH (expr
));
2242 for (i
= 0; i
< length
; i
++)
2243 TREE_OPERAND (expr
, i
) = lto_input_tree (ib
, data_in
);
2245 loc
= lto_input_location (ib
, data_in
);
2246 SET_EXPR_LOCATION (expr
, loc
);
2247 TREE_BLOCK (expr
) = lto_input_tree (ib
, data_in
);
2251 /* Read all pointer fields in the TS_BLOCK structure of EXPR from input
2252 block IB. DATA_IN contains tables and descriptors for the
2256 lto_input_ts_block_tree_pointers (struct lto_input_block
*ib
,
2257 struct data_in
*data_in
, tree expr
)
2261 BLOCK_SOURCE_LOCATION (expr
) = lto_input_location (ib
, data_in
);
2262 BLOCK_VARS (expr
) = lto_input_chain (ib
, data_in
);
2264 len
= lto_input_uleb128 (ib
);
2265 for (i
= 0; i
< len
; i
++)
2267 tree t
= lto_input_tree (ib
, data_in
);
2268 VEC_safe_push (tree
, gc
, BLOCK_NONLOCALIZED_VARS (expr
), t
);
2271 BLOCK_SUPERCONTEXT (expr
) = lto_input_tree (ib
, data_in
);
2272 BLOCK_ABSTRACT_ORIGIN (expr
) = lto_input_tree (ib
, data_in
);
2273 BLOCK_FRAGMENT_ORIGIN (expr
) = lto_input_tree (ib
, data_in
);
2274 BLOCK_FRAGMENT_CHAIN (expr
) = lto_input_tree (ib
, data_in
);
2275 BLOCK_SUBBLOCKS (expr
) = lto_input_chain (ib
, data_in
);
2279 /* Read all pointer fields in the TS_BINFO structure of EXPR from input
2280 block IB. DATA_IN contains tables and descriptors for the
2284 lto_input_ts_binfo_tree_pointers (struct lto_input_block
*ib
,
2285 struct data_in
*data_in
, tree expr
)
2290 /* Note that the number of slots in EXPR was read in
2291 lto_materialize_tree when instantiating EXPR. However, the
2292 vector is empty so we cannot rely on VEC_length to know how many
2293 elements to read. So, this list is emitted as a 0-terminated
2294 list on the writer side. */
2297 t
= lto_input_tree (ib
, data_in
);
2299 VEC_quick_push (tree
, BINFO_BASE_BINFOS (expr
), t
);
2303 BINFO_OFFSET (expr
) = lto_input_tree (ib
, data_in
);
2304 BINFO_VTABLE (expr
) = lto_input_tree (ib
, data_in
);
2305 BINFO_VIRTUALS (expr
) = lto_input_tree (ib
, data_in
);
2306 BINFO_VPTR_FIELD (expr
) = lto_input_tree (ib
, data_in
);
2308 len
= lto_input_uleb128 (ib
);
2309 for (i
= 0; i
< len
; i
++)
2311 tree a
= lto_input_tree (ib
, data_in
);
2312 VEC_safe_push (tree
, gc
, BINFO_BASE_ACCESSES (expr
), a
);
2315 BINFO_INHERITANCE_CHAIN (expr
) = lto_input_tree (ib
, data_in
);
2316 BINFO_SUBVTT_INDEX (expr
) = lto_input_tree (ib
, data_in
);
2317 BINFO_VPTR_INDEX (expr
) = lto_input_tree (ib
, data_in
);
2321 /* Read all pointer fields in the TS_CONSTRUCTOR structure of EXPR from
2322 input block IB. DATA_IN contains tables and descriptors for the
2326 lto_input_ts_constructor_tree_pointers (struct lto_input_block
*ib
,
2327 struct data_in
*data_in
, tree expr
)
2331 len
= lto_input_uleb128 (ib
);
2332 for (i
= 0; i
< len
; i
++)
2336 index
= lto_input_tree (ib
, data_in
);
2337 value
= lto_input_tree (ib
, data_in
);
2338 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (expr
), index
, value
);
2343 /* Helper for lto_input_tree. Read all pointer fields in EXPR from
2344 input block IB. DATA_IN contains tables and descriptors for the
2348 lto_input_tree_pointers (struct lto_input_block
*ib
, struct data_in
*data_in
,
2351 enum tree_code code
;
2353 code
= TREE_CODE (expr
);
2355 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
2356 lto_input_ts_common_tree_pointers (ib
, data_in
, expr
);
2358 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
2359 lto_input_ts_vector_tree_pointers (ib
, data_in
, expr
);
2361 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
2362 lto_input_ts_complex_tree_pointers (ib
, data_in
, expr
);
2364 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
2365 lto_input_ts_decl_minimal_tree_pointers (ib
, data_in
, expr
);
2367 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
2368 lto_input_ts_decl_common_tree_pointers (ib
, data_in
, expr
);
2370 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
2371 lto_input_ts_decl_non_common_tree_pointers (ib
, data_in
, expr
);
2373 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
2374 lto_input_ts_decl_with_vis_tree_pointers (ib
, data_in
, expr
);
2376 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
2377 lto_input_ts_field_decl_tree_pointers (ib
, data_in
, expr
);
2379 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
2380 lto_input_ts_function_decl_tree_pointers (ib
, data_in
, expr
);
2382 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE
))
2383 lto_input_ts_type_tree_pointers (ib
, data_in
, expr
);
2385 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
2386 lto_input_ts_list_tree_pointers (ib
, data_in
, expr
);
2388 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
2389 lto_input_ts_vec_tree_pointers (ib
, data_in
, expr
);
2391 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
2392 lto_input_ts_exp_tree_pointers (ib
, data_in
, expr
);
2394 if (CODE_CONTAINS_STRUCT (code
, TS_SSA_NAME
))
2396 /* We only stream the version number of SSA names. */
2400 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
2401 lto_input_ts_block_tree_pointers (ib
, data_in
, expr
);
2403 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
2404 lto_input_ts_binfo_tree_pointers (ib
, data_in
, expr
);
2406 if (CODE_CONTAINS_STRUCT (code
, TS_STATEMENT_LIST
))
2408 /* This should only appear in GENERIC. */
2412 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
2413 lto_input_ts_constructor_tree_pointers (ib
, data_in
, expr
);
2415 if (CODE_CONTAINS_STRUCT (code
, TS_OMP_CLAUSE
))
2417 /* This should only appear in High GIMPLE. */
2421 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
2423 sorry ("optimization options not supported yet");
2426 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
))
2428 sorry ("target optimization options not supported yet");
2433 /* Register DECL with the global symbol table and change its
2434 name if necessary to avoid name clashes for static globals across
2438 lto_register_var_decl_in_symtab (struct data_in
*data_in
, tree decl
)
2440 /* Register symbols with file or global scope to mark what input
2441 file has their definition. */
2442 if (decl_function_context (decl
) == NULL_TREE
)
2444 /* Variable has file scope, not local. Need to ensure static variables
2445 between different files don't clash unexpectedly. */
2446 if (!TREE_PUBLIC (decl
))
2448 /* ??? We normally pre-mangle names before we serialize them
2449 out. Here, in lto1, we do not know the language, and
2450 thus cannot do the mangling again. Instead, we just
2451 append a suffix to the mangled name. The resulting name,
2452 however, is not a properly-formed mangled name, and will
2453 confuse any attempt to unmangle it. */
2454 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
2457 ASM_FORMAT_PRIVATE_NAME (label
, name
, DECL_UID (decl
));
2458 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (label
));
2459 rest_of_decl_compilation (decl
, 1, 0);
2463 /* If this variable has already been declared, queue the
2464 declaration for merging. */
2465 if (TREE_PUBLIC (decl
))
2468 if (!lto_streamer_cache_lookup (data_in
->reader_cache
, decl
, &ix
))
2470 lto_symtab_register_decl (decl
, get_resolution (data_in
, ix
),
2471 data_in
->file_data
);
2477 /* Register DECL with the global symbol table and change its
2478 name if necessary to avoid name clashes for static globals across
2479 different files. DATA_IN contains descriptors and tables for the
2483 lto_register_function_decl_in_symtab (struct data_in
*data_in
, tree decl
)
2485 /* Need to ensure static entities between different files
2486 don't clash unexpectedly. */
2487 if (!TREE_PUBLIC (decl
))
2489 /* We must not use the DECL_ASSEMBLER_NAME macro here, as it
2490 may set the assembler name where it was previously empty. */
2491 tree old_assembler_name
= decl
->decl_with_vis
.assembler_name
;
2493 /* FIXME lto: We normally pre-mangle names before we serialize
2494 them out. Here, in lto1, we do not know the language, and
2495 thus cannot do the mangling again. Instead, we just append a
2496 suffix to the mangled name. The resulting name, however, is
2497 not a properly-formed mangled name, and will confuse any
2498 attempt to unmangle it. */
2499 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
2502 ASM_FORMAT_PRIVATE_NAME (label
, name
, DECL_UID (decl
));
2503 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (label
));
2505 /* We may arrive here with the old assembler name not set
2506 if the function body is not needed, e.g., it has been
2507 inlined away and does not appear in the cgraph. */
2508 if (old_assembler_name
)
2510 tree new_assembler_name
= DECL_ASSEMBLER_NAME (decl
);
2512 /* Make the original assembler name available for later use.
2513 We may have used it to indicate the section within its
2514 object file where the function body may be found.
2515 FIXME lto: Find a better way to maintain the function decl
2516 to body section mapping so we don't need this hack. */
2517 lto_record_renamed_decl (data_in
->file_data
,
2518 IDENTIFIER_POINTER (old_assembler_name
),
2519 IDENTIFIER_POINTER (new_assembler_name
));
2521 /* Also register the reverse mapping so that we can find the
2522 new name given to an existing assembler name (used when
2523 restoring alias pairs in input_constructors_or_inits. */
2524 lto_record_renamed_decl (data_in
->file_data
,
2525 IDENTIFIER_POINTER (new_assembler_name
),
2526 IDENTIFIER_POINTER (old_assembler_name
));
2530 /* If this variable has already been declared, queue the
2531 declaration for merging. */
2532 if (TREE_PUBLIC (decl
) && !DECL_ABSTRACT (decl
))
2535 if (!lto_streamer_cache_lookup (data_in
->reader_cache
, decl
, &ix
))
2537 lto_symtab_register_decl (decl
, get_resolution (data_in
, ix
),
2538 data_in
->file_data
);
2543 /* Read an index IX from input block IB and return the tree node at
2544 DATA_IN->FILE_DATA->GLOBALS_INDEX[IX]. */
2547 lto_get_pickled_tree (struct lto_input_block
*ib
, struct data_in
*data_in
)
2551 enum LTO_tags expected_tag
;
2552 unsigned HOST_WIDE_INT orig_offset
;
2554 ix
= lto_input_sleb128 (ib
);
2555 expected_tag
= (enum LTO_tags
) lto_input_uleb128 (ib
);
2557 orig_offset
= lto_input_uleb128 (ib
);
2558 gcc_assert (orig_offset
== (unsigned) orig_offset
);
2560 result
= lto_streamer_cache_get (data_in
->reader_cache
, ix
);
2561 if (result
== NULL_TREE
)
2563 /* We have not yet read the cache slot IX. Go to the offset
2564 in the stream where the physical tree node is, and materialize
2566 struct lto_input_block fwd_ib
;
2568 /* If we are trying to go back in the stream, something is wrong.
2569 We should've read the node at the earlier position already. */
2570 if (ib
->p
>= orig_offset
)
2571 internal_error ("bytecode stream: tried to jump backwards in the "
2574 LTO_INIT_INPUT_BLOCK (fwd_ib
, ib
->data
, orig_offset
, ib
->len
);
2575 result
= lto_input_tree (&fwd_ib
, data_in
);
2579 && TREE_CODE (result
) == lto_tag_to_tree_code (expected_tag
));
2585 /* Read a code and class from input block IB and return the
2586 corresponding builtin. DATA_IN is as in lto_input_tree. */
2589 lto_get_builtin_tree (struct lto_input_block
*ib
, struct data_in
*data_in
)
2591 enum built_in_class fclass
;
2592 enum built_in_function fcode
;
2593 const char *asmname
;
2597 fclass
= (enum built_in_class
) lto_input_uleb128 (ib
);
2598 gcc_assert (fclass
== BUILT_IN_NORMAL
|| fclass
== BUILT_IN_MD
);
2600 fcode
= (enum built_in_function
) lto_input_uleb128 (ib
);
2602 ix
= lto_input_sleb128 (ib
);
2603 gcc_assert (ix
== (int) ix
);
2605 if (fclass
== BUILT_IN_NORMAL
)
2607 gcc_assert (fcode
< END_BUILTINS
);
2608 result
= built_in_decls
[fcode
];
2609 gcc_assert (result
);
2611 else if (fclass
== BUILT_IN_MD
)
2613 result
= targetm
.builtin_decl (fcode
, true);
2614 if (!result
|| result
== error_mark_node
)
2615 fatal_error ("target specific builtin not available");
2620 asmname
= input_string (data_in
, ib
);
2622 set_builtin_user_assembler_name (result
, asmname
);
2624 lto_streamer_cache_insert_at (data_in
->reader_cache
, result
, ix
);
2630 /* Read the physical representation of a tree node with tag TAG from
2631 input block IB using the per-file context in DATA_IN. */
2634 lto_read_tree (struct lto_input_block
*ib
, struct data_in
*data_in
,
2640 result
= lto_materialize_tree (ib
, data_in
, tag
, &ix
);
2642 /* Read all the pointer fields in RESULT. */
2643 lto_input_tree_pointers (ib
, data_in
, result
);
2645 /* We should never try to instantiate an MD or NORMAL builtin here. */
2646 if (TREE_CODE (result
) == FUNCTION_DECL
)
2647 gcc_assert (!lto_stream_as_builtin_p (result
));
2649 if (TREE_CODE (result
) == VAR_DECL
)
2650 lto_register_var_decl_in_symtab (data_in
, result
);
2651 else if (TREE_CODE (result
) == FUNCTION_DECL
&& !DECL_BUILT_IN (result
))
2652 lto_register_function_decl_in_symtab (data_in
, result
);
2654 /* end_marker = */ lto_input_1_unsigned (ib
);
2656 #ifdef LTO_STREAMER_DEBUG
2657 /* Remove the mapping to RESULT's original address set by
2658 lto_materialize_tree. */
2659 lto_orig_address_remove (result
);
2666 /* Read and INTEGER_CST node from input block IB using the per-file
2667 context in DATA_IN. */
2670 lto_input_integer_cst (struct lto_input_block
*ib
, struct data_in
*data_in
)
2673 HOST_WIDE_INT low
, high
;
2676 type
= lto_input_tree (ib
, data_in
);
2677 overflow_p
= (lto_input_1_unsigned (ib
) != 0);
2678 low
= lto_input_uleb128 (ib
);
2679 high
= lto_input_uleb128 (ib
);
2680 result
= build_int_cst_wide (type
, low
, high
);
2682 /* If the original constant had overflown, build a replica of RESULT to
2683 avoid modifying the shared constant returned by build_int_cst_wide. */
2686 result
= copy_node (result
);
2687 TREE_OVERFLOW (result
) = 1;
2694 /* Read a tree from input block IB using the per-file context in
2695 DATA_IN. This context is used, for example, to resolve references
2696 to previously read nodes. */
2699 lto_input_tree (struct lto_input_block
*ib
, struct data_in
*data_in
)
2704 tag
= input_record_start (ib
);
2705 gcc_assert ((unsigned) tag
< (unsigned) LTO_NUM_TAGS
);
2707 if (tag
== LTO_null
)
2709 else if (tag
>= LTO_field_decl_ref
&& tag
<= LTO_global_decl_ref
)
2711 /* If TAG is a reference to an indexable tree, the next value
2712 in IB is the index into the table where we expect to find
2714 result
= lto_input_tree_ref (ib
, data_in
, cfun
, tag
);
2716 else if (tag
== LTO_tree_pickle_reference
)
2718 /* If TAG is a reference to a previously read tree, look it up in
2719 the reader cache. */
2720 result
= lto_get_pickled_tree (ib
, data_in
);
2722 else if (tag
== LTO_builtin_decl
)
2724 /* If we are going to read a built-in function, all we need is
2725 the code and class. */
2726 result
= lto_get_builtin_tree (ib
, data_in
);
2728 else if (tag
== lto_tree_code_to_tag (INTEGER_CST
))
2730 /* For integer constants we only need the type and its hi/low
2732 result
= lto_input_integer_cst (ib
, data_in
);
2736 /* Otherwise, materialize a new node from IB. */
2737 result
= lto_read_tree (ib
, data_in
, tag
);
2744 /* Initialization for the LTO reader. */
2747 lto_init_reader (void)
2749 lto_streamer_init ();
2751 memset (<o_stats
, 0, sizeof (lto_stats
));
2752 bitmap_obstack_initialize (NULL
);
2754 file_name_hash_table
= htab_create (37, hash_string_slot_node
,
2755 eq_string_slot_node
, free
);
2757 gimple_register_cfg_hooks ();
2761 /* Create a new data_in object for FILE_DATA. STRINGS is the string
2762 table to use with LEN strings. RESOLUTIONS is the vector of linker
2763 resolutions (NULL if not using a linker plugin). */
2766 lto_data_in_create (struct lto_file_decl_data
*file_data
, const char *strings
,
2768 VEC(ld_plugin_symbol_resolution_t
,heap
) *resolutions
)
2770 struct data_in
*data_in
= XCNEW (struct data_in
);
2771 data_in
->file_data
= file_data
;
2772 data_in
->strings
= strings
;
2773 data_in
->strings_len
= len
;
2774 data_in
->globals_resolution
= resolutions
;
2775 data_in
->reader_cache
= lto_streamer_cache_create ();
2781 /* Remove DATA_IN. */
2784 lto_data_in_delete (struct data_in
*data_in
)
2786 VEC_free (ld_plugin_symbol_resolution_t
, heap
, data_in
->globals_resolution
);
2787 lto_streamer_cache_delete (data_in
->reader_cache
);
2788 free (data_in
->labels
);