1 /* Routines for emitting trees to a file stream.
3 Copyright 2011 Free Software Foundation, Inc.
4 Contributed by Diego Novillo <dnovillo@google.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
25 #include "diagnostic.h"
27 #include "tree-streamer.h"
28 #include "data-streamer.h"
29 #include "streamer-hooks.h"
31 /* Output the STRING constant to the string
32 table in OB. Then put the index onto the INDEX_STREAM. */
35 streamer_write_string_cst (struct output_block
*ob
,
36 struct lto_output_stream
*index_stream
,
39 streamer_write_string_with_length (ob
, index_stream
,
40 string
? TREE_STRING_POINTER (string
)
42 string
? TREE_STRING_LENGTH (string
) : 0,
47 /* Output the identifier ID to the string
48 table in OB. Then put the index onto the INDEX_STREAM. */
51 write_identifier (struct output_block
*ob
,
52 struct lto_output_stream
*index_stream
,
55 streamer_write_string_with_length (ob
, index_stream
,
56 IDENTIFIER_POINTER (id
),
57 IDENTIFIER_LENGTH (id
),
62 /* Pack all the non-pointer fields of the TS_BASE structure of
63 expression EXPR into bitpack BP. */
66 pack_ts_base_value_fields (struct bitpack_d
*bp
, tree expr
)
68 bp_pack_value (bp
, TREE_CODE (expr
), 16);
71 bp_pack_value (bp
, TREE_SIDE_EFFECTS (expr
), 1);
72 bp_pack_value (bp
, TREE_CONSTANT (expr
), 1);
73 bp_pack_value (bp
, TREE_READONLY (expr
), 1);
75 /* TREE_PUBLIC is used on types to indicate that the type
76 has a TYPE_CACHED_VALUES vector. This is not streamed out,
77 so we skip it here. */
78 bp_pack_value (bp
, TREE_PUBLIC (expr
), 1);
81 bp_pack_value (bp
, 0, 4);
82 bp_pack_value (bp
, TREE_ADDRESSABLE (expr
), 1);
83 bp_pack_value (bp
, TREE_THIS_VOLATILE (expr
), 1);
85 bp_pack_value (bp
, DECL_UNSIGNED (expr
), 1);
86 else if (TYPE_P (expr
))
87 bp_pack_value (bp
, TYPE_UNSIGNED (expr
), 1);
89 bp_pack_value (bp
, 0, 1);
90 /* We write debug info two times, do not confuse the second one. */
91 bp_pack_value (bp
, ((TYPE_P (expr
) || TREE_CODE (expr
) == TYPE_DECL
)
92 ? 0 : TREE_ASM_WRITTEN (expr
)), 1);
94 bp_pack_value (bp
, TYPE_ARTIFICIAL (expr
), 1);
96 bp_pack_value (bp
, TREE_NO_WARNING (expr
), 1);
97 bp_pack_value (bp
, TREE_USED (expr
), 1);
98 bp_pack_value (bp
, TREE_NOTHROW (expr
), 1);
99 bp_pack_value (bp
, TREE_STATIC (expr
), 1);
100 bp_pack_value (bp
, TREE_PRIVATE (expr
), 1);
101 bp_pack_value (bp
, TREE_PROTECTED (expr
), 1);
102 bp_pack_value (bp
, TREE_DEPRECATED (expr
), 1);
105 bp_pack_value (bp
, TYPE_SATURATING (expr
), 1);
106 bp_pack_value (bp
, TYPE_ADDR_SPACE (expr
), 8);
108 else if (TREE_CODE (expr
) == SSA_NAME
)
109 bp_pack_value (bp
, SSA_NAME_IS_DEFAULT_DEF (expr
), 1);
111 bp_pack_value (bp
, 0, 1);
115 /* Pack all the non-pointer fields of the TS_REAL_CST structure of
116 expression EXPR into bitpack BP. */
119 pack_ts_real_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
124 r
= TREE_REAL_CST (expr
);
125 bp_pack_value (bp
, r
.cl
, 2);
126 bp_pack_value (bp
, r
.decimal
, 1);
127 bp_pack_value (bp
, r
.sign
, 1);
128 bp_pack_value (bp
, r
.signalling
, 1);
129 bp_pack_value (bp
, r
.canonical
, 1);
130 bp_pack_value (bp
, r
.uexp
, EXP_BITS
);
131 for (i
= 0; i
< SIGSZ
; i
++)
132 bp_pack_value (bp
, r
.sig
[i
], HOST_BITS_PER_LONG
);
136 /* Pack all the non-pointer fields of the TS_FIXED_CST structure of
137 expression EXPR into bitpack BP. */
140 pack_ts_fixed_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
142 struct fixed_value fv
= TREE_FIXED_CST (expr
);
143 bp_pack_enum (bp
, machine_mode
, MAX_MACHINE_MODE
, fv
.mode
);
144 bp_pack_var_len_int (bp
, fv
.data
.low
);
145 bp_pack_var_len_int (bp
, fv
.data
.high
);
149 /* Pack all the non-pointer fields of the TS_DECL_COMMON structure
150 of expression EXPR into bitpack BP. */
153 pack_ts_decl_common_value_fields (struct bitpack_d
*bp
, tree expr
)
155 bp_pack_enum (bp
, machine_mode
, MAX_MACHINE_MODE
, DECL_MODE (expr
));
156 bp_pack_value (bp
, DECL_NONLOCAL (expr
), 1);
157 bp_pack_value (bp
, DECL_VIRTUAL_P (expr
), 1);
158 bp_pack_value (bp
, DECL_IGNORED_P (expr
), 1);
159 bp_pack_value (bp
, DECL_ABSTRACT (expr
), 1);
160 bp_pack_value (bp
, DECL_ARTIFICIAL (expr
), 1);
161 bp_pack_value (bp
, DECL_USER_ALIGN (expr
), 1);
162 bp_pack_value (bp
, DECL_PRESERVE_P (expr
), 1);
163 bp_pack_value (bp
, DECL_DEBUG_EXPR_IS_FROM (expr
), 1);
164 bp_pack_value (bp
, DECL_EXTERNAL (expr
), 1);
165 bp_pack_value (bp
, DECL_GIMPLE_REG_P (expr
), 1);
166 bp_pack_var_len_unsigned (bp
, DECL_ALIGN (expr
));
168 if (TREE_CODE (expr
) == LABEL_DECL
)
170 /* Note that we do not write LABEL_DECL_UID. The reader will
171 always assume an initial value of -1 so that the
172 label_to_block_map is recreated by gimple_set_bb. */
173 bp_pack_value (bp
, DECL_ERROR_ISSUED (expr
), 1);
174 bp_pack_var_len_unsigned (bp
, EH_LANDING_PAD_NR (expr
));
177 if (TREE_CODE (expr
) == FIELD_DECL
)
179 bp_pack_value (bp
, DECL_PACKED (expr
), 1);
180 bp_pack_value (bp
, DECL_NONADDRESSABLE_P (expr
), 1);
181 bp_pack_value (bp
, expr
->decl_common
.off_align
, 8);
184 if (TREE_CODE (expr
) == RESULT_DECL
185 || TREE_CODE (expr
) == PARM_DECL
186 || TREE_CODE (expr
) == VAR_DECL
)
188 bp_pack_value (bp
, DECL_BY_REFERENCE (expr
), 1);
189 if (TREE_CODE (expr
) == VAR_DECL
190 || TREE_CODE (expr
) == PARM_DECL
)
191 bp_pack_value (bp
, DECL_HAS_VALUE_EXPR_P (expr
), 1);
192 bp_pack_value (bp
, DECL_RESTRICTED_P (expr
), 1);
197 /* Pack all the non-pointer fields of the TS_DECL_WRTL structure
198 of expression EXPR into bitpack BP. */
201 pack_ts_decl_wrtl_value_fields (struct bitpack_d
*bp
, tree expr
)
203 bp_pack_value (bp
, DECL_REGISTER (expr
), 1);
207 /* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
208 of expression EXPR into bitpack BP. */
211 pack_ts_decl_with_vis_value_fields (struct bitpack_d
*bp
, tree expr
)
213 bp_pack_value (bp
, DECL_DEFER_OUTPUT (expr
), 1);
214 bp_pack_value (bp
, DECL_COMMON (expr
), 1);
215 bp_pack_value (bp
, DECL_DLLIMPORT_P (expr
), 1);
216 bp_pack_value (bp
, DECL_WEAK (expr
), 1);
217 bp_pack_value (bp
, DECL_SEEN_IN_BIND_EXPR_P (expr
), 1);
218 bp_pack_value (bp
, DECL_COMDAT (expr
), 1);
219 bp_pack_value (bp
, DECL_VISIBILITY (expr
), 2);
220 bp_pack_value (bp
, DECL_VISIBILITY_SPECIFIED (expr
), 1);
222 if (TREE_CODE (expr
) == VAR_DECL
)
224 bp_pack_value (bp
, DECL_HARD_REGISTER (expr
), 1);
225 bp_pack_value (bp
, DECL_IN_TEXT_SECTION (expr
), 1);
226 bp_pack_value (bp
, DECL_IN_CONSTANT_POOL (expr
), 1);
227 bp_pack_value (bp
, DECL_TLS_MODEL (expr
), 3);
230 if (VAR_OR_FUNCTION_DECL_P (expr
))
231 bp_pack_var_len_unsigned (bp
, DECL_INIT_PRIORITY (expr
));
235 /* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure
236 of expression EXPR into bitpack BP. */
239 pack_ts_function_decl_value_fields (struct bitpack_d
*bp
, tree expr
)
241 /* For normal/md builtins we only write the class and code, so they
242 should never be handled here. */
243 gcc_assert (!streamer_handle_as_builtin_p (expr
));
245 bp_pack_enum (bp
, built_in_class
, BUILT_IN_LAST
,
246 DECL_BUILT_IN_CLASS (expr
));
247 bp_pack_value (bp
, DECL_STATIC_CONSTRUCTOR (expr
), 1);
248 bp_pack_value (bp
, DECL_STATIC_DESTRUCTOR (expr
), 1);
249 bp_pack_value (bp
, DECL_UNINLINABLE (expr
), 1);
250 bp_pack_value (bp
, DECL_POSSIBLY_INLINED (expr
), 1);
251 bp_pack_value (bp
, DECL_IS_NOVOPS (expr
), 1);
252 bp_pack_value (bp
, DECL_IS_RETURNS_TWICE (expr
), 1);
253 bp_pack_value (bp
, DECL_IS_MALLOC (expr
), 1);
254 bp_pack_value (bp
, DECL_IS_OPERATOR_NEW (expr
), 1);
255 bp_pack_value (bp
, DECL_DECLARED_INLINE_P (expr
), 1);
256 bp_pack_value (bp
, DECL_STATIC_CHAIN (expr
), 1);
257 bp_pack_value (bp
, DECL_NO_INLINE_WARNING_P (expr
), 1);
258 bp_pack_value (bp
, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr
), 1);
259 bp_pack_value (bp
, DECL_NO_LIMIT_STACK (expr
), 1);
260 bp_pack_value (bp
, DECL_DISREGARD_INLINE_LIMITS (expr
), 1);
261 bp_pack_value (bp
, DECL_PURE_P (expr
), 1);
262 bp_pack_value (bp
, DECL_LOOPING_CONST_OR_PURE_P (expr
), 1);
263 if (DECL_BUILT_IN_CLASS (expr
) != NOT_BUILT_IN
)
264 bp_pack_value (bp
, DECL_FUNCTION_CODE (expr
), 11);
265 if (DECL_STATIC_DESTRUCTOR (expr
))
266 bp_pack_var_len_unsigned (bp
, DECL_FINI_PRIORITY (expr
));
270 /* Pack all the non-pointer fields of the TS_TYPE_COMMON structure
271 of expression EXPR into bitpack BP. */
274 pack_ts_type_common_value_fields (struct bitpack_d
*bp
, tree expr
)
276 bp_pack_enum (bp
, machine_mode
, MAX_MACHINE_MODE
, TYPE_MODE (expr
));
277 bp_pack_value (bp
, TYPE_STRING_FLAG (expr
), 1);
278 bp_pack_value (bp
, TYPE_NO_FORCE_BLK (expr
), 1);
279 bp_pack_value (bp
, TYPE_NEEDS_CONSTRUCTING (expr
), 1);
280 if (RECORD_OR_UNION_TYPE_P (expr
))
281 bp_pack_value (bp
, TYPE_TRANSPARENT_AGGR (expr
), 1);
282 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
283 bp_pack_value (bp
, TYPE_NONALIASED_COMPONENT (expr
), 1);
284 bp_pack_value (bp
, TYPE_PACKED (expr
), 1);
285 bp_pack_value (bp
, TYPE_RESTRICT (expr
), 1);
286 bp_pack_value (bp
, TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr
), 2);
287 bp_pack_value (bp
, TYPE_USER_ALIGN (expr
), 1);
288 bp_pack_value (bp
, TYPE_READONLY (expr
), 1);
289 bp_pack_var_len_unsigned (bp
, TYPE_PRECISION (expr
));
290 bp_pack_var_len_unsigned (bp
, TYPE_ALIGN (expr
));
291 bp_pack_var_len_int (bp
, TYPE_ALIAS_SET (expr
) == 0 ? 0 : -1);
295 /* Pack all the non-pointer fields of the TS_BLOCK structure
296 of expression EXPR into bitpack BP. */
299 pack_ts_block_value_fields (struct bitpack_d
*bp
, tree expr
)
301 bp_pack_value (bp
, BLOCK_ABSTRACT (expr
), 1);
302 /* BLOCK_NUMBER is recomputed. */
305 /* Pack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL structure
306 of expression EXPR into bitpack BP. */
309 pack_ts_translation_unit_decl_value_fields (struct bitpack_d
*bp ATTRIBUTE_UNUSED
, tree expr ATTRIBUTE_UNUSED
)
314 /* Pack all the bitfields in EXPR into a bit pack. */
317 streamer_pack_tree_bitfields (struct bitpack_d
*bp
, tree expr
)
321 code
= TREE_CODE (expr
);
323 /* Note that all these functions are highly sensitive to changes in
324 the types and sizes of each of the fields being packed. */
325 pack_ts_base_value_fields (bp
, expr
);
327 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
328 pack_ts_real_cst_value_fields (bp
, expr
);
330 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
331 pack_ts_fixed_cst_value_fields (bp
, expr
);
333 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
334 pack_ts_decl_common_value_fields (bp
, expr
);
336 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
337 pack_ts_decl_wrtl_value_fields (bp
, expr
);
339 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
340 pack_ts_decl_with_vis_value_fields (bp
, expr
);
342 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
343 pack_ts_function_decl_value_fields (bp
, expr
);
345 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
346 pack_ts_type_common_value_fields (bp
, expr
);
348 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
349 pack_ts_block_value_fields (bp
, expr
);
351 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
352 pack_ts_translation_unit_decl_value_fields (bp
, expr
);
356 /* Write the code and class of builtin EXPR to output block OB. IX is
357 the index into the streamer cache where EXPR is stored.*/
360 streamer_write_builtin (struct output_block
*ob
, tree expr
)
362 gcc_assert (streamer_handle_as_builtin_p (expr
));
364 if (DECL_BUILT_IN_CLASS (expr
) == BUILT_IN_MD
365 && !targetm
.builtin_decl
)
366 sorry ("tree bytecode streams do not support machine specific builtin "
367 "functions on this target");
369 streamer_write_record_start (ob
, LTO_builtin_decl
);
370 streamer_write_enum (ob
->main_stream
, built_in_class
, BUILT_IN_LAST
,
371 DECL_BUILT_IN_CLASS (expr
));
372 streamer_write_uhwi (ob
, DECL_FUNCTION_CODE (expr
));
374 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
376 /* When the assembler name of a builtin gets a user name,
377 the new name is always prefixed with '*' by
378 set_builtin_user_assembler_name. So, to prevent the
379 reader side from adding a second '*', we omit it here. */
380 const char *str
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (expr
));
381 if (strlen (str
) > 1 && str
[0] == '*')
382 streamer_write_string (ob
, ob
->main_stream
, &str
[1], true);
384 streamer_write_string (ob
, ob
->main_stream
, NULL
, true);
387 streamer_write_string (ob
, ob
->main_stream
, NULL
, true);
391 /* Emit the chain of tree nodes starting at T. OB is the output block
392 to write to. REF_P is true if chain elements should be emitted
396 streamer_write_chain (struct output_block
*ob
, tree t
, bool ref_p
)
400 count
= list_length (t
);
401 streamer_write_hwi (ob
, count
);
402 for (i
= 0; i
< count
; i
++)
406 /* Clear TREE_CHAIN to avoid blindly recursing into the rest
408 saved_chain
= TREE_CHAIN (t
);
409 TREE_CHAIN (t
) = NULL_TREE
;
411 /* We avoid outputting external vars or functions by reference
412 to the global decls section as we do not want to have them
413 enter decl merging. This is, of course, only for the call
414 for streaming BLOCK_VARS, but other callers are safe. */
415 if (VAR_OR_FUNCTION_DECL_P (t
)
416 && DECL_EXTERNAL (t
))
417 stream_write_tree_shallow_non_ref (ob
, t
, ref_p
);
419 stream_write_tree (ob
, t
, ref_p
);
421 TREE_CHAIN (t
) = saved_chain
;
427 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
428 block OB. If REF_P is true, write a reference to EXPR's pointer
432 write_ts_common_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
434 if (TREE_CODE (expr
) != IDENTIFIER_NODE
)
435 stream_write_tree (ob
, TREE_TYPE (expr
), ref_p
);
439 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
440 block OB. If REF_P is true, write a reference to EXPR's pointer
444 write_ts_vector_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
446 streamer_write_chain (ob
, TREE_VECTOR_CST_ELTS (expr
), ref_p
);
450 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
451 block OB. If REF_P is true, write a reference to EXPR's pointer
455 write_ts_complex_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
457 stream_write_tree (ob
, TREE_REALPART (expr
), ref_p
);
458 stream_write_tree (ob
, TREE_IMAGPART (expr
), ref_p
);
462 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
463 to output block OB. If REF_P is true, write a reference to EXPR's
467 write_ts_decl_minimal_tree_pointers (struct output_block
*ob
, tree expr
,
470 stream_write_tree (ob
, DECL_NAME (expr
), ref_p
);
471 stream_write_tree (ob
, DECL_CONTEXT (expr
), ref_p
);
472 lto_output_location (ob
, DECL_SOURCE_LOCATION (expr
));
476 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
477 output block OB. If REF_P is true, write a reference to EXPR's
481 write_ts_decl_common_tree_pointers (struct output_block
*ob
, tree expr
,
484 stream_write_tree (ob
, DECL_SIZE (expr
), ref_p
);
485 stream_write_tree (ob
, DECL_SIZE_UNIT (expr
), ref_p
);
487 /* Note, DECL_INITIAL is not handled here. Since DECL_INITIAL needs
488 special handling in LTO, it must be handled by streamer hooks. */
490 stream_write_tree (ob
, DECL_ATTRIBUTES (expr
), ref_p
);
492 /* Do not stream DECL_ABSTRACT_ORIGIN. We cannot handle debug information
493 for early inlining so drop it on the floor instead of ICEing in
496 if (TREE_CODE (expr
) == PARM_DECL
)
497 streamer_write_chain (ob
, TREE_CHAIN (expr
), ref_p
);
499 if ((TREE_CODE (expr
) == VAR_DECL
500 || TREE_CODE (expr
) == PARM_DECL
)
501 && DECL_HAS_VALUE_EXPR_P (expr
))
502 stream_write_tree (ob
, DECL_VALUE_EXPR (expr
), ref_p
);
504 if (TREE_CODE (expr
) == VAR_DECL
)
505 stream_write_tree (ob
, DECL_DEBUG_EXPR (expr
), ref_p
);
509 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
510 EXPR to output block OB. If REF_P is true, write a reference to EXPR's
514 write_ts_decl_non_common_tree_pointers (struct output_block
*ob
, tree expr
,
517 if (TREE_CODE (expr
) == FUNCTION_DECL
)
519 stream_write_tree (ob
, DECL_ARGUMENTS (expr
), ref_p
);
520 stream_write_tree (ob
, DECL_RESULT (expr
), ref_p
);
522 else if (TREE_CODE (expr
) == TYPE_DECL
)
523 stream_write_tree (ob
, DECL_ORIGINAL_TYPE (expr
), ref_p
);
524 stream_write_tree (ob
, DECL_VINDEX (expr
), ref_p
);
528 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
529 to output block OB. If REF_P is true, write a reference to EXPR's
533 write_ts_decl_with_vis_tree_pointers (struct output_block
*ob
, tree expr
,
536 /* Make sure we don't inadvertently set the assembler name. */
537 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
538 stream_write_tree (ob
, DECL_ASSEMBLER_NAME (expr
), ref_p
);
540 stream_write_tree (ob
, NULL_TREE
, false);
542 stream_write_tree (ob
, DECL_SECTION_NAME (expr
), ref_p
);
543 stream_write_tree (ob
, DECL_COMDAT_GROUP (expr
), ref_p
);
547 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
548 output block OB. If REF_P is true, write a reference to EXPR's
552 write_ts_field_decl_tree_pointers (struct output_block
*ob
, tree expr
,
555 stream_write_tree (ob
, DECL_FIELD_OFFSET (expr
), ref_p
);
556 stream_write_tree (ob
, DECL_BIT_FIELD_TYPE (expr
), ref_p
);
557 stream_write_tree (ob
, DECL_BIT_FIELD_REPRESENTATIVE (expr
), ref_p
);
558 stream_write_tree (ob
, DECL_FIELD_BIT_OFFSET (expr
), ref_p
);
559 stream_write_tree (ob
, DECL_FCONTEXT (expr
), ref_p
);
563 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
564 to output block OB. If REF_P is true, write a reference to EXPR's
568 write_ts_function_decl_tree_pointers (struct output_block
*ob
, tree expr
,
571 /* DECL_STRUCT_FUNCTION is handled by lto_output_function. FIXME lto,
572 maybe it should be handled here? */
573 stream_write_tree (ob
, DECL_FUNCTION_PERSONALITY (expr
), ref_p
);
574 stream_write_tree (ob
, DECL_FUNCTION_SPECIFIC_TARGET (expr
), ref_p
);
575 stream_write_tree (ob
, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr
), ref_p
);
579 /* Write all pointer fields in the TS_TYPE_COMMON structure of EXPR to
580 output block OB. If REF_P is true, write a reference to EXPR's
584 write_ts_type_common_tree_pointers (struct output_block
*ob
, tree expr
,
587 stream_write_tree (ob
, TYPE_SIZE (expr
), ref_p
);
588 stream_write_tree (ob
, TYPE_SIZE_UNIT (expr
), ref_p
);
589 stream_write_tree (ob
, TYPE_ATTRIBUTES (expr
), ref_p
);
590 stream_write_tree (ob
, TYPE_NAME (expr
), ref_p
);
591 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
592 reconstructed during fixup. */
593 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
595 stream_write_tree (ob
, TYPE_MAIN_VARIANT (expr
), ref_p
);
596 stream_write_tree (ob
, TYPE_CONTEXT (expr
), ref_p
);
597 /* TYPE_CANONICAL is re-computed during type merging, so no need
598 to stream it here. */
599 stream_write_tree (ob
, TYPE_STUB_DECL (expr
), ref_p
);
602 /* Write all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
603 to output block OB. If REF_P is true, write a reference to EXPR's
607 write_ts_type_non_common_tree_pointers (struct output_block
*ob
, tree expr
,
610 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
611 stream_write_tree (ob
, TYPE_VALUES (expr
), ref_p
);
612 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
613 stream_write_tree (ob
, TYPE_DOMAIN (expr
), ref_p
);
614 else if (RECORD_OR_UNION_TYPE_P (expr
))
615 streamer_write_chain (ob
, TYPE_FIELDS (expr
), ref_p
);
616 else if (TREE_CODE (expr
) == FUNCTION_TYPE
617 || TREE_CODE (expr
) == METHOD_TYPE
)
618 stream_write_tree (ob
, TYPE_ARG_TYPES (expr
), ref_p
);
620 if (!POINTER_TYPE_P (expr
))
621 stream_write_tree (ob
, TYPE_MINVAL (expr
), ref_p
);
622 stream_write_tree (ob
, TYPE_MAXVAL (expr
), ref_p
);
623 if (RECORD_OR_UNION_TYPE_P (expr
))
624 stream_write_tree (ob
, TYPE_BINFO (expr
), ref_p
);
628 /* Write all pointer fields in the TS_LIST structure of EXPR to output
629 block OB. If REF_P is true, write a reference to EXPR's pointer
633 write_ts_list_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
635 stream_write_tree (ob
, TREE_PURPOSE (expr
), ref_p
);
636 stream_write_tree (ob
, TREE_VALUE (expr
), ref_p
);
637 streamer_write_chain (ob
, TREE_CHAIN (expr
), ref_p
);
641 /* Write all pointer fields in the TS_VEC structure of EXPR to output
642 block OB. If REF_P is true, write a reference to EXPR's pointer
646 write_ts_vec_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
650 /* Note that the number of slots for EXPR has already been emitted
651 in EXPR's header (see streamer_write_tree_header). */
652 for (i
= 0; i
< TREE_VEC_LENGTH (expr
); i
++)
653 stream_write_tree (ob
, TREE_VEC_ELT (expr
, i
), ref_p
);
657 /* Write all pointer fields in the TS_EXP structure of EXPR to output
658 block OB. If REF_P is true, write a reference to EXPR's pointer
662 write_ts_exp_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
666 streamer_write_hwi (ob
, TREE_OPERAND_LENGTH (expr
));
667 for (i
= 0; i
< TREE_OPERAND_LENGTH (expr
); i
++)
668 stream_write_tree (ob
, TREE_OPERAND (expr
, i
), ref_p
);
669 lto_output_location (ob
, EXPR_LOCATION (expr
));
670 stream_write_tree (ob
, TREE_BLOCK (expr
), ref_p
);
674 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
675 block OB. If REF_P is true, write a reference to EXPR's pointer
679 write_ts_block_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
681 /* Do not stream BLOCK_SOURCE_LOCATION. We cannot handle debug information
682 for early inlining so drop it on the floor instead of ICEing in
684 streamer_write_chain (ob
, BLOCK_VARS (expr
), ref_p
);
686 /* Do not stream BLOCK_NONLOCALIZED_VARS. We cannot handle debug information
687 for early inlining so drop it on the floor instead of ICEing in
690 stream_write_tree (ob
, BLOCK_SUPERCONTEXT (expr
), ref_p
);
691 /* Do not stream BLOCK_ABSTRACT_ORIGIN. We cannot handle debug information
692 for early inlining so drop it on the floor instead of ICEing in
694 stream_write_tree (ob
, BLOCK_FRAGMENT_ORIGIN (expr
), ref_p
);
695 stream_write_tree (ob
, BLOCK_FRAGMENT_CHAIN (expr
), ref_p
);
696 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
697 list is re-constructed from BLOCK_SUPERCONTEXT. */
701 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
702 block OB. If REF_P is true, write a reference to EXPR's pointer
706 write_ts_binfo_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
711 /* Note that the number of BINFO slots has already been emitted in
712 EXPR's header (see streamer_write_tree_header) because this length
713 is needed to build the empty BINFO node on the reader side. */
714 FOR_EACH_VEC_ELT (tree
, BINFO_BASE_BINFOS (expr
), i
, t
)
715 stream_write_tree (ob
, t
, ref_p
);
716 stream_write_tree (ob
, NULL_TREE
, false);
718 stream_write_tree (ob
, BINFO_OFFSET (expr
), ref_p
);
719 stream_write_tree (ob
, BINFO_VTABLE (expr
), ref_p
);
720 stream_write_tree (ob
, BINFO_VPTR_FIELD (expr
), ref_p
);
722 streamer_write_uhwi (ob
, VEC_length (tree
, BINFO_BASE_ACCESSES (expr
)));
723 FOR_EACH_VEC_ELT (tree
, BINFO_BASE_ACCESSES (expr
), i
, t
)
724 stream_write_tree (ob
, t
, ref_p
);
726 stream_write_tree (ob
, BINFO_INHERITANCE_CHAIN (expr
), ref_p
);
727 stream_write_tree (ob
, BINFO_SUBVTT_INDEX (expr
), ref_p
);
728 stream_write_tree (ob
, BINFO_VPTR_INDEX (expr
), ref_p
);
732 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
733 output block OB. If REF_P is true, write a reference to EXPR's
737 write_ts_constructor_tree_pointers (struct output_block
*ob
, tree expr
,
743 streamer_write_uhwi (ob
, CONSTRUCTOR_NELTS (expr
));
744 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr
), i
, index
, value
)
746 stream_write_tree (ob
, index
, ref_p
);
747 stream_write_tree (ob
, value
, ref_p
);
751 /* Write a TS_TARGET_OPTION tree in EXPR to OB. */
754 write_ts_target_option (struct output_block
*ob
, tree expr
)
756 struct cl_target_option
*t
= TREE_TARGET_OPTION (expr
);
760 /* The cl_target_option is target specific and generated by the options
761 awk script, so we just recreate a byte-by-byte copy here. */
763 bp
= bitpack_create (ob
->main_stream
);
764 len
= sizeof (struct cl_target_option
);
765 for (i
= 0; i
< len
; i
++)
766 bp_pack_value (&bp
, ((unsigned char *)t
)[i
], 8);
767 /* Catch struct size mismatches between reader and writer. */
768 bp_pack_value (&bp
, 0x12345678, 32);
769 streamer_write_bitpack (&bp
);
772 /* Write a TS_OPTIMIZATION tree in EXPR to OB. */
775 write_ts_optimization (struct output_block
*ob
, tree expr
)
777 struct cl_optimization
*t
= TREE_OPTIMIZATION (expr
);
781 /* The cl_optimization is generated by the options
782 awk script, so we just recreate a byte-by-byte copy here. */
784 bp
= bitpack_create (ob
->main_stream
);
785 len
= sizeof (struct cl_optimization
);
786 for (i
= 0; i
< len
; i
++)
787 bp_pack_value (&bp
, ((unsigned char *)t
)[i
], 8);
788 /* Catch struct size mismatches between reader and writer. */
789 bp_pack_value (&bp
, 0x12345678, 32);
790 streamer_write_bitpack (&bp
);
793 /* Write a TS_TRANSLATION_UNIT_DECL tree in EXPR to OB. */
796 write_ts_translation_unit_decl_tree_pointers (struct output_block
*ob
,
799 streamer_write_string (ob
, ob
->main_stream
,
800 TRANSLATION_UNIT_LANGUAGE (expr
), true);
803 /* Write all pointer fields in EXPR to output block OB. If REF_P is true,
804 the leaves of EXPR are emitted as references. */
807 streamer_write_tree_body (struct output_block
*ob
, tree expr
, bool ref_p
)
811 code
= TREE_CODE (expr
);
813 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
814 write_ts_common_tree_pointers (ob
, expr
, ref_p
);
816 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
817 write_ts_vector_tree_pointers (ob
, expr
, ref_p
);
819 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
820 write_ts_complex_tree_pointers (ob
, expr
, ref_p
);
822 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
823 write_ts_decl_minimal_tree_pointers (ob
, expr
, ref_p
);
825 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
826 write_ts_decl_common_tree_pointers (ob
, expr
, ref_p
);
828 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
829 write_ts_decl_non_common_tree_pointers (ob
, expr
, ref_p
);
831 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
832 write_ts_decl_with_vis_tree_pointers (ob
, expr
, ref_p
);
834 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
835 write_ts_field_decl_tree_pointers (ob
, expr
, ref_p
);
837 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
838 write_ts_function_decl_tree_pointers (ob
, expr
, ref_p
);
840 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
841 write_ts_type_common_tree_pointers (ob
, expr
, ref_p
);
843 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
844 write_ts_type_non_common_tree_pointers (ob
, expr
, ref_p
);
846 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
847 write_ts_list_tree_pointers (ob
, expr
, ref_p
);
849 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
850 write_ts_vec_tree_pointers (ob
, expr
, ref_p
);
852 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
853 write_ts_exp_tree_pointers (ob
, expr
, ref_p
);
855 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
856 write_ts_block_tree_pointers (ob
, expr
, ref_p
);
858 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
859 write_ts_binfo_tree_pointers (ob
, expr
, ref_p
);
861 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
862 write_ts_constructor_tree_pointers (ob
, expr
, ref_p
);
864 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
))
865 write_ts_target_option (ob
, expr
);
867 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
868 write_ts_optimization (ob
, expr
);
870 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
871 write_ts_translation_unit_decl_tree_pointers (ob
, expr
);
875 /* Emit header information for tree EXPR to output block OB. The header
876 contains everything needed to instantiate an empty skeleton for
877 EXPR on the reading side. IX is the index into the streamer cache
878 where EXPR is stored. */
881 streamer_write_tree_header (struct output_block
*ob
, tree expr
)
886 /* We should not see any tree nodes not handled by the streamer. */
887 code
= TREE_CODE (expr
);
889 /* The header of a tree node consists of its tag, the size of
890 the node, and any other information needed to instantiate
891 EXPR on the reading side (such as the number of slots in
892 variable sized nodes). */
893 tag
= lto_tree_code_to_tag (code
);
894 streamer_write_record_start (ob
, tag
);
896 /* The following will cause bootstrap miscomparisons. Enable with care. */
897 #ifdef LTO_STREAMER_DEBUG
898 /* This is used mainly for debugging purposes. When the reader
899 and the writer do not agree on a streamed node, the pointer
900 value for EXPR can be used to track down the differences in
902 gcc_assert ((HOST_WIDEST_INT
) (intptr_t) expr
== (intptr_t) expr
);
903 streamer_write_hwi (ob
, (HOST_WIDEST_INT
) (intptr_t) expr
);
906 /* The text in strings and identifiers are completely emitted in
908 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
909 streamer_write_string_cst (ob
, ob
->main_stream
, expr
);
910 else if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
911 write_identifier (ob
, ob
->main_stream
, expr
);
912 else if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
913 streamer_write_hwi (ob
, TREE_VEC_LENGTH (expr
));
914 else if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
915 streamer_write_uhwi (ob
, BINFO_N_BASE_BINFOS (expr
));
916 else if (TREE_CODE (expr
) == CALL_EXPR
)
917 streamer_write_uhwi (ob
, call_expr_nargs (expr
));
921 /* Emit the integer constant CST to output block OB. If REF_P is true,
922 CST's type will be emitted as a reference. */
925 streamer_write_integer_cst (struct output_block
*ob
, tree cst
, bool ref_p
)
927 streamer_write_record_start (ob
, lto_tree_code_to_tag (INTEGER_CST
));
928 stream_write_tree (ob
, TREE_TYPE (cst
), ref_p
);
929 streamer_write_char_stream (ob
->main_stream
, TREE_OVERFLOW_P (cst
));
930 streamer_write_uhwi (ob
, TREE_INT_CST_LOW (cst
));
931 streamer_write_uhwi (ob
, TREE_INT_CST_HIGH (cst
));