1 /* Write the GIMPLE representation to a file stream.
3 Copyright (C) 2009-2014 Free Software Foundation, Inc.
4 Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
5 Re-implemented by Diego Novillo <dnovillo@google.com>
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
28 #include "stor-layout.h"
29 #include "stringpool.h"
35 #include "basic-block.h"
36 #include "tree-ssa-alias.h"
37 #include "internal-fn.h"
38 #include "gimple-expr.h"
41 #include "gimple-iterator.h"
42 #include "gimple-ssa.h"
43 #include "tree-ssanames.h"
44 #include "tree-pass.h"
46 #include "diagnostic-core.h"
49 #include "lto-symtab.h"
50 #include "lto-streamer.h"
51 #include "data-streamer.h"
52 #include "gimple-streamer.h"
53 #include "tree-streamer.h"
54 #include "streamer-hooks.h"
59 static void lto_write_tree (struct output_block
*, tree
, bool);
61 /* Clear the line info stored in DATA_IN. */
64 clear_line_info (struct output_block
*ob
)
66 ob
->current_file
= NULL
;
72 /* Create the output block and return it. SECTION_TYPE is
73 LTO_section_function_body or LTO_static_initializer. */
76 create_output_block (enum lto_section_type section_type
)
78 struct output_block
*ob
= XCNEW (struct output_block
);
80 ob
->section_type
= section_type
;
81 ob
->decl_state
= lto_get_out_decl_state ();
82 ob
->main_stream
= XCNEW (struct lto_output_stream
);
83 ob
->string_stream
= XCNEW (struct lto_output_stream
);
84 ob
->writer_cache
= streamer_tree_cache_create (!flag_wpa
, true, false);
86 if (section_type
== LTO_section_function_body
)
87 ob
->cfg_stream
= XCNEW (struct lto_output_stream
);
91 ob
->string_hash_table
= new hash_table
<string_slot_hasher
> (37);
92 gcc_obstack_init (&ob
->obstack
);
98 /* Destroy the output block OB. */
101 destroy_output_block (struct output_block
*ob
)
103 enum lto_section_type section_type
= ob
->section_type
;
105 delete ob
->string_hash_table
;
106 ob
->string_hash_table
= NULL
;
108 free (ob
->main_stream
);
109 free (ob
->string_stream
);
110 if (section_type
== LTO_section_function_body
)
111 free (ob
->cfg_stream
);
113 streamer_tree_cache_delete (ob
->writer_cache
);
114 obstack_free (&ob
->obstack
, NULL
);
120 /* Look up NODE in the type table and write the index for it to OB. */
123 output_type_ref (struct output_block
*ob
, tree node
)
125 streamer_write_record_start (ob
, LTO_type_ref
);
126 lto_output_type_ref_index (ob
->decl_state
, ob
->main_stream
, node
);
130 /* Return true if tree node T is written to various tables. For these
131 nodes, we sometimes want to write their phyiscal representation
132 (via lto_output_tree), and sometimes we need to emit an index
133 reference into a table (via lto_output_tree_ref). */
136 tree_is_indexable (tree t
)
138 /* Parameters and return values of functions of variably modified types
139 must go to global stream, because they may be used in the type
141 if (TREE_CODE (t
) == PARM_DECL
|| TREE_CODE (t
) == RESULT_DECL
)
142 return variably_modified_type_p (TREE_TYPE (DECL_CONTEXT (t
)), NULL_TREE
);
143 /* IMPORTED_DECL is put into BLOCK and thus it never can be shared. */
144 else if (TREE_CODE (t
) == IMPORTED_DECL
)
146 else if (((TREE_CODE (t
) == VAR_DECL
&& !TREE_STATIC (t
))
147 || TREE_CODE (t
) == TYPE_DECL
148 || TREE_CODE (t
) == CONST_DECL
149 || TREE_CODE (t
) == NAMELIST_DECL
)
150 && decl_function_context (t
))
152 else if (TREE_CODE (t
) == DEBUG_EXPR_DECL
)
154 /* Variably modified types need to be streamed alongside function
155 bodies because they can refer to local entities. Together with
156 them we have to localize their members as well.
157 ??? In theory that includes non-FIELD_DECLs as well. */
159 && variably_modified_type_p (t
, NULL_TREE
))
161 else if (TREE_CODE (t
) == FIELD_DECL
162 && variably_modified_type_p (DECL_CONTEXT (t
), NULL_TREE
))
165 return (TYPE_P (t
) || DECL_P (t
) || TREE_CODE (t
) == SSA_NAME
);
169 /* Output info about new location into bitpack BP.
170 After outputting bitpack, lto_output_location_data has
171 to be done to output actual data. */
174 lto_output_location (struct output_block
*ob
, struct bitpack_d
*bp
,
177 expanded_location xloc
;
179 loc
= LOCATION_LOCUS (loc
);
180 bp_pack_value (bp
, loc
== UNKNOWN_LOCATION
, 1);
181 if (loc
== UNKNOWN_LOCATION
)
184 xloc
= expand_location (loc
);
186 bp_pack_value (bp
, ob
->current_file
!= xloc
.file
, 1);
187 bp_pack_value (bp
, ob
->current_line
!= xloc
.line
, 1);
188 bp_pack_value (bp
, ob
->current_col
!= xloc
.column
, 1);
190 if (ob
->current_file
!= xloc
.file
)
191 bp_pack_var_len_unsigned (bp
,
192 streamer_string_index (ob
, xloc
.file
,
193 strlen (xloc
.file
) + 1,
195 ob
->current_file
= xloc
.file
;
197 if (ob
->current_line
!= xloc
.line
)
198 bp_pack_var_len_unsigned (bp
, xloc
.line
);
199 ob
->current_line
= xloc
.line
;
201 if (ob
->current_col
!= xloc
.column
)
202 bp_pack_var_len_unsigned (bp
, xloc
.column
);
203 ob
->current_col
= xloc
.column
;
207 /* If EXPR is an indexable tree node, output a reference to it to
208 output block OB. Otherwise, output the physical representation of
212 lto_output_tree_ref (struct output_block
*ob
, tree expr
)
218 output_type_ref (ob
, expr
);
222 code
= TREE_CODE (expr
);
226 streamer_write_record_start (ob
, LTO_ssa_name_ref
);
227 streamer_write_uhwi (ob
, SSA_NAME_VERSION (expr
));
231 streamer_write_record_start (ob
, LTO_field_decl_ref
);
232 lto_output_field_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
236 streamer_write_record_start (ob
, LTO_function_decl_ref
);
237 lto_output_fn_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
241 case DEBUG_EXPR_DECL
:
242 gcc_assert (decl_function_context (expr
) == NULL
|| TREE_STATIC (expr
));
244 streamer_write_record_start (ob
, LTO_global_decl_ref
);
245 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
249 streamer_write_record_start (ob
, LTO_const_decl_ref
);
250 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
254 gcc_assert (decl_function_context (expr
) == NULL
);
255 streamer_write_record_start (ob
, LTO_imported_decl_ref
);
256 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
260 streamer_write_record_start (ob
, LTO_type_decl_ref
);
261 lto_output_type_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
265 streamer_write_record_start (ob
, LTO_namelist_decl_ref
);
266 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
270 streamer_write_record_start (ob
, LTO_namespace_decl_ref
);
271 lto_output_namespace_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
275 streamer_write_record_start (ob
, LTO_label_decl_ref
);
276 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
280 streamer_write_record_start (ob
, LTO_result_decl_ref
);
281 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
284 case TRANSLATION_UNIT_DECL
:
285 streamer_write_record_start (ob
, LTO_translation_unit_decl_ref
);
286 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
290 /* No other node is indexable, so it should have been handled by
297 /* Return true if EXPR is a tree node that can be written to disk. */
300 lto_is_streamable (tree expr
)
302 enum tree_code code
= TREE_CODE (expr
);
304 /* Notice that we reject SSA_NAMEs as well. We only emit the SSA
305 name version in lto_output_tree_ref (see output_ssa_names). */
306 return !is_lang_specific (expr
)
310 && code
!= MODIFY_EXPR
312 && code
!= TARGET_EXPR
314 && code
!= WITH_CLEANUP_EXPR
315 && code
!= STATEMENT_LIST
316 && (code
== CASE_LABEL_EXPR
318 || TREE_CODE_CLASS (code
) != tcc_statement
);
322 /* For EXPR lookup and return what we want to stream to OB as DECL_INITIAL. */
325 get_symbol_initial_value (lto_symtab_encoder_t encoder
, tree expr
)
327 gcc_checking_assert (DECL_P (expr
)
328 && TREE_CODE (expr
) != FUNCTION_DECL
329 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
);
331 /* Handle DECL_INITIAL for symbols. */
332 tree initial
= DECL_INITIAL (expr
);
333 if (TREE_CODE (expr
) == VAR_DECL
334 && (TREE_STATIC (expr
) || DECL_EXTERNAL (expr
))
335 && !DECL_IN_CONSTANT_POOL (expr
)
339 /* Extra section needs about 30 bytes; do not produce it for simple
341 if (TREE_CODE (DECL_INITIAL (expr
)) == CONSTRUCTOR
342 || !(vnode
= varpool_node::get (expr
))
343 || !lto_symtab_encoder_encode_initializer_p (encoder
, vnode
))
344 initial
= error_mark_node
;
351 /* Write a physical representation of tree node EXPR to output block
352 OB. If REF_P is true, the leaves of EXPR are emitted as references
353 via lto_output_tree_ref. IX is the index into the streamer cache
354 where EXPR is stored. */
357 lto_write_tree_1 (struct output_block
*ob
, tree expr
, bool ref_p
)
359 /* Pack all the non-pointer fields in EXPR into a bitpack and write
360 the resulting bitpack. */
361 bitpack_d bp
= bitpack_create (ob
->main_stream
);
362 streamer_pack_tree_bitfields (ob
, &bp
, expr
);
363 streamer_write_bitpack (&bp
);
365 /* Write all the pointer fields in EXPR. */
366 streamer_write_tree_body (ob
, expr
, ref_p
);
368 /* Write any LTO-specific data to OB. */
370 && TREE_CODE (expr
) != FUNCTION_DECL
371 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
373 /* Handle DECL_INITIAL for symbols. */
374 tree initial
= get_symbol_initial_value
375 (ob
->decl_state
->symtab_node_encoder
, expr
);
376 stream_write_tree (ob
, initial
, ref_p
);
380 /* Write a physical representation of tree node EXPR to output block
381 OB. If REF_P is true, the leaves of EXPR are emitted as references
382 via lto_output_tree_ref. IX is the index into the streamer cache
383 where EXPR is stored. */
386 lto_write_tree (struct output_block
*ob
, tree expr
, bool ref_p
)
388 if (!lto_is_streamable (expr
))
389 internal_error ("tree code %qs is not supported in LTO streams",
390 get_tree_code_name (TREE_CODE (expr
)));
392 /* Write the header, containing everything needed to materialize
393 EXPR on the reading side. */
394 streamer_write_tree_header (ob
, expr
);
396 lto_write_tree_1 (ob
, expr
, ref_p
);
398 /* Mark the end of EXPR. */
399 streamer_write_zero (ob
);
402 /* Emit the physical representation of tree node EXPR to output block
403 OB. If THIS_REF_P is true, the leaves of EXPR are emitted as references
404 via lto_output_tree_ref. REF_P is used for streaming siblings of EXPR. */
407 lto_output_tree_1 (struct output_block
*ob
, tree expr
, hashval_t hash
,
408 bool ref_p
, bool this_ref_p
)
412 gcc_checking_assert (expr
!= NULL_TREE
413 && !(this_ref_p
&& tree_is_indexable (expr
)));
415 bool exists_p
= streamer_tree_cache_insert (ob
->writer_cache
,
417 gcc_assert (!exists_p
);
418 if (streamer_handle_as_builtin_p (expr
))
420 /* MD and NORMAL builtins do not need to be written out
421 completely as they are always instantiated by the
422 compiler on startup. The only builtins that need to
423 be written out are BUILT_IN_FRONTEND. For all other
424 builtins, we simply write the class and code. */
425 streamer_write_builtin (ob
, expr
);
427 else if (TREE_CODE (expr
) == INTEGER_CST
428 && !TREE_OVERFLOW (expr
))
430 /* Shared INTEGER_CST nodes are special because they need their
431 original type to be materialized by the reader (to implement
432 TYPE_CACHED_VALUES). */
433 streamer_write_integer_cst (ob
, expr
, ref_p
);
437 /* This is the first time we see EXPR, write its fields
439 lto_write_tree (ob
, expr
, ref_p
);
455 static unsigned int next_dfs_num
;
456 static vec
<scc_entry
> sccstack
;
457 static struct pointer_map_t
*sccstate
;
458 static struct obstack sccstate_obstack
;
461 DFS_write_tree (struct output_block
*ob
, sccs
*from_state
,
462 tree expr
, bool ref_p
, bool this_ref_p
);
464 /* Handle the tree EXPR in the DFS walk with SCC state EXPR_STATE and
465 DFS recurse for all tree edges originating from it. */
468 DFS_write_tree_body (struct output_block
*ob
,
469 tree expr
, sccs
*expr_state
, bool ref_p
)
471 #define DFS_follow_tree_edge(DEST) \
472 DFS_write_tree (ob, expr_state, DEST, ref_p, ref_p)
476 code
= TREE_CODE (expr
);
478 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
480 if (TREE_CODE (expr
) != IDENTIFIER_NODE
)
481 DFS_follow_tree_edge (TREE_TYPE (expr
));
484 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
486 for (unsigned i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
487 DFS_follow_tree_edge (VECTOR_CST_ELT (expr
, i
));
490 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
492 DFS_follow_tree_edge (TREE_REALPART (expr
));
493 DFS_follow_tree_edge (TREE_IMAGPART (expr
));
496 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
498 /* Drop names that were created for anonymous entities. */
500 && TREE_CODE (DECL_NAME (expr
)) == IDENTIFIER_NODE
501 && ANON_AGGRNAME_P (DECL_NAME (expr
)))
504 DFS_follow_tree_edge (DECL_NAME (expr
));
505 DFS_follow_tree_edge (DECL_CONTEXT (expr
));
508 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
510 DFS_follow_tree_edge (DECL_SIZE (expr
));
511 DFS_follow_tree_edge (DECL_SIZE_UNIT (expr
));
513 /* Note, DECL_INITIAL is not handled here. Since DECL_INITIAL needs
514 special handling in LTO, it must be handled by streamer hooks. */
516 DFS_follow_tree_edge (DECL_ATTRIBUTES (expr
));
518 /* Do not follow DECL_ABSTRACT_ORIGIN. We cannot handle debug information
519 for early inlining so drop it on the floor instead of ICEing in
522 if ((TREE_CODE (expr
) == VAR_DECL
523 || TREE_CODE (expr
) == PARM_DECL
)
524 && DECL_HAS_VALUE_EXPR_P (expr
))
525 DFS_follow_tree_edge (DECL_VALUE_EXPR (expr
));
526 if (TREE_CODE (expr
) == VAR_DECL
)
527 DFS_follow_tree_edge (DECL_DEBUG_EXPR (expr
));
530 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
532 if (TREE_CODE (expr
) == TYPE_DECL
)
533 DFS_follow_tree_edge (DECL_ORIGINAL_TYPE (expr
));
536 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
538 /* Make sure we don't inadvertently set the assembler name. */
539 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
540 DFS_follow_tree_edge (DECL_ASSEMBLER_NAME (expr
));
543 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
545 DFS_follow_tree_edge (DECL_FIELD_OFFSET (expr
));
546 DFS_follow_tree_edge (DECL_BIT_FIELD_TYPE (expr
));
547 DFS_follow_tree_edge (DECL_BIT_FIELD_REPRESENTATIVE (expr
));
548 DFS_follow_tree_edge (DECL_FIELD_BIT_OFFSET (expr
));
549 DFS_follow_tree_edge (DECL_FCONTEXT (expr
));
552 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
554 DFS_follow_tree_edge (DECL_VINDEX (expr
));
555 DFS_follow_tree_edge (DECL_FUNCTION_PERSONALITY (expr
));
556 /* Do not DECL_FUNCTION_SPECIFIC_TARGET. They will be regenerated. */
557 DFS_follow_tree_edge (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr
));
560 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
562 DFS_follow_tree_edge (TYPE_SIZE (expr
));
563 DFS_follow_tree_edge (TYPE_SIZE_UNIT (expr
));
564 DFS_follow_tree_edge (TYPE_ATTRIBUTES (expr
));
565 DFS_follow_tree_edge (TYPE_NAME (expr
));
566 /* Do not follow TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
567 reconstructed during fixup. */
568 /* Do not follow TYPE_NEXT_VARIANT, we reconstruct the variant lists
570 DFS_follow_tree_edge (TYPE_MAIN_VARIANT (expr
));
571 DFS_follow_tree_edge (TYPE_CONTEXT (expr
));
572 /* TYPE_CANONICAL is re-computed during type merging, so no need
573 to follow it here. */
574 DFS_follow_tree_edge (TYPE_STUB_DECL (expr
));
577 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
579 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
580 DFS_follow_tree_edge (TYPE_VALUES (expr
));
581 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
582 DFS_follow_tree_edge (TYPE_DOMAIN (expr
));
583 else if (RECORD_OR_UNION_TYPE_P (expr
))
584 for (tree t
= TYPE_FIELDS (expr
); t
; t
= TREE_CHAIN (t
))
585 DFS_follow_tree_edge (t
);
586 else if (TREE_CODE (expr
) == FUNCTION_TYPE
587 || TREE_CODE (expr
) == METHOD_TYPE
)
588 DFS_follow_tree_edge (TYPE_ARG_TYPES (expr
));
590 if (!POINTER_TYPE_P (expr
))
591 DFS_follow_tree_edge (TYPE_MINVAL (expr
));
592 DFS_follow_tree_edge (TYPE_MAXVAL (expr
));
593 if (RECORD_OR_UNION_TYPE_P (expr
))
594 DFS_follow_tree_edge (TYPE_BINFO (expr
));
597 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
599 DFS_follow_tree_edge (TREE_PURPOSE (expr
));
600 DFS_follow_tree_edge (TREE_VALUE (expr
));
601 DFS_follow_tree_edge (TREE_CHAIN (expr
));
604 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
606 for (int i
= 0; i
< TREE_VEC_LENGTH (expr
); i
++)
607 DFS_follow_tree_edge (TREE_VEC_ELT (expr
, i
));
610 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
612 for (int i
= 0; i
< TREE_OPERAND_LENGTH (expr
); i
++)
613 DFS_follow_tree_edge (TREE_OPERAND (expr
, i
));
614 DFS_follow_tree_edge (TREE_BLOCK (expr
));
617 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
619 for (tree t
= BLOCK_VARS (expr
); t
; t
= TREE_CHAIN (t
))
620 /* ??? FIXME. See also streamer_write_chain. */
621 if (!(VAR_OR_FUNCTION_DECL_P (t
)
622 && DECL_EXTERNAL (t
)))
623 DFS_follow_tree_edge (t
);
625 DFS_follow_tree_edge (BLOCK_SUPERCONTEXT (expr
));
627 /* Follow BLOCK_ABSTRACT_ORIGIN for the limited cases we can
628 handle - those that represent inlined function scopes.
629 For the drop rest them on the floor instead of ICEing
631 if (inlined_function_outer_scope_p (expr
))
633 tree ultimate_origin
= block_ultimate_origin (expr
);
634 DFS_follow_tree_edge (ultimate_origin
);
636 /* Do not follow BLOCK_NONLOCALIZED_VARS. We cannot handle debug
637 information for early inlined BLOCKs so drop it on the floor instead
638 of ICEing in dwarf2out.c. */
640 /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
643 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
644 list is re-constructed from BLOCK_SUPERCONTEXT. */
647 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
652 /* Note that the number of BINFO slots has already been emitted in
653 EXPR's header (see streamer_write_tree_header) because this length
654 is needed to build the empty BINFO node on the reader side. */
655 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr
), i
, t
)
656 DFS_follow_tree_edge (t
);
657 DFS_follow_tree_edge (BINFO_OFFSET (expr
));
658 DFS_follow_tree_edge (BINFO_VTABLE (expr
));
659 DFS_follow_tree_edge (BINFO_VPTR_FIELD (expr
));
661 /* The number of BINFO_BASE_ACCESSES has already been emitted in
662 EXPR's bitfield section. */
663 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (expr
), i
, t
)
664 DFS_follow_tree_edge (t
);
666 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
667 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
670 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
675 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr
), i
, index
, value
)
677 DFS_follow_tree_edge (index
);
678 DFS_follow_tree_edge (value
);
682 if (code
== OMP_CLAUSE
)
685 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (expr
)]; i
++)
686 DFS_follow_tree_edge (OMP_CLAUSE_OPERAND (expr
, i
));
687 DFS_follow_tree_edge (OMP_CLAUSE_CHAIN (expr
));
690 #undef DFS_follow_tree_edge
693 /* Return a hash value for the tree T. */
696 hash_tree (struct streamer_tree_cache_d
*cache
, tree t
)
700 #define visit(SIBLING) \
703 if (SIBLING && streamer_tree_cache_lookup (cache, SIBLING, &ix)) \
704 hstate.add_int (streamer_tree_cache_get_hash (cache, ix)); \
708 enum tree_code code
= TREE_CODE (t
);
709 hstate
.add_int (code
);
712 hstate
.add_flag (TREE_SIDE_EFFECTS (t
));
713 hstate
.add_flag (TREE_CONSTANT (t
));
714 hstate
.add_flag (TREE_READONLY (t
));
715 hstate
.add_flag (TREE_PUBLIC (t
));
717 hstate
.add_flag (TREE_ADDRESSABLE (t
));
718 hstate
.add_flag (TREE_THIS_VOLATILE (t
));
720 hstate
.add_flag (DECL_UNSIGNED (t
));
722 hstate
.add_flag (TYPE_UNSIGNED (t
));
724 hstate
.add_flag (TYPE_ARTIFICIAL (t
));
726 hstate
.add_flag (TREE_NO_WARNING (t
));
727 hstate
.add_flag (TREE_NOTHROW (t
));
728 hstate
.add_flag (TREE_STATIC (t
));
729 hstate
.add_flag (TREE_PROTECTED (t
));
730 hstate
.add_flag (TREE_DEPRECATED (t
));
731 if (code
!= TREE_BINFO
)
732 hstate
.add_flag (TREE_PRIVATE (t
));
735 hstate
.add_flag (TYPE_SATURATING (t
));
736 hstate
.add_flag (TYPE_ADDR_SPACE (t
));
738 else if (code
== SSA_NAME
)
739 hstate
.add_flag (SSA_NAME_IS_DEFAULT_DEF (t
));
740 hstate
.commit_flag ();
742 if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
745 hstate
.add_wide_int (TREE_INT_CST_NUNITS (t
));
746 hstate
.add_wide_int (TREE_INT_CST_EXT_NUNITS (t
));
747 for (i
= 0; i
< TREE_INT_CST_NUNITS (t
); i
++)
748 hstate
.add_wide_int (TREE_INT_CST_ELT (t
, i
));
751 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
753 REAL_VALUE_TYPE r
= TREE_REAL_CST (t
);
754 hstate
.add_flag (r
.cl
);
755 hstate
.add_flag (r
.sign
);
756 hstate
.add_flag (r
.signalling
);
757 hstate
.add_flag (r
.canonical
);
758 hstate
.commit_flag ();
759 hstate
.add_int (r
.uexp
);
760 hstate
.add (r
.sig
, sizeof (r
.sig
));
763 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
765 FIXED_VALUE_TYPE f
= TREE_FIXED_CST (t
);
766 hstate
.add_int (f
.mode
);
767 hstate
.add_int (f
.data
.low
);
768 hstate
.add_int (f
.data
.high
);
771 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
773 hstate
.add_wide_int (DECL_MODE (t
));
774 hstate
.add_flag (DECL_NONLOCAL (t
));
775 hstate
.add_flag (DECL_VIRTUAL_P (t
));
776 hstate
.add_flag (DECL_IGNORED_P (t
));
777 hstate
.add_flag (DECL_ABSTRACT (t
));
778 hstate
.add_flag (DECL_ARTIFICIAL (t
));
779 hstate
.add_flag (DECL_USER_ALIGN (t
));
780 hstate
.add_flag (DECL_PRESERVE_P (t
));
781 hstate
.add_flag (DECL_EXTERNAL (t
));
782 hstate
.add_flag (DECL_GIMPLE_REG_P (t
));
783 hstate
.commit_flag ();
784 hstate
.add_int (DECL_ALIGN (t
));
785 if (code
== LABEL_DECL
)
787 hstate
.add_int (EH_LANDING_PAD_NR (t
));
788 hstate
.add_int (LABEL_DECL_UID (t
));
790 else if (code
== FIELD_DECL
)
792 hstate
.add_flag (DECL_PACKED (t
));
793 hstate
.add_flag (DECL_NONADDRESSABLE_P (t
));
794 hstate
.add_int (DECL_OFFSET_ALIGN (t
));
796 else if (code
== VAR_DECL
)
798 hstate
.add_flag (DECL_HAS_DEBUG_EXPR_P (t
));
799 hstate
.add_flag (DECL_NONLOCAL_FRAME (t
));
801 if (code
== RESULT_DECL
805 hstate
.add_flag (DECL_BY_REFERENCE (t
));
807 || code
== PARM_DECL
)
808 hstate
.add_flag (DECL_HAS_VALUE_EXPR_P (t
));
810 hstate
.commit_flag ();
813 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
814 hstate
.add_int (DECL_REGISTER (t
));
816 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
818 hstate
.add_flag (DECL_COMMON (t
));
819 hstate
.add_flag (DECL_DLLIMPORT_P (t
));
820 hstate
.add_flag (DECL_WEAK (t
));
821 hstate
.add_flag (DECL_SEEN_IN_BIND_EXPR_P (t
));
822 hstate
.add_flag (DECL_COMDAT (t
));
823 hstate
.add_flag (DECL_VISIBILITY_SPECIFIED (t
));
824 hstate
.add_int (DECL_VISIBILITY (t
));
825 if (code
== VAR_DECL
)
827 /* DECL_IN_TEXT_SECTION is set during final asm output only. */
828 hstate
.add_flag (DECL_HARD_REGISTER (t
));
829 hstate
.add_flag (DECL_IN_CONSTANT_POOL (t
));
831 if (TREE_CODE (t
) == FUNCTION_DECL
)
833 hstate
.add_flag (DECL_FINAL_P (t
));
834 hstate
.add_flag (DECL_CXX_CONSTRUCTOR_P (t
));
835 hstate
.add_flag (DECL_CXX_DESTRUCTOR_P (t
));
837 hstate
.commit_flag ();
840 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
842 hstate
.add_int (DECL_BUILT_IN_CLASS (t
));
843 hstate
.add_flag (DECL_STATIC_CONSTRUCTOR (t
));
844 hstate
.add_flag (DECL_STATIC_DESTRUCTOR (t
));
845 hstate
.add_flag (DECL_UNINLINABLE (t
));
846 hstate
.add_flag (DECL_POSSIBLY_INLINED (t
));
847 hstate
.add_flag (DECL_IS_NOVOPS (t
));
848 hstate
.add_flag (DECL_IS_RETURNS_TWICE (t
));
849 hstate
.add_flag (DECL_IS_MALLOC (t
));
850 hstate
.add_flag (DECL_IS_OPERATOR_NEW (t
));
851 hstate
.add_flag (DECL_DECLARED_INLINE_P (t
));
852 hstate
.add_flag (DECL_STATIC_CHAIN (t
));
853 hstate
.add_flag (DECL_NO_INLINE_WARNING_P (t
));
854 hstate
.add_flag (DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (t
));
855 hstate
.add_flag (DECL_NO_LIMIT_STACK (t
));
856 hstate
.add_flag (DECL_DISREGARD_INLINE_LIMITS (t
));
857 hstate
.add_flag (DECL_PURE_P (t
));
858 hstate
.add_flag (DECL_LOOPING_CONST_OR_PURE_P (t
));
859 hstate
.commit_flag ();
860 if (DECL_BUILT_IN_CLASS (t
) != NOT_BUILT_IN
)
861 hstate
.add_int (DECL_FUNCTION_CODE (t
));
864 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
866 hstate
.add_wide_int (TYPE_MODE (t
));
867 hstate
.add_flag (TYPE_STRING_FLAG (t
));
868 hstate
.add_flag (TYPE_NO_FORCE_BLK (t
));
869 hstate
.add_flag (TYPE_NEEDS_CONSTRUCTING (t
));
870 hstate
.add_flag (TYPE_PACKED (t
));
871 hstate
.add_flag (TYPE_RESTRICT (t
));
872 hstate
.add_flag (TYPE_USER_ALIGN (t
));
873 hstate
.add_flag (TYPE_READONLY (t
));
874 if (RECORD_OR_UNION_TYPE_P (t
))
876 hstate
.add_flag (TYPE_TRANSPARENT_AGGR (t
));
877 hstate
.add_flag (TYPE_FINAL_P (t
));
879 else if (code
== ARRAY_TYPE
)
880 hstate
.add_flag (TYPE_NONALIASED_COMPONENT (t
));
881 hstate
.commit_flag ();
882 hstate
.add_int (TYPE_PRECISION (t
));
883 hstate
.add_int (TYPE_ALIGN (t
));
884 hstate
.add_int ((TYPE_ALIAS_SET (t
) == 0
886 && get_alias_set (t
) == 0))
890 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
891 hstate
.add (TRANSLATION_UNIT_LANGUAGE (t
),
892 strlen (TRANSLATION_UNIT_LANGUAGE (t
)));
894 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
))
897 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
898 hstate
.add (t
, sizeof (struct cl_optimization
));
900 if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
901 hstate
.merge_hash (IDENTIFIER_HASH_VALUE (t
));
903 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
904 hstate
.add (TREE_STRING_POINTER (t
), TREE_STRING_LENGTH (t
));
906 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
908 if (POINTER_TYPE_P (t
))
910 /* For pointers factor in the pointed-to type recursively as
911 we cannot recurse through only pointers.
912 ??? We can generalize this by keeping track of the
913 in-SCC edges for each tree (or arbitrarily the first
914 such edge) and hashing that in in a second stage
915 (instead of the quadratic mixing of the SCC we do now). */
918 if (streamer_tree_cache_lookup (cache
, TREE_TYPE (t
), &ix
))
919 x
= streamer_tree_cache_get_hash (cache
, ix
);
921 x
= hash_tree (cache
, TREE_TYPE (t
));
922 hstate
.merge_hash (x
);
924 else if (code
!= IDENTIFIER_NODE
)
925 visit (TREE_TYPE (t
));
928 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
929 for (unsigned i
= 0; i
< VECTOR_CST_NELTS (t
); ++i
)
930 visit (VECTOR_CST_ELT (t
, i
));
932 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
934 visit (TREE_REALPART (t
));
935 visit (TREE_IMAGPART (t
));
938 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
940 /* Drop names that were created for anonymous entities. */
942 && TREE_CODE (DECL_NAME (t
)) == IDENTIFIER_NODE
943 && ANON_AGGRNAME_P (DECL_NAME (t
)))
946 visit (DECL_NAME (t
));
947 if (DECL_FILE_SCOPE_P (t
))
950 visit (DECL_CONTEXT (t
));
953 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
955 visit (DECL_SIZE (t
));
956 visit (DECL_SIZE_UNIT (t
));
957 visit (DECL_ATTRIBUTES (t
));
958 if ((code
== VAR_DECL
959 || code
== PARM_DECL
)
960 && DECL_HAS_VALUE_EXPR_P (t
))
961 visit (DECL_VALUE_EXPR (t
));
963 && DECL_HAS_DEBUG_EXPR_P (t
))
964 visit (DECL_DEBUG_EXPR (t
));
965 /* ??? Hash DECL_INITIAL as streamed. Needs the output-block to
966 be able to call get_symbol_initial_value. */
969 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
971 if (code
== TYPE_DECL
)
972 visit (DECL_ORIGINAL_TYPE (t
));
975 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
977 if (DECL_ASSEMBLER_NAME_SET_P (t
))
978 visit (DECL_ASSEMBLER_NAME (t
));
981 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
983 visit (DECL_FIELD_OFFSET (t
));
984 visit (DECL_BIT_FIELD_TYPE (t
));
985 visit (DECL_BIT_FIELD_REPRESENTATIVE (t
));
986 visit (DECL_FIELD_BIT_OFFSET (t
));
987 visit (DECL_FCONTEXT (t
));
990 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
992 visit (DECL_VINDEX (t
));
993 visit (DECL_FUNCTION_PERSONALITY (t
));
994 /* Do not follow DECL_FUNCTION_SPECIFIC_TARGET. */
995 visit (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t
));
998 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
1000 visit (TYPE_SIZE (t
));
1001 visit (TYPE_SIZE_UNIT (t
));
1002 visit (TYPE_ATTRIBUTES (t
));
1003 visit (TYPE_NAME (t
));
1004 visit (TYPE_MAIN_VARIANT (t
));
1005 if (TYPE_FILE_SCOPE_P (t
))
1008 visit (TYPE_CONTEXT (t
));
1009 visit (TYPE_STUB_DECL (t
));
1012 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
1014 if (code
== ENUMERAL_TYPE
)
1015 visit (TYPE_VALUES (t
));
1016 else if (code
== ARRAY_TYPE
)
1017 visit (TYPE_DOMAIN (t
));
1018 else if (RECORD_OR_UNION_TYPE_P (t
))
1019 for (tree f
= TYPE_FIELDS (t
); f
; f
= TREE_CHAIN (f
))
1021 else if (code
== FUNCTION_TYPE
1022 || code
== METHOD_TYPE
)
1023 visit (TYPE_ARG_TYPES (t
));
1024 if (!POINTER_TYPE_P (t
))
1025 visit (TYPE_MINVAL (t
));
1026 visit (TYPE_MAXVAL (t
));
1027 if (RECORD_OR_UNION_TYPE_P (t
))
1028 visit (TYPE_BINFO (t
));
1031 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
1033 visit (TREE_PURPOSE (t
));
1034 visit (TREE_VALUE (t
));
1035 visit (TREE_CHAIN (t
));
1038 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1039 for (int i
= 0; i
< TREE_VEC_LENGTH (t
); ++i
)
1040 visit (TREE_VEC_ELT (t
, i
));
1042 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
1044 hstate
.add_wide_int (TREE_OPERAND_LENGTH (t
));
1045 for (int i
= 0; i
< TREE_OPERAND_LENGTH (t
); ++i
)
1046 visit (TREE_OPERAND (t
, i
));
1049 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1053 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (t
), i
, b
)
1055 visit (BINFO_OFFSET (t
));
1056 visit (BINFO_VTABLE (t
));
1057 visit (BINFO_VPTR_FIELD (t
));
1058 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (t
), i
, b
)
1060 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
1061 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
1064 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1068 hstate
.add_wide_int (CONSTRUCTOR_NELTS (t
));
1069 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), i
, index
, value
)
1076 if (code
== OMP_CLAUSE
)
1081 hstate
.add_wide_int (OMP_CLAUSE_CODE (t
));
1082 switch (OMP_CLAUSE_CODE (t
))
1084 case OMP_CLAUSE_DEFAULT
:
1085 val
= OMP_CLAUSE_DEFAULT_KIND (t
);
1087 case OMP_CLAUSE_SCHEDULE
:
1088 val
= OMP_CLAUSE_SCHEDULE_KIND (t
);
1090 case OMP_CLAUSE_DEPEND
:
1091 val
= OMP_CLAUSE_DEPEND_KIND (t
);
1093 case OMP_CLAUSE_MAP
:
1094 val
= OMP_CLAUSE_MAP_KIND (t
);
1096 case OMP_CLAUSE_PROC_BIND
:
1097 val
= OMP_CLAUSE_PROC_BIND_KIND (t
);
1099 case OMP_CLAUSE_REDUCTION
:
1100 val
= OMP_CLAUSE_REDUCTION_CODE (t
);
1106 hstate
.add_wide_int (val
);
1107 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (t
)]; i
++)
1108 visit (OMP_CLAUSE_OPERAND (t
, i
));
1109 visit (OMP_CLAUSE_CHAIN (t
));
1112 return hstate
.end ();
1117 /* Compare two SCC entries by their hash value for qsorting them. */
1120 scc_entry_compare (const void *p1_
, const void *p2_
)
1122 const scc_entry
*p1
= (const scc_entry
*) p1_
;
1123 const scc_entry
*p2
= (const scc_entry
*) p2_
;
1124 if (p1
->hash
< p2
->hash
)
1126 else if (p1
->hash
> p2
->hash
)
1131 /* Return a hash value for the SCC on the SCC stack from FIRST with
1135 hash_scc (struct streamer_tree_cache_d
*cache
, unsigned first
, unsigned size
)
1137 /* Compute hash values for the SCC members. */
1138 for (unsigned i
= 0; i
< size
; ++i
)
1139 sccstack
[first
+i
].hash
= hash_tree (cache
, sccstack
[first
+i
].t
);
1142 return sccstack
[first
].hash
;
1144 /* Sort the SCC of type, hash pairs so that when we mix in
1145 all members of the SCC the hash value becomes independent on
1146 the order we visited the SCC. Produce hash of the whole SCC as
1147 combination of hashes of individual elements. Then combine that hash into
1148 hash of each element, so othewise identically looking elements from two
1149 different SCCs are distinguished. */
1150 qsort (&sccstack
[first
], size
, sizeof (scc_entry
), scc_entry_compare
);
1152 hashval_t scc_hash
= sccstack
[first
].hash
;
1153 for (unsigned i
= 1; i
< size
; ++i
)
1154 scc_hash
= iterative_hash_hashval_t (scc_hash
,
1155 sccstack
[first
+i
].hash
);
1156 for (unsigned i
= 0; i
< size
; ++i
)
1157 sccstack
[first
+i
].hash
= iterative_hash_hashval_t (sccstack
[first
+i
].hash
, scc_hash
);
1161 /* DFS walk EXPR and stream SCCs of tree bodies if they are not
1162 already in the streamer cache. Main routine called for
1163 each visit of EXPR. */
1166 DFS_write_tree (struct output_block
*ob
, sccs
*from_state
,
1167 tree expr
, bool ref_p
, bool this_ref_p
)
1172 /* Handle special cases. */
1173 if (expr
== NULL_TREE
)
1176 /* Do not DFS walk into indexable trees. */
1177 if (this_ref_p
&& tree_is_indexable (expr
))
1180 /* Check if we already streamed EXPR. */
1181 if (streamer_tree_cache_lookup (ob
->writer_cache
, expr
, &ix
))
1184 slot
= (sccs
**)pointer_map_insert (sccstate
, expr
);
1185 sccs
*cstate
= *slot
;
1188 scc_entry e
= { expr
, 0 };
1189 /* Not yet visited. DFS recurse and push it onto the stack. */
1190 *slot
= cstate
= XOBNEW (&sccstate_obstack
, struct sccs
);
1191 sccstack
.safe_push (e
);
1192 cstate
->dfsnum
= next_dfs_num
++;
1193 cstate
->low
= cstate
->dfsnum
;
1195 if (streamer_handle_as_builtin_p (expr
))
1197 else if (TREE_CODE (expr
) == INTEGER_CST
1198 && !TREE_OVERFLOW (expr
))
1199 DFS_write_tree (ob
, cstate
, TREE_TYPE (expr
), ref_p
, ref_p
);
1202 DFS_write_tree_body (ob
, expr
, cstate
, ref_p
);
1204 /* Walk any LTO-specific edges. */
1206 && TREE_CODE (expr
) != FUNCTION_DECL
1207 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
1209 /* Handle DECL_INITIAL for symbols. */
1210 tree initial
= get_symbol_initial_value (ob
->decl_state
->symtab_node_encoder
,
1212 DFS_write_tree (ob
, cstate
, initial
, ref_p
, ref_p
);
1216 /* See if we found an SCC. */
1217 if (cstate
->low
== cstate
->dfsnum
)
1219 unsigned first
, size
;
1222 /* Pop the SCC and compute its size. */
1223 first
= sccstack
.length ();
1226 x
= sccstack
[--first
].t
;
1229 size
= sccstack
.length () - first
;
1231 /* No need to compute hashes for LTRANS units, we don't perform
1232 any merging there. */
1233 hashval_t scc_hash
= 0;
1234 unsigned scc_entry_len
= 0;
1237 scc_hash
= hash_scc (ob
->writer_cache
, first
, size
);
1239 /* Put the entries with the least number of collisions first. */
1240 unsigned entry_start
= 0;
1241 scc_entry_len
= size
+ 1;
1242 for (unsigned i
= 0; i
< size
;)
1245 for (i
= i
+ 1; i
< size
1246 && (sccstack
[first
+ i
].hash
1247 == sccstack
[first
+ from
].hash
); ++i
)
1249 if (i
- from
< scc_entry_len
)
1251 scc_entry_len
= i
- from
;
1255 for (unsigned i
= 0; i
< scc_entry_len
; ++i
)
1257 scc_entry tem
= sccstack
[first
+ i
];
1258 sccstack
[first
+ i
] = sccstack
[first
+ entry_start
+ i
];
1259 sccstack
[first
+ entry_start
+ i
] = tem
;
1263 /* Write LTO_tree_scc. */
1264 streamer_write_record_start (ob
, LTO_tree_scc
);
1265 streamer_write_uhwi (ob
, size
);
1266 streamer_write_uhwi (ob
, scc_hash
);
1268 /* Write size-1 SCCs without wrapping them inside SCC bundles.
1269 All INTEGER_CSTs need to be handled this way as we need
1270 their type to materialize them. Also builtins are handled
1272 ??? We still wrap these in LTO_tree_scc so at the
1273 input side we can properly identify the tree we want
1274 to ultimatively return. */
1276 lto_output_tree_1 (ob
, expr
, scc_hash
, ref_p
, this_ref_p
);
1279 /* Write the size of the SCC entry candidates. */
1280 streamer_write_uhwi (ob
, scc_entry_len
);
1282 /* Write all headers and populate the streamer cache. */
1283 for (unsigned i
= 0; i
< size
; ++i
)
1285 hashval_t hash
= sccstack
[first
+i
].hash
;
1286 tree t
= sccstack
[first
+i
].t
;
1287 bool exists_p
= streamer_tree_cache_insert (ob
->writer_cache
,
1289 gcc_assert (!exists_p
);
1291 if (!lto_is_streamable (t
))
1292 internal_error ("tree code %qs is not supported "
1294 get_tree_code_name (TREE_CODE (t
)));
1296 gcc_checking_assert (!streamer_handle_as_builtin_p (t
));
1298 /* Write the header, containing everything needed to
1299 materialize EXPR on the reading side. */
1300 streamer_write_tree_header (ob
, t
);
1303 /* Write the bitpacks and tree references. */
1304 for (unsigned i
= 0; i
< size
; ++i
)
1306 lto_write_tree_1 (ob
, sccstack
[first
+i
].t
, ref_p
);
1308 /* Mark the end of the tree. */
1309 streamer_write_zero (ob
);
1313 /* Finally truncate the vector. */
1314 sccstack
.truncate (first
);
1317 from_state
->low
= MIN (from_state
->low
, cstate
->low
);
1322 from_state
->low
= MIN (from_state
->low
, cstate
->low
);
1324 gcc_checking_assert (from_state
);
1325 if (cstate
->dfsnum
< from_state
->dfsnum
)
1326 from_state
->low
= MIN (cstate
->dfsnum
, from_state
->low
);
1330 /* Emit the physical representation of tree node EXPR to output block
1331 OB. If THIS_REF_P is true, the leaves of EXPR are emitted as references
1332 via lto_output_tree_ref. REF_P is used for streaming siblings of EXPR. */
1335 lto_output_tree (struct output_block
*ob
, tree expr
,
1336 bool ref_p
, bool this_ref_p
)
1341 if (expr
== NULL_TREE
)
1343 streamer_write_record_start (ob
, LTO_null
);
1347 if (this_ref_p
&& tree_is_indexable (expr
))
1349 lto_output_tree_ref (ob
, expr
);
1353 existed_p
= streamer_tree_cache_lookup (ob
->writer_cache
, expr
, &ix
);
1356 /* If a node has already been streamed out, make sure that
1357 we don't write it more than once. Otherwise, the reader
1358 will instantiate two different nodes for the same object. */
1359 streamer_write_record_start (ob
, LTO_tree_pickle_reference
);
1360 streamer_write_uhwi (ob
, ix
);
1361 streamer_write_enum (ob
->main_stream
, LTO_tags
, LTO_NUM_TAGS
,
1362 lto_tree_code_to_tag (TREE_CODE (expr
)));
1363 lto_stats
.num_pickle_refs_output
++;
1367 /* This is the first time we see EXPR, write all reachable
1369 static bool in_dfs_walk
;
1371 /* Protect against recursion which means disconnect between
1372 what tree edges we walk in the DFS walk and what edges
1374 gcc_assert (!in_dfs_walk
);
1376 /* Start the DFS walk. */
1377 /* Save ob state ... */
1380 sccstate
= pointer_map_create ();
1381 gcc_obstack_init (&sccstate_obstack
);
1383 DFS_write_tree (ob
, NULL
, expr
, ref_p
, this_ref_p
);
1384 sccstack
.release ();
1385 pointer_map_destroy (sccstate
);
1386 obstack_free (&sccstate_obstack
, NULL
);
1387 in_dfs_walk
= false;
1389 /* Finally append a reference to the tree we were writing.
1390 ??? If expr ended up as a singleton we could have
1391 inlined it here and avoid outputting a reference. */
1392 existed_p
= streamer_tree_cache_lookup (ob
->writer_cache
, expr
, &ix
);
1393 gcc_assert (existed_p
);
1394 streamer_write_record_start (ob
, LTO_tree_pickle_reference
);
1395 streamer_write_uhwi (ob
, ix
);
1396 streamer_write_enum (ob
->main_stream
, LTO_tags
, LTO_NUM_TAGS
,
1397 lto_tree_code_to_tag (TREE_CODE (expr
)));
1398 lto_stats
.num_pickle_refs_output
++;
1403 /* Output to OB a list of try/catch handlers starting with FIRST. */
1406 output_eh_try_list (struct output_block
*ob
, eh_catch first
)
1410 for (n
= first
; n
; n
= n
->next_catch
)
1412 streamer_write_record_start (ob
, LTO_eh_catch
);
1413 stream_write_tree (ob
, n
->type_list
, true);
1414 stream_write_tree (ob
, n
->filter_list
, true);
1415 stream_write_tree (ob
, n
->label
, true);
1418 streamer_write_record_start (ob
, LTO_null
);
1422 /* Output EH region R in function FN to OB. CURR_RN is the slot index
1423 that is being emitted in FN->EH->REGION_ARRAY. This is used to
1424 detect EH region sharing. */
1427 output_eh_region (struct output_block
*ob
, eh_region r
)
1433 streamer_write_record_start (ob
, LTO_null
);
1437 if (r
->type
== ERT_CLEANUP
)
1438 tag
= LTO_ert_cleanup
;
1439 else if (r
->type
== ERT_TRY
)
1441 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
1442 tag
= LTO_ert_allowed_exceptions
;
1443 else if (r
->type
== ERT_MUST_NOT_THROW
)
1444 tag
= LTO_ert_must_not_throw
;
1448 streamer_write_record_start (ob
, tag
);
1449 streamer_write_hwi (ob
, r
->index
);
1452 streamer_write_hwi (ob
, r
->outer
->index
);
1454 streamer_write_zero (ob
);
1457 streamer_write_hwi (ob
, r
->inner
->index
);
1459 streamer_write_zero (ob
);
1462 streamer_write_hwi (ob
, r
->next_peer
->index
);
1464 streamer_write_zero (ob
);
1466 if (r
->type
== ERT_TRY
)
1468 output_eh_try_list (ob
, r
->u
.eh_try
.first_catch
);
1470 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
1472 stream_write_tree (ob
, r
->u
.allowed
.type_list
, true);
1473 stream_write_tree (ob
, r
->u
.allowed
.label
, true);
1474 streamer_write_uhwi (ob
, r
->u
.allowed
.filter
);
1476 else if (r
->type
== ERT_MUST_NOT_THROW
)
1478 stream_write_tree (ob
, r
->u
.must_not_throw
.failure_decl
, true);
1479 bitpack_d bp
= bitpack_create (ob
->main_stream
);
1480 stream_output_location (ob
, &bp
, r
->u
.must_not_throw
.failure_loc
);
1481 streamer_write_bitpack (&bp
);
1484 if (r
->landing_pads
)
1485 streamer_write_hwi (ob
, r
->landing_pads
->index
);
1487 streamer_write_zero (ob
);
1491 /* Output landing pad LP to OB. */
1494 output_eh_lp (struct output_block
*ob
, eh_landing_pad lp
)
1498 streamer_write_record_start (ob
, LTO_null
);
1502 streamer_write_record_start (ob
, LTO_eh_landing_pad
);
1503 streamer_write_hwi (ob
, lp
->index
);
1505 streamer_write_hwi (ob
, lp
->next_lp
->index
);
1507 streamer_write_zero (ob
);
1510 streamer_write_hwi (ob
, lp
->region
->index
);
1512 streamer_write_zero (ob
);
1514 stream_write_tree (ob
, lp
->post_landing_pad
, true);
1518 /* Output the existing eh_table to OB. */
1521 output_eh_regions (struct output_block
*ob
, struct function
*fn
)
1523 if (fn
->eh
&& fn
->eh
->region_tree
)
1530 streamer_write_record_start (ob
, LTO_eh_table
);
1532 /* Emit the index of the root of the EH region tree. */
1533 streamer_write_hwi (ob
, fn
->eh
->region_tree
->index
);
1535 /* Emit all the EH regions in the region array. */
1536 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->region_array
));
1537 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->region_array
, i
, eh
)
1538 output_eh_region (ob
, eh
);
1540 /* Emit all landing pads. */
1541 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->lp_array
));
1542 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->lp_array
, i
, lp
)
1543 output_eh_lp (ob
, lp
);
1545 /* Emit all the runtime type data. */
1546 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->ttype_data
));
1547 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->ttype_data
, i
, ttype
)
1548 stream_write_tree (ob
, ttype
, true);
1550 /* Emit the table of action chains. */
1551 if (targetm
.arm_eabi_unwinder
)
1554 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->ehspec_data
.arm_eabi
));
1555 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->ehspec_data
.arm_eabi
, i
, t
)
1556 stream_write_tree (ob
, t
, true);
1561 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->ehspec_data
.other
));
1562 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->ehspec_data
.other
, i
, c
)
1563 streamer_write_char_stream (ob
->main_stream
, c
);
1567 /* The LTO_null either terminates the record or indicates that there
1568 are no eh_records at all. */
1569 streamer_write_record_start (ob
, LTO_null
);
1573 /* Output all of the active ssa names to the ssa_names stream. */
1576 output_ssa_names (struct output_block
*ob
, struct function
*fn
)
1578 unsigned int i
, len
;
1580 len
= vec_safe_length (SSANAMES (fn
));
1581 streamer_write_uhwi (ob
, len
);
1583 for (i
= 1; i
< len
; i
++)
1585 tree ptr
= (*SSANAMES (fn
))[i
];
1587 if (ptr
== NULL_TREE
1588 || SSA_NAME_IN_FREE_LIST (ptr
)
1589 || virtual_operand_p (ptr
))
1592 streamer_write_uhwi (ob
, i
);
1593 streamer_write_char_stream (ob
->main_stream
,
1594 SSA_NAME_IS_DEFAULT_DEF (ptr
));
1595 if (SSA_NAME_VAR (ptr
))
1596 stream_write_tree (ob
, SSA_NAME_VAR (ptr
), true);
1598 /* ??? This drops SSA_NAME_IDENTIFIER on the floor. */
1599 stream_write_tree (ob
, TREE_TYPE (ptr
), true);
1602 streamer_write_zero (ob
);
1606 /* Output a wide-int. */
1609 streamer_write_wi (struct output_block
*ob
,
1610 const widest_int
&w
)
1612 int len
= w
.get_len ();
1614 streamer_write_uhwi (ob
, w
.get_precision ());
1615 streamer_write_uhwi (ob
, len
);
1616 for (int i
= 0; i
< len
; i
++)
1617 streamer_write_hwi (ob
, w
.elt (i
));
1621 /* Output the cfg. */
1624 output_cfg (struct output_block
*ob
, struct function
*fn
)
1626 struct lto_output_stream
*tmp_stream
= ob
->main_stream
;
1629 ob
->main_stream
= ob
->cfg_stream
;
1631 streamer_write_enum (ob
->main_stream
, profile_status_d
, PROFILE_LAST
,
1632 profile_status_for_fn (fn
));
1634 /* Output the number of the highest basic block. */
1635 streamer_write_uhwi (ob
, last_basic_block_for_fn (fn
));
1637 FOR_ALL_BB_FN (bb
, fn
)
1642 streamer_write_hwi (ob
, bb
->index
);
1644 /* Output the successors and the edge flags. */
1645 streamer_write_uhwi (ob
, EDGE_COUNT (bb
->succs
));
1646 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1648 streamer_write_uhwi (ob
, e
->dest
->index
);
1649 streamer_write_hwi (ob
, e
->probability
);
1650 streamer_write_gcov_count (ob
, e
->count
);
1651 streamer_write_uhwi (ob
, e
->flags
);
1655 streamer_write_hwi (ob
, -1);
1657 bb
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
1660 streamer_write_hwi (ob
, bb
->next_bb
->index
);
1664 streamer_write_hwi (ob
, -1);
1666 /* ??? The cfgloop interface is tied to cfun. */
1667 gcc_assert (cfun
== fn
);
1669 /* Output the number of loops. */
1670 streamer_write_uhwi (ob
, number_of_loops (fn
));
1672 /* Output each loop, skipping the tree root which has number zero. */
1673 for (unsigned i
= 1; i
< number_of_loops (fn
); ++i
)
1675 struct loop
*loop
= get_loop (fn
, i
);
1677 /* Write the index of the loop header. That's enough to rebuild
1678 the loop tree on the reader side. Stream -1 for an unused
1682 streamer_write_hwi (ob
, -1);
1686 streamer_write_hwi (ob
, loop
->header
->index
);
1688 /* Write everything copy_loop_info copies. */
1689 streamer_write_enum (ob
->main_stream
,
1690 loop_estimation
, EST_LAST
, loop
->estimate_state
);
1691 streamer_write_hwi (ob
, loop
->any_upper_bound
);
1692 if (loop
->any_upper_bound
)
1693 streamer_write_wi (ob
, loop
->nb_iterations_upper_bound
);
1694 streamer_write_hwi (ob
, loop
->any_estimate
);
1695 if (loop
->any_estimate
)
1696 streamer_write_wi (ob
, loop
->nb_iterations_estimate
);
1698 /* Write OMP SIMD related info. */
1699 streamer_write_hwi (ob
, loop
->safelen
);
1700 streamer_write_hwi (ob
, loop
->dont_vectorize
);
1701 streamer_write_hwi (ob
, loop
->force_vectorize
);
1702 stream_write_tree (ob
, loop
->simduid
, true);
1705 ob
->main_stream
= tmp_stream
;
1709 /* Create the header in the file using OB. If the section type is for
1710 a function, set FN to the decl for that function. */
1713 produce_asm (struct output_block
*ob
, tree fn
)
1715 enum lto_section_type section_type
= ob
->section_type
;
1716 struct lto_function_header header
;
1718 struct lto_output_stream
*header_stream
;
1720 if (section_type
== LTO_section_function_body
)
1722 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn
));
1723 section_name
= lto_get_section_name (section_type
, name
, NULL
);
1726 section_name
= lto_get_section_name (section_type
, NULL
, NULL
);
1728 lto_begin_section (section_name
, !flag_wpa
);
1729 free (section_name
);
1731 /* The entire header is stream computed here. */
1732 memset (&header
, 0, sizeof (struct lto_function_header
));
1734 /* Write the header. */
1735 header
.lto_header
.major_version
= LTO_major_version
;
1736 header
.lto_header
.minor_version
= LTO_minor_version
;
1738 header
.compressed_size
= 0;
1740 if (section_type
== LTO_section_function_body
)
1741 header
.cfg_size
= ob
->cfg_stream
->total_size
;
1742 header
.main_size
= ob
->main_stream
->total_size
;
1743 header
.string_size
= ob
->string_stream
->total_size
;
1745 header_stream
= XCNEW (struct lto_output_stream
);
1746 lto_output_data_stream (header_stream
, &header
, sizeof header
);
1747 lto_write_stream (header_stream
);
1748 free (header_stream
);
1750 /* Put all of the gimple and the string table out the asm file as a
1752 if (section_type
== LTO_section_function_body
)
1753 lto_write_stream (ob
->cfg_stream
);
1754 lto_write_stream (ob
->main_stream
);
1755 lto_write_stream (ob
->string_stream
);
1761 /* Output the base body of struct function FN using output block OB. */
1764 output_struct_function_base (struct output_block
*ob
, struct function
*fn
)
1766 struct bitpack_d bp
;
1770 /* Output the static chain and non-local goto save area. */
1771 stream_write_tree (ob
, fn
->static_chain_decl
, true);
1772 stream_write_tree (ob
, fn
->nonlocal_goto_save_area
, true);
1774 /* Output all the local variables in the function. */
1775 streamer_write_hwi (ob
, vec_safe_length (fn
->local_decls
));
1776 FOR_EACH_VEC_SAFE_ELT (fn
->local_decls
, i
, t
)
1777 stream_write_tree (ob
, t
, true);
1779 /* Output current IL state of the function. */
1780 streamer_write_uhwi (ob
, fn
->curr_properties
);
1782 /* Write all the attributes for FN. */
1783 bp
= bitpack_create (ob
->main_stream
);
1784 bp_pack_value (&bp
, fn
->is_thunk
, 1);
1785 bp_pack_value (&bp
, fn
->has_local_explicit_reg_vars
, 1);
1786 bp_pack_value (&bp
, fn
->returns_pcc_struct
, 1);
1787 bp_pack_value (&bp
, fn
->returns_struct
, 1);
1788 bp_pack_value (&bp
, fn
->can_throw_non_call_exceptions
, 1);
1789 bp_pack_value (&bp
, fn
->can_delete_dead_exceptions
, 1);
1790 bp_pack_value (&bp
, fn
->always_inline_functions_inlined
, 1);
1791 bp_pack_value (&bp
, fn
->after_inlining
, 1);
1792 bp_pack_value (&bp
, fn
->stdarg
, 1);
1793 bp_pack_value (&bp
, fn
->has_nonlocal_label
, 1);
1794 bp_pack_value (&bp
, fn
->calls_alloca
, 1);
1795 bp_pack_value (&bp
, fn
->calls_setjmp
, 1);
1796 bp_pack_value (&bp
, fn
->has_force_vectorize_loops
, 1);
1797 bp_pack_value (&bp
, fn
->has_simduid_loops
, 1);
1798 bp_pack_value (&bp
, fn
->va_list_fpr_size
, 8);
1799 bp_pack_value (&bp
, fn
->va_list_gpr_size
, 8);
1801 /* Output the function start and end loci. */
1802 stream_output_location (ob
, &bp
, fn
->function_start_locus
);
1803 stream_output_location (ob
, &bp
, fn
->function_end_locus
);
1805 streamer_write_bitpack (&bp
);
1809 /* Output the body of function NODE->DECL. */
1812 output_function (struct cgraph_node
*node
)
1815 struct function
*fn
;
1817 struct output_block
*ob
;
1819 function
= node
->decl
;
1820 fn
= DECL_STRUCT_FUNCTION (function
);
1821 ob
= create_output_block (LTO_section_function_body
);
1823 clear_line_info (ob
);
1826 gcc_assert (current_function_decl
== NULL_TREE
&& cfun
== NULL
);
1828 /* Set current_function_decl and cfun. */
1831 /* Make string 0 be a NULL string. */
1832 streamer_write_char_stream (ob
->string_stream
, 0);
1834 streamer_write_record_start (ob
, LTO_function
);
1836 /* Output decls for parameters and args. */
1837 stream_write_tree (ob
, DECL_RESULT (function
), true);
1838 streamer_write_chain (ob
, DECL_ARGUMENTS (function
), true);
1840 /* Output DECL_INITIAL for the function, which contains the tree of
1842 stream_write_tree (ob
, DECL_INITIAL (function
), true);
1844 /* We also stream abstract functions where we stream only stuff needed for
1846 if (gimple_has_body_p (function
))
1848 streamer_write_uhwi (ob
, 1);
1849 output_struct_function_base (ob
, fn
);
1851 /* Output all the SSA names used in the function. */
1852 output_ssa_names (ob
, fn
);
1854 /* Output any exception handling regions. */
1855 output_eh_regions (ob
, fn
);
1858 /* We will renumber the statements. The code that does this uses
1859 the same ordering that we use for serializing them so we can use
1860 the same code on the other end and not have to write out the
1861 statement numbers. We do not assign UIDs to PHIs here because
1862 virtual PHIs get re-computed on-the-fly which would make numbers
1864 set_gimple_stmt_max_uid (cfun
, 0);
1865 FOR_ALL_BB_FN (bb
, cfun
)
1867 gimple_stmt_iterator gsi
;
1868 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1870 gimple stmt
= gsi_stmt (gsi
);
1872 /* Virtual PHIs are not going to be streamed. */
1873 if (!virtual_operand_p (gimple_phi_result (stmt
)))
1874 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
1876 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1878 gimple stmt
= gsi_stmt (gsi
);
1879 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
1882 /* To avoid keeping duplicate gimple IDs in the statements, renumber
1883 virtual phis now. */
1884 FOR_ALL_BB_FN (bb
, cfun
)
1886 gimple_stmt_iterator gsi
;
1887 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1889 gimple stmt
= gsi_stmt (gsi
);
1890 if (virtual_operand_p (gimple_phi_result (stmt
)))
1891 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
1895 /* Output the code for the function. */
1896 FOR_ALL_BB_FN (bb
, fn
)
1897 output_bb (ob
, bb
, fn
);
1899 /* The terminator for this function. */
1900 streamer_write_record_start (ob
, LTO_null
);
1902 output_cfg (ob
, fn
);
1907 streamer_write_uhwi (ob
, 0);
1909 /* Create a section to hold the pickled output of this function. */
1910 produce_asm (ob
, function
);
1912 destroy_output_block (ob
);
1915 /* Output the body of function NODE->DECL. */
1918 output_constructor (struct varpool_node
*node
)
1920 tree var
= node
->decl
;
1921 struct output_block
*ob
;
1923 ob
= create_output_block (LTO_section_function_body
);
1925 clear_line_info (ob
);
1928 /* Make string 0 be a NULL string. */
1929 streamer_write_char_stream (ob
->string_stream
, 0);
1931 /* Output DECL_INITIAL for the function, which contains the tree of
1933 stream_write_tree (ob
, DECL_INITIAL (var
), true);
1935 /* Create a section to hold the pickled output of this function. */
1936 produce_asm (ob
, var
);
1938 destroy_output_block (ob
);
1942 /* Emit toplevel asms. */
1945 lto_output_toplevel_asms (void)
1947 struct output_block
*ob
;
1948 struct asm_node
*can
;
1950 struct lto_output_stream
*header_stream
;
1951 struct lto_asm_header header
;
1956 ob
= create_output_block (LTO_section_asm
);
1958 /* Make string 0 be a NULL string. */
1959 streamer_write_char_stream (ob
->string_stream
, 0);
1961 for (can
= asm_nodes
; can
; can
= can
->next
)
1963 streamer_write_string_cst (ob
, ob
->main_stream
, can
->asm_str
);
1964 streamer_write_hwi (ob
, can
->order
);
1967 streamer_write_string_cst (ob
, ob
->main_stream
, NULL_TREE
);
1969 section_name
= lto_get_section_name (LTO_section_asm
, NULL
, NULL
);
1970 lto_begin_section (section_name
, !flag_wpa
);
1971 free (section_name
);
1973 /* The entire header stream is computed here. */
1974 memset (&header
, 0, sizeof (header
));
1976 /* Write the header. */
1977 header
.lto_header
.major_version
= LTO_major_version
;
1978 header
.lto_header
.minor_version
= LTO_minor_version
;
1980 header
.main_size
= ob
->main_stream
->total_size
;
1981 header
.string_size
= ob
->string_stream
->total_size
;
1983 header_stream
= XCNEW (struct lto_output_stream
);
1984 lto_output_data_stream (header_stream
, &header
, sizeof (header
));
1985 lto_write_stream (header_stream
);
1986 free (header_stream
);
1988 /* Put all of the gimple and the string table out the asm file as a
1990 lto_write_stream (ob
->main_stream
);
1991 lto_write_stream (ob
->string_stream
);
1995 destroy_output_block (ob
);
1999 /* Copy the function body or variable constructor of NODE without deserializing. */
2002 copy_function_or_variable (struct symtab_node
*node
)
2004 tree function
= node
->decl
;
2005 struct lto_file_decl_data
*file_data
= node
->lto_file_data
;
2006 struct lto_output_stream
*output_stream
= XCNEW (struct lto_output_stream
);
2009 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function
));
2010 char *section_name
=
2011 lto_get_section_name (LTO_section_function_body
, name
, NULL
);
2013 struct lto_in_decl_state
*in_state
;
2014 struct lto_out_decl_state
*out_state
= lto_get_out_decl_state ();
2016 lto_begin_section (section_name
, !flag_wpa
);
2017 free (section_name
);
2019 /* We may have renamed the declaration, e.g., a static function. */
2020 name
= lto_get_decl_name_mapping (file_data
, name
);
2022 data
= lto_get_section_data (file_data
, LTO_section_function_body
,
2026 /* Do a bit copy of the function body. */
2027 lto_output_data_stream (output_stream
, data
, len
);
2028 lto_write_stream (output_stream
);
2032 lto_get_function_in_decl_state (node
->lto_file_data
, function
);
2033 gcc_assert (in_state
);
2035 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2037 size_t n
= in_state
->streams
[i
].size
;
2038 tree
*trees
= in_state
->streams
[i
].trees
;
2039 struct lto_tree_ref_encoder
*encoder
= &(out_state
->streams
[i
]);
2041 /* The out state must have the same indices and the in state.
2042 So just copy the vector. All the encoders in the in state
2043 must be empty where we reach here. */
2044 gcc_assert (lto_tree_ref_encoder_size (encoder
) == 0);
2045 encoder
->trees
.reserve_exact (n
);
2046 for (j
= 0; j
< n
; j
++)
2047 encoder
->trees
.safe_push (trees
[j
]);
2050 lto_free_section_data (file_data
, LTO_section_function_body
, name
,
2052 free (output_stream
);
2056 /* Wrap symbol references in *TP inside a type-preserving MEM_REF. */
2059 wrap_refs (tree
*tp
, int *ws
, void *)
2062 if (handled_component_p (t
)
2063 && TREE_CODE (TREE_OPERAND (t
, 0)) == VAR_DECL
)
2065 tree decl
= TREE_OPERAND (t
, 0);
2066 tree ptrtype
= build_pointer_type (TREE_TYPE (decl
));
2067 TREE_OPERAND (t
, 0) = build2 (MEM_REF
, TREE_TYPE (decl
),
2068 build1 (ADDR_EXPR
, ptrtype
, decl
),
2069 build_int_cst (ptrtype
, 0));
2070 TREE_THIS_VOLATILE (TREE_OPERAND (t
, 0)) = TREE_THIS_VOLATILE (decl
);
2073 else if (TREE_CODE (t
) == CONSTRUCTOR
)
2075 else if (!EXPR_P (t
))
2080 /* Main entry point from the pass manager. */
2085 struct lto_out_decl_state
*decl_state
;
2086 #ifdef ENABLE_CHECKING
2087 bitmap output
= lto_bitmap_alloc ();
2090 lto_symtab_encoder_t encoder
= lto_get_out_decl_state ()->symtab_node_encoder
;
2092 /* Initialize the streamer. */
2093 lto_streamer_init ();
2095 n_nodes
= lto_symtab_encoder_size (encoder
);
2096 /* Process only the functions with bodies. */
2097 for (i
= 0; i
< n_nodes
; i
++)
2099 symtab_node
*snode
= lto_symtab_encoder_deref (encoder
, i
);
2100 if (cgraph_node
*node
= dyn_cast
<cgraph_node
*> (snode
))
2102 if (lto_symtab_encoder_encode_body_p (encoder
, node
)
2105 #ifdef ENABLE_CHECKING
2106 gcc_assert (!bitmap_bit_p (output
, DECL_UID (node
->decl
)));
2107 bitmap_set_bit (output
, DECL_UID (node
->decl
));
2109 decl_state
= lto_new_out_decl_state ();
2110 lto_push_out_decl_state (decl_state
);
2111 if (gimple_has_body_p (node
->decl
) || !flag_wpa
)
2112 output_function (node
);
2114 copy_function_or_variable (node
);
2115 gcc_assert (lto_get_out_decl_state () == decl_state
);
2116 lto_pop_out_decl_state ();
2117 lto_record_function_out_decl_state (node
->decl
, decl_state
);
2120 else if (varpool_node
*node
= dyn_cast
<varpool_node
*> (snode
))
2122 /* Wrap symbol references inside the ctor in a type
2123 preserving MEM_REF. */
2124 tree ctor
= DECL_INITIAL (node
->decl
);
2125 if (ctor
&& !in_lto_p
)
2126 walk_tree (&ctor
, wrap_refs
, NULL
, NULL
);
2127 if (get_symbol_initial_value (encoder
, node
->decl
) == error_mark_node
2128 && lto_symtab_encoder_encode_initializer_p (encoder
, node
)
2131 timevar_push (TV_IPA_LTO_CTORS_OUT
);
2132 #ifdef ENABLE_CHECKING
2133 gcc_assert (!bitmap_bit_p (output
, DECL_UID (node
->decl
)));
2134 bitmap_set_bit (output
, DECL_UID (node
->decl
));
2136 decl_state
= lto_new_out_decl_state ();
2137 lto_push_out_decl_state (decl_state
);
2138 if (DECL_INITIAL (node
->decl
) != error_mark_node
2140 output_constructor (node
);
2142 copy_function_or_variable (node
);
2143 gcc_assert (lto_get_out_decl_state () == decl_state
);
2144 lto_pop_out_decl_state ();
2145 lto_record_function_out_decl_state (node
->decl
, decl_state
);
2146 timevar_pop (TV_IPA_LTO_CTORS_OUT
);
2151 /* Emit the callgraph after emitting function bodies. This needs to
2152 be done now to make sure that all the statements in every function
2153 have been renumbered so that edges can be associated with call
2154 statements using the statement UIDs. */
2157 #ifdef ENABLE_CHECKING
2158 lto_bitmap_free (output
);
2162 /* Write each node in encoded by ENCODER to OB, as well as those reachable
2163 from it and required for correct representation of its semantics.
2164 Each node in ENCODER must be a global declaration or a type. A node
2165 is written only once, even if it appears multiple times in the
2166 vector. Certain transitively-reachable nodes, such as those
2167 representing expressions, may be duplicated, but such nodes
2168 must not appear in ENCODER itself. */
2171 write_global_stream (struct output_block
*ob
,
2172 struct lto_tree_ref_encoder
*encoder
)
2176 const size_t size
= lto_tree_ref_encoder_size (encoder
);
2178 for (index
= 0; index
< size
; index
++)
2180 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2181 if (!streamer_tree_cache_lookup (ob
->writer_cache
, t
, NULL
))
2182 stream_write_tree (ob
, t
, false);
2187 /* Write a sequence of indices into the globals vector corresponding
2188 to the trees in ENCODER. These are used by the reader to map the
2189 indices used to refer to global entities within function bodies to
2193 write_global_references (struct output_block
*ob
,
2194 struct lto_output_stream
*ref_stream
,
2195 struct lto_tree_ref_encoder
*encoder
)
2199 const uint32_t size
= lto_tree_ref_encoder_size (encoder
);
2201 /* Write size as 32-bit unsigned. */
2202 lto_output_data_stream (ref_stream
, &size
, sizeof (int32_t));
2204 for (index
= 0; index
< size
; index
++)
2208 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2209 streamer_tree_cache_lookup (ob
->writer_cache
, t
, &slot_num
);
2210 gcc_assert (slot_num
!= (unsigned)-1);
2211 lto_output_data_stream (ref_stream
, &slot_num
, sizeof slot_num
);
2216 /* Write all the streams in an lto_out_decl_state STATE using
2217 output block OB and output stream OUT_STREAM. */
2220 lto_output_decl_state_streams (struct output_block
*ob
,
2221 struct lto_out_decl_state
*state
)
2225 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2226 write_global_stream (ob
, &state
->streams
[i
]);
2230 /* Write all the references in an lto_out_decl_state STATE using
2231 output block OB and output stream OUT_STREAM. */
2234 lto_output_decl_state_refs (struct output_block
*ob
,
2235 struct lto_output_stream
*out_stream
,
2236 struct lto_out_decl_state
*state
)
2242 /* Write reference to FUNCTION_DECL. If there is not function,
2243 write reference to void_type_node. */
2244 decl
= (state
->fn_decl
) ? state
->fn_decl
: void_type_node
;
2245 streamer_tree_cache_lookup (ob
->writer_cache
, decl
, &ref
);
2246 gcc_assert (ref
!= (unsigned)-1);
2247 lto_output_data_stream (out_stream
, &ref
, sizeof (uint32_t));
2249 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2250 write_global_references (ob
, out_stream
, &state
->streams
[i
]);
2254 /* Return the written size of STATE. */
2257 lto_out_decl_state_written_size (struct lto_out_decl_state
*state
)
2262 size
= sizeof (int32_t); /* fn_ref. */
2263 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2265 size
+= sizeof (int32_t); /* vector size. */
2266 size
+= (lto_tree_ref_encoder_size (&state
->streams
[i
])
2267 * sizeof (int32_t));
2273 /* Write symbol T into STREAM in CACHE. SEEN specifies symbols we wrote
2277 write_symbol (struct streamer_tree_cache_d
*cache
,
2278 struct lto_output_stream
*stream
,
2279 tree t
, struct pointer_set_t
*seen
, bool alias
)
2282 enum gcc_plugin_symbol_kind kind
;
2283 enum gcc_plugin_symbol_visibility visibility
;
2289 /* None of the following kinds of symbols are needed in the
2291 if (!TREE_PUBLIC (t
)
2292 || is_builtin_fn (t
)
2293 || DECL_ABSTRACT (t
)
2294 || (TREE_CODE (t
) == VAR_DECL
&& DECL_HARD_REGISTER (t
)))
2296 gcc_assert (TREE_CODE (t
) != RESULT_DECL
);
2298 gcc_assert (TREE_CODE (t
) == VAR_DECL
2299 || TREE_CODE (t
) == FUNCTION_DECL
);
2301 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t
));
2303 /* This behaves like assemble_name_raw in varasm.c, performing the
2304 same name manipulations that ASM_OUTPUT_LABELREF does. */
2305 name
= IDENTIFIER_POINTER ((*targetm
.asm_out
.mangle_assembler_name
) (name
));
2307 if (pointer_set_contains (seen
, name
))
2309 pointer_set_insert (seen
, name
);
2311 streamer_tree_cache_lookup (cache
, t
, &slot_num
);
2312 gcc_assert (slot_num
!= (unsigned)-1);
2314 if (DECL_EXTERNAL (t
))
2317 kind
= GCCPK_WEAKUNDEF
;
2324 kind
= GCCPK_WEAKDEF
;
2325 else if (DECL_COMMON (t
))
2326 kind
= GCCPK_COMMON
;
2330 /* When something is defined, it should have node attached. */
2331 gcc_assert (alias
|| TREE_CODE (t
) != VAR_DECL
2332 || varpool_node::get (t
)->definition
);
2333 gcc_assert (alias
|| TREE_CODE (t
) != FUNCTION_DECL
2334 || (cgraph_node::get (t
)
2335 && cgraph_node::get (t
)->definition
));
2338 /* Imitate what default_elf_asm_output_external do.
2339 When symbol is external, we need to output it with DEFAULT visibility
2340 when compiling with -fvisibility=default, while with HIDDEN visibility
2341 when symbol has attribute (visibility("hidden")) specified.
2342 targetm.binds_local_p check DECL_VISIBILITY_SPECIFIED and gets this
2345 if (DECL_EXTERNAL (t
)
2346 && !targetm
.binds_local_p (t
))
2347 visibility
= GCCPV_DEFAULT
;
2349 switch (DECL_VISIBILITY (t
))
2351 case VISIBILITY_DEFAULT
:
2352 visibility
= GCCPV_DEFAULT
;
2354 case VISIBILITY_PROTECTED
:
2355 visibility
= GCCPV_PROTECTED
;
2357 case VISIBILITY_HIDDEN
:
2358 visibility
= GCCPV_HIDDEN
;
2360 case VISIBILITY_INTERNAL
:
2361 visibility
= GCCPV_INTERNAL
;
2365 if (kind
== GCCPK_COMMON
2366 && DECL_SIZE_UNIT (t
)
2367 && TREE_CODE (DECL_SIZE_UNIT (t
)) == INTEGER_CST
)
2368 size
= TREE_INT_CST_LOW (DECL_SIZE_UNIT (t
));
2372 if (DECL_ONE_ONLY (t
))
2373 comdat
= IDENTIFIER_POINTER (decl_comdat_group_id (t
));
2377 lto_output_data_stream (stream
, name
, strlen (name
) + 1);
2378 lto_output_data_stream (stream
, comdat
, strlen (comdat
) + 1);
2379 c
= (unsigned char) kind
;
2380 lto_output_data_stream (stream
, &c
, 1);
2381 c
= (unsigned char) visibility
;
2382 lto_output_data_stream (stream
, &c
, 1);
2383 lto_output_data_stream (stream
, &size
, 8);
2384 lto_output_data_stream (stream
, &slot_num
, 4);
2387 /* Return true if NODE should appear in the plugin symbol table. */
2390 output_symbol_p (symtab_node
*node
)
2392 struct cgraph_node
*cnode
;
2393 if (!node
->real_symbol_p ())
2395 /* We keep external functions in symtab for sake of inlining
2396 and devirtualization. We do not want to see them in symbol table as
2397 references unless they are really used. */
2398 cnode
= dyn_cast
<cgraph_node
*> (node
);
2399 if (cnode
&& (!node
->definition
|| DECL_EXTERNAL (cnode
->decl
))
2403 /* Ignore all references from external vars initializers - they are not really
2404 part of the compilation unit until they are used by folding. Some symbols,
2405 like references to external construction vtables can not be referred to at all.
2406 We decide this at can_refer_decl_in_current_unit_p. */
2407 if (!node
->definition
|| DECL_EXTERNAL (node
->decl
))
2410 struct ipa_ref
*ref
;
2411 for (i
= 0; node
->iterate_referring (i
, ref
); i
++)
2413 if (ref
->use
== IPA_REF_ALIAS
)
2415 if (is_a
<cgraph_node
*> (ref
->referring
))
2417 if (!DECL_EXTERNAL (ref
->referring
->decl
))
2426 /* Write an IL symbol table to OB.
2427 SET and VSET are cgraph/varpool node sets we are outputting. */
2430 produce_symtab (struct output_block
*ob
)
2432 struct streamer_tree_cache_d
*cache
= ob
->writer_cache
;
2433 char *section_name
= lto_get_section_name (LTO_section_symtab
, NULL
, NULL
);
2434 struct pointer_set_t
*seen
;
2435 struct lto_output_stream stream
;
2436 lto_symtab_encoder_t encoder
= ob
->decl_state
->symtab_node_encoder
;
2437 lto_symtab_encoder_iterator lsei
;
2439 lto_begin_section (section_name
, false);
2440 free (section_name
);
2442 seen
= pointer_set_create ();
2443 memset (&stream
, 0, sizeof (stream
));
2445 /* Write the symbol table.
2446 First write everything defined and then all declarations.
2447 This is necessary to handle cases where we have duplicated symbols. */
2448 for (lsei
= lsei_start (encoder
);
2449 !lsei_end_p (lsei
); lsei_next (&lsei
))
2451 symtab_node
*node
= lsei_node (lsei
);
2453 if (!output_symbol_p (node
) || DECL_EXTERNAL (node
->decl
))
2455 write_symbol (cache
, &stream
, node
->decl
, seen
, false);
2457 for (lsei
= lsei_start (encoder
);
2458 !lsei_end_p (lsei
); lsei_next (&lsei
))
2460 symtab_node
*node
= lsei_node (lsei
);
2462 if (!output_symbol_p (node
) || !DECL_EXTERNAL (node
->decl
))
2464 write_symbol (cache
, &stream
, node
->decl
, seen
, false);
2467 lto_write_stream (&stream
);
2468 pointer_set_destroy (seen
);
2474 /* This pass is run after all of the functions are serialized and all
2475 of the IPA passes have written their serialized forms. This pass
2476 causes the vector of all of the global decls and types used from
2477 this file to be written in to a section that can then be read in to
2478 recover these on other side. */
2481 produce_asm_for_decls (void)
2483 struct lto_out_decl_state
*out_state
;
2484 struct lto_out_decl_state
*fn_out_state
;
2485 struct lto_decl_header header
;
2487 struct output_block
*ob
;
2488 struct lto_output_stream
*header_stream
, *decl_state_stream
;
2489 unsigned idx
, num_fns
;
2490 size_t decl_state_size
;
2491 int32_t num_decl_states
;
2493 ob
= create_output_block (LTO_section_decls
);
2496 memset (&header
, 0, sizeof (struct lto_decl_header
));
2498 section_name
= lto_get_section_name (LTO_section_decls
, NULL
, NULL
);
2499 lto_begin_section (section_name
, !flag_wpa
);
2500 free (section_name
);
2502 /* Make string 0 be a NULL string. */
2503 streamer_write_char_stream (ob
->string_stream
, 0);
2505 gcc_assert (!alias_pairs
);
2507 /* Get rid of the global decl state hash tables to save some memory. */
2508 out_state
= lto_get_out_decl_state ();
2509 for (int i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2510 if (out_state
->streams
[i
].tree_hash_table
)
2512 delete out_state
->streams
[i
].tree_hash_table
;
2513 out_state
->streams
[i
].tree_hash_table
= NULL
;
2516 /* Write the global symbols. */
2517 lto_output_decl_state_streams (ob
, out_state
);
2518 num_fns
= lto_function_decl_states
.length ();
2519 for (idx
= 0; idx
< num_fns
; idx
++)
2522 lto_function_decl_states
[idx
];
2523 lto_output_decl_state_streams (ob
, fn_out_state
);
2526 header
.lto_header
.major_version
= LTO_major_version
;
2527 header
.lto_header
.minor_version
= LTO_minor_version
;
2529 /* Currently not used. This field would allow us to preallocate
2530 the globals vector, so that it need not be resized as it is extended. */
2531 header
.num_nodes
= -1;
2533 /* Compute the total size of all decl out states. */
2534 decl_state_size
= sizeof (int32_t);
2535 decl_state_size
+= lto_out_decl_state_written_size (out_state
);
2536 for (idx
= 0; idx
< num_fns
; idx
++)
2539 lto_function_decl_states
[idx
];
2540 decl_state_size
+= lto_out_decl_state_written_size (fn_out_state
);
2542 header
.decl_state_size
= decl_state_size
;
2544 header
.main_size
= ob
->main_stream
->total_size
;
2545 header
.string_size
= ob
->string_stream
->total_size
;
2547 header_stream
= XCNEW (struct lto_output_stream
);
2548 lto_output_data_stream (header_stream
, &header
, sizeof header
);
2549 lto_write_stream (header_stream
);
2550 free (header_stream
);
2552 /* Write the main out-decl state, followed by out-decl states of
2554 decl_state_stream
= XCNEW (struct lto_output_stream
);
2555 num_decl_states
= num_fns
+ 1;
2556 lto_output_data_stream (decl_state_stream
, &num_decl_states
,
2557 sizeof (num_decl_states
));
2558 lto_output_decl_state_refs (ob
, decl_state_stream
, out_state
);
2559 for (idx
= 0; idx
< num_fns
; idx
++)
2562 lto_function_decl_states
[idx
];
2563 lto_output_decl_state_refs (ob
, decl_state_stream
, fn_out_state
);
2565 lto_write_stream (decl_state_stream
);
2566 free (decl_state_stream
);
2568 lto_write_stream (ob
->main_stream
);
2569 lto_write_stream (ob
->string_stream
);
2573 /* Write the symbol table. It is used by linker to determine dependencies
2574 and thus we can skip it for WPA. */
2576 produce_symtab (ob
);
2578 /* Write command line opts. */
2579 lto_write_options ();
2581 /* Deallocate memory and clean up. */
2582 for (idx
= 0; idx
< num_fns
; idx
++)
2585 lto_function_decl_states
[idx
];
2586 lto_delete_out_decl_state (fn_out_state
);
2588 lto_symtab_encoder_delete (ob
->decl_state
->symtab_node_encoder
);
2589 lto_function_decl_states
.release ();
2590 destroy_output_block (ob
);