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 bp_pack_value (bp
, TYPE_PACKED (expr
), 1);
283 bp_pack_value (bp
, TYPE_RESTRICT (expr
), 1);
284 bp_pack_value (bp
, TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr
), 2);
285 bp_pack_value (bp
, TYPE_USER_ALIGN (expr
), 1);
286 bp_pack_value (bp
, TYPE_READONLY (expr
), 1);
287 bp_pack_var_len_unsigned (bp
, TYPE_PRECISION (expr
));
288 bp_pack_var_len_unsigned (bp
, TYPE_ALIGN (expr
));
289 bp_pack_var_len_int (bp
, TYPE_ALIAS_SET (expr
) == 0 ? 0 : -1);
293 /* Pack all the non-pointer fields of the TS_BLOCK structure
294 of expression EXPR into bitpack BP. */
297 pack_ts_block_value_fields (struct bitpack_d
*bp
, tree expr
)
299 bp_pack_value (bp
, BLOCK_ABSTRACT (expr
), 1);
300 /* BLOCK_NUMBER is recomputed. */
303 /* Pack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL structure
304 of expression EXPR into bitpack BP. */
307 pack_ts_translation_unit_decl_value_fields (struct bitpack_d
*bp ATTRIBUTE_UNUSED
, tree expr ATTRIBUTE_UNUSED
)
312 /* Pack all the bitfields in EXPR into a bit pack. */
315 streamer_pack_tree_bitfields (struct bitpack_d
*bp
, tree expr
)
319 code
= TREE_CODE (expr
);
321 /* Note that all these functions are highly sensitive to changes in
322 the types and sizes of each of the fields being packed. */
323 pack_ts_base_value_fields (bp
, expr
);
325 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
326 pack_ts_real_cst_value_fields (bp
, expr
);
328 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
329 pack_ts_fixed_cst_value_fields (bp
, expr
);
331 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
332 pack_ts_decl_common_value_fields (bp
, expr
);
334 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
335 pack_ts_decl_wrtl_value_fields (bp
, expr
);
337 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
338 pack_ts_decl_with_vis_value_fields (bp
, expr
);
340 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
341 pack_ts_function_decl_value_fields (bp
, expr
);
343 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
344 pack_ts_type_common_value_fields (bp
, expr
);
346 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
347 pack_ts_block_value_fields (bp
, expr
);
349 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
350 pack_ts_translation_unit_decl_value_fields (bp
, expr
);
354 /* Write the code and class of builtin EXPR to output block OB. IX is
355 the index into the streamer cache where EXPR is stored.*/
358 streamer_write_builtin (struct output_block
*ob
, tree expr
)
360 gcc_assert (streamer_handle_as_builtin_p (expr
));
362 if (DECL_BUILT_IN_CLASS (expr
) == BUILT_IN_MD
363 && !targetm
.builtin_decl
)
364 sorry ("tree bytecode streams do not support machine specific builtin "
365 "functions on this target");
367 streamer_write_record_start (ob
, LTO_builtin_decl
);
368 streamer_write_enum (ob
->main_stream
, built_in_class
, BUILT_IN_LAST
,
369 DECL_BUILT_IN_CLASS (expr
));
370 streamer_write_uhwi (ob
, DECL_FUNCTION_CODE (expr
));
372 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
374 /* When the assembler name of a builtin gets a user name,
375 the new name is always prefixed with '*' by
376 set_builtin_user_assembler_name. So, to prevent the
377 reader side from adding a second '*', we omit it here. */
378 const char *str
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (expr
));
379 if (strlen (str
) > 1 && str
[0] == '*')
380 streamer_write_string (ob
, ob
->main_stream
, &str
[1], true);
382 streamer_write_string (ob
, ob
->main_stream
, NULL
, true);
385 streamer_write_string (ob
, ob
->main_stream
, NULL
, true);
389 /* Emit the chain of tree nodes starting at T. OB is the output block
390 to write to. REF_P is true if chain elements should be emitted
394 streamer_write_chain (struct output_block
*ob
, tree t
, bool ref_p
)
398 count
= list_length (t
);
399 streamer_write_hwi (ob
, count
);
400 for (i
= 0; i
< count
; i
++)
404 /* Clear TREE_CHAIN to avoid blindly recursing into the rest
406 saved_chain
= TREE_CHAIN (t
);
407 TREE_CHAIN (t
) = NULL_TREE
;
409 /* We avoid outputting external vars or functions by reference
410 to the global decls section as we do not want to have them
411 enter decl merging. This is, of course, only for the call
412 for streaming BLOCK_VARS, but other callers are safe. */
413 if (VAR_OR_FUNCTION_DECL_P (t
)
414 && DECL_EXTERNAL (t
))
415 stream_write_tree_shallow_non_ref (ob
, t
, ref_p
);
417 stream_write_tree (ob
, t
, ref_p
);
419 TREE_CHAIN (t
) = saved_chain
;
425 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
426 block OB. If REF_P is true, write a reference to EXPR's pointer
430 write_ts_common_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
432 if (TREE_CODE (expr
) != IDENTIFIER_NODE
)
433 stream_write_tree (ob
, TREE_TYPE (expr
), ref_p
);
437 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
438 block OB. If REF_P is true, write a reference to EXPR's pointer
442 write_ts_vector_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
445 /* Note that the number of elements for EXPR has already been emitted
446 in EXPR's header (see streamer_write_tree_header). */
447 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
448 stream_write_tree (ob
, VECTOR_CST_ELT (expr
, i
), ref_p
);
452 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
453 block OB. If REF_P is true, write a reference to EXPR's pointer
457 write_ts_complex_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
459 stream_write_tree (ob
, TREE_REALPART (expr
), ref_p
);
460 stream_write_tree (ob
, TREE_IMAGPART (expr
), ref_p
);
464 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
465 to output block OB. If REF_P is true, write a reference to EXPR's
469 write_ts_decl_minimal_tree_pointers (struct output_block
*ob
, tree expr
,
472 stream_write_tree (ob
, DECL_NAME (expr
), ref_p
);
473 stream_write_tree (ob
, DECL_CONTEXT (expr
), ref_p
);
474 lto_output_location (ob
, DECL_SOURCE_LOCATION (expr
));
478 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
479 output block OB. If REF_P is true, write a reference to EXPR's
483 write_ts_decl_common_tree_pointers (struct output_block
*ob
, tree expr
,
486 stream_write_tree (ob
, DECL_SIZE (expr
), ref_p
);
487 stream_write_tree (ob
, DECL_SIZE_UNIT (expr
), ref_p
);
489 /* Note, DECL_INITIAL is not handled here. Since DECL_INITIAL needs
490 special handling in LTO, it must be handled by streamer hooks. */
492 stream_write_tree (ob
, DECL_ATTRIBUTES (expr
), ref_p
);
494 /* Do not stream DECL_ABSTRACT_ORIGIN. We cannot handle debug information
495 for early inlining so drop it on the floor instead of ICEing in
498 if (TREE_CODE (expr
) == PARM_DECL
)
499 streamer_write_chain (ob
, TREE_CHAIN (expr
), ref_p
);
501 if ((TREE_CODE (expr
) == VAR_DECL
502 || TREE_CODE (expr
) == PARM_DECL
)
503 && DECL_HAS_VALUE_EXPR_P (expr
))
504 stream_write_tree (ob
, DECL_VALUE_EXPR (expr
), ref_p
);
506 if (TREE_CODE (expr
) == VAR_DECL
)
507 stream_write_tree (ob
, DECL_DEBUG_EXPR (expr
), ref_p
);
511 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
512 EXPR to output block OB. If REF_P is true, write a reference to EXPR's
516 write_ts_decl_non_common_tree_pointers (struct output_block
*ob
, tree expr
,
519 if (TREE_CODE (expr
) == FUNCTION_DECL
)
521 stream_write_tree (ob
, DECL_ARGUMENTS (expr
), ref_p
);
522 stream_write_tree (ob
, DECL_RESULT (expr
), ref_p
);
524 else if (TREE_CODE (expr
) == TYPE_DECL
)
525 stream_write_tree (ob
, DECL_ORIGINAL_TYPE (expr
), ref_p
);
526 stream_write_tree (ob
, DECL_VINDEX (expr
), ref_p
);
530 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
531 to output block OB. If REF_P is true, write a reference to EXPR's
535 write_ts_decl_with_vis_tree_pointers (struct output_block
*ob
, tree expr
,
538 /* Make sure we don't inadvertently set the assembler name. */
539 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
540 stream_write_tree (ob
, DECL_ASSEMBLER_NAME (expr
), ref_p
);
542 stream_write_tree (ob
, NULL_TREE
, false);
544 stream_write_tree (ob
, DECL_SECTION_NAME (expr
), ref_p
);
545 stream_write_tree (ob
, DECL_COMDAT_GROUP (expr
), ref_p
);
549 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
550 output block OB. If REF_P is true, write a reference to EXPR's
554 write_ts_field_decl_tree_pointers (struct output_block
*ob
, tree expr
,
557 stream_write_tree (ob
, DECL_FIELD_OFFSET (expr
), ref_p
);
558 stream_write_tree (ob
, DECL_BIT_FIELD_TYPE (expr
), ref_p
);
559 stream_write_tree (ob
, DECL_BIT_FIELD_REPRESENTATIVE (expr
), ref_p
);
560 stream_write_tree (ob
, DECL_FIELD_BIT_OFFSET (expr
), ref_p
);
561 stream_write_tree (ob
, DECL_FCONTEXT (expr
), ref_p
);
565 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
566 to output block OB. If REF_P is true, write a reference to EXPR's
570 write_ts_function_decl_tree_pointers (struct output_block
*ob
, tree expr
,
573 /* DECL_STRUCT_FUNCTION is handled by lto_output_function. FIXME lto,
574 maybe it should be handled here? */
575 stream_write_tree (ob
, DECL_FUNCTION_PERSONALITY (expr
), ref_p
);
576 stream_write_tree (ob
, DECL_FUNCTION_SPECIFIC_TARGET (expr
), ref_p
);
577 stream_write_tree (ob
, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr
), ref_p
);
581 /* Write all pointer fields in the TS_TYPE_COMMON structure of EXPR to
582 output block OB. If REF_P is true, write a reference to EXPR's
586 write_ts_type_common_tree_pointers (struct output_block
*ob
, tree expr
,
589 stream_write_tree (ob
, TYPE_SIZE (expr
), ref_p
);
590 stream_write_tree (ob
, TYPE_SIZE_UNIT (expr
), ref_p
);
591 stream_write_tree (ob
, TYPE_ATTRIBUTES (expr
), ref_p
);
592 stream_write_tree (ob
, TYPE_NAME (expr
), ref_p
);
593 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
594 reconstructed during fixup. */
595 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
597 stream_write_tree (ob
, TYPE_MAIN_VARIANT (expr
), ref_p
);
598 stream_write_tree (ob
, TYPE_CONTEXT (expr
), ref_p
);
599 /* TYPE_CANONICAL is re-computed during type merging, so no need
600 to stream it here. */
601 stream_write_tree (ob
, TYPE_STUB_DECL (expr
), ref_p
);
604 /* Write all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
605 to output block OB. If REF_P is true, write a reference to EXPR's
609 write_ts_type_non_common_tree_pointers (struct output_block
*ob
, tree expr
,
612 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
613 stream_write_tree (ob
, TYPE_VALUES (expr
), ref_p
);
614 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
615 stream_write_tree (ob
, TYPE_DOMAIN (expr
), ref_p
);
616 else if (RECORD_OR_UNION_TYPE_P (expr
))
617 streamer_write_chain (ob
, TYPE_FIELDS (expr
), ref_p
);
618 else if (TREE_CODE (expr
) == FUNCTION_TYPE
619 || TREE_CODE (expr
) == METHOD_TYPE
)
620 stream_write_tree (ob
, TYPE_ARG_TYPES (expr
), ref_p
);
622 if (!POINTER_TYPE_P (expr
))
623 stream_write_tree (ob
, TYPE_MINVAL (expr
), ref_p
);
624 stream_write_tree (ob
, TYPE_MAXVAL (expr
), ref_p
);
625 if (RECORD_OR_UNION_TYPE_P (expr
))
626 stream_write_tree (ob
, TYPE_BINFO (expr
), ref_p
);
630 /* Write all pointer fields in the TS_LIST structure of EXPR to output
631 block OB. If REF_P is true, write a reference to EXPR's pointer
635 write_ts_list_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
637 stream_write_tree (ob
, TREE_PURPOSE (expr
), ref_p
);
638 stream_write_tree (ob
, TREE_VALUE (expr
), ref_p
);
639 streamer_write_chain (ob
, TREE_CHAIN (expr
), ref_p
);
643 /* Write all pointer fields in the TS_VEC structure of EXPR to output
644 block OB. If REF_P is true, write a reference to EXPR's pointer
648 write_ts_vec_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
652 /* Note that the number of slots for EXPR has already been emitted
653 in EXPR's header (see streamer_write_tree_header). */
654 for (i
= 0; i
< TREE_VEC_LENGTH (expr
); i
++)
655 stream_write_tree (ob
, TREE_VEC_ELT (expr
, i
), ref_p
);
659 /* Write all pointer fields in the TS_EXP structure of EXPR to output
660 block OB. If REF_P is true, write a reference to EXPR's pointer
664 write_ts_exp_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
668 streamer_write_hwi (ob
, TREE_OPERAND_LENGTH (expr
));
669 for (i
= 0; i
< TREE_OPERAND_LENGTH (expr
); i
++)
670 stream_write_tree (ob
, TREE_OPERAND (expr
, i
), ref_p
);
671 lto_output_location (ob
, EXPR_LOCATION (expr
));
672 stream_write_tree (ob
, TREE_BLOCK (expr
), ref_p
);
676 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
677 block OB. If REF_P is true, write a reference to EXPR's pointer
681 write_ts_block_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
683 /* Do not stream BLOCK_SOURCE_LOCATION. We cannot handle debug information
684 for early inlining so drop it on the floor instead of ICEing in
686 streamer_write_chain (ob
, BLOCK_VARS (expr
), ref_p
);
688 /* Do not stream BLOCK_NONLOCALIZED_VARS. We cannot handle debug information
689 for early inlining so drop it on the floor instead of ICEing in
692 stream_write_tree (ob
, BLOCK_SUPERCONTEXT (expr
), ref_p
);
693 /* Do not stream BLOCK_ABSTRACT_ORIGIN. We cannot handle debug information
694 for early inlining so drop it on the floor instead of ICEing in
696 stream_write_tree (ob
, BLOCK_FRAGMENT_ORIGIN (expr
), ref_p
);
697 stream_write_tree (ob
, BLOCK_FRAGMENT_CHAIN (expr
), ref_p
);
698 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
699 list is re-constructed from BLOCK_SUPERCONTEXT. */
703 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
704 block OB. If REF_P is true, write a reference to EXPR's pointer
708 write_ts_binfo_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
713 /* Note that the number of BINFO slots has already been emitted in
714 EXPR's header (see streamer_write_tree_header) because this length
715 is needed to build the empty BINFO node on the reader side. */
716 FOR_EACH_VEC_ELT (tree
, BINFO_BASE_BINFOS (expr
), i
, t
)
717 stream_write_tree (ob
, t
, ref_p
);
718 stream_write_tree (ob
, NULL_TREE
, false);
720 stream_write_tree (ob
, BINFO_OFFSET (expr
), ref_p
);
721 stream_write_tree (ob
, BINFO_VTABLE (expr
), ref_p
);
722 stream_write_tree (ob
, BINFO_VPTR_FIELD (expr
), ref_p
);
724 streamer_write_uhwi (ob
, VEC_length (tree
, BINFO_BASE_ACCESSES (expr
)));
725 FOR_EACH_VEC_ELT (tree
, BINFO_BASE_ACCESSES (expr
), i
, t
)
726 stream_write_tree (ob
, t
, ref_p
);
728 stream_write_tree (ob
, BINFO_INHERITANCE_CHAIN (expr
), ref_p
);
729 stream_write_tree (ob
, BINFO_SUBVTT_INDEX (expr
), ref_p
);
730 stream_write_tree (ob
, BINFO_VPTR_INDEX (expr
), ref_p
);
734 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
735 output block OB. If REF_P is true, write a reference to EXPR's
739 write_ts_constructor_tree_pointers (struct output_block
*ob
, tree expr
,
745 streamer_write_uhwi (ob
, CONSTRUCTOR_NELTS (expr
));
746 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr
), i
, index
, value
)
748 stream_write_tree (ob
, index
, ref_p
);
749 stream_write_tree (ob
, value
, ref_p
);
753 /* Write a TS_TARGET_OPTION tree in EXPR to OB. */
756 write_ts_target_option (struct output_block
*ob
, tree expr
)
758 struct cl_target_option
*t
= TREE_TARGET_OPTION (expr
);
762 /* The cl_target_option is target specific and generated by the options
763 awk script, so we just recreate a byte-by-byte copy here. */
765 bp
= bitpack_create (ob
->main_stream
);
766 len
= sizeof (struct cl_target_option
);
767 for (i
= 0; i
< len
; i
++)
768 bp_pack_value (&bp
, ((unsigned char *)t
)[i
], 8);
769 /* Catch struct size mismatches between reader and writer. */
770 bp_pack_value (&bp
, 0x12345678, 32);
771 streamer_write_bitpack (&bp
);
774 /* Write a TS_OPTIMIZATION tree in EXPR to OB. */
777 write_ts_optimization (struct output_block
*ob
, tree expr
)
779 struct cl_optimization
*t
= TREE_OPTIMIZATION (expr
);
783 /* The cl_optimization is generated by the options
784 awk script, so we just recreate a byte-by-byte copy here. */
786 bp
= bitpack_create (ob
->main_stream
);
787 len
= sizeof (struct cl_optimization
);
788 for (i
= 0; i
< len
; i
++)
789 bp_pack_value (&bp
, ((unsigned char *)t
)[i
], 8);
790 /* Catch struct size mismatches between reader and writer. */
791 bp_pack_value (&bp
, 0x12345678, 32);
792 streamer_write_bitpack (&bp
);
795 /* Write a TS_TRANSLATION_UNIT_DECL tree in EXPR to OB. */
798 write_ts_translation_unit_decl_tree_pointers (struct output_block
*ob
,
801 streamer_write_string (ob
, ob
->main_stream
,
802 TRANSLATION_UNIT_LANGUAGE (expr
), true);
805 /* Write all pointer fields in EXPR to output block OB. If REF_P is true,
806 the leaves of EXPR are emitted as references. */
809 streamer_write_tree_body (struct output_block
*ob
, tree expr
, bool ref_p
)
813 code
= TREE_CODE (expr
);
815 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
816 write_ts_common_tree_pointers (ob
, expr
, ref_p
);
818 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
819 write_ts_vector_tree_pointers (ob
, expr
, ref_p
);
821 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
822 write_ts_complex_tree_pointers (ob
, expr
, ref_p
);
824 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
825 write_ts_decl_minimal_tree_pointers (ob
, expr
, ref_p
);
827 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
828 write_ts_decl_common_tree_pointers (ob
, expr
, ref_p
);
830 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
831 write_ts_decl_non_common_tree_pointers (ob
, expr
, ref_p
);
833 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
834 write_ts_decl_with_vis_tree_pointers (ob
, expr
, ref_p
);
836 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
837 write_ts_field_decl_tree_pointers (ob
, expr
, ref_p
);
839 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
840 write_ts_function_decl_tree_pointers (ob
, expr
, ref_p
);
842 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
843 write_ts_type_common_tree_pointers (ob
, expr
, ref_p
);
845 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
846 write_ts_type_non_common_tree_pointers (ob
, expr
, ref_p
);
848 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
849 write_ts_list_tree_pointers (ob
, expr
, ref_p
);
851 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
852 write_ts_vec_tree_pointers (ob
, expr
, ref_p
);
854 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
855 write_ts_exp_tree_pointers (ob
, expr
, ref_p
);
857 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
858 write_ts_block_tree_pointers (ob
, expr
, ref_p
);
860 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
861 write_ts_binfo_tree_pointers (ob
, expr
, ref_p
);
863 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
864 write_ts_constructor_tree_pointers (ob
, expr
, ref_p
);
866 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
))
867 write_ts_target_option (ob
, expr
);
869 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
870 write_ts_optimization (ob
, expr
);
872 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
873 write_ts_translation_unit_decl_tree_pointers (ob
, expr
);
877 /* Emit header information for tree EXPR to output block OB. The header
878 contains everything needed to instantiate an empty skeleton for
879 EXPR on the reading side. IX is the index into the streamer cache
880 where EXPR is stored. */
883 streamer_write_tree_header (struct output_block
*ob
, tree expr
)
888 /* We should not see any tree nodes not handled by the streamer. */
889 code
= TREE_CODE (expr
);
891 /* The header of a tree node consists of its tag, the size of
892 the node, and any other information needed to instantiate
893 EXPR on the reading side (such as the number of slots in
894 variable sized nodes). */
895 tag
= lto_tree_code_to_tag (code
);
896 streamer_write_record_start (ob
, tag
);
898 /* The following will cause bootstrap miscomparisons. Enable with care. */
899 #ifdef LTO_STREAMER_DEBUG
900 /* This is used mainly for debugging purposes. When the reader
901 and the writer do not agree on a streamed node, the pointer
902 value for EXPR can be used to track down the differences in
904 gcc_assert ((HOST_WIDEST_INT
) (intptr_t) expr
== (intptr_t) expr
);
905 streamer_write_hwi (ob
, (HOST_WIDEST_INT
) (intptr_t) expr
);
908 /* The text in strings and identifiers are completely emitted in
910 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
911 streamer_write_string_cst (ob
, ob
->main_stream
, expr
);
912 else if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
913 write_identifier (ob
, ob
->main_stream
, expr
);
914 else if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
915 streamer_write_hwi (ob
, VECTOR_CST_NELTS (expr
));
916 else if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
917 streamer_write_hwi (ob
, TREE_VEC_LENGTH (expr
));
918 else if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
919 streamer_write_uhwi (ob
, BINFO_N_BASE_BINFOS (expr
));
920 else if (TREE_CODE (expr
) == CALL_EXPR
)
921 streamer_write_uhwi (ob
, call_expr_nargs (expr
));
925 /* Emit the integer constant CST to output block OB. If REF_P is true,
926 CST's type will be emitted as a reference. */
929 streamer_write_integer_cst (struct output_block
*ob
, tree cst
, bool ref_p
)
931 streamer_write_record_start (ob
, lto_tree_code_to_tag (INTEGER_CST
));
932 stream_write_tree (ob
, TREE_TYPE (cst
), ref_p
);
933 streamer_write_char_stream (ob
->main_stream
, TREE_OVERFLOW_P (cst
));
934 streamer_write_uhwi (ob
, TREE_INT_CST_LOW (cst
));
935 streamer_write_uhwi (ob
, TREE_INT_CST_HIGH (cst
));