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"
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);
90 bp_pack_value (bp
, DECL_UNSIGNED (expr
), 1);
91 else if (TYPE_P (expr
))
92 bp_pack_value (bp
, TYPE_UNSIGNED (expr
), 1);
94 bp_pack_value (bp
, 0, 1);
95 /* We write debug info two times, do not confuse the second one.
96 The only relevant TREE_ASM_WRITTEN use is on SSA names. */
97 bp_pack_value (bp
, (TREE_CODE (expr
) != SSA_NAME
98 ? 0 : TREE_ASM_WRITTEN (expr
)), 1);
100 bp_pack_value (bp
, TYPE_ARTIFICIAL (expr
), 1);
102 bp_pack_value (bp
, TREE_NO_WARNING (expr
), 1);
103 bp_pack_value (bp
, TREE_NOTHROW (expr
), 1);
104 bp_pack_value (bp
, TREE_STATIC (expr
), 1);
105 if (TREE_CODE (expr
) != TREE_BINFO
)
106 bp_pack_value (bp
, TREE_PRIVATE (expr
), 1);
108 bp_pack_value (bp
, 0, 1);
109 bp_pack_value (bp
, TREE_PROTECTED (expr
), 1);
110 bp_pack_value (bp
, TREE_DEPRECATED (expr
), 1);
113 if (AGGREGATE_TYPE_P (expr
))
114 bp_pack_value (bp
, TYPE_REVERSE_STORAGE_ORDER (expr
), 1);
116 bp_pack_value (bp
, TYPE_SATURATING (expr
), 1);
117 bp_pack_value (bp
, TYPE_ADDR_SPACE (expr
), 8);
119 else if (TREE_CODE (expr
) == BIT_FIELD_REF
|| TREE_CODE (expr
) == MEM_REF
)
121 bp_pack_value (bp
, REF_REVERSE_STORAGE_ORDER (expr
), 1);
122 bp_pack_value (bp
, 0, 8);
124 else if (TREE_CODE (expr
) == SSA_NAME
)
126 bp_pack_value (bp
, SSA_NAME_IS_DEFAULT_DEF (expr
), 1);
127 bp_pack_value (bp
, 0, 8);
130 bp_pack_value (bp
, 0, 9);
134 /* Pack all the non-pointer fields of the TS_INTEGER_CST structure of
135 expression EXPR into bitpack BP. */
138 pack_ts_int_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
141 /* Note that the number of elements has already been written out in
142 streamer_write_tree_header. */
143 for (i
= 0; i
< TREE_INT_CST_EXT_NUNITS (expr
); i
++)
144 bp_pack_var_len_int (bp
, TREE_INT_CST_ELT (expr
, i
));
148 /* Pack all the non-pointer fields of the TS_REAL_CST structure of
149 expression EXPR into bitpack BP. */
152 pack_ts_real_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
157 r
= TREE_REAL_CST (expr
);
158 bp_pack_value (bp
, r
.cl
, 2);
159 bp_pack_value (bp
, r
.decimal
, 1);
160 bp_pack_value (bp
, r
.sign
, 1);
161 bp_pack_value (bp
, r
.signalling
, 1);
162 bp_pack_value (bp
, r
.canonical
, 1);
163 bp_pack_value (bp
, r
.uexp
, EXP_BITS
);
164 for (i
= 0; i
< SIGSZ
; i
++)
165 bp_pack_value (bp
, r
.sig
[i
], HOST_BITS_PER_LONG
);
169 /* Pack all the non-pointer fields of the TS_FIXED_CST structure of
170 expression EXPR into bitpack BP. */
173 pack_ts_fixed_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
175 struct fixed_value fv
= TREE_FIXED_CST (expr
);
176 bp_pack_machine_mode (bp
, fv
.mode
);
177 bp_pack_var_len_int (bp
, fv
.data
.low
);
178 bp_pack_var_len_int (bp
, fv
.data
.high
);
181 /* Pack all the non-pointer fields of the TS_DECL_COMMON structure
182 of expression EXPR into bitpack BP. */
185 pack_ts_decl_common_value_fields (struct bitpack_d
*bp
, tree expr
)
187 bp_pack_machine_mode (bp
, DECL_MODE (expr
));
188 bp_pack_value (bp
, DECL_NONLOCAL (expr
), 1);
189 bp_pack_value (bp
, DECL_VIRTUAL_P (expr
), 1);
190 bp_pack_value (bp
, DECL_IGNORED_P (expr
), 1);
191 bp_pack_value (bp
, DECL_ABSTRACT_P (expr
), 1);
192 bp_pack_value (bp
, DECL_ARTIFICIAL (expr
), 1);
193 bp_pack_value (bp
, DECL_USER_ALIGN (expr
), 1);
194 bp_pack_value (bp
, DECL_PRESERVE_P (expr
), 1);
195 bp_pack_value (bp
, DECL_EXTERNAL (expr
), 1);
196 bp_pack_value (bp
, DECL_GIMPLE_REG_P (expr
), 1);
197 bp_pack_var_len_unsigned (bp
, DECL_ALIGN (expr
));
199 if (TREE_CODE (expr
) == LABEL_DECL
)
201 /* Note that we do not write LABEL_DECL_UID. The reader will
202 always assume an initial value of -1 so that the
203 label_to_block_map is recreated by gimple_set_bb. */
204 bp_pack_var_len_unsigned (bp
, EH_LANDING_PAD_NR (expr
));
207 if (TREE_CODE (expr
) == FIELD_DECL
)
209 bp_pack_value (bp
, DECL_PACKED (expr
), 1);
210 bp_pack_value (bp
, DECL_NONADDRESSABLE_P (expr
), 1);
211 bp_pack_value (bp
, expr
->decl_common
.off_align
, 8);
214 if (TREE_CODE (expr
) == VAR_DECL
)
216 bp_pack_value (bp
, DECL_HAS_DEBUG_EXPR_P (expr
), 1);
217 bp_pack_value (bp
, DECL_NONLOCAL_FRAME (expr
), 1);
220 if (TREE_CODE (expr
) == RESULT_DECL
221 || TREE_CODE (expr
) == PARM_DECL
222 || TREE_CODE (expr
) == VAR_DECL
)
224 bp_pack_value (bp
, DECL_BY_REFERENCE (expr
), 1);
225 if (TREE_CODE (expr
) == VAR_DECL
226 || TREE_CODE (expr
) == PARM_DECL
)
227 bp_pack_value (bp
, DECL_HAS_VALUE_EXPR_P (expr
), 1);
232 /* Pack all the non-pointer fields of the TS_DECL_WRTL structure
233 of expression EXPR into bitpack BP. */
236 pack_ts_decl_wrtl_value_fields (struct bitpack_d
*bp
, tree expr
)
238 bp_pack_value (bp
, DECL_REGISTER (expr
), 1);
242 /* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
243 of expression EXPR into bitpack BP. */
246 pack_ts_decl_with_vis_value_fields (struct bitpack_d
*bp
, tree expr
)
248 bp_pack_value (bp
, DECL_COMMON (expr
), 1);
249 bp_pack_value (bp
, DECL_DLLIMPORT_P (expr
), 1);
250 bp_pack_value (bp
, DECL_WEAK (expr
), 1);
251 bp_pack_value (bp
, DECL_SEEN_IN_BIND_EXPR_P (expr
), 1);
252 bp_pack_value (bp
, DECL_COMDAT (expr
), 1);
253 bp_pack_value (bp
, DECL_VISIBILITY (expr
), 2);
254 bp_pack_value (bp
, DECL_VISIBILITY_SPECIFIED (expr
), 1);
256 if (TREE_CODE (expr
) == VAR_DECL
)
258 bp_pack_value (bp
, DECL_HARD_REGISTER (expr
), 1);
259 /* DECL_IN_TEXT_SECTION is set during final asm output only. */
260 bp_pack_value (bp
, DECL_IN_CONSTANT_POOL (expr
), 1);
263 if (TREE_CODE (expr
) == FUNCTION_DECL
)
265 bp_pack_value (bp
, DECL_FINAL_P (expr
), 1);
266 bp_pack_value (bp
, DECL_CXX_CONSTRUCTOR_P (expr
), 1);
267 bp_pack_value (bp
, DECL_CXX_DESTRUCTOR_P (expr
), 1);
272 /* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure
273 of expression EXPR into bitpack BP. */
276 pack_ts_function_decl_value_fields (struct bitpack_d
*bp
, tree expr
)
278 /* For normal/md builtins we only write the class and code, so they
279 should never be handled here. */
280 gcc_assert (!streamer_handle_as_builtin_p (expr
));
282 bp_pack_enum (bp
, built_in_class
, BUILT_IN_LAST
,
283 DECL_BUILT_IN_CLASS (expr
));
284 bp_pack_value (bp
, DECL_STATIC_CONSTRUCTOR (expr
), 1);
285 bp_pack_value (bp
, DECL_STATIC_DESTRUCTOR (expr
), 1);
286 bp_pack_value (bp
, DECL_UNINLINABLE (expr
), 1);
287 bp_pack_value (bp
, DECL_POSSIBLY_INLINED (expr
), 1);
288 bp_pack_value (bp
, DECL_IS_NOVOPS (expr
), 1);
289 bp_pack_value (bp
, DECL_IS_RETURNS_TWICE (expr
), 1);
290 bp_pack_value (bp
, DECL_IS_MALLOC (expr
), 1);
291 bp_pack_value (bp
, DECL_IS_OPERATOR_NEW (expr
), 1);
292 bp_pack_value (bp
, DECL_DECLARED_INLINE_P (expr
), 1);
293 bp_pack_value (bp
, DECL_STATIC_CHAIN (expr
), 1);
294 bp_pack_value (bp
, DECL_NO_INLINE_WARNING_P (expr
), 1);
295 bp_pack_value (bp
, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr
), 1);
296 bp_pack_value (bp
, DECL_NO_LIMIT_STACK (expr
), 1);
297 bp_pack_value (bp
, DECL_DISREGARD_INLINE_LIMITS (expr
), 1);
298 bp_pack_value (bp
, DECL_PURE_P (expr
), 1);
299 bp_pack_value (bp
, DECL_LOOPING_CONST_OR_PURE_P (expr
), 1);
300 if (DECL_BUILT_IN_CLASS (expr
) != NOT_BUILT_IN
)
301 bp_pack_value (bp
, DECL_FUNCTION_CODE (expr
), 12);
305 /* Pack all the non-pointer fields of the TS_TYPE_COMMON structure
306 of expression EXPR into bitpack BP. */
309 pack_ts_type_common_value_fields (struct bitpack_d
*bp
, tree expr
)
311 bp_pack_machine_mode (bp
, TYPE_MODE (expr
));
312 bp_pack_value (bp
, TYPE_STRING_FLAG (expr
), 1);
313 /* TYPE_NO_FORCE_BLK is private to stor-layout and need
315 bp_pack_value (bp
, TYPE_NEEDS_CONSTRUCTING (expr
), 1);
316 bp_pack_value (bp
, TYPE_PACKED (expr
), 1);
317 bp_pack_value (bp
, TYPE_RESTRICT (expr
), 1);
318 bp_pack_value (bp
, TYPE_USER_ALIGN (expr
), 1);
319 bp_pack_value (bp
, TYPE_READONLY (expr
), 1);
320 /* We used to stream TYPE_ALIAS_SET == 0 information to let frontends mark
321 types that are opaque for TBAA. This however did not work as intended,
322 becuase TYPE_ALIAS_SET == 0 was regularly lost in type merging. */
323 if (RECORD_OR_UNION_TYPE_P (expr
))
325 bp_pack_value (bp
, TYPE_TRANSPARENT_AGGR (expr
), 1);
326 bp_pack_value (bp
, TYPE_FINAL_P (expr
), 1);
328 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
329 bp_pack_value (bp
, TYPE_NONALIASED_COMPONENT (expr
), 1);
330 bp_pack_var_len_unsigned (bp
, TYPE_PRECISION (expr
));
331 bp_pack_var_len_unsigned (bp
, TYPE_ALIGN (expr
));
335 /* Pack all the non-pointer fields of the TS_BLOCK structure
336 of expression EXPR into bitpack BP. */
339 pack_ts_block_value_fields (struct output_block
*ob
,
340 struct bitpack_d
*bp
, tree expr
)
342 bp_pack_value (bp
, BLOCK_ABSTRACT (expr
), 1);
343 /* BLOCK_NUMBER is recomputed. */
344 /* Stream BLOCK_SOURCE_LOCATION for the limited cases we can handle - those
345 that represent inlined function scopes.
346 For the rest them on the floor instead of ICEing in dwarf2out.c. */
347 if (inlined_function_outer_scope_p (expr
))
348 stream_output_location (ob
, bp
, BLOCK_SOURCE_LOCATION (expr
));
350 stream_output_location (ob
, bp
, UNKNOWN_LOCATION
);
353 /* Pack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL structure
354 of expression EXPR into bitpack BP. */
357 pack_ts_translation_unit_decl_value_fields (struct output_block
*ob
,
358 struct bitpack_d
*bp
, tree expr
)
360 bp_pack_string (ob
, bp
, TRANSLATION_UNIT_LANGUAGE (expr
), true);
364 /* Pack all the non-pointer fields of the TS_OMP_CLAUSE structure
365 of expression EXPR into bitpack BP. */
368 pack_ts_omp_clause_value_fields (struct output_block
*ob
,
369 struct bitpack_d
*bp
, tree expr
)
371 stream_output_location (ob
, bp
, OMP_CLAUSE_LOCATION (expr
));
372 switch (OMP_CLAUSE_CODE (expr
))
374 case OMP_CLAUSE_DEFAULT
:
375 bp_pack_enum (bp
, omp_clause_default_kind
, OMP_CLAUSE_DEFAULT_LAST
,
376 OMP_CLAUSE_DEFAULT_KIND (expr
));
378 case OMP_CLAUSE_SCHEDULE
:
379 bp_pack_enum (bp
, omp_clause_schedule_kind
, OMP_CLAUSE_SCHEDULE_LAST
,
380 OMP_CLAUSE_SCHEDULE_KIND (expr
));
382 case OMP_CLAUSE_DEPEND
:
383 bp_pack_enum (bp
, omp_clause_depend_kind
, OMP_CLAUSE_DEPEND_LAST
,
384 OMP_CLAUSE_DEPEND_KIND (expr
));
387 bp_pack_enum (bp
, gomp_map_kind
, GOMP_MAP_LAST
,
388 OMP_CLAUSE_MAP_KIND (expr
));
390 case OMP_CLAUSE_PROC_BIND
:
391 bp_pack_enum (bp
, omp_clause_proc_bind_kind
, OMP_CLAUSE_PROC_BIND_LAST
,
392 OMP_CLAUSE_PROC_BIND_KIND (expr
));
394 case OMP_CLAUSE_REDUCTION
:
395 bp_pack_enum (bp
, tree_code
, MAX_TREE_CODES
,
396 OMP_CLAUSE_REDUCTION_CODE (expr
));
404 /* Pack all the bitfields in EXPR into a bit pack. */
407 streamer_write_tree_bitfields (struct output_block
*ob
, tree expr
)
409 bitpack_d bp
= bitpack_create (ob
->main_stream
);
412 code
= TREE_CODE (expr
);
414 /* Note that all these functions are highly sensitive to changes in
415 the types and sizes of each of the fields being packed. */
416 pack_ts_base_value_fields (&bp
, expr
);
418 if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
419 pack_ts_int_cst_value_fields (&bp
, expr
);
421 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
422 pack_ts_real_cst_value_fields (&bp
, expr
);
424 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
425 pack_ts_fixed_cst_value_fields (&bp
, expr
);
427 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
428 stream_output_location (ob
, &bp
, DECL_SOURCE_LOCATION (expr
));
430 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
431 pack_ts_decl_common_value_fields (&bp
, expr
);
433 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
434 pack_ts_decl_wrtl_value_fields (&bp
, expr
);
436 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
437 pack_ts_decl_with_vis_value_fields (&bp
, expr
);
439 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
440 pack_ts_function_decl_value_fields (&bp
, expr
);
442 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
443 pack_ts_type_common_value_fields (&bp
, expr
);
445 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
447 stream_output_location (ob
, &bp
, EXPR_LOCATION (expr
));
449 || code
== TARGET_MEM_REF
)
451 bp_pack_value (&bp
, MR_DEPENDENCE_CLIQUE (expr
), sizeof (short) * 8);
452 if (MR_DEPENDENCE_CLIQUE (expr
) != 0)
453 bp_pack_value (&bp
, MR_DEPENDENCE_BASE (expr
), sizeof (short) * 8);
457 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
458 pack_ts_block_value_fields (ob
, &bp
, expr
);
460 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
461 pack_ts_translation_unit_decl_value_fields (ob
, &bp
, expr
);
463 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
464 cl_optimization_stream_out (&bp
, TREE_OPTIMIZATION (expr
));
466 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
467 bp_pack_var_len_unsigned (&bp
, vec_safe_length (BINFO_BASE_ACCESSES (expr
)));
469 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
470 bp_pack_var_len_unsigned (&bp
, CONSTRUCTOR_NELTS (expr
));
472 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
)
473 /* Don't stream these when passing things to a different target. */
474 && !lto_stream_offload_p
)
475 cl_target_option_stream_out (ob
, &bp
, TREE_TARGET_OPTION (expr
));
477 if (code
== OMP_CLAUSE
)
478 pack_ts_omp_clause_value_fields (ob
, &bp
, expr
);
480 streamer_write_bitpack (&bp
);
484 /* Write the code and class of builtin EXPR to output block OB. IX is
485 the index into the streamer cache where EXPR is stored.*/
488 streamer_write_builtin (struct output_block
*ob
, tree expr
)
490 gcc_assert (streamer_handle_as_builtin_p (expr
));
492 if (DECL_BUILT_IN_CLASS (expr
) == BUILT_IN_MD
493 && !targetm
.builtin_decl
)
494 sorry ("tree bytecode streams do not support machine specific builtin "
495 "functions on this target");
497 streamer_write_record_start (ob
, LTO_builtin_decl
);
498 streamer_write_enum (ob
->main_stream
, built_in_class
, BUILT_IN_LAST
,
499 DECL_BUILT_IN_CLASS (expr
));
500 streamer_write_uhwi (ob
, DECL_FUNCTION_CODE (expr
));
502 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
504 /* When the assembler name of a builtin gets a user name,
505 the new name is always prefixed with '*' by
506 set_builtin_user_assembler_name. So, to prevent the
507 reader side from adding a second '*', we omit it here. */
508 const char *str
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (expr
));
509 if (strlen (str
) > 1 && str
[0] == '*')
510 streamer_write_string (ob
, ob
->main_stream
, &str
[1], true);
512 streamer_write_string (ob
, ob
->main_stream
, NULL
, true);
515 streamer_write_string (ob
, ob
->main_stream
, NULL
, true);
519 /* Emit the chain of tree nodes starting at T. OB is the output block
520 to write to. REF_P is true if chain elements should be emitted
524 streamer_write_chain (struct output_block
*ob
, tree t
, bool ref_p
)
528 /* We avoid outputting external vars or functions by reference
529 to the global decls section as we do not want to have them
530 enter decl merging. This is, of course, only for the call
531 for streaming BLOCK_VARS, but other callers are safe.
532 See also lto-streamer-out.c:DFS_write_tree_body. */
533 if (VAR_OR_FUNCTION_DECL_P (t
)
534 && DECL_EXTERNAL (t
))
535 stream_write_tree_shallow_non_ref (ob
, t
, ref_p
);
537 stream_write_tree (ob
, t
, ref_p
);
542 /* Write a sentinel to terminate the chain. */
543 stream_write_tree (ob
, NULL_TREE
, ref_p
);
547 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
548 block OB. If REF_P is true, write a reference to EXPR's pointer
552 write_ts_common_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
554 if (TREE_CODE (expr
) != IDENTIFIER_NODE
)
555 stream_write_tree (ob
, TREE_TYPE (expr
), ref_p
);
559 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
560 block OB. If REF_P is true, write a reference to EXPR's pointer
564 write_ts_vector_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
567 /* Note that the number of elements for EXPR has already been emitted
568 in EXPR's header (see streamer_write_tree_header). */
569 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
570 stream_write_tree (ob
, VECTOR_CST_ELT (expr
, i
), ref_p
);
574 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
575 block OB. If REF_P is true, write a reference to EXPR's pointer
579 write_ts_complex_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
581 stream_write_tree (ob
, TREE_REALPART (expr
), ref_p
);
582 stream_write_tree (ob
, TREE_IMAGPART (expr
), ref_p
);
586 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
587 to output block OB. If REF_P is true, write a reference to EXPR's
591 write_ts_decl_minimal_tree_pointers (struct output_block
*ob
, tree expr
,
594 /* Drop names that were created for anonymous entities. */
596 && TREE_CODE (DECL_NAME (expr
)) == IDENTIFIER_NODE
597 && anon_aggrname_p (DECL_NAME (expr
)))
598 stream_write_tree (ob
, NULL_TREE
, ref_p
);
600 stream_write_tree (ob
, DECL_NAME (expr
), ref_p
);
601 stream_write_tree (ob
, DECL_CONTEXT (expr
), ref_p
);
605 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
606 output block OB. If REF_P is true, write a reference to EXPR's
610 write_ts_decl_common_tree_pointers (struct output_block
*ob
, tree expr
,
613 stream_write_tree (ob
, DECL_SIZE (expr
), ref_p
);
614 stream_write_tree (ob
, DECL_SIZE_UNIT (expr
), ref_p
);
616 /* Note, DECL_INITIAL is not handled here. Since DECL_INITIAL needs
617 special handling in LTO, it must be handled by streamer hooks. */
619 stream_write_tree (ob
, DECL_ATTRIBUTES (expr
), ref_p
);
621 /* Do not stream DECL_ABSTRACT_ORIGIN. We cannot handle debug information
622 for early inlining so drop it on the floor instead of ICEing in
625 if ((TREE_CODE (expr
) == VAR_DECL
626 || TREE_CODE (expr
) == PARM_DECL
)
627 && DECL_HAS_VALUE_EXPR_P (expr
))
628 stream_write_tree (ob
, DECL_VALUE_EXPR (expr
), ref_p
);
630 if (TREE_CODE (expr
) == VAR_DECL
)
631 stream_write_tree (ob
, DECL_DEBUG_EXPR (expr
), ref_p
);
635 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
636 EXPR to output block OB. If REF_P is true, write a reference to EXPR's
640 write_ts_decl_non_common_tree_pointers (struct output_block
*ob
, tree expr
,
643 if (TREE_CODE (expr
) == TYPE_DECL
)
644 stream_write_tree (ob
, DECL_ORIGINAL_TYPE (expr
), ref_p
);
648 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
649 to output block OB. If REF_P is true, write a reference to EXPR's
653 write_ts_decl_with_vis_tree_pointers (struct output_block
*ob
, tree expr
,
656 /* Make sure we don't inadvertently set the assembler name. */
657 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
658 stream_write_tree (ob
, DECL_ASSEMBLER_NAME (expr
), ref_p
);
660 stream_write_tree (ob
, NULL_TREE
, false);
664 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
665 output block OB. If REF_P is true, write a reference to EXPR's
669 write_ts_field_decl_tree_pointers (struct output_block
*ob
, tree expr
,
672 stream_write_tree (ob
, DECL_FIELD_OFFSET (expr
), ref_p
);
673 stream_write_tree (ob
, DECL_BIT_FIELD_TYPE (expr
), ref_p
);
674 stream_write_tree (ob
, DECL_BIT_FIELD_REPRESENTATIVE (expr
), ref_p
);
675 stream_write_tree (ob
, DECL_FIELD_BIT_OFFSET (expr
), ref_p
);
676 stream_write_tree (ob
, DECL_FCONTEXT (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 stream_write_tree (ob
, DECL_VINDEX (expr
), ref_p
);
689 /* DECL_STRUCT_FUNCTION is handled by lto_output_function. */
690 stream_write_tree (ob
, DECL_FUNCTION_PERSONALITY (expr
), ref_p
);
691 /* Don't stream these when passing things to a different target. */
692 if (!lto_stream_offload_p
)
693 stream_write_tree (ob
, DECL_FUNCTION_SPECIFIC_TARGET (expr
), ref_p
);
694 stream_write_tree (ob
, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr
), ref_p
);
698 /* Write all pointer fields in the TS_TYPE_COMMON structure of EXPR to
699 output block OB. If REF_P is true, write a reference to EXPR's
703 write_ts_type_common_tree_pointers (struct output_block
*ob
, tree expr
,
706 stream_write_tree (ob
, TYPE_SIZE (expr
), ref_p
);
707 stream_write_tree (ob
, TYPE_SIZE_UNIT (expr
), ref_p
);
708 stream_write_tree (ob
, TYPE_ATTRIBUTES (expr
), ref_p
);
709 stream_write_tree (ob
, TYPE_NAME (expr
), ref_p
);
710 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
711 reconstructed during fixup. */
712 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
714 stream_write_tree (ob
, TYPE_MAIN_VARIANT (expr
), ref_p
);
715 stream_write_tree (ob
, TYPE_CONTEXT (expr
), ref_p
);
716 /* TYPE_CANONICAL is re-computed during type merging, so no need
717 to stream it here. */
718 stream_write_tree (ob
, TYPE_STUB_DECL (expr
), ref_p
);
721 /* Write all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
722 to output block OB. If REF_P is true, write a reference to EXPR's
726 write_ts_type_non_common_tree_pointers (struct output_block
*ob
, tree expr
,
729 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
730 stream_write_tree (ob
, TYPE_VALUES (expr
), ref_p
);
731 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
732 stream_write_tree (ob
, TYPE_DOMAIN (expr
), ref_p
);
733 else if (RECORD_OR_UNION_TYPE_P (expr
))
734 streamer_write_chain (ob
, TYPE_FIELDS (expr
), ref_p
);
735 else if (TREE_CODE (expr
) == FUNCTION_TYPE
736 || TREE_CODE (expr
) == METHOD_TYPE
)
737 stream_write_tree (ob
, TYPE_ARG_TYPES (expr
), ref_p
);
739 if (!POINTER_TYPE_P (expr
))
740 stream_write_tree (ob
, TYPE_MINVAL (expr
), ref_p
);
741 stream_write_tree (ob
, TYPE_MAXVAL (expr
), ref_p
);
742 if (RECORD_OR_UNION_TYPE_P (expr
))
743 stream_write_tree (ob
, TYPE_BINFO (expr
), ref_p
);
747 /* Write all pointer fields in the TS_LIST structure of EXPR to output
748 block OB. If REF_P is true, write a reference to EXPR's pointer
752 write_ts_list_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
754 stream_write_tree (ob
, TREE_PURPOSE (expr
), ref_p
);
755 stream_write_tree (ob
, TREE_VALUE (expr
), ref_p
);
756 stream_write_tree (ob
, TREE_CHAIN (expr
), ref_p
);
760 /* Write all pointer fields in the TS_VEC structure of EXPR to output
761 block OB. If REF_P is true, write a reference to EXPR's pointer
765 write_ts_vec_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
769 /* Note that the number of slots for EXPR has already been emitted
770 in EXPR's header (see streamer_write_tree_header). */
771 for (i
= 0; i
< TREE_VEC_LENGTH (expr
); i
++)
772 stream_write_tree (ob
, TREE_VEC_ELT (expr
, i
), ref_p
);
776 /* Write all pointer fields in the TS_EXP structure of EXPR to output
777 block OB. If REF_P is true, write a reference to EXPR's pointer
781 write_ts_exp_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
785 for (i
= 0; i
< TREE_OPERAND_LENGTH (expr
); i
++)
786 stream_write_tree (ob
, TREE_OPERAND (expr
, i
), ref_p
);
787 stream_write_tree (ob
, TREE_BLOCK (expr
), ref_p
);
791 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
792 block OB. If REF_P is true, write a reference to EXPR's pointer
796 write_ts_block_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
798 streamer_write_chain (ob
, BLOCK_VARS (expr
), ref_p
);
800 stream_write_tree (ob
, BLOCK_SUPERCONTEXT (expr
), ref_p
);
802 /* Stream BLOCK_ABSTRACT_ORIGIN for the limited cases we can handle - those
803 that represent inlined function scopes.
804 For the rest them on the floor instead of ICEing in dwarf2out.c. */
805 if (inlined_function_outer_scope_p (expr
))
807 tree ultimate_origin
= block_ultimate_origin (expr
);
808 stream_write_tree (ob
, ultimate_origin
, ref_p
);
811 stream_write_tree (ob
, NULL_TREE
, ref_p
);
812 /* Do not stream BLOCK_NONLOCALIZED_VARS. We cannot handle debug information
813 for early inlined BLOCKs so drop it on the floor instead of ICEing in
816 /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
819 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
820 list is re-constructed from BLOCK_SUPERCONTEXT. */
824 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
825 block OB. If REF_P is true, write a reference to EXPR's pointer
829 write_ts_binfo_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
834 /* Note that the number of BINFO slots has already been emitted in
835 EXPR's header (see streamer_write_tree_header) because this length
836 is needed to build the empty BINFO node on the reader side. */
837 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr
), i
, t
)
838 stream_write_tree (ob
, t
, ref_p
);
839 stream_write_tree (ob
, NULL_TREE
, false);
841 stream_write_tree (ob
, BINFO_OFFSET (expr
), ref_p
);
842 stream_write_tree (ob
, BINFO_VTABLE (expr
), ref_p
);
843 stream_write_tree (ob
, BINFO_VPTR_FIELD (expr
), ref_p
);
845 /* The number of BINFO_BASE_ACCESSES has already been emitted in
846 EXPR's bitfield section. */
847 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (expr
), i
, t
)
848 stream_write_tree (ob
, t
, ref_p
);
850 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
851 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
855 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
856 output block OB. If REF_P is true, write a reference to EXPR's
860 write_ts_constructor_tree_pointers (struct output_block
*ob
, tree expr
,
866 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr
), i
, index
, value
)
868 stream_write_tree (ob
, index
, ref_p
);
869 stream_write_tree (ob
, value
, ref_p
);
874 /* Write all pointer fields in the TS_OMP_CLAUSE structure of EXPR
875 to output block OB. If REF_P is true, write a reference to EXPR's
879 write_ts_omp_clause_tree_pointers (struct output_block
*ob
, tree expr
,
883 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (expr
)]; i
++)
884 stream_write_tree (ob
, OMP_CLAUSE_OPERAND (expr
, i
), ref_p
);
885 if (OMP_CLAUSE_CODE (expr
) == OMP_CLAUSE_REDUCTION
)
887 /* We don't stream these right now, handle it if streaming
888 of them is needed. */
889 gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (expr
) == NULL
);
890 gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (expr
) == NULL
);
892 stream_write_tree (ob
, OMP_CLAUSE_CHAIN (expr
), ref_p
);
896 /* Write all pointer fields in EXPR to output block OB. If REF_P is true,
897 the leaves of EXPR are emitted as references. */
900 streamer_write_tree_body (struct output_block
*ob
, tree expr
, bool ref_p
)
904 lto_stats
.num_tree_bodies_output
++;
906 code
= TREE_CODE (expr
);
908 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
909 write_ts_common_tree_pointers (ob
, expr
, ref_p
);
911 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
912 write_ts_vector_tree_pointers (ob
, expr
, ref_p
);
914 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
915 write_ts_complex_tree_pointers (ob
, expr
, ref_p
);
917 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
918 write_ts_decl_minimal_tree_pointers (ob
, expr
, ref_p
);
920 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
921 write_ts_decl_common_tree_pointers (ob
, expr
, ref_p
);
923 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
924 write_ts_decl_non_common_tree_pointers (ob
, expr
, ref_p
);
926 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
927 write_ts_decl_with_vis_tree_pointers (ob
, expr
, ref_p
);
929 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
930 write_ts_field_decl_tree_pointers (ob
, expr
, ref_p
);
932 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
933 write_ts_function_decl_tree_pointers (ob
, expr
, ref_p
);
935 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
936 write_ts_type_common_tree_pointers (ob
, expr
, ref_p
);
938 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
939 write_ts_type_non_common_tree_pointers (ob
, expr
, ref_p
);
941 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
942 write_ts_list_tree_pointers (ob
, expr
, ref_p
);
944 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
945 write_ts_vec_tree_pointers (ob
, expr
, ref_p
);
947 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
948 write_ts_exp_tree_pointers (ob
, expr
, ref_p
);
950 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
951 write_ts_block_tree_pointers (ob
, expr
, ref_p
);
953 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
954 write_ts_binfo_tree_pointers (ob
, expr
, ref_p
);
956 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
957 write_ts_constructor_tree_pointers (ob
, expr
, ref_p
);
959 if (code
== OMP_CLAUSE
)
960 write_ts_omp_clause_tree_pointers (ob
, expr
, ref_p
);
964 /* Emit header information for tree EXPR to output block OB. The header
965 contains everything needed to instantiate an empty skeleton for
966 EXPR on the reading side. IX is the index into the streamer cache
967 where EXPR is stored. */
970 streamer_write_tree_header (struct output_block
*ob
, tree expr
)
975 /* We should not see any tree nodes not handled by the streamer. */
976 code
= TREE_CODE (expr
);
978 /* The header of a tree node consists of its tag, the size of
979 the node, and any other information needed to instantiate
980 EXPR on the reading side (such as the number of slots in
981 variable sized nodes). */
982 tag
= lto_tree_code_to_tag (code
);
983 streamer_write_record_start (ob
, tag
);
985 /* The following will cause bootstrap miscomparisons. Enable with care. */
986 #ifdef LTO_STREAMER_DEBUG
987 /* This is used mainly for debugging purposes. When the reader
988 and the writer do not agree on a streamed node, the pointer
989 value for EXPR can be used to track down the differences in
991 gcc_assert ((HOST_WIDE_INT
) (intptr_t) expr
== (intptr_t) expr
);
992 streamer_write_hwi (ob
, (HOST_WIDE_INT
) (intptr_t) expr
);
995 /* The text in strings and identifiers are completely emitted in
997 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
998 streamer_write_string_cst (ob
, ob
->main_stream
, expr
);
999 else if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
1000 write_identifier (ob
, ob
->main_stream
, expr
);
1001 else if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
1002 streamer_write_hwi (ob
, VECTOR_CST_NELTS (expr
));
1003 else if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1004 streamer_write_hwi (ob
, TREE_VEC_LENGTH (expr
));
1005 else if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1006 streamer_write_uhwi (ob
, BINFO_N_BASE_BINFOS (expr
));
1007 else if (TREE_CODE (expr
) == CALL_EXPR
)
1008 streamer_write_uhwi (ob
, call_expr_nargs (expr
));
1009 else if (TREE_CODE (expr
) == OMP_CLAUSE
)
1010 streamer_write_uhwi (ob
, OMP_CLAUSE_CODE (expr
));
1011 else if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
1013 gcc_checking_assert (TREE_INT_CST_NUNITS (expr
));
1014 streamer_write_uhwi (ob
, TREE_INT_CST_NUNITS (expr
));
1015 streamer_write_uhwi (ob
, TREE_INT_CST_EXT_NUNITS (expr
));
1020 /* Emit the integer constant CST to output block OB. If REF_P is true,
1021 CST's type will be emitted as a reference. */
1024 streamer_write_integer_cst (struct output_block
*ob
, tree cst
, bool ref_p
)
1027 int len
= TREE_INT_CST_NUNITS (cst
);
1028 gcc_assert (!TREE_OVERFLOW (cst
));
1029 streamer_write_record_start (ob
, LTO_integer_cst
);
1030 stream_write_tree (ob
, TREE_TYPE (cst
), ref_p
);
1031 /* We're effectively streaming a non-sign-extended wide_int here,
1032 so there's no need to stream TREE_INT_CST_EXT_NUNITS or any
1033 array members beyond LEN. We'll recreate the tree from the
1034 wide_int and the type. */
1035 streamer_write_uhwi (ob
, len
);
1036 for (i
= 0; i
< len
; i
++)
1037 streamer_write_hwi (ob
, TREE_INT_CST_ELT (cst
, i
));