1 /* Routines for emitting trees to a file stream.
3 Copyright (C) 2011-2015 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"
28 #include "hard-reg-set.h"
29 #include "diagnostic.h"
31 #include "fold-const.h"
32 #include "stor-layout.h"
33 #include "internal-fn.h"
35 #include "tree-streamer.h"
36 #include "data-streamer.h"
37 #include "streamer-hooks.h"
38 #include "gomp-constants.h"
41 /* Output the STRING constant to the string
42 table in OB. Then put the index onto the INDEX_STREAM. */
45 streamer_write_string_cst (struct output_block
*ob
,
46 struct lto_output_stream
*index_stream
,
49 streamer_write_string_with_length (ob
, index_stream
,
50 string
? TREE_STRING_POINTER (string
)
52 string
? TREE_STRING_LENGTH (string
) : 0,
57 /* Output the identifier ID to the string
58 table in OB. Then put the index onto the INDEX_STREAM. */
61 write_identifier (struct output_block
*ob
,
62 struct lto_output_stream
*index_stream
,
65 streamer_write_string_with_length (ob
, index_stream
,
66 IDENTIFIER_POINTER (id
),
67 IDENTIFIER_LENGTH (id
),
72 /* Pack all the non-pointer fields of the TS_BASE structure of
73 expression EXPR into bitpack BP. */
76 pack_ts_base_value_fields (struct bitpack_d
*bp
, tree expr
)
78 bp_pack_value (bp
, TREE_CODE (expr
), 16);
81 bp_pack_value (bp
, TREE_SIDE_EFFECTS (expr
), 1);
82 bp_pack_value (bp
, TREE_CONSTANT (expr
), 1);
83 bp_pack_value (bp
, TREE_READONLY (expr
), 1);
85 /* TREE_PUBLIC is used on types to indicate that the type
86 has a TYPE_CACHED_VALUES vector. This is not streamed out,
87 so we skip it here. */
88 bp_pack_value (bp
, TREE_PUBLIC (expr
), 1);
91 bp_pack_value (bp
, 0, 4);
92 bp_pack_value (bp
, TREE_ADDRESSABLE (expr
), 1);
93 bp_pack_value (bp
, TREE_THIS_VOLATILE (expr
), 1);
95 bp_pack_value (bp
, DECL_UNSIGNED (expr
), 1);
96 else if (TYPE_P (expr
))
97 bp_pack_value (bp
, TYPE_UNSIGNED (expr
), 1);
99 bp_pack_value (bp
, 0, 1);
100 /* We write debug info two times, do not confuse the second one.
101 The only relevant TREE_ASM_WRITTEN use is on SSA names. */
102 bp_pack_value (bp
, (TREE_CODE (expr
) != SSA_NAME
103 ? 0 : TREE_ASM_WRITTEN (expr
)), 1);
105 bp_pack_value (bp
, TYPE_ARTIFICIAL (expr
), 1);
107 bp_pack_value (bp
, TREE_NO_WARNING (expr
), 1);
108 bp_pack_value (bp
, TREE_NOTHROW (expr
), 1);
109 bp_pack_value (bp
, TREE_STATIC (expr
), 1);
110 if (TREE_CODE (expr
) != TREE_BINFO
)
111 bp_pack_value (bp
, TREE_PRIVATE (expr
), 1);
113 bp_pack_value (bp
, 0, 1);
114 bp_pack_value (bp
, TREE_PROTECTED (expr
), 1);
115 bp_pack_value (bp
, TREE_DEPRECATED (expr
), 1);
118 bp_pack_value (bp
, TYPE_SATURATING (expr
), 1);
119 bp_pack_value (bp
, TYPE_ADDR_SPACE (expr
), 8);
121 else if (TREE_CODE (expr
) == SSA_NAME
)
123 bp_pack_value (bp
, SSA_NAME_IS_DEFAULT_DEF (expr
), 1);
124 bp_pack_value (bp
, 0, 8);
127 bp_pack_value (bp
, 0, 9);
131 /* Pack all the non-pointer fields of the TS_INTEGER_CST structure of
132 expression EXPR into bitpack BP. */
135 pack_ts_int_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
138 /* Note that the number of elements has already been written out in
139 streamer_write_tree_header. */
140 for (i
= 0; i
< TREE_INT_CST_EXT_NUNITS (expr
); i
++)
141 bp_pack_var_len_int (bp
, TREE_INT_CST_ELT (expr
, i
));
145 /* Pack all the non-pointer fields of the TS_REAL_CST structure of
146 expression EXPR into bitpack BP. */
149 pack_ts_real_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
154 r
= TREE_REAL_CST (expr
);
155 bp_pack_value (bp
, r
.cl
, 2);
156 bp_pack_value (bp
, r
.decimal
, 1);
157 bp_pack_value (bp
, r
.sign
, 1);
158 bp_pack_value (bp
, r
.signalling
, 1);
159 bp_pack_value (bp
, r
.canonical
, 1);
160 bp_pack_value (bp
, r
.uexp
, EXP_BITS
);
161 for (i
= 0; i
< SIGSZ
; i
++)
162 bp_pack_value (bp
, r
.sig
[i
], HOST_BITS_PER_LONG
);
166 /* Pack all the non-pointer fields of the TS_FIXED_CST structure of
167 expression EXPR into bitpack BP. */
170 pack_ts_fixed_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
172 struct fixed_value fv
= TREE_FIXED_CST (expr
);
173 bp_pack_machine_mode (bp
, fv
.mode
);
174 bp_pack_var_len_int (bp
, fv
.data
.low
);
175 bp_pack_var_len_int (bp
, fv
.data
.high
);
178 /* Pack all the non-pointer fields of the TS_DECL_COMMON structure
179 of expression EXPR into bitpack BP. */
182 pack_ts_decl_common_value_fields (struct bitpack_d
*bp
, tree expr
)
184 bp_pack_machine_mode (bp
, DECL_MODE (expr
));
185 bp_pack_value (bp
, DECL_NONLOCAL (expr
), 1);
186 bp_pack_value (bp
, DECL_VIRTUAL_P (expr
), 1);
187 bp_pack_value (bp
, DECL_IGNORED_P (expr
), 1);
188 bp_pack_value (bp
, DECL_ABSTRACT_P (expr
), 1);
189 bp_pack_value (bp
, DECL_ARTIFICIAL (expr
), 1);
190 bp_pack_value (bp
, DECL_USER_ALIGN (expr
), 1);
191 bp_pack_value (bp
, DECL_PRESERVE_P (expr
), 1);
192 bp_pack_value (bp
, DECL_EXTERNAL (expr
), 1);
193 bp_pack_value (bp
, DECL_GIMPLE_REG_P (expr
), 1);
194 bp_pack_var_len_unsigned (bp
, DECL_ALIGN (expr
));
196 if (TREE_CODE (expr
) == LABEL_DECL
)
198 /* Note that we do not write LABEL_DECL_UID. The reader will
199 always assume an initial value of -1 so that the
200 label_to_block_map is recreated by gimple_set_bb. */
201 bp_pack_var_len_unsigned (bp
, EH_LANDING_PAD_NR (expr
));
204 if (TREE_CODE (expr
) == FIELD_DECL
)
206 bp_pack_value (bp
, DECL_PACKED (expr
), 1);
207 bp_pack_value (bp
, DECL_NONADDRESSABLE_P (expr
), 1);
208 bp_pack_value (bp
, expr
->decl_common
.off_align
, 8);
211 if (TREE_CODE (expr
) == VAR_DECL
)
213 bp_pack_value (bp
, DECL_HAS_DEBUG_EXPR_P (expr
), 1);
214 bp_pack_value (bp
, DECL_NONLOCAL_FRAME (expr
), 1);
217 if (TREE_CODE (expr
) == RESULT_DECL
218 || TREE_CODE (expr
) == PARM_DECL
219 || TREE_CODE (expr
) == VAR_DECL
)
221 bp_pack_value (bp
, DECL_BY_REFERENCE (expr
), 1);
222 if (TREE_CODE (expr
) == VAR_DECL
223 || TREE_CODE (expr
) == PARM_DECL
)
224 bp_pack_value (bp
, DECL_HAS_VALUE_EXPR_P (expr
), 1);
229 /* Pack all the non-pointer fields of the TS_DECL_WRTL structure
230 of expression EXPR into bitpack BP. */
233 pack_ts_decl_wrtl_value_fields (struct bitpack_d
*bp
, tree expr
)
235 bp_pack_value (bp
, DECL_REGISTER (expr
), 1);
239 /* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
240 of expression EXPR into bitpack BP. */
243 pack_ts_decl_with_vis_value_fields (struct bitpack_d
*bp
, tree expr
)
245 bp_pack_value (bp
, DECL_COMMON (expr
), 1);
246 bp_pack_value (bp
, DECL_DLLIMPORT_P (expr
), 1);
247 bp_pack_value (bp
, DECL_WEAK (expr
), 1);
248 bp_pack_value (bp
, DECL_SEEN_IN_BIND_EXPR_P (expr
), 1);
249 bp_pack_value (bp
, DECL_COMDAT (expr
), 1);
250 bp_pack_value (bp
, DECL_VISIBILITY (expr
), 2);
251 bp_pack_value (bp
, DECL_VISIBILITY_SPECIFIED (expr
), 1);
253 if (TREE_CODE (expr
) == VAR_DECL
)
255 bp_pack_value (bp
, DECL_HARD_REGISTER (expr
), 1);
256 /* DECL_IN_TEXT_SECTION is set during final asm output only. */
257 bp_pack_value (bp
, DECL_IN_CONSTANT_POOL (expr
), 1);
260 if (TREE_CODE (expr
) == FUNCTION_DECL
)
262 bp_pack_value (bp
, DECL_FINAL_P (expr
), 1);
263 bp_pack_value (bp
, DECL_CXX_CONSTRUCTOR_P (expr
), 1);
264 bp_pack_value (bp
, DECL_CXX_DESTRUCTOR_P (expr
), 1);
269 /* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure
270 of expression EXPR into bitpack BP. */
273 pack_ts_function_decl_value_fields (struct bitpack_d
*bp
, tree expr
)
275 /* For normal/md builtins we only write the class and code, so they
276 should never be handled here. */
277 gcc_assert (!streamer_handle_as_builtin_p (expr
));
279 bp_pack_enum (bp
, built_in_class
, BUILT_IN_LAST
,
280 DECL_BUILT_IN_CLASS (expr
));
281 bp_pack_value (bp
, DECL_STATIC_CONSTRUCTOR (expr
), 1);
282 bp_pack_value (bp
, DECL_STATIC_DESTRUCTOR (expr
), 1);
283 bp_pack_value (bp
, DECL_UNINLINABLE (expr
), 1);
284 bp_pack_value (bp
, DECL_POSSIBLY_INLINED (expr
), 1);
285 bp_pack_value (bp
, DECL_IS_NOVOPS (expr
), 1);
286 bp_pack_value (bp
, DECL_IS_RETURNS_TWICE (expr
), 1);
287 bp_pack_value (bp
, DECL_IS_MALLOC (expr
), 1);
288 bp_pack_value (bp
, DECL_IS_OPERATOR_NEW (expr
), 1);
289 bp_pack_value (bp
, DECL_DECLARED_INLINE_P (expr
), 1);
290 bp_pack_value (bp
, DECL_STATIC_CHAIN (expr
), 1);
291 bp_pack_value (bp
, DECL_NO_INLINE_WARNING_P (expr
), 1);
292 bp_pack_value (bp
, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr
), 1);
293 bp_pack_value (bp
, DECL_NO_LIMIT_STACK (expr
), 1);
294 bp_pack_value (bp
, DECL_DISREGARD_INLINE_LIMITS (expr
), 1);
295 bp_pack_value (bp
, DECL_PURE_P (expr
), 1);
296 bp_pack_value (bp
, DECL_LOOPING_CONST_OR_PURE_P (expr
), 1);
297 if (DECL_BUILT_IN_CLASS (expr
) != NOT_BUILT_IN
)
298 bp_pack_value (bp
, DECL_FUNCTION_CODE (expr
), 12);
302 /* Pack all the non-pointer fields of the TS_TYPE_COMMON structure
303 of expression EXPR into bitpack BP. */
306 pack_ts_type_common_value_fields (struct bitpack_d
*bp
, tree expr
)
308 bp_pack_machine_mode (bp
, TYPE_MODE (expr
));
309 bp_pack_value (bp
, TYPE_STRING_FLAG (expr
), 1);
310 /* TYPE_NO_FORCE_BLK is private to stor-layout and need
312 bp_pack_value (bp
, TYPE_NEEDS_CONSTRUCTING (expr
), 1);
313 if (RECORD_OR_UNION_TYPE_P (expr
))
315 bp_pack_value (bp
, TYPE_TRANSPARENT_AGGR (expr
), 1);
316 bp_pack_value (bp
, TYPE_FINAL_P (expr
), 1);
318 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
319 bp_pack_value (bp
, TYPE_NONALIASED_COMPONENT (expr
), 1);
320 bp_pack_value (bp
, TYPE_PACKED (expr
), 1);
321 bp_pack_value (bp
, TYPE_RESTRICT (expr
), 1);
322 bp_pack_value (bp
, TYPE_USER_ALIGN (expr
), 1);
323 bp_pack_value (bp
, TYPE_READONLY (expr
), 1);
324 bp_pack_var_len_unsigned (bp
, TYPE_PRECISION (expr
));
325 bp_pack_var_len_unsigned (bp
, TYPE_ALIGN (expr
));
326 /* Make sure to preserve the fact whether the frontend would assign
327 alias-set zero to this type. */
328 bp_pack_var_len_int (bp
, (TYPE_ALIAS_SET (expr
) == 0
330 && get_alias_set (expr
) == 0)) ? 0 : -1);
334 /* Pack all the non-pointer fields of the TS_BLOCK structure
335 of expression EXPR into bitpack BP. */
338 pack_ts_block_value_fields (struct output_block
*ob
,
339 struct bitpack_d
*bp
, tree expr
)
341 bp_pack_value (bp
, BLOCK_ABSTRACT (expr
), 1);
342 /* BLOCK_NUMBER is recomputed. */
343 /* Stream BLOCK_SOURCE_LOCATION for the limited cases we can handle - those
344 that represent inlined function scopes.
345 For the rest them on the floor instead of ICEing in dwarf2out.c. */
346 if (inlined_function_outer_scope_p (expr
))
347 stream_output_location (ob
, bp
, BLOCK_SOURCE_LOCATION (expr
));
349 stream_output_location (ob
, bp
, UNKNOWN_LOCATION
);
352 /* Pack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL structure
353 of expression EXPR into bitpack BP. */
356 pack_ts_translation_unit_decl_value_fields (struct output_block
*ob
,
357 struct bitpack_d
*bp
, tree expr
)
359 bp_pack_string (ob
, bp
, TRANSLATION_UNIT_LANGUAGE (expr
), true);
363 /* Pack all the non-pointer fields of the TS_OMP_CLAUSE structure
364 of expression EXPR into bitpack BP. */
367 pack_ts_omp_clause_value_fields (struct output_block
*ob
,
368 struct bitpack_d
*bp
, tree expr
)
370 stream_output_location (ob
, bp
, OMP_CLAUSE_LOCATION (expr
));
371 switch (OMP_CLAUSE_CODE (expr
))
373 case OMP_CLAUSE_DEFAULT
:
374 bp_pack_enum (bp
, omp_clause_default_kind
, OMP_CLAUSE_DEFAULT_LAST
,
375 OMP_CLAUSE_DEFAULT_KIND (expr
));
377 case OMP_CLAUSE_SCHEDULE
:
378 bp_pack_enum (bp
, omp_clause_schedule_kind
, OMP_CLAUSE_SCHEDULE_LAST
,
379 OMP_CLAUSE_SCHEDULE_KIND (expr
));
381 case OMP_CLAUSE_DEPEND
:
382 bp_pack_enum (bp
, omp_clause_depend_kind
, OMP_CLAUSE_DEPEND_LAST
,
383 OMP_CLAUSE_DEPEND_KIND (expr
));
386 bp_pack_enum (bp
, gomp_map_kind
, GOMP_MAP_LAST
,
387 OMP_CLAUSE_MAP_KIND (expr
));
389 case OMP_CLAUSE_PROC_BIND
:
390 bp_pack_enum (bp
, omp_clause_proc_bind_kind
, OMP_CLAUSE_PROC_BIND_LAST
,
391 OMP_CLAUSE_PROC_BIND_KIND (expr
));
393 case OMP_CLAUSE_REDUCTION
:
394 bp_pack_enum (bp
, tree_code
, MAX_TREE_CODES
,
395 OMP_CLAUSE_REDUCTION_CODE (expr
));
403 /* Pack all the bitfields in EXPR into a bit pack. */
406 streamer_write_tree_bitfields (struct output_block
*ob
, tree expr
)
408 bitpack_d bp
= bitpack_create (ob
->main_stream
);
411 code
= TREE_CODE (expr
);
413 /* Note that all these functions are highly sensitive to changes in
414 the types and sizes of each of the fields being packed. */
415 pack_ts_base_value_fields (&bp
, expr
);
417 if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
418 pack_ts_int_cst_value_fields (&bp
, expr
);
420 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
421 pack_ts_real_cst_value_fields (&bp
, expr
);
423 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
424 pack_ts_fixed_cst_value_fields (&bp
, expr
);
426 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
427 stream_output_location (ob
, &bp
, DECL_SOURCE_LOCATION (expr
));
429 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
430 pack_ts_decl_common_value_fields (&bp
, expr
);
432 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
433 pack_ts_decl_wrtl_value_fields (&bp
, expr
);
435 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
436 pack_ts_decl_with_vis_value_fields (&bp
, expr
);
438 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
439 pack_ts_function_decl_value_fields (&bp
, expr
);
441 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
442 pack_ts_type_common_value_fields (&bp
, expr
);
444 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
446 stream_output_location (ob
, &bp
, EXPR_LOCATION (expr
));
448 || code
== TARGET_MEM_REF
)
450 bp_pack_value (&bp
, MR_DEPENDENCE_CLIQUE (expr
), sizeof (short) * 8);
451 if (MR_DEPENDENCE_CLIQUE (expr
) != 0)
452 bp_pack_value (&bp
, MR_DEPENDENCE_BASE (expr
), sizeof (short) * 8);
456 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
457 pack_ts_block_value_fields (ob
, &bp
, expr
);
459 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
460 pack_ts_translation_unit_decl_value_fields (ob
, &bp
, expr
);
462 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
463 cl_optimization_stream_out (&bp
, TREE_OPTIMIZATION (expr
));
465 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
466 bp_pack_var_len_unsigned (&bp
, vec_safe_length (BINFO_BASE_ACCESSES (expr
)));
468 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
469 bp_pack_var_len_unsigned (&bp
, CONSTRUCTOR_NELTS (expr
));
471 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
)
472 /* Don't stream these when passing things to a different target. */
473 && !lto_stream_offload_p
)
474 cl_target_option_stream_out (ob
, &bp
, TREE_TARGET_OPTION (expr
));
476 if (code
== OMP_CLAUSE
)
477 pack_ts_omp_clause_value_fields (ob
, &bp
, expr
);
479 streamer_write_bitpack (&bp
);
483 /* Write the code and class of builtin EXPR to output block OB. IX is
484 the index into the streamer cache where EXPR is stored.*/
487 streamer_write_builtin (struct output_block
*ob
, tree expr
)
489 gcc_assert (streamer_handle_as_builtin_p (expr
));
491 if (DECL_BUILT_IN_CLASS (expr
) == BUILT_IN_MD
492 && !targetm
.builtin_decl
)
493 sorry ("tree bytecode streams do not support machine specific builtin "
494 "functions on this target");
496 streamer_write_record_start (ob
, LTO_builtin_decl
);
497 streamer_write_enum (ob
->main_stream
, built_in_class
, BUILT_IN_LAST
,
498 DECL_BUILT_IN_CLASS (expr
));
499 streamer_write_uhwi (ob
, DECL_FUNCTION_CODE (expr
));
501 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
503 /* When the assembler name of a builtin gets a user name,
504 the new name is always prefixed with '*' by
505 set_builtin_user_assembler_name. So, to prevent the
506 reader side from adding a second '*', we omit it here. */
507 const char *str
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (expr
));
508 if (strlen (str
) > 1 && str
[0] == '*')
509 streamer_write_string (ob
, ob
->main_stream
, &str
[1], true);
511 streamer_write_string (ob
, ob
->main_stream
, NULL
, true);
514 streamer_write_string (ob
, ob
->main_stream
, NULL
, true);
518 /* Emit the chain of tree nodes starting at T. OB is the output block
519 to write to. REF_P is true if chain elements should be emitted
523 streamer_write_chain (struct output_block
*ob
, tree t
, bool ref_p
)
527 /* We avoid outputting external vars or functions by reference
528 to the global decls section as we do not want to have them
529 enter decl merging. This is, of course, only for the call
530 for streaming BLOCK_VARS, but other callers are safe.
531 See also lto-streamer-out.c:DFS_write_tree_body. */
532 if (VAR_OR_FUNCTION_DECL_P (t
)
533 && DECL_EXTERNAL (t
))
534 stream_write_tree_shallow_non_ref (ob
, t
, ref_p
);
536 stream_write_tree (ob
, t
, ref_p
);
541 /* Write a sentinel to terminate the chain. */
542 stream_write_tree (ob
, NULL_TREE
, ref_p
);
546 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
547 block OB. If REF_P is true, write a reference to EXPR's pointer
551 write_ts_common_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
553 if (TREE_CODE (expr
) != IDENTIFIER_NODE
)
554 stream_write_tree (ob
, TREE_TYPE (expr
), ref_p
);
558 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
559 block OB. If REF_P is true, write a reference to EXPR's pointer
563 write_ts_vector_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
566 /* Note that the number of elements for EXPR has already been emitted
567 in EXPR's header (see streamer_write_tree_header). */
568 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
569 stream_write_tree (ob
, VECTOR_CST_ELT (expr
, i
), ref_p
);
573 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
574 block OB. If REF_P is true, write a reference to EXPR's pointer
578 write_ts_complex_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
580 stream_write_tree (ob
, TREE_REALPART (expr
), ref_p
);
581 stream_write_tree (ob
, TREE_IMAGPART (expr
), ref_p
);
585 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
586 to output block OB. If REF_P is true, write a reference to EXPR's
590 write_ts_decl_minimal_tree_pointers (struct output_block
*ob
, tree expr
,
593 /* Drop names that were created for anonymous entities. */
595 && TREE_CODE (DECL_NAME (expr
)) == IDENTIFIER_NODE
596 && anon_aggrname_p (DECL_NAME (expr
)))
597 stream_write_tree (ob
, NULL_TREE
, ref_p
);
599 stream_write_tree (ob
, DECL_NAME (expr
), ref_p
);
600 stream_write_tree (ob
, DECL_CONTEXT (expr
), ref_p
);
604 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
605 output block OB. If REF_P is true, write a reference to EXPR's
609 write_ts_decl_common_tree_pointers (struct output_block
*ob
, tree expr
,
612 stream_write_tree (ob
, DECL_SIZE (expr
), ref_p
);
613 stream_write_tree (ob
, DECL_SIZE_UNIT (expr
), ref_p
);
615 /* Note, DECL_INITIAL is not handled here. Since DECL_INITIAL needs
616 special handling in LTO, it must be handled by streamer hooks. */
618 stream_write_tree (ob
, DECL_ATTRIBUTES (expr
), ref_p
);
620 /* Do not stream DECL_ABSTRACT_ORIGIN. We cannot handle debug information
621 for early inlining so drop it on the floor instead of ICEing in
624 if ((TREE_CODE (expr
) == VAR_DECL
625 || TREE_CODE (expr
) == PARM_DECL
)
626 && DECL_HAS_VALUE_EXPR_P (expr
))
627 stream_write_tree (ob
, DECL_VALUE_EXPR (expr
), ref_p
);
629 if (TREE_CODE (expr
) == VAR_DECL
)
630 stream_write_tree (ob
, DECL_DEBUG_EXPR (expr
), ref_p
);
634 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
635 EXPR to output block OB. If REF_P is true, write a reference to EXPR's
639 write_ts_decl_non_common_tree_pointers (struct output_block
*ob
, tree expr
,
642 if (TREE_CODE (expr
) == TYPE_DECL
)
643 stream_write_tree (ob
, DECL_ORIGINAL_TYPE (expr
), ref_p
);
647 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
648 to output block OB. If REF_P is true, write a reference to EXPR's
652 write_ts_decl_with_vis_tree_pointers (struct output_block
*ob
, tree expr
,
655 /* Make sure we don't inadvertently set the assembler name. */
656 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
657 stream_write_tree (ob
, DECL_ASSEMBLER_NAME (expr
), ref_p
);
659 stream_write_tree (ob
, NULL_TREE
, false);
663 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
664 output block OB. If REF_P is true, write a reference to EXPR's
668 write_ts_field_decl_tree_pointers (struct output_block
*ob
, tree expr
,
671 stream_write_tree (ob
, DECL_FIELD_OFFSET (expr
), ref_p
);
672 stream_write_tree (ob
, DECL_BIT_FIELD_TYPE (expr
), ref_p
);
673 stream_write_tree (ob
, DECL_BIT_FIELD_REPRESENTATIVE (expr
), ref_p
);
674 stream_write_tree (ob
, DECL_FIELD_BIT_OFFSET (expr
), ref_p
);
675 stream_write_tree (ob
, DECL_FCONTEXT (expr
), ref_p
);
679 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
680 to output block OB. If REF_P is true, write a reference to EXPR's
684 write_ts_function_decl_tree_pointers (struct output_block
*ob
, tree expr
,
687 stream_write_tree (ob
, DECL_VINDEX (expr
), ref_p
);
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 stream_write_tree (ob
, TYPE_STUB_DECL (expr
), ref_p
);
720 /* Write all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
721 to output block OB. If REF_P is true, write a reference to EXPR's
725 write_ts_type_non_common_tree_pointers (struct output_block
*ob
, tree expr
,
728 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
729 stream_write_tree (ob
, TYPE_VALUES (expr
), ref_p
);
730 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
731 stream_write_tree (ob
, TYPE_DOMAIN (expr
), ref_p
);
732 else if (RECORD_OR_UNION_TYPE_P (expr
))
733 streamer_write_chain (ob
, TYPE_FIELDS (expr
), ref_p
);
734 else if (TREE_CODE (expr
) == FUNCTION_TYPE
735 || TREE_CODE (expr
) == METHOD_TYPE
)
736 stream_write_tree (ob
, TYPE_ARG_TYPES (expr
), ref_p
);
738 if (!POINTER_TYPE_P (expr
))
739 stream_write_tree (ob
, TYPE_MINVAL (expr
), ref_p
);
740 stream_write_tree (ob
, TYPE_MAXVAL (expr
), ref_p
);
741 if (RECORD_OR_UNION_TYPE_P (expr
))
742 stream_write_tree (ob
, TYPE_BINFO (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
);
801 /* Stream BLOCK_ABSTRACT_ORIGIN for the limited cases we can handle - those
802 that represent inlined function scopes.
803 For the rest them on the floor instead of ICEing in dwarf2out.c. */
804 if (inlined_function_outer_scope_p (expr
))
806 tree ultimate_origin
= block_ultimate_origin (expr
);
807 stream_write_tree (ob
, ultimate_origin
, ref_p
);
810 stream_write_tree (ob
, NULL_TREE
, ref_p
);
811 /* Do not stream BLOCK_NONLOCALIZED_VARS. We cannot handle debug information
812 for early inlined BLOCKs so drop it on the floor instead of ICEing in
815 /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
818 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
819 list is re-constructed from BLOCK_SUPERCONTEXT. */
823 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
824 block OB. If REF_P is true, write a reference to EXPR's pointer
828 write_ts_binfo_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
833 /* Note that the number of BINFO slots has already been emitted in
834 EXPR's header (see streamer_write_tree_header) because this length
835 is needed to build the empty BINFO node on the reader side. */
836 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr
), i
, t
)
837 stream_write_tree (ob
, t
, ref_p
);
838 stream_write_tree (ob
, NULL_TREE
, false);
840 stream_write_tree (ob
, BINFO_OFFSET (expr
), ref_p
);
841 stream_write_tree (ob
, BINFO_VTABLE (expr
), ref_p
);
842 stream_write_tree (ob
, BINFO_VPTR_FIELD (expr
), ref_p
);
844 /* The number of BINFO_BASE_ACCESSES has already been emitted in
845 EXPR's bitfield section. */
846 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (expr
), i
, t
)
847 stream_write_tree (ob
, t
, ref_p
);
849 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
850 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
854 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
855 output block OB. If REF_P is true, write a reference to EXPR's
859 write_ts_constructor_tree_pointers (struct output_block
*ob
, tree expr
,
865 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr
), i
, index
, value
)
867 stream_write_tree (ob
, index
, ref_p
);
868 stream_write_tree (ob
, value
, ref_p
);
873 /* Write all pointer fields in the TS_OMP_CLAUSE structure of EXPR
874 to output block OB. If REF_P is true, write a reference to EXPR's
878 write_ts_omp_clause_tree_pointers (struct output_block
*ob
, tree expr
,
882 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (expr
)]; i
++)
883 stream_write_tree (ob
, OMP_CLAUSE_OPERAND (expr
, i
), ref_p
);
884 if (OMP_CLAUSE_CODE (expr
) == OMP_CLAUSE_REDUCTION
)
886 /* We don't stream these right now, handle it if streaming
887 of them is needed. */
888 gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (expr
) == NULL
);
889 gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (expr
) == NULL
);
891 stream_write_tree (ob
, OMP_CLAUSE_CHAIN (expr
), ref_p
);
895 /* Write all pointer fields in EXPR to output block OB. If REF_P is true,
896 the leaves of EXPR are emitted as references. */
899 streamer_write_tree_body (struct output_block
*ob
, tree expr
, bool ref_p
)
903 lto_stats
.num_tree_bodies_output
++;
905 code
= TREE_CODE (expr
);
907 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
908 write_ts_common_tree_pointers (ob
, expr
, ref_p
);
910 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
911 write_ts_vector_tree_pointers (ob
, expr
, ref_p
);
913 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
914 write_ts_complex_tree_pointers (ob
, expr
, ref_p
);
916 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
917 write_ts_decl_minimal_tree_pointers (ob
, expr
, ref_p
);
919 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
920 write_ts_decl_common_tree_pointers (ob
, expr
, ref_p
);
922 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
923 write_ts_decl_non_common_tree_pointers (ob
, expr
, ref_p
);
925 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
926 write_ts_decl_with_vis_tree_pointers (ob
, expr
, ref_p
);
928 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
929 write_ts_field_decl_tree_pointers (ob
, expr
, ref_p
);
931 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
932 write_ts_function_decl_tree_pointers (ob
, expr
, ref_p
);
934 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
935 write_ts_type_common_tree_pointers (ob
, expr
, ref_p
);
937 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
938 write_ts_type_non_common_tree_pointers (ob
, expr
, ref_p
);
940 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
941 write_ts_list_tree_pointers (ob
, expr
, ref_p
);
943 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
944 write_ts_vec_tree_pointers (ob
, expr
, ref_p
);
946 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
947 write_ts_exp_tree_pointers (ob
, expr
, ref_p
);
949 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
950 write_ts_block_tree_pointers (ob
, expr
, ref_p
);
952 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
953 write_ts_binfo_tree_pointers (ob
, expr
, ref_p
);
955 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
956 write_ts_constructor_tree_pointers (ob
, expr
, ref_p
);
958 if (code
== OMP_CLAUSE
)
959 write_ts_omp_clause_tree_pointers (ob
, expr
, ref_p
);
963 /* Emit header information for tree EXPR to output block OB. The header
964 contains everything needed to instantiate an empty skeleton for
965 EXPR on the reading side. IX is the index into the streamer cache
966 where EXPR is stored. */
969 streamer_write_tree_header (struct output_block
*ob
, tree expr
)
974 /* We should not see any tree nodes not handled by the streamer. */
975 code
= TREE_CODE (expr
);
977 /* The header of a tree node consists of its tag, the size of
978 the node, and any other information needed to instantiate
979 EXPR on the reading side (such as the number of slots in
980 variable sized nodes). */
981 tag
= lto_tree_code_to_tag (code
);
982 streamer_write_record_start (ob
, tag
);
984 /* The following will cause bootstrap miscomparisons. Enable with care. */
985 #ifdef LTO_STREAMER_DEBUG
986 /* This is used mainly for debugging purposes. When the reader
987 and the writer do not agree on a streamed node, the pointer
988 value for EXPR can be used to track down the differences in
990 gcc_assert ((HOST_WIDE_INT
) (intptr_t) expr
== (intptr_t) expr
);
991 streamer_write_hwi (ob
, (HOST_WIDE_INT
) (intptr_t) expr
);
994 /* The text in strings and identifiers are completely emitted in
996 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
997 streamer_write_string_cst (ob
, ob
->main_stream
, expr
);
998 else if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
999 write_identifier (ob
, ob
->main_stream
, expr
);
1000 else if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
1001 streamer_write_hwi (ob
, VECTOR_CST_NELTS (expr
));
1002 else if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1003 streamer_write_hwi (ob
, TREE_VEC_LENGTH (expr
));
1004 else if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1005 streamer_write_uhwi (ob
, BINFO_N_BASE_BINFOS (expr
));
1006 else if (TREE_CODE (expr
) == CALL_EXPR
)
1007 streamer_write_uhwi (ob
, call_expr_nargs (expr
));
1008 else if (TREE_CODE (expr
) == OMP_CLAUSE
)
1009 streamer_write_uhwi (ob
, OMP_CLAUSE_CODE (expr
));
1010 else if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
1012 gcc_checking_assert (TREE_INT_CST_NUNITS (expr
));
1013 streamer_write_uhwi (ob
, TREE_INT_CST_NUNITS (expr
));
1014 streamer_write_uhwi (ob
, TREE_INT_CST_EXT_NUNITS (expr
));
1019 /* Emit the integer constant CST to output block OB. If REF_P is true,
1020 CST's type will be emitted as a reference. */
1023 streamer_write_integer_cst (struct output_block
*ob
, tree cst
, bool ref_p
)
1026 int len
= TREE_INT_CST_NUNITS (cst
);
1027 gcc_assert (!TREE_OVERFLOW (cst
));
1028 streamer_write_record_start (ob
, LTO_integer_cst
);
1029 stream_write_tree (ob
, TREE_TYPE (cst
), ref_p
);
1030 /* We're effectively streaming a non-sign-extended wide_int here,
1031 so there's no need to stream TREE_INT_CST_EXT_NUNITS or any
1032 array members beyond LEN. We'll recreate the tree from the
1033 wide_int and the type. */
1034 streamer_write_uhwi (ob
, len
);
1035 for (i
= 0; i
< len
; i
++)
1036 streamer_write_hwi (ob
, TREE_INT_CST_ELT (cst
, i
));