1 /* Routines for emitting trees to a file stream.
3 Copyright (C) 2011-2020 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"
29 #include "tree-streamer.h"
32 #include "stor-layout.h"
33 #include "gomp-constants.h"
36 /* Output the STRING constant to the string
37 table in OB. Then put the index onto the INDEX_STREAM. */
40 streamer_write_string_cst (struct output_block
*ob
,
41 struct lto_output_stream
*index_stream
,
44 streamer_write_string_with_length (ob
, index_stream
,
45 string
? TREE_STRING_POINTER (string
)
47 string
? TREE_STRING_LENGTH (string
) : 0,
52 /* Output the identifier ID to the string
53 table in OB. Then put the index onto the INDEX_STREAM. */
56 write_identifier (struct output_block
*ob
,
57 struct lto_output_stream
*index_stream
,
60 streamer_write_string_with_length (ob
, index_stream
,
61 IDENTIFIER_POINTER (id
),
62 IDENTIFIER_LENGTH (id
),
67 /* Pack all the non-pointer fields of the TS_BASE structure of
68 expression EXPR into bitpack BP. */
71 pack_ts_base_value_fields (struct bitpack_d
*bp
, tree expr
)
73 bp_pack_value (bp
, TREE_CODE (expr
), 16);
76 bp_pack_value (bp
, TREE_SIDE_EFFECTS (expr
), 1);
77 bp_pack_value (bp
, TREE_CONSTANT (expr
), 1);
78 bp_pack_value (bp
, TREE_READONLY (expr
), 1);
80 /* TREE_PUBLIC is used on types to indicate that the type
81 has a TYPE_CACHED_VALUES vector. This is not streamed out,
82 so we skip it here. */
83 bp_pack_value (bp
, TREE_PUBLIC (expr
), 1);
86 bp_pack_value (bp
, 0, 4);
87 bp_pack_value (bp
, TREE_ADDRESSABLE (expr
), 1);
88 bp_pack_value (bp
, TREE_THIS_VOLATILE (expr
), 1);
91 bp_pack_value (bp
, DECL_UNSIGNED (expr
), 1);
92 bp_pack_value (bp
, DECL_NAMELESS (expr
), 1);
94 else if (TYPE_P (expr
))
95 bp_pack_value (bp
, TYPE_UNSIGNED (expr
), 1);
97 bp_pack_value (bp
, 0, 1);
98 /* We write debug info two times, do not confuse the second one.
99 The only relevant TREE_ASM_WRITTEN use is on SSA names. */
100 bp_pack_value (bp
, (TREE_CODE (expr
) != SSA_NAME
101 ? 0 : TREE_ASM_WRITTEN (expr
)), 1);
103 bp_pack_value (bp
, TYPE_ARTIFICIAL (expr
), 1);
105 bp_pack_value (bp
, TREE_NO_WARNING (expr
), 1);
106 bp_pack_value (bp
, TREE_NOTHROW (expr
), 1);
107 bp_pack_value (bp
, TREE_STATIC (expr
), 1);
108 if (TREE_CODE (expr
) != TREE_BINFO
)
109 bp_pack_value (bp
, TREE_PRIVATE (expr
), 1);
111 bp_pack_value (bp
, 0, 1);
112 bp_pack_value (bp
, TREE_PROTECTED (expr
), 1);
113 bp_pack_value (bp
, TREE_DEPRECATED (expr
), 1);
116 if (AGGREGATE_TYPE_P (expr
))
117 bp_pack_value (bp
, TYPE_REVERSE_STORAGE_ORDER (expr
), 1);
119 bp_pack_value (bp
, TYPE_SATURATING (expr
), 1);
120 bp_pack_value (bp
, TYPE_ADDR_SPACE (expr
), 8);
122 else if (TREE_CODE (expr
) == BIT_FIELD_REF
|| TREE_CODE (expr
) == MEM_REF
)
124 bp_pack_value (bp
, REF_REVERSE_STORAGE_ORDER (expr
), 1);
125 bp_pack_value (bp
, 0, 8);
127 else if (TREE_CODE (expr
) == SSA_NAME
)
129 bp_pack_value (bp
, SSA_NAME_IS_DEFAULT_DEF (expr
), 1);
130 bp_pack_value (bp
, 0, 8);
132 else if (TREE_CODE (expr
) == CALL_EXPR
)
134 bp_pack_value (bp
, CALL_EXPR_BY_DESCRIPTOR (expr
), 1);
135 bp_pack_value (bp
, 0, 8);
138 bp_pack_value (bp
, 0, 9);
142 /* Pack all the non-pointer fields of the TS_INTEGER_CST structure of
143 expression EXPR into bitpack BP. */
146 pack_ts_int_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
149 /* Note that the number of elements has already been written out in
150 streamer_write_tree_header. */
151 for (i
= 0; i
< TREE_INT_CST_EXT_NUNITS (expr
); i
++)
152 bp_pack_var_len_int (bp
, TREE_INT_CST_ELT (expr
, i
));
156 /* Pack all the non-pointer fields of the TS_REAL_CST structure of
157 expression EXPR into bitpack BP. */
160 pack_ts_real_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
165 r
= TREE_REAL_CST (expr
);
166 bp_pack_value (bp
, r
.cl
, 2);
167 bp_pack_value (bp
, r
.decimal
, 1);
168 bp_pack_value (bp
, r
.sign
, 1);
169 bp_pack_value (bp
, r
.signalling
, 1);
170 bp_pack_value (bp
, r
.canonical
, 1);
171 bp_pack_value (bp
, r
.uexp
, EXP_BITS
);
172 for (i
= 0; i
< SIGSZ
; i
++)
173 bp_pack_value (bp
, r
.sig
[i
], HOST_BITS_PER_LONG
);
177 /* Pack all the non-pointer fields of the TS_FIXED_CST structure of
178 expression EXPR into bitpack BP. */
181 pack_ts_fixed_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
183 struct fixed_value fv
= TREE_FIXED_CST (expr
);
184 bp_pack_machine_mode (bp
, fv
.mode
);
185 bp_pack_var_len_int (bp
, fv
.data
.low
);
186 bp_pack_var_len_int (bp
, fv
.data
.high
);
189 /* Pack all the non-pointer fields of the TS_DECL_COMMON structure
190 of expression EXPR into bitpack BP. */
193 pack_ts_decl_common_value_fields (struct bitpack_d
*bp
, tree expr
)
195 bp_pack_machine_mode (bp
, DECL_MODE (expr
));
196 bp_pack_value (bp
, DECL_NONLOCAL (expr
), 1);
197 bp_pack_value (bp
, DECL_VIRTUAL_P (expr
), 1);
198 bp_pack_value (bp
, DECL_IGNORED_P (expr
), 1);
199 bp_pack_value (bp
, DECL_ABSTRACT_P (expr
), 1);
200 bp_pack_value (bp
, DECL_ARTIFICIAL (expr
), 1);
201 bp_pack_value (bp
, DECL_USER_ALIGN (expr
), 1);
202 bp_pack_value (bp
, DECL_PRESERVE_P (expr
), 1);
203 bp_pack_value (bp
, DECL_EXTERNAL (expr
), 1);
204 bp_pack_value (bp
, DECL_GIMPLE_REG_P (expr
), 1);
205 bp_pack_var_len_unsigned (bp
, DECL_ALIGN (expr
));
207 if (TREE_CODE (expr
) == LABEL_DECL
)
209 /* Note that we do not write LABEL_DECL_UID. The reader will
210 always assume an initial value of -1 so that the
211 label_to_block_map is recreated by gimple_set_bb. */
212 bp_pack_var_len_unsigned (bp
, EH_LANDING_PAD_NR (expr
));
215 else if (TREE_CODE (expr
) == FIELD_DECL
)
217 bp_pack_value (bp
, DECL_PACKED (expr
), 1);
218 bp_pack_value (bp
, DECL_NONADDRESSABLE_P (expr
), 1);
219 bp_pack_value (bp
, DECL_PADDING_P (expr
), 1);
220 bp_pack_value (bp
, expr
->decl_common
.off_align
, 8);
223 else if (VAR_P (expr
))
225 bp_pack_value (bp
, DECL_HAS_DEBUG_EXPR_P (expr
), 1);
226 bp_pack_value (bp
, DECL_NONLOCAL_FRAME (expr
), 1);
229 else if (TREE_CODE (expr
) == PARM_DECL
)
230 bp_pack_value (bp
, DECL_HIDDEN_STRING_LENGTH (expr
), 1);
232 if (TREE_CODE (expr
) == RESULT_DECL
233 || TREE_CODE (expr
) == PARM_DECL
236 bp_pack_value (bp
, DECL_BY_REFERENCE (expr
), 1);
237 if (VAR_P (expr
) || TREE_CODE (expr
) == PARM_DECL
)
238 bp_pack_value (bp
, DECL_HAS_VALUE_EXPR_P (expr
), 1);
243 /* Pack all the non-pointer fields of the TS_DECL_WRTL structure
244 of expression EXPR into bitpack BP. */
247 pack_ts_decl_wrtl_value_fields (struct bitpack_d
*bp
, tree expr
)
249 bp_pack_value (bp
, DECL_REGISTER (expr
), 1);
253 /* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
254 of expression EXPR into bitpack BP. */
257 pack_ts_decl_with_vis_value_fields (struct bitpack_d
*bp
, tree expr
)
259 bp_pack_value (bp
, DECL_COMMON (expr
), 1);
260 bp_pack_value (bp
, DECL_DLLIMPORT_P (expr
), 1);
261 bp_pack_value (bp
, DECL_WEAK (expr
), 1);
262 bp_pack_value (bp
, DECL_SEEN_IN_BIND_EXPR_P (expr
), 1);
263 bp_pack_value (bp
, DECL_COMDAT (expr
), 1);
264 bp_pack_value (bp
, DECL_VISIBILITY (expr
), 2);
265 bp_pack_value (bp
, DECL_VISIBILITY_SPECIFIED (expr
), 1);
269 bp_pack_value (bp
, DECL_HARD_REGISTER (expr
), 1);
270 /* DECL_IN_TEXT_SECTION is set during final asm output only. */
271 bp_pack_value (bp
, DECL_IN_CONSTANT_POOL (expr
), 1);
274 if (TREE_CODE (expr
) == FUNCTION_DECL
)
276 bp_pack_value (bp
, DECL_FINAL_P (expr
), 1);
277 bp_pack_value (bp
, DECL_CXX_CONSTRUCTOR_P (expr
), 1);
278 bp_pack_value (bp
, DECL_CXX_DESTRUCTOR_P (expr
), 1);
283 /* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure
284 of expression EXPR into bitpack BP. */
287 pack_ts_function_decl_value_fields (struct bitpack_d
*bp
, tree expr
)
289 bp_pack_enum (bp
, built_in_class
, BUILT_IN_LAST
,
290 DECL_BUILT_IN_CLASS (expr
));
291 bp_pack_value (bp
, DECL_STATIC_CONSTRUCTOR (expr
), 1);
292 bp_pack_value (bp
, DECL_STATIC_DESTRUCTOR (expr
), 1);
293 bp_pack_value (bp
, DECL_UNINLINABLE (expr
), 1);
294 bp_pack_value (bp
, DECL_POSSIBLY_INLINED (expr
), 1);
295 bp_pack_value (bp
, DECL_IS_NOVOPS (expr
), 1);
296 bp_pack_value (bp
, DECL_IS_RETURNS_TWICE (expr
), 1);
297 bp_pack_value (bp
, DECL_IS_MALLOC (expr
), 1);
298 bp_pack_value (bp
, DECL_IS_OPERATOR_NEW_P (expr
), 1);
299 bp_pack_value (bp
, DECL_IS_OPERATOR_DELETE_P (expr
), 1);
300 bp_pack_value (bp
, DECL_DECLARED_INLINE_P (expr
), 1);
301 bp_pack_value (bp
, DECL_STATIC_CHAIN (expr
), 1);
302 bp_pack_value (bp
, DECL_NO_INLINE_WARNING_P (expr
), 1);
303 bp_pack_value (bp
, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr
), 1);
304 bp_pack_value (bp
, DECL_NO_LIMIT_STACK (expr
), 1);
305 bp_pack_value (bp
, DECL_DISREGARD_INLINE_LIMITS (expr
), 1);
306 bp_pack_value (bp
, DECL_PURE_P (expr
), 1);
307 bp_pack_value (bp
, DECL_LOOPING_CONST_OR_PURE_P (expr
), 1);
308 if (DECL_BUILT_IN_CLASS (expr
) != NOT_BUILT_IN
)
309 bp_pack_value (bp
, DECL_UNCHECKED_FUNCTION_CODE (expr
), 32);
313 /* Pack all the non-pointer fields of the TS_TYPE_COMMON structure
314 of expression EXPR into bitpack BP. */
317 pack_ts_type_common_value_fields (struct bitpack_d
*bp
, tree expr
)
319 /* for VECTOR_TYPE, TYPE_MODE reevaluates the mode using target_flags
320 not necessary valid in a global context.
321 Use the raw value previously set by layout_type. */
322 bp_pack_machine_mode (bp
, TYPE_MODE_RAW (expr
));
323 /* TYPE_NO_FORCE_BLK is private to stor-layout and need
325 bp_pack_value (bp
, TYPE_PACKED (expr
), 1);
326 bp_pack_value (bp
, TYPE_RESTRICT (expr
), 1);
327 bp_pack_value (bp
, TYPE_USER_ALIGN (expr
), 1);
328 bp_pack_value (bp
, TYPE_READONLY (expr
), 1);
331 vla_p
= TYPE_LANG_FLAG_0 (TYPE_MAIN_VARIANT (expr
));
333 vla_p
= variably_modified_type_p (expr
, NULL_TREE
);
334 bp_pack_value (bp
, vla_p
, 1);
335 /* We used to stream TYPE_ALIAS_SET == 0 information to let frontends mark
336 types that are opaque for TBAA. This however did not work as intended,
337 because TYPE_ALIAS_SET == 0 was regularly lost in type merging. */
338 if (RECORD_OR_UNION_TYPE_P (expr
))
340 bp_pack_value (bp
, TYPE_TRANSPARENT_AGGR (expr
), 1);
341 bp_pack_value (bp
, TYPE_FINAL_P (expr
), 1);
342 bp_pack_value (bp
, TYPE_CXX_ODR_P (expr
), 1);
344 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
345 bp_pack_value (bp
, TYPE_NONALIASED_COMPONENT (expr
), 1);
346 if (TREE_CODE (expr
) == ARRAY_TYPE
|| TREE_CODE (expr
) == INTEGER_TYPE
)
347 bp_pack_value (bp
, TYPE_STRING_FLAG (expr
), 1);
348 if (AGGREGATE_TYPE_P (expr
))
349 bp_pack_value (bp
, TYPE_TYPELESS_STORAGE (expr
), 1);
350 bp_pack_value (bp
, TYPE_EMPTY_P (expr
), 1);
351 bp_pack_var_len_unsigned (bp
, TYPE_PRECISION (expr
));
352 bp_pack_var_len_unsigned (bp
, TYPE_ALIGN (expr
));
356 /* Pack all the non-pointer fields of the TS_BLOCK structure
357 of expression EXPR into bitpack BP. */
360 pack_ts_block_value_fields (struct output_block
*ob
,
361 struct bitpack_d
*bp
, tree expr
)
363 /* BLOCK_NUMBER is recomputed. */
364 /* Stream BLOCK_SOURCE_LOCATION for the limited cases we can handle - those
365 that represent inlined function scopes.
366 For the rest them on the floor instead of ICEing in dwarf2out.c. */
367 if (inlined_function_outer_scope_p (expr
))
368 stream_output_location (ob
, bp
, BLOCK_SOURCE_LOCATION (expr
));
370 stream_output_location (ob
, bp
, UNKNOWN_LOCATION
);
373 /* Pack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL structure
374 of expression EXPR into bitpack BP. */
377 pack_ts_translation_unit_decl_value_fields (struct output_block
*ob
,
378 struct bitpack_d
*bp
, tree expr
)
380 bp_pack_string (ob
, bp
, TRANSLATION_UNIT_LANGUAGE (expr
), true);
384 /* Pack all the non-pointer fields of the TS_OMP_CLAUSE structure
385 of expression EXPR into bitpack BP. */
388 pack_ts_omp_clause_value_fields (struct output_block
*ob
,
389 struct bitpack_d
*bp
, tree expr
)
391 stream_output_location (ob
, bp
, OMP_CLAUSE_LOCATION (expr
));
392 switch (OMP_CLAUSE_CODE (expr
))
394 case OMP_CLAUSE_DEFAULT
:
395 bp_pack_enum (bp
, omp_clause_default_kind
, OMP_CLAUSE_DEFAULT_LAST
,
396 OMP_CLAUSE_DEFAULT_KIND (expr
));
398 case OMP_CLAUSE_SCHEDULE
:
399 bp_pack_enum (bp
, omp_clause_schedule_kind
, OMP_CLAUSE_SCHEDULE_LAST
,
400 OMP_CLAUSE_SCHEDULE_KIND (expr
));
402 case OMP_CLAUSE_DEPEND
:
403 bp_pack_enum (bp
, omp_clause_depend_kind
, OMP_CLAUSE_DEPEND_LAST
,
404 OMP_CLAUSE_DEPEND_KIND (expr
));
407 bp_pack_enum (bp
, gomp_map_kind
, GOMP_MAP_LAST
,
408 OMP_CLAUSE_MAP_KIND (expr
));
410 case OMP_CLAUSE_PROC_BIND
:
411 bp_pack_enum (bp
, omp_clause_proc_bind_kind
, OMP_CLAUSE_PROC_BIND_LAST
,
412 OMP_CLAUSE_PROC_BIND_KIND (expr
));
414 case OMP_CLAUSE_REDUCTION
:
415 case OMP_CLAUSE_TASK_REDUCTION
:
416 case OMP_CLAUSE_IN_REDUCTION
:
417 bp_pack_enum (bp
, tree_code
, MAX_TREE_CODES
,
418 OMP_CLAUSE_REDUCTION_CODE (expr
));
426 /* Pack all the bitfields in EXPR into a bit pack. */
429 streamer_write_tree_bitfields (struct output_block
*ob
, tree expr
)
431 bitpack_d bp
= bitpack_create (ob
->main_stream
);
434 code
= TREE_CODE (expr
);
436 /* Note that all these functions are highly sensitive to changes in
437 the types and sizes of each of the fields being packed. */
438 pack_ts_base_value_fields (&bp
, expr
);
440 if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
441 pack_ts_int_cst_value_fields (&bp
, expr
);
443 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
444 pack_ts_real_cst_value_fields (&bp
, expr
);
446 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
447 pack_ts_fixed_cst_value_fields (&bp
, expr
);
449 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
450 stream_output_location (ob
, &bp
, DECL_SOURCE_LOCATION (expr
));
452 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
453 pack_ts_decl_common_value_fields (&bp
, expr
);
455 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
456 pack_ts_decl_wrtl_value_fields (&bp
, expr
);
458 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
459 pack_ts_decl_with_vis_value_fields (&bp
, expr
);
461 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
462 pack_ts_function_decl_value_fields (&bp
, expr
);
464 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
465 pack_ts_type_common_value_fields (&bp
, expr
);
467 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
469 stream_output_location (ob
, &bp
, EXPR_LOCATION (expr
));
471 || code
== TARGET_MEM_REF
)
473 bp_pack_value (&bp
, MR_DEPENDENCE_CLIQUE (expr
), sizeof (short) * 8);
474 if (MR_DEPENDENCE_CLIQUE (expr
) != 0)
475 bp_pack_value (&bp
, MR_DEPENDENCE_BASE (expr
), sizeof (short) * 8);
477 else if (code
== CALL_EXPR
)
478 bp_pack_enum (&bp
, internal_fn
, IFN_LAST
, CALL_EXPR_IFN (expr
));
481 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
482 pack_ts_block_value_fields (ob
, &bp
, expr
);
484 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
485 pack_ts_translation_unit_decl_value_fields (ob
, &bp
, expr
);
487 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
488 cl_optimization_stream_out (ob
, &bp
, TREE_OPTIMIZATION (expr
));
490 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
491 bp_pack_var_len_unsigned (&bp
, CONSTRUCTOR_NELTS (expr
));
493 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
)
494 /* Don't stream these when passing things to a different target. */
495 && !lto_stream_offload_p
)
496 cl_target_option_stream_out (ob
, &bp
, TREE_TARGET_OPTION (expr
));
498 if (code
== OMP_CLAUSE
)
499 pack_ts_omp_clause_value_fields (ob
, &bp
, expr
);
501 streamer_write_bitpack (&bp
);
505 /* Emit the chain of tree nodes starting at T. OB is the output block
506 to write to. REF_P is true if chain elements should be emitted
510 streamer_write_chain (struct output_block
*ob
, tree t
, bool ref_p
)
514 /* We avoid outputting external vars or functions by reference
515 to the global decls section as we do not want to have them
516 enter decl merging. We should not need to do this anymore because
517 free_lang_data removes them from block scopes. */
518 gcc_assert (!VAR_OR_FUNCTION_DECL_P (t
) || !DECL_EXTERNAL (t
));
519 stream_write_tree (ob
, t
, ref_p
);
524 /* Write a sentinel to terminate the chain. */
525 stream_write_tree (ob
, NULL_TREE
, ref_p
);
529 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
530 block OB. If REF_P is true, write a reference to EXPR's pointer
534 write_ts_common_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
536 if (TREE_CODE (expr
) != IDENTIFIER_NODE
)
537 stream_write_tree (ob
, TREE_TYPE (expr
), ref_p
);
541 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
542 block OB. If REF_P is true, write a reference to EXPR's pointer
546 write_ts_vector_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
548 /* Note that the number of elements for EXPR has already been emitted
549 in EXPR's header (see streamer_write_tree_header). */
550 unsigned int count
= vector_cst_encoded_nelts (expr
);
551 for (unsigned int i
= 0; i
< count
; ++i
)
552 stream_write_tree (ob
, VECTOR_CST_ENCODED_ELT (expr
, i
), ref_p
);
556 /* Write all pointer fields in the TS_POLY_INT_CST structure of EXPR to
557 output block OB. If REF_P is true, write a reference to EXPR's pointer
561 write_ts_poly_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
563 for (unsigned int i
= 0; i
< NUM_POLY_INT_COEFFS
; ++i
)
564 stream_write_tree (ob
, POLY_INT_CST_COEFF (expr
, i
), ref_p
);
568 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
569 block OB. If REF_P is true, write a reference to EXPR's pointer
573 write_ts_complex_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
575 stream_write_tree (ob
, TREE_REALPART (expr
), ref_p
);
576 stream_write_tree (ob
, TREE_IMAGPART (expr
), ref_p
);
580 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
581 to output block OB. If REF_P is true, write a reference to EXPR's
585 write_ts_decl_minimal_tree_pointers (struct output_block
*ob
, tree expr
,
588 /* Drop names that were created for anonymous entities. */
590 && TREE_CODE (DECL_NAME (expr
)) == IDENTIFIER_NODE
591 && IDENTIFIER_ANON_P (DECL_NAME (expr
)))
592 stream_write_tree (ob
, NULL_TREE
, ref_p
);
594 stream_write_tree (ob
, DECL_NAME (expr
), ref_p
);
595 if (TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
596 && ! DECL_CONTEXT (expr
))
597 stream_write_tree (ob
, (*all_translation_units
)[0], ref_p
);
599 stream_write_tree (ob
, DECL_CONTEXT (expr
), ref_p
);
603 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
604 output block OB. If REF_P is true, write a reference to EXPR's
608 write_ts_decl_common_tree_pointers (struct output_block
*ob
, tree expr
,
611 stream_write_tree (ob
, DECL_SIZE (expr
), ref_p
);
612 stream_write_tree (ob
, DECL_SIZE_UNIT (expr
), ref_p
);
614 /* Note, DECL_INITIAL is not handled here. Since DECL_INITIAL needs
615 special handling in LTO, it must be handled by streamer hooks. */
617 stream_write_tree (ob
, DECL_ATTRIBUTES (expr
), ref_p
);
619 /* On non-early-LTO enabled targets we claim we compiled with -g0
620 but dwarf2out still did its set_decl_origin_self game fooling
621 itself late. Und that here since we won't have access to the
622 early generated abstract DIEs. */
623 tree ao
= DECL_ABSTRACT_ORIGIN (expr
);
624 if (debug_info_level
== DINFO_LEVEL_NONE
627 stream_write_tree (ob
, ao
, ref_p
);
629 if ((VAR_P (expr
) || TREE_CODE (expr
) == PARM_DECL
)
630 && DECL_HAS_VALUE_EXPR_P (expr
))
631 stream_write_tree (ob
, DECL_VALUE_EXPR (expr
), ref_p
);
634 && DECL_HAS_DEBUG_EXPR_P (expr
))
635 stream_write_tree (ob
, DECL_DEBUG_EXPR (expr
), ref_p
);
639 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
640 EXPR to output block OB. If REF_P is true, write a reference to EXPR's
644 write_ts_decl_non_common_tree_pointers (struct output_block
*, tree
, bool)
649 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
650 to output block OB. If REF_P is true, write a reference to EXPR's
654 write_ts_decl_with_vis_tree_pointers (struct output_block
*ob
, tree expr
,
657 /* Make sure we don't inadvertently set the assembler name. */
658 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
659 stream_write_tree (ob
, DECL_ASSEMBLER_NAME (expr
), ref_p
);
661 stream_write_tree (ob
, NULL_TREE
, false);
665 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
666 output block OB. If REF_P is true, write a reference to EXPR's
670 write_ts_field_decl_tree_pointers (struct output_block
*ob
, tree expr
,
673 stream_write_tree (ob
, DECL_FIELD_OFFSET (expr
), ref_p
);
674 stream_write_tree (ob
, DECL_BIT_FIELD_TYPE (expr
), ref_p
);
675 stream_write_tree (ob
, DECL_BIT_FIELD_REPRESENTATIVE (expr
), ref_p
);
676 stream_write_tree (ob
, DECL_FIELD_BIT_OFFSET (expr
), ref_p
);
680 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
681 to output block OB. If REF_P is true, write a reference to EXPR's
685 write_ts_function_decl_tree_pointers (struct output_block
*ob
, tree expr
,
688 /* DECL_STRUCT_FUNCTION is handled by lto_output_function. */
689 stream_write_tree (ob
, DECL_FUNCTION_PERSONALITY (expr
), ref_p
);
690 /* Don't stream these when passing things to a different target. */
691 if (!lto_stream_offload_p
)
692 stream_write_tree (ob
, DECL_FUNCTION_SPECIFIC_TARGET (expr
), ref_p
);
693 stream_write_tree (ob
, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr
), ref_p
);
697 /* Write all pointer fields in the TS_TYPE_COMMON structure of EXPR to
698 output block OB. If REF_P is true, write a reference to EXPR's
702 write_ts_type_common_tree_pointers (struct output_block
*ob
, tree expr
,
705 stream_write_tree (ob
, TYPE_SIZE (expr
), ref_p
);
706 stream_write_tree (ob
, TYPE_SIZE_UNIT (expr
), ref_p
);
707 stream_write_tree (ob
, TYPE_ATTRIBUTES (expr
), ref_p
);
708 stream_write_tree (ob
, TYPE_NAME (expr
), ref_p
);
709 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
710 reconstructed during fixup. */
711 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
713 stream_write_tree (ob
, TYPE_MAIN_VARIANT (expr
), ref_p
);
714 stream_write_tree (ob
, TYPE_CONTEXT (expr
), ref_p
);
715 /* TYPE_CANONICAL is re-computed during type merging, so no need
716 to stream it here. */
717 /* Do not stream TYPE_STUB_DECL; it is not needed by LTO but currently
718 it cannot be freed by free_lang_data without triggering ICEs in
722 /* Write all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
723 to output block OB. If REF_P is true, write a reference to EXPR's
727 write_ts_type_non_common_tree_pointers (struct output_block
*ob
, tree expr
,
730 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
731 stream_write_tree (ob
, TYPE_VALUES (expr
), ref_p
);
732 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
733 stream_write_tree (ob
, TYPE_DOMAIN (expr
), ref_p
);
734 else if (RECORD_OR_UNION_TYPE_P (expr
))
735 streamer_write_chain (ob
, TYPE_FIELDS (expr
), ref_p
);
736 else if (TREE_CODE (expr
) == FUNCTION_TYPE
737 || TREE_CODE (expr
) == METHOD_TYPE
)
738 stream_write_tree (ob
, TYPE_ARG_TYPES (expr
), ref_p
);
740 if (!POINTER_TYPE_P (expr
))
741 stream_write_tree (ob
, TYPE_MIN_VALUE_RAW (expr
), ref_p
);
742 stream_write_tree (ob
, TYPE_MAX_VALUE_RAW (expr
), ref_p
);
746 /* Write all pointer fields in the TS_LIST structure of EXPR to output
747 block OB. If REF_P is true, write a reference to EXPR's pointer
751 write_ts_list_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
753 stream_write_tree (ob
, TREE_PURPOSE (expr
), ref_p
);
754 stream_write_tree (ob
, TREE_VALUE (expr
), ref_p
);
755 stream_write_tree (ob
, TREE_CHAIN (expr
), ref_p
);
759 /* Write all pointer fields in the TS_VEC structure of EXPR to output
760 block OB. If REF_P is true, write a reference to EXPR's pointer
764 write_ts_vec_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
768 /* Note that the number of slots for EXPR has already been emitted
769 in EXPR's header (see streamer_write_tree_header). */
770 for (i
= 0; i
< TREE_VEC_LENGTH (expr
); i
++)
771 stream_write_tree (ob
, TREE_VEC_ELT (expr
, i
), ref_p
);
775 /* Write all pointer fields in the TS_EXP structure of EXPR to output
776 block OB. If REF_P is true, write a reference to EXPR's pointer
780 write_ts_exp_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
784 for (i
= 0; i
< TREE_OPERAND_LENGTH (expr
); i
++)
785 stream_write_tree (ob
, TREE_OPERAND (expr
, i
), ref_p
);
786 stream_write_tree (ob
, TREE_BLOCK (expr
), ref_p
);
790 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
791 block OB. If REF_P is true, write a reference to EXPR's pointer
795 write_ts_block_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
797 streamer_write_chain (ob
, BLOCK_VARS (expr
), ref_p
);
799 stream_write_tree (ob
, BLOCK_SUPERCONTEXT (expr
), ref_p
);
800 stream_write_tree (ob
, BLOCK_ABSTRACT_ORIGIN (expr
), ref_p
);
802 /* Do not stream BLOCK_NONLOCALIZED_VARS. We cannot handle debug information
803 for early inlined BLOCKs so drop it on the floor instead of ICEing in
806 /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
809 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
810 list is re-constructed from BLOCK_SUPERCONTEXT. */
814 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
815 block OB. If REF_P is true, write a reference to EXPR's pointer
819 write_ts_binfo_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
824 /* Note that the number of BINFO slots has already been emitted in
825 EXPR's header (see streamer_write_tree_header) because this length
826 is needed to build the empty BINFO node on the reader side. */
827 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr
), i
, t
)
828 stream_write_tree (ob
, t
, ref_p
);
829 stream_write_tree (ob
, NULL_TREE
, false);
831 stream_write_tree (ob
, BINFO_OFFSET (expr
), ref_p
);
832 stream_write_tree (ob
, BINFO_VTABLE (expr
), ref_p
);
834 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX,
835 BINFO_BASE_ACCESSES and BINFO_VPTR_INDEX; these are used by C++ FE only. */
839 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
840 output block OB. If REF_P is true, write a reference to EXPR's
844 write_ts_constructor_tree_pointers (struct output_block
*ob
, tree expr
,
850 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr
), i
, index
, value
)
852 stream_write_tree (ob
, index
, ref_p
);
853 stream_write_tree (ob
, value
, ref_p
);
858 /* Write all pointer fields in the TS_OMP_CLAUSE structure of EXPR
859 to output block OB. If REF_P is true, write a reference to EXPR's
863 write_ts_omp_clause_tree_pointers (struct output_block
*ob
, tree expr
,
867 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (expr
)]; i
++)
868 stream_write_tree (ob
, OMP_CLAUSE_OPERAND (expr
, i
), ref_p
);
869 switch (OMP_CLAUSE_CODE (expr
))
871 case OMP_CLAUSE_REDUCTION
:
872 case OMP_CLAUSE_TASK_REDUCTION
:
873 case OMP_CLAUSE_IN_REDUCTION
:
874 /* We don't stream these right now, handle it if streaming
875 of them is needed. */
876 gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (expr
) == NULL
);
877 gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (expr
) == NULL
);
882 stream_write_tree (ob
, OMP_CLAUSE_CHAIN (expr
), ref_p
);
886 /* Write all pointer fields in EXPR to output block OB. If REF_P is true,
887 the leaves of EXPR are emitted as references. */
890 streamer_write_tree_body (struct output_block
*ob
, tree expr
, bool ref_p
)
894 lto_stats
.num_tree_bodies_output
++;
896 code
= TREE_CODE (expr
);
898 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
899 write_ts_common_tree_pointers (ob
, expr
, ref_p
);
901 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
902 write_ts_vector_tree_pointers (ob
, expr
, ref_p
);
904 if (CODE_CONTAINS_STRUCT (code
, TS_POLY_INT_CST
))
905 write_ts_poly_tree_pointers (ob
, expr
, ref_p
);
907 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
908 write_ts_complex_tree_pointers (ob
, expr
, ref_p
);
910 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
911 write_ts_decl_minimal_tree_pointers (ob
, expr
, ref_p
);
913 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
914 write_ts_decl_common_tree_pointers (ob
, expr
, ref_p
);
916 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
917 write_ts_decl_non_common_tree_pointers (ob
, expr
, ref_p
);
919 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
920 write_ts_decl_with_vis_tree_pointers (ob
, expr
, ref_p
);
922 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
923 write_ts_field_decl_tree_pointers (ob
, expr
, ref_p
);
925 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
926 write_ts_function_decl_tree_pointers (ob
, expr
, ref_p
);
928 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
929 write_ts_type_common_tree_pointers (ob
, expr
, ref_p
);
931 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
932 write_ts_type_non_common_tree_pointers (ob
, expr
, ref_p
);
934 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
935 write_ts_list_tree_pointers (ob
, expr
, ref_p
);
937 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
938 write_ts_vec_tree_pointers (ob
, expr
, ref_p
);
940 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
941 write_ts_exp_tree_pointers (ob
, expr
, ref_p
);
943 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
944 write_ts_block_tree_pointers (ob
, expr
, ref_p
);
946 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
947 write_ts_binfo_tree_pointers (ob
, expr
, ref_p
);
949 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
950 write_ts_constructor_tree_pointers (ob
, expr
, ref_p
);
952 if (code
== OMP_CLAUSE
)
953 write_ts_omp_clause_tree_pointers (ob
, expr
, ref_p
);
957 /* Emit header information for tree EXPR to output block OB. The header
958 contains everything needed to instantiate an empty skeleton for
959 EXPR on the reading side. IX is the index into the streamer cache
960 where EXPR is stored. */
963 streamer_write_tree_header (struct output_block
*ob
, tree expr
)
968 /* We should not see any tree nodes not handled by the streamer. */
969 code
= TREE_CODE (expr
);
971 /* The header of a tree node consists of its tag, the size of
972 the node, and any other information needed to instantiate
973 EXPR on the reading side (such as the number of slots in
974 variable sized nodes). */
975 tag
= lto_tree_code_to_tag (code
);
976 streamer_write_record_start (ob
, tag
);
978 /* The text in strings and identifiers are completely emitted in
980 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
981 streamer_write_string_cst (ob
, ob
->main_stream
, expr
);
982 else if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
983 write_identifier (ob
, ob
->main_stream
, expr
);
984 else if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
986 bitpack_d bp
= bitpack_create (ob
->main_stream
);
987 bp_pack_value (&bp
, VECTOR_CST_LOG2_NPATTERNS (expr
), 8);
988 bp_pack_value (&bp
, VECTOR_CST_NELTS_PER_PATTERN (expr
), 8);
989 streamer_write_bitpack (&bp
);
991 else if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
992 streamer_write_hwi (ob
, TREE_VEC_LENGTH (expr
));
993 else if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
994 streamer_write_uhwi (ob
, BINFO_N_BASE_BINFOS (expr
));
995 else if (TREE_CODE (expr
) == CALL_EXPR
)
996 streamer_write_uhwi (ob
, call_expr_nargs (expr
));
997 else if (TREE_CODE (expr
) == OMP_CLAUSE
)
998 streamer_write_uhwi (ob
, OMP_CLAUSE_CODE (expr
));
999 else if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
1001 gcc_checking_assert (TREE_INT_CST_NUNITS (expr
));
1002 streamer_write_uhwi (ob
, TREE_INT_CST_NUNITS (expr
));
1003 streamer_write_uhwi (ob
, TREE_INT_CST_EXT_NUNITS (expr
));
1008 /* Emit the integer constant CST to output block OB. If REF_P is true,
1009 CST's type will be emitted as a reference. */
1012 streamer_write_integer_cst (struct output_block
*ob
, tree cst
, bool ref_p
)
1015 int len
= TREE_INT_CST_NUNITS (cst
);
1016 gcc_assert (!TREE_OVERFLOW (cst
));
1017 streamer_write_record_start (ob
, LTO_integer_cst
);
1018 stream_write_tree (ob
, TREE_TYPE (cst
), ref_p
);
1019 /* We're effectively streaming a non-sign-extended wide_int here,
1020 so there's no need to stream TREE_INT_CST_EXT_NUNITS or any
1021 array members beyond LEN. We'll recreate the tree from the
1022 wide_int and the type. */
1023 streamer_write_uhwi (ob
, len
);
1024 for (i
= 0; i
< len
; i
++)
1025 streamer_write_hwi (ob
, TREE_INT_CST_ELT (cst
, i
));