1 /* Routines for emitting trees to a file stream.
3 Copyright (C) 2011-2018 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);
133 bp_pack_value (bp
, 0, 9);
137 /* Pack all the non-pointer fields of the TS_INTEGER_CST structure of
138 expression EXPR into bitpack BP. */
141 pack_ts_int_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
144 /* Note that the number of elements has already been written out in
145 streamer_write_tree_header. */
146 for (i
= 0; i
< TREE_INT_CST_EXT_NUNITS (expr
); i
++)
147 bp_pack_var_len_int (bp
, TREE_INT_CST_ELT (expr
, i
));
151 /* Pack all the non-pointer fields of the TS_REAL_CST structure of
152 expression EXPR into bitpack BP. */
155 pack_ts_real_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
160 r
= TREE_REAL_CST (expr
);
161 bp_pack_value (bp
, r
.cl
, 2);
162 bp_pack_value (bp
, r
.decimal
, 1);
163 bp_pack_value (bp
, r
.sign
, 1);
164 bp_pack_value (bp
, r
.signalling
, 1);
165 bp_pack_value (bp
, r
.canonical
, 1);
166 bp_pack_value (bp
, r
.uexp
, EXP_BITS
);
167 for (i
= 0; i
< SIGSZ
; i
++)
168 bp_pack_value (bp
, r
.sig
[i
], HOST_BITS_PER_LONG
);
172 /* Pack all the non-pointer fields of the TS_FIXED_CST structure of
173 expression EXPR into bitpack BP. */
176 pack_ts_fixed_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
178 struct fixed_value fv
= TREE_FIXED_CST (expr
);
179 bp_pack_machine_mode (bp
, fv
.mode
);
180 bp_pack_var_len_int (bp
, fv
.data
.low
);
181 bp_pack_var_len_int (bp
, fv
.data
.high
);
184 /* Pack all the non-pointer fields of the TS_DECL_COMMON structure
185 of expression EXPR into bitpack BP. */
188 pack_ts_decl_common_value_fields (struct bitpack_d
*bp
, tree expr
)
190 bp_pack_machine_mode (bp
, DECL_MODE (expr
));
191 bp_pack_value (bp
, DECL_NONLOCAL (expr
), 1);
192 bp_pack_value (bp
, DECL_VIRTUAL_P (expr
), 1);
193 bp_pack_value (bp
, DECL_IGNORED_P (expr
), 1);
194 bp_pack_value (bp
, DECL_ABSTRACT_P (expr
), 1);
195 bp_pack_value (bp
, DECL_ARTIFICIAL (expr
), 1);
196 bp_pack_value (bp
, DECL_USER_ALIGN (expr
), 1);
197 bp_pack_value (bp
, DECL_PRESERVE_P (expr
), 1);
198 bp_pack_value (bp
, DECL_EXTERNAL (expr
), 1);
199 bp_pack_value (bp
, DECL_GIMPLE_REG_P (expr
), 1);
200 bp_pack_var_len_unsigned (bp
, DECL_ALIGN (expr
));
202 if (TREE_CODE (expr
) == LABEL_DECL
)
204 /* Note that we do not write LABEL_DECL_UID. The reader will
205 always assume an initial value of -1 so that the
206 label_to_block_map is recreated by gimple_set_bb. */
207 bp_pack_var_len_unsigned (bp
, EH_LANDING_PAD_NR (expr
));
210 if (TREE_CODE (expr
) == FIELD_DECL
)
212 bp_pack_value (bp
, DECL_PACKED (expr
), 1);
213 bp_pack_value (bp
, DECL_NONADDRESSABLE_P (expr
), 1);
214 bp_pack_value (bp
, DECL_PADDING_P (expr
), 1);
215 bp_pack_value (bp
, expr
->decl_common
.off_align
, 8);
220 bp_pack_value (bp
, DECL_HAS_DEBUG_EXPR_P (expr
), 1);
221 bp_pack_value (bp
, DECL_NONLOCAL_FRAME (expr
), 1);
224 if (TREE_CODE (expr
) == RESULT_DECL
225 || TREE_CODE (expr
) == PARM_DECL
228 bp_pack_value (bp
, DECL_BY_REFERENCE (expr
), 1);
229 if (VAR_P (expr
) || TREE_CODE (expr
) == PARM_DECL
)
230 bp_pack_value (bp
, DECL_HAS_VALUE_EXPR_P (expr
), 1);
235 /* Pack all the non-pointer fields of the TS_DECL_WRTL structure
236 of expression EXPR into bitpack BP. */
239 pack_ts_decl_wrtl_value_fields (struct bitpack_d
*bp
, tree expr
)
241 bp_pack_value (bp
, DECL_REGISTER (expr
), 1);
245 /* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
246 of expression EXPR into bitpack BP. */
249 pack_ts_decl_with_vis_value_fields (struct bitpack_d
*bp
, tree expr
)
251 bp_pack_value (bp
, DECL_COMMON (expr
), 1);
252 bp_pack_value (bp
, DECL_DLLIMPORT_P (expr
), 1);
253 bp_pack_value (bp
, DECL_WEAK (expr
), 1);
254 bp_pack_value (bp
, DECL_SEEN_IN_BIND_EXPR_P (expr
), 1);
255 bp_pack_value (bp
, DECL_COMDAT (expr
), 1);
256 bp_pack_value (bp
, DECL_VISIBILITY (expr
), 2);
257 bp_pack_value (bp
, DECL_VISIBILITY_SPECIFIED (expr
), 1);
261 bp_pack_value (bp
, DECL_HARD_REGISTER (expr
), 1);
262 /* DECL_IN_TEXT_SECTION is set during final asm output only. */
263 bp_pack_value (bp
, DECL_IN_CONSTANT_POOL (expr
), 1);
266 if (TREE_CODE (expr
) == FUNCTION_DECL
)
268 bp_pack_value (bp
, DECL_FINAL_P (expr
), 1);
269 bp_pack_value (bp
, DECL_CXX_CONSTRUCTOR_P (expr
), 1);
270 bp_pack_value (bp
, DECL_CXX_DESTRUCTOR_P (expr
), 1);
275 /* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure
276 of expression EXPR into bitpack BP. */
279 pack_ts_function_decl_value_fields (struct bitpack_d
*bp
, tree expr
)
281 bp_pack_enum (bp
, built_in_class
, BUILT_IN_LAST
,
282 DECL_BUILT_IN_CLASS (expr
));
283 bp_pack_value (bp
, DECL_STATIC_CONSTRUCTOR (expr
), 1);
284 bp_pack_value (bp
, DECL_STATIC_DESTRUCTOR (expr
), 1);
285 bp_pack_value (bp
, DECL_UNINLINABLE (expr
), 1);
286 bp_pack_value (bp
, DECL_POSSIBLY_INLINED (expr
), 1);
287 bp_pack_value (bp
, DECL_IS_NOVOPS (expr
), 1);
288 bp_pack_value (bp
, DECL_IS_RETURNS_TWICE (expr
), 1);
289 bp_pack_value (bp
, DECL_IS_MALLOC (expr
), 1);
290 bp_pack_value (bp
, DECL_IS_OPERATOR_NEW (expr
), 1);
291 bp_pack_value (bp
, DECL_DECLARED_INLINE_P (expr
), 1);
292 bp_pack_value (bp
, DECL_STATIC_CHAIN (expr
), 1);
293 bp_pack_value (bp
, DECL_NO_INLINE_WARNING_P (expr
), 1);
294 bp_pack_value (bp
, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr
), 1);
295 bp_pack_value (bp
, DECL_NO_LIMIT_STACK (expr
), 1);
296 bp_pack_value (bp
, DECL_DISREGARD_INLINE_LIMITS (expr
), 1);
297 bp_pack_value (bp
, DECL_PURE_P (expr
), 1);
298 bp_pack_value (bp
, DECL_LOOPING_CONST_OR_PURE_P (expr
), 1);
299 if (DECL_BUILT_IN_CLASS (expr
) != NOT_BUILT_IN
)
300 bp_pack_value (bp
, DECL_FUNCTION_CODE (expr
), 12);
304 /* Pack all the non-pointer fields of the TS_TYPE_COMMON structure
305 of expression EXPR into bitpack BP. */
308 pack_ts_type_common_value_fields (struct bitpack_d
*bp
, tree expr
)
310 /* for VECTOR_TYPE, TYPE_MODE reevaluates the mode using target_flags
311 not necessary valid in a global context.
312 Use the raw value previously set by layout_type. */
313 bp_pack_machine_mode (bp
, TYPE_MODE_RAW (expr
));
314 bp_pack_value (bp
, TYPE_STRING_FLAG (expr
), 1);
315 /* TYPE_NO_FORCE_BLK is private to stor-layout and need
317 bp_pack_value (bp
, TYPE_NEEDS_CONSTRUCTING (expr
), 1);
318 bp_pack_value (bp
, TYPE_PACKED (expr
), 1);
319 bp_pack_value (bp
, TYPE_RESTRICT (expr
), 1);
320 bp_pack_value (bp
, TYPE_USER_ALIGN (expr
), 1);
321 bp_pack_value (bp
, TYPE_READONLY (expr
), 1);
322 /* We used to stream TYPE_ALIAS_SET == 0 information to let frontends mark
323 types that are opaque for TBAA. This however did not work as intended,
324 because TYPE_ALIAS_SET == 0 was regularly lost in type merging. */
325 if (RECORD_OR_UNION_TYPE_P (expr
))
327 bp_pack_value (bp
, TYPE_TRANSPARENT_AGGR (expr
), 1);
328 bp_pack_value (bp
, TYPE_FINAL_P (expr
), 1);
330 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
331 bp_pack_value (bp
, TYPE_NONALIASED_COMPONENT (expr
), 1);
332 if (AGGREGATE_TYPE_P (expr
))
333 bp_pack_value (bp
, TYPE_TYPELESS_STORAGE (expr
), 1);
334 bp_pack_value (bp
, TYPE_EMPTY_P (expr
), 1);
335 bp_pack_var_len_unsigned (bp
, TYPE_PRECISION (expr
));
336 bp_pack_var_len_unsigned (bp
, TYPE_ALIGN (expr
));
340 /* Pack all the non-pointer fields of the TS_BLOCK structure
341 of expression EXPR into bitpack BP. */
344 pack_ts_block_value_fields (struct output_block
*ob
,
345 struct bitpack_d
*bp
, tree expr
)
347 bp_pack_value (bp
, BLOCK_ABSTRACT (expr
), 1);
348 /* BLOCK_NUMBER is recomputed. */
349 /* Stream BLOCK_SOURCE_LOCATION for the limited cases we can handle - those
350 that represent inlined function scopes.
351 For the rest them on the floor instead of ICEing in dwarf2out.c. */
352 if (inlined_function_outer_scope_p (expr
))
353 stream_output_location (ob
, bp
, BLOCK_SOURCE_LOCATION (expr
));
355 stream_output_location (ob
, bp
, UNKNOWN_LOCATION
);
358 /* Pack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL structure
359 of expression EXPR into bitpack BP. */
362 pack_ts_translation_unit_decl_value_fields (struct output_block
*ob
,
363 struct bitpack_d
*bp
, tree expr
)
365 bp_pack_string (ob
, bp
, TRANSLATION_UNIT_LANGUAGE (expr
), true);
369 /* Pack all the non-pointer fields of the TS_OMP_CLAUSE structure
370 of expression EXPR into bitpack BP. */
373 pack_ts_omp_clause_value_fields (struct output_block
*ob
,
374 struct bitpack_d
*bp
, tree expr
)
376 stream_output_location (ob
, bp
, OMP_CLAUSE_LOCATION (expr
));
377 switch (OMP_CLAUSE_CODE (expr
))
379 case OMP_CLAUSE_DEFAULT
:
380 bp_pack_enum (bp
, omp_clause_default_kind
, OMP_CLAUSE_DEFAULT_LAST
,
381 OMP_CLAUSE_DEFAULT_KIND (expr
));
383 case OMP_CLAUSE_SCHEDULE
:
384 bp_pack_enum (bp
, omp_clause_schedule_kind
, OMP_CLAUSE_SCHEDULE_LAST
,
385 OMP_CLAUSE_SCHEDULE_KIND (expr
));
387 case OMP_CLAUSE_DEPEND
:
388 bp_pack_enum (bp
, omp_clause_depend_kind
, OMP_CLAUSE_DEPEND_LAST
,
389 OMP_CLAUSE_DEPEND_KIND (expr
));
392 bp_pack_enum (bp
, gomp_map_kind
, GOMP_MAP_LAST
,
393 OMP_CLAUSE_MAP_KIND (expr
));
395 case OMP_CLAUSE_PROC_BIND
:
396 bp_pack_enum (bp
, omp_clause_proc_bind_kind
, OMP_CLAUSE_PROC_BIND_LAST
,
397 OMP_CLAUSE_PROC_BIND_KIND (expr
));
399 case OMP_CLAUSE_REDUCTION
:
400 bp_pack_enum (bp
, tree_code
, MAX_TREE_CODES
,
401 OMP_CLAUSE_REDUCTION_CODE (expr
));
409 /* Pack all the bitfields in EXPR into a bit pack. */
412 streamer_write_tree_bitfields (struct output_block
*ob
, tree expr
)
414 bitpack_d bp
= bitpack_create (ob
->main_stream
);
417 code
= TREE_CODE (expr
);
419 /* Note that all these functions are highly sensitive to changes in
420 the types and sizes of each of the fields being packed. */
421 pack_ts_base_value_fields (&bp
, expr
);
423 if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
424 pack_ts_int_cst_value_fields (&bp
, expr
);
426 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
427 pack_ts_real_cst_value_fields (&bp
, expr
);
429 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
430 pack_ts_fixed_cst_value_fields (&bp
, expr
);
432 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
433 stream_output_location (ob
, &bp
, DECL_SOURCE_LOCATION (expr
));
435 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
436 pack_ts_decl_common_value_fields (&bp
, expr
);
438 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
439 pack_ts_decl_wrtl_value_fields (&bp
, expr
);
441 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
442 pack_ts_decl_with_vis_value_fields (&bp
, expr
);
444 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
445 pack_ts_function_decl_value_fields (&bp
, expr
);
447 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
448 pack_ts_type_common_value_fields (&bp
, expr
);
450 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
452 stream_output_location (ob
, &bp
, EXPR_LOCATION (expr
));
454 || code
== TARGET_MEM_REF
)
456 bp_pack_value (&bp
, MR_DEPENDENCE_CLIQUE (expr
), sizeof (short) * 8);
457 if (MR_DEPENDENCE_CLIQUE (expr
) != 0)
458 bp_pack_value (&bp
, MR_DEPENDENCE_BASE (expr
), sizeof (short) * 8);
462 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
463 pack_ts_block_value_fields (ob
, &bp
, expr
);
465 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
466 pack_ts_translation_unit_decl_value_fields (ob
, &bp
, expr
);
468 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
469 cl_optimization_stream_out (ob
, &bp
, TREE_OPTIMIZATION (expr
));
471 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
472 bp_pack_var_len_unsigned (&bp
, CONSTRUCTOR_NELTS (expr
));
474 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
)
475 /* Don't stream these when passing things to a different target. */
476 && !lto_stream_offload_p
)
477 cl_target_option_stream_out (ob
, &bp
, TREE_TARGET_OPTION (expr
));
479 if (code
== OMP_CLAUSE
)
480 pack_ts_omp_clause_value_fields (ob
, &bp
, expr
);
482 streamer_write_bitpack (&bp
);
486 /* Emit the chain of tree nodes starting at T. OB is the output block
487 to write to. REF_P is true if chain elements should be emitted
491 streamer_write_chain (struct output_block
*ob
, tree t
, bool ref_p
)
495 /* We avoid outputting external vars or functions by reference
496 to the global decls section as we do not want to have them
497 enter decl merging. This is, of course, only for the call
498 for streaming BLOCK_VARS, but other callers are safe.
499 See also lto-streamer-out.c:DFS_write_tree_body. */
500 if (VAR_OR_FUNCTION_DECL_P (t
)
501 && DECL_EXTERNAL (t
))
502 stream_write_tree_shallow_non_ref (ob
, t
, ref_p
);
504 stream_write_tree (ob
, t
, ref_p
);
509 /* Write a sentinel to terminate the chain. */
510 stream_write_tree (ob
, NULL_TREE
, ref_p
);
514 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
515 block OB. If REF_P is true, write a reference to EXPR's pointer
519 write_ts_common_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
521 if (TREE_CODE (expr
) != IDENTIFIER_NODE
)
522 stream_write_tree (ob
, TREE_TYPE (expr
), ref_p
);
526 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
527 block OB. If REF_P is true, write a reference to EXPR's pointer
531 write_ts_vector_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
533 /* Note that the number of elements for EXPR has already been emitted
534 in EXPR's header (see streamer_write_tree_header). */
535 unsigned int count
= vector_cst_encoded_nelts (expr
);
536 for (unsigned int i
= 0; i
< count
; ++i
)
537 stream_write_tree (ob
, VECTOR_CST_ENCODED_ELT (expr
, i
), ref_p
);
541 /* Write all pointer fields in the TS_POLY_INT_CST structure of EXPR to
542 output block OB. If REF_P is true, write a reference to EXPR's pointer
546 write_ts_poly_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
548 for (unsigned int i
= 0; i
< NUM_POLY_INT_COEFFS
; ++i
)
549 stream_write_tree (ob
, POLY_INT_CST_COEFF (expr
, i
), ref_p
);
553 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
554 block OB. If REF_P is true, write a reference to EXPR's pointer
558 write_ts_complex_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
560 stream_write_tree (ob
, TREE_REALPART (expr
), ref_p
);
561 stream_write_tree (ob
, TREE_IMAGPART (expr
), ref_p
);
565 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
566 to output block OB. If REF_P is true, write a reference to EXPR's
570 write_ts_decl_minimal_tree_pointers (struct output_block
*ob
, tree expr
,
573 /* Drop names that were created for anonymous entities. */
575 && TREE_CODE (DECL_NAME (expr
)) == IDENTIFIER_NODE
576 && anon_aggrname_p (DECL_NAME (expr
)))
577 stream_write_tree (ob
, NULL_TREE
, ref_p
);
579 stream_write_tree (ob
, DECL_NAME (expr
), ref_p
);
580 if (TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
581 && ! DECL_CONTEXT (expr
))
582 stream_write_tree (ob
, (*all_translation_units
)[0], ref_p
);
584 stream_write_tree (ob
, DECL_CONTEXT (expr
), ref_p
);
588 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
589 output block OB. If REF_P is true, write a reference to EXPR's
593 write_ts_decl_common_tree_pointers (struct output_block
*ob
, tree expr
,
596 stream_write_tree (ob
, DECL_SIZE (expr
), ref_p
);
597 stream_write_tree (ob
, DECL_SIZE_UNIT (expr
), ref_p
);
599 /* Note, DECL_INITIAL is not handled here. Since DECL_INITIAL needs
600 special handling in LTO, it must be handled by streamer hooks. */
602 stream_write_tree (ob
, DECL_ATTRIBUTES (expr
), ref_p
);
603 stream_write_tree (ob
, DECL_ABSTRACT_ORIGIN (expr
), ref_p
);
605 if ((VAR_P (expr
) || TREE_CODE (expr
) == PARM_DECL
)
606 && DECL_HAS_VALUE_EXPR_P (expr
))
607 stream_write_tree (ob
, DECL_VALUE_EXPR (expr
), ref_p
);
610 && DECL_HAS_DEBUG_EXPR_P (expr
))
611 stream_write_tree (ob
, DECL_DEBUG_EXPR (expr
), ref_p
);
615 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
616 EXPR to output block OB. If REF_P is true, write a reference to EXPR's
620 write_ts_decl_non_common_tree_pointers (struct output_block
*ob
, tree expr
,
623 if (TREE_CODE (expr
) == TYPE_DECL
)
624 stream_write_tree (ob
, DECL_ORIGINAL_TYPE (expr
), ref_p
);
628 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
629 to output block OB. If REF_P is true, write a reference to EXPR's
633 write_ts_decl_with_vis_tree_pointers (struct output_block
*ob
, tree expr
,
636 /* Make sure we don't inadvertently set the assembler name. */
637 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
638 stream_write_tree (ob
, DECL_ASSEMBLER_NAME (expr
), ref_p
);
640 stream_write_tree (ob
, NULL_TREE
, false);
644 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
645 output block OB. If REF_P is true, write a reference to EXPR's
649 write_ts_field_decl_tree_pointers (struct output_block
*ob
, tree expr
,
652 stream_write_tree (ob
, DECL_FIELD_OFFSET (expr
), ref_p
);
653 stream_write_tree (ob
, DECL_BIT_FIELD_TYPE (expr
), ref_p
);
654 stream_write_tree (ob
, DECL_BIT_FIELD_REPRESENTATIVE (expr
), ref_p
);
655 stream_write_tree (ob
, DECL_FIELD_BIT_OFFSET (expr
), ref_p
);
656 stream_write_tree (ob
, DECL_FCONTEXT (expr
), ref_p
);
660 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
661 to output block OB. If REF_P is true, write a reference to EXPR's
665 write_ts_function_decl_tree_pointers (struct output_block
*ob
, tree expr
,
668 stream_write_tree (ob
, DECL_VINDEX (expr
), ref_p
);
669 /* DECL_STRUCT_FUNCTION is handled by lto_output_function. */
670 stream_write_tree (ob
, DECL_FUNCTION_PERSONALITY (expr
), ref_p
);
671 /* Don't stream these when passing things to a different target. */
672 if (!lto_stream_offload_p
)
673 stream_write_tree (ob
, DECL_FUNCTION_SPECIFIC_TARGET (expr
), ref_p
);
674 stream_write_tree (ob
, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr
), ref_p
);
678 /* Write all pointer fields in the TS_TYPE_COMMON structure of EXPR to
679 output block OB. If REF_P is true, write a reference to EXPR's
683 write_ts_type_common_tree_pointers (struct output_block
*ob
, tree expr
,
686 stream_write_tree (ob
, TYPE_SIZE (expr
), ref_p
);
687 stream_write_tree (ob
, TYPE_SIZE_UNIT (expr
), ref_p
);
688 stream_write_tree (ob
, TYPE_ATTRIBUTES (expr
), ref_p
);
689 stream_write_tree (ob
, TYPE_NAME (expr
), ref_p
);
690 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
691 reconstructed during fixup. */
692 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
694 stream_write_tree (ob
, TYPE_MAIN_VARIANT (expr
), ref_p
);
695 stream_write_tree (ob
, TYPE_CONTEXT (expr
), ref_p
);
696 /* TYPE_CANONICAL is re-computed during type merging, so no need
697 to stream it here. */
698 stream_write_tree (ob
, TYPE_STUB_DECL (expr
), ref_p
);
701 /* Write all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
702 to output block OB. If REF_P is true, write a reference to EXPR's
706 write_ts_type_non_common_tree_pointers (struct output_block
*ob
, tree expr
,
709 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
710 stream_write_tree (ob
, TYPE_VALUES (expr
), ref_p
);
711 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
712 stream_write_tree (ob
, TYPE_DOMAIN (expr
), ref_p
);
713 else if (RECORD_OR_UNION_TYPE_P (expr
))
714 streamer_write_chain (ob
, TYPE_FIELDS (expr
), ref_p
);
715 else if (TREE_CODE (expr
) == FUNCTION_TYPE
716 || TREE_CODE (expr
) == METHOD_TYPE
)
717 stream_write_tree (ob
, TYPE_ARG_TYPES (expr
), ref_p
);
719 if (!POINTER_TYPE_P (expr
))
720 stream_write_tree (ob
, TYPE_MIN_VALUE_RAW (expr
), ref_p
);
721 stream_write_tree (ob
, TYPE_MAX_VALUE_RAW (expr
), ref_p
);
725 /* Write all pointer fields in the TS_LIST structure of EXPR to output
726 block OB. If REF_P is true, write a reference to EXPR's pointer
730 write_ts_list_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
732 stream_write_tree (ob
, TREE_PURPOSE (expr
), ref_p
);
733 stream_write_tree (ob
, TREE_VALUE (expr
), ref_p
);
734 stream_write_tree (ob
, TREE_CHAIN (expr
), ref_p
);
738 /* Write all pointer fields in the TS_VEC structure of EXPR to output
739 block OB. If REF_P is true, write a reference to EXPR's pointer
743 write_ts_vec_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
747 /* Note that the number of slots for EXPR has already been emitted
748 in EXPR's header (see streamer_write_tree_header). */
749 for (i
= 0; i
< TREE_VEC_LENGTH (expr
); i
++)
750 stream_write_tree (ob
, TREE_VEC_ELT (expr
, i
), ref_p
);
754 /* Write all pointer fields in the TS_EXP structure of EXPR to output
755 block OB. If REF_P is true, write a reference to EXPR's pointer
759 write_ts_exp_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
763 for (i
= 0; i
< TREE_OPERAND_LENGTH (expr
); i
++)
764 stream_write_tree (ob
, TREE_OPERAND (expr
, i
), ref_p
);
765 stream_write_tree (ob
, TREE_BLOCK (expr
), ref_p
);
769 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
770 block OB. If REF_P is true, write a reference to EXPR's pointer
774 write_ts_block_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
776 streamer_write_chain (ob
, BLOCK_VARS (expr
), ref_p
);
778 stream_write_tree (ob
, BLOCK_SUPERCONTEXT (expr
), ref_p
);
779 stream_write_tree (ob
, BLOCK_ABSTRACT_ORIGIN (expr
), ref_p
);
781 /* Do not stream BLOCK_NONLOCALIZED_VARS. We cannot handle debug information
782 for early inlined BLOCKs so drop it on the floor instead of ICEing in
785 /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
788 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
789 list is re-constructed from BLOCK_SUPERCONTEXT. */
793 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
794 block OB. If REF_P is true, write a reference to EXPR's pointer
798 write_ts_binfo_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
803 /* Note that the number of BINFO slots has already been emitted in
804 EXPR's header (see streamer_write_tree_header) because this length
805 is needed to build the empty BINFO node on the reader side. */
806 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr
), i
, t
)
807 stream_write_tree (ob
, t
, ref_p
);
808 stream_write_tree (ob
, NULL_TREE
, false);
810 stream_write_tree (ob
, BINFO_OFFSET (expr
), ref_p
);
811 stream_write_tree (ob
, BINFO_VTABLE (expr
), ref_p
);
813 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX,
814 BINFO_BASE_ACCESSES and BINFO_VPTR_INDEX; these are used by C++ FE only. */
818 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
819 output block OB. If REF_P is true, write a reference to EXPR's
823 write_ts_constructor_tree_pointers (struct output_block
*ob
, tree expr
,
829 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr
), i
, index
, value
)
831 stream_write_tree (ob
, index
, ref_p
);
832 stream_write_tree (ob
, value
, ref_p
);
837 /* Write all pointer fields in the TS_OMP_CLAUSE structure of EXPR
838 to output block OB. If REF_P is true, write a reference to EXPR's
842 write_ts_omp_clause_tree_pointers (struct output_block
*ob
, tree expr
,
846 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (expr
)]; i
++)
847 stream_write_tree (ob
, OMP_CLAUSE_OPERAND (expr
, i
), ref_p
);
848 if (OMP_CLAUSE_CODE (expr
) == OMP_CLAUSE_REDUCTION
)
850 /* We don't stream these right now, handle it if streaming
851 of them is needed. */
852 gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (expr
) == NULL
);
853 gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (expr
) == NULL
);
855 stream_write_tree (ob
, OMP_CLAUSE_CHAIN (expr
), ref_p
);
859 /* Write all pointer fields in EXPR to output block OB. If REF_P is true,
860 the leaves of EXPR are emitted as references. */
863 streamer_write_tree_body (struct output_block
*ob
, tree expr
, bool ref_p
)
867 lto_stats
.num_tree_bodies_output
++;
869 code
= TREE_CODE (expr
);
871 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
872 write_ts_common_tree_pointers (ob
, expr
, ref_p
);
874 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
875 write_ts_vector_tree_pointers (ob
, expr
, ref_p
);
877 if (CODE_CONTAINS_STRUCT (code
, TS_POLY_INT_CST
))
878 write_ts_poly_tree_pointers (ob
, expr
, ref_p
);
880 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
881 write_ts_complex_tree_pointers (ob
, expr
, ref_p
);
883 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
884 write_ts_decl_minimal_tree_pointers (ob
, expr
, ref_p
);
886 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
887 write_ts_decl_common_tree_pointers (ob
, expr
, ref_p
);
889 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
890 write_ts_decl_non_common_tree_pointers (ob
, expr
, ref_p
);
892 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
893 write_ts_decl_with_vis_tree_pointers (ob
, expr
, ref_p
);
895 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
896 write_ts_field_decl_tree_pointers (ob
, expr
, ref_p
);
898 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
899 write_ts_function_decl_tree_pointers (ob
, expr
, ref_p
);
901 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
902 write_ts_type_common_tree_pointers (ob
, expr
, ref_p
);
904 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
905 write_ts_type_non_common_tree_pointers (ob
, expr
, ref_p
);
907 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
908 write_ts_list_tree_pointers (ob
, expr
, ref_p
);
910 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
911 write_ts_vec_tree_pointers (ob
, expr
, ref_p
);
913 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
914 write_ts_exp_tree_pointers (ob
, expr
, ref_p
);
916 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
917 write_ts_block_tree_pointers (ob
, expr
, ref_p
);
919 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
920 write_ts_binfo_tree_pointers (ob
, expr
, ref_p
);
922 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
923 write_ts_constructor_tree_pointers (ob
, expr
, ref_p
);
925 if (code
== OMP_CLAUSE
)
926 write_ts_omp_clause_tree_pointers (ob
, expr
, ref_p
);
930 /* Emit header information for tree EXPR to output block OB. The header
931 contains everything needed to instantiate an empty skeleton for
932 EXPR on the reading side. IX is the index into the streamer cache
933 where EXPR is stored. */
936 streamer_write_tree_header (struct output_block
*ob
, tree expr
)
941 /* We should not see any tree nodes not handled by the streamer. */
942 code
= TREE_CODE (expr
);
944 /* The header of a tree node consists of its tag, the size of
945 the node, and any other information needed to instantiate
946 EXPR on the reading side (such as the number of slots in
947 variable sized nodes). */
948 tag
= lto_tree_code_to_tag (code
);
949 streamer_write_record_start (ob
, tag
);
951 /* The text in strings and identifiers are completely emitted in
953 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
954 streamer_write_string_cst (ob
, ob
->main_stream
, expr
);
955 else if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
956 write_identifier (ob
, ob
->main_stream
, expr
);
957 else if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
959 bitpack_d bp
= bitpack_create (ob
->main_stream
);
960 bp_pack_value (&bp
, VECTOR_CST_LOG2_NPATTERNS (expr
), 8);
961 bp_pack_value (&bp
, VECTOR_CST_NELTS_PER_PATTERN (expr
), 8);
962 streamer_write_bitpack (&bp
);
964 else if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
965 streamer_write_hwi (ob
, TREE_VEC_LENGTH (expr
));
966 else if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
967 streamer_write_uhwi (ob
, BINFO_N_BASE_BINFOS (expr
));
968 else if (TREE_CODE (expr
) == CALL_EXPR
)
969 streamer_write_uhwi (ob
, call_expr_nargs (expr
));
970 else if (TREE_CODE (expr
) == OMP_CLAUSE
)
971 streamer_write_uhwi (ob
, OMP_CLAUSE_CODE (expr
));
972 else if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
974 gcc_checking_assert (TREE_INT_CST_NUNITS (expr
));
975 streamer_write_uhwi (ob
, TREE_INT_CST_NUNITS (expr
));
976 streamer_write_uhwi (ob
, TREE_INT_CST_EXT_NUNITS (expr
));
981 /* Emit the integer constant CST to output block OB. If REF_P is true,
982 CST's type will be emitted as a reference. */
985 streamer_write_integer_cst (struct output_block
*ob
, tree cst
, bool ref_p
)
988 int len
= TREE_INT_CST_NUNITS (cst
);
989 gcc_assert (!TREE_OVERFLOW (cst
));
990 streamer_write_record_start (ob
, LTO_integer_cst
);
991 stream_write_tree (ob
, TREE_TYPE (cst
), ref_p
);
992 /* We're effectively streaming a non-sign-extended wide_int here,
993 so there's no need to stream TREE_INT_CST_EXT_NUNITS or any
994 array members beyond LEN. We'll recreate the tree from the
995 wide_int and the type. */
996 streamer_write_uhwi (ob
, len
);
997 for (i
= 0; i
< len
; i
++)
998 streamer_write_hwi (ob
, TREE_INT_CST_ELT (cst
, i
));