1 /* Read the GIMPLE representation from a file stream.
3 Copyright 2009, 2010 Free Software Foundation, Inc.
4 Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
5 Re-implemented by Diego Novillo <dnovillo@google.com>
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
34 #include "basic-block.h"
35 #include "tree-flow.h"
36 #include "tree-pass.h"
40 #include "diagnostic.h"
47 #include "ipa-utils.h"
48 #include "lto-streamer.h"
49 #include "tree-pass.h"
51 /* Data structure used to hash file names in the source_location field. */
55 unsigned int slot_num
;
58 /* The table to hold the file names. */
59 static htab_t file_name_hash_table
;
62 /* Check that tag ACTUAL has one of the given values. NUM_TAGS is the
63 number of valid tag values to check. */
66 lto_tag_check_set (enum LTO_tags actual
, int ntags
, ...)
72 for (i
= 0; i
< ntags
; i
++)
73 if ((unsigned) actual
== va_arg (ap
, unsigned))
80 internal_error ("bytecode stream: unexpected tag %s", lto_tag_name (actual
));
84 /* Check that tag ACTUAL is in the range [TAG1, TAG2]. */
87 lto_tag_check_range (enum LTO_tags actual
, enum LTO_tags tag1
,
90 if (actual
< tag1
|| actual
> tag2
)
91 internal_error ("bytecode stream: tag %s is not in the expected range "
93 lto_tag_name (actual
),
99 /* Check that tag ACTUAL == EXPECTED. */
102 lto_tag_check (enum LTO_tags actual
, enum LTO_tags expected
)
104 if (actual
!= expected
)
105 internal_error ("bytecode stream: expected tag %s instead of %s",
106 lto_tag_name (expected
), lto_tag_name (actual
));
110 /* Return a hash code for P. */
113 hash_string_slot_node (const void *p
)
115 const struct string_slot
*ds
= (const struct string_slot
*) p
;
116 return (hashval_t
) htab_hash_string (ds
->s
);
120 /* Returns nonzero if P1 and P2 are equal. */
123 eq_string_slot_node (const void *p1
, const void *p2
)
125 const struct string_slot
*ds1
= (const struct string_slot
*) p1
;
126 const struct string_slot
*ds2
= (const struct string_slot
*) p2
;
127 return strcmp (ds1
->s
, ds2
->s
) == 0;
131 /* Read a string from the string table in DATA_IN using input block
132 IB. Write the length to RLEN. */
135 string_for_index (struct data_in
*data_in
,
139 struct lto_input_block str_tab
;
149 /* Get the string stored at location LOC in DATA_IN->STRINGS. */
150 LTO_INIT_INPUT_BLOCK (str_tab
, data_in
->strings
, loc
- 1, data_in
->strings_len
);
151 len
= lto_input_uleb128 (&str_tab
);
154 if (str_tab
.p
+ len
> data_in
->strings_len
)
155 internal_error ("bytecode stream: string too long for the string table");
157 result
= (const char *)(data_in
->strings
+ str_tab
.p
);
163 /* Read a string from the string table in DATA_IN using input block
164 IB. Write the length to RLEN. */
167 input_string_internal (struct data_in
*data_in
, struct lto_input_block
*ib
,
170 return string_for_index (data_in
, lto_input_uleb128 (ib
), rlen
);
174 /* Read a STRING_CST from the string table in DATA_IN using input
178 input_string_cst (struct data_in
*data_in
, struct lto_input_block
*ib
)
183 ptr
= input_string_internal (data_in
, ib
, &len
);
186 return build_string (len
, ptr
);
190 /* Read an IDENTIFIER from the string table in DATA_IN using input
194 input_identifier (struct data_in
*data_in
, struct lto_input_block
*ib
)
199 ptr
= input_string_internal (data_in
, ib
, &len
);
202 return get_identifier_with_length (ptr
, len
);
206 /* Read LENGTH bytes from STREAM to ADDR. */
209 lto_input_data_block (struct lto_input_block
*ib
, void *addr
, size_t length
)
212 unsigned char *const buffer
= (unsigned char *const) addr
;
214 for (i
= 0; i
< length
; i
++)
215 buffer
[i
] = lto_input_1_unsigned (ib
);
219 /* Read a NULL terminated string from the string table in DATA_IN. */
222 lto_input_string (struct data_in
*data_in
, struct lto_input_block
*ib
)
227 ptr
= input_string_internal (data_in
, ib
, &len
);
230 if (ptr
[len
- 1] != '\0')
231 internal_error ("bytecode stream: found non-null terminated string");
237 /* Return the next tag in the input block IB. */
239 static inline enum LTO_tags
240 input_record_start (struct lto_input_block
*ib
)
242 return lto_input_enum (ib
, LTO_tags
, LTO_NUM_TAGS
);
246 /* Lookup STRING in file_name_hash_table. If found, return the existing
247 string, otherwise insert STRING as the canonical version. */
250 canon_file_name (const char *string
)
253 struct string_slot s_slot
;
256 slot
= htab_find_slot (file_name_hash_table
, &s_slot
, INSERT
);
261 struct string_slot
*new_slot
;
263 len
= strlen (string
);
264 saved_string
= (char *) xmalloc (len
+ 1);
265 new_slot
= XCNEW (struct string_slot
);
266 strcpy (saved_string
, string
);
267 new_slot
->s
= saved_string
;
273 struct string_slot
*old_slot
= (struct string_slot
*) *slot
;
279 /* Clear the line info stored in DATA_IN. */
282 clear_line_info (struct data_in
*data_in
)
284 if (data_in
->current_file
)
285 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
286 data_in
->current_file
= NULL
;
287 data_in
->current_line
= 0;
288 data_in
->current_col
= 0;
292 /* Read a location bitpack from input block IB. */
295 lto_input_location_bitpack (struct data_in
*data_in
, struct bitpack_d
*bp
)
297 bool file_change
, line_change
, column_change
;
299 bool prev_file
= data_in
->current_file
!= NULL
;
301 if (bp_unpack_value (bp
, 1))
302 return UNKNOWN_LOCATION
;
304 file_change
= bp_unpack_value (bp
, 1);
306 data_in
->current_file
= canon_file_name
307 (string_for_index (data_in
,
308 bp_unpack_var_len_unsigned (bp
),
311 line_change
= bp_unpack_value (bp
, 1);
313 data_in
->current_line
= bp_unpack_var_len_unsigned (bp
);
315 column_change
= bp_unpack_value (bp
, 1);
317 data_in
->current_col
= bp_unpack_var_len_unsigned (bp
);
322 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
324 linemap_add (line_table
, LC_ENTER
, false, data_in
->current_file
,
325 data_in
->current_line
);
327 else if (line_change
)
328 linemap_line_start (line_table
, data_in
->current_line
, data_in
->current_col
);
330 return linemap_position_for_column (line_table
, data_in
->current_col
);
334 /* Read a location from input block IB. */
337 lto_input_location (struct lto_input_block
*ib
, struct data_in
*data_in
)
341 bp
= lto_input_bitpack (ib
);
342 return lto_input_location_bitpack (data_in
, &bp
);
346 /* Read a reference to a tree node from DATA_IN using input block IB.
347 TAG is the expected node that should be found in IB, if TAG belongs
348 to one of the indexable trees, expect to read a reference index to
349 be looked up in one of the symbol tables, otherwise read the pysical
350 representation of the tree using lto_input_tree. FN is the
351 function scope for the read tree. */
354 lto_input_tree_ref (struct lto_input_block
*ib
, struct data_in
*data_in
,
355 struct function
*fn
, enum LTO_tags tag
)
357 unsigned HOST_WIDE_INT ix_u
;
358 tree result
= NULL_TREE
;
360 lto_tag_check_range (tag
, LTO_field_decl_ref
, LTO_global_decl_ref
);
365 ix_u
= lto_input_uleb128 (ib
);
366 result
= lto_file_decl_data_get_type (data_in
->file_data
, ix_u
);
369 case LTO_ssa_name_ref
:
370 ix_u
= lto_input_uleb128 (ib
);
371 result
= VEC_index (tree
, SSANAMES (fn
), ix_u
);
374 case LTO_field_decl_ref
:
375 ix_u
= lto_input_uleb128 (ib
);
376 result
= lto_file_decl_data_get_field_decl (data_in
->file_data
, ix_u
);
379 case LTO_function_decl_ref
:
380 ix_u
= lto_input_uleb128 (ib
);
381 result
= lto_file_decl_data_get_fn_decl (data_in
->file_data
, ix_u
);
384 case LTO_type_decl_ref
:
385 ix_u
= lto_input_uleb128 (ib
);
386 result
= lto_file_decl_data_get_type_decl (data_in
->file_data
, ix_u
);
389 case LTO_namespace_decl_ref
:
390 ix_u
= lto_input_uleb128 (ib
);
391 result
= lto_file_decl_data_get_namespace_decl (data_in
->file_data
, ix_u
);
394 case LTO_global_decl_ref
:
395 case LTO_result_decl_ref
:
396 case LTO_const_decl_ref
:
397 case LTO_imported_decl_ref
:
398 case LTO_label_decl_ref
:
399 case LTO_translation_unit_decl_ref
:
400 ix_u
= lto_input_uleb128 (ib
);
401 result
= lto_file_decl_data_get_var_decl (data_in
->file_data
, ix_u
);
414 /* Read a chain of tree nodes from input block IB. DATA_IN contains
415 tables and descriptors for the file being read. */
418 lto_input_chain (struct lto_input_block
*ib
, struct data_in
*data_in
)
421 tree first
, prev
, curr
;
423 first
= prev
= NULL_TREE
;
424 count
= lto_input_sleb128 (ib
);
425 for (i
= 0; i
< count
; i
++)
427 curr
= lto_input_tree (ib
, data_in
);
429 TREE_CHAIN (prev
) = curr
;
433 TREE_CHAIN (curr
) = NULL_TREE
;
441 /* Read and return a double-linked list of catch handlers from input
442 block IB, using descriptors in DATA_IN. */
444 static struct eh_catch_d
*
445 lto_input_eh_catch_list (struct lto_input_block
*ib
, struct data_in
*data_in
,
451 *last_p
= first
= NULL
;
452 tag
= input_record_start (ib
);
458 lto_tag_check_range (tag
, LTO_eh_catch
, LTO_eh_catch
);
460 /* Read the catch node. */
461 n
= ggc_alloc_cleared_eh_catch_d ();
462 n
->type_list
= lto_input_tree (ib
, data_in
);
463 n
->filter_list
= lto_input_tree (ib
, data_in
);
464 n
->label
= lto_input_tree (ib
, data_in
);
466 /* Register all the types in N->FILTER_LIST. */
467 for (list
= n
->filter_list
; list
; list
= TREE_CHAIN (list
))
468 add_type_for_runtime (TREE_VALUE (list
));
470 /* Chain N to the end of the list. */
472 (*last_p
)->next_catch
= n
;
473 n
->prev_catch
= *last_p
;
476 /* Set the head of the list the first time through the loop. */
480 tag
= input_record_start (ib
);
487 /* Read and return EH region IX from input block IB, using descriptors
491 input_eh_region (struct lto_input_block
*ib
, struct data_in
*data_in
, int ix
)
496 /* Read the region header. */
497 tag
= input_record_start (ib
);
501 r
= ggc_alloc_cleared_eh_region_d ();
502 r
->index
= lto_input_sleb128 (ib
);
504 gcc_assert (r
->index
== ix
);
506 /* Read all the region pointers as region numbers. We'll fix up
507 the pointers once the whole array has been read. */
508 r
->outer
= (eh_region
) (intptr_t) lto_input_sleb128 (ib
);
509 r
->inner
= (eh_region
) (intptr_t) lto_input_sleb128 (ib
);
510 r
->next_peer
= (eh_region
) (intptr_t) lto_input_sleb128 (ib
);
514 case LTO_ert_cleanup
:
515 r
->type
= ERT_CLEANUP
;
520 struct eh_catch_d
*last_catch
;
522 r
->u
.eh_try
.first_catch
= lto_input_eh_catch_list (ib
, data_in
,
524 r
->u
.eh_try
.last_catch
= last_catch
;
528 case LTO_ert_allowed_exceptions
:
532 r
->type
= ERT_ALLOWED_EXCEPTIONS
;
533 r
->u
.allowed
.type_list
= lto_input_tree (ib
, data_in
);
534 r
->u
.allowed
.label
= lto_input_tree (ib
, data_in
);
535 r
->u
.allowed
.filter
= lto_input_uleb128 (ib
);
537 for (l
= r
->u
.allowed
.type_list
; l
; l
= TREE_CHAIN (l
))
538 add_type_for_runtime (TREE_VALUE (l
));
542 case LTO_ert_must_not_throw
:
543 r
->type
= ERT_MUST_NOT_THROW
;
544 r
->u
.must_not_throw
.failure_decl
= lto_input_tree (ib
, data_in
);
545 r
->u
.must_not_throw
.failure_loc
= lto_input_location (ib
, data_in
);
552 r
->landing_pads
= (eh_landing_pad
) (intptr_t) lto_input_sleb128 (ib
);
558 /* Read and return EH landing pad IX from input block IB, using descriptors
561 static eh_landing_pad
562 input_eh_lp (struct lto_input_block
*ib
, struct data_in
*data_in
, int ix
)
567 /* Read the landing pad header. */
568 tag
= input_record_start (ib
);
572 lto_tag_check_range (tag
, LTO_eh_landing_pad
, LTO_eh_landing_pad
);
574 lp
= ggc_alloc_cleared_eh_landing_pad_d ();
575 lp
->index
= lto_input_sleb128 (ib
);
576 gcc_assert (lp
->index
== ix
);
577 lp
->next_lp
= (eh_landing_pad
) (intptr_t) lto_input_sleb128 (ib
);
578 lp
->region
= (eh_region
) (intptr_t) lto_input_sleb128 (ib
);
579 lp
->post_landing_pad
= lto_input_tree (ib
, data_in
);
585 /* After reading the EH regions, pointers to peer and children regions
586 are region numbers. This converts all these region numbers into
587 real pointers into the rematerialized regions for FN. ROOT_REGION
588 is the region number for the root EH region in FN. */
591 fixup_eh_region_pointers (struct function
*fn
, HOST_WIDE_INT root_region
)
594 VEC(eh_region
,gc
) *eh_array
= fn
->eh
->region_array
;
595 VEC(eh_landing_pad
,gc
) *lp_array
= fn
->eh
->lp_array
;
599 gcc_assert (eh_array
&& lp_array
);
601 gcc_assert (root_region
>= 0);
602 fn
->eh
->region_tree
= VEC_index (eh_region
, eh_array
, root_region
);
604 #define FIXUP_EH_REGION(r) (r) = VEC_index (eh_region, eh_array, \
605 (HOST_WIDE_INT) (intptr_t) (r))
606 #define FIXUP_EH_LP(p) (p) = VEC_index (eh_landing_pad, lp_array, \
607 (HOST_WIDE_INT) (intptr_t) (p))
609 /* Convert all the index numbers stored in pointer fields into
610 pointers to the corresponding slots in the EH region array. */
611 FOR_EACH_VEC_ELT (eh_region
, eh_array
, i
, r
)
613 /* The array may contain NULL regions. */
617 gcc_assert (i
== (unsigned) r
->index
);
618 FIXUP_EH_REGION (r
->outer
);
619 FIXUP_EH_REGION (r
->inner
);
620 FIXUP_EH_REGION (r
->next_peer
);
621 FIXUP_EH_LP (r
->landing_pads
);
624 /* Convert all the index numbers stored in pointer fields into
625 pointers to the corresponding slots in the EH landing pad array. */
626 FOR_EACH_VEC_ELT (eh_landing_pad
, lp_array
, i
, lp
)
628 /* The array may contain NULL landing pads. */
632 gcc_assert (i
== (unsigned) lp
->index
);
633 FIXUP_EH_LP (lp
->next_lp
);
634 FIXUP_EH_REGION (lp
->region
);
637 #undef FIXUP_EH_REGION
642 /* Initialize EH support. */
647 static bool eh_initialized_p
= false;
649 if (eh_initialized_p
)
652 /* Contrary to most other FEs, we only initialize EH support when at
653 least one of the files in the set contains exception regions in
654 it. Since this happens much later than the call to init_eh in
655 lang_dependent_init, we have to set flag_exceptions and call
656 init_eh again to initialize the EH tables. */
660 /* Initialize dwarf2 tables. Since dwarf2out_do_frame() returns
661 true only when exceptions are enabled, this initialization is
662 never done during lang_dependent_init. */
663 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
664 if (dwarf2out_do_frame ())
665 dwarf2out_frame_init ();
668 eh_initialized_p
= true;
672 /* Read the exception table for FN from IB using the data descriptors
676 input_eh_regions (struct lto_input_block
*ib
, struct data_in
*data_in
,
679 HOST_WIDE_INT i
, root_region
, len
;
682 tag
= input_record_start (ib
);
686 lto_tag_check_range (tag
, LTO_eh_table
, LTO_eh_table
);
688 /* If the file contains EH regions, then it was compiled with
689 -fexceptions. In that case, initialize the backend EH
695 root_region
= lto_input_sleb128 (ib
);
696 gcc_assert (root_region
== (int) root_region
);
698 /* Read the EH region array. */
699 len
= lto_input_sleb128 (ib
);
700 gcc_assert (len
== (int) len
);
703 VEC_safe_grow (eh_region
, gc
, fn
->eh
->region_array
, len
);
704 for (i
= 0; i
< len
; i
++)
706 eh_region r
= input_eh_region (ib
, data_in
, i
);
707 VEC_replace (eh_region
, fn
->eh
->region_array
, i
, r
);
711 /* Read the landing pads. */
712 len
= lto_input_sleb128 (ib
);
713 gcc_assert (len
== (int) len
);
716 VEC_safe_grow (eh_landing_pad
, gc
, fn
->eh
->lp_array
, len
);
717 for (i
= 0; i
< len
; i
++)
719 eh_landing_pad lp
= input_eh_lp (ib
, data_in
, i
);
720 VEC_replace (eh_landing_pad
, fn
->eh
->lp_array
, i
, lp
);
724 /* Read the runtime type data. */
725 len
= lto_input_sleb128 (ib
);
726 gcc_assert (len
== (int) len
);
729 VEC_safe_grow (tree
, gc
, fn
->eh
->ttype_data
, len
);
730 for (i
= 0; i
< len
; i
++)
732 tree ttype
= lto_input_tree (ib
, data_in
);
733 VEC_replace (tree
, fn
->eh
->ttype_data
, i
, ttype
);
737 /* Read the table of action chains. */
738 len
= lto_input_sleb128 (ib
);
739 gcc_assert (len
== (int) len
);
742 if (targetm
.arm_eabi_unwinder
)
744 VEC_safe_grow (tree
, gc
, fn
->eh
->ehspec_data
.arm_eabi
, len
);
745 for (i
= 0; i
< len
; i
++)
747 tree t
= lto_input_tree (ib
, data_in
);
748 VEC_replace (tree
, fn
->eh
->ehspec_data
.arm_eabi
, i
, t
);
753 VEC_safe_grow (uchar
, gc
, fn
->eh
->ehspec_data
.other
, len
);
754 for (i
= 0; i
< len
; i
++)
756 uchar c
= lto_input_1_unsigned (ib
);
757 VEC_replace (uchar
, fn
->eh
->ehspec_data
.other
, i
, c
);
762 /* Reconstruct the EH region tree by fixing up the peer/children
764 fixup_eh_region_pointers (fn
, root_region
);
766 tag
= input_record_start (ib
);
767 lto_tag_check_range (tag
, LTO_null
, LTO_null
);
771 /* Make a new basic block with index INDEX in function FN. */
774 make_new_block (struct function
*fn
, unsigned int index
)
776 basic_block bb
= alloc_block ();
778 SET_BASIC_BLOCK_FOR_FUNCTION (fn
, index
, bb
);
779 bb
->il
.gimple
= ggc_alloc_cleared_gimple_bb_info ();
780 n_basic_blocks_for_function (fn
)++;
782 set_bb_seq (bb
, gimple_seq_alloc ());
787 /* Read the CFG for function FN from input block IB. */
790 input_cfg (struct lto_input_block
*ib
, struct function
*fn
,
791 int count_materialization_scale
)
793 unsigned int bb_count
;
798 init_empty_tree_cfg_for_function (fn
);
799 init_ssa_operands ();
801 profile_status_for_function (fn
) = lto_input_enum (ib
, profile_status_d
, PROFILE_LAST
);
803 bb_count
= lto_input_uleb128 (ib
);
805 last_basic_block_for_function (fn
) = bb_count
;
806 if (bb_count
> VEC_length (basic_block
, basic_block_info_for_function (fn
)))
807 VEC_safe_grow_cleared (basic_block
, gc
,
808 basic_block_info_for_function (fn
), bb_count
);
810 if (bb_count
> VEC_length (basic_block
, label_to_block_map_for_function (fn
)))
811 VEC_safe_grow_cleared (basic_block
, gc
,
812 label_to_block_map_for_function (fn
), bb_count
);
814 index
= lto_input_sleb128 (ib
);
817 basic_block bb
= BASIC_BLOCK_FOR_FUNCTION (fn
, index
);
818 unsigned int edge_count
;
821 bb
= make_new_block (fn
, index
);
823 edge_count
= lto_input_uleb128 (ib
);
825 /* Connect up the CFG. */
826 for (i
= 0; i
< edge_count
; i
++)
828 unsigned int dest_index
;
829 unsigned int edge_flags
;
835 dest_index
= lto_input_uleb128 (ib
);
836 probability
= (int) lto_input_sleb128 (ib
);
837 count
= ((gcov_type
) lto_input_sleb128 (ib
) * count_materialization_scale
838 + REG_BR_PROB_BASE
/ 2) / REG_BR_PROB_BASE
;
839 edge_flags
= lto_input_uleb128 (ib
);
841 dest
= BASIC_BLOCK_FOR_FUNCTION (fn
, dest_index
);
844 dest
= make_new_block (fn
, dest_index
);
846 e
= make_edge (bb
, dest
, edge_flags
);
847 e
->probability
= probability
;
851 index
= lto_input_sleb128 (ib
);
854 p_bb
= ENTRY_BLOCK_PTR_FOR_FUNCTION(fn
);
855 index
= lto_input_sleb128 (ib
);
858 basic_block bb
= BASIC_BLOCK_FOR_FUNCTION (fn
, index
);
862 index
= lto_input_sleb128 (ib
);
867 /* Read a PHI function for basic block BB in function FN. DATA_IN is
868 the file being read. IB is the input block to use for reading. */
871 input_phi (struct lto_input_block
*ib
, basic_block bb
, struct data_in
*data_in
,
874 unsigned HOST_WIDE_INT ix
;
879 ix
= lto_input_uleb128 (ib
);
880 phi_result
= VEC_index (tree
, SSANAMES (fn
), ix
);
881 len
= EDGE_COUNT (bb
->preds
);
882 result
= create_phi_node (phi_result
, bb
);
883 SSA_NAME_DEF_STMT (phi_result
) = result
;
885 /* We have to go through a lookup process here because the preds in the
886 reconstructed graph are generally in a different order than they
887 were in the original program. */
888 for (i
= 0; i
< len
; i
++)
890 tree def
= lto_input_tree (ib
, data_in
);
891 int src_index
= lto_input_uleb128 (ib
);
892 location_t arg_loc
= lto_input_location (ib
, data_in
);
893 basic_block sbb
= BASIC_BLOCK_FOR_FUNCTION (fn
, src_index
);
898 for (j
= 0; j
< len
; j
++)
899 if (EDGE_PRED (bb
, j
)->src
== sbb
)
901 e
= EDGE_PRED (bb
, j
);
905 add_phi_arg (result
, def
, e
, arg_loc
);
912 /* Read the SSA names array for function FN from DATA_IN using input
916 input_ssa_names (struct lto_input_block
*ib
, struct data_in
*data_in
,
919 unsigned int i
, size
;
921 size
= lto_input_uleb128 (ib
);
922 init_ssanames (fn
, size
);
924 i
= lto_input_uleb128 (ib
);
930 /* Skip over the elements that had been freed. */
931 while (VEC_length (tree
, SSANAMES (fn
)) < i
)
932 VEC_quick_push (tree
, SSANAMES (fn
), NULL_TREE
);
934 is_default_def
= (lto_input_1_unsigned (ib
) != 0);
935 name
= lto_input_tree (ib
, data_in
);
936 ssa_name
= make_ssa_name_fn (fn
, name
, gimple_build_nop ());
939 set_default_def (SSA_NAME_VAR (ssa_name
), ssa_name
);
941 i
= lto_input_uleb128 (ib
);
945 /* Read a statement with tag TAG in function FN from block IB using
946 descriptors in DATA_IN. */
949 input_gimple_stmt (struct lto_input_block
*ib
, struct data_in
*data_in
,
950 struct function
*fn
, enum LTO_tags tag
)
953 enum gimple_code code
;
954 unsigned HOST_WIDE_INT num_ops
;
958 code
= lto_tag_to_gimple_code (tag
);
960 /* Read the tuple header. */
961 bp
= lto_input_bitpack (ib
);
962 num_ops
= bp_unpack_var_len_unsigned (&bp
);
963 stmt
= gimple_alloc (code
, num_ops
);
964 stmt
->gsbase
.no_warning
= bp_unpack_value (&bp
, 1);
965 if (is_gimple_assign (stmt
))
966 stmt
->gsbase
.nontemporal_move
= bp_unpack_value (&bp
, 1);
967 stmt
->gsbase
.has_volatile_ops
= bp_unpack_value (&bp
, 1);
968 stmt
->gsbase
.subcode
= bp_unpack_var_len_unsigned (&bp
);
970 /* Read location information. */
971 gimple_set_location (stmt
, lto_input_location (ib
, data_in
));
973 /* Read lexical block reference. */
974 gimple_set_block (stmt
, lto_input_tree (ib
, data_in
));
976 /* Read in all the operands. */
980 gimple_resx_set_region (stmt
, lto_input_sleb128 (ib
));
983 case GIMPLE_EH_MUST_NOT_THROW
:
984 gimple_eh_must_not_throw_set_fndecl (stmt
, lto_input_tree (ib
, data_in
));
987 case GIMPLE_EH_DISPATCH
:
988 gimple_eh_dispatch_set_region (stmt
, lto_input_sleb128 (ib
));
993 /* FIXME lto. Move most of this into a new gimple_asm_set_string(). */
995 stmt
->gimple_asm
.ni
= lto_input_uleb128 (ib
);
996 stmt
->gimple_asm
.no
= lto_input_uleb128 (ib
);
997 stmt
->gimple_asm
.nc
= lto_input_uleb128 (ib
);
998 stmt
->gimple_asm
.nl
= lto_input_uleb128 (ib
);
999 str
= input_string_cst (data_in
, ib
);
1000 stmt
->gimple_asm
.string
= TREE_STRING_POINTER (str
);
1012 for (i
= 0; i
< num_ops
; i
++)
1014 tree op
= lto_input_tree (ib
, data_in
);
1015 gimple_set_op (stmt
, i
, op
);
1019 /* Fixup FIELD_DECLs in COMPONENT_REFs, they are not handled
1021 if (TREE_CODE (op
) == ADDR_EXPR
)
1022 op
= TREE_OPERAND (op
, 0);
1023 while (handled_component_p (op
))
1025 if (TREE_CODE (op
) == COMPONENT_REF
)
1027 tree field
, type
, tem
;
1028 tree closest_match
= NULL_TREE
;
1029 field
= TREE_OPERAND (op
, 1);
1030 type
= DECL_CONTEXT (field
);
1031 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
1035 if (DECL_NONADDRESSABLE_P (tem
)
1036 == DECL_NONADDRESSABLE_P (field
)
1037 && gimple_compare_field_offset (tem
, field
))
1039 if (types_compatible_p (TREE_TYPE (tem
),
1043 closest_match
= tem
;
1046 /* In case of type mismatches across units we can fail
1047 to unify some types and thus not find a proper
1049 if (tem
== NULL_TREE
)
1051 /* Thus, emit a ODR violation warning. */
1052 if (warning_at (gimple_location (stmt
), 0,
1053 "use of type %<%E%> with two mismatching "
1054 "declarations at field %<%E%>",
1055 type
, TREE_OPERAND (op
, 1)))
1057 if (TYPE_FIELDS (type
))
1058 inform (DECL_SOURCE_LOCATION (TYPE_FIELDS (type
)),
1059 "original type declared here");
1060 inform (DECL_SOURCE_LOCATION (TREE_OPERAND (op
, 1)),
1061 "field in mismatching type declared here");
1062 if (TYPE_NAME (TREE_TYPE (field
))
1063 && (TREE_CODE (TYPE_NAME (TREE_TYPE (field
)))
1065 inform (DECL_SOURCE_LOCATION
1066 (TYPE_NAME (TREE_TYPE (field
))),
1067 "type of field declared here");
1069 && TYPE_NAME (TREE_TYPE (closest_match
))
1070 && (TREE_CODE (TYPE_NAME
1071 (TREE_TYPE (closest_match
))) == TYPE_DECL
))
1072 inform (DECL_SOURCE_LOCATION
1073 (TYPE_NAME (TREE_TYPE (closest_match
))),
1074 "type of mismatching field declared here");
1076 /* And finally fixup the types. */
1077 TREE_OPERAND (op
, 0)
1078 = build1 (VIEW_CONVERT_EXPR
, type
,
1079 TREE_OPERAND (op
, 0));
1082 TREE_OPERAND (op
, 1) = tem
;
1085 op
= TREE_OPERAND (op
, 0);
1088 if (is_gimple_call (stmt
))
1090 if (gimple_call_internal_p (stmt
))
1091 gimple_call_set_internal_fn
1092 (stmt
, lto_input_enum (ib
, internal_fn
, IFN_LAST
));
1094 gimple_call_set_fntype (stmt
, lto_input_tree (ib
, data_in
));
1099 case GIMPLE_PREDICT
:
1103 internal_error ("bytecode stream: unknown GIMPLE statement tag %s",
1104 lto_tag_name (tag
));
1107 /* Update the properties of symbols, SSA names and labels associated
1109 if (code
== GIMPLE_ASSIGN
|| code
== GIMPLE_CALL
)
1111 tree lhs
= gimple_get_lhs (stmt
);
1112 if (lhs
&& TREE_CODE (lhs
) == SSA_NAME
)
1113 SSA_NAME_DEF_STMT (lhs
) = stmt
;
1115 else if (code
== GIMPLE_LABEL
)
1116 gcc_assert (emit_label_in_global_context_p (gimple_label_label (stmt
))
1117 || DECL_CONTEXT (gimple_label_label (stmt
)) == fn
->decl
);
1118 else if (code
== GIMPLE_ASM
)
1122 for (i
= 0; i
< gimple_asm_noutputs (stmt
); i
++)
1124 tree op
= TREE_VALUE (gimple_asm_output_op (stmt
, i
));
1125 if (TREE_CODE (op
) == SSA_NAME
)
1126 SSA_NAME_DEF_STMT (op
) = stmt
;
1130 /* Reset alias information. */
1131 if (code
== GIMPLE_CALL
)
1132 gimple_call_reset_alias_info (stmt
);
1134 /* Mark the statement modified so its operand vectors can be filled in. */
1135 gimple_set_modified (stmt
, true);
1141 /* Read a basic block with tag TAG from DATA_IN using input block IB.
1142 FN is the function being processed. */
1145 input_bb (struct lto_input_block
*ib
, enum LTO_tags tag
,
1146 struct data_in
*data_in
, struct function
*fn
,
1147 int count_materialization_scale
)
1151 gimple_stmt_iterator bsi
;
1153 /* This routine assumes that CFUN is set to FN, as it needs to call
1154 basic GIMPLE routines that use CFUN. */
1155 gcc_assert (cfun
== fn
);
1157 index
= lto_input_uleb128 (ib
);
1158 bb
= BASIC_BLOCK_FOR_FUNCTION (fn
, index
);
1160 bb
->count
= (lto_input_sleb128 (ib
) * count_materialization_scale
1161 + REG_BR_PROB_BASE
/ 2) / REG_BR_PROB_BASE
;
1162 bb
->loop_depth
= lto_input_sleb128 (ib
);
1163 bb
->frequency
= lto_input_sleb128 (ib
);
1164 bb
->flags
= lto_input_sleb128 (ib
);
1166 /* LTO_bb1 has statements. LTO_bb0 does not. */
1170 bsi
= gsi_start_bb (bb
);
1171 tag
= input_record_start (ib
);
1174 gimple stmt
= input_gimple_stmt (ib
, data_in
, fn
, tag
);
1175 if (!is_gimple_debug (stmt
))
1176 find_referenced_vars_in (stmt
);
1177 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1179 /* After the statement, expect a 0 delimiter or the EH region
1180 that the previous statement belongs to. */
1181 tag
= input_record_start (ib
);
1182 lto_tag_check_set (tag
, 2, LTO_eh_region
, LTO_null
);
1184 if (tag
== LTO_eh_region
)
1186 HOST_WIDE_INT region
= lto_input_sleb128 (ib
);
1187 gcc_assert (region
== (int) region
);
1188 add_stmt_to_eh_lp (stmt
, region
);
1191 tag
= input_record_start (ib
);
1194 tag
= input_record_start (ib
);
1197 gimple phi
= input_phi (ib
, bb
, data_in
, fn
);
1198 find_referenced_vars_in (phi
);
1199 tag
= input_record_start (ib
);
1203 /* Go through all NODE edges and fixup call_stmt pointers
1204 so they point to STMTS. */
1207 fixup_call_stmt_edges_1 (struct cgraph_node
*node
, gimple
*stmts
)
1209 struct cgraph_edge
*cedge
;
1210 for (cedge
= node
->callees
; cedge
; cedge
= cedge
->next_callee
)
1211 cedge
->call_stmt
= stmts
[cedge
->lto_stmt_uid
];
1212 for (cedge
= node
->indirect_calls
; cedge
; cedge
= cedge
->next_callee
)
1213 cedge
->call_stmt
= stmts
[cedge
->lto_stmt_uid
];
1216 /* Fixup call_stmt pointers in NODE and all clones. */
1219 fixup_call_stmt_edges (struct cgraph_node
*orig
, gimple
*stmts
)
1221 struct cgraph_node
*node
;
1223 while (orig
->clone_of
)
1224 orig
= orig
->clone_of
;
1226 fixup_call_stmt_edges_1 (orig
, stmts
);
1228 for (node
= orig
->clones
; node
!= orig
;)
1230 fixup_call_stmt_edges_1 (node
, stmts
);
1232 node
= node
->clones
;
1233 else if (node
->next_sibling_clone
)
1234 node
= node
->next_sibling_clone
;
1237 while (node
!= orig
&& !node
->next_sibling_clone
)
1238 node
= node
->clone_of
;
1240 node
= node
->next_sibling_clone
;
1245 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1248 input_function (tree fn_decl
, struct data_in
*data_in
,
1249 struct lto_input_block
*ib
)
1251 struct function
*fn
;
1255 struct bitpack_d bp
;
1256 struct cgraph_node
*node
;
1257 tree args
, narg
, oarg
;
1260 fn
= DECL_STRUCT_FUNCTION (fn_decl
);
1261 tag
= input_record_start (ib
);
1262 clear_line_info (data_in
);
1264 gimple_register_cfg_hooks ();
1265 lto_tag_check (tag
, LTO_function
);
1267 /* Read all the attributes for FN. */
1268 bp
= lto_input_bitpack (ib
);
1269 fn
->is_thunk
= bp_unpack_value (&bp
, 1);
1270 fn
->has_local_explicit_reg_vars
= bp_unpack_value (&bp
, 1);
1271 fn
->after_tree_profile
= bp_unpack_value (&bp
, 1);
1272 fn
->returns_pcc_struct
= bp_unpack_value (&bp
, 1);
1273 fn
->returns_struct
= bp_unpack_value (&bp
, 1);
1274 fn
->can_throw_non_call_exceptions
= bp_unpack_value (&bp
, 1);
1275 fn
->always_inline_functions_inlined
= bp_unpack_value (&bp
, 1);
1276 fn
->after_inlining
= bp_unpack_value (&bp
, 1);
1277 fn
->stdarg
= bp_unpack_value (&bp
, 1);
1278 fn
->has_nonlocal_label
= bp_unpack_value (&bp
, 1);
1279 fn
->calls_alloca
= bp_unpack_value (&bp
, 1);
1280 fn
->calls_setjmp
= bp_unpack_value (&bp
, 1);
1281 fn
->va_list_fpr_size
= bp_unpack_value (&bp
, 8);
1282 fn
->va_list_gpr_size
= bp_unpack_value (&bp
, 8);
1284 /* Input the function start and end loci. */
1285 fn
->function_start_locus
= lto_input_location (ib
, data_in
);
1286 fn
->function_end_locus
= lto_input_location (ib
, data_in
);
1288 /* Input the current IL state of the function. */
1289 fn
->curr_properties
= lto_input_uleb128 (ib
);
1291 /* Read the static chain and non-local goto save area. */
1292 fn
->static_chain_decl
= lto_input_tree (ib
, data_in
);
1293 fn
->nonlocal_goto_save_area
= lto_input_tree (ib
, data_in
);
1295 /* Read all the local symbols. */
1296 len
= lto_input_sleb128 (ib
);
1300 VEC_safe_grow (tree
, gc
, fn
->local_decls
, len
);
1301 for (i
= 0; i
< len
; i
++)
1303 tree t
= lto_input_tree (ib
, data_in
);
1304 VEC_replace (tree
, fn
->local_decls
, i
, t
);
1308 /* Read all function arguments. We need to re-map them here to the
1309 arguments of the merged function declaration. */
1310 args
= lto_input_tree (ib
, data_in
);
1311 for (oarg
= args
, narg
= DECL_ARGUMENTS (fn_decl
);
1313 oarg
= TREE_CHAIN (oarg
), narg
= TREE_CHAIN (narg
))
1317 res
= lto_streamer_cache_lookup (data_in
->reader_cache
, oarg
, &ix
);
1319 /* Replace the argument in the streamer cache. */
1320 lto_streamer_cache_insert_at (data_in
->reader_cache
, narg
, ix
);
1322 gcc_assert (!oarg
&& !narg
);
1324 /* Read all the SSA names. */
1325 input_ssa_names (ib
, data_in
, fn
);
1327 /* Read the exception handling regions in the function. */
1328 input_eh_regions (ib
, data_in
, fn
);
1330 /* Read the tree of lexical scopes for the function. */
1331 DECL_INITIAL (fn_decl
) = lto_input_tree (ib
, data_in
);
1332 gcc_assert (DECL_INITIAL (fn_decl
));
1333 DECL_SAVED_TREE (fn_decl
) = NULL_TREE
;
1334 node
= cgraph_get_create_node (fn_decl
);
1336 /* Read all the basic blocks. */
1337 tag
= input_record_start (ib
);
1340 input_bb (ib
, tag
, data_in
, fn
,
1341 node
->count_materialization_scale
);
1342 tag
= input_record_start (ib
);
1345 /* Fix up the call statements that are mentioned in the callgraph
1347 set_gimple_stmt_max_uid (cfun
, 0);
1350 gimple_stmt_iterator gsi
;
1351 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1353 gimple stmt
= gsi_stmt (gsi
);
1354 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
1357 stmts
= (gimple
*) xcalloc (gimple_stmt_max_uid (fn
), sizeof (gimple
));
1360 gimple_stmt_iterator bsi
= gsi_start_bb (bb
);
1361 while (!gsi_end_p (bsi
))
1363 gimple stmt
= gsi_stmt (bsi
);
1364 /* If we're recompiling LTO objects with debug stmts but
1365 we're not supposed to have debug stmts, remove them now.
1366 We can't remove them earlier because this would cause uid
1367 mismatches in fixups, but we can do it at this point, as
1368 long as debug stmts don't require fixups. */
1369 if (!MAY_HAVE_DEBUG_STMTS
&& is_gimple_debug (stmt
))
1371 gimple_stmt_iterator gsi
= bsi
;
1373 gsi_remove (&gsi
, true);
1378 stmts
[gimple_uid (stmt
)] = stmt
;
1383 /* Set the gimple body to the statement sequence in the entry
1384 basic block. FIXME lto, this is fairly hacky. The existence
1385 of a gimple body is used by the cgraph routines, but we should
1386 really use the presence of the CFG. */
1388 edge_iterator ei
= ei_start (ENTRY_BLOCK_PTR
->succs
);
1389 gimple_set_body (fn_decl
, bb_seq (ei_edge (ei
)->dest
));
1392 fixup_call_stmt_edges (node
, stmts
);
1393 execute_all_ipa_stmt_fixups (node
, stmts
);
1395 update_ssa (TODO_update_ssa_only_virtuals
);
1396 free_dominance_info (CDI_DOMINATORS
);
1397 free_dominance_info (CDI_POST_DOMINATORS
);
1402 /* Read initializer expressions for public statics. DATA_IN is the
1403 file being read. IB is the input block used for reading. */
1406 input_alias_pairs (struct lto_input_block
*ib
, struct data_in
*data_in
)
1410 clear_line_info (data_in
);
1412 var
= lto_input_tree (ib
, data_in
);
1415 const char *orig_name
, *new_name
;
1418 p
= VEC_safe_push (alias_pair
, gc
, alias_pairs
, NULL
);
1420 p
->target
= lto_input_tree (ib
, data_in
);
1422 /* If the target is a static object, we may have registered a
1423 new name for it to avoid clashes between statics coming from
1424 different files. In that case, use the new name. */
1425 orig_name
= IDENTIFIER_POINTER (p
->target
);
1426 new_name
= lto_get_decl_name_mapping (data_in
->file_data
, orig_name
);
1427 if (strcmp (orig_name
, new_name
) != 0)
1428 p
->target
= get_identifier (new_name
);
1430 var
= lto_input_tree (ib
, data_in
);
1435 /* Read the body from DATA for function FN_DECL and fill it in.
1436 FILE_DATA are the global decls and types. SECTION_TYPE is either
1437 LTO_section_function_body or LTO_section_static_initializer. If
1438 section type is LTO_section_function_body, FN must be the decl for
1442 lto_read_body (struct lto_file_decl_data
*file_data
, tree fn_decl
,
1443 const char *data
, enum lto_section_type section_type
)
1445 const struct lto_function_header
*header
;
1446 struct data_in
*data_in
;
1448 int32_t main_offset
;
1449 int32_t string_offset
;
1450 struct lto_input_block ib_cfg
;
1451 struct lto_input_block ib_main
;
1453 header
= (const struct lto_function_header
*) data
;
1454 cfg_offset
= sizeof (struct lto_function_header
);
1455 main_offset
= cfg_offset
+ header
->cfg_size
;
1456 string_offset
= main_offset
+ header
->main_size
;
1458 LTO_INIT_INPUT_BLOCK (ib_cfg
,
1463 LTO_INIT_INPUT_BLOCK (ib_main
,
1468 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
1469 header
->string_size
, NULL
);
1471 /* Make sure the file was generated by the exact same compiler. */
1472 lto_check_version (header
->lto_header
.major_version
,
1473 header
->lto_header
.minor_version
);
1475 if (section_type
== LTO_section_function_body
)
1477 struct function
*fn
= DECL_STRUCT_FUNCTION (fn_decl
);
1478 struct lto_in_decl_state
*decl_state
;
1479 struct cgraph_node
*node
= cgraph_get_node (fn_decl
);
1481 gcc_checking_assert (node
);
1485 /* Use the function's decl state. */
1486 decl_state
= lto_get_function_in_decl_state (file_data
, fn_decl
);
1487 gcc_assert (decl_state
);
1488 file_data
->current_decl_state
= decl_state
;
1490 input_cfg (&ib_cfg
, fn
, node
->count_materialization_scale
);
1492 /* Set up the struct function. */
1493 input_function (fn_decl
, data_in
, &ib_main
);
1495 /* We should now be in SSA. */
1496 cfun
->gimple_df
->in_ssa_p
= true;
1498 /* Restore decl state */
1499 file_data
->current_decl_state
= file_data
->global_decl_state
;
1505 input_alias_pairs (&ib_main
, data_in
);
1508 clear_line_info (data_in
);
1509 lto_data_in_delete (data_in
);
1513 /* Read the body of FN_DECL using DATA. FILE_DATA holds the global
1517 lto_input_function_body (struct lto_file_decl_data
*file_data
,
1518 tree fn_decl
, const char *data
)
1520 current_function_decl
= fn_decl
;
1521 lto_read_body (file_data
, fn_decl
, data
, LTO_section_function_body
);
1525 /* Read in VAR_DECL using DATA. FILE_DATA holds the global decls and
1529 lto_input_constructors_and_inits (struct lto_file_decl_data
*file_data
,
1532 lto_read_body (file_data
, NULL
, data
, LTO_section_static_initializer
);
1536 /* Unpack all the non-pointer fields of the TS_BASE structure of
1537 expression EXPR from bitpack BP. */
1540 unpack_ts_base_value_fields (struct bitpack_d
*bp
, tree expr
)
1542 /* Note that the code for EXPR has already been unpacked to create EXPR in
1543 lto_materialize_tree. */
1546 TREE_SIDE_EFFECTS (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1547 TREE_CONSTANT (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1548 TREE_READONLY (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1550 /* TREE_PUBLIC is used on types to indicate that the type
1551 has a TYPE_CACHED_VALUES vector. This is not streamed out,
1552 so we skip it here. */
1553 TREE_PUBLIC (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1556 bp_unpack_value (bp
, 4);
1557 TREE_ADDRESSABLE (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1558 TREE_THIS_VOLATILE (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1560 DECL_UNSIGNED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1561 else if (TYPE_P (expr
))
1562 TYPE_UNSIGNED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1564 bp_unpack_value (bp
, 1);
1565 TREE_ASM_WRITTEN (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1566 TREE_NO_WARNING (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1567 TREE_USED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1568 TREE_NOTHROW (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1569 TREE_STATIC (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1570 TREE_PRIVATE (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1571 TREE_PROTECTED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1572 TREE_DEPRECATED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1574 TYPE_SATURATING (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1575 else if (TREE_CODE (expr
) == SSA_NAME
)
1576 SSA_NAME_IS_DEFAULT_DEF (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1578 bp_unpack_value (bp
, 1);
1582 /* Unpack all the non-pointer fields of the TS_REAL_CST structure of
1583 expression EXPR from bitpack BP. */
1586 unpack_ts_real_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
1590 REAL_VALUE_TYPE
*rp
;
1592 r
.cl
= (unsigned) bp_unpack_value (bp
, 2);
1593 r
.decimal
= (unsigned) bp_unpack_value (bp
, 1);
1594 r
.sign
= (unsigned) bp_unpack_value (bp
, 1);
1595 r
.signalling
= (unsigned) bp_unpack_value (bp
, 1);
1596 r
.canonical
= (unsigned) bp_unpack_value (bp
, 1);
1597 r
.uexp
= (unsigned) bp_unpack_value (bp
, EXP_BITS
);
1598 for (i
= 0; i
< SIGSZ
; i
++)
1599 r
.sig
[i
] = (unsigned long) bp_unpack_value (bp
, HOST_BITS_PER_LONG
);
1601 rp
= ggc_alloc_real_value ();
1602 memcpy (rp
, &r
, sizeof (REAL_VALUE_TYPE
));
1603 TREE_REAL_CST_PTR (expr
) = rp
;
1607 /* Unpack all the non-pointer fields of the TS_FIXED_CST structure of
1608 expression EXPR from bitpack BP. */
1611 unpack_ts_fixed_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
1613 struct fixed_value fv
;
1615 fv
.mode
= bp_unpack_enum (bp
, machine_mode
, MAX_MACHINE_MODE
);
1616 fv
.data
.low
= bp_unpack_var_len_int (bp
);
1617 fv
.data
.high
= bp_unpack_var_len_int (bp
);
1618 TREE_FIXED_CST (expr
) = fv
;
1622 /* Unpack all the non-pointer fields of the TS_DECL_COMMON structure
1623 of expression EXPR from bitpack BP. */
1626 unpack_ts_decl_common_value_fields (struct bitpack_d
*bp
, tree expr
)
1628 DECL_MODE (expr
) = bp_unpack_enum (bp
, machine_mode
, MAX_MACHINE_MODE
);
1629 DECL_NONLOCAL (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1630 DECL_VIRTUAL_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1631 DECL_IGNORED_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1632 DECL_ABSTRACT (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1633 DECL_ARTIFICIAL (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1634 DECL_USER_ALIGN (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1635 DECL_PRESERVE_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1636 DECL_DEBUG_EXPR_IS_FROM (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1637 DECL_EXTERNAL (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1638 DECL_GIMPLE_REG_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1639 DECL_ALIGN (expr
) = (unsigned) bp_unpack_var_len_unsigned (bp
);
1641 if (TREE_CODE (expr
) == LABEL_DECL
)
1643 DECL_ERROR_ISSUED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1644 EH_LANDING_PAD_NR (expr
) = (int) bp_unpack_var_len_unsigned (bp
);
1646 /* Always assume an initial value of -1 for LABEL_DECL_UID to
1647 force gimple_set_bb to recreate label_to_block_map. */
1648 LABEL_DECL_UID (expr
) = -1;
1651 if (TREE_CODE (expr
) == FIELD_DECL
)
1653 DECL_PACKED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1654 DECL_NONADDRESSABLE_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1655 expr
->decl_common
.off_align
= bp_unpack_value (bp
, 8);
1658 if (TREE_CODE (expr
) == RESULT_DECL
1659 || TREE_CODE (expr
) == PARM_DECL
1660 || TREE_CODE (expr
) == VAR_DECL
)
1662 DECL_BY_REFERENCE (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1663 if (TREE_CODE (expr
) == VAR_DECL
1664 || TREE_CODE (expr
) == PARM_DECL
)
1665 DECL_HAS_VALUE_EXPR_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1666 DECL_RESTRICTED_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1671 /* Unpack all the non-pointer fields of the TS_DECL_WRTL structure
1672 of expression EXPR from bitpack BP. */
1675 unpack_ts_decl_wrtl_value_fields (struct bitpack_d
*bp
, tree expr
)
1677 DECL_REGISTER (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1681 /* Unpack all the non-pointer fields of the TS_DECL_WITH_VIS structure
1682 of expression EXPR from bitpack BP. */
1685 unpack_ts_decl_with_vis_value_fields (struct bitpack_d
*bp
, tree expr
)
1687 DECL_DEFER_OUTPUT (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1688 DECL_COMMON (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1689 DECL_DLLIMPORT_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1690 DECL_WEAK (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1691 DECL_SEEN_IN_BIND_EXPR_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1692 DECL_COMDAT (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1693 DECL_VISIBILITY (expr
) = (enum symbol_visibility
) bp_unpack_value (bp
, 2);
1694 DECL_VISIBILITY_SPECIFIED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1696 if (TREE_CODE (expr
) == VAR_DECL
)
1698 DECL_HARD_REGISTER (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1699 DECL_IN_TEXT_SECTION (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1700 DECL_IN_CONSTANT_POOL (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1701 DECL_TLS_MODEL (expr
) = (enum tls_model
) bp_unpack_value (bp
, 3);
1704 if (VAR_OR_FUNCTION_DECL_P (expr
))
1707 p
= (priority_type
) bp_unpack_var_len_unsigned (bp
);
1708 SET_DECL_INIT_PRIORITY (expr
, p
);
1713 /* Unpack all the non-pointer fields of the TS_FUNCTION_DECL structure
1714 of expression EXPR from bitpack BP. */
1717 unpack_ts_function_decl_value_fields (struct bitpack_d
*bp
, tree expr
)
1719 DECL_BUILT_IN_CLASS (expr
) = bp_unpack_enum (bp
, built_in_class
,
1721 DECL_STATIC_CONSTRUCTOR (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1722 DECL_STATIC_DESTRUCTOR (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1723 DECL_UNINLINABLE (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1724 DECL_POSSIBLY_INLINED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1725 DECL_IS_NOVOPS (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1726 DECL_IS_RETURNS_TWICE (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1727 DECL_IS_MALLOC (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1728 DECL_IS_OPERATOR_NEW (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1729 DECL_DECLARED_INLINE_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1730 DECL_STATIC_CHAIN (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1731 DECL_NO_INLINE_WARNING_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1732 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr
)
1733 = (unsigned) bp_unpack_value (bp
, 1);
1734 DECL_NO_LIMIT_STACK (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1735 DECL_DISREGARD_INLINE_LIMITS (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1736 DECL_PURE_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1737 DECL_LOOPING_CONST_OR_PURE_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1738 if (DECL_BUILT_IN_CLASS (expr
) != NOT_BUILT_IN
)
1740 DECL_FUNCTION_CODE (expr
) = (enum built_in_function
) bp_unpack_value (bp
, 11);
1741 if (DECL_BUILT_IN_CLASS (expr
) == BUILT_IN_NORMAL
1742 && DECL_FUNCTION_CODE (expr
) >= END_BUILTINS
)
1743 fatal_error ("machine independent builtin code out of range");
1744 else if (DECL_BUILT_IN_CLASS (expr
) == BUILT_IN_MD
)
1746 tree result
= targetm
.builtin_decl (DECL_FUNCTION_CODE (expr
), true);
1747 if (!result
|| result
== error_mark_node
)
1748 fatal_error ("target specific builtin not available");
1751 if (DECL_STATIC_DESTRUCTOR (expr
))
1754 p
= (priority_type
) bp_unpack_var_len_unsigned (bp
);
1755 SET_DECL_FINI_PRIORITY (expr
, p
);
1760 /* Unpack all the non-pointer fields of the TS_TYPE_COMMON structure
1761 of expression EXPR from bitpack BP. */
1764 unpack_ts_type_common_value_fields (struct bitpack_d
*bp
, tree expr
)
1766 enum machine_mode mode
;
1768 mode
= bp_unpack_enum (bp
, machine_mode
, MAX_MACHINE_MODE
);
1769 SET_TYPE_MODE (expr
, mode
);
1770 TYPE_STRING_FLAG (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1771 TYPE_NO_FORCE_BLK (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1772 TYPE_NEEDS_CONSTRUCTING (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1773 if (RECORD_OR_UNION_TYPE_P (expr
))
1774 TYPE_TRANSPARENT_AGGR (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1775 TYPE_PACKED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1776 TYPE_RESTRICT (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1777 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr
)
1778 = (unsigned) bp_unpack_value (bp
, 2);
1779 TYPE_USER_ALIGN (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1780 TYPE_READONLY (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1781 TYPE_PRECISION (expr
) = bp_unpack_var_len_unsigned (bp
);
1782 TYPE_ALIGN (expr
) = bp_unpack_var_len_unsigned (bp
);
1783 TYPE_ALIAS_SET (expr
) = bp_unpack_var_len_int (bp
);
1787 /* Unpack all the non-pointer fields of the TS_BLOCK structure
1788 of expression EXPR from bitpack BP. */
1791 unpack_ts_block_value_fields (struct bitpack_d
*bp
, tree expr
)
1793 BLOCK_ABSTRACT (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1794 /* BLOCK_NUMBER is recomputed. */
1797 /* Unpack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL
1798 structure of expression EXPR from bitpack BP. */
1801 unpack_ts_translation_unit_decl_value_fields (struct bitpack_d
*bp ATTRIBUTE_UNUSED
, tree expr ATTRIBUTE_UNUSED
)
1805 /* Unpack all the non-pointer fields in EXPR into a bit pack. */
1808 unpack_value_fields (struct bitpack_d
*bp
, tree expr
)
1810 enum tree_code code
;
1812 code
= TREE_CODE (expr
);
1814 /* Note that all these functions are highly sensitive to changes in
1815 the types and sizes of each of the fields being packed. */
1816 unpack_ts_base_value_fields (bp
, expr
);
1818 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
1819 unpack_ts_real_cst_value_fields (bp
, expr
);
1821 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
1822 unpack_ts_fixed_cst_value_fields (bp
, expr
);
1824 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1825 unpack_ts_decl_common_value_fields (bp
, expr
);
1827 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
1828 unpack_ts_decl_wrtl_value_fields (bp
, expr
);
1830 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1831 unpack_ts_decl_with_vis_value_fields (bp
, expr
);
1833 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1834 unpack_ts_function_decl_value_fields (bp
, expr
);
1836 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
1837 unpack_ts_type_common_value_fields (bp
, expr
);
1839 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
1840 unpack_ts_block_value_fields (bp
, expr
);
1842 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
1843 unpack_ts_translation_unit_decl_value_fields (bp
, expr
);
1847 /* Materialize a new tree from input block IB using descriptors in
1848 DATA_IN. The code for the new tree should match TAG. Store in
1849 *IX_P the index into the reader cache where the new tree is stored. */
1852 lto_materialize_tree (struct lto_input_block
*ib
, struct data_in
*data_in
,
1855 struct bitpack_d bp
;
1856 enum tree_code code
;
1858 #ifdef LTO_STREAMER_DEBUG
1859 HOST_WIDEST_INT orig_address_in_writer
;
1864 #ifdef LTO_STREAMER_DEBUG
1865 /* Read the word representing the memory address for the tree
1866 as it was written by the writer. This is useful when
1867 debugging differences between the writer and reader. */
1868 orig_address_in_writer
= lto_input_sleb128 (ib
);
1869 gcc_assert ((intptr_t) orig_address_in_writer
== orig_address_in_writer
);
1872 code
= lto_tag_to_tree_code (tag
);
1874 /* We should never see an SSA_NAME tree. Only the version numbers of
1875 SSA names are ever written out. See input_ssa_names. */
1876 gcc_assert (code
!= SSA_NAME
);
1878 /* Instantiate a new tree using the header data. */
1879 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
1880 result
= input_string_cst (data_in
, ib
);
1881 else if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
1882 result
= input_identifier (data_in
, ib
);
1883 else if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1885 HOST_WIDE_INT len
= lto_input_sleb128 (ib
);
1886 result
= make_tree_vec (len
);
1888 else if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1890 unsigned HOST_WIDE_INT len
= lto_input_uleb128 (ib
);
1891 result
= make_tree_binfo (len
);
1895 /* All other nodes can be materialized with a raw make_node call. */
1896 result
= make_node (code
);
1899 #ifdef LTO_STREAMER_DEBUG
1900 /* Store the original address of the tree as seen by the writer
1901 in RESULT's aux field. This is useful when debugging streaming
1902 problems. This way, a debugging session can be started on
1903 both writer and reader with a breakpoint using this address
1905 lto_orig_address_map (result
, (intptr_t) orig_address_in_writer
);
1908 /* Read the bitpack of non-pointer values from IB. */
1909 bp
= lto_input_bitpack (ib
);
1911 /* The first word in BP contains the code of the tree that we
1912 are about to read. */
1913 code
= (enum tree_code
) bp_unpack_value (&bp
, 16);
1914 lto_tag_check (lto_tree_code_to_tag (code
), tag
);
1916 /* Unpack all the value fields from BP. */
1917 unpack_value_fields (&bp
, result
);
1919 /* Enter RESULT in the reader cache. This will make RESULT
1920 available so that circular references in the rest of the tree
1921 structure can be resolved in subsequent calls to lto_input_tree. */
1922 lto_streamer_cache_append (data_in
->reader_cache
, result
);
1928 /* Read all pointer fields in the TS_COMMON structure of EXPR from input
1929 block IB. DATA_IN contains tables and descriptors for the
1934 lto_input_ts_common_tree_pointers (struct lto_input_block
*ib
,
1935 struct data_in
*data_in
, tree expr
)
1937 if (TREE_CODE (expr
) != IDENTIFIER_NODE
)
1938 TREE_TYPE (expr
) = lto_input_tree (ib
, data_in
);
1942 /* Read all pointer fields in the TS_VECTOR structure of EXPR from input
1943 block IB. DATA_IN contains tables and descriptors for the
1947 lto_input_ts_vector_tree_pointers (struct lto_input_block
*ib
,
1948 struct data_in
*data_in
, tree expr
)
1950 TREE_VECTOR_CST_ELTS (expr
) = lto_input_chain (ib
, data_in
);
1954 /* Read all pointer fields in the TS_COMPLEX structure of EXPR from input
1955 block IB. DATA_IN contains tables and descriptors for the
1959 lto_input_ts_complex_tree_pointers (struct lto_input_block
*ib
,
1960 struct data_in
*data_in
, tree expr
)
1962 TREE_REALPART (expr
) = lto_input_tree (ib
, data_in
);
1963 TREE_IMAGPART (expr
) = lto_input_tree (ib
, data_in
);
1967 /* Read all pointer fields in the TS_DECL_MINIMAL structure of EXPR
1968 from input block IB. DATA_IN contains tables and descriptors for the
1972 lto_input_ts_decl_minimal_tree_pointers (struct lto_input_block
*ib
,
1973 struct data_in
*data_in
, tree expr
)
1975 DECL_NAME (expr
) = lto_input_tree (ib
, data_in
);
1976 DECL_CONTEXT (expr
) = lto_input_tree (ib
, data_in
);
1977 DECL_SOURCE_LOCATION (expr
) = lto_input_location (ib
, data_in
);
1981 /* Read all pointer fields in the TS_DECL_COMMON structure of EXPR from
1982 input block IB. DATA_IN contains tables and descriptors for the
1986 lto_input_ts_decl_common_tree_pointers (struct lto_input_block
*ib
,
1987 struct data_in
*data_in
, tree expr
)
1989 DECL_SIZE (expr
) = lto_input_tree (ib
, data_in
);
1990 DECL_SIZE_UNIT (expr
) = lto_input_tree (ib
, data_in
);
1992 if (TREE_CODE (expr
) != FUNCTION_DECL
1993 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
1994 DECL_INITIAL (expr
) = lto_input_tree (ib
, data_in
);
1996 DECL_ATTRIBUTES (expr
) = lto_input_tree (ib
, data_in
);
1997 /* Do not stream DECL_ABSTRACT_ORIGIN. We cannot handle debug information
1998 for early inlining so drop it on the floor instead of ICEing in
2001 if (TREE_CODE (expr
) == PARM_DECL
)
2002 TREE_CHAIN (expr
) = lto_input_chain (ib
, data_in
);
2004 if ((TREE_CODE (expr
) == VAR_DECL
2005 || TREE_CODE (expr
) == PARM_DECL
)
2006 && DECL_HAS_VALUE_EXPR_P (expr
))
2007 SET_DECL_VALUE_EXPR (expr
, lto_input_tree (ib
, data_in
));
2009 if (TREE_CODE (expr
) == VAR_DECL
)
2011 tree dexpr
= lto_input_tree (ib
, data_in
);
2013 SET_DECL_DEBUG_EXPR (expr
, dexpr
);
2018 /* Read all pointer fields in the TS_DECL_NON_COMMON structure of
2019 EXPR from input block IB. DATA_IN contains tables and descriptors for the
2023 lto_input_ts_decl_non_common_tree_pointers (struct lto_input_block
*ib
,
2024 struct data_in
*data_in
, tree expr
)
2026 if (TREE_CODE (expr
) == FUNCTION_DECL
)
2028 DECL_ARGUMENTS (expr
) = lto_input_tree (ib
, data_in
);
2029 DECL_RESULT (expr
) = lto_input_tree (ib
, data_in
);
2031 DECL_VINDEX (expr
) = lto_input_tree (ib
, data_in
);
2035 /* Read all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
2036 from input block IB. DATA_IN contains tables and descriptors for the
2040 lto_input_ts_decl_with_vis_tree_pointers (struct lto_input_block
*ib
,
2041 struct data_in
*data_in
, tree expr
)
2045 id
= lto_input_tree (ib
, data_in
);
2048 gcc_assert (TREE_CODE (id
) == IDENTIFIER_NODE
);
2049 SET_DECL_ASSEMBLER_NAME (expr
, id
);
2052 DECL_SECTION_NAME (expr
) = lto_input_tree (ib
, data_in
);
2053 DECL_COMDAT_GROUP (expr
) = lto_input_tree (ib
, data_in
);
2057 /* Read all pointer fields in the TS_FIELD_DECL structure of EXPR from
2058 input block IB. DATA_IN contains tables and descriptors for the
2062 lto_input_ts_field_decl_tree_pointers (struct lto_input_block
*ib
,
2063 struct data_in
*data_in
, tree expr
)
2065 DECL_FIELD_OFFSET (expr
) = lto_input_tree (ib
, data_in
);
2066 DECL_BIT_FIELD_TYPE (expr
) = lto_input_tree (ib
, data_in
);
2067 DECL_QUALIFIER (expr
) = lto_input_tree (ib
, data_in
);
2068 DECL_FIELD_BIT_OFFSET (expr
) = lto_input_tree (ib
, data_in
);
2069 DECL_FCONTEXT (expr
) = lto_input_tree (ib
, data_in
);
2070 TREE_CHAIN (expr
) = lto_input_chain (ib
, data_in
);
2074 /* Read all pointer fields in the TS_FUNCTION_DECL structure of EXPR
2075 from input block IB. DATA_IN contains tables and descriptors for the
2079 lto_input_ts_function_decl_tree_pointers (struct lto_input_block
*ib
,
2080 struct data_in
*data_in
, tree expr
)
2082 /* DECL_STRUCT_FUNCTION is handled by lto_input_function. FIXME lto,
2083 maybe it should be handled here? */
2084 DECL_FUNCTION_PERSONALITY (expr
) = lto_input_tree (ib
, data_in
);
2085 DECL_FUNCTION_SPECIFIC_TARGET (expr
) = lto_input_tree (ib
, data_in
);
2086 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr
) = lto_input_tree (ib
, data_in
);
2088 /* If the file contains a function with an EH personality set,
2089 then it was compiled with -fexceptions. In that case, initialize
2090 the backend EH machinery. */
2091 if (DECL_FUNCTION_PERSONALITY (expr
))
2096 /* Read all pointer fields in the TS_TYPE_COMMON structure of EXPR from
2097 input block IB. DATA_IN contains tables and descriptors for the file
2101 lto_input_ts_type_common_tree_pointers (struct lto_input_block
*ib
,
2102 struct data_in
*data_in
, tree expr
)
2104 TYPE_SIZE (expr
) = lto_input_tree (ib
, data_in
);
2105 TYPE_SIZE_UNIT (expr
) = lto_input_tree (ib
, data_in
);
2106 TYPE_ATTRIBUTES (expr
) = lto_input_tree (ib
, data_in
);
2107 TYPE_NAME (expr
) = lto_input_tree (ib
, data_in
);
2108 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
2109 reconstructed during fixup. */
2110 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
2112 TYPE_MAIN_VARIANT (expr
) = lto_input_tree (ib
, data_in
);
2113 TYPE_CONTEXT (expr
) = lto_input_tree (ib
, data_in
);
2114 /* TYPE_CANONICAL gets re-computed during type merging. */
2115 TYPE_CANONICAL (expr
) = NULL_TREE
;
2116 TYPE_STUB_DECL (expr
) = lto_input_tree (ib
, data_in
);
2119 /* Read all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
2120 from input block IB. DATA_IN contains tables and descriptors for the
2124 lto_input_ts_type_non_common_tree_pointers (struct lto_input_block
*ib
,
2125 struct data_in
*data_in
,
2128 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
2129 TYPE_VALUES (expr
) = lto_input_tree (ib
, data_in
);
2130 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
2131 TYPE_DOMAIN (expr
) = lto_input_tree (ib
, data_in
);
2132 else if (RECORD_OR_UNION_TYPE_P (expr
))
2133 TYPE_FIELDS (expr
) = lto_input_tree (ib
, data_in
);
2134 else if (TREE_CODE (expr
) == FUNCTION_TYPE
2135 || TREE_CODE (expr
) == METHOD_TYPE
)
2136 TYPE_ARG_TYPES (expr
) = lto_input_tree (ib
, data_in
);
2138 if (!POINTER_TYPE_P (expr
))
2139 TYPE_MINVAL (expr
) = lto_input_tree (ib
, data_in
);
2140 TYPE_MAXVAL (expr
) = lto_input_tree (ib
, data_in
);
2141 if (RECORD_OR_UNION_TYPE_P (expr
))
2142 TYPE_BINFO (expr
) = lto_input_tree (ib
, data_in
);
2146 /* Read all pointer fields in the TS_LIST structure of EXPR from input
2147 block IB. DATA_IN contains tables and descriptors for the
2151 lto_input_ts_list_tree_pointers (struct lto_input_block
*ib
,
2152 struct data_in
*data_in
, tree expr
)
2154 TREE_PURPOSE (expr
) = lto_input_tree (ib
, data_in
);
2155 TREE_VALUE (expr
) = lto_input_tree (ib
, data_in
);
2156 TREE_CHAIN (expr
) = lto_input_chain (ib
, data_in
);
2160 /* Read all pointer fields in the TS_VEC structure of EXPR from input
2161 block IB. DATA_IN contains tables and descriptors for the
2165 lto_input_ts_vec_tree_pointers (struct lto_input_block
*ib
,
2166 struct data_in
*data_in
, tree expr
)
2170 /* Note that TREE_VEC_LENGTH was read by lto_materialize_tree to
2171 instantiate EXPR. */
2172 for (i
= 0; i
< TREE_VEC_LENGTH (expr
); i
++)
2173 TREE_VEC_ELT (expr
, i
) = lto_input_tree (ib
, data_in
);
2177 /* Read all pointer fields in the TS_EXP structure of EXPR from input
2178 block IB. DATA_IN contains tables and descriptors for the
2183 lto_input_ts_exp_tree_pointers (struct lto_input_block
*ib
,
2184 struct data_in
*data_in
, tree expr
)
2189 length
= lto_input_sleb128 (ib
);
2190 gcc_assert (length
== TREE_OPERAND_LENGTH (expr
));
2192 for (i
= 0; i
< length
; i
++)
2193 TREE_OPERAND (expr
, i
) = lto_input_tree (ib
, data_in
);
2195 loc
= lto_input_location (ib
, data_in
);
2196 SET_EXPR_LOCATION (expr
, loc
);
2197 TREE_BLOCK (expr
) = lto_input_tree (ib
, data_in
);
2201 /* Read all pointer fields in the TS_BLOCK structure of EXPR from input
2202 block IB. DATA_IN contains tables and descriptors for the
2206 lto_input_ts_block_tree_pointers (struct lto_input_block
*ib
,
2207 struct data_in
*data_in
, tree expr
)
2209 /* Do not stream BLOCK_SOURCE_LOCATION. We cannot handle debug information
2210 for early inlining so drop it on the floor instead of ICEing in
2212 BLOCK_VARS (expr
) = lto_input_chain (ib
, data_in
);
2214 /* Do not stream BLOCK_NONLOCALIZED_VARS. We cannot handle debug information
2215 for early inlining so drop it on the floor instead of ICEing in
2218 BLOCK_SUPERCONTEXT (expr
) = lto_input_tree (ib
, data_in
);
2219 /* Do not stream BLOCK_ABSTRACT_ORIGIN. We cannot handle debug information
2220 for early inlining so drop it on the floor instead of ICEing in
2222 BLOCK_FRAGMENT_ORIGIN (expr
) = lto_input_tree (ib
, data_in
);
2223 BLOCK_FRAGMENT_CHAIN (expr
) = lto_input_tree (ib
, data_in
);
2224 /* We re-compute BLOCK_SUBBLOCKS of our parent here instead
2225 of streaming it. For non-BLOCK BLOCK_SUPERCONTEXTs we still
2226 stream the child relationship explicitly. */
2227 if (BLOCK_SUPERCONTEXT (expr
)
2228 && TREE_CODE (BLOCK_SUPERCONTEXT (expr
)) == BLOCK
)
2230 BLOCK_CHAIN (expr
) = BLOCK_SUBBLOCKS (BLOCK_SUPERCONTEXT (expr
));
2231 BLOCK_SUBBLOCKS (BLOCK_SUPERCONTEXT (expr
)) = expr
;
2233 /* The global block is rooted at the TU decl. Hook it here to
2234 avoid the need to stream in this block during WPA time. */
2235 else if (BLOCK_SUPERCONTEXT (expr
)
2236 && TREE_CODE (BLOCK_SUPERCONTEXT (expr
)) == TRANSLATION_UNIT_DECL
)
2237 DECL_INITIAL (BLOCK_SUPERCONTEXT (expr
)) = expr
;
2238 /* The function-level block is connected at the time we read in
2239 function bodies for the same reason. */
2243 /* Read all pointer fields in the TS_BINFO structure of EXPR from input
2244 block IB. DATA_IN contains tables and descriptors for the
2248 lto_input_ts_binfo_tree_pointers (struct lto_input_block
*ib
,
2249 struct data_in
*data_in
, tree expr
)
2254 /* Note that the number of slots in EXPR was read in
2255 lto_materialize_tree when instantiating EXPR. However, the
2256 vector is empty so we cannot rely on VEC_length to know how many
2257 elements to read. So, this list is emitted as a 0-terminated
2258 list on the writer side. */
2261 t
= lto_input_tree (ib
, data_in
);
2263 VEC_quick_push (tree
, BINFO_BASE_BINFOS (expr
), t
);
2267 BINFO_OFFSET (expr
) = lto_input_tree (ib
, data_in
);
2268 BINFO_VTABLE (expr
) = lto_input_tree (ib
, data_in
);
2269 BINFO_VIRTUALS (expr
) = lto_input_tree (ib
, data_in
);
2270 BINFO_VPTR_FIELD (expr
) = lto_input_tree (ib
, data_in
);
2272 len
= lto_input_uleb128 (ib
);
2275 VEC_reserve_exact (tree
, gc
, BINFO_BASE_ACCESSES (expr
), len
);
2276 for (i
= 0; i
< len
; i
++)
2278 tree a
= lto_input_tree (ib
, data_in
);
2279 VEC_quick_push (tree
, BINFO_BASE_ACCESSES (expr
), a
);
2283 BINFO_INHERITANCE_CHAIN (expr
) = lto_input_tree (ib
, data_in
);
2284 BINFO_SUBVTT_INDEX (expr
) = lto_input_tree (ib
, data_in
);
2285 BINFO_VPTR_INDEX (expr
) = lto_input_tree (ib
, data_in
);
2289 /* Read all pointer fields in the TS_CONSTRUCTOR structure of EXPR from
2290 input block IB. DATA_IN contains tables and descriptors for the
2294 lto_input_ts_constructor_tree_pointers (struct lto_input_block
*ib
,
2295 struct data_in
*data_in
, tree expr
)
2299 len
= lto_input_uleb128 (ib
);
2300 for (i
= 0; i
< len
; i
++)
2304 index
= lto_input_tree (ib
, data_in
);
2305 value
= lto_input_tree (ib
, data_in
);
2306 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (expr
), index
, value
);
2311 /* Input a TS_TARGET_OPTION tree from IB into EXPR. */
2314 lto_input_ts_target_option (struct lto_input_block
*ib
, tree expr
)
2317 struct bitpack_d bp
;
2318 struct cl_target_option
*t
= TREE_TARGET_OPTION (expr
);
2320 bp
= lto_input_bitpack (ib
);
2321 len
= sizeof (struct cl_target_option
);
2322 for (i
= 0; i
< len
; i
++)
2323 ((unsigned char *)t
)[i
] = bp_unpack_value (&bp
, 8);
2324 if (bp_unpack_value (&bp
, 32) != 0x12345678)
2325 fatal_error ("cl_target_option size mismatch in LTO reader and writer");
2328 /* Input a TS_TRANSLATION_UNIT_DECL tree from IB and DATA_IN into EXPR. */
2331 lto_input_ts_translation_unit_decl_tree_pointers (struct lto_input_block
*ib
,
2332 struct data_in
*data_in
,
2335 TRANSLATION_UNIT_LANGUAGE (expr
) = xstrdup (lto_input_string (data_in
, ib
));
2336 VEC_safe_push (tree
, gc
, all_translation_units
, expr
);
2339 /* Helper for lto_input_tree. Read all pointer fields in EXPR from
2340 input block IB. DATA_IN contains tables and descriptors for the
2344 lto_input_tree_pointers (struct lto_input_block
*ib
, struct data_in
*data_in
,
2347 enum tree_code code
;
2349 code
= TREE_CODE (expr
);
2351 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
2352 lto_input_ts_common_tree_pointers (ib
, data_in
, expr
);
2354 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
2355 lto_input_ts_vector_tree_pointers (ib
, data_in
, expr
);
2357 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
2358 lto_input_ts_complex_tree_pointers (ib
, data_in
, expr
);
2360 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
2361 lto_input_ts_decl_minimal_tree_pointers (ib
, data_in
, expr
);
2363 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
2364 lto_input_ts_decl_common_tree_pointers (ib
, data_in
, expr
);
2366 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
2367 lto_input_ts_decl_non_common_tree_pointers (ib
, data_in
, expr
);
2369 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
2370 lto_input_ts_decl_with_vis_tree_pointers (ib
, data_in
, expr
);
2372 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
2373 lto_input_ts_field_decl_tree_pointers (ib
, data_in
, expr
);
2375 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
2376 lto_input_ts_function_decl_tree_pointers (ib
, data_in
, expr
);
2378 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
2379 lto_input_ts_type_common_tree_pointers (ib
, data_in
, expr
);
2381 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
2382 lto_input_ts_type_non_common_tree_pointers (ib
, data_in
, expr
);
2384 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
2385 lto_input_ts_list_tree_pointers (ib
, data_in
, expr
);
2387 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
2388 lto_input_ts_vec_tree_pointers (ib
, data_in
, expr
);
2390 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
2391 lto_input_ts_exp_tree_pointers (ib
, data_in
, expr
);
2393 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
2394 lto_input_ts_block_tree_pointers (ib
, data_in
, expr
);
2396 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
2397 lto_input_ts_binfo_tree_pointers (ib
, data_in
, expr
);
2399 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
2400 lto_input_ts_constructor_tree_pointers (ib
, data_in
, expr
);
2402 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
))
2403 lto_input_ts_target_option (ib
, expr
);
2405 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
2406 lto_input_ts_translation_unit_decl_tree_pointers (ib
, data_in
, expr
);
2410 /* Read an index IX from input block IB and return the tree node at
2411 DATA_IN->FILE_DATA->GLOBALS_INDEX[IX]. */
2414 lto_get_pickled_tree (struct lto_input_block
*ib
, struct data_in
*data_in
)
2416 unsigned HOST_WIDE_INT ix
;
2418 enum LTO_tags expected_tag
;
2420 ix
= lto_input_uleb128 (ib
);
2421 expected_tag
= lto_input_enum (ib
, LTO_tags
, LTO_NUM_TAGS
);
2423 result
= lto_streamer_cache_get (data_in
->reader_cache
, ix
);
2425 && TREE_CODE (result
) == lto_tag_to_tree_code (expected_tag
));
2431 /* Read a code and class from input block IB and return the
2432 corresponding builtin. DATA_IN is as in lto_input_tree. */
2435 lto_get_builtin_tree (struct lto_input_block
*ib
, struct data_in
*data_in
)
2437 enum built_in_class fclass
;
2438 enum built_in_function fcode
;
2439 const char *asmname
;
2442 fclass
= lto_input_enum (ib
, built_in_class
, BUILT_IN_LAST
);
2443 gcc_assert (fclass
== BUILT_IN_NORMAL
|| fclass
== BUILT_IN_MD
);
2445 fcode
= (enum built_in_function
) lto_input_uleb128 (ib
);
2447 if (fclass
== BUILT_IN_NORMAL
)
2449 if (fcode
>= END_BUILTINS
)
2450 fatal_error ("machine independent builtin code out of range");
2451 result
= built_in_decls
[fcode
];
2452 gcc_assert (result
);
2454 else if (fclass
== BUILT_IN_MD
)
2456 result
= targetm
.builtin_decl (fcode
, true);
2457 if (!result
|| result
== error_mark_node
)
2458 fatal_error ("target specific builtin not available");
2463 asmname
= lto_input_string (data_in
, ib
);
2465 set_builtin_user_assembler_name (result
, asmname
);
2467 lto_streamer_cache_append (data_in
->reader_cache
, result
);
2473 /* Read the physical representation of a tree node with tag TAG from
2474 input block IB using the per-file context in DATA_IN. */
2477 lto_read_tree (struct lto_input_block
*ib
, struct data_in
*data_in
,
2482 result
= lto_materialize_tree (ib
, data_in
, tag
);
2484 /* Read all the pointer fields in RESULT. */
2485 lto_input_tree_pointers (ib
, data_in
, result
);
2487 /* We should never try to instantiate an MD or NORMAL builtin here. */
2488 if (TREE_CODE (result
) == FUNCTION_DECL
)
2489 gcc_assert (!lto_stream_as_builtin_p (result
));
2491 /* end_marker = */ lto_input_1_unsigned (ib
);
2493 #ifdef LTO_STREAMER_DEBUG
2494 /* Remove the mapping to RESULT's original address set by
2495 lto_materialize_tree. */
2496 lto_orig_address_remove (result
);
2503 /* Read and INTEGER_CST node from input block IB using the per-file
2504 context in DATA_IN. */
2507 lto_input_integer_cst (struct lto_input_block
*ib
, struct data_in
*data_in
)
2510 HOST_WIDE_INT low
, high
;
2513 type
= lto_input_tree (ib
, data_in
);
2514 overflow_p
= (lto_input_1_unsigned (ib
) != 0);
2515 low
= lto_input_uleb128 (ib
);
2516 high
= lto_input_uleb128 (ib
);
2517 result
= build_int_cst_wide (type
, low
, high
);
2519 /* If the original constant had overflown, build a replica of RESULT to
2520 avoid modifying the shared constant returned by build_int_cst_wide. */
2523 result
= copy_node (result
);
2524 TREE_OVERFLOW (result
) = 1;
2531 /* Read a tree from input block IB using the per-file context in
2532 DATA_IN. This context is used, for example, to resolve references
2533 to previously read nodes. */
2536 lto_input_tree (struct lto_input_block
*ib
, struct data_in
*data_in
)
2541 tag
= input_record_start (ib
);
2542 gcc_assert ((unsigned) tag
< (unsigned) LTO_NUM_TAGS
);
2544 if (tag
== LTO_null
)
2546 else if (tag
>= LTO_field_decl_ref
&& tag
<= LTO_global_decl_ref
)
2548 /* If TAG is a reference to an indexable tree, the next value
2549 in IB is the index into the table where we expect to find
2551 result
= lto_input_tree_ref (ib
, data_in
, cfun
, tag
);
2553 else if (tag
== LTO_tree_pickle_reference
)
2555 /* If TAG is a reference to a previously read tree, look it up in
2556 the reader cache. */
2557 result
= lto_get_pickled_tree (ib
, data_in
);
2559 else if (tag
== LTO_builtin_decl
)
2561 /* If we are going to read a built-in function, all we need is
2562 the code and class. */
2563 result
= lto_get_builtin_tree (ib
, data_in
);
2565 else if (tag
== lto_tree_code_to_tag (INTEGER_CST
))
2567 /* For integer constants we only need the type and its hi/low
2569 result
= lto_input_integer_cst (ib
, data_in
);
2573 /* Otherwise, materialize a new node from IB. */
2574 result
= lto_read_tree (ib
, data_in
, tag
);
2581 /* Initialization for the LTO reader. */
2584 lto_init_reader (void)
2586 lto_streamer_init ();
2588 memset (<o_stats
, 0, sizeof (lto_stats
));
2589 bitmap_obstack_initialize (NULL
);
2591 file_name_hash_table
= htab_create (37, hash_string_slot_node
,
2592 eq_string_slot_node
, free
);
2594 gimple_register_cfg_hooks ();
2598 /* Create a new data_in object for FILE_DATA. STRINGS is the string
2599 table to use with LEN strings. RESOLUTIONS is the vector of linker
2600 resolutions (NULL if not using a linker plugin). */
2603 lto_data_in_create (struct lto_file_decl_data
*file_data
, const char *strings
,
2605 VEC(ld_plugin_symbol_resolution_t
,heap
) *resolutions
)
2607 struct data_in
*data_in
= XCNEW (struct data_in
);
2608 data_in
->file_data
= file_data
;
2609 data_in
->strings
= strings
;
2610 data_in
->strings_len
= len
;
2611 data_in
->globals_resolution
= resolutions
;
2612 data_in
->reader_cache
= lto_streamer_cache_create ();
2618 /* Remove DATA_IN. */
2621 lto_data_in_delete (struct data_in
*data_in
)
2623 VEC_free (ld_plugin_symbol_resolution_t
, heap
, data_in
->globals_resolution
);
2624 lto_streamer_cache_delete (data_in
->reader_cache
);
2625 free (data_in
->labels
);