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"
26 #include "diagnostic.h"
31 #include "fold-const.h"
32 #include "stor-layout.h"
34 #include "hard-reg-set.h"
37 #include "basic-block.h"
38 #include "tree-ssa-alias.h"
39 #include "internal-fn.h"
40 #include "gimple-expr.h"
43 #include "plugin-api.h"
46 #include "tree-streamer.h"
47 #include "data-streamer.h"
48 #include "streamer-hooks.h"
49 #include "gomp-constants.h"
52 /* Output the STRING constant to the string
53 table in OB. Then put the index onto the INDEX_STREAM. */
56 streamer_write_string_cst (struct output_block
*ob
,
57 struct lto_output_stream
*index_stream
,
60 streamer_write_string_with_length (ob
, index_stream
,
61 string
? TREE_STRING_POINTER (string
)
63 string
? TREE_STRING_LENGTH (string
) : 0,
68 /* Output the identifier ID to the string
69 table in OB. Then put the index onto the INDEX_STREAM. */
72 write_identifier (struct output_block
*ob
,
73 struct lto_output_stream
*index_stream
,
76 streamer_write_string_with_length (ob
, index_stream
,
77 IDENTIFIER_POINTER (id
),
78 IDENTIFIER_LENGTH (id
),
83 /* Pack all the non-pointer fields of the TS_BASE structure of
84 expression EXPR into bitpack BP. */
87 pack_ts_base_value_fields (struct bitpack_d
*bp
, tree expr
)
89 bp_pack_value (bp
, TREE_CODE (expr
), 16);
92 bp_pack_value (bp
, TREE_SIDE_EFFECTS (expr
), 1);
93 bp_pack_value (bp
, TREE_CONSTANT (expr
), 1);
94 bp_pack_value (bp
, TREE_READONLY (expr
), 1);
96 /* TREE_PUBLIC is used on types to indicate that the type
97 has a TYPE_CACHED_VALUES vector. This is not streamed out,
98 so we skip it here. */
99 bp_pack_value (bp
, TREE_PUBLIC (expr
), 1);
102 bp_pack_value (bp
, 0, 4);
103 bp_pack_value (bp
, TREE_ADDRESSABLE (expr
), 1);
104 bp_pack_value (bp
, TREE_THIS_VOLATILE (expr
), 1);
106 bp_pack_value (bp
, DECL_UNSIGNED (expr
), 1);
107 else if (TYPE_P (expr
))
108 bp_pack_value (bp
, TYPE_UNSIGNED (expr
), 1);
110 bp_pack_value (bp
, 0, 1);
111 /* We write debug info two times, do not confuse the second one.
112 The only relevant TREE_ASM_WRITTEN use is on SSA names. */
113 bp_pack_value (bp
, (TREE_CODE (expr
) != SSA_NAME
114 ? 0 : TREE_ASM_WRITTEN (expr
)), 1);
116 bp_pack_value (bp
, TYPE_ARTIFICIAL (expr
), 1);
118 bp_pack_value (bp
, TREE_NO_WARNING (expr
), 1);
119 bp_pack_value (bp
, TREE_NOTHROW (expr
), 1);
120 bp_pack_value (bp
, TREE_STATIC (expr
), 1);
121 if (TREE_CODE (expr
) != TREE_BINFO
)
122 bp_pack_value (bp
, TREE_PRIVATE (expr
), 1);
124 bp_pack_value (bp
, 0, 1);
125 bp_pack_value (bp
, TREE_PROTECTED (expr
), 1);
126 bp_pack_value (bp
, TREE_DEPRECATED (expr
), 1);
129 bp_pack_value (bp
, TYPE_SATURATING (expr
), 1);
130 bp_pack_value (bp
, TYPE_ADDR_SPACE (expr
), 8);
132 else if (TREE_CODE (expr
) == SSA_NAME
)
134 bp_pack_value (bp
, SSA_NAME_IS_DEFAULT_DEF (expr
), 1);
135 bp_pack_value (bp
, 0, 8);
138 bp_pack_value (bp
, 0, 9);
142 /* Pack all the non-pointer fields of the TS_INTEGER_CST structure of
143 expression EXPR into bitpack BP. */
146 pack_ts_int_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
149 /* Note that the number of elements has already been written out in
150 streamer_write_tree_header. */
151 for (i
= 0; i
< TREE_INT_CST_EXT_NUNITS (expr
); i
++)
152 bp_pack_var_len_int (bp
, TREE_INT_CST_ELT (expr
, i
));
156 /* Pack all the non-pointer fields of the TS_REAL_CST structure of
157 expression EXPR into bitpack BP. */
160 pack_ts_real_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
165 r
= TREE_REAL_CST (expr
);
166 bp_pack_value (bp
, r
.cl
, 2);
167 bp_pack_value (bp
, r
.decimal
, 1);
168 bp_pack_value (bp
, r
.sign
, 1);
169 bp_pack_value (bp
, r
.signalling
, 1);
170 bp_pack_value (bp
, r
.canonical
, 1);
171 bp_pack_value (bp
, r
.uexp
, EXP_BITS
);
172 for (i
= 0; i
< SIGSZ
; i
++)
173 bp_pack_value (bp
, r
.sig
[i
], HOST_BITS_PER_LONG
);
177 /* Pack all the non-pointer fields of the TS_FIXED_CST structure of
178 expression EXPR into bitpack BP. */
181 pack_ts_fixed_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
183 struct fixed_value fv
= TREE_FIXED_CST (expr
);
184 bp_pack_machine_mode (bp
, fv
.mode
);
185 bp_pack_var_len_int (bp
, fv
.data
.low
);
186 bp_pack_var_len_int (bp
, fv
.data
.high
);
189 /* Pack all the non-pointer fields of the TS_DECL_COMMON structure
190 of expression EXPR into bitpack BP. */
193 pack_ts_decl_common_value_fields (struct bitpack_d
*bp
, tree expr
)
195 bp_pack_machine_mode (bp
, DECL_MODE (expr
));
196 bp_pack_value (bp
, DECL_NONLOCAL (expr
), 1);
197 bp_pack_value (bp
, DECL_VIRTUAL_P (expr
), 1);
198 bp_pack_value (bp
, DECL_IGNORED_P (expr
), 1);
199 bp_pack_value (bp
, DECL_ABSTRACT_P (expr
), 1);
200 bp_pack_value (bp
, DECL_ARTIFICIAL (expr
), 1);
201 bp_pack_value (bp
, DECL_USER_ALIGN (expr
), 1);
202 bp_pack_value (bp
, DECL_PRESERVE_P (expr
), 1);
203 bp_pack_value (bp
, DECL_EXTERNAL (expr
), 1);
204 bp_pack_value (bp
, DECL_GIMPLE_REG_P (expr
), 1);
205 bp_pack_var_len_unsigned (bp
, DECL_ALIGN (expr
));
207 if (TREE_CODE (expr
) == LABEL_DECL
)
209 /* Note that we do not write LABEL_DECL_UID. The reader will
210 always assume an initial value of -1 so that the
211 label_to_block_map is recreated by gimple_set_bb. */
212 bp_pack_var_len_unsigned (bp
, EH_LANDING_PAD_NR (expr
));
215 if (TREE_CODE (expr
) == FIELD_DECL
)
217 bp_pack_value (bp
, DECL_PACKED (expr
), 1);
218 bp_pack_value (bp
, DECL_NONADDRESSABLE_P (expr
), 1);
219 bp_pack_value (bp
, expr
->decl_common
.off_align
, 8);
222 if (TREE_CODE (expr
) == VAR_DECL
)
224 bp_pack_value (bp
, DECL_HAS_DEBUG_EXPR_P (expr
), 1);
225 bp_pack_value (bp
, DECL_NONLOCAL_FRAME (expr
), 1);
228 if (TREE_CODE (expr
) == RESULT_DECL
229 || TREE_CODE (expr
) == PARM_DECL
230 || TREE_CODE (expr
) == VAR_DECL
)
232 bp_pack_value (bp
, DECL_BY_REFERENCE (expr
), 1);
233 if (TREE_CODE (expr
) == VAR_DECL
234 || TREE_CODE (expr
) == PARM_DECL
)
235 bp_pack_value (bp
, DECL_HAS_VALUE_EXPR_P (expr
), 1);
240 /* Pack all the non-pointer fields of the TS_DECL_WRTL structure
241 of expression EXPR into bitpack BP. */
244 pack_ts_decl_wrtl_value_fields (struct bitpack_d
*bp
, tree expr
)
246 bp_pack_value (bp
, DECL_REGISTER (expr
), 1);
250 /* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
251 of expression EXPR into bitpack BP. */
254 pack_ts_decl_with_vis_value_fields (struct bitpack_d
*bp
, tree expr
)
256 bp_pack_value (bp
, DECL_COMMON (expr
), 1);
257 bp_pack_value (bp
, DECL_DLLIMPORT_P (expr
), 1);
258 bp_pack_value (bp
, DECL_WEAK (expr
), 1);
259 bp_pack_value (bp
, DECL_SEEN_IN_BIND_EXPR_P (expr
), 1);
260 bp_pack_value (bp
, DECL_COMDAT (expr
), 1);
261 bp_pack_value (bp
, DECL_VISIBILITY (expr
), 2);
262 bp_pack_value (bp
, DECL_VISIBILITY_SPECIFIED (expr
), 1);
264 if (TREE_CODE (expr
) == VAR_DECL
)
266 bp_pack_value (bp
, DECL_HARD_REGISTER (expr
), 1);
267 /* DECL_IN_TEXT_SECTION is set during final asm output only. */
268 bp_pack_value (bp
, DECL_IN_CONSTANT_POOL (expr
), 1);
271 if (TREE_CODE (expr
) == FUNCTION_DECL
)
273 bp_pack_value (bp
, DECL_FINAL_P (expr
), 1);
274 bp_pack_value (bp
, DECL_CXX_CONSTRUCTOR_P (expr
), 1);
275 bp_pack_value (bp
, DECL_CXX_DESTRUCTOR_P (expr
), 1);
280 /* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure
281 of expression EXPR into bitpack BP. */
284 pack_ts_function_decl_value_fields (struct bitpack_d
*bp
, tree expr
)
286 /* For normal/md builtins we only write the class and code, so they
287 should never be handled here. */
288 gcc_assert (!streamer_handle_as_builtin_p (expr
));
290 bp_pack_enum (bp
, built_in_class
, BUILT_IN_LAST
,
291 DECL_BUILT_IN_CLASS (expr
));
292 bp_pack_value (bp
, DECL_STATIC_CONSTRUCTOR (expr
), 1);
293 bp_pack_value (bp
, DECL_STATIC_DESTRUCTOR (expr
), 1);
294 bp_pack_value (bp
, DECL_UNINLINABLE (expr
), 1);
295 bp_pack_value (bp
, DECL_POSSIBLY_INLINED (expr
), 1);
296 bp_pack_value (bp
, DECL_IS_NOVOPS (expr
), 1);
297 bp_pack_value (bp
, DECL_IS_RETURNS_TWICE (expr
), 1);
298 bp_pack_value (bp
, DECL_IS_MALLOC (expr
), 1);
299 bp_pack_value (bp
, DECL_IS_OPERATOR_NEW (expr
), 1);
300 bp_pack_value (bp
, DECL_DECLARED_INLINE_P (expr
), 1);
301 bp_pack_value (bp
, DECL_STATIC_CHAIN (expr
), 1);
302 bp_pack_value (bp
, DECL_NO_INLINE_WARNING_P (expr
), 1);
303 bp_pack_value (bp
, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr
), 1);
304 bp_pack_value (bp
, DECL_NO_LIMIT_STACK (expr
), 1);
305 bp_pack_value (bp
, DECL_DISREGARD_INLINE_LIMITS (expr
), 1);
306 bp_pack_value (bp
, DECL_PURE_P (expr
), 1);
307 bp_pack_value (bp
, DECL_LOOPING_CONST_OR_PURE_P (expr
), 1);
308 if (DECL_BUILT_IN_CLASS (expr
) != NOT_BUILT_IN
)
309 bp_pack_value (bp
, DECL_FUNCTION_CODE (expr
), 12);
313 /* Pack all the non-pointer fields of the TS_TYPE_COMMON structure
314 of expression EXPR into bitpack BP. */
317 pack_ts_type_common_value_fields (struct bitpack_d
*bp
, tree expr
)
319 bp_pack_machine_mode (bp
, TYPE_MODE (expr
));
320 bp_pack_value (bp
, TYPE_STRING_FLAG (expr
), 1);
321 bp_pack_value (bp
, TYPE_NO_FORCE_BLK (expr
), 1);
322 bp_pack_value (bp
, TYPE_NEEDS_CONSTRUCTING (expr
), 1);
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_value (bp
, TYPE_PACKED (expr
), 1);
331 bp_pack_value (bp
, TYPE_RESTRICT (expr
), 1);
332 bp_pack_value (bp
, TYPE_USER_ALIGN (expr
), 1);
333 bp_pack_value (bp
, TYPE_READONLY (expr
), 1);
334 bp_pack_var_len_unsigned (bp
, TYPE_PRECISION (expr
));
335 bp_pack_var_len_unsigned (bp
, TYPE_ALIGN (expr
));
336 /* Make sure to preserve the fact whether the frontend would assign
337 alias-set zero to this type. */
338 bp_pack_var_len_int (bp
, (TYPE_ALIAS_SET (expr
) == 0
340 && get_alias_set (expr
) == 0)) ? 0 : -1);
344 /* Pack all the non-pointer fields of the TS_BLOCK structure
345 of expression EXPR into bitpack BP. */
348 pack_ts_block_value_fields (struct output_block
*ob
,
349 struct bitpack_d
*bp
, tree expr
)
351 bp_pack_value (bp
, BLOCK_ABSTRACT (expr
), 1);
352 /* BLOCK_NUMBER is recomputed. */
353 /* Stream BLOCK_SOURCE_LOCATION for the limited cases we can handle - those
354 that represent inlined function scopes.
355 For the rest them on the floor instead of ICEing in dwarf2out.c. */
356 if (inlined_function_outer_scope_p (expr
))
357 stream_output_location (ob
, bp
, BLOCK_SOURCE_LOCATION (expr
));
359 stream_output_location (ob
, bp
, UNKNOWN_LOCATION
);
362 /* Pack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL structure
363 of expression EXPR into bitpack BP. */
366 pack_ts_translation_unit_decl_value_fields (struct output_block
*ob
,
367 struct bitpack_d
*bp
, tree expr
)
369 bp_pack_string (ob
, bp
, TRANSLATION_UNIT_LANGUAGE (expr
), true);
373 /* Pack all the non-pointer fields of the TS_OMP_CLAUSE structure
374 of expression EXPR into bitpack BP. */
377 pack_ts_omp_clause_value_fields (struct output_block
*ob
,
378 struct bitpack_d
*bp
, tree expr
)
380 stream_output_location (ob
, bp
, OMP_CLAUSE_LOCATION (expr
));
381 switch (OMP_CLAUSE_CODE (expr
))
383 case OMP_CLAUSE_DEFAULT
:
384 bp_pack_enum (bp
, omp_clause_default_kind
, OMP_CLAUSE_DEFAULT_LAST
,
385 OMP_CLAUSE_DEFAULT_KIND (expr
));
387 case OMP_CLAUSE_SCHEDULE
:
388 bp_pack_enum (bp
, omp_clause_schedule_kind
, OMP_CLAUSE_SCHEDULE_LAST
,
389 OMP_CLAUSE_SCHEDULE_KIND (expr
));
391 case OMP_CLAUSE_DEPEND
:
392 bp_pack_enum (bp
, omp_clause_depend_kind
, OMP_CLAUSE_DEPEND_LAST
,
393 OMP_CLAUSE_DEPEND_KIND (expr
));
396 bp_pack_enum (bp
, gomp_map_kind
, GOMP_MAP_LAST
,
397 OMP_CLAUSE_MAP_KIND (expr
));
399 case OMP_CLAUSE_PROC_BIND
:
400 bp_pack_enum (bp
, omp_clause_proc_bind_kind
, OMP_CLAUSE_PROC_BIND_LAST
,
401 OMP_CLAUSE_PROC_BIND_KIND (expr
));
403 case OMP_CLAUSE_REDUCTION
:
404 bp_pack_enum (bp
, tree_code
, MAX_TREE_CODES
,
405 OMP_CLAUSE_REDUCTION_CODE (expr
));
413 /* Pack all the bitfields in EXPR into a bit pack. */
416 streamer_write_tree_bitfields (struct output_block
*ob
, tree expr
)
418 bitpack_d bp
= bitpack_create (ob
->main_stream
);
421 code
= TREE_CODE (expr
);
423 /* Note that all these functions are highly sensitive to changes in
424 the types and sizes of each of the fields being packed. */
425 pack_ts_base_value_fields (&bp
, expr
);
427 if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
428 pack_ts_int_cst_value_fields (&bp
, expr
);
430 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
431 pack_ts_real_cst_value_fields (&bp
, expr
);
433 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
434 pack_ts_fixed_cst_value_fields (&bp
, expr
);
436 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
437 stream_output_location (ob
, &bp
, DECL_SOURCE_LOCATION (expr
));
439 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
440 pack_ts_decl_common_value_fields (&bp
, expr
);
442 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
443 pack_ts_decl_wrtl_value_fields (&bp
, expr
);
445 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
446 pack_ts_decl_with_vis_value_fields (&bp
, expr
);
448 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
449 pack_ts_function_decl_value_fields (&bp
, expr
);
451 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
452 pack_ts_type_common_value_fields (&bp
, expr
);
454 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
456 stream_output_location (ob
, &bp
, EXPR_LOCATION (expr
));
458 || code
== TARGET_MEM_REF
)
460 bp_pack_value (&bp
, MR_DEPENDENCE_CLIQUE (expr
), sizeof (short) * 8);
461 if (MR_DEPENDENCE_CLIQUE (expr
) != 0)
462 bp_pack_value (&bp
, MR_DEPENDENCE_BASE (expr
), sizeof (short) * 8);
466 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
467 pack_ts_block_value_fields (ob
, &bp
, expr
);
469 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
470 pack_ts_translation_unit_decl_value_fields (ob
, &bp
, expr
);
472 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
473 cl_optimization_stream_out (&bp
, TREE_OPTIMIZATION (expr
));
475 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
476 bp_pack_var_len_unsigned (&bp
, vec_safe_length (BINFO_BASE_ACCESSES (expr
)));
478 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
479 bp_pack_var_len_unsigned (&bp
, CONSTRUCTOR_NELTS (expr
));
481 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
)
482 /* Don't stream these when passing things to a different target. */
483 && !lto_stream_offload_p
)
484 cl_target_option_stream_out (ob
, &bp
, TREE_TARGET_OPTION (expr
));
486 if (code
== OMP_CLAUSE
)
487 pack_ts_omp_clause_value_fields (ob
, &bp
, expr
);
489 streamer_write_bitpack (&bp
);
493 /* Write the code and class of builtin EXPR to output block OB. IX is
494 the index into the streamer cache where EXPR is stored.*/
497 streamer_write_builtin (struct output_block
*ob
, tree expr
)
499 gcc_assert (streamer_handle_as_builtin_p (expr
));
501 if (DECL_BUILT_IN_CLASS (expr
) == BUILT_IN_MD
502 && !targetm
.builtin_decl
)
503 sorry ("tree bytecode streams do not support machine specific builtin "
504 "functions on this target");
506 streamer_write_record_start (ob
, LTO_builtin_decl
);
507 streamer_write_enum (ob
->main_stream
, built_in_class
, BUILT_IN_LAST
,
508 DECL_BUILT_IN_CLASS (expr
));
509 streamer_write_uhwi (ob
, DECL_FUNCTION_CODE (expr
));
511 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
513 /* When the assembler name of a builtin gets a user name,
514 the new name is always prefixed with '*' by
515 set_builtin_user_assembler_name. So, to prevent the
516 reader side from adding a second '*', we omit it here. */
517 const char *str
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (expr
));
518 if (strlen (str
) > 1 && str
[0] == '*')
519 streamer_write_string (ob
, ob
->main_stream
, &str
[1], true);
521 streamer_write_string (ob
, ob
->main_stream
, NULL
, true);
524 streamer_write_string (ob
, ob
->main_stream
, NULL
, true);
528 /* Emit the chain of tree nodes starting at T. OB is the output block
529 to write to. REF_P is true if chain elements should be emitted
533 streamer_write_chain (struct output_block
*ob
, tree t
, bool ref_p
)
537 /* We avoid outputting external vars or functions by reference
538 to the global decls section as we do not want to have them
539 enter decl merging. This is, of course, only for the call
540 for streaming BLOCK_VARS, but other callers are safe.
541 See also lto-streamer-out.c:DFS_write_tree_body. */
542 if (VAR_OR_FUNCTION_DECL_P (t
)
543 && DECL_EXTERNAL (t
))
544 stream_write_tree_shallow_non_ref (ob
, t
, ref_p
);
546 stream_write_tree (ob
, t
, ref_p
);
551 /* Write a sentinel to terminate the chain. */
552 stream_write_tree (ob
, NULL_TREE
, ref_p
);
556 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
557 block OB. If REF_P is true, write a reference to EXPR's pointer
561 write_ts_common_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
563 if (TREE_CODE (expr
) != IDENTIFIER_NODE
)
564 stream_write_tree (ob
, TREE_TYPE (expr
), ref_p
);
568 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
569 block OB. If REF_P is true, write a reference to EXPR's pointer
573 write_ts_vector_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
576 /* Note that the number of elements for EXPR has already been emitted
577 in EXPR's header (see streamer_write_tree_header). */
578 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
579 stream_write_tree (ob
, VECTOR_CST_ELT (expr
, i
), ref_p
);
583 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
584 block OB. If REF_P is true, write a reference to EXPR's pointer
588 write_ts_complex_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
590 stream_write_tree (ob
, TREE_REALPART (expr
), ref_p
);
591 stream_write_tree (ob
, TREE_IMAGPART (expr
), ref_p
);
595 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
596 to output block OB. If REF_P is true, write a reference to EXPR's
600 write_ts_decl_minimal_tree_pointers (struct output_block
*ob
, tree expr
,
603 /* Drop names that were created for anonymous entities. */
605 && TREE_CODE (DECL_NAME (expr
)) == IDENTIFIER_NODE
606 && ANON_AGGRNAME_P (DECL_NAME (expr
)))
607 stream_write_tree (ob
, NULL_TREE
, ref_p
);
609 stream_write_tree (ob
, DECL_NAME (expr
), ref_p
);
610 stream_write_tree (ob
, DECL_CONTEXT (expr
), ref_p
);
614 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
615 output block OB. If REF_P is true, write a reference to EXPR's
619 write_ts_decl_common_tree_pointers (struct output_block
*ob
, tree expr
,
622 stream_write_tree (ob
, DECL_SIZE (expr
), ref_p
);
623 stream_write_tree (ob
, DECL_SIZE_UNIT (expr
), ref_p
);
625 /* Note, DECL_INITIAL is not handled here. Since DECL_INITIAL needs
626 special handling in LTO, it must be handled by streamer hooks. */
628 stream_write_tree (ob
, DECL_ATTRIBUTES (expr
), ref_p
);
630 /* Do not stream DECL_ABSTRACT_ORIGIN. We cannot handle debug information
631 for early inlining so drop it on the floor instead of ICEing in
634 if ((TREE_CODE (expr
) == VAR_DECL
635 || TREE_CODE (expr
) == PARM_DECL
)
636 && DECL_HAS_VALUE_EXPR_P (expr
))
637 stream_write_tree (ob
, DECL_VALUE_EXPR (expr
), ref_p
);
639 if (TREE_CODE (expr
) == VAR_DECL
)
640 stream_write_tree (ob
, DECL_DEBUG_EXPR (expr
), ref_p
);
644 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
645 EXPR to output block OB. If REF_P is true, write a reference to EXPR's
649 write_ts_decl_non_common_tree_pointers (struct output_block
*ob
, tree expr
,
652 if (TREE_CODE (expr
) == TYPE_DECL
)
653 stream_write_tree (ob
, DECL_ORIGINAL_TYPE (expr
), ref_p
);
657 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
658 to output block OB. If REF_P is true, write a reference to EXPR's
662 write_ts_decl_with_vis_tree_pointers (struct output_block
*ob
, tree expr
,
665 /* Make sure we don't inadvertently set the assembler name. */
666 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
667 stream_write_tree (ob
, DECL_ASSEMBLER_NAME (expr
), ref_p
);
669 stream_write_tree (ob
, NULL_TREE
, false);
673 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
674 output block OB. If REF_P is true, write a reference to EXPR's
678 write_ts_field_decl_tree_pointers (struct output_block
*ob
, tree expr
,
681 stream_write_tree (ob
, DECL_FIELD_OFFSET (expr
), ref_p
);
682 stream_write_tree (ob
, DECL_BIT_FIELD_TYPE (expr
), ref_p
);
683 stream_write_tree (ob
, DECL_BIT_FIELD_REPRESENTATIVE (expr
), ref_p
);
684 stream_write_tree (ob
, DECL_FIELD_BIT_OFFSET (expr
), ref_p
);
685 stream_write_tree (ob
, DECL_FCONTEXT (expr
), ref_p
);
689 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
690 to output block OB. If REF_P is true, write a reference to EXPR's
694 write_ts_function_decl_tree_pointers (struct output_block
*ob
, tree expr
,
697 stream_write_tree (ob
, DECL_VINDEX (expr
), ref_p
);
698 /* DECL_STRUCT_FUNCTION is handled by lto_output_function. */
699 stream_write_tree (ob
, DECL_FUNCTION_PERSONALITY (expr
), ref_p
);
700 /* Don't stream these when passing things to a different target. */
701 if (!lto_stream_offload_p
)
702 stream_write_tree (ob
, DECL_FUNCTION_SPECIFIC_TARGET (expr
), ref_p
);
703 stream_write_tree (ob
, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr
), ref_p
);
707 /* Write all pointer fields in the TS_TYPE_COMMON structure of EXPR to
708 output block OB. If REF_P is true, write a reference to EXPR's
712 write_ts_type_common_tree_pointers (struct output_block
*ob
, tree expr
,
715 stream_write_tree (ob
, TYPE_SIZE (expr
), ref_p
);
716 stream_write_tree (ob
, TYPE_SIZE_UNIT (expr
), ref_p
);
717 stream_write_tree (ob
, TYPE_ATTRIBUTES (expr
), ref_p
);
718 stream_write_tree (ob
, TYPE_NAME (expr
), ref_p
);
719 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
720 reconstructed during fixup. */
721 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
723 stream_write_tree (ob
, TYPE_MAIN_VARIANT (expr
), ref_p
);
724 stream_write_tree (ob
, TYPE_CONTEXT (expr
), ref_p
);
725 /* TYPE_CANONICAL is re-computed during type merging, so no need
726 to stream it here. */
727 stream_write_tree (ob
, TYPE_STUB_DECL (expr
), ref_p
);
730 /* Write all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
731 to output block OB. If REF_P is true, write a reference to EXPR's
735 write_ts_type_non_common_tree_pointers (struct output_block
*ob
, tree expr
,
738 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
739 stream_write_tree (ob
, TYPE_VALUES (expr
), ref_p
);
740 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
741 stream_write_tree (ob
, TYPE_DOMAIN (expr
), ref_p
);
742 else if (RECORD_OR_UNION_TYPE_P (expr
))
743 streamer_write_chain (ob
, TYPE_FIELDS (expr
), ref_p
);
744 else if (TREE_CODE (expr
) == FUNCTION_TYPE
745 || TREE_CODE (expr
) == METHOD_TYPE
)
746 stream_write_tree (ob
, TYPE_ARG_TYPES (expr
), ref_p
);
748 if (!POINTER_TYPE_P (expr
))
749 stream_write_tree (ob
, TYPE_MINVAL (expr
), ref_p
);
750 stream_write_tree (ob
, TYPE_MAXVAL (expr
), ref_p
);
751 if (RECORD_OR_UNION_TYPE_P (expr
))
752 stream_write_tree (ob
, TYPE_BINFO (expr
), ref_p
);
756 /* Write all pointer fields in the TS_LIST structure of EXPR to output
757 block OB. If REF_P is true, write a reference to EXPR's pointer
761 write_ts_list_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
763 stream_write_tree (ob
, TREE_PURPOSE (expr
), ref_p
);
764 stream_write_tree (ob
, TREE_VALUE (expr
), ref_p
);
765 stream_write_tree (ob
, TREE_CHAIN (expr
), ref_p
);
769 /* Write all pointer fields in the TS_VEC structure of EXPR to output
770 block OB. If REF_P is true, write a reference to EXPR's pointer
774 write_ts_vec_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
778 /* Note that the number of slots for EXPR has already been emitted
779 in EXPR's header (see streamer_write_tree_header). */
780 for (i
= 0; i
< TREE_VEC_LENGTH (expr
); i
++)
781 stream_write_tree (ob
, TREE_VEC_ELT (expr
, i
), ref_p
);
785 /* Write all pointer fields in the TS_EXP structure of EXPR to output
786 block OB. If REF_P is true, write a reference to EXPR's pointer
790 write_ts_exp_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
794 for (i
= 0; i
< TREE_OPERAND_LENGTH (expr
); i
++)
795 stream_write_tree (ob
, TREE_OPERAND (expr
, i
), ref_p
);
796 stream_write_tree (ob
, TREE_BLOCK (expr
), ref_p
);
800 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
801 block OB. If REF_P is true, write a reference to EXPR's pointer
805 write_ts_block_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
807 streamer_write_chain (ob
, BLOCK_VARS (expr
), ref_p
);
809 stream_write_tree (ob
, BLOCK_SUPERCONTEXT (expr
), ref_p
);
811 /* Stream BLOCK_ABSTRACT_ORIGIN for the limited cases we can handle - those
812 that represent inlined function scopes.
813 For the rest them on the floor instead of ICEing in dwarf2out.c. */
814 if (inlined_function_outer_scope_p (expr
))
816 tree ultimate_origin
= block_ultimate_origin (expr
);
817 stream_write_tree (ob
, ultimate_origin
, ref_p
);
820 stream_write_tree (ob
, NULL_TREE
, ref_p
);
821 /* Do not stream BLOCK_NONLOCALIZED_VARS. We cannot handle debug information
822 for early inlined BLOCKs so drop it on the floor instead of ICEing in
825 /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
828 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
829 list is re-constructed from BLOCK_SUPERCONTEXT. */
833 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
834 block OB. If REF_P is true, write a reference to EXPR's pointer
838 write_ts_binfo_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
843 /* Note that the number of BINFO slots has already been emitted in
844 EXPR's header (see streamer_write_tree_header) because this length
845 is needed to build the empty BINFO node on the reader side. */
846 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr
), i
, t
)
847 stream_write_tree (ob
, t
, ref_p
);
848 stream_write_tree (ob
, NULL_TREE
, false);
850 stream_write_tree (ob
, BINFO_OFFSET (expr
), ref_p
);
851 stream_write_tree (ob
, BINFO_VTABLE (expr
), ref_p
);
852 stream_write_tree (ob
, BINFO_VPTR_FIELD (expr
), ref_p
);
854 /* The number of BINFO_BASE_ACCESSES has already been emitted in
855 EXPR's bitfield section. */
856 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (expr
), i
, t
)
857 stream_write_tree (ob
, t
, ref_p
);
859 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
860 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
864 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
865 output block OB. If REF_P is true, write a reference to EXPR's
869 write_ts_constructor_tree_pointers (struct output_block
*ob
, tree expr
,
875 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr
), i
, index
, value
)
877 stream_write_tree (ob
, index
, ref_p
);
878 stream_write_tree (ob
, value
, ref_p
);
883 /* Write all pointer fields in the TS_OMP_CLAUSE structure of EXPR
884 to output block OB. If REF_P is true, write a reference to EXPR's
888 write_ts_omp_clause_tree_pointers (struct output_block
*ob
, tree expr
,
892 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (expr
)]; i
++)
893 stream_write_tree (ob
, OMP_CLAUSE_OPERAND (expr
, i
), ref_p
);
894 if (OMP_CLAUSE_CODE (expr
) == OMP_CLAUSE_REDUCTION
)
896 /* We don't stream these right now, handle it if streaming
897 of them is needed. */
898 gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (expr
) == NULL
);
899 gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (expr
) == NULL
);
901 stream_write_tree (ob
, OMP_CLAUSE_CHAIN (expr
), ref_p
);
905 /* Write all pointer fields in EXPR to output block OB. If REF_P is true,
906 the leaves of EXPR are emitted as references. */
909 streamer_write_tree_body (struct output_block
*ob
, tree expr
, bool ref_p
)
913 lto_stats
.num_tree_bodies_output
++;
915 code
= TREE_CODE (expr
);
917 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
918 write_ts_common_tree_pointers (ob
, expr
, ref_p
);
920 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
921 write_ts_vector_tree_pointers (ob
, expr
, ref_p
);
923 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
924 write_ts_complex_tree_pointers (ob
, expr
, ref_p
);
926 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
927 write_ts_decl_minimal_tree_pointers (ob
, expr
, ref_p
);
929 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
930 write_ts_decl_common_tree_pointers (ob
, expr
, ref_p
);
932 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
933 write_ts_decl_non_common_tree_pointers (ob
, expr
, ref_p
);
935 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
936 write_ts_decl_with_vis_tree_pointers (ob
, expr
, ref_p
);
938 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
939 write_ts_field_decl_tree_pointers (ob
, expr
, ref_p
);
941 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
942 write_ts_function_decl_tree_pointers (ob
, expr
, ref_p
);
944 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
945 write_ts_type_common_tree_pointers (ob
, expr
, ref_p
);
947 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
948 write_ts_type_non_common_tree_pointers (ob
, expr
, ref_p
);
950 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
951 write_ts_list_tree_pointers (ob
, expr
, ref_p
);
953 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
954 write_ts_vec_tree_pointers (ob
, expr
, ref_p
);
956 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
957 write_ts_exp_tree_pointers (ob
, expr
, ref_p
);
959 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
960 write_ts_block_tree_pointers (ob
, expr
, ref_p
);
962 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
963 write_ts_binfo_tree_pointers (ob
, expr
, ref_p
);
965 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
966 write_ts_constructor_tree_pointers (ob
, expr
, ref_p
);
968 if (code
== OMP_CLAUSE
)
969 write_ts_omp_clause_tree_pointers (ob
, expr
, ref_p
);
973 /* Emit header information for tree EXPR to output block OB. The header
974 contains everything needed to instantiate an empty skeleton for
975 EXPR on the reading side. IX is the index into the streamer cache
976 where EXPR is stored. */
979 streamer_write_tree_header (struct output_block
*ob
, tree expr
)
984 /* We should not see any tree nodes not handled by the streamer. */
985 code
= TREE_CODE (expr
);
987 /* The header of a tree node consists of its tag, the size of
988 the node, and any other information needed to instantiate
989 EXPR on the reading side (such as the number of slots in
990 variable sized nodes). */
991 tag
= lto_tree_code_to_tag (code
);
992 streamer_write_record_start (ob
, tag
);
994 /* The following will cause bootstrap miscomparisons. Enable with care. */
995 #ifdef LTO_STREAMER_DEBUG
996 /* This is used mainly for debugging purposes. When the reader
997 and the writer do not agree on a streamed node, the pointer
998 value for EXPR can be used to track down the differences in
1000 gcc_assert ((HOST_WIDE_INT
) (intptr_t) expr
== (intptr_t) expr
);
1001 streamer_write_hwi (ob
, (HOST_WIDE_INT
) (intptr_t) expr
);
1004 /* The text in strings and identifiers are completely emitted in
1006 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
1007 streamer_write_string_cst (ob
, ob
->main_stream
, expr
);
1008 else if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
1009 write_identifier (ob
, ob
->main_stream
, expr
);
1010 else if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
1011 streamer_write_hwi (ob
, VECTOR_CST_NELTS (expr
));
1012 else if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1013 streamer_write_hwi (ob
, TREE_VEC_LENGTH (expr
));
1014 else if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1015 streamer_write_uhwi (ob
, BINFO_N_BASE_BINFOS (expr
));
1016 else if (TREE_CODE (expr
) == CALL_EXPR
)
1017 streamer_write_uhwi (ob
, call_expr_nargs (expr
));
1018 else if (TREE_CODE (expr
) == OMP_CLAUSE
)
1019 streamer_write_uhwi (ob
, OMP_CLAUSE_CODE (expr
));
1020 else if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
1022 gcc_checking_assert (TREE_INT_CST_NUNITS (expr
));
1023 streamer_write_uhwi (ob
, TREE_INT_CST_NUNITS (expr
));
1024 streamer_write_uhwi (ob
, TREE_INT_CST_EXT_NUNITS (expr
));
1029 /* Emit the integer constant CST to output block OB. If REF_P is true,
1030 CST's type will be emitted as a reference. */
1033 streamer_write_integer_cst (struct output_block
*ob
, tree cst
, bool ref_p
)
1036 int len
= TREE_INT_CST_NUNITS (cst
);
1037 gcc_assert (!TREE_OVERFLOW (cst
));
1038 streamer_write_record_start (ob
, LTO_integer_cst
);
1039 stream_write_tree (ob
, TREE_TYPE (cst
), ref_p
);
1040 /* We're effectively streaming a non-sign-extended wide_int here,
1041 so there's no need to stream TREE_INT_CST_EXT_NUNITS or any
1042 array members beyond LEN. We'll recreate the tree from the
1043 wide_int and the type. */
1044 streamer_write_uhwi (ob
, len
);
1045 for (i
= 0; i
< len
; i
++)
1046 streamer_write_hwi (ob
, TREE_INT_CST_ELT (cst
, i
));