1/* Routines for emitting trees to a file stream.
2
3 Copyright (C) 2011-2017 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
35
36/* Output the STRING constant to the string
37 table in OB. Then put the index onto the INDEX_STREAM. */
38
39void
40streamer_write_string_cst (struct output_block *ob,
41 struct lto_output_stream *index_stream,
42 tree string)
43{
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);
49}
50
51
52/* Output the identifier ID to the string
53 table in OB. Then put the index onto the INDEX_STREAM. */
54
55static void
56write_identifier (struct output_block *ob,
57 struct lto_output_stream *index_stream,
58 tree id)
59{
60 streamer_write_string_with_length (ob, index_stream,
61 IDENTIFIER_POINTER (id),
62 IDENTIFIER_LENGTH (id),
63 true);
64}
65
66
67/* Pack all the non-pointer fields of the TS_BASE structure of
68 expression EXPR into bitpack BP. */
69
70static inline void
71pack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
72{
73 bp_pack_value (bp, TREE_CODE (expr), 16);
74 if (!TYPE_P (expr))
75 {
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);
79
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);
84 }
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))
90 {
91 bp_pack_value (bp, DECL_UNSIGNED (expr), 1);
92 bp_pack_value (bp, DECL_NAMELESS (expr), 1);
93 }
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))
115 {
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);
121 }
122 else if (TREE_CODE (expr) == BIT_FIELD_REF || TREE_CODE (expr) == MEM_REF)
123 {
124 bp_pack_value (bp, REF_REVERSE_STORAGE_ORDER (expr), 1);
125 bp_pack_value (bp, 0, 8);
126 }
127 else if (TREE_CODE (expr) == SSA_NAME)
128 {
129 bp_pack_value (bp, SSA_NAME_IS_DEFAULT_DEF (expr), 1);
130 bp_pack_value (bp, 0, 8);
131 }
132 else
133 bp_pack_value (bp, 0, 9);
134}
135
136
137/* Pack all the non-pointer fields of the TS_INTEGER_CST structure of
138 expression EXPR into bitpack BP. */
139
140static void
141pack_ts_int_cst_value_fields (struct bitpack_d *bp, tree expr)
142{
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));
148}
149
150
151/* Pack all the non-pointer fields of the TS_REAL_CST structure of
152 expression EXPR into bitpack BP. */
153
154static void
155pack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
156{
157 unsigned i;
158 REAL_VALUE_TYPE r;
159
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);
169}
170
171
172/* Pack all the non-pointer fields of the TS_FIXED_CST structure of
173 expression EXPR into bitpack BP. */
174
175static void
176pack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr)
177{
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);
182}
183
184/* Pack all the non-pointer fields of the TS_DECL_COMMON structure
185 of expression EXPR into bitpack BP. */
186
187static void
188pack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr)
189{
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));
201
202 if (TREE_CODE (expr) == LABEL_DECL)
203 {
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));
208 }
209
210 if (TREE_CODE (expr) == FIELD_DECL)
211 {
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);
216 }
217
218 if (VAR_P (expr))
219 {
220 bp_pack_value (bp, DECL_HAS_DEBUG_EXPR_P (expr), 1);
221 bp_pack_value (bp, DECL_NONLOCAL_FRAME (expr), 1);
222 }
223
224 if (TREE_CODE (expr) == RESULT_DECL
225 || TREE_CODE (expr) == PARM_DECL
226 || VAR_P (expr))
227 {
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);
231 }
232}
233
234
235/* Pack all the non-pointer fields of the TS_DECL_WRTL structure
236 of expression EXPR into bitpack BP. */
237
238static void
239pack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
240{
241 bp_pack_value (bp, DECL_REGISTER (expr), 1);
242}
243
244
245/* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
246 of expression EXPR into bitpack BP. */
247
248static void
249pack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
250{
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);
258
259 if (VAR_P (expr))
260 {
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);
264 }
265
266 if (TREE_CODE (expr) == FUNCTION_DECL)
267 {
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);
271 }
272}
273
274
275/* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure
276 of expression EXPR into bitpack BP. */
277
278static void
279pack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
280{
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);
301}
302
303
304/* Pack all the non-pointer fields of the TS_TYPE_COMMON structure
305 of expression EXPR into bitpack BP. */
306
307static void
308pack_ts_type_common_value_fields (struct bitpack_d *bp, tree expr)
309{
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_NEEDS_CONSTRUCTING (expr), 1);
318 bp_pack_value (bp, TYPE_PACKED (expr), 1);
319 bp_pack_value (bp, TYPE_RESTRICT (expr), 1);
320 bp_pack_value (bp, TYPE_USER_ALIGN (expr), 1);
321 bp_pack_value (bp, TYPE_READONLY (expr), 1);
322 /* We used to stream TYPE_ALIAS_SET == 0 information to let frontends mark
323 types that are opaque for TBAA. This however did not work as intended,
324 because TYPE_ALIAS_SET == 0 was regularly lost in type merging. */
325 if (RECORD_OR_UNION_TYPE_P (expr))
326 {
327 bp_pack_value (bp, TYPE_TRANSPARENT_AGGR (expr), 1);
328 bp_pack_value (bp, TYPE_FINAL_P (expr), 1);
329 }
330 else if (TREE_CODE (expr) == ARRAY_TYPE)
331 bp_pack_value (bp, TYPE_NONALIASED_COMPONENT (expr), 1);
332 if (AGGREGATE_TYPE_P (expr))
333 bp_pack_value (bp, TYPE_TYPELESS_STORAGE (expr), 1);
334 bp_pack_value (bp, TYPE_EMPTY_P (expr), 1);
335 bp_pack_var_len_unsigned (bp, TYPE_PRECISION (expr));
336 bp_pack_var_len_unsigned (bp, TYPE_ALIGN (expr));
337}
338
339
340/* Pack all the non-pointer fields of the TS_BLOCK structure
341 of expression EXPR into bitpack BP. */
342
343static void
344pack_ts_block_value_fields (struct output_block *ob,
345 struct bitpack_d *bp, tree expr)
346{
347 bp_pack_value (bp, BLOCK_ABSTRACT (expr), 1);
348 /* BLOCK_NUMBER is recomputed. */
349 /* Stream BLOCK_SOURCE_LOCATION for the limited cases we can handle - those
350 that represent inlined function scopes.
351 For the rest them on the floor instead of ICEing in dwarf2out.c. */
352 if (inlined_function_outer_scope_p (expr))
353 stream_output_location (ob, bp, BLOCK_SOURCE_LOCATION (expr));
354 else
355 stream_output_location (ob, bp, UNKNOWN_LOCATION);
356}
357
358/* Pack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL structure
359 of expression EXPR into bitpack BP. */
360
361static void
362pack_ts_translation_unit_decl_value_fields (struct output_block *ob,
363 struct bitpack_d *bp, tree expr)
364{
365 bp_pack_string (ob, bp, TRANSLATION_UNIT_LANGUAGE (expr), true);
366}
367
368
369/* Pack all the non-pointer fields of the TS_OMP_CLAUSE structure
370 of expression EXPR into bitpack BP. */
371
372static void
373pack_ts_omp_clause_value_fields (struct output_block *ob,
374 struct bitpack_d *bp, tree expr)
375{
376 stream_output_location (ob, bp, OMP_CLAUSE_LOCATION (expr));
377 switch (OMP_CLAUSE_CODE (expr))
378 {
379 case OMP_CLAUSE_DEFAULT:
380 bp_pack_enum (bp, omp_clause_default_kind, OMP_CLAUSE_DEFAULT_LAST,
381 OMP_CLAUSE_DEFAULT_KIND (expr));
382 break;
383 case OMP_CLAUSE_SCHEDULE:
384 bp_pack_enum (bp, omp_clause_schedule_kind, OMP_CLAUSE_SCHEDULE_LAST,
385 OMP_CLAUSE_SCHEDULE_KIND (expr));
386 break;
387 case OMP_CLAUSE_DEPEND:
388 bp_pack_enum (bp, omp_clause_depend_kind, OMP_CLAUSE_DEPEND_LAST,
389 OMP_CLAUSE_DEPEND_KIND (expr));
390 break;
391 case OMP_CLAUSE_MAP:
392 bp_pack_enum (bp, gomp_map_kind, GOMP_MAP_LAST,
393 OMP_CLAUSE_MAP_KIND (expr));
394 break;
395 case OMP_CLAUSE_PROC_BIND:
396 bp_pack_enum (bp, omp_clause_proc_bind_kind, OMP_CLAUSE_PROC_BIND_LAST,
397 OMP_CLAUSE_PROC_BIND_KIND (expr));
398 break;
399 case OMP_CLAUSE_REDUCTION:
400 bp_pack_enum (bp, tree_code, MAX_TREE_CODES,
401 OMP_CLAUSE_REDUCTION_CODE (expr));
402 break;
403 default:
404 break;
405 }
406}
407
408
409/* Pack all the bitfields in EXPR into a bit pack. */
410
411void
412streamer_write_tree_bitfields (struct output_block *ob, tree expr)
413{
414 bitpack_d bp = bitpack_create (ob->main_stream);
415 enum tree_code code;
416
417 code = TREE_CODE (expr);
418
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);
422
423 if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
424 pack_ts_int_cst_value_fields (&bp, expr);
425
426 if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
427 pack_ts_real_cst_value_fields (&bp, expr);
428
429 if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
430 pack_ts_fixed_cst_value_fields (&bp, expr);
431
432 if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
433 stream_output_location (ob, &bp, DECL_SOURCE_LOCATION (expr));
434
435 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
436 pack_ts_decl_common_value_fields (&bp, expr);
437
438 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
439 pack_ts_decl_wrtl_value_fields (&bp, expr);
440
441 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
442 pack_ts_decl_with_vis_value_fields (&bp, expr);
443
444 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
445 pack_ts_function_decl_value_fields (&bp, expr);
446
447 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
448 pack_ts_type_common_value_fields (&bp, expr);
449
450 if (CODE_CONTAINS_STRUCT (code, TS_EXP))
451 {
452 stream_output_location (ob, &bp, EXPR_LOCATION (expr));
453 if (code == MEM_REF
454 || code == TARGET_MEM_REF)
455 {
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);
459 }
460 }
461
462 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
463 pack_ts_block_value_fields (ob, &bp, expr);
464
465 if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
466 pack_ts_translation_unit_decl_value_fields (ob, &bp, expr);
467
468 if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
469 cl_optimization_stream_out (&bp, TREE_OPTIMIZATION (expr));
470
471 if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
472 bp_pack_var_len_unsigned (&bp, vec_safe_length (BINFO_BASE_ACCESSES (expr)));
473
474 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
475 bp_pack_var_len_unsigned (&bp, CONSTRUCTOR_NELTS (expr));
476
477 if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION)
478 /* Don't stream these when passing things to a different target. */
479 && !lto_stream_offload_p)
480 cl_target_option_stream_out (ob, &bp, TREE_TARGET_OPTION (expr));
481
482 if (code == OMP_CLAUSE)
483 pack_ts_omp_clause_value_fields (ob, &bp, expr);
484
485 streamer_write_bitpack (&bp);
486}
487
488
489/* Emit the chain of tree nodes starting at T. OB is the output block
490 to write to. REF_P is true if chain elements should be emitted
491 as references. */
492
493void
494streamer_write_chain (struct output_block *ob, tree t, bool ref_p)
495{
496 while (t)
497 {
498 /* We avoid outputting external vars or functions by reference
499 to the global decls section as we do not want to have them
500 enter decl merging. This is, of course, only for the call
501 for streaming BLOCK_VARS, but other callers are safe.
502 See also lto-streamer-out.c:DFS_write_tree_body. */
503 if (VAR_OR_FUNCTION_DECL_P (t)
504 && DECL_EXTERNAL (t))
505 stream_write_tree_shallow_non_ref (ob, t, ref_p);
506 else
507 stream_write_tree (ob, t, ref_p);
508
509 t = TREE_CHAIN (t);
510 }
511
512 /* Write a sentinel to terminate the chain. */
513 stream_write_tree (ob, NULL_TREE, ref_p);
514}
515
516
517/* Write all pointer fields in the TS_COMMON structure of EXPR to output
518 block OB. If REF_P is true, write a reference to EXPR's pointer
519 fields. */
520
521static void
522write_ts_common_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
523{
524 if (TREE_CODE (expr) != IDENTIFIER_NODE)
525 stream_write_tree (ob, TREE_TYPE (expr), ref_p);
526}
527
528
529/* Write all pointer fields in the TS_VECTOR structure of EXPR to output
530 block OB. If REF_P is true, write a reference to EXPR's pointer
531 fields. */
532
533static void
534write_ts_vector_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
535{
536 /* Note that the number of elements for EXPR has already been emitted
537 in EXPR's header (see streamer_write_tree_header). */
538 unsigned int count = vector_cst_encoded_nelts (expr);
539 for (unsigned int i = 0; i < count; ++i)
540 stream_write_tree (ob, VECTOR_CST_ENCODED_ELT (expr, i), ref_p);
541}
542
543
544/* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
545 block OB. If REF_P is true, write a reference to EXPR's pointer
546 fields. */
547
548static void
549write_ts_complex_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
550{
551 stream_write_tree (ob, TREE_REALPART (expr), ref_p);
552 stream_write_tree (ob, TREE_IMAGPART (expr), ref_p);
553}
554
555
556/* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
557 to output block OB. If REF_P is true, write a reference to EXPR's
558 pointer fields. */
559
560static void
561write_ts_decl_minimal_tree_pointers (struct output_block *ob, tree expr,
562 bool ref_p)
563{
564 /* Drop names that were created for anonymous entities. */
565 if (DECL_NAME (expr)
566 && TREE_CODE (DECL_NAME (expr)) == IDENTIFIER_NODE
567 && anon_aggrname_p (DECL_NAME (expr)))
568 stream_write_tree (ob, NULL_TREE, ref_p);
569 else
570 stream_write_tree (ob, DECL_NAME (expr), ref_p);
571 if (TREE_CODE (expr) != TRANSLATION_UNIT_DECL
572 && ! DECL_CONTEXT (expr))
573 stream_write_tree (ob, (*all_translation_units)[0], ref_p);
574 else
575 stream_write_tree (ob, DECL_CONTEXT (expr), ref_p);
576}
577
578
579/* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
580 output block OB. If REF_P is true, write a reference to EXPR's
581 pointer fields. */
582
583static void
584write_ts_decl_common_tree_pointers (struct output_block *ob, tree expr,
585 bool ref_p)
586{
587 stream_write_tree (ob, DECL_SIZE (expr), ref_p);
588 stream_write_tree (ob, DECL_SIZE_UNIT (expr), ref_p);
589
590 /* Note, DECL_INITIAL is not handled here. Since DECL_INITIAL needs
591 special handling in LTO, it must be handled by streamer hooks. */
592
593 stream_write_tree (ob, DECL_ATTRIBUTES (expr), ref_p);
594 stream_write_tree (ob, DECL_ABSTRACT_ORIGIN (expr), ref_p);
595
596 if ((VAR_P (expr) || TREE_CODE (expr) == PARM_DECL)
597 && DECL_HAS_VALUE_EXPR_P (expr))
598 stream_write_tree (ob, DECL_VALUE_EXPR (expr), ref_p);
599
600 if (VAR_P (expr))
601 stream_write_tree (ob, DECL_DEBUG_EXPR (expr), ref_p);
602}
603
604
605/* Write all pointer fields in the TS_DECL_NON_COMMON structure of
606 EXPR to output block OB. If REF_P is true, write a reference to EXPR's
607 pointer fields. */
608
609static void
610write_ts_decl_non_common_tree_pointers (struct output_block *ob, tree expr,
611 bool ref_p)
612{
613 if (TREE_CODE (expr) == TYPE_DECL)
614 stream_write_tree (ob, DECL_ORIGINAL_TYPE (expr), ref_p);
615}
616
617
618/* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
619 to output block OB. If REF_P is true, write a reference to EXPR's
620 pointer fields. */
621
622static void
623write_ts_decl_with_vis_tree_pointers (struct output_block *ob, tree expr,
624 bool ref_p)
625{
626 /* Make sure we don't inadvertently set the assembler name. */
627 if (DECL_ASSEMBLER_NAME_SET_P (expr))
628 stream_write_tree (ob, DECL_ASSEMBLER_NAME (expr), ref_p);
629 else
630 stream_write_tree (ob, NULL_TREE, false);
631}
632
633
634/* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
635 output block OB. If REF_P is true, write a reference to EXPR's
636 pointer fields. */
637
638static void
639write_ts_field_decl_tree_pointers (struct output_block *ob, tree expr,
640 bool ref_p)
641{
642 stream_write_tree (ob, DECL_FIELD_OFFSET (expr), ref_p);
643 stream_write_tree (ob, DECL_BIT_FIELD_TYPE (expr), ref_p);
644 stream_write_tree (ob, DECL_BIT_FIELD_REPRESENTATIVE (expr), ref_p);
645 stream_write_tree (ob, DECL_FIELD_BIT_OFFSET (expr), ref_p);
646 stream_write_tree (ob, DECL_FCONTEXT (expr), ref_p);
647}
648
649
650/* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
651 to output block OB. If REF_P is true, write a reference to EXPR's
652 pointer fields. */
653
654static void
655write_ts_function_decl_tree_pointers (struct output_block *ob, tree expr,
656 bool ref_p)
657{
658 stream_write_tree (ob, DECL_VINDEX (expr), ref_p);
659 /* DECL_STRUCT_FUNCTION is handled by lto_output_function. */
660 stream_write_tree (ob, DECL_FUNCTION_PERSONALITY (expr), ref_p);
661 /* Don't stream these when passing things to a different target. */
662 if (!lto_stream_offload_p)
663 stream_write_tree (ob, DECL_FUNCTION_SPECIFIC_TARGET (expr), ref_p);
664 stream_write_tree (ob, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr), ref_p);
665}
666
667
668/* Write all pointer fields in the TS_TYPE_COMMON structure of EXPR to
669 output block OB. If REF_P is true, write a reference to EXPR's
670 pointer fields. */
671
672static void
673write_ts_type_common_tree_pointers (struct output_block *ob, tree expr,
674 bool ref_p)
675{
676 stream_write_tree (ob, TYPE_SIZE (expr), ref_p);
677 stream_write_tree (ob, TYPE_SIZE_UNIT (expr), ref_p);
678 stream_write_tree (ob, TYPE_ATTRIBUTES (expr), ref_p);
679 stream_write_tree (ob, TYPE_NAME (expr), ref_p);
680 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
681 reconstructed during fixup. */
682 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
683 during fixup. */
684 stream_write_tree (ob, TYPE_MAIN_VARIANT (expr), ref_p);
685 stream_write_tree (ob, TYPE_CONTEXT (expr), ref_p);
686 /* TYPE_CANONICAL is re-computed during type merging, so no need
687 to stream it here. */
688 stream_write_tree (ob, TYPE_STUB_DECL (expr), ref_p);
689}
690
691/* Write all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
692 to output block OB. If REF_P is true, write a reference to EXPR's
693 pointer fields. */
694
695static void
696write_ts_type_non_common_tree_pointers (struct output_block *ob, tree expr,
697 bool ref_p)
698{
699 if (TREE_CODE (expr) == ENUMERAL_TYPE)
700 stream_write_tree (ob, TYPE_VALUES (expr), ref_p);
701 else if (TREE_CODE (expr) == ARRAY_TYPE)
702 stream_write_tree (ob, TYPE_DOMAIN (expr), ref_p);
703 else if (RECORD_OR_UNION_TYPE_P (expr))
704 streamer_write_chain (ob, TYPE_FIELDS (expr), ref_p);
705 else if (TREE_CODE (expr) == FUNCTION_TYPE
706 || TREE_CODE (expr) == METHOD_TYPE)
707 stream_write_tree (ob, TYPE_ARG_TYPES (expr), ref_p);
708
709 if (!POINTER_TYPE_P (expr))
710 stream_write_tree (ob, TYPE_MIN_VALUE_RAW (expr), ref_p);
711 stream_write_tree (ob, TYPE_MAX_VALUE_RAW (expr), ref_p);
712}
713
714
715/* Write all pointer fields in the TS_LIST structure of EXPR to output
716 block OB. If REF_P is true, write a reference to EXPR's pointer
717 fields. */
718
719static void
720write_ts_list_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
721{
722 stream_write_tree (ob, TREE_PURPOSE (expr), ref_p);
723 stream_write_tree (ob, TREE_VALUE (expr), ref_p);
724 stream_write_tree (ob, TREE_CHAIN (expr), ref_p);
725}
726
727
728/* Write all pointer fields in the TS_VEC structure of EXPR to output
729 block OB. If REF_P is true, write a reference to EXPR's pointer
730 fields. */
731
732static void
733write_ts_vec_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
734{
735 int i;
736
737 /* Note that the number of slots for EXPR has already been emitted
738 in EXPR's header (see streamer_write_tree_header). */
739 for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
740 stream_write_tree (ob, TREE_VEC_ELT (expr, i), ref_p);
741}
742
743
744/* Write all pointer fields in the TS_EXP structure of EXPR to output
745 block OB. If REF_P is true, write a reference to EXPR's pointer
746 fields. */
747
748static void
749write_ts_exp_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
750{
751 int i;
752
753 for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
754 stream_write_tree (ob, TREE_OPERAND (expr, i), ref_p);
755 stream_write_tree (ob, TREE_BLOCK (expr), ref_p);
756}
757
758
759/* Write all pointer fields in the TS_BLOCK structure of EXPR to output
760 block OB. If REF_P is true, write a reference to EXPR's pointer
761 fields. */
762
763static void
764write_ts_block_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
765{
766 streamer_write_chain (ob, BLOCK_VARS (expr), ref_p);
767
768 stream_write_tree (ob, BLOCK_SUPERCONTEXT (expr), ref_p);
769
770 /* Stream BLOCK_ABSTRACT_ORIGIN for the limited cases we can handle - those
771 that represent inlined function scopes.
772 For the rest them on the floor instead of ICEing in dwarf2out.c, but
773 keep the notion of whether the block is an inlined block by refering
774 to itself for the sake of tree_nonartificial_location. */
775 if (inlined_function_outer_scope_p (expr))
776 {
777 tree ultimate_origin = block_ultimate_origin (expr);
778 stream_write_tree (ob, ultimate_origin, ref_p);
779 }
780 else
781 stream_write_tree (ob, (BLOCK_ABSTRACT_ORIGIN (expr)
782 ? expr : NULL_TREE), ref_p);
783 /* Do not stream BLOCK_NONLOCALIZED_VARS. We cannot handle debug information
784 for early inlined BLOCKs so drop it on the floor instead of ICEing in
785 dwarf2out.c. */
786
787 /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
788 streaming time. */
789
790 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
791 list is re-constructed from BLOCK_SUPERCONTEXT. */
792}
793
794
795/* Write all pointer fields in the TS_BINFO structure of EXPR to output
796 block OB. If REF_P is true, write a reference to EXPR's pointer
797 fields. */
798
799static void
800write_ts_binfo_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
801{
802 unsigned i;
803 tree t;
804
805 /* Note that the number of BINFO slots has already been emitted in
806 EXPR's header (see streamer_write_tree_header) because this length
807 is needed to build the empty BINFO node on the reader side. */
808 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr), i, t)
809 stream_write_tree (ob, t, ref_p);
810 stream_write_tree (ob, NULL_TREE, false);
811
812 stream_write_tree (ob, BINFO_OFFSET (expr), ref_p);
813 stream_write_tree (ob, BINFO_VTABLE (expr), ref_p);
814 stream_write_tree (ob, BINFO_VPTR_FIELD (expr), ref_p);
815
816 /* The number of BINFO_BASE_ACCESSES has already been emitted in
817 EXPR's bitfield section. */
818 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (expr), i, t)
819 stream_write_tree (ob, t, ref_p);
820
821 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
822 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
823}
824
825
826/* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
827 output block OB. If REF_P is true, write a reference to EXPR's
828 pointer fields. */
829
830static void
831write_ts_constructor_tree_pointers (struct output_block *ob, tree expr,
832 bool ref_p)
833{
834 unsigned i;
835 tree index, value;
836
837 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value)
838 {
839 stream_write_tree (ob, index, ref_p);
840 stream_write_tree (ob, value, ref_p);
841 }
842}
843
844
845/* Write all pointer fields in the TS_OMP_CLAUSE structure of EXPR
846 to output block OB. If REF_P is true, write a reference to EXPR's
847 pointer fields. */
848
849static void
850write_ts_omp_clause_tree_pointers (struct output_block *ob, tree expr,
851 bool ref_p)
852{
853 int i;
854 for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (expr)]; i++)
855 stream_write_tree (ob, OMP_CLAUSE_OPERAND (expr, i), ref_p);
856 if (OMP_CLAUSE_CODE (expr) == OMP_CLAUSE_REDUCTION)
857 {
858 /* We don't stream these right now, handle it if streaming
859 of them is needed. */
860 gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (expr) == NULL);
861 gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (expr) == NULL);
862 }
863 stream_write_tree (ob, OMP_CLAUSE_CHAIN (expr), ref_p);
864}
865
866
867/* Write all pointer fields in EXPR to output block OB. If REF_P is true,
868 the leaves of EXPR are emitted as references. */
869
870void
871streamer_write_tree_body (struct output_block *ob, tree expr, bool ref_p)
872{
873 enum tree_code code;
874
875 lto_stats.num_tree_bodies_output++;
876
877 code = TREE_CODE (expr);
878
879 if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
880 write_ts_common_tree_pointers (ob, expr, ref_p);
881
882 if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
883 write_ts_vector_tree_pointers (ob, expr, ref_p);
884
885 if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
886 write_ts_complex_tree_pointers (ob, expr, ref_p);
887
888 if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
889 write_ts_decl_minimal_tree_pointers (ob, expr, ref_p);
890
891 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
892 write_ts_decl_common_tree_pointers (ob, expr, ref_p);
893
894 if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
895 write_ts_decl_non_common_tree_pointers (ob, expr, ref_p);
896
897 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
898 write_ts_decl_with_vis_tree_pointers (ob, expr, ref_p);
899
900 if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
901 write_ts_field_decl_tree_pointers (ob, expr, ref_p);
902
903 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
904 write_ts_function_decl_tree_pointers (ob, expr, ref_p);
905
906 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
907 write_ts_type_common_tree_pointers (ob, expr, ref_p);
908
909 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
910 write_ts_type_non_common_tree_pointers (ob, expr, ref_p);
911
912 if (CODE_CONTAINS_STRUCT (code, TS_LIST))
913 write_ts_list_tree_pointers (ob, expr, ref_p);
914
915 if (CODE_CONTAINS_STRUCT (code, TS_VEC))
916 write_ts_vec_tree_pointers (ob, expr, ref_p);
917
918 if (CODE_CONTAINS_STRUCT (code, TS_EXP))
919 write_ts_exp_tree_pointers (ob, expr, ref_p);
920
921 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
922 write_ts_block_tree_pointers (ob, expr, ref_p);
923
924 if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
925 write_ts_binfo_tree_pointers (ob, expr, ref_p);
926
927 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
928 write_ts_constructor_tree_pointers (ob, expr, ref_p);
929
930 if (code == OMP_CLAUSE)
931 write_ts_omp_clause_tree_pointers (ob, expr, ref_p);
932}
933
934
935/* Emit header information for tree EXPR to output block OB. The header
936 contains everything needed to instantiate an empty skeleton for
937 EXPR on the reading side. IX is the index into the streamer cache
938 where EXPR is stored. */
939
940void
941streamer_write_tree_header (struct output_block *ob, tree expr)
942{
943 enum LTO_tags tag;
944 enum tree_code code;
945
946 /* We should not see any tree nodes not handled by the streamer. */
947 code = TREE_CODE (expr);
948
949 /* The header of a tree node consists of its tag, the size of
950 the node, and any other information needed to instantiate
951 EXPR on the reading side (such as the number of slots in
952 variable sized nodes). */
953 tag = lto_tree_code_to_tag (code);
954 streamer_write_record_start (ob, tag);
955
956 /* The text in strings and identifiers are completely emitted in
957 the header. */
958 if (CODE_CONTAINS_STRUCT (code, TS_STRING))
959 streamer_write_string_cst (ob, ob->main_stream, expr);
960 else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
961 write_identifier (ob, ob->main_stream, expr);
962 else if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
963 {
964 bitpack_d bp = bitpack_create (ob->main_stream);
965 bp_pack_value (&bp, VECTOR_CST_LOG2_NPATTERNS (expr), 8);
966 bp_pack_value (&bp, VECTOR_CST_NELTS_PER_PATTERN (expr), 8);
967 streamer_write_bitpack (&bp);
968 }
969 else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
970 streamer_write_hwi (ob, TREE_VEC_LENGTH (expr));
971 else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
972 streamer_write_uhwi (ob, BINFO_N_BASE_BINFOS (expr));
973 else if (TREE_CODE (expr) == CALL_EXPR)
974 streamer_write_uhwi (ob, call_expr_nargs (expr));
975 else if (TREE_CODE (expr) == OMP_CLAUSE)
976 streamer_write_uhwi (ob, OMP_CLAUSE_CODE (expr));
977 else if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
978 {
979 gcc_checking_assert (TREE_INT_CST_NUNITS (expr));
980 streamer_write_uhwi (ob, TREE_INT_CST_NUNITS (expr));
981 streamer_write_uhwi (ob, TREE_INT_CST_EXT_NUNITS (expr));
982 }
983}
984
985
986/* Emit the integer constant CST to output block OB. If REF_P is true,
987 CST's type will be emitted as a reference. */
988
989void
990streamer_write_integer_cst (struct output_block *ob, tree cst, bool ref_p)
991{
992 int i;
993 int len = TREE_INT_CST_NUNITS (cst);
994 gcc_assert (!TREE_OVERFLOW (cst));
995 streamer_write_record_start (ob, LTO_integer_cst);
996 stream_write_tree (ob, TREE_TYPE (cst), ref_p);
997 /* We're effectively streaming a non-sign-extended wide_int here,
998 so there's no need to stream TREE_INT_CST_EXT_NUNITS or any
999 array members beyond LEN. We'll recreate the tree from the
1000 wide_int and the type. */
1001 streamer_write_uhwi (ob, len);
1002 for (i = 0; i < len; i++)
1003 streamer_write_hwi (ob, TREE_INT_CST_ELT (cst, i));
1004}
1005