1 /* Write the GIMPLE representation to a file stream.
3 Copyright (C) 2009-2018 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
)
311 && code
!= MODIFY_EXPR
313 && code
!= TARGET_EXPR
315 && code
!= WITH_CLEANUP_EXPR
316 && code
!= STATEMENT_LIST
317 && (code
== CASE_LABEL_EXPR
319 || TREE_CODE_CLASS (code
) != tcc_statement
);
322 /* Very rough estimate of streaming size of the initializer. If we ignored
323 presence of strings, we could simply just count number of non-indexable
324 tree nodes and number of references to indexable nodes. Strings however
325 may be very large and we do not want to dump them int othe global stream.
327 Count the size of initializer until the size in DATA is positive. */
330 subtract_estimated_size (tree
*tp
, int *ws
, void *data
)
332 long *sum
= (long *)data
;
333 if (tree_is_indexable (*tp
))
335 /* Indexable tree is one reference to global stream.
336 Guess it may be about 4 bytes. */
340 /* String table entry + base of tree node needs to be streamed. */
341 if (TREE_CODE (*tp
) == STRING_CST
)
342 *sum
-= TREE_STRING_LENGTH (*tp
) + 8;
345 /* Identifiers are also variable length but should not appear
346 naked in constructor. */
347 gcc_checking_assert (TREE_CODE (*tp
) != IDENTIFIER_NODE
);
348 /* We do not really make attempt to work out size of pickled tree, as
349 it is very variable. Make it bigger than the reference. */
358 /* For EXPR lookup and return what we want to stream to OB as DECL_INITIAL. */
361 get_symbol_initial_value (lto_symtab_encoder_t encoder
, tree expr
)
363 gcc_checking_assert (DECL_P (expr
)
364 && TREE_CODE (expr
) != FUNCTION_DECL
365 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
);
367 /* Handle DECL_INITIAL for symbols. */
368 tree initial
= DECL_INITIAL (expr
);
370 && (TREE_STATIC (expr
) || DECL_EXTERNAL (expr
))
371 && !DECL_IN_CONSTANT_POOL (expr
)
375 /* Extra section needs about 30 bytes; do not produce it for simple
377 if (!(vnode
= varpool_node::get (expr
))
378 || !lto_symtab_encoder_encode_initializer_p (encoder
, vnode
))
379 initial
= error_mark_node
;
380 if (initial
!= error_mark_node
)
383 if (walk_tree (&initial
, subtract_estimated_size
, (void *)&max_size
,
385 initial
= error_mark_node
;
393 /* Write a physical representation of tree node EXPR to output block
394 OB. If REF_P is true, the leaves of EXPR are emitted as references
395 via lto_output_tree_ref. IX is the index into the streamer cache
396 where EXPR is stored. */
399 lto_write_tree_1 (struct output_block
*ob
, tree expr
, bool ref_p
)
401 /* Pack all the non-pointer fields in EXPR into a bitpack and write
402 the resulting bitpack. */
403 streamer_write_tree_bitfields (ob
, expr
);
405 /* Write all the pointer fields in EXPR. */
406 streamer_write_tree_body (ob
, expr
, ref_p
);
408 /* Write any LTO-specific data to OB. */
410 && TREE_CODE (expr
) != FUNCTION_DECL
411 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
413 /* Handle DECL_INITIAL for symbols. */
414 tree initial
= get_symbol_initial_value
415 (ob
->decl_state
->symtab_node_encoder
, expr
);
416 stream_write_tree (ob
, initial
, ref_p
);
419 /* Stream references to early generated DIEs. Keep in sync with the
420 trees handled in dwarf2out_die_ref_for_decl. */
422 && TREE_CODE (expr
) != FIELD_DECL
423 && TREE_CODE (expr
) != DEBUG_EXPR_DECL
424 && TREE_CODE (expr
) != TYPE_DECL
)
425 || TREE_CODE (expr
) == BLOCK
)
428 unsigned HOST_WIDE_INT off
;
429 if (debug_info_level
> DINFO_LEVEL_NONE
430 && debug_hooks
->die_ref_for_decl (expr
, &sym
, &off
))
432 streamer_write_string (ob
, ob
->main_stream
, sym
, true);
433 streamer_write_uhwi (ob
, off
);
436 streamer_write_string (ob
, ob
->main_stream
, NULL
, true);
440 /* Write a physical representation of tree node EXPR to output block
441 OB. If REF_P is true, the leaves of EXPR are emitted as references
442 via lto_output_tree_ref. IX is the index into the streamer cache
443 where EXPR is stored. */
446 lto_write_tree (struct output_block
*ob
, tree expr
, bool ref_p
)
448 if (!lto_is_streamable (expr
))
449 internal_error ("tree code %qs is not supported in LTO streams",
450 get_tree_code_name (TREE_CODE (expr
)));
452 /* Write the header, containing everything needed to materialize
453 EXPR on the reading side. */
454 streamer_write_tree_header (ob
, expr
);
456 lto_write_tree_1 (ob
, expr
, ref_p
);
458 /* Mark the end of EXPR. */
459 streamer_write_zero (ob
);
462 /* Emit the physical representation of tree node EXPR to output block OB,
463 If THIS_REF_P is true, the leaves of EXPR are emitted as references via
464 lto_output_tree_ref. REF_P is used for streaming siblings of EXPR. */
467 lto_output_tree_1 (struct output_block
*ob
, tree expr
, hashval_t hash
,
468 bool ref_p
, bool this_ref_p
)
472 gcc_checking_assert (expr
!= NULL_TREE
473 && !(this_ref_p
&& tree_is_indexable (expr
)));
475 bool exists_p
= streamer_tree_cache_insert (ob
->writer_cache
,
477 gcc_assert (!exists_p
);
478 if (TREE_CODE (expr
) == INTEGER_CST
479 && !TREE_OVERFLOW (expr
))
481 /* Shared INTEGER_CST nodes are special because they need their
482 original type to be materialized by the reader (to implement
483 TYPE_CACHED_VALUES). */
484 streamer_write_integer_cst (ob
, expr
, ref_p
);
488 /* This is the first time we see EXPR, write its fields
490 lto_write_tree (ob
, expr
, ref_p
);
497 DFS (struct output_block
*ob
, tree expr
, bool ref_p
, bool this_ref_p
,
506 vec
<scc_entry
> sccstack
;
523 static int scc_entry_compare (const void *, const void *);
525 void DFS_write_tree_body (struct output_block
*ob
,
526 tree expr
, sccs
*expr_state
, bool ref_p
);
528 void DFS_write_tree (struct output_block
*ob
, sccs
*from_state
,
529 tree expr
, bool ref_p
, bool this_ref_p
);
532 hash_scc (struct output_block
*ob
, unsigned first
, unsigned size
,
533 bool ref_p
, bool this_ref_p
);
535 hash_map
<tree
, sccs
*> sccstate
;
536 vec
<worklist
> worklist_vec
;
537 struct obstack sccstate_obstack
;
540 /* Emit the physical representation of tree node EXPR to output block OB,
541 using depth-first search on the subgraph. If THIS_REF_P is true, the
542 leaves of EXPR are emitted as references via lto_output_tree_ref.
543 REF_P is used for streaming siblings of EXPR. If SINGLE_P is true,
544 this is for a rewalk of a single leaf SCC. */
546 DFS::DFS (struct output_block
*ob
, tree expr
, bool ref_p
, bool this_ref_p
,
549 unsigned int next_dfs_num
= 1;
551 gcc_obstack_init (&sccstate_obstack
);
552 worklist_vec
= vNULL
;
553 DFS_write_tree (ob
, NULL
, expr
, ref_p
, this_ref_p
);
554 while (!worklist_vec
.is_empty ())
556 worklist
&w
= worklist_vec
.last ();
558 sccs
*from_state
= w
.from_state
;
559 sccs
*cstate
= w
.cstate
;
561 this_ref_p
= w
.this_ref_p
;
564 sccs
**slot
= &sccstate
.get_or_insert (expr
);
568 gcc_checking_assert (from_state
);
569 if (cstate
->dfsnum
< from_state
->dfsnum
)
570 from_state
->low
= MIN (cstate
->dfsnum
, from_state
->low
);
575 scc_entry e
= { expr
, 0 };
576 /* Not yet visited. DFS recurse and push it onto the stack. */
577 *slot
= cstate
= XOBNEW (&sccstate_obstack
, struct sccs
);
578 sccstack
.safe_push (e
);
579 cstate
->dfsnum
= next_dfs_num
++;
580 cstate
->low
= cstate
->dfsnum
;
583 if (TREE_CODE (expr
) == INTEGER_CST
584 && !TREE_OVERFLOW (expr
))
585 DFS_write_tree (ob
, cstate
, TREE_TYPE (expr
), ref_p
, ref_p
);
588 DFS_write_tree_body (ob
, expr
, cstate
, ref_p
);
590 /* Walk any LTO-specific edges. */
592 && TREE_CODE (expr
) != FUNCTION_DECL
593 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
595 /* Handle DECL_INITIAL for symbols. */
597 = get_symbol_initial_value (ob
->decl_state
->symtab_node_encoder
,
599 DFS_write_tree (ob
, cstate
, initial
, ref_p
, ref_p
);
605 /* See if we found an SCC. */
606 if (cstate
->low
== cstate
->dfsnum
)
608 unsigned first
, size
;
611 /* If we are re-walking a single leaf SCC just pop it,
612 let earlier worklist item access the sccstack. */
619 /* Pop the SCC and compute its size. */
620 first
= sccstack
.length ();
623 x
= sccstack
[--first
].t
;
626 size
= sccstack
.length () - first
;
628 /* No need to compute hashes for LTRANS units, we don't perform
629 any merging there. */
630 hashval_t scc_hash
= 0;
631 unsigned scc_entry_len
= 0;
634 scc_hash
= hash_scc (ob
, first
, size
, ref_p
, this_ref_p
);
636 /* Put the entries with the least number of collisions first. */
637 unsigned entry_start
= 0;
638 scc_entry_len
= size
+ 1;
639 for (unsigned i
= 0; i
< size
;)
642 for (i
= i
+ 1; i
< size
643 && (sccstack
[first
+ i
].hash
644 == sccstack
[first
+ from
].hash
); ++i
)
646 if (i
- from
< scc_entry_len
)
648 scc_entry_len
= i
- from
;
652 for (unsigned i
= 0; i
< scc_entry_len
; ++i
)
653 std::swap (sccstack
[first
+ i
],
654 sccstack
[first
+ entry_start
+ i
]);
656 /* We already sorted SCC deterministically in hash_scc. */
658 /* Check that we have only one SCC.
659 Naturally we may have conflicts if hash function is not
660 strong enough. Lets see how far this gets. */
661 gcc_checking_assert (scc_entry_len
== 1);
664 /* Write LTO_tree_scc. */
665 streamer_write_record_start (ob
, LTO_tree_scc
);
666 streamer_write_uhwi (ob
, size
);
667 streamer_write_uhwi (ob
, scc_hash
);
669 /* Write size-1 SCCs without wrapping them inside SCC bundles.
670 All INTEGER_CSTs need to be handled this way as we need
671 their type to materialize them. Also builtins are handled
673 ??? We still wrap these in LTO_tree_scc so at the
674 input side we can properly identify the tree we want
675 to ultimatively return. */
677 lto_output_tree_1 (ob
, expr
, scc_hash
, ref_p
, this_ref_p
);
680 /* Write the size of the SCC entry candidates. */
681 streamer_write_uhwi (ob
, scc_entry_len
);
683 /* Write all headers and populate the streamer cache. */
684 for (unsigned i
= 0; i
< size
; ++i
)
686 hashval_t hash
= sccstack
[first
+i
].hash
;
687 tree t
= sccstack
[first
+i
].t
;
688 bool exists_p
= streamer_tree_cache_insert (ob
->writer_cache
,
690 gcc_assert (!exists_p
);
692 if (!lto_is_streamable (t
))
693 internal_error ("tree code %qs is not supported "
695 get_tree_code_name (TREE_CODE (t
)));
697 /* Write the header, containing everything needed to
698 materialize EXPR on the reading side. */
699 streamer_write_tree_header (ob
, t
);
702 /* Write the bitpacks and tree references. */
703 for (unsigned i
= 0; i
< size
; ++i
)
705 lto_write_tree_1 (ob
, sccstack
[first
+i
].t
, ref_p
);
707 /* Mark the end of the tree. */
708 streamer_write_zero (ob
);
712 /* Finally truncate the vector. */
713 sccstack
.truncate (first
);
716 from_state
->low
= MIN (from_state
->low
, cstate
->low
);
721 gcc_checking_assert (from_state
);
722 from_state
->low
= MIN (from_state
->low
, cstate
->low
);
723 if (cstate
->dfsnum
< from_state
->dfsnum
)
724 from_state
->low
= MIN (cstate
->dfsnum
, from_state
->low
);
727 worklist_vec
.release ();
733 obstack_free (&sccstate_obstack
, NULL
);
736 /* Handle the tree EXPR in the DFS walk with SCC state EXPR_STATE and
737 DFS recurse for all tree edges originating from it. */
740 DFS::DFS_write_tree_body (struct output_block
*ob
,
741 tree expr
, sccs
*expr_state
, bool ref_p
)
743 #define DFS_follow_tree_edge(DEST) \
744 DFS_write_tree (ob, expr_state, DEST, ref_p, ref_p)
748 if (streamer_dump_file
)
750 print_node_brief (streamer_dump_file
, " Streaming ",
752 fprintf (streamer_dump_file
, " to %s\n",
753 lto_section_name
[ob
->section_type
]);
756 code
= TREE_CODE (expr
);
758 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
760 if (TREE_CODE (expr
) != IDENTIFIER_NODE
)
761 DFS_follow_tree_edge (TREE_TYPE (expr
));
764 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
766 unsigned int count
= vector_cst_encoded_nelts (expr
);
767 for (unsigned int i
= 0; i
< count
; ++i
)
768 DFS_follow_tree_edge (VECTOR_CST_ENCODED_ELT (expr
, i
));
771 if (CODE_CONTAINS_STRUCT (code
, TS_POLY_INT_CST
))
772 for (unsigned int i
= 0; i
< NUM_POLY_INT_COEFFS
; ++i
)
773 DFS_follow_tree_edge (POLY_INT_CST_COEFF (expr
, i
));
775 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
777 DFS_follow_tree_edge (TREE_REALPART (expr
));
778 DFS_follow_tree_edge (TREE_IMAGPART (expr
));
781 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
783 /* Drop names that were created for anonymous entities. */
785 && TREE_CODE (DECL_NAME (expr
)) == IDENTIFIER_NODE
786 && anon_aggrname_p (DECL_NAME (expr
)))
789 DFS_follow_tree_edge (DECL_NAME (expr
));
790 if (TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
791 && ! DECL_CONTEXT (expr
))
792 DFS_follow_tree_edge ((*all_translation_units
)[0]);
794 DFS_follow_tree_edge (DECL_CONTEXT (expr
));
797 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
799 DFS_follow_tree_edge (DECL_SIZE (expr
));
800 DFS_follow_tree_edge (DECL_SIZE_UNIT (expr
));
802 /* Note, DECL_INITIAL is not handled here. Since DECL_INITIAL needs
803 special handling in LTO, it must be handled by streamer hooks. */
805 DFS_follow_tree_edge (DECL_ATTRIBUTES (expr
));
807 /* We use DECL_ABSTRACT_ORIGIN == error_mark_node to mark
808 declarations which should be eliminated by decl merging. Be sure none
809 leaks to this point. */
810 gcc_assert (DECL_ABSTRACT_ORIGIN (expr
) != error_mark_node
);
811 DFS_follow_tree_edge (DECL_ABSTRACT_ORIGIN (expr
));
814 || TREE_CODE (expr
) == PARM_DECL
)
815 && DECL_HAS_VALUE_EXPR_P (expr
))
816 DFS_follow_tree_edge (DECL_VALUE_EXPR (expr
));
818 && DECL_HAS_DEBUG_EXPR_P (expr
))
819 DFS_follow_tree_edge (DECL_DEBUG_EXPR (expr
));
822 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
824 /* Make sure we don't inadvertently set the assembler name. */
825 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
826 DFS_follow_tree_edge (DECL_ASSEMBLER_NAME (expr
));
829 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
831 DFS_follow_tree_edge (DECL_FIELD_OFFSET (expr
));
832 DFS_follow_tree_edge (DECL_BIT_FIELD_TYPE (expr
));
833 DFS_follow_tree_edge (DECL_BIT_FIELD_REPRESENTATIVE (expr
));
834 DFS_follow_tree_edge (DECL_FIELD_BIT_OFFSET (expr
));
835 gcc_checking_assert (!DECL_FCONTEXT (expr
));
838 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
840 gcc_checking_assert (DECL_VINDEX (expr
) == NULL
);
841 DFS_follow_tree_edge (DECL_FUNCTION_PERSONALITY (expr
));
842 DFS_follow_tree_edge (DECL_FUNCTION_SPECIFIC_TARGET (expr
));
843 DFS_follow_tree_edge (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr
));
846 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
848 DFS_follow_tree_edge (TYPE_SIZE (expr
));
849 DFS_follow_tree_edge (TYPE_SIZE_UNIT (expr
));
850 DFS_follow_tree_edge (TYPE_ATTRIBUTES (expr
));
851 DFS_follow_tree_edge (TYPE_NAME (expr
));
852 /* Do not follow TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
853 reconstructed during fixup. */
854 /* Do not follow TYPE_NEXT_VARIANT, we reconstruct the variant lists
856 DFS_follow_tree_edge (TYPE_MAIN_VARIANT (expr
));
857 DFS_follow_tree_edge (TYPE_CONTEXT (expr
));
858 /* TYPE_CANONICAL is re-computed during type merging, so no need
859 to follow it here. */
860 /* Do not stream TYPE_STUB_DECL; it is not needed by LTO but currently
861 it can not be freed by free_lang_data without triggering ICEs in
865 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
867 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
868 DFS_follow_tree_edge (TYPE_VALUES (expr
));
869 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
870 DFS_follow_tree_edge (TYPE_DOMAIN (expr
));
871 else if (RECORD_OR_UNION_TYPE_P (expr
))
872 for (tree t
= TYPE_FIELDS (expr
); t
; t
= TREE_CHAIN (t
))
873 DFS_follow_tree_edge (t
);
874 else if (TREE_CODE (expr
) == FUNCTION_TYPE
875 || TREE_CODE (expr
) == METHOD_TYPE
)
876 DFS_follow_tree_edge (TYPE_ARG_TYPES (expr
));
878 if (!POINTER_TYPE_P (expr
))
879 DFS_follow_tree_edge (TYPE_MIN_VALUE_RAW (expr
));
880 DFS_follow_tree_edge (TYPE_MAX_VALUE_RAW (expr
));
883 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
885 DFS_follow_tree_edge (TREE_PURPOSE (expr
));
886 DFS_follow_tree_edge (TREE_VALUE (expr
));
887 DFS_follow_tree_edge (TREE_CHAIN (expr
));
890 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
892 for (int i
= 0; i
< TREE_VEC_LENGTH (expr
); i
++)
893 DFS_follow_tree_edge (TREE_VEC_ELT (expr
, i
));
896 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
898 for (int i
= 0; i
< TREE_OPERAND_LENGTH (expr
); i
++)
899 DFS_follow_tree_edge (TREE_OPERAND (expr
, i
));
900 DFS_follow_tree_edge (TREE_BLOCK (expr
));
903 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
905 for (tree t
= BLOCK_VARS (expr
); t
; t
= TREE_CHAIN (t
))
907 /* We would have to stream externals in the block chain as
908 non-references but we should have dropped them in
910 gcc_assert (!VAR_OR_FUNCTION_DECL_P (t
) || !DECL_EXTERNAL (t
));
911 DFS_follow_tree_edge (t
);
914 DFS_follow_tree_edge (BLOCK_SUPERCONTEXT (expr
));
915 DFS_follow_tree_edge (BLOCK_ABSTRACT_ORIGIN (expr
));
917 /* Do not follow BLOCK_NONLOCALIZED_VARS. We cannot handle debug
918 information for early inlined BLOCKs so drop it on the floor instead
919 of ICEing in dwarf2out.c. */
921 /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
924 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
925 list is re-constructed from BLOCK_SUPERCONTEXT. */
928 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
933 /* Note that the number of BINFO slots has already been emitted in
934 EXPR's header (see streamer_write_tree_header) because this length
935 is needed to build the empty BINFO node on the reader side. */
936 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr
), i
, t
)
937 DFS_follow_tree_edge (t
);
938 DFS_follow_tree_edge (BINFO_OFFSET (expr
));
939 DFS_follow_tree_edge (BINFO_VTABLE (expr
));
941 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX,
942 BINFO_BASE_ACCESSES and BINFO_VPTR_INDEX; these are used
946 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
951 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr
), i
, index
, value
)
953 DFS_follow_tree_edge (index
);
954 DFS_follow_tree_edge (value
);
958 if (code
== OMP_CLAUSE
)
961 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (expr
)]; i
++)
962 DFS_follow_tree_edge (OMP_CLAUSE_OPERAND (expr
, i
));
963 DFS_follow_tree_edge (OMP_CLAUSE_CHAIN (expr
));
966 #undef DFS_follow_tree_edge
969 /* Return a hash value for the tree T.
970 CACHE holds hash values of trees outside current SCC. MAP, if non-NULL,
971 may hold hash values if trees inside current SCC. */
974 hash_tree (struct streamer_tree_cache_d
*cache
, hash_map
<tree
, hashval_t
> *map
, tree t
)
976 inchash::hash hstate
;
978 #define visit(SIBLING) \
982 hstate.add_int (0); \
983 else if (streamer_tree_cache_lookup (cache, SIBLING, &ix)) \
984 hstate.add_int (streamer_tree_cache_get_hash (cache, ix)); \
986 hstate.add_int (*map->get (SIBLING)); \
988 hstate.add_int (1); \
992 enum tree_code code
= TREE_CODE (t
);
993 hstate
.add_int (code
);
996 hstate
.add_flag (TREE_SIDE_EFFECTS (t
));
997 hstate
.add_flag (TREE_CONSTANT (t
));
998 hstate
.add_flag (TREE_READONLY (t
));
999 hstate
.add_flag (TREE_PUBLIC (t
));
1001 hstate
.add_flag (TREE_ADDRESSABLE (t
));
1002 hstate
.add_flag (TREE_THIS_VOLATILE (t
));
1004 hstate
.add_flag (DECL_UNSIGNED (t
));
1005 else if (TYPE_P (t
))
1006 hstate
.add_flag (TYPE_UNSIGNED (t
));
1008 hstate
.add_flag (TYPE_ARTIFICIAL (t
));
1010 hstate
.add_flag (TREE_NO_WARNING (t
));
1011 hstate
.add_flag (TREE_NOTHROW (t
));
1012 hstate
.add_flag (TREE_STATIC (t
));
1013 hstate
.add_flag (TREE_PROTECTED (t
));
1014 hstate
.add_flag (TREE_DEPRECATED (t
));
1015 if (code
!= TREE_BINFO
)
1016 hstate
.add_flag (TREE_PRIVATE (t
));
1019 hstate
.add_flag (AGGREGATE_TYPE_P (t
)
1020 ? TYPE_REVERSE_STORAGE_ORDER (t
) : TYPE_SATURATING (t
));
1021 hstate
.add_flag (TYPE_ADDR_SPACE (t
));
1023 else if (code
== SSA_NAME
)
1024 hstate
.add_flag (SSA_NAME_IS_DEFAULT_DEF (t
));
1025 hstate
.commit_flag ();
1027 if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
1028 hstate
.add_wide_int (wi::to_widest (t
));
1030 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
1032 REAL_VALUE_TYPE r
= TREE_REAL_CST (t
);
1033 hstate
.add_flag (r
.cl
);
1034 hstate
.add_flag (r
.sign
);
1035 hstate
.add_flag (r
.signalling
);
1036 hstate
.add_flag (r
.canonical
);
1037 hstate
.commit_flag ();
1038 hstate
.add_int (r
.uexp
);
1039 hstate
.add (r
.sig
, sizeof (r
.sig
));
1042 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
1044 FIXED_VALUE_TYPE f
= TREE_FIXED_CST (t
);
1045 hstate
.add_int (f
.mode
);
1046 hstate
.add_int (f
.data
.low
);
1047 hstate
.add_int (f
.data
.high
);
1050 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1052 hstate
.add_hwi (DECL_MODE (t
));
1053 hstate
.add_flag (DECL_NONLOCAL (t
));
1054 hstate
.add_flag (DECL_VIRTUAL_P (t
));
1055 hstate
.add_flag (DECL_IGNORED_P (t
));
1056 hstate
.add_flag (DECL_ABSTRACT_P (t
));
1057 hstate
.add_flag (DECL_ARTIFICIAL (t
));
1058 hstate
.add_flag (DECL_USER_ALIGN (t
));
1059 hstate
.add_flag (DECL_PRESERVE_P (t
));
1060 hstate
.add_flag (DECL_EXTERNAL (t
));
1061 hstate
.add_flag (DECL_GIMPLE_REG_P (t
));
1062 hstate
.commit_flag ();
1063 hstate
.add_int (DECL_ALIGN (t
));
1064 if (code
== LABEL_DECL
)
1066 hstate
.add_int (EH_LANDING_PAD_NR (t
));
1067 hstate
.add_int (LABEL_DECL_UID (t
));
1069 else if (code
== FIELD_DECL
)
1071 hstate
.add_flag (DECL_PACKED (t
));
1072 hstate
.add_flag (DECL_NONADDRESSABLE_P (t
));
1073 hstate
.add_flag (DECL_PADDING_P (t
));
1074 hstate
.add_int (DECL_OFFSET_ALIGN (t
));
1076 else if (code
== VAR_DECL
)
1078 hstate
.add_flag (DECL_HAS_DEBUG_EXPR_P (t
));
1079 hstate
.add_flag (DECL_NONLOCAL_FRAME (t
));
1081 if (code
== RESULT_DECL
1082 || code
== PARM_DECL
1083 || code
== VAR_DECL
)
1085 hstate
.add_flag (DECL_BY_REFERENCE (t
));
1086 if (code
== VAR_DECL
1087 || code
== PARM_DECL
)
1088 hstate
.add_flag (DECL_HAS_VALUE_EXPR_P (t
));
1090 hstate
.commit_flag ();
1093 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
1094 hstate
.add_int (DECL_REGISTER (t
));
1096 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1098 hstate
.add_flag (DECL_COMMON (t
));
1099 hstate
.add_flag (DECL_DLLIMPORT_P (t
));
1100 hstate
.add_flag (DECL_WEAK (t
));
1101 hstate
.add_flag (DECL_SEEN_IN_BIND_EXPR_P (t
));
1102 hstate
.add_flag (DECL_COMDAT (t
));
1103 hstate
.add_flag (DECL_VISIBILITY_SPECIFIED (t
));
1104 hstate
.add_int (DECL_VISIBILITY (t
));
1105 if (code
== VAR_DECL
)
1107 /* DECL_IN_TEXT_SECTION is set during final asm output only. */
1108 hstate
.add_flag (DECL_HARD_REGISTER (t
));
1109 hstate
.add_flag (DECL_IN_CONSTANT_POOL (t
));
1111 if (TREE_CODE (t
) == FUNCTION_DECL
)
1113 hstate
.add_flag (DECL_FINAL_P (t
));
1114 hstate
.add_flag (DECL_CXX_CONSTRUCTOR_P (t
));
1115 hstate
.add_flag (DECL_CXX_DESTRUCTOR_P (t
));
1117 hstate
.commit_flag ();
1120 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1122 hstate
.add_int (DECL_BUILT_IN_CLASS (t
));
1123 hstate
.add_flag (DECL_STATIC_CONSTRUCTOR (t
));
1124 hstate
.add_flag (DECL_STATIC_DESTRUCTOR (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_IS_OPERATOR_NEW (t
));
1131 hstate
.add_flag (DECL_DECLARED_INLINE_P (t
));
1132 hstate
.add_flag (DECL_STATIC_CHAIN (t
));
1133 hstate
.add_flag (DECL_NO_INLINE_WARNING_P (t
));
1134 hstate
.add_flag (DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (t
));
1135 hstate
.add_flag (DECL_NO_LIMIT_STACK (t
));
1136 hstate
.add_flag (DECL_DISREGARD_INLINE_LIMITS (t
));
1137 hstate
.add_flag (DECL_PURE_P (t
));
1138 hstate
.add_flag (DECL_LOOPING_CONST_OR_PURE_P (t
));
1139 hstate
.commit_flag ();
1140 if (DECL_BUILT_IN_CLASS (t
) != NOT_BUILT_IN
)
1141 hstate
.add_int (DECL_FUNCTION_CODE (t
));
1144 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
1146 hstate
.add_hwi (TYPE_MODE (t
));
1147 hstate
.add_flag (TYPE_STRING_FLAG (t
));
1148 /* TYPE_NO_FORCE_BLK is private to stor-layout and need
1150 hstate
.add_flag (TYPE_PACKED (t
));
1151 hstate
.add_flag (TYPE_RESTRICT (t
));
1152 hstate
.add_flag (TYPE_USER_ALIGN (t
));
1153 hstate
.add_flag (TYPE_READONLY (t
));
1154 if (RECORD_OR_UNION_TYPE_P (t
))
1156 hstate
.add_flag (TYPE_TRANSPARENT_AGGR (t
));
1157 hstate
.add_flag (TYPE_FINAL_P (t
));
1159 else if (code
== ARRAY_TYPE
)
1160 hstate
.add_flag (TYPE_NONALIASED_COMPONENT (t
));
1161 if (AGGREGATE_TYPE_P (t
))
1162 hstate
.add_flag (TYPE_TYPELESS_STORAGE (t
));
1163 hstate
.commit_flag ();
1164 hstate
.add_int (TYPE_PRECISION (t
));
1165 hstate
.add_int (TYPE_ALIGN (t
));
1166 hstate
.add_int (TYPE_EMPTY_P (t
));
1169 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
1170 hstate
.add (TRANSLATION_UNIT_LANGUAGE (t
),
1171 strlen (TRANSLATION_UNIT_LANGUAGE (t
)));
1173 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
)
1174 /* We don't stream these when passing things to a different target. */
1175 && !lto_stream_offload_p
)
1176 hstate
.add_hwi (cl_target_option_hash (TREE_TARGET_OPTION (t
)));
1178 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
1179 hstate
.add_hwi (cl_optimization_hash (TREE_OPTIMIZATION (t
)));
1181 if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
1182 hstate
.merge_hash (IDENTIFIER_HASH_VALUE (t
));
1184 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
1185 hstate
.add (TREE_STRING_POINTER (t
), TREE_STRING_LENGTH (t
));
1187 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
1189 if (code
!= IDENTIFIER_NODE
)
1190 visit (TREE_TYPE (t
));
1193 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
1195 unsigned int count
= vector_cst_encoded_nelts (t
);
1196 for (unsigned int i
= 0; i
< count
; ++i
)
1197 visit (VECTOR_CST_ENCODED_ELT (t
, i
));
1200 if (CODE_CONTAINS_STRUCT (code
, TS_POLY_INT_CST
))
1201 for (unsigned int i
= 0; i
< NUM_POLY_INT_COEFFS
; ++i
)
1202 visit (POLY_INT_CST_COEFF (t
, i
));
1204 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
1206 visit (TREE_REALPART (t
));
1207 visit (TREE_IMAGPART (t
));
1210 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
1212 /* Drop names that were created for anonymous entities. */
1214 && TREE_CODE (DECL_NAME (t
)) == IDENTIFIER_NODE
1215 && anon_aggrname_p (DECL_NAME (t
)))
1218 visit (DECL_NAME (t
));
1219 if (DECL_FILE_SCOPE_P (t
))
1222 visit (DECL_CONTEXT (t
));
1225 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1227 visit (DECL_SIZE (t
));
1228 visit (DECL_SIZE_UNIT (t
));
1229 visit (DECL_ATTRIBUTES (t
));
1230 if ((code
== VAR_DECL
1231 || code
== PARM_DECL
)
1232 && DECL_HAS_VALUE_EXPR_P (t
))
1233 visit (DECL_VALUE_EXPR (t
));
1234 if (code
== VAR_DECL
1235 && DECL_HAS_DEBUG_EXPR_P (t
))
1236 visit (DECL_DEBUG_EXPR (t
));
1237 /* ??? Hash DECL_INITIAL as streamed. Needs the output-block to
1238 be able to call get_symbol_initial_value. */
1241 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1243 if (DECL_ASSEMBLER_NAME_SET_P (t
))
1244 visit (DECL_ASSEMBLER_NAME (t
));
1247 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
1249 visit (DECL_FIELD_OFFSET (t
));
1250 visit (DECL_BIT_FIELD_TYPE (t
));
1251 visit (DECL_BIT_FIELD_REPRESENTATIVE (t
));
1252 visit (DECL_FIELD_BIT_OFFSET (t
));
1255 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1257 visit (DECL_FUNCTION_PERSONALITY (t
));
1258 visit (DECL_FUNCTION_SPECIFIC_TARGET (t
));
1259 visit (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t
));
1262 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
1264 visit (TYPE_SIZE (t
));
1265 visit (TYPE_SIZE_UNIT (t
));
1266 visit (TYPE_ATTRIBUTES (t
));
1267 visit (TYPE_NAME (t
));
1268 visit (TYPE_MAIN_VARIANT (t
));
1269 if (TYPE_FILE_SCOPE_P (t
))
1272 visit (TYPE_CONTEXT (t
));
1275 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
1277 if (code
== ENUMERAL_TYPE
)
1278 visit (TYPE_VALUES (t
));
1279 else if (code
== ARRAY_TYPE
)
1280 visit (TYPE_DOMAIN (t
));
1281 else if (RECORD_OR_UNION_TYPE_P (t
))
1282 for (tree f
= TYPE_FIELDS (t
); f
; f
= TREE_CHAIN (f
))
1284 else if (code
== FUNCTION_TYPE
1285 || code
== METHOD_TYPE
)
1286 visit (TYPE_ARG_TYPES (t
));
1287 if (!POINTER_TYPE_P (t
))
1288 visit (TYPE_MIN_VALUE_RAW (t
));
1289 visit (TYPE_MAX_VALUE_RAW (t
));
1292 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
1294 visit (TREE_PURPOSE (t
));
1295 visit (TREE_VALUE (t
));
1296 visit (TREE_CHAIN (t
));
1299 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1300 for (int i
= 0; i
< TREE_VEC_LENGTH (t
); ++i
)
1301 visit (TREE_VEC_ELT (t
, i
));
1303 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
1305 hstate
.add_hwi (TREE_OPERAND_LENGTH (t
));
1306 for (int i
= 0; i
< TREE_OPERAND_LENGTH (t
); ++i
)
1307 visit (TREE_OPERAND (t
, i
));
1310 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1314 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (t
), i
, b
)
1316 visit (BINFO_OFFSET (t
));
1317 visit (BINFO_VTABLE (t
));
1318 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
1319 BINFO_BASE_ACCESSES and BINFO_VPTR_INDEX; these are used
1323 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1327 hstate
.add_hwi (CONSTRUCTOR_NELTS (t
));
1328 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), i
, index
, value
)
1335 if (code
== OMP_CLAUSE
)
1340 hstate
.add_hwi (OMP_CLAUSE_CODE (t
));
1341 switch (OMP_CLAUSE_CODE (t
))
1343 case OMP_CLAUSE_DEFAULT
:
1344 val
= OMP_CLAUSE_DEFAULT_KIND (t
);
1346 case OMP_CLAUSE_SCHEDULE
:
1347 val
= OMP_CLAUSE_SCHEDULE_KIND (t
);
1349 case OMP_CLAUSE_DEPEND
:
1350 val
= OMP_CLAUSE_DEPEND_KIND (t
);
1352 case OMP_CLAUSE_MAP
:
1353 val
= OMP_CLAUSE_MAP_KIND (t
);
1355 case OMP_CLAUSE_PROC_BIND
:
1356 val
= OMP_CLAUSE_PROC_BIND_KIND (t
);
1358 case OMP_CLAUSE_REDUCTION
:
1359 case OMP_CLAUSE_TASK_REDUCTION
:
1360 case OMP_CLAUSE_IN_REDUCTION
:
1361 val
= OMP_CLAUSE_REDUCTION_CODE (t
);
1367 hstate
.add_hwi (val
);
1368 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (t
)]; i
++)
1369 visit (OMP_CLAUSE_OPERAND (t
, i
));
1370 visit (OMP_CLAUSE_CHAIN (t
));
1373 return hstate
.end ();
1378 /* Compare two SCC entries by their hash value for qsorting them. */
1381 DFS::scc_entry_compare (const void *p1_
, const void *p2_
)
1383 const scc_entry
*p1
= (const scc_entry
*) p1_
;
1384 const scc_entry
*p2
= (const scc_entry
*) p2_
;
1385 if (p1
->hash
< p2
->hash
)
1387 else if (p1
->hash
> p2
->hash
)
1392 /* Return a hash value for the SCC on the SCC stack from FIRST with SIZE.
1393 THIS_REF_P and REF_P are as passed to lto_output_tree for FIRST. */
1396 DFS::hash_scc (struct output_block
*ob
, unsigned first
, unsigned size
,
1397 bool ref_p
, bool this_ref_p
)
1399 unsigned int last_classes
= 0, iterations
= 0;
1401 /* Compute hash values for the SCC members. */
1402 for (unsigned i
= 0; i
< size
; ++i
)
1403 sccstack
[first
+i
].hash
1404 = hash_tree (ob
->writer_cache
, NULL
, sccstack
[first
+i
].t
);
1407 return sccstack
[first
].hash
;
1409 /* We aim to get unique hash for every tree within SCC and compute hash value
1410 of the whole SCC by combining all values together in a stable (entry-point
1411 independent) order. This guarantees that the same SCC regions within
1412 different translation units will get the same hash values and therefore
1413 will be merged at WPA time.
1415 Often the hashes are already unique. In that case we compute the SCC hash
1416 by combining individual hash values in an increasing order.
1418 If there are duplicates, we seek at least one tree with unique hash (and
1419 pick one with minimal hash and this property). Then we obtain a stable
1420 order by DFS walk starting from this unique tree and then use the index
1421 within this order to make individual hash values unique.
1423 If there is no tree with unique hash, we iteratively propagate the hash
1424 values across the internal edges of SCC. This usually quickly leads
1425 to unique hashes. Consider, for example, an SCC containing two pointers
1426 that are identical except for the types they point to and assume that
1427 these types are also part of the SCC. The propagation will add the
1428 points-to type information into their hash values. */
1431 /* Sort the SCC so we can easily check for uniqueness. */
1432 qsort (&sccstack
[first
], size
, sizeof (scc_entry
), scc_entry_compare
);
1434 unsigned int classes
= 1;
1435 int firstunique
= -1;
1437 /* Find the tree with lowest unique hash (if it exists) and compute
1438 the number of equivalence classes. */
1439 if (sccstack
[first
].hash
!= sccstack
[first
+1].hash
)
1441 for (unsigned i
= 1; i
< size
; ++i
)
1442 if (sccstack
[first
+i
-1].hash
!= sccstack
[first
+i
].hash
)
1445 if (firstunique
== -1
1447 || sccstack
[first
+i
+1].hash
!= sccstack
[first
+i
].hash
))
1451 /* If we found a tree with unique hash, stop the iteration. */
1452 if (firstunique
!= -1
1453 /* Also terminate if we run out of iterations or if the number of
1454 equivalence classes is no longer increasing.
1455 For example a cyclic list of trees that are all equivalent will
1456 never have unique entry point; we however do not build such SCCs
1458 || classes
<= last_classes
|| iterations
> 16)
1462 /* If some hashes are not unique (CLASSES != SIZE), use the DFS walk
1463 starting from FIRSTUNIQUE to obtain a stable order. */
1464 if (classes
!= size
&& firstunique
!= -1)
1466 hash_map
<tree
, hashval_t
> map(size
*2);
1468 /* Store hash values into a map, so we can associate them with
1469 the reordered SCC. */
1470 for (unsigned i
= 0; i
< size
; ++i
)
1471 map
.put (sccstack
[first
+i
].t
, sccstack
[first
+i
].hash
);
1473 DFS
again (ob
, sccstack
[first
+firstunique
].t
, ref_p
, this_ref_p
,
1475 gcc_assert (again
.sccstack
.length () == size
);
1477 memcpy (sccstack
.address () + first
,
1478 again
.sccstack
.address (),
1479 sizeof (scc_entry
) * size
);
1481 /* Update hash values of individual members by hashing in the
1482 index within the stable order. This ensures uniqueness.
1483 Also compute the SCC hash by mixing in all hash values in
1484 the stable order we obtained. */
1485 sccstack
[first
].hash
= *map
.get (sccstack
[first
].t
);
1486 scc_hash
= sccstack
[first
].hash
;
1487 for (unsigned i
= 1; i
< size
; ++i
)
1489 sccstack
[first
+i
].hash
1490 = iterative_hash_hashval_t (i
,
1491 *map
.get (sccstack
[first
+i
].t
));
1493 = iterative_hash_hashval_t (scc_hash
,
1494 sccstack
[first
+i
].hash
);
1497 /* If we got a unique hash value for each tree, then sort already
1498 ensured entry-point independent order. Only compute the final
1501 If we failed to find the unique entry point, we go by the same
1502 route. We will eventually introduce unwanted hash conflicts. */
1505 scc_hash
= sccstack
[first
].hash
;
1506 for (unsigned i
= 1; i
< size
; ++i
)
1508 = iterative_hash_hashval_t (scc_hash
, sccstack
[first
+i
].hash
);
1510 /* We cannot 100% guarantee that the hash won't conflict so as
1511 to make it impossible to find a unique hash. This however
1512 should be an extremely rare case. ICE for now so possible
1513 issues are found and evaluated. */
1514 gcc_checking_assert (classes
== size
);
1517 /* To avoid conflicts across SCCs, iteratively hash the whole SCC
1518 hash into the hash of each element. */
1519 for (unsigned i
= 0; i
< size
; ++i
)
1520 sccstack
[first
+i
].hash
1521 = iterative_hash_hashval_t (sccstack
[first
+i
].hash
, scc_hash
);
1525 last_classes
= classes
;
1528 /* We failed to identify the entry point; propagate hash values across
1530 hash_map
<tree
, hashval_t
> map(size
*2);
1532 for (unsigned i
= 0; i
< size
; ++i
)
1533 map
.put (sccstack
[first
+i
].t
, sccstack
[first
+i
].hash
);
1535 for (unsigned i
= 0; i
< size
; i
++)
1536 sccstack
[first
+i
].hash
1537 = hash_tree (ob
->writer_cache
, &map
, sccstack
[first
+i
].t
);
1542 /* DFS walk EXPR and stream SCCs of tree bodies if they are not
1543 already in the streamer cache. Main routine called for
1544 each visit of EXPR. */
1547 DFS::DFS_write_tree (struct output_block
*ob
, sccs
*from_state
,
1548 tree expr
, bool ref_p
, bool this_ref_p
)
1550 /* Handle special cases. */
1551 if (expr
== NULL_TREE
)
1554 /* Do not DFS walk into indexable trees. */
1555 if (this_ref_p
&& tree_is_indexable (expr
))
1558 /* Check if we already streamed EXPR. */
1559 if (streamer_tree_cache_lookup (ob
->writer_cache
, expr
, NULL
))
1564 w
.from_state
= from_state
;
1567 w
.this_ref_p
= this_ref_p
;
1568 worklist_vec
.safe_push (w
);
1572 /* Emit the physical representation of tree node EXPR to output block OB.
1573 If THIS_REF_P is true, the leaves of EXPR are emitted as references via
1574 lto_output_tree_ref. REF_P is used for streaming siblings of EXPR. */
1577 lto_output_tree (struct output_block
*ob
, tree expr
,
1578 bool ref_p
, bool this_ref_p
)
1583 if (expr
== NULL_TREE
)
1585 streamer_write_record_start (ob
, LTO_null
);
1589 if (this_ref_p
&& tree_is_indexable (expr
))
1591 lto_output_tree_ref (ob
, expr
);
1595 existed_p
= streamer_tree_cache_lookup (ob
->writer_cache
, expr
, &ix
);
1598 /* If a node has already been streamed out, make sure that
1599 we don't write it more than once. Otherwise, the reader
1600 will instantiate two different nodes for the same object. */
1601 streamer_write_record_start (ob
, LTO_tree_pickle_reference
);
1602 streamer_write_uhwi (ob
, ix
);
1603 streamer_write_enum (ob
->main_stream
, LTO_tags
, LTO_NUM_TAGS
,
1604 lto_tree_code_to_tag (TREE_CODE (expr
)));
1605 lto_stats
.num_pickle_refs_output
++;
1609 /* This is the first time we see EXPR, write all reachable
1611 static bool in_dfs_walk
;
1613 /* Protect against recursion which means disconnect between
1614 what tree edges we walk in the DFS walk and what edges
1616 gcc_assert (!in_dfs_walk
);
1618 if (streamer_dump_file
)
1620 print_node_brief (streamer_dump_file
, " Streaming SCC of ",
1622 fprintf (streamer_dump_file
, "\n");
1625 /* Start the DFS walk. */
1626 /* Save ob state ... */
1629 DFS (ob
, expr
, ref_p
, this_ref_p
, false);
1630 in_dfs_walk
= false;
1632 /* Finally append a reference to the tree we were writing.
1633 ??? If expr ended up as a singleton we could have
1634 inlined it here and avoid outputting a reference. */
1635 existed_p
= streamer_tree_cache_lookup (ob
->writer_cache
, expr
, &ix
);
1636 gcc_assert (existed_p
);
1637 streamer_write_record_start (ob
, LTO_tree_pickle_reference
);
1638 streamer_write_uhwi (ob
, ix
);
1639 streamer_write_enum (ob
->main_stream
, LTO_tags
, LTO_NUM_TAGS
,
1640 lto_tree_code_to_tag (TREE_CODE (expr
)));
1641 if (streamer_dump_file
)
1643 print_node_brief (streamer_dump_file
, " Finished SCC of ",
1645 fprintf (streamer_dump_file
, "\n\n");
1647 lto_stats
.num_pickle_refs_output
++;
1652 /* Output to OB a list of try/catch handlers starting with FIRST. */
1655 output_eh_try_list (struct output_block
*ob
, eh_catch first
)
1659 for (n
= first
; n
; n
= n
->next_catch
)
1661 streamer_write_record_start (ob
, LTO_eh_catch
);
1662 stream_write_tree (ob
, n
->type_list
, true);
1663 stream_write_tree (ob
, n
->filter_list
, true);
1664 stream_write_tree (ob
, n
->label
, true);
1667 streamer_write_record_start (ob
, LTO_null
);
1671 /* Output EH region R in function FN to OB. CURR_RN is the slot index
1672 that is being emitted in FN->EH->REGION_ARRAY. This is used to
1673 detect EH region sharing. */
1676 output_eh_region (struct output_block
*ob
, eh_region r
)
1682 streamer_write_record_start (ob
, LTO_null
);
1686 if (r
->type
== ERT_CLEANUP
)
1687 tag
= LTO_ert_cleanup
;
1688 else if (r
->type
== ERT_TRY
)
1690 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
1691 tag
= LTO_ert_allowed_exceptions
;
1692 else if (r
->type
== ERT_MUST_NOT_THROW
)
1693 tag
= LTO_ert_must_not_throw
;
1697 streamer_write_record_start (ob
, tag
);
1698 streamer_write_hwi (ob
, r
->index
);
1701 streamer_write_hwi (ob
, r
->outer
->index
);
1703 streamer_write_zero (ob
);
1706 streamer_write_hwi (ob
, r
->inner
->index
);
1708 streamer_write_zero (ob
);
1711 streamer_write_hwi (ob
, r
->next_peer
->index
);
1713 streamer_write_zero (ob
);
1715 if (r
->type
== ERT_TRY
)
1717 output_eh_try_list (ob
, r
->u
.eh_try
.first_catch
);
1719 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
1721 stream_write_tree (ob
, r
->u
.allowed
.type_list
, true);
1722 stream_write_tree (ob
, r
->u
.allowed
.label
, true);
1723 streamer_write_uhwi (ob
, r
->u
.allowed
.filter
);
1725 else if (r
->type
== ERT_MUST_NOT_THROW
)
1727 stream_write_tree (ob
, r
->u
.must_not_throw
.failure_decl
, true);
1728 bitpack_d bp
= bitpack_create (ob
->main_stream
);
1729 stream_output_location (ob
, &bp
, r
->u
.must_not_throw
.failure_loc
);
1730 streamer_write_bitpack (&bp
);
1733 if (r
->landing_pads
)
1734 streamer_write_hwi (ob
, r
->landing_pads
->index
);
1736 streamer_write_zero (ob
);
1740 /* Output landing pad LP to OB. */
1743 output_eh_lp (struct output_block
*ob
, eh_landing_pad lp
)
1747 streamer_write_record_start (ob
, LTO_null
);
1751 streamer_write_record_start (ob
, LTO_eh_landing_pad
);
1752 streamer_write_hwi (ob
, lp
->index
);
1754 streamer_write_hwi (ob
, lp
->next_lp
->index
);
1756 streamer_write_zero (ob
);
1759 streamer_write_hwi (ob
, lp
->region
->index
);
1761 streamer_write_zero (ob
);
1763 stream_write_tree (ob
, lp
->post_landing_pad
, true);
1767 /* Output the existing eh_table to OB. */
1770 output_eh_regions (struct output_block
*ob
, struct function
*fn
)
1772 if (fn
->eh
&& fn
->eh
->region_tree
)
1779 streamer_write_record_start (ob
, LTO_eh_table
);
1781 /* Emit the index of the root of the EH region tree. */
1782 streamer_write_hwi (ob
, fn
->eh
->region_tree
->index
);
1784 /* Emit all the EH regions in the region array. */
1785 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->region_array
));
1786 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->region_array
, i
, eh
)
1787 output_eh_region (ob
, eh
);
1789 /* Emit all landing pads. */
1790 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->lp_array
));
1791 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->lp_array
, i
, lp
)
1792 output_eh_lp (ob
, lp
);
1794 /* Emit all the runtime type data. */
1795 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->ttype_data
));
1796 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->ttype_data
, i
, ttype
)
1797 stream_write_tree (ob
, ttype
, true);
1799 /* Emit the table of action chains. */
1800 if (targetm
.arm_eabi_unwinder
)
1803 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->ehspec_data
.arm_eabi
));
1804 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->ehspec_data
.arm_eabi
, i
, t
)
1805 stream_write_tree (ob
, t
, true);
1810 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->ehspec_data
.other
));
1811 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->ehspec_data
.other
, i
, c
)
1812 streamer_write_char_stream (ob
->main_stream
, c
);
1816 /* The LTO_null either terminates the record or indicates that there
1817 are no eh_records at all. */
1818 streamer_write_record_start (ob
, LTO_null
);
1822 /* Output all of the active ssa names to the ssa_names stream. */
1825 output_ssa_names (struct output_block
*ob
, struct function
*fn
)
1827 unsigned int i
, len
;
1829 len
= vec_safe_length (SSANAMES (fn
));
1830 streamer_write_uhwi (ob
, len
);
1832 for (i
= 1; i
< len
; i
++)
1834 tree ptr
= (*SSANAMES (fn
))[i
];
1836 if (ptr
== NULL_TREE
1837 || SSA_NAME_IN_FREE_LIST (ptr
)
1838 || virtual_operand_p (ptr
)
1839 /* Simply skip unreleased SSA names. */
1840 || (! SSA_NAME_IS_DEFAULT_DEF (ptr
)
1841 && (! SSA_NAME_DEF_STMT (ptr
)
1842 || ! gimple_bb (SSA_NAME_DEF_STMT (ptr
)))))
1845 streamer_write_uhwi (ob
, i
);
1846 streamer_write_char_stream (ob
->main_stream
,
1847 SSA_NAME_IS_DEFAULT_DEF (ptr
));
1848 if (SSA_NAME_VAR (ptr
))
1849 stream_write_tree (ob
, SSA_NAME_VAR (ptr
), true);
1851 /* ??? This drops SSA_NAME_IDENTIFIER on the floor. */
1852 stream_write_tree (ob
, TREE_TYPE (ptr
), true);
1855 streamer_write_zero (ob
);
1860 /* Output the cfg. */
1863 output_cfg (struct output_block
*ob
, struct function
*fn
)
1865 struct lto_output_stream
*tmp_stream
= ob
->main_stream
;
1868 ob
->main_stream
= ob
->cfg_stream
;
1870 streamer_write_enum (ob
->main_stream
, profile_status_d
, PROFILE_LAST
,
1871 profile_status_for_fn (fn
));
1873 /* Output the number of the highest basic block. */
1874 streamer_write_uhwi (ob
, last_basic_block_for_fn (fn
));
1876 FOR_ALL_BB_FN (bb
, fn
)
1881 streamer_write_hwi (ob
, bb
->index
);
1883 /* Output the successors and the edge flags. */
1884 streamer_write_uhwi (ob
, EDGE_COUNT (bb
->succs
));
1885 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1887 streamer_write_uhwi (ob
, e
->dest
->index
);
1888 e
->probability
.stream_out (ob
);
1889 streamer_write_uhwi (ob
, e
->flags
);
1893 streamer_write_hwi (ob
, -1);
1895 bb
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
1898 streamer_write_hwi (ob
, bb
->next_bb
->index
);
1902 streamer_write_hwi (ob
, -1);
1904 /* ??? The cfgloop interface is tied to cfun. */
1905 gcc_assert (cfun
== fn
);
1907 /* Output the number of loops. */
1908 streamer_write_uhwi (ob
, number_of_loops (fn
));
1910 /* Output each loop, skipping the tree root which has number zero. */
1911 for (unsigned i
= 1; i
< number_of_loops (fn
); ++i
)
1913 struct loop
*loop
= get_loop (fn
, i
);
1915 /* Write the index of the loop header. That's enough to rebuild
1916 the loop tree on the reader side. Stream -1 for an unused
1920 streamer_write_hwi (ob
, -1);
1924 streamer_write_hwi (ob
, loop
->header
->index
);
1926 /* Write everything copy_loop_info copies. */
1927 streamer_write_enum (ob
->main_stream
,
1928 loop_estimation
, EST_LAST
, loop
->estimate_state
);
1929 streamer_write_hwi (ob
, loop
->any_upper_bound
);
1930 if (loop
->any_upper_bound
)
1931 streamer_write_widest_int (ob
, loop
->nb_iterations_upper_bound
);
1932 streamer_write_hwi (ob
, loop
->any_likely_upper_bound
);
1933 if (loop
->any_likely_upper_bound
)
1934 streamer_write_widest_int (ob
, loop
->nb_iterations_likely_upper_bound
);
1935 streamer_write_hwi (ob
, loop
->any_estimate
);
1936 if (loop
->any_estimate
)
1937 streamer_write_widest_int (ob
, loop
->nb_iterations_estimate
);
1939 /* Write OMP SIMD related info. */
1940 streamer_write_hwi (ob
, loop
->safelen
);
1941 streamer_write_hwi (ob
, loop
->unroll
);
1942 streamer_write_hwi (ob
, loop
->dont_vectorize
);
1943 streamer_write_hwi (ob
, loop
->force_vectorize
);
1944 stream_write_tree (ob
, loop
->simduid
, true);
1947 ob
->main_stream
= tmp_stream
;
1951 /* Create the header in the file using OB. If the section type is for
1952 a function, set FN to the decl for that function. */
1955 produce_asm (struct output_block
*ob
, tree fn
)
1957 enum lto_section_type section_type
= ob
->section_type
;
1958 struct lto_function_header header
;
1961 if (section_type
== LTO_section_function_body
)
1963 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn
));
1964 section_name
= lto_get_section_name (section_type
, name
, NULL
);
1967 section_name
= lto_get_section_name (section_type
, NULL
, NULL
);
1969 lto_begin_section (section_name
, !flag_wpa
);
1970 free (section_name
);
1972 /* The entire header is stream computed here. */
1973 memset (&header
, 0, sizeof (struct lto_function_header
));
1975 /* Write the header. */
1976 header
.major_version
= LTO_major_version
;
1977 header
.minor_version
= LTO_minor_version
;
1979 if (section_type
== LTO_section_function_body
)
1980 header
.cfg_size
= ob
->cfg_stream
->total_size
;
1981 header
.main_size
= ob
->main_stream
->total_size
;
1982 header
.string_size
= ob
->string_stream
->total_size
;
1983 lto_write_data (&header
, sizeof header
);
1985 /* Put all of the gimple and the string table out the asm file as a
1987 if (section_type
== LTO_section_function_body
)
1988 lto_write_stream (ob
->cfg_stream
);
1989 lto_write_stream (ob
->main_stream
);
1990 lto_write_stream (ob
->string_stream
);
1996 /* Output the base body of struct function FN using output block OB. */
1999 output_struct_function_base (struct output_block
*ob
, struct function
*fn
)
2001 struct bitpack_d bp
;
2005 /* Output the static chain and non-local goto save area. */
2006 stream_write_tree (ob
, fn
->static_chain_decl
, true);
2007 stream_write_tree (ob
, fn
->nonlocal_goto_save_area
, true);
2009 /* Output all the local variables in the function. */
2010 streamer_write_hwi (ob
, vec_safe_length (fn
->local_decls
));
2011 FOR_EACH_VEC_SAFE_ELT (fn
->local_decls
, i
, t
)
2012 stream_write_tree (ob
, t
, true);
2014 /* Output current IL state of the function. */
2015 streamer_write_uhwi (ob
, fn
->curr_properties
);
2017 /* Write all the attributes for FN. */
2018 bp
= bitpack_create (ob
->main_stream
);
2019 bp_pack_value (&bp
, fn
->is_thunk
, 1);
2020 bp_pack_value (&bp
, fn
->has_local_explicit_reg_vars
, 1);
2021 bp_pack_value (&bp
, fn
->returns_pcc_struct
, 1);
2022 bp_pack_value (&bp
, fn
->returns_struct
, 1);
2023 bp_pack_value (&bp
, fn
->can_throw_non_call_exceptions
, 1);
2024 bp_pack_value (&bp
, fn
->can_delete_dead_exceptions
, 1);
2025 bp_pack_value (&bp
, fn
->always_inline_functions_inlined
, 1);
2026 bp_pack_value (&bp
, fn
->after_inlining
, 1);
2027 bp_pack_value (&bp
, fn
->stdarg
, 1);
2028 bp_pack_value (&bp
, fn
->has_nonlocal_label
, 1);
2029 bp_pack_value (&bp
, fn
->has_forced_label_in_static
, 1);
2030 bp_pack_value (&bp
, fn
->calls_alloca
, 1);
2031 bp_pack_value (&bp
, fn
->calls_setjmp
, 1);
2032 bp_pack_value (&bp
, fn
->has_force_vectorize_loops
, 1);
2033 bp_pack_value (&bp
, fn
->has_simduid_loops
, 1);
2034 bp_pack_value (&bp
, fn
->va_list_fpr_size
, 8);
2035 bp_pack_value (&bp
, fn
->va_list_gpr_size
, 8);
2036 bp_pack_value (&bp
, fn
->last_clique
, sizeof (short) * 8);
2038 /* Output the function start and end loci. */
2039 stream_output_location (ob
, &bp
, fn
->function_start_locus
);
2040 stream_output_location (ob
, &bp
, fn
->function_end_locus
);
2042 /* Save the instance discriminator if present. */
2043 int *instance_number_p
= NULL
;
2044 if (decl_to_instance_map
)
2045 instance_number_p
= decl_to_instance_map
->get (fn
->decl
);
2046 bp_pack_value (&bp
, !!instance_number_p
, 1);
2047 if (instance_number_p
)
2048 bp_pack_value (&bp
, *instance_number_p
, sizeof (int) * CHAR_BIT
);
2050 streamer_write_bitpack (&bp
);
2054 /* Collect all leaf BLOCKs beyond ROOT into LEAFS. */
2057 collect_block_tree_leafs (tree root
, vec
<tree
> &leafs
)
2059 for (root
= BLOCK_SUBBLOCKS (root
); root
; root
= BLOCK_CHAIN (root
))
2060 if (! BLOCK_SUBBLOCKS (root
))
2061 leafs
.safe_push (root
);
2063 collect_block_tree_leafs (BLOCK_SUBBLOCKS (root
), leafs
);
2066 /* Output the body of function NODE->DECL. */
2069 output_function (struct cgraph_node
*node
)
2072 struct function
*fn
;
2074 struct output_block
*ob
;
2076 if (streamer_dump_file
)
2077 fprintf (streamer_dump_file
, "\nStreaming body of %s\n",
2080 function
= node
->decl
;
2081 fn
= DECL_STRUCT_FUNCTION (function
);
2082 ob
= create_output_block (LTO_section_function_body
);
2084 clear_line_info (ob
);
2087 gcc_assert (current_function_decl
== NULL_TREE
&& cfun
== NULL
);
2089 /* Set current_function_decl and cfun. */
2092 /* Make string 0 be a NULL string. */
2093 streamer_write_char_stream (ob
->string_stream
, 0);
2095 streamer_write_record_start (ob
, LTO_function
);
2097 /* Output decls for parameters and args. */
2098 stream_write_tree (ob
, DECL_RESULT (function
), true);
2099 streamer_write_chain (ob
, DECL_ARGUMENTS (function
), true);
2101 /* Output debug args if available. */
2102 vec
<tree
, va_gc
> **debugargs
= decl_debug_args_lookup (function
);
2104 streamer_write_uhwi (ob
, 0);
2107 streamer_write_uhwi (ob
, (*debugargs
)->length ());
2108 for (unsigned i
= 0; i
< (*debugargs
)->length (); ++i
)
2109 stream_write_tree (ob
, (**debugargs
)[i
], true);
2112 /* Output DECL_INITIAL for the function, which contains the tree of
2114 stream_write_tree (ob
, DECL_INITIAL (function
), true);
2115 /* As we do not recurse into BLOCK_SUBBLOCKS but only BLOCK_SUPERCONTEXT
2116 collect block tree leafs and stream those. */
2117 auto_vec
<tree
> block_tree_leafs
;
2118 if (DECL_INITIAL (function
))
2119 collect_block_tree_leafs (DECL_INITIAL (function
), block_tree_leafs
);
2120 streamer_write_uhwi (ob
, block_tree_leafs
.length ());
2121 for (unsigned i
= 0; i
< block_tree_leafs
.length (); ++i
)
2122 stream_write_tree (ob
, block_tree_leafs
[i
], true);
2124 /* We also stream abstract functions where we stream only stuff needed for
2126 if (gimple_has_body_p (function
))
2128 /* Fixup loops if required to match discovery done in the reader. */
2129 loop_optimizer_init (AVOID_CFG_MODIFICATIONS
);
2131 streamer_write_uhwi (ob
, 1);
2132 output_struct_function_base (ob
, fn
);
2134 /* Output all the SSA names used in the function. */
2135 output_ssa_names (ob
, fn
);
2137 /* Output any exception handling regions. */
2138 output_eh_regions (ob
, fn
);
2141 /* We will renumber the statements. The code that does this uses
2142 the same ordering that we use for serializing them so we can use
2143 the same code on the other end and not have to write out the
2144 statement numbers. We do not assign UIDs to PHIs here because
2145 virtual PHIs get re-computed on-the-fly which would make numbers
2147 set_gimple_stmt_max_uid (cfun
, 0);
2148 FOR_ALL_BB_FN (bb
, cfun
)
2150 for (gphi_iterator gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
);
2153 gphi
*stmt
= gsi
.phi ();
2155 /* Virtual PHIs are not going to be streamed. */
2156 if (!virtual_operand_p (gimple_phi_result (stmt
)))
2157 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
2159 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);
2162 gimple
*stmt
= gsi_stmt (gsi
);
2163 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
2166 /* To avoid keeping duplicate gimple IDs in the statements, renumber
2167 virtual phis now. */
2168 FOR_ALL_BB_FN (bb
, cfun
)
2170 for (gphi_iterator gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
);
2173 gphi
*stmt
= gsi
.phi ();
2174 if (virtual_operand_p (gimple_phi_result (stmt
)))
2175 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
2179 /* Output the code for the function. */
2180 FOR_ALL_BB_FN (bb
, fn
)
2181 output_bb (ob
, bb
, fn
);
2183 /* The terminator for this function. */
2184 streamer_write_record_start (ob
, LTO_null
);
2186 output_cfg (ob
, fn
);
2188 loop_optimizer_finalize ();
2192 streamer_write_uhwi (ob
, 0);
2194 /* Create a section to hold the pickled output of this function. */
2195 produce_asm (ob
, function
);
2197 destroy_output_block (ob
);
2198 if (streamer_dump_file
)
2199 fprintf (streamer_dump_file
, "Finished streaming %s\n",
2203 /* Output the body of function NODE->DECL. */
2206 output_constructor (struct varpool_node
*node
)
2208 tree var
= node
->decl
;
2209 struct output_block
*ob
;
2211 if (streamer_dump_file
)
2212 fprintf (streamer_dump_file
, "\nStreaming constructor of %s\n",
2215 ob
= create_output_block (LTO_section_function_body
);
2217 clear_line_info (ob
);
2220 /* Make string 0 be a NULL string. */
2221 streamer_write_char_stream (ob
->string_stream
, 0);
2223 /* Output DECL_INITIAL for the function, which contains the tree of
2225 stream_write_tree (ob
, DECL_INITIAL (var
), true);
2227 /* Create a section to hold the pickled output of this function. */
2228 produce_asm (ob
, var
);
2230 destroy_output_block (ob
);
2231 if (streamer_dump_file
)
2232 fprintf (streamer_dump_file
, "Finished streaming %s\n",
2237 /* Emit toplevel asms. */
2240 lto_output_toplevel_asms (void)
2242 struct output_block
*ob
;
2243 struct asm_node
*can
;
2245 struct lto_simple_header_with_strings header
;
2247 if (!symtab
->first_asm_symbol ())
2250 ob
= create_output_block (LTO_section_asm
);
2252 /* Make string 0 be a NULL string. */
2253 streamer_write_char_stream (ob
->string_stream
, 0);
2255 for (can
= symtab
->first_asm_symbol (); can
; can
= can
->next
)
2257 streamer_write_string_cst (ob
, ob
->main_stream
, can
->asm_str
);
2258 streamer_write_hwi (ob
, can
->order
);
2261 streamer_write_string_cst (ob
, ob
->main_stream
, NULL_TREE
);
2263 section_name
= lto_get_section_name (LTO_section_asm
, NULL
, NULL
);
2264 lto_begin_section (section_name
, !flag_wpa
);
2265 free (section_name
);
2267 /* The entire header stream is computed here. */
2268 memset (&header
, 0, sizeof (header
));
2270 /* Write the header. */
2271 header
.major_version
= LTO_major_version
;
2272 header
.minor_version
= LTO_minor_version
;
2274 header
.main_size
= ob
->main_stream
->total_size
;
2275 header
.string_size
= ob
->string_stream
->total_size
;
2276 lto_write_data (&header
, sizeof header
);
2278 /* Put all of the gimple and the string table out the asm file as a
2280 lto_write_stream (ob
->main_stream
);
2281 lto_write_stream (ob
->string_stream
);
2285 destroy_output_block (ob
);
2289 /* Copy the function body or variable constructor of NODE without deserializing. */
2292 copy_function_or_variable (struct symtab_node
*node
)
2294 tree function
= node
->decl
;
2295 struct lto_file_decl_data
*file_data
= node
->lto_file_data
;
2298 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function
));
2299 char *section_name
=
2300 lto_get_section_name (LTO_section_function_body
, name
, NULL
);
2302 struct lto_in_decl_state
*in_state
;
2303 struct lto_out_decl_state
*out_state
= lto_get_out_decl_state ();
2305 if (streamer_dump_file
)
2306 fprintf (streamer_dump_file
, "Copying section for %s\n", name
);
2307 lto_begin_section (section_name
, false);
2308 free (section_name
);
2310 /* We may have renamed the declaration, e.g., a static function. */
2311 name
= lto_get_decl_name_mapping (file_data
, name
);
2313 data
= lto_get_raw_section_data (file_data
, LTO_section_function_body
,
2317 /* Do a bit copy of the function body. */
2318 lto_write_raw_data (data
, len
);
2322 lto_get_function_in_decl_state (node
->lto_file_data
, function
);
2323 out_state
->compressed
= in_state
->compressed
;
2324 gcc_assert (in_state
);
2326 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2328 size_t n
= vec_safe_length (in_state
->streams
[i
]);
2329 vec
<tree
, va_gc
> *trees
= in_state
->streams
[i
];
2330 struct lto_tree_ref_encoder
*encoder
= &(out_state
->streams
[i
]);
2332 /* The out state must have the same indices and the in state.
2333 So just copy the vector. All the encoders in the in state
2334 must be empty where we reach here. */
2335 gcc_assert (lto_tree_ref_encoder_size (encoder
) == 0);
2336 encoder
->trees
.reserve_exact (n
);
2337 for (j
= 0; j
< n
; j
++)
2338 encoder
->trees
.safe_push ((*trees
)[j
]);
2341 lto_free_raw_section_data (file_data
, LTO_section_function_body
, name
,
2346 /* Wrap symbol references in *TP inside a type-preserving MEM_REF. */
2349 wrap_refs (tree
*tp
, int *ws
, void *)
2352 if (handled_component_p (t
)
2353 && TREE_CODE (TREE_OPERAND (t
, 0)) == VAR_DECL
2354 && TREE_PUBLIC (TREE_OPERAND (t
, 0)))
2356 tree decl
= TREE_OPERAND (t
, 0);
2357 tree ptrtype
= build_pointer_type (TREE_TYPE (decl
));
2358 TREE_OPERAND (t
, 0) = build2 (MEM_REF
, TREE_TYPE (decl
),
2359 build1 (ADDR_EXPR
, ptrtype
, decl
),
2360 build_int_cst (ptrtype
, 0));
2361 TREE_THIS_VOLATILE (TREE_OPERAND (t
, 0)) = TREE_THIS_VOLATILE (decl
);
2364 else if (TREE_CODE (t
) == CONSTRUCTOR
)
2366 else if (!EXPR_P (t
))
2371 /* Remove functions that are no longer used from offload_funcs, and mark the
2372 remaining ones with DECL_PRESERVE_P. */
2375 prune_offload_funcs (void)
2382 VEC_ORDERED_REMOVE_IF (*offload_funcs
, ix
, ix2
, elem_ptr
,
2383 cgraph_node::get (*elem_ptr
) == NULL
);
2386 FOR_EACH_VEC_ELT (*offload_funcs
, ix
, fn_decl
)
2387 DECL_PRESERVE_P (fn_decl
) = 1;
2390 /* Main entry point from the pass manager. */
2395 struct lto_out_decl_state
*decl_state
;
2396 bitmap output
= NULL
;
2398 lto_symtab_encoder_t encoder
= lto_get_out_decl_state ()->symtab_node_encoder
;
2400 prune_offload_funcs ();
2403 output
= lto_bitmap_alloc ();
2405 /* Initialize the streamer. */
2406 lto_streamer_init ();
2408 n_nodes
= lto_symtab_encoder_size (encoder
);
2409 /* Process only the functions with bodies. */
2410 for (i
= 0; i
< n_nodes
; i
++)
2412 symtab_node
*snode
= lto_symtab_encoder_deref (encoder
, i
);
2413 if (cgraph_node
*node
= dyn_cast
<cgraph_node
*> (snode
))
2415 if (lto_symtab_encoder_encode_body_p (encoder
, node
)
2417 && (!node
->thunk
.thunk_p
|| !node
->thunk
.add_pointer_bounds_args
))
2421 gcc_assert (!bitmap_bit_p (output
, DECL_UID (node
->decl
)));
2422 bitmap_set_bit (output
, DECL_UID (node
->decl
));
2424 decl_state
= lto_new_out_decl_state ();
2425 lto_push_out_decl_state (decl_state
);
2426 if (gimple_has_body_p (node
->decl
)
2428 && flag_incremental_link
!= INCREMENTAL_LINK_LTO
)
2429 /* Thunks have no body but they may be synthetized
2431 || DECL_ARGUMENTS (node
->decl
))
2432 output_function (node
);
2434 copy_function_or_variable (node
);
2435 gcc_assert (lto_get_out_decl_state () == decl_state
);
2436 lto_pop_out_decl_state ();
2437 lto_record_function_out_decl_state (node
->decl
, decl_state
);
2440 else if (varpool_node
*node
= dyn_cast
<varpool_node
*> (snode
))
2442 /* Wrap symbol references inside the ctor in a type
2443 preserving MEM_REF. */
2444 tree ctor
= DECL_INITIAL (node
->decl
);
2445 if (ctor
&& !in_lto_p
)
2446 walk_tree (&ctor
, wrap_refs
, NULL
, NULL
);
2447 if (get_symbol_initial_value (encoder
, node
->decl
) == error_mark_node
2448 && lto_symtab_encoder_encode_initializer_p (encoder
, node
)
2451 timevar_push (TV_IPA_LTO_CTORS_OUT
);
2454 gcc_assert (!bitmap_bit_p (output
, DECL_UID (node
->decl
)));
2455 bitmap_set_bit (output
, DECL_UID (node
->decl
));
2457 decl_state
= lto_new_out_decl_state ();
2458 lto_push_out_decl_state (decl_state
);
2459 if (DECL_INITIAL (node
->decl
) != error_mark_node
2461 && flag_incremental_link
!= INCREMENTAL_LINK_LTO
))
2462 output_constructor (node
);
2464 copy_function_or_variable (node
);
2465 gcc_assert (lto_get_out_decl_state () == decl_state
);
2466 lto_pop_out_decl_state ();
2467 lto_record_function_out_decl_state (node
->decl
, decl_state
);
2468 timevar_pop (TV_IPA_LTO_CTORS_OUT
);
2473 /* Emit the callgraph after emitting function bodies. This needs to
2474 be done now to make sure that all the statements in every function
2475 have been renumbered so that edges can be associated with call
2476 statements using the statement UIDs. */
2479 output_offload_tables ();
2482 lto_bitmap_free (output
);
2486 /* Write each node in encoded by ENCODER to OB, as well as those reachable
2487 from it and required for correct representation of its semantics.
2488 Each node in ENCODER must be a global declaration or a type. A node
2489 is written only once, even if it appears multiple times in the
2490 vector. Certain transitively-reachable nodes, such as those
2491 representing expressions, may be duplicated, but such nodes
2492 must not appear in ENCODER itself. */
2495 write_global_stream (struct output_block
*ob
,
2496 struct lto_tree_ref_encoder
*encoder
)
2500 const size_t size
= lto_tree_ref_encoder_size (encoder
);
2502 for (index
= 0; index
< size
; index
++)
2504 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2505 if (streamer_dump_file
)
2507 fprintf (streamer_dump_file
, " %i:", (int)index
);
2508 print_node_brief (streamer_dump_file
, "", t
, 4);
2509 fprintf (streamer_dump_file
, "\n");
2511 if (!streamer_tree_cache_lookup (ob
->writer_cache
, t
, NULL
))
2512 stream_write_tree (ob
, t
, false);
2517 /* Write a sequence of indices into the globals vector corresponding
2518 to the trees in ENCODER. These are used by the reader to map the
2519 indices used to refer to global entities within function bodies to
2523 write_global_references (struct output_block
*ob
,
2524 struct lto_tree_ref_encoder
*encoder
)
2528 const uint32_t size
= lto_tree_ref_encoder_size (encoder
);
2530 /* Write size and slot indexes as 32-bit unsigned numbers. */
2531 uint32_t *data
= XNEWVEC (uint32_t, size
+ 1);
2534 for (index
= 0; index
< size
; index
++)
2538 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2539 streamer_tree_cache_lookup (ob
->writer_cache
, t
, &slot_num
);
2540 gcc_assert (slot_num
!= (unsigned)-1);
2541 data
[index
+ 1] = slot_num
;
2544 lto_write_data (data
, sizeof (int32_t) * (size
+ 1));
2549 /* Write all the streams in an lto_out_decl_state STATE using
2550 output block OB and output stream OUT_STREAM. */
2553 lto_output_decl_state_streams (struct output_block
*ob
,
2554 struct lto_out_decl_state
*state
)
2558 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2559 write_global_stream (ob
, &state
->streams
[i
]);
2563 /* Write all the references in an lto_out_decl_state STATE using
2564 output block OB and output stream OUT_STREAM. */
2567 lto_output_decl_state_refs (struct output_block
*ob
,
2568 struct lto_out_decl_state
*state
)
2574 /* Write reference to FUNCTION_DECL. If there is not function,
2575 write reference to void_type_node. */
2576 decl
= (state
->fn_decl
) ? state
->fn_decl
: void_type_node
;
2577 streamer_tree_cache_lookup (ob
->writer_cache
, decl
, &ref
);
2578 gcc_assert (ref
!= (unsigned)-1);
2579 ref
= ref
* 2 + (state
->compressed
? 1 : 0);
2580 lto_write_data (&ref
, sizeof (uint32_t));
2582 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2583 write_global_references (ob
, &state
->streams
[i
]);
2587 /* Return the written size of STATE. */
2590 lto_out_decl_state_written_size (struct lto_out_decl_state
*state
)
2595 size
= sizeof (int32_t); /* fn_ref. */
2596 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2598 size
+= sizeof (int32_t); /* vector size. */
2599 size
+= (lto_tree_ref_encoder_size (&state
->streams
[i
])
2600 * sizeof (int32_t));
2606 /* Write symbol T into STREAM in CACHE. SEEN specifies symbols we wrote
2610 write_symbol (struct streamer_tree_cache_d
*cache
,
2611 tree t
, hash_set
<const char *> *seen
, bool alias
)
2614 enum gcc_plugin_symbol_kind kind
;
2615 enum gcc_plugin_symbol_visibility visibility
= GCCPV_DEFAULT
;
2621 gcc_checking_assert (TREE_PUBLIC (t
)
2622 && (TREE_CODE (t
) != FUNCTION_DECL
2623 || !fndecl_built_in_p (t
))
2624 && !DECL_ABSTRACT_P (t
)
2625 && (!VAR_P (t
) || !DECL_HARD_REGISTER (t
)));
2627 gcc_assert (VAR_OR_FUNCTION_DECL_P (t
));
2629 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t
));
2631 /* This behaves like assemble_name_raw in varasm.c, performing the
2632 same name manipulations that ASM_OUTPUT_LABELREF does. */
2633 name
= IDENTIFIER_POINTER ((*targetm
.asm_out
.mangle_assembler_name
) (name
));
2635 if (seen
->add (name
))
2638 streamer_tree_cache_lookup (cache
, t
, &slot_num
);
2639 gcc_assert (slot_num
!= (unsigned)-1);
2641 if (DECL_EXTERNAL (t
))
2644 kind
= GCCPK_WEAKUNDEF
;
2651 kind
= GCCPK_WEAKDEF
;
2652 else if (DECL_COMMON (t
))
2653 kind
= GCCPK_COMMON
;
2657 /* When something is defined, it should have node attached. */
2658 gcc_assert (alias
|| !VAR_P (t
) || varpool_node::get (t
)->definition
);
2659 gcc_assert (alias
|| TREE_CODE (t
) != FUNCTION_DECL
2660 || (cgraph_node::get (t
)
2661 && cgraph_node::get (t
)->definition
));
2664 /* Imitate what default_elf_asm_output_external do.
2665 When symbol is external, we need to output it with DEFAULT visibility
2666 when compiling with -fvisibility=default, while with HIDDEN visibility
2667 when symbol has attribute (visibility("hidden")) specified.
2668 targetm.binds_local_p check DECL_VISIBILITY_SPECIFIED and gets this
2671 if (DECL_EXTERNAL (t
)
2672 && !targetm
.binds_local_p (t
))
2673 visibility
= GCCPV_DEFAULT
;
2675 switch (DECL_VISIBILITY (t
))
2677 case VISIBILITY_DEFAULT
:
2678 visibility
= GCCPV_DEFAULT
;
2680 case VISIBILITY_PROTECTED
:
2681 visibility
= GCCPV_PROTECTED
;
2683 case VISIBILITY_HIDDEN
:
2684 visibility
= GCCPV_HIDDEN
;
2686 case VISIBILITY_INTERNAL
:
2687 visibility
= GCCPV_INTERNAL
;
2691 if (kind
== GCCPK_COMMON
2692 && DECL_SIZE_UNIT (t
)
2693 && TREE_CODE (DECL_SIZE_UNIT (t
)) == INTEGER_CST
)
2694 size
= TREE_INT_CST_LOW (DECL_SIZE_UNIT (t
));
2698 if (DECL_ONE_ONLY (t
))
2699 comdat
= IDENTIFIER_POINTER (decl_comdat_group_id (t
));
2703 lto_write_data (name
, strlen (name
) + 1);
2704 lto_write_data (comdat
, strlen (comdat
) + 1);
2705 c
= (unsigned char) kind
;
2706 lto_write_data (&c
, 1);
2707 c
= (unsigned char) visibility
;
2708 lto_write_data (&c
, 1);
2709 lto_write_data (&size
, 8);
2710 lto_write_data (&slot_num
, 4);
2713 /* Write an IL symbol table to OB.
2714 SET and VSET are cgraph/varpool node sets we are outputting. */
2717 produce_symtab (struct output_block
*ob
)
2719 struct streamer_tree_cache_d
*cache
= ob
->writer_cache
;
2720 char *section_name
= lto_get_section_name (LTO_section_symtab
, NULL
, NULL
);
2721 lto_symtab_encoder_t encoder
= ob
->decl_state
->symtab_node_encoder
;
2722 lto_symtab_encoder_iterator lsei
;
2724 lto_begin_section (section_name
, false);
2725 free (section_name
);
2727 hash_set
<const char *> seen
;
2729 /* Write the symbol table.
2730 First write everything defined and then all declarations.
2731 This is necessary to handle cases where we have duplicated symbols. */
2732 for (lsei
= lsei_start (encoder
);
2733 !lsei_end_p (lsei
); lsei_next (&lsei
))
2735 symtab_node
*node
= lsei_node (lsei
);
2737 if (DECL_EXTERNAL (node
->decl
) || !node
->output_to_lto_symbol_table_p ())
2739 write_symbol (cache
, node
->decl
, &seen
, false);
2741 for (lsei
= lsei_start (encoder
);
2742 !lsei_end_p (lsei
); lsei_next (&lsei
))
2744 symtab_node
*node
= lsei_node (lsei
);
2746 if (!DECL_EXTERNAL (node
->decl
) || !node
->output_to_lto_symbol_table_p ())
2748 write_symbol (cache
, node
->decl
, &seen
, false);
2755 /* Init the streamer_mode_table for output, where we collect info on what
2756 machine_mode values have been streamed. */
2758 lto_output_init_mode_table (void)
2760 memset (streamer_mode_table
, '\0', MAX_MACHINE_MODE
);
2764 /* Write the mode table. */
2766 lto_write_mode_table (void)
2768 struct output_block
*ob
;
2769 ob
= create_output_block (LTO_section_mode_table
);
2770 bitpack_d bp
= bitpack_create (ob
->main_stream
);
2772 /* Ensure that for GET_MODE_INNER (m) != m we have
2773 also the inner mode marked. */
2774 for (int i
= 0; i
< (int) MAX_MACHINE_MODE
; i
++)
2775 if (streamer_mode_table
[i
])
2777 machine_mode m
= (machine_mode
) i
;
2778 machine_mode inner_m
= GET_MODE_INNER (m
);
2780 streamer_mode_table
[(int) inner_m
] = 1;
2782 /* First stream modes that have GET_MODE_INNER (m) == m,
2783 so that we can refer to them afterwards. */
2784 for (int pass
= 0; pass
< 2; pass
++)
2785 for (int i
= 0; i
< (int) MAX_MACHINE_MODE
; i
++)
2786 if (streamer_mode_table
[i
] && i
!= (int) VOIDmode
&& i
!= (int) BLKmode
)
2788 machine_mode m
= (machine_mode
) i
;
2789 if ((GET_MODE_INNER (m
) == m
) ^ (pass
== 0))
2791 bp_pack_value (&bp
, m
, 8);
2792 bp_pack_enum (&bp
, mode_class
, MAX_MODE_CLASS
, GET_MODE_CLASS (m
));
2793 bp_pack_poly_value (&bp
, GET_MODE_SIZE (m
), 16);
2794 bp_pack_poly_value (&bp
, GET_MODE_PRECISION (m
), 16);
2795 bp_pack_value (&bp
, GET_MODE_INNER (m
), 8);
2796 bp_pack_poly_value (&bp
, GET_MODE_NUNITS (m
), 16);
2797 switch (GET_MODE_CLASS (m
))
2803 bp_pack_value (&bp
, GET_MODE_IBIT (m
), 8);
2804 bp_pack_value (&bp
, GET_MODE_FBIT (m
), 8);
2807 case MODE_DECIMAL_FLOAT
:
2808 bp_pack_string (ob
, &bp
, REAL_MODE_FORMAT (m
)->name
, true);
2813 bp_pack_string (ob
, &bp
, GET_MODE_NAME (m
), true);
2815 bp_pack_value (&bp
, VOIDmode
, 8);
2817 streamer_write_bitpack (&bp
);
2820 = lto_get_section_name (LTO_section_mode_table
, NULL
, NULL
);
2821 lto_begin_section (section_name
, !flag_wpa
);
2822 free (section_name
);
2824 /* The entire header stream is computed here. */
2825 struct lto_simple_header_with_strings header
;
2826 memset (&header
, 0, sizeof (header
));
2828 /* Write the header. */
2829 header
.major_version
= LTO_major_version
;
2830 header
.minor_version
= LTO_minor_version
;
2832 header
.main_size
= ob
->main_stream
->total_size
;
2833 header
.string_size
= ob
->string_stream
->total_size
;
2834 lto_write_data (&header
, sizeof header
);
2836 /* Put all of the gimple and the string table out the asm file as a
2838 lto_write_stream (ob
->main_stream
);
2839 lto_write_stream (ob
->string_stream
);
2842 destroy_output_block (ob
);
2846 /* This pass is run after all of the functions are serialized and all
2847 of the IPA passes have written their serialized forms. This pass
2848 causes the vector of all of the global decls and types used from
2849 this file to be written in to a section that can then be read in to
2850 recover these on other side. */
2853 produce_asm_for_decls (void)
2855 struct lto_out_decl_state
*out_state
;
2856 struct lto_out_decl_state
*fn_out_state
;
2857 struct lto_decl_header header
;
2859 struct output_block
*ob
;
2860 unsigned idx
, num_fns
;
2861 size_t decl_state_size
;
2862 int32_t num_decl_states
;
2864 ob
= create_output_block (LTO_section_decls
);
2866 memset (&header
, 0, sizeof (struct lto_decl_header
));
2868 section_name
= lto_get_section_name (LTO_section_decls
, NULL
, NULL
);
2869 lto_begin_section (section_name
, !flag_wpa
);
2870 free (section_name
);
2872 /* Make string 0 be a NULL string. */
2873 streamer_write_char_stream (ob
->string_stream
, 0);
2875 gcc_assert (!alias_pairs
);
2877 /* Get rid of the global decl state hash tables to save some memory. */
2878 out_state
= lto_get_out_decl_state ();
2879 for (int i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2880 if (out_state
->streams
[i
].tree_hash_table
)
2882 delete out_state
->streams
[i
].tree_hash_table
;
2883 out_state
->streams
[i
].tree_hash_table
= NULL
;
2886 /* Write the global symbols. */
2887 if (streamer_dump_file
)
2888 fprintf (streamer_dump_file
, "Outputting global stream\n");
2889 lto_output_decl_state_streams (ob
, out_state
);
2890 num_fns
= lto_function_decl_states
.length ();
2891 for (idx
= 0; idx
< num_fns
; idx
++)
2894 lto_function_decl_states
[idx
];
2895 if (streamer_dump_file
)
2896 fprintf (streamer_dump_file
, "Outputting stream for %s\n",
2898 (DECL_ASSEMBLER_NAME (fn_out_state
->fn_decl
)));
2899 lto_output_decl_state_streams (ob
, fn_out_state
);
2902 header
.major_version
= LTO_major_version
;
2903 header
.minor_version
= LTO_minor_version
;
2905 /* Currently not used. This field would allow us to preallocate
2906 the globals vector, so that it need not be resized as it is extended. */
2907 header
.num_nodes
= -1;
2909 /* Compute the total size of all decl out states. */
2910 decl_state_size
= sizeof (int32_t);
2911 decl_state_size
+= lto_out_decl_state_written_size (out_state
);
2912 for (idx
= 0; idx
< num_fns
; idx
++)
2915 lto_function_decl_states
[idx
];
2916 decl_state_size
+= lto_out_decl_state_written_size (fn_out_state
);
2918 header
.decl_state_size
= decl_state_size
;
2920 header
.main_size
= ob
->main_stream
->total_size
;
2921 header
.string_size
= ob
->string_stream
->total_size
;
2923 lto_write_data (&header
, sizeof header
);
2925 /* Write the main out-decl state, followed by out-decl states of
2927 num_decl_states
= num_fns
+ 1;
2928 lto_write_data (&num_decl_states
, sizeof (num_decl_states
));
2929 lto_output_decl_state_refs (ob
, out_state
);
2930 for (idx
= 0; idx
< num_fns
; idx
++)
2932 fn_out_state
= lto_function_decl_states
[idx
];
2933 lto_output_decl_state_refs (ob
, fn_out_state
);
2936 lto_write_stream (ob
->main_stream
);
2937 lto_write_stream (ob
->string_stream
);
2941 /* Write the symbol table. It is used by linker to determine dependencies
2942 and thus we can skip it for WPA. */
2944 produce_symtab (ob
);
2946 /* Write command line opts. */
2947 lto_write_options ();
2949 /* Deallocate memory and clean up. */
2950 for (idx
= 0; idx
< num_fns
; idx
++)
2953 lto_function_decl_states
[idx
];
2954 lto_delete_out_decl_state (fn_out_state
);
2956 lto_symtab_encoder_delete (ob
->decl_state
->symtab_node_encoder
);
2957 lto_function_decl_states
.release ();
2958 destroy_output_block (ob
);
2959 if (lto_stream_offload_p
)
2960 lto_write_mode_table ();