1 /* Write the GIMPLE representation to a file stream.
3 Copyright (C) 2009-2019 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"
31 #include "tree-pass.h"
33 #include "gimple-streamer.h"
35 #include "stor-layout.h"
36 #include "gimple-iterator.h"
38 #include "lto-symtab.h"
42 #include "gomp-constants.h"
44 #include "omp-offload.h"
45 #include "print-tree.h"
48 static void lto_write_tree (struct output_block
*, tree
, bool);
50 /* Clear the line info stored in DATA_IN. */
53 clear_line_info (struct output_block
*ob
)
55 ob
->current_file
= NULL
;
58 ob
->current_sysp
= false;
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
);
69 if (streamer_dump_file
)
70 fprintf (streamer_dump_file
, "Creating output block for %s\n",
71 lto_section_name
[section_type
]);
73 ob
->section_type
= section_type
;
74 ob
->decl_state
= lto_get_out_decl_state ();
75 ob
->main_stream
= XCNEW (struct lto_output_stream
);
76 ob
->string_stream
= XCNEW (struct lto_output_stream
);
77 ob
->writer_cache
= streamer_tree_cache_create (!flag_wpa
, true, false);
79 if (section_type
== LTO_section_function_body
)
80 ob
->cfg_stream
= XCNEW (struct lto_output_stream
);
84 ob
->string_hash_table
= new hash_table
<string_slot_hasher
> (37);
85 gcc_obstack_init (&ob
->obstack
);
91 /* Destroy the output block OB. */
94 destroy_output_block (struct output_block
*ob
)
96 enum lto_section_type section_type
= ob
->section_type
;
98 delete ob
->string_hash_table
;
99 ob
->string_hash_table
= NULL
;
101 free (ob
->main_stream
);
102 free (ob
->string_stream
);
103 if (section_type
== LTO_section_function_body
)
104 free (ob
->cfg_stream
);
106 streamer_tree_cache_delete (ob
->writer_cache
);
107 obstack_free (&ob
->obstack
, NULL
);
113 /* Look up NODE in the type table and write the index for it to OB. */
116 output_type_ref (struct output_block
*ob
, tree node
)
118 streamer_write_record_start (ob
, LTO_type_ref
);
119 lto_output_type_ref_index (ob
->decl_state
, ob
->main_stream
, node
);
123 /* Return true if tree node T is written to various tables. For these
124 nodes, we sometimes want to write their phyiscal representation
125 (via lto_output_tree), and sometimes we need to emit an index
126 reference into a table (via lto_output_tree_ref). */
129 tree_is_indexable (tree t
)
131 /* Parameters and return values of functions of variably modified types
132 must go to global stream, because they may be used in the type
134 if ((TREE_CODE (t
) == PARM_DECL
|| TREE_CODE (t
) == RESULT_DECL
)
136 return variably_modified_type_p (TREE_TYPE (DECL_CONTEXT (t
)), NULL_TREE
);
137 /* IMPORTED_DECL is put into BLOCK and thus it never can be shared.
138 We should no longer need to stream it. */
139 else if (TREE_CODE (t
) == IMPORTED_DECL
)
141 else if (TREE_CODE (t
) == LABEL_DECL
)
142 return FORCED_LABEL (t
) || DECL_NONLOCAL (t
);
143 else if (((VAR_P (t
) && !TREE_STATIC (t
))
144 || TREE_CODE (t
) == TYPE_DECL
145 || TREE_CODE (t
) == CONST_DECL
146 || TREE_CODE (t
) == NAMELIST_DECL
)
147 && decl_function_context (t
))
149 else if (TREE_CODE (t
) == DEBUG_EXPR_DECL
)
151 /* Variably modified types need to be streamed alongside function
152 bodies because they can refer to local entities. Together with
153 them we have to localize their members as well.
154 ??? In theory that includes non-FIELD_DECLs as well. */
156 && variably_modified_type_p (t
, NULL_TREE
))
158 else if (TREE_CODE (t
) == FIELD_DECL
159 && variably_modified_type_p (DECL_CONTEXT (t
), NULL_TREE
))
162 return (TYPE_P (t
) || DECL_P (t
) || TREE_CODE (t
) == SSA_NAME
);
166 /* Output info about new location into bitpack BP.
167 After outputting bitpack, lto_output_location_data has
168 to be done to output actual data. */
171 lto_output_location (struct output_block
*ob
, struct bitpack_d
*bp
,
174 expanded_location xloc
;
176 loc
= LOCATION_LOCUS (loc
);
177 bp_pack_int_in_range (bp
, 0, RESERVED_LOCATION_COUNT
,
178 loc
< RESERVED_LOCATION_COUNT
179 ? loc
: RESERVED_LOCATION_COUNT
);
180 if (loc
< RESERVED_LOCATION_COUNT
)
183 xloc
= expand_location (loc
);
185 bp_pack_value (bp
, ob
->current_file
!= xloc
.file
, 1);
186 bp_pack_value (bp
, ob
->current_line
!= xloc
.line
, 1);
187 bp_pack_value (bp
, ob
->current_col
!= xloc
.column
, 1);
189 if (ob
->current_file
!= xloc
.file
)
191 bp_pack_string (ob
, bp
, xloc
.file
, true);
192 bp_pack_value (bp
, xloc
.sysp
, 1);
194 ob
->current_file
= xloc
.file
;
195 ob
->current_sysp
= xloc
.sysp
;
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
));
245 streamer_write_record_start (ob
, LTO_global_decl_ref
);
246 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
250 streamer_write_record_start (ob
, LTO_const_decl_ref
);
251 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
255 gcc_assert (decl_function_context (expr
) == NULL
);
256 streamer_write_record_start (ob
, LTO_imported_decl_ref
);
257 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
261 streamer_write_record_start (ob
, LTO_type_decl_ref
);
262 lto_output_type_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
266 streamer_write_record_start (ob
, LTO_namelist_decl_ref
);
267 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
271 streamer_write_record_start (ob
, LTO_namespace_decl_ref
);
272 lto_output_namespace_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
276 streamer_write_record_start (ob
, LTO_label_decl_ref
);
277 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
281 streamer_write_record_start (ob
, LTO_result_decl_ref
);
282 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
285 case TRANSLATION_UNIT_DECL
:
286 streamer_write_record_start (ob
, LTO_translation_unit_decl_ref
);
287 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
291 /* No other node is indexable, so it should have been handled by
298 /* Return true if EXPR is a tree node that can be written to disk. */
301 lto_is_streamable (tree expr
)
303 enum tree_code code
= TREE_CODE (expr
);
305 /* Notice that we reject SSA_NAMEs as well. We only emit the SSA
306 name version in lto_output_tree_ref (see output_ssa_names). */
307 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
);
321 /* Very rough estimate of streaming size of the initializer. If we ignored
322 presence of strings, we could simply just count number of non-indexable
323 tree nodes and number of references to indexable nodes. Strings however
324 may be very large and we do not want to dump them int othe global stream.
326 Count the size of initializer until the size in DATA is positive. */
329 subtract_estimated_size (tree
*tp
, int *ws
, void *data
)
331 long *sum
= (long *)data
;
332 if (tree_is_indexable (*tp
))
334 /* Indexable tree is one reference to global stream.
335 Guess it may be about 4 bytes. */
339 /* String table entry + base of tree node needs to be streamed. */
340 if (TREE_CODE (*tp
) == STRING_CST
)
341 *sum
-= TREE_STRING_LENGTH (*tp
) + 8;
344 /* Identifiers are also variable length but should not appear
345 naked in constructor. */
346 gcc_checking_assert (TREE_CODE (*tp
) != IDENTIFIER_NODE
);
347 /* We do not really make attempt to work out size of pickled tree, as
348 it is very variable. Make it bigger than the reference. */
357 /* For EXPR lookup and return what we want to stream to OB as DECL_INITIAL. */
360 get_symbol_initial_value (lto_symtab_encoder_t encoder
, tree expr
)
362 gcc_checking_assert (DECL_P (expr
)
363 && TREE_CODE (expr
) != FUNCTION_DECL
364 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
);
366 /* Handle DECL_INITIAL for symbols. */
367 tree initial
= DECL_INITIAL (expr
);
369 && (TREE_STATIC (expr
) || DECL_EXTERNAL (expr
))
370 && !DECL_IN_CONSTANT_POOL (expr
)
374 /* Extra section needs about 30 bytes; do not produce it for simple
376 if (!(vnode
= varpool_node::get (expr
))
377 || !lto_symtab_encoder_encode_initializer_p (encoder
, vnode
))
378 initial
= error_mark_node
;
379 if (initial
!= error_mark_node
)
382 if (walk_tree (&initial
, subtract_estimated_size
, (void *)&max_size
,
384 initial
= error_mark_node
;
392 /* Write a physical representation of tree node EXPR to output block
393 OB. If REF_P is true, the leaves of EXPR are emitted as references
394 via lto_output_tree_ref. IX is the index into the streamer cache
395 where EXPR is stored. */
398 lto_write_tree_1 (struct output_block
*ob
, tree expr
, bool ref_p
)
400 /* Pack all the non-pointer fields in EXPR into a bitpack and write
401 the resulting bitpack. */
402 streamer_write_tree_bitfields (ob
, expr
);
404 /* Write all the pointer fields in EXPR. */
405 streamer_write_tree_body (ob
, expr
, ref_p
);
407 /* Write any LTO-specific data to OB. */
409 && TREE_CODE (expr
) != FUNCTION_DECL
410 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
412 /* Handle DECL_INITIAL for symbols. */
413 tree initial
= get_symbol_initial_value
414 (ob
->decl_state
->symtab_node_encoder
, expr
);
415 stream_write_tree (ob
, initial
, ref_p
);
418 /* Stream references to early generated DIEs. Keep in sync with the
419 trees handled in dwarf2out_die_ref_for_decl. */
421 && TREE_CODE (expr
) != FIELD_DECL
422 && TREE_CODE (expr
) != DEBUG_EXPR_DECL
423 && TREE_CODE (expr
) != TYPE_DECL
)
424 || TREE_CODE (expr
) == BLOCK
)
427 unsigned HOST_WIDE_INT off
;
428 if (debug_info_level
> DINFO_LEVEL_NONE
429 && debug_hooks
->die_ref_for_decl (expr
, &sym
, &off
))
431 streamer_write_string (ob
, ob
->main_stream
, sym
, true);
432 streamer_write_uhwi (ob
, off
);
435 streamer_write_string (ob
, ob
->main_stream
, NULL
, true);
439 /* Write a physical representation of tree node EXPR to output block
440 OB. If REF_P is true, the leaves of EXPR are emitted as references
441 via lto_output_tree_ref. IX is the index into the streamer cache
442 where EXPR is stored. */
445 lto_write_tree (struct output_block
*ob
, tree expr
, bool ref_p
)
447 if (!lto_is_streamable (expr
))
448 internal_error ("tree code %qs is not supported in LTO streams",
449 get_tree_code_name (TREE_CODE (expr
)));
451 /* Write the header, containing everything needed to materialize
452 EXPR on the reading side. */
453 streamer_write_tree_header (ob
, expr
);
455 lto_write_tree_1 (ob
, expr
, ref_p
);
457 /* Mark the end of EXPR. */
458 streamer_write_zero (ob
);
461 /* Emit the physical representation of tree node EXPR to output block OB,
462 If THIS_REF_P is true, the leaves of EXPR are emitted as references via
463 lto_output_tree_ref. REF_P is used for streaming siblings of EXPR. */
466 lto_output_tree_1 (struct output_block
*ob
, tree expr
, hashval_t hash
,
467 bool ref_p
, bool this_ref_p
)
471 gcc_checking_assert (expr
!= NULL_TREE
472 && !(this_ref_p
&& tree_is_indexable (expr
)));
474 bool exists_p
= streamer_tree_cache_insert (ob
->writer_cache
,
476 gcc_assert (!exists_p
);
477 if (TREE_CODE (expr
) == INTEGER_CST
478 && !TREE_OVERFLOW (expr
))
480 /* Shared INTEGER_CST nodes are special because they need their
481 original type to be materialized by the reader (to implement
482 TYPE_CACHED_VALUES). */
483 streamer_write_integer_cst (ob
, expr
, ref_p
);
487 /* This is the first time we see EXPR, write its fields
489 lto_write_tree (ob
, expr
, ref_p
);
496 DFS (struct output_block
*ob
, tree expr
, bool ref_p
, bool this_ref_p
,
505 vec
<scc_entry
> sccstack
;
522 static int scc_entry_compare (const void *, const void *);
524 void DFS_write_tree_body (struct output_block
*ob
,
525 tree expr
, sccs
*expr_state
, bool ref_p
);
527 void DFS_write_tree (struct output_block
*ob
, sccs
*from_state
,
528 tree expr
, bool ref_p
, bool this_ref_p
);
531 hash_scc (struct output_block
*ob
, unsigned first
, unsigned size
,
532 bool ref_p
, bool this_ref_p
);
534 hash_map
<tree
, sccs
*> sccstate
;
535 vec
<worklist
> worklist_vec
;
536 struct obstack sccstate_obstack
;
539 /* Emit the physical representation of tree node EXPR to output block OB,
540 using depth-first search on the subgraph. If THIS_REF_P is true, the
541 leaves of EXPR are emitted as references via lto_output_tree_ref.
542 REF_P is used for streaming siblings of EXPR. If SINGLE_P is true,
543 this is for a rewalk of a single leaf SCC. */
545 DFS::DFS (struct output_block
*ob
, tree expr
, bool ref_p
, bool this_ref_p
,
548 unsigned int next_dfs_num
= 1;
550 gcc_obstack_init (&sccstate_obstack
);
551 worklist_vec
= vNULL
;
552 DFS_write_tree (ob
, NULL
, expr
, ref_p
, this_ref_p
);
553 while (!worklist_vec
.is_empty ())
555 worklist
&w
= worklist_vec
.last ();
557 sccs
*from_state
= w
.from_state
;
558 sccs
*cstate
= w
.cstate
;
560 this_ref_p
= w
.this_ref_p
;
563 sccs
**slot
= &sccstate
.get_or_insert (expr
);
567 gcc_checking_assert (from_state
);
568 if (cstate
->dfsnum
< from_state
->dfsnum
)
569 from_state
->low
= MIN (cstate
->dfsnum
, from_state
->low
);
574 scc_entry e
= { expr
, 0 };
575 /* Not yet visited. DFS recurse and push it onto the stack. */
576 *slot
= cstate
= XOBNEW (&sccstate_obstack
, struct sccs
);
577 sccstack
.safe_push (e
);
578 cstate
->dfsnum
= next_dfs_num
++;
579 cstate
->low
= cstate
->dfsnum
;
582 if (TREE_CODE (expr
) == INTEGER_CST
583 && !TREE_OVERFLOW (expr
))
584 DFS_write_tree (ob
, cstate
, TREE_TYPE (expr
), ref_p
, ref_p
);
587 DFS_write_tree_body (ob
, expr
, cstate
, ref_p
);
589 /* Walk any LTO-specific edges. */
591 && TREE_CODE (expr
) != FUNCTION_DECL
592 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
594 /* Handle DECL_INITIAL for symbols. */
596 = get_symbol_initial_value (ob
->decl_state
->symtab_node_encoder
,
598 DFS_write_tree (ob
, cstate
, initial
, ref_p
, ref_p
);
604 /* See if we found an SCC. */
605 if (cstate
->low
== cstate
->dfsnum
)
607 unsigned first
, size
;
610 /* If we are re-walking a single leaf SCC just pop it,
611 let earlier worklist item access the sccstack. */
618 /* Pop the SCC and compute its size. */
619 first
= sccstack
.length ();
622 x
= sccstack
[--first
].t
;
625 size
= sccstack
.length () - first
;
627 /* No need to compute hashes for LTRANS units, we don't perform
628 any merging there. */
629 hashval_t scc_hash
= 0;
630 unsigned scc_entry_len
= 0;
633 scc_hash
= hash_scc (ob
, first
, size
, ref_p
, this_ref_p
);
635 /* Put the entries with the least number of collisions first. */
636 unsigned entry_start
= 0;
637 scc_entry_len
= size
+ 1;
638 for (unsigned i
= 0; i
< size
;)
641 for (i
= i
+ 1; i
< size
642 && (sccstack
[first
+ i
].hash
643 == sccstack
[first
+ from
].hash
); ++i
)
645 if (i
- from
< scc_entry_len
)
647 scc_entry_len
= i
- from
;
651 for (unsigned i
= 0; i
< scc_entry_len
; ++i
)
652 std::swap (sccstack
[first
+ i
],
653 sccstack
[first
+ entry_start
+ i
]);
655 /* We already sorted SCC deterministically in hash_scc. */
657 /* Check that we have only one SCC.
658 Naturally we may have conflicts if hash function is not
659 strong enough. Lets see how far this gets. */
660 gcc_checking_assert (scc_entry_len
== 1);
663 /* Write LTO_tree_scc. */
664 streamer_write_record_start (ob
, LTO_tree_scc
);
665 streamer_write_uhwi (ob
, size
);
666 streamer_write_uhwi (ob
, scc_hash
);
668 /* Write size-1 SCCs without wrapping them inside SCC bundles.
669 All INTEGER_CSTs need to be handled this way as we need
670 their type to materialize them. Also builtins are handled
672 ??? We still wrap these in LTO_tree_scc so at the
673 input side we can properly identify the tree we want
674 to ultimatively return. */
676 lto_output_tree_1 (ob
, expr
, scc_hash
, ref_p
, this_ref_p
);
679 /* Write the size of the SCC entry candidates. */
680 streamer_write_uhwi (ob
, scc_entry_len
);
682 /* Write all headers and populate the streamer cache. */
683 for (unsigned i
= 0; i
< size
; ++i
)
685 hashval_t hash
= sccstack
[first
+i
].hash
;
686 tree t
= sccstack
[first
+i
].t
;
687 bool exists_p
= streamer_tree_cache_insert (ob
->writer_cache
,
689 gcc_assert (!exists_p
);
691 if (!lto_is_streamable (t
))
692 internal_error ("tree code %qs is not supported "
694 get_tree_code_name (TREE_CODE (t
)));
696 /* Write the header, containing everything needed to
697 materialize EXPR on the reading side. */
698 streamer_write_tree_header (ob
, t
);
701 /* Write the bitpacks and tree references. */
702 for (unsigned i
= 0; i
< size
; ++i
)
704 lto_write_tree_1 (ob
, sccstack
[first
+i
].t
, ref_p
);
706 /* Mark the end of the tree. */
707 streamer_write_zero (ob
);
711 /* Finally truncate the vector. */
712 sccstack
.truncate (first
);
715 from_state
->low
= MIN (from_state
->low
, cstate
->low
);
720 gcc_checking_assert (from_state
);
721 from_state
->low
= MIN (from_state
->low
, cstate
->low
);
722 if (cstate
->dfsnum
< from_state
->dfsnum
)
723 from_state
->low
= MIN (cstate
->dfsnum
, from_state
->low
);
726 worklist_vec
.release ();
732 obstack_free (&sccstate_obstack
, NULL
);
735 /* Handle the tree EXPR in the DFS walk with SCC state EXPR_STATE and
736 DFS recurse for all tree edges originating from it. */
739 DFS::DFS_write_tree_body (struct output_block
*ob
,
740 tree expr
, sccs
*expr_state
, bool ref_p
)
742 #define DFS_follow_tree_edge(DEST) \
743 DFS_write_tree (ob, expr_state, DEST, ref_p, ref_p)
747 if (streamer_dump_file
)
749 print_node_brief (streamer_dump_file
, " Streaming ",
751 fprintf (streamer_dump_file
, " to %s\n",
752 lto_section_name
[ob
->section_type
]);
755 code
= TREE_CODE (expr
);
757 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
759 if (TREE_CODE (expr
) != IDENTIFIER_NODE
)
760 DFS_follow_tree_edge (TREE_TYPE (expr
));
763 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
765 unsigned int count
= vector_cst_encoded_nelts (expr
);
766 for (unsigned int i
= 0; i
< count
; ++i
)
767 DFS_follow_tree_edge (VECTOR_CST_ENCODED_ELT (expr
, i
));
770 if (CODE_CONTAINS_STRUCT (code
, TS_POLY_INT_CST
))
771 for (unsigned int i
= 0; i
< NUM_POLY_INT_COEFFS
; ++i
)
772 DFS_follow_tree_edge (POLY_INT_CST_COEFF (expr
, i
));
774 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
776 DFS_follow_tree_edge (TREE_REALPART (expr
));
777 DFS_follow_tree_edge (TREE_IMAGPART (expr
));
780 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
782 /* Drop names that were created for anonymous entities. */
784 && TREE_CODE (DECL_NAME (expr
)) == IDENTIFIER_NODE
785 && IDENTIFIER_ANON_P (DECL_NAME (expr
)))
788 DFS_follow_tree_edge (DECL_NAME (expr
));
789 if (TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
790 && ! DECL_CONTEXT (expr
))
791 DFS_follow_tree_edge ((*all_translation_units
)[0]);
793 DFS_follow_tree_edge (DECL_CONTEXT (expr
));
796 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
798 DFS_follow_tree_edge (DECL_SIZE (expr
));
799 DFS_follow_tree_edge (DECL_SIZE_UNIT (expr
));
801 /* Note, DECL_INITIAL is not handled here. Since DECL_INITIAL needs
802 special handling in LTO, it must be handled by streamer hooks. */
804 DFS_follow_tree_edge (DECL_ATTRIBUTES (expr
));
806 /* We use DECL_ABSTRACT_ORIGIN == error_mark_node to mark
807 declarations which should be eliminated by decl merging. Be sure none
808 leaks to this point. */
809 gcc_assert (DECL_ABSTRACT_ORIGIN (expr
) != error_mark_node
);
810 DFS_follow_tree_edge (DECL_ABSTRACT_ORIGIN (expr
));
813 || TREE_CODE (expr
) == PARM_DECL
)
814 && DECL_HAS_VALUE_EXPR_P (expr
))
815 DFS_follow_tree_edge (DECL_VALUE_EXPR (expr
));
817 && DECL_HAS_DEBUG_EXPR_P (expr
))
818 DFS_follow_tree_edge (DECL_DEBUG_EXPR (expr
));
821 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
823 /* Make sure we don't inadvertently set the assembler name. */
824 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
825 DFS_follow_tree_edge (DECL_ASSEMBLER_NAME (expr
));
828 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
830 DFS_follow_tree_edge (DECL_FIELD_OFFSET (expr
));
831 DFS_follow_tree_edge (DECL_BIT_FIELD_TYPE (expr
));
832 DFS_follow_tree_edge (DECL_BIT_FIELD_REPRESENTATIVE (expr
));
833 DFS_follow_tree_edge (DECL_FIELD_BIT_OFFSET (expr
));
834 gcc_checking_assert (!DECL_FCONTEXT (expr
));
837 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
839 gcc_checking_assert (DECL_VINDEX (expr
) == NULL
);
840 DFS_follow_tree_edge (DECL_FUNCTION_PERSONALITY (expr
));
841 DFS_follow_tree_edge (DECL_FUNCTION_SPECIFIC_TARGET (expr
));
842 DFS_follow_tree_edge (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr
));
845 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
847 DFS_follow_tree_edge (TYPE_SIZE (expr
));
848 DFS_follow_tree_edge (TYPE_SIZE_UNIT (expr
));
849 DFS_follow_tree_edge (TYPE_ATTRIBUTES (expr
));
850 DFS_follow_tree_edge (TYPE_NAME (expr
));
851 /* Do not follow TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
852 reconstructed during fixup. */
853 /* Do not follow TYPE_NEXT_VARIANT, we reconstruct the variant lists
855 DFS_follow_tree_edge (TYPE_MAIN_VARIANT (expr
));
856 DFS_follow_tree_edge (TYPE_CONTEXT (expr
));
857 /* TYPE_CANONICAL is re-computed during type merging, so no need
858 to follow it here. */
859 /* Do not stream TYPE_STUB_DECL; it is not needed by LTO but currently
860 it cannot be freed by free_lang_data without triggering ICEs in
864 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
866 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
867 DFS_follow_tree_edge (TYPE_VALUES (expr
));
868 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
869 DFS_follow_tree_edge (TYPE_DOMAIN (expr
));
870 else if (RECORD_OR_UNION_TYPE_P (expr
))
871 for (tree t
= TYPE_FIELDS (expr
); t
; t
= TREE_CHAIN (t
))
872 DFS_follow_tree_edge (t
);
873 else if (TREE_CODE (expr
) == FUNCTION_TYPE
874 || TREE_CODE (expr
) == METHOD_TYPE
)
875 DFS_follow_tree_edge (TYPE_ARG_TYPES (expr
));
877 if (!POINTER_TYPE_P (expr
))
878 DFS_follow_tree_edge (TYPE_MIN_VALUE_RAW (expr
));
879 DFS_follow_tree_edge (TYPE_MAX_VALUE_RAW (expr
));
882 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
884 DFS_follow_tree_edge (TREE_PURPOSE (expr
));
885 DFS_follow_tree_edge (TREE_VALUE (expr
));
886 DFS_follow_tree_edge (TREE_CHAIN (expr
));
889 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
891 for (int i
= 0; i
< TREE_VEC_LENGTH (expr
); i
++)
892 DFS_follow_tree_edge (TREE_VEC_ELT (expr
, i
));
895 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
897 for (int i
= 0; i
< TREE_OPERAND_LENGTH (expr
); i
++)
898 DFS_follow_tree_edge (TREE_OPERAND (expr
, i
));
899 DFS_follow_tree_edge (TREE_BLOCK (expr
));
902 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
904 for (tree t
= BLOCK_VARS (expr
); t
; t
= TREE_CHAIN (t
))
906 /* We would have to stream externals in the block chain as
907 non-references but we should have dropped them in
909 gcc_assert (!VAR_OR_FUNCTION_DECL_P (t
) || !DECL_EXTERNAL (t
));
910 DFS_follow_tree_edge (t
);
913 DFS_follow_tree_edge (BLOCK_SUPERCONTEXT (expr
));
914 DFS_follow_tree_edge (BLOCK_ABSTRACT_ORIGIN (expr
));
916 /* Do not follow BLOCK_NONLOCALIZED_VARS. We cannot handle debug
917 information for early inlined BLOCKs so drop it on the floor instead
918 of ICEing in dwarf2out.c. */
920 /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
923 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
924 list is re-constructed from BLOCK_SUPERCONTEXT. */
927 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
932 /* Note that the number of BINFO slots has already been emitted in
933 EXPR's header (see streamer_write_tree_header) because this length
934 is needed to build the empty BINFO node on the reader side. */
935 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr
), i
, t
)
936 DFS_follow_tree_edge (t
);
937 DFS_follow_tree_edge (BINFO_OFFSET (expr
));
938 DFS_follow_tree_edge (BINFO_VTABLE (expr
));
940 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX,
941 BINFO_BASE_ACCESSES and BINFO_VPTR_INDEX; these are used
945 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
950 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr
), i
, index
, value
)
952 DFS_follow_tree_edge (index
);
953 DFS_follow_tree_edge (value
);
957 if (code
== OMP_CLAUSE
)
960 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (expr
)]; i
++)
961 DFS_follow_tree_edge (OMP_CLAUSE_OPERAND (expr
, i
));
962 DFS_follow_tree_edge (OMP_CLAUSE_CHAIN (expr
));
965 #undef DFS_follow_tree_edge
968 /* Return a hash value for the tree T.
969 CACHE holds hash values of trees outside current SCC. MAP, if non-NULL,
970 may hold hash values if trees inside current SCC. */
973 hash_tree (struct streamer_tree_cache_d
*cache
, hash_map
<tree
, hashval_t
> *map
, tree t
)
975 inchash::hash hstate
;
977 #define visit(SIBLING) \
981 hstate.add_int (0); \
982 else if (streamer_tree_cache_lookup (cache, SIBLING, &ix)) \
983 hstate.add_int (streamer_tree_cache_get_hash (cache, ix)); \
985 hstate.add_int (*map->get (SIBLING)); \
987 hstate.add_int (1); \
991 enum tree_code code
= TREE_CODE (t
);
992 hstate
.add_int (code
);
995 hstate
.add_flag (TREE_SIDE_EFFECTS (t
));
996 hstate
.add_flag (TREE_CONSTANT (t
));
997 hstate
.add_flag (TREE_READONLY (t
));
998 hstate
.add_flag (TREE_PUBLIC (t
));
1000 hstate
.add_flag (TREE_ADDRESSABLE (t
));
1001 hstate
.add_flag (TREE_THIS_VOLATILE (t
));
1003 hstate
.add_flag (DECL_UNSIGNED (t
));
1004 else if (TYPE_P (t
))
1005 hstate
.add_flag (TYPE_UNSIGNED (t
));
1007 hstate
.add_flag (TYPE_ARTIFICIAL (t
));
1009 hstate
.add_flag (TREE_NO_WARNING (t
));
1010 hstate
.add_flag (TREE_NOTHROW (t
));
1011 hstate
.add_flag (TREE_STATIC (t
));
1012 hstate
.add_flag (TREE_PROTECTED (t
));
1013 hstate
.add_flag (TREE_DEPRECATED (t
));
1014 if (code
!= TREE_BINFO
)
1015 hstate
.add_flag (TREE_PRIVATE (t
));
1018 hstate
.add_flag (AGGREGATE_TYPE_P (t
)
1019 ? TYPE_REVERSE_STORAGE_ORDER (t
) : TYPE_SATURATING (t
));
1020 hstate
.add_flag (TYPE_ADDR_SPACE (t
));
1022 else if (code
== SSA_NAME
)
1023 hstate
.add_flag (SSA_NAME_IS_DEFAULT_DEF (t
));
1024 hstate
.commit_flag ();
1026 if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
1027 hstate
.add_wide_int (wi::to_widest (t
));
1029 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
1031 REAL_VALUE_TYPE r
= TREE_REAL_CST (t
);
1032 hstate
.add_flag (r
.cl
);
1033 hstate
.add_flag (r
.sign
);
1034 hstate
.add_flag (r
.signalling
);
1035 hstate
.add_flag (r
.canonical
);
1036 hstate
.commit_flag ();
1037 hstate
.add_int (r
.uexp
);
1038 hstate
.add (r
.sig
, sizeof (r
.sig
));
1041 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
1043 FIXED_VALUE_TYPE f
= TREE_FIXED_CST (t
);
1044 hstate
.add_int (f
.mode
);
1045 hstate
.add_int (f
.data
.low
);
1046 hstate
.add_int (f
.data
.high
);
1049 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1051 hstate
.add_hwi (DECL_MODE (t
));
1052 hstate
.add_flag (DECL_NONLOCAL (t
));
1053 hstate
.add_flag (DECL_VIRTUAL_P (t
));
1054 hstate
.add_flag (DECL_IGNORED_P (t
));
1055 hstate
.add_flag (DECL_ABSTRACT_P (t
));
1056 hstate
.add_flag (DECL_ARTIFICIAL (t
));
1057 hstate
.add_flag (DECL_USER_ALIGN (t
));
1058 hstate
.add_flag (DECL_PRESERVE_P (t
));
1059 hstate
.add_flag (DECL_EXTERNAL (t
));
1060 hstate
.add_flag (DECL_GIMPLE_REG_P (t
));
1061 hstate
.commit_flag ();
1062 hstate
.add_int (DECL_ALIGN (t
));
1063 if (code
== LABEL_DECL
)
1065 hstate
.add_int (EH_LANDING_PAD_NR (t
));
1066 hstate
.add_int (LABEL_DECL_UID (t
));
1068 else if (code
== FIELD_DECL
)
1070 hstate
.add_flag (DECL_PACKED (t
));
1071 hstate
.add_flag (DECL_NONADDRESSABLE_P (t
));
1072 hstate
.add_flag (DECL_PADDING_P (t
));
1073 hstate
.add_int (DECL_OFFSET_ALIGN (t
));
1075 else if (code
== VAR_DECL
)
1077 hstate
.add_flag (DECL_HAS_DEBUG_EXPR_P (t
));
1078 hstate
.add_flag (DECL_NONLOCAL_FRAME (t
));
1080 if (code
== RESULT_DECL
1081 || code
== PARM_DECL
1082 || code
== VAR_DECL
)
1084 hstate
.add_flag (DECL_BY_REFERENCE (t
));
1085 if (code
== VAR_DECL
1086 || code
== PARM_DECL
)
1087 hstate
.add_flag (DECL_HAS_VALUE_EXPR_P (t
));
1089 hstate
.commit_flag ();
1092 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
1093 hstate
.add_int (DECL_REGISTER (t
));
1095 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1097 hstate
.add_flag (DECL_COMMON (t
));
1098 hstate
.add_flag (DECL_DLLIMPORT_P (t
));
1099 hstate
.add_flag (DECL_WEAK (t
));
1100 hstate
.add_flag (DECL_SEEN_IN_BIND_EXPR_P (t
));
1101 hstate
.add_flag (DECL_COMDAT (t
));
1102 hstate
.add_flag (DECL_VISIBILITY_SPECIFIED (t
));
1103 hstate
.add_int (DECL_VISIBILITY (t
));
1104 if (code
== VAR_DECL
)
1106 /* DECL_IN_TEXT_SECTION is set during final asm output only. */
1107 hstate
.add_flag (DECL_HARD_REGISTER (t
));
1108 hstate
.add_flag (DECL_IN_CONSTANT_POOL (t
));
1110 if (TREE_CODE (t
) == FUNCTION_DECL
)
1112 hstate
.add_flag (DECL_FINAL_P (t
));
1113 hstate
.add_flag (DECL_CXX_CONSTRUCTOR_P (t
));
1114 hstate
.add_flag (DECL_CXX_DESTRUCTOR_P (t
));
1116 hstate
.commit_flag ();
1119 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1121 hstate
.add_int (DECL_BUILT_IN_CLASS (t
));
1122 hstate
.add_flag (DECL_STATIC_CONSTRUCTOR (t
));
1123 hstate
.add_flag (DECL_STATIC_DESTRUCTOR (t
));
1124 hstate
.add_flag (FUNCTION_DECL_DECL_TYPE (t
));
1125 hstate
.add_flag (DECL_UNINLINABLE (t
));
1126 hstate
.add_flag (DECL_POSSIBLY_INLINED (t
));
1127 hstate
.add_flag (DECL_IS_NOVOPS (t
));
1128 hstate
.add_flag (DECL_IS_RETURNS_TWICE (t
));
1129 hstate
.add_flag (DECL_IS_MALLOC (t
));
1130 hstate
.add_flag (DECL_DECLARED_INLINE_P (t
));
1131 hstate
.add_flag (DECL_STATIC_CHAIN (t
));
1132 hstate
.add_flag (DECL_NO_INLINE_WARNING_P (t
));
1133 hstate
.add_flag (DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (t
));
1134 hstate
.add_flag (DECL_NO_LIMIT_STACK (t
));
1135 hstate
.add_flag (DECL_DISREGARD_INLINE_LIMITS (t
));
1136 hstate
.add_flag (DECL_PURE_P (t
));
1137 hstate
.add_flag (DECL_LOOPING_CONST_OR_PURE_P (t
));
1138 hstate
.commit_flag ();
1139 if (DECL_BUILT_IN_CLASS (t
) != NOT_BUILT_IN
)
1140 hstate
.add_int (DECL_UNCHECKED_FUNCTION_CODE (t
));
1143 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
1145 hstate
.add_hwi (TYPE_MODE (t
));
1146 /* TYPE_NO_FORCE_BLK is private to stor-layout and need
1148 hstate
.add_flag (TYPE_PACKED (t
));
1149 hstate
.add_flag (TYPE_RESTRICT (t
));
1150 hstate
.add_flag (TYPE_USER_ALIGN (t
));
1151 hstate
.add_flag (TYPE_READONLY (t
));
1152 if (RECORD_OR_UNION_TYPE_P (t
))
1154 hstate
.add_flag (TYPE_TRANSPARENT_AGGR (t
));
1155 hstate
.add_flag (TYPE_FINAL_P (t
));
1156 hstate
.add_flag (TYPE_CXX_ODR_P (t
));
1158 else if (code
== ARRAY_TYPE
)
1159 hstate
.add_flag (TYPE_NONALIASED_COMPONENT (t
));
1160 if (code
== ARRAY_TYPE
|| code
== INTEGER_TYPE
)
1161 hstate
.add_flag (TYPE_STRING_FLAG (t
));
1162 if (AGGREGATE_TYPE_P (t
))
1163 hstate
.add_flag (TYPE_TYPELESS_STORAGE (t
));
1164 hstate
.commit_flag ();
1165 hstate
.add_int (TYPE_PRECISION (t
));
1166 hstate
.add_int (TYPE_ALIGN (t
));
1167 hstate
.add_int (TYPE_EMPTY_P (t
));
1170 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
1171 hstate
.add (TRANSLATION_UNIT_LANGUAGE (t
),
1172 strlen (TRANSLATION_UNIT_LANGUAGE (t
)));
1174 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
)
1175 /* We don't stream these when passing things to a different target. */
1176 && !lto_stream_offload_p
)
1177 hstate
.add_hwi (cl_target_option_hash (TREE_TARGET_OPTION (t
)));
1179 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
1180 hstate
.add_hwi (cl_optimization_hash (TREE_OPTIMIZATION (t
)));
1182 if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
1183 hstate
.merge_hash (IDENTIFIER_HASH_VALUE (t
));
1185 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
1186 hstate
.add (TREE_STRING_POINTER (t
), TREE_STRING_LENGTH (t
));
1188 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
1190 if (code
!= IDENTIFIER_NODE
)
1191 visit (TREE_TYPE (t
));
1194 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
1196 unsigned int count
= vector_cst_encoded_nelts (t
);
1197 for (unsigned int i
= 0; i
< count
; ++i
)
1198 visit (VECTOR_CST_ENCODED_ELT (t
, i
));
1201 if (CODE_CONTAINS_STRUCT (code
, TS_POLY_INT_CST
))
1202 for (unsigned int i
= 0; i
< NUM_POLY_INT_COEFFS
; ++i
)
1203 visit (POLY_INT_CST_COEFF (t
, i
));
1205 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
1207 visit (TREE_REALPART (t
));
1208 visit (TREE_IMAGPART (t
));
1211 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
1213 /* Drop names that were created for anonymous entities. */
1215 && TREE_CODE (DECL_NAME (t
)) == IDENTIFIER_NODE
1216 && IDENTIFIER_ANON_P (DECL_NAME (t
)))
1219 visit (DECL_NAME (t
));
1220 if (DECL_FILE_SCOPE_P (t
))
1223 visit (DECL_CONTEXT (t
));
1226 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1228 visit (DECL_SIZE (t
));
1229 visit (DECL_SIZE_UNIT (t
));
1230 visit (DECL_ATTRIBUTES (t
));
1231 if ((code
== VAR_DECL
1232 || code
== PARM_DECL
)
1233 && DECL_HAS_VALUE_EXPR_P (t
))
1234 visit (DECL_VALUE_EXPR (t
));
1235 if (code
== VAR_DECL
1236 && DECL_HAS_DEBUG_EXPR_P (t
))
1237 visit (DECL_DEBUG_EXPR (t
));
1238 /* ??? Hash DECL_INITIAL as streamed. Needs the output-block to
1239 be able to call get_symbol_initial_value. */
1242 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1244 if (DECL_ASSEMBLER_NAME_SET_P (t
))
1245 visit (DECL_ASSEMBLER_NAME (t
));
1248 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
1250 visit (DECL_FIELD_OFFSET (t
));
1251 visit (DECL_BIT_FIELD_TYPE (t
));
1252 visit (DECL_BIT_FIELD_REPRESENTATIVE (t
));
1253 visit (DECL_FIELD_BIT_OFFSET (t
));
1256 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1258 visit (DECL_FUNCTION_PERSONALITY (t
));
1259 visit (DECL_FUNCTION_SPECIFIC_TARGET (t
));
1260 visit (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t
));
1263 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
1265 visit (TYPE_SIZE (t
));
1266 visit (TYPE_SIZE_UNIT (t
));
1267 visit (TYPE_ATTRIBUTES (t
));
1268 visit (TYPE_NAME (t
));
1269 visit (TYPE_MAIN_VARIANT (t
));
1270 if (TYPE_FILE_SCOPE_P (t
))
1273 visit (TYPE_CONTEXT (t
));
1276 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
1278 if (code
== ENUMERAL_TYPE
)
1279 visit (TYPE_VALUES (t
));
1280 else if (code
== ARRAY_TYPE
)
1281 visit (TYPE_DOMAIN (t
));
1282 else if (RECORD_OR_UNION_TYPE_P (t
))
1283 for (tree f
= TYPE_FIELDS (t
); f
; f
= TREE_CHAIN (f
))
1285 else if (code
== FUNCTION_TYPE
1286 || code
== METHOD_TYPE
)
1287 visit (TYPE_ARG_TYPES (t
));
1288 if (!POINTER_TYPE_P (t
))
1289 visit (TYPE_MIN_VALUE_RAW (t
));
1290 visit (TYPE_MAX_VALUE_RAW (t
));
1293 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
1295 visit (TREE_PURPOSE (t
));
1296 visit (TREE_VALUE (t
));
1297 visit (TREE_CHAIN (t
));
1300 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1301 for (int i
= 0; i
< TREE_VEC_LENGTH (t
); ++i
)
1302 visit (TREE_VEC_ELT (t
, i
));
1304 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
1306 hstate
.add_hwi (TREE_OPERAND_LENGTH (t
));
1307 for (int i
= 0; i
< TREE_OPERAND_LENGTH (t
); ++i
)
1308 visit (TREE_OPERAND (t
, i
));
1311 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1315 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (t
), i
, b
)
1317 visit (BINFO_OFFSET (t
));
1318 visit (BINFO_VTABLE (t
));
1319 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
1320 BINFO_BASE_ACCESSES and BINFO_VPTR_INDEX; these are used
1324 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1328 hstate
.add_hwi (CONSTRUCTOR_NELTS (t
));
1329 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), i
, index
, value
)
1336 if (code
== OMP_CLAUSE
)
1341 hstate
.add_hwi (OMP_CLAUSE_CODE (t
));
1342 switch (OMP_CLAUSE_CODE (t
))
1344 case OMP_CLAUSE_DEFAULT
:
1345 val
= OMP_CLAUSE_DEFAULT_KIND (t
);
1347 case OMP_CLAUSE_SCHEDULE
:
1348 val
= OMP_CLAUSE_SCHEDULE_KIND (t
);
1350 case OMP_CLAUSE_DEPEND
:
1351 val
= OMP_CLAUSE_DEPEND_KIND (t
);
1353 case OMP_CLAUSE_MAP
:
1354 val
= OMP_CLAUSE_MAP_KIND (t
);
1356 case OMP_CLAUSE_PROC_BIND
:
1357 val
= OMP_CLAUSE_PROC_BIND_KIND (t
);
1359 case OMP_CLAUSE_REDUCTION
:
1360 case OMP_CLAUSE_TASK_REDUCTION
:
1361 case OMP_CLAUSE_IN_REDUCTION
:
1362 val
= OMP_CLAUSE_REDUCTION_CODE (t
);
1368 hstate
.add_hwi (val
);
1369 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (t
)]; i
++)
1370 visit (OMP_CLAUSE_OPERAND (t
, i
));
1371 visit (OMP_CLAUSE_CHAIN (t
));
1374 return hstate
.end ();
1379 /* Compare two SCC entries by their hash value for qsorting them. */
1382 DFS::scc_entry_compare (const void *p1_
, const void *p2_
)
1384 const scc_entry
*p1
= (const scc_entry
*) p1_
;
1385 const scc_entry
*p2
= (const scc_entry
*) p2_
;
1386 if (p1
->hash
< p2
->hash
)
1388 else if (p1
->hash
> p2
->hash
)
1393 /* Return a hash value for the SCC on the SCC stack from FIRST with SIZE.
1394 THIS_REF_P and REF_P are as passed to lto_output_tree for FIRST. */
1397 DFS::hash_scc (struct output_block
*ob
, unsigned first
, unsigned size
,
1398 bool ref_p
, bool this_ref_p
)
1400 unsigned int last_classes
= 0, iterations
= 0;
1402 /* Compute hash values for the SCC members. */
1403 for (unsigned i
= 0; i
< size
; ++i
)
1404 sccstack
[first
+i
].hash
1405 = hash_tree (ob
->writer_cache
, NULL
, sccstack
[first
+i
].t
);
1408 return sccstack
[first
].hash
;
1410 /* We aim to get unique hash for every tree within SCC and compute hash value
1411 of the whole SCC by combining all values together in a stable (entry-point
1412 independent) order. This guarantees that the same SCC regions within
1413 different translation units will get the same hash values and therefore
1414 will be merged at WPA time.
1416 Often the hashes are already unique. In that case we compute the SCC hash
1417 by combining individual hash values in an increasing order.
1419 If there are duplicates, we seek at least one tree with unique hash (and
1420 pick one with minimal hash and this property). Then we obtain a stable
1421 order by DFS walk starting from this unique tree and then use the index
1422 within this order to make individual hash values unique.
1424 If there is no tree with unique hash, we iteratively propagate the hash
1425 values across the internal edges of SCC. This usually quickly leads
1426 to unique hashes. Consider, for example, an SCC containing two pointers
1427 that are identical except for the types they point to and assume that
1428 these types are also part of the SCC. The propagation will add the
1429 points-to type information into their hash values. */
1432 /* Sort the SCC so we can easily check for uniqueness. */
1433 qsort (&sccstack
[first
], size
, sizeof (scc_entry
), scc_entry_compare
);
1435 unsigned int classes
= 1;
1436 int firstunique
= -1;
1438 /* Find the tree with lowest unique hash (if it exists) and compute
1439 the number of equivalence classes. */
1440 if (sccstack
[first
].hash
!= sccstack
[first
+1].hash
)
1442 for (unsigned i
= 1; i
< size
; ++i
)
1443 if (sccstack
[first
+i
-1].hash
!= sccstack
[first
+i
].hash
)
1446 if (firstunique
== -1
1448 || sccstack
[first
+i
+1].hash
!= sccstack
[first
+i
].hash
))
1452 /* If we found a tree with unique hash, stop the iteration. */
1453 if (firstunique
!= -1
1454 /* Also terminate if we run out of iterations or if the number of
1455 equivalence classes is no longer increasing.
1456 For example a cyclic list of trees that are all equivalent will
1457 never have unique entry point; we however do not build such SCCs
1459 || classes
<= last_classes
|| iterations
> 16)
1463 /* If some hashes are not unique (CLASSES != SIZE), use the DFS walk
1464 starting from FIRSTUNIQUE to obtain a stable order. */
1465 if (classes
!= size
&& firstunique
!= -1)
1467 hash_map
<tree
, hashval_t
> map(size
*2);
1469 /* Store hash values into a map, so we can associate them with
1470 the reordered SCC. */
1471 for (unsigned i
= 0; i
< size
; ++i
)
1472 map
.put (sccstack
[first
+i
].t
, sccstack
[first
+i
].hash
);
1474 DFS
again (ob
, sccstack
[first
+firstunique
].t
, ref_p
, this_ref_p
,
1476 gcc_assert (again
.sccstack
.length () == size
);
1478 memcpy (sccstack
.address () + first
,
1479 again
.sccstack
.address (),
1480 sizeof (scc_entry
) * size
);
1482 /* Update hash values of individual members by hashing in the
1483 index within the stable order. This ensures uniqueness.
1484 Also compute the SCC hash by mixing in all hash values in
1485 the stable order we obtained. */
1486 sccstack
[first
].hash
= *map
.get (sccstack
[first
].t
);
1487 scc_hash
= sccstack
[first
].hash
;
1488 for (unsigned i
= 1; i
< size
; ++i
)
1490 sccstack
[first
+i
].hash
1491 = iterative_hash_hashval_t (i
,
1492 *map
.get (sccstack
[first
+i
].t
));
1494 = iterative_hash_hashval_t (scc_hash
,
1495 sccstack
[first
+i
].hash
);
1498 /* If we got a unique hash value for each tree, then sort already
1499 ensured entry-point independent order. Only compute the final
1502 If we failed to find the unique entry point, we go by the same
1503 route. We will eventually introduce unwanted hash conflicts. */
1506 scc_hash
= sccstack
[first
].hash
;
1507 for (unsigned i
= 1; i
< size
; ++i
)
1509 = iterative_hash_hashval_t (scc_hash
, sccstack
[first
+i
].hash
);
1511 /* We cannot 100% guarantee that the hash won't conflict so as
1512 to make it impossible to find a unique hash. This however
1513 should be an extremely rare case. ICE for now so possible
1514 issues are found and evaluated. */
1515 gcc_checking_assert (classes
== size
);
1518 /* To avoid conflicts across SCCs, iteratively hash the whole SCC
1519 hash into the hash of each element. */
1520 for (unsigned i
= 0; i
< size
; ++i
)
1521 sccstack
[first
+i
].hash
1522 = iterative_hash_hashval_t (sccstack
[first
+i
].hash
, scc_hash
);
1526 last_classes
= classes
;
1529 /* We failed to identify the entry point; propagate hash values across
1531 hash_map
<tree
, hashval_t
> map(size
*2);
1533 for (unsigned i
= 0; i
< size
; ++i
)
1534 map
.put (sccstack
[first
+i
].t
, sccstack
[first
+i
].hash
);
1536 for (unsigned i
= 0; i
< size
; i
++)
1537 sccstack
[first
+i
].hash
1538 = hash_tree (ob
->writer_cache
, &map
, sccstack
[first
+i
].t
);
1543 /* DFS walk EXPR and stream SCCs of tree bodies if they are not
1544 already in the streamer cache. Main routine called for
1545 each visit of EXPR. */
1548 DFS::DFS_write_tree (struct output_block
*ob
, sccs
*from_state
,
1549 tree expr
, bool ref_p
, bool this_ref_p
)
1551 /* Handle special cases. */
1552 if (expr
== NULL_TREE
)
1555 /* Do not DFS walk into indexable trees. */
1556 if (this_ref_p
&& tree_is_indexable (expr
))
1559 /* Check if we already streamed EXPR. */
1560 if (streamer_tree_cache_lookup (ob
->writer_cache
, expr
, NULL
))
1565 w
.from_state
= from_state
;
1568 w
.this_ref_p
= this_ref_p
;
1569 worklist_vec
.safe_push (w
);
1573 /* Emit the physical representation of tree node EXPR to output block OB.
1574 If THIS_REF_P is true, the leaves of EXPR are emitted as references via
1575 lto_output_tree_ref. REF_P is used for streaming siblings of EXPR. */
1578 lto_output_tree (struct output_block
*ob
, tree expr
,
1579 bool ref_p
, bool this_ref_p
)
1584 if (expr
== NULL_TREE
)
1586 streamer_write_record_start (ob
, LTO_null
);
1590 if (this_ref_p
&& tree_is_indexable (expr
))
1592 lto_output_tree_ref (ob
, expr
);
1596 existed_p
= streamer_tree_cache_lookup (ob
->writer_cache
, expr
, &ix
);
1599 /* If a node has already been streamed out, make sure that
1600 we don't write it more than once. Otherwise, the reader
1601 will instantiate two different nodes for the same object. */
1602 streamer_write_record_start (ob
, LTO_tree_pickle_reference
);
1603 streamer_write_uhwi (ob
, ix
);
1604 streamer_write_enum (ob
->main_stream
, LTO_tags
, LTO_NUM_TAGS
,
1605 lto_tree_code_to_tag (TREE_CODE (expr
)));
1606 lto_stats
.num_pickle_refs_output
++;
1610 /* This is the first time we see EXPR, write all reachable
1612 static bool in_dfs_walk
;
1614 /* Protect against recursion which means disconnect between
1615 what tree edges we walk in the DFS walk and what edges
1617 gcc_assert (!in_dfs_walk
);
1619 if (streamer_dump_file
)
1621 print_node_brief (streamer_dump_file
, " Streaming SCC of ",
1623 fprintf (streamer_dump_file
, "\n");
1626 /* Start the DFS walk. */
1627 /* Save ob state ... */
1630 DFS (ob
, expr
, ref_p
, this_ref_p
, false);
1631 in_dfs_walk
= false;
1633 /* Finally append a reference to the tree we were writing.
1634 ??? If expr ended up as a singleton we could have
1635 inlined it here and avoid outputting a reference. */
1636 existed_p
= streamer_tree_cache_lookup (ob
->writer_cache
, expr
, &ix
);
1637 gcc_assert (existed_p
);
1638 streamer_write_record_start (ob
, LTO_tree_pickle_reference
);
1639 streamer_write_uhwi (ob
, ix
);
1640 streamer_write_enum (ob
->main_stream
, LTO_tags
, LTO_NUM_TAGS
,
1641 lto_tree_code_to_tag (TREE_CODE (expr
)));
1642 if (streamer_dump_file
)
1644 print_node_brief (streamer_dump_file
, " Finished SCC of ",
1646 fprintf (streamer_dump_file
, "\n\n");
1648 lto_stats
.num_pickle_refs_output
++;
1653 /* Output to OB a list of try/catch handlers starting with FIRST. */
1656 output_eh_try_list (struct output_block
*ob
, eh_catch first
)
1660 for (n
= first
; n
; n
= n
->next_catch
)
1662 streamer_write_record_start (ob
, LTO_eh_catch
);
1663 stream_write_tree (ob
, n
->type_list
, true);
1664 stream_write_tree (ob
, n
->filter_list
, true);
1665 stream_write_tree (ob
, n
->label
, true);
1668 streamer_write_record_start (ob
, LTO_null
);
1672 /* Output EH region R in function FN to OB. CURR_RN is the slot index
1673 that is being emitted in FN->EH->REGION_ARRAY. This is used to
1674 detect EH region sharing. */
1677 output_eh_region (struct output_block
*ob
, eh_region r
)
1683 streamer_write_record_start (ob
, LTO_null
);
1687 if (r
->type
== ERT_CLEANUP
)
1688 tag
= LTO_ert_cleanup
;
1689 else if (r
->type
== ERT_TRY
)
1691 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
1692 tag
= LTO_ert_allowed_exceptions
;
1693 else if (r
->type
== ERT_MUST_NOT_THROW
)
1694 tag
= LTO_ert_must_not_throw
;
1698 streamer_write_record_start (ob
, tag
);
1699 streamer_write_hwi (ob
, r
->index
);
1702 streamer_write_hwi (ob
, r
->outer
->index
);
1704 streamer_write_zero (ob
);
1707 streamer_write_hwi (ob
, r
->inner
->index
);
1709 streamer_write_zero (ob
);
1712 streamer_write_hwi (ob
, r
->next_peer
->index
);
1714 streamer_write_zero (ob
);
1716 if (r
->type
== ERT_TRY
)
1718 output_eh_try_list (ob
, r
->u
.eh_try
.first_catch
);
1720 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
1722 stream_write_tree (ob
, r
->u
.allowed
.type_list
, true);
1723 stream_write_tree (ob
, r
->u
.allowed
.label
, true);
1724 streamer_write_uhwi (ob
, r
->u
.allowed
.filter
);
1726 else if (r
->type
== ERT_MUST_NOT_THROW
)
1728 stream_write_tree (ob
, r
->u
.must_not_throw
.failure_decl
, true);
1729 bitpack_d bp
= bitpack_create (ob
->main_stream
);
1730 stream_output_location (ob
, &bp
, r
->u
.must_not_throw
.failure_loc
);
1731 streamer_write_bitpack (&bp
);
1734 if (r
->landing_pads
)
1735 streamer_write_hwi (ob
, r
->landing_pads
->index
);
1737 streamer_write_zero (ob
);
1741 /* Output landing pad LP to OB. */
1744 output_eh_lp (struct output_block
*ob
, eh_landing_pad lp
)
1748 streamer_write_record_start (ob
, LTO_null
);
1752 streamer_write_record_start (ob
, LTO_eh_landing_pad
);
1753 streamer_write_hwi (ob
, lp
->index
);
1755 streamer_write_hwi (ob
, lp
->next_lp
->index
);
1757 streamer_write_zero (ob
);
1760 streamer_write_hwi (ob
, lp
->region
->index
);
1762 streamer_write_zero (ob
);
1764 stream_write_tree (ob
, lp
->post_landing_pad
, true);
1768 /* Output the existing eh_table to OB. */
1771 output_eh_regions (struct output_block
*ob
, struct function
*fn
)
1773 if (fn
->eh
&& fn
->eh
->region_tree
)
1780 streamer_write_record_start (ob
, LTO_eh_table
);
1782 /* Emit the index of the root of the EH region tree. */
1783 streamer_write_hwi (ob
, fn
->eh
->region_tree
->index
);
1785 /* Emit all the EH regions in the region array. */
1786 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->region_array
));
1787 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->region_array
, i
, eh
)
1788 output_eh_region (ob
, eh
);
1790 /* Emit all landing pads. */
1791 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->lp_array
));
1792 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->lp_array
, i
, lp
)
1793 output_eh_lp (ob
, lp
);
1795 /* Emit all the runtime type data. */
1796 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->ttype_data
));
1797 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->ttype_data
, i
, ttype
)
1798 stream_write_tree (ob
, ttype
, true);
1800 /* Emit the table of action chains. */
1801 if (targetm
.arm_eabi_unwinder
)
1804 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->ehspec_data
.arm_eabi
));
1805 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->ehspec_data
.arm_eabi
, i
, t
)
1806 stream_write_tree (ob
, t
, true);
1811 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->ehspec_data
.other
));
1812 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->ehspec_data
.other
, i
, c
)
1813 streamer_write_char_stream (ob
->main_stream
, c
);
1817 /* The LTO_null either terminates the record or indicates that there
1818 are no eh_records at all. */
1819 streamer_write_record_start (ob
, LTO_null
);
1823 /* Output all of the active ssa names to the ssa_names stream. */
1826 output_ssa_names (struct output_block
*ob
, struct function
*fn
)
1828 unsigned int i
, len
;
1830 len
= vec_safe_length (SSANAMES (fn
));
1831 streamer_write_uhwi (ob
, len
);
1833 for (i
= 1; i
< len
; i
++)
1835 tree ptr
= (*SSANAMES (fn
))[i
];
1837 if (ptr
== NULL_TREE
1838 || SSA_NAME_IN_FREE_LIST (ptr
)
1839 || virtual_operand_p (ptr
)
1840 /* Simply skip unreleased SSA names. */
1841 || (! SSA_NAME_IS_DEFAULT_DEF (ptr
)
1842 && (! SSA_NAME_DEF_STMT (ptr
)
1843 || ! gimple_bb (SSA_NAME_DEF_STMT (ptr
)))))
1846 streamer_write_uhwi (ob
, i
);
1847 streamer_write_char_stream (ob
->main_stream
,
1848 SSA_NAME_IS_DEFAULT_DEF (ptr
));
1849 if (SSA_NAME_VAR (ptr
))
1850 stream_write_tree (ob
, SSA_NAME_VAR (ptr
), true);
1852 /* ??? This drops SSA_NAME_IDENTIFIER on the floor. */
1853 stream_write_tree (ob
, TREE_TYPE (ptr
), true);
1856 streamer_write_zero (ob
);
1861 /* Output the cfg. */
1864 output_cfg (struct output_block
*ob
, struct function
*fn
)
1866 struct lto_output_stream
*tmp_stream
= ob
->main_stream
;
1869 ob
->main_stream
= ob
->cfg_stream
;
1871 streamer_write_enum (ob
->main_stream
, profile_status_d
, PROFILE_LAST
,
1872 profile_status_for_fn (fn
));
1874 /* Output the number of the highest basic block. */
1875 streamer_write_uhwi (ob
, last_basic_block_for_fn (fn
));
1877 FOR_ALL_BB_FN (bb
, fn
)
1882 streamer_write_hwi (ob
, bb
->index
);
1884 /* Output the successors and the edge flags. */
1885 streamer_write_uhwi (ob
, EDGE_COUNT (bb
->succs
));
1886 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1888 streamer_write_uhwi (ob
, e
->dest
->index
);
1889 e
->probability
.stream_out (ob
);
1890 streamer_write_uhwi (ob
, e
->flags
);
1894 streamer_write_hwi (ob
, -1);
1896 bb
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
1899 streamer_write_hwi (ob
, bb
->next_bb
->index
);
1903 streamer_write_hwi (ob
, -1);
1905 /* ??? The cfgloop interface is tied to cfun. */
1906 gcc_assert (cfun
== fn
);
1908 /* Output the number of loops. */
1909 streamer_write_uhwi (ob
, number_of_loops (fn
));
1911 /* Output each loop, skipping the tree root which has number zero. */
1912 for (unsigned i
= 1; i
< number_of_loops (fn
); ++i
)
1914 class loop
*loop
= get_loop (fn
, i
);
1916 /* Write the index of the loop header. That's enough to rebuild
1917 the loop tree on the reader side. Stream -1 for an unused
1921 streamer_write_hwi (ob
, -1);
1925 streamer_write_hwi (ob
, loop
->header
->index
);
1927 /* Write everything copy_loop_info copies. */
1928 streamer_write_enum (ob
->main_stream
,
1929 loop_estimation
, EST_LAST
, loop
->estimate_state
);
1930 streamer_write_hwi (ob
, loop
->any_upper_bound
);
1931 if (loop
->any_upper_bound
)
1932 streamer_write_widest_int (ob
, loop
->nb_iterations_upper_bound
);
1933 streamer_write_hwi (ob
, loop
->any_likely_upper_bound
);
1934 if (loop
->any_likely_upper_bound
)
1935 streamer_write_widest_int (ob
, loop
->nb_iterations_likely_upper_bound
);
1936 streamer_write_hwi (ob
, loop
->any_estimate
);
1937 if (loop
->any_estimate
)
1938 streamer_write_widest_int (ob
, loop
->nb_iterations_estimate
);
1940 /* Write OMP SIMD related info. */
1941 streamer_write_hwi (ob
, loop
->safelen
);
1942 streamer_write_hwi (ob
, loop
->unroll
);
1943 streamer_write_hwi (ob
, loop
->owned_clique
);
1944 streamer_write_hwi (ob
, loop
->dont_vectorize
);
1945 streamer_write_hwi (ob
, loop
->force_vectorize
);
1946 stream_write_tree (ob
, loop
->simduid
, true);
1949 ob
->main_stream
= tmp_stream
;
1953 /* Create the header in the file using OB. If the section type is for
1954 a function, set FN to the decl for that function. */
1957 produce_asm (struct output_block
*ob
, tree fn
)
1959 enum lto_section_type section_type
= ob
->section_type
;
1960 struct lto_function_header header
;
1963 if (section_type
== LTO_section_function_body
)
1965 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn
));
1966 section_name
= lto_get_section_name (section_type
, name
, NULL
);
1969 section_name
= lto_get_section_name (section_type
, NULL
, NULL
);
1971 lto_begin_section (section_name
, !flag_wpa
);
1972 free (section_name
);
1974 /* The entire header is stream computed here. */
1975 memset (&header
, 0, sizeof (struct lto_function_header
));
1977 if (section_type
== LTO_section_function_body
)
1978 header
.cfg_size
= ob
->cfg_stream
->total_size
;
1979 header
.main_size
= ob
->main_stream
->total_size
;
1980 header
.string_size
= ob
->string_stream
->total_size
;
1981 lto_write_data (&header
, sizeof header
);
1983 /* Put all of the gimple and the string table out the asm file as a
1985 if (section_type
== LTO_section_function_body
)
1986 lto_write_stream (ob
->cfg_stream
);
1987 lto_write_stream (ob
->main_stream
);
1988 lto_write_stream (ob
->string_stream
);
1994 /* Output the base body of struct function FN using output block OB. */
1997 output_struct_function_base (struct output_block
*ob
, struct function
*fn
)
1999 struct bitpack_d bp
;
2003 /* Output the static chain and non-local goto save area. */
2004 stream_write_tree (ob
, fn
->static_chain_decl
, true);
2005 stream_write_tree (ob
, fn
->nonlocal_goto_save_area
, true);
2007 /* Output all the local variables in the function. */
2008 streamer_write_hwi (ob
, vec_safe_length (fn
->local_decls
));
2009 FOR_EACH_VEC_SAFE_ELT (fn
->local_decls
, i
, t
)
2010 stream_write_tree (ob
, t
, true);
2012 /* Output current IL state of the function. */
2013 streamer_write_uhwi (ob
, fn
->curr_properties
);
2015 /* Write all the attributes for FN. */
2016 bp
= bitpack_create (ob
->main_stream
);
2017 bp_pack_value (&bp
, fn
->is_thunk
, 1);
2018 bp_pack_value (&bp
, fn
->has_local_explicit_reg_vars
, 1);
2019 bp_pack_value (&bp
, fn
->returns_pcc_struct
, 1);
2020 bp_pack_value (&bp
, fn
->returns_struct
, 1);
2021 bp_pack_value (&bp
, fn
->can_throw_non_call_exceptions
, 1);
2022 bp_pack_value (&bp
, fn
->can_delete_dead_exceptions
, 1);
2023 bp_pack_value (&bp
, fn
->always_inline_functions_inlined
, 1);
2024 bp_pack_value (&bp
, fn
->after_inlining
, 1);
2025 bp_pack_value (&bp
, fn
->stdarg
, 1);
2026 bp_pack_value (&bp
, fn
->has_nonlocal_label
, 1);
2027 bp_pack_value (&bp
, fn
->has_forced_label_in_static
, 1);
2028 bp_pack_value (&bp
, fn
->calls_alloca
, 1);
2029 bp_pack_value (&bp
, fn
->calls_setjmp
, 1);
2030 bp_pack_value (&bp
, fn
->calls_eh_return
, 1);
2031 bp_pack_value (&bp
, fn
->has_force_vectorize_loops
, 1);
2032 bp_pack_value (&bp
, fn
->has_simduid_loops
, 1);
2033 bp_pack_value (&bp
, fn
->va_list_fpr_size
, 8);
2034 bp_pack_value (&bp
, fn
->va_list_gpr_size
, 8);
2035 bp_pack_value (&bp
, fn
->last_clique
, sizeof (short) * 8);
2037 /* Output the function start and end loci. */
2038 stream_output_location (ob
, &bp
, fn
->function_start_locus
);
2039 stream_output_location (ob
, &bp
, fn
->function_end_locus
);
2041 /* Save the instance discriminator if present. */
2042 int *instance_number_p
= NULL
;
2043 if (decl_to_instance_map
)
2044 instance_number_p
= decl_to_instance_map
->get (fn
->decl
);
2045 bp_pack_value (&bp
, !!instance_number_p
, 1);
2046 if (instance_number_p
)
2047 bp_pack_value (&bp
, *instance_number_p
, sizeof (int) * CHAR_BIT
);
2049 streamer_write_bitpack (&bp
);
2053 /* Collect all leaf BLOCKs beyond ROOT into LEAFS. */
2056 collect_block_tree_leafs (tree root
, vec
<tree
> &leafs
)
2058 for (root
= BLOCK_SUBBLOCKS (root
); root
; root
= BLOCK_CHAIN (root
))
2059 if (! BLOCK_SUBBLOCKS (root
))
2060 leafs
.safe_push (root
);
2062 collect_block_tree_leafs (BLOCK_SUBBLOCKS (root
), leafs
);
2065 /* Output the body of function NODE->DECL. */
2068 output_function (struct cgraph_node
*node
)
2071 struct function
*fn
;
2073 struct output_block
*ob
;
2075 if (streamer_dump_file
)
2076 fprintf (streamer_dump_file
, "\nStreaming body of %s\n",
2079 function
= node
->decl
;
2080 fn
= DECL_STRUCT_FUNCTION (function
);
2081 ob
= create_output_block (LTO_section_function_body
);
2083 clear_line_info (ob
);
2086 gcc_assert (current_function_decl
== NULL_TREE
&& cfun
== NULL
);
2088 /* Set current_function_decl and cfun. */
2091 /* Make string 0 be a NULL string. */
2092 streamer_write_char_stream (ob
->string_stream
, 0);
2094 streamer_write_record_start (ob
, LTO_function
);
2096 /* Output decls for parameters and args. */
2097 stream_write_tree (ob
, DECL_RESULT (function
), true);
2098 streamer_write_chain (ob
, DECL_ARGUMENTS (function
), true);
2100 /* Output debug args if available. */
2101 vec
<tree
, va_gc
> **debugargs
= decl_debug_args_lookup (function
);
2103 streamer_write_uhwi (ob
, 0);
2106 streamer_write_uhwi (ob
, (*debugargs
)->length ());
2107 for (unsigned i
= 0; i
< (*debugargs
)->length (); ++i
)
2108 stream_write_tree (ob
, (**debugargs
)[i
], true);
2111 /* Output DECL_INITIAL for the function, which contains the tree of
2113 stream_write_tree (ob
, DECL_INITIAL (function
), true);
2114 /* As we do not recurse into BLOCK_SUBBLOCKS but only BLOCK_SUPERCONTEXT
2115 collect block tree leafs and stream those. */
2116 auto_vec
<tree
> block_tree_leafs
;
2117 if (DECL_INITIAL (function
))
2118 collect_block_tree_leafs (DECL_INITIAL (function
), block_tree_leafs
);
2119 streamer_write_uhwi (ob
, block_tree_leafs
.length ());
2120 for (unsigned i
= 0; i
< block_tree_leafs
.length (); ++i
)
2121 stream_write_tree (ob
, block_tree_leafs
[i
], true);
2123 /* We also stream abstract functions where we stream only stuff needed for
2125 if (gimple_has_body_p (function
))
2127 /* Fixup loops if required to match discovery done in the reader. */
2128 loop_optimizer_init (AVOID_CFG_MODIFICATIONS
);
2130 streamer_write_uhwi (ob
, 1);
2131 output_struct_function_base (ob
, fn
);
2133 /* Output all the SSA names used in the function. */
2134 output_ssa_names (ob
, fn
);
2136 /* Output any exception handling regions. */
2137 output_eh_regions (ob
, fn
);
2140 /* We will renumber the statements. The code that does this uses
2141 the same ordering that we use for serializing them so we can use
2142 the same code on the other end and not have to write out the
2143 statement numbers. We do not assign UIDs to PHIs here because
2144 virtual PHIs get re-computed on-the-fly which would make numbers
2146 set_gimple_stmt_max_uid (cfun
, 0);
2147 FOR_ALL_BB_FN (bb
, cfun
)
2149 for (gphi_iterator gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
);
2152 gphi
*stmt
= gsi
.phi ();
2154 /* Virtual PHIs are not going to be streamed. */
2155 if (!virtual_operand_p (gimple_phi_result (stmt
)))
2156 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
2158 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);
2161 gimple
*stmt
= gsi_stmt (gsi
);
2162 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
2165 /* To avoid keeping duplicate gimple IDs in the statements, renumber
2166 virtual phis now. */
2167 FOR_ALL_BB_FN (bb
, cfun
)
2169 for (gphi_iterator gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
);
2172 gphi
*stmt
= gsi
.phi ();
2173 if (virtual_operand_p (gimple_phi_result (stmt
)))
2174 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
2178 /* Output the code for the function. */
2179 FOR_ALL_BB_FN (bb
, fn
)
2180 output_bb (ob
, bb
, fn
);
2182 /* The terminator for this function. */
2183 streamer_write_record_start (ob
, LTO_null
);
2185 output_cfg (ob
, fn
);
2187 loop_optimizer_finalize ();
2191 streamer_write_uhwi (ob
, 0);
2193 /* Create a section to hold the pickled output of this function. */
2194 produce_asm (ob
, function
);
2196 destroy_output_block (ob
);
2197 if (streamer_dump_file
)
2198 fprintf (streamer_dump_file
, "Finished streaming %s\n",
2202 /* Output the body of function NODE->DECL. */
2205 output_constructor (struct varpool_node
*node
)
2207 tree var
= node
->decl
;
2208 struct output_block
*ob
;
2210 if (streamer_dump_file
)
2211 fprintf (streamer_dump_file
, "\nStreaming constructor of %s\n",
2214 ob
= create_output_block (LTO_section_function_body
);
2216 clear_line_info (ob
);
2219 /* Make string 0 be a NULL string. */
2220 streamer_write_char_stream (ob
->string_stream
, 0);
2222 /* Output DECL_INITIAL for the function, which contains the tree of
2224 stream_write_tree (ob
, DECL_INITIAL (var
), true);
2226 /* Create a section to hold the pickled output of this function. */
2227 produce_asm (ob
, var
);
2229 destroy_output_block (ob
);
2230 if (streamer_dump_file
)
2231 fprintf (streamer_dump_file
, "Finished streaming %s\n",
2236 /* Emit toplevel asms. */
2239 lto_output_toplevel_asms (void)
2241 struct output_block
*ob
;
2242 struct asm_node
*can
;
2244 struct lto_simple_header_with_strings header
;
2246 if (!symtab
->first_asm_symbol ())
2249 ob
= create_output_block (LTO_section_asm
);
2251 /* Make string 0 be a NULL string. */
2252 streamer_write_char_stream (ob
->string_stream
, 0);
2254 for (can
= symtab
->first_asm_symbol (); can
; can
= can
->next
)
2256 streamer_write_string_cst (ob
, ob
->main_stream
, can
->asm_str
);
2257 streamer_write_hwi (ob
, can
->order
);
2260 streamer_write_string_cst (ob
, ob
->main_stream
, NULL_TREE
);
2262 section_name
= lto_get_section_name (LTO_section_asm
, NULL
, NULL
);
2263 lto_begin_section (section_name
, !flag_wpa
);
2264 free (section_name
);
2266 /* The entire header stream is computed here. */
2267 memset (&header
, 0, sizeof (header
));
2269 header
.main_size
= ob
->main_stream
->total_size
;
2270 header
.string_size
= ob
->string_stream
->total_size
;
2271 lto_write_data (&header
, sizeof header
);
2273 /* Put all of the gimple and the string table out the asm file as a
2275 lto_write_stream (ob
->main_stream
);
2276 lto_write_stream (ob
->string_stream
);
2280 destroy_output_block (ob
);
2284 /* Copy the function body or variable constructor of NODE without deserializing. */
2287 copy_function_or_variable (struct symtab_node
*node
)
2289 tree function
= node
->decl
;
2290 struct lto_file_decl_data
*file_data
= node
->lto_file_data
;
2293 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function
));
2294 char *section_name
=
2295 lto_get_section_name (LTO_section_function_body
, name
, NULL
);
2297 struct lto_in_decl_state
*in_state
;
2298 struct lto_out_decl_state
*out_state
= lto_get_out_decl_state ();
2300 if (streamer_dump_file
)
2301 fprintf (streamer_dump_file
, "Copying section for %s\n", name
);
2302 lto_begin_section (section_name
, false);
2303 free (section_name
);
2305 /* We may have renamed the declaration, e.g., a static function. */
2306 name
= lto_get_decl_name_mapping (file_data
, name
);
2308 data
= lto_get_raw_section_data (file_data
, LTO_section_function_body
,
2312 /* Do a bit copy of the function body. */
2313 lto_write_raw_data (data
, len
);
2317 lto_get_function_in_decl_state (node
->lto_file_data
, function
);
2318 out_state
->compressed
= in_state
->compressed
;
2319 gcc_assert (in_state
);
2321 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2323 size_t n
= vec_safe_length (in_state
->streams
[i
]);
2324 vec
<tree
, va_gc
> *trees
= in_state
->streams
[i
];
2325 struct lto_tree_ref_encoder
*encoder
= &(out_state
->streams
[i
]);
2327 /* The out state must have the same indices and the in state.
2328 So just copy the vector. All the encoders in the in state
2329 must be empty where we reach here. */
2330 gcc_assert (lto_tree_ref_encoder_size (encoder
) == 0);
2331 encoder
->trees
.reserve_exact (n
);
2332 for (j
= 0; j
< n
; j
++)
2333 encoder
->trees
.safe_push ((*trees
)[j
]);
2336 lto_free_raw_section_data (file_data
, LTO_section_function_body
, name
,
2341 /* Wrap symbol references in *TP inside a type-preserving MEM_REF. */
2344 wrap_refs (tree
*tp
, int *ws
, void *)
2347 if (handled_component_p (t
)
2348 && TREE_CODE (TREE_OPERAND (t
, 0)) == VAR_DECL
2349 && TREE_PUBLIC (TREE_OPERAND (t
, 0)))
2351 tree decl
= TREE_OPERAND (t
, 0);
2352 tree ptrtype
= build_pointer_type (TREE_TYPE (decl
));
2353 TREE_OPERAND (t
, 0) = build2 (MEM_REF
, TREE_TYPE (decl
),
2354 build1 (ADDR_EXPR
, ptrtype
, decl
),
2355 build_int_cst (ptrtype
, 0));
2356 TREE_THIS_VOLATILE (TREE_OPERAND (t
, 0)) = TREE_THIS_VOLATILE (decl
);
2359 else if (TREE_CODE (t
) == CONSTRUCTOR
)
2361 else if (!EXPR_P (t
))
2366 /* Remove functions that are no longer used from offload_funcs, and mark the
2367 remaining ones with DECL_PRESERVE_P. */
2370 prune_offload_funcs (void)
2377 VEC_ORDERED_REMOVE_IF (*offload_funcs
, ix
, ix2
, elem_ptr
,
2378 cgraph_node::get (*elem_ptr
) == NULL
);
2381 FOR_EACH_VEC_ELT (*offload_funcs
, ix
, fn_decl
)
2382 DECL_PRESERVE_P (fn_decl
) = 1;
2385 /* Produce LTO section that contains global information
2386 about LTO bytecode. */
2389 produce_lto_section ()
2391 /* Stream LTO meta section. */
2392 output_block
*ob
= create_output_block (LTO_section_lto
);
2394 char * section_name
= lto_get_section_name (LTO_section_lto
, NULL
, NULL
);
2395 lto_begin_section (section_name
, false);
2396 free (section_name
);
2399 lto_compression compression
= ZSTD
;
2401 lto_compression compression
= ZLIB
;
2404 bool slim_object
= flag_generate_lto
&& !flag_fat_lto_objects
;
2406 = { LTO_major_version
, LTO_minor_version
, slim_object
, 0 };
2407 s
.set_compression (compression
);
2408 lto_write_data (&s
, sizeof s
);
2410 destroy_output_block (ob
);
2413 /* Main entry point from the pass manager. */
2418 struct lto_out_decl_state
*decl_state
;
2419 bitmap output
= NULL
;
2420 bitmap_obstack output_obstack
;
2422 lto_symtab_encoder_t encoder
= lto_get_out_decl_state ()->symtab_node_encoder
;
2424 prune_offload_funcs ();
2428 bitmap_obstack_initialize (&output_obstack
);
2429 output
= BITMAP_ALLOC (&output_obstack
);
2432 /* Initialize the streamer. */
2433 lto_streamer_init ();
2435 produce_lto_section ();
2437 n_nodes
= lto_symtab_encoder_size (encoder
);
2438 /* Process only the functions with bodies. */
2439 for (i
= 0; i
< n_nodes
; i
++)
2441 symtab_node
*snode
= lto_symtab_encoder_deref (encoder
, i
);
2442 if (cgraph_node
*node
= dyn_cast
<cgraph_node
*> (snode
))
2444 if (lto_symtab_encoder_encode_body_p (encoder
, node
)
2448 gcc_assert (bitmap_set_bit (output
, DECL_UID (node
->decl
)));
2449 decl_state
= lto_new_out_decl_state ();
2450 lto_push_out_decl_state (decl_state
);
2451 if (gimple_has_body_p (node
->decl
)
2453 && flag_incremental_link
!= INCREMENTAL_LINK_LTO
)
2454 /* Thunks have no body but they may be synthetized
2456 || DECL_ARGUMENTS (node
->decl
))
2457 output_function (node
);
2459 copy_function_or_variable (node
);
2460 gcc_assert (lto_get_out_decl_state () == decl_state
);
2461 lto_pop_out_decl_state ();
2462 lto_record_function_out_decl_state (node
->decl
, decl_state
);
2465 else if (varpool_node
*node
= dyn_cast
<varpool_node
*> (snode
))
2467 /* Wrap symbol references inside the ctor in a type
2468 preserving MEM_REF. */
2469 tree ctor
= DECL_INITIAL (node
->decl
);
2470 if (ctor
&& !in_lto_p
)
2471 walk_tree (&ctor
, wrap_refs
, NULL
, NULL
);
2472 if (get_symbol_initial_value (encoder
, node
->decl
) == error_mark_node
2473 && lto_symtab_encoder_encode_initializer_p (encoder
, node
)
2476 timevar_push (TV_IPA_LTO_CTORS_OUT
);
2478 gcc_assert (bitmap_set_bit (output
, DECL_UID (node
->decl
)));
2479 decl_state
= lto_new_out_decl_state ();
2480 lto_push_out_decl_state (decl_state
);
2481 if (DECL_INITIAL (node
->decl
) != error_mark_node
2483 && flag_incremental_link
!= INCREMENTAL_LINK_LTO
))
2484 output_constructor (node
);
2486 copy_function_or_variable (node
);
2487 gcc_assert (lto_get_out_decl_state () == decl_state
);
2488 lto_pop_out_decl_state ();
2489 lto_record_function_out_decl_state (node
->decl
, decl_state
);
2490 timevar_pop (TV_IPA_LTO_CTORS_OUT
);
2495 /* Emit the callgraph after emitting function bodies. This needs to
2496 be done now to make sure that all the statements in every function
2497 have been renumbered so that edges can be associated with call
2498 statements using the statement UIDs. */
2501 output_offload_tables ();
2505 BITMAP_FREE (output
);
2506 bitmap_obstack_release (&output_obstack
);
2510 /* Write each node in encoded by ENCODER to OB, as well as those reachable
2511 from it and required for correct representation of its semantics.
2512 Each node in ENCODER must be a global declaration or a type. A node
2513 is written only once, even if it appears multiple times in the
2514 vector. Certain transitively-reachable nodes, such as those
2515 representing expressions, may be duplicated, but such nodes
2516 must not appear in ENCODER itself. */
2519 write_global_stream (struct output_block
*ob
,
2520 struct lto_tree_ref_encoder
*encoder
)
2524 const size_t size
= lto_tree_ref_encoder_size (encoder
);
2526 for (index
= 0; index
< size
; index
++)
2528 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2529 if (streamer_dump_file
)
2531 fprintf (streamer_dump_file
, " %i:", (int)index
);
2532 print_node_brief (streamer_dump_file
, "", t
, 4);
2533 fprintf (streamer_dump_file
, "\n");
2535 if (!streamer_tree_cache_lookup (ob
->writer_cache
, t
, NULL
))
2536 stream_write_tree (ob
, t
, false);
2541 /* Write a sequence of indices into the globals vector corresponding
2542 to the trees in ENCODER. These are used by the reader to map the
2543 indices used to refer to global entities within function bodies to
2547 write_global_references (struct output_block
*ob
,
2548 struct lto_tree_ref_encoder
*encoder
)
2552 const uint32_t size
= lto_tree_ref_encoder_size (encoder
);
2554 /* Write size and slot indexes as 32-bit unsigned numbers. */
2555 uint32_t *data
= XNEWVEC (uint32_t, size
+ 1);
2558 for (index
= 0; index
< size
; index
++)
2562 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2563 streamer_tree_cache_lookup (ob
->writer_cache
, t
, &slot_num
);
2564 gcc_assert (slot_num
!= (unsigned)-1);
2565 data
[index
+ 1] = slot_num
;
2568 lto_write_data (data
, sizeof (int32_t) * (size
+ 1));
2573 /* Write all the streams in an lto_out_decl_state STATE using
2574 output block OB and output stream OUT_STREAM. */
2577 lto_output_decl_state_streams (struct output_block
*ob
,
2578 struct lto_out_decl_state
*state
)
2582 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2583 write_global_stream (ob
, &state
->streams
[i
]);
2587 /* Write all the references in an lto_out_decl_state STATE using
2588 output block OB and output stream OUT_STREAM. */
2591 lto_output_decl_state_refs (struct output_block
*ob
,
2592 struct lto_out_decl_state
*state
)
2598 /* Write reference to FUNCTION_DECL. If there is not function,
2599 write reference to void_type_node. */
2600 decl
= (state
->fn_decl
) ? state
->fn_decl
: void_type_node
;
2601 streamer_tree_cache_lookup (ob
->writer_cache
, decl
, &ref
);
2602 gcc_assert (ref
!= (unsigned)-1);
2603 ref
= ref
* 2 + (state
->compressed
? 1 : 0);
2604 lto_write_data (&ref
, sizeof (uint32_t));
2606 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2607 write_global_references (ob
, &state
->streams
[i
]);
2611 /* Return the written size of STATE. */
2614 lto_out_decl_state_written_size (struct lto_out_decl_state
*state
)
2619 size
= sizeof (int32_t); /* fn_ref. */
2620 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2622 size
+= sizeof (int32_t); /* vector size. */
2623 size
+= (lto_tree_ref_encoder_size (&state
->streams
[i
])
2624 * sizeof (int32_t));
2630 /* Write symbol T into STREAM in CACHE. SEEN specifies symbols we wrote
2634 write_symbol (struct streamer_tree_cache_d
*cache
,
2635 tree t
, hash_set
<const char *> *seen
, bool alias
)
2638 enum gcc_plugin_symbol_kind kind
;
2639 enum gcc_plugin_symbol_visibility visibility
= GCCPV_DEFAULT
;
2645 gcc_assert (VAR_OR_FUNCTION_DECL_P (t
));
2647 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t
));
2649 /* This behaves like assemble_name_raw in varasm.c, performing the
2650 same name manipulations that ASM_OUTPUT_LABELREF does. */
2651 name
= IDENTIFIER_POINTER ((*targetm
.asm_out
.mangle_assembler_name
) (name
));
2653 if (seen
->add (name
))
2656 streamer_tree_cache_lookup (cache
, t
, &slot_num
);
2657 gcc_assert (slot_num
!= (unsigned)-1);
2659 if (DECL_EXTERNAL (t
))
2662 kind
= GCCPK_WEAKUNDEF
;
2669 kind
= GCCPK_WEAKDEF
;
2670 else if (DECL_COMMON (t
))
2671 kind
= GCCPK_COMMON
;
2675 /* When something is defined, it should have node attached. */
2676 gcc_assert (alias
|| !VAR_P (t
) || varpool_node::get (t
)->definition
);
2677 gcc_assert (alias
|| TREE_CODE (t
) != FUNCTION_DECL
2678 || (cgraph_node::get (t
)
2679 && cgraph_node::get (t
)->definition
));
2682 /* Imitate what default_elf_asm_output_external do.
2683 When symbol is external, we need to output it with DEFAULT visibility
2684 when compiling with -fvisibility=default, while with HIDDEN visibility
2685 when symbol has attribute (visibility("hidden")) specified.
2686 targetm.binds_local_p check DECL_VISIBILITY_SPECIFIED and gets this
2689 if (DECL_EXTERNAL (t
)
2690 && !targetm
.binds_local_p (t
))
2691 visibility
= GCCPV_DEFAULT
;
2693 switch (DECL_VISIBILITY (t
))
2695 case VISIBILITY_DEFAULT
:
2696 visibility
= GCCPV_DEFAULT
;
2698 case VISIBILITY_PROTECTED
:
2699 visibility
= GCCPV_PROTECTED
;
2701 case VISIBILITY_HIDDEN
:
2702 visibility
= GCCPV_HIDDEN
;
2704 case VISIBILITY_INTERNAL
:
2705 visibility
= GCCPV_INTERNAL
;
2709 if (kind
== GCCPK_COMMON
2710 && DECL_SIZE_UNIT (t
)
2711 && TREE_CODE (DECL_SIZE_UNIT (t
)) == INTEGER_CST
)
2712 size
= TREE_INT_CST_LOW (DECL_SIZE_UNIT (t
));
2716 if (DECL_ONE_ONLY (t
))
2717 comdat
= IDENTIFIER_POINTER (decl_comdat_group_id (t
));
2721 lto_write_data (name
, strlen (name
) + 1);
2722 lto_write_data (comdat
, strlen (comdat
) + 1);
2723 c
= (unsigned char) kind
;
2724 lto_write_data (&c
, 1);
2725 c
= (unsigned char) visibility
;
2726 lto_write_data (&c
, 1);
2727 lto_write_data (&size
, 8);
2728 lto_write_data (&slot_num
, 4);
2731 /* Write an IL symbol table to OB.
2732 SET and VSET are cgraph/varpool node sets we are outputting. */
2735 produce_symtab (struct output_block
*ob
)
2737 struct streamer_tree_cache_d
*cache
= ob
->writer_cache
;
2738 char *section_name
= lto_get_section_name (LTO_section_symtab
, NULL
, NULL
);
2739 lto_symtab_encoder_t encoder
= ob
->decl_state
->symtab_node_encoder
;
2740 lto_symtab_encoder_iterator lsei
;
2742 lto_begin_section (section_name
, false);
2743 free (section_name
);
2745 hash_set
<const char *> seen
;
2747 /* Write the symbol table.
2748 First write everything defined and then all declarations.
2749 This is necessary to handle cases where we have duplicated symbols. */
2750 for (lsei
= lsei_start (encoder
);
2751 !lsei_end_p (lsei
); lsei_next (&lsei
))
2753 symtab_node
*node
= lsei_node (lsei
);
2755 if (DECL_EXTERNAL (node
->decl
) || !node
->output_to_lto_symbol_table_p ())
2757 write_symbol (cache
, node
->decl
, &seen
, false);
2759 for (lsei
= lsei_start (encoder
);
2760 !lsei_end_p (lsei
); lsei_next (&lsei
))
2762 symtab_node
*node
= lsei_node (lsei
);
2764 if (!DECL_EXTERNAL (node
->decl
) || !node
->output_to_lto_symbol_table_p ())
2766 write_symbol (cache
, node
->decl
, &seen
, false);
2773 /* Init the streamer_mode_table for output, where we collect info on what
2774 machine_mode values have been streamed. */
2776 lto_output_init_mode_table (void)
2778 memset (streamer_mode_table
, '\0', MAX_MACHINE_MODE
);
2782 /* Write the mode table. */
2784 lto_write_mode_table (void)
2786 struct output_block
*ob
;
2787 ob
= create_output_block (LTO_section_mode_table
);
2788 bitpack_d bp
= bitpack_create (ob
->main_stream
);
2790 /* Ensure that for GET_MODE_INNER (m) != m we have
2791 also the inner mode marked. */
2792 for (int i
= 0; i
< (int) MAX_MACHINE_MODE
; i
++)
2793 if (streamer_mode_table
[i
])
2795 machine_mode m
= (machine_mode
) i
;
2796 machine_mode inner_m
= GET_MODE_INNER (m
);
2798 streamer_mode_table
[(int) inner_m
] = 1;
2800 /* First stream modes that have GET_MODE_INNER (m) == m,
2801 so that we can refer to them afterwards. */
2802 for (int pass
= 0; pass
< 2; pass
++)
2803 for (int i
= 0; i
< (int) MAX_MACHINE_MODE
; i
++)
2804 if (streamer_mode_table
[i
] && i
!= (int) VOIDmode
&& i
!= (int) BLKmode
)
2806 machine_mode m
= (machine_mode
) i
;
2807 if ((GET_MODE_INNER (m
) == m
) ^ (pass
== 0))
2809 bp_pack_value (&bp
, m
, 8);
2810 bp_pack_enum (&bp
, mode_class
, MAX_MODE_CLASS
, GET_MODE_CLASS (m
));
2811 bp_pack_poly_value (&bp
, GET_MODE_SIZE (m
), 16);
2812 bp_pack_poly_value (&bp
, GET_MODE_PRECISION (m
), 16);
2813 bp_pack_value (&bp
, GET_MODE_INNER (m
), 8);
2814 bp_pack_poly_value (&bp
, GET_MODE_NUNITS (m
), 16);
2815 switch (GET_MODE_CLASS (m
))
2821 bp_pack_value (&bp
, GET_MODE_IBIT (m
), 8);
2822 bp_pack_value (&bp
, GET_MODE_FBIT (m
), 8);
2825 case MODE_DECIMAL_FLOAT
:
2826 bp_pack_string (ob
, &bp
, REAL_MODE_FORMAT (m
)->name
, true);
2831 bp_pack_string (ob
, &bp
, GET_MODE_NAME (m
), true);
2833 bp_pack_value (&bp
, VOIDmode
, 8);
2835 streamer_write_bitpack (&bp
);
2838 = lto_get_section_name (LTO_section_mode_table
, NULL
, NULL
);
2839 lto_begin_section (section_name
, !flag_wpa
);
2840 free (section_name
);
2842 /* The entire header stream is computed here. */
2843 struct lto_simple_header_with_strings header
;
2844 memset (&header
, 0, sizeof (header
));
2846 header
.main_size
= ob
->main_stream
->total_size
;
2847 header
.string_size
= ob
->string_stream
->total_size
;
2848 lto_write_data (&header
, sizeof header
);
2850 /* Put all of the gimple and the string table out the asm file as a
2852 lto_write_stream (ob
->main_stream
);
2853 lto_write_stream (ob
->string_stream
);
2856 destroy_output_block (ob
);
2860 /* This pass is run after all of the functions are serialized and all
2861 of the IPA passes have written their serialized forms. This pass
2862 causes the vector of all of the global decls and types used from
2863 this file to be written in to a section that can then be read in to
2864 recover these on other side. */
2867 produce_asm_for_decls (void)
2869 struct lto_out_decl_state
*out_state
;
2870 struct lto_out_decl_state
*fn_out_state
;
2871 struct lto_decl_header header
;
2873 struct output_block
*ob
;
2874 unsigned idx
, num_fns
;
2875 size_t decl_state_size
;
2876 int32_t num_decl_states
;
2878 ob
= create_output_block (LTO_section_decls
);
2880 memset (&header
, 0, sizeof (struct lto_decl_header
));
2882 section_name
= lto_get_section_name (LTO_section_decls
, NULL
, NULL
);
2883 lto_begin_section (section_name
, !flag_wpa
);
2884 free (section_name
);
2886 /* Make string 0 be a NULL string. */
2887 streamer_write_char_stream (ob
->string_stream
, 0);
2889 gcc_assert (!alias_pairs
);
2891 /* Get rid of the global decl state hash tables to save some memory. */
2892 out_state
= lto_get_out_decl_state ();
2893 for (int i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2894 if (out_state
->streams
[i
].tree_hash_table
)
2896 delete out_state
->streams
[i
].tree_hash_table
;
2897 out_state
->streams
[i
].tree_hash_table
= NULL
;
2900 /* Write the global symbols. */
2901 if (streamer_dump_file
)
2902 fprintf (streamer_dump_file
, "Outputting global stream\n");
2903 lto_output_decl_state_streams (ob
, out_state
);
2904 num_fns
= lto_function_decl_states
.length ();
2905 for (idx
= 0; idx
< num_fns
; idx
++)
2908 lto_function_decl_states
[idx
];
2909 if (streamer_dump_file
)
2910 fprintf (streamer_dump_file
, "Outputting stream for %s\n",
2912 (DECL_ASSEMBLER_NAME (fn_out_state
->fn_decl
)));
2913 lto_output_decl_state_streams (ob
, fn_out_state
);
2916 /* Currently not used. This field would allow us to preallocate
2917 the globals vector, so that it need not be resized as it is extended. */
2918 header
.num_nodes
= -1;
2920 /* Compute the total size of all decl out states. */
2921 decl_state_size
= sizeof (int32_t);
2922 decl_state_size
+= lto_out_decl_state_written_size (out_state
);
2923 for (idx
= 0; idx
< num_fns
; idx
++)
2926 lto_function_decl_states
[idx
];
2927 decl_state_size
+= lto_out_decl_state_written_size (fn_out_state
);
2929 header
.decl_state_size
= decl_state_size
;
2931 header
.main_size
= ob
->main_stream
->total_size
;
2932 header
.string_size
= ob
->string_stream
->total_size
;
2934 lto_write_data (&header
, sizeof header
);
2936 /* Write the main out-decl state, followed by out-decl states of
2938 num_decl_states
= num_fns
+ 1;
2939 lto_write_data (&num_decl_states
, sizeof (num_decl_states
));
2940 lto_output_decl_state_refs (ob
, out_state
);
2941 for (idx
= 0; idx
< num_fns
; idx
++)
2943 fn_out_state
= lto_function_decl_states
[idx
];
2944 lto_output_decl_state_refs (ob
, fn_out_state
);
2947 lto_write_stream (ob
->main_stream
);
2948 lto_write_stream (ob
->string_stream
);
2952 /* Write the symbol table. It is used by linker to determine dependencies
2953 and thus we can skip it for WPA. */
2955 produce_symtab (ob
);
2957 /* Write command line opts. */
2958 lto_write_options ();
2960 /* Deallocate memory and clean up. */
2961 for (idx
= 0; idx
< num_fns
; idx
++)
2964 lto_function_decl_states
[idx
];
2965 lto_delete_out_decl_state (fn_out_state
);
2967 lto_symtab_encoder_delete (ob
->decl_state
->symtab_node_encoder
);
2968 lto_function_decl_states
.release ();
2969 destroy_output_block (ob
);
2970 if (lto_stream_offload_p
)
2971 lto_write_mode_table ();