1/* Routines for emitting trees to a file stream.
2
3 Copyright (C) 2011-2023 Free Software Foundation, Inc.
4 Contributed by Diego Novillo <dnovillo@google.com>
5
6This file is part of GCC.
7
8GCC is free software; you can redistribute it and/or modify it under
9the terms of the GNU General Public License as published by the Free
10Software Foundation; either version 3, or (at your option) any later
11version.
12
13GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14WARRANTY; without even the implied warranty of MERCHANTABILITY or
15FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16for more details.
17
18You should have received a copy of the GNU General Public License
19along with GCC; see the file COPYING3. If not see
20<http://www.gnu.org/licenses/>. */
21
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"
34#include "print-tree.h"
35
36
37/* Output the STRING constant to the string
38 table in OB. Then put the index onto the INDEX_STREAM. */
39
40void
41streamer_write_string_cst (struct output_block *ob,
42 struct lto_output_stream *index_stream,
43 tree string)
44{
45 streamer_write_string_with_length (ob, index_stream,
46 string ? TREE_STRING_POINTER (string)
47 : NULL,
48 string ? TREE_STRING_LENGTH (string) : 0,
49 true);
50}
51
52
53/* Output the identifier ID to the string
54 table in OB. Then put the index onto the INDEX_STREAM. */
55
56static void
57write_identifier (struct output_block *ob,
58 struct lto_output_stream *index_stream,
59 tree id)
60{
61 streamer_write_string_with_length (ob, index_stream,
62 IDENTIFIER_POINTER (id),
63 IDENTIFIER_LENGTH (id),
64 true);
65}
66
67
68/* Pack all the non-pointer fields of the TS_BASE structure of
69 expression EXPR into bitpack BP. */
70
71static inline void
72pack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
73{
74 if (streamer_debugging)
75 bp_pack_value (bp, TREE_CODE (expr), nbits: 16);
76 if (!TYPE_P (expr))
77 {
78 bp_pack_value (bp, TREE_SIDE_EFFECTS (expr), nbits: 1);
79 bp_pack_value (bp, TREE_CONSTANT (expr), nbits: 1);
80 bp_pack_value (bp, TREE_READONLY (expr), nbits: 1);
81
82 /* TREE_PUBLIC is used on types to indicate that the type
83 has a TYPE_CACHED_VALUES vector. This is not streamed out,
84 so we skip it here. */
85 bp_pack_value (bp, TREE_PUBLIC (expr), nbits: 1);
86 }
87 else
88 bp_pack_value (bp, val: 0, nbits: 4);
89 bp_pack_value (bp, TREE_ADDRESSABLE (expr), nbits: 1);
90 bp_pack_value (bp, TREE_THIS_VOLATILE (expr), nbits: 1);
91 if (DECL_P (expr))
92 {
93 bp_pack_value (bp, DECL_UNSIGNED (expr), nbits: 1);
94 bp_pack_value (bp, DECL_NAMELESS (expr), nbits: 1);
95 }
96 else if (TYPE_P (expr))
97 bp_pack_value (bp, TYPE_UNSIGNED (expr), nbits: 1);
98 else
99 bp_pack_value (bp, val: 0, nbits: 1);
100 /* We write debug info two times, do not confuse the second one.
101 The only relevant TREE_ASM_WRITTEN use is on SSA names. */
102 bp_pack_value (bp, val: (TREE_CODE (expr) != SSA_NAME
103 ? 0 : TREE_ASM_WRITTEN (expr)), nbits: 1);
104 if (TYPE_P (expr))
105 bp_pack_value (bp, TYPE_ARTIFICIAL (expr), nbits: 1);
106 else
107 bp_pack_value (bp, TREE_NO_WARNING (expr), nbits: 1);
108 bp_pack_value (bp, TREE_NOTHROW (expr), nbits: 1);
109 bp_pack_value (bp, TREE_STATIC (expr), nbits: 1);
110 if (TREE_CODE (expr) != TREE_BINFO)
111 bp_pack_value (bp, TREE_PRIVATE (expr), nbits: 1);
112 else
113 bp_pack_value (bp, val: 0, nbits: 1);
114 bp_pack_value (bp, TREE_PROTECTED (expr), nbits: 1);
115 bp_pack_value (bp, TREE_DEPRECATED (expr), nbits: 1);
116 if (TYPE_P (expr))
117 {
118 if (AGGREGATE_TYPE_P (expr))
119 bp_pack_value (bp, TYPE_REVERSE_STORAGE_ORDER (expr), nbits: 1);
120 else
121 bp_pack_value (bp, TYPE_SATURATING (expr), nbits: 1);
122 if (lto_stream_offload_p)
123 /* Host and offload targets have no common meaning of address
124 spaces. */
125 ;
126 else
127 bp_pack_value (bp, TYPE_ADDR_SPACE (expr), nbits: 8);
128 }
129 else if (TREE_CODE (expr) == BIT_FIELD_REF || TREE_CODE (expr) == MEM_REF)
130 {
131 bp_pack_value (bp, REF_REVERSE_STORAGE_ORDER (expr), nbits: 1);
132 bp_pack_value (bp, val: 0, nbits: 8);
133 }
134 else if (TREE_CODE (expr) == SSA_NAME)
135 {
136 bp_pack_value (bp, SSA_NAME_IS_DEFAULT_DEF (expr), nbits: 1);
137 bp_pack_value (bp, val: 0, nbits: 8);
138 }
139 else if (TREE_CODE (expr) == CALL_EXPR)
140 {
141 bp_pack_value (bp, CALL_EXPR_BY_DESCRIPTOR (expr), nbits: 1);
142 bp_pack_value (bp, val: 0, nbits: 8);
143 }
144 else
145 bp_pack_value (bp, val: 0, nbits: 9);
146}
147
148
149/* Pack all the non-pointer fields of the TS_INTEGER_CST structure of
150 expression EXPR into bitpack BP. */
151
152static void
153pack_ts_int_cst_value_fields (struct bitpack_d *bp, tree expr)
154{
155 int i;
156 /* Note that the number of elements has already been written out in
157 streamer_write_tree_header. */
158 for (i = 0; i < TREE_INT_CST_EXT_NUNITS (expr); i++)
159 bp_pack_var_len_int (bp, TREE_INT_CST_ELT (expr, i));
160}
161
162
163/* Pack all the non-pointer fields of the TS_REAL_CST structure of
164 expression EXPR into bitpack BP. */
165
166static void
167pack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
168{
169 REAL_VALUE_TYPE r = TREE_REAL_CST (expr);
170 bp_pack_real_value (bp, &r);
171}
172
173
174/* Pack all the non-pointer fields of the TS_FIXED_CST structure of
175 expression EXPR into bitpack BP. */
176
177static void
178pack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr)
179{
180 struct fixed_value fv = TREE_FIXED_CST (expr);
181 bp_pack_machine_mode (bp, mode: fv.mode);
182 bp_pack_var_len_int (bp, fv.data.low);
183 bp_pack_var_len_int (bp, fv.data.high);
184}
185
186/* Pack all the non-pointer fields of the TS_DECL_COMMON structure
187 of expression EXPR into bitpack BP. */
188
189static void
190pack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr)
191{
192 bp_pack_machine_mode (bp, DECL_MODE (expr));
193 bp_pack_value (bp, DECL_NONLOCAL (expr), nbits: 1);
194 bp_pack_value (bp, DECL_VIRTUAL_P (expr), nbits: 1);
195 bp_pack_value (bp, DECL_IGNORED_P (expr), nbits: 1);
196 bp_pack_value (bp, DECL_ABSTRACT_P (expr), nbits: 1);
197 bp_pack_value (bp, DECL_ARTIFICIAL (expr), nbits: 1);
198 bp_pack_value (bp, DECL_USER_ALIGN (expr), nbits: 1);
199 bp_pack_value (bp, DECL_PRESERVE_P (expr), nbits: 1);
200 bp_pack_value (bp, DECL_EXTERNAL (expr), nbits: 1);
201 bp_pack_value (bp, DECL_NOT_GIMPLE_REG_P (expr), nbits: 1);
202 bp_pack_var_len_unsigned (bp, DECL_ALIGN (expr));
203
204 if (TREE_CODE (expr) == LABEL_DECL)
205 {
206 /* Note that we do not write LABEL_DECL_UID. The reader will
207 always assume an initial value of -1 so that the
208 label_to_block_map is recreated by gimple_set_bb. */
209 bp_pack_var_len_unsigned (bp, EH_LANDING_PAD_NR (expr));
210 }
211
212 else if (TREE_CODE (expr) == FIELD_DECL)
213 {
214 bp_pack_value (bp, DECL_PACKED (expr), nbits: 1);
215 bp_pack_value (bp, DECL_NONADDRESSABLE_P (expr), nbits: 1);
216 bp_pack_value (bp, DECL_PADDING_P (expr), nbits: 1);
217 if (DECL_BIT_FIELD (expr))
218 bp_pack_value (bp, DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD (expr), nbits: 1);
219 else
220 bp_pack_value (bp, DECL_FIELD_ABI_IGNORED (expr), nbits: 1);
221 bp_pack_value (bp, val: expr->decl_common.off_align, nbits: 8);
222 bp_pack_value (bp, DECL_NOT_FLEXARRAY (expr), nbits: 1);
223 }
224
225 else if (VAR_P (expr))
226 {
227 bp_pack_value (bp, DECL_HAS_DEBUG_EXPR_P (expr), nbits: 1);
228 bp_pack_value (bp, DECL_NONLOCAL_FRAME (expr), nbits: 1);
229 }
230
231 else if (TREE_CODE (expr) == PARM_DECL)
232 bp_pack_value (bp, DECL_HIDDEN_STRING_LENGTH (expr), nbits: 1);
233
234 if (TREE_CODE (expr) == RESULT_DECL
235 || TREE_CODE (expr) == PARM_DECL
236 || VAR_P (expr))
237 {
238 bp_pack_value (bp, DECL_BY_REFERENCE (expr), nbits: 1);
239 if (VAR_P (expr) || TREE_CODE (expr) == PARM_DECL)
240 bp_pack_value (bp, DECL_HAS_VALUE_EXPR_P (expr), nbits: 1);
241 }
242}
243
244
245/* Pack all the non-pointer fields of the TS_DECL_WRTL structure
246 of expression EXPR into bitpack BP. */
247
248static void
249pack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
250{
251 bp_pack_value (bp, DECL_REGISTER (expr), nbits: 1);
252}
253
254
255/* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
256 of expression EXPR into bitpack BP. */
257
258static void
259pack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
260{
261 bp_pack_value (bp, DECL_COMMON (expr), nbits: 1);
262 bp_pack_value (bp, DECL_DLLIMPORT_P (expr), nbits: 1);
263 bp_pack_value (bp, DECL_WEAK (expr), nbits: 1);
264 bp_pack_value (bp, DECL_SEEN_IN_BIND_EXPR_P (expr), nbits: 1);
265 bp_pack_value (bp, DECL_COMDAT (expr), nbits: 1);
266 bp_pack_value (bp, DECL_VISIBILITY (expr), nbits: 2);
267 bp_pack_value (bp, DECL_VISIBILITY_SPECIFIED (expr), nbits: 1);
268
269 if (VAR_P (expr))
270 {
271 bp_pack_value (bp, DECL_HARD_REGISTER (expr), nbits: 1);
272 /* DECL_IN_TEXT_SECTION is set during final asm output only. */
273 bp_pack_value (bp, DECL_IN_CONSTANT_POOL (expr), nbits: 1);
274 }
275
276 if (TREE_CODE (expr) == FUNCTION_DECL)
277 {
278 bp_pack_value (bp, DECL_FINAL_P (expr), nbits: 1);
279 bp_pack_value (bp, DECL_CXX_CONSTRUCTOR_P (expr), nbits: 1);
280 bp_pack_value (bp, DECL_CXX_DESTRUCTOR_P (expr), nbits: 1);
281 }
282}
283
284
285/* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure
286 of expression EXPR into bitpack BP. */
287
288static void
289pack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
290{
291 bp_pack_enum (bp, built_in_class, BUILT_IN_LAST,
292 DECL_BUILT_IN_CLASS (expr));
293 bp_pack_value (bp, DECL_STATIC_CONSTRUCTOR (expr), nbits: 1);
294 bp_pack_value (bp, DECL_STATIC_DESTRUCTOR (expr), nbits: 1);
295 bp_pack_value (bp, DECL_UNINLINABLE (expr), nbits: 1);
296 bp_pack_value (bp, DECL_POSSIBLY_INLINED (expr), nbits: 1);
297 bp_pack_value (bp, DECL_IS_NOVOPS (expr), nbits: 1);
298 bp_pack_value (bp, DECL_IS_RETURNS_TWICE (expr), nbits: 1);
299 bp_pack_value (bp, DECL_IS_MALLOC (expr), nbits: 1);
300 bp_pack_value (bp, FUNCTION_DECL_DECL_TYPE (expr), nbits: 2);
301 bp_pack_value (bp, DECL_IS_OPERATOR_DELETE_P (expr), nbits: 1);
302 bp_pack_value (bp, DECL_DECLARED_INLINE_P (expr), nbits: 1);
303 bp_pack_value (bp, DECL_STATIC_CHAIN (expr), nbits: 1);
304 bp_pack_value (bp, DECL_NO_INLINE_WARNING_P (expr), nbits: 1);
305 bp_pack_value (bp, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr), nbits: 1);
306 bp_pack_value (bp, DECL_NO_LIMIT_STACK (expr), nbits: 1);
307 bp_pack_value (bp, DECL_DISREGARD_INLINE_LIMITS (expr), nbits: 1);
308 bp_pack_value (bp, DECL_PURE_P (expr), nbits: 1);
309 bp_pack_value (bp, DECL_LOOPING_CONST_OR_PURE_P (expr), nbits: 1);
310 bp_pack_value (bp, DECL_IS_REPLACEABLE_OPERATOR (expr), nbits: 1);
311 if (DECL_BUILT_IN_CLASS (expr) != NOT_BUILT_IN)
312 bp_pack_value (bp, DECL_UNCHECKED_FUNCTION_CODE (expr), nbits: 32);
313}
314
315
316/* Pack all the non-pointer fields of the TS_TYPE_COMMON structure
317 of expression EXPR into bitpack BP. */
318
319static void
320pack_ts_type_common_value_fields (struct bitpack_d *bp, tree expr)
321{
322 /* for VECTOR_TYPE, TYPE_MODE reevaluates the mode using target_flags
323 not necessary valid in a global context.
324 Use the raw value previously set by layout_type. */
325 bp_pack_machine_mode (bp, TYPE_MODE_RAW (expr));
326 /* TYPE_NO_FORCE_BLK is private to stor-layout and need
327 no streaming. */
328 bp_pack_value (bp, TYPE_PACKED (expr), nbits: 1);
329 bp_pack_value (bp, TYPE_RESTRICT (expr), nbits: 1);
330 bp_pack_value (bp, TYPE_USER_ALIGN (expr), nbits: 1);
331 bp_pack_value (bp, TYPE_READONLY (expr), nbits: 1);
332 unsigned vla_p;
333 if (in_lto_p)
334 vla_p = TYPE_LANG_FLAG_0 (TYPE_MAIN_VARIANT (expr));
335 else
336 vla_p = variably_modified_type_p (expr, NULL_TREE);
337 bp_pack_value (bp, val: vla_p, nbits: 1);
338 /* We used to stream TYPE_ALIAS_SET == 0 information to let frontends mark
339 types that are opaque for TBAA. This however did not work as intended,
340 because TYPE_ALIAS_SET == 0 was regularly lost in type merging. */
341 if (RECORD_OR_UNION_TYPE_P (expr))
342 {
343 bp_pack_value (bp, TYPE_TRANSPARENT_AGGR (expr), nbits: 1);
344 bp_pack_value (bp, TYPE_FINAL_P (expr), nbits: 1);
345 /* alias_ptr_types_compatible_p relies on fact that during LTO
346 types do not get refined from WPA time to ltrans. */
347 bp_pack_value (bp, flag_wpa && TYPE_CANONICAL (expr)
348 ? TYPE_CXX_ODR_P (TYPE_CANONICAL (expr))
349 : TYPE_CXX_ODR_P (expr), nbits: 1);
350 }
351 else if (TREE_CODE (expr) == ARRAY_TYPE)
352 bp_pack_value (bp, TYPE_NONALIASED_COMPONENT (expr), nbits: 1);
353 if (TREE_CODE (expr) == ARRAY_TYPE || TREE_CODE (expr) == INTEGER_TYPE)
354 bp_pack_value (bp, TYPE_STRING_FLAG (expr), nbits: 1);
355 if (AGGREGATE_TYPE_P (expr))
356 bp_pack_value (bp, TYPE_TYPELESS_STORAGE (expr), nbits: 1);
357 bp_pack_value (bp, TYPE_EMPTY_P (expr), nbits: 1);
358 if (FUNC_OR_METHOD_TYPE_P (expr))
359 bp_pack_value (bp, TYPE_NO_NAMED_ARGS_STDARG_P (expr), nbits: 1);
360 if (RECORD_OR_UNION_TYPE_P (expr))
361 bp_pack_value (bp, TYPE_INCLUDES_FLEXARRAY (expr), nbits: 1);
362 bp_pack_var_len_unsigned (bp, TYPE_PRECISION_RAW (expr));
363 bp_pack_var_len_unsigned (bp, TYPE_ALIGN (expr));
364}
365
366
367/* Pack all the non-pointer fields of the TS_BLOCK structure
368 of expression EXPR into bitpack BP. */
369
370static void
371pack_ts_block_value_fields (struct output_block *ob,
372 struct bitpack_d *bp, tree expr)
373{
374 /* BLOCK_NUMBER is recomputed. */
375 /* Stream BLOCK_SOURCE_LOCATION for the limited cases we can handle - those
376 that represent inlined function scopes.
377 For the rest them on the floor instead of ICEing in dwarf2out.cc. */
378 if (inlined_function_outer_scope_p (block: expr))
379 stream_output_location (ob, bp, BLOCK_SOURCE_LOCATION (expr));
380 else
381 stream_output_location (ob, bp, UNKNOWN_LOCATION);
382}
383
384/* Pack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL structure
385 of expression EXPR into bitpack BP. */
386
387static void
388pack_ts_translation_unit_decl_value_fields (struct output_block *ob,
389 struct bitpack_d *bp, tree expr)
390{
391 bp_pack_string (ob, bp, TRANSLATION_UNIT_LANGUAGE (expr), true);
392}
393
394
395/* Pack all the non-pointer fields of the TS_OMP_CLAUSE structure
396 of expression EXPR into bitpack BP. */
397
398static void
399pack_ts_omp_clause_value_fields (struct output_block *ob,
400 struct bitpack_d *bp, tree expr)
401{
402 stream_output_location (ob, bp, OMP_CLAUSE_LOCATION (expr));
403 switch (OMP_CLAUSE_CODE (expr))
404 {
405 case OMP_CLAUSE_DEFAULT:
406 bp_pack_enum (bp, omp_clause_default_kind, OMP_CLAUSE_DEFAULT_LAST,
407 OMP_CLAUSE_DEFAULT_KIND (expr));
408 break;
409 case OMP_CLAUSE_SCHEDULE:
410 bp_pack_enum (bp, omp_clause_schedule_kind, OMP_CLAUSE_SCHEDULE_LAST,
411 OMP_CLAUSE_SCHEDULE_KIND (expr));
412 break;
413 case OMP_CLAUSE_DEPEND:
414 bp_pack_enum (bp, omp_clause_depend_kind, OMP_CLAUSE_DEPEND_LAST,
415 OMP_CLAUSE_DEPEND_KIND (expr));
416 break;
417 case OMP_CLAUSE_DOACROSS:
418 bp_pack_enum (bp, omp_clause_doacross_kind, OMP_CLAUSE_DOACROSS_LAST,
419 OMP_CLAUSE_DOACROSS_KIND (expr));
420 break;
421 case OMP_CLAUSE_MAP:
422 bp_pack_enum (bp, gomp_map_kind, GOMP_MAP_LAST,
423 OMP_CLAUSE_MAP_KIND (expr));
424 break;
425 case OMP_CLAUSE_PROC_BIND:
426 bp_pack_enum (bp, omp_clause_proc_bind_kind, OMP_CLAUSE_PROC_BIND_LAST,
427 OMP_CLAUSE_PROC_BIND_KIND (expr));
428 break;
429 case OMP_CLAUSE_REDUCTION:
430 case OMP_CLAUSE_TASK_REDUCTION:
431 case OMP_CLAUSE_IN_REDUCTION:
432 bp_pack_enum (bp, tree_code, MAX_TREE_CODES,
433 OMP_CLAUSE_REDUCTION_CODE (expr));
434 break;
435 default:
436 break;
437 }
438}
439
440
441/* Pack all the bitfields in EXPR into a bit pack. */
442
443void
444streamer_write_tree_bitfields (struct output_block *ob, tree expr)
445{
446 bitpack_d bp = bitpack_create (s: ob->main_stream);
447 enum tree_code code;
448
449 code = TREE_CODE (expr);
450
451 /* Note that all these functions are highly sensitive to changes in
452 the types and sizes of each of the fields being packed. */
453 pack_ts_base_value_fields (bp: &bp, expr);
454
455 if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
456 pack_ts_int_cst_value_fields (bp: &bp, expr);
457
458 if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
459 pack_ts_real_cst_value_fields (bp: &bp, expr);
460
461 if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
462 pack_ts_fixed_cst_value_fields (bp: &bp, expr);
463
464 if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
465 stream_output_location (ob, &bp, DECL_SOURCE_LOCATION (expr));
466
467 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
468 pack_ts_decl_common_value_fields (bp: &bp, expr);
469
470 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
471 pack_ts_decl_wrtl_value_fields (bp: &bp, expr);
472
473 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
474 pack_ts_decl_with_vis_value_fields (bp: &bp, expr);
475
476 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
477 pack_ts_function_decl_value_fields (bp: &bp, expr);
478
479 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
480 pack_ts_type_common_value_fields (bp: &bp, expr);
481
482 if (CODE_CONTAINS_STRUCT (code, TS_EXP))
483 {
484 stream_output_location (ob, &bp, EXPR_LOCATION (expr));
485 if (code == MEM_REF
486 || code == TARGET_MEM_REF)
487 {
488 bp_pack_value (bp: &bp, MR_DEPENDENCE_CLIQUE (expr), nbits: sizeof (short) * 8);
489 if (MR_DEPENDENCE_CLIQUE (expr) != 0)
490 bp_pack_value (bp: &bp, MR_DEPENDENCE_BASE (expr), nbits: sizeof (short) * 8);
491 }
492 else if (code == CALL_EXPR)
493 bp_pack_enum (&bp, internal_fn, IFN_LAST, CALL_EXPR_IFN (expr));
494 }
495
496 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
497 pack_ts_block_value_fields (ob, bp: &bp, expr);
498
499 if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
500 pack_ts_translation_unit_decl_value_fields (ob, bp: &bp, expr);
501
502 if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
503 cl_optimization_stream_out (ob, &bp, TREE_OPTIMIZATION (expr));
504
505 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
506 {
507 bp_pack_enum (&bp, clobber_kind, CLOBBER_LAST, CLOBBER_KIND (expr));
508 bp_pack_var_len_unsigned (&bp, CONSTRUCTOR_NELTS (expr));
509 }
510
511 if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION)
512 /* Don't stream these when passing things to a different target. */
513 && !lto_stream_offload_p)
514 cl_target_option_stream_out (ob, &bp, TREE_TARGET_OPTION (expr));
515
516 if (code == OMP_CLAUSE)
517 pack_ts_omp_clause_value_fields (ob, bp: &bp, expr);
518
519 streamer_write_bitpack (bp: &bp);
520}
521
522
523/* Emit the chain of tree nodes starting at T. OB is the output block
524 to write to. REF_P is true if chain elements should be emitted
525 as references. */
526
527static void
528streamer_write_chain (struct output_block *ob, tree t)
529{
530 while (t)
531 {
532 /* We avoid outputting external vars or functions by reference
533 to the global decls section as we do not want to have them
534 enter decl merging. We should not need to do this anymore because
535 free_lang_data removes them from block scopes. */
536 gcc_assert (!VAR_OR_FUNCTION_DECL_P (t) || !DECL_EXTERNAL (t));
537 stream_write_tree_ref (ob, t);
538
539 t = TREE_CHAIN (t);
540 }
541
542 /* Write a sentinel to terminate the chain. */
543 stream_write_tree_ref (ob, NULL_TREE);
544}
545
546
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
549 fields. */
550
551static void
552write_ts_common_tree_pointers (struct output_block *ob, tree expr)
553{
554 if (TREE_CODE (expr) != IDENTIFIER_NODE)
555 stream_write_tree_ref (ob, TREE_TYPE (expr));
556}
557
558
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
561 fields. */
562
563static void
564write_ts_vector_tree_pointers (struct output_block *ob, tree expr)
565{
566 /* Note that the number of elements for EXPR has already been emitted
567 in EXPR's header (see streamer_write_tree_header). */
568 unsigned int count = vector_cst_encoded_nelts (t: expr);
569 for (unsigned int i = 0; i < count; ++i)
570 stream_write_tree_ref (ob, VECTOR_CST_ENCODED_ELT (expr, i));
571}
572
573
574/* Write all pointer fields in the TS_POLY_INT_CST structure of EXPR to
575 output block OB. If REF_P is true, write a reference to EXPR's pointer
576 fields. */
577
578static void
579write_ts_poly_tree_pointers (struct output_block *ob, tree expr)
580{
581 for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
582 stream_write_tree_ref (ob, POLY_INT_CST_COEFF (expr, i));
583}
584
585
586/* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
587 block OB. If REF_P is true, write a reference to EXPR's pointer
588 fields. */
589
590static void
591write_ts_complex_tree_pointers (struct output_block *ob, tree expr)
592{
593 stream_write_tree_ref (ob, TREE_REALPART (expr));
594 stream_write_tree_ref (ob, TREE_IMAGPART (expr));
595}
596
597
598/* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
599 to output block OB. If REF_P is true, write a reference to EXPR's
600 pointer fields. */
601
602static void
603write_ts_decl_minimal_tree_pointers (struct output_block *ob, tree expr)
604{
605 /* Drop names that were created for anonymous entities. */
606 if (DECL_NAME (expr)
607 && TREE_CODE (DECL_NAME (expr)) == IDENTIFIER_NODE
608 && IDENTIFIER_ANON_P (DECL_NAME (expr)))
609 stream_write_tree_ref (ob, NULL_TREE);
610 else
611 stream_write_tree_ref (ob, DECL_NAME (expr));
612 if (TREE_CODE (expr) != TRANSLATION_UNIT_DECL
613 && ! DECL_CONTEXT (expr))
614 stream_write_tree_ref (ob, (*all_translation_units)[0]);
615 else
616 stream_write_tree_ref (ob, DECL_CONTEXT (expr));
617}
618
619
620/* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
621 output block OB. If REF_P is true, write a reference to EXPR's
622 pointer fields. */
623
624static void
625write_ts_decl_common_tree_pointers (struct output_block *ob, tree expr)
626{
627 stream_write_tree_ref (ob, DECL_SIZE (expr));
628 stream_write_tree_ref (ob, DECL_SIZE_UNIT (expr));
629
630 /* Note, DECL_INITIAL is not handled here. Since DECL_INITIAL needs
631 special handling in LTO, it must be handled by streamer hooks. */
632
633 stream_write_tree_ref (ob, DECL_ATTRIBUTES (expr));
634
635 /* On non-early-LTO enabled targets we claim we compiled with -g0
636 but dwarf2out still did its set_decl_origin_self game fooling
637 itself late. Und that here since we won't have access to the
638 early generated abstract DIEs. */
639 tree ao = DECL_ABSTRACT_ORIGIN (expr);
640 if (debug_info_level == DINFO_LEVEL_NONE
641 && ao == expr)
642 ao = NULL_TREE;
643 stream_write_tree_ref (ob, ao);
644
645 if ((VAR_P (expr) || TREE_CODE (expr) == PARM_DECL)
646 && DECL_HAS_VALUE_EXPR_P (expr))
647 stream_write_tree_ref (ob, DECL_VALUE_EXPR (expr));
648
649 if (VAR_P (expr)
650 && DECL_HAS_DEBUG_EXPR_P (expr))
651 stream_write_tree_ref (ob, DECL_DEBUG_EXPR (expr));
652}
653
654
655/* Write all pointer fields in the TS_DECL_NON_COMMON structure of
656 EXPR to output block OB. If REF_P is true, write a reference to EXPR's
657 pointer fields. */
658
659static void
660write_ts_decl_non_common_tree_pointers (struct output_block *, tree)
661{
662}
663
664
665/* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
666 to output block OB. If REF_P is true, write a reference to EXPR's
667 pointer fields. */
668
669static void
670write_ts_decl_with_vis_tree_pointers (struct output_block *ob, tree expr)
671{
672 /* Make sure we don't inadvertently set the assembler name. */
673 if (DECL_ASSEMBLER_NAME_SET_P (expr))
674 stream_write_tree_ref (ob, DECL_ASSEMBLER_NAME (expr));
675 else
676 stream_write_tree_ref (ob, NULL_TREE);
677}
678
679
680/* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
681 output block OB. If REF_P is true, write a reference to EXPR's
682 pointer fields. */
683
684static void
685write_ts_field_decl_tree_pointers (struct output_block *ob, tree expr)
686{
687 stream_write_tree_ref (ob, DECL_FIELD_OFFSET (expr));
688 stream_write_tree_ref (ob, DECL_BIT_FIELD_TYPE (expr));
689 stream_write_tree_ref (ob, DECL_BIT_FIELD_REPRESENTATIVE (expr));
690 stream_write_tree_ref (ob, DECL_FIELD_BIT_OFFSET (expr));
691}
692
693
694/* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
695 to output block OB. If REF_P is true, write a reference to EXPR's
696 pointer fields. */
697
698static void
699write_ts_function_decl_tree_pointers (struct output_block *ob, tree expr)
700{
701 /* DECL_STRUCT_FUNCTION is handled by lto_output_function. */
702 stream_write_tree_ref (ob, DECL_FUNCTION_PERSONALITY (expr));
703 /* Don't stream these when passing things to a different target. */
704 if (!lto_stream_offload_p)
705 stream_write_tree_ref (ob, DECL_FUNCTION_SPECIFIC_TARGET (expr));
706 stream_write_tree_ref (ob, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr));
707}
708
709
710/* Write all pointer fields in the TS_TYPE_COMMON structure of EXPR to
711 output block OB. If REF_P is true, write a reference to EXPR's
712 pointer fields. */
713
714static void
715write_ts_type_common_tree_pointers (struct output_block *ob, tree expr)
716{
717 stream_write_tree_ref (ob, TYPE_SIZE (expr));
718 stream_write_tree_ref (ob, TYPE_SIZE_UNIT (expr));
719 stream_write_tree_ref (ob, TYPE_ATTRIBUTES (expr));
720 stream_write_tree_ref (ob, TYPE_NAME (expr));
721 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
722 reconstructed during fixup. */
723 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
724 during fixup. */
725 stream_write_tree_ref (ob, TYPE_MAIN_VARIANT (expr));
726 stream_write_tree_ref (ob, TYPE_CONTEXT (expr));
727 /* TYPE_CANONICAL is re-computed during type merging, so no need
728 to stream it here. */
729 /* Do not stream TYPE_STUB_DECL; it is not needed by LTO but currently
730 it cannot be freed by free_lang_data without triggering ICEs in
731 langhooks. */
732}
733
734/* Write all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
735 to output block OB. If REF_P is true, write a reference to EXPR's
736 pointer fields. */
737
738static void
739write_ts_type_non_common_tree_pointers (struct output_block *ob, tree expr)
740{
741 if (TREE_CODE (expr) == ARRAY_TYPE)
742 stream_write_tree_ref (ob, TYPE_DOMAIN (expr));
743 else if (RECORD_OR_UNION_TYPE_P (expr))
744 streamer_write_chain (ob, TYPE_FIELDS (expr));
745 else if (FUNC_OR_METHOD_TYPE_P (expr))
746 stream_write_tree_ref (ob, TYPE_ARG_TYPES (expr));
747
748 if (!POINTER_TYPE_P (expr))
749 stream_write_tree_ref (ob, TYPE_MIN_VALUE_RAW (expr));
750 stream_write_tree_ref (ob, TYPE_MAX_VALUE_RAW (expr));
751}
752
753
754/* Write all pointer fields in the TS_LIST structure of EXPR to output
755 block OB. If REF_P is true, write a reference to EXPR's pointer
756 fields. */
757
758static void
759write_ts_list_tree_pointers (struct output_block *ob, tree expr)
760{
761 stream_write_tree_ref (ob, TREE_PURPOSE (expr));
762 stream_write_tree_ref (ob, TREE_VALUE (expr));
763 stream_write_tree_ref (ob, TREE_CHAIN (expr));
764}
765
766
767/* Write all pointer fields in the TS_VEC structure of EXPR to output
768 block OB. If REF_P is true, write a reference to EXPR's pointer
769 fields. */
770
771static void
772write_ts_vec_tree_pointers (struct output_block *ob, tree expr)
773{
774 int i;
775
776 /* Note that the number of slots for EXPR has already been emitted
777 in EXPR's header (see streamer_write_tree_header). */
778 for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
779 stream_write_tree_ref (ob, TREE_VEC_ELT (expr, i));
780}
781
782
783/* Write all pointer fields in the TS_EXP structure of EXPR to output
784 block OB. If REF_P is true, write a reference to EXPR's pointer
785 fields. */
786
787static void
788write_ts_exp_tree_pointers (struct output_block *ob, tree expr)
789{
790 int i;
791
792 for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
793 stream_write_tree_ref (ob, TREE_OPERAND (expr, i));
794 stream_write_tree_ref (ob, TREE_BLOCK (expr));
795}
796
797
798/* Write all pointer fields in the TS_BLOCK structure of EXPR to output
799 block OB. If REF_P is true, write a reference to EXPR's pointer
800 fields. */
801
802static void
803write_ts_block_tree_pointers (struct output_block *ob, tree expr)
804{
805 streamer_write_chain (ob, BLOCK_VARS (expr));
806
807 stream_write_tree_ref (ob, BLOCK_SUPERCONTEXT (expr));
808 stream_write_tree_ref (ob, BLOCK_ABSTRACT_ORIGIN (expr));
809
810 /* Do not stream BLOCK_NONLOCALIZED_VARS. We cannot handle debug information
811 for early inlined BLOCKs so drop it on the floor instead of ICEing in
812 dwarf2out.cc. */
813
814 /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
815 streaming time. */
816
817 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
818 list is re-constructed from BLOCK_SUPERCONTEXT. */
819}
820
821
822/* Write all pointer fields in the TS_BINFO structure of EXPR to output
823 block OB. If REF_P is true, write a reference to EXPR's pointer
824 fields. */
825
826static void
827write_ts_binfo_tree_pointers (struct output_block *ob, tree expr)
828{
829 unsigned i;
830 tree t;
831
832 /* Note that the number of BINFO slots has already been emitted in
833 EXPR's header (see streamer_write_tree_header) because this length
834 is needed to build the empty BINFO node on the reader side. */
835 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr), i, t)
836 stream_write_tree_ref (ob, t);
837 stream_write_tree_ref (ob, NULL_TREE);
838
839 stream_write_tree_ref (ob, BINFO_OFFSET (expr));
840 stream_write_tree_ref (ob, BINFO_VTABLE (expr));
841
842 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX,
843 BINFO_BASE_ACCESSES and BINFO_VPTR_INDEX; these are used by C++ FE only. */
844}
845
846
847/* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
848 output block OB. If REF_P is true, write a reference to EXPR's
849 pointer fields. */
850
851static void
852write_ts_constructor_tree_pointers (struct output_block *ob, tree expr)
853{
854 unsigned i;
855 tree index, value;
856
857 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value)
858 {
859 stream_write_tree_ref (ob, index);
860 stream_write_tree_ref (ob, value);
861 }
862}
863
864
865/* Write all pointer fields in the TS_OMP_CLAUSE structure of EXPR
866 to output block OB. If REF_P is true, write a reference to EXPR's
867 pointer fields. */
868
869static void
870write_ts_omp_clause_tree_pointers (struct output_block *ob, tree expr)
871{
872 int i;
873 for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (expr)]; i++)
874 stream_write_tree_ref (ob, OMP_CLAUSE_OPERAND (expr, i));
875 switch (OMP_CLAUSE_CODE (expr))
876 {
877 case OMP_CLAUSE_REDUCTION:
878 case OMP_CLAUSE_TASK_REDUCTION:
879 case OMP_CLAUSE_IN_REDUCTION:
880 /* We don't stream these right now, handle it if streaming
881 of them is needed. */
882 gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (expr) == NULL);
883 gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (expr) == NULL);
884 break;
885 default:
886 break;
887 }
888 stream_write_tree_ref (ob, OMP_CLAUSE_CHAIN (expr));
889}
890
891
892/* Write all pointer fields in EXPR to output block OB. If REF_P is true,
893 the leaves of EXPR are emitted as references. */
894
895void
896streamer_write_tree_body (struct output_block *ob, tree expr)
897{
898 enum tree_code code;
899
900 lto_stats.num_tree_bodies_output++;
901
902 code = TREE_CODE (expr);
903
904 if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
905 write_ts_common_tree_pointers (ob, expr);
906
907 if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
908 write_ts_vector_tree_pointers (ob, expr);
909
910 if (CODE_CONTAINS_STRUCT (code, TS_POLY_INT_CST))
911 write_ts_poly_tree_pointers (ob, expr);
912
913 if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
914 write_ts_complex_tree_pointers (ob, expr);
915
916 if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
917 write_ts_decl_minimal_tree_pointers (ob, expr);
918
919 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
920 write_ts_decl_common_tree_pointers (ob, expr);
921
922 if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
923 write_ts_decl_non_common_tree_pointers (ob, expr);
924
925 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
926 write_ts_decl_with_vis_tree_pointers (ob, expr);
927
928 if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
929 write_ts_field_decl_tree_pointers (ob, expr);
930
931 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
932 write_ts_function_decl_tree_pointers (ob, expr);
933
934 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
935 write_ts_type_common_tree_pointers (ob, expr);
936
937 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
938 write_ts_type_non_common_tree_pointers (ob, expr);
939
940 if (CODE_CONTAINS_STRUCT (code, TS_LIST))
941 write_ts_list_tree_pointers (ob, expr);
942
943 if (CODE_CONTAINS_STRUCT (code, TS_VEC))
944 write_ts_vec_tree_pointers (ob, expr);
945
946 if (CODE_CONTAINS_STRUCT (code, TS_EXP))
947 write_ts_exp_tree_pointers (ob, expr);
948
949 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
950 write_ts_block_tree_pointers (ob, expr);
951
952 if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
953 write_ts_binfo_tree_pointers (ob, expr);
954
955 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
956 write_ts_constructor_tree_pointers (ob, expr);
957
958 if (code == OMP_CLAUSE)
959 write_ts_omp_clause_tree_pointers (ob, expr);
960}
961
962
963/* Emit header information for tree EXPR to output block OB. The header
964 contains everything needed to instantiate an empty skeleton for
965 EXPR on the reading side. IX is the index into the streamer cache
966 where EXPR is stored. */
967
968void
969streamer_write_tree_header (struct output_block *ob, tree expr)
970{
971 enum LTO_tags tag;
972 enum tree_code code;
973
974 if (streamer_dump_file)
975 {
976 print_node_brief (streamer_dump_file, " Streaming header of ",
977 expr, 4);
978 fprintf (stream: streamer_dump_file, format: " to %s\n",
979 lto_section_name[ob->section_type]);
980 }
981
982 /* We should not see any tree nodes not handled by the streamer. */
983 code = TREE_CODE (expr);
984
985 /* The header of a tree node consists of its tag, the size of
986 the node, and any other information needed to instantiate
987 EXPR on the reading side (such as the number of slots in
988 variable sized nodes). */
989 tag = lto_tree_code_to_tag (code);
990 streamer_write_record_start (ob, tag);
991
992 /* The text in strings and identifiers are completely emitted in
993 the header. */
994 if (CODE_CONTAINS_STRUCT (code, TS_STRING))
995 streamer_write_string_cst (ob, index_stream: ob->main_stream, string: expr);
996 else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
997 write_identifier (ob, index_stream: ob->main_stream, id: expr);
998 else if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
999 {
1000 bitpack_d bp = bitpack_create (s: ob->main_stream);
1001 bp_pack_value (bp: &bp, VECTOR_CST_LOG2_NPATTERNS (expr), nbits: 8);
1002 bp_pack_value (bp: &bp, VECTOR_CST_NELTS_PER_PATTERN (expr), nbits: 8);
1003 streamer_write_bitpack (bp: &bp);
1004 }
1005 else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1006 streamer_write_hwi (ob, TREE_VEC_LENGTH (expr));
1007 else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1008 streamer_write_uhwi (ob, BINFO_N_BASE_BINFOS (expr));
1009 else if (TREE_CODE (expr) == CALL_EXPR)
1010 streamer_write_uhwi (ob, call_expr_nargs (expr));
1011 else if (TREE_CODE (expr) == OMP_CLAUSE)
1012 streamer_write_uhwi (ob, OMP_CLAUSE_CODE (expr));
1013 else if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
1014 {
1015 gcc_checking_assert (TREE_INT_CST_NUNITS (expr));
1016 streamer_write_uhwi (ob, TREE_INT_CST_NUNITS (expr));
1017 streamer_write_uhwi (ob, TREE_INT_CST_EXT_NUNITS (expr));
1018 }
1019}
1020
1021
1022/* Emit the integer constant CST to output block OB. If REF_P is true,
1023 CST's type will be emitted as a reference. */
1024
1025void
1026streamer_write_integer_cst (struct output_block *ob, tree cst)
1027{
1028 int i;
1029 int len = TREE_INT_CST_NUNITS (cst);
1030 gcc_assert (!TREE_OVERFLOW (cst));
1031 if (streamer_dump_file)
1032 {
1033 print_node_brief (streamer_dump_file, " Streaming integer ",
1034 cst, 4);
1035 fprintf (stream: streamer_dump_file, format: "\n");
1036 }
1037 streamer_write_record_start (ob, tag: LTO_integer_cst);
1038 stream_write_tree_ref (ob, TREE_TYPE (cst));
1039 /* We're effectively streaming a non-sign-extended wide_int here,
1040 so there's no need to stream TREE_INT_CST_EXT_NUNITS or any
1041 array members beyond LEN. We'll recreate the tree from the
1042 wide_int and the type. */
1043 streamer_write_uhwi (ob, len);
1044 for (i = 0; i < len; i++)
1045 streamer_write_hwi (ob, TREE_INT_CST_ELT (cst, i));
1046}
1047

source code of gcc/tree-streamer-out.cc