1 /* Write the GIMPLE representation to a file stream.
3 Copyright (C) 2009-2013 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"
33 #include "basic-block.h"
35 #include "gimple-iterator.h"
36 #include "gimple-ssa.h"
37 #include "tree-ssanames.h"
38 #include "tree-pass.h"
41 #include "diagnostic-core.h"
44 #include "lto-symtab.h"
45 #include "lto-streamer.h"
46 #include "data-streamer.h"
47 #include "gimple-streamer.h"
48 #include "tree-streamer.h"
49 #include "streamer-hooks.h"
53 /* Clear the line info stored in DATA_IN. */
56 clear_line_info (struct output_block
*ob
)
58 ob
->current_file
= NULL
;
64 /* Create the output block and return it. SECTION_TYPE is
65 LTO_section_function_body or LTO_static_initializer. */
68 create_output_block (enum lto_section_type section_type
)
70 struct output_block
*ob
= XCNEW (struct output_block
);
72 ob
->section_type
= section_type
;
73 ob
->decl_state
= lto_get_out_decl_state ();
74 ob
->main_stream
= XCNEW (struct lto_output_stream
);
75 ob
->string_stream
= XCNEW (struct lto_output_stream
);
76 ob
->writer_cache
= streamer_tree_cache_create (!flag_wpa
, true);
78 if (section_type
== LTO_section_function_body
)
79 ob
->cfg_stream
= XCNEW (struct lto_output_stream
);
83 ob
->string_hash_table
.create (37);
84 gcc_obstack_init (&ob
->obstack
);
90 /* Destroy the output block OB. */
93 destroy_output_block (struct output_block
*ob
)
95 enum lto_section_type section_type
= ob
->section_type
;
97 ob
->string_hash_table
.dispose ();
99 free (ob
->main_stream
);
100 free (ob
->string_stream
);
101 if (section_type
== LTO_section_function_body
)
102 free (ob
->cfg_stream
);
104 streamer_tree_cache_delete (ob
->writer_cache
);
105 obstack_free (&ob
->obstack
, NULL
);
111 /* Look up NODE in the type table and write the index for it to OB. */
114 output_type_ref (struct output_block
*ob
, tree node
)
116 streamer_write_record_start (ob
, LTO_type_ref
);
117 lto_output_type_ref_index (ob
->decl_state
, ob
->main_stream
, node
);
121 /* Return true if tree node T is written to various tables. For these
122 nodes, we sometimes want to write their phyiscal representation
123 (via lto_output_tree), and sometimes we need to emit an index
124 reference into a table (via lto_output_tree_ref). */
127 tree_is_indexable (tree t
)
129 /* Parameters and return values of functions of variably modified types
130 must go to global stream, because they may be used in the type
132 if (TREE_CODE (t
) == PARM_DECL
|| TREE_CODE (t
) == RESULT_DECL
)
133 return variably_modified_type_p (TREE_TYPE (DECL_CONTEXT (t
)), NULL_TREE
);
134 else if (TREE_CODE (t
) == VAR_DECL
&& decl_function_context (t
)
137 else if (TREE_CODE (t
) == DEBUG_EXPR_DECL
)
139 /* Variably modified types need to be streamed alongside function
140 bodies because they can refer to local entities. Together with
141 them we have to localize their members as well.
142 ??? In theory that includes non-FIELD_DECLs as well. */
144 && variably_modified_type_p (t
, NULL_TREE
))
146 else if (TREE_CODE (t
) == FIELD_DECL
147 && variably_modified_type_p (DECL_CONTEXT (t
), NULL_TREE
))
150 return (TYPE_P (t
) || DECL_P (t
) || TREE_CODE (t
) == SSA_NAME
);
154 /* Output info about new location into bitpack BP.
155 After outputting bitpack, lto_output_location_data has
156 to be done to output actual data. */
159 lto_output_location (struct output_block
*ob
, struct bitpack_d
*bp
,
162 expanded_location xloc
;
164 loc
= LOCATION_LOCUS (loc
);
165 bp_pack_value (bp
, loc
== UNKNOWN_LOCATION
, 1);
166 if (loc
== UNKNOWN_LOCATION
)
169 xloc
= expand_location (loc
);
171 bp_pack_value (bp
, ob
->current_file
!= xloc
.file
, 1);
172 bp_pack_value (bp
, ob
->current_line
!= xloc
.line
, 1);
173 bp_pack_value (bp
, ob
->current_col
!= xloc
.column
, 1);
175 if (ob
->current_file
!= xloc
.file
)
176 bp_pack_var_len_unsigned (bp
,
177 streamer_string_index (ob
, xloc
.file
,
178 strlen (xloc
.file
) + 1,
180 ob
->current_file
= xloc
.file
;
182 if (ob
->current_line
!= xloc
.line
)
183 bp_pack_var_len_unsigned (bp
, xloc
.line
);
184 ob
->current_line
= xloc
.line
;
186 if (ob
->current_col
!= xloc
.column
)
187 bp_pack_var_len_unsigned (bp
, xloc
.column
);
188 ob
->current_col
= xloc
.column
;
192 /* If EXPR is an indexable tree node, output a reference to it to
193 output block OB. Otherwise, output the physical representation of
197 lto_output_tree_ref (struct output_block
*ob
, tree expr
)
203 output_type_ref (ob
, expr
);
207 code
= TREE_CODE (expr
);
211 streamer_write_record_start (ob
, LTO_ssa_name_ref
);
212 streamer_write_uhwi (ob
, SSA_NAME_VERSION (expr
));
216 streamer_write_record_start (ob
, LTO_field_decl_ref
);
217 lto_output_field_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
221 streamer_write_record_start (ob
, LTO_function_decl_ref
);
222 lto_output_fn_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
226 case DEBUG_EXPR_DECL
:
227 gcc_assert (decl_function_context (expr
) == NULL
|| TREE_STATIC (expr
));
229 streamer_write_record_start (ob
, LTO_global_decl_ref
);
230 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
234 streamer_write_record_start (ob
, LTO_const_decl_ref
);
235 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
239 gcc_assert (decl_function_context (expr
) == NULL
);
240 streamer_write_record_start (ob
, LTO_imported_decl_ref
);
241 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
245 streamer_write_record_start (ob
, LTO_type_decl_ref
);
246 lto_output_type_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
250 streamer_write_record_start (ob
, LTO_namespace_decl_ref
);
251 lto_output_namespace_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
255 streamer_write_record_start (ob
, LTO_label_decl_ref
);
256 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
260 streamer_write_record_start (ob
, LTO_result_decl_ref
);
261 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
264 case TRANSLATION_UNIT_DECL
:
265 streamer_write_record_start (ob
, LTO_translation_unit_decl_ref
);
266 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
270 /* No other node is indexable, so it should have been handled by
277 /* Return true if EXPR is a tree node that can be written to disk. */
280 lto_is_streamable (tree expr
)
282 enum tree_code code
= TREE_CODE (expr
);
284 /* Notice that we reject SSA_NAMEs as well. We only emit the SSA
285 name version in lto_output_tree_ref (see output_ssa_names). */
286 return !is_lang_specific (expr
)
290 && code
!= MODIFY_EXPR
292 && code
!= TARGET_EXPR
294 && code
!= WITH_CLEANUP_EXPR
295 && code
!= STATEMENT_LIST
296 && code
!= OMP_CLAUSE
297 && (code
== CASE_LABEL_EXPR
299 || TREE_CODE_CLASS (code
) != tcc_statement
);
303 /* For EXPR lookup and return what we want to stream to OB as DECL_INITIAL. */
306 get_symbol_initial_value (struct output_block
*ob
, tree expr
)
308 gcc_checking_assert (DECL_P (expr
)
309 && TREE_CODE (expr
) != FUNCTION_DECL
310 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
);
312 /* Handle DECL_INITIAL for symbols. */
313 tree initial
= DECL_INITIAL (expr
);
314 if (TREE_CODE (expr
) == VAR_DECL
315 && (TREE_STATIC (expr
) || DECL_EXTERNAL (expr
))
316 && !DECL_IN_CONSTANT_POOL (expr
)
319 lto_symtab_encoder_t encoder
;
320 struct varpool_node
*vnode
;
322 encoder
= ob
->decl_state
->symtab_node_encoder
;
323 vnode
= varpool_get_node (expr
);
325 || !lto_symtab_encoder_encode_initializer_p (encoder
,
327 initial
= error_mark_node
;
334 /* Write a physical representation of tree node EXPR to output block
335 OB. If REF_P is true, the leaves of EXPR are emitted as references
336 via lto_output_tree_ref. IX is the index into the streamer cache
337 where EXPR is stored. */
340 lto_write_tree_1 (struct output_block
*ob
, tree expr
, bool ref_p
)
342 /* Pack all the non-pointer fields in EXPR into a bitpack and write
343 the resulting bitpack. */
344 bitpack_d bp
= bitpack_create (ob
->main_stream
);
345 streamer_pack_tree_bitfields (ob
, &bp
, expr
);
346 streamer_write_bitpack (&bp
);
348 /* Write all the pointer fields in EXPR. */
349 streamer_write_tree_body (ob
, expr
, ref_p
);
351 /* Write any LTO-specific data to OB. */
353 && TREE_CODE (expr
) != FUNCTION_DECL
354 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
356 /* Handle DECL_INITIAL for symbols. */
357 tree initial
= get_symbol_initial_value (ob
, expr
);
358 stream_write_tree (ob
, initial
, ref_p
);
362 /* Write a physical representation of tree node EXPR to output block
363 OB. If REF_P is true, the leaves of EXPR are emitted as references
364 via lto_output_tree_ref. IX is the index into the streamer cache
365 where EXPR is stored. */
368 lto_write_tree (struct output_block
*ob
, tree expr
, bool ref_p
)
370 if (!lto_is_streamable (expr
))
371 internal_error ("tree code %qs is not supported in LTO streams",
372 get_tree_code_name (TREE_CODE (expr
)));
374 /* Write the header, containing everything needed to materialize
375 EXPR on the reading side. */
376 streamer_write_tree_header (ob
, expr
);
378 lto_write_tree_1 (ob
, expr
, ref_p
);
380 /* Mark the end of EXPR. */
381 streamer_write_zero (ob
);
384 /* Emit the physical representation of tree node EXPR to output block
385 OB. If THIS_REF_P is true, the leaves of EXPR are emitted as references
386 via lto_output_tree_ref. REF_P is used for streaming siblings of EXPR. */
389 lto_output_tree_1 (struct output_block
*ob
, tree expr
, hashval_t hash
,
390 bool ref_p
, bool this_ref_p
)
394 gcc_checking_assert (expr
!= NULL_TREE
395 && !(this_ref_p
&& tree_is_indexable (expr
)));
397 bool exists_p
= streamer_tree_cache_insert (ob
->writer_cache
,
399 gcc_assert (!exists_p
);
400 if (streamer_handle_as_builtin_p (expr
))
402 /* MD and NORMAL builtins do not need to be written out
403 completely as they are always instantiated by the
404 compiler on startup. The only builtins that need to
405 be written out are BUILT_IN_FRONTEND. For all other
406 builtins, we simply write the class and code. */
407 streamer_write_builtin (ob
, expr
);
409 else if (TREE_CODE (expr
) == INTEGER_CST
410 && !TREE_OVERFLOW (expr
))
412 /* Shared INTEGER_CST nodes are special because they need their
413 original type to be materialized by the reader (to implement
414 TYPE_CACHED_VALUES). */
415 streamer_write_integer_cst (ob
, expr
, ref_p
);
419 /* This is the first time we see EXPR, write its fields
421 lto_write_tree (ob
, expr
, ref_p
);
437 static unsigned int next_dfs_num
;
438 static vec
<scc_entry
> sccstack
;
439 static struct pointer_map_t
*sccstate
;
440 static struct obstack sccstate_obstack
;
443 DFS_write_tree (struct output_block
*ob
, sccs
*from_state
,
444 tree expr
, bool ref_p
, bool this_ref_p
);
446 /* Handle the tree EXPR in the DFS walk with SCC state EXPR_STATE and
447 DFS recurse for all tree edges originating from it. */
450 DFS_write_tree_body (struct output_block
*ob
,
451 tree expr
, sccs
*expr_state
, bool ref_p
)
453 #define DFS_follow_tree_edge(DEST) \
454 DFS_write_tree (ob, expr_state, DEST, ref_p, ref_p)
458 code
= TREE_CODE (expr
);
460 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
462 if (TREE_CODE (expr
) != IDENTIFIER_NODE
)
463 DFS_follow_tree_edge (TREE_TYPE (expr
));
466 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
468 for (unsigned i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
469 DFS_follow_tree_edge (VECTOR_CST_ELT (expr
, i
));
472 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
474 DFS_follow_tree_edge (TREE_REALPART (expr
));
475 DFS_follow_tree_edge (TREE_IMAGPART (expr
));
478 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
480 /* Drop names that were created for anonymous entities. */
482 && TREE_CODE (DECL_NAME (expr
)) == IDENTIFIER_NODE
483 && ANON_AGGRNAME_P (DECL_NAME (expr
)))
486 DFS_follow_tree_edge (DECL_NAME (expr
));
487 DFS_follow_tree_edge (DECL_CONTEXT (expr
));
490 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
492 DFS_follow_tree_edge (DECL_SIZE (expr
));
493 DFS_follow_tree_edge (DECL_SIZE_UNIT (expr
));
495 /* Note, DECL_INITIAL is not handled here. Since DECL_INITIAL needs
496 special handling in LTO, it must be handled by streamer hooks. */
498 DFS_follow_tree_edge (DECL_ATTRIBUTES (expr
));
500 /* Do not follow DECL_ABSTRACT_ORIGIN. We cannot handle debug information
501 for early inlining so drop it on the floor instead of ICEing in
504 if ((TREE_CODE (expr
) == VAR_DECL
505 || TREE_CODE (expr
) == PARM_DECL
)
506 && DECL_HAS_VALUE_EXPR_P (expr
))
507 DFS_follow_tree_edge (DECL_VALUE_EXPR (expr
));
508 if (TREE_CODE (expr
) == VAR_DECL
)
509 DFS_follow_tree_edge (DECL_DEBUG_EXPR (expr
));
512 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
514 if (TREE_CODE (expr
) == TYPE_DECL
)
515 DFS_follow_tree_edge (DECL_ORIGINAL_TYPE (expr
));
516 DFS_follow_tree_edge (DECL_VINDEX (expr
));
519 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
521 /* Make sure we don't inadvertently set the assembler name. */
522 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
523 DFS_follow_tree_edge (DECL_ASSEMBLER_NAME (expr
));
524 DFS_follow_tree_edge (DECL_SECTION_NAME (expr
));
525 DFS_follow_tree_edge (DECL_COMDAT_GROUP (expr
));
528 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
530 DFS_follow_tree_edge (DECL_FIELD_OFFSET (expr
));
531 DFS_follow_tree_edge (DECL_BIT_FIELD_TYPE (expr
));
532 DFS_follow_tree_edge (DECL_BIT_FIELD_REPRESENTATIVE (expr
));
533 DFS_follow_tree_edge (DECL_FIELD_BIT_OFFSET (expr
));
534 DFS_follow_tree_edge (DECL_FCONTEXT (expr
));
537 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
539 DFS_follow_tree_edge (DECL_FUNCTION_PERSONALITY (expr
));
540 DFS_follow_tree_edge (DECL_FUNCTION_SPECIFIC_TARGET (expr
));
541 DFS_follow_tree_edge (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr
));
544 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
546 DFS_follow_tree_edge (TYPE_SIZE (expr
));
547 DFS_follow_tree_edge (TYPE_SIZE_UNIT (expr
));
548 DFS_follow_tree_edge (TYPE_ATTRIBUTES (expr
));
549 DFS_follow_tree_edge (TYPE_NAME (expr
));
550 /* Do not follow TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
551 reconstructed during fixup. */
552 /* Do not follow TYPE_NEXT_VARIANT, we reconstruct the variant lists
554 DFS_follow_tree_edge (TYPE_MAIN_VARIANT (expr
));
555 DFS_follow_tree_edge (TYPE_CONTEXT (expr
));
556 /* TYPE_CANONICAL is re-computed during type merging, so no need
557 to follow it here. */
558 DFS_follow_tree_edge (TYPE_STUB_DECL (expr
));
561 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
563 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
564 DFS_follow_tree_edge (TYPE_VALUES (expr
));
565 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
566 DFS_follow_tree_edge (TYPE_DOMAIN (expr
));
567 else if (RECORD_OR_UNION_TYPE_P (expr
))
568 for (tree t
= TYPE_FIELDS (expr
); t
; t
= TREE_CHAIN (t
))
569 DFS_follow_tree_edge (t
);
570 else if (TREE_CODE (expr
) == FUNCTION_TYPE
571 || TREE_CODE (expr
) == METHOD_TYPE
)
572 DFS_follow_tree_edge (TYPE_ARG_TYPES (expr
));
574 if (!POINTER_TYPE_P (expr
))
575 DFS_follow_tree_edge (TYPE_MINVAL (expr
));
576 DFS_follow_tree_edge (TYPE_MAXVAL (expr
));
577 if (RECORD_OR_UNION_TYPE_P (expr
))
578 DFS_follow_tree_edge (TYPE_BINFO (expr
));
581 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
583 DFS_follow_tree_edge (TREE_PURPOSE (expr
));
584 DFS_follow_tree_edge (TREE_VALUE (expr
));
585 DFS_follow_tree_edge (TREE_CHAIN (expr
));
588 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
590 for (int i
= 0; i
< TREE_VEC_LENGTH (expr
); i
++)
591 DFS_follow_tree_edge (TREE_VEC_ELT (expr
, i
));
594 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
596 for (int i
= 0; i
< TREE_OPERAND_LENGTH (expr
); i
++)
597 DFS_follow_tree_edge (TREE_OPERAND (expr
, i
));
598 DFS_follow_tree_edge (TREE_BLOCK (expr
));
601 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
603 for (tree t
= BLOCK_VARS (expr
); t
; t
= TREE_CHAIN (t
))
604 /* ??? FIXME. See also streamer_write_chain. */
605 if (!(VAR_OR_FUNCTION_DECL_P (t
)
606 && DECL_EXTERNAL (t
)))
607 DFS_follow_tree_edge (t
);
609 DFS_follow_tree_edge (BLOCK_SUPERCONTEXT (expr
));
611 /* Follow BLOCK_ABSTRACT_ORIGIN for the limited cases we can
612 handle - those that represent inlined function scopes.
613 For the drop rest them on the floor instead of ICEing
615 if (inlined_function_outer_scope_p (expr
))
617 tree ultimate_origin
= block_ultimate_origin (expr
);
618 DFS_follow_tree_edge (ultimate_origin
);
620 /* Do not follow BLOCK_NONLOCALIZED_VARS. We cannot handle debug
621 information for early inlined BLOCKs so drop it on the floor instead
622 of ICEing in dwarf2out.c. */
624 /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
627 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
628 list is re-constructed from BLOCK_SUPERCONTEXT. */
631 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
636 /* Note that the number of BINFO slots has already been emitted in
637 EXPR's header (see streamer_write_tree_header) because this length
638 is needed to build the empty BINFO node on the reader side. */
639 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr
), i
, t
)
640 DFS_follow_tree_edge (t
);
641 DFS_follow_tree_edge (BINFO_OFFSET (expr
));
642 DFS_follow_tree_edge (BINFO_VTABLE (expr
));
643 DFS_follow_tree_edge (BINFO_VPTR_FIELD (expr
));
645 /* The number of BINFO_BASE_ACCESSES has already been emitted in
646 EXPR's bitfield section. */
647 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (expr
), i
, t
)
648 DFS_follow_tree_edge (t
);
650 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
651 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
654 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
659 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr
), i
, index
, value
)
661 DFS_follow_tree_edge (index
);
662 DFS_follow_tree_edge (value
);
666 #undef DFS_follow_tree_edge
669 /* Return a hash value for the tree T. */
672 hash_tree (struct streamer_tree_cache_d
*cache
, tree t
)
674 #define visit(SIBLING) \
677 if (SIBLING && streamer_tree_cache_lookup (cache, SIBLING, &ix)) \
678 v = iterative_hash_hashval_t (streamer_tree_cache_get_hash (cache, ix), v); \
682 enum tree_code code
= TREE_CODE (t
);
683 hashval_t v
= iterative_hash_host_wide_int (code
, 0);
686 v
= iterative_hash_host_wide_int (TREE_SIDE_EFFECTS (t
)
687 | (TREE_CONSTANT (t
) << 1)
688 | (TREE_READONLY (t
) << 2)
689 | (TREE_PUBLIC (t
) << 3), v
);
691 v
= iterative_hash_host_wide_int (TREE_ADDRESSABLE (t
)
692 | (TREE_THIS_VOLATILE (t
) << 1), v
);
694 v
= iterative_hash_host_wide_int (DECL_UNSIGNED (t
), v
);
696 v
= iterative_hash_host_wide_int (TYPE_UNSIGNED (t
), v
);
698 v
= iterative_hash_host_wide_int (TYPE_ARTIFICIAL (t
), v
);
700 v
= iterative_hash_host_wide_int (TREE_NO_WARNING (t
), v
);
701 v
= iterative_hash_host_wide_int (TREE_NOTHROW (t
)
702 | (TREE_STATIC (t
) << 1)
703 | (TREE_PROTECTED (t
) << 2)
704 | (TREE_DEPRECATED (t
) << 3), v
);
705 if (code
!= TREE_BINFO
)
706 v
= iterative_hash_host_wide_int (TREE_PRIVATE (t
), v
);
708 v
= iterative_hash_host_wide_int (TYPE_SATURATING (t
)
709 | (TYPE_ADDR_SPACE (t
) << 1), v
);
710 else if (code
== SSA_NAME
)
711 v
= iterative_hash_host_wide_int (SSA_NAME_IS_DEFAULT_DEF (t
), v
);
713 if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
715 v
= iterative_hash_host_wide_int (TREE_INT_CST_LOW (t
), v
);
716 v
= iterative_hash_host_wide_int (TREE_INT_CST_HIGH (t
), v
);
719 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
721 REAL_VALUE_TYPE r
= TREE_REAL_CST (t
);
722 v
= iterative_hash_host_wide_int (r
.cl
, v
);
723 v
= iterative_hash_host_wide_int (r
.decimal
725 | (r
.signalling
<< 2)
726 | (r
.canonical
<< 3), v
);
727 v
= iterative_hash_host_wide_int (r
.uexp
, v
);
728 for (unsigned i
= 0; i
< SIGSZ
; ++i
)
729 v
= iterative_hash_host_wide_int (r
.sig
[i
], v
);
732 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
734 FIXED_VALUE_TYPE f
= TREE_FIXED_CST (t
);
735 v
= iterative_hash_host_wide_int (f
.mode
, v
);
736 v
= iterative_hash_host_wide_int (f
.data
.low
, v
);
737 v
= iterative_hash_host_wide_int (f
.data
.high
, v
);
740 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
742 v
= iterative_hash_host_wide_int (DECL_MODE (t
), v
);
743 v
= iterative_hash_host_wide_int (DECL_NONLOCAL (t
)
744 | (DECL_VIRTUAL_P (t
) << 1)
745 | (DECL_IGNORED_P (t
) << 2)
746 | (DECL_ABSTRACT (t
) << 3)
747 | (DECL_ARTIFICIAL (t
) << 4)
748 | (DECL_USER_ALIGN (t
) << 5)
749 | (DECL_PRESERVE_P (t
) << 6)
750 | (DECL_EXTERNAL (t
) << 7)
751 | (DECL_GIMPLE_REG_P (t
) << 8), v
);
752 v
= iterative_hash_host_wide_int (DECL_ALIGN (t
), v
);
753 if (code
== LABEL_DECL
)
755 v
= iterative_hash_host_wide_int (EH_LANDING_PAD_NR (t
), v
);
756 v
= iterative_hash_host_wide_int (LABEL_DECL_UID (t
), v
);
758 else if (code
== FIELD_DECL
)
760 v
= iterative_hash_host_wide_int (DECL_PACKED (t
)
761 | (DECL_NONADDRESSABLE_P (t
) << 1),
763 v
= iterative_hash_host_wide_int (DECL_OFFSET_ALIGN (t
), v
);
765 else if (code
== VAR_DECL
)
767 v
= iterative_hash_host_wide_int (DECL_HAS_DEBUG_EXPR_P (t
)
768 | (DECL_NONLOCAL_FRAME (t
) << 1),
771 if (code
== RESULT_DECL
775 v
= iterative_hash_host_wide_int (DECL_BY_REFERENCE (t
), v
);
777 || code
== PARM_DECL
)
778 v
= iterative_hash_host_wide_int (DECL_HAS_VALUE_EXPR_P (t
), v
);
782 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
783 v
= iterative_hash_host_wide_int (DECL_REGISTER (t
), v
);
785 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
787 v
= iterative_hash_host_wide_int ((DECL_COMMON (t
))
788 | (DECL_DLLIMPORT_P (t
) << 1)
789 | (DECL_WEAK (t
) << 2)
790 | (DECL_SEEN_IN_BIND_EXPR_P (t
) << 3)
791 | (DECL_COMDAT (t
) << 4)
792 | (DECL_VISIBILITY_SPECIFIED (t
) << 6),
794 v
= iterative_hash_host_wide_int (DECL_VISIBILITY (t
), v
);
795 if (code
== VAR_DECL
)
797 /* DECL_IN_TEXT_SECTION is set during final asm output only. */
798 v
= iterative_hash_host_wide_int (DECL_HARD_REGISTER (t
)
799 | (DECL_IN_CONSTANT_POOL (t
) << 1),
801 v
= iterative_hash_host_wide_int (DECL_TLS_MODEL (t
), v
);
803 if (TREE_CODE (t
) == FUNCTION_DECL
)
804 v
= iterative_hash_host_wide_int (DECL_FINAL_P (t
)
805 | (DECL_CXX_CONSTRUCTOR_P (t
) << 1)
806 | (DECL_CXX_DESTRUCTOR_P (t
) << 2),
808 if (VAR_OR_FUNCTION_DECL_P (t
))
809 v
= iterative_hash_host_wide_int (DECL_INIT_PRIORITY (t
), v
);
812 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
814 v
= iterative_hash_host_wide_int (DECL_BUILT_IN_CLASS (t
), v
);
815 v
= iterative_hash_host_wide_int (DECL_STATIC_CONSTRUCTOR (t
)
816 | (DECL_STATIC_DESTRUCTOR (t
) << 1)
817 | (DECL_UNINLINABLE (t
) << 2)
818 | (DECL_POSSIBLY_INLINED (t
) << 3)
819 | (DECL_IS_NOVOPS (t
) << 4)
820 | (DECL_IS_RETURNS_TWICE (t
) << 5)
821 | (DECL_IS_MALLOC (t
) << 6)
822 | (DECL_IS_OPERATOR_NEW (t
) << 7)
823 | (DECL_DECLARED_INLINE_P (t
) << 8)
824 | (DECL_STATIC_CHAIN (t
) << 9)
825 | (DECL_NO_INLINE_WARNING_P (t
) << 10)
826 | (DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (t
) << 11)
827 | (DECL_NO_LIMIT_STACK (t
) << 12)
828 | (DECL_DISREGARD_INLINE_LIMITS (t
) << 13)
829 | (DECL_PURE_P (t
) << 14)
830 | (DECL_LOOPING_CONST_OR_PURE_P (t
) << 15), v
);
831 if (DECL_BUILT_IN_CLASS (t
) != NOT_BUILT_IN
)
832 v
= iterative_hash_host_wide_int (DECL_FUNCTION_CODE (t
), v
);
833 if (DECL_STATIC_DESTRUCTOR (t
))
834 v
= iterative_hash_host_wide_int (DECL_FINI_PRIORITY (t
), v
);
837 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
839 v
= iterative_hash_host_wide_int (TYPE_MODE (t
), v
);
840 v
= iterative_hash_host_wide_int (TYPE_STRING_FLAG (t
)
841 | (TYPE_NO_FORCE_BLK (t
) << 1)
842 | (TYPE_NEEDS_CONSTRUCTING (t
) << 2)
843 | (TYPE_PACKED (t
) << 3)
844 | (TYPE_RESTRICT (t
) << 4)
845 | (TYPE_USER_ALIGN (t
) << 5)
846 | (TYPE_READONLY (t
) << 6), v
);
847 if (RECORD_OR_UNION_TYPE_P (t
))
849 v
= iterative_hash_host_wide_int (TYPE_TRANSPARENT_AGGR (t
)
850 | (TYPE_FINAL_P (t
) << 1), v
);
852 else if (code
== ARRAY_TYPE
)
853 v
= iterative_hash_host_wide_int (TYPE_NONALIASED_COMPONENT (t
), v
);
854 v
= iterative_hash_host_wide_int (TYPE_PRECISION (t
), v
);
855 v
= iterative_hash_host_wide_int (TYPE_ALIGN (t
), v
);
856 v
= iterative_hash_host_wide_int ((TYPE_ALIAS_SET (t
) == 0
858 && get_alias_set (t
) == 0))
862 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
863 v
= iterative_hash (TRANSLATION_UNIT_LANGUAGE (t
),
864 strlen (TRANSLATION_UNIT_LANGUAGE (t
)), v
);
866 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
))
867 v
= iterative_hash (t
, sizeof (struct cl_target_option
), v
);
869 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
870 v
= iterative_hash (t
, sizeof (struct cl_optimization
), v
);
872 if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
873 v
= iterative_hash_host_wide_int (IDENTIFIER_HASH_VALUE (t
), v
);
875 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
876 v
= iterative_hash (TREE_STRING_POINTER (t
), TREE_STRING_LENGTH (t
), v
);
878 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
880 if (POINTER_TYPE_P (t
))
882 /* For pointers factor in the pointed-to type recursively as
883 we cannot recurse through only pointers.
884 ??? We can generalize this by keeping track of the
885 in-SCC edges for each tree (or arbitrarily the first
886 such edge) and hashing that in in a second stage
887 (instead of the quadratic mixing of the SCC we do now). */
890 if (streamer_tree_cache_lookup (cache
, TREE_TYPE (t
), &ix
))
891 x
= streamer_tree_cache_get_hash (cache
, ix
);
893 x
= hash_tree (cache
, TREE_TYPE (t
));
894 v
= iterative_hash_hashval_t (x
, v
);
896 else if (code
!= IDENTIFIER_NODE
)
897 visit (TREE_TYPE (t
));
900 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
901 for (unsigned i
= 0; i
< VECTOR_CST_NELTS (t
); ++i
)
902 visit (VECTOR_CST_ELT (t
, i
));
904 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
906 visit (TREE_REALPART (t
));
907 visit (TREE_IMAGPART (t
));
910 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
912 /* Drop names that were created for anonymous entities. */
914 && TREE_CODE (DECL_NAME (t
)) == IDENTIFIER_NODE
915 && ANON_AGGRNAME_P (DECL_NAME (t
)))
918 visit (DECL_NAME (t
));
919 if (DECL_FILE_SCOPE_P (t
))
922 visit (DECL_CONTEXT (t
));
925 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
927 visit (DECL_SIZE (t
));
928 visit (DECL_SIZE_UNIT (t
));
929 visit (DECL_ATTRIBUTES (t
));
930 if ((code
== VAR_DECL
931 || code
== PARM_DECL
)
932 && DECL_HAS_VALUE_EXPR_P (t
))
933 visit (DECL_VALUE_EXPR (t
));
935 && DECL_HAS_DEBUG_EXPR_P (t
))
936 visit (DECL_DEBUG_EXPR (t
));
937 /* ??? Hash DECL_INITIAL as streamed. Needs the output-block to
938 be able to call get_symbol_initial_value. */
941 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
943 if (code
== TYPE_DECL
)
944 visit (DECL_ORIGINAL_TYPE (t
));
945 visit (DECL_VINDEX (t
));
948 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
950 if (DECL_ASSEMBLER_NAME_SET_P (t
))
951 visit (DECL_ASSEMBLER_NAME (t
));
952 visit (DECL_SECTION_NAME (t
));
953 visit (DECL_COMDAT_GROUP (t
));
956 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
958 visit (DECL_FIELD_OFFSET (t
));
959 visit (DECL_BIT_FIELD_TYPE (t
));
960 visit (DECL_BIT_FIELD_REPRESENTATIVE (t
));
961 visit (DECL_FIELD_BIT_OFFSET (t
));
962 visit (DECL_FCONTEXT (t
));
965 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
967 visit (DECL_FUNCTION_PERSONALITY (t
));
968 visit (DECL_FUNCTION_SPECIFIC_TARGET (t
));
969 visit (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t
));
972 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
974 visit (TYPE_SIZE (t
));
975 visit (TYPE_SIZE_UNIT (t
));
976 visit (TYPE_ATTRIBUTES (t
));
977 visit (TYPE_NAME (t
));
978 visit (TYPE_MAIN_VARIANT (t
));
979 if (TYPE_FILE_SCOPE_P (t
))
982 visit (TYPE_CONTEXT (t
));
983 visit (TYPE_STUB_DECL (t
));
986 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
988 if (code
== ENUMERAL_TYPE
)
989 visit (TYPE_VALUES (t
));
990 else if (code
== ARRAY_TYPE
)
991 visit (TYPE_DOMAIN (t
));
992 else if (RECORD_OR_UNION_TYPE_P (t
))
993 for (tree f
= TYPE_FIELDS (t
); f
; f
= TREE_CHAIN (f
))
995 else if (code
== FUNCTION_TYPE
996 || code
== METHOD_TYPE
)
997 visit (TYPE_ARG_TYPES (t
));
998 if (!POINTER_TYPE_P (t
))
999 visit (TYPE_MINVAL (t
));
1000 visit (TYPE_MAXVAL (t
));
1001 if (RECORD_OR_UNION_TYPE_P (t
))
1002 visit (TYPE_BINFO (t
));
1005 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
1007 visit (TREE_PURPOSE (t
));
1008 visit (TREE_VALUE (t
));
1009 visit (TREE_CHAIN (t
));
1012 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1013 for (int i
= 0; i
< TREE_VEC_LENGTH (t
); ++i
)
1014 visit (TREE_VEC_ELT (t
, i
));
1016 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
1018 v
= iterative_hash_host_wide_int (TREE_OPERAND_LENGTH (t
), v
);
1019 for (int i
= 0; i
< TREE_OPERAND_LENGTH (t
); ++i
)
1020 visit (TREE_OPERAND (t
, i
));
1023 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1027 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (t
), i
, b
)
1029 visit (BINFO_OFFSET (t
));
1030 visit (BINFO_VTABLE (t
));
1031 visit (BINFO_VPTR_FIELD (t
));
1032 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (t
), i
, b
)
1034 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
1035 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
1038 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1042 v
= iterative_hash_host_wide_int (CONSTRUCTOR_NELTS (t
), v
);
1043 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), i
, index
, value
)
1055 /* Compare two SCC entries by their hash value for qsorting them. */
1058 scc_entry_compare (const void *p1_
, const void *p2_
)
1060 const scc_entry
*p1
= (const scc_entry
*) p1_
;
1061 const scc_entry
*p2
= (const scc_entry
*) p2_
;
1062 if (p1
->hash
< p2
->hash
)
1064 else if (p1
->hash
> p2
->hash
)
1069 /* Return a hash value for the SCC on the SCC stack from FIRST with
1073 hash_scc (struct streamer_tree_cache_d
*cache
, unsigned first
, unsigned size
)
1075 /* Compute hash values for the SCC members. */
1076 for (unsigned i
= 0; i
< size
; ++i
)
1077 sccstack
[first
+i
].hash
= hash_tree (cache
, sccstack
[first
+i
].t
);
1080 return sccstack
[first
].hash
;
1082 /* Sort the SCC of type, hash pairs so that when we mix in
1083 all members of the SCC the hash value becomes independent on
1084 the order we visited the SCC. Disregard hashes equal to
1085 the hash of the tree we mix into because we cannot guarantee
1086 a stable sort for those across different TUs. */
1087 qsort (&sccstack
[first
], size
, sizeof (scc_entry
), scc_entry_compare
);
1088 hashval_t
*tem
= XALLOCAVEC (hashval_t
, size
);
1089 for (unsigned i
= 0; i
< size
; ++i
)
1091 hashval_t hash
= sccstack
[first
+i
].hash
;
1092 hashval_t orig_hash
= hash
;
1094 /* Skip same hashes. */
1096 j
< size
&& sccstack
[first
+j
].hash
== orig_hash
; ++j
)
1098 for (; j
< size
; ++j
)
1099 hash
= iterative_hash_hashval_t (sccstack
[first
+j
].hash
, hash
);
1100 for (j
= 0; sccstack
[first
+j
].hash
!= orig_hash
; ++j
)
1101 hash
= iterative_hash_hashval_t (sccstack
[first
+j
].hash
, hash
);
1104 hashval_t scc_hash
= 0;
1105 for (unsigned i
= 0; i
< size
; ++i
)
1107 sccstack
[first
+i
].hash
= tem
[i
];
1108 scc_hash
= iterative_hash_hashval_t (tem
[i
], scc_hash
);
1113 /* DFS walk EXPR and stream SCCs of tree bodies if they are not
1114 already in the streamer cache. Main routine called for
1115 each visit of EXPR. */
1118 DFS_write_tree (struct output_block
*ob
, sccs
*from_state
,
1119 tree expr
, bool ref_p
, bool this_ref_p
)
1124 /* Handle special cases. */
1125 if (expr
== NULL_TREE
)
1128 /* Do not DFS walk into indexable trees. */
1129 if (this_ref_p
&& tree_is_indexable (expr
))
1132 /* Check if we already streamed EXPR. */
1133 if (streamer_tree_cache_lookup (ob
->writer_cache
, expr
, &ix
))
1136 slot
= (sccs
**)pointer_map_insert (sccstate
, expr
);
1137 sccs
*cstate
= *slot
;
1140 scc_entry e
= { expr
, 0 };
1141 /* Not yet visited. DFS recurse and push it onto the stack. */
1142 *slot
= cstate
= XOBNEW (&sccstate_obstack
, struct sccs
);
1143 sccstack
.safe_push (e
);
1144 cstate
->dfsnum
= next_dfs_num
++;
1145 cstate
->low
= cstate
->dfsnum
;
1147 if (streamer_handle_as_builtin_p (expr
))
1149 else if (TREE_CODE (expr
) == INTEGER_CST
1150 && !TREE_OVERFLOW (expr
))
1151 DFS_write_tree (ob
, cstate
, TREE_TYPE (expr
), ref_p
, ref_p
);
1154 DFS_write_tree_body (ob
, expr
, cstate
, ref_p
);
1156 /* Walk any LTO-specific edges. */
1158 && TREE_CODE (expr
) != FUNCTION_DECL
1159 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
1161 /* Handle DECL_INITIAL for symbols. */
1162 tree initial
= get_symbol_initial_value (ob
, expr
);
1163 DFS_write_tree (ob
, cstate
, initial
, ref_p
, ref_p
);
1167 /* See if we found an SCC. */
1168 if (cstate
->low
== cstate
->dfsnum
)
1170 unsigned first
, size
;
1173 /* Pop the SCC and compute its size. */
1174 first
= sccstack
.length ();
1177 x
= sccstack
[--first
].t
;
1180 size
= sccstack
.length () - first
;
1182 /* No need to compute hashes for LTRANS units, we don't perform
1183 any merging there. */
1184 hashval_t scc_hash
= 0;
1185 unsigned scc_entry_len
= 0;
1188 scc_hash
= hash_scc (ob
->writer_cache
, first
, size
);
1190 /* Put the entries with the least number of collisions first. */
1191 unsigned entry_start
= 0;
1192 scc_entry_len
= size
+ 1;
1193 for (unsigned i
= 0; i
< size
;)
1196 for (i
= i
+ 1; i
< size
1197 && (sccstack
[first
+ i
].hash
1198 == sccstack
[first
+ from
].hash
); ++i
)
1200 if (i
- from
< scc_entry_len
)
1202 scc_entry_len
= i
- from
;
1206 for (unsigned i
= 0; i
< scc_entry_len
; ++i
)
1208 scc_entry tem
= sccstack
[first
+ i
];
1209 sccstack
[first
+ i
] = sccstack
[first
+ entry_start
+ i
];
1210 sccstack
[first
+ entry_start
+ i
] = tem
;
1214 /* Write LTO_tree_scc. */
1215 streamer_write_record_start (ob
, LTO_tree_scc
);
1216 streamer_write_uhwi (ob
, size
);
1217 streamer_write_uhwi (ob
, scc_hash
);
1219 /* Write size-1 SCCs without wrapping them inside SCC bundles.
1220 All INTEGER_CSTs need to be handled this way as we need
1221 their type to materialize them. Also builtins are handled
1223 ??? We still wrap these in LTO_tree_scc so at the
1224 input side we can properly identify the tree we want
1225 to ultimatively return. */
1226 size_t old_len
= ob
->writer_cache
->nodes
.length ();
1228 lto_output_tree_1 (ob
, expr
, scc_hash
, ref_p
, this_ref_p
);
1231 /* Write the size of the SCC entry candidates. */
1232 streamer_write_uhwi (ob
, scc_entry_len
);
1234 /* Write all headers and populate the streamer cache. */
1235 for (unsigned i
= 0; i
< size
; ++i
)
1237 hashval_t hash
= sccstack
[first
+i
].hash
;
1238 tree t
= sccstack
[first
+i
].t
;
1239 bool exists_p
= streamer_tree_cache_insert (ob
->writer_cache
,
1241 gcc_assert (!exists_p
);
1243 if (!lto_is_streamable (t
))
1244 internal_error ("tree code %qs is not supported "
1246 get_tree_code_name (TREE_CODE (t
)));
1248 gcc_checking_assert (!streamer_handle_as_builtin_p (t
));
1250 /* Write the header, containing everything needed to
1251 materialize EXPR on the reading side. */
1252 streamer_write_tree_header (ob
, t
);
1255 /* Write the bitpacks and tree references. */
1256 for (unsigned i
= 0; i
< size
; ++i
)
1258 lto_write_tree_1 (ob
, sccstack
[first
+i
].t
, ref_p
);
1260 /* Mark the end of the tree. */
1261 streamer_write_zero (ob
);
1264 gcc_assert (old_len
+ size
== ob
->writer_cache
->nodes
.length ());
1266 /* Finally truncate the vector. */
1267 sccstack
.truncate (first
);
1270 from_state
->low
= MIN (from_state
->low
, cstate
->low
);
1275 from_state
->low
= MIN (from_state
->low
, cstate
->low
);
1277 gcc_checking_assert (from_state
);
1278 if (cstate
->dfsnum
< from_state
->dfsnum
)
1279 from_state
->low
= MIN (cstate
->dfsnum
, from_state
->low
);
1283 /* Emit the physical representation of tree node EXPR to output block
1284 OB. If THIS_REF_P is true, the leaves of EXPR are emitted as references
1285 via lto_output_tree_ref. REF_P is used for streaming siblings of EXPR. */
1288 lto_output_tree (struct output_block
*ob
, tree expr
,
1289 bool ref_p
, bool this_ref_p
)
1294 if (expr
== NULL_TREE
)
1296 streamer_write_record_start (ob
, LTO_null
);
1300 if (this_ref_p
&& tree_is_indexable (expr
))
1302 lto_output_tree_ref (ob
, expr
);
1306 existed_p
= streamer_tree_cache_lookup (ob
->writer_cache
, expr
, &ix
);
1309 /* If a node has already been streamed out, make sure that
1310 we don't write it more than once. Otherwise, the reader
1311 will instantiate two different nodes for the same object. */
1312 streamer_write_record_start (ob
, LTO_tree_pickle_reference
);
1313 streamer_write_uhwi (ob
, ix
);
1314 streamer_write_enum (ob
->main_stream
, LTO_tags
, LTO_NUM_TAGS
,
1315 lto_tree_code_to_tag (TREE_CODE (expr
)));
1316 lto_stats
.num_pickle_refs_output
++;
1320 /* This is the first time we see EXPR, write all reachable
1322 static bool in_dfs_walk
;
1324 /* Protect against recursion which means disconnect between
1325 what tree edges we walk in the DFS walk and what edges
1327 gcc_assert (!in_dfs_walk
);
1329 /* Start the DFS walk. */
1330 /* Save ob state ... */
1333 sccstate
= pointer_map_create ();
1334 gcc_obstack_init (&sccstate_obstack
);
1336 DFS_write_tree (ob
, NULL
, expr
, ref_p
, this_ref_p
);
1337 sccstack
.release ();
1338 pointer_map_destroy (sccstate
);
1339 obstack_free (&sccstate_obstack
, NULL
);
1340 in_dfs_walk
= false;
1342 /* Finally append a reference to the tree we were writing.
1343 ??? If expr ended up as a singleton we could have
1344 inlined it here and avoid outputting a reference. */
1345 existed_p
= streamer_tree_cache_lookup (ob
->writer_cache
, expr
, &ix
);
1346 gcc_assert (existed_p
);
1347 streamer_write_record_start (ob
, LTO_tree_pickle_reference
);
1348 streamer_write_uhwi (ob
, ix
);
1349 streamer_write_enum (ob
->main_stream
, LTO_tags
, LTO_NUM_TAGS
,
1350 lto_tree_code_to_tag (TREE_CODE (expr
)));
1351 lto_stats
.num_pickle_refs_output
++;
1356 /* Output to OB a list of try/catch handlers starting with FIRST. */
1359 output_eh_try_list (struct output_block
*ob
, eh_catch first
)
1363 for (n
= first
; n
; n
= n
->next_catch
)
1365 streamer_write_record_start (ob
, LTO_eh_catch
);
1366 stream_write_tree (ob
, n
->type_list
, true);
1367 stream_write_tree (ob
, n
->filter_list
, true);
1368 stream_write_tree (ob
, n
->label
, true);
1371 streamer_write_record_start (ob
, LTO_null
);
1375 /* Output EH region R in function FN to OB. CURR_RN is the slot index
1376 that is being emitted in FN->EH->REGION_ARRAY. This is used to
1377 detect EH region sharing. */
1380 output_eh_region (struct output_block
*ob
, eh_region r
)
1386 streamer_write_record_start (ob
, LTO_null
);
1390 if (r
->type
== ERT_CLEANUP
)
1391 tag
= LTO_ert_cleanup
;
1392 else if (r
->type
== ERT_TRY
)
1394 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
1395 tag
= LTO_ert_allowed_exceptions
;
1396 else if (r
->type
== ERT_MUST_NOT_THROW
)
1397 tag
= LTO_ert_must_not_throw
;
1401 streamer_write_record_start (ob
, tag
);
1402 streamer_write_hwi (ob
, r
->index
);
1405 streamer_write_hwi (ob
, r
->outer
->index
);
1407 streamer_write_zero (ob
);
1410 streamer_write_hwi (ob
, r
->inner
->index
);
1412 streamer_write_zero (ob
);
1415 streamer_write_hwi (ob
, r
->next_peer
->index
);
1417 streamer_write_zero (ob
);
1419 if (r
->type
== ERT_TRY
)
1421 output_eh_try_list (ob
, r
->u
.eh_try
.first_catch
);
1423 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
1425 stream_write_tree (ob
, r
->u
.allowed
.type_list
, true);
1426 stream_write_tree (ob
, r
->u
.allowed
.label
, true);
1427 streamer_write_uhwi (ob
, r
->u
.allowed
.filter
);
1429 else if (r
->type
== ERT_MUST_NOT_THROW
)
1431 stream_write_tree (ob
, r
->u
.must_not_throw
.failure_decl
, true);
1432 bitpack_d bp
= bitpack_create (ob
->main_stream
);
1433 stream_output_location (ob
, &bp
, r
->u
.must_not_throw
.failure_loc
);
1434 streamer_write_bitpack (&bp
);
1437 if (r
->landing_pads
)
1438 streamer_write_hwi (ob
, r
->landing_pads
->index
);
1440 streamer_write_zero (ob
);
1444 /* Output landing pad LP to OB. */
1447 output_eh_lp (struct output_block
*ob
, eh_landing_pad lp
)
1451 streamer_write_record_start (ob
, LTO_null
);
1455 streamer_write_record_start (ob
, LTO_eh_landing_pad
);
1456 streamer_write_hwi (ob
, lp
->index
);
1458 streamer_write_hwi (ob
, lp
->next_lp
->index
);
1460 streamer_write_zero (ob
);
1463 streamer_write_hwi (ob
, lp
->region
->index
);
1465 streamer_write_zero (ob
);
1467 stream_write_tree (ob
, lp
->post_landing_pad
, true);
1471 /* Output the existing eh_table to OB. */
1474 output_eh_regions (struct output_block
*ob
, struct function
*fn
)
1476 if (fn
->eh
&& fn
->eh
->region_tree
)
1483 streamer_write_record_start (ob
, LTO_eh_table
);
1485 /* Emit the index of the root of the EH region tree. */
1486 streamer_write_hwi (ob
, fn
->eh
->region_tree
->index
);
1488 /* Emit all the EH regions in the region array. */
1489 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->region_array
));
1490 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->region_array
, i
, eh
)
1491 output_eh_region (ob
, eh
);
1493 /* Emit all landing pads. */
1494 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->lp_array
));
1495 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->lp_array
, i
, lp
)
1496 output_eh_lp (ob
, lp
);
1498 /* Emit all the runtime type data. */
1499 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->ttype_data
));
1500 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->ttype_data
, i
, ttype
)
1501 stream_write_tree (ob
, ttype
, true);
1503 /* Emit the table of action chains. */
1504 if (targetm
.arm_eabi_unwinder
)
1507 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->ehspec_data
.arm_eabi
));
1508 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->ehspec_data
.arm_eabi
, i
, t
)
1509 stream_write_tree (ob
, t
, true);
1514 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->ehspec_data
.other
));
1515 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->ehspec_data
.other
, i
, c
)
1516 streamer_write_char_stream (ob
->main_stream
, c
);
1520 /* The LTO_null either terminates the record or indicates that there
1521 are no eh_records at all. */
1522 streamer_write_record_start (ob
, LTO_null
);
1526 /* Output all of the active ssa names to the ssa_names stream. */
1529 output_ssa_names (struct output_block
*ob
, struct function
*fn
)
1531 unsigned int i
, len
;
1533 len
= vec_safe_length (SSANAMES (fn
));
1534 streamer_write_uhwi (ob
, len
);
1536 for (i
= 1; i
< len
; i
++)
1538 tree ptr
= (*SSANAMES (fn
))[i
];
1540 if (ptr
== NULL_TREE
1541 || SSA_NAME_IN_FREE_LIST (ptr
)
1542 || virtual_operand_p (ptr
))
1545 streamer_write_uhwi (ob
, i
);
1546 streamer_write_char_stream (ob
->main_stream
,
1547 SSA_NAME_IS_DEFAULT_DEF (ptr
));
1548 if (SSA_NAME_VAR (ptr
))
1549 stream_write_tree (ob
, SSA_NAME_VAR (ptr
), true);
1551 /* ??? This drops SSA_NAME_IDENTIFIER on the floor. */
1552 stream_write_tree (ob
, TREE_TYPE (ptr
), true);
1555 streamer_write_zero (ob
);
1559 /* Output the cfg. */
1562 output_cfg (struct output_block
*ob
, struct function
*fn
)
1564 struct lto_output_stream
*tmp_stream
= ob
->main_stream
;
1567 ob
->main_stream
= ob
->cfg_stream
;
1569 streamer_write_enum (ob
->main_stream
, profile_status_d
, PROFILE_LAST
,
1570 profile_status_for_function (fn
));
1572 /* Output the number of the highest basic block. */
1573 streamer_write_uhwi (ob
, last_basic_block_for_function (fn
));
1575 FOR_ALL_BB_FN (bb
, fn
)
1580 streamer_write_hwi (ob
, bb
->index
);
1582 /* Output the successors and the edge flags. */
1583 streamer_write_uhwi (ob
, EDGE_COUNT (bb
->succs
));
1584 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1586 streamer_write_uhwi (ob
, e
->dest
->index
);
1587 streamer_write_hwi (ob
, e
->probability
);
1588 streamer_write_gcov_count (ob
, e
->count
);
1589 streamer_write_uhwi (ob
, e
->flags
);
1593 streamer_write_hwi (ob
, -1);
1595 bb
= ENTRY_BLOCK_PTR
;
1598 streamer_write_hwi (ob
, bb
->next_bb
->index
);
1602 streamer_write_hwi (ob
, -1);
1604 /* ??? The cfgloop interface is tied to cfun. */
1605 gcc_assert (cfun
== fn
);
1607 /* Output the number of loops. */
1608 streamer_write_uhwi (ob
, number_of_loops (fn
));
1610 /* Output each loop, skipping the tree root which has number zero. */
1611 for (unsigned i
= 1; i
< number_of_loops (fn
); ++i
)
1613 struct loop
*loop
= get_loop (fn
, i
);
1615 /* Write the index of the loop header. That's enough to rebuild
1616 the loop tree on the reader side. Stream -1 for an unused
1620 streamer_write_hwi (ob
, -1);
1624 streamer_write_hwi (ob
, loop
->header
->index
);
1626 /* Write everything copy_loop_info copies. */
1627 streamer_write_enum (ob
->main_stream
,
1628 loop_estimation
, EST_LAST
, loop
->estimate_state
);
1629 streamer_write_hwi (ob
, loop
->any_upper_bound
);
1630 if (loop
->any_upper_bound
)
1632 streamer_write_uhwi (ob
, loop
->nb_iterations_upper_bound
.low
);
1633 streamer_write_hwi (ob
, loop
->nb_iterations_upper_bound
.high
);
1635 streamer_write_hwi (ob
, loop
->any_estimate
);
1636 if (loop
->any_estimate
)
1638 streamer_write_uhwi (ob
, loop
->nb_iterations_estimate
.low
);
1639 streamer_write_hwi (ob
, loop
->nb_iterations_estimate
.high
);
1643 ob
->main_stream
= tmp_stream
;
1647 /* Create the header in the file using OB. If the section type is for
1648 a function, set FN to the decl for that function. */
1651 produce_asm (struct output_block
*ob
, tree fn
)
1653 enum lto_section_type section_type
= ob
->section_type
;
1654 struct lto_function_header header
;
1656 struct lto_output_stream
*header_stream
;
1658 if (section_type
== LTO_section_function_body
)
1660 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn
));
1661 section_name
= lto_get_section_name (section_type
, name
, NULL
);
1664 section_name
= lto_get_section_name (section_type
, NULL
, NULL
);
1666 lto_begin_section (section_name
, !flag_wpa
);
1667 free (section_name
);
1669 /* The entire header is stream computed here. */
1670 memset (&header
, 0, sizeof (struct lto_function_header
));
1672 /* Write the header. */
1673 header
.lto_header
.major_version
= LTO_major_version
;
1674 header
.lto_header
.minor_version
= LTO_minor_version
;
1676 header
.compressed_size
= 0;
1678 if (section_type
== LTO_section_function_body
)
1679 header
.cfg_size
= ob
->cfg_stream
->total_size
;
1680 header
.main_size
= ob
->main_stream
->total_size
;
1681 header
.string_size
= ob
->string_stream
->total_size
;
1683 header_stream
= XCNEW (struct lto_output_stream
);
1684 lto_output_data_stream (header_stream
, &header
, sizeof header
);
1685 lto_write_stream (header_stream
);
1686 free (header_stream
);
1688 /* Put all of the gimple and the string table out the asm file as a
1690 if (section_type
== LTO_section_function_body
)
1691 lto_write_stream (ob
->cfg_stream
);
1692 lto_write_stream (ob
->main_stream
);
1693 lto_write_stream (ob
->string_stream
);
1699 /* Output the base body of struct function FN using output block OB. */
1702 output_struct_function_base (struct output_block
*ob
, struct function
*fn
)
1704 struct bitpack_d bp
;
1708 /* Output the static chain and non-local goto save area. */
1709 stream_write_tree (ob
, fn
->static_chain_decl
, true);
1710 stream_write_tree (ob
, fn
->nonlocal_goto_save_area
, true);
1712 /* Output all the local variables in the function. */
1713 streamer_write_hwi (ob
, vec_safe_length (fn
->local_decls
));
1714 FOR_EACH_VEC_SAFE_ELT (fn
->local_decls
, i
, t
)
1715 stream_write_tree (ob
, t
, true);
1717 /* Output current IL state of the function. */
1718 streamer_write_uhwi (ob
, fn
->curr_properties
);
1720 /* Write all the attributes for FN. */
1721 bp
= bitpack_create (ob
->main_stream
);
1722 bp_pack_value (&bp
, fn
->is_thunk
, 1);
1723 bp_pack_value (&bp
, fn
->has_local_explicit_reg_vars
, 1);
1724 bp_pack_value (&bp
, fn
->returns_pcc_struct
, 1);
1725 bp_pack_value (&bp
, fn
->returns_struct
, 1);
1726 bp_pack_value (&bp
, fn
->can_throw_non_call_exceptions
, 1);
1727 bp_pack_value (&bp
, fn
->can_delete_dead_exceptions
, 1);
1728 bp_pack_value (&bp
, fn
->always_inline_functions_inlined
, 1);
1729 bp_pack_value (&bp
, fn
->after_inlining
, 1);
1730 bp_pack_value (&bp
, fn
->stdarg
, 1);
1731 bp_pack_value (&bp
, fn
->has_nonlocal_label
, 1);
1732 bp_pack_value (&bp
, fn
->calls_alloca
, 1);
1733 bp_pack_value (&bp
, fn
->calls_setjmp
, 1);
1734 bp_pack_value (&bp
, fn
->va_list_fpr_size
, 8);
1735 bp_pack_value (&bp
, fn
->va_list_gpr_size
, 8);
1737 /* Output the function start and end loci. */
1738 stream_output_location (ob
, &bp
, fn
->function_start_locus
);
1739 stream_output_location (ob
, &bp
, fn
->function_end_locus
);
1741 streamer_write_bitpack (&bp
);
1745 /* Output the body of function NODE->DECL. */
1748 output_function (struct cgraph_node
*node
)
1751 struct function
*fn
;
1753 struct output_block
*ob
;
1755 function
= node
->decl
;
1756 fn
= DECL_STRUCT_FUNCTION (function
);
1757 ob
= create_output_block (LTO_section_function_body
);
1759 clear_line_info (ob
);
1760 ob
->cgraph_node
= node
;
1762 gcc_assert (current_function_decl
== NULL_TREE
&& cfun
== NULL
);
1764 /* Set current_function_decl and cfun. */
1767 /* Make string 0 be a NULL string. */
1768 streamer_write_char_stream (ob
->string_stream
, 0);
1770 streamer_write_record_start (ob
, LTO_function
);
1772 /* Output decls for parameters and args. */
1773 stream_write_tree (ob
, DECL_RESULT (function
), true);
1774 streamer_write_chain (ob
, DECL_ARGUMENTS (function
), true);
1776 /* Output DECL_INITIAL for the function, which contains the tree of
1778 stream_write_tree (ob
, DECL_INITIAL (function
), true);
1780 /* We also stream abstract functions where we stream only stuff needed for
1782 if (gimple_has_body_p (function
))
1784 streamer_write_uhwi (ob
, 1);
1785 output_struct_function_base (ob
, fn
);
1787 /* Output all the SSA names used in the function. */
1788 output_ssa_names (ob
, fn
);
1790 /* Output any exception handling regions. */
1791 output_eh_regions (ob
, fn
);
1794 /* We will renumber the statements. The code that does this uses
1795 the same ordering that we use for serializing them so we can use
1796 the same code on the other end and not have to write out the
1797 statement numbers. We do not assign UIDs to PHIs here because
1798 virtual PHIs get re-computed on-the-fly which would make numbers
1800 set_gimple_stmt_max_uid (cfun
, 0);
1803 gimple_stmt_iterator gsi
;
1804 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1806 gimple stmt
= gsi_stmt (gsi
);
1808 /* Virtual PHIs are not going to be streamed. */
1809 if (!virtual_operand_p (gimple_phi_result (stmt
)))
1810 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
1812 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1814 gimple stmt
= gsi_stmt (gsi
);
1815 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
1818 /* To avoid keeping duplicate gimple IDs in the statements, renumber
1819 virtual phis now. */
1822 gimple_stmt_iterator gsi
;
1823 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1825 gimple stmt
= gsi_stmt (gsi
);
1826 if (virtual_operand_p (gimple_phi_result (stmt
)))
1827 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
1831 /* Output the code for the function. */
1832 FOR_ALL_BB_FN (bb
, fn
)
1833 output_bb (ob
, bb
, fn
);
1835 /* The terminator for this function. */
1836 streamer_write_record_start (ob
, LTO_null
);
1838 output_cfg (ob
, fn
);
1843 streamer_write_uhwi (ob
, 0);
1845 /* Create a section to hold the pickled output of this function. */
1846 produce_asm (ob
, function
);
1848 destroy_output_block (ob
);
1852 /* Emit toplevel asms. */
1855 lto_output_toplevel_asms (void)
1857 struct output_block
*ob
;
1858 struct asm_node
*can
;
1860 struct lto_output_stream
*header_stream
;
1861 struct lto_asm_header header
;
1866 ob
= create_output_block (LTO_section_asm
);
1868 /* Make string 0 be a NULL string. */
1869 streamer_write_char_stream (ob
->string_stream
, 0);
1871 for (can
= asm_nodes
; can
; can
= can
->next
)
1873 streamer_write_string_cst (ob
, ob
->main_stream
, can
->asm_str
);
1874 streamer_write_hwi (ob
, can
->order
);
1877 streamer_write_string_cst (ob
, ob
->main_stream
, NULL_TREE
);
1879 section_name
= lto_get_section_name (LTO_section_asm
, NULL
, NULL
);
1880 lto_begin_section (section_name
, !flag_wpa
);
1881 free (section_name
);
1883 /* The entire header stream is computed here. */
1884 memset (&header
, 0, sizeof (header
));
1886 /* Write the header. */
1887 header
.lto_header
.major_version
= LTO_major_version
;
1888 header
.lto_header
.minor_version
= LTO_minor_version
;
1890 header
.main_size
= ob
->main_stream
->total_size
;
1891 header
.string_size
= ob
->string_stream
->total_size
;
1893 header_stream
= XCNEW (struct lto_output_stream
);
1894 lto_output_data_stream (header_stream
, &header
, sizeof (header
));
1895 lto_write_stream (header_stream
);
1896 free (header_stream
);
1898 /* Put all of the gimple and the string table out the asm file as a
1900 lto_write_stream (ob
->main_stream
);
1901 lto_write_stream (ob
->string_stream
);
1905 destroy_output_block (ob
);
1909 /* Copy the function body of NODE without deserializing. */
1912 copy_function (struct cgraph_node
*node
)
1914 tree function
= node
->decl
;
1915 struct lto_file_decl_data
*file_data
= node
->lto_file_data
;
1916 struct lto_output_stream
*output_stream
= XCNEW (struct lto_output_stream
);
1919 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function
));
1920 char *section_name
=
1921 lto_get_section_name (LTO_section_function_body
, name
, NULL
);
1923 struct lto_in_decl_state
*in_state
;
1924 struct lto_out_decl_state
*out_state
= lto_get_out_decl_state ();
1926 lto_begin_section (section_name
, !flag_wpa
);
1927 free (section_name
);
1929 /* We may have renamed the declaration, e.g., a static function. */
1930 name
= lto_get_decl_name_mapping (file_data
, name
);
1932 data
= lto_get_section_data (file_data
, LTO_section_function_body
,
1936 /* Do a bit copy of the function body. */
1937 lto_output_data_stream (output_stream
, data
, len
);
1938 lto_write_stream (output_stream
);
1942 lto_get_function_in_decl_state (node
->lto_file_data
, function
);
1943 gcc_assert (in_state
);
1945 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
1947 size_t n
= in_state
->streams
[i
].size
;
1948 tree
*trees
= in_state
->streams
[i
].trees
;
1949 struct lto_tree_ref_encoder
*encoder
= &(out_state
->streams
[i
]);
1951 /* The out state must have the same indices and the in state.
1952 So just copy the vector. All the encoders in the in state
1953 must be empty where we reach here. */
1954 gcc_assert (lto_tree_ref_encoder_size (encoder
) == 0);
1955 encoder
->trees
.reserve_exact (n
);
1956 for (j
= 0; j
< n
; j
++)
1957 encoder
->trees
.safe_push (trees
[j
]);
1960 lto_free_section_data (file_data
, LTO_section_function_body
, name
,
1962 free (output_stream
);
1967 /* Main entry point from the pass manager. */
1972 struct lto_out_decl_state
*decl_state
;
1973 #ifdef ENABLE_CHECKING
1974 bitmap output
= lto_bitmap_alloc ();
1977 lto_symtab_encoder_t encoder
= lto_get_out_decl_state ()->symtab_node_encoder
;
1979 /* Initialize the streamer. */
1980 lto_streamer_init ();
1982 n_nodes
= lto_symtab_encoder_size (encoder
);
1983 /* Process only the functions with bodies. */
1984 for (i
= 0; i
< n_nodes
; i
++)
1986 symtab_node
*snode
= lto_symtab_encoder_deref (encoder
, i
);
1987 cgraph_node
*node
= dyn_cast
<cgraph_node
> (snode
);
1989 && lto_symtab_encoder_encode_body_p (encoder
, node
)
1992 #ifdef ENABLE_CHECKING
1993 gcc_assert (!bitmap_bit_p (output
, DECL_UID (node
->decl
)));
1994 bitmap_set_bit (output
, DECL_UID (node
->decl
));
1996 decl_state
= lto_new_out_decl_state ();
1997 lto_push_out_decl_state (decl_state
);
1998 if (gimple_has_body_p (node
->decl
) || !flag_wpa
)
1999 output_function (node
);
2001 copy_function (node
);
2002 gcc_assert (lto_get_out_decl_state () == decl_state
);
2003 lto_pop_out_decl_state ();
2004 lto_record_function_out_decl_state (node
->decl
, decl_state
);
2008 /* Emit the callgraph after emitting function bodies. This needs to
2009 be done now to make sure that all the statements in every function
2010 have been renumbered so that edges can be associated with call
2011 statements using the statement UIDs. */
2014 #ifdef ENABLE_CHECKING
2015 lto_bitmap_free (output
);
2021 const pass_data pass_data_ipa_lto_gimple_out
=
2023 IPA_PASS
, /* type */
2024 "lto_gimple_out", /* name */
2025 OPTGROUP_NONE
, /* optinfo_flags */
2026 true, /* has_gate */
2027 false, /* has_execute */
2028 TV_IPA_LTO_GIMPLE_OUT
, /* tv_id */
2029 0, /* properties_required */
2030 0, /* properties_provided */
2031 0, /* properties_destroyed */
2032 0, /* todo_flags_start */
2033 0, /* todo_flags_finish */
2036 class pass_ipa_lto_gimple_out
: public ipa_opt_pass_d
2039 pass_ipa_lto_gimple_out (gcc::context
*ctxt
)
2040 : ipa_opt_pass_d (pass_data_ipa_lto_gimple_out
, ctxt
,
2041 NULL
, /* generate_summary */
2042 lto_output
, /* write_summary */
2043 NULL
, /* read_summary */
2044 lto_output
, /* write_optimization_summary */
2045 NULL
, /* read_optimization_summary */
2046 NULL
, /* stmt_fixup */
2047 0, /* function_transform_todo_flags_start */
2048 NULL
, /* function_transform */
2049 NULL
) /* variable_transform */
2052 /* opt_pass methods: */
2053 bool gate () { return gate_lto_out (); }
2055 }; // class pass_ipa_lto_gimple_out
2060 make_pass_ipa_lto_gimple_out (gcc::context
*ctxt
)
2062 return new pass_ipa_lto_gimple_out (ctxt
);
2066 /* Write each node in encoded by ENCODER to OB, as well as those reachable
2067 from it and required for correct representation of its semantics.
2068 Each node in ENCODER must be a global declaration or a type. A node
2069 is written only once, even if it appears multiple times in the
2070 vector. Certain transitively-reachable nodes, such as those
2071 representing expressions, may be duplicated, but such nodes
2072 must not appear in ENCODER itself. */
2075 write_global_stream (struct output_block
*ob
,
2076 struct lto_tree_ref_encoder
*encoder
)
2080 const size_t size
= lto_tree_ref_encoder_size (encoder
);
2082 for (index
= 0; index
< size
; index
++)
2084 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2085 if (!streamer_tree_cache_lookup (ob
->writer_cache
, t
, NULL
))
2086 stream_write_tree (ob
, t
, false);
2091 /* Write a sequence of indices into the globals vector corresponding
2092 to the trees in ENCODER. These are used by the reader to map the
2093 indices used to refer to global entities within function bodies to
2097 write_global_references (struct output_block
*ob
,
2098 struct lto_output_stream
*ref_stream
,
2099 struct lto_tree_ref_encoder
*encoder
)
2103 const uint32_t size
= lto_tree_ref_encoder_size (encoder
);
2105 /* Write size as 32-bit unsigned. */
2106 lto_output_data_stream (ref_stream
, &size
, sizeof (int32_t));
2108 for (index
= 0; index
< size
; index
++)
2112 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2113 streamer_tree_cache_lookup (ob
->writer_cache
, t
, &slot_num
);
2114 gcc_assert (slot_num
!= (unsigned)-1);
2115 lto_output_data_stream (ref_stream
, &slot_num
, sizeof slot_num
);
2120 /* Write all the streams in an lto_out_decl_state STATE using
2121 output block OB and output stream OUT_STREAM. */
2124 lto_output_decl_state_streams (struct output_block
*ob
,
2125 struct lto_out_decl_state
*state
)
2129 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2130 write_global_stream (ob
, &state
->streams
[i
]);
2134 /* Write all the references in an lto_out_decl_state STATE using
2135 output block OB and output stream OUT_STREAM. */
2138 lto_output_decl_state_refs (struct output_block
*ob
,
2139 struct lto_output_stream
*out_stream
,
2140 struct lto_out_decl_state
*state
)
2146 /* Write reference to FUNCTION_DECL. If there is not function,
2147 write reference to void_type_node. */
2148 decl
= (state
->fn_decl
) ? state
->fn_decl
: void_type_node
;
2149 streamer_tree_cache_lookup (ob
->writer_cache
, decl
, &ref
);
2150 gcc_assert (ref
!= (unsigned)-1);
2151 lto_output_data_stream (out_stream
, &ref
, sizeof (uint32_t));
2153 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2154 write_global_references (ob
, out_stream
, &state
->streams
[i
]);
2158 /* Return the written size of STATE. */
2161 lto_out_decl_state_written_size (struct lto_out_decl_state
*state
)
2166 size
= sizeof (int32_t); /* fn_ref. */
2167 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2169 size
+= sizeof (int32_t); /* vector size. */
2170 size
+= (lto_tree_ref_encoder_size (&state
->streams
[i
])
2171 * sizeof (int32_t));
2177 /* Write symbol T into STREAM in CACHE. SEEN specifies symbols we wrote
2181 write_symbol (struct streamer_tree_cache_d
*cache
,
2182 struct lto_output_stream
*stream
,
2183 tree t
, struct pointer_set_t
*seen
, bool alias
)
2186 enum gcc_plugin_symbol_kind kind
;
2187 enum gcc_plugin_symbol_visibility visibility
;
2189 unsigned HOST_WIDEST_INT size
;
2193 /* None of the following kinds of symbols are needed in the
2195 if (!TREE_PUBLIC (t
)
2196 || is_builtin_fn (t
)
2197 || DECL_ABSTRACT (t
)
2198 || (TREE_CODE (t
) == VAR_DECL
&& DECL_HARD_REGISTER (t
)))
2200 gcc_assert (TREE_CODE (t
) != RESULT_DECL
);
2202 gcc_assert (TREE_CODE (t
) == VAR_DECL
2203 || TREE_CODE (t
) == FUNCTION_DECL
);
2205 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t
));
2207 /* This behaves like assemble_name_raw in varasm.c, performing the
2208 same name manipulations that ASM_OUTPUT_LABELREF does. */
2209 name
= IDENTIFIER_POINTER ((*targetm
.asm_out
.mangle_assembler_name
) (name
));
2211 if (pointer_set_contains (seen
, name
))
2213 pointer_set_insert (seen
, name
);
2215 streamer_tree_cache_lookup (cache
, t
, &slot_num
);
2216 gcc_assert (slot_num
!= (unsigned)-1);
2218 if (DECL_EXTERNAL (t
))
2221 kind
= GCCPK_WEAKUNDEF
;
2228 kind
= GCCPK_WEAKDEF
;
2229 else if (DECL_COMMON (t
))
2230 kind
= GCCPK_COMMON
;
2234 /* When something is defined, it should have node attached. */
2235 gcc_assert (alias
|| TREE_CODE (t
) != VAR_DECL
2236 || varpool_get_node (t
)->definition
);
2237 gcc_assert (alias
|| TREE_CODE (t
) != FUNCTION_DECL
2238 || (cgraph_get_node (t
)
2239 && cgraph_get_node (t
)->definition
));
2242 /* Imitate what default_elf_asm_output_external do.
2243 When symbol is external, we need to output it with DEFAULT visibility
2244 when compiling with -fvisibility=default, while with HIDDEN visibility
2245 when symbol has attribute (visibility("hidden")) specified.
2246 targetm.binds_local_p check DECL_VISIBILITY_SPECIFIED and gets this
2249 if (DECL_EXTERNAL (t
)
2250 && !targetm
.binds_local_p (t
))
2251 visibility
= GCCPV_DEFAULT
;
2253 switch (DECL_VISIBILITY (t
))
2255 case VISIBILITY_DEFAULT
:
2256 visibility
= GCCPV_DEFAULT
;
2258 case VISIBILITY_PROTECTED
:
2259 visibility
= GCCPV_PROTECTED
;
2261 case VISIBILITY_HIDDEN
:
2262 visibility
= GCCPV_HIDDEN
;
2264 case VISIBILITY_INTERNAL
:
2265 visibility
= GCCPV_INTERNAL
;
2269 if (kind
== GCCPK_COMMON
2270 && DECL_SIZE_UNIT (t
)
2271 && TREE_CODE (DECL_SIZE_UNIT (t
)) == INTEGER_CST
)
2272 size
= TREE_INT_CST_LOW (DECL_SIZE_UNIT (t
));
2276 if (DECL_ONE_ONLY (t
))
2277 comdat
= IDENTIFIER_POINTER (DECL_COMDAT_GROUP (t
));
2281 lto_output_data_stream (stream
, name
, strlen (name
) + 1);
2282 lto_output_data_stream (stream
, comdat
, strlen (comdat
) + 1);
2283 c
= (unsigned char) kind
;
2284 lto_output_data_stream (stream
, &c
, 1);
2285 c
= (unsigned char) visibility
;
2286 lto_output_data_stream (stream
, &c
, 1);
2287 lto_output_data_stream (stream
, &size
, 8);
2288 lto_output_data_stream (stream
, &slot_num
, 4);
2291 /* Return true if NODE should appear in the plugin symbol table. */
2294 output_symbol_p (symtab_node
*node
)
2296 struct cgraph_node
*cnode
;
2297 if (!symtab_real_symbol_p (node
))
2299 /* We keep external functions in symtab for sake of inlining
2300 and devirtualization. We do not want to see them in symbol table as
2301 references unless they are really used. */
2302 cnode
= dyn_cast
<cgraph_node
> (node
);
2303 if (cnode
&& (!node
->definition
|| DECL_EXTERNAL (cnode
->decl
))
2307 /* Ignore all references from external vars initializers - they are not really
2308 part of the compilation unit until they are used by folding. Some symbols,
2309 like references to external construction vtables can not be referred to at all.
2310 We decide this at can_refer_decl_in_current_unit_p. */
2311 if (!node
->definition
|| DECL_EXTERNAL (node
->decl
))
2314 struct ipa_ref
*ref
;
2315 for (i
= 0; ipa_ref_list_referring_iterate (&node
->ref_list
,
2318 if (ref
->use
== IPA_REF_ALIAS
)
2320 if (is_a
<cgraph_node
> (ref
->referring
))
2322 if (!DECL_EXTERNAL (ref
->referring
->decl
))
2331 /* Write an IL symbol table to OB.
2332 SET and VSET are cgraph/varpool node sets we are outputting. */
2335 produce_symtab (struct output_block
*ob
)
2337 struct streamer_tree_cache_d
*cache
= ob
->writer_cache
;
2338 char *section_name
= lto_get_section_name (LTO_section_symtab
, NULL
, NULL
);
2339 struct pointer_set_t
*seen
;
2340 struct lto_output_stream stream
;
2341 lto_symtab_encoder_t encoder
= ob
->decl_state
->symtab_node_encoder
;
2342 lto_symtab_encoder_iterator lsei
;
2344 lto_begin_section (section_name
, false);
2345 free (section_name
);
2347 seen
= pointer_set_create ();
2348 memset (&stream
, 0, sizeof (stream
));
2350 /* Write the symbol table.
2351 First write everything defined and then all declarations.
2352 This is necessary to handle cases where we have duplicated symbols. */
2353 for (lsei
= lsei_start (encoder
);
2354 !lsei_end_p (lsei
); lsei_next (&lsei
))
2356 symtab_node
*node
= lsei_node (lsei
);
2358 if (!output_symbol_p (node
) || DECL_EXTERNAL (node
->decl
))
2360 write_symbol (cache
, &stream
, node
->decl
, seen
, false);
2362 for (lsei
= lsei_start (encoder
);
2363 !lsei_end_p (lsei
); lsei_next (&lsei
))
2365 symtab_node
*node
= lsei_node (lsei
);
2367 if (!output_symbol_p (node
) || !DECL_EXTERNAL (node
->decl
))
2369 write_symbol (cache
, &stream
, node
->decl
, seen
, false);
2372 lto_write_stream (&stream
);
2373 pointer_set_destroy (seen
);
2379 /* This pass is run after all of the functions are serialized and all
2380 of the IPA passes have written their serialized forms. This pass
2381 causes the vector of all of the global decls and types used from
2382 this file to be written in to a section that can then be read in to
2383 recover these on other side. */
2386 produce_asm_for_decls (void)
2388 struct lto_out_decl_state
*out_state
;
2389 struct lto_out_decl_state
*fn_out_state
;
2390 struct lto_decl_header header
;
2392 struct output_block
*ob
;
2393 struct lto_output_stream
*header_stream
, *decl_state_stream
;
2394 unsigned idx
, num_fns
;
2395 size_t decl_state_size
;
2396 int32_t num_decl_states
;
2398 ob
= create_output_block (LTO_section_decls
);
2401 memset (&header
, 0, sizeof (struct lto_decl_header
));
2403 section_name
= lto_get_section_name (LTO_section_decls
, NULL
, NULL
);
2404 lto_begin_section (section_name
, !flag_wpa
);
2405 free (section_name
);
2407 /* Make string 0 be a NULL string. */
2408 streamer_write_char_stream (ob
->string_stream
, 0);
2410 gcc_assert (!alias_pairs
);
2412 /* Write the global symbols. */
2413 out_state
= lto_get_out_decl_state ();
2414 num_fns
= lto_function_decl_states
.length ();
2415 lto_output_decl_state_streams (ob
, out_state
);
2416 for (idx
= 0; idx
< num_fns
; idx
++)
2419 lto_function_decl_states
[idx
];
2420 lto_output_decl_state_streams (ob
, fn_out_state
);
2423 header
.lto_header
.major_version
= LTO_major_version
;
2424 header
.lto_header
.minor_version
= LTO_minor_version
;
2426 /* Currently not used. This field would allow us to preallocate
2427 the globals vector, so that it need not be resized as it is extended. */
2428 header
.num_nodes
= -1;
2430 /* Compute the total size of all decl out states. */
2431 decl_state_size
= sizeof (int32_t);
2432 decl_state_size
+= lto_out_decl_state_written_size (out_state
);
2433 for (idx
= 0; idx
< num_fns
; idx
++)
2436 lto_function_decl_states
[idx
];
2437 decl_state_size
+= lto_out_decl_state_written_size (fn_out_state
);
2439 header
.decl_state_size
= decl_state_size
;
2441 header
.main_size
= ob
->main_stream
->total_size
;
2442 header
.string_size
= ob
->string_stream
->total_size
;
2444 header_stream
= XCNEW (struct lto_output_stream
);
2445 lto_output_data_stream (header_stream
, &header
, sizeof header
);
2446 lto_write_stream (header_stream
);
2447 free (header_stream
);
2449 /* Write the main out-decl state, followed by out-decl states of
2451 decl_state_stream
= XCNEW (struct lto_output_stream
);
2452 num_decl_states
= num_fns
+ 1;
2453 lto_output_data_stream (decl_state_stream
, &num_decl_states
,
2454 sizeof (num_decl_states
));
2455 lto_output_decl_state_refs (ob
, decl_state_stream
, out_state
);
2456 for (idx
= 0; idx
< num_fns
; idx
++)
2459 lto_function_decl_states
[idx
];
2460 lto_output_decl_state_refs (ob
, decl_state_stream
, fn_out_state
);
2462 lto_write_stream (decl_state_stream
);
2463 free (decl_state_stream
);
2465 lto_write_stream (ob
->main_stream
);
2466 lto_write_stream (ob
->string_stream
);
2470 /* Write the symbol table. It is used by linker to determine dependencies
2471 and thus we can skip it for WPA. */
2473 produce_symtab (ob
);
2475 /* Write command line opts. */
2476 lto_write_options ();
2478 /* Deallocate memory and clean up. */
2479 for (idx
= 0; idx
< num_fns
; idx
++)
2482 lto_function_decl_states
[idx
];
2483 lto_delete_out_decl_state (fn_out_state
);
2485 lto_symtab_encoder_delete (ob
->decl_state
->symtab_node_encoder
);
2486 lto_function_decl_states
.release ();
2487 destroy_output_block (ob
);
2493 const pass_data pass_data_ipa_lto_finish_out
=
2495 IPA_PASS
, /* type */
2496 "lto_decls_out", /* name */
2497 OPTGROUP_NONE
, /* optinfo_flags */
2498 true, /* has_gate */
2499 false, /* has_execute */
2500 TV_IPA_LTO_DECL_OUT
, /* tv_id */
2501 0, /* properties_required */
2502 0, /* properties_provided */
2503 0, /* properties_destroyed */
2504 0, /* todo_flags_start */
2505 0, /* todo_flags_finish */
2508 class pass_ipa_lto_finish_out
: public ipa_opt_pass_d
2511 pass_ipa_lto_finish_out (gcc::context
*ctxt
)
2512 : ipa_opt_pass_d (pass_data_ipa_lto_finish_out
, ctxt
,
2513 NULL
, /* generate_summary */
2514 produce_asm_for_decls
, /* write_summary */
2515 NULL
, /* read_summary */
2516 produce_asm_for_decls
, /* write_optimization_summary */
2517 NULL
, /* read_optimization_summary */
2518 NULL
, /* stmt_fixup */
2519 0, /* function_transform_todo_flags_start */
2520 NULL
, /* function_transform */
2521 NULL
) /* variable_transform */
2524 /* opt_pass methods: */
2525 bool gate () { return gate_lto_out (); }
2527 }; // class pass_ipa_lto_finish_out
2532 make_pass_ipa_lto_finish_out (gcc::context
*ctxt
)
2534 return new pass_ipa_lto_finish_out (ctxt
);