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