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