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