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