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