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