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) ? 0 : TREE_ASM_WRITTEN (expr), 1);
93 bp_pack_value (bp, TYPE_ARTIFICIAL (expr), 1);
95 bp_pack_value (bp, TREE_NO_WARNING (expr), 1);
96 bp_pack_value (bp, TREE_USED (expr), 1);
97 bp_pack_value (bp, TREE_NOTHROW (expr), 1);
98 bp_pack_value (bp, TREE_STATIC (expr), 1);
99 bp_pack_value (bp, TREE_PRIVATE (expr), 1);
100 bp_pack_value (bp, TREE_PROTECTED (expr), 1);
101 bp_pack_value (bp, TREE_DEPRECATED (expr), 1);
104 bp_pack_value (bp, TYPE_SATURATING (expr), 1);
105 bp_pack_value (bp, TYPE_ADDR_SPACE (expr), 8);
107 else if (TREE_CODE (expr) == SSA_NAME)
108 bp_pack_value (bp, SSA_NAME_IS_DEFAULT_DEF (expr), 1);
110 bp_pack_value (bp, 0, 1);
114 /* Pack all the non-pointer fields of the TS_REAL_CST structure of
115 expression EXPR into bitpack BP. */
118 pack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
123 r = TREE_REAL_CST (expr);
124 bp_pack_value (bp, r.cl, 2);
125 bp_pack_value (bp, r.decimal, 1);
126 bp_pack_value (bp, r.sign, 1);
127 bp_pack_value (bp, r.signalling, 1);
128 bp_pack_value (bp, r.canonical, 1);
129 bp_pack_value (bp, r.uexp, EXP_BITS);
130 for (i = 0; i < SIGSZ; i++)
131 bp_pack_value (bp, r.sig[i], HOST_BITS_PER_LONG);
135 /* Pack all the non-pointer fields of the TS_FIXED_CST structure of
136 expression EXPR into bitpack BP. */
139 pack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr)
141 struct fixed_value fv = TREE_FIXED_CST (expr);
142 bp_pack_enum (bp, machine_mode, MAX_MACHINE_MODE, fv.mode);
143 bp_pack_var_len_int (bp, fv.data.low);
144 bp_pack_var_len_int (bp, fv.data.high);
148 /* Pack all the non-pointer fields of the TS_DECL_COMMON structure
149 of expression EXPR into bitpack BP. */
152 pack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr)
154 bp_pack_enum (bp, machine_mode, MAX_MACHINE_MODE, DECL_MODE (expr));
155 bp_pack_value (bp, DECL_NONLOCAL (expr), 1);
156 bp_pack_value (bp, DECL_VIRTUAL_P (expr), 1);
157 bp_pack_value (bp, DECL_IGNORED_P (expr), 1);
158 bp_pack_value (bp, DECL_ABSTRACT (expr), 1);
159 bp_pack_value (bp, DECL_ARTIFICIAL (expr), 1);
160 bp_pack_value (bp, DECL_USER_ALIGN (expr), 1);
161 bp_pack_value (bp, DECL_PRESERVE_P (expr), 1);
162 bp_pack_value (bp, DECL_DEBUG_EXPR_IS_FROM (expr), 1);
163 bp_pack_value (bp, DECL_EXTERNAL (expr), 1);
164 bp_pack_value (bp, DECL_GIMPLE_REG_P (expr), 1);
165 bp_pack_var_len_unsigned (bp, DECL_ALIGN (expr));
167 if (TREE_CODE (expr) == LABEL_DECL)
169 /* Note that we do not write LABEL_DECL_UID. The reader will
170 always assume an initial value of -1 so that the
171 label_to_block_map is recreated by gimple_set_bb. */
172 bp_pack_value (bp, DECL_ERROR_ISSUED (expr), 1);
173 bp_pack_var_len_unsigned (bp, EH_LANDING_PAD_NR (expr));
176 if (TREE_CODE (expr) == FIELD_DECL)
178 bp_pack_value (bp, DECL_PACKED (expr), 1);
179 bp_pack_value (bp, DECL_NONADDRESSABLE_P (expr), 1);
180 bp_pack_value (bp, expr->decl_common.off_align, 8);
183 if (TREE_CODE (expr) == RESULT_DECL
184 || TREE_CODE (expr) == PARM_DECL
185 || TREE_CODE (expr) == VAR_DECL)
187 bp_pack_value (bp, DECL_BY_REFERENCE (expr), 1);
188 if (TREE_CODE (expr) == VAR_DECL
189 || TREE_CODE (expr) == PARM_DECL)
190 bp_pack_value (bp, DECL_HAS_VALUE_EXPR_P (expr), 1);
191 bp_pack_value (bp, DECL_RESTRICTED_P (expr), 1);
196 /* Pack all the non-pointer fields of the TS_DECL_WRTL structure
197 of expression EXPR into bitpack BP. */
200 pack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
202 bp_pack_value (bp, DECL_REGISTER (expr), 1);
206 /* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
207 of expression EXPR into bitpack BP. */
210 pack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
212 bp_pack_value (bp, DECL_DEFER_OUTPUT (expr), 1);
213 bp_pack_value (bp, DECL_COMMON (expr), 1);
214 bp_pack_value (bp, DECL_DLLIMPORT_P (expr), 1);
215 bp_pack_value (bp, DECL_WEAK (expr), 1);
216 bp_pack_value (bp, DECL_SEEN_IN_BIND_EXPR_P (expr), 1);
217 bp_pack_value (bp, DECL_COMDAT (expr), 1);
218 bp_pack_value (bp, DECL_VISIBILITY (expr), 2);
219 bp_pack_value (bp, DECL_VISIBILITY_SPECIFIED (expr), 1);
221 if (TREE_CODE (expr) == VAR_DECL)
223 bp_pack_value (bp, DECL_HARD_REGISTER (expr), 1);
224 bp_pack_value (bp, DECL_IN_TEXT_SECTION (expr), 1);
225 bp_pack_value (bp, DECL_IN_CONSTANT_POOL (expr), 1);
226 bp_pack_value (bp, DECL_TLS_MODEL (expr), 3);
229 if (VAR_OR_FUNCTION_DECL_P (expr))
230 bp_pack_var_len_unsigned (bp, DECL_INIT_PRIORITY (expr));
234 /* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure
235 of expression EXPR into bitpack BP. */
238 pack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
240 /* For normal/md builtins we only write the class and code, so they
241 should never be handled here. */
242 gcc_assert (!streamer_handle_as_builtin_p (expr));
244 bp_pack_enum (bp, built_in_class, BUILT_IN_LAST,
245 DECL_BUILT_IN_CLASS (expr));
246 bp_pack_value (bp, DECL_STATIC_CONSTRUCTOR (expr), 1);
247 bp_pack_value (bp, DECL_STATIC_DESTRUCTOR (expr), 1);
248 bp_pack_value (bp, DECL_UNINLINABLE (expr), 1);
249 bp_pack_value (bp, DECL_POSSIBLY_INLINED (expr), 1);
250 bp_pack_value (bp, DECL_IS_NOVOPS (expr), 1);
251 bp_pack_value (bp, DECL_IS_RETURNS_TWICE (expr), 1);
252 bp_pack_value (bp, DECL_IS_MALLOC (expr), 1);
253 bp_pack_value (bp, DECL_IS_OPERATOR_NEW (expr), 1);
254 bp_pack_value (bp, DECL_DECLARED_INLINE_P (expr), 1);
255 bp_pack_value (bp, DECL_STATIC_CHAIN (expr), 1);
256 bp_pack_value (bp, DECL_NO_INLINE_WARNING_P (expr), 1);
257 bp_pack_value (bp, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr), 1);
258 bp_pack_value (bp, DECL_NO_LIMIT_STACK (expr), 1);
259 bp_pack_value (bp, DECL_DISREGARD_INLINE_LIMITS (expr), 1);
260 bp_pack_value (bp, DECL_PURE_P (expr), 1);
261 bp_pack_value (bp, DECL_LOOPING_CONST_OR_PURE_P (expr), 1);
262 if (DECL_BUILT_IN_CLASS (expr) != NOT_BUILT_IN)
263 bp_pack_value (bp, DECL_FUNCTION_CODE (expr), 11);
264 if (DECL_STATIC_DESTRUCTOR (expr))
265 bp_pack_var_len_unsigned (bp, DECL_FINI_PRIORITY (expr));
269 /* Pack all the non-pointer fields of the TS_TYPE_COMMON structure
270 of expression EXPR into bitpack BP. */
273 pack_ts_type_common_value_fields (struct bitpack_d *bp, tree expr)
275 bp_pack_enum (bp, machine_mode, MAX_MACHINE_MODE, TYPE_MODE (expr));
276 bp_pack_value (bp, TYPE_STRING_FLAG (expr), 1);
277 bp_pack_value (bp, TYPE_NO_FORCE_BLK (expr), 1);
278 bp_pack_value (bp, TYPE_NEEDS_CONSTRUCTING (expr), 1);
279 if (RECORD_OR_UNION_TYPE_P (expr))
280 bp_pack_value (bp, TYPE_TRANSPARENT_AGGR (expr), 1);
281 bp_pack_value (bp, TYPE_PACKED (expr), 1);
282 bp_pack_value (bp, TYPE_RESTRICT (expr), 1);
283 bp_pack_value (bp, TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr), 2);
284 bp_pack_value (bp, TYPE_USER_ALIGN (expr), 1);
285 bp_pack_value (bp, TYPE_READONLY (expr), 1);
286 bp_pack_var_len_unsigned (bp, TYPE_PRECISION (expr));
287 bp_pack_var_len_unsigned (bp, TYPE_ALIGN (expr));
288 bp_pack_var_len_int (bp, TYPE_ALIAS_SET (expr) == 0 ? 0 : -1);
292 /* Pack all the non-pointer fields of the TS_BLOCK structure
293 of expression EXPR into bitpack BP. */
296 pack_ts_block_value_fields (struct bitpack_d *bp, tree expr)
298 bp_pack_value (bp, BLOCK_ABSTRACT (expr), 1);
299 /* BLOCK_NUMBER is recomputed. */
302 /* Pack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL structure
303 of expression EXPR into bitpack BP. */
306 pack_ts_translation_unit_decl_value_fields (struct bitpack_d *bp ATTRIBUTE_UNUSED, tree expr ATTRIBUTE_UNUSED)
311 /* Pack all the bitfields in EXPR into a bit pack. */
314 streamer_pack_tree_bitfields (struct bitpack_d *bp, tree expr)
318 code = TREE_CODE (expr);
320 /* Note that all these functions are highly sensitive to changes in
321 the types and sizes of each of the fields being packed. */
322 pack_ts_base_value_fields (bp, expr);
324 if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
325 pack_ts_real_cst_value_fields (bp, expr);
327 if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
328 pack_ts_fixed_cst_value_fields (bp, expr);
330 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
331 pack_ts_decl_common_value_fields (bp, expr);
333 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
334 pack_ts_decl_wrtl_value_fields (bp, expr);
336 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
337 pack_ts_decl_with_vis_value_fields (bp, expr);
339 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
340 pack_ts_function_decl_value_fields (bp, expr);
342 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
343 pack_ts_type_common_value_fields (bp, expr);
345 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
346 pack_ts_block_value_fields (bp, expr);
348 if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
349 pack_ts_translation_unit_decl_value_fields (bp, expr);
353 /* Write the code and class of builtin EXPR to output block OB. IX is
354 the index into the streamer cache where EXPR is stored.*/
357 streamer_write_builtin (struct output_block *ob, tree expr)
359 gcc_assert (streamer_handle_as_builtin_p (expr));
361 if (DECL_BUILT_IN_CLASS (expr) == BUILT_IN_MD
362 && !targetm.builtin_decl)
363 sorry ("tree bytecode streams do not support machine specific builtin "
364 "functions on this target");
366 streamer_write_record_start (ob, LTO_builtin_decl);
367 streamer_write_enum (ob->main_stream, built_in_class, BUILT_IN_LAST,
368 DECL_BUILT_IN_CLASS (expr));
369 streamer_write_uhwi (ob, DECL_FUNCTION_CODE (expr));
371 if (DECL_ASSEMBLER_NAME_SET_P (expr))
373 /* When the assembler name of a builtin gets a user name,
374 the new name is always prefixed with '*' by
375 set_builtin_user_assembler_name. So, to prevent the
376 reader side from adding a second '*', we omit it here. */
377 const char *str = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (expr));
378 if (strlen (str) > 1 && str[0] == '*')
379 streamer_write_string (ob, ob->main_stream, &str[1], true);
381 streamer_write_string (ob, ob->main_stream, NULL, true);
384 streamer_write_string (ob, ob->main_stream, NULL, true);
388 /* Emit the chain of tree nodes starting at T. OB is the output block
389 to write to. REF_P is true if chain elements should be emitted
393 streamer_write_chain (struct output_block *ob, tree t, bool ref_p)
397 count = list_length (t);
398 streamer_write_hwi (ob, count);
399 for (i = 0; i < count; i++)
403 /* Clear TREE_CHAIN to avoid blindly recursing into the rest
405 saved_chain = TREE_CHAIN (t);
406 TREE_CHAIN (t) = NULL_TREE;
408 /* We avoid outputting external vars or functions by reference
409 to the global decls section as we do not want to have them
410 enter decl merging. This is, of course, only for the call
411 for streaming BLOCK_VARS, but other callers are safe. */
412 stream_write_tree (ob, t,
413 ref_p && !(VAR_OR_FUNCTION_DECL_P (t)
414 && DECL_EXTERNAL (t)));
416 TREE_CHAIN (t) = saved_chain;
422 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
423 block OB. If REF_P is true, write a reference to EXPR's pointer
427 write_ts_common_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
429 if (TREE_CODE (expr) != IDENTIFIER_NODE)
430 stream_write_tree (ob, TREE_TYPE (expr), ref_p);
434 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
435 block OB. If REF_P is true, write a reference to EXPR's pointer
439 write_ts_vector_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
441 streamer_write_chain (ob, TREE_VECTOR_CST_ELTS (expr), ref_p);
445 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
446 block OB. If REF_P is true, write a reference to EXPR's pointer
450 write_ts_complex_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
452 stream_write_tree (ob, TREE_REALPART (expr), ref_p);
453 stream_write_tree (ob, TREE_IMAGPART (expr), ref_p);
457 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
458 to output block OB. If REF_P is true, write a reference to EXPR's
462 write_ts_decl_minimal_tree_pointers (struct output_block *ob, tree expr,
465 stream_write_tree (ob, DECL_NAME (expr), ref_p);
466 stream_write_tree (ob, DECL_CONTEXT (expr), ref_p);
467 lto_output_location (ob, DECL_SOURCE_LOCATION (expr));
471 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
472 output block OB. If REF_P is true, write a reference to EXPR's
476 write_ts_decl_common_tree_pointers (struct output_block *ob, tree expr,
479 stream_write_tree (ob, DECL_SIZE (expr), ref_p);
480 stream_write_tree (ob, DECL_SIZE_UNIT (expr), ref_p);
482 /* Note, DECL_INITIAL is not handled here. Since DECL_INITIAL needs
483 special handling in LTO, it must be handled by streamer hooks. */
485 stream_write_tree (ob, DECL_ATTRIBUTES (expr), ref_p);
487 /* Do not stream DECL_ABSTRACT_ORIGIN. We cannot handle debug information
488 for early inlining so drop it on the floor instead of ICEing in
491 if (TREE_CODE (expr) == PARM_DECL)
492 streamer_write_chain (ob, TREE_CHAIN (expr), ref_p);
494 if ((TREE_CODE (expr) == VAR_DECL
495 || TREE_CODE (expr) == PARM_DECL)
496 && DECL_HAS_VALUE_EXPR_P (expr))
497 stream_write_tree (ob, DECL_VALUE_EXPR (expr), ref_p);
499 if (TREE_CODE (expr) == VAR_DECL)
500 stream_write_tree (ob, DECL_DEBUG_EXPR (expr), ref_p);
504 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
505 EXPR to output block OB. If REF_P is true, write a reference to EXPR's
509 write_ts_decl_non_common_tree_pointers (struct output_block *ob, tree expr,
512 if (TREE_CODE (expr) == FUNCTION_DECL)
514 stream_write_tree (ob, DECL_ARGUMENTS (expr), ref_p);
515 stream_write_tree (ob, DECL_RESULT (expr), ref_p);
517 else if (TREE_CODE (expr) == TYPE_DECL)
518 stream_write_tree (ob, DECL_ORIGINAL_TYPE (expr), ref_p);
519 stream_write_tree (ob, DECL_VINDEX (expr), ref_p);
523 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
524 to output block OB. If REF_P is true, write a reference to EXPR's
528 write_ts_decl_with_vis_tree_pointers (struct output_block *ob, tree expr,
531 /* Make sure we don't inadvertently set the assembler name. */
532 if (DECL_ASSEMBLER_NAME_SET_P (expr))
533 stream_write_tree (ob, DECL_ASSEMBLER_NAME (expr), ref_p);
535 stream_write_tree (ob, NULL_TREE, false);
537 stream_write_tree (ob, DECL_SECTION_NAME (expr), ref_p);
538 stream_write_tree (ob, DECL_COMDAT_GROUP (expr), ref_p);
542 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
543 output block OB. If REF_P is true, write a reference to EXPR's
547 write_ts_field_decl_tree_pointers (struct output_block *ob, tree expr,
550 stream_write_tree (ob, DECL_FIELD_OFFSET (expr), ref_p);
551 stream_write_tree (ob, DECL_BIT_FIELD_TYPE (expr), ref_p);
552 stream_write_tree (ob, DECL_QUALIFIER (expr), ref_p);
553 stream_write_tree (ob, DECL_FIELD_BIT_OFFSET (expr), ref_p);
554 stream_write_tree (ob, DECL_FCONTEXT (expr), ref_p);
555 streamer_write_chain (ob, TREE_CHAIN (expr), ref_p);
559 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
560 to output block OB. If REF_P is true, write a reference to EXPR's
564 write_ts_function_decl_tree_pointers (struct output_block *ob, tree expr,
567 /* DECL_STRUCT_FUNCTION is handled by lto_output_function. FIXME lto,
568 maybe it should be handled here? */
569 stream_write_tree (ob, DECL_FUNCTION_PERSONALITY (expr), ref_p);
570 stream_write_tree (ob, DECL_FUNCTION_SPECIFIC_TARGET (expr), ref_p);
571 stream_write_tree (ob, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr), ref_p);
575 /* Write all pointer fields in the TS_TYPE_COMMON structure of EXPR to
576 output block OB. If REF_P is true, write a reference to EXPR's
580 write_ts_type_common_tree_pointers (struct output_block *ob, tree expr,
583 stream_write_tree (ob, TYPE_SIZE (expr), ref_p);
584 stream_write_tree (ob, TYPE_SIZE_UNIT (expr), ref_p);
585 stream_write_tree (ob, TYPE_ATTRIBUTES (expr), ref_p);
586 stream_write_tree (ob, TYPE_NAME (expr), ref_p);
587 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
588 reconstructed during fixup. */
589 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
591 stream_write_tree (ob, TYPE_MAIN_VARIANT (expr), ref_p);
592 stream_write_tree (ob, TYPE_CONTEXT (expr), ref_p);
593 /* TYPE_CANONICAL is re-computed during type merging, so no need
594 to stream it here. */
595 stream_write_tree (ob, TYPE_STUB_DECL (expr), ref_p);
598 /* Write all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
599 to output block OB. If REF_P is true, write a reference to EXPR's
603 write_ts_type_non_common_tree_pointers (struct output_block *ob, tree expr,
606 if (TREE_CODE (expr) == ENUMERAL_TYPE)
607 stream_write_tree (ob, TYPE_VALUES (expr), ref_p);
608 else if (TREE_CODE (expr) == ARRAY_TYPE)
609 stream_write_tree (ob, TYPE_DOMAIN (expr), ref_p);
610 else if (RECORD_OR_UNION_TYPE_P (expr))
611 stream_write_tree (ob, TYPE_FIELDS (expr), ref_p);
612 else if (TREE_CODE (expr) == FUNCTION_TYPE
613 || TREE_CODE (expr) == METHOD_TYPE)
614 stream_write_tree (ob, TYPE_ARG_TYPES (expr), ref_p);
616 if (!POINTER_TYPE_P (expr))
617 stream_write_tree (ob, TYPE_MINVAL (expr), ref_p);
618 stream_write_tree (ob, TYPE_MAXVAL (expr), ref_p);
619 if (RECORD_OR_UNION_TYPE_P (expr))
620 stream_write_tree (ob, TYPE_BINFO (expr), ref_p);
624 /* Write all pointer fields in the TS_LIST structure of EXPR to output
625 block OB. If REF_P is true, write a reference to EXPR's pointer
629 write_ts_list_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
631 stream_write_tree (ob, TREE_PURPOSE (expr), ref_p);
632 stream_write_tree (ob, TREE_VALUE (expr), ref_p);
633 streamer_write_chain (ob, TREE_CHAIN (expr), ref_p);
637 /* Write all pointer fields in the TS_VEC structure of EXPR to output
638 block OB. If REF_P is true, write a reference to EXPR's pointer
642 write_ts_vec_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
646 /* Note that the number of slots for EXPR has already been emitted
647 in EXPR's header (see streamer_write_tree_header). */
648 for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
649 stream_write_tree (ob, TREE_VEC_ELT (expr, i), ref_p);
653 /* Write all pointer fields in the TS_EXP structure of EXPR to output
654 block OB. If REF_P is true, write a reference to EXPR's pointer
658 write_ts_exp_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
662 streamer_write_hwi (ob, TREE_OPERAND_LENGTH (expr));
663 for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
664 stream_write_tree (ob, TREE_OPERAND (expr, i), ref_p);
665 lto_output_location (ob, EXPR_LOCATION (expr));
666 stream_write_tree (ob, TREE_BLOCK (expr), ref_p);
670 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
671 block OB. If REF_P is true, write a reference to EXPR's pointer
675 write_ts_block_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
677 /* Do not stream BLOCK_SOURCE_LOCATION. We cannot handle debug information
678 for early inlining so drop it on the floor instead of ICEing in
680 streamer_write_chain (ob, BLOCK_VARS (expr), ref_p);
682 /* Do not stream BLOCK_NONLOCALIZED_VARS. We cannot handle debug information
683 for early inlining so drop it on the floor instead of ICEing in
686 stream_write_tree (ob, BLOCK_SUPERCONTEXT (expr), ref_p);
687 /* Do not stream BLOCK_ABSTRACT_ORIGIN. We cannot handle debug information
688 for early inlining so drop it on the floor instead of ICEing in
690 stream_write_tree (ob, BLOCK_FRAGMENT_ORIGIN (expr), ref_p);
691 stream_write_tree (ob, BLOCK_FRAGMENT_CHAIN (expr), ref_p);
692 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
693 list is re-constructed from BLOCK_SUPERCONTEXT. */
697 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
698 block OB. If REF_P is true, write a reference to EXPR's pointer
702 write_ts_binfo_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
707 /* Note that the number of BINFO slots has already been emitted in
708 EXPR's header (see streamer_write_tree_header) because this length
709 is needed to build the empty BINFO node on the reader side. */
710 FOR_EACH_VEC_ELT (tree, BINFO_BASE_BINFOS (expr), i, t)
711 stream_write_tree (ob, t, ref_p);
712 stream_write_tree (ob, NULL_TREE, false);
714 stream_write_tree (ob, BINFO_OFFSET (expr), ref_p);
715 stream_write_tree (ob, BINFO_VTABLE (expr), ref_p);
716 stream_write_tree (ob, BINFO_VPTR_FIELD (expr), ref_p);
718 streamer_write_uhwi (ob, VEC_length (tree, BINFO_BASE_ACCESSES (expr)));
719 FOR_EACH_VEC_ELT (tree, BINFO_BASE_ACCESSES (expr), i, t)
720 stream_write_tree (ob, t, ref_p);
722 stream_write_tree (ob, BINFO_INHERITANCE_CHAIN (expr), ref_p);
723 stream_write_tree (ob, BINFO_SUBVTT_INDEX (expr), ref_p);
724 stream_write_tree (ob, BINFO_VPTR_INDEX (expr), ref_p);
728 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
729 output block OB. If REF_P is true, write a reference to EXPR's
733 write_ts_constructor_tree_pointers (struct output_block *ob, tree expr,
739 streamer_write_uhwi (ob, CONSTRUCTOR_NELTS (expr));
740 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value)
742 stream_write_tree (ob, index, ref_p);
743 stream_write_tree (ob, value, ref_p);
747 /* Write a TS_TARGET_OPTION tree in EXPR to OB. */
750 write_ts_target_option (struct output_block *ob, tree expr)
752 struct cl_target_option *t = TREE_TARGET_OPTION (expr);
756 /* The cl_target_option is target specific and generated by the options
757 awk script, so we just recreate a byte-by-byte copy here. */
759 bp = bitpack_create (ob->main_stream);
760 len = sizeof (struct cl_target_option);
761 for (i = 0; i < len; i++)
762 bp_pack_value (&bp, ((unsigned char *)t)[i], 8);
763 /* Catch struct size mismatches between reader and writer. */
764 bp_pack_value (&bp, 0x12345678, 32);
765 streamer_write_bitpack (&bp);
768 /* Write a TS_TRANSLATION_UNIT_DECL tree in EXPR to OB. */
771 write_ts_translation_unit_decl_tree_pointers (struct output_block *ob,
774 streamer_write_string (ob, ob->main_stream,
775 TRANSLATION_UNIT_LANGUAGE (expr), true);
778 /* Write all pointer fields in EXPR to output block OB. If REF_P is true,
779 the leaves of EXPR are emitted as references. */
782 streamer_write_tree_body (struct output_block *ob, tree expr, bool ref_p)
786 code = TREE_CODE (expr);
788 if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
789 write_ts_common_tree_pointers (ob, expr, ref_p);
791 if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
792 write_ts_vector_tree_pointers (ob, expr, ref_p);
794 if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
795 write_ts_complex_tree_pointers (ob, expr, ref_p);
797 if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
798 write_ts_decl_minimal_tree_pointers (ob, expr, ref_p);
800 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
801 write_ts_decl_common_tree_pointers (ob, expr, ref_p);
803 if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
804 write_ts_decl_non_common_tree_pointers (ob, expr, ref_p);
806 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
807 write_ts_decl_with_vis_tree_pointers (ob, expr, ref_p);
809 if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
810 write_ts_field_decl_tree_pointers (ob, expr, ref_p);
812 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
813 write_ts_function_decl_tree_pointers (ob, expr, ref_p);
815 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
816 write_ts_type_common_tree_pointers (ob, expr, ref_p);
818 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
819 write_ts_type_non_common_tree_pointers (ob, expr, ref_p);
821 if (CODE_CONTAINS_STRUCT (code, TS_LIST))
822 write_ts_list_tree_pointers (ob, expr, ref_p);
824 if (CODE_CONTAINS_STRUCT (code, TS_VEC))
825 write_ts_vec_tree_pointers (ob, expr, ref_p);
827 if (CODE_CONTAINS_STRUCT (code, TS_EXP))
828 write_ts_exp_tree_pointers (ob, expr, ref_p);
830 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
831 write_ts_block_tree_pointers (ob, expr, ref_p);
833 if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
834 write_ts_binfo_tree_pointers (ob, expr, ref_p);
836 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
837 write_ts_constructor_tree_pointers (ob, expr, ref_p);
839 if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
840 write_ts_target_option (ob, expr);
842 if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
843 write_ts_translation_unit_decl_tree_pointers (ob, expr);
847 /* Emit header information for tree EXPR to output block OB. The header
848 contains everything needed to instantiate an empty skeleton for
849 EXPR on the reading side. IX is the index into the streamer cache
850 where EXPR is stored. */
853 streamer_write_tree_header (struct output_block *ob, tree expr)
858 /* We should not see any tree nodes not handled by the streamer. */
859 code = TREE_CODE (expr);
861 /* The header of a tree node consists of its tag, the size of
862 the node, and any other information needed to instantiate
863 EXPR on the reading side (such as the number of slots in
864 variable sized nodes). */
865 tag = lto_tree_code_to_tag (code);
866 streamer_write_record_start (ob, tag);
868 /* The following will cause bootstrap miscomparisons. Enable with care. */
869 #ifdef LTO_STREAMER_DEBUG
870 /* This is used mainly for debugging purposes. When the reader
871 and the writer do not agree on a streamed node, the pointer
872 value for EXPR can be used to track down the differences in
874 gcc_assert ((HOST_WIDEST_INT) (intptr_t) expr == (intptr_t) expr);
875 streamer_write_hwi (ob, (HOST_WIDEST_INT) (intptr_t) expr);
878 /* The text in strings and identifiers are completely emitted in
880 if (CODE_CONTAINS_STRUCT (code, TS_STRING))
881 streamer_write_string_cst (ob, ob->main_stream, expr);
882 else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
883 write_identifier (ob, ob->main_stream, expr);
884 else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
885 streamer_write_hwi (ob, TREE_VEC_LENGTH (expr));
886 else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
887 streamer_write_uhwi (ob, BINFO_N_BASE_BINFOS (expr));
888 else if (TREE_CODE (expr) == CALL_EXPR)
889 streamer_write_uhwi (ob, call_expr_nargs (expr));
893 /* Emit the integer constant CST to output block OB. If REF_P is true,
894 CST's type will be emitted as a reference. */
897 streamer_write_integer_cst (struct output_block *ob, tree cst, bool ref_p)
899 streamer_write_record_start (ob, lto_tree_code_to_tag (INTEGER_CST));
900 stream_write_tree (ob, TREE_TYPE (cst), ref_p);
901 streamer_write_char_stream (ob->main_stream, TREE_OVERFLOW_P (cst));
902 streamer_write_uhwi (ob, TREE_INT_CST_LOW (cst));
903 streamer_write_uhwi (ob, TREE_INT_CST_HIGH (cst));