1 /* Routines for emitting trees to a file stream.
3 Copyright (C) 2011-2014 Free Software Foundation, Inc.
4 Contributed by Diego Novillo <dnovillo@google.com>
6 This file is part of GCC.
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
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
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/>. */
24 #include "coretypes.h"
26 #include "diagnostic.h"
28 #include "stor-layout.h"
34 #include "hard-reg-set.h"
37 #include "basic-block.h"
38 #include "tree-ssa-alias.h"
39 #include "internal-fn.h"
40 #include "gimple-expr.h"
44 #include "plugin-api.h"
47 #include "tree-streamer.h"
48 #include "data-streamer.h"
49 #include "streamer-hooks.h"
51 /* Output the STRING constant to the string
52 table in OB. Then put the index onto the INDEX_STREAM. */
55 streamer_write_string_cst (struct output_block
*ob
,
56 struct lto_output_stream
*index_stream
,
59 streamer_write_string_with_length (ob
, index_stream
,
60 string
? TREE_STRING_POINTER (string
)
62 string
? TREE_STRING_LENGTH (string
) : 0,
67 /* Output the identifier ID to the string
68 table in OB. Then put the index onto the INDEX_STREAM. */
71 write_identifier (struct output_block
*ob
,
72 struct lto_output_stream
*index_stream
,
75 streamer_write_string_with_length (ob
, index_stream
,
76 IDENTIFIER_POINTER (id
),
77 IDENTIFIER_LENGTH (id
),
82 /* Pack all the non-pointer fields of the TS_BASE structure of
83 expression EXPR into bitpack BP. */
86 pack_ts_base_value_fields (struct bitpack_d
*bp
, tree expr
)
88 bp_pack_value (bp
, TREE_CODE (expr
), 16);
91 bp_pack_value (bp
, TREE_SIDE_EFFECTS (expr
), 1);
92 bp_pack_value (bp
, TREE_CONSTANT (expr
), 1);
93 bp_pack_value (bp
, TREE_READONLY (expr
), 1);
95 /* TREE_PUBLIC is used on types to indicate that the type
96 has a TYPE_CACHED_VALUES vector. This is not streamed out,
97 so we skip it here. */
98 bp_pack_value (bp
, TREE_PUBLIC (expr
), 1);
101 bp_pack_value (bp
, 0, 4);
102 bp_pack_value (bp
, TREE_ADDRESSABLE (expr
), 1);
103 bp_pack_value (bp
, TREE_THIS_VOLATILE (expr
), 1);
105 bp_pack_value (bp
, DECL_UNSIGNED (expr
), 1);
106 else if (TYPE_P (expr
))
107 bp_pack_value (bp
, TYPE_UNSIGNED (expr
), 1);
109 bp_pack_value (bp
, 0, 1);
110 /* We write debug info two times, do not confuse the second one.
111 The only relevant TREE_ASM_WRITTEN use is on SSA names. */
112 bp_pack_value (bp
, (TREE_CODE (expr
) != SSA_NAME
113 ? 0 : TREE_ASM_WRITTEN (expr
)), 1);
115 bp_pack_value (bp
, TYPE_ARTIFICIAL (expr
), 1);
117 bp_pack_value (bp
, TREE_NO_WARNING (expr
), 1);
118 bp_pack_value (bp
, TREE_NOTHROW (expr
), 1);
119 bp_pack_value (bp
, TREE_STATIC (expr
), 1);
120 if (TREE_CODE (expr
) != TREE_BINFO
)
121 bp_pack_value (bp
, TREE_PRIVATE (expr
), 1);
122 bp_pack_value (bp
, TREE_PROTECTED (expr
), 1);
123 bp_pack_value (bp
, TREE_DEPRECATED (expr
), 1);
126 bp_pack_value (bp
, TYPE_SATURATING (expr
), 1);
127 bp_pack_value (bp
, TYPE_ADDR_SPACE (expr
), 8);
129 else if (TREE_CODE (expr
) == SSA_NAME
)
130 bp_pack_value (bp
, SSA_NAME_IS_DEFAULT_DEF (expr
), 1);
132 bp_pack_value (bp
, 0, 1);
136 /* Pack all the non-pointer fields of the TS_INTEGER_CST structure of
137 expression EXPR into bitpack BP. */
140 pack_ts_int_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
143 /* Note that the number of elements has already been written out in
144 streamer_write_tree_header. */
145 for (i
= 0; i
< TREE_INT_CST_EXT_NUNITS (expr
); i
++)
146 bp_pack_var_len_int (bp
, TREE_INT_CST_ELT (expr
, i
));
150 /* Pack all the non-pointer fields of the TS_REAL_CST structure of
151 expression EXPR into bitpack BP. */
154 pack_ts_real_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
159 r
= TREE_REAL_CST (expr
);
160 bp_pack_value (bp
, r
.cl
, 2);
161 bp_pack_value (bp
, r
.decimal
, 1);
162 bp_pack_value (bp
, r
.sign
, 1);
163 bp_pack_value (bp
, r
.signalling
, 1);
164 bp_pack_value (bp
, r
.canonical
, 1);
165 bp_pack_value (bp
, r
.uexp
, EXP_BITS
);
166 for (i
= 0; i
< SIGSZ
; i
++)
167 bp_pack_value (bp
, r
.sig
[i
], HOST_BITS_PER_LONG
);
171 /* Pack all the non-pointer fields of the TS_FIXED_CST structure of
172 expression EXPR into bitpack BP. */
175 pack_ts_fixed_cst_value_fields (struct bitpack_d
*bp
, tree expr
)
177 struct fixed_value fv
= TREE_FIXED_CST (expr
);
178 bp_pack_enum (bp
, machine_mode
, MAX_MACHINE_MODE
, fv
.mode
);
179 bp_pack_var_len_int (bp
, fv
.data
.low
);
180 bp_pack_var_len_int (bp
, fv
.data
.high
);
183 /* Pack all the non-pointer fields of the TS_DECL_COMMON structure
184 of expression EXPR into bitpack BP. */
187 pack_ts_decl_common_value_fields (struct bitpack_d
*bp
, tree expr
)
189 bp_pack_enum (bp
, machine_mode
, MAX_MACHINE_MODE
, DECL_MODE (expr
));
190 bp_pack_value (bp
, DECL_NONLOCAL (expr
), 1);
191 bp_pack_value (bp
, DECL_VIRTUAL_P (expr
), 1);
192 bp_pack_value (bp
, DECL_IGNORED_P (expr
), 1);
193 bp_pack_value (bp
, DECL_ABSTRACT_P (expr
), 1);
194 bp_pack_value (bp
, DECL_ARTIFICIAL (expr
), 1);
195 bp_pack_value (bp
, DECL_USER_ALIGN (expr
), 1);
196 bp_pack_value (bp
, DECL_PRESERVE_P (expr
), 1);
197 bp_pack_value (bp
, DECL_EXTERNAL (expr
), 1);
198 bp_pack_value (bp
, DECL_GIMPLE_REG_P (expr
), 1);
199 bp_pack_var_len_unsigned (bp
, DECL_ALIGN (expr
));
201 if (TREE_CODE (expr
) == LABEL_DECL
)
203 /* Note that we do not write LABEL_DECL_UID. The reader will
204 always assume an initial value of -1 so that the
205 label_to_block_map is recreated by gimple_set_bb. */
206 bp_pack_var_len_unsigned (bp
, EH_LANDING_PAD_NR (expr
));
209 if (TREE_CODE (expr
) == FIELD_DECL
)
211 bp_pack_value (bp
, DECL_PACKED (expr
), 1);
212 bp_pack_value (bp
, DECL_NONADDRESSABLE_P (expr
), 1);
213 bp_pack_value (bp
, expr
->decl_common
.off_align
, 8);
216 if (TREE_CODE (expr
) == VAR_DECL
)
218 bp_pack_value (bp
, DECL_HAS_DEBUG_EXPR_P (expr
), 1);
219 bp_pack_value (bp
, DECL_NONLOCAL_FRAME (expr
), 1);
222 if (TREE_CODE (expr
) == RESULT_DECL
223 || TREE_CODE (expr
) == PARM_DECL
224 || TREE_CODE (expr
) == VAR_DECL
)
226 bp_pack_value (bp
, DECL_BY_REFERENCE (expr
), 1);
227 if (TREE_CODE (expr
) == VAR_DECL
228 || TREE_CODE (expr
) == PARM_DECL
)
229 bp_pack_value (bp
, DECL_HAS_VALUE_EXPR_P (expr
), 1);
234 /* Pack all the non-pointer fields of the TS_DECL_WRTL structure
235 of expression EXPR into bitpack BP. */
238 pack_ts_decl_wrtl_value_fields (struct bitpack_d
*bp
, tree expr
)
240 bp_pack_value (bp
, DECL_REGISTER (expr
), 1);
244 /* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
245 of expression EXPR into bitpack BP. */
248 pack_ts_decl_with_vis_value_fields (struct bitpack_d
*bp
, tree expr
)
250 bp_pack_value (bp
, DECL_COMMON (expr
), 1);
251 bp_pack_value (bp
, DECL_DLLIMPORT_P (expr
), 1);
252 bp_pack_value (bp
, DECL_WEAK (expr
), 1);
253 bp_pack_value (bp
, DECL_SEEN_IN_BIND_EXPR_P (expr
), 1);
254 bp_pack_value (bp
, DECL_COMDAT (expr
), 1);
255 bp_pack_value (bp
, DECL_VISIBILITY (expr
), 2);
256 bp_pack_value (bp
, DECL_VISIBILITY_SPECIFIED (expr
), 1);
258 if (TREE_CODE (expr
) == VAR_DECL
)
260 bp_pack_value (bp
, DECL_HARD_REGISTER (expr
), 1);
261 /* DECL_IN_TEXT_SECTION is set during final asm output only. */
262 bp_pack_value (bp
, DECL_IN_CONSTANT_POOL (expr
), 1);
265 if (TREE_CODE (expr
) == FUNCTION_DECL
)
267 bp_pack_value (bp
, DECL_FINAL_P (expr
), 1);
268 bp_pack_value (bp
, DECL_CXX_CONSTRUCTOR_P (expr
), 1);
269 bp_pack_value (bp
, DECL_CXX_DESTRUCTOR_P (expr
), 1);
274 /* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure
275 of expression EXPR into bitpack BP. */
278 pack_ts_function_decl_value_fields (struct bitpack_d
*bp
, tree expr
)
280 /* For normal/md builtins we only write the class and code, so they
281 should never be handled here. */
282 gcc_assert (!streamer_handle_as_builtin_p (expr
));
284 bp_pack_enum (bp
, built_in_class
, BUILT_IN_LAST
,
285 DECL_BUILT_IN_CLASS (expr
));
286 bp_pack_value (bp
, DECL_STATIC_CONSTRUCTOR (expr
), 1);
287 bp_pack_value (bp
, DECL_STATIC_DESTRUCTOR (expr
), 1);
288 bp_pack_value (bp
, DECL_UNINLINABLE (expr
), 1);
289 bp_pack_value (bp
, DECL_POSSIBLY_INLINED (expr
), 1);
290 bp_pack_value (bp
, DECL_IS_NOVOPS (expr
), 1);
291 bp_pack_value (bp
, DECL_IS_RETURNS_TWICE (expr
), 1);
292 bp_pack_value (bp
, DECL_IS_MALLOC (expr
), 1);
293 bp_pack_value (bp
, DECL_IS_OPERATOR_NEW (expr
), 1);
294 bp_pack_value (bp
, DECL_DECLARED_INLINE_P (expr
), 1);
295 bp_pack_value (bp
, DECL_STATIC_CHAIN (expr
), 1);
296 bp_pack_value (bp
, DECL_NO_INLINE_WARNING_P (expr
), 1);
297 bp_pack_value (bp
, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr
), 1);
298 bp_pack_value (bp
, DECL_NO_LIMIT_STACK (expr
), 1);
299 bp_pack_value (bp
, DECL_DISREGARD_INLINE_LIMITS (expr
), 1);
300 bp_pack_value (bp
, DECL_PURE_P (expr
), 1);
301 bp_pack_value (bp
, DECL_LOOPING_CONST_OR_PURE_P (expr
), 1);
302 if (DECL_BUILT_IN_CLASS (expr
) != NOT_BUILT_IN
)
303 bp_pack_value (bp
, DECL_FUNCTION_CODE (expr
), 11);
307 /* Pack all the non-pointer fields of the TS_TYPE_COMMON structure
308 of expression EXPR into bitpack BP. */
311 pack_ts_type_common_value_fields (struct bitpack_d
*bp
, tree expr
)
313 bp_pack_enum (bp
, machine_mode
, MAX_MACHINE_MODE
, TYPE_MODE (expr
));
314 bp_pack_value (bp
, TYPE_STRING_FLAG (expr
), 1);
315 bp_pack_value (bp
, TYPE_NO_FORCE_BLK (expr
), 1);
316 bp_pack_value (bp
, TYPE_NEEDS_CONSTRUCTING (expr
), 1);
317 if (RECORD_OR_UNION_TYPE_P (expr
))
319 bp_pack_value (bp
, TYPE_TRANSPARENT_AGGR (expr
), 1);
320 bp_pack_value (bp
, TYPE_FINAL_P (expr
), 1);
322 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
323 bp_pack_value (bp
, TYPE_NONALIASED_COMPONENT (expr
), 1);
324 bp_pack_value (bp
, TYPE_PACKED (expr
), 1);
325 bp_pack_value (bp
, TYPE_RESTRICT (expr
), 1);
326 bp_pack_value (bp
, TYPE_USER_ALIGN (expr
), 1);
327 bp_pack_value (bp
, TYPE_READONLY (expr
), 1);
328 bp_pack_var_len_unsigned (bp
, TYPE_PRECISION (expr
));
329 bp_pack_var_len_unsigned (bp
, TYPE_ALIGN (expr
));
330 /* Make sure to preserve the fact whether the frontend would assign
331 alias-set zero to this type. */
332 bp_pack_var_len_int (bp
, (TYPE_ALIAS_SET (expr
) == 0
334 && get_alias_set (expr
) == 0)) ? 0 : -1);
338 /* Pack all the non-pointer fields of the TS_BLOCK structure
339 of expression EXPR into bitpack BP. */
342 pack_ts_block_value_fields (struct output_block
*ob
,
343 struct bitpack_d
*bp
, tree expr
)
345 bp_pack_value (bp
, BLOCK_ABSTRACT (expr
), 1);
346 /* BLOCK_NUMBER is recomputed. */
347 /* Stream BLOCK_SOURCE_LOCATION for the limited cases we can handle - those
348 that represent inlined function scopes.
349 For the rest them on the floor instead of ICEing in dwarf2out.c. */
350 if (inlined_function_outer_scope_p (expr
))
351 stream_output_location (ob
, bp
, BLOCK_SOURCE_LOCATION (expr
));
353 stream_output_location (ob
, bp
, UNKNOWN_LOCATION
);
356 /* Pack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL structure
357 of expression EXPR into bitpack BP. */
360 pack_ts_translation_unit_decl_value_fields (struct output_block
*ob
,
361 struct bitpack_d
*bp
, tree expr
)
363 bp_pack_string (ob
, bp
, TRANSLATION_UNIT_LANGUAGE (expr
), true);
366 /* Pack a TS_OPTIMIZATION tree in EXPR to BP. */
369 pack_ts_optimization (struct bitpack_d
*bp
, tree expr
)
371 struct cl_optimization
*t
= TREE_OPTIMIZATION (expr
);
374 /* The cl_optimization is generated by the options
375 awk script, so we just recreate a byte-by-byte copy here. */
377 len
= sizeof (struct cl_optimization
);
378 for (i
= 0; i
< len
; i
++)
379 bp_pack_value (bp
, ((unsigned char *)t
)[i
], 8);
380 /* Catch struct size mismatches between reader and writer. */
381 bp_pack_value (bp
, 0x12345678, 32);
385 /* Pack all the non-pointer fields of the TS_OMP_CLAUSE structure
386 of expression EXPR into bitpack BP. */
389 pack_ts_omp_clause_value_fields (struct output_block
*ob
,
390 struct bitpack_d
*bp
, tree expr
)
392 stream_output_location (ob
, bp
, OMP_CLAUSE_LOCATION (expr
));
393 switch (OMP_CLAUSE_CODE (expr
))
395 case OMP_CLAUSE_DEFAULT
:
396 bp_pack_enum (bp
, omp_clause_default_kind
, OMP_CLAUSE_DEFAULT_LAST
,
397 OMP_CLAUSE_DEFAULT_KIND (expr
));
399 case OMP_CLAUSE_SCHEDULE
:
400 bp_pack_enum (bp
, omp_clause_schedule_kind
, OMP_CLAUSE_SCHEDULE_LAST
,
401 OMP_CLAUSE_SCHEDULE_KIND (expr
));
403 case OMP_CLAUSE_DEPEND
:
404 bp_pack_enum (bp
, omp_clause_depend_kind
, OMP_CLAUSE_DEPEND_LAST
,
405 OMP_CLAUSE_DEPEND_KIND (expr
));
408 bp_pack_enum (bp
, omp_clause_map_kind
, OMP_CLAUSE_MAP_LAST
,
409 OMP_CLAUSE_MAP_KIND (expr
));
411 case OMP_CLAUSE_PROC_BIND
:
412 bp_pack_enum (bp
, omp_clause_proc_bind_kind
, OMP_CLAUSE_PROC_BIND_LAST
,
413 OMP_CLAUSE_PROC_BIND_KIND (expr
));
415 case OMP_CLAUSE_REDUCTION
:
416 bp_pack_enum (bp
, tree_code
, MAX_TREE_CODES
,
417 OMP_CLAUSE_REDUCTION_CODE (expr
));
425 /* Pack all the bitfields in EXPR into a bit pack. */
428 streamer_pack_tree_bitfields (struct output_block
*ob
,
429 struct bitpack_d
*bp
, tree expr
)
433 code
= TREE_CODE (expr
);
435 /* Note that all these functions are highly sensitive to changes in
436 the types and sizes of each of the fields being packed. */
437 pack_ts_base_value_fields (bp
, expr
);
439 if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
440 pack_ts_int_cst_value_fields (bp
, expr
);
442 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
443 pack_ts_real_cst_value_fields (bp
, expr
);
445 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
446 pack_ts_fixed_cst_value_fields (bp
, expr
);
448 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
449 stream_output_location (ob
, bp
, DECL_SOURCE_LOCATION (expr
));
451 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
452 pack_ts_decl_common_value_fields (bp
, expr
);
454 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
455 pack_ts_decl_wrtl_value_fields (bp
, expr
);
457 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
458 pack_ts_decl_with_vis_value_fields (bp
, expr
);
460 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
461 pack_ts_function_decl_value_fields (bp
, expr
);
463 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
464 pack_ts_type_common_value_fields (bp
, expr
);
466 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
467 stream_output_location (ob
, bp
, EXPR_LOCATION (expr
));
469 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
470 pack_ts_block_value_fields (ob
, bp
, expr
);
472 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
473 pack_ts_translation_unit_decl_value_fields (ob
, bp
, expr
);
475 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
))
478 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
479 pack_ts_optimization (bp
, expr
);
481 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
482 bp_pack_var_len_unsigned (bp
, vec_safe_length (BINFO_BASE_ACCESSES (expr
)));
484 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
485 bp_pack_var_len_unsigned (bp
, CONSTRUCTOR_NELTS (expr
));
487 if (code
== OMP_CLAUSE
)
488 pack_ts_omp_clause_value_fields (ob
, bp
, expr
);
492 /* Write the code and class of builtin EXPR to output block OB. IX is
493 the index into the streamer cache where EXPR is stored.*/
496 streamer_write_builtin (struct output_block
*ob
, tree expr
)
498 gcc_assert (streamer_handle_as_builtin_p (expr
));
500 if (DECL_BUILT_IN_CLASS (expr
) == BUILT_IN_MD
501 && !targetm
.builtin_decl
)
502 sorry ("tree bytecode streams do not support machine specific builtin "
503 "functions on this target");
505 streamer_write_record_start (ob
, LTO_builtin_decl
);
506 streamer_write_enum (ob
->main_stream
, built_in_class
, BUILT_IN_LAST
,
507 DECL_BUILT_IN_CLASS (expr
));
508 streamer_write_uhwi (ob
, DECL_FUNCTION_CODE (expr
));
510 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
512 /* When the assembler name of a builtin gets a user name,
513 the new name is always prefixed with '*' by
514 set_builtin_user_assembler_name. So, to prevent the
515 reader side from adding a second '*', we omit it here. */
516 const char *str
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (expr
));
517 if (strlen (str
) > 1 && str
[0] == '*')
518 streamer_write_string (ob
, ob
->main_stream
, &str
[1], true);
520 streamer_write_string (ob
, ob
->main_stream
, NULL
, true);
523 streamer_write_string (ob
, ob
->main_stream
, NULL
, true);
527 /* Emit the chain of tree nodes starting at T. OB is the output block
528 to write to. REF_P is true if chain elements should be emitted
532 streamer_write_chain (struct output_block
*ob
, tree t
, bool ref_p
)
536 /* We avoid outputting external vars or functions by reference
537 to the global decls section as we do not want to have them
538 enter decl merging. This is, of course, only for the call
539 for streaming BLOCK_VARS, but other callers are safe.
540 See also lto-streamer-out.c:DFS_write_tree_body. */
541 if (VAR_OR_FUNCTION_DECL_P (t
)
542 && DECL_EXTERNAL (t
))
543 stream_write_tree_shallow_non_ref (ob
, t
, ref_p
);
545 stream_write_tree (ob
, t
, ref_p
);
550 /* Write a sentinel to terminate the chain. */
551 stream_write_tree (ob
, NULL_TREE
, ref_p
);
555 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
556 block OB. If REF_P is true, write a reference to EXPR's pointer
560 write_ts_common_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
562 if (TREE_CODE (expr
) != IDENTIFIER_NODE
)
563 stream_write_tree (ob
, TREE_TYPE (expr
), ref_p
);
567 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
568 block OB. If REF_P is true, write a reference to EXPR's pointer
572 write_ts_vector_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
575 /* Note that the number of elements for EXPR has already been emitted
576 in EXPR's header (see streamer_write_tree_header). */
577 for (i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
578 stream_write_tree (ob
, VECTOR_CST_ELT (expr
, i
), ref_p
);
582 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
583 block OB. If REF_P is true, write a reference to EXPR's pointer
587 write_ts_complex_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
589 stream_write_tree (ob
, TREE_REALPART (expr
), ref_p
);
590 stream_write_tree (ob
, TREE_IMAGPART (expr
), ref_p
);
594 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
595 to output block OB. If REF_P is true, write a reference to EXPR's
599 write_ts_decl_minimal_tree_pointers (struct output_block
*ob
, tree expr
,
602 /* Drop names that were created for anonymous entities. */
604 && TREE_CODE (DECL_NAME (expr
)) == IDENTIFIER_NODE
605 && ANON_AGGRNAME_P (DECL_NAME (expr
)))
606 stream_write_tree (ob
, NULL_TREE
, ref_p
);
608 stream_write_tree (ob
, DECL_NAME (expr
), ref_p
);
609 stream_write_tree (ob
, DECL_CONTEXT (expr
), ref_p
);
613 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
614 output block OB. If REF_P is true, write a reference to EXPR's
618 write_ts_decl_common_tree_pointers (struct output_block
*ob
, tree expr
,
621 stream_write_tree (ob
, DECL_SIZE (expr
), ref_p
);
622 stream_write_tree (ob
, DECL_SIZE_UNIT (expr
), ref_p
);
624 /* Note, DECL_INITIAL is not handled here. Since DECL_INITIAL needs
625 special handling in LTO, it must be handled by streamer hooks. */
627 stream_write_tree (ob
, DECL_ATTRIBUTES (expr
), ref_p
);
629 /* Do not stream DECL_ABSTRACT_ORIGIN. We cannot handle debug information
630 for early inlining so drop it on the floor instead of ICEing in
633 if ((TREE_CODE (expr
) == VAR_DECL
634 || TREE_CODE (expr
) == PARM_DECL
)
635 && DECL_HAS_VALUE_EXPR_P (expr
))
636 stream_write_tree (ob
, DECL_VALUE_EXPR (expr
), ref_p
);
638 if (TREE_CODE (expr
) == VAR_DECL
)
639 stream_write_tree (ob
, DECL_DEBUG_EXPR (expr
), ref_p
);
643 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
644 EXPR to output block OB. If REF_P is true, write a reference to EXPR's
648 write_ts_decl_non_common_tree_pointers (struct output_block
*ob
, tree expr
,
651 if (TREE_CODE (expr
) == TYPE_DECL
)
652 stream_write_tree (ob
, DECL_ORIGINAL_TYPE (expr
), ref_p
);
656 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
657 to output block OB. If REF_P is true, write a reference to EXPR's
661 write_ts_decl_with_vis_tree_pointers (struct output_block
*ob
, tree expr
,
664 /* Make sure we don't inadvertently set the assembler name. */
665 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
666 stream_write_tree (ob
, DECL_ASSEMBLER_NAME (expr
), ref_p
);
668 stream_write_tree (ob
, NULL_TREE
, false);
672 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
673 output block OB. If REF_P is true, write a reference to EXPR's
677 write_ts_field_decl_tree_pointers (struct output_block
*ob
, tree expr
,
680 stream_write_tree (ob
, DECL_FIELD_OFFSET (expr
), ref_p
);
681 stream_write_tree (ob
, DECL_BIT_FIELD_TYPE (expr
), ref_p
);
682 stream_write_tree (ob
, DECL_BIT_FIELD_REPRESENTATIVE (expr
), ref_p
);
683 stream_write_tree (ob
, DECL_FIELD_BIT_OFFSET (expr
), ref_p
);
684 stream_write_tree (ob
, DECL_FCONTEXT (expr
), ref_p
);
688 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
689 to output block OB. If REF_P is true, write a reference to EXPR's
693 write_ts_function_decl_tree_pointers (struct output_block
*ob
, tree expr
,
696 stream_write_tree (ob
, DECL_VINDEX (expr
), ref_p
);
697 /* DECL_STRUCT_FUNCTION is handled by lto_output_function. FIXME lto,
698 maybe it should be handled here? */
699 stream_write_tree (ob
, DECL_FUNCTION_PERSONALITY (expr
), ref_p
);
700 /* DECL_FUNCTION_SPECIFIC_TARGET is regenerated. */
701 stream_write_tree (ob
, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr
), ref_p
);
705 /* Write all pointer fields in the TS_TYPE_COMMON structure of EXPR to
706 output block OB. If REF_P is true, write a reference to EXPR's
710 write_ts_type_common_tree_pointers (struct output_block
*ob
, tree expr
,
713 stream_write_tree (ob
, TYPE_SIZE (expr
), ref_p
);
714 stream_write_tree (ob
, TYPE_SIZE_UNIT (expr
), ref_p
);
715 stream_write_tree (ob
, TYPE_ATTRIBUTES (expr
), ref_p
);
716 stream_write_tree (ob
, TYPE_NAME (expr
), ref_p
);
717 /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
718 reconstructed during fixup. */
719 /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
721 stream_write_tree (ob
, TYPE_MAIN_VARIANT (expr
), ref_p
);
722 stream_write_tree (ob
, TYPE_CONTEXT (expr
), ref_p
);
723 /* TYPE_CANONICAL is re-computed during type merging, so no need
724 to stream it here. */
725 stream_write_tree (ob
, TYPE_STUB_DECL (expr
), ref_p
);
728 /* Write all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
729 to output block OB. If REF_P is true, write a reference to EXPR's
733 write_ts_type_non_common_tree_pointers (struct output_block
*ob
, tree expr
,
736 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
737 stream_write_tree (ob
, TYPE_VALUES (expr
), ref_p
);
738 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
739 stream_write_tree (ob
, TYPE_DOMAIN (expr
), ref_p
);
740 else if (RECORD_OR_UNION_TYPE_P (expr
))
741 streamer_write_chain (ob
, TYPE_FIELDS (expr
), ref_p
);
742 else if (TREE_CODE (expr
) == FUNCTION_TYPE
743 || TREE_CODE (expr
) == METHOD_TYPE
)
744 stream_write_tree (ob
, TYPE_ARG_TYPES (expr
), ref_p
);
746 if (!POINTER_TYPE_P (expr
))
747 stream_write_tree (ob
, TYPE_MINVAL (expr
), ref_p
);
748 stream_write_tree (ob
, TYPE_MAXVAL (expr
), ref_p
);
749 if (RECORD_OR_UNION_TYPE_P (expr
))
750 stream_write_tree (ob
, TYPE_BINFO (expr
), ref_p
);
754 /* Write all pointer fields in the TS_LIST structure of EXPR to output
755 block OB. If REF_P is true, write a reference to EXPR's pointer
759 write_ts_list_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
761 stream_write_tree (ob
, TREE_PURPOSE (expr
), ref_p
);
762 stream_write_tree (ob
, TREE_VALUE (expr
), ref_p
);
763 stream_write_tree (ob
, TREE_CHAIN (expr
), ref_p
);
767 /* Write all pointer fields in the TS_VEC structure of EXPR to output
768 block OB. If REF_P is true, write a reference to EXPR's pointer
772 write_ts_vec_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
776 /* Note that the number of slots for EXPR has already been emitted
777 in EXPR's header (see streamer_write_tree_header). */
778 for (i
= 0; i
< TREE_VEC_LENGTH (expr
); i
++)
779 stream_write_tree (ob
, TREE_VEC_ELT (expr
, i
), ref_p
);
783 /* Write all pointer fields in the TS_EXP structure of EXPR to output
784 block OB. If REF_P is true, write a reference to EXPR's pointer
788 write_ts_exp_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
792 for (i
= 0; i
< TREE_OPERAND_LENGTH (expr
); i
++)
793 stream_write_tree (ob
, TREE_OPERAND (expr
, i
), ref_p
);
794 stream_write_tree (ob
, TREE_BLOCK (expr
), ref_p
);
798 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
799 block OB. If REF_P is true, write a reference to EXPR's pointer
803 write_ts_block_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
805 streamer_write_chain (ob
, BLOCK_VARS (expr
), ref_p
);
807 stream_write_tree (ob
, BLOCK_SUPERCONTEXT (expr
), ref_p
);
809 /* Stream BLOCK_ABSTRACT_ORIGIN for the limited cases we can handle - those
810 that represent inlined function scopes.
811 For the rest them on the floor instead of ICEing in dwarf2out.c. */
812 if (inlined_function_outer_scope_p (expr
))
814 tree ultimate_origin
= block_ultimate_origin (expr
);
815 stream_write_tree (ob
, ultimate_origin
, ref_p
);
818 stream_write_tree (ob
, NULL_TREE
, ref_p
);
819 /* Do not stream BLOCK_NONLOCALIZED_VARS. We cannot handle debug information
820 for early inlined BLOCKs so drop it on the floor instead of ICEing in
823 /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
826 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
827 list is re-constructed from BLOCK_SUPERCONTEXT. */
831 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
832 block OB. If REF_P is true, write a reference to EXPR's pointer
836 write_ts_binfo_tree_pointers (struct output_block
*ob
, tree expr
, bool ref_p
)
841 /* Note that the number of BINFO slots has already been emitted in
842 EXPR's header (see streamer_write_tree_header) because this length
843 is needed to build the empty BINFO node on the reader side. */
844 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr
), i
, t
)
845 stream_write_tree (ob
, t
, ref_p
);
846 stream_write_tree (ob
, NULL_TREE
, false);
848 stream_write_tree (ob
, BINFO_OFFSET (expr
), ref_p
);
849 stream_write_tree (ob
, BINFO_VTABLE (expr
), ref_p
);
850 stream_write_tree (ob
, BINFO_VPTR_FIELD (expr
), ref_p
);
852 /* The number of BINFO_BASE_ACCESSES has already been emitted in
853 EXPR's bitfield section. */
854 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (expr
), i
, t
)
855 stream_write_tree (ob
, t
, ref_p
);
857 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
858 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
862 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
863 output block OB. If REF_P is true, write a reference to EXPR's
867 write_ts_constructor_tree_pointers (struct output_block
*ob
, tree expr
,
873 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr
), i
, index
, value
)
875 stream_write_tree (ob
, index
, ref_p
);
876 stream_write_tree (ob
, value
, ref_p
);
881 /* Write all pointer fields in the TS_OMP_CLAUSE structure of EXPR
882 to output block OB. If REF_P is true, write a reference to EXPR's
886 write_ts_omp_clause_tree_pointers (struct output_block
*ob
, tree expr
,
890 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (expr
)]; i
++)
891 stream_write_tree (ob
, OMP_CLAUSE_OPERAND (expr
, i
), ref_p
);
892 if (OMP_CLAUSE_CODE (expr
) == OMP_CLAUSE_REDUCTION
)
894 /* We don't stream these right now, handle it if streaming
895 of them is needed. */
896 gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (expr
) == NULL
);
897 gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (expr
) == NULL
);
899 stream_write_tree (ob
, OMP_CLAUSE_CHAIN (expr
), ref_p
);
903 /* Write all pointer fields in EXPR to output block OB. If REF_P is true,
904 the leaves of EXPR are emitted as references. */
907 streamer_write_tree_body (struct output_block
*ob
, tree expr
, bool ref_p
)
911 lto_stats
.num_tree_bodies_output
++;
913 code
= TREE_CODE (expr
);
915 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
916 write_ts_common_tree_pointers (ob
, expr
, ref_p
);
918 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
919 write_ts_vector_tree_pointers (ob
, expr
, ref_p
);
921 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
922 write_ts_complex_tree_pointers (ob
, expr
, ref_p
);
924 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
925 write_ts_decl_minimal_tree_pointers (ob
, expr
, ref_p
);
927 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
928 write_ts_decl_common_tree_pointers (ob
, expr
, ref_p
);
930 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
931 write_ts_decl_non_common_tree_pointers (ob
, expr
, ref_p
);
933 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
934 write_ts_decl_with_vis_tree_pointers (ob
, expr
, ref_p
);
936 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
937 write_ts_field_decl_tree_pointers (ob
, expr
, ref_p
);
939 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
940 write_ts_function_decl_tree_pointers (ob
, expr
, ref_p
);
942 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
943 write_ts_type_common_tree_pointers (ob
, expr
, ref_p
);
945 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
946 write_ts_type_non_common_tree_pointers (ob
, expr
, ref_p
);
948 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
949 write_ts_list_tree_pointers (ob
, expr
, ref_p
);
951 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
952 write_ts_vec_tree_pointers (ob
, expr
, ref_p
);
954 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
955 write_ts_exp_tree_pointers (ob
, expr
, ref_p
);
957 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
958 write_ts_block_tree_pointers (ob
, expr
, ref_p
);
960 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
961 write_ts_binfo_tree_pointers (ob
, expr
, ref_p
);
963 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
964 write_ts_constructor_tree_pointers (ob
, expr
, ref_p
);
966 if (code
== OMP_CLAUSE
)
967 write_ts_omp_clause_tree_pointers (ob
, expr
, ref_p
);
971 /* Emit header information for tree EXPR to output block OB. The header
972 contains everything needed to instantiate an empty skeleton for
973 EXPR on the reading side. IX is the index into the streamer cache
974 where EXPR is stored. */
977 streamer_write_tree_header (struct output_block
*ob
, tree expr
)
982 /* We should not see any tree nodes not handled by the streamer. */
983 code
= TREE_CODE (expr
);
985 /* The header of a tree node consists of its tag, the size of
986 the node, and any other information needed to instantiate
987 EXPR on the reading side (such as the number of slots in
988 variable sized nodes). */
989 tag
= lto_tree_code_to_tag (code
);
990 streamer_write_record_start (ob
, tag
);
992 /* The following will cause bootstrap miscomparisons. Enable with care. */
993 #ifdef LTO_STREAMER_DEBUG
994 /* This is used mainly for debugging purposes. When the reader
995 and the writer do not agree on a streamed node, the pointer
996 value for EXPR can be used to track down the differences in
998 gcc_assert ((HOST_WIDE_INT
) (intptr_t) expr
== (intptr_t) expr
);
999 streamer_write_hwi (ob
, (HOST_WIDE_INT
) (intptr_t) expr
);
1002 /* The text in strings and identifiers are completely emitted in
1004 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
1005 streamer_write_string_cst (ob
, ob
->main_stream
, expr
);
1006 else if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
1007 write_identifier (ob
, ob
->main_stream
, expr
);
1008 else if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
1009 streamer_write_hwi (ob
, VECTOR_CST_NELTS (expr
));
1010 else if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1011 streamer_write_hwi (ob
, TREE_VEC_LENGTH (expr
));
1012 else if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1013 streamer_write_uhwi (ob
, BINFO_N_BASE_BINFOS (expr
));
1014 else if (TREE_CODE (expr
) == CALL_EXPR
)
1015 streamer_write_uhwi (ob
, call_expr_nargs (expr
));
1016 else if (TREE_CODE (expr
) == OMP_CLAUSE
)
1017 streamer_write_uhwi (ob
, OMP_CLAUSE_CODE (expr
));
1018 else if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
1020 gcc_checking_assert (TREE_INT_CST_NUNITS (expr
));
1021 streamer_write_uhwi (ob
, TREE_INT_CST_NUNITS (expr
));
1022 streamer_write_uhwi (ob
, TREE_INT_CST_EXT_NUNITS (expr
));
1027 /* Emit the integer constant CST to output block OB. If REF_P is true,
1028 CST's type will be emitted as a reference. */
1031 streamer_write_integer_cst (struct output_block
*ob
, tree cst
, bool ref_p
)
1034 int len
= TREE_INT_CST_NUNITS (cst
);
1035 gcc_assert (!TREE_OVERFLOW (cst
));
1036 streamer_write_record_start (ob
, LTO_integer_cst
);
1037 stream_write_tree (ob
, TREE_TYPE (cst
), ref_p
);
1038 /* We're effectively streaming a non-sign-extended wide_int here,
1039 so there's no need to stream TREE_INT_CST_EXT_NUNITS or any
1040 array members beyond LEN. We'll recreate the tree from the
1041 wide_int and the type. */
1042 streamer_write_uhwi (ob
, len
);
1043 for (i
= 0; i
< len
; i
++)
1044 streamer_write_hwi (ob
, TREE_INT_CST_ELT (cst
, i
));