1 /* Routines for emitting trees to a file stream.
2
3 Copyright (C) 2011-2014 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 "tm.h"
26 #include "diagnostic.h"
27 #include "tree.h"
28 #include "stor-layout.h"
29 #include "basic-block.h"
30 #include "tree-ssa-alias.h"
31 #include "internal-fn.h"
32 #include "gimple-expr.h"
33 #include "is-a.h"
34 #include "gimple.h"
35 #include "tree-streamer.h"
36 #include "data-streamer.h"
37 #include "streamer-hooks.h"
38
39 /* Output the STRING constant to the string
40 table in OB. Then put the index onto the INDEX_STREAM. */
41
42 void
streamer_write_string_cst(struct output_block * ob,struct lto_output_stream * index_stream,tree string)43 streamer_write_string_cst (struct output_block *ob,
44 struct lto_output_stream *index_stream,
45 tree string)
46 {
47 streamer_write_string_with_length (ob, index_stream,
48 string ? TREE_STRING_POINTER (string)
49 : NULL,
50 string ? TREE_STRING_LENGTH (string) : 0,
51 true);
52 }
53
54
55 /* Output the identifier ID to the string
56 table in OB. Then put the index onto the INDEX_STREAM. */
57
58 static void
write_identifier(struct output_block * ob,struct lto_output_stream * index_stream,tree id)59 write_identifier (struct output_block *ob,
60 struct lto_output_stream *index_stream,
61 tree id)
62 {
63 streamer_write_string_with_length (ob, index_stream,
64 IDENTIFIER_POINTER (id),
65 IDENTIFIER_LENGTH (id),
66 true);
67 }
68
69
70 /* Pack all the non-pointer fields of the TS_BASE structure of
71 expression EXPR into bitpack BP. */
72
73 static void
pack_ts_base_value_fields(struct bitpack_d * bp,tree expr)74 pack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
75 {
76 bp_pack_value (bp, TREE_CODE (expr), 16);
77 if (!TYPE_P (expr))
78 {
79 bp_pack_value (bp, TREE_SIDE_EFFECTS (expr), 1);
80 bp_pack_value (bp, TREE_CONSTANT (expr), 1);
81 bp_pack_value (bp, TREE_READONLY (expr), 1);
82
83 /* TREE_PUBLIC is used on types to indicate that the type
84 has a TYPE_CACHED_VALUES vector. This is not streamed out,
85 so we skip it here. */
86 bp_pack_value (bp, TREE_PUBLIC (expr), 1);
87 }
88 else
89 bp_pack_value (bp, 0, 4);
90 bp_pack_value (bp, TREE_ADDRESSABLE (expr), 1);
91 bp_pack_value (bp, TREE_THIS_VOLATILE (expr), 1);
92 if (DECL_P (expr))
93 bp_pack_value (bp, DECL_UNSIGNED (expr), 1);
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 bp_pack_value (bp, TREE_PROTECTED (expr), 1);
111 bp_pack_value (bp, TREE_DEPRECATED (expr), 1);
112 if (TYPE_P (expr))
113 {
114 bp_pack_value (bp, TYPE_SATURATING (expr), 1);
115 bp_pack_value (bp, TYPE_ADDR_SPACE (expr), 8);
116 }
117 else if (TREE_CODE (expr) == SSA_NAME)
118 bp_pack_value (bp, SSA_NAME_IS_DEFAULT_DEF (expr), 1);
119 else
120 bp_pack_value (bp, 0, 1);
121 }
122
123
124 /* Pack all the non-pointer fields of the TS_INTEGER_CST structure of
125 expression EXPR into bitpack BP. */
126
127 static void
pack_ts_int_cst_value_fields(struct bitpack_d * bp,tree expr)128 pack_ts_int_cst_value_fields (struct bitpack_d *bp, tree expr)
129 {
130 bp_pack_var_len_unsigned (bp, TREE_INT_CST_LOW (expr));
131 bp_pack_var_len_int (bp, TREE_INT_CST_HIGH (expr));
132 }
133
134
135 /* Pack all the non-pointer fields of the TS_REAL_CST structure of
136 expression EXPR into bitpack BP. */
137
138 static void
pack_ts_real_cst_value_fields(struct bitpack_d * bp,tree expr)139 pack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
140 {
141 unsigned i;
142 REAL_VALUE_TYPE r;
143
144 r = TREE_REAL_CST (expr);
145 bp_pack_value (bp, r.cl, 2);
146 bp_pack_value (bp, r.decimal, 1);
147 bp_pack_value (bp, r.sign, 1);
148 bp_pack_value (bp, r.signalling, 1);
149 bp_pack_value (bp, r.canonical, 1);
150 bp_pack_value (bp, r.uexp, EXP_BITS);
151 for (i = 0; i < SIGSZ; i++)
152 bp_pack_value (bp, r.sig[i], HOST_BITS_PER_LONG);
153 }
154
155
156 /* Pack all the non-pointer fields of the TS_FIXED_CST structure of
157 expression EXPR into bitpack BP. */
158
159 static void
pack_ts_fixed_cst_value_fields(struct bitpack_d * bp,tree expr)160 pack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr)
161 {
162 struct fixed_value fv = TREE_FIXED_CST (expr);
163 bp_pack_enum (bp, machine_mode, MAX_MACHINE_MODE, fv.mode);
164 bp_pack_var_len_int (bp, fv.data.low);
165 bp_pack_var_len_int (bp, fv.data.high);
166 }
167
168 /* Pack all the non-pointer fields of the TS_DECL_COMMON structure
169 of expression EXPR into bitpack BP. */
170
171 static void
pack_ts_decl_common_value_fields(struct bitpack_d * bp,tree expr)172 pack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr)
173 {
174 bp_pack_enum (bp, machine_mode, MAX_MACHINE_MODE, DECL_MODE (expr));
175 bp_pack_value (bp, DECL_NONLOCAL (expr), 1);
176 bp_pack_value (bp, DECL_VIRTUAL_P (expr), 1);
177 bp_pack_value (bp, DECL_IGNORED_P (expr), 1);
178 bp_pack_value (bp, DECL_ABSTRACT (expr), 1);
179 bp_pack_value (bp, DECL_ARTIFICIAL (expr), 1);
180 bp_pack_value (bp, DECL_USER_ALIGN (expr), 1);
181 bp_pack_value (bp, DECL_PRESERVE_P (expr), 1);
182 bp_pack_value (bp, DECL_EXTERNAL (expr), 1);
183 bp_pack_value (bp, DECL_GIMPLE_REG_P (expr), 1);
184 bp_pack_var_len_unsigned (bp, DECL_ALIGN (expr));
185
186 if (TREE_CODE (expr) == LABEL_DECL)
187 {
188 /* Note that we do not write LABEL_DECL_UID. The reader will
189 always assume an initial value of -1 so that the
190 label_to_block_map is recreated by gimple_set_bb. */
191 bp_pack_var_len_unsigned (bp, EH_LANDING_PAD_NR (expr));
192 }
193
194 if (TREE_CODE (expr) == FIELD_DECL)
195 {
196 bp_pack_value (bp, DECL_PACKED (expr), 1);
197 bp_pack_value (bp, DECL_NONADDRESSABLE_P (expr), 1);
198 bp_pack_value (bp, expr->decl_common.off_align, 8);
199 }
200
201 if (TREE_CODE (expr) == VAR_DECL)
202 {
203 bp_pack_value (bp, DECL_HAS_DEBUG_EXPR_P (expr), 1);
204 bp_pack_value (bp, DECL_NONLOCAL_FRAME (expr), 1);
205 }
206
207 if (TREE_CODE (expr) == RESULT_DECL
208 || TREE_CODE (expr) == PARM_DECL
209 || TREE_CODE (expr) == VAR_DECL)
210 {
211 bp_pack_value (bp, DECL_BY_REFERENCE (expr), 1);
212 if (TREE_CODE (expr) == VAR_DECL
213 || TREE_CODE (expr) == PARM_DECL)
214 bp_pack_value (bp, DECL_HAS_VALUE_EXPR_P (expr), 1);
215 }
216 }
217
218
219 /* Pack all the non-pointer fields of the TS_DECL_WRTL structure
220 of expression EXPR into bitpack BP. */
221
222 static void
pack_ts_decl_wrtl_value_fields(struct bitpack_d * bp,tree expr)223 pack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
224 {
225 bp_pack_value (bp, DECL_REGISTER (expr), 1);
226 }
227
228
229 /* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
230 of expression EXPR into bitpack BP. */
231
232 static void
pack_ts_decl_with_vis_value_fields(struct bitpack_d * bp,tree expr)233 pack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
234 {
235 bp_pack_value (bp, DECL_COMMON (expr), 1);
236 bp_pack_value (bp, DECL_DLLIMPORT_P (expr), 1);
237 bp_pack_value (bp, DECL_WEAK (expr), 1);
238 bp_pack_value (bp, DECL_SEEN_IN_BIND_EXPR_P (expr), 1);
239 bp_pack_value (bp, DECL_COMDAT (expr), 1);
240 bp_pack_value (bp, DECL_VISIBILITY (expr), 2);
241 bp_pack_value (bp, DECL_VISIBILITY_SPECIFIED (expr), 1);
242
243 if (TREE_CODE (expr) == VAR_DECL)
244 {
245 bp_pack_value (bp, DECL_HARD_REGISTER (expr), 1);
246 /* DECL_IN_TEXT_SECTION is set during final asm output only. */
247 bp_pack_value (bp, DECL_IN_CONSTANT_POOL (expr), 1);
248 bp_pack_value (bp, DECL_TLS_MODEL (expr), 3);
249 }
250
251 if (TREE_CODE (expr) == FUNCTION_DECL)
252 {
253 bp_pack_value (bp, DECL_FINAL_P (expr), 1);
254 bp_pack_value (bp, DECL_CXX_CONSTRUCTOR_P (expr), 1);
255 bp_pack_value (bp, DECL_CXX_DESTRUCTOR_P (expr), 1);
256 }
257 if (VAR_OR_FUNCTION_DECL_P (expr))
258 bp_pack_var_len_unsigned (bp, DECL_INIT_PRIORITY (expr));
259 }
260
261
262 /* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure
263 of expression EXPR into bitpack BP. */
264
265 static void
pack_ts_function_decl_value_fields(struct bitpack_d * bp,tree expr)266 pack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
267 {
268 /* For normal/md builtins we only write the class and code, so they
269 should never be handled here. */
270 gcc_assert (!streamer_handle_as_builtin_p (expr));
271
272 bp_pack_enum (bp, built_in_class, BUILT_IN_LAST,
273 DECL_BUILT_IN_CLASS (expr));
274 bp_pack_value (bp, DECL_STATIC_CONSTRUCTOR (expr), 1);
275 bp_pack_value (bp, DECL_STATIC_DESTRUCTOR (expr), 1);
276 bp_pack_value (bp, DECL_UNINLINABLE (expr), 1);
277 bp_pack_value (bp, DECL_POSSIBLY_INLINED (expr), 1);
278 bp_pack_value (bp, DECL_IS_NOVOPS (expr), 1);
279 bp_pack_value (bp, DECL_IS_RETURNS_TWICE (expr), 1);
280 bp_pack_value (bp, DECL_IS_MALLOC (expr), 1);
281 bp_pack_value (bp, DECL_IS_OPERATOR_NEW (expr), 1);
282 bp_pack_value (bp, DECL_DECLARED_INLINE_P (expr), 1);
283 bp_pack_value (bp, DECL_STATIC_CHAIN (expr), 1);
284 bp_pack_value (bp, DECL_NO_INLINE_WARNING_P (expr), 1);
285 bp_pack_value (bp, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr), 1);
286 bp_pack_value (bp, DECL_NO_LIMIT_STACK (expr), 1);
287 bp_pack_value (bp, DECL_DISREGARD_INLINE_LIMITS (expr), 1);
288 bp_pack_value (bp, DECL_PURE_P (expr), 1);
289 bp_pack_value (bp, DECL_LOOPING_CONST_OR_PURE_P (expr), 1);
290 if (DECL_BUILT_IN_CLASS (expr) != NOT_BUILT_IN)
291 bp_pack_value (bp, DECL_FUNCTION_CODE (expr), 11);
292 if (DECL_STATIC_DESTRUCTOR (expr))
293 bp_pack_var_len_unsigned (bp, DECL_FINI_PRIORITY (expr));
294 }
295
296
297 /* Pack all the non-pointer fields of the TS_TYPE_COMMON structure
298 of expression EXPR into bitpack BP. */
299
300 static void
pack_ts_type_common_value_fields(struct bitpack_d * bp,tree expr)301 pack_ts_type_common_value_fields (struct bitpack_d *bp, tree expr)
302 {
303 bp_pack_enum (bp, machine_mode, MAX_MACHINE_MODE, TYPE_MODE (expr));
304 bp_pack_value (bp, TYPE_STRING_FLAG (expr), 1);
305 bp_pack_value (bp, TYPE_NO_FORCE_BLK (expr), 1);
306 bp_pack_value (bp, TYPE_NEEDS_CONSTRUCTING (expr), 1);
307 if (RECORD_OR_UNION_TYPE_P (expr))
308 {
309 bp_pack_value (bp, TYPE_TRANSPARENT_AGGR (expr), 1);
310 bp_pack_value (bp, TYPE_FINAL_P (expr), 1);
311 }
312 else if (TREE_CODE (expr) == ARRAY_TYPE)
313 bp_pack_value (bp, TYPE_NONALIASED_COMPONENT (expr), 1);
314 bp_pack_value (bp, TYPE_PACKED (expr), 1);
315 bp_pack_value (bp, TYPE_RESTRICT (expr), 1);
316 bp_pack_value (bp, TYPE_USER_ALIGN (expr), 1);
317 bp_pack_value (bp, TYPE_READONLY (expr), 1);
318 bp_pack_var_len_unsigned (bp, TYPE_PRECISION (expr));
319 bp_pack_var_len_unsigned (bp, TYPE_ALIGN (expr));
320 /* Make sure to preserve the fact whether the frontend would assign
321 alias-set zero to this type. */
322 bp_pack_var_len_int (bp, (TYPE_ALIAS_SET (expr) == 0
323 || (!in_lto_p
324 && get_alias_set (expr) == 0)) ? 0 : -1);
325 }
326
327
328 /* Pack all the non-pointer fields of the TS_BLOCK structure
329 of expression EXPR into bitpack BP. */
330
331 static void
pack_ts_block_value_fields(struct output_block * ob,struct bitpack_d * bp,tree expr)332 pack_ts_block_value_fields (struct output_block *ob,
333 struct bitpack_d *bp, tree expr)
334 {
335 bp_pack_value (bp, BLOCK_ABSTRACT (expr), 1);
336 /* BLOCK_NUMBER is recomputed. */
337 /* Stream BLOCK_SOURCE_LOCATION for the limited cases we can handle - those
338 that represent inlined function scopes.
339 For the rest them on the floor instead of ICEing in dwarf2out.c. */
340 if (inlined_function_outer_scope_p (expr))
341 stream_output_location (ob, bp, BLOCK_SOURCE_LOCATION (expr));
342 else
343 stream_output_location (ob, bp, UNKNOWN_LOCATION);
344 }
345
346 /* Pack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL structure
347 of expression EXPR into bitpack BP. */
348
349 static void
pack_ts_translation_unit_decl_value_fields(struct output_block * ob,struct bitpack_d * bp,tree expr)350 pack_ts_translation_unit_decl_value_fields (struct output_block *ob,
351 struct bitpack_d *bp, tree expr)
352 {
353 bp_pack_string (ob, bp, TRANSLATION_UNIT_LANGUAGE (expr), true);
354 }
355
356 /* Pack a TS_OPTIMIZATION tree in EXPR to BP. */
357
358 static void
pack_ts_optimization(struct bitpack_d * bp,tree expr)359 pack_ts_optimization (struct bitpack_d *bp, tree expr)
360 {
361 struct cl_optimization *t = TREE_OPTIMIZATION (expr);
362 unsigned i, len;
363
364 /* The cl_optimization is generated by the options
365 awk script, so we just recreate a byte-by-byte copy here. */
366
367 len = sizeof (struct cl_optimization);
368 for (i = 0; i < len; i++)
369 bp_pack_value (bp, ((unsigned char *)t)[i], 8);
370 /* Catch struct size mismatches between reader and writer. */
371 bp_pack_value (bp, 0x12345678, 32);
372 }
373
374
375 /* Pack all the non-pointer fields of the TS_OMP_CLAUSE structure
376 of expression EXPR into bitpack BP. */
377
378 static void
pack_ts_omp_clause_value_fields(struct output_block * ob,struct bitpack_d * bp,tree expr)379 pack_ts_omp_clause_value_fields (struct output_block *ob,
380 struct bitpack_d *bp, tree expr)
381 {
382 stream_output_location (ob, bp, OMP_CLAUSE_LOCATION (expr));
383 switch (OMP_CLAUSE_CODE (expr))
384 {
385 case OMP_CLAUSE_DEFAULT:
386 bp_pack_enum (bp, omp_clause_default_kind, OMP_CLAUSE_DEFAULT_LAST,
387 OMP_CLAUSE_DEFAULT_KIND (expr));
388 break;
389 case OMP_CLAUSE_SCHEDULE:
390 bp_pack_enum (bp, omp_clause_schedule_kind, OMP_CLAUSE_SCHEDULE_LAST,
391 OMP_CLAUSE_SCHEDULE_KIND (expr));
392 break;
393 case OMP_CLAUSE_DEPEND:
394 bp_pack_enum (bp, omp_clause_depend_kind, OMP_CLAUSE_DEPEND_LAST,
395 OMP_CLAUSE_DEPEND_KIND (expr));
396 break;
397 case OMP_CLAUSE_MAP:
398 bp_pack_enum (bp, omp_clause_map_kind, OMP_CLAUSE_MAP_LAST,
399 OMP_CLAUSE_MAP_KIND (expr));
400 break;
401 case OMP_CLAUSE_PROC_BIND:
402 bp_pack_enum (bp, omp_clause_proc_bind_kind, OMP_CLAUSE_PROC_BIND_LAST,
403 OMP_CLAUSE_PROC_BIND_KIND (expr));
404 break;
405 case OMP_CLAUSE_REDUCTION:
406 bp_pack_enum (bp, tree_code, MAX_TREE_CODES,
407 OMP_CLAUSE_REDUCTION_CODE (expr));
408 break;
409 default:
410 break;
411 }
412 }
413
414
415 /* Pack all the bitfields in EXPR into a bit pack. */
416
417 void
streamer_pack_tree_bitfields(struct output_block * ob,struct bitpack_d * bp,tree expr)418 streamer_pack_tree_bitfields (struct output_block *ob,
419 struct bitpack_d *bp, tree expr)
420 {
421 enum tree_code code;
422
423 code = TREE_CODE (expr);
424
425 /* Note that all these functions are highly sensitive to changes in
426 the types and sizes of each of the fields being packed. */
427 pack_ts_base_value_fields (bp, expr);
428
429 if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
430 pack_ts_int_cst_value_fields (bp, expr);
431
432 if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
433 pack_ts_real_cst_value_fields (bp, expr);
434
435 if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
436 pack_ts_fixed_cst_value_fields (bp, expr);
437
438 if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
439 stream_output_location (ob, bp, DECL_SOURCE_LOCATION (expr));
440
441 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
442 pack_ts_decl_common_value_fields (bp, expr);
443
444 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
445 pack_ts_decl_wrtl_value_fields (bp, expr);
446
447 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
448 pack_ts_decl_with_vis_value_fields (bp, expr);
449
450 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
451 pack_ts_function_decl_value_fields (bp, expr);
452
453 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
454 pack_ts_type_common_value_fields (bp, expr);
455
456 if (CODE_CONTAINS_STRUCT (code, TS_EXP))
457 stream_output_location (ob, bp, EXPR_LOCATION (expr));
458
459 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
460 pack_ts_block_value_fields (ob, bp, expr);
461
462 if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
463 pack_ts_translation_unit_decl_value_fields (ob, bp, expr);
464
465 if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
466 gcc_unreachable ();
467
468 if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
469 pack_ts_optimization (bp, expr);
470
471 if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
472 bp_pack_var_len_unsigned (bp, vec_safe_length (BINFO_BASE_ACCESSES (expr)));
473
474 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
475 bp_pack_var_len_unsigned (bp, CONSTRUCTOR_NELTS (expr));
476
477 if (code == OMP_CLAUSE)
478 pack_ts_omp_clause_value_fields (ob, bp, expr);
479 }
480
481
482 /* Write the code and class of builtin EXPR to output block OB. IX is
483 the index into the streamer cache where EXPR is stored.*/
484
485 void
streamer_write_builtin(struct output_block * ob,tree expr)486 streamer_write_builtin (struct output_block *ob, tree expr)
487 {
488 gcc_assert (streamer_handle_as_builtin_p (expr));
489
490 if (DECL_BUILT_IN_CLASS (expr) == BUILT_IN_MD
491 && !targetm.builtin_decl)
492 sorry ("tree bytecode streams do not support machine specific builtin "
493 "functions on this target");
494
495 streamer_write_record_start (ob, LTO_builtin_decl);
496 streamer_write_enum (ob->main_stream, built_in_class, BUILT_IN_LAST,
497 DECL_BUILT_IN_CLASS (expr));
498 streamer_write_uhwi (ob, DECL_FUNCTION_CODE (expr));
499
500 if (DECL_ASSEMBLER_NAME_SET_P (expr))
501 {
502 /* When the assembler name of a builtin gets a user name,
503 the new name is always prefixed with '*' by
504 set_builtin_user_assembler_name. So, to prevent the
505 reader side from adding a second '*', we omit it here. */
506 const char *str = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (expr));
507 if (strlen (str) > 1 && str[0] == '*')
508 streamer_write_string (ob, ob->main_stream, &str[1], true);
509 else
510 streamer_write_string (ob, ob->main_stream, NULL, true);
511 }
512 else
513 streamer_write_string (ob, ob->main_stream, NULL, true);
514 }
515
516
517 /* Emit the chain of tree nodes starting at T. OB is the output block
518 to write to. REF_P is true if chain elements should be emitted
519 as references. */
520
521 void
streamer_write_chain(struct output_block * ob,tree t,bool ref_p)522 streamer_write_chain (struct output_block *ob, tree t, bool ref_p)
523 {
524 while (t)
525 {
526 /* We avoid outputting external vars or functions by reference
527 to the global decls section as we do not want to have them
528 enter decl merging. This is, of course, only for the call
529 for streaming BLOCK_VARS, but other callers are safe. */
530 /* ??? FIXME wrt SCC streaming. Drop these for now. */
531 if (VAR_OR_FUNCTION_DECL_P (t)
532 && DECL_EXTERNAL (t))
533 ; /* stream_write_tree_shallow_non_ref (ob, t, ref_p); */
534 else
535 stream_write_tree (ob, t, ref_p);
536
537 t = TREE_CHAIN (t);
538 }
539
540 /* Write a sentinel to terminate the chain. */
541 stream_write_tree (ob, NULL_TREE, ref_p);
542 }
543
544
545 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
546 block OB. If REF_P is true, write a reference to EXPR's pointer
547 fields. */
548
549 static void
write_ts_common_tree_pointers(struct output_block * ob,tree expr,bool ref_p)550 write_ts_common_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
551 {
552 if (TREE_CODE (expr) != IDENTIFIER_NODE)
553 stream_write_tree (ob, TREE_TYPE (expr), ref_p);
554 }
555
556
557 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
558 block OB. If REF_P is true, write a reference to EXPR's pointer
559 fields. */
560
561 static void
write_ts_vector_tree_pointers(struct output_block * ob,tree expr,bool ref_p)562 write_ts_vector_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
563 {
564 unsigned i;
565 /* Note that the number of elements for EXPR has already been emitted
566 in EXPR's header (see streamer_write_tree_header). */
567 for (i = 0; i < VECTOR_CST_NELTS (expr); ++i)
568 stream_write_tree (ob, VECTOR_CST_ELT (expr, i), ref_p);
569 }
570
571
572 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
573 block OB. If REF_P is true, write a reference to EXPR's pointer
574 fields. */
575
576 static void
write_ts_complex_tree_pointers(struct output_block * ob,tree expr,bool ref_p)577 write_ts_complex_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
578 {
579 stream_write_tree (ob, TREE_REALPART (expr), ref_p);
580 stream_write_tree (ob, TREE_IMAGPART (expr), ref_p);
581 }
582
583
584 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
585 to output block OB. If REF_P is true, write a reference to EXPR's
586 pointer fields. */
587
588 static void
write_ts_decl_minimal_tree_pointers(struct output_block * ob,tree expr,bool ref_p)589 write_ts_decl_minimal_tree_pointers (struct output_block *ob, tree expr,
590 bool ref_p)
591 {
592 /* Drop names that were created for anonymous entities. */
593 if (DECL_NAME (expr)
594 && TREE_CODE (DECL_NAME (expr)) == IDENTIFIER_NODE
595 && ANON_AGGRNAME_P (DECL_NAME (expr)))
596 stream_write_tree (ob, NULL_TREE, ref_p);
597 else
598 stream_write_tree (ob, DECL_NAME (expr), ref_p);
599 stream_write_tree (ob, DECL_CONTEXT (expr), ref_p);
600 }
601
602
603 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
604 output block OB. If REF_P is true, write a reference to EXPR's
605 pointer fields. */
606
607 static void
write_ts_decl_common_tree_pointers(struct output_block * ob,tree expr,bool ref_p)608 write_ts_decl_common_tree_pointers (struct output_block *ob, tree expr,
609 bool ref_p)
610 {
611 stream_write_tree (ob, DECL_SIZE (expr), ref_p);
612 stream_write_tree (ob, DECL_SIZE_UNIT (expr), ref_p);
613
614 /* Note, DECL_INITIAL is not handled here. Since DECL_INITIAL needs
615 special handling in LTO, it must be handled by streamer hooks. */
616
617 stream_write_tree (ob, DECL_ATTRIBUTES (expr), ref_p);
618
619 /* Do not stream DECL_ABSTRACT_ORIGIN. We cannot handle debug information
620 for early inlining so drop it on the floor instead of ICEing in
621 dwarf2out.c. */
622
623 if ((TREE_CODE (expr) == VAR_DECL
624 || TREE_CODE (expr) == PARM_DECL)
625 && DECL_HAS_VALUE_EXPR_P (expr))
626 stream_write_tree (ob, DECL_VALUE_EXPR (expr), ref_p);
627
628 if (TREE_CODE (expr) == VAR_DECL)
629 stream_write_tree (ob, DECL_DEBUG_EXPR (expr), ref_p);
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
637 static void
write_ts_decl_non_common_tree_pointers(struct output_block * ob,tree expr,bool ref_p)638 write_ts_decl_non_common_tree_pointers (struct output_block *ob, tree expr,
639 bool ref_p)
640 {
641 if (TREE_CODE (expr) == TYPE_DECL)
642 stream_write_tree (ob, DECL_ORIGINAL_TYPE (expr), ref_p);
643 stream_write_tree (ob, DECL_VINDEX (expr), ref_p);
644 }
645
646
647 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
648 to output block OB. If REF_P is true, write a reference to EXPR's
649 pointer fields. */
650
651 static void
write_ts_decl_with_vis_tree_pointers(struct output_block * ob,tree expr,bool ref_p)652 write_ts_decl_with_vis_tree_pointers (struct output_block *ob, tree expr,
653 bool ref_p)
654 {
655 /* Make sure we don't inadvertently set the assembler name. */
656 if (DECL_ASSEMBLER_NAME_SET_P (expr))
657 stream_write_tree (ob, DECL_ASSEMBLER_NAME (expr), ref_p);
658 else
659 stream_write_tree (ob, NULL_TREE, false);
660
661 stream_write_tree (ob, DECL_SECTION_NAME (expr), ref_p);
662 stream_write_tree (ob, DECL_COMDAT_GROUP (expr), ref_p);
663 }
664
665
666 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
667 output block OB. If REF_P is true, write a reference to EXPR's
668 pointer fields. */
669
670 static void
write_ts_field_decl_tree_pointers(struct output_block * ob,tree expr,bool ref_p)671 write_ts_field_decl_tree_pointers (struct output_block *ob, tree expr,
672 bool ref_p)
673 {
674 stream_write_tree (ob, DECL_FIELD_OFFSET (expr), ref_p);
675 stream_write_tree (ob, DECL_BIT_FIELD_TYPE (expr), ref_p);
676 stream_write_tree (ob, DECL_BIT_FIELD_REPRESENTATIVE (expr), ref_p);
677 stream_write_tree (ob, DECL_FIELD_BIT_OFFSET (expr), ref_p);
678 stream_write_tree (ob, DECL_FCONTEXT (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. FIXME lto,
691 maybe it should be handled here? */
692 stream_write_tree (ob, DECL_FUNCTION_PERSONALITY (expr), ref_p);
693 /* DECL_FUNCTION_SPECIFIC_TARGET is regenerated. */
694 stream_write_tree (ob, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr), ref_p);
695 }
696
697
698 /* Write all pointer fields in the TS_TYPE_COMMON structure of EXPR to
699 output block OB. If REF_P is true, write a reference to EXPR's
700 pointer fields. */
701
702 static void
write_ts_type_common_tree_pointers(struct output_block * ob,tree expr,bool ref_p)703 write_ts_type_common_tree_pointers (struct output_block *ob, tree expr,
704 bool ref_p)
705 {
706 stream_write_tree (ob, TYPE_SIZE (expr), ref_p);
707 stream_write_tree (ob, TYPE_SIZE_UNIT (expr), ref_p);
708 stream_write_tree (ob, TYPE_ATTRIBUTES (expr), ref_p);
709 stream_write_tree (ob, TYPE_NAME (expr), ref_p);
710 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
711 reconstructed during fixup. */
712 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
713 during fixup. */
714 stream_write_tree (ob, TYPE_MAIN_VARIANT (expr), ref_p);
715 stream_write_tree (ob, TYPE_CONTEXT (expr), ref_p);
716 /* TYPE_CANONICAL is re-computed during type merging, so no need
717 to stream it here. */
718 stream_write_tree (ob, TYPE_STUB_DECL (expr), ref_p);
719 }
720
721 /* Write all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
722 to output block OB. If REF_P is true, write a reference to EXPR's
723 pointer fields. */
724
725 static void
write_ts_type_non_common_tree_pointers(struct output_block * ob,tree expr,bool ref_p)726 write_ts_type_non_common_tree_pointers (struct output_block *ob, tree expr,
727 bool ref_p)
728 {
729 if (TREE_CODE (expr) == ENUMERAL_TYPE)
730 stream_write_tree (ob, TYPE_VALUES (expr), ref_p);
731 else if (TREE_CODE (expr) == ARRAY_TYPE)
732 stream_write_tree (ob, TYPE_DOMAIN (expr), ref_p);
733 else if (RECORD_OR_UNION_TYPE_P (expr))
734 streamer_write_chain (ob, TYPE_FIELDS (expr), ref_p);
735 else if (TREE_CODE (expr) == FUNCTION_TYPE
736 || TREE_CODE (expr) == METHOD_TYPE)
737 stream_write_tree (ob, TYPE_ARG_TYPES (expr), ref_p);
738
739 if (!POINTER_TYPE_P (expr))
740 stream_write_tree (ob, TYPE_MINVAL (expr), ref_p);
741 stream_write_tree (ob, TYPE_MAXVAL (expr), ref_p);
742 if (RECORD_OR_UNION_TYPE_P (expr))
743 stream_write_tree (ob, TYPE_BINFO (expr), ref_p);
744 }
745
746
747 /* Write all pointer fields in the TS_LIST structure of EXPR to output
748 block OB. If REF_P is true, write a reference to EXPR's pointer
749 fields. */
750
751 static void
write_ts_list_tree_pointers(struct output_block * ob,tree expr,bool ref_p)752 write_ts_list_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
753 {
754 stream_write_tree (ob, TREE_PURPOSE (expr), ref_p);
755 stream_write_tree (ob, TREE_VALUE (expr), ref_p);
756 stream_write_tree (ob, TREE_CHAIN (expr), ref_p);
757 }
758
759
760 /* Write all pointer fields in the TS_VEC structure of EXPR to output
761 block OB. If REF_P is true, write a reference to EXPR's pointer
762 fields. */
763
764 static void
write_ts_vec_tree_pointers(struct output_block * ob,tree expr,bool ref_p)765 write_ts_vec_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
766 {
767 int i;
768
769 /* Note that the number of slots for EXPR has already been emitted
770 in EXPR's header (see streamer_write_tree_header). */
771 for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
772 stream_write_tree (ob, TREE_VEC_ELT (expr, i), ref_p);
773 }
774
775
776 /* Write all pointer fields in the TS_EXP structure of EXPR to output
777 block OB. If REF_P is true, write a reference to EXPR's pointer
778 fields. */
779
780 static void
write_ts_exp_tree_pointers(struct output_block * ob,tree expr,bool ref_p)781 write_ts_exp_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
782 {
783 int i;
784
785 for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
786 stream_write_tree (ob, TREE_OPERAND (expr, i), ref_p);
787 stream_write_tree (ob, TREE_BLOCK (expr), ref_p);
788 }
789
790
791 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
792 block OB. If REF_P is true, write a reference to EXPR's pointer
793 fields. */
794
795 static void
write_ts_block_tree_pointers(struct output_block * ob,tree expr,bool ref_p)796 write_ts_block_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
797 {
798 streamer_write_chain (ob, BLOCK_VARS (expr), ref_p);
799
800 stream_write_tree (ob, BLOCK_SUPERCONTEXT (expr), ref_p);
801
802 /* Stream BLOCK_ABSTRACT_ORIGIN for the limited cases we can handle - those
803 that represent inlined function scopes.
804 For the rest them on the floor instead of ICEing in dwarf2out.c. */
805 if (inlined_function_outer_scope_p (expr))
806 {
807 tree ultimate_origin = block_ultimate_origin (expr);
808 stream_write_tree (ob, ultimate_origin, ref_p);
809 }
810 else
811 stream_write_tree (ob, NULL_TREE, ref_p);
812 /* Do not stream BLOCK_NONLOCALIZED_VARS. We cannot handle debug information
813 for early inlined BLOCKs so drop it on the floor instead of ICEing in
814 dwarf2out.c. */
815
816 /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
817 streaming time. */
818
819 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
820 list is re-constructed from BLOCK_SUPERCONTEXT. */
821 }
822
823
824 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
825 block OB. If REF_P is true, write a reference to EXPR's pointer
826 fields. */
827
828 static void
write_ts_binfo_tree_pointers(struct output_block * ob,tree expr,bool ref_p)829 write_ts_binfo_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
830 {
831 unsigned i;
832 tree t;
833
834 /* Note that the number of BINFO slots has already been emitted in
835 EXPR's header (see streamer_write_tree_header) because this length
836 is needed to build the empty BINFO node on the reader side. */
837 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr), i, t)
838 stream_write_tree (ob, t, ref_p);
839 stream_write_tree (ob, NULL_TREE, false);
840
841 stream_write_tree (ob, BINFO_OFFSET (expr), ref_p);
842 stream_write_tree (ob, BINFO_VTABLE (expr), ref_p);
843 stream_write_tree (ob, BINFO_VPTR_FIELD (expr), ref_p);
844
845 /* The number of BINFO_BASE_ACCESSES has already been emitted in
846 EXPR's bitfield section. */
847 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (expr), i, t)
848 stream_write_tree (ob, t, ref_p);
849
850 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
851 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
852 }
853
854
855 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
856 output block OB. If REF_P is true, write a reference to EXPR's
857 pointer fields. */
858
859 static void
write_ts_constructor_tree_pointers(struct output_block * ob,tree expr,bool ref_p)860 write_ts_constructor_tree_pointers (struct output_block *ob, tree expr,
861 bool ref_p)
862 {
863 unsigned i;
864 tree index, value;
865
866 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value)
867 {
868 stream_write_tree (ob, index, ref_p);
869 stream_write_tree (ob, value, ref_p);
870 }
871 }
872
873
874 /* Write all pointer fields in the TS_OMP_CLAUSE structure of EXPR
875 to output block OB. If REF_P is true, write a reference to EXPR's
876 pointer fields. */
877
878 static void
write_ts_omp_clause_tree_pointers(struct output_block * ob,tree expr,bool ref_p)879 write_ts_omp_clause_tree_pointers (struct output_block *ob, tree expr,
880 bool ref_p)
881 {
882 int i;
883 for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (expr)]; i++)
884 stream_write_tree (ob, OMP_CLAUSE_OPERAND (expr, i), ref_p);
885 if (OMP_CLAUSE_CODE (expr) == OMP_CLAUSE_REDUCTION)
886 {
887 /* We don't stream these right now, handle it if streaming
888 of them is needed. */
889 gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (expr) == NULL);
890 gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (expr) == NULL);
891 }
892 stream_write_tree (ob, OMP_CLAUSE_CHAIN (expr), ref_p);
893 }
894
895
896 /* Write all pointer fields in EXPR to output block OB. If REF_P is true,
897 the leaves of EXPR are emitted as references. */
898
899 void
streamer_write_tree_body(struct output_block * ob,tree expr,bool ref_p)900 streamer_write_tree_body (struct output_block *ob, tree expr, bool ref_p)
901 {
902 enum tree_code code;
903
904 lto_stats.num_tree_bodies_output++;
905
906 code = TREE_CODE (expr);
907
908 if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
909 write_ts_common_tree_pointers (ob, expr, ref_p);
910
911 if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
912 write_ts_vector_tree_pointers (ob, expr, ref_p);
913
914 if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
915 write_ts_complex_tree_pointers (ob, expr, ref_p);
916
917 if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
918 write_ts_decl_minimal_tree_pointers (ob, expr, ref_p);
919
920 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
921 write_ts_decl_common_tree_pointers (ob, expr, ref_p);
922
923 if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
924 write_ts_decl_non_common_tree_pointers (ob, expr, ref_p);
925
926 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
927 write_ts_decl_with_vis_tree_pointers (ob, expr, ref_p);
928
929 if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
930 write_ts_field_decl_tree_pointers (ob, expr, ref_p);
931
932 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
933 write_ts_function_decl_tree_pointers (ob, expr, ref_p);
934
935 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
936 write_ts_type_common_tree_pointers (ob, expr, ref_p);
937
938 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
939 write_ts_type_non_common_tree_pointers (ob, expr, ref_p);
940
941 if (CODE_CONTAINS_STRUCT (code, TS_LIST))
942 write_ts_list_tree_pointers (ob, expr, ref_p);
943
944 if (CODE_CONTAINS_STRUCT (code, TS_VEC))
945 write_ts_vec_tree_pointers (ob, expr, ref_p);
946
947 if (CODE_CONTAINS_STRUCT (code, TS_EXP))
948 write_ts_exp_tree_pointers (ob, expr, ref_p);
949
950 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
951 write_ts_block_tree_pointers (ob, expr, ref_p);
952
953 if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
954 write_ts_binfo_tree_pointers (ob, expr, ref_p);
955
956 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
957 write_ts_constructor_tree_pointers (ob, expr, ref_p);
958
959 if (code == OMP_CLAUSE)
960 write_ts_omp_clause_tree_pointers (ob, expr, ref_p);
961 }
962
963
964 /* Emit header information for tree EXPR to output block OB. The header
965 contains everything needed to instantiate an empty skeleton for
966 EXPR on the reading side. IX is the index into the streamer cache
967 where EXPR is stored. */
968
969 void
streamer_write_tree_header(struct output_block * ob,tree expr)970 streamer_write_tree_header (struct output_block *ob, tree expr)
971 {
972 enum LTO_tags tag;
973 enum tree_code code;
974
975 /* We should not see any tree nodes not handled by the streamer. */
976 code = TREE_CODE (expr);
977
978 /* The header of a tree node consists of its tag, the size of
979 the node, and any other information needed to instantiate
980 EXPR on the reading side (such as the number of slots in
981 variable sized nodes). */
982 tag = lto_tree_code_to_tag (code);
983 streamer_write_record_start (ob, tag);
984
985 /* The following will cause bootstrap miscomparisons. Enable with care. */
986 #ifdef LTO_STREAMER_DEBUG
987 /* This is used mainly for debugging purposes. When the reader
988 and the writer do not agree on a streamed node, the pointer
989 value for EXPR can be used to track down the differences in
990 the debugger. */
991 gcc_assert ((HOST_WIDEST_INT) (intptr_t) expr == (intptr_t) expr);
992 streamer_write_hwi (ob, (HOST_WIDEST_INT) (intptr_t) expr);
993 #endif
994
995 /* The text in strings and identifiers are completely emitted in
996 the header. */
997 if (CODE_CONTAINS_STRUCT (code, TS_STRING))
998 streamer_write_string_cst (ob, ob->main_stream, expr);
999 else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
1000 write_identifier (ob, ob->main_stream, expr);
1001 else if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
1002 streamer_write_hwi (ob, VECTOR_CST_NELTS (expr));
1003 else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1004 streamer_write_hwi (ob, TREE_VEC_LENGTH (expr));
1005 else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1006 streamer_write_uhwi (ob, BINFO_N_BASE_BINFOS (expr));
1007 else if (TREE_CODE (expr) == CALL_EXPR)
1008 streamer_write_uhwi (ob, call_expr_nargs (expr));
1009 else if (TREE_CODE (expr) == OMP_CLAUSE)
1010 streamer_write_uhwi (ob, OMP_CLAUSE_CODE (expr));
1011 }
1012
1013
1014 /* Emit the integer constant CST to output block OB. If REF_P is true,
1015 CST's type will be emitted as a reference. */
1016
1017 void
streamer_write_integer_cst(struct output_block * ob,tree cst,bool ref_p)1018 streamer_write_integer_cst (struct output_block *ob, tree cst, bool ref_p)
1019 {
1020 gcc_assert (!TREE_OVERFLOW (cst));
1021 streamer_write_record_start (ob, LTO_integer_cst);
1022 stream_write_tree (ob, TREE_TYPE (cst), ref_p);
1023 streamer_write_uhwi (ob, TREE_INT_CST_LOW (cst));
1024 streamer_write_hwi (ob, TREE_INT_CST_HIGH (cst));
1025 }
1026