1 /* Read the GIMPLE representation from a file stream.
3 Copyright 2009 Free Software Foundation, Inc.
4 Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
5 Re-implemented by Diego Novillo <dnovillo@google.com>
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
35 #include "basic-block.h"
36 #include "tree-flow.h"
37 #include "tree-pass.h"
41 #include "diagnostic.h"
48 #include "ipa-utils.h"
49 #include "lto-streamer.h"
51 /* Data structure used to hash file names in the source_location field. */
55 unsigned int slot_num
;
58 /* The table to hold the file names. */
59 static htab_t file_name_hash_table
;
62 /* Check that tag ACTUAL has one of the given values. NUM_TAGS is the
63 number of valid tag values to check. */
66 lto_tag_check_set (enum LTO_tags actual
, int ntags
, ...)
72 for (i
= 0; i
< ntags
; i
++)
73 if ((unsigned) actual
== va_arg (ap
, unsigned))
80 internal_error ("bytecode stream: unexpected tag %s", lto_tag_name (actual
));
84 /* Check that tag ACTUAL is in the range [TAG1, TAG2]. */
87 lto_tag_check_range (enum LTO_tags actual
, enum LTO_tags tag1
,
90 if (actual
< tag1
|| actual
> tag2
)
91 internal_error ("bytecode stream: tag %s is not in the expected range "
93 lto_tag_name (actual
),
99 /* Check that tag ACTUAL == EXPECTED. */
102 lto_tag_check (enum LTO_tags actual
, enum LTO_tags expected
)
104 if (actual
!= expected
)
105 internal_error ("bytecode stream: expected tag %s instead of %s",
106 lto_tag_name (expected
), lto_tag_name (actual
));
110 /* Return a hash code for P. */
113 hash_string_slot_node (const void *p
)
115 const struct string_slot
*ds
= (const struct string_slot
*) p
;
116 return (hashval_t
) htab_hash_string (ds
->s
);
120 /* Returns nonzero if P1 and P2 are equal. */
123 eq_string_slot_node (const void *p1
, const void *p2
)
125 const struct string_slot
*ds1
= (const struct string_slot
*) p1
;
126 const struct string_slot
*ds2
= (const struct string_slot
*) p2
;
127 return strcmp (ds1
->s
, ds2
->s
) == 0;
131 /* Read a string from the string table in DATA_IN using input block
132 IB. Write the length to RLEN. */
135 input_string_internal (struct data_in
*data_in
, struct lto_input_block
*ib
,
138 struct lto_input_block str_tab
;
143 loc
= lto_input_uleb128 (ib
);
144 LTO_INIT_INPUT_BLOCK (str_tab
, data_in
->strings
, loc
, data_in
->strings_len
);
145 len
= lto_input_uleb128 (&str_tab
);
148 if (str_tab
.p
+ len
> data_in
->strings_len
)
149 internal_error ("bytecode stream: string too long for the string table");
151 result
= (const char *)(data_in
->strings
+ str_tab
.p
);
157 /* Read a STRING_CST from the string table in DATA_IN using input
161 input_string_cst (struct data_in
*data_in
, struct lto_input_block
*ib
)
165 unsigned int is_null
;
167 is_null
= lto_input_uleb128 (ib
);
171 ptr
= input_string_internal (data_in
, ib
, &len
);
172 return build_string (len
, ptr
);
176 /* Read an IDENTIFIER from the string table in DATA_IN using input
180 input_identifier (struct data_in
*data_in
, struct lto_input_block
*ib
)
184 unsigned int is_null
;
186 is_null
= lto_input_uleb128 (ib
);
190 ptr
= input_string_internal (data_in
, ib
, &len
);
191 return get_identifier_with_length (ptr
, len
);
194 /* Read a NULL terminated string from the string table in DATA_IN. */
197 input_string (struct data_in
*data_in
, struct lto_input_block
*ib
)
201 unsigned int is_null
;
203 is_null
= lto_input_uleb128 (ib
);
207 ptr
= input_string_internal (data_in
, ib
, &len
);
208 if (ptr
[len
- 1] != '\0')
209 internal_error ("bytecode stream: found non-null terminated string");
215 /* Return the next tag in the input block IB. */
218 input_record_start (struct lto_input_block
*ib
)
220 enum LTO_tags tag
= (enum LTO_tags
) lto_input_uleb128 (ib
);
225 /* Lookup STRING in file_name_hash_table. If found, return the existing
226 string, otherwise insert STRING as the canonical version. */
229 canon_file_name (const char *string
)
232 struct string_slot s_slot
;
235 slot
= htab_find_slot (file_name_hash_table
, &s_slot
, INSERT
);
240 struct string_slot
*new_slot
;
242 len
= strlen (string
);
243 saved_string
= (char *) xmalloc (len
+ 1);
244 new_slot
= XCNEW (struct string_slot
);
245 strcpy (saved_string
, string
);
246 new_slot
->s
= saved_string
;
252 struct string_slot
*old_slot
= (struct string_slot
*) *slot
;
258 /* Clear the line info stored in DATA_IN. */
261 clear_line_info (struct data_in
*data_in
)
263 if (data_in
->current_file
)
264 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
265 data_in
->current_file
= NULL
;
266 data_in
->current_line
= 0;
267 data_in
->current_col
= 0;
271 /* Read a location from input block IB. */
274 lto_input_location (struct lto_input_block
*ib
, struct data_in
*data_in
)
276 expanded_location xloc
;
279 xloc
.file
= input_string (data_in
, ib
);
280 if (xloc
.file
== NULL
)
281 return UNKNOWN_LOCATION
;
283 xloc
.line
= lto_input_sleb128 (ib
);
284 xloc
.column
= lto_input_sleb128 (ib
);
286 if (data_in
->current_file
)
287 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
289 data_in
->current_file
= canon_file_name (xloc
.file
);
290 data_in
->current_line
= xloc
.line
;
291 data_in
->current_col
= xloc
.column
;
293 linemap_add (line_table
, LC_ENTER
, false, data_in
->current_file
, xloc
.line
);
294 LINEMAP_POSITION_FOR_COLUMN (loc
, line_table
, xloc
.column
);
300 /* Read a reference to a tree node from DATA_IN using input block IB.
301 TAG is the expected node that should be found in IB, if TAG belongs
302 to one of the indexable trees, expect to read a reference index to
303 be looked up in one of the symbol tables, otherwise read the pysical
304 representation of the tree using lto_input_tree. FN is the
305 function scope for the read tree. */
308 lto_input_tree_ref (struct lto_input_block
*ib
, struct data_in
*data_in
,
309 struct function
*fn
, enum LTO_tags tag
)
311 unsigned HOST_WIDE_INT ix_u
;
312 tree result
= NULL_TREE
;
314 lto_tag_check_range (tag
, LTO_field_decl_ref
, LTO_global_decl_ref
);
319 ix_u
= lto_input_uleb128 (ib
);
320 result
= lto_file_decl_data_get_type (data_in
->file_data
, ix_u
);
323 case LTO_ssa_name_ref
:
324 ix_u
= lto_input_uleb128 (ib
);
325 result
= VEC_index (tree
, SSANAMES (fn
), ix_u
);
328 case LTO_field_decl_ref
:
329 ix_u
= lto_input_uleb128 (ib
);
330 result
= lto_file_decl_data_get_field_decl (data_in
->file_data
, ix_u
);
333 case LTO_function_decl_ref
:
334 ix_u
= lto_input_uleb128 (ib
);
335 result
= lto_file_decl_data_get_fn_decl (data_in
->file_data
, ix_u
);
338 case LTO_type_decl_ref
:
339 ix_u
= lto_input_uleb128 (ib
);
340 result
= lto_file_decl_data_get_type_decl (data_in
->file_data
, ix_u
);
343 case LTO_namespace_decl_ref
:
344 ix_u
= lto_input_uleb128 (ib
);
345 result
= lto_file_decl_data_get_namespace_decl (data_in
->file_data
, ix_u
);
348 case LTO_global_decl_ref
:
349 case LTO_result_decl_ref
:
350 case LTO_const_decl_ref
:
351 case LTO_imported_decl_ref
:
352 case LTO_label_decl_ref
:
353 ix_u
= lto_input_uleb128 (ib
);
354 result
= lto_file_decl_data_get_var_decl (data_in
->file_data
, ix_u
);
355 if (tag
== LTO_global_decl_ref
)
356 varpool_mark_needed_node (varpool_node (result
));
369 /* Read and return a double-linked list of catch handlers from input
370 block IB, using descriptors in DATA_IN. */
372 static struct eh_catch_d
*
373 lto_input_eh_catch_list (struct lto_input_block
*ib
, struct data_in
*data_in
,
379 *last_p
= first
= NULL
;
380 tag
= input_record_start (ib
);
386 lto_tag_check_range (tag
, LTO_eh_catch
, LTO_eh_catch
);
388 /* Read the catch node. */
389 n
= GGC_CNEW (struct eh_catch_d
);
390 n
->type_list
= lto_input_tree (ib
, data_in
);
391 n
->filter_list
= lto_input_tree (ib
, data_in
);
392 n
->label
= lto_input_tree (ib
, data_in
);
394 /* Register all the types in N->FILTER_LIST. */
395 for (list
= n
->filter_list
; list
; list
= TREE_CHAIN (list
))
396 add_type_for_runtime (TREE_VALUE (list
));
398 /* Chain N to the end of the list. */
400 (*last_p
)->next_catch
= n
;
401 n
->prev_catch
= *last_p
;
404 /* Set the head of the list the first time through the loop. */
408 tag
= input_record_start (ib
);
415 /* Read and return EH region IX from input block IB, using descriptors
419 input_eh_region (struct lto_input_block
*ib
, struct data_in
*data_in
, int ix
)
424 /* Read the region header. */
425 tag
= input_record_start (ib
);
429 r
= GGC_CNEW (struct eh_region_d
);
430 r
->index
= lto_input_sleb128 (ib
);
432 gcc_assert (r
->index
== ix
);
434 /* Read all the region pointers as region numbers. We'll fix up
435 the pointers once the whole array has been read. */
436 r
->outer
= (eh_region
) (intptr_t) lto_input_sleb128 (ib
);
437 r
->inner
= (eh_region
) (intptr_t) lto_input_sleb128 (ib
);
438 r
->next_peer
= (eh_region
) (intptr_t) lto_input_sleb128 (ib
);
442 case LTO_ert_cleanup
:
443 r
->type
= ERT_CLEANUP
;
448 struct eh_catch_d
*last_catch
;
450 r
->u
.eh_try
.first_catch
= lto_input_eh_catch_list (ib
, data_in
,
452 r
->u
.eh_try
.last_catch
= last_catch
;
456 case LTO_ert_allowed_exceptions
:
460 r
->type
= ERT_ALLOWED_EXCEPTIONS
;
461 r
->u
.allowed
.type_list
= lto_input_tree (ib
, data_in
);
462 r
->u
.allowed
.label
= lto_input_tree (ib
, data_in
);
463 r
->u
.allowed
.filter
= lto_input_uleb128 (ib
);
465 for (l
= r
->u
.allowed
.type_list
; l
; l
= TREE_CHAIN (l
))
466 add_type_for_runtime (TREE_VALUE (l
));
470 case LTO_ert_must_not_throw
:
471 r
->type
= ERT_MUST_NOT_THROW
;
472 r
->u
.must_not_throw
.failure_decl
= lto_input_tree (ib
, data_in
);
473 r
->u
.must_not_throw
.failure_loc
= lto_input_location (ib
, data_in
);
480 r
->landing_pads
= (eh_landing_pad
) (intptr_t) lto_input_sleb128 (ib
);
486 /* Read and return EH landing pad IX from input block IB, using descriptors
489 static eh_landing_pad
490 input_eh_lp (struct lto_input_block
*ib
, struct data_in
*data_in
, int ix
)
495 /* Read the landing pad header. */
496 tag
= input_record_start (ib
);
500 lto_tag_check_range (tag
, LTO_eh_landing_pad
, LTO_eh_landing_pad
);
502 lp
= GGC_CNEW (struct eh_landing_pad_d
);
503 lp
->index
= lto_input_sleb128 (ib
);
504 gcc_assert (lp
->index
== ix
);
505 lp
->next_lp
= (eh_landing_pad
) (intptr_t) lto_input_sleb128 (ib
);
506 lp
->region
= (eh_region
) (intptr_t) lto_input_sleb128 (ib
);
507 lp
->post_landing_pad
= lto_input_tree (ib
, data_in
);
513 /* After reading the EH regions, pointers to peer and children regions
514 are region numbers. This converts all these region numbers into
515 real pointers into the rematerialized regions for FN. ROOT_REGION
516 is the region number for the root EH region in FN. */
519 fixup_eh_region_pointers (struct function
*fn
, HOST_WIDE_INT root_region
)
522 VEC(eh_region
,gc
) *eh_array
= fn
->eh
->region_array
;
523 VEC(eh_landing_pad
,gc
) *lp_array
= fn
->eh
->lp_array
;
527 gcc_assert (eh_array
&& lp_array
);
529 gcc_assert (root_region
>= 0);
530 fn
->eh
->region_tree
= VEC_index (eh_region
, eh_array
, root_region
);
532 #define FIXUP_EH_REGION(r) (r) = VEC_index (eh_region, eh_array, \
533 (HOST_WIDE_INT) (intptr_t) (r))
534 #define FIXUP_EH_LP(p) (p) = VEC_index (eh_landing_pad, lp_array, \
535 (HOST_WIDE_INT) (intptr_t) (p))
537 /* Convert all the index numbers stored in pointer fields into
538 pointers to the corresponding slots in the EH region array. */
539 for (i
= 0; VEC_iterate (eh_region
, eh_array
, i
, r
); i
++)
541 /* The array may contain NULL regions. */
545 gcc_assert (i
== (unsigned) r
->index
);
546 FIXUP_EH_REGION (r
->outer
);
547 FIXUP_EH_REGION (r
->inner
);
548 FIXUP_EH_REGION (r
->next_peer
);
549 FIXUP_EH_LP (r
->landing_pads
);
552 /* Convert all the index numbers stored in pointer fields into
553 pointers to the corresponding slots in the EH landing pad array. */
554 for (i
= 0; VEC_iterate (eh_landing_pad
, lp_array
, i
, lp
); i
++)
556 /* The array may contain NULL landing pads. */
560 gcc_assert (i
== (unsigned) lp
->index
);
561 FIXUP_EH_LP (lp
->next_lp
);
562 FIXUP_EH_REGION (lp
->region
);
565 #undef FIXUP_EH_REGION
570 /* Initialize EH support. */
575 /* Contrary to most other FEs, we only initialize EH support when at
576 least one of the files in the set contains exception regions in
577 it. Since this happens much later than the call to init_eh in
578 lang_dependent_init, we have to set flag_exceptions and call
579 init_eh again to initialize the EH tables. */
583 /* Initialize dwarf2 tables. Since dwarf2out_do_frame() returns
584 true only when exceptions are enabled, this initialization is
585 never done during lang_dependent_init. */
586 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
587 if (dwarf2out_do_frame ())
588 dwarf2out_frame_init ();
593 /* Read the exception table for FN from IB using the data descriptors
597 input_eh_regions (struct lto_input_block
*ib
, struct data_in
*data_in
,
600 HOST_WIDE_INT i
, root_region
, len
;
602 static bool eh_initialized_p
= false;
604 tag
= input_record_start (ib
);
608 lto_tag_check_range (tag
, LTO_eh_table
, LTO_eh_table
);
610 /* If the file contains EH regions, then it was compiled with
611 -fexceptions. In that case, initialize the backend EH
613 if (!eh_initialized_p
)
616 eh_initialized_p
= true;
621 root_region
= lto_input_sleb128 (ib
);
622 gcc_assert (root_region
== (int) root_region
);
624 /* Read the EH region array. */
625 len
= lto_input_sleb128 (ib
);
626 gcc_assert (len
== (int) len
);
629 VEC_safe_grow (eh_region
, gc
, fn
->eh
->region_array
, len
);
630 for (i
= 0; i
< len
; i
++)
632 eh_region r
= input_eh_region (ib
, data_in
, i
);
633 VEC_replace (eh_region
, fn
->eh
->region_array
, i
, r
);
637 /* Read the landing pads. */
638 len
= lto_input_sleb128 (ib
);
639 gcc_assert (len
== (int) len
);
642 VEC_safe_grow (eh_landing_pad
, gc
, fn
->eh
->lp_array
, len
);
643 for (i
= 0; i
< len
; i
++)
645 eh_landing_pad lp
= input_eh_lp (ib
, data_in
, i
);
646 VEC_replace (eh_landing_pad
, fn
->eh
->lp_array
, i
, lp
);
650 /* Read the runtime type data. */
651 len
= lto_input_sleb128 (ib
);
652 gcc_assert (len
== (int) len
);
655 VEC_safe_grow (tree
, gc
, fn
->eh
->ttype_data
, len
);
656 for (i
= 0; i
< len
; i
++)
658 tree ttype
= lto_input_tree (ib
, data_in
);
659 VEC_replace (tree
, fn
->eh
->ttype_data
, i
, ttype
);
663 /* Read the table of action chains. */
664 len
= lto_input_sleb128 (ib
);
665 gcc_assert (len
== (int) len
);
668 if (targetm
.arm_eabi_unwinder
)
670 VEC_safe_grow (tree
, gc
, fn
->eh
->ehspec_data
.arm_eabi
, len
);
671 for (i
= 0; i
< len
; i
++)
673 tree t
= lto_input_tree (ib
, data_in
);
674 VEC_replace (tree
, fn
->eh
->ehspec_data
.arm_eabi
, i
, t
);
679 VEC_safe_grow (uchar
, gc
, fn
->eh
->ehspec_data
.other
, len
);
680 for (i
= 0; i
< len
; i
++)
682 uchar c
= lto_input_1_unsigned (ib
);
683 VEC_replace (uchar
, fn
->eh
->ehspec_data
.other
, i
, c
);
688 /* Reconstruct the EH region tree by fixing up the peer/children
690 fixup_eh_region_pointers (fn
, root_region
);
692 tag
= input_record_start (ib
);
693 lto_tag_check_range (tag
, LTO_null
, LTO_null
);
697 /* Make a new basic block with index INDEX in function FN. */
700 make_new_block (struct function
*fn
, unsigned int index
)
702 basic_block bb
= alloc_block ();
704 SET_BASIC_BLOCK_FOR_FUNCTION (fn
, index
, bb
);
705 bb
->il
.gimple
= GGC_CNEW (struct gimple_bb_info
);
706 n_basic_blocks_for_function (fn
)++;
708 set_bb_seq (bb
, gimple_seq_alloc ());
713 /* Read the CFG for function FN from input block IB. */
716 input_cfg (struct lto_input_block
*ib
, struct function
*fn
)
718 unsigned int bb_count
;
723 init_empty_tree_cfg_for_function (fn
);
724 init_ssa_operands ();
726 profile_status_for_function (fn
) =
727 (enum profile_status_d
) lto_input_uleb128 (ib
);
729 bb_count
= lto_input_uleb128 (ib
);
731 last_basic_block_for_function (fn
) = bb_count
;
732 if (bb_count
> VEC_length (basic_block
, basic_block_info_for_function (fn
)))
733 VEC_safe_grow_cleared (basic_block
, gc
,
734 basic_block_info_for_function (fn
), bb_count
);
736 if (bb_count
> VEC_length (basic_block
, label_to_block_map_for_function (fn
)))
737 VEC_safe_grow_cleared (basic_block
, gc
,
738 label_to_block_map_for_function (fn
), bb_count
);
740 index
= lto_input_sleb128 (ib
);
743 basic_block bb
= BASIC_BLOCK_FOR_FUNCTION (fn
, index
);
744 unsigned int edge_count
;
747 bb
= make_new_block (fn
, index
);
749 edge_count
= lto_input_uleb128 (ib
);
751 /* Connect up the CFG. */
752 for (i
= 0; i
< edge_count
; i
++)
754 unsigned int dest_index
;
755 unsigned int edge_flags
;
761 dest_index
= lto_input_uleb128 (ib
);
762 probability
= (int) lto_input_sleb128 (ib
);
763 count
= (gcov_type
) lto_input_sleb128 (ib
);
764 edge_flags
= lto_input_uleb128 (ib
);
766 dest
= BASIC_BLOCK_FOR_FUNCTION (fn
, dest_index
);
769 dest
= make_new_block (fn
, dest_index
);
771 e
= make_edge (bb
, dest
, edge_flags
);
772 e
->probability
= probability
;
776 index
= lto_input_sleb128 (ib
);
779 p_bb
= ENTRY_BLOCK_PTR_FOR_FUNCTION(fn
);
780 index
= lto_input_sleb128 (ib
);
783 basic_block bb
= BASIC_BLOCK_FOR_FUNCTION (fn
, index
);
787 index
= lto_input_sleb128 (ib
);
792 /* Read a PHI function for basic block BB in function FN. DATA_IN is
793 the file being read. IB is the input block to use for reading. */
796 input_phi (struct lto_input_block
*ib
, basic_block bb
, struct data_in
*data_in
,
799 unsigned HOST_WIDE_INT ix
;
804 ix
= lto_input_uleb128 (ib
);
805 phi_result
= VEC_index (tree
, SSANAMES (fn
), ix
);
806 len
= EDGE_COUNT (bb
->preds
);
807 result
= create_phi_node (phi_result
, bb
);
808 SSA_NAME_DEF_STMT (phi_result
) = result
;
810 /* We have to go through a lookup process here because the preds in the
811 reconstructed graph are generally in a different order than they
812 were in the original program. */
813 for (i
= 0; i
< len
; i
++)
815 tree def
= lto_input_tree (ib
, data_in
);
816 int src_index
= lto_input_uleb128 (ib
);
817 location_t arg_loc
= lto_input_location (ib
, data_in
);
818 basic_block sbb
= BASIC_BLOCK_FOR_FUNCTION (fn
, src_index
);
823 for (j
= 0; j
< len
; j
++)
824 if (EDGE_PRED (bb
, j
)->src
== sbb
)
826 e
= EDGE_PRED (bb
, j
);
830 add_phi_arg (result
, def
, e
, arg_loc
);
837 /* Read the SSA names array for function FN from DATA_IN using input
841 input_ssa_names (struct lto_input_block
*ib
, struct data_in
*data_in
,
844 unsigned int i
, size
;
846 size
= lto_input_uleb128 (ib
);
847 init_ssanames (fn
, size
);
849 i
= lto_input_uleb128 (ib
);
855 /* Skip over the elements that had been freed. */
856 while (VEC_length (tree
, SSANAMES (fn
)) < i
)
857 VEC_quick_push (tree
, SSANAMES (fn
), NULL_TREE
);
859 is_default_def
= (lto_input_1_unsigned (ib
) != 0);
860 name
= lto_input_tree (ib
, data_in
);
861 ssa_name
= make_ssa_name_fn (fn
, name
, gimple_build_nop ());
864 set_default_def (SSA_NAME_VAR (ssa_name
), ssa_name
);
866 i
= lto_input_uleb128 (ib
);
871 /* Fixup the reference tree OP for replaced VAR_DECLs with mismatched
875 maybe_fixup_handled_component (tree op
)
880 while (handled_component_p (TREE_OPERAND (op
, 0)))
881 op
= TREE_OPERAND (op
, 0);
882 if (TREE_CODE (TREE_OPERAND (op
, 0)) != VAR_DECL
)
885 decl_type
= TREE_TYPE (TREE_OPERAND (op
, 0));
887 switch (TREE_CODE (op
))
890 /* The DECL_CONTEXT of the field-decl is the record type we look for. */
891 wanted_type
= DECL_CONTEXT (TREE_OPERAND (op
, 1));
895 if (TREE_CODE (decl_type
) == ARRAY_TYPE
896 && (TREE_TYPE (decl_type
) == TREE_TYPE (op
)
897 || useless_type_conversion_p (TREE_TYPE (op
),
898 TREE_TYPE (decl_type
))))
900 /* An unknown size array type should be ok. But we do not
901 lower the lower bound in all cases - ugh. */
902 wanted_type
= build_array_type (TREE_TYPE (op
), NULL_TREE
);
905 case ARRAY_RANGE_REF
:
906 if (TREE_CODE (decl_type
) == ARRAY_TYPE
907 && (TREE_TYPE (decl_type
) == TREE_TYPE (TREE_TYPE (op
))
908 || useless_type_conversion_p (TREE_TYPE (TREE_TYPE (op
)),
909 TREE_TYPE (decl_type
))))
911 /* An unknown size array type should be ok. But we do not
912 lower the lower bound in all cases - ugh. */
913 wanted_type
= build_array_type (TREE_TYPE (TREE_TYPE (op
)), NULL_TREE
);
917 case VIEW_CONVERT_EXPR
:
918 /* Very nice - nothing to do. */
923 if (TREE_CODE (decl_type
) == COMPLEX_TYPE
924 && (TREE_TYPE (decl_type
) == TREE_TYPE (op
)
925 || useless_type_conversion_p (TREE_TYPE (op
),
926 TREE_TYPE (decl_type
))))
928 wanted_type
= build_complex_type (TREE_TYPE (op
));
935 if (!useless_type_conversion_p (wanted_type
, decl_type
))
936 TREE_OPERAND (op
, 0) = build1 (VIEW_CONVERT_EXPR
, wanted_type
,
937 TREE_OPERAND (op
, 0));
940 /* Fixup reference tree operands for substituted prevailing decls
941 with mismatched types in STMT. */
944 maybe_fixup_decls (gimple stmt
)
946 /* We have to fixup replaced decls here in case there were
947 inter-TU type mismatches. Catch the most common cases
948 for now - this way we'll get testcases for the rest as
949 the type verifier will complain. */
950 if (gimple_assign_single_p (stmt
))
952 tree lhs
= gimple_assign_lhs (stmt
);
953 tree rhs
= gimple_assign_rhs1 (stmt
);
955 /* First catch loads and aggregate copies by adjusting the rhs. */
956 if (TREE_CODE (rhs
) == VAR_DECL
)
958 if (!useless_type_conversion_p (TREE_TYPE (lhs
), TREE_TYPE (rhs
)))
959 gimple_assign_set_rhs1 (stmt
, build1 (VIEW_CONVERT_EXPR
,
960 TREE_TYPE (lhs
), rhs
));
962 else if (handled_component_p (rhs
))
963 maybe_fixup_handled_component (rhs
);
964 /* Then catch scalar stores. */
965 else if (TREE_CODE (lhs
) == VAR_DECL
)
967 if (!useless_type_conversion_p (TREE_TYPE (lhs
), TREE_TYPE (rhs
)))
968 gimple_assign_set_lhs (stmt
, build1 (VIEW_CONVERT_EXPR
,
969 TREE_TYPE (rhs
), lhs
));
971 else if (handled_component_p (lhs
))
972 maybe_fixup_handled_component (lhs
);
974 else if (is_gimple_call (stmt
))
976 tree lhs
= gimple_call_lhs (stmt
);
978 if (lhs
&& TREE_CODE (lhs
) == VAR_DECL
)
980 if (!useless_type_conversion_p (TREE_TYPE (lhs
),
981 gimple_call_return_type (stmt
)))
982 gimple_call_set_lhs (stmt
, build1 (VIEW_CONVERT_EXPR
,
983 gimple_call_return_type (stmt
),
986 else if (lhs
&& handled_component_p (lhs
))
987 maybe_fixup_handled_component (lhs
);
989 /* Arguments, especially for varargs functions will be funny... */
993 /* Read a statement with tag TAG in function FN from block IB using
994 descriptors in DATA_IN. */
997 input_gimple_stmt (struct lto_input_block
*ib
, struct data_in
*data_in
,
998 struct function
*fn
, enum LTO_tags tag
)
1001 enum gimple_code code
;
1002 unsigned HOST_WIDE_INT num_ops
;
1004 struct bitpack_d
*bp
;
1006 code
= lto_tag_to_gimple_code (tag
);
1008 /* Read the tuple header. */
1009 bp
= lto_input_bitpack (ib
);
1010 num_ops
= bp_unpack_value (bp
, sizeof (unsigned) * 8);
1011 stmt
= gimple_alloc (code
, num_ops
);
1012 stmt
->gsbase
.no_warning
= bp_unpack_value (bp
, 1);
1013 if (is_gimple_assign (stmt
))
1014 stmt
->gsbase
.nontemporal_move
= bp_unpack_value (bp
, 1);
1015 stmt
->gsbase
.has_volatile_ops
= bp_unpack_value (bp
, 1);
1016 stmt
->gsbase
.subcode
= bp_unpack_value (bp
, 16);
1017 bitpack_delete (bp
);
1019 /* Read location information. */
1020 gimple_set_location (stmt
, lto_input_location (ib
, data_in
));
1022 /* Read lexical block reference. */
1023 gimple_set_block (stmt
, lto_input_tree (ib
, data_in
));
1025 /* Read in all the operands. */
1029 gimple_resx_set_region (stmt
, lto_input_sleb128 (ib
));
1032 case GIMPLE_EH_MUST_NOT_THROW
:
1033 gimple_eh_must_not_throw_set_fndecl (stmt
, lto_input_tree (ib
, data_in
));
1036 case GIMPLE_EH_DISPATCH
:
1037 gimple_eh_dispatch_set_region (stmt
, lto_input_sleb128 (ib
));
1042 /* FIXME lto. Move most of this into a new gimple_asm_set_string(). */
1044 stmt
->gimple_asm
.ni
= lto_input_uleb128 (ib
);
1045 stmt
->gimple_asm
.no
= lto_input_uleb128 (ib
);
1046 stmt
->gimple_asm
.nc
= lto_input_uleb128 (ib
);
1047 str
= input_string_cst (data_in
, ib
);
1048 stmt
->gimple_asm
.string
= TREE_STRING_POINTER (str
);
1060 for (i
= 0; i
< num_ops
; i
++)
1062 tree op
= lto_input_tree (ib
, data_in
);
1063 gimple_set_op (stmt
, i
, op
);
1065 /* Fixup FIELD_DECLs. */
1066 while (op
&& handled_component_p (op
))
1068 if (TREE_CODE (op
) == COMPONENT_REF
)
1070 tree field
, type
, tem
;
1071 field
= TREE_OPERAND (op
, 1);
1072 type
= DECL_CONTEXT (field
);
1073 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
1076 || (TREE_TYPE (tem
) == TREE_TYPE (field
)
1077 && (DECL_FIELD_OFFSET (tem
)
1078 == DECL_FIELD_OFFSET (field
))
1079 && (DECL_FIELD_BIT_OFFSET (tem
)
1080 == DECL_FIELD_BIT_OFFSET (field
))
1081 && (DECL_OFFSET_ALIGN (tem
)
1082 == DECL_OFFSET_ALIGN (field
))))
1085 /* In case of type mismatches across units we can fail
1086 to unify some types and thus not find a proper
1087 field-decl here. Just do nothing in this case. */
1088 if (tem
!= NULL_TREE
)
1089 TREE_OPERAND (op
, 1) = tem
;
1092 op
= TREE_OPERAND (op
, 0);
1098 case GIMPLE_PREDICT
:
1102 internal_error ("bytecode stream: unknown GIMPLE statement tag %s",
1103 lto_tag_name (tag
));
1106 /* Update the properties of symbols, SSA names and labels associated
1108 if (code
== GIMPLE_ASSIGN
|| code
== GIMPLE_CALL
)
1110 tree lhs
= gimple_get_lhs (stmt
);
1111 if (lhs
&& TREE_CODE (lhs
) == SSA_NAME
)
1112 SSA_NAME_DEF_STMT (lhs
) = stmt
;
1114 else if (code
== GIMPLE_LABEL
)
1115 gcc_assert (emit_label_in_global_context_p (gimple_label_label (stmt
))
1116 || DECL_CONTEXT (gimple_label_label (stmt
)) == fn
->decl
);
1117 else if (code
== GIMPLE_ASM
)
1121 for (i
= 0; i
< gimple_asm_noutputs (stmt
); i
++)
1123 tree op
= TREE_VALUE (gimple_asm_output_op (stmt
, i
));
1124 if (TREE_CODE (op
) == SSA_NAME
)
1125 SSA_NAME_DEF_STMT (op
) = stmt
;
1129 /* Fixup reference tree operands for substituted prevailing decls
1130 with mismatched types. */
1131 maybe_fixup_decls (stmt
);
1133 /* Mark the statement modified so its operand vectors can be filled in. */
1134 gimple_set_modified (stmt
, true);
1140 /* Read a basic block with tag TAG from DATA_IN using input block IB.
1141 FN is the function being processed. */
1144 input_bb (struct lto_input_block
*ib
, enum LTO_tags tag
,
1145 struct data_in
*data_in
, struct function
*fn
)
1149 gimple_stmt_iterator bsi
;
1151 /* This routine assumes that CFUN is set to FN, as it needs to call
1152 basic GIMPLE routines that use CFUN. */
1153 gcc_assert (cfun
== fn
);
1155 index
= lto_input_uleb128 (ib
);
1156 bb
= BASIC_BLOCK_FOR_FUNCTION (fn
, index
);
1158 bb
->count
= lto_input_sleb128 (ib
);
1159 bb
->loop_depth
= lto_input_sleb128 (ib
);
1160 bb
->frequency
= lto_input_sleb128 (ib
);
1161 bb
->flags
= lto_input_sleb128 (ib
);
1163 /* LTO_bb1 has statements. LTO_bb0 does not. */
1167 bsi
= gsi_start_bb (bb
);
1168 tag
= input_record_start (ib
);
1171 gimple stmt
= input_gimple_stmt (ib
, data_in
, fn
, tag
);
1173 /* Change debug stmts to nops on-the-fly if we do not have VTA enabled.
1174 This allows us to build for example static libs with debugging
1175 enabled and do the final link without. */
1176 if (!MAY_HAVE_DEBUG_STMTS
1177 && is_gimple_debug (stmt
))
1178 stmt
= gimple_build_nop ();
1180 find_referenced_vars_in (stmt
);
1181 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1183 /* After the statement, expect a 0 delimiter or the EH region
1184 that the previous statement belongs to. */
1185 tag
= input_record_start (ib
);
1186 lto_tag_check_set (tag
, 2, LTO_eh_region
, LTO_null
);
1188 if (tag
== LTO_eh_region
)
1190 HOST_WIDE_INT region
= lto_input_sleb128 (ib
);
1191 gcc_assert (region
== (int) region
);
1192 add_stmt_to_eh_lp (stmt
, region
);
1195 tag
= input_record_start (ib
);
1198 tag
= input_record_start (ib
);
1201 gimple phi
= input_phi (ib
, bb
, data_in
, fn
);
1202 find_referenced_vars_in (phi
);
1203 tag
= input_record_start (ib
);
1207 /* Go through all NODE edges and fixup call_stmt pointers
1208 so they point to STMTS. */
1211 fixup_call_stmt_edges_1 (struct cgraph_node
*node
, gimple
*stmts
)
1213 struct cgraph_edge
*cedge
;
1214 for (cedge
= node
->callees
; cedge
; cedge
= cedge
->next_callee
)
1215 cedge
->call_stmt
= stmts
[cedge
->lto_stmt_uid
];
1218 /* Fixup call_stmt pointers in NODE and all clones. */
1221 fixup_call_stmt_edges (struct cgraph_node
*orig
, gimple
*stmts
)
1223 struct cgraph_node
*node
;
1225 while (orig
->clone_of
)
1226 orig
= orig
->clone_of
;
1228 fixup_call_stmt_edges_1 (orig
, stmts
);
1230 for (node
= orig
->clones
; node
!= orig
;)
1232 fixup_call_stmt_edges_1 (node
, stmts
);
1234 node
= node
->clones
;
1235 else if (node
->next_sibling_clone
)
1236 node
= node
->next_sibling_clone
;
1239 while (node
!= orig
&& !node
->next_sibling_clone
)
1240 node
= node
->clone_of
;
1242 node
= node
->next_sibling_clone
;
1247 /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1250 input_function (tree fn_decl
, struct data_in
*data_in
,
1251 struct lto_input_block
*ib
)
1253 struct function
*fn
;
1257 struct bitpack_d
*bp
;
1259 fn
= DECL_STRUCT_FUNCTION (fn_decl
);
1260 tag
= input_record_start (ib
);
1261 clear_line_info (data_in
);
1263 gimple_register_cfg_hooks ();
1264 lto_tag_check (tag
, LTO_function
);
1266 /* Read all the attributes for FN. */
1267 bp
= lto_input_bitpack (ib
);
1268 fn
->is_thunk
= bp_unpack_value (bp
, 1);
1269 fn
->has_local_explicit_reg_vars
= bp_unpack_value (bp
, 1);
1270 fn
->after_tree_profile
= bp_unpack_value (bp
, 1);
1271 fn
->returns_pcc_struct
= bp_unpack_value (bp
, 1);
1272 fn
->returns_struct
= bp_unpack_value (bp
, 1);
1273 fn
->always_inline_functions_inlined
= bp_unpack_value (bp
, 1);
1274 fn
->after_inlining
= bp_unpack_value (bp
, 1);
1275 fn
->dont_save_pending_sizes_p
= bp_unpack_value (bp
, 1);
1276 fn
->stdarg
= bp_unpack_value (bp
, 1);
1277 fn
->has_nonlocal_label
= bp_unpack_value (bp
, 1);
1278 fn
->calls_alloca
= bp_unpack_value (bp
, 1);
1279 fn
->calls_setjmp
= bp_unpack_value (bp
, 1);
1280 fn
->function_frequency
= (enum function_frequency
) bp_unpack_value (bp
, 2);
1281 fn
->va_list_fpr_size
= bp_unpack_value (bp
, 8);
1282 fn
->va_list_gpr_size
= bp_unpack_value (bp
, 8);
1283 bitpack_delete (bp
);
1285 /* Read the static chain and non-local goto save area. */
1286 fn
->static_chain_decl
= lto_input_tree (ib
, data_in
);
1287 fn
->nonlocal_goto_save_area
= lto_input_tree (ib
, data_in
);
1289 /* Read all the local symbols. */
1290 fn
->local_decls
= lto_input_tree (ib
, data_in
);
1292 /* Read all the SSA names. */
1293 input_ssa_names (ib
, data_in
, fn
);
1295 /* Read the exception handling regions in the function. */
1296 input_eh_regions (ib
, data_in
, fn
);
1298 /* Read the tree of lexical scopes for the function. */
1299 DECL_INITIAL (fn_decl
) = lto_input_tree (ib
, data_in
);
1300 gcc_assert (DECL_INITIAL (fn_decl
));
1301 DECL_SAVED_TREE (fn_decl
) = NULL_TREE
;
1303 /* Read all function arguments. */
1304 DECL_ARGUMENTS (fn_decl
) = lto_input_tree (ib
, data_in
);
1306 /* Read all the basic blocks. */
1307 tag
= input_record_start (ib
);
1310 input_bb (ib
, tag
, data_in
, fn
);
1311 tag
= input_record_start (ib
);
1314 /* Fix up the call statements that are mentioned in the callgraph
1316 renumber_gimple_stmt_uids ();
1317 stmts
= (gimple
*) xcalloc (gimple_stmt_max_uid (fn
), sizeof (gimple
));
1320 gimple_stmt_iterator bsi
;
1321 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
1323 gimple stmt
= gsi_stmt (bsi
);
1324 stmts
[gimple_uid (stmt
)] = stmt
;
1328 /* Set the gimple body to the statement sequence in the entry
1329 basic block. FIXME lto, this is fairly hacky. The existence
1330 of a gimple body is used by the cgraph routines, but we should
1331 really use the presence of the CFG. */
1333 edge_iterator ei
= ei_start (ENTRY_BLOCK_PTR
->succs
);
1334 gimple_set_body (fn_decl
, bb_seq (ei_edge (ei
)->dest
));
1337 fixup_call_stmt_edges (cgraph_node (fn_decl
), stmts
);
1339 update_ssa (TODO_update_ssa_only_virtuals
);
1344 /* Read initializer expressions for public statics. DATA_IN is the
1345 file being read. IB is the input block used for reading. */
1348 input_alias_pairs (struct lto_input_block
*ib
, struct data_in
*data_in
)
1352 clear_line_info (data_in
);
1354 /* Skip over all the unreferenced globals. */
1356 var
= lto_input_tree (ib
, data_in
);
1359 var
= lto_input_tree (ib
, data_in
);
1362 const char *orig_name
, *new_name
;
1365 p
= VEC_safe_push (alias_pair
, gc
, alias_pairs
, NULL
);
1367 p
->target
= lto_input_tree (ib
, data_in
);
1369 /* If the target is a static object, we may have registered a
1370 new name for it to avoid clashes between statics coming from
1371 different files. In that case, use the new name. */
1372 orig_name
= IDENTIFIER_POINTER (p
->target
);
1373 new_name
= lto_get_decl_name_mapping (data_in
->file_data
, orig_name
);
1374 if (strcmp (orig_name
, new_name
) != 0)
1375 p
->target
= get_identifier (new_name
);
1377 var
= lto_input_tree (ib
, data_in
);
1382 /* Read the body from DATA for function FN_DECL and fill it in.
1383 FILE_DATA are the global decls and types. SECTION_TYPE is either
1384 LTO_section_function_body or LTO_section_static_initializer. If
1385 section type is LTO_section_function_body, FN must be the decl for
1389 lto_read_body (struct lto_file_decl_data
*file_data
, tree fn_decl
,
1390 const char *data
, enum lto_section_type section_type
)
1392 const struct lto_function_header
*header
;
1393 struct data_in
*data_in
;
1395 int32_t main_offset
;
1396 int32_t string_offset
;
1397 struct lto_input_block ib_cfg
;
1398 struct lto_input_block ib_main
;
1400 header
= (const struct lto_function_header
*) data
;
1401 cfg_offset
= sizeof (struct lto_function_header
);
1402 main_offset
= cfg_offset
+ header
->cfg_size
;
1403 string_offset
= main_offset
+ header
->main_size
;
1405 LTO_INIT_INPUT_BLOCK (ib_cfg
,
1410 LTO_INIT_INPUT_BLOCK (ib_main
,
1415 data_in
= lto_data_in_create (file_data
, data
+ string_offset
,
1416 header
->string_size
, NULL
);
1418 /* Make sure the file was generated by the exact same compiler. */
1419 lto_check_version (header
->lto_header
.major_version
,
1420 header
->lto_header
.minor_version
);
1422 if (section_type
== LTO_section_function_body
)
1424 struct function
*fn
= DECL_STRUCT_FUNCTION (fn_decl
);
1425 struct lto_in_decl_state
*decl_state
;
1430 /* Use the function's decl state. */
1431 decl_state
= lto_get_function_in_decl_state (file_data
, fn_decl
);
1432 gcc_assert (decl_state
);
1433 file_data
->current_decl_state
= decl_state
;
1435 input_cfg (&ib_cfg
, fn
);
1437 /* Set up the struct function. */
1438 input_function (fn_decl
, data_in
, &ib_main
);
1440 /* We should now be in SSA. */
1441 cfun
->gimple_df
->in_ssa_p
= true;
1443 /* Fill in properties we know hold for the rebuilt CFG. */
1444 cfun
->curr_properties
= PROP_ssa
1449 | PROP_referenced_vars
;
1451 /* Restore decl state */
1452 file_data
->current_decl_state
= file_data
->global_decl_state
;
1458 input_alias_pairs (&ib_main
, data_in
);
1461 clear_line_info (data_in
);
1462 lto_data_in_delete (data_in
);
1466 /* Read the body of FN_DECL using DATA. FILE_DATA holds the global
1470 lto_input_function_body (struct lto_file_decl_data
*file_data
,
1471 tree fn_decl
, const char *data
)
1473 current_function_decl
= fn_decl
;
1474 lto_read_body (file_data
, fn_decl
, data
, LTO_section_function_body
);
1478 /* Read in VAR_DECL using DATA. FILE_DATA holds the global decls and
1482 lto_input_constructors_and_inits (struct lto_file_decl_data
*file_data
,
1485 lto_read_body (file_data
, NULL
, data
, LTO_section_static_initializer
);
1489 /* Return the resolution for the decl with index INDEX from DATA_IN. */
1491 static enum ld_plugin_symbol_resolution
1492 get_resolution (struct data_in
*data_in
, unsigned index
)
1494 if (data_in
->globals_resolution
)
1496 ld_plugin_symbol_resolution_t ret
;
1497 gcc_assert (index
< VEC_length (ld_plugin_symbol_resolution_t
,
1498 data_in
->globals_resolution
));
1499 ret
= VEC_index (ld_plugin_symbol_resolution_t
,
1500 data_in
->globals_resolution
,
1502 gcc_assert (ret
!= LDPR_UNKNOWN
);
1506 /* Delay resolution finding until decl merging. */
1507 return LDPR_UNKNOWN
;
1511 /* Unpack all the non-pointer fields of the TS_BASE structure of
1512 expression EXPR from bitpack BP. */
1515 unpack_ts_base_value_fields (struct bitpack_d
*bp
, tree expr
)
1517 /* Note that the code for EXPR has already been unpacked to create EXPR in
1518 lto_materialize_tree. */
1521 TREE_SIDE_EFFECTS (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1522 TREE_CONSTANT (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1523 TREE_READONLY (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1525 /* TREE_PUBLIC is used on types to indicate that the type
1526 has a TYPE_CACHED_VALUES vector. This is not streamed out,
1527 so we skip it here. */
1528 TREE_PUBLIC (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1530 TREE_ADDRESSABLE (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1531 TREE_THIS_VOLATILE (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1533 DECL_UNSIGNED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1534 else if (TYPE_P (expr
))
1535 TYPE_UNSIGNED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1536 TREE_ASM_WRITTEN (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1537 TREE_NO_WARNING (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1538 TREE_USED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1539 TREE_NOTHROW (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1540 TREE_STATIC (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1541 TREE_PRIVATE (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1542 TREE_PROTECTED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1543 TREE_DEPRECATED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1545 TYPE_SATURATING (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1546 if (TREE_CODE (expr
) == SSA_NAME
)
1547 SSA_NAME_IS_DEFAULT_DEF (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1551 /* Unpack all the non-pointer fields of the TS_REAL_CST structure of
1552 expression EXPR from bitpack BP. */
1555 unpack_ts_real_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
1559 REAL_VALUE_TYPE
*rp
;
1561 r
.cl
= (unsigned) bp_unpack_value (bp
, 2);
1562 r
.decimal
= (unsigned) bp_unpack_value (bp
, 1);
1563 r
.sign
= (unsigned) bp_unpack_value (bp
, 1);
1564 r
.signalling
= (unsigned) bp_unpack_value (bp
, 1);
1565 r
.canonical
= (unsigned) bp_unpack_value (bp
, 1);
1566 r
.uexp
= (unsigned) bp_unpack_value (bp
, EXP_BITS
);
1567 for (i
= 0; i
< SIGSZ
; i
++)
1568 r
.sig
[i
] = (unsigned long) bp_unpack_value (bp
, HOST_BITS_PER_LONG
);
1570 rp
= GGC_NEW (REAL_VALUE_TYPE
);
1571 memcpy (rp
, &r
, sizeof (REAL_VALUE_TYPE
));
1572 TREE_REAL_CST_PTR (expr
) = rp
;
1576 /* Unpack all the non-pointer fields of the TS_FIXED_CST structure of
1577 expression EXPR from bitpack BP. */
1580 unpack_ts_fixed_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
1582 struct fixed_value fv
;
1584 fv
.data
.low
= (HOST_WIDE_INT
) bp_unpack_value (bp
, HOST_BITS_PER_WIDE_INT
);
1585 fv
.data
.high
= (HOST_WIDE_INT
) bp_unpack_value (bp
, HOST_BITS_PER_WIDE_INT
);
1586 TREE_FIXED_CST (expr
) = fv
;
1590 /* Unpack all the non-pointer fields of the TS_DECL_COMMON structure
1591 of expression EXPR from bitpack BP. */
1594 unpack_ts_decl_common_value_fields (struct bitpack_d
*bp
, tree expr
)
1596 DECL_MODE (expr
) = (enum machine_mode
) bp_unpack_value (bp
, 8);
1597 DECL_NONLOCAL (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1598 DECL_VIRTUAL_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1599 DECL_IGNORED_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1600 DECL_ABSTRACT (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1601 DECL_ARTIFICIAL (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1602 DECL_USER_ALIGN (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1603 DECL_PRESERVE_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1604 DECL_DEBUG_EXPR_IS_FROM (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1605 DECL_EXTERNAL (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1606 DECL_GIMPLE_REG_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1607 DECL_ALIGN (expr
) = (unsigned) bp_unpack_value (bp
, HOST_BITS_PER_INT
);
1609 if (TREE_CODE (expr
) == LABEL_DECL
)
1611 DECL_ERROR_ISSUED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1612 EH_LANDING_PAD_NR (expr
) = (int) bp_unpack_value (bp
, HOST_BITS_PER_INT
);
1614 /* Always assume an initial value of -1 for LABEL_DECL_UID to
1615 force gimple_set_bb to recreate label_to_block_map. */
1616 LABEL_DECL_UID (expr
) = -1;
1619 if (TREE_CODE (expr
) == FIELD_DECL
)
1621 unsigned HOST_WIDE_INT off_align
;
1622 DECL_PACKED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1623 DECL_NONADDRESSABLE_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1624 off_align
= (unsigned HOST_WIDE_INT
) bp_unpack_value (bp
, 8);
1625 SET_DECL_OFFSET_ALIGN (expr
, off_align
);
1628 if (TREE_CODE (expr
) == RESULT_DECL
1629 || TREE_CODE (expr
) == PARM_DECL
1630 || TREE_CODE (expr
) == VAR_DECL
)
1632 DECL_BY_REFERENCE (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1633 if (TREE_CODE (expr
) == VAR_DECL
1634 || TREE_CODE (expr
) == PARM_DECL
)
1635 DECL_HAS_VALUE_EXPR_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1640 /* Unpack all the non-pointer fields of the TS_DECL_WRTL structure
1641 of expression EXPR from bitpack BP. */
1644 unpack_ts_decl_wrtl_value_fields (struct bitpack_d
*bp
, tree expr
)
1646 DECL_REGISTER (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1650 /* Unpack all the non-pointer fields of the TS_DECL_WITH_VIS structure
1651 of expression EXPR from bitpack BP. */
1654 unpack_ts_decl_with_vis_value_fields (struct bitpack_d
*bp
, tree expr
)
1656 DECL_DEFER_OUTPUT (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1657 DECL_COMMON (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1658 DECL_DLLIMPORT_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1659 DECL_WEAK (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1660 DECL_SEEN_IN_BIND_EXPR_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1661 DECL_COMDAT (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1662 DECL_VISIBILITY (expr
) = (enum symbol_visibility
) bp_unpack_value (bp
, 2);
1663 DECL_VISIBILITY_SPECIFIED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1665 if (TREE_CODE (expr
) == VAR_DECL
)
1667 DECL_HARD_REGISTER (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1668 DECL_IN_TEXT_SECTION (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1669 DECL_TLS_MODEL (expr
) = (enum tls_model
) bp_unpack_value (bp
, 3);
1672 if (VAR_OR_FUNCTION_DECL_P (expr
))
1675 p
= (priority_type
) bp_unpack_value (bp
, HOST_BITS_PER_SHORT
);
1676 SET_DECL_INIT_PRIORITY (expr
, p
);
1681 /* Unpack all the non-pointer fields of the TS_FUNCTION_DECL structure
1682 of expression EXPR from bitpack BP. */
1685 unpack_ts_function_decl_value_fields (struct bitpack_d
*bp
, tree expr
)
1687 DECL_FUNCTION_CODE (expr
) = (enum built_in_function
) bp_unpack_value (bp
, 11);
1688 DECL_BUILT_IN_CLASS (expr
) = (enum built_in_class
) bp_unpack_value (bp
, 2);
1689 DECL_STATIC_CONSTRUCTOR (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1690 DECL_STATIC_DESTRUCTOR (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1691 DECL_UNINLINABLE (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1692 DECL_POSSIBLY_INLINED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1693 DECL_IS_NOVOPS (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1694 DECL_IS_RETURNS_TWICE (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1695 DECL_IS_MALLOC (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1696 DECL_IS_OPERATOR_NEW (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1697 DECL_DECLARED_INLINE_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1698 DECL_STATIC_CHAIN (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1699 DECL_NO_INLINE_WARNING_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1700 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr
)
1701 = (unsigned) bp_unpack_value (bp
, 1);
1702 DECL_NO_LIMIT_STACK (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1703 DECL_DISREGARD_INLINE_LIMITS (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1704 DECL_PURE_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1705 DECL_LOOPING_CONST_OR_PURE_P (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1709 /* Unpack all the non-pointer fields of the TS_TYPE structure
1710 of expression EXPR from bitpack BP. */
1713 unpack_ts_type_value_fields (struct bitpack_d
*bp
, tree expr
)
1715 enum machine_mode mode
;
1717 TYPE_PRECISION (expr
) = (unsigned) bp_unpack_value (bp
, 9);
1718 mode
= (enum machine_mode
) bp_unpack_value (bp
, 7);
1719 SET_TYPE_MODE (expr
, mode
);
1720 TYPE_STRING_FLAG (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1721 TYPE_NO_FORCE_BLK (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1722 TYPE_NEEDS_CONSTRUCTING(expr
) = (unsigned) bp_unpack_value (bp
, 1);
1723 if (TREE_CODE (expr
) == UNION_TYPE
)
1724 TYPE_TRANSPARENT_UNION (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1725 TYPE_PACKED (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1726 TYPE_RESTRICT (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1727 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr
)
1728 = (unsigned) bp_unpack_value (bp
, 2);
1729 TYPE_USER_ALIGN (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1730 TYPE_READONLY (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1731 TYPE_ALIGN (expr
) = (unsigned) bp_unpack_value (bp
, HOST_BITS_PER_INT
);
1732 TYPE_ALIAS_SET (expr
) = bp_unpack_value (bp
, HOST_BITS_PER_INT
);
1736 /* Unpack all the non-pointer fields of the TS_BLOCK structure
1737 of expression EXPR from bitpack BP. */
1740 unpack_ts_block_value_fields (struct bitpack_d
*bp
, tree expr
)
1742 BLOCK_ABSTRACT (expr
) = (unsigned) bp_unpack_value (bp
, 1);
1743 BLOCK_NUMBER (expr
) = (unsigned) bp_unpack_value (bp
, 31);
1747 /* Unpack all the non-pointer fields in EXPR into a bit pack. */
1750 unpack_value_fields (struct bitpack_d
*bp
, tree expr
)
1752 enum tree_code code
;
1754 code
= TREE_CODE (expr
);
1756 /* Note that all these functions are highly sensitive to changes in
1757 the types and sizes of each of the fields being packed. */
1758 unpack_ts_base_value_fields (bp
, expr
);
1760 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
1761 unpack_ts_real_cst_value_fields (bp
, expr
);
1763 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
1764 unpack_ts_fixed_cst_value_fields (bp
, expr
);
1766 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1767 unpack_ts_decl_common_value_fields (bp
, expr
);
1769 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
1770 unpack_ts_decl_wrtl_value_fields (bp
, expr
);
1772 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1773 unpack_ts_decl_with_vis_value_fields (bp
, expr
);
1775 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1776 unpack_ts_function_decl_value_fields (bp
, expr
);
1778 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE
))
1779 unpack_ts_type_value_fields (bp
, expr
);
1781 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
1782 unpack_ts_block_value_fields (bp
, expr
);
1784 if (CODE_CONTAINS_STRUCT (code
, TS_SSA_NAME
))
1786 /* We only stream the version number of SSA names. */
1790 if (CODE_CONTAINS_STRUCT (code
, TS_STATEMENT_LIST
))
1792 /* This is only used by GENERIC. */
1796 if (CODE_CONTAINS_STRUCT (code
, TS_OMP_CLAUSE
))
1798 /* This is only used by High GIMPLE. */
1804 /* Read a bitpack from input block IB. */
1807 lto_input_bitpack (struct lto_input_block
*ib
)
1809 unsigned i
, num_words
;
1810 struct bitpack_d
*bp
;
1812 bp
= bitpack_create ();
1814 /* If we are about to read more than a handful of words, something
1815 is wrong. This check is overly strict, but it acts as an early
1816 warning. No streamed object has hundreds of bits in its fields. */
1817 num_words
= lto_input_uleb128 (ib
);
1818 gcc_assert (num_words
< 20);
1820 for (i
= 0; i
< num_words
; i
++)
1822 bitpack_word_t w
= lto_input_uleb128 (ib
);
1823 VEC_safe_push (bitpack_word_t
, heap
, bp
->values
, w
);
1830 /* Materialize a new tree from input block IB using descriptors in
1831 DATA_IN. The code for the new tree should match TAG. Store in
1832 *IX_P the index into the reader cache where the new tree is stored. */
1835 lto_materialize_tree (struct lto_input_block
*ib
, struct data_in
*data_in
,
1836 enum LTO_tags tag
, int *ix_p
)
1838 struct bitpack_d
*bp
;
1839 enum tree_code code
;
1841 #ifdef LTO_STREAMER_DEBUG
1842 HOST_WIDEST_INT orig_address_in_writer
;
1848 /* Read the header of the node we are about to create. */
1849 ix
= lto_input_sleb128 (ib
);
1850 gcc_assert ((int) ix
== ix
);
1853 #ifdef LTO_STREAMER_DEBUG
1854 /* Read the word representing the memory address for the tree
1855 as it was written by the writer. This is useful when
1856 debugging differences between the writer and reader. */
1857 orig_address_in_writer
= lto_input_sleb128 (ib
);
1858 gcc_assert ((intptr_t) orig_address_in_writer
== orig_address_in_writer
);
1861 code
= lto_tag_to_tree_code (tag
);
1863 /* We should never see an SSA_NAME tree. Only the version numbers of
1864 SSA names are ever written out. See input_ssa_names. */
1865 gcc_assert (code
!= SSA_NAME
);
1867 /* Instantiate a new tree using the header data. */
1868 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
1869 result
= input_string_cst (data_in
, ib
);
1870 else if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
1871 result
= input_identifier (data_in
, ib
);
1872 else if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1874 HOST_WIDE_INT len
= lto_input_sleb128 (ib
);
1875 result
= make_tree_vec (len
);
1877 else if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1879 unsigned HOST_WIDE_INT len
= lto_input_uleb128 (ib
);
1880 result
= make_tree_binfo (len
);
1884 /* All other nodes can be materialized with a raw make_node
1886 result
= make_node (code
);
1889 #ifdef LTO_STREAMER_DEBUG
1890 /* Store the original address of the tree as seen by the writer
1891 in RESULT's aux field. This is useful when debugging streaming
1892 problems. This way, a debugging session can be started on
1893 both writer and reader with a breakpoint using this address
1895 lto_orig_address_map (result
, (intptr_t) orig_address_in_writer
);
1898 /* Read the bitpack of non-pointer values from IB. */
1899 bp
= lto_input_bitpack (ib
);
1901 /* The first word in BP contains the code of the tree that we
1902 are about to read. */
1903 code
= (enum tree_code
) bp_unpack_value (bp
, 16);
1904 lto_tag_check (lto_tree_code_to_tag (code
), tag
);
1906 /* Unpack all the value fields from BP. */
1907 unpack_value_fields (bp
, result
);
1908 bitpack_delete (bp
);
1910 /* Enter RESULT in the reader cache. This will make RESULT
1911 available so that circular references in the rest of the tree
1912 structure can be resolved in subsequent calls to lto_input_tree. */
1913 lto_streamer_cache_insert_at (data_in
->reader_cache
, result
, ix
);
1919 /* Read a chain of tree nodes from input block IB. DATA_IN contains
1920 tables and descriptors for the file being read. */
1923 lto_input_chain (struct lto_input_block
*ib
, struct data_in
*data_in
)
1926 tree first
, prev
, curr
;
1928 first
= prev
= NULL_TREE
;
1929 count
= lto_input_sleb128 (ib
);
1930 for (i
= 0; i
< count
; i
++)
1932 curr
= lto_input_tree (ib
, data_in
);
1934 TREE_CHAIN (prev
) = curr
;
1938 TREE_CHAIN (curr
) = NULL_TREE
;
1946 /* Read all pointer fields in the TS_COMMON structure of EXPR from input
1947 block IB. DATA_IN contains tables and descriptors for the
1952 lto_input_ts_common_tree_pointers (struct lto_input_block
*ib
,
1953 struct data_in
*data_in
, tree expr
)
1955 TREE_TYPE (expr
) = lto_input_tree (ib
, data_in
);
1959 /* Read all pointer fields in the TS_VECTOR structure of EXPR from input
1960 block IB. DATA_IN contains tables and descriptors for the
1964 lto_input_ts_vector_tree_pointers (struct lto_input_block
*ib
,
1965 struct data_in
*data_in
, tree expr
)
1967 TREE_VECTOR_CST_ELTS (expr
) = lto_input_chain (ib
, data_in
);
1971 /* Read all pointer fields in the TS_COMPLEX structure of EXPR from input
1972 block IB. DATA_IN contains tables and descriptors for the
1976 lto_input_ts_complex_tree_pointers (struct lto_input_block
*ib
,
1977 struct data_in
*data_in
, tree expr
)
1979 TREE_REALPART (expr
) = lto_input_tree (ib
, data_in
);
1980 TREE_IMAGPART (expr
) = lto_input_tree (ib
, data_in
);
1984 /* Read all pointer fields in the TS_DECL_MINIMAL structure of EXPR
1985 from input block IB. DATA_IN contains tables and descriptors for the
1989 lto_input_ts_decl_minimal_tree_pointers (struct lto_input_block
*ib
,
1990 struct data_in
*data_in
, tree expr
)
1992 DECL_NAME (expr
) = lto_input_tree (ib
, data_in
);
1993 DECL_CONTEXT (expr
) = lto_input_tree (ib
, data_in
);
1994 DECL_SOURCE_LOCATION (expr
) = lto_input_location (ib
, data_in
);
1998 /* Read all pointer fields in the TS_DECL_COMMON structure of EXPR from
1999 input block IB. DATA_IN contains tables and descriptors for the
2003 lto_input_ts_decl_common_tree_pointers (struct lto_input_block
*ib
,
2004 struct data_in
*data_in
, tree expr
)
2006 DECL_SIZE (expr
) = lto_input_tree (ib
, data_in
);
2007 DECL_SIZE_UNIT (expr
) = lto_input_tree (ib
, data_in
);
2009 if (TREE_CODE (expr
) != FUNCTION_DECL
)
2010 DECL_INITIAL (expr
) = lto_input_tree (ib
, data_in
);
2012 DECL_ATTRIBUTES (expr
) = lto_input_tree (ib
, data_in
);
2013 DECL_ABSTRACT_ORIGIN (expr
) = lto_input_tree (ib
, data_in
);
2015 if (TREE_CODE (expr
) == PARM_DECL
)
2016 TREE_CHAIN (expr
) = lto_input_chain (ib
, data_in
);
2020 /* Read all pointer fields in the TS_DECL_NON_COMMON structure of
2021 EXPR from input block IB. DATA_IN contains tables and descriptors for the
2025 lto_input_ts_decl_non_common_tree_pointers (struct lto_input_block
*ib
,
2026 struct data_in
*data_in
, tree expr
)
2028 if (TREE_CODE (expr
) == FUNCTION_DECL
)
2030 DECL_ARGUMENTS (expr
) = lto_input_tree (ib
, data_in
);
2031 DECL_RESULT (expr
) = lto_input_tree (ib
, data_in
);
2033 DECL_VINDEX (expr
) = lto_input_tree (ib
, data_in
);
2037 /* Read all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
2038 from input block IB. DATA_IN contains tables and descriptors for the
2042 lto_input_ts_decl_with_vis_tree_pointers (struct lto_input_block
*ib
,
2043 struct data_in
*data_in
, tree expr
)
2047 id
= lto_input_tree (ib
, data_in
);
2050 gcc_assert (TREE_CODE (id
) == IDENTIFIER_NODE
);
2051 SET_DECL_ASSEMBLER_NAME (expr
, id
);
2054 DECL_SECTION_NAME (expr
) = lto_input_tree (ib
, data_in
);
2055 DECL_COMDAT_GROUP (expr
) = lto_input_tree (ib
, data_in
);
2059 /* Read all pointer fields in the TS_FIELD_DECL structure of EXPR from
2060 input block IB. DATA_IN contains tables and descriptors for the
2064 lto_input_ts_field_decl_tree_pointers (struct lto_input_block
*ib
,
2065 struct data_in
*data_in
, tree expr
)
2067 DECL_FIELD_OFFSET (expr
) = lto_input_tree (ib
, data_in
);
2068 DECL_BIT_FIELD_TYPE (expr
) = lto_input_tree (ib
, data_in
);
2069 DECL_QUALIFIER (expr
) = lto_input_tree (ib
, data_in
);
2070 DECL_FIELD_BIT_OFFSET (expr
) = lto_input_tree (ib
, data_in
);
2071 DECL_FCONTEXT (expr
) = lto_input_tree (ib
, data_in
);
2072 TREE_CHAIN (expr
) = lto_input_chain (ib
, data_in
);
2076 /* Read all pointer fields in the TS_FUNCTION_DECL structure of EXPR
2077 from input block IB. DATA_IN contains tables and descriptors for the
2081 lto_input_ts_function_decl_tree_pointers (struct lto_input_block
*ib
,
2082 struct data_in
*data_in
, tree expr
)
2084 /* DECL_STRUCT_FUNCTION is handled by lto_input_function. FIXME lto,
2085 maybe it should be handled here? */
2086 DECL_FUNCTION_PERSONALITY (expr
) = lto_input_tree (ib
, data_in
);
2087 DECL_FUNCTION_SPECIFIC_TARGET (expr
) = lto_input_tree (ib
, data_in
);
2088 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr
) = lto_input_tree (ib
, data_in
);
2092 /* Read all pointer fields in the TS_TYPE structure of EXPR from input
2093 block IB. DATA_IN contains tables and descriptors for the
2097 lto_input_ts_type_tree_pointers (struct lto_input_block
*ib
,
2098 struct data_in
*data_in
, tree expr
)
2100 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
2101 TYPE_VALUES (expr
) = lto_input_tree (ib
, data_in
);
2102 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
2103 TYPE_DOMAIN (expr
) = lto_input_tree (ib
, data_in
);
2104 else if (TREE_CODE (expr
) == RECORD_TYPE
|| TREE_CODE (expr
) == UNION_TYPE
)
2105 TYPE_FIELDS (expr
) = lto_input_tree (ib
, data_in
);
2106 else if (TREE_CODE (expr
) == FUNCTION_TYPE
|| TREE_CODE (expr
) == METHOD_TYPE
)
2107 TYPE_ARG_TYPES (expr
) = lto_input_tree (ib
, data_in
);
2108 else if (TREE_CODE (expr
) == VECTOR_TYPE
)
2109 TYPE_DEBUG_REPRESENTATION_TYPE (expr
) = lto_input_tree (ib
, data_in
);
2111 TYPE_SIZE (expr
) = lto_input_tree (ib
, data_in
);
2112 TYPE_SIZE_UNIT (expr
) = lto_input_tree (ib
, data_in
);
2113 TYPE_ATTRIBUTES (expr
) = lto_input_tree (ib
, data_in
);
2114 TYPE_NAME (expr
) = lto_input_tree (ib
, data_in
);
2115 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO nor
2116 TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO. */
2117 if (!POINTER_TYPE_P (expr
))
2118 TYPE_MINVAL (expr
) = lto_input_tree (ib
, data_in
);
2119 TYPE_MAXVAL (expr
) = lto_input_tree (ib
, data_in
);
2120 TYPE_MAIN_VARIANT (expr
) = lto_input_tree (ib
, data_in
);
2121 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
2123 if (RECORD_OR_UNION_TYPE_P (expr
))
2124 TYPE_BINFO (expr
) = lto_input_tree (ib
, data_in
);
2125 TYPE_CONTEXT (expr
) = lto_input_tree (ib
, data_in
);
2126 TYPE_CANONICAL (expr
) = lto_input_tree (ib
, data_in
);
2130 /* Read all pointer fields in the TS_LIST structure of EXPR from input
2131 block IB. DATA_IN contains tables and descriptors for the
2135 lto_input_ts_list_tree_pointers (struct lto_input_block
*ib
,
2136 struct data_in
*data_in
, tree expr
)
2138 TREE_PURPOSE (expr
) = lto_input_tree (ib
, data_in
);
2139 TREE_VALUE (expr
) = lto_input_tree (ib
, data_in
);
2140 TREE_CHAIN (expr
) = lto_input_chain (ib
, data_in
);
2144 /* Read all pointer fields in the TS_VEC structure of EXPR from input
2145 block IB. DATA_IN contains tables and descriptors for the
2149 lto_input_ts_vec_tree_pointers (struct lto_input_block
*ib
,
2150 struct data_in
*data_in
, tree expr
)
2154 /* Note that TREE_VEC_LENGTH was read by lto_materialize_tree to
2155 instantiate EXPR. */
2156 for (i
= 0; i
< TREE_VEC_LENGTH (expr
); i
++)
2157 TREE_VEC_ELT (expr
, i
) = lto_input_tree (ib
, data_in
);
2161 /* Read all pointer fields in the TS_EXP structure of EXPR from input
2162 block IB. DATA_IN contains tables and descriptors for the
2167 lto_input_ts_exp_tree_pointers (struct lto_input_block
*ib
,
2168 struct data_in
*data_in
, tree expr
)
2173 length
= lto_input_sleb128 (ib
);
2174 gcc_assert (length
== TREE_OPERAND_LENGTH (expr
));
2176 for (i
= 0; i
< length
; i
++)
2177 TREE_OPERAND (expr
, i
) = lto_input_tree (ib
, data_in
);
2179 loc
= lto_input_location (ib
, data_in
);
2180 SET_EXPR_LOCATION (expr
, loc
);
2181 TREE_BLOCK (expr
) = lto_input_tree (ib
, data_in
);
2185 /* Read all pointer fields in the TS_BLOCK structure of EXPR from input
2186 block IB. DATA_IN contains tables and descriptors for the
2190 lto_input_ts_block_tree_pointers (struct lto_input_block
*ib
,
2191 struct data_in
*data_in
, tree expr
)
2195 BLOCK_SOURCE_LOCATION (expr
) = lto_input_location (ib
, data_in
);
2196 BLOCK_VARS (expr
) = lto_input_chain (ib
, data_in
);
2198 len
= lto_input_uleb128 (ib
);
2199 for (i
= 0; i
< len
; i
++)
2201 tree t
= lto_input_tree (ib
, data_in
);
2202 VEC_safe_push (tree
, gc
, BLOCK_NONLOCALIZED_VARS (expr
), t
);
2205 BLOCK_SUPERCONTEXT (expr
) = lto_input_tree (ib
, data_in
);
2206 BLOCK_ABSTRACT_ORIGIN (expr
) = lto_input_tree (ib
, data_in
);
2207 BLOCK_FRAGMENT_ORIGIN (expr
) = lto_input_tree (ib
, data_in
);
2208 BLOCK_FRAGMENT_CHAIN (expr
) = lto_input_tree (ib
, data_in
);
2209 BLOCK_SUBBLOCKS (expr
) = lto_input_chain (ib
, data_in
);
2213 /* Read all pointer fields in the TS_BINFO structure of EXPR from input
2214 block IB. DATA_IN contains tables and descriptors for the
2218 lto_input_ts_binfo_tree_pointers (struct lto_input_block
*ib
,
2219 struct data_in
*data_in
, tree expr
)
2224 /* Note that the number of slots in EXPR was read in
2225 lto_materialize_tree when instantiating EXPR. However, the
2226 vector is empty so we cannot rely on VEC_length to know how many
2227 elements to read. So, this list is emitted as a 0-terminated
2228 list on the writer side. */
2231 t
= lto_input_tree (ib
, data_in
);
2233 VEC_quick_push (tree
, BINFO_BASE_BINFOS (expr
), t
);
2237 BINFO_OFFSET (expr
) = lto_input_tree (ib
, data_in
);
2238 BINFO_VTABLE (expr
) = lto_input_tree (ib
, data_in
);
2239 BINFO_VIRTUALS (expr
) = lto_input_tree (ib
, data_in
);
2240 BINFO_VPTR_FIELD (expr
) = lto_input_tree (ib
, data_in
);
2242 len
= lto_input_uleb128 (ib
);
2243 for (i
= 0; i
< len
; i
++)
2245 tree a
= lto_input_tree (ib
, data_in
);
2246 VEC_safe_push (tree
, gc
, BINFO_BASE_ACCESSES (expr
), a
);
2249 BINFO_INHERITANCE_CHAIN (expr
) = lto_input_tree (ib
, data_in
);
2250 BINFO_SUBVTT_INDEX (expr
) = lto_input_tree (ib
, data_in
);
2251 BINFO_VPTR_INDEX (expr
) = lto_input_tree (ib
, data_in
);
2255 /* Read all pointer fields in the TS_CONSTRUCTOR structure of EXPR from
2256 input block IB. DATA_IN contains tables and descriptors for the
2260 lto_input_ts_constructor_tree_pointers (struct lto_input_block
*ib
,
2261 struct data_in
*data_in
, tree expr
)
2265 len
= lto_input_uleb128 (ib
);
2266 for (i
= 0; i
< len
; i
++)
2270 index
= lto_input_tree (ib
, data_in
);
2271 value
= lto_input_tree (ib
, data_in
);
2272 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (expr
), index
, value
);
2277 /* Helper for lto_input_tree. Read all pointer fields in EXPR from
2278 input block IB. DATA_IN contains tables and descriptors for the
2282 lto_input_tree_pointers (struct lto_input_block
*ib
, struct data_in
*data_in
,
2285 enum tree_code code
;
2287 code
= TREE_CODE (expr
);
2289 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
2290 lto_input_ts_common_tree_pointers (ib
, data_in
, expr
);
2292 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
2293 lto_input_ts_vector_tree_pointers (ib
, data_in
, expr
);
2295 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
2296 lto_input_ts_complex_tree_pointers (ib
, data_in
, expr
);
2298 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
2299 lto_input_ts_decl_minimal_tree_pointers (ib
, data_in
, expr
);
2301 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
2302 lto_input_ts_decl_common_tree_pointers (ib
, data_in
, expr
);
2304 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
2305 lto_input_ts_decl_non_common_tree_pointers (ib
, data_in
, expr
);
2307 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
2308 lto_input_ts_decl_with_vis_tree_pointers (ib
, data_in
, expr
);
2310 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
2311 lto_input_ts_field_decl_tree_pointers (ib
, data_in
, expr
);
2313 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
2314 lto_input_ts_function_decl_tree_pointers (ib
, data_in
, expr
);
2316 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE
))
2317 lto_input_ts_type_tree_pointers (ib
, data_in
, expr
);
2319 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
2320 lto_input_ts_list_tree_pointers (ib
, data_in
, expr
);
2322 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
2323 lto_input_ts_vec_tree_pointers (ib
, data_in
, expr
);
2325 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
2326 lto_input_ts_exp_tree_pointers (ib
, data_in
, expr
);
2328 if (CODE_CONTAINS_STRUCT (code
, TS_SSA_NAME
))
2330 /* We only stream the version number of SSA names. */
2334 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
2335 lto_input_ts_block_tree_pointers (ib
, data_in
, expr
);
2337 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
2338 lto_input_ts_binfo_tree_pointers (ib
, data_in
, expr
);
2340 if (CODE_CONTAINS_STRUCT (code
, TS_STATEMENT_LIST
))
2342 /* This should only appear in GENERIC. */
2346 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
2347 lto_input_ts_constructor_tree_pointers (ib
, data_in
, expr
);
2349 if (CODE_CONTAINS_STRUCT (code
, TS_OMP_CLAUSE
))
2351 /* This should only appear in High GIMPLE. */
2355 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
2357 sorry ("optimization options not supported yet");
2360 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
))
2362 sorry ("target optimization options not supported yet");
2367 /* Register DECL with the global symbol table and change its
2368 name if necessary to avoid name clashes for static globals across
2372 lto_register_var_decl_in_symtab (struct data_in
*data_in
, tree decl
)
2374 /* Register symbols with file or global scope to mark what input
2375 file has their definition. */
2376 if (decl_function_context (decl
) == NULL_TREE
)
2378 /* Variable has file scope, not local. Need to ensure static variables
2379 between different files don't clash unexpectedly. */
2380 if (!TREE_PUBLIC (decl
))
2382 /* ??? We normally pre-mangle names before we serialize them
2383 out. Here, in lto1, we do not know the language, and
2384 thus cannot do the mangling again. Instead, we just
2385 append a suffix to the mangled name. The resulting name,
2386 however, is not a properly-formed mangled name, and will
2387 confuse any attempt to unmangle it. */
2388 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
2391 ASM_FORMAT_PRIVATE_NAME (label
, name
, DECL_UID (decl
));
2392 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (label
));
2393 rest_of_decl_compilation (decl
, 1, 0);
2397 /* If this variable has already been declared, queue the
2398 declaration for merging. */
2399 if (TREE_PUBLIC (decl
))
2402 if (!lto_streamer_cache_lookup (data_in
->reader_cache
, decl
, &ix
))
2404 lto_symtab_register_decl (decl
, get_resolution (data_in
, ix
),
2405 data_in
->file_data
);
2411 /* Register DECL with the global symbol table and change its
2412 name if necessary to avoid name clashes for static globals across
2413 different files. DATA_IN contains descriptors and tables for the
2417 lto_register_function_decl_in_symtab (struct data_in
*data_in
, tree decl
)
2419 /* Need to ensure static entities between different files
2420 don't clash unexpectedly. */
2421 if (!TREE_PUBLIC (decl
))
2423 /* We must not use the DECL_ASSEMBLER_NAME macro here, as it
2424 may set the assembler name where it was previously empty. */
2425 tree old_assembler_name
= decl
->decl_with_vis
.assembler_name
;
2427 /* FIXME lto: We normally pre-mangle names before we serialize
2428 them out. Here, in lto1, we do not know the language, and
2429 thus cannot do the mangling again. Instead, we just append a
2430 suffix to the mangled name. The resulting name, however, is
2431 not a properly-formed mangled name, and will confuse any
2432 attempt to unmangle it. */
2433 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
2436 ASM_FORMAT_PRIVATE_NAME (label
, name
, DECL_UID (decl
));
2437 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (label
));
2439 /* We may arrive here with the old assembler name not set
2440 if the function body is not needed, e.g., it has been
2441 inlined away and does not appear in the cgraph. */
2442 if (old_assembler_name
)
2444 tree new_assembler_name
= DECL_ASSEMBLER_NAME (decl
);
2446 /* Make the original assembler name available for later use.
2447 We may have used it to indicate the section within its
2448 object file where the function body may be found.
2449 FIXME lto: Find a better way to maintain the function decl
2450 to body section mapping so we don't need this hack. */
2451 lto_record_renamed_decl (data_in
->file_data
,
2452 IDENTIFIER_POINTER (old_assembler_name
),
2453 IDENTIFIER_POINTER (new_assembler_name
));
2455 /* Also register the reverse mapping so that we can find the
2456 new name given to an existing assembler name (used when
2457 restoring alias pairs in input_constructors_or_inits. */
2458 lto_record_renamed_decl (data_in
->file_data
,
2459 IDENTIFIER_POINTER (new_assembler_name
),
2460 IDENTIFIER_POINTER (old_assembler_name
));
2464 /* If this variable has already been declared, queue the
2465 declaration for merging. */
2466 if (TREE_PUBLIC (decl
) && !DECL_ABSTRACT (decl
))
2469 if (!lto_streamer_cache_lookup (data_in
->reader_cache
, decl
, &ix
))
2471 lto_symtab_register_decl (decl
, get_resolution (data_in
, ix
),
2472 data_in
->file_data
);
2477 /* Read an index IX from input block IB and return the tree node at
2478 DATA_IN->FILE_DATA->GLOBALS_INDEX[IX]. */
2481 lto_get_pickled_tree (struct lto_input_block
*ib
, struct data_in
*data_in
)
2485 enum LTO_tags expected_tag
;
2486 unsigned HOST_WIDE_INT orig_offset
;
2488 ix
= lto_input_sleb128 (ib
);
2489 expected_tag
= (enum LTO_tags
) lto_input_uleb128 (ib
);
2491 orig_offset
= lto_input_uleb128 (ib
);
2492 gcc_assert (orig_offset
== (unsigned) orig_offset
);
2494 result
= lto_streamer_cache_get (data_in
->reader_cache
, ix
);
2495 if (result
== NULL_TREE
)
2497 /* We have not yet read the cache slot IX. Go to the offset
2498 in the stream where the physical tree node is, and materialize
2500 struct lto_input_block fwd_ib
;
2502 /* If we are trying to go back in the stream, something is wrong.
2503 We should've read the node at the earlier position already. */
2504 if (ib
->p
>= orig_offset
)
2505 internal_error ("bytecode stream: tried to jump backwards in the "
2508 LTO_INIT_INPUT_BLOCK (fwd_ib
, ib
->data
, orig_offset
, ib
->len
);
2509 result
= lto_input_tree (&fwd_ib
, data_in
);
2513 && TREE_CODE (result
) == lto_tag_to_tree_code (expected_tag
));
2519 /* Read a code and class from input block IB and return the
2520 corresponding builtin. DATA_IN is as in lto_input_tree. */
2523 lto_get_builtin_tree (struct lto_input_block
*ib
, struct data_in
*data_in
)
2525 enum built_in_class fclass
;
2526 enum built_in_function fcode
;
2527 const char *asmname
;
2531 fclass
= (enum built_in_class
) lto_input_uleb128 (ib
);
2532 gcc_assert (fclass
== BUILT_IN_NORMAL
|| fclass
== BUILT_IN_MD
);
2534 fcode
= (enum built_in_function
) lto_input_uleb128 (ib
);
2536 ix
= lto_input_sleb128 (ib
);
2537 gcc_assert (ix
== (int) ix
);
2539 if (fclass
== BUILT_IN_NORMAL
)
2541 gcc_assert (fcode
< END_BUILTINS
);
2542 result
= built_in_decls
[fcode
];
2543 gcc_assert (result
);
2545 else if (fclass
== BUILT_IN_MD
)
2547 result
= targetm
.builtin_decl (fcode
, true);
2548 if (!result
|| result
== error_mark_node
)
2549 fatal_error ("target specific builtin not available");
2552 asmname
= input_string (data_in
, ib
);
2554 set_builtin_user_assembler_name (result
, asmname
);
2556 lto_streamer_cache_insert_at (data_in
->reader_cache
, result
, ix
);
2562 /* Read the physical representation of a tree node with tag TAG from
2563 input block IB using the per-file context in DATA_IN. */
2566 lto_read_tree (struct lto_input_block
*ib
, struct data_in
*data_in
,
2573 result
= lto_materialize_tree (ib
, data_in
, tag
, &ix
);
2575 /* Read all the pointer fields in RESULT. */
2576 lto_input_tree_pointers (ib
, data_in
, result
);
2578 /* We should never try to instantiate an MD or NORMAL builtin here. */
2579 if (TREE_CODE (result
) == FUNCTION_DECL
)
2580 gcc_assert (!lto_stream_as_builtin_p (result
));
2582 if (TREE_CODE (result
) == VAR_DECL
)
2583 lto_register_var_decl_in_symtab (data_in
, result
);
2584 else if (TREE_CODE (result
) == FUNCTION_DECL
&& !DECL_BUILT_IN (result
))
2585 lto_register_function_decl_in_symtab (data_in
, result
);
2587 end_marker
= lto_input_1_unsigned (ib
);
2589 #ifdef LTO_STREAMER_DEBUG
2590 /* Remove the mapping to RESULT's original address set by
2591 lto_materialize_tree. */
2592 lto_orig_address_remove (result
);
2599 /* Read and INTEGER_CST node from input block IB using the per-file
2600 context in DATA_IN. */
2603 lto_input_integer_cst (struct lto_input_block
*ib
, struct data_in
*data_in
)
2606 HOST_WIDE_INT low
, high
;
2609 type
= lto_input_tree (ib
, data_in
);
2610 overflow_p
= (lto_input_1_unsigned (ib
) != 0);
2611 low
= lto_input_uleb128 (ib
);
2612 high
= lto_input_uleb128 (ib
);
2613 result
= build_int_cst_wide (type
, low
, high
);
2615 /* If the original constant had overflown, build a replica of RESULT to
2616 avoid modifying the shared constant returned by build_int_cst_wide. */
2619 result
= copy_node (result
);
2620 TREE_OVERFLOW (result
) = 1;
2627 /* Read a tree from input block IB using the per-file context in
2628 DATA_IN. This context is used, for example, to resolve references
2629 to previously read nodes. */
2632 lto_input_tree (struct lto_input_block
*ib
, struct data_in
*data_in
)
2637 tag
= input_record_start (ib
);
2638 gcc_assert ((unsigned) tag
< (unsigned) LTO_NUM_TAGS
);
2640 if (tag
== LTO_null
)
2642 else if (tag
>= LTO_field_decl_ref
&& tag
<= LTO_global_decl_ref
)
2644 /* If TAG is a reference to an indexable tree, the next value
2645 in IB is the index into the table where we expect to find
2647 result
= lto_input_tree_ref (ib
, data_in
, cfun
, tag
);
2649 else if (tag
== LTO_tree_pickle_reference
)
2651 /* If TAG is a reference to a previously read tree, look it up in
2652 the reader cache. */
2653 result
= lto_get_pickled_tree (ib
, data_in
);
2655 else if (tag
== LTO_builtin_decl
)
2657 /* If we are going to read a built-in function, all we need is
2658 the code and class. */
2659 result
= lto_get_builtin_tree (ib
, data_in
);
2661 else if (tag
== lto_tree_code_to_tag (INTEGER_CST
))
2663 /* For integer constants we only need the type and its hi/low
2665 result
= lto_input_integer_cst (ib
, data_in
);
2669 /* Otherwise, materialize a new node from IB. */
2670 result
= lto_read_tree (ib
, data_in
, tag
);
2677 /* Initialization for the LTO reader. */
2680 lto_init_reader (void)
2682 lto_streamer_init ();
2684 memset (<o_stats
, 0, sizeof (lto_stats
));
2685 bitmap_obstack_initialize (NULL
);
2687 file_name_hash_table
= htab_create (37, hash_string_slot_node
,
2688 eq_string_slot_node
, free
);
2690 gimple_register_cfg_hooks ();
2694 /* Create a new data_in object for FILE_DATA. STRINGS is the string
2695 table to use with LEN strings. RESOLUTIONS is the vector of linker
2696 resolutions (NULL if not using a linker plugin). */
2699 lto_data_in_create (struct lto_file_decl_data
*file_data
, const char *strings
,
2701 VEC(ld_plugin_symbol_resolution_t
,heap
) *resolutions
)
2703 struct data_in
*data_in
= XCNEW (struct data_in
);
2704 data_in
->file_data
= file_data
;
2705 data_in
->strings
= strings
;
2706 data_in
->strings_len
= len
;
2707 data_in
->globals_resolution
= resolutions
;
2708 data_in
->reader_cache
= lto_streamer_cache_create ();
2714 /* Remove DATA_IN. */
2717 lto_data_in_delete (struct data_in
*data_in
)
2719 VEC_free (ld_plugin_symbol_resolution_t
, heap
, data_in
->globals_resolution
);
2720 lto_streamer_cache_delete (data_in
->reader_cache
);
2721 free (data_in
->labels
);