2018-11-09 Richard Biener <rguenther@suse.de>
[official-gcc.git] / gcc / tree-streamer-out.c
blobac798a3e9344e6bb349773f68e14f85d966cc487
1 /* Routines for emitting trees to a file stream.
3 Copyright (C) 2011-2018 Free Software Foundation, Inc.
4 Contributed by Diego Novillo <dnovillo@google.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
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
16 for more details.
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/>. */
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "backend.h"
26 #include "target.h"
27 #include "tree.h"
28 #include "gimple.h"
29 #include "tree-streamer.h"
30 #include "cgraph.h"
31 #include "alias.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. */
39 void
40 streamer_write_string_cst (struct output_block *ob,
41 struct lto_output_stream *index_stream,
42 tree string)
44 streamer_write_string_with_length (ob, index_stream,
45 string ? TREE_STRING_POINTER (string)
46 : NULL,
47 string ? TREE_STRING_LENGTH (string) : 0,
48 true);
52 /* Output the identifier ID to the string
53 table in OB. Then put the index onto the INDEX_STREAM. */
55 static void
56 write_identifier (struct output_block *ob,
57 struct lto_output_stream *index_stream,
58 tree id)
60 streamer_write_string_with_length (ob, index_stream,
61 IDENTIFIER_POINTER (id),
62 IDENTIFIER_LENGTH (id),
63 true);
67 /* Pack all the non-pointer fields of the TS_BASE structure of
68 expression EXPR into bitpack BP. */
70 static inline void
71 pack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
73 bp_pack_value (bp, TREE_CODE (expr), 16);
74 if (!TYPE_P (expr))
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);
85 else
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);
89 if (DECL_P (expr))
91 bp_pack_value (bp, DECL_UNSIGNED (expr), 1);
92 bp_pack_value (bp, DECL_NAMELESS (expr), 1);
94 else if (TYPE_P (expr))
95 bp_pack_value (bp, TYPE_UNSIGNED (expr), 1);
96 else
97 bp_pack_value (bp, 0, 1);
98 /* We write debug info two times, do not confuse the second one.
99 The only relevant TREE_ASM_WRITTEN use is on SSA names. */
100 bp_pack_value (bp, (TREE_CODE (expr) != SSA_NAME
101 ? 0 : TREE_ASM_WRITTEN (expr)), 1);
102 if (TYPE_P (expr))
103 bp_pack_value (bp, TYPE_ARTIFICIAL (expr), 1);
104 else
105 bp_pack_value (bp, TREE_NO_WARNING (expr), 1);
106 bp_pack_value (bp, TREE_NOTHROW (expr), 1);
107 bp_pack_value (bp, TREE_STATIC (expr), 1);
108 if (TREE_CODE (expr) != TREE_BINFO)
109 bp_pack_value (bp, TREE_PRIVATE (expr), 1);
110 else
111 bp_pack_value (bp, 0, 1);
112 bp_pack_value (bp, TREE_PROTECTED (expr), 1);
113 bp_pack_value (bp, TREE_DEPRECATED (expr), 1);
114 if (TYPE_P (expr))
116 if (AGGREGATE_TYPE_P (expr))
117 bp_pack_value (bp, TYPE_REVERSE_STORAGE_ORDER (expr), 1);
118 else
119 bp_pack_value (bp, TYPE_SATURATING (expr), 1);
120 bp_pack_value (bp, TYPE_ADDR_SPACE (expr), 8);
122 else if (TREE_CODE (expr) == BIT_FIELD_REF || TREE_CODE (expr) == MEM_REF)
124 bp_pack_value (bp, REF_REVERSE_STORAGE_ORDER (expr), 1);
125 bp_pack_value (bp, 0, 8);
127 else if (TREE_CODE (expr) == SSA_NAME)
129 bp_pack_value (bp, SSA_NAME_IS_DEFAULT_DEF (expr), 1);
130 bp_pack_value (bp, 0, 8);
132 else
133 bp_pack_value (bp, 0, 9);
137 /* Pack all the non-pointer fields of the TS_INTEGER_CST structure of
138 expression EXPR into bitpack BP. */
140 static void
141 pack_ts_int_cst_value_fields (struct bitpack_d *bp, tree expr)
143 int i;
144 /* Note that the number of elements has already been written out in
145 streamer_write_tree_header. */
146 for (i = 0; i < TREE_INT_CST_EXT_NUNITS (expr); i++)
147 bp_pack_var_len_int (bp, TREE_INT_CST_ELT (expr, i));
151 /* Pack all the non-pointer fields of the TS_REAL_CST structure of
152 expression EXPR into bitpack BP. */
154 static void
155 pack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
157 unsigned i;
158 REAL_VALUE_TYPE r;
160 r = TREE_REAL_CST (expr);
161 bp_pack_value (bp, r.cl, 2);
162 bp_pack_value (bp, r.decimal, 1);
163 bp_pack_value (bp, r.sign, 1);
164 bp_pack_value (bp, r.signalling, 1);
165 bp_pack_value (bp, r.canonical, 1);
166 bp_pack_value (bp, r.uexp, EXP_BITS);
167 for (i = 0; i < SIGSZ; i++)
168 bp_pack_value (bp, r.sig[i], HOST_BITS_PER_LONG);
172 /* Pack all the non-pointer fields of the TS_FIXED_CST structure of
173 expression EXPR into bitpack BP. */
175 static void
176 pack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr)
178 struct fixed_value fv = TREE_FIXED_CST (expr);
179 bp_pack_machine_mode (bp, fv.mode);
180 bp_pack_var_len_int (bp, fv.data.low);
181 bp_pack_var_len_int (bp, fv.data.high);
184 /* Pack all the non-pointer fields of the TS_DECL_COMMON structure
185 of expression EXPR into bitpack BP. */
187 static void
188 pack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr)
190 bp_pack_machine_mode (bp, DECL_MODE (expr));
191 bp_pack_value (bp, DECL_NONLOCAL (expr), 1);
192 bp_pack_value (bp, DECL_VIRTUAL_P (expr), 1);
193 bp_pack_value (bp, DECL_IGNORED_P (expr), 1);
194 bp_pack_value (bp, DECL_ABSTRACT_P (expr), 1);
195 bp_pack_value (bp, DECL_ARTIFICIAL (expr), 1);
196 bp_pack_value (bp, DECL_USER_ALIGN (expr), 1);
197 bp_pack_value (bp, DECL_PRESERVE_P (expr), 1);
198 bp_pack_value (bp, DECL_EXTERNAL (expr), 1);
199 bp_pack_value (bp, DECL_GIMPLE_REG_P (expr), 1);
200 bp_pack_var_len_unsigned (bp, DECL_ALIGN (expr));
202 if (TREE_CODE (expr) == LABEL_DECL)
204 /* Note that we do not write LABEL_DECL_UID. The reader will
205 always assume an initial value of -1 so that the
206 label_to_block_map is recreated by gimple_set_bb. */
207 bp_pack_var_len_unsigned (bp, EH_LANDING_PAD_NR (expr));
210 if (TREE_CODE (expr) == FIELD_DECL)
212 bp_pack_value (bp, DECL_PACKED (expr), 1);
213 bp_pack_value (bp, DECL_NONADDRESSABLE_P (expr), 1);
214 bp_pack_value (bp, DECL_PADDING_P (expr), 1);
215 bp_pack_value (bp, expr->decl_common.off_align, 8);
218 if (VAR_P (expr))
220 bp_pack_value (bp, DECL_HAS_DEBUG_EXPR_P (expr), 1);
221 bp_pack_value (bp, DECL_NONLOCAL_FRAME (expr), 1);
224 if (TREE_CODE (expr) == RESULT_DECL
225 || TREE_CODE (expr) == PARM_DECL
226 || VAR_P (expr))
228 bp_pack_value (bp, DECL_BY_REFERENCE (expr), 1);
229 if (VAR_P (expr) || TREE_CODE (expr) == PARM_DECL)
230 bp_pack_value (bp, DECL_HAS_VALUE_EXPR_P (expr), 1);
235 /* Pack all the non-pointer fields of the TS_DECL_WRTL structure
236 of expression EXPR into bitpack BP. */
238 static void
239 pack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
241 bp_pack_value (bp, DECL_REGISTER (expr), 1);
245 /* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
246 of expression EXPR into bitpack BP. */
248 static void
249 pack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
251 bp_pack_value (bp, DECL_COMMON (expr), 1);
252 bp_pack_value (bp, DECL_DLLIMPORT_P (expr), 1);
253 bp_pack_value (bp, DECL_WEAK (expr), 1);
254 bp_pack_value (bp, DECL_SEEN_IN_BIND_EXPR_P (expr), 1);
255 bp_pack_value (bp, DECL_COMDAT (expr), 1);
256 bp_pack_value (bp, DECL_VISIBILITY (expr), 2);
257 bp_pack_value (bp, DECL_VISIBILITY_SPECIFIED (expr), 1);
259 if (VAR_P (expr))
261 bp_pack_value (bp, DECL_HARD_REGISTER (expr), 1);
262 /* DECL_IN_TEXT_SECTION is set during final asm output only. */
263 bp_pack_value (bp, DECL_IN_CONSTANT_POOL (expr), 1);
266 if (TREE_CODE (expr) == FUNCTION_DECL)
268 bp_pack_value (bp, DECL_FINAL_P (expr), 1);
269 bp_pack_value (bp, DECL_CXX_CONSTRUCTOR_P (expr), 1);
270 bp_pack_value (bp, DECL_CXX_DESTRUCTOR_P (expr), 1);
275 /* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure
276 of expression EXPR into bitpack BP. */
278 static void
279 pack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
281 bp_pack_enum (bp, built_in_class, BUILT_IN_LAST,
282 DECL_BUILT_IN_CLASS (expr));
283 bp_pack_value (bp, DECL_STATIC_CONSTRUCTOR (expr), 1);
284 bp_pack_value (bp, DECL_STATIC_DESTRUCTOR (expr), 1);
285 bp_pack_value (bp, DECL_UNINLINABLE (expr), 1);
286 bp_pack_value (bp, DECL_POSSIBLY_INLINED (expr), 1);
287 bp_pack_value (bp, DECL_IS_NOVOPS (expr), 1);
288 bp_pack_value (bp, DECL_IS_RETURNS_TWICE (expr), 1);
289 bp_pack_value (bp, DECL_IS_MALLOC (expr), 1);
290 bp_pack_value (bp, DECL_IS_OPERATOR_NEW (expr), 1);
291 bp_pack_value (bp, DECL_DECLARED_INLINE_P (expr), 1);
292 bp_pack_value (bp, DECL_STATIC_CHAIN (expr), 1);
293 bp_pack_value (bp, DECL_NO_INLINE_WARNING_P (expr), 1);
294 bp_pack_value (bp, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr), 1);
295 bp_pack_value (bp, DECL_NO_LIMIT_STACK (expr), 1);
296 bp_pack_value (bp, DECL_DISREGARD_INLINE_LIMITS (expr), 1);
297 bp_pack_value (bp, DECL_PURE_P (expr), 1);
298 bp_pack_value (bp, DECL_LOOPING_CONST_OR_PURE_P (expr), 1);
299 if (DECL_BUILT_IN_CLASS (expr) != NOT_BUILT_IN)
300 bp_pack_value (bp, DECL_FUNCTION_CODE (expr), 12);
304 /* Pack all the non-pointer fields of the TS_TYPE_COMMON structure
305 of expression EXPR into bitpack BP. */
307 static void
308 pack_ts_type_common_value_fields (struct bitpack_d *bp, tree expr)
310 /* for VECTOR_TYPE, TYPE_MODE reevaluates the mode using target_flags
311 not necessary valid in a global context.
312 Use the raw value previously set by layout_type. */
313 bp_pack_machine_mode (bp, TYPE_MODE_RAW (expr));
314 bp_pack_value (bp, TYPE_STRING_FLAG (expr), 1);
315 /* TYPE_NO_FORCE_BLK is private to stor-layout and need
316 no streaming. */
317 bp_pack_value (bp, TYPE_PACKED (expr), 1);
318 bp_pack_value (bp, TYPE_RESTRICT (expr), 1);
319 bp_pack_value (bp, TYPE_USER_ALIGN (expr), 1);
320 bp_pack_value (bp, TYPE_READONLY (expr), 1);
321 /* We used to stream TYPE_ALIAS_SET == 0 information to let frontends mark
322 types that are opaque for TBAA. This however did not work as intended,
323 because TYPE_ALIAS_SET == 0 was regularly lost in type merging. */
324 if (RECORD_OR_UNION_TYPE_P (expr))
326 bp_pack_value (bp, TYPE_TRANSPARENT_AGGR (expr), 1);
327 bp_pack_value (bp, TYPE_FINAL_P (expr), 1);
329 else if (TREE_CODE (expr) == ARRAY_TYPE)
330 bp_pack_value (bp, TYPE_NONALIASED_COMPONENT (expr), 1);
331 if (AGGREGATE_TYPE_P (expr))
332 bp_pack_value (bp, TYPE_TYPELESS_STORAGE (expr), 1);
333 bp_pack_value (bp, TYPE_EMPTY_P (expr), 1);
334 bp_pack_var_len_unsigned (bp, TYPE_PRECISION (expr));
335 bp_pack_var_len_unsigned (bp, TYPE_ALIGN (expr));
339 /* Pack all the non-pointer fields of the TS_BLOCK structure
340 of expression EXPR into bitpack BP. */
342 static void
343 pack_ts_block_value_fields (struct output_block *ob,
344 struct bitpack_d *bp, tree expr)
346 /* BLOCK_NUMBER is recomputed. */
347 /* Stream BLOCK_SOURCE_LOCATION for the limited cases we can handle - those
348 that represent inlined function scopes.
349 For the rest them on the floor instead of ICEing in dwarf2out.c. */
350 if (inlined_function_outer_scope_p (expr))
351 stream_output_location (ob, bp, BLOCK_SOURCE_LOCATION (expr));
352 else
353 stream_output_location (ob, bp, UNKNOWN_LOCATION);
356 /* Pack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL structure
357 of expression EXPR into bitpack BP. */
359 static void
360 pack_ts_translation_unit_decl_value_fields (struct output_block *ob,
361 struct bitpack_d *bp, tree expr)
363 bp_pack_string (ob, bp, TRANSLATION_UNIT_LANGUAGE (expr), true);
367 /* Pack all the non-pointer fields of the TS_OMP_CLAUSE structure
368 of expression EXPR into bitpack BP. */
370 static void
371 pack_ts_omp_clause_value_fields (struct output_block *ob,
372 struct bitpack_d *bp, tree expr)
374 stream_output_location (ob, bp, OMP_CLAUSE_LOCATION (expr));
375 switch (OMP_CLAUSE_CODE (expr))
377 case OMP_CLAUSE_DEFAULT:
378 bp_pack_enum (bp, omp_clause_default_kind, OMP_CLAUSE_DEFAULT_LAST,
379 OMP_CLAUSE_DEFAULT_KIND (expr));
380 break;
381 case OMP_CLAUSE_SCHEDULE:
382 bp_pack_enum (bp, omp_clause_schedule_kind, OMP_CLAUSE_SCHEDULE_LAST,
383 OMP_CLAUSE_SCHEDULE_KIND (expr));
384 break;
385 case OMP_CLAUSE_DEPEND:
386 bp_pack_enum (bp, omp_clause_depend_kind, OMP_CLAUSE_DEPEND_LAST,
387 OMP_CLAUSE_DEPEND_KIND (expr));
388 break;
389 case OMP_CLAUSE_MAP:
390 bp_pack_enum (bp, gomp_map_kind, GOMP_MAP_LAST,
391 OMP_CLAUSE_MAP_KIND (expr));
392 break;
393 case OMP_CLAUSE_PROC_BIND:
394 bp_pack_enum (bp, omp_clause_proc_bind_kind, OMP_CLAUSE_PROC_BIND_LAST,
395 OMP_CLAUSE_PROC_BIND_KIND (expr));
396 break;
397 case OMP_CLAUSE_REDUCTION:
398 case OMP_CLAUSE_TASK_REDUCTION:
399 case OMP_CLAUSE_IN_REDUCTION:
400 bp_pack_enum (bp, tree_code, MAX_TREE_CODES,
401 OMP_CLAUSE_REDUCTION_CODE (expr));
402 break;
403 default:
404 break;
409 /* Pack all the bitfields in EXPR into a bit pack. */
411 void
412 streamer_write_tree_bitfields (struct output_block *ob, tree expr)
414 bitpack_d bp = bitpack_create (ob->main_stream);
415 enum tree_code code;
417 code = TREE_CODE (expr);
419 /* Note that all these functions are highly sensitive to changes in
420 the types and sizes of each of the fields being packed. */
421 pack_ts_base_value_fields (&bp, expr);
423 if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
424 pack_ts_int_cst_value_fields (&bp, expr);
426 if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
427 pack_ts_real_cst_value_fields (&bp, expr);
429 if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
430 pack_ts_fixed_cst_value_fields (&bp, expr);
432 if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
433 stream_output_location (ob, &bp, DECL_SOURCE_LOCATION (expr));
435 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
436 pack_ts_decl_common_value_fields (&bp, expr);
438 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
439 pack_ts_decl_wrtl_value_fields (&bp, expr);
441 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
442 pack_ts_decl_with_vis_value_fields (&bp, expr);
444 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
445 pack_ts_function_decl_value_fields (&bp, expr);
447 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
448 pack_ts_type_common_value_fields (&bp, expr);
450 if (CODE_CONTAINS_STRUCT (code, TS_EXP))
452 stream_output_location (ob, &bp, EXPR_LOCATION (expr));
453 if (code == MEM_REF
454 || code == TARGET_MEM_REF)
456 bp_pack_value (&bp, MR_DEPENDENCE_CLIQUE (expr), sizeof (short) * 8);
457 if (MR_DEPENDENCE_CLIQUE (expr) != 0)
458 bp_pack_value (&bp, MR_DEPENDENCE_BASE (expr), sizeof (short) * 8);
462 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
463 pack_ts_block_value_fields (ob, &bp, expr);
465 if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
466 pack_ts_translation_unit_decl_value_fields (ob, &bp, expr);
468 if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
469 cl_optimization_stream_out (ob, &bp, TREE_OPTIMIZATION (expr));
471 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
472 bp_pack_var_len_unsigned (&bp, CONSTRUCTOR_NELTS (expr));
474 if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION)
475 /* Don't stream these when passing things to a different target. */
476 && !lto_stream_offload_p)
477 cl_target_option_stream_out (ob, &bp, TREE_TARGET_OPTION (expr));
479 if (code == OMP_CLAUSE)
480 pack_ts_omp_clause_value_fields (ob, &bp, expr);
482 streamer_write_bitpack (&bp);
486 /* Emit the chain of tree nodes starting at T. OB is the output block
487 to write to. REF_P is true if chain elements should be emitted
488 as references. */
490 void
491 streamer_write_chain (struct output_block *ob, tree t, bool ref_p)
493 while (t)
495 /* We avoid outputting external vars or functions by reference
496 to the global decls section as we do not want to have them
497 enter decl merging. We should not need to do this anymore because
498 free_lang_data removes them from block scopes. */
499 gcc_assert (!VAR_OR_FUNCTION_DECL_P (t) || !DECL_EXTERNAL (t));
500 stream_write_tree (ob, t, ref_p);
502 t = TREE_CHAIN (t);
505 /* Write a sentinel to terminate the chain. */
506 stream_write_tree (ob, NULL_TREE, ref_p);
510 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
511 block OB. If REF_P is true, write a reference to EXPR's pointer
512 fields. */
514 static void
515 write_ts_common_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
517 if (TREE_CODE (expr) != IDENTIFIER_NODE)
518 stream_write_tree (ob, TREE_TYPE (expr), ref_p);
522 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
523 block OB. If REF_P is true, write a reference to EXPR's pointer
524 fields. */
526 static void
527 write_ts_vector_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
529 /* Note that the number of elements for EXPR has already been emitted
530 in EXPR's header (see streamer_write_tree_header). */
531 unsigned int count = vector_cst_encoded_nelts (expr);
532 for (unsigned int i = 0; i < count; ++i)
533 stream_write_tree (ob, VECTOR_CST_ENCODED_ELT (expr, i), ref_p);
537 /* Write all pointer fields in the TS_POLY_INT_CST structure of EXPR to
538 output block OB. If REF_P is true, write a reference to EXPR's pointer
539 fields. */
541 static void
542 write_ts_poly_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
544 for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
545 stream_write_tree (ob, POLY_INT_CST_COEFF (expr, i), ref_p);
549 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
550 block OB. If REF_P is true, write a reference to EXPR's pointer
551 fields. */
553 static void
554 write_ts_complex_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
556 stream_write_tree (ob, TREE_REALPART (expr), ref_p);
557 stream_write_tree (ob, TREE_IMAGPART (expr), ref_p);
561 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
562 to output block OB. If REF_P is true, write a reference to EXPR's
563 pointer fields. */
565 static void
566 write_ts_decl_minimal_tree_pointers (struct output_block *ob, tree expr,
567 bool ref_p)
569 /* Drop names that were created for anonymous entities. */
570 if (DECL_NAME (expr)
571 && TREE_CODE (DECL_NAME (expr)) == IDENTIFIER_NODE
572 && anon_aggrname_p (DECL_NAME (expr)))
573 stream_write_tree (ob, NULL_TREE, ref_p);
574 else
575 stream_write_tree (ob, DECL_NAME (expr), ref_p);
576 if (TREE_CODE (expr) != TRANSLATION_UNIT_DECL
577 && ! DECL_CONTEXT (expr))
578 stream_write_tree (ob, (*all_translation_units)[0], ref_p);
579 else
580 stream_write_tree (ob, DECL_CONTEXT (expr), ref_p);
584 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
585 output block OB. If REF_P is true, write a reference to EXPR's
586 pointer fields. */
588 static void
589 write_ts_decl_common_tree_pointers (struct output_block *ob, tree expr,
590 bool ref_p)
592 stream_write_tree (ob, DECL_SIZE (expr), ref_p);
593 stream_write_tree (ob, DECL_SIZE_UNIT (expr), ref_p);
595 /* Note, DECL_INITIAL is not handled here. Since DECL_INITIAL needs
596 special handling in LTO, it must be handled by streamer hooks. */
598 stream_write_tree (ob, DECL_ATTRIBUTES (expr), ref_p);
599 stream_write_tree (ob, DECL_ABSTRACT_ORIGIN (expr), ref_p);
601 if ((VAR_P (expr) || TREE_CODE (expr) == PARM_DECL)
602 && DECL_HAS_VALUE_EXPR_P (expr))
603 stream_write_tree (ob, DECL_VALUE_EXPR (expr), ref_p);
605 if (VAR_P (expr)
606 && DECL_HAS_DEBUG_EXPR_P (expr))
607 stream_write_tree (ob, DECL_DEBUG_EXPR (expr), ref_p);
611 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
612 EXPR to output block OB. If REF_P is true, write a reference to EXPR's
613 pointer fields. */
615 static void
616 write_ts_decl_non_common_tree_pointers (struct output_block *, tree, bool)
621 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
622 to output block OB. If REF_P is true, write a reference to EXPR's
623 pointer fields. */
625 static void
626 write_ts_decl_with_vis_tree_pointers (struct output_block *ob, tree expr,
627 bool ref_p)
629 /* Make sure we don't inadvertently set the assembler name. */
630 if (DECL_ASSEMBLER_NAME_SET_P (expr))
631 stream_write_tree (ob, DECL_ASSEMBLER_NAME (expr), ref_p);
632 else
633 stream_write_tree (ob, NULL_TREE, false);
637 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
638 output block OB. If REF_P is true, write a reference to EXPR's
639 pointer fields. */
641 static void
642 write_ts_field_decl_tree_pointers (struct output_block *ob, tree expr,
643 bool ref_p)
645 stream_write_tree (ob, DECL_FIELD_OFFSET (expr), ref_p);
646 stream_write_tree (ob, DECL_BIT_FIELD_TYPE (expr), ref_p);
647 stream_write_tree (ob, DECL_BIT_FIELD_REPRESENTATIVE (expr), ref_p);
648 stream_write_tree (ob, DECL_FIELD_BIT_OFFSET (expr), ref_p);
652 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
653 to output block OB. If REF_P is true, write a reference to EXPR's
654 pointer fields. */
656 static void
657 write_ts_function_decl_tree_pointers (struct output_block *ob, tree expr,
658 bool ref_p)
660 /* DECL_STRUCT_FUNCTION is handled by lto_output_function. */
661 stream_write_tree (ob, DECL_FUNCTION_PERSONALITY (expr), ref_p);
662 /* Don't stream these when passing things to a different target. */
663 if (!lto_stream_offload_p)
664 stream_write_tree (ob, DECL_FUNCTION_SPECIFIC_TARGET (expr), ref_p);
665 stream_write_tree (ob, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr), ref_p);
669 /* Write all pointer fields in the TS_TYPE_COMMON structure of EXPR to
670 output block OB. If REF_P is true, write a reference to EXPR's
671 pointer fields. */
673 static void
674 write_ts_type_common_tree_pointers (struct output_block *ob, tree expr,
675 bool ref_p)
677 stream_write_tree (ob, TYPE_SIZE (expr), ref_p);
678 stream_write_tree (ob, TYPE_SIZE_UNIT (expr), ref_p);
679 stream_write_tree (ob, TYPE_ATTRIBUTES (expr), ref_p);
680 stream_write_tree (ob, TYPE_NAME (expr), ref_p);
681 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
682 reconstructed during fixup. */
683 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
684 during fixup. */
685 stream_write_tree (ob, TYPE_MAIN_VARIANT (expr), ref_p);
686 stream_write_tree (ob, TYPE_CONTEXT (expr), ref_p);
687 /* TYPE_CANONICAL is re-computed during type merging, so no need
688 to stream it here. */
689 /* Do not stream TYPE_STUB_DECL; it is not needed by LTO but currently
690 it can not be freed by free_lang_data without triggering ICEs in
691 langhooks. */
694 /* Write all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
695 to output block OB. If REF_P is true, write a reference to EXPR's
696 pointer fields. */
698 static void
699 write_ts_type_non_common_tree_pointers (struct output_block *ob, tree expr,
700 bool ref_p)
702 if (TREE_CODE (expr) == ENUMERAL_TYPE)
703 stream_write_tree (ob, TYPE_VALUES (expr), ref_p);
704 else if (TREE_CODE (expr) == ARRAY_TYPE)
705 stream_write_tree (ob, TYPE_DOMAIN (expr), ref_p);
706 else if (RECORD_OR_UNION_TYPE_P (expr))
707 streamer_write_chain (ob, TYPE_FIELDS (expr), ref_p);
708 else if (TREE_CODE (expr) == FUNCTION_TYPE
709 || TREE_CODE (expr) == METHOD_TYPE)
710 stream_write_tree (ob, TYPE_ARG_TYPES (expr), ref_p);
712 if (!POINTER_TYPE_P (expr))
713 stream_write_tree (ob, TYPE_MIN_VALUE_RAW (expr), ref_p);
714 stream_write_tree (ob, TYPE_MAX_VALUE_RAW (expr), ref_p);
718 /* Write all pointer fields in the TS_LIST structure of EXPR to output
719 block OB. If REF_P is true, write a reference to EXPR's pointer
720 fields. */
722 static void
723 write_ts_list_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
725 stream_write_tree (ob, TREE_PURPOSE (expr), ref_p);
726 stream_write_tree (ob, TREE_VALUE (expr), ref_p);
727 stream_write_tree (ob, TREE_CHAIN (expr), ref_p);
731 /* Write all pointer fields in the TS_VEC structure of EXPR to output
732 block OB. If REF_P is true, write a reference to EXPR's pointer
733 fields. */
735 static void
736 write_ts_vec_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
738 int i;
740 /* Note that the number of slots for EXPR has already been emitted
741 in EXPR's header (see streamer_write_tree_header). */
742 for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
743 stream_write_tree (ob, TREE_VEC_ELT (expr, i), ref_p);
747 /* Write all pointer fields in the TS_EXP structure of EXPR to output
748 block OB. If REF_P is true, write a reference to EXPR's pointer
749 fields. */
751 static void
752 write_ts_exp_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
754 int i;
756 for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
757 stream_write_tree (ob, TREE_OPERAND (expr, i), ref_p);
758 stream_write_tree (ob, TREE_BLOCK (expr), ref_p);
762 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
763 block OB. If REF_P is true, write a reference to EXPR's pointer
764 fields. */
766 static void
767 write_ts_block_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
769 streamer_write_chain (ob, BLOCK_VARS (expr), ref_p);
771 stream_write_tree (ob, BLOCK_SUPERCONTEXT (expr), ref_p);
772 stream_write_tree (ob, BLOCK_ABSTRACT_ORIGIN (expr), ref_p);
774 /* Do not stream BLOCK_NONLOCALIZED_VARS. We cannot handle debug information
775 for early inlined BLOCKs so drop it on the floor instead of ICEing in
776 dwarf2out.c. */
778 /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
779 streaming time. */
781 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
782 list is re-constructed from BLOCK_SUPERCONTEXT. */
786 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
787 block OB. If REF_P is true, write a reference to EXPR's pointer
788 fields. */
790 static void
791 write_ts_binfo_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
793 unsigned i;
794 tree t;
796 /* Note that the number of BINFO slots has already been emitted in
797 EXPR's header (see streamer_write_tree_header) because this length
798 is needed to build the empty BINFO node on the reader side. */
799 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr), i, t)
800 stream_write_tree (ob, t, ref_p);
801 stream_write_tree (ob, NULL_TREE, false);
803 stream_write_tree (ob, BINFO_OFFSET (expr), ref_p);
804 stream_write_tree (ob, BINFO_VTABLE (expr), ref_p);
806 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX,
807 BINFO_BASE_ACCESSES and BINFO_VPTR_INDEX; these are used by C++ FE only. */
811 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
812 output block OB. If REF_P is true, write a reference to EXPR's
813 pointer fields. */
815 static void
816 write_ts_constructor_tree_pointers (struct output_block *ob, tree expr,
817 bool ref_p)
819 unsigned i;
820 tree index, value;
822 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value)
824 stream_write_tree (ob, index, ref_p);
825 stream_write_tree (ob, value, ref_p);
830 /* Write all pointer fields in the TS_OMP_CLAUSE structure of EXPR
831 to output block OB. If REF_P is true, write a reference to EXPR's
832 pointer fields. */
834 static void
835 write_ts_omp_clause_tree_pointers (struct output_block *ob, tree expr,
836 bool ref_p)
838 int i;
839 for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (expr)]; i++)
840 stream_write_tree (ob, OMP_CLAUSE_OPERAND (expr, i), ref_p);
841 switch (OMP_CLAUSE_CODE (expr))
843 case OMP_CLAUSE_REDUCTION:
844 case OMP_CLAUSE_TASK_REDUCTION:
845 case OMP_CLAUSE_IN_REDUCTION:
846 /* We don't stream these right now, handle it if streaming
847 of them is needed. */
848 gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (expr) == NULL);
849 gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (expr) == NULL);
850 break;
851 default:
852 break;
854 stream_write_tree (ob, OMP_CLAUSE_CHAIN (expr), ref_p);
858 /* Write all pointer fields in EXPR to output block OB. If REF_P is true,
859 the leaves of EXPR are emitted as references. */
861 void
862 streamer_write_tree_body (struct output_block *ob, tree expr, bool ref_p)
864 enum tree_code code;
866 lto_stats.num_tree_bodies_output++;
868 code = TREE_CODE (expr);
870 if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
871 write_ts_common_tree_pointers (ob, expr, ref_p);
873 if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
874 write_ts_vector_tree_pointers (ob, expr, ref_p);
876 if (CODE_CONTAINS_STRUCT (code, TS_POLY_INT_CST))
877 write_ts_poly_tree_pointers (ob, expr, ref_p);
879 if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
880 write_ts_complex_tree_pointers (ob, expr, ref_p);
882 if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
883 write_ts_decl_minimal_tree_pointers (ob, expr, ref_p);
885 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
886 write_ts_decl_common_tree_pointers (ob, expr, ref_p);
888 if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
889 write_ts_decl_non_common_tree_pointers (ob, expr, ref_p);
891 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
892 write_ts_decl_with_vis_tree_pointers (ob, expr, ref_p);
894 if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
895 write_ts_field_decl_tree_pointers (ob, expr, ref_p);
897 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
898 write_ts_function_decl_tree_pointers (ob, expr, ref_p);
900 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
901 write_ts_type_common_tree_pointers (ob, expr, ref_p);
903 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
904 write_ts_type_non_common_tree_pointers (ob, expr, ref_p);
906 if (CODE_CONTAINS_STRUCT (code, TS_LIST))
907 write_ts_list_tree_pointers (ob, expr, ref_p);
909 if (CODE_CONTAINS_STRUCT (code, TS_VEC))
910 write_ts_vec_tree_pointers (ob, expr, ref_p);
912 if (CODE_CONTAINS_STRUCT (code, TS_EXP))
913 write_ts_exp_tree_pointers (ob, expr, ref_p);
915 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
916 write_ts_block_tree_pointers (ob, expr, ref_p);
918 if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
919 write_ts_binfo_tree_pointers (ob, expr, ref_p);
921 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
922 write_ts_constructor_tree_pointers (ob, expr, ref_p);
924 if (code == OMP_CLAUSE)
925 write_ts_omp_clause_tree_pointers (ob, expr, ref_p);
929 /* Emit header information for tree EXPR to output block OB. The header
930 contains everything needed to instantiate an empty skeleton for
931 EXPR on the reading side. IX is the index into the streamer cache
932 where EXPR is stored. */
934 void
935 streamer_write_tree_header (struct output_block *ob, tree expr)
937 enum LTO_tags tag;
938 enum tree_code code;
940 /* We should not see any tree nodes not handled by the streamer. */
941 code = TREE_CODE (expr);
943 /* The header of a tree node consists of its tag, the size of
944 the node, and any other information needed to instantiate
945 EXPR on the reading side (such as the number of slots in
946 variable sized nodes). */
947 tag = lto_tree_code_to_tag (code);
948 streamer_write_record_start (ob, tag);
950 /* The text in strings and identifiers are completely emitted in
951 the header. */
952 if (CODE_CONTAINS_STRUCT (code, TS_STRING))
953 streamer_write_string_cst (ob, ob->main_stream, expr);
954 else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
955 write_identifier (ob, ob->main_stream, expr);
956 else if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
958 bitpack_d bp = bitpack_create (ob->main_stream);
959 bp_pack_value (&bp, VECTOR_CST_LOG2_NPATTERNS (expr), 8);
960 bp_pack_value (&bp, VECTOR_CST_NELTS_PER_PATTERN (expr), 8);
961 streamer_write_bitpack (&bp);
963 else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
964 streamer_write_hwi (ob, TREE_VEC_LENGTH (expr));
965 else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
966 streamer_write_uhwi (ob, BINFO_N_BASE_BINFOS (expr));
967 else if (TREE_CODE (expr) == CALL_EXPR)
968 streamer_write_uhwi (ob, call_expr_nargs (expr));
969 else if (TREE_CODE (expr) == OMP_CLAUSE)
970 streamer_write_uhwi (ob, OMP_CLAUSE_CODE (expr));
971 else if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
973 gcc_checking_assert (TREE_INT_CST_NUNITS (expr));
974 streamer_write_uhwi (ob, TREE_INT_CST_NUNITS (expr));
975 streamer_write_uhwi (ob, TREE_INT_CST_EXT_NUNITS (expr));
980 /* Emit the integer constant CST to output block OB. If REF_P is true,
981 CST's type will be emitted as a reference. */
983 void
984 streamer_write_integer_cst (struct output_block *ob, tree cst, bool ref_p)
986 int i;
987 int len = TREE_INT_CST_NUNITS (cst);
988 gcc_assert (!TREE_OVERFLOW (cst));
989 streamer_write_record_start (ob, LTO_integer_cst);
990 stream_write_tree (ob, TREE_TYPE (cst), ref_p);
991 /* We're effectively streaming a non-sign-extended wide_int here,
992 so there's no need to stream TREE_INT_CST_EXT_NUNITS or any
993 array members beyond LEN. We'll recreate the tree from the
994 wide_int and the type. */
995 streamer_write_uhwi (ob, len);
996 for (i = 0; i < len; i++)
997 streamer_write_hwi (ob, TREE_INT_CST_ELT (cst, i));