1 /* Write the GIMPLE representation to a file stream.
3 Copyright (C) 2009-2014 Free Software Foundation, Inc.
4 Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
5 Re-implemented by Diego Novillo <dnovillo@google.com>
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
28 #include "stor-layout.h"
29 #include "stringpool.h"
35 #include "basic-block.h"
36 #include "tree-ssa-alias.h"
37 #include "internal-fn.h"
38 #include "gimple-expr.h"
41 #include "gimple-iterator.h"
42 #include "gimple-ssa.h"
43 #include "tree-ssanames.h"
44 #include "tree-pass.h"
46 #include "diagnostic-core.h"
48 #include "lto-symtab.h"
49 #include "lto-streamer.h"
50 #include "data-streamer.h"
51 #include "gimple-streamer.h"
52 #include "tree-streamer.h"
53 #include "streamer-hooks.h"
58 static void lto_write_tree (struct output_block
*, tree
, bool);
60 /* Clear the line info stored in DATA_IN. */
63 clear_line_info (struct output_block
*ob
)
65 ob
->current_file
= NULL
;
71 /* Create the output block and return it. SECTION_TYPE is
72 LTO_section_function_body or LTO_static_initializer. */
75 create_output_block (enum lto_section_type section_type
)
77 struct output_block
*ob
= XCNEW (struct output_block
);
79 ob
->section_type
= section_type
;
80 ob
->decl_state
= lto_get_out_decl_state ();
81 ob
->main_stream
= XCNEW (struct lto_output_stream
);
82 ob
->string_stream
= XCNEW (struct lto_output_stream
);
83 ob
->writer_cache
= streamer_tree_cache_create (!flag_wpa
, true, false);
85 if (section_type
== LTO_section_function_body
)
86 ob
->cfg_stream
= XCNEW (struct lto_output_stream
);
90 ob
->string_hash_table
.create (37);
91 gcc_obstack_init (&ob
->obstack
);
97 /* Destroy the output block OB. */
100 destroy_output_block (struct output_block
*ob
)
102 enum lto_section_type section_type
= ob
->section_type
;
104 ob
->string_hash_table
.dispose ();
106 free (ob
->main_stream
);
107 free (ob
->string_stream
);
108 if (section_type
== LTO_section_function_body
)
109 free (ob
->cfg_stream
);
111 streamer_tree_cache_delete (ob
->writer_cache
);
112 obstack_free (&ob
->obstack
, NULL
);
118 /* Look up NODE in the type table and write the index for it to OB. */
121 output_type_ref (struct output_block
*ob
, tree node
)
123 streamer_write_record_start (ob
, LTO_type_ref
);
124 lto_output_type_ref_index (ob
->decl_state
, ob
->main_stream
, node
);
128 /* Return true if tree node T is written to various tables. For these
129 nodes, we sometimes want to write their phyiscal representation
130 (via lto_output_tree), and sometimes we need to emit an index
131 reference into a table (via lto_output_tree_ref). */
134 tree_is_indexable (tree t
)
136 /* Parameters and return values of functions of variably modified types
137 must go to global stream, because they may be used in the type
139 if (TREE_CODE (t
) == PARM_DECL
|| TREE_CODE (t
) == RESULT_DECL
)
140 return variably_modified_type_p (TREE_TYPE (DECL_CONTEXT (t
)), NULL_TREE
);
141 else if (((TREE_CODE (t
) == VAR_DECL
&& !TREE_STATIC (t
))
142 || TREE_CODE (t
) == TYPE_DECL
143 || TREE_CODE (t
) == CONST_DECL
144 || TREE_CODE (t
) == NAMELIST_DECL
)
145 && decl_function_context (t
))
147 else if (TREE_CODE (t
) == DEBUG_EXPR_DECL
)
149 /* Variably modified types need to be streamed alongside function
150 bodies because they can refer to local entities. Together with
151 them we have to localize their members as well.
152 ??? In theory that includes non-FIELD_DECLs as well. */
154 && variably_modified_type_p (t
, NULL_TREE
))
156 else if (TREE_CODE (t
) == FIELD_DECL
157 && variably_modified_type_p (DECL_CONTEXT (t
), NULL_TREE
))
160 return (TYPE_P (t
) || DECL_P (t
) || TREE_CODE (t
) == SSA_NAME
);
164 /* Output info about new location into bitpack BP.
165 After outputting bitpack, lto_output_location_data has
166 to be done to output actual data. */
169 lto_output_location (struct output_block
*ob
, struct bitpack_d
*bp
,
172 expanded_location xloc
;
174 loc
= LOCATION_LOCUS (loc
);
175 bp_pack_value (bp
, loc
== UNKNOWN_LOCATION
, 1);
176 if (loc
== UNKNOWN_LOCATION
)
179 xloc
= expand_location (loc
);
181 bp_pack_value (bp
, ob
->current_file
!= xloc
.file
, 1);
182 bp_pack_value (bp
, ob
->current_line
!= xloc
.line
, 1);
183 bp_pack_value (bp
, ob
->current_col
!= xloc
.column
, 1);
185 if (ob
->current_file
!= xloc
.file
)
186 bp_pack_var_len_unsigned (bp
,
187 streamer_string_index (ob
, xloc
.file
,
188 strlen (xloc
.file
) + 1,
190 ob
->current_file
= xloc
.file
;
192 if (ob
->current_line
!= xloc
.line
)
193 bp_pack_var_len_unsigned (bp
, xloc
.line
);
194 ob
->current_line
= xloc
.line
;
196 if (ob
->current_col
!= xloc
.column
)
197 bp_pack_var_len_unsigned (bp
, xloc
.column
);
198 ob
->current_col
= xloc
.column
;
202 /* If EXPR is an indexable tree node, output a reference to it to
203 output block OB. Otherwise, output the physical representation of
207 lto_output_tree_ref (struct output_block
*ob
, tree expr
)
213 output_type_ref (ob
, expr
);
217 code
= TREE_CODE (expr
);
221 streamer_write_record_start (ob
, LTO_ssa_name_ref
);
222 streamer_write_uhwi (ob
, SSA_NAME_VERSION (expr
));
226 streamer_write_record_start (ob
, LTO_field_decl_ref
);
227 lto_output_field_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
231 streamer_write_record_start (ob
, LTO_function_decl_ref
);
232 lto_output_fn_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
236 case DEBUG_EXPR_DECL
:
237 gcc_assert (decl_function_context (expr
) == NULL
|| TREE_STATIC (expr
));
239 streamer_write_record_start (ob
, LTO_global_decl_ref
);
240 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
244 streamer_write_record_start (ob
, LTO_const_decl_ref
);
245 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
249 gcc_assert (decl_function_context (expr
) == NULL
);
250 streamer_write_record_start (ob
, LTO_imported_decl_ref
);
251 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
255 streamer_write_record_start (ob
, LTO_type_decl_ref
);
256 lto_output_type_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
260 streamer_write_record_start (ob
, LTO_namelist_decl_ref
);
261 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
265 streamer_write_record_start (ob
, LTO_namespace_decl_ref
);
266 lto_output_namespace_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
270 streamer_write_record_start (ob
, LTO_label_decl_ref
);
271 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
275 streamer_write_record_start (ob
, LTO_result_decl_ref
);
276 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
279 case TRANSLATION_UNIT_DECL
:
280 streamer_write_record_start (ob
, LTO_translation_unit_decl_ref
);
281 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
285 /* No other node is indexable, so it should have been handled by
292 /* Return true if EXPR is a tree node that can be written to disk. */
295 lto_is_streamable (tree expr
)
297 enum tree_code code
= TREE_CODE (expr
);
299 /* Notice that we reject SSA_NAMEs as well. We only emit the SSA
300 name version in lto_output_tree_ref (see output_ssa_names). */
301 return !is_lang_specific (expr
)
305 && code
!= MODIFY_EXPR
307 && code
!= TARGET_EXPR
309 && code
!= WITH_CLEANUP_EXPR
310 && code
!= STATEMENT_LIST
311 && (code
== CASE_LABEL_EXPR
313 || TREE_CODE_CLASS (code
) != tcc_statement
);
317 /* For EXPR lookup and return what we want to stream to OB as DECL_INITIAL. */
320 get_symbol_initial_value (struct output_block
*ob
, tree expr
)
322 gcc_checking_assert (DECL_P (expr
)
323 && TREE_CODE (expr
) != FUNCTION_DECL
324 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
);
326 /* Handle DECL_INITIAL for symbols. */
327 tree initial
= DECL_INITIAL (expr
);
328 if (TREE_CODE (expr
) == VAR_DECL
329 && (TREE_STATIC (expr
) || DECL_EXTERNAL (expr
))
330 && !DECL_IN_CONSTANT_POOL (expr
)
333 lto_symtab_encoder_t encoder
;
336 encoder
= ob
->decl_state
->symtab_node_encoder
;
337 vnode
= varpool_get_node (expr
);
339 || !lto_symtab_encoder_encode_initializer_p (encoder
,
341 initial
= error_mark_node
;
348 /* Write a physical representation of tree node EXPR to output block
349 OB. If REF_P is true, the leaves of EXPR are emitted as references
350 via lto_output_tree_ref. IX is the index into the streamer cache
351 where EXPR is stored. */
354 lto_write_tree_1 (struct output_block
*ob
, tree expr
, bool ref_p
)
356 /* Pack all the non-pointer fields in EXPR into a bitpack and write
357 the resulting bitpack. */
358 bitpack_d bp
= bitpack_create (ob
->main_stream
);
359 streamer_pack_tree_bitfields (ob
, &bp
, expr
);
360 streamer_write_bitpack (&bp
);
362 /* Write all the pointer fields in EXPR. */
363 streamer_write_tree_body (ob
, expr
, ref_p
);
365 /* Write any LTO-specific data to OB. */
367 && TREE_CODE (expr
) != FUNCTION_DECL
368 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
370 /* Handle DECL_INITIAL for symbols. */
371 tree initial
= get_symbol_initial_value (ob
, expr
);
372 stream_write_tree (ob
, initial
, ref_p
);
376 /* Write a physical representation of tree node EXPR to output block
377 OB. If REF_P is true, the leaves of EXPR are emitted as references
378 via lto_output_tree_ref. IX is the index into the streamer cache
379 where EXPR is stored. */
382 lto_write_tree (struct output_block
*ob
, tree expr
, bool ref_p
)
384 if (!lto_is_streamable (expr
))
385 internal_error ("tree code %qs is not supported in LTO streams",
386 get_tree_code_name (TREE_CODE (expr
)));
388 /* Write the header, containing everything needed to materialize
389 EXPR on the reading side. */
390 streamer_write_tree_header (ob
, expr
);
392 lto_write_tree_1 (ob
, expr
, ref_p
);
394 /* Mark the end of EXPR. */
395 streamer_write_zero (ob
);
398 /* Emit the physical representation of tree node EXPR to output block
399 OB. If THIS_REF_P is true, the leaves of EXPR are emitted as references
400 via lto_output_tree_ref. REF_P is used for streaming siblings of EXPR. */
403 lto_output_tree_1 (struct output_block
*ob
, tree expr
, hashval_t hash
,
404 bool ref_p
, bool this_ref_p
)
408 gcc_checking_assert (expr
!= NULL_TREE
409 && !(this_ref_p
&& tree_is_indexable (expr
)));
411 bool exists_p
= streamer_tree_cache_insert (ob
->writer_cache
,
413 gcc_assert (!exists_p
);
414 if (streamer_handle_as_builtin_p (expr
))
416 /* MD and NORMAL builtins do not need to be written out
417 completely as they are always instantiated by the
418 compiler on startup. The only builtins that need to
419 be written out are BUILT_IN_FRONTEND. For all other
420 builtins, we simply write the class and code. */
421 streamer_write_builtin (ob
, expr
);
423 else if (TREE_CODE (expr
) == INTEGER_CST
424 && !TREE_OVERFLOW (expr
))
426 /* Shared INTEGER_CST nodes are special because they need their
427 original type to be materialized by the reader (to implement
428 TYPE_CACHED_VALUES). */
429 streamer_write_integer_cst (ob
, expr
, ref_p
);
433 /* This is the first time we see EXPR, write its fields
435 lto_write_tree (ob
, expr
, ref_p
);
451 static unsigned int next_dfs_num
;
452 static vec
<scc_entry
> sccstack
;
453 static struct pointer_map_t
*sccstate
;
454 static struct obstack sccstate_obstack
;
457 DFS_write_tree (struct output_block
*ob
, sccs
*from_state
,
458 tree expr
, bool ref_p
, bool this_ref_p
);
460 /* Handle the tree EXPR in the DFS walk with SCC state EXPR_STATE and
461 DFS recurse for all tree edges originating from it. */
464 DFS_write_tree_body (struct output_block
*ob
,
465 tree expr
, sccs
*expr_state
, bool ref_p
)
467 #define DFS_follow_tree_edge(DEST) \
468 DFS_write_tree (ob, expr_state, DEST, ref_p, ref_p)
472 code
= TREE_CODE (expr
);
474 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
476 if (TREE_CODE (expr
) != IDENTIFIER_NODE
)
477 DFS_follow_tree_edge (TREE_TYPE (expr
));
480 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
482 for (unsigned i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
483 DFS_follow_tree_edge (VECTOR_CST_ELT (expr
, i
));
486 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
488 DFS_follow_tree_edge (TREE_REALPART (expr
));
489 DFS_follow_tree_edge (TREE_IMAGPART (expr
));
492 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
494 /* Drop names that were created for anonymous entities. */
496 && TREE_CODE (DECL_NAME (expr
)) == IDENTIFIER_NODE
497 && ANON_AGGRNAME_P (DECL_NAME (expr
)))
500 DFS_follow_tree_edge (DECL_NAME (expr
));
501 DFS_follow_tree_edge (DECL_CONTEXT (expr
));
504 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
506 DFS_follow_tree_edge (DECL_SIZE (expr
));
507 DFS_follow_tree_edge (DECL_SIZE_UNIT (expr
));
509 /* Note, DECL_INITIAL is not handled here. Since DECL_INITIAL needs
510 special handling in LTO, it must be handled by streamer hooks. */
512 DFS_follow_tree_edge (DECL_ATTRIBUTES (expr
));
514 /* Do not follow DECL_ABSTRACT_ORIGIN. We cannot handle debug information
515 for early inlining so drop it on the floor instead of ICEing in
518 if ((TREE_CODE (expr
) == VAR_DECL
519 || TREE_CODE (expr
) == PARM_DECL
)
520 && DECL_HAS_VALUE_EXPR_P (expr
))
521 DFS_follow_tree_edge (DECL_VALUE_EXPR (expr
));
522 if (TREE_CODE (expr
) == VAR_DECL
)
523 DFS_follow_tree_edge (DECL_DEBUG_EXPR (expr
));
526 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
528 if (TREE_CODE (expr
) == TYPE_DECL
)
529 DFS_follow_tree_edge (DECL_ORIGINAL_TYPE (expr
));
530 DFS_follow_tree_edge (DECL_VINDEX (expr
));
533 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
535 /* Make sure we don't inadvertently set the assembler name. */
536 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
537 DFS_follow_tree_edge (DECL_ASSEMBLER_NAME (expr
));
540 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
542 DFS_follow_tree_edge (DECL_FIELD_OFFSET (expr
));
543 DFS_follow_tree_edge (DECL_BIT_FIELD_TYPE (expr
));
544 DFS_follow_tree_edge (DECL_BIT_FIELD_REPRESENTATIVE (expr
));
545 DFS_follow_tree_edge (DECL_FIELD_BIT_OFFSET (expr
));
546 DFS_follow_tree_edge (DECL_FCONTEXT (expr
));
549 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
551 DFS_follow_tree_edge (DECL_FUNCTION_PERSONALITY (expr
));
552 /* Do not DECL_FUNCTION_SPECIFIC_TARGET. They will be regenerated. */
553 DFS_follow_tree_edge (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr
));
556 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
558 DFS_follow_tree_edge (TYPE_SIZE (expr
));
559 DFS_follow_tree_edge (TYPE_SIZE_UNIT (expr
));
560 DFS_follow_tree_edge (TYPE_ATTRIBUTES (expr
));
561 DFS_follow_tree_edge (TYPE_NAME (expr
));
562 /* Do not follow TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
563 reconstructed during fixup. */
564 /* Do not follow TYPE_NEXT_VARIANT, we reconstruct the variant lists
566 DFS_follow_tree_edge (TYPE_MAIN_VARIANT (expr
));
567 DFS_follow_tree_edge (TYPE_CONTEXT (expr
));
568 /* TYPE_CANONICAL is re-computed during type merging, so no need
569 to follow it here. */
570 DFS_follow_tree_edge (TYPE_STUB_DECL (expr
));
573 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
575 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
576 DFS_follow_tree_edge (TYPE_VALUES (expr
));
577 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
578 DFS_follow_tree_edge (TYPE_DOMAIN (expr
));
579 else if (RECORD_OR_UNION_TYPE_P (expr
))
580 for (tree t
= TYPE_FIELDS (expr
); t
; t
= TREE_CHAIN (t
))
581 DFS_follow_tree_edge (t
);
582 else if (TREE_CODE (expr
) == FUNCTION_TYPE
583 || TREE_CODE (expr
) == METHOD_TYPE
)
584 DFS_follow_tree_edge (TYPE_ARG_TYPES (expr
));
586 if (!POINTER_TYPE_P (expr
))
587 DFS_follow_tree_edge (TYPE_MINVAL (expr
));
588 DFS_follow_tree_edge (TYPE_MAXVAL (expr
));
589 if (RECORD_OR_UNION_TYPE_P (expr
))
590 DFS_follow_tree_edge (TYPE_BINFO (expr
));
593 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
595 DFS_follow_tree_edge (TREE_PURPOSE (expr
));
596 DFS_follow_tree_edge (TREE_VALUE (expr
));
597 DFS_follow_tree_edge (TREE_CHAIN (expr
));
600 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
602 for (int i
= 0; i
< TREE_VEC_LENGTH (expr
); i
++)
603 DFS_follow_tree_edge (TREE_VEC_ELT (expr
, i
));
606 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
608 for (int i
= 0; i
< TREE_OPERAND_LENGTH (expr
); i
++)
609 DFS_follow_tree_edge (TREE_OPERAND (expr
, i
));
610 DFS_follow_tree_edge (TREE_BLOCK (expr
));
613 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
615 for (tree t
= BLOCK_VARS (expr
); t
; t
= TREE_CHAIN (t
))
616 /* ??? FIXME. See also streamer_write_chain. */
617 if (!(VAR_OR_FUNCTION_DECL_P (t
)
618 && DECL_EXTERNAL (t
)))
619 DFS_follow_tree_edge (t
);
621 DFS_follow_tree_edge (BLOCK_SUPERCONTEXT (expr
));
623 /* Follow BLOCK_ABSTRACT_ORIGIN for the limited cases we can
624 handle - those that represent inlined function scopes.
625 For the drop rest them on the floor instead of ICEing
627 if (inlined_function_outer_scope_p (expr
))
629 tree ultimate_origin
= block_ultimate_origin (expr
);
630 DFS_follow_tree_edge (ultimate_origin
);
632 /* Do not follow BLOCK_NONLOCALIZED_VARS. We cannot handle debug
633 information for early inlined BLOCKs so drop it on the floor instead
634 of ICEing in dwarf2out.c. */
636 /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
639 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
640 list is re-constructed from BLOCK_SUPERCONTEXT. */
643 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
648 /* Note that the number of BINFO slots has already been emitted in
649 EXPR's header (see streamer_write_tree_header) because this length
650 is needed to build the empty BINFO node on the reader side. */
651 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr
), i
, t
)
652 DFS_follow_tree_edge (t
);
653 DFS_follow_tree_edge (BINFO_OFFSET (expr
));
654 DFS_follow_tree_edge (BINFO_VTABLE (expr
));
655 DFS_follow_tree_edge (BINFO_VPTR_FIELD (expr
));
657 /* The number of BINFO_BASE_ACCESSES has already been emitted in
658 EXPR's bitfield section. */
659 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (expr
), i
, t
)
660 DFS_follow_tree_edge (t
);
662 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
663 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
666 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
671 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr
), i
, index
, value
)
673 DFS_follow_tree_edge (index
);
674 DFS_follow_tree_edge (value
);
678 if (code
== OMP_CLAUSE
)
681 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (expr
)]; i
++)
682 DFS_follow_tree_edge (OMP_CLAUSE_OPERAND (expr
, i
));
683 DFS_follow_tree_edge (OMP_CLAUSE_CHAIN (expr
));
686 #undef DFS_follow_tree_edge
689 /* Return a hash value for the tree T. */
692 hash_tree (struct streamer_tree_cache_d
*cache
, tree t
)
694 #define visit(SIBLING) \
697 if (SIBLING && streamer_tree_cache_lookup (cache, SIBLING, &ix)) \
698 v = iterative_hash_hashval_t (streamer_tree_cache_get_hash (cache, ix), v); \
702 enum tree_code code
= TREE_CODE (t
);
703 hashval_t v
= iterative_hash_host_wide_int (code
, 0);
706 v
= iterative_hash_host_wide_int (TREE_SIDE_EFFECTS (t
)
707 | (TREE_CONSTANT (t
) << 1)
708 | (TREE_READONLY (t
) << 2)
709 | (TREE_PUBLIC (t
) << 3), v
);
711 v
= iterative_hash_host_wide_int (TREE_ADDRESSABLE (t
)
712 | (TREE_THIS_VOLATILE (t
) << 1), v
);
714 v
= iterative_hash_host_wide_int (DECL_UNSIGNED (t
), v
);
716 v
= iterative_hash_host_wide_int (TYPE_UNSIGNED (t
), v
);
718 v
= iterative_hash_host_wide_int (TYPE_ARTIFICIAL (t
), v
);
720 v
= iterative_hash_host_wide_int (TREE_NO_WARNING (t
), v
);
721 v
= iterative_hash_host_wide_int (TREE_NOTHROW (t
)
722 | (TREE_STATIC (t
) << 1)
723 | (TREE_PROTECTED (t
) << 2)
724 | (TREE_DEPRECATED (t
) << 3), v
);
725 if (code
!= TREE_BINFO
)
726 v
= iterative_hash_host_wide_int (TREE_PRIVATE (t
), v
);
728 v
= iterative_hash_host_wide_int (TYPE_SATURATING (t
)
729 | (TYPE_ADDR_SPACE (t
) << 1), v
);
730 else if (code
== SSA_NAME
)
731 v
= iterative_hash_host_wide_int (SSA_NAME_IS_DEFAULT_DEF (t
), v
);
733 if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
736 v
= iterative_hash_host_wide_int (TREE_INT_CST_NUNITS (t
), v
);
737 v
= iterative_hash_host_wide_int (TREE_INT_CST_EXT_NUNITS (t
), v
);
738 for (i
= 0; i
< TREE_INT_CST_NUNITS (t
); i
++)
739 v
= iterative_hash_host_wide_int (TREE_INT_CST_ELT (t
, i
), v
);
742 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
744 REAL_VALUE_TYPE r
= TREE_REAL_CST (t
);
745 v
= iterative_hash_host_wide_int (r
.cl
, v
);
746 v
= iterative_hash_host_wide_int (r
.decimal
748 | (r
.signalling
<< 2)
749 | (r
.canonical
<< 3), v
);
750 v
= iterative_hash_host_wide_int (r
.uexp
, v
);
751 for (unsigned i
= 0; i
< SIGSZ
; ++i
)
752 v
= iterative_hash_host_wide_int (r
.sig
[i
], v
);
755 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
757 FIXED_VALUE_TYPE f
= TREE_FIXED_CST (t
);
758 v
= iterative_hash_host_wide_int (f
.mode
, v
);
759 v
= iterative_hash_host_wide_int (f
.data
.low
, v
);
760 v
= iterative_hash_host_wide_int (f
.data
.high
, v
);
763 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
765 v
= iterative_hash_host_wide_int (DECL_MODE (t
), v
);
766 v
= iterative_hash_host_wide_int (DECL_NONLOCAL (t
)
767 | (DECL_VIRTUAL_P (t
) << 1)
768 | (DECL_IGNORED_P (t
) << 2)
769 | (DECL_ABSTRACT (t
) << 3)
770 | (DECL_ARTIFICIAL (t
) << 4)
771 | (DECL_USER_ALIGN (t
) << 5)
772 | (DECL_PRESERVE_P (t
) << 6)
773 | (DECL_EXTERNAL (t
) << 7)
774 | (DECL_GIMPLE_REG_P (t
) << 8), v
);
775 v
= iterative_hash_host_wide_int (DECL_ALIGN (t
), v
);
776 if (code
== LABEL_DECL
)
778 v
= iterative_hash_host_wide_int (EH_LANDING_PAD_NR (t
), v
);
779 v
= iterative_hash_host_wide_int (LABEL_DECL_UID (t
), v
);
781 else if (code
== FIELD_DECL
)
783 v
= iterative_hash_host_wide_int (DECL_PACKED (t
)
784 | (DECL_NONADDRESSABLE_P (t
) << 1),
786 v
= iterative_hash_host_wide_int (DECL_OFFSET_ALIGN (t
), v
);
788 else if (code
== VAR_DECL
)
790 v
= iterative_hash_host_wide_int (DECL_HAS_DEBUG_EXPR_P (t
)
791 | (DECL_NONLOCAL_FRAME (t
) << 1),
794 if (code
== RESULT_DECL
798 v
= iterative_hash_host_wide_int (DECL_BY_REFERENCE (t
), v
);
800 || code
== PARM_DECL
)
801 v
= iterative_hash_host_wide_int (DECL_HAS_VALUE_EXPR_P (t
), v
);
805 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
806 v
= iterative_hash_host_wide_int (DECL_REGISTER (t
), v
);
808 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
810 v
= iterative_hash_host_wide_int ((DECL_COMMON (t
))
811 | (DECL_DLLIMPORT_P (t
) << 1)
812 | (DECL_WEAK (t
) << 2)
813 | (DECL_SEEN_IN_BIND_EXPR_P (t
) << 3)
814 | (DECL_COMDAT (t
) << 4)
815 | (DECL_VISIBILITY_SPECIFIED (t
) << 6),
817 v
= iterative_hash_host_wide_int (DECL_VISIBILITY (t
), v
);
818 if (code
== VAR_DECL
)
820 /* DECL_IN_TEXT_SECTION is set during final asm output only. */
821 v
= iterative_hash_host_wide_int (DECL_HARD_REGISTER (t
)
822 | (DECL_IN_CONSTANT_POOL (t
) << 1),
825 if (TREE_CODE (t
) == FUNCTION_DECL
)
826 v
= iterative_hash_host_wide_int (DECL_FINAL_P (t
)
827 | (DECL_CXX_CONSTRUCTOR_P (t
) << 1)
828 | (DECL_CXX_DESTRUCTOR_P (t
) << 2),
830 if (VAR_OR_FUNCTION_DECL_P (t
))
831 v
= iterative_hash_host_wide_int (DECL_INIT_PRIORITY (t
), v
);
834 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
836 v
= iterative_hash_host_wide_int (DECL_BUILT_IN_CLASS (t
), v
);
837 v
= iterative_hash_host_wide_int (DECL_STATIC_CONSTRUCTOR (t
)
838 | (DECL_STATIC_DESTRUCTOR (t
) << 1)
839 | (DECL_UNINLINABLE (t
) << 2)
840 | (DECL_POSSIBLY_INLINED (t
) << 3)
841 | (DECL_IS_NOVOPS (t
) << 4)
842 | (DECL_IS_RETURNS_TWICE (t
) << 5)
843 | (DECL_IS_MALLOC (t
) << 6)
844 | (DECL_IS_OPERATOR_NEW (t
) << 7)
845 | (DECL_DECLARED_INLINE_P (t
) << 8)
846 | (DECL_STATIC_CHAIN (t
) << 9)
847 | (DECL_NO_INLINE_WARNING_P (t
) << 10)
848 | (DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (t
) << 11)
849 | (DECL_NO_LIMIT_STACK (t
) << 12)
850 | (DECL_DISREGARD_INLINE_LIMITS (t
) << 13)
851 | (DECL_PURE_P (t
) << 14)
852 | (DECL_LOOPING_CONST_OR_PURE_P (t
) << 15), v
);
853 if (DECL_BUILT_IN_CLASS (t
) != NOT_BUILT_IN
)
854 v
= iterative_hash_host_wide_int (DECL_FUNCTION_CODE (t
), v
);
855 if (DECL_STATIC_DESTRUCTOR (t
))
856 v
= iterative_hash_host_wide_int (DECL_FINI_PRIORITY (t
), v
);
859 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
861 v
= iterative_hash_host_wide_int (TYPE_MODE (t
), v
);
862 v
= iterative_hash_host_wide_int (TYPE_STRING_FLAG (t
)
863 | (TYPE_NO_FORCE_BLK (t
) << 1)
864 | (TYPE_NEEDS_CONSTRUCTING (t
) << 2)
865 | (TYPE_PACKED (t
) << 3)
866 | (TYPE_RESTRICT (t
) << 4)
867 | (TYPE_USER_ALIGN (t
) << 5)
868 | (TYPE_READONLY (t
) << 6), v
);
869 if (RECORD_OR_UNION_TYPE_P (t
))
871 v
= iterative_hash_host_wide_int (TYPE_TRANSPARENT_AGGR (t
)
872 | (TYPE_FINAL_P (t
) << 1), v
);
874 else if (code
== ARRAY_TYPE
)
875 v
= iterative_hash_host_wide_int (TYPE_NONALIASED_COMPONENT (t
), v
);
876 v
= iterative_hash_host_wide_int (TYPE_PRECISION (t
), v
);
877 v
= iterative_hash_host_wide_int (TYPE_ALIGN (t
), v
);
878 v
= iterative_hash_host_wide_int ((TYPE_ALIAS_SET (t
) == 0
880 && get_alias_set (t
) == 0))
884 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
885 v
= iterative_hash (TRANSLATION_UNIT_LANGUAGE (t
),
886 strlen (TRANSLATION_UNIT_LANGUAGE (t
)), v
);
888 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
))
891 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
892 v
= iterative_hash (t
, sizeof (struct cl_optimization
), v
);
894 if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
895 v
= iterative_hash_host_wide_int (IDENTIFIER_HASH_VALUE (t
), v
);
897 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
898 v
= iterative_hash (TREE_STRING_POINTER (t
), TREE_STRING_LENGTH (t
), v
);
900 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
902 if (POINTER_TYPE_P (t
))
904 /* For pointers factor in the pointed-to type recursively as
905 we cannot recurse through only pointers.
906 ??? We can generalize this by keeping track of the
907 in-SCC edges for each tree (or arbitrarily the first
908 such edge) and hashing that in in a second stage
909 (instead of the quadratic mixing of the SCC we do now). */
912 if (streamer_tree_cache_lookup (cache
, TREE_TYPE (t
), &ix
))
913 x
= streamer_tree_cache_get_hash (cache
, ix
);
915 x
= hash_tree (cache
, TREE_TYPE (t
));
916 v
= iterative_hash_hashval_t (x
, v
);
918 else if (code
!= IDENTIFIER_NODE
)
919 visit (TREE_TYPE (t
));
922 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
923 for (unsigned i
= 0; i
< VECTOR_CST_NELTS (t
); ++i
)
924 visit (VECTOR_CST_ELT (t
, i
));
926 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
928 visit (TREE_REALPART (t
));
929 visit (TREE_IMAGPART (t
));
932 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
934 /* Drop names that were created for anonymous entities. */
936 && TREE_CODE (DECL_NAME (t
)) == IDENTIFIER_NODE
937 && ANON_AGGRNAME_P (DECL_NAME (t
)))
940 visit (DECL_NAME (t
));
941 if (DECL_FILE_SCOPE_P (t
))
944 visit (DECL_CONTEXT (t
));
947 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
949 visit (DECL_SIZE (t
));
950 visit (DECL_SIZE_UNIT (t
));
951 visit (DECL_ATTRIBUTES (t
));
952 if ((code
== VAR_DECL
953 || code
== PARM_DECL
)
954 && DECL_HAS_VALUE_EXPR_P (t
))
955 visit (DECL_VALUE_EXPR (t
));
957 && DECL_HAS_DEBUG_EXPR_P (t
))
958 visit (DECL_DEBUG_EXPR (t
));
959 /* ??? Hash DECL_INITIAL as streamed. Needs the output-block to
960 be able to call get_symbol_initial_value. */
963 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
965 if (code
== TYPE_DECL
)
966 visit (DECL_ORIGINAL_TYPE (t
));
967 visit (DECL_VINDEX (t
));
970 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
972 if (DECL_ASSEMBLER_NAME_SET_P (t
))
973 visit (DECL_ASSEMBLER_NAME (t
));
976 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
978 visit (DECL_FIELD_OFFSET (t
));
979 visit (DECL_BIT_FIELD_TYPE (t
));
980 visit (DECL_BIT_FIELD_REPRESENTATIVE (t
));
981 visit (DECL_FIELD_BIT_OFFSET (t
));
982 visit (DECL_FCONTEXT (t
));
985 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
987 visit (DECL_FUNCTION_PERSONALITY (t
));
988 /* Do not follow DECL_FUNCTION_SPECIFIC_TARGET. */
989 visit (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t
));
992 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
994 visit (TYPE_SIZE (t
));
995 visit (TYPE_SIZE_UNIT (t
));
996 visit (TYPE_ATTRIBUTES (t
));
997 visit (TYPE_NAME (t
));
998 visit (TYPE_MAIN_VARIANT (t
));
999 if (TYPE_FILE_SCOPE_P (t
))
1002 visit (TYPE_CONTEXT (t
));
1003 visit (TYPE_STUB_DECL (t
));
1006 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
1008 if (code
== ENUMERAL_TYPE
)
1009 visit (TYPE_VALUES (t
));
1010 else if (code
== ARRAY_TYPE
)
1011 visit (TYPE_DOMAIN (t
));
1012 else if (RECORD_OR_UNION_TYPE_P (t
))
1013 for (tree f
= TYPE_FIELDS (t
); f
; f
= TREE_CHAIN (f
))
1015 else if (code
== FUNCTION_TYPE
1016 || code
== METHOD_TYPE
)
1017 visit (TYPE_ARG_TYPES (t
));
1018 if (!POINTER_TYPE_P (t
))
1019 visit (TYPE_MINVAL (t
));
1020 visit (TYPE_MAXVAL (t
));
1021 if (RECORD_OR_UNION_TYPE_P (t
))
1022 visit (TYPE_BINFO (t
));
1025 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
1027 visit (TREE_PURPOSE (t
));
1028 visit (TREE_VALUE (t
));
1029 visit (TREE_CHAIN (t
));
1032 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1033 for (int i
= 0; i
< TREE_VEC_LENGTH (t
); ++i
)
1034 visit (TREE_VEC_ELT (t
, i
));
1036 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
1038 v
= iterative_hash_host_wide_int (TREE_OPERAND_LENGTH (t
), v
);
1039 for (int i
= 0; i
< TREE_OPERAND_LENGTH (t
); ++i
)
1040 visit (TREE_OPERAND (t
, i
));
1043 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1047 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (t
), i
, b
)
1049 visit (BINFO_OFFSET (t
));
1050 visit (BINFO_VTABLE (t
));
1051 visit (BINFO_VPTR_FIELD (t
));
1052 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (t
), i
, b
)
1054 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
1055 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
1058 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1062 v
= iterative_hash_host_wide_int (CONSTRUCTOR_NELTS (t
), v
);
1063 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), i
, index
, value
)
1070 if (code
== OMP_CLAUSE
)
1074 v
= iterative_hash_host_wide_int (OMP_CLAUSE_CODE (t
), v
);
1075 switch (OMP_CLAUSE_CODE (t
))
1077 case OMP_CLAUSE_DEFAULT
:
1078 v
= iterative_hash_host_wide_int (OMP_CLAUSE_DEFAULT_KIND (t
), v
);
1080 case OMP_CLAUSE_SCHEDULE
:
1081 v
= iterative_hash_host_wide_int (OMP_CLAUSE_SCHEDULE_KIND (t
), v
);
1083 case OMP_CLAUSE_DEPEND
:
1084 v
= iterative_hash_host_wide_int (OMP_CLAUSE_DEPEND_KIND (t
), v
);
1086 case OMP_CLAUSE_MAP
:
1087 v
= iterative_hash_host_wide_int (OMP_CLAUSE_MAP_KIND (t
), v
);
1089 case OMP_CLAUSE_PROC_BIND
:
1090 v
= iterative_hash_host_wide_int (OMP_CLAUSE_PROC_BIND_KIND (t
), v
);
1092 case OMP_CLAUSE_REDUCTION
:
1093 v
= iterative_hash_host_wide_int (OMP_CLAUSE_REDUCTION_CODE (t
), v
);
1098 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (t
)]; i
++)
1099 visit (OMP_CLAUSE_OPERAND (t
, i
));
1100 visit (OMP_CLAUSE_CHAIN (t
));
1108 /* Compare two SCC entries by their hash value for qsorting them. */
1111 scc_entry_compare (const void *p1_
, const void *p2_
)
1113 const scc_entry
*p1
= (const scc_entry
*) p1_
;
1114 const scc_entry
*p2
= (const scc_entry
*) p2_
;
1115 if (p1
->hash
< p2
->hash
)
1117 else if (p1
->hash
> p2
->hash
)
1122 /* Return a hash value for the SCC on the SCC stack from FIRST with
1126 hash_scc (struct streamer_tree_cache_d
*cache
, unsigned first
, unsigned size
)
1128 /* Compute hash values for the SCC members. */
1129 for (unsigned i
= 0; i
< size
; ++i
)
1130 sccstack
[first
+i
].hash
= hash_tree (cache
, sccstack
[first
+i
].t
);
1133 return sccstack
[first
].hash
;
1135 /* Sort the SCC of type, hash pairs so that when we mix in
1136 all members of the SCC the hash value becomes independent on
1137 the order we visited the SCC. Disregard hashes equal to
1138 the hash of the tree we mix into because we cannot guarantee
1139 a stable sort for those across different TUs. */
1140 qsort (&sccstack
[first
], size
, sizeof (scc_entry
), scc_entry_compare
);
1141 hashval_t
*tem
= XALLOCAVEC (hashval_t
, size
);
1142 for (unsigned i
= 0; i
< size
; ++i
)
1144 hashval_t hash
= sccstack
[first
+i
].hash
;
1145 hashval_t orig_hash
= hash
;
1147 /* Skip same hashes. */
1149 j
< size
&& sccstack
[first
+j
].hash
== orig_hash
; ++j
)
1151 for (; j
< size
; ++j
)
1152 hash
= iterative_hash_hashval_t (sccstack
[first
+j
].hash
, hash
);
1153 for (j
= 0; sccstack
[first
+j
].hash
!= orig_hash
; ++j
)
1154 hash
= iterative_hash_hashval_t (sccstack
[first
+j
].hash
, hash
);
1157 hashval_t scc_hash
= 0;
1158 for (unsigned i
= 0; i
< size
; ++i
)
1160 sccstack
[first
+i
].hash
= tem
[i
];
1161 scc_hash
= iterative_hash_hashval_t (tem
[i
], scc_hash
);
1166 /* DFS walk EXPR and stream SCCs of tree bodies if they are not
1167 already in the streamer cache. Main routine called for
1168 each visit of EXPR. */
1171 DFS_write_tree (struct output_block
*ob
, sccs
*from_state
,
1172 tree expr
, bool ref_p
, bool this_ref_p
)
1177 /* Handle special cases. */
1178 if (expr
== NULL_TREE
)
1181 /* Do not DFS walk into indexable trees. */
1182 if (this_ref_p
&& tree_is_indexable (expr
))
1185 /* Check if we already streamed EXPR. */
1186 if (streamer_tree_cache_lookup (ob
->writer_cache
, expr
, &ix
))
1189 slot
= (sccs
**)pointer_map_insert (sccstate
, expr
);
1190 sccs
*cstate
= *slot
;
1193 scc_entry e
= { expr
, 0 };
1194 /* Not yet visited. DFS recurse and push it onto the stack. */
1195 *slot
= cstate
= XOBNEW (&sccstate_obstack
, struct sccs
);
1196 sccstack
.safe_push (e
);
1197 cstate
->dfsnum
= next_dfs_num
++;
1198 cstate
->low
= cstate
->dfsnum
;
1200 if (streamer_handle_as_builtin_p (expr
))
1202 else if (TREE_CODE (expr
) == INTEGER_CST
1203 && !TREE_OVERFLOW (expr
))
1204 DFS_write_tree (ob
, cstate
, TREE_TYPE (expr
), ref_p
, ref_p
);
1207 DFS_write_tree_body (ob
, expr
, cstate
, ref_p
);
1209 /* Walk any LTO-specific edges. */
1211 && TREE_CODE (expr
) != FUNCTION_DECL
1212 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
1214 /* Handle DECL_INITIAL for symbols. */
1215 tree initial
= get_symbol_initial_value (ob
, expr
);
1216 DFS_write_tree (ob
, cstate
, initial
, ref_p
, ref_p
);
1220 /* See if we found an SCC. */
1221 if (cstate
->low
== cstate
->dfsnum
)
1223 unsigned first
, size
;
1226 /* Pop the SCC and compute its size. */
1227 first
= sccstack
.length ();
1230 x
= sccstack
[--first
].t
;
1233 size
= sccstack
.length () - first
;
1235 /* No need to compute hashes for LTRANS units, we don't perform
1236 any merging there. */
1237 hashval_t scc_hash
= 0;
1238 unsigned scc_entry_len
= 0;
1241 scc_hash
= hash_scc (ob
->writer_cache
, first
, size
);
1243 /* Put the entries with the least number of collisions first. */
1244 unsigned entry_start
= 0;
1245 scc_entry_len
= size
+ 1;
1246 for (unsigned i
= 0; i
< size
;)
1249 for (i
= i
+ 1; i
< size
1250 && (sccstack
[first
+ i
].hash
1251 == sccstack
[first
+ from
].hash
); ++i
)
1253 if (i
- from
< scc_entry_len
)
1255 scc_entry_len
= i
- from
;
1259 for (unsigned i
= 0; i
< scc_entry_len
; ++i
)
1261 scc_entry tem
= sccstack
[first
+ i
];
1262 sccstack
[first
+ i
] = sccstack
[first
+ entry_start
+ i
];
1263 sccstack
[first
+ entry_start
+ i
] = tem
;
1267 /* Write LTO_tree_scc. */
1268 streamer_write_record_start (ob
, LTO_tree_scc
);
1269 streamer_write_uhwi (ob
, size
);
1270 streamer_write_uhwi (ob
, scc_hash
);
1272 /* Write size-1 SCCs without wrapping them inside SCC bundles.
1273 All INTEGER_CSTs need to be handled this way as we need
1274 their type to materialize them. Also builtins are handled
1276 ??? We still wrap these in LTO_tree_scc so at the
1277 input side we can properly identify the tree we want
1278 to ultimatively return. */
1280 lto_output_tree_1 (ob
, expr
, scc_hash
, ref_p
, this_ref_p
);
1283 /* Write the size of the SCC entry candidates. */
1284 streamer_write_uhwi (ob
, scc_entry_len
);
1286 /* Write all headers and populate the streamer cache. */
1287 for (unsigned i
= 0; i
< size
; ++i
)
1289 hashval_t hash
= sccstack
[first
+i
].hash
;
1290 tree t
= sccstack
[first
+i
].t
;
1291 bool exists_p
= streamer_tree_cache_insert (ob
->writer_cache
,
1293 gcc_assert (!exists_p
);
1295 if (!lto_is_streamable (t
))
1296 internal_error ("tree code %qs is not supported "
1298 get_tree_code_name (TREE_CODE (t
)));
1300 gcc_checking_assert (!streamer_handle_as_builtin_p (t
));
1302 /* Write the header, containing everything needed to
1303 materialize EXPR on the reading side. */
1304 streamer_write_tree_header (ob
, t
);
1307 /* Write the bitpacks and tree references. */
1308 for (unsigned i
= 0; i
< size
; ++i
)
1310 lto_write_tree_1 (ob
, sccstack
[first
+i
].t
, ref_p
);
1312 /* Mark the end of the tree. */
1313 streamer_write_zero (ob
);
1317 /* Finally truncate the vector. */
1318 sccstack
.truncate (first
);
1321 from_state
->low
= MIN (from_state
->low
, cstate
->low
);
1326 from_state
->low
= MIN (from_state
->low
, cstate
->low
);
1328 gcc_checking_assert (from_state
);
1329 if (cstate
->dfsnum
< from_state
->dfsnum
)
1330 from_state
->low
= MIN (cstate
->dfsnum
, from_state
->low
);
1334 /* Emit the physical representation of tree node EXPR to output block
1335 OB. If THIS_REF_P is true, the leaves of EXPR are emitted as references
1336 via lto_output_tree_ref. REF_P is used for streaming siblings of EXPR. */
1339 lto_output_tree (struct output_block
*ob
, tree expr
,
1340 bool ref_p
, bool this_ref_p
)
1345 if (expr
== NULL_TREE
)
1347 streamer_write_record_start (ob
, LTO_null
);
1351 if (this_ref_p
&& tree_is_indexable (expr
))
1353 lto_output_tree_ref (ob
, expr
);
1357 existed_p
= streamer_tree_cache_lookup (ob
->writer_cache
, expr
, &ix
);
1360 /* If a node has already been streamed out, make sure that
1361 we don't write it more than once. Otherwise, the reader
1362 will instantiate two different nodes for the same object. */
1363 streamer_write_record_start (ob
, LTO_tree_pickle_reference
);
1364 streamer_write_uhwi (ob
, ix
);
1365 streamer_write_enum (ob
->main_stream
, LTO_tags
, LTO_NUM_TAGS
,
1366 lto_tree_code_to_tag (TREE_CODE (expr
)));
1367 lto_stats
.num_pickle_refs_output
++;
1371 /* This is the first time we see EXPR, write all reachable
1373 static bool in_dfs_walk
;
1375 /* Protect against recursion which means disconnect between
1376 what tree edges we walk in the DFS walk and what edges
1378 gcc_assert (!in_dfs_walk
);
1380 /* Start the DFS walk. */
1381 /* Save ob state ... */
1384 sccstate
= pointer_map_create ();
1385 gcc_obstack_init (&sccstate_obstack
);
1387 DFS_write_tree (ob
, NULL
, expr
, ref_p
, this_ref_p
);
1388 sccstack
.release ();
1389 pointer_map_destroy (sccstate
);
1390 obstack_free (&sccstate_obstack
, NULL
);
1391 in_dfs_walk
= false;
1393 /* Finally append a reference to the tree we were writing.
1394 ??? If expr ended up as a singleton we could have
1395 inlined it here and avoid outputting a reference. */
1396 existed_p
= streamer_tree_cache_lookup (ob
->writer_cache
, expr
, &ix
);
1397 gcc_assert (existed_p
);
1398 streamer_write_record_start (ob
, LTO_tree_pickle_reference
);
1399 streamer_write_uhwi (ob
, ix
);
1400 streamer_write_enum (ob
->main_stream
, LTO_tags
, LTO_NUM_TAGS
,
1401 lto_tree_code_to_tag (TREE_CODE (expr
)));
1402 lto_stats
.num_pickle_refs_output
++;
1407 /* Output to OB a list of try/catch handlers starting with FIRST. */
1410 output_eh_try_list (struct output_block
*ob
, eh_catch first
)
1414 for (n
= first
; n
; n
= n
->next_catch
)
1416 streamer_write_record_start (ob
, LTO_eh_catch
);
1417 stream_write_tree (ob
, n
->type_list
, true);
1418 stream_write_tree (ob
, n
->filter_list
, true);
1419 stream_write_tree (ob
, n
->label
, true);
1422 streamer_write_record_start (ob
, LTO_null
);
1426 /* Output EH region R in function FN to OB. CURR_RN is the slot index
1427 that is being emitted in FN->EH->REGION_ARRAY. This is used to
1428 detect EH region sharing. */
1431 output_eh_region (struct output_block
*ob
, eh_region r
)
1437 streamer_write_record_start (ob
, LTO_null
);
1441 if (r
->type
== ERT_CLEANUP
)
1442 tag
= LTO_ert_cleanup
;
1443 else if (r
->type
== ERT_TRY
)
1445 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
1446 tag
= LTO_ert_allowed_exceptions
;
1447 else if (r
->type
== ERT_MUST_NOT_THROW
)
1448 tag
= LTO_ert_must_not_throw
;
1452 streamer_write_record_start (ob
, tag
);
1453 streamer_write_hwi (ob
, r
->index
);
1456 streamer_write_hwi (ob
, r
->outer
->index
);
1458 streamer_write_zero (ob
);
1461 streamer_write_hwi (ob
, r
->inner
->index
);
1463 streamer_write_zero (ob
);
1466 streamer_write_hwi (ob
, r
->next_peer
->index
);
1468 streamer_write_zero (ob
);
1470 if (r
->type
== ERT_TRY
)
1472 output_eh_try_list (ob
, r
->u
.eh_try
.first_catch
);
1474 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
1476 stream_write_tree (ob
, r
->u
.allowed
.type_list
, true);
1477 stream_write_tree (ob
, r
->u
.allowed
.label
, true);
1478 streamer_write_uhwi (ob
, r
->u
.allowed
.filter
);
1480 else if (r
->type
== ERT_MUST_NOT_THROW
)
1482 stream_write_tree (ob
, r
->u
.must_not_throw
.failure_decl
, true);
1483 bitpack_d bp
= bitpack_create (ob
->main_stream
);
1484 stream_output_location (ob
, &bp
, r
->u
.must_not_throw
.failure_loc
);
1485 streamer_write_bitpack (&bp
);
1488 if (r
->landing_pads
)
1489 streamer_write_hwi (ob
, r
->landing_pads
->index
);
1491 streamer_write_zero (ob
);
1495 /* Output landing pad LP to OB. */
1498 output_eh_lp (struct output_block
*ob
, eh_landing_pad lp
)
1502 streamer_write_record_start (ob
, LTO_null
);
1506 streamer_write_record_start (ob
, LTO_eh_landing_pad
);
1507 streamer_write_hwi (ob
, lp
->index
);
1509 streamer_write_hwi (ob
, lp
->next_lp
->index
);
1511 streamer_write_zero (ob
);
1514 streamer_write_hwi (ob
, lp
->region
->index
);
1516 streamer_write_zero (ob
);
1518 stream_write_tree (ob
, lp
->post_landing_pad
, true);
1522 /* Output the existing eh_table to OB. */
1525 output_eh_regions (struct output_block
*ob
, struct function
*fn
)
1527 if (fn
->eh
&& fn
->eh
->region_tree
)
1534 streamer_write_record_start (ob
, LTO_eh_table
);
1536 /* Emit the index of the root of the EH region tree. */
1537 streamer_write_hwi (ob
, fn
->eh
->region_tree
->index
);
1539 /* Emit all the EH regions in the region array. */
1540 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->region_array
));
1541 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->region_array
, i
, eh
)
1542 output_eh_region (ob
, eh
);
1544 /* Emit all landing pads. */
1545 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->lp_array
));
1546 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->lp_array
, i
, lp
)
1547 output_eh_lp (ob
, lp
);
1549 /* Emit all the runtime type data. */
1550 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->ttype_data
));
1551 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->ttype_data
, i
, ttype
)
1552 stream_write_tree (ob
, ttype
, true);
1554 /* Emit the table of action chains. */
1555 if (targetm
.arm_eabi_unwinder
)
1558 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->ehspec_data
.arm_eabi
));
1559 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->ehspec_data
.arm_eabi
, i
, t
)
1560 stream_write_tree (ob
, t
, true);
1565 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->ehspec_data
.other
));
1566 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->ehspec_data
.other
, i
, c
)
1567 streamer_write_char_stream (ob
->main_stream
, c
);
1571 /* The LTO_null either terminates the record or indicates that there
1572 are no eh_records at all. */
1573 streamer_write_record_start (ob
, LTO_null
);
1577 /* Output all of the active ssa names to the ssa_names stream. */
1580 output_ssa_names (struct output_block
*ob
, struct function
*fn
)
1582 unsigned int i
, len
;
1584 len
= vec_safe_length (SSANAMES (fn
));
1585 streamer_write_uhwi (ob
, len
);
1587 for (i
= 1; i
< len
; i
++)
1589 tree ptr
= (*SSANAMES (fn
))[i
];
1591 if (ptr
== NULL_TREE
1592 || SSA_NAME_IN_FREE_LIST (ptr
)
1593 || virtual_operand_p (ptr
))
1596 streamer_write_uhwi (ob
, i
);
1597 streamer_write_char_stream (ob
->main_stream
,
1598 SSA_NAME_IS_DEFAULT_DEF (ptr
));
1599 if (SSA_NAME_VAR (ptr
))
1600 stream_write_tree (ob
, SSA_NAME_VAR (ptr
), true);
1602 /* ??? This drops SSA_NAME_IDENTIFIER on the floor. */
1603 stream_write_tree (ob
, TREE_TYPE (ptr
), true);
1606 streamer_write_zero (ob
);
1610 /* Output a wide-int. */
1613 streamer_write_wi (struct output_block
*ob
,
1614 const widest_int
&w
)
1616 int len
= w
.get_len ();
1618 streamer_write_uhwi (ob
, w
.get_precision ());
1619 streamer_write_uhwi (ob
, len
);
1620 for (int i
= 0; i
< len
; i
++)
1621 streamer_write_hwi (ob
, w
.elt (i
));
1625 /* Output the cfg. */
1628 output_cfg (struct output_block
*ob
, struct function
*fn
)
1630 struct lto_output_stream
*tmp_stream
= ob
->main_stream
;
1633 ob
->main_stream
= ob
->cfg_stream
;
1635 streamer_write_enum (ob
->main_stream
, profile_status_d
, PROFILE_LAST
,
1636 profile_status_for_fn (fn
));
1638 /* Output the number of the highest basic block. */
1639 streamer_write_uhwi (ob
, last_basic_block_for_fn (fn
));
1641 FOR_ALL_BB_FN (bb
, fn
)
1646 streamer_write_hwi (ob
, bb
->index
);
1648 /* Output the successors and the edge flags. */
1649 streamer_write_uhwi (ob
, EDGE_COUNT (bb
->succs
));
1650 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1652 streamer_write_uhwi (ob
, e
->dest
->index
);
1653 streamer_write_hwi (ob
, e
->probability
);
1654 streamer_write_gcov_count (ob
, e
->count
);
1655 streamer_write_uhwi (ob
, e
->flags
);
1659 streamer_write_hwi (ob
, -1);
1661 bb
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
1664 streamer_write_hwi (ob
, bb
->next_bb
->index
);
1668 streamer_write_hwi (ob
, -1);
1670 /* ??? The cfgloop interface is tied to cfun. */
1671 gcc_assert (cfun
== fn
);
1673 /* Output the number of loops. */
1674 streamer_write_uhwi (ob
, number_of_loops (fn
));
1676 /* Output each loop, skipping the tree root which has number zero. */
1677 for (unsigned i
= 1; i
< number_of_loops (fn
); ++i
)
1679 struct loop
*loop
= get_loop (fn
, i
);
1681 /* Write the index of the loop header. That's enough to rebuild
1682 the loop tree on the reader side. Stream -1 for an unused
1686 streamer_write_hwi (ob
, -1);
1690 streamer_write_hwi (ob
, loop
->header
->index
);
1692 /* Write everything copy_loop_info copies. */
1693 streamer_write_enum (ob
->main_stream
,
1694 loop_estimation
, EST_LAST
, loop
->estimate_state
);
1695 streamer_write_hwi (ob
, loop
->any_upper_bound
);
1696 if (loop
->any_upper_bound
)
1697 streamer_write_wi (ob
, loop
->nb_iterations_upper_bound
);
1698 streamer_write_hwi (ob
, loop
->any_estimate
);
1699 if (loop
->any_estimate
)
1700 streamer_write_wi (ob
, loop
->nb_iterations_estimate
);
1702 /* Write OMP SIMD related info. */
1703 streamer_write_hwi (ob
, loop
->safelen
);
1704 streamer_write_hwi (ob
, loop
->dont_vectorize
);
1705 streamer_write_hwi (ob
, loop
->force_vectorize
);
1706 stream_write_tree (ob
, loop
->simduid
, true);
1709 ob
->main_stream
= tmp_stream
;
1713 /* Create the header in the file using OB. If the section type is for
1714 a function, set FN to the decl for that function. */
1717 produce_asm (struct output_block
*ob
, tree fn
)
1719 enum lto_section_type section_type
= ob
->section_type
;
1720 struct lto_function_header header
;
1722 struct lto_output_stream
*header_stream
;
1724 if (section_type
== LTO_section_function_body
)
1726 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn
));
1727 section_name
= lto_get_section_name (section_type
, name
, NULL
);
1730 section_name
= lto_get_section_name (section_type
, NULL
, NULL
);
1732 lto_begin_section (section_name
, !flag_wpa
);
1733 free (section_name
);
1735 /* The entire header is stream computed here. */
1736 memset (&header
, 0, sizeof (struct lto_function_header
));
1738 /* Write the header. */
1739 header
.lto_header
.major_version
= LTO_major_version
;
1740 header
.lto_header
.minor_version
= LTO_minor_version
;
1742 header
.compressed_size
= 0;
1744 if (section_type
== LTO_section_function_body
)
1745 header
.cfg_size
= ob
->cfg_stream
->total_size
;
1746 header
.main_size
= ob
->main_stream
->total_size
;
1747 header
.string_size
= ob
->string_stream
->total_size
;
1749 header_stream
= XCNEW (struct lto_output_stream
);
1750 lto_output_data_stream (header_stream
, &header
, sizeof header
);
1751 lto_write_stream (header_stream
);
1752 free (header_stream
);
1754 /* Put all of the gimple and the string table out the asm file as a
1756 if (section_type
== LTO_section_function_body
)
1757 lto_write_stream (ob
->cfg_stream
);
1758 lto_write_stream (ob
->main_stream
);
1759 lto_write_stream (ob
->string_stream
);
1765 /* Output the base body of struct function FN using output block OB. */
1768 output_struct_function_base (struct output_block
*ob
, struct function
*fn
)
1770 struct bitpack_d bp
;
1774 /* Output the static chain and non-local goto save area. */
1775 stream_write_tree (ob
, fn
->static_chain_decl
, true);
1776 stream_write_tree (ob
, fn
->nonlocal_goto_save_area
, true);
1778 /* Output all the local variables in the function. */
1779 streamer_write_hwi (ob
, vec_safe_length (fn
->local_decls
));
1780 FOR_EACH_VEC_SAFE_ELT (fn
->local_decls
, i
, t
)
1781 stream_write_tree (ob
, t
, true);
1783 /* Output current IL state of the function. */
1784 streamer_write_uhwi (ob
, fn
->curr_properties
);
1786 /* Write all the attributes for FN. */
1787 bp
= bitpack_create (ob
->main_stream
);
1788 bp_pack_value (&bp
, fn
->is_thunk
, 1);
1789 bp_pack_value (&bp
, fn
->has_local_explicit_reg_vars
, 1);
1790 bp_pack_value (&bp
, fn
->returns_pcc_struct
, 1);
1791 bp_pack_value (&bp
, fn
->returns_struct
, 1);
1792 bp_pack_value (&bp
, fn
->can_throw_non_call_exceptions
, 1);
1793 bp_pack_value (&bp
, fn
->can_delete_dead_exceptions
, 1);
1794 bp_pack_value (&bp
, fn
->always_inline_functions_inlined
, 1);
1795 bp_pack_value (&bp
, fn
->after_inlining
, 1);
1796 bp_pack_value (&bp
, fn
->stdarg
, 1);
1797 bp_pack_value (&bp
, fn
->has_nonlocal_label
, 1);
1798 bp_pack_value (&bp
, fn
->calls_alloca
, 1);
1799 bp_pack_value (&bp
, fn
->calls_setjmp
, 1);
1800 bp_pack_value (&bp
, fn
->has_force_vectorize_loops
, 1);
1801 bp_pack_value (&bp
, fn
->has_simduid_loops
, 1);
1802 bp_pack_value (&bp
, fn
->va_list_fpr_size
, 8);
1803 bp_pack_value (&bp
, fn
->va_list_gpr_size
, 8);
1805 /* Output the function start and end loci. */
1806 stream_output_location (ob
, &bp
, fn
->function_start_locus
);
1807 stream_output_location (ob
, &bp
, fn
->function_end_locus
);
1809 streamer_write_bitpack (&bp
);
1813 /* Output the body of function NODE->DECL. */
1816 output_function (struct cgraph_node
*node
)
1819 struct function
*fn
;
1821 struct output_block
*ob
;
1823 function
= node
->decl
;
1824 fn
= DECL_STRUCT_FUNCTION (function
);
1825 ob
= create_output_block (LTO_section_function_body
);
1827 clear_line_info (ob
);
1828 ob
->cgraph_node
= node
;
1830 gcc_assert (current_function_decl
== NULL_TREE
&& cfun
== NULL
);
1832 /* Set current_function_decl and cfun. */
1835 /* Make string 0 be a NULL string. */
1836 streamer_write_char_stream (ob
->string_stream
, 0);
1838 streamer_write_record_start (ob
, LTO_function
);
1840 /* Output decls for parameters and args. */
1841 stream_write_tree (ob
, DECL_RESULT (function
), true);
1842 streamer_write_chain (ob
, DECL_ARGUMENTS (function
), true);
1844 /* Output DECL_INITIAL for the function, which contains the tree of
1846 stream_write_tree (ob
, DECL_INITIAL (function
), true);
1848 /* We also stream abstract functions where we stream only stuff needed for
1850 if (gimple_has_body_p (function
))
1852 streamer_write_uhwi (ob
, 1);
1853 output_struct_function_base (ob
, fn
);
1855 /* Output all the SSA names used in the function. */
1856 output_ssa_names (ob
, fn
);
1858 /* Output any exception handling regions. */
1859 output_eh_regions (ob
, fn
);
1862 /* We will renumber the statements. The code that does this uses
1863 the same ordering that we use for serializing them so we can use
1864 the same code on the other end and not have to write out the
1865 statement numbers. We do not assign UIDs to PHIs here because
1866 virtual PHIs get re-computed on-the-fly which would make numbers
1868 set_gimple_stmt_max_uid (cfun
, 0);
1869 FOR_ALL_BB_FN (bb
, cfun
)
1871 gimple_stmt_iterator gsi
;
1872 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1874 gimple stmt
= gsi_stmt (gsi
);
1876 /* Virtual PHIs are not going to be streamed. */
1877 if (!virtual_operand_p (gimple_phi_result (stmt
)))
1878 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
1880 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1882 gimple stmt
= gsi_stmt (gsi
);
1883 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
1886 /* To avoid keeping duplicate gimple IDs in the statements, renumber
1887 virtual phis now. */
1888 FOR_ALL_BB_FN (bb
, cfun
)
1890 gimple_stmt_iterator gsi
;
1891 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1893 gimple stmt
= gsi_stmt (gsi
);
1894 if (virtual_operand_p (gimple_phi_result (stmt
)))
1895 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
1899 /* Output the code for the function. */
1900 FOR_ALL_BB_FN (bb
, fn
)
1901 output_bb (ob
, bb
, fn
);
1903 /* The terminator for this function. */
1904 streamer_write_record_start (ob
, LTO_null
);
1906 output_cfg (ob
, fn
);
1911 streamer_write_uhwi (ob
, 0);
1913 /* Create a section to hold the pickled output of this function. */
1914 produce_asm (ob
, function
);
1916 destroy_output_block (ob
);
1920 /* Emit toplevel asms. */
1923 lto_output_toplevel_asms (void)
1925 struct output_block
*ob
;
1926 struct asm_node
*can
;
1928 struct lto_output_stream
*header_stream
;
1929 struct lto_asm_header header
;
1934 ob
= create_output_block (LTO_section_asm
);
1936 /* Make string 0 be a NULL string. */
1937 streamer_write_char_stream (ob
->string_stream
, 0);
1939 for (can
= asm_nodes
; can
; can
= can
->next
)
1941 streamer_write_string_cst (ob
, ob
->main_stream
, can
->asm_str
);
1942 streamer_write_hwi (ob
, can
->order
);
1945 streamer_write_string_cst (ob
, ob
->main_stream
, NULL_TREE
);
1947 section_name
= lto_get_section_name (LTO_section_asm
, NULL
, NULL
);
1948 lto_begin_section (section_name
, !flag_wpa
);
1949 free (section_name
);
1951 /* The entire header stream is computed here. */
1952 memset (&header
, 0, sizeof (header
));
1954 /* Write the header. */
1955 header
.lto_header
.major_version
= LTO_major_version
;
1956 header
.lto_header
.minor_version
= LTO_minor_version
;
1958 header
.main_size
= ob
->main_stream
->total_size
;
1959 header
.string_size
= ob
->string_stream
->total_size
;
1961 header_stream
= XCNEW (struct lto_output_stream
);
1962 lto_output_data_stream (header_stream
, &header
, sizeof (header
));
1963 lto_write_stream (header_stream
);
1964 free (header_stream
);
1966 /* Put all of the gimple and the string table out the asm file as a
1968 lto_write_stream (ob
->main_stream
);
1969 lto_write_stream (ob
->string_stream
);
1973 destroy_output_block (ob
);
1977 /* Copy the function body of NODE without deserializing. */
1980 copy_function (struct cgraph_node
*node
)
1982 tree function
= node
->decl
;
1983 struct lto_file_decl_data
*file_data
= node
->lto_file_data
;
1984 struct lto_output_stream
*output_stream
= XCNEW (struct lto_output_stream
);
1987 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function
));
1988 char *section_name
=
1989 lto_get_section_name (LTO_section_function_body
, name
, NULL
);
1991 struct lto_in_decl_state
*in_state
;
1992 struct lto_out_decl_state
*out_state
= lto_get_out_decl_state ();
1994 lto_begin_section (section_name
, !flag_wpa
);
1995 free (section_name
);
1997 /* We may have renamed the declaration, e.g., a static function. */
1998 name
= lto_get_decl_name_mapping (file_data
, name
);
2000 data
= lto_get_section_data (file_data
, LTO_section_function_body
,
2004 /* Do a bit copy of the function body. */
2005 lto_output_data_stream (output_stream
, data
, len
);
2006 lto_write_stream (output_stream
);
2010 lto_get_function_in_decl_state (node
->lto_file_data
, function
);
2011 gcc_assert (in_state
);
2013 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2015 size_t n
= in_state
->streams
[i
].size
;
2016 tree
*trees
= in_state
->streams
[i
].trees
;
2017 struct lto_tree_ref_encoder
*encoder
= &(out_state
->streams
[i
]);
2019 /* The out state must have the same indices and the in state.
2020 So just copy the vector. All the encoders in the in state
2021 must be empty where we reach here. */
2022 gcc_assert (lto_tree_ref_encoder_size (encoder
) == 0);
2023 encoder
->trees
.reserve_exact (n
);
2024 for (j
= 0; j
< n
; j
++)
2025 encoder
->trees
.safe_push (trees
[j
]);
2028 lto_free_section_data (file_data
, LTO_section_function_body
, name
,
2030 free (output_stream
);
2034 /* Wrap symbol references in *TP inside a type-preserving MEM_REF. */
2037 wrap_refs (tree
*tp
, int *ws
, void *)
2040 if (handled_component_p (t
)
2041 && TREE_CODE (TREE_OPERAND (t
, 0)) == VAR_DECL
)
2043 tree decl
= TREE_OPERAND (t
, 0);
2044 tree ptrtype
= build_pointer_type (TREE_TYPE (decl
));
2045 TREE_OPERAND (t
, 0) = build2 (MEM_REF
, TREE_TYPE (decl
),
2046 build1 (ADDR_EXPR
, ptrtype
, decl
),
2047 build_int_cst (ptrtype
, 0));
2048 TREE_THIS_VOLATILE (TREE_OPERAND (t
, 0)) = TREE_THIS_VOLATILE (decl
);
2051 else if (TREE_CODE (t
) == CONSTRUCTOR
)
2053 else if (!EXPR_P (t
))
2058 /* Main entry point from the pass manager. */
2063 struct lto_out_decl_state
*decl_state
;
2064 #ifdef ENABLE_CHECKING
2065 bitmap output
= lto_bitmap_alloc ();
2068 lto_symtab_encoder_t encoder
= lto_get_out_decl_state ()->symtab_node_encoder
;
2070 /* Initialize the streamer. */
2071 lto_streamer_init ();
2073 n_nodes
= lto_symtab_encoder_size (encoder
);
2074 /* Process only the functions with bodies. */
2075 for (i
= 0; i
< n_nodes
; i
++)
2077 symtab_node
*snode
= lto_symtab_encoder_deref (encoder
, i
);
2078 if (cgraph_node
*node
= dyn_cast
<cgraph_node
*> (snode
))
2080 if (lto_symtab_encoder_encode_body_p (encoder
, node
)
2083 #ifdef ENABLE_CHECKING
2084 gcc_assert (!bitmap_bit_p (output
, DECL_UID (node
->decl
)));
2085 bitmap_set_bit (output
, DECL_UID (node
->decl
));
2087 decl_state
= lto_new_out_decl_state ();
2088 lto_push_out_decl_state (decl_state
);
2089 if (gimple_has_body_p (node
->decl
) || !flag_wpa
)
2090 output_function (node
);
2092 copy_function (node
);
2093 gcc_assert (lto_get_out_decl_state () == decl_state
);
2094 lto_pop_out_decl_state ();
2095 lto_record_function_out_decl_state (node
->decl
, decl_state
);
2098 else if (varpool_node
*node
= dyn_cast
<varpool_node
*> (snode
))
2100 /* Wrap symbol references inside the ctor in a type
2101 preserving MEM_REF. */
2102 tree ctor
= DECL_INITIAL (node
->decl
);
2103 if (ctor
&& !in_lto_p
)
2104 walk_tree (&ctor
, wrap_refs
, NULL
, NULL
);
2108 /* Emit the callgraph after emitting function bodies. This needs to
2109 be done now to make sure that all the statements in every function
2110 have been renumbered so that edges can be associated with call
2111 statements using the statement UIDs. */
2114 #ifdef ENABLE_CHECKING
2115 lto_bitmap_free (output
);
2119 /* Write each node in encoded by ENCODER to OB, as well as those reachable
2120 from it and required for correct representation of its semantics.
2121 Each node in ENCODER must be a global declaration or a type. A node
2122 is written only once, even if it appears multiple times in the
2123 vector. Certain transitively-reachable nodes, such as those
2124 representing expressions, may be duplicated, but such nodes
2125 must not appear in ENCODER itself. */
2128 write_global_stream (struct output_block
*ob
,
2129 struct lto_tree_ref_encoder
*encoder
)
2133 const size_t size
= lto_tree_ref_encoder_size (encoder
);
2135 for (index
= 0; index
< size
; index
++)
2137 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2138 if (!streamer_tree_cache_lookup (ob
->writer_cache
, t
, NULL
))
2139 stream_write_tree (ob
, t
, false);
2144 /* Write a sequence of indices into the globals vector corresponding
2145 to the trees in ENCODER. These are used by the reader to map the
2146 indices used to refer to global entities within function bodies to
2150 write_global_references (struct output_block
*ob
,
2151 struct lto_output_stream
*ref_stream
,
2152 struct lto_tree_ref_encoder
*encoder
)
2156 const uint32_t size
= lto_tree_ref_encoder_size (encoder
);
2158 /* Write size as 32-bit unsigned. */
2159 lto_output_data_stream (ref_stream
, &size
, sizeof (int32_t));
2161 for (index
= 0; index
< size
; index
++)
2165 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2166 streamer_tree_cache_lookup (ob
->writer_cache
, t
, &slot_num
);
2167 gcc_assert (slot_num
!= (unsigned)-1);
2168 lto_output_data_stream (ref_stream
, &slot_num
, sizeof slot_num
);
2173 /* Write all the streams in an lto_out_decl_state STATE using
2174 output block OB and output stream OUT_STREAM. */
2177 lto_output_decl_state_streams (struct output_block
*ob
,
2178 struct lto_out_decl_state
*state
)
2182 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2183 write_global_stream (ob
, &state
->streams
[i
]);
2187 /* Write all the references in an lto_out_decl_state STATE using
2188 output block OB and output stream OUT_STREAM. */
2191 lto_output_decl_state_refs (struct output_block
*ob
,
2192 struct lto_output_stream
*out_stream
,
2193 struct lto_out_decl_state
*state
)
2199 /* Write reference to FUNCTION_DECL. If there is not function,
2200 write reference to void_type_node. */
2201 decl
= (state
->fn_decl
) ? state
->fn_decl
: void_type_node
;
2202 streamer_tree_cache_lookup (ob
->writer_cache
, decl
, &ref
);
2203 gcc_assert (ref
!= (unsigned)-1);
2204 lto_output_data_stream (out_stream
, &ref
, sizeof (uint32_t));
2206 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2207 write_global_references (ob
, out_stream
, &state
->streams
[i
]);
2211 /* Return the written size of STATE. */
2214 lto_out_decl_state_written_size (struct lto_out_decl_state
*state
)
2219 size
= sizeof (int32_t); /* fn_ref. */
2220 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2222 size
+= sizeof (int32_t); /* vector size. */
2223 size
+= (lto_tree_ref_encoder_size (&state
->streams
[i
])
2224 * sizeof (int32_t));
2230 /* Write symbol T into STREAM in CACHE. SEEN specifies symbols we wrote
2234 write_symbol (struct streamer_tree_cache_d
*cache
,
2235 struct lto_output_stream
*stream
,
2236 tree t
, struct pointer_set_t
*seen
, bool alias
)
2239 enum gcc_plugin_symbol_kind kind
;
2240 enum gcc_plugin_symbol_visibility visibility
;
2246 /* None of the following kinds of symbols are needed in the
2248 if (!TREE_PUBLIC (t
)
2249 || is_builtin_fn (t
)
2250 || DECL_ABSTRACT (t
)
2251 || (TREE_CODE (t
) == VAR_DECL
&& DECL_HARD_REGISTER (t
)))
2253 gcc_assert (TREE_CODE (t
) != RESULT_DECL
);
2255 gcc_assert (TREE_CODE (t
) == VAR_DECL
2256 || TREE_CODE (t
) == FUNCTION_DECL
);
2258 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t
));
2260 /* This behaves like assemble_name_raw in varasm.c, performing the
2261 same name manipulations that ASM_OUTPUT_LABELREF does. */
2262 name
= IDENTIFIER_POINTER ((*targetm
.asm_out
.mangle_assembler_name
) (name
));
2264 if (pointer_set_contains (seen
, name
))
2266 pointer_set_insert (seen
, name
);
2268 streamer_tree_cache_lookup (cache
, t
, &slot_num
);
2269 gcc_assert (slot_num
!= (unsigned)-1);
2271 if (DECL_EXTERNAL (t
))
2274 kind
= GCCPK_WEAKUNDEF
;
2281 kind
= GCCPK_WEAKDEF
;
2282 else if (DECL_COMMON (t
))
2283 kind
= GCCPK_COMMON
;
2287 /* When something is defined, it should have node attached. */
2288 gcc_assert (alias
|| TREE_CODE (t
) != VAR_DECL
2289 || varpool_get_node (t
)->definition
);
2290 gcc_assert (alias
|| TREE_CODE (t
) != FUNCTION_DECL
2291 || (cgraph_get_node (t
)
2292 && cgraph_get_node (t
)->definition
));
2295 /* Imitate what default_elf_asm_output_external do.
2296 When symbol is external, we need to output it with DEFAULT visibility
2297 when compiling with -fvisibility=default, while with HIDDEN visibility
2298 when symbol has attribute (visibility("hidden")) specified.
2299 targetm.binds_local_p check DECL_VISIBILITY_SPECIFIED and gets this
2302 if (DECL_EXTERNAL (t
)
2303 && !targetm
.binds_local_p (t
))
2304 visibility
= GCCPV_DEFAULT
;
2306 switch (DECL_VISIBILITY (t
))
2308 case VISIBILITY_DEFAULT
:
2309 visibility
= GCCPV_DEFAULT
;
2311 case VISIBILITY_PROTECTED
:
2312 visibility
= GCCPV_PROTECTED
;
2314 case VISIBILITY_HIDDEN
:
2315 visibility
= GCCPV_HIDDEN
;
2317 case VISIBILITY_INTERNAL
:
2318 visibility
= GCCPV_INTERNAL
;
2322 if (kind
== GCCPK_COMMON
2323 && DECL_SIZE_UNIT (t
)
2324 && TREE_CODE (DECL_SIZE_UNIT (t
)) == INTEGER_CST
)
2325 size
= TREE_INT_CST_LOW (DECL_SIZE_UNIT (t
));
2329 if (DECL_ONE_ONLY (t
))
2330 comdat
= IDENTIFIER_POINTER (decl_comdat_group_id (t
));
2334 lto_output_data_stream (stream
, name
, strlen (name
) + 1);
2335 lto_output_data_stream (stream
, comdat
, strlen (comdat
) + 1);
2336 c
= (unsigned char) kind
;
2337 lto_output_data_stream (stream
, &c
, 1);
2338 c
= (unsigned char) visibility
;
2339 lto_output_data_stream (stream
, &c
, 1);
2340 lto_output_data_stream (stream
, &size
, 8);
2341 lto_output_data_stream (stream
, &slot_num
, 4);
2344 /* Return true if NODE should appear in the plugin symbol table. */
2347 output_symbol_p (symtab_node
*node
)
2349 struct cgraph_node
*cnode
;
2350 if (!symtab_real_symbol_p (node
))
2352 /* We keep external functions in symtab for sake of inlining
2353 and devirtualization. We do not want to see them in symbol table as
2354 references unless they are really used. */
2355 cnode
= dyn_cast
<cgraph_node
*> (node
);
2356 if (cnode
&& (!node
->definition
|| DECL_EXTERNAL (cnode
->decl
))
2360 /* Ignore all references from external vars initializers - they are not really
2361 part of the compilation unit until they are used by folding. Some symbols,
2362 like references to external construction vtables can not be referred to at all.
2363 We decide this at can_refer_decl_in_current_unit_p. */
2364 if (!node
->definition
|| DECL_EXTERNAL (node
->decl
))
2367 struct ipa_ref
*ref
;
2368 for (i
= 0; ipa_ref_list_referring_iterate (&node
->ref_list
,
2371 if (ref
->use
== IPA_REF_ALIAS
)
2373 if (is_a
<cgraph_node
*> (ref
->referring
))
2375 if (!DECL_EXTERNAL (ref
->referring
->decl
))
2384 /* Write an IL symbol table to OB.
2385 SET and VSET are cgraph/varpool node sets we are outputting. */
2388 produce_symtab (struct output_block
*ob
)
2390 struct streamer_tree_cache_d
*cache
= ob
->writer_cache
;
2391 char *section_name
= lto_get_section_name (LTO_section_symtab
, NULL
, NULL
);
2392 struct pointer_set_t
*seen
;
2393 struct lto_output_stream stream
;
2394 lto_symtab_encoder_t encoder
= ob
->decl_state
->symtab_node_encoder
;
2395 lto_symtab_encoder_iterator lsei
;
2397 lto_begin_section (section_name
, false);
2398 free (section_name
);
2400 seen
= pointer_set_create ();
2401 memset (&stream
, 0, sizeof (stream
));
2403 /* Write the symbol table.
2404 First write everything defined and then all declarations.
2405 This is necessary to handle cases where we have duplicated symbols. */
2406 for (lsei
= lsei_start (encoder
);
2407 !lsei_end_p (lsei
); lsei_next (&lsei
))
2409 symtab_node
*node
= lsei_node (lsei
);
2411 if (!output_symbol_p (node
) || DECL_EXTERNAL (node
->decl
))
2413 write_symbol (cache
, &stream
, node
->decl
, seen
, false);
2415 for (lsei
= lsei_start (encoder
);
2416 !lsei_end_p (lsei
); lsei_next (&lsei
))
2418 symtab_node
*node
= lsei_node (lsei
);
2420 if (!output_symbol_p (node
) || !DECL_EXTERNAL (node
->decl
))
2422 write_symbol (cache
, &stream
, node
->decl
, seen
, false);
2425 lto_write_stream (&stream
);
2426 pointer_set_destroy (seen
);
2432 /* This pass is run after all of the functions are serialized and all
2433 of the IPA passes have written their serialized forms. This pass
2434 causes the vector of all of the global decls and types used from
2435 this file to be written in to a section that can then be read in to
2436 recover these on other side. */
2439 produce_asm_for_decls (void)
2441 struct lto_out_decl_state
*out_state
;
2442 struct lto_out_decl_state
*fn_out_state
;
2443 struct lto_decl_header header
;
2445 struct output_block
*ob
;
2446 struct lto_output_stream
*header_stream
, *decl_state_stream
;
2447 unsigned idx
, num_fns
;
2448 size_t decl_state_size
;
2449 int32_t num_decl_states
;
2451 ob
= create_output_block (LTO_section_decls
);
2454 memset (&header
, 0, sizeof (struct lto_decl_header
));
2456 section_name
= lto_get_section_name (LTO_section_decls
, NULL
, NULL
);
2457 lto_begin_section (section_name
, !flag_wpa
);
2458 free (section_name
);
2460 /* Make string 0 be a NULL string. */
2461 streamer_write_char_stream (ob
->string_stream
, 0);
2463 gcc_assert (!alias_pairs
);
2465 /* Get rid of the global decl state hash tables to save some memory. */
2466 out_state
= lto_get_out_decl_state ();
2467 for (int i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2468 if (out_state
->streams
[i
].tree_hash_table
)
2470 delete out_state
->streams
[i
].tree_hash_table
;
2471 out_state
->streams
[i
].tree_hash_table
= NULL
;
2474 /* Write the global symbols. */
2475 lto_output_decl_state_streams (ob
, out_state
);
2476 num_fns
= lto_function_decl_states
.length ();
2477 for (idx
= 0; idx
< num_fns
; idx
++)
2480 lto_function_decl_states
[idx
];
2481 lto_output_decl_state_streams (ob
, fn_out_state
);
2484 header
.lto_header
.major_version
= LTO_major_version
;
2485 header
.lto_header
.minor_version
= LTO_minor_version
;
2487 /* Currently not used. This field would allow us to preallocate
2488 the globals vector, so that it need not be resized as it is extended. */
2489 header
.num_nodes
= -1;
2491 /* Compute the total size of all decl out states. */
2492 decl_state_size
= sizeof (int32_t);
2493 decl_state_size
+= lto_out_decl_state_written_size (out_state
);
2494 for (idx
= 0; idx
< num_fns
; idx
++)
2497 lto_function_decl_states
[idx
];
2498 decl_state_size
+= lto_out_decl_state_written_size (fn_out_state
);
2500 header
.decl_state_size
= decl_state_size
;
2502 header
.main_size
= ob
->main_stream
->total_size
;
2503 header
.string_size
= ob
->string_stream
->total_size
;
2505 header_stream
= XCNEW (struct lto_output_stream
);
2506 lto_output_data_stream (header_stream
, &header
, sizeof header
);
2507 lto_write_stream (header_stream
);
2508 free (header_stream
);
2510 /* Write the main out-decl state, followed by out-decl states of
2512 decl_state_stream
= XCNEW (struct lto_output_stream
);
2513 num_decl_states
= num_fns
+ 1;
2514 lto_output_data_stream (decl_state_stream
, &num_decl_states
,
2515 sizeof (num_decl_states
));
2516 lto_output_decl_state_refs (ob
, decl_state_stream
, out_state
);
2517 for (idx
= 0; idx
< num_fns
; idx
++)
2520 lto_function_decl_states
[idx
];
2521 lto_output_decl_state_refs (ob
, decl_state_stream
, fn_out_state
);
2523 lto_write_stream (decl_state_stream
);
2524 free (decl_state_stream
);
2526 lto_write_stream (ob
->main_stream
);
2527 lto_write_stream (ob
->string_stream
);
2531 /* Write the symbol table. It is used by linker to determine dependencies
2532 and thus we can skip it for WPA. */
2534 produce_symtab (ob
);
2536 /* Write command line opts. */
2537 lto_write_options ();
2539 /* Deallocate memory and clean up. */
2540 for (idx
= 0; idx
< num_fns
; idx
++)
2543 lto_function_decl_states
[idx
];
2544 lto_delete_out_decl_state (fn_out_state
);
2546 lto_symtab_encoder_delete (ob
->decl_state
->symtab_node_encoder
);
2547 lto_function_decl_states
.release ();
2548 destroy_output_block (ob
);