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"
34 #include "tree-flow.h"
35 #include "tree-pass.h"
39 #include "diagnostic-core.h"
42 #include "lto-symtab.h"
43 #include "lto-streamer.h"
44 #include "data-streamer.h"
45 #include "gimple-streamer.h"
46 #include "tree-streamer.h"
47 #include "streamer-hooks.h"
51 /* Clear the line info stored in DATA_IN. */
54 clear_line_info (struct output_block
*ob
)
56 ob
->current_file
= NULL
;
62 /* Create the output block and return it. SECTION_TYPE is
63 LTO_section_function_body or LTO_static_initializer. */
66 create_output_block (enum lto_section_type section_type
)
68 struct output_block
*ob
= XCNEW (struct output_block
);
70 ob
->section_type
= section_type
;
71 ob
->decl_state
= lto_get_out_decl_state ();
72 ob
->main_stream
= XCNEW (struct lto_output_stream
);
73 ob
->string_stream
= XCNEW (struct lto_output_stream
);
74 ob
->writer_cache
= streamer_tree_cache_create (!flag_wpa
);
76 if (section_type
== LTO_section_function_body
)
77 ob
->cfg_stream
= XCNEW (struct lto_output_stream
);
81 ob
->string_hash_table
.create (37);
82 gcc_obstack_init (&ob
->obstack
);
88 /* Destroy the output block OB. */
91 destroy_output_block (struct output_block
*ob
)
93 enum lto_section_type section_type
= ob
->section_type
;
95 ob
->string_hash_table
.dispose ();
97 free (ob
->main_stream
);
98 free (ob
->string_stream
);
99 if (section_type
== LTO_section_function_body
)
100 free (ob
->cfg_stream
);
102 streamer_tree_cache_delete (ob
->writer_cache
);
103 obstack_free (&ob
->obstack
, NULL
);
109 /* Look up NODE in the type table and write the index for it to OB. */
112 output_type_ref (struct output_block
*ob
, tree node
)
114 streamer_write_record_start (ob
, LTO_type_ref
);
115 lto_output_type_ref_index (ob
->decl_state
, ob
->main_stream
, node
);
119 /* Return true if tree node T is written to various tables. For these
120 nodes, we sometimes want to write their phyiscal representation
121 (via lto_output_tree), and sometimes we need to emit an index
122 reference into a table (via lto_output_tree_ref). */
125 tree_is_indexable (tree t
)
127 if (TREE_CODE (t
) == PARM_DECL
)
129 else if (TREE_CODE (t
) == VAR_DECL
&& decl_function_context (t
)
132 else if (TREE_CODE (t
) == DEBUG_EXPR_DECL
)
134 /* Variably modified types need to be streamed alongside function
135 bodies because they can refer to local entities. Together with
136 them we have to localize their members as well.
137 ??? In theory that includes non-FIELD_DECLs as well. */
139 && variably_modified_type_p (t
, NULL_TREE
))
141 else if (TREE_CODE (t
) == FIELD_DECL
142 && variably_modified_type_p (DECL_CONTEXT (t
), NULL_TREE
))
145 return (TYPE_P (t
) || DECL_P (t
) || TREE_CODE (t
) == SSA_NAME
);
149 /* Output info about new location into bitpack BP.
150 After outputting bitpack, lto_output_location_data has
151 to be done to output actual data. */
154 lto_output_location (struct output_block
*ob
, struct bitpack_d
*bp
,
157 expanded_location xloc
;
159 loc
= LOCATION_LOCUS (loc
);
160 bp_pack_value (bp
, loc
== UNKNOWN_LOCATION
, 1);
161 if (loc
== UNKNOWN_LOCATION
)
164 xloc
= expand_location (loc
);
166 bp_pack_value (bp
, ob
->current_file
!= xloc
.file
, 1);
167 bp_pack_value (bp
, ob
->current_line
!= xloc
.line
, 1);
168 bp_pack_value (bp
, ob
->current_col
!= xloc
.column
, 1);
170 if (ob
->current_file
!= xloc
.file
)
171 bp_pack_var_len_unsigned (bp
,
172 streamer_string_index (ob
, xloc
.file
,
173 strlen (xloc
.file
) + 1,
175 ob
->current_file
= xloc
.file
;
177 if (ob
->current_line
!= xloc
.line
)
178 bp_pack_var_len_unsigned (bp
, xloc
.line
);
179 ob
->current_line
= xloc
.line
;
181 if (ob
->current_col
!= xloc
.column
)
182 bp_pack_var_len_unsigned (bp
, xloc
.column
);
183 ob
->current_col
= xloc
.column
;
187 /* If EXPR is an indexable tree node, output a reference to it to
188 output block OB. Otherwise, output the physical representation of
192 lto_output_tree_ref (struct output_block
*ob
, tree expr
)
198 output_type_ref (ob
, expr
);
202 code
= TREE_CODE (expr
);
206 streamer_write_record_start (ob
, LTO_ssa_name_ref
);
207 streamer_write_uhwi (ob
, SSA_NAME_VERSION (expr
));
211 streamer_write_record_start (ob
, LTO_field_decl_ref
);
212 lto_output_field_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
216 streamer_write_record_start (ob
, LTO_function_decl_ref
);
217 lto_output_fn_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
221 case DEBUG_EXPR_DECL
:
222 gcc_assert (decl_function_context (expr
) == NULL
|| TREE_STATIC (expr
));
224 streamer_write_record_start (ob
, LTO_global_decl_ref
);
225 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
229 streamer_write_record_start (ob
, LTO_const_decl_ref
);
230 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
234 gcc_assert (decl_function_context (expr
) == NULL
);
235 streamer_write_record_start (ob
, LTO_imported_decl_ref
);
236 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
240 streamer_write_record_start (ob
, LTO_type_decl_ref
);
241 lto_output_type_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
245 streamer_write_record_start (ob
, LTO_namespace_decl_ref
);
246 lto_output_namespace_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
250 streamer_write_record_start (ob
, LTO_label_decl_ref
);
251 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
255 streamer_write_record_start (ob
, LTO_result_decl_ref
);
256 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
259 case TRANSLATION_UNIT_DECL
:
260 streamer_write_record_start (ob
, LTO_translation_unit_decl_ref
);
261 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
265 /* No other node is indexable, so it should have been handled by
272 /* Return true if EXPR is a tree node that can be written to disk. */
275 lto_is_streamable (tree expr
)
277 enum tree_code code
= TREE_CODE (expr
);
279 /* Notice that we reject SSA_NAMEs as well. We only emit the SSA
280 name version in lto_output_tree_ref (see output_ssa_names). */
281 return !is_lang_specific (expr
)
285 && code
!= MODIFY_EXPR
287 && code
!= TARGET_EXPR
289 && code
!= WITH_CLEANUP_EXPR
290 && code
!= STATEMENT_LIST
291 && code
!= OMP_CLAUSE
292 && (code
== CASE_LABEL_EXPR
294 || TREE_CODE_CLASS (code
) != tcc_statement
);
298 /* For EXPR lookup and return what we want to stream to OB as DECL_INITIAL. */
301 get_symbol_initial_value (struct output_block
*ob
, tree expr
)
303 gcc_checking_assert (DECL_P (expr
)
304 && TREE_CODE (expr
) != FUNCTION_DECL
305 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
);
307 /* Handle DECL_INITIAL for symbols. */
308 tree initial
= DECL_INITIAL (expr
);
309 if (TREE_CODE (expr
) == VAR_DECL
310 && (TREE_STATIC (expr
) || DECL_EXTERNAL (expr
))
311 && !DECL_IN_CONSTANT_POOL (expr
)
314 lto_symtab_encoder_t encoder
;
315 struct varpool_node
*vnode
;
317 encoder
= ob
->decl_state
->symtab_node_encoder
;
318 vnode
= varpool_get_node (expr
);
320 || !lto_symtab_encoder_encode_initializer_p (encoder
,
322 initial
= error_mark_node
;
329 /* Write a physical representation of tree node EXPR to output block
330 OB. If REF_P is true, the leaves of EXPR are emitted as references
331 via lto_output_tree_ref. IX is the index into the streamer cache
332 where EXPR is stored. */
335 lto_write_tree_1 (struct output_block
*ob
, tree expr
, bool ref_p
)
337 /* Pack all the non-pointer fields in EXPR into a bitpack and write
338 the resulting bitpack. */
339 bitpack_d bp
= bitpack_create (ob
->main_stream
);
340 streamer_pack_tree_bitfields (ob
, &bp
, expr
);
341 streamer_write_bitpack (&bp
);
343 /* Write all the pointer fields in EXPR. */
344 streamer_write_tree_body (ob
, expr
, ref_p
);
346 /* Write any LTO-specific data to OB. */
348 && TREE_CODE (expr
) != FUNCTION_DECL
349 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
351 /* Handle DECL_INITIAL for symbols. */
352 tree initial
= get_symbol_initial_value (ob
, expr
);
353 stream_write_tree (ob
, initial
, ref_p
);
357 /* Write a physical representation of tree node EXPR to output block
358 OB. If REF_P is true, the leaves of EXPR are emitted as references
359 via lto_output_tree_ref. IX is the index into the streamer cache
360 where EXPR is stored. */
363 lto_write_tree (struct output_block
*ob
, tree expr
, bool ref_p
)
365 if (!lto_is_streamable (expr
))
366 internal_error ("tree code %qs is not supported in LTO streams",
367 tree_code_name
[TREE_CODE (expr
)]);
369 /* Write the header, containing everything needed to materialize
370 EXPR on the reading side. */
371 streamer_write_tree_header (ob
, expr
);
373 lto_write_tree_1 (ob
, expr
, ref_p
);
375 /* Mark the end of EXPR. */
376 streamer_write_zero (ob
);
379 /* Emit the physical representation of tree node EXPR to output block
380 OB. If THIS_REF_P is true, the leaves of EXPR are emitted as references
381 via lto_output_tree_ref. REF_P is used for streaming siblings of EXPR. */
384 lto_output_tree_1 (struct output_block
*ob
, tree expr
, hashval_t hash
,
385 bool ref_p
, bool this_ref_p
)
389 gcc_checking_assert (expr
!= NULL_TREE
390 && !(this_ref_p
&& tree_is_indexable (expr
)));
392 bool exists_p
= streamer_tree_cache_insert (ob
->writer_cache
,
394 gcc_assert (!exists_p
);
395 if (streamer_handle_as_builtin_p (expr
))
397 /* MD and NORMAL builtins do not need to be written out
398 completely as they are always instantiated by the
399 compiler on startup. The only builtins that need to
400 be written out are BUILT_IN_FRONTEND. For all other
401 builtins, we simply write the class and code. */
402 streamer_write_builtin (ob
, expr
);
404 else if (TREE_CODE (expr
) == INTEGER_CST
405 && !TREE_OVERFLOW (expr
))
407 /* Shared INTEGER_CST nodes are special because they need their
408 original type to be materialized by the reader (to implement
409 TYPE_CACHED_VALUES). */
410 streamer_write_integer_cst (ob
, expr
, ref_p
);
414 /* This is the first time we see EXPR, write its fields
416 lto_write_tree (ob
, expr
, ref_p
);
432 static unsigned int next_dfs_num
;
433 static vec
<scc_entry
> sccstack
;
434 static struct pointer_map_t
*sccstate
;
435 static struct obstack sccstate_obstack
;
438 DFS_write_tree (struct output_block
*ob
, sccs
*from_state
,
439 tree expr
, bool ref_p
, bool this_ref_p
);
441 /* Handle the tree EXPR in the DFS walk with SCC state EXPR_STATE and
442 DFS recurse for all tree edges originating from it. */
445 DFS_write_tree_body (struct output_block
*ob
,
446 tree expr
, sccs
*expr_state
, bool ref_p
)
448 #define DFS_follow_tree_edge(DEST) \
449 DFS_write_tree (ob, expr_state, DEST, ref_p, ref_p)
453 code
= TREE_CODE (expr
);
455 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
457 if (TREE_CODE (expr
) != IDENTIFIER_NODE
)
458 DFS_follow_tree_edge (TREE_TYPE (expr
));
461 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
463 for (unsigned i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
464 DFS_follow_tree_edge (VECTOR_CST_ELT (expr
, i
));
467 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
469 DFS_follow_tree_edge (TREE_REALPART (expr
));
470 DFS_follow_tree_edge (TREE_IMAGPART (expr
));
473 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
475 /* Drop names that were created for anonymous entities. */
477 && TREE_CODE (DECL_NAME (expr
)) == IDENTIFIER_NODE
478 && ANON_AGGRNAME_P (DECL_NAME (expr
)))
481 DFS_follow_tree_edge (DECL_NAME (expr
));
482 DFS_follow_tree_edge (DECL_CONTEXT (expr
));
485 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
487 DFS_follow_tree_edge (DECL_SIZE (expr
));
488 DFS_follow_tree_edge (DECL_SIZE_UNIT (expr
));
490 /* Note, DECL_INITIAL is not handled here. Since DECL_INITIAL needs
491 special handling in LTO, it must be handled by streamer hooks. */
493 DFS_follow_tree_edge (DECL_ATTRIBUTES (expr
));
495 /* Do not follow DECL_ABSTRACT_ORIGIN. We cannot handle debug information
496 for early inlining so drop it on the floor instead of ICEing in
499 if ((TREE_CODE (expr
) == VAR_DECL
500 || TREE_CODE (expr
) == PARM_DECL
)
501 && DECL_HAS_VALUE_EXPR_P (expr
))
502 DFS_follow_tree_edge (DECL_VALUE_EXPR (expr
));
503 if (TREE_CODE (expr
) == VAR_DECL
)
504 DFS_follow_tree_edge (DECL_DEBUG_EXPR (expr
));
507 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
509 if (TREE_CODE (expr
) == FUNCTION_DECL
)
511 for (tree t
= DECL_ARGUMENTS (expr
); t
; t
= TREE_CHAIN (t
))
512 DFS_follow_tree_edge (t
);
513 DFS_follow_tree_edge (DECL_RESULT (expr
));
515 else if (TREE_CODE (expr
) == TYPE_DECL
)
516 DFS_follow_tree_edge (DECL_ORIGINAL_TYPE (expr
));
517 DFS_follow_tree_edge (DECL_VINDEX (expr
));
520 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
522 /* Make sure we don't inadvertently set the assembler name. */
523 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
524 DFS_follow_tree_edge (DECL_ASSEMBLER_NAME (expr
));
525 DFS_follow_tree_edge (DECL_SECTION_NAME (expr
));
526 DFS_follow_tree_edge (DECL_COMDAT_GROUP (expr
));
529 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
531 DFS_follow_tree_edge (DECL_FIELD_OFFSET (expr
));
532 DFS_follow_tree_edge (DECL_BIT_FIELD_TYPE (expr
));
533 DFS_follow_tree_edge (DECL_BIT_FIELD_REPRESENTATIVE (expr
));
534 DFS_follow_tree_edge (DECL_FIELD_BIT_OFFSET (expr
));
535 DFS_follow_tree_edge (DECL_FCONTEXT (expr
));
538 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
540 DFS_follow_tree_edge (DECL_FUNCTION_PERSONALITY (expr
));
541 DFS_follow_tree_edge (DECL_FUNCTION_SPECIFIC_TARGET (expr
));
542 DFS_follow_tree_edge (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr
));
545 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
547 DFS_follow_tree_edge (TYPE_SIZE (expr
));
548 DFS_follow_tree_edge (TYPE_SIZE_UNIT (expr
));
549 DFS_follow_tree_edge (TYPE_ATTRIBUTES (expr
));
550 DFS_follow_tree_edge (TYPE_NAME (expr
));
551 /* Do not follow TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
552 reconstructed during fixup. */
553 /* Do not follow TYPE_NEXT_VARIANT, we reconstruct the variant lists
555 DFS_follow_tree_edge (TYPE_MAIN_VARIANT (expr
));
556 DFS_follow_tree_edge (TYPE_CONTEXT (expr
));
557 /* TYPE_CANONICAL is re-computed during type merging, so no need
558 to follow it here. */
559 DFS_follow_tree_edge (TYPE_STUB_DECL (expr
));
562 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
564 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
565 DFS_follow_tree_edge (TYPE_VALUES (expr
));
566 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
567 DFS_follow_tree_edge (TYPE_DOMAIN (expr
));
568 else if (RECORD_OR_UNION_TYPE_P (expr
))
569 for (tree t
= TYPE_FIELDS (expr
); t
; t
= TREE_CHAIN (t
))
570 DFS_follow_tree_edge (t
);
571 else if (TREE_CODE (expr
) == FUNCTION_TYPE
572 || TREE_CODE (expr
) == METHOD_TYPE
)
573 DFS_follow_tree_edge (TYPE_ARG_TYPES (expr
));
575 if (!POINTER_TYPE_P (expr
))
576 DFS_follow_tree_edge (TYPE_MINVAL (expr
));
577 DFS_follow_tree_edge (TYPE_MAXVAL (expr
));
578 if (RECORD_OR_UNION_TYPE_P (expr
))
579 DFS_follow_tree_edge (TYPE_BINFO (expr
));
582 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
584 DFS_follow_tree_edge (TREE_PURPOSE (expr
));
585 DFS_follow_tree_edge (TREE_VALUE (expr
));
586 DFS_follow_tree_edge (TREE_CHAIN (expr
));
589 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
591 for (int i
= 0; i
< TREE_VEC_LENGTH (expr
); i
++)
592 DFS_follow_tree_edge (TREE_VEC_ELT (expr
, i
));
595 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
597 for (int i
= 0; i
< TREE_OPERAND_LENGTH (expr
); i
++)
598 DFS_follow_tree_edge (TREE_OPERAND (expr
, i
));
599 DFS_follow_tree_edge (TREE_BLOCK (expr
));
602 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
604 for (tree t
= BLOCK_VARS (expr
); t
; t
= TREE_CHAIN (t
))
605 /* ??? FIXME. See also streamer_write_chain. */
606 if (!(VAR_OR_FUNCTION_DECL_P (t
)
607 && DECL_EXTERNAL (t
)))
608 DFS_follow_tree_edge (t
);
610 DFS_follow_tree_edge (BLOCK_SUPERCONTEXT (expr
));
612 /* Follow BLOCK_ABSTRACT_ORIGIN for the limited cases we can
613 handle - those that represent inlined function scopes.
614 For the drop rest them on the floor instead of ICEing
616 if (inlined_function_outer_scope_p (expr
))
618 tree ultimate_origin
= block_ultimate_origin (expr
);
619 DFS_follow_tree_edge (ultimate_origin
);
621 /* Do not follow BLOCK_NONLOCALIZED_VARS. We cannot handle debug
622 information for early inlined BLOCKs so drop it on the floor instead
623 of ICEing in dwarf2out.c. */
625 /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
628 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
629 list is re-constructed from BLOCK_SUPERCONTEXT. */
632 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
637 /* Note that the number of BINFO slots has already been emitted in
638 EXPR's header (see streamer_write_tree_header) because this length
639 is needed to build the empty BINFO node on the reader side. */
640 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr
), i
, t
)
641 DFS_follow_tree_edge (t
);
642 DFS_follow_tree_edge (BINFO_OFFSET (expr
));
643 DFS_follow_tree_edge (BINFO_VTABLE (expr
));
644 DFS_follow_tree_edge (BINFO_VPTR_FIELD (expr
));
646 /* The number of BINFO_BASE_ACCESSES has already been emitted in
647 EXPR's bitfield section. */
648 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (expr
), i
, t
)
649 DFS_follow_tree_edge (t
);
651 DFS_follow_tree_edge (BINFO_INHERITANCE_CHAIN (expr
));
652 DFS_follow_tree_edge (BINFO_SUBVTT_INDEX (expr
));
653 DFS_follow_tree_edge (BINFO_VPTR_INDEX (expr
));
656 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
661 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr
), i
, index
, value
)
663 DFS_follow_tree_edge (index
);
664 DFS_follow_tree_edge (value
);
668 #undef DFS_follow_tree_edge
671 /* Return a hash value for the tree T. */
674 hash_tree (struct streamer_tree_cache_d
*cache
, tree t
)
676 #define visit(SIBLING) \
679 if (SIBLING && streamer_tree_cache_lookup (cache, SIBLING, &ix)) \
680 v = iterative_hash_hashval_t (streamer_tree_cache_get_hash (cache, ix), v); \
684 enum tree_code code
= TREE_CODE (t
);
685 hashval_t v
= iterative_hash_host_wide_int (code
, 0);
688 v
= iterative_hash_host_wide_int (TREE_SIDE_EFFECTS (t
)
689 | (TREE_CONSTANT (t
) << 1)
690 | (TREE_READONLY (t
) << 2)
691 | (TREE_PUBLIC (t
) << 3), v
);
693 v
= iterative_hash_host_wide_int (TREE_ADDRESSABLE (t
)
694 | (TREE_THIS_VOLATILE (t
) << 1), v
);
696 v
= iterative_hash_host_wide_int (DECL_UNSIGNED (t
), v
);
698 v
= iterative_hash_host_wide_int (TYPE_UNSIGNED (t
), v
);
700 v
= iterative_hash_host_wide_int (TYPE_ARTIFICIAL (t
), v
);
702 v
= iterative_hash_host_wide_int (TREE_NO_WARNING (t
), v
);
703 v
= iterative_hash_host_wide_int (TREE_NOTHROW (t
)
704 | (TREE_STATIC (t
) << 1)
705 | (TREE_PROTECTED (t
) << 2)
706 | (TREE_DEPRECATED (t
) << 3), v
);
707 if (code
!= TREE_BINFO
)
708 v
= iterative_hash_host_wide_int (TREE_PRIVATE (t
), v
);
710 v
= iterative_hash_host_wide_int (TYPE_SATURATING (t
)
711 | (TYPE_ADDR_SPACE (t
) << 1), v
);
712 else if (code
== SSA_NAME
)
713 v
= iterative_hash_host_wide_int (SSA_NAME_IS_DEFAULT_DEF (t
), v
);
715 if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
717 v
= iterative_hash_host_wide_int (TREE_INT_CST_LOW (t
), v
);
718 v
= iterative_hash_host_wide_int (TREE_INT_CST_HIGH (t
), v
);
721 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
723 REAL_VALUE_TYPE r
= TREE_REAL_CST (t
);
724 v
= iterative_hash_host_wide_int (r
.cl
, v
);
725 v
= iterative_hash_host_wide_int (r
.decimal
727 | (r
.signalling
<< 2)
728 | (r
.canonical
<< 3), v
);
729 v
= iterative_hash_host_wide_int (r
.uexp
, v
);
730 for (unsigned i
= 0; i
< SIGSZ
; ++i
)
731 v
= iterative_hash_host_wide_int (r
.sig
[i
], v
);
734 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
736 FIXED_VALUE_TYPE f
= TREE_FIXED_CST (t
);
737 v
= iterative_hash_host_wide_int (f
.mode
, v
);
738 v
= iterative_hash_host_wide_int (f
.data
.low
, v
);
739 v
= iterative_hash_host_wide_int (f
.data
.high
, v
);
742 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
744 v
= iterative_hash_host_wide_int (DECL_MODE (t
), v
);
745 v
= iterative_hash_host_wide_int (DECL_NONLOCAL (t
)
746 | (DECL_VIRTUAL_P (t
) << 1)
747 | (DECL_IGNORED_P (t
) << 2)
748 | (DECL_ABSTRACT (t
) << 3)
749 | (DECL_ARTIFICIAL (t
) << 4)
750 | (DECL_USER_ALIGN (t
) << 5)
751 | (DECL_PRESERVE_P (t
) << 6)
752 | (DECL_EXTERNAL (t
) << 7)
753 | (DECL_GIMPLE_REG_P (t
) << 8), v
);
754 v
= iterative_hash_host_wide_int (DECL_ALIGN (t
), v
);
755 if (code
== LABEL_DECL
)
757 v
= iterative_hash_host_wide_int (DECL_ERROR_ISSUED (t
), v
);
758 v
= iterative_hash_host_wide_int (EH_LANDING_PAD_NR (t
), v
);
759 v
= iterative_hash_host_wide_int (LABEL_DECL_UID (t
), v
);
761 else if (code
== FIELD_DECL
)
763 v
= iterative_hash_host_wide_int (DECL_PACKED (t
)
764 | (DECL_NONADDRESSABLE_P (t
) << 1),
766 v
= iterative_hash_host_wide_int (DECL_OFFSET_ALIGN (t
), v
);
768 else if (code
== VAR_DECL
)
770 v
= iterative_hash_host_wide_int (DECL_HAS_DEBUG_EXPR_P (t
)
771 | (DECL_NONLOCAL_FRAME (t
) << 1),
774 if (code
== RESULT_DECL
778 v
= iterative_hash_host_wide_int (DECL_BY_REFERENCE (t
), v
);
780 || code
== PARM_DECL
)
781 v
= iterative_hash_host_wide_int (DECL_HAS_VALUE_EXPR_P (t
), v
);
785 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
786 v
= iterative_hash_host_wide_int (DECL_REGISTER (t
), v
);
788 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
790 v
= iterative_hash_host_wide_int (DECL_DEFER_OUTPUT (t
)
791 | (DECL_COMMON (t
) << 1)
792 | (DECL_DLLIMPORT_P (t
) << 2)
793 | (DECL_WEAK (t
) << 3)
794 | (DECL_SEEN_IN_BIND_EXPR_P (t
) << 4)
795 | (DECL_COMDAT (t
) << 5)
796 | (DECL_VISIBILITY_SPECIFIED (t
) << 6),
798 v
= iterative_hash_host_wide_int (DECL_VISIBILITY (t
), v
);
799 if (code
== VAR_DECL
)
801 v
= iterative_hash_host_wide_int (DECL_HARD_REGISTER (t
)
802 | (DECL_IN_TEXT_SECTION (t
) << 1)
803 | (DECL_IN_CONSTANT_POOL (t
) << 2),
805 v
= iterative_hash_host_wide_int (DECL_TLS_MODEL (t
), v
);
807 if (VAR_OR_FUNCTION_DECL_P (t
))
808 v
= iterative_hash_host_wide_int (DECL_INIT_PRIORITY (t
), v
);
811 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
813 v
= iterative_hash_host_wide_int (DECL_BUILT_IN_CLASS (t
), v
);
814 v
= iterative_hash_host_wide_int (DECL_STATIC_CONSTRUCTOR (t
)
815 | (DECL_STATIC_DESTRUCTOR (t
) << 1)
816 | (DECL_UNINLINABLE (t
) << 2)
817 | (DECL_POSSIBLY_INLINED (t
) << 3)
818 | (DECL_IS_NOVOPS (t
) << 4)
819 | (DECL_IS_RETURNS_TWICE (t
) << 5)
820 | (DECL_IS_MALLOC (t
) << 6)
821 | (DECL_IS_OPERATOR_NEW (t
) << 7)
822 | (DECL_DECLARED_INLINE_P (t
) << 8)
823 | (DECL_STATIC_CHAIN (t
) << 9)
824 | (DECL_NO_INLINE_WARNING_P (t
) << 10)
825 | (DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (t
) << 11)
826 | (DECL_NO_LIMIT_STACK (t
) << 12)
827 | (DECL_DISREGARD_INLINE_LIMITS (t
) << 13)
828 | (DECL_PURE_P (t
) << 14)
829 | (DECL_LOOPING_CONST_OR_PURE_P (t
) << 15), v
);
830 if (DECL_BUILT_IN_CLASS (t
) != NOT_BUILT_IN
)
831 v
= iterative_hash_host_wide_int (DECL_FUNCTION_CODE (t
), v
);
832 if (DECL_STATIC_DESTRUCTOR (t
))
833 v
= iterative_hash_host_wide_int (DECL_FINI_PRIORITY (t
), v
);
836 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
838 v
= iterative_hash_host_wide_int (TYPE_MODE (t
), v
);
839 v
= iterative_hash_host_wide_int (TYPE_STRING_FLAG (t
)
840 | (TYPE_NO_FORCE_BLK (t
) << 1)
841 | (TYPE_NEEDS_CONSTRUCTING (t
) << 2)
842 | (TYPE_PACKED (t
) << 3)
843 | (TYPE_RESTRICT (t
) << 4)
844 | (TYPE_USER_ALIGN (t
) << 5)
845 | (TYPE_READONLY (t
) << 6), v
);
846 if (RECORD_OR_UNION_TYPE_P (t
))
847 v
= iterative_hash_host_wide_int (TYPE_TRANSPARENT_AGGR (t
), v
);
848 else if (code
== ARRAY_TYPE
)
849 v
= iterative_hash_host_wide_int (TYPE_NONALIASED_COMPONENT (t
), v
);
850 v
= iterative_hash_host_wide_int (TYPE_PRECISION (t
), v
);
851 v
= iterative_hash_host_wide_int (TYPE_ALIGN (t
), v
);
852 v
= iterative_hash_host_wide_int ((TYPE_ALIAS_SET (t
) == 0
854 && get_alias_set (t
) == 0))
858 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
859 v
= iterative_hash (TRANSLATION_UNIT_LANGUAGE (t
),
860 strlen (TRANSLATION_UNIT_LANGUAGE (t
)), v
);
862 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
))
863 v
= iterative_hash (t
, sizeof (struct cl_target_option
), v
);
865 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
866 v
= iterative_hash (t
, sizeof (struct cl_optimization
), v
);
868 if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
869 v
= iterative_hash_host_wide_int (IDENTIFIER_HASH_VALUE (t
), v
);
871 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
872 v
= iterative_hash (TREE_STRING_POINTER (t
), TREE_STRING_LENGTH (t
), v
);
874 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
876 if (POINTER_TYPE_P (t
))
878 /* For pointers factor in the pointed-to type recursively as
879 we cannot recurse through only pointers.
880 ??? We can generalize this by keeping track of the
881 in-SCC edges for each tree (or arbitrarily the first
882 such edge) and hashing that in in a second stage
883 (instead of the quadratic mixing of the SCC we do now). */
886 if (streamer_tree_cache_lookup (cache
, TREE_TYPE (t
), &ix
))
887 x
= streamer_tree_cache_get_hash (cache
, ix
);
889 x
= hash_tree (cache
, TREE_TYPE (t
));
890 v
= iterative_hash_hashval_t (x
, v
);
892 else if (code
!= IDENTIFIER_NODE
)
893 visit (TREE_TYPE (t
));
896 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
897 for (unsigned i
= 0; i
< VECTOR_CST_NELTS (t
); ++i
)
898 visit (VECTOR_CST_ELT (t
, i
));
900 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
902 visit (TREE_REALPART (t
));
903 visit (TREE_IMAGPART (t
));
906 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
908 /* Drop names that were created for anonymous entities. */
910 && TREE_CODE (DECL_NAME (t
)) == IDENTIFIER_NODE
911 && ANON_AGGRNAME_P (DECL_NAME (t
)))
914 visit (DECL_NAME (t
));
915 if (DECL_FILE_SCOPE_P (t
))
918 visit (DECL_CONTEXT (t
));
921 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
923 visit (DECL_SIZE (t
));
924 visit (DECL_SIZE_UNIT (t
));
925 visit (DECL_ATTRIBUTES (t
));
926 if ((code
== VAR_DECL
927 || code
== PARM_DECL
)
928 && DECL_HAS_VALUE_EXPR_P (t
))
929 visit (DECL_VALUE_EXPR (t
));
931 && DECL_HAS_DEBUG_EXPR_P (t
))
932 visit (DECL_DEBUG_EXPR (t
));
933 /* ??? Hash DECL_INITIAL as streamed. Needs the output-block to
934 be able to call get_symbol_initial_value. */
937 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
939 if (code
== FUNCTION_DECL
)
941 for (tree a
= DECL_ARGUMENTS (t
); a
; a
= DECL_CHAIN (a
))
943 visit (DECL_RESULT (t
));
945 else if (code
== TYPE_DECL
)
946 visit (DECL_ORIGINAL_TYPE (t
));
947 visit (DECL_VINDEX (t
));
950 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
952 if (DECL_ASSEMBLER_NAME_SET_P (t
))
953 visit (DECL_ASSEMBLER_NAME (t
));
954 visit (DECL_SECTION_NAME (t
));
955 visit (DECL_COMDAT_GROUP (t
));
958 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
960 visit (DECL_FIELD_OFFSET (t
));
961 visit (DECL_BIT_FIELD_TYPE (t
));
962 visit (DECL_BIT_FIELD_REPRESENTATIVE (t
));
963 visit (DECL_FIELD_BIT_OFFSET (t
));
964 visit (DECL_FCONTEXT (t
));
967 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
969 visit (DECL_FUNCTION_PERSONALITY (t
));
970 visit (DECL_FUNCTION_SPECIFIC_TARGET (t
));
971 visit (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t
));
974 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
976 visit (TYPE_SIZE (t
));
977 visit (TYPE_SIZE_UNIT (t
));
978 visit (TYPE_ATTRIBUTES (t
));
979 visit (TYPE_NAME (t
));
980 visit (TYPE_MAIN_VARIANT (t
));
981 if (TYPE_FILE_SCOPE_P (t
))
984 visit (TYPE_CONTEXT (t
));
985 visit (TYPE_STUB_DECL (t
));
988 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
990 if (code
== ENUMERAL_TYPE
)
991 visit (TYPE_VALUES (t
));
992 else if (code
== ARRAY_TYPE
)
993 visit (TYPE_DOMAIN (t
));
994 else if (RECORD_OR_UNION_TYPE_P (t
))
995 for (tree f
= TYPE_FIELDS (t
); f
; f
= TREE_CHAIN (f
))
997 else if (code
== FUNCTION_TYPE
998 || code
== METHOD_TYPE
)
999 visit (TYPE_ARG_TYPES (t
));
1000 if (!POINTER_TYPE_P (t
))
1001 visit (TYPE_MINVAL (t
));
1002 visit (TYPE_MAXVAL (t
));
1003 if (RECORD_OR_UNION_TYPE_P (t
))
1004 visit (TYPE_BINFO (t
));
1007 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
1009 visit (TREE_PURPOSE (t
));
1010 visit (TREE_VALUE (t
));
1011 visit (TREE_CHAIN (t
));
1014 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1015 for (int i
= 0; i
< TREE_VEC_LENGTH (t
); ++i
)
1016 visit (TREE_VEC_ELT (t
, i
));
1018 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
1020 v
= iterative_hash_host_wide_int (TREE_OPERAND_LENGTH (t
), v
);
1021 for (int i
= 0; i
< TREE_OPERAND_LENGTH (t
); ++i
)
1022 visit (TREE_OPERAND (t
, i
));
1025 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1029 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (t
), i
, b
)
1031 visit (BINFO_OFFSET (t
));
1032 visit (BINFO_VTABLE (t
));
1033 visit (BINFO_VPTR_FIELD (t
));
1034 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (t
), i
, b
)
1036 visit (BINFO_INHERITANCE_CHAIN (t
));
1037 visit (BINFO_SUBVTT_INDEX (t
));
1038 visit (BINFO_VPTR_INDEX (t
));
1041 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1045 v
= iterative_hash_host_wide_int (CONSTRUCTOR_NELTS (t
), v
);
1046 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), i
, index
, value
)
1058 /* Compare two SCC entries by their hash value for qsorting them. */
1061 scc_entry_compare (const void *p1_
, const void *p2_
)
1063 const scc_entry
*p1
= (const scc_entry
*) p1_
;
1064 const scc_entry
*p2
= (const scc_entry
*) p2_
;
1065 if (p1
->hash
< p2
->hash
)
1067 else if (p1
->hash
> p2
->hash
)
1072 /* Return a hash value for the SCC on the SCC stack from FIRST with
1076 hash_scc (struct streamer_tree_cache_d
*cache
, unsigned first
, unsigned size
)
1078 /* Compute hash values for the SCC members. */
1079 for (unsigned i
= 0; i
< size
; ++i
)
1080 sccstack
[first
+i
].hash
= hash_tree (cache
, sccstack
[first
+i
].t
);
1083 return sccstack
[first
].hash
;
1085 /* Sort the SCC of type, hash pairs so that when we mix in
1086 all members of the SCC the hash value becomes independent on
1087 the order we visited the SCC. Disregard hashes equal to
1088 the hash of the tree we mix into because we cannot guarantee
1089 a stable sort for those across different TUs. */
1090 qsort (&sccstack
[first
], size
, sizeof (scc_entry
), scc_entry_compare
);
1091 hashval_t
*tem
= XALLOCAVEC (hashval_t
, size
);
1092 for (unsigned i
= 0; i
< size
; ++i
)
1094 hashval_t hash
= sccstack
[first
+i
].hash
;
1095 hashval_t orig_hash
= hash
;
1097 /* Skip same hashes. */
1099 j
< size
&& sccstack
[first
+j
].hash
== orig_hash
; ++j
)
1101 for (; j
< size
; ++j
)
1102 hash
= iterative_hash_hashval_t (sccstack
[first
+j
].hash
, hash
);
1103 for (j
= 0; sccstack
[first
+j
].hash
!= orig_hash
; ++j
)
1104 hash
= iterative_hash_hashval_t (sccstack
[first
+j
].hash
, hash
);
1107 hashval_t scc_hash
= 0;
1108 for (unsigned i
= 0; i
< size
; ++i
)
1110 sccstack
[first
+i
].hash
= tem
[i
];
1111 scc_hash
= iterative_hash_hashval_t (tem
[i
], scc_hash
);
1116 /* DFS walk EXPR and stream SCCs of tree bodies if they are not
1117 already in the streamer cache. Main routine called for
1118 each visit of EXPR. */
1121 DFS_write_tree (struct output_block
*ob
, sccs
*from_state
,
1122 tree expr
, bool ref_p
, bool this_ref_p
)
1127 /* Handle special cases. */
1128 if (expr
== NULL_TREE
)
1131 /* Do not DFS walk into indexable trees. */
1132 if (this_ref_p
&& tree_is_indexable (expr
))
1135 /* Check if we already streamed EXPR. */
1136 if (streamer_tree_cache_lookup (ob
->writer_cache
, expr
, &ix
))
1139 slot
= (sccs
**)pointer_map_insert (sccstate
, expr
);
1140 sccs
*cstate
= *slot
;
1143 scc_entry e
= { expr
, 0 };
1144 /* Not yet visited. DFS recurse and push it onto the stack. */
1145 *slot
= cstate
= XOBNEW (&sccstate_obstack
, struct sccs
);
1146 sccstack
.safe_push (e
);
1147 cstate
->dfsnum
= next_dfs_num
++;
1148 cstate
->low
= cstate
->dfsnum
;
1150 if (streamer_handle_as_builtin_p (expr
))
1152 else if (TREE_CODE (expr
) == INTEGER_CST
1153 && !TREE_OVERFLOW (expr
))
1154 DFS_write_tree (ob
, cstate
, TREE_TYPE (expr
), ref_p
, ref_p
);
1157 DFS_write_tree_body (ob
, expr
, cstate
, ref_p
);
1159 /* Walk any LTO-specific edges. */
1161 && TREE_CODE (expr
) != FUNCTION_DECL
1162 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
1164 /* Handle DECL_INITIAL for symbols. */
1165 tree initial
= get_symbol_initial_value (ob
, expr
);
1166 DFS_write_tree (ob
, cstate
, initial
, ref_p
, ref_p
);
1170 /* See if we found an SCC. */
1171 if (cstate
->low
== cstate
->dfsnum
)
1173 unsigned first
, size
;
1176 /* Pop the SCC and compute its size. */
1177 first
= sccstack
.length ();
1180 x
= sccstack
[--first
].t
;
1183 size
= sccstack
.length () - first
;
1185 /* No need to compute hashes for LTRANS units, we don't perform
1186 any merging there. */
1187 hashval_t scc_hash
= 0;
1188 unsigned scc_entry_len
= 0;
1191 scc_hash
= hash_scc (ob
->writer_cache
, first
, size
);
1193 /* Put the entries with the least number of collisions first. */
1194 unsigned entry_start
= 0;
1195 scc_entry_len
= size
+ 1;
1196 for (unsigned i
= 0; i
< size
;)
1199 for (i
= i
+ 1; i
< size
1200 && (sccstack
[first
+ i
].hash
1201 == sccstack
[first
+ from
].hash
); ++i
)
1203 if (i
- from
< scc_entry_len
)
1205 scc_entry_len
= i
- from
;
1209 for (unsigned i
= 0; i
< scc_entry_len
; ++i
)
1211 scc_entry tem
= sccstack
[first
+ i
];
1212 sccstack
[first
+ i
] = sccstack
[first
+ entry_start
+ i
];
1213 sccstack
[first
+ entry_start
+ i
] = tem
;
1217 /* Write LTO_tree_scc. */
1218 streamer_write_record_start (ob
, LTO_tree_scc
);
1219 streamer_write_uhwi (ob
, size
);
1220 streamer_write_uhwi (ob
, scc_hash
);
1222 /* Write size-1 SCCs without wrapping them inside SCC bundles.
1223 All INTEGER_CSTs need to be handled this way as we need
1224 their type to materialize them. Also builtins are handled
1226 ??? We still wrap these in LTO_tree_scc so at the
1227 input side we can properly identify the tree we want
1228 to ultimatively return. */
1229 size_t old_len
= ob
->writer_cache
->nodes
.length ();
1231 lto_output_tree_1 (ob
, expr
, scc_hash
, ref_p
, this_ref_p
);
1234 /* Write the size of the SCC entry candidates. */
1235 streamer_write_uhwi (ob
, scc_entry_len
);
1237 /* Write all headers and populate the streamer cache. */
1238 for (unsigned i
= 0; i
< size
; ++i
)
1240 hashval_t hash
= sccstack
[first
+i
].hash
;
1241 tree t
= sccstack
[first
+i
].t
;
1242 bool exists_p
= streamer_tree_cache_insert (ob
->writer_cache
,
1244 gcc_assert (!exists_p
);
1246 if (!lto_is_streamable (t
))
1247 internal_error ("tree code %qs is not supported "
1249 tree_code_name
[TREE_CODE (t
)]);
1251 gcc_checking_assert (!streamer_handle_as_builtin_p (t
));
1253 /* Write the header, containing everything needed to
1254 materialize EXPR on the reading side. */
1255 streamer_write_tree_header (ob
, t
);
1258 /* Write the bitpacks and tree references. */
1259 for (unsigned i
= 0; i
< size
; ++i
)
1261 lto_write_tree_1 (ob
, sccstack
[first
+i
].t
, ref_p
);
1263 /* Mark the end of the tree. */
1264 streamer_write_zero (ob
);
1267 gcc_assert (old_len
+ size
== ob
->writer_cache
->nodes
.length ());
1269 /* Finally truncate the vector. */
1270 sccstack
.truncate (first
);
1273 from_state
->low
= MIN (from_state
->low
, cstate
->low
);
1278 from_state
->low
= MIN (from_state
->low
, cstate
->low
);
1280 gcc_checking_assert (from_state
);
1281 if (cstate
->dfsnum
< from_state
->dfsnum
)
1282 from_state
->low
= MIN (cstate
->dfsnum
, from_state
->low
);
1286 /* Emit the physical representation of tree node EXPR to output block
1287 OB. If THIS_REF_P is true, the leaves of EXPR are emitted as references
1288 via lto_output_tree_ref. REF_P is used for streaming siblings of EXPR. */
1291 lto_output_tree (struct output_block
*ob
, tree expr
,
1292 bool ref_p
, bool this_ref_p
)
1297 if (expr
== NULL_TREE
)
1299 streamer_write_record_start (ob
, LTO_null
);
1303 if (this_ref_p
&& tree_is_indexable (expr
))
1305 lto_output_tree_ref (ob
, expr
);
1309 existed_p
= streamer_tree_cache_lookup (ob
->writer_cache
, expr
, &ix
);
1312 /* If a node has already been streamed out, make sure that
1313 we don't write it more than once. Otherwise, the reader
1314 will instantiate two different nodes for the same object. */
1315 streamer_write_record_start (ob
, LTO_tree_pickle_reference
);
1316 streamer_write_uhwi (ob
, ix
);
1317 streamer_write_enum (ob
->main_stream
, LTO_tags
, LTO_NUM_TAGS
,
1318 lto_tree_code_to_tag (TREE_CODE (expr
)));
1319 lto_stats
.num_pickle_refs_output
++;
1323 /* This is the first time we see EXPR, write all reachable
1325 static bool in_dfs_walk
;
1327 /* Protect against recursion which means disconnect between
1328 what tree edges we walk in the DFS walk and what edges
1330 gcc_assert (!in_dfs_walk
);
1332 /* Start the DFS walk. */
1333 /* Save ob state ... */
1336 sccstate
= pointer_map_create ();
1337 gcc_obstack_init (&sccstate_obstack
);
1339 DFS_write_tree (ob
, NULL
, expr
, ref_p
, this_ref_p
);
1340 sccstack
.release ();
1341 pointer_map_destroy (sccstate
);
1342 obstack_free (&sccstate_obstack
, NULL
);
1343 in_dfs_walk
= false;
1345 /* Finally append a reference to the tree we were writing.
1346 ??? If expr ended up as a singleton we could have
1347 inlined it here and avoid outputting a reference. */
1348 existed_p
= streamer_tree_cache_lookup (ob
->writer_cache
, expr
, &ix
);
1349 gcc_assert (existed_p
);
1350 streamer_write_record_start (ob
, LTO_tree_pickle_reference
);
1351 streamer_write_uhwi (ob
, ix
);
1352 streamer_write_enum (ob
->main_stream
, LTO_tags
, LTO_NUM_TAGS
,
1353 lto_tree_code_to_tag (TREE_CODE (expr
)));
1354 lto_stats
.num_pickle_refs_output
++;
1359 /* Output to OB a list of try/catch handlers starting with FIRST. */
1362 output_eh_try_list (struct output_block
*ob
, eh_catch first
)
1366 for (n
= first
; n
; n
= n
->next_catch
)
1368 streamer_write_record_start (ob
, LTO_eh_catch
);
1369 stream_write_tree (ob
, n
->type_list
, true);
1370 stream_write_tree (ob
, n
->filter_list
, true);
1371 stream_write_tree (ob
, n
->label
, true);
1374 streamer_write_record_start (ob
, LTO_null
);
1378 /* Output EH region R in function FN to OB. CURR_RN is the slot index
1379 that is being emitted in FN->EH->REGION_ARRAY. This is used to
1380 detect EH region sharing. */
1383 output_eh_region (struct output_block
*ob
, eh_region r
)
1389 streamer_write_record_start (ob
, LTO_null
);
1393 if (r
->type
== ERT_CLEANUP
)
1394 tag
= LTO_ert_cleanup
;
1395 else if (r
->type
== ERT_TRY
)
1397 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
1398 tag
= LTO_ert_allowed_exceptions
;
1399 else if (r
->type
== ERT_MUST_NOT_THROW
)
1400 tag
= LTO_ert_must_not_throw
;
1404 streamer_write_record_start (ob
, tag
);
1405 streamer_write_hwi (ob
, r
->index
);
1408 streamer_write_hwi (ob
, r
->outer
->index
);
1410 streamer_write_zero (ob
);
1413 streamer_write_hwi (ob
, r
->inner
->index
);
1415 streamer_write_zero (ob
);
1418 streamer_write_hwi (ob
, r
->next_peer
->index
);
1420 streamer_write_zero (ob
);
1422 if (r
->type
== ERT_TRY
)
1424 output_eh_try_list (ob
, r
->u
.eh_try
.first_catch
);
1426 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
1428 stream_write_tree (ob
, r
->u
.allowed
.type_list
, true);
1429 stream_write_tree (ob
, r
->u
.allowed
.label
, true);
1430 streamer_write_uhwi (ob
, r
->u
.allowed
.filter
);
1432 else if (r
->type
== ERT_MUST_NOT_THROW
)
1434 stream_write_tree (ob
, r
->u
.must_not_throw
.failure_decl
, true);
1435 bitpack_d bp
= bitpack_create (ob
->main_stream
);
1436 stream_output_location (ob
, &bp
, r
->u
.must_not_throw
.failure_loc
);
1437 streamer_write_bitpack (&bp
);
1440 if (r
->landing_pads
)
1441 streamer_write_hwi (ob
, r
->landing_pads
->index
);
1443 streamer_write_zero (ob
);
1447 /* Output landing pad LP to OB. */
1450 output_eh_lp (struct output_block
*ob
, eh_landing_pad lp
)
1454 streamer_write_record_start (ob
, LTO_null
);
1458 streamer_write_record_start (ob
, LTO_eh_landing_pad
);
1459 streamer_write_hwi (ob
, lp
->index
);
1461 streamer_write_hwi (ob
, lp
->next_lp
->index
);
1463 streamer_write_zero (ob
);
1466 streamer_write_hwi (ob
, lp
->region
->index
);
1468 streamer_write_zero (ob
);
1470 stream_write_tree (ob
, lp
->post_landing_pad
, true);
1474 /* Output the existing eh_table to OB. */
1477 output_eh_regions (struct output_block
*ob
, struct function
*fn
)
1479 if (fn
->eh
&& fn
->eh
->region_tree
)
1486 streamer_write_record_start (ob
, LTO_eh_table
);
1488 /* Emit the index of the root of the EH region tree. */
1489 streamer_write_hwi (ob
, fn
->eh
->region_tree
->index
);
1491 /* Emit all the EH regions in the region array. */
1492 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->region_array
));
1493 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->region_array
, i
, eh
)
1494 output_eh_region (ob
, eh
);
1496 /* Emit all landing pads. */
1497 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->lp_array
));
1498 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->lp_array
, i
, lp
)
1499 output_eh_lp (ob
, lp
);
1501 /* Emit all the runtime type data. */
1502 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->ttype_data
));
1503 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->ttype_data
, i
, ttype
)
1504 stream_write_tree (ob
, ttype
, true);
1506 /* Emit the table of action chains. */
1507 if (targetm
.arm_eabi_unwinder
)
1510 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->ehspec_data
.arm_eabi
));
1511 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->ehspec_data
.arm_eabi
, i
, t
)
1512 stream_write_tree (ob
, t
, true);
1517 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->ehspec_data
.other
));
1518 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->ehspec_data
.other
, i
, c
)
1519 streamer_write_char_stream (ob
->main_stream
, c
);
1523 /* The LTO_null either terminates the record or indicates that there
1524 are no eh_records at all. */
1525 streamer_write_record_start (ob
, LTO_null
);
1529 /* Output all of the active ssa names to the ssa_names stream. */
1532 output_ssa_names (struct output_block
*ob
, struct function
*fn
)
1534 unsigned int i
, len
;
1536 len
= vec_safe_length (SSANAMES (fn
));
1537 streamer_write_uhwi (ob
, len
);
1539 for (i
= 1; i
< len
; i
++)
1541 tree ptr
= (*SSANAMES (fn
))[i
];
1543 if (ptr
== NULL_TREE
1544 || SSA_NAME_IN_FREE_LIST (ptr
)
1545 || virtual_operand_p (ptr
))
1548 streamer_write_uhwi (ob
, i
);
1549 streamer_write_char_stream (ob
->main_stream
,
1550 SSA_NAME_IS_DEFAULT_DEF (ptr
));
1551 if (SSA_NAME_VAR (ptr
))
1552 stream_write_tree (ob
, SSA_NAME_VAR (ptr
), true);
1554 /* ??? This drops SSA_NAME_IDENTIFIER on the floor. */
1555 stream_write_tree (ob
, TREE_TYPE (ptr
), true);
1558 streamer_write_zero (ob
);
1562 /* Output the cfg. */
1565 output_cfg (struct output_block
*ob
, struct function
*fn
)
1567 struct lto_output_stream
*tmp_stream
= ob
->main_stream
;
1570 ob
->main_stream
= ob
->cfg_stream
;
1572 streamer_write_enum (ob
->main_stream
, profile_status_d
, PROFILE_LAST
,
1573 profile_status_for_function (fn
));
1575 /* Output the number of the highest basic block. */
1576 streamer_write_uhwi (ob
, last_basic_block_for_function (fn
));
1578 FOR_ALL_BB_FN (bb
, fn
)
1583 streamer_write_hwi (ob
, bb
->index
);
1585 /* Output the successors and the edge flags. */
1586 streamer_write_uhwi (ob
, EDGE_COUNT (bb
->succs
));
1587 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1589 streamer_write_uhwi (ob
, e
->dest
->index
);
1590 streamer_write_hwi (ob
, e
->probability
);
1591 streamer_write_gcov_count (ob
, e
->count
);
1592 streamer_write_uhwi (ob
, e
->flags
);
1596 streamer_write_hwi (ob
, -1);
1598 bb
= ENTRY_BLOCK_PTR
;
1601 streamer_write_hwi (ob
, bb
->next_bb
->index
);
1605 streamer_write_hwi (ob
, -1);
1607 /* ??? The cfgloop interface is tied to cfun. */
1608 gcc_assert (cfun
== fn
);
1610 /* Output the number of loops. */
1611 streamer_write_uhwi (ob
, number_of_loops (fn
));
1613 /* Output each loop, skipping the tree root which has number zero. */
1614 for (unsigned i
= 1; i
< number_of_loops (fn
); ++i
)
1616 struct loop
*loop
= get_loop (fn
, i
);
1618 /* Write the index of the loop header. That's enough to rebuild
1619 the loop tree on the reader side. Stream -1 for an unused
1623 streamer_write_hwi (ob
, -1);
1627 streamer_write_hwi (ob
, loop
->header
->index
);
1629 /* Write everything copy_loop_info copies. */
1630 streamer_write_enum (ob
->main_stream
,
1631 loop_estimation
, EST_LAST
, loop
->estimate_state
);
1632 streamer_write_hwi (ob
, loop
->any_upper_bound
);
1633 if (loop
->any_upper_bound
)
1635 streamer_write_uhwi (ob
, loop
->nb_iterations_upper_bound
.low
);
1636 streamer_write_hwi (ob
, loop
->nb_iterations_upper_bound
.high
);
1638 streamer_write_hwi (ob
, loop
->any_estimate
);
1639 if (loop
->any_estimate
)
1641 streamer_write_uhwi (ob
, loop
->nb_iterations_estimate
.low
);
1642 streamer_write_hwi (ob
, loop
->nb_iterations_estimate
.high
);
1646 ob
->main_stream
= tmp_stream
;
1650 /* Create the header in the file using OB. If the section type is for
1651 a function, set FN to the decl for that function. */
1654 produce_asm (struct output_block
*ob
, tree fn
)
1656 enum lto_section_type section_type
= ob
->section_type
;
1657 struct lto_function_header header
;
1659 struct lto_output_stream
*header_stream
;
1661 if (section_type
== LTO_section_function_body
)
1663 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn
));
1664 section_name
= lto_get_section_name (section_type
, name
, NULL
);
1667 section_name
= lto_get_section_name (section_type
, NULL
, NULL
);
1669 lto_begin_section (section_name
, !flag_wpa
);
1670 free (section_name
);
1672 /* The entire header is stream computed here. */
1673 memset (&header
, 0, sizeof (struct lto_function_header
));
1675 /* Write the header. */
1676 header
.lto_header
.major_version
= LTO_major_version
;
1677 header
.lto_header
.minor_version
= LTO_minor_version
;
1679 header
.compressed_size
= 0;
1681 if (section_type
== LTO_section_function_body
)
1682 header
.cfg_size
= ob
->cfg_stream
->total_size
;
1683 header
.main_size
= ob
->main_stream
->total_size
;
1684 header
.string_size
= ob
->string_stream
->total_size
;
1686 header_stream
= XCNEW (struct lto_output_stream
);
1687 lto_output_data_stream (header_stream
, &header
, sizeof header
);
1688 lto_write_stream (header_stream
);
1689 free (header_stream
);
1691 /* Put all of the gimple and the string table out the asm file as a
1693 if (section_type
== LTO_section_function_body
)
1694 lto_write_stream (ob
->cfg_stream
);
1695 lto_write_stream (ob
->main_stream
);
1696 lto_write_stream (ob
->string_stream
);
1702 /* Output the base body of struct function FN using output block OB. */
1705 output_struct_function_base (struct output_block
*ob
, struct function
*fn
)
1707 struct bitpack_d bp
;
1711 /* Output the static chain and non-local goto save area. */
1712 stream_write_tree (ob
, fn
->static_chain_decl
, true);
1713 stream_write_tree (ob
, fn
->nonlocal_goto_save_area
, true);
1715 /* Output all the local variables in the function. */
1716 streamer_write_hwi (ob
, vec_safe_length (fn
->local_decls
));
1717 FOR_EACH_VEC_SAFE_ELT (fn
->local_decls
, i
, t
)
1718 stream_write_tree (ob
, t
, true);
1720 /* Output current IL state of the function. */
1721 streamer_write_uhwi (ob
, fn
->curr_properties
);
1723 /* Write all the attributes for FN. */
1724 bp
= bitpack_create (ob
->main_stream
);
1725 bp_pack_value (&bp
, fn
->is_thunk
, 1);
1726 bp_pack_value (&bp
, fn
->has_local_explicit_reg_vars
, 1);
1727 bp_pack_value (&bp
, fn
->returns_pcc_struct
, 1);
1728 bp_pack_value (&bp
, fn
->returns_struct
, 1);
1729 bp_pack_value (&bp
, fn
->can_throw_non_call_exceptions
, 1);
1730 bp_pack_value (&bp
, fn
->can_delete_dead_exceptions
, 1);
1731 bp_pack_value (&bp
, fn
->always_inline_functions_inlined
, 1);
1732 bp_pack_value (&bp
, fn
->after_inlining
, 1);
1733 bp_pack_value (&bp
, fn
->stdarg
, 1);
1734 bp_pack_value (&bp
, fn
->has_nonlocal_label
, 1);
1735 bp_pack_value (&bp
, fn
->calls_alloca
, 1);
1736 bp_pack_value (&bp
, fn
->calls_setjmp
, 1);
1737 bp_pack_value (&bp
, fn
->va_list_fpr_size
, 8);
1738 bp_pack_value (&bp
, fn
->va_list_gpr_size
, 8);
1740 /* Output the function start and end loci. */
1741 stream_output_location (ob
, &bp
, fn
->function_start_locus
);
1742 stream_output_location (ob
, &bp
, fn
->function_end_locus
);
1744 streamer_write_bitpack (&bp
);
1748 /* Output the body of function NODE->DECL. */
1751 output_function (struct cgraph_node
*node
)
1754 struct function
*fn
;
1756 struct output_block
*ob
;
1758 function
= node
->symbol
.decl
;
1759 fn
= DECL_STRUCT_FUNCTION (function
);
1760 ob
= create_output_block (LTO_section_function_body
);
1762 clear_line_info (ob
);
1763 ob
->cgraph_node
= node
;
1765 gcc_assert (current_function_decl
== NULL_TREE
&& cfun
== NULL
);
1767 /* Set current_function_decl and cfun. */
1770 /* Make string 0 be a NULL string. */
1771 streamer_write_char_stream (ob
->string_stream
, 0);
1773 streamer_write_record_start (ob
, LTO_function
);
1775 output_struct_function_base (ob
, fn
);
1777 /* Output all the SSA names used in the function. */
1778 output_ssa_names (ob
, fn
);
1780 /* Output any exception handling regions. */
1781 output_eh_regions (ob
, fn
);
1783 /* Output DECL_INITIAL for the function, which contains the tree of
1785 stream_write_tree (ob
, DECL_INITIAL (function
), true);
1787 /* We will renumber the statements. The code that does this uses
1788 the same ordering that we use for serializing them so we can use
1789 the same code on the other end and not have to write out the
1790 statement numbers. We do not assign UIDs to PHIs here because
1791 virtual PHIs get re-computed on-the-fly which would make numbers
1793 set_gimple_stmt_max_uid (cfun
, 0);
1796 gimple_stmt_iterator gsi
;
1797 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1799 gimple stmt
= gsi_stmt (gsi
);
1800 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
1804 /* Output the code for the function. */
1805 FOR_ALL_BB_FN (bb
, fn
)
1806 output_bb (ob
, bb
, fn
);
1808 /* The terminator for this function. */
1809 streamer_write_record_start (ob
, LTO_null
);
1811 output_cfg (ob
, fn
);
1813 /* Create a section to hold the pickled output of this function. */
1814 produce_asm (ob
, function
);
1816 destroy_output_block (ob
);
1822 /* Emit toplevel asms. */
1825 lto_output_toplevel_asms (void)
1827 struct output_block
*ob
;
1828 struct asm_node
*can
;
1830 struct lto_output_stream
*header_stream
;
1831 struct lto_asm_header header
;
1836 ob
= create_output_block (LTO_section_asm
);
1838 /* Make string 0 be a NULL string. */
1839 streamer_write_char_stream (ob
->string_stream
, 0);
1841 for (can
= asm_nodes
; can
; can
= can
->next
)
1843 streamer_write_string_cst (ob
, ob
->main_stream
, can
->asm_str
);
1844 streamer_write_hwi (ob
, can
->order
);
1847 streamer_write_string_cst (ob
, ob
->main_stream
, NULL_TREE
);
1849 section_name
= lto_get_section_name (LTO_section_asm
, NULL
, NULL
);
1850 lto_begin_section (section_name
, !flag_wpa
);
1851 free (section_name
);
1853 /* The entire header stream is computed here. */
1854 memset (&header
, 0, sizeof (header
));
1856 /* Write the header. */
1857 header
.lto_header
.major_version
= LTO_major_version
;
1858 header
.lto_header
.minor_version
= LTO_minor_version
;
1860 header
.main_size
= ob
->main_stream
->total_size
;
1861 header
.string_size
= ob
->string_stream
->total_size
;
1863 header_stream
= XCNEW (struct lto_output_stream
);
1864 lto_output_data_stream (header_stream
, &header
, sizeof (header
));
1865 lto_write_stream (header_stream
);
1866 free (header_stream
);
1868 /* Put all of the gimple and the string table out the asm file as a
1870 lto_write_stream (ob
->main_stream
);
1871 lto_write_stream (ob
->string_stream
);
1875 destroy_output_block (ob
);
1879 /* Copy the function body of NODE without deserializing. */
1882 copy_function (struct cgraph_node
*node
)
1884 tree function
= node
->symbol
.decl
;
1885 struct lto_file_decl_data
*file_data
= node
->symbol
.lto_file_data
;
1886 struct lto_output_stream
*output_stream
= XCNEW (struct lto_output_stream
);
1889 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function
));
1890 char *section_name
=
1891 lto_get_section_name (LTO_section_function_body
, name
, NULL
);
1893 struct lto_in_decl_state
*in_state
;
1894 struct lto_out_decl_state
*out_state
= lto_get_out_decl_state ();
1896 lto_begin_section (section_name
, !flag_wpa
);
1897 free (section_name
);
1899 /* We may have renamed the declaration, e.g., a static function. */
1900 name
= lto_get_decl_name_mapping (file_data
, name
);
1902 data
= lto_get_section_data (file_data
, LTO_section_function_body
,
1906 /* Do a bit copy of the function body. */
1907 lto_output_data_stream (output_stream
, data
, len
);
1908 lto_write_stream (output_stream
);
1912 lto_get_function_in_decl_state (node
->symbol
.lto_file_data
, function
);
1913 gcc_assert (in_state
);
1915 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
1917 size_t n
= in_state
->streams
[i
].size
;
1918 tree
*trees
= in_state
->streams
[i
].trees
;
1919 struct lto_tree_ref_encoder
*encoder
= &(out_state
->streams
[i
]);
1921 /* The out state must have the same indices and the in state.
1922 So just copy the vector. All the encoders in the in state
1923 must be empty where we reach here. */
1924 gcc_assert (lto_tree_ref_encoder_size (encoder
) == 0);
1925 for (j
= 0; j
< n
; j
++)
1926 encoder
->trees
.safe_push (trees
[j
]);
1927 encoder
->next_index
= n
;
1930 lto_free_section_data (file_data
, LTO_section_function_body
, name
,
1932 free (output_stream
);
1937 /* Main entry point from the pass manager. */
1942 struct lto_out_decl_state
*decl_state
;
1943 #ifdef ENABLE_CHECKING
1944 bitmap output
= lto_bitmap_alloc ();
1947 lto_symtab_encoder_t encoder
= lto_get_out_decl_state ()->symtab_node_encoder
;
1949 /* Initialize the streamer. */
1950 lto_streamer_init ();
1952 n_nodes
= lto_symtab_encoder_size (encoder
);
1953 /* Process only the functions with bodies. */
1954 for (i
= 0; i
< n_nodes
; i
++)
1956 symtab_node snode
= lto_symtab_encoder_deref (encoder
, i
);
1957 cgraph_node
*node
= dyn_cast
<cgraph_node
> (snode
);
1959 && lto_symtab_encoder_encode_body_p (encoder
, node
)
1960 && !node
->symbol
.alias
1961 && !node
->thunk
.thunk_p
)
1963 #ifdef ENABLE_CHECKING
1964 gcc_assert (!bitmap_bit_p (output
, DECL_UID (node
->symbol
.decl
)));
1965 bitmap_set_bit (output
, DECL_UID (node
->symbol
.decl
));
1967 decl_state
= lto_new_out_decl_state ();
1968 lto_push_out_decl_state (decl_state
);
1969 if (gimple_has_body_p (node
->symbol
.decl
))
1970 output_function (node
);
1972 copy_function (node
);
1973 gcc_assert (lto_get_out_decl_state () == decl_state
);
1974 lto_pop_out_decl_state ();
1975 lto_record_function_out_decl_state (node
->symbol
.decl
, decl_state
);
1979 /* Emit the callgraph after emitting function bodies. This needs to
1980 be done now to make sure that all the statements in every function
1981 have been renumbered so that edges can be associated with call
1982 statements using the statement UIDs. */
1985 #ifdef ENABLE_CHECKING
1986 lto_bitmap_free (output
);
1990 struct ipa_opt_pass_d pass_ipa_lto_gimple_out
=
1994 "lto_gimple_out", /* name */
1995 OPTGROUP_NONE
, /* optinfo_flags */
1996 gate_lto_out
, /* gate */
2000 0, /* static_pass_number */
2001 TV_IPA_LTO_GIMPLE_OUT
, /* tv_id */
2002 0, /* properties_required */
2003 0, /* properties_provided */
2004 0, /* properties_destroyed */
2005 0, /* todo_flags_start */
2006 0 /* todo_flags_finish */
2008 NULL
, /* generate_summary */
2009 lto_output
, /* write_summary */
2010 NULL
, /* read_summary */
2011 lto_output
, /* write_optimization_summary */
2012 NULL
, /* read_optimization_summary */
2013 NULL
, /* stmt_fixup */
2015 NULL
, /* function_transform */
2016 NULL
/* variable_transform */
2020 /* Write each node in encoded by ENCODER to OB, as well as those reachable
2021 from it and required for correct representation of its semantics.
2022 Each node in ENCODER must be a global declaration or a type. A node
2023 is written only once, even if it appears multiple times in the
2024 vector. Certain transitively-reachable nodes, such as those
2025 representing expressions, may be duplicated, but such nodes
2026 must not appear in ENCODER itself. */
2029 write_global_stream (struct output_block
*ob
,
2030 struct lto_tree_ref_encoder
*encoder
)
2034 const size_t size
= lto_tree_ref_encoder_size (encoder
);
2036 for (index
= 0; index
< size
; index
++)
2038 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2039 if (!streamer_tree_cache_lookup (ob
->writer_cache
, t
, NULL
))
2040 stream_write_tree (ob
, t
, false);
2045 /* Write a sequence of indices into the globals vector corresponding
2046 to the trees in ENCODER. These are used by the reader to map the
2047 indices used to refer to global entities within function bodies to
2051 write_global_references (struct output_block
*ob
,
2052 struct lto_output_stream
*ref_stream
,
2053 struct lto_tree_ref_encoder
*encoder
)
2057 const uint32_t size
= lto_tree_ref_encoder_size (encoder
);
2059 /* Write size as 32-bit unsigned. */
2060 lto_output_data_stream (ref_stream
, &size
, sizeof (int32_t));
2062 for (index
= 0; index
< size
; index
++)
2066 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2067 streamer_tree_cache_lookup (ob
->writer_cache
, t
, &slot_num
);
2068 gcc_assert (slot_num
!= (unsigned)-1);
2069 lto_output_data_stream (ref_stream
, &slot_num
, sizeof slot_num
);
2074 /* Write all the streams in an lto_out_decl_state STATE using
2075 output block OB and output stream OUT_STREAM. */
2078 lto_output_decl_state_streams (struct output_block
*ob
,
2079 struct lto_out_decl_state
*state
)
2083 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2084 write_global_stream (ob
, &state
->streams
[i
]);
2088 /* Write all the references in an lto_out_decl_state STATE using
2089 output block OB and output stream OUT_STREAM. */
2092 lto_output_decl_state_refs (struct output_block
*ob
,
2093 struct lto_output_stream
*out_stream
,
2094 struct lto_out_decl_state
*state
)
2100 /* Write reference to FUNCTION_DECL. If there is not function,
2101 write reference to void_type_node. */
2102 decl
= (state
->fn_decl
) ? state
->fn_decl
: void_type_node
;
2103 streamer_tree_cache_lookup (ob
->writer_cache
, decl
, &ref
);
2104 gcc_assert (ref
!= (unsigned)-1);
2105 lto_output_data_stream (out_stream
, &ref
, sizeof (uint32_t));
2107 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2108 write_global_references (ob
, out_stream
, &state
->streams
[i
]);
2112 /* Return the written size of STATE. */
2115 lto_out_decl_state_written_size (struct lto_out_decl_state
*state
)
2120 size
= sizeof (int32_t); /* fn_ref. */
2121 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2123 size
+= sizeof (int32_t); /* vector size. */
2124 size
+= (lto_tree_ref_encoder_size (&state
->streams
[i
])
2125 * sizeof (int32_t));
2131 /* Write symbol T into STREAM in CACHE. SEEN specifies symbols we wrote
2135 write_symbol (struct streamer_tree_cache_d
*cache
,
2136 struct lto_output_stream
*stream
,
2137 tree t
, struct pointer_set_t
*seen
, bool alias
)
2140 enum gcc_plugin_symbol_kind kind
;
2141 enum gcc_plugin_symbol_visibility visibility
;
2143 unsigned HOST_WIDEST_INT size
;
2147 /* None of the following kinds of symbols are needed in the
2149 if (!TREE_PUBLIC (t
)
2150 || is_builtin_fn (t
)
2151 || DECL_ABSTRACT (t
)
2152 || TREE_CODE (t
) == RESULT_DECL
2153 || (TREE_CODE (t
) == VAR_DECL
&& DECL_HARD_REGISTER (t
)))
2156 gcc_assert (TREE_CODE (t
) == VAR_DECL
2157 || TREE_CODE (t
) == FUNCTION_DECL
);
2159 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t
));
2161 /* This behaves like assemble_name_raw in varasm.c, performing the
2162 same name manipulations that ASM_OUTPUT_LABELREF does. */
2163 name
= IDENTIFIER_POINTER ((*targetm
.asm_out
.mangle_assembler_name
) (name
));
2165 if (pointer_set_contains (seen
, name
))
2167 pointer_set_insert (seen
, name
);
2169 streamer_tree_cache_lookup (cache
, t
, &slot_num
);
2170 gcc_assert (slot_num
!= (unsigned)-1);
2172 if (DECL_EXTERNAL (t
))
2175 kind
= GCCPK_WEAKUNDEF
;
2182 kind
= GCCPK_WEAKDEF
;
2183 else if (DECL_COMMON (t
))
2184 kind
= GCCPK_COMMON
;
2188 /* When something is defined, it should have node attached. */
2189 gcc_assert (alias
|| TREE_CODE (t
) != VAR_DECL
2190 || varpool_get_node (t
)->symbol
.definition
);
2191 gcc_assert (alias
|| TREE_CODE (t
) != FUNCTION_DECL
2192 || (cgraph_get_node (t
)
2193 && cgraph_get_node (t
)->symbol
.definition
));
2196 /* Imitate what default_elf_asm_output_external do.
2197 When symbol is external, we need to output it with DEFAULT visibility
2198 when compiling with -fvisibility=default, while with HIDDEN visibility
2199 when symbol has attribute (visibility("hidden")) specified.
2200 targetm.binds_local_p check DECL_VISIBILITY_SPECIFIED and gets this
2203 if (DECL_EXTERNAL (t
)
2204 && !targetm
.binds_local_p (t
))
2205 visibility
= GCCPV_DEFAULT
;
2207 switch (DECL_VISIBILITY(t
))
2209 case VISIBILITY_DEFAULT
:
2210 visibility
= GCCPV_DEFAULT
;
2212 case VISIBILITY_PROTECTED
:
2213 visibility
= GCCPV_PROTECTED
;
2215 case VISIBILITY_HIDDEN
:
2216 visibility
= GCCPV_HIDDEN
;
2218 case VISIBILITY_INTERNAL
:
2219 visibility
= GCCPV_INTERNAL
;
2223 if (kind
== GCCPK_COMMON
2224 && DECL_SIZE_UNIT (t
)
2225 && TREE_CODE (DECL_SIZE_UNIT (t
)) == INTEGER_CST
)
2226 size
= TREE_INT_CST_LOW (DECL_SIZE_UNIT (t
));
2230 if (DECL_ONE_ONLY (t
))
2231 comdat
= IDENTIFIER_POINTER (DECL_COMDAT_GROUP (t
));
2235 lto_output_data_stream (stream
, name
, strlen (name
) + 1);
2236 lto_output_data_stream (stream
, comdat
, strlen (comdat
) + 1);
2237 c
= (unsigned char) kind
;
2238 lto_output_data_stream (stream
, &c
, 1);
2239 c
= (unsigned char) visibility
;
2240 lto_output_data_stream (stream
, &c
, 1);
2241 lto_output_data_stream (stream
, &size
, 8);
2242 lto_output_data_stream (stream
, &slot_num
, 4);
2245 /* Return true if NODE should appear in the plugin symbol table. */
2248 output_symbol_p (symtab_node node
)
2250 struct cgraph_node
*cnode
;
2251 if (!symtab_real_symbol_p (node
))
2253 /* We keep external functions in symtab for sake of inlining
2254 and devirtualization. We do not want to see them in symbol table as
2255 references unless they are really used. */
2256 cnode
= dyn_cast
<cgraph_node
> (node
);
2257 if (cnode
&& DECL_EXTERNAL (cnode
->symbol
.decl
)
2261 /* Ignore all references from external vars initializers - they are not really
2262 part of the compilation unit until they are used by folding. Some symbols,
2263 like references to external construction vtables can not be referred to at all.
2264 We decide this at can_refer_decl_in_current_unit_p. */
2265 if (DECL_EXTERNAL (node
->symbol
.decl
))
2268 struct ipa_ref
*ref
;
2269 for (i
= 0; ipa_ref_list_referring_iterate (&node
->symbol
.ref_list
,
2272 if (ref
->use
== IPA_REF_ALIAS
)
2274 if (is_a
<cgraph_node
> (ref
->referring
))
2276 if (!DECL_EXTERNAL (ref
->referring
->symbol
.decl
))
2285 /* Write an IL symbol table to OB.
2286 SET and VSET are cgraph/varpool node sets we are outputting. */
2289 produce_symtab (struct output_block
*ob
)
2291 struct streamer_tree_cache_d
*cache
= ob
->writer_cache
;
2292 char *section_name
= lto_get_section_name (LTO_section_symtab
, NULL
, NULL
);
2293 struct pointer_set_t
*seen
;
2294 struct lto_output_stream stream
;
2295 lto_symtab_encoder_t encoder
= ob
->decl_state
->symtab_node_encoder
;
2296 lto_symtab_encoder_iterator lsei
;
2298 lto_begin_section (section_name
, false);
2299 free (section_name
);
2301 seen
= pointer_set_create ();
2302 memset (&stream
, 0, sizeof (stream
));
2304 /* Write the symbol table.
2305 First write everything defined and then all declarations.
2306 This is neccesary to handle cases where we have duplicated symbols. */
2307 for (lsei
= lsei_start (encoder
);
2308 !lsei_end_p (lsei
); lsei_next (&lsei
))
2310 symtab_node node
= lsei_node (lsei
);
2312 if (!output_symbol_p (node
) || DECL_EXTERNAL (node
->symbol
.decl
))
2314 write_symbol (cache
, &stream
, node
->symbol
.decl
, seen
, false);
2316 for (lsei
= lsei_start (encoder
);
2317 !lsei_end_p (lsei
); lsei_next (&lsei
))
2319 symtab_node node
= lsei_node (lsei
);
2321 if (!output_symbol_p (node
) || !DECL_EXTERNAL (node
->symbol
.decl
))
2323 write_symbol (cache
, &stream
, node
->symbol
.decl
, seen
, false);
2326 lto_write_stream (&stream
);
2327 pointer_set_destroy (seen
);
2333 /* This pass is run after all of the functions are serialized and all
2334 of the IPA passes have written their serialized forms. This pass
2335 causes the vector of all of the global decls and types used from
2336 this file to be written in to a section that can then be read in to
2337 recover these on other side. */
2340 produce_asm_for_decls (void)
2342 struct lto_out_decl_state
*out_state
;
2343 struct lto_out_decl_state
*fn_out_state
;
2344 struct lto_decl_header header
;
2346 struct output_block
*ob
;
2347 struct lto_output_stream
*header_stream
, *decl_state_stream
;
2348 unsigned idx
, num_fns
;
2349 size_t decl_state_size
;
2350 int32_t num_decl_states
;
2352 ob
= create_output_block (LTO_section_decls
);
2355 memset (&header
, 0, sizeof (struct lto_decl_header
));
2357 section_name
= lto_get_section_name (LTO_section_decls
, NULL
, NULL
);
2358 lto_begin_section (section_name
, !flag_wpa
);
2359 free (section_name
);
2361 /* Make string 0 be a NULL string. */
2362 streamer_write_char_stream (ob
->string_stream
, 0);
2364 gcc_assert (!alias_pairs
);
2366 /* Write the global symbols. */
2367 out_state
= lto_get_out_decl_state ();
2368 num_fns
= lto_function_decl_states
.length ();
2369 lto_output_decl_state_streams (ob
, out_state
);
2370 for (idx
= 0; idx
< num_fns
; idx
++)
2373 lto_function_decl_states
[idx
];
2374 lto_output_decl_state_streams (ob
, fn_out_state
);
2377 header
.lto_header
.major_version
= LTO_major_version
;
2378 header
.lto_header
.minor_version
= LTO_minor_version
;
2380 /* Currently not used. This field would allow us to preallocate
2381 the globals vector, so that it need not be resized as it is extended. */
2382 header
.num_nodes
= -1;
2384 /* Compute the total size of all decl out states. */
2385 decl_state_size
= sizeof (int32_t);
2386 decl_state_size
+= lto_out_decl_state_written_size (out_state
);
2387 for (idx
= 0; idx
< num_fns
; idx
++)
2390 lto_function_decl_states
[idx
];
2391 decl_state_size
+= lto_out_decl_state_written_size (fn_out_state
);
2393 header
.decl_state_size
= decl_state_size
;
2395 header
.main_size
= ob
->main_stream
->total_size
;
2396 header
.string_size
= ob
->string_stream
->total_size
;
2398 header_stream
= XCNEW (struct lto_output_stream
);
2399 lto_output_data_stream (header_stream
, &header
, sizeof header
);
2400 lto_write_stream (header_stream
);
2401 free (header_stream
);
2403 /* Write the main out-decl state, followed by out-decl states of
2405 decl_state_stream
= XCNEW (struct lto_output_stream
);
2406 num_decl_states
= num_fns
+ 1;
2407 lto_output_data_stream (decl_state_stream
, &num_decl_states
,
2408 sizeof (num_decl_states
));
2409 lto_output_decl_state_refs (ob
, decl_state_stream
, out_state
);
2410 for (idx
= 0; idx
< num_fns
; idx
++)
2413 lto_function_decl_states
[idx
];
2414 lto_output_decl_state_refs (ob
, decl_state_stream
, fn_out_state
);
2416 lto_write_stream (decl_state_stream
);
2417 free(decl_state_stream
);
2419 lto_write_stream (ob
->main_stream
);
2420 lto_write_stream (ob
->string_stream
);
2424 /* Write the symbol table. It is used by linker to determine dependencies
2425 and thus we can skip it for WPA. */
2427 produce_symtab (ob
);
2429 /* Write command line opts. */
2430 lto_write_options ();
2432 /* Deallocate memory and clean up. */
2433 for (idx
= 0; idx
< num_fns
; idx
++)
2436 lto_function_decl_states
[idx
];
2437 lto_delete_out_decl_state (fn_out_state
);
2439 lto_symtab_encoder_delete (ob
->decl_state
->symtab_node_encoder
);
2440 lto_function_decl_states
.release ();
2441 destroy_output_block (ob
);
2445 struct ipa_opt_pass_d pass_ipa_lto_finish_out
=
2449 "lto_decls_out", /* name */
2450 OPTGROUP_NONE
, /* optinfo_flags */
2451 gate_lto_out
, /* gate */
2455 0, /* static_pass_number */
2456 TV_IPA_LTO_DECL_OUT
, /* tv_id */
2457 0, /* properties_required */
2458 0, /* properties_provided */
2459 0, /* properties_destroyed */
2460 0, /* todo_flags_start */
2461 0 /* todo_flags_finish */
2463 NULL
, /* generate_summary */
2464 produce_asm_for_decls
, /* write_summary */
2465 NULL
, /* read_summary */
2466 produce_asm_for_decls
, /* write_optimization_summary */
2467 NULL
, /* read_optimization_summary */
2468 NULL
, /* stmt_fixup */
2470 NULL
, /* function_transform */
2471 NULL
/* variable_transform */