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