1 /* Read the GIMPLE representation from a file stream.
3 Copyright 2009, 2010 Free Software Foundation, Inc.
4 Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
5 Re-implemented by Diego Novillo <dnovillo@google.com>
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
34 #include "basic-block.h"
35 #include "tree-flow.h"
36 #include "tree-pass.h"
40 #include "diagnostic.h"
47 #include "ipa-utils.h"
48 #include "lto-streamer.h"
49 #include "tree-pass.h"
51 /* Data structure used to hash file names in the source_location field. */
55 unsigned int slot_num
;
58 /* The table to hold the file names. */
59 static htab_t file_name_hash_table
;
62 /* Check that tag ACTUAL has one of the given values. NUM_TAGS is the
63 number of valid tag values to check. */
66 lto_tag_check_set (enum LTO_tags actual
, int ntags
, ...)
72 for (i
= 0; i
< ntags
; i
++)
73 if ((unsigned) actual
== va_arg (ap
, unsigned))
80 internal_error ("bytecode stream: unexpected tag %s", lto_tag_name (actual
));
84 /* Check that tag ACTUAL is in the range [TAG1, TAG2]. */
87 lto_tag_check_range (enum LTO_tags actual
, enum LTO_tags tag1
,
90 if (actual
< tag1
|| actual
> tag2
)
91 internal_error ("bytecode stream: tag %s is not in the expected range "
93 lto_tag_name (actual
),
99 /* Check that tag ACTUAL == EXPECTED. */
102 lto_tag_check (enum LTO_tags actual
, enum LTO_tags expected
)
104 if (actual
!= expected
)
105 internal_error ("bytecode stream: expected tag %s instead of %s",
106 lto_tag_name (expected
), lto_tag_name (actual
));
110 /* Return a hash code for P. */
113 hash_string_slot_node (const void *p
)
115 const struct string_slot
*ds
= (const struct string_slot
*) p
;
116 return (hashval_t
) htab_hash_string (ds
->s
);
120 /* Returns nonzero if P1 and P2 are equal. */
123 eq_string_slot_node (const void *p1
, const void *p2
)
125 const struct string_slot
*ds1
= (const struct string_slot
*) p1
;
126 const struct string_slot
*ds2
= (const struct string_slot
*) p2
;
127 return strcmp (ds1
->s
, ds2
->s
) == 0;
131 /* Read a string from the string table in DATA_IN using input block
132 IB. Write the length to RLEN. */
135 input_string_internal (struct data_in
*data_in
, struct lto_input_block
*ib
,
138 struct lto_input_block str_tab
;
143 loc
= lto_input_uleb128 (ib
);
144 LTO_INIT_INPUT_BLOCK (str_tab
, data_in
->strings
, loc
, data_in
->strings_len
);
145 len
= lto_input_uleb128 (&str_tab
);
148 if (str_tab
.p
+ len
> data_in
->strings_len
)
149 internal_error ("bytecode stream: string too long for the string table");
151 result
= (const char *)(data_in
->strings
+ str_tab
.p
);
157 /* Read a STRING_CST from the string table in DATA_IN using input
161 input_string_cst (struct data_in
*data_in
, struct lto_input_block
*ib
)
165 unsigned int is_null
;
167 is_null
= lto_input_uleb128 (ib
);
171 ptr
= input_string_internal (data_in
, ib
, &len
);
172 return build_string (len
, ptr
);
176 /* Read an IDENTIFIER from the string table in DATA_IN using input
180 input_identifier (struct data_in
*data_in
, struct lto_input_block
*ib
)
184 unsigned int is_null
;
186 is_null
= lto_input_uleb128 (ib
);
190 ptr
= input_string_internal (data_in
, ib
, &len
);
191 return get_identifier_with_length (ptr
, len
);
194 /* Read a NULL terminated string from the string table in DATA_IN. */
197 input_string (struct data_in
*data_in
, struct lto_input_block
*ib
)
201 unsigned int is_null
;
203 is_null
= lto_input_uleb128 (ib
);
207 ptr
= input_string_internal (data_in
, ib
, &len
);
208 if (ptr
[len
- 1] != '\0')
209 internal_error ("bytecode stream: found non-null terminated string");
215 /* Return the next tag in the input block IB. */
218 input_record_start (struct lto_input_block
*ib
)
220 enum LTO_tags tag
= (enum LTO_tags
) lto_input_uleb128 (ib
);
225 /* Lookup STRING in file_name_hash_table. If found, return the existing
226 string, otherwise insert STRING as the canonical version. */
229 canon_file_name (const char *string
)
232 struct string_slot s_slot
;
235 slot
= htab_find_slot (file_name_hash_table
, &s_slot
, INSERT
);
240 struct string_slot
*new_slot
;
242 len
= strlen (string
);
243 saved_string
= (char *) xmalloc (len
+ 1);
244 new_slot
= XCNEW (struct string_slot
);
245 strcpy (saved_string
, string
);
246 new_slot
->s
= saved_string
;
252 struct string_slot
*old_slot
= (struct string_slot
*) *slot
;
258 /* Clear the line info stored in DATA_IN. */
261 clear_line_info (struct data_in
*data_in
)
263 if (data_in
->current_file
)
264 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
265 data_in
->current_file
= NULL
;
266 data_in
->current_line
= 0;
267 data_in
->current_col
= 0;
271 /* Read a location from input block IB. */
274 lto_input_location (struct lto_input_block
*ib
, struct data_in
*data_in
)
276 expanded_location xloc
;
278 xloc
.file
= input_string (data_in
, ib
);
279 if (xloc
.file
== NULL
)
280 return UNKNOWN_LOCATION
;
282 xloc
.file
= canon_file_name (xloc
.file
);
283 xloc
.line
= lto_input_sleb128 (ib
);
284 xloc
.column
= lto_input_sleb128 (ib
);
285 xloc
.sysp
= lto_input_sleb128 (ib
);
287 if (data_in
->current_file
!= xloc
.file
)
289 if (data_in
->current_file
)
290 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
292 linemap_add (line_table
, LC_ENTER
, xloc
.sysp
, xloc
.file
, xloc
.line
);
294 else if (data_in
->current_line
!= xloc
.line
)
295 linemap_line_start (line_table
, xloc
.line
, xloc
.column
);
297 data_in
->current_file
= xloc
.file
;
298 data_in
->current_line
= xloc
.line
;
299 data_in
->current_col
= xloc
.column
;
301 return linemap_position_for_column (line_table
, xloc
.column
);
305 /* Read a reference to a tree node from DATA_IN using input block IB.
306 TAG is the expected node that should be found in IB, if TAG belongs
307 to one of the indexable trees, expect to read a reference index to
308 be looked up in one of the symbol tables, otherwise read the pysical
309 representation of the tree using lto_input_tree. FN is the
310 function scope for the read tree. */
313 lto_input_tree_ref (struct lto_input_block
*ib
, struct data_in
*data_in
,
314 struct function
*fn
, enum LTO_tags tag
)
316 unsigned HOST_WIDE_INT ix_u
;
317 tree result
= NULL_TREE
;
319 lto_tag_check_range (tag
, LTO_field_decl_ref
, LTO_global_decl_ref
);
324 ix_u
= lto_input_uleb128 (ib
);
325 result
= lto_file_decl_data_get_type (data_in
->file_data
, ix_u
);
328 case LTO_ssa_name_ref
:
329 ix_u
= lto_input_uleb128 (ib
);
330 result
= VEC_index (tree
, SSANAMES (fn
), ix_u
);
333 case LTO_field_decl_ref
:
334 ix_u
= lto_input_uleb128 (ib
);
335 result
= lto_file_decl_data_get_field_decl (data_in
->file_data
, ix_u
);
338 case LTO_function_decl_ref
:
339 ix_u
= lto_input_uleb128 (ib
);
340 result
= lto_file_decl_data_get_fn_decl (data_in
->file_data
, ix_u
);
343 case LTO_type_decl_ref
:
344 ix_u
= lto_input_uleb128 (ib
);
345 result
= lto_file_decl_data_get_type_decl (data_in
->file_data
, ix_u
);
348 case LTO_namespace_decl_ref
:
349 ix_u
= lto_input_uleb128 (ib
);
350 result
= lto_file_decl_data_get_namespace_decl (data_in
->file_data
, ix_u
);
353 case LTO_global_decl_ref
:
354 case LTO_result_decl_ref
:
355 case LTO_const_decl_ref
:
356 case LTO_imported_decl_ref
:
357 case LTO_label_decl_ref
:
358 case LTO_translation_unit_decl_ref
:
359 ix_u
= lto_input_uleb128 (ib
);
360 result
= lto_file_decl_data_get_var_decl (data_in
->file_data
, ix_u
);
373 /* Read and return a double-linked list of catch handlers from input
374 block IB, using descriptors in DATA_IN. */
376 static struct eh_catch_d
*
377 lto_input_eh_catch_list (struct lto_input_block
*ib
, struct data_in
*data_in
,
383 *last_p
= first
= NULL
;
384 tag
= input_record_start (ib
);
390 lto_tag_check_range (tag
, LTO_eh_catch
, LTO_eh_catch
);
392 /* Read the catch node. */
393 n
= ggc_alloc_cleared_eh_catch_d ();
394 n
->type_list
= lto_input_tree (ib
, data_in
);
395 n
->filter_list
= lto_input_tree (ib
, data_in
);
396 n
->label
= lto_input_tree (ib
, data_in
);
398 /* Register all the types in N->FILTER_LIST. */
399 for (list
= n
->filter_list
; list
; list
= TREE_CHAIN (list
))
400 add_type_for_runtime (TREE_VALUE (list
));
402 /* Chain N to the end of the list. */
404 (*last_p
)->next_catch
= n
;
405 n
->prev_catch
= *last_p
;
408 /* Set the head of the list the first time through the loop. */
412 tag
= input_record_start (ib
);
419 /* Read and return EH region IX from input block IB, using descriptors
423 input_eh_region (struct lto_input_block
*ib
, struct data_in
*data_in
, int ix
)
428 /* Read the region header. */
429 tag
= input_record_start (ib
);
433 r
= ggc_alloc_cleared_eh_region_d ();
434 r
->index
= lto_input_sleb128 (ib
);
436 gcc_assert (r
->index
== ix
);
438 /* Read all the region pointers as region numbers. We'll fix up
439 the pointers once the whole array has been read. */
440 r
->outer
= (eh_region
) (intptr_t) lto_input_sleb128 (ib
);
441 r
->inner
= (eh_region
) (intptr_t) lto_input_sleb128 (ib
);
442 r
->next_peer
= (eh_region
) (intptr_t) lto_input_sleb128 (ib
);
446 case LTO_ert_cleanup
:
447 r
->type
= ERT_CLEANUP
;
452 struct eh_catch_d
*last_catch
;
454 r
->u
.eh_try
.first_catch
= lto_input_eh_catch_list (ib
, data_in
,
456 r
->u
.eh_try
.last_catch
= last_catch
;
460 case LTO_ert_allowed_exceptions
:
464 r
->type
= ERT_ALLOWED_EXCEPTIONS
;
465 r
->u
.allowed
.type_list
= lto_input_tree (ib
, data_in
);
466 r
->u
.allowed
.label
= lto_input_tree (ib
, data_in
);
467 r
->u
.allowed
.filter
= lto_input_uleb128 (ib
);
469 for (l
= r
->u
.allowed
.type_list
; l
; l
= TREE_CHAIN (l
))
470 add_type_for_runtime (TREE_VALUE (l
));
474 case LTO_ert_must_not_throw
:
475 r
->type
= ERT_MUST_NOT_THROW
;
476 r
->u
.must_not_throw
.failure_decl
= lto_input_tree (ib
, data_in
);
477 r
->u
.must_not_throw
.failure_loc
= lto_input_location (ib
, data_in
);
484 r
->landing_pads
= (eh_landing_pad
) (intptr_t) lto_input_sleb128 (ib
);
490 /* Read and return EH landing pad IX from input block IB, using descriptors
493 static eh_landing_pad
494 input_eh_lp (struct lto_input_block
*ib
, struct data_in
*data_in
, int ix
)
499 /* Read the landing pad header. */
500 tag
= input_record_start (ib
);
504 lto_tag_check_range (tag
, LTO_eh_landing_pad
, LTO_eh_landing_pad
);
506 lp
= ggc_alloc_cleared_eh_landing_pad_d ();
507 lp
->index
= lto_input_sleb128 (ib
);
508 gcc_assert (lp
->index
== ix
);
509 lp
->next_lp
= (eh_landing_pad
) (intptr_t) lto_input_sleb128 (ib
);
510 lp
->region
= (eh_region
) (intptr_t) lto_input_sleb128 (ib
);
511 lp
->post_landing_pad
= lto_input_tree (ib
, data_in
);
517 /* After reading the EH regions, pointers to peer and children regions
518 are region numbers. This converts all these region numbers into
519 real pointers into the rematerialized regions for FN. ROOT_REGION
520 is the region number for the root EH region in FN. */
523 fixup_eh_region_pointers (struct function
*fn
, HOST_WIDE_INT root_region
)
526 VEC(eh_region
,gc
) *eh_array
= fn
->eh
->region_array
;
527 VEC(eh_landing_pad
,gc
) *lp_array
= fn
->eh
->lp_array
;
531 gcc_assert (eh_array
&& lp_array
);
533 gcc_assert (root_region
>= 0);
534 fn
->eh
->region_tree
= VEC_index (eh_region
, eh_array
, root_region
);
536 #define FIXUP_EH_REGION(r) (r) = VEC_index (eh_region, eh_array, \
537 (HOST_WIDE_INT) (intptr_t) (r))
538 #define FIXUP_EH_LP(p) (p) = VEC_index (eh_landing_pad, lp_array, \
539 (HOST_WIDE_INT) (intptr_t) (p))
541 /* Convert all the index numbers stored in pointer fields into
542 pointers to the corresponding slots in the EH region array. */
543 FOR_EACH_VEC_ELT (eh_region
, eh_array
, i
, r
)
545 /* The array may contain NULL regions. */
549 gcc_assert (i
== (unsigned) r
->index
);
550 FIXUP_EH_REGION (r
->outer
);
551 FIXUP_EH_REGION (r
->inner
);
552 FIXUP_EH_REGION (r
->next_peer
);
553 FIXUP_EH_LP (r
->landing_pads
);
556 /* Convert all the index numbers stored in pointer fields into
557 pointers to the corresponding slots in the EH landing pad array. */
558 FOR_EACH_VEC_ELT (eh_landing_pad
, lp_array
, i
, lp
)
560 /* The array may contain NULL landing pads. */
564 gcc_assert (i
== (unsigned) lp
->index
);
565 FIXUP_EH_LP (lp
->next_lp
);
566 FIXUP_EH_REGION (lp
->region
);
569 #undef FIXUP_EH_REGION
574 /* Initialize EH support. */
579 static bool eh_initialized_p
= false;
581 if (eh_initialized_p
)
584 /* Contrary to most other FEs, we only initialize EH support when at
585 least one of the files in the set contains exception regions in
586 it. Since this happens much later than the call to init_eh in
587 lang_dependent_init, we have to set flag_exceptions and call
588 init_eh again to initialize the EH tables. */
592 /* Initialize dwarf2 tables. Since dwarf2out_do_frame() returns
593 true only when exceptions are enabled, this initialization is
594 never done during lang_dependent_init. */
595 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
596 if (dwarf2out_do_frame ())
597 dwarf2out_frame_init ();
600 eh_initialized_p
= true;
604 /* Read the exception table for FN from IB using the data descriptors
608 input_eh_regions (struct lto_input_block
*ib
, struct data_in
*data_in
,
611 HOST_WIDE_INT i
, root_region
, len
;
614 tag
= input_record_start (ib
);
618 lto_tag_check_range (tag
, LTO_eh_table
, LTO_eh_table
);
620 /* If the file contains EH regions, then it was compiled with
621 -fexceptions. In that case, initialize the backend EH
627 root_region
= lto_input_sleb128 (ib
);
628 gcc_assert (root_region
== (int) root_region
);
630 /* Read the EH region array. */
631 len
= lto_input_sleb128 (ib
);
632 gcc_assert (len
== (int) len
);
635 VEC_safe_grow (eh_region
, gc
, fn
->eh
->region_array
, len
);
636 for (i
= 0; i
< len
; i
++)
638 eh_region r
= input_eh_region (ib
, data_in
, i
);
639 VEC_replace (eh_region
, fn
->eh
->region_array
, i
, r
);
643 /* Read the landing pads. */
644 len
= lto_input_sleb128 (ib
);
645 gcc_assert (len
== (int) len
);
648 VEC_safe_grow (eh_landing_pad
, gc
, fn
->eh
->lp_array
, len
);
649 for (i
= 0; i
< len
; i
++)
651 eh_landing_pad lp
= input_eh_lp (ib
, data_in
, i
);
652 VEC_replace (eh_landing_pad
, fn
->eh
->lp_array
, i
, lp
);
656 /* Read the runtime type data. */
657 len
= lto_input_sleb128 (ib
);
658 gcc_assert (len
== (int) len
);
661 VEC_safe_grow (tree
, gc
, fn
->eh
->ttype_data
, len
);
662 for (i
= 0; i
< len
; i
++)
664 tree ttype
= lto_input_tree (ib
, data_in
);
665 VEC_replace (tree
, fn
->eh
->ttype_data
, i
, ttype
);
669 /* Read the table of action chains. */
670 len
= lto_input_sleb128 (ib
);
671 gcc_assert (len
== (int) len
);
674 if (targetm
.arm_eabi_unwinder
)
676 VEC_safe_grow (tree
, gc
, fn
->eh
->ehspec_data
.arm_eabi
, len
);
677 for (i
= 0; i
< len
; i
++)
679 tree t
= lto_input_tree (ib
, data_in
);
680 VEC_replace (tree
, fn
->eh
->ehspec_data
.arm_eabi
, i
, t
);
685 VEC_safe_grow (uchar
, gc
, fn
->eh
->ehspec_data
.other
, len
);
686 for (i
= 0; i
< len
; i
++)
688 uchar c
= lto_input_1_unsigned (ib
);
689 VEC_replace (uchar
, fn
->eh
->ehspec_data
.other
, i
, c
);
694 /* Reconstruct the EH region tree by fixing up the peer/children
696 fixup_eh_region_pointers (fn
, root_region
);
698 tag
= input_record_start (ib
);
699 lto_tag_check_range (tag
, LTO_null
, LTO_null
);
703 /* Make a new basic block with index INDEX in function FN. */
706 make_new_block (struct function
*fn
, unsigned int index
)
708 basic_block bb
= alloc_block ();
710 SET_BASIC_BLOCK_FOR_FUNCTION (fn
, index
, bb
);
711 bb
->il
.gimple
= ggc_alloc_cleared_gimple_bb_info ();
712 n_basic_blocks_for_function (fn
)++;
714 set_bb_seq (bb
, gimple_seq_alloc ());
719 /* Read the CFG for function FN from input block IB. */
722 input_cfg (struct lto_input_block
*ib
, struct function
*fn
)
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
);
876 /* Read a statement with tag TAG in function FN from block IB using
877 descriptors in DATA_IN. */
880 input_gimple_stmt (struct lto_input_block
*ib
, struct data_in
*data_in
,
881 struct function
*fn
, enum LTO_tags tag
)
884 enum gimple_code code
;
885 unsigned HOST_WIDE_INT num_ops
;
889 code
= lto_tag_to_gimple_code (tag
);
891 /* Read the tuple header. */
892 bp
= lto_input_bitpack (ib
);
893 num_ops
= bp_unpack_value (&bp
, sizeof (unsigned) * 8);
894 stmt
= gimple_alloc (code
, num_ops
);
895 stmt
->gsbase
.no_warning
= bp_unpack_value (&bp
, 1);
896 if (is_gimple_assign (stmt
))
897 stmt
->gsbase
.nontemporal_move
= bp_unpack_value (&bp
, 1);
898 stmt
->gsbase
.has_volatile_ops
= bp_unpack_value (&bp
, 1);
899 stmt
->gsbase
.subcode
= bp_unpack_value (&bp
, 16);
901 /* Read location information. */
902 gimple_set_location (stmt
, lto_input_location (ib
, data_in
));
904 /* Read lexical block reference. */
905 gimple_set_block (stmt
, lto_input_tree (ib
, data_in
));
907 /* Read in all the operands. */
911 gimple_resx_set_region (stmt
, lto_input_sleb128 (ib
));
914 case GIMPLE_EH_MUST_NOT_THROW
:
915 gimple_eh_must_not_throw_set_fndecl (stmt
, lto_input_tree (ib
, data_in
));
918 case GIMPLE_EH_DISPATCH
:
919 gimple_eh_dispatch_set_region (stmt
, lto_input_sleb128 (ib
));
924 /* FIXME lto. Move most of this into a new gimple_asm_set_string(). */
926 stmt
->gimple_asm
.ni
= lto_input_uleb128 (ib
);
927 stmt
->gimple_asm
.no
= lto_input_uleb128 (ib
);
928 stmt
->gimple_asm
.nc
= lto_input_uleb128 (ib
);
929 stmt
->gimple_asm
.nl
= lto_input_uleb128 (ib
);
930 str
= input_string_cst (data_in
, ib
);
931 stmt
->gimple_asm
.string
= TREE_STRING_POINTER (str
);
943 for (i
= 0; i
< num_ops
; i
++)
945 tree op
= lto_input_tree (ib
, data_in
);
946 gimple_set_op (stmt
, i
, op
);
950 /* Fixup FIELD_DECLs in COMPONENT_REFs, they are not handled
952 if (TREE_CODE (op
) == ADDR_EXPR
)
953 op
= TREE_OPERAND (op
, 0);
954 while (handled_component_p (op
))
956 if (TREE_CODE (op
) == COMPONENT_REF
)
958 tree field
, type
, tem
;
959 field
= TREE_OPERAND (op
, 1);
960 type
= DECL_CONTEXT (field
);
961 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
964 || (gimple_types_compatible_p (TREE_TYPE (tem
),
967 && DECL_NONADDRESSABLE_P (tem
)
968 == DECL_NONADDRESSABLE_P (field
)
969 && gimple_compare_field_offset (tem
, field
)))
972 /* In case of type mismatches across units we can fail
973 to unify some types and thus not find a proper
974 field-decl here. So only assert here if checking
976 #ifdef ENABLE_CHECKING
977 gcc_assert (tem
!= NULL_TREE
);
979 if (tem
!= NULL_TREE
)
980 TREE_OPERAND (op
, 1) = tem
;
983 op
= TREE_OPERAND (op
, 0);
993 internal_error ("bytecode stream: unknown GIMPLE statement tag %s",
997 /* Update the properties of symbols, SSA names and labels associated
999 if (code
== GIMPLE_ASSIGN
|| code
== GIMPLE_CALL
)
1001 tree lhs
= gimple_get_lhs (stmt
);
1002 if (lhs
&& TREE_CODE (lhs
) == SSA_NAME
)
1003 SSA_NAME_DEF_STMT (lhs
) = stmt
;
1005 else if (code
== GIMPLE_LABEL
)
1006 gcc_assert (emit_label_in_global_context_p (gimple_label_label (stmt
))
1007 || DECL_CONTEXT (gimple_label_label (stmt
)) == fn
->decl
);
1008 else if (code
== GIMPLE_ASM
)
1012 for (i
= 0; i
< gimple_asm_noutputs (stmt
); i
++)
1014 tree op
= TREE_VALUE (gimple_asm_output_op (stmt
, i
));
1015 if (TREE_CODE (op
) == SSA_NAME
)
1016 SSA_NAME_DEF_STMT (op
) = stmt
;
1020 /* Reset alias information. */
1021 if (code
== GIMPLE_CALL
)
1022 gimple_call_reset_alias_info (stmt
);
1024 /* Mark the statement modified so its operand vectors can be filled in. */
1025 gimple_set_modified (stmt
, true);
1031 /* Read a basic block with tag TAG from DATA_IN using input block IB.
1032 FN is the function being processed. */
1035 input_bb (struct lto_input_block
*ib
, enum LTO_tags tag
,
1036 struct data_in
*data_in
, struct function
*fn
)
1040 gimple_stmt_iterator bsi
;
1042 /* This routine assumes that CFUN is set to FN, as it needs to call
1043 basic GIMPLE routines that use CFUN. */
1044 gcc_assert (cfun
== fn
);
1046 index
= lto_input_uleb128 (ib
);
1047 bb
= BASIC_BLOCK_FOR_FUNCTION (fn
, index
);
1049 bb
->count
= lto_input_sleb128 (ib
);
1050 bb
->loop_depth
= lto_input_sleb128 (ib
);
1051 bb
->frequency
= lto_input_sleb128 (ib
);
1052 bb
->flags
= lto_input_sleb128 (ib
);
1054 /* LTO_bb1 has statements. LTO_bb0 does not. */
1058 bsi
= gsi_start_bb (bb
);
1059 tag
= input_record_start (ib
);
1062 gimple stmt
= input_gimple_stmt (ib
, data_in
, fn
, tag
);
1064 find_referenced_vars_in (stmt
);
1065 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1067 /* After the statement, expect a 0 delimiter or the EH region
1068 that the previous statement belongs to. */
1069 tag
= input_record_start (ib
);
1070 lto_tag_check_set (tag
, 2, LTO_eh_region
, LTO_null
);
1072 if (tag
== LTO_eh_region
)
1074 HOST_WIDE_INT region
= lto_input_sleb128 (ib
);
1075 gcc_assert (region
== (int) region
);
1076 add_stmt_to_eh_lp (stmt
, region
);
1079 tag
= input_record_start (ib
);
1082 tag
= input_record_start (ib
);
1085 gimple phi
= input_phi (ib
, bb
, data_in
, fn
);
1086 find_referenced_vars_in (phi
);
1087 tag
= input_record_start (ib
);
1091 /* Go through all NODE edges and fixup call_stmt pointers
1092 so they point to STMTS. */
1095 fixup_call_stmt_edges_1 (struct cgraph_node
*node
, gimple
*stmts
)
1097 struct cgraph_edge
*cedge
;
1098 for (cedge
= node
->callees
; cedge
; cedge
= cedge
->next_callee
)
1099 cedge
->call_stmt
= stmts
[cedge
->lto_stmt_uid
];
1100 for (cedge
= node
->indirect_calls
; cedge
; cedge
= cedge
->next_callee
)
1101 cedge
->call_stmt
= stmts
[cedge
->lto_stmt_uid
];
1104 /* Fixup call_stmt pointers in NODE and all clones. */
1107 fixup_call_stmt_edges (struct cgraph_node
*orig
, gimple
*stmts
)
1109 struct cgraph_node
*node
;
1111 while (orig
->clone_of
)
1112 orig
= orig
->clone_of
;
1114 fixup_call_stmt_edges_1 (orig
, stmts
);
1116 for (node
= orig
->clones
; node
!= orig
;)
1118 fixup_call_stmt_edges_1 (node
, stmts
);
1120 node
= node
->clones
;
1121 else if (node
->next_sibling_clone
)
1122 node
= node
->next_sibling_clone
;
1125 while (node
!= orig
&& !node
->next_sibling_clone
)
1126 node
= node
->clone_of
;
1128 node
= node
->next_sibling_clone
;
1133 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1136 input_function (tree fn_decl
, struct data_in
*data_in
,
1137 struct lto_input_block
*ib
)
1139 struct function
*fn
;
1143 struct bitpack_d bp
;
1144 struct cgraph_node
*node
;
1145 tree args
, narg
, oarg
;
1148 fn
= DECL_STRUCT_FUNCTION (fn_decl
);
1149 tag
= input_record_start (ib
);
1150 clear_line_info (data_in
);
1152 gimple_register_cfg_hooks ();
1153 lto_tag_check (tag
, LTO_function
);
1155 /* Read all the attributes for FN. */
1156 bp
= lto_input_bitpack (ib
);
1157 fn
->is_thunk
= bp_unpack_value (&bp
, 1);
1158 fn
->has_local_explicit_reg_vars
= bp_unpack_value (&bp
, 1);
1159 fn
->after_tree_profile
= bp_unpack_value (&bp
, 1);
1160 fn
->returns_pcc_struct
= bp_unpack_value (&bp
, 1);
1161 fn
->returns_struct
= bp_unpack_value (&bp
, 1);
1162 fn
->can_throw_non_call_exceptions
= bp_unpack_value (&bp
, 1);
1163 fn
->always_inline_functions_inlined
= bp_unpack_value (&bp
, 1);
1164 fn
->after_inlining
= bp_unpack_value (&bp
, 1);
1165 fn
->dont_save_pending_sizes_p
= bp_unpack_value (&bp
, 1);
1166 fn
->stdarg
= bp_unpack_value (&bp
, 1);
1167 fn
->has_nonlocal_label
= bp_unpack_value (&bp
, 1);
1168 fn
->calls_alloca
= bp_unpack_value (&bp
, 1);
1169 fn
->calls_setjmp
= bp_unpack_value (&bp
, 1);
1170 fn
->va_list_fpr_size
= bp_unpack_value (&bp
, 8);
1171 fn
->va_list_gpr_size
= bp_unpack_value (&bp
, 8);
1173 /* Input the function start and end loci. */
1174 fn
->function_start_locus
= lto_input_location (ib
, data_in
);
1175 fn
->function_end_locus
= lto_input_location (ib
, data_in
);
1177 /* Input the current IL state of the function. */
1178 fn
->curr_properties
= lto_input_uleb128 (ib
);
1180 /* Read the static chain and non-local goto save area. */
1181 fn
->static_chain_decl
= lto_input_tree (ib
, data_in
);
1182 fn
->nonlocal_goto_save_area
= lto_input_tree (ib
, data_in
);
1184 /* Read all the local symbols. */
1185 len
= lto_input_sleb128 (ib
);
1189 VEC_safe_grow (tree
, gc
, fn
->local_decls
, len
);
1190 for (i
= 0; i
< len
; i
++)
1192 tree t
= lto_input_tree (ib
, data_in
);
1193 VEC_replace (tree
, fn
->local_decls
, i
, t
);
1197 /* Read all function arguments. We need to re-map them here to the
1198 arguments of the merged function declaration. */
1199 args
= lto_input_tree (ib
, data_in
);
1200 for (oarg
= args
, narg
= DECL_ARGUMENTS (fn_decl
);
1202 oarg
= TREE_CHAIN (oarg
), narg
= TREE_CHAIN (narg
))
1206 res
= lto_streamer_cache_lookup (data_in
->reader_cache
, oarg
, &ix
);
1208 /* Replace the argument in the streamer cache. */
1209 lto_streamer_cache_insert_at (data_in
->reader_cache
, narg
, ix
);
1211 gcc_assert (!oarg
&& !narg
);
1213 /* Read all the SSA names. */
1214 input_ssa_names (ib
, data_in
, fn
);
1216 /* Read the exception handling regions in the function. */
1217 input_eh_regions (ib
, data_in
, fn
);
1219 /* Read the tree of lexical scopes for the function. */
1220 DECL_INITIAL (fn_decl
) = lto_input_tree (ib
, data_in
);
1221 gcc_assert (DECL_INITIAL (fn_decl
));
1222 DECL_SAVED_TREE (fn_decl
) = NULL_TREE
;
1224 /* Read all the basic blocks. */
1225 tag
= input_record_start (ib
);
1228 input_bb (ib
, tag
, data_in
, fn
);
1229 tag
= input_record_start (ib
);
1232 /* Fix up the call statements that are mentioned in the callgraph
1234 renumber_gimple_stmt_uids ();
1235 stmts
= (gimple
*) xcalloc (gimple_stmt_max_uid (fn
), sizeof (gimple
));
1238 gimple_stmt_iterator bsi
= gsi_start_bb (bb
);
1239 while (!gsi_end_p (bsi
))
1241 gimple stmt
= gsi_stmt (bsi
);
1242 /* If we're recompiling LTO objects with debug stmts but
1243 we're not supposed to have debug stmts, remove them now.
1244 We can't remove them earlier because this would cause uid
1245 mismatches in fixups, but we can do it at this point, as
1246 long as debug stmts don't require fixups. */
1247 if (!MAY_HAVE_DEBUG_STMTS
&& is_gimple_debug (stmt
))
1249 gimple_stmt_iterator gsi
= bsi
;
1251 gsi_remove (&gsi
, true);
1256 stmts
[gimple_uid (stmt
)] = stmt
;
1261 /* Set the gimple body to the statement sequence in the entry
1262 basic block. FIXME lto, this is fairly hacky. The existence
1263 of a gimple body is used by the cgraph routines, but we should
1264 really use the presence of the CFG. */
1266 edge_iterator ei
= ei_start (ENTRY_BLOCK_PTR
->succs
);
1267 gimple_set_body (fn_decl
, bb_seq (ei_edge (ei
)->dest
));
1270 node
= cgraph_node (fn_decl
);
1271 fixup_call_stmt_edges (node
, stmts
);
1272 execute_all_ipa_stmt_fixups (node
, stmts
);
1274 update_ssa (TODO_update_ssa_only_virtuals
);
1275 free_dominance_info (CDI_DOMINATORS
);
1276 free_dominance_info (CDI_POST_DOMINATORS
);
1281 /* Read initializer expressions for public statics. DATA_IN is the
1282 file being read. IB is the input block used for reading. */
1285 input_alias_pairs (struct lto_input_block
*ib
, struct data_in
*data_in
)
1289 clear_line_info (data_in
);
1291 /* Skip over all the unreferenced globals. */
1293 var
= lto_input_tree (ib
, data_in
);
1296 var
= lto_input_tree (ib
, data_in
);
1299 const char *orig_name
, *new_name
;
1302 p
= VEC_safe_push (alias_pair
, gc
, alias_pairs
, NULL
);
1304 p
->target
= lto_input_tree (ib
, data_in
);
1306 /* If the target is a static object, we may have registered a
1307 new name for it to avoid clashes between statics coming from
1308 different files. In that case, use the new name. */
1309 orig_name
= IDENTIFIER_POINTER (p
->target
);
1310 new_name
= lto_get_decl_name_mapping (data_in
->file_data
, orig_name
);
1311 if (strcmp (orig_name
, new_name
) != 0)
1312 p
->target
= get_identifier (new_name
);
1314 var
= lto_input_tree (ib
, data_in
);
1319 /* Read the body from DATA for function FN_DECL and fill it in.
1320 FILE_DATA are the global decls and types. SECTION_TYPE is either
1321 LTO_section_function_body or LTO_section_static_initializer. If
1322 section type is LTO_section_function_body, FN must be the decl for
1326 lto_read_body (struct lto_file_decl_data
*file_data
, tree fn_decl
,
1327 const char *data
, enum lto_section_type section_type
)
1329 const struct lto_function_header
*header
;
1330 struct data_in
*data_in
;
1332 int32_t main_offset
;
1333 int32_t string_offset
;
1334 struct lto_input_block ib_cfg
;
1335 struct lto_input_block ib_main
;
1337 header
= (const struct lto_function_header
*) data
;
1338 cfg_offset
= sizeof (struct lto_function_header
);
1339 main_offset
= cfg_offset
+ header
->cfg_size
;
1340 string_offset
= main_offset
+ header
->main_size
;
1342 LTO_INIT_INPUT_BLOCK (ib_cfg
,
1347 LTO_INIT_INPUT_BLOCK (ib_main
,
1352 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
1353 header
->string_size
, NULL
);
1355 /* Make sure the file was generated by the exact same compiler. */
1356 lto_check_version (header
->lto_header
.major_version
,
1357 header
->lto_header
.minor_version
);
1359 if (section_type
== LTO_section_function_body
)
1361 struct function
*fn
= DECL_STRUCT_FUNCTION (fn_decl
);
1362 struct lto_in_decl_state
*decl_state
;
1367 /* Use the function's decl state. */
1368 decl_state
= lto_get_function_in_decl_state (file_data
, fn_decl
);
1369 gcc_assert (decl_state
);
1370 file_data
->current_decl_state
= decl_state
;
1372 input_cfg (&ib_cfg
, fn
);
1374 /* Set up the struct function. */
1375 input_function (fn_decl
, data_in
, &ib_main
);
1377 /* We should now be in SSA. */
1378 cfun
->gimple_df
->in_ssa_p
= true;
1380 /* Restore decl state */
1381 file_data
->current_decl_state
= file_data
->global_decl_state
;
1387 input_alias_pairs (&ib_main
, data_in
);
1390 clear_line_info (data_in
);
1391 lto_data_in_delete (data_in
);
1395 /* Read the body of FN_DECL using DATA. FILE_DATA holds the global
1399 lto_input_function_body (struct lto_file_decl_data
*file_data
,
1400 tree fn_decl
, const char *data
)
1402 current_function_decl
= fn_decl
;
1403 lto_read_body (file_data
, fn_decl
, data
, LTO_section_function_body
);
1407 /* Read in VAR_DECL using DATA. FILE_DATA holds the global decls and
1411 lto_input_constructors_and_inits (struct lto_file_decl_data
*file_data
,
1414 lto_read_body (file_data
, NULL
, data
, LTO_section_static_initializer
);
1418 /* Return the resolution for the decl with index INDEX from DATA_IN. */
1420 static enum ld_plugin_symbol_resolution
1421 get_resolution (struct data_in
*data_in
, unsigned index
)
1423 if (data_in
->globals_resolution
)
1425 ld_plugin_symbol_resolution_t ret
;
1426 /* We can have references to not emitted functions in
1427 DECL_FUNCTION_PERSONALITY at least. So we can and have
1428 to indeed return LDPR_UNKNOWN in some cases. */
1429 if (VEC_length (ld_plugin_symbol_resolution_t
,
1430 data_in
->globals_resolution
) <= index
)
1431 return LDPR_UNKNOWN
;
1432 ret
= VEC_index (ld_plugin_symbol_resolution_t
,
1433 data_in
->globals_resolution
,
1438 /* Delay resolution finding until decl merging. */
1439 return LDPR_UNKNOWN
;
1443 /* Unpack all the non-pointer fields of the TS_BASE structure of
1444 expression EXPR from bitpack BP. */
1447 unpack_ts_base_value_fields (struct bitpack_d
*bp
, tree expr
)
1449 /* Note that the code for EXPR has already been unpacked to create EXPR in
1450 lto_materialize_tree. */
1453 TREE_SIDE_EFFECTS (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1454 TREE_CONSTANT (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1455 TREE_READONLY (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1457 /* TREE_PUBLIC is used on types to indicate that the type
1458 has a TYPE_CACHED_VALUES vector. This is not streamed out,
1459 so we skip it here. */
1460 TREE_PUBLIC (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1463 bp_unpack_value (bp
, 4);
1464 TREE_ADDRESSABLE (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1465 TREE_THIS_VOLATILE (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1467 DECL_UNSIGNED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1468 else if (TYPE_P (expr
))
1469 TYPE_UNSIGNED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1471 bp_unpack_value (bp
, 1);
1472 TREE_ASM_WRITTEN (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1473 TREE_NO_WARNING (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1474 TREE_USED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1475 TREE_NOTHROW (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1476 TREE_STATIC (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1477 TREE_PRIVATE (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1478 TREE_PROTECTED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1479 TREE_DEPRECATED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1481 TYPE_SATURATING (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1482 else if (TREE_CODE (expr
) == SSA_NAME
)
1483 SSA_NAME_IS_DEFAULT_DEF (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1485 bp_unpack_value (bp
, 1);
1489 /* Unpack all the non-pointer fields of the TS_REAL_CST structure of
1490 expression EXPR from bitpack BP. */
1493 unpack_ts_real_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
1497 REAL_VALUE_TYPE
*rp
;
1499 r
.cl
= (unsigned) bp_unpack_value (bp
, 2);
1500 r
.decimal
= (unsigned) bp_unpack_value (bp
, 1);
1501 r
.sign
= (unsigned) bp_unpack_value (bp
, 1);
1502 r
.signalling
= (unsigned) bp_unpack_value (bp
, 1);
1503 r
.canonical
= (unsigned) bp_unpack_value (bp
, 1);
1504 r
.uexp
= (unsigned) bp_unpack_value (bp
, EXP_BITS
);
1505 for (i
= 0; i
< SIGSZ
; i
++)
1506 r
.sig
[i
] = (unsigned long) bp_unpack_value (bp
, HOST_BITS_PER_LONG
);
1508 rp
= ggc_alloc_real_value ();
1509 memcpy (rp
, &r
, sizeof (REAL_VALUE_TYPE
));
1510 TREE_REAL_CST_PTR (expr
) = rp
;
1514 /* Unpack all the non-pointer fields of the TS_FIXED_CST structure of
1515 expression EXPR from bitpack BP. */
1518 unpack_ts_fixed_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
1520 struct fixed_value fv
;
1522 fv
.data
.low
= (HOST_WIDE_INT
) bp_unpack_value (bp
, HOST_BITS_PER_WIDE_INT
);
1523 fv
.data
.high
= (HOST_WIDE_INT
) bp_unpack_value (bp
, HOST_BITS_PER_WIDE_INT
);
1524 fv
.mode
= (enum machine_mode
) bp_unpack_value (bp
, HOST_BITS_PER_INT
);
1525 TREE_FIXED_CST (expr
) = fv
;
1529 /* Unpack all the non-pointer fields of the TS_DECL_COMMON structure
1530 of expression EXPR from bitpack BP. */
1533 unpack_ts_decl_common_value_fields (struct bitpack_d
*bp
, tree expr
)
1535 DECL_MODE (expr
) = (enum machine_mode
) bp_unpack_value (bp
, 8);
1536 DECL_NONLOCAL (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1537 DECL_VIRTUAL_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1538 DECL_IGNORED_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1539 DECL_ABSTRACT (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1540 DECL_ARTIFICIAL (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1541 DECL_USER_ALIGN (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1542 DECL_PRESERVE_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1543 DECL_DEBUG_EXPR_IS_FROM (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1544 DECL_EXTERNAL (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1545 DECL_GIMPLE_REG_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1546 DECL_ALIGN (expr
) = (unsigned) bp_unpack_value (bp
, HOST_BITS_PER_INT
);
1548 if (TREE_CODE (expr
) == LABEL_DECL
)
1550 DECL_ERROR_ISSUED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1551 EH_LANDING_PAD_NR (expr
) = (int) bp_unpack_value (bp
, HOST_BITS_PER_INT
);
1553 /* Always assume an initial value of -1 for LABEL_DECL_UID to
1554 force gimple_set_bb to recreate label_to_block_map. */
1555 LABEL_DECL_UID (expr
) = -1;
1558 if (TREE_CODE (expr
) == FIELD_DECL
)
1560 unsigned HOST_WIDE_INT off_align
;
1561 DECL_PACKED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1562 DECL_NONADDRESSABLE_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1563 off_align
= (unsigned HOST_WIDE_INT
) bp_unpack_value (bp
, 8);
1564 SET_DECL_OFFSET_ALIGN (expr
, off_align
);
1567 if (TREE_CODE (expr
) == RESULT_DECL
1568 || TREE_CODE (expr
) == PARM_DECL
1569 || TREE_CODE (expr
) == VAR_DECL
)
1571 DECL_BY_REFERENCE (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1572 if (TREE_CODE (expr
) == VAR_DECL
1573 || TREE_CODE (expr
) == PARM_DECL
)
1574 DECL_HAS_VALUE_EXPR_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1575 DECL_RESTRICTED_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1580 /* Unpack all the non-pointer fields of the TS_DECL_WRTL structure
1581 of expression EXPR from bitpack BP. */
1584 unpack_ts_decl_wrtl_value_fields (struct bitpack_d
*bp
, tree expr
)
1586 DECL_REGISTER (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1590 /* Unpack all the non-pointer fields of the TS_DECL_WITH_VIS structure
1591 of expression EXPR from bitpack BP. */
1594 unpack_ts_decl_with_vis_value_fields (struct bitpack_d
*bp
, tree expr
)
1596 DECL_DEFER_OUTPUT (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1597 DECL_COMMON (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1598 DECL_DLLIMPORT_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1599 DECL_WEAK (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1600 DECL_SEEN_IN_BIND_EXPR_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1601 DECL_COMDAT (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1602 DECL_VISIBILITY (expr
) = (enum symbol_visibility
) bp_unpack_value (bp
, 2);
1603 DECL_VISIBILITY_SPECIFIED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1605 if (TREE_CODE (expr
) == VAR_DECL
)
1607 DECL_HARD_REGISTER (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1608 DECL_IN_TEXT_SECTION (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1609 DECL_IN_CONSTANT_POOL (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1610 DECL_TLS_MODEL (expr
) = (enum tls_model
) bp_unpack_value (bp
, 3);
1613 if (VAR_OR_FUNCTION_DECL_P (expr
))
1616 p
= (priority_type
) bp_unpack_value (bp
, HOST_BITS_PER_SHORT
);
1617 SET_DECL_INIT_PRIORITY (expr
, p
);
1622 /* Unpack all the non-pointer fields of the TS_FUNCTION_DECL structure
1623 of expression EXPR from bitpack BP. */
1626 unpack_ts_function_decl_value_fields (struct bitpack_d
*bp
, tree expr
)
1628 DECL_FUNCTION_CODE (expr
) = (enum built_in_function
) bp_unpack_value (bp
, 11);
1629 DECL_BUILT_IN_CLASS (expr
) = (enum built_in_class
) bp_unpack_value (bp
, 2);
1630 DECL_STATIC_CONSTRUCTOR (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1631 DECL_STATIC_DESTRUCTOR (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1632 DECL_UNINLINABLE (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1633 DECL_POSSIBLY_INLINED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1634 DECL_IS_NOVOPS (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1635 DECL_IS_RETURNS_TWICE (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1636 DECL_IS_MALLOC (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1637 DECL_IS_OPERATOR_NEW (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1638 DECL_DECLARED_INLINE_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1639 DECL_STATIC_CHAIN (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1640 DECL_NO_INLINE_WARNING_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1641 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr
)
1642 = (unsigned) bp_unpack_value (bp
, 1);
1643 DECL_NO_LIMIT_STACK (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1644 DECL_DISREGARD_INLINE_LIMITS (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1645 DECL_PURE_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1646 DECL_LOOPING_CONST_OR_PURE_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1650 /* Unpack all the non-pointer fields of the TS_TYPE structure
1651 of expression EXPR from bitpack BP. */
1654 unpack_ts_type_value_fields (struct bitpack_d
*bp
, tree expr
)
1656 enum machine_mode mode
;
1658 TYPE_PRECISION (expr
) = (unsigned) bp_unpack_value (bp
, 10);
1659 mode
= (enum machine_mode
) bp_unpack_value (bp
, 8);
1660 SET_TYPE_MODE (expr
, mode
);
1661 TYPE_STRING_FLAG (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1662 TYPE_NO_FORCE_BLK (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1663 TYPE_NEEDS_CONSTRUCTING (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1664 if (RECORD_OR_UNION_TYPE_P (expr
))
1665 TYPE_TRANSPARENT_AGGR (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1666 TYPE_PACKED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1667 TYPE_RESTRICT (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1668 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr
)
1669 = (unsigned) bp_unpack_value (bp
, 2);
1670 TYPE_USER_ALIGN (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1671 TYPE_READONLY (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1672 TYPE_ALIGN (expr
) = (unsigned) bp_unpack_value (bp
, HOST_BITS_PER_INT
);
1673 TYPE_ALIAS_SET (expr
) = bp_unpack_value (bp
, HOST_BITS_PER_INT
);
1677 /* Unpack all the non-pointer fields of the TS_BLOCK structure
1678 of expression EXPR from bitpack BP. */
1681 unpack_ts_block_value_fields (struct bitpack_d
*bp
, tree expr
)
1683 BLOCK_ABSTRACT (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1684 BLOCK_NUMBER (expr
) = (unsigned) bp_unpack_value (bp
, 31);
1687 /* Unpack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL
1688 structure of expression EXPR from bitpack BP. */
1691 unpack_ts_translation_unit_decl_value_fields (struct bitpack_d
*bp ATTRIBUTE_UNUSED
, tree expr ATTRIBUTE_UNUSED
)
1695 /* Unpack all the non-pointer fields in EXPR into a bit pack. */
1698 unpack_value_fields (struct bitpack_d
*bp
, tree expr
)
1700 enum tree_code code
;
1702 code
= TREE_CODE (expr
);
1704 /* Note that all these functions are highly sensitive to changes in
1705 the types and sizes of each of the fields being packed. */
1706 unpack_ts_base_value_fields (bp
, expr
);
1708 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
1709 unpack_ts_real_cst_value_fields (bp
, expr
);
1711 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
1712 unpack_ts_fixed_cst_value_fields (bp
, expr
);
1714 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1715 unpack_ts_decl_common_value_fields (bp
, expr
);
1717 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
1718 unpack_ts_decl_wrtl_value_fields (bp
, expr
);
1720 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1721 unpack_ts_decl_with_vis_value_fields (bp
, expr
);
1723 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1724 unpack_ts_function_decl_value_fields (bp
, expr
);
1726 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE
))
1727 unpack_ts_type_value_fields (bp
, expr
);
1729 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
1730 unpack_ts_block_value_fields (bp
, expr
);
1732 if (CODE_CONTAINS_STRUCT (code
, TS_SSA_NAME
))
1734 /* We only stream the version number of SSA names. */
1738 if (CODE_CONTAINS_STRUCT (code
, TS_STATEMENT_LIST
))
1740 /* This is only used by GENERIC. */
1744 if (CODE_CONTAINS_STRUCT (code
, TS_OMP_CLAUSE
))
1746 /* This is only used by High GIMPLE. */
1750 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
1751 unpack_ts_translation_unit_decl_value_fields (bp
, expr
);
1755 /* Materialize a new tree from input block IB using descriptors in
1756 DATA_IN. The code for the new tree should match TAG. Store in
1757 *IX_P the index into the reader cache where the new tree is stored. */
1760 lto_materialize_tree (struct lto_input_block
*ib
, struct data_in
*data_in
,
1761 enum LTO_tags tag
, int *ix_p
)
1763 struct bitpack_d bp
;
1764 enum tree_code code
;
1766 #ifdef LTO_STREAMER_DEBUG
1767 HOST_WIDEST_INT orig_address_in_writer
;
1773 /* Read the header of the node we are about to create. */
1774 ix
= lto_input_sleb128 (ib
);
1775 gcc_assert ((int) ix
== ix
);
1778 #ifdef LTO_STREAMER_DEBUG
1779 /* Read the word representing the memory address for the tree
1780 as it was written by the writer. This is useful when
1781 debugging differences between the writer and reader. */
1782 orig_address_in_writer
= lto_input_sleb128 (ib
);
1783 gcc_assert ((intptr_t) orig_address_in_writer
== orig_address_in_writer
);
1786 code
= lto_tag_to_tree_code (tag
);
1788 /* We should never see an SSA_NAME tree. Only the version numbers of
1789 SSA names are ever written out. See input_ssa_names. */
1790 gcc_assert (code
!= SSA_NAME
);
1792 /* Instantiate a new tree using the header data. */
1793 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
1794 result
= input_string_cst (data_in
, ib
);
1795 else if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
1796 result
= input_identifier (data_in
, ib
);
1797 else if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1799 HOST_WIDE_INT len
= lto_input_sleb128 (ib
);
1800 result
= make_tree_vec (len
);
1802 else if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1804 unsigned HOST_WIDE_INT len
= lto_input_uleb128 (ib
);
1805 result
= make_tree_binfo (len
);
1809 /* All other nodes can be materialized with a raw make_node
1811 result
= make_node (code
);
1814 #ifdef LTO_STREAMER_DEBUG
1815 /* Store the original address of the tree as seen by the writer
1816 in RESULT's aux field. This is useful when debugging streaming
1817 problems. This way, a debugging session can be started on
1818 both writer and reader with a breakpoint using this address
1820 lto_orig_address_map (result
, (intptr_t) orig_address_in_writer
);
1823 /* Read the bitpack of non-pointer values from IB. */
1824 bp
= lto_input_bitpack (ib
);
1826 /* The first word in BP contains the code of the tree that we
1827 are about to read. */
1828 code
= (enum tree_code
) bp_unpack_value (&bp
, 16);
1829 lto_tag_check (lto_tree_code_to_tag (code
), tag
);
1831 /* Unpack all the value fields from BP. */
1832 unpack_value_fields (&bp
, result
);
1834 /* Enter RESULT in the reader cache. This will make RESULT
1835 available so that circular references in the rest of the tree
1836 structure can be resolved in subsequent calls to lto_input_tree. */
1837 lto_streamer_cache_insert_at (data_in
->reader_cache
, result
, ix
);
1843 /* Read a chain of tree nodes from input block IB. DATA_IN contains
1844 tables and descriptors for the file being read. */
1847 lto_input_chain (struct lto_input_block
*ib
, struct data_in
*data_in
)
1850 tree first
, prev
, curr
;
1852 first
= prev
= NULL_TREE
;
1853 count
= lto_input_sleb128 (ib
);
1854 for (i
= 0; i
< count
; i
++)
1856 curr
= lto_input_tree (ib
, data_in
);
1858 TREE_CHAIN (prev
) = curr
;
1862 TREE_CHAIN (curr
) = NULL_TREE
;
1870 /* Read all pointer fields in the TS_COMMON structure of EXPR from input
1871 block IB. DATA_IN contains tables and descriptors for the
1876 lto_input_ts_common_tree_pointers (struct lto_input_block
*ib
,
1877 struct data_in
*data_in
, tree expr
)
1879 TREE_TYPE (expr
) = lto_input_tree (ib
, data_in
);
1883 /* Read all pointer fields in the TS_VECTOR structure of EXPR from input
1884 block IB. DATA_IN contains tables and descriptors for the
1888 lto_input_ts_vector_tree_pointers (struct lto_input_block
*ib
,
1889 struct data_in
*data_in
, tree expr
)
1891 TREE_VECTOR_CST_ELTS (expr
) = lto_input_chain (ib
, data_in
);
1895 /* Read all pointer fields in the TS_COMPLEX structure of EXPR from input
1896 block IB. DATA_IN contains tables and descriptors for the
1900 lto_input_ts_complex_tree_pointers (struct lto_input_block
*ib
,
1901 struct data_in
*data_in
, tree expr
)
1903 TREE_REALPART (expr
) = lto_input_tree (ib
, data_in
);
1904 TREE_IMAGPART (expr
) = lto_input_tree (ib
, data_in
);
1908 /* Read all pointer fields in the TS_DECL_MINIMAL structure of EXPR
1909 from input block IB. DATA_IN contains tables and descriptors for the
1913 lto_input_ts_decl_minimal_tree_pointers (struct lto_input_block
*ib
,
1914 struct data_in
*data_in
, tree expr
)
1916 DECL_NAME (expr
) = lto_input_tree (ib
, data_in
);
1917 DECL_CONTEXT (expr
) = lto_input_tree (ib
, data_in
);
1918 /* We do not stream BLOCK_VARS but lazily construct it here. */
1919 if (DECL_CONTEXT (expr
)
1920 && TREE_CODE (DECL_CONTEXT (expr
)) == BLOCK
)
1922 TREE_CHAIN (expr
) = BLOCK_VARS (DECL_CONTEXT (expr
));
1923 BLOCK_VARS (DECL_CONTEXT (expr
)) = expr
;
1925 DECL_SOURCE_LOCATION (expr
) = lto_input_location (ib
, data_in
);
1929 /* Read all pointer fields in the TS_DECL_COMMON structure of EXPR from
1930 input block IB. DATA_IN contains tables and descriptors for the
1934 lto_input_ts_decl_common_tree_pointers (struct lto_input_block
*ib
,
1935 struct data_in
*data_in
, tree expr
)
1937 DECL_SIZE (expr
) = lto_input_tree (ib
, data_in
);
1938 DECL_SIZE_UNIT (expr
) = lto_input_tree (ib
, data_in
);
1940 if (TREE_CODE (expr
) != FUNCTION_DECL
)
1941 DECL_INITIAL (expr
) = lto_input_tree (ib
, data_in
);
1943 DECL_ATTRIBUTES (expr
) = lto_input_tree (ib
, data_in
);
1944 DECL_ABSTRACT_ORIGIN (expr
) = lto_input_tree (ib
, data_in
);
1946 if (TREE_CODE (expr
) == PARM_DECL
)
1947 TREE_CHAIN (expr
) = lto_input_chain (ib
, data_in
);
1949 if ((TREE_CODE (expr
) == VAR_DECL
1950 || TREE_CODE (expr
) == PARM_DECL
)
1951 && DECL_HAS_VALUE_EXPR_P (expr
))
1952 SET_DECL_VALUE_EXPR (expr
, lto_input_tree (ib
, data_in
));
1954 if (TREE_CODE (expr
) == VAR_DECL
)
1956 tree dexpr
= lto_input_tree (ib
, data_in
);
1958 SET_DECL_DEBUG_EXPR (expr
, dexpr
);
1963 /* Read all pointer fields in the TS_DECL_NON_COMMON structure of
1964 EXPR from input block IB. DATA_IN contains tables and descriptors for the
1968 lto_input_ts_decl_non_common_tree_pointers (struct lto_input_block
*ib
,
1969 struct data_in
*data_in
, tree expr
)
1971 if (TREE_CODE (expr
) == FUNCTION_DECL
)
1973 DECL_ARGUMENTS (expr
) = lto_input_tree (ib
, data_in
);
1974 DECL_RESULT (expr
) = lto_input_tree (ib
, data_in
);
1976 DECL_VINDEX (expr
) = lto_input_tree (ib
, data_in
);
1980 /* Read all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
1981 from input block IB. DATA_IN contains tables and descriptors for the
1985 lto_input_ts_decl_with_vis_tree_pointers (struct lto_input_block
*ib
,
1986 struct data_in
*data_in
, tree expr
)
1990 id
= lto_input_tree (ib
, data_in
);
1993 gcc_assert (TREE_CODE (id
) == IDENTIFIER_NODE
);
1994 SET_DECL_ASSEMBLER_NAME (expr
, id
);
1997 DECL_SECTION_NAME (expr
) = lto_input_tree (ib
, data_in
);
1998 DECL_COMDAT_GROUP (expr
) = lto_input_tree (ib
, data_in
);
2002 /* Read all pointer fields in the TS_FIELD_DECL structure of EXPR from
2003 input block IB. DATA_IN contains tables and descriptors for the
2007 lto_input_ts_field_decl_tree_pointers (struct lto_input_block
*ib
,
2008 struct data_in
*data_in
, tree expr
)
2010 DECL_FIELD_OFFSET (expr
) = lto_input_tree (ib
, data_in
);
2011 DECL_BIT_FIELD_TYPE (expr
) = lto_input_tree (ib
, data_in
);
2012 DECL_QUALIFIER (expr
) = lto_input_tree (ib
, data_in
);
2013 DECL_FIELD_BIT_OFFSET (expr
) = lto_input_tree (ib
, data_in
);
2014 DECL_FCONTEXT (expr
) = lto_input_tree (ib
, data_in
);
2015 TREE_CHAIN (expr
) = lto_input_chain (ib
, data_in
);
2019 /* Read all pointer fields in the TS_FUNCTION_DECL structure of EXPR
2020 from input block IB. DATA_IN contains tables and descriptors for the
2024 lto_input_ts_function_decl_tree_pointers (struct lto_input_block
*ib
,
2025 struct data_in
*data_in
, tree expr
)
2027 /* DECL_STRUCT_FUNCTION is handled by lto_input_function. FIXME lto,
2028 maybe it should be handled here? */
2029 DECL_FUNCTION_PERSONALITY (expr
) = lto_input_tree (ib
, data_in
);
2030 DECL_FUNCTION_SPECIFIC_TARGET (expr
) = lto_input_tree (ib
, data_in
);
2031 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr
) = lto_input_tree (ib
, data_in
);
2033 /* If the file contains a function with an EH personality set,
2034 then it was compiled with -fexceptions. In that case, initialize
2035 the backend EH machinery. */
2036 if (DECL_FUNCTION_PERSONALITY (expr
))
2041 /* Read all pointer fields in the TS_TYPE structure of EXPR from input
2042 block IB. DATA_IN contains tables and descriptors for the
2046 lto_input_ts_type_tree_pointers (struct lto_input_block
*ib
,
2047 struct data_in
*data_in
, tree expr
)
2049 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
2050 TYPE_VALUES (expr
) = lto_input_tree (ib
, data_in
);
2051 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
2052 TYPE_DOMAIN (expr
) = lto_input_tree (ib
, data_in
);
2053 else if (RECORD_OR_UNION_TYPE_P (expr
))
2054 TYPE_FIELDS (expr
) = lto_input_tree (ib
, data_in
);
2055 else if (TREE_CODE (expr
) == FUNCTION_TYPE
2056 || TREE_CODE (expr
) == METHOD_TYPE
)
2057 TYPE_ARG_TYPES (expr
) = lto_input_tree (ib
, data_in
);
2059 TYPE_SIZE (expr
) = lto_input_tree (ib
, data_in
);
2060 TYPE_SIZE_UNIT (expr
) = lto_input_tree (ib
, data_in
);
2061 TYPE_ATTRIBUTES (expr
) = lto_input_tree (ib
, data_in
);
2062 TYPE_NAME (expr
) = lto_input_tree (ib
, data_in
);
2063 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO nor
2064 TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. */
2065 if (!POINTER_TYPE_P (expr
))
2066 TYPE_MINVAL (expr
) = lto_input_tree (ib
, data_in
);
2067 TYPE_MAXVAL (expr
) = lto_input_tree (ib
, data_in
);
2068 TYPE_MAIN_VARIANT (expr
) = lto_input_tree (ib
, data_in
);
2069 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
2071 if (RECORD_OR_UNION_TYPE_P (expr
))
2072 TYPE_BINFO (expr
) = lto_input_tree (ib
, data_in
);
2073 TYPE_CONTEXT (expr
) = lto_input_tree (ib
, data_in
);
2074 /* TYPE_CANONICAL gets re-computed during type merging. */
2075 TYPE_CANONICAL (expr
) = NULL_TREE
;
2076 TYPE_STUB_DECL (expr
) = lto_input_tree (ib
, data_in
);
2080 /* Read all pointer fields in the TS_LIST structure of EXPR from input
2081 block IB. DATA_IN contains tables and descriptors for the
2085 lto_input_ts_list_tree_pointers (struct lto_input_block
*ib
,
2086 struct data_in
*data_in
, tree expr
)
2088 TREE_PURPOSE (expr
) = lto_input_tree (ib
, data_in
);
2089 TREE_VALUE (expr
) = lto_input_tree (ib
, data_in
);
2090 TREE_CHAIN (expr
) = lto_input_chain (ib
, data_in
);
2094 /* Read all pointer fields in the TS_VEC structure of EXPR from input
2095 block IB. DATA_IN contains tables and descriptors for the
2099 lto_input_ts_vec_tree_pointers (struct lto_input_block
*ib
,
2100 struct data_in
*data_in
, tree expr
)
2104 /* Note that TREE_VEC_LENGTH was read by lto_materialize_tree to
2105 instantiate EXPR. */
2106 for (i
= 0; i
< TREE_VEC_LENGTH (expr
); i
++)
2107 TREE_VEC_ELT (expr
, i
) = lto_input_tree (ib
, data_in
);
2111 /* Read all pointer fields in the TS_EXP structure of EXPR from input
2112 block IB. DATA_IN contains tables and descriptors for the
2117 lto_input_ts_exp_tree_pointers (struct lto_input_block
*ib
,
2118 struct data_in
*data_in
, tree expr
)
2123 length
= lto_input_sleb128 (ib
);
2124 gcc_assert (length
== TREE_OPERAND_LENGTH (expr
));
2126 for (i
= 0; i
< length
; i
++)
2127 TREE_OPERAND (expr
, i
) = lto_input_tree (ib
, data_in
);
2129 loc
= lto_input_location (ib
, data_in
);
2130 SET_EXPR_LOCATION (expr
, loc
);
2131 TREE_BLOCK (expr
) = lto_input_tree (ib
, data_in
);
2135 /* Read all pointer fields in the TS_BLOCK structure of EXPR from input
2136 block IB. DATA_IN contains tables and descriptors for the
2140 lto_input_ts_block_tree_pointers (struct lto_input_block
*ib
,
2141 struct data_in
*data_in
, tree expr
)
2145 BLOCK_SOURCE_LOCATION (expr
) = lto_input_location (ib
, data_in
);
2146 /* We do not stream BLOCK_VARS but lazily construct it when reading
2149 len
= lto_input_uleb128 (ib
);
2152 VEC_reserve_exact (tree
, gc
, BLOCK_NONLOCALIZED_VARS (expr
), len
);
2153 for (i
= 0; i
< len
; i
++)
2155 tree t
= lto_input_tree (ib
, data_in
);
2156 VEC_quick_push (tree
, BLOCK_NONLOCALIZED_VARS (expr
), t
);
2160 BLOCK_SUPERCONTEXT (expr
) = lto_input_tree (ib
, data_in
);
2161 BLOCK_ABSTRACT_ORIGIN (expr
) = lto_input_tree (ib
, data_in
);
2162 BLOCK_FRAGMENT_ORIGIN (expr
) = lto_input_tree (ib
, data_in
);
2163 BLOCK_FRAGMENT_CHAIN (expr
) = lto_input_tree (ib
, data_in
);
2164 /* We re-compute BLOCK_SUBBLOCKS of our parent here instead
2165 of streaming it. For non-BLOCK BLOCK_SUPERCONTEXTs we still
2166 stream the child relationship explicitly. */
2167 if (BLOCK_SUPERCONTEXT (expr
)
2168 && TREE_CODE (BLOCK_SUPERCONTEXT (expr
)) == BLOCK
)
2170 BLOCK_CHAIN (expr
) = BLOCK_SUBBLOCKS (BLOCK_SUPERCONTEXT (expr
));
2171 BLOCK_SUBBLOCKS (BLOCK_SUPERCONTEXT (expr
)) = expr
;
2176 /* Read all pointer fields in the TS_BINFO structure of EXPR from input
2177 block IB. DATA_IN contains tables and descriptors for the
2181 lto_input_ts_binfo_tree_pointers (struct lto_input_block
*ib
,
2182 struct data_in
*data_in
, tree expr
)
2187 /* Note that the number of slots in EXPR was read in
2188 lto_materialize_tree when instantiating EXPR. However, the
2189 vector is empty so we cannot rely on VEC_length to know how many
2190 elements to read. So, this list is emitted as a 0-terminated
2191 list on the writer side. */
2194 t
= lto_input_tree (ib
, data_in
);
2196 VEC_quick_push (tree
, BINFO_BASE_BINFOS (expr
), t
);
2200 BINFO_OFFSET (expr
) = lto_input_tree (ib
, data_in
);
2201 BINFO_VTABLE (expr
) = lto_input_tree (ib
, data_in
);
2202 BINFO_VIRTUALS (expr
) = lto_input_tree (ib
, data_in
);
2203 BINFO_VPTR_FIELD (expr
) = lto_input_tree (ib
, data_in
);
2205 len
= lto_input_uleb128 (ib
);
2208 VEC_reserve_exact (tree
, gc
, BINFO_BASE_ACCESSES (expr
), len
);
2209 for (i
= 0; i
< len
; i
++)
2211 tree a
= lto_input_tree (ib
, data_in
);
2212 VEC_quick_push (tree
, BINFO_BASE_ACCESSES (expr
), a
);
2216 BINFO_INHERITANCE_CHAIN (expr
) = lto_input_tree (ib
, data_in
);
2217 BINFO_SUBVTT_INDEX (expr
) = lto_input_tree (ib
, data_in
);
2218 BINFO_VPTR_INDEX (expr
) = lto_input_tree (ib
, data_in
);
2222 /* Read all pointer fields in the TS_CONSTRUCTOR structure of EXPR from
2223 input block IB. DATA_IN contains tables and descriptors for the
2227 lto_input_ts_constructor_tree_pointers (struct lto_input_block
*ib
,
2228 struct data_in
*data_in
, tree expr
)
2232 len
= lto_input_uleb128 (ib
);
2233 for (i
= 0; i
< len
; i
++)
2237 index
= lto_input_tree (ib
, data_in
);
2238 value
= lto_input_tree (ib
, data_in
);
2239 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (expr
), index
, value
);
2244 /* Input a TS_TARGET_OPTION tree from IB into EXPR. */
2247 lto_input_ts_target_option (struct lto_input_block
*ib
, tree expr
)
2250 struct bitpack_d bp
;
2251 struct cl_target_option
*t
= TREE_TARGET_OPTION (expr
);
2253 bp
= lto_input_bitpack (ib
);
2254 len
= sizeof (struct cl_target_option
);
2255 for (i
= 0; i
< len
; i
++)
2256 ((unsigned char *)t
)[i
] = bp_unpack_value (&bp
, 8);
2257 if (bp_unpack_value (&bp
, 32) != 0x12345678)
2258 fatal_error ("cl_target_option size mismatch in LTO reader and writer");
2261 /* Input a TS_TRANSLATION_UNIT_DECL tree from IB and DATA_IN into EXPR. */
2264 lto_input_ts_translation_unit_decl_tree_pointers (struct lto_input_block
*ib
,
2265 struct data_in
*data_in
,
2268 TRANSLATION_UNIT_LANGUAGE (expr
) = xstrdup (input_string (data_in
, ib
));
2269 VEC_safe_push (tree
, gc
, all_translation_units
, expr
);
2272 /* Helper for lto_input_tree. Read all pointer fields in EXPR from
2273 input block IB. DATA_IN contains tables and descriptors for the
2277 lto_input_tree_pointers (struct lto_input_block
*ib
, struct data_in
*data_in
,
2280 enum tree_code code
;
2282 code
= TREE_CODE (expr
);
2284 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
2285 lto_input_ts_common_tree_pointers (ib
, data_in
, expr
);
2287 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
2288 lto_input_ts_vector_tree_pointers (ib
, data_in
, expr
);
2290 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
2291 lto_input_ts_complex_tree_pointers (ib
, data_in
, expr
);
2293 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
2294 lto_input_ts_decl_minimal_tree_pointers (ib
, data_in
, expr
);
2296 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
2297 lto_input_ts_decl_common_tree_pointers (ib
, data_in
, expr
);
2299 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
2300 lto_input_ts_decl_non_common_tree_pointers (ib
, data_in
, expr
);
2302 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
2303 lto_input_ts_decl_with_vis_tree_pointers (ib
, data_in
, expr
);
2305 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
2306 lto_input_ts_field_decl_tree_pointers (ib
, data_in
, expr
);
2308 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
2309 lto_input_ts_function_decl_tree_pointers (ib
, data_in
, expr
);
2311 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE
))
2312 lto_input_ts_type_tree_pointers (ib
, data_in
, expr
);
2314 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
2315 lto_input_ts_list_tree_pointers (ib
, data_in
, expr
);
2317 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
2318 lto_input_ts_vec_tree_pointers (ib
, data_in
, expr
);
2320 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
2321 lto_input_ts_exp_tree_pointers (ib
, data_in
, expr
);
2323 if (CODE_CONTAINS_STRUCT (code
, TS_SSA_NAME
))
2325 /* We only stream the version number of SSA names. */
2329 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
2330 lto_input_ts_block_tree_pointers (ib
, data_in
, expr
);
2332 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
2333 lto_input_ts_binfo_tree_pointers (ib
, data_in
, expr
);
2335 if (CODE_CONTAINS_STRUCT (code
, TS_STATEMENT_LIST
))
2337 /* This should only appear in GENERIC. */
2341 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
2342 lto_input_ts_constructor_tree_pointers (ib
, data_in
, expr
);
2344 if (CODE_CONTAINS_STRUCT (code
, TS_OMP_CLAUSE
))
2346 /* This should only appear in High GIMPLE. */
2350 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
2352 sorry ("optimization options not supported yet");
2355 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
))
2356 lto_input_ts_target_option (ib
, expr
);
2358 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
2359 lto_input_ts_translation_unit_decl_tree_pointers (ib
, data_in
, expr
);
2363 /* Register DECL with the global symbol table and change its
2364 name if necessary to avoid name clashes for static globals across
2368 lto_register_var_decl_in_symtab (struct data_in
*data_in
, tree decl
)
2372 /* Variable has file scope, not local. Need to ensure static variables
2373 between different files don't clash unexpectedly. */
2374 if (!TREE_PUBLIC (decl
)
2375 && !((context
= decl_function_context (decl
))
2376 && auto_var_in_fn_p (decl
, context
)))
2378 /* ??? We normally pre-mangle names before we serialize them
2379 out. Here, in lto1, we do not know the language, and
2380 thus cannot do the mangling again. Instead, we just
2381 append a suffix to the mangled name. The resulting name,
2382 however, is not a properly-formed mangled name, and will
2383 confuse any attempt to unmangle it. */
2384 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
2387 ASM_FORMAT_PRIVATE_NAME (label
, name
, DECL_UID (decl
));
2388 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (label
));
2389 rest_of_decl_compilation (decl
, 1, 0);
2392 /* If this variable has already been declared, queue the
2393 declaration for merging. */
2394 if (TREE_PUBLIC (decl
))
2397 if (!lto_streamer_cache_lookup (data_in
->reader_cache
, decl
, &ix
))
2399 lto_symtab_register_decl (decl
, get_resolution (data_in
, ix
),
2400 data_in
->file_data
);
2406 /* Register DECL with the global symbol table and change its
2407 name if necessary to avoid name clashes for static globals across
2408 different files. DATA_IN contains descriptors and tables for the
2412 lto_register_function_decl_in_symtab (struct data_in
*data_in
, tree decl
)
2414 /* Need to ensure static entities between different files
2415 don't clash unexpectedly. */
2416 if (!TREE_PUBLIC (decl
))
2418 /* We must not use the DECL_ASSEMBLER_NAME macro here, as it
2419 may set the assembler name where it was previously empty. */
2420 tree old_assembler_name
= decl
->decl_with_vis
.assembler_name
;
2422 /* FIXME lto: We normally pre-mangle names before we serialize
2423 them out. Here, in lto1, we do not know the language, and
2424 thus cannot do the mangling again. Instead, we just append a
2425 suffix to the mangled name. The resulting name, however, is
2426 not a properly-formed mangled name, and will confuse any
2427 attempt to unmangle it. */
2428 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
2431 ASM_FORMAT_PRIVATE_NAME (label
, name
, DECL_UID (decl
));
2432 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (label
));
2434 /* We may arrive here with the old assembler name not set
2435 if the function body is not needed, e.g., it has been
2436 inlined away and does not appear in the cgraph. */
2437 if (old_assembler_name
)
2439 tree new_assembler_name
= DECL_ASSEMBLER_NAME (decl
);
2441 /* Make the original assembler name available for later use.
2442 We may have used it to indicate the section within its
2443 object file where the function body may be found.
2444 FIXME lto: Find a better way to maintain the function decl
2445 to body section mapping so we don't need this hack. */
2446 lto_record_renamed_decl (data_in
->file_data
,
2447 IDENTIFIER_POINTER (old_assembler_name
),
2448 IDENTIFIER_POINTER (new_assembler_name
));
2450 /* Also register the reverse mapping so that we can find the
2451 new name given to an existing assembler name (used when
2452 restoring alias pairs in input_constructors_or_inits. */
2453 lto_record_renamed_decl (data_in
->file_data
,
2454 IDENTIFIER_POINTER (new_assembler_name
),
2455 IDENTIFIER_POINTER (old_assembler_name
));
2459 /* If this variable has already been declared, queue the
2460 declaration for merging. */
2461 if (TREE_PUBLIC (decl
) && !DECL_ABSTRACT (decl
))
2464 if (!lto_streamer_cache_lookup (data_in
->reader_cache
, decl
, &ix
))
2466 lto_symtab_register_decl (decl
, get_resolution (data_in
, ix
),
2467 data_in
->file_data
);
2472 /* Read an index IX from input block IB and return the tree node at
2473 DATA_IN->FILE_DATA->GLOBALS_INDEX[IX]. */
2476 lto_get_pickled_tree (struct lto_input_block
*ib
, struct data_in
*data_in
)
2480 enum LTO_tags expected_tag
;
2481 unsigned HOST_WIDE_INT orig_offset
;
2483 ix
= lto_input_sleb128 (ib
);
2484 expected_tag
= (enum LTO_tags
) lto_input_uleb128 (ib
);
2486 orig_offset
= lto_input_uleb128 (ib
);
2487 gcc_assert (orig_offset
== (unsigned) orig_offset
);
2489 result
= lto_streamer_cache_get (data_in
->reader_cache
, ix
);
2490 if (result
== NULL_TREE
)
2492 /* We have not yet read the cache slot IX. Go to the offset
2493 in the stream where the physical tree node is, and materialize
2495 struct lto_input_block fwd_ib
;
2497 /* If we are trying to go back in the stream, something is wrong.
2498 We should've read the node at the earlier position already. */
2499 if (ib
->p
>= orig_offset
)
2500 internal_error ("bytecode stream: tried to jump backwards in the "
2503 LTO_INIT_INPUT_BLOCK (fwd_ib
, ib
->data
, orig_offset
, ib
->len
);
2504 result
= lto_input_tree (&fwd_ib
, data_in
);
2508 && TREE_CODE (result
) == lto_tag_to_tree_code (expected_tag
));
2514 /* Read a code and class from input block IB and return the
2515 corresponding builtin. DATA_IN is as in lto_input_tree. */
2518 lto_get_builtin_tree (struct lto_input_block
*ib
, struct data_in
*data_in
)
2520 enum built_in_class fclass
;
2521 enum built_in_function fcode
;
2522 const char *asmname
;
2526 fclass
= (enum built_in_class
) lto_input_uleb128 (ib
);
2527 gcc_assert (fclass
== BUILT_IN_NORMAL
|| fclass
== BUILT_IN_MD
);
2529 fcode
= (enum built_in_function
) lto_input_uleb128 (ib
);
2531 ix
= lto_input_sleb128 (ib
);
2532 gcc_assert (ix
== (int) ix
);
2534 if (fclass
== BUILT_IN_NORMAL
)
2536 gcc_assert (fcode
< END_BUILTINS
);
2537 result
= built_in_decls
[fcode
];
2538 gcc_assert (result
);
2540 else if (fclass
== BUILT_IN_MD
)
2542 result
= targetm
.builtin_decl (fcode
, true);
2543 if (!result
|| result
== error_mark_node
)
2544 fatal_error ("target specific builtin not available");
2549 asmname
= input_string (data_in
, ib
);
2551 set_builtin_user_assembler_name (result
, asmname
);
2553 lto_streamer_cache_insert_at (data_in
->reader_cache
, result
, ix
);
2559 /* Read the physical representation of a tree node with tag TAG from
2560 input block IB using the per-file context in DATA_IN. */
2563 lto_read_tree (struct lto_input_block
*ib
, struct data_in
*data_in
,
2569 result
= lto_materialize_tree (ib
, data_in
, tag
, &ix
);
2571 /* Read all the pointer fields in RESULT. */
2572 lto_input_tree_pointers (ib
, data_in
, result
);
2574 /* We should never try to instantiate an MD or NORMAL builtin here. */
2575 if (TREE_CODE (result
) == FUNCTION_DECL
)
2576 gcc_assert (!lto_stream_as_builtin_p (result
));
2578 if (TREE_CODE (result
) == VAR_DECL
)
2579 lto_register_var_decl_in_symtab (data_in
, result
);
2580 else if (TREE_CODE (result
) == FUNCTION_DECL
&& !DECL_BUILT_IN (result
))
2581 lto_register_function_decl_in_symtab (data_in
, result
);
2583 /* end_marker = */ lto_input_1_unsigned (ib
);
2585 #ifdef LTO_STREAMER_DEBUG
2586 /* Remove the mapping to RESULT's original address set by
2587 lto_materialize_tree. */
2588 lto_orig_address_remove (result
);
2595 /* Read and INTEGER_CST node from input block IB using the per-file
2596 context in DATA_IN. */
2599 lto_input_integer_cst (struct lto_input_block
*ib
, struct data_in
*data_in
)
2602 HOST_WIDE_INT low
, high
;
2605 type
= lto_input_tree (ib
, data_in
);
2606 overflow_p
= (lto_input_1_unsigned (ib
) != 0);
2607 low
= lto_input_uleb128 (ib
);
2608 high
= lto_input_uleb128 (ib
);
2609 result
= build_int_cst_wide (type
, low
, high
);
2611 /* If the original constant had overflown, build a replica of RESULT to
2612 avoid modifying the shared constant returned by build_int_cst_wide. */
2615 result
= copy_node (result
);
2616 TREE_OVERFLOW (result
) = 1;
2623 /* Read a tree from input block IB using the per-file context in
2624 DATA_IN. This context is used, for example, to resolve references
2625 to previously read nodes. */
2628 lto_input_tree (struct lto_input_block
*ib
, struct data_in
*data_in
)
2633 tag
= input_record_start (ib
);
2634 gcc_assert ((unsigned) tag
< (unsigned) LTO_NUM_TAGS
);
2636 if (tag
== LTO_null
)
2638 else if (tag
>= LTO_field_decl_ref
&& tag
<= LTO_global_decl_ref
)
2640 /* If TAG is a reference to an indexable tree, the next value
2641 in IB is the index into the table where we expect to find
2643 result
= lto_input_tree_ref (ib
, data_in
, cfun
, tag
);
2645 else if (tag
== LTO_tree_pickle_reference
)
2647 /* If TAG is a reference to a previously read tree, look it up in
2648 the reader cache. */
2649 result
= lto_get_pickled_tree (ib
, data_in
);
2651 else if (tag
== LTO_builtin_decl
)
2653 /* If we are going to read a built-in function, all we need is
2654 the code and class. */
2655 result
= lto_get_builtin_tree (ib
, data_in
);
2657 else if (tag
== lto_tree_code_to_tag (INTEGER_CST
))
2659 /* For integer constants we only need the type and its hi/low
2661 result
= lto_input_integer_cst (ib
, data_in
);
2665 /* Otherwise, materialize a new node from IB. */
2666 result
= lto_read_tree (ib
, data_in
, tag
);
2673 /* Initialization for the LTO reader. */
2676 lto_init_reader (void)
2678 lto_streamer_init ();
2680 memset (<o_stats
, 0, sizeof (lto_stats
));
2681 bitmap_obstack_initialize (NULL
);
2683 file_name_hash_table
= htab_create (37, hash_string_slot_node
,
2684 eq_string_slot_node
, free
);
2686 gimple_register_cfg_hooks ();
2690 /* Create a new data_in object for FILE_DATA. STRINGS is the string
2691 table to use with LEN strings. RESOLUTIONS is the vector of linker
2692 resolutions (NULL if not using a linker plugin). */
2695 lto_data_in_create (struct lto_file_decl_data
*file_data
, const char *strings
,
2697 VEC(ld_plugin_symbol_resolution_t
,heap
) *resolutions
)
2699 struct data_in
*data_in
= XCNEW (struct data_in
);
2700 data_in
->file_data
= file_data
;
2701 data_in
->strings
= strings
;
2702 data_in
->strings_len
= len
;
2703 data_in
->globals_resolution
= resolutions
;
2704 data_in
->reader_cache
= lto_streamer_cache_create ();
2710 /* Remove DATA_IN. */
2713 lto_data_in_delete (struct data_in
*data_in
)
2715 VEC_free (ld_plugin_symbol_resolution_t
, heap
, data_in
->globals_resolution
);
2716 lto_streamer_cache_delete (data_in
->reader_cache
);
2717 free (data_in
->labels
);