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