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 DFS_follow_tree_edge (DECL_FCONTEXT (expr
));
838 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
840 DFS_follow_tree_edge (DECL_VINDEX (expr
));
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 DFS_follow_tree_edge (TYPE_STUB_DECL (expr
));
863 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
865 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
866 DFS_follow_tree_edge (TYPE_VALUES (expr
));
867 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
868 DFS_follow_tree_edge (TYPE_DOMAIN (expr
));
869 else if (RECORD_OR_UNION_TYPE_P (expr
))
870 for (tree t
= TYPE_FIELDS (expr
); t
; t
= TREE_CHAIN (t
))
871 DFS_follow_tree_edge (t
);
872 else if (TREE_CODE (expr
) == FUNCTION_TYPE
873 || TREE_CODE (expr
) == METHOD_TYPE
)
874 DFS_follow_tree_edge (TYPE_ARG_TYPES (expr
));
876 if (!POINTER_TYPE_P (expr
))
877 DFS_follow_tree_edge (TYPE_MIN_VALUE_RAW (expr
));
878 DFS_follow_tree_edge (TYPE_MAX_VALUE_RAW (expr
));
881 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
883 DFS_follow_tree_edge (TREE_PURPOSE (expr
));
884 DFS_follow_tree_edge (TREE_VALUE (expr
));
885 DFS_follow_tree_edge (TREE_CHAIN (expr
));
888 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
890 for (int i
= 0; i
< TREE_VEC_LENGTH (expr
); i
++)
891 DFS_follow_tree_edge (TREE_VEC_ELT (expr
, i
));
894 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
896 for (int i
= 0; i
< TREE_OPERAND_LENGTH (expr
); i
++)
897 DFS_follow_tree_edge (TREE_OPERAND (expr
, i
));
898 DFS_follow_tree_edge (TREE_BLOCK (expr
));
901 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
903 for (tree t
= BLOCK_VARS (expr
); t
; t
= TREE_CHAIN (t
))
905 /* We would have to stream externals in the block chain as
906 non-references but we should have dropped them in
908 gcc_assert (!VAR_OR_FUNCTION_DECL_P (t
) || !DECL_EXTERNAL (t
));
909 DFS_follow_tree_edge (t
);
912 DFS_follow_tree_edge (BLOCK_SUPERCONTEXT (expr
));
913 DFS_follow_tree_edge (BLOCK_ABSTRACT_ORIGIN (expr
));
915 /* Do not follow BLOCK_NONLOCALIZED_VARS. We cannot handle debug
916 information for early inlined BLOCKs so drop it on the floor instead
917 of ICEing in dwarf2out.c. */
919 /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
922 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
923 list is re-constructed from BLOCK_SUPERCONTEXT. */
926 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
931 /* Note that the number of BINFO slots has already been emitted in
932 EXPR's header (see streamer_write_tree_header) because this length
933 is needed to build the empty BINFO node on the reader side. */
934 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr
), i
, t
)
935 DFS_follow_tree_edge (t
);
936 DFS_follow_tree_edge (BINFO_OFFSET (expr
));
937 DFS_follow_tree_edge (BINFO_VTABLE (expr
));
939 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX,
940 BINFO_BASE_ACCESSES and BINFO_VPTR_INDEX; these are used
944 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
949 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr
), i
, index
, value
)
951 DFS_follow_tree_edge (index
);
952 DFS_follow_tree_edge (value
);
956 if (code
== OMP_CLAUSE
)
959 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (expr
)]; i
++)
960 DFS_follow_tree_edge (OMP_CLAUSE_OPERAND (expr
, i
));
961 DFS_follow_tree_edge (OMP_CLAUSE_CHAIN (expr
));
964 #undef DFS_follow_tree_edge
967 /* Return a hash value for the tree T.
968 CACHE holds hash values of trees outside current SCC. MAP, if non-NULL,
969 may hold hash values if trees inside current SCC. */
972 hash_tree (struct streamer_tree_cache_d
*cache
, hash_map
<tree
, hashval_t
> *map
, tree t
)
974 inchash::hash hstate
;
976 #define visit(SIBLING) \
980 hstate.add_int (0); \
981 else if (streamer_tree_cache_lookup (cache, SIBLING, &ix)) \
982 hstate.add_int (streamer_tree_cache_get_hash (cache, ix)); \
984 hstate.add_int (*map->get (SIBLING)); \
986 hstate.add_int (1); \
990 enum tree_code code
= TREE_CODE (t
);
991 hstate
.add_int (code
);
994 hstate
.add_flag (TREE_SIDE_EFFECTS (t
));
995 hstate
.add_flag (TREE_CONSTANT (t
));
996 hstate
.add_flag (TREE_READONLY (t
));
997 hstate
.add_flag (TREE_PUBLIC (t
));
999 hstate
.add_flag (TREE_ADDRESSABLE (t
));
1000 hstate
.add_flag (TREE_THIS_VOLATILE (t
));
1002 hstate
.add_flag (DECL_UNSIGNED (t
));
1003 else if (TYPE_P (t
))
1004 hstate
.add_flag (TYPE_UNSIGNED (t
));
1006 hstate
.add_flag (TYPE_ARTIFICIAL (t
));
1008 hstate
.add_flag (TREE_NO_WARNING (t
));
1009 hstate
.add_flag (TREE_NOTHROW (t
));
1010 hstate
.add_flag (TREE_STATIC (t
));
1011 hstate
.add_flag (TREE_PROTECTED (t
));
1012 hstate
.add_flag (TREE_DEPRECATED (t
));
1013 if (code
!= TREE_BINFO
)
1014 hstate
.add_flag (TREE_PRIVATE (t
));
1017 hstate
.add_flag (AGGREGATE_TYPE_P (t
)
1018 ? TYPE_REVERSE_STORAGE_ORDER (t
) : TYPE_SATURATING (t
));
1019 hstate
.add_flag (TYPE_ADDR_SPACE (t
));
1021 else if (code
== SSA_NAME
)
1022 hstate
.add_flag (SSA_NAME_IS_DEFAULT_DEF (t
));
1023 hstate
.commit_flag ();
1025 if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
1026 hstate
.add_wide_int (wi::to_widest (t
));
1028 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
1030 REAL_VALUE_TYPE r
= TREE_REAL_CST (t
);
1031 hstate
.add_flag (r
.cl
);
1032 hstate
.add_flag (r
.sign
);
1033 hstate
.add_flag (r
.signalling
);
1034 hstate
.add_flag (r
.canonical
);
1035 hstate
.commit_flag ();
1036 hstate
.add_int (r
.uexp
);
1037 hstate
.add (r
.sig
, sizeof (r
.sig
));
1040 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
1042 FIXED_VALUE_TYPE f
= TREE_FIXED_CST (t
);
1043 hstate
.add_int (f
.mode
);
1044 hstate
.add_int (f
.data
.low
);
1045 hstate
.add_int (f
.data
.high
);
1048 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1050 hstate
.add_hwi (DECL_MODE (t
));
1051 hstate
.add_flag (DECL_NONLOCAL (t
));
1052 hstate
.add_flag (DECL_VIRTUAL_P (t
));
1053 hstate
.add_flag (DECL_IGNORED_P (t
));
1054 hstate
.add_flag (DECL_ABSTRACT_P (t
));
1055 hstate
.add_flag (DECL_ARTIFICIAL (t
));
1056 hstate
.add_flag (DECL_USER_ALIGN (t
));
1057 hstate
.add_flag (DECL_PRESERVE_P (t
));
1058 hstate
.add_flag (DECL_EXTERNAL (t
));
1059 hstate
.add_flag (DECL_GIMPLE_REG_P (t
));
1060 hstate
.commit_flag ();
1061 hstate
.add_int (DECL_ALIGN (t
));
1062 if (code
== LABEL_DECL
)
1064 hstate
.add_int (EH_LANDING_PAD_NR (t
));
1065 hstate
.add_int (LABEL_DECL_UID (t
));
1067 else if (code
== FIELD_DECL
)
1069 hstate
.add_flag (DECL_PACKED (t
));
1070 hstate
.add_flag (DECL_NONADDRESSABLE_P (t
));
1071 hstate
.add_flag (DECL_PADDING_P (t
));
1072 hstate
.add_int (DECL_OFFSET_ALIGN (t
));
1074 else if (code
== VAR_DECL
)
1076 hstate
.add_flag (DECL_HAS_DEBUG_EXPR_P (t
));
1077 hstate
.add_flag (DECL_NONLOCAL_FRAME (t
));
1079 if (code
== RESULT_DECL
1080 || code
== PARM_DECL
1081 || code
== VAR_DECL
)
1083 hstate
.add_flag (DECL_BY_REFERENCE (t
));
1084 if (code
== VAR_DECL
1085 || code
== PARM_DECL
)
1086 hstate
.add_flag (DECL_HAS_VALUE_EXPR_P (t
));
1088 hstate
.commit_flag ();
1091 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
1092 hstate
.add_int (DECL_REGISTER (t
));
1094 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1096 hstate
.add_flag (DECL_COMMON (t
));
1097 hstate
.add_flag (DECL_DLLIMPORT_P (t
));
1098 hstate
.add_flag (DECL_WEAK (t
));
1099 hstate
.add_flag (DECL_SEEN_IN_BIND_EXPR_P (t
));
1100 hstate
.add_flag (DECL_COMDAT (t
));
1101 hstate
.add_flag (DECL_VISIBILITY_SPECIFIED (t
));
1102 hstate
.add_int (DECL_VISIBILITY (t
));
1103 if (code
== VAR_DECL
)
1105 /* DECL_IN_TEXT_SECTION is set during final asm output only. */
1106 hstate
.add_flag (DECL_HARD_REGISTER (t
));
1107 hstate
.add_flag (DECL_IN_CONSTANT_POOL (t
));
1109 if (TREE_CODE (t
) == FUNCTION_DECL
)
1111 hstate
.add_flag (DECL_FINAL_P (t
));
1112 hstate
.add_flag (DECL_CXX_CONSTRUCTOR_P (t
));
1113 hstate
.add_flag (DECL_CXX_DESTRUCTOR_P (t
));
1115 hstate
.commit_flag ();
1118 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1120 hstate
.add_int (DECL_BUILT_IN_CLASS (t
));
1121 hstate
.add_flag (DECL_STATIC_CONSTRUCTOR (t
));
1122 hstate
.add_flag (DECL_STATIC_DESTRUCTOR (t
));
1123 hstate
.add_flag (DECL_UNINLINABLE (t
));
1124 hstate
.add_flag (DECL_POSSIBLY_INLINED (t
));
1125 hstate
.add_flag (DECL_IS_NOVOPS (t
));
1126 hstate
.add_flag (DECL_IS_RETURNS_TWICE (t
));
1127 hstate
.add_flag (DECL_IS_MALLOC (t
));
1128 hstate
.add_flag (DECL_IS_OPERATOR_NEW (t
));
1129 hstate
.add_flag (DECL_DECLARED_INLINE_P (t
));
1130 hstate
.add_flag (DECL_STATIC_CHAIN (t
));
1131 hstate
.add_flag (DECL_NO_INLINE_WARNING_P (t
));
1132 hstate
.add_flag (DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (t
));
1133 hstate
.add_flag (DECL_NO_LIMIT_STACK (t
));
1134 hstate
.add_flag (DECL_DISREGARD_INLINE_LIMITS (t
));
1135 hstate
.add_flag (DECL_PURE_P (t
));
1136 hstate
.add_flag (DECL_LOOPING_CONST_OR_PURE_P (t
));
1137 hstate
.commit_flag ();
1138 if (DECL_BUILT_IN_CLASS (t
) != NOT_BUILT_IN
)
1139 hstate
.add_int (DECL_FUNCTION_CODE (t
));
1142 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
1144 hstate
.add_hwi (TYPE_MODE (t
));
1145 hstate
.add_flag (TYPE_STRING_FLAG (t
));
1146 /* TYPE_NO_FORCE_BLK is private to stor-layout and need
1148 hstate
.add_flag (TYPE_NEEDS_CONSTRUCTING (t
));
1149 hstate
.add_flag (TYPE_PACKED (t
));
1150 hstate
.add_flag (TYPE_RESTRICT (t
));
1151 hstate
.add_flag (TYPE_USER_ALIGN (t
));
1152 hstate
.add_flag (TYPE_READONLY (t
));
1153 if (RECORD_OR_UNION_TYPE_P (t
))
1155 hstate
.add_flag (TYPE_TRANSPARENT_AGGR (t
));
1156 hstate
.add_flag (TYPE_FINAL_P (t
));
1158 else if (code
== ARRAY_TYPE
)
1159 hstate
.add_flag (TYPE_NONALIASED_COMPONENT (t
));
1160 if (AGGREGATE_TYPE_P (t
))
1161 hstate
.add_flag (TYPE_TYPELESS_STORAGE (t
));
1162 hstate
.commit_flag ();
1163 hstate
.add_int (TYPE_PRECISION (t
));
1164 hstate
.add_int (TYPE_ALIGN (t
));
1165 hstate
.add_int (TYPE_EMPTY_P (t
));
1168 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
1169 hstate
.add (TRANSLATION_UNIT_LANGUAGE (t
),
1170 strlen (TRANSLATION_UNIT_LANGUAGE (t
)));
1172 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
)
1173 /* We don't stream these when passing things to a different target. */
1174 && !lto_stream_offload_p
)
1175 hstate
.add_hwi (cl_target_option_hash (TREE_TARGET_OPTION (t
)));
1177 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
1178 hstate
.add_hwi (cl_optimization_hash (TREE_OPTIMIZATION (t
)));
1180 if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
1181 hstate
.merge_hash (IDENTIFIER_HASH_VALUE (t
));
1183 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
1184 hstate
.add (TREE_STRING_POINTER (t
), TREE_STRING_LENGTH (t
));
1186 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
1188 if (code
!= IDENTIFIER_NODE
)
1189 visit (TREE_TYPE (t
));
1192 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
1194 unsigned int count
= vector_cst_encoded_nelts (t
);
1195 for (unsigned int i
= 0; i
< count
; ++i
)
1196 visit (VECTOR_CST_ENCODED_ELT (t
, i
));
1199 if (CODE_CONTAINS_STRUCT (code
, TS_POLY_INT_CST
))
1200 for (unsigned int i
= 0; i
< NUM_POLY_INT_COEFFS
; ++i
)
1201 visit (POLY_INT_CST_COEFF (t
, i
));
1203 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
1205 visit (TREE_REALPART (t
));
1206 visit (TREE_IMAGPART (t
));
1209 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
1211 /* Drop names that were created for anonymous entities. */
1213 && TREE_CODE (DECL_NAME (t
)) == IDENTIFIER_NODE
1214 && anon_aggrname_p (DECL_NAME (t
)))
1217 visit (DECL_NAME (t
));
1218 if (DECL_FILE_SCOPE_P (t
))
1221 visit (DECL_CONTEXT (t
));
1224 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1226 visit (DECL_SIZE (t
));
1227 visit (DECL_SIZE_UNIT (t
));
1228 visit (DECL_ATTRIBUTES (t
));
1229 if ((code
== VAR_DECL
1230 || code
== PARM_DECL
)
1231 && DECL_HAS_VALUE_EXPR_P (t
))
1232 visit (DECL_VALUE_EXPR (t
));
1233 if (code
== VAR_DECL
1234 && DECL_HAS_DEBUG_EXPR_P (t
))
1235 visit (DECL_DEBUG_EXPR (t
));
1236 /* ??? Hash DECL_INITIAL as streamed. Needs the output-block to
1237 be able to call get_symbol_initial_value. */
1240 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1242 if (DECL_ASSEMBLER_NAME_SET_P (t
))
1243 visit (DECL_ASSEMBLER_NAME (t
));
1246 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
1248 visit (DECL_FIELD_OFFSET (t
));
1249 visit (DECL_BIT_FIELD_TYPE (t
));
1250 visit (DECL_BIT_FIELD_REPRESENTATIVE (t
));
1251 visit (DECL_FIELD_BIT_OFFSET (t
));
1252 visit (DECL_FCONTEXT (t
));
1255 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1257 visit (DECL_VINDEX (t
));
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
));
1274 visit (TYPE_STUB_DECL (t
));
1277 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
1279 if (code
== ENUMERAL_TYPE
)
1280 visit (TYPE_VALUES (t
));
1281 else if (code
== ARRAY_TYPE
)
1282 visit (TYPE_DOMAIN (t
));
1283 else if (RECORD_OR_UNION_TYPE_P (t
))
1284 for (tree f
= TYPE_FIELDS (t
); f
; f
= TREE_CHAIN (f
))
1286 else if (code
== FUNCTION_TYPE
1287 || code
== METHOD_TYPE
)
1288 visit (TYPE_ARG_TYPES (t
));
1289 if (!POINTER_TYPE_P (t
))
1290 visit (TYPE_MIN_VALUE_RAW (t
));
1291 visit (TYPE_MAX_VALUE_RAW (t
));
1294 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
1296 visit (TREE_PURPOSE (t
));
1297 visit (TREE_VALUE (t
));
1298 visit (TREE_CHAIN (t
));
1301 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1302 for (int i
= 0; i
< TREE_VEC_LENGTH (t
); ++i
)
1303 visit (TREE_VEC_ELT (t
, i
));
1305 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
1307 hstate
.add_hwi (TREE_OPERAND_LENGTH (t
));
1308 for (int i
= 0; i
< TREE_OPERAND_LENGTH (t
); ++i
)
1309 visit (TREE_OPERAND (t
, i
));
1312 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1316 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (t
), i
, b
)
1318 visit (BINFO_OFFSET (t
));
1319 visit (BINFO_VTABLE (t
));
1320 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
1321 BINFO_BASE_ACCESSES and BINFO_VPTR_INDEX; these are used
1325 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1329 hstate
.add_hwi (CONSTRUCTOR_NELTS (t
));
1330 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), i
, index
, value
)
1337 if (code
== OMP_CLAUSE
)
1342 hstate
.add_hwi (OMP_CLAUSE_CODE (t
));
1343 switch (OMP_CLAUSE_CODE (t
))
1345 case OMP_CLAUSE_DEFAULT
:
1346 val
= OMP_CLAUSE_DEFAULT_KIND (t
);
1348 case OMP_CLAUSE_SCHEDULE
:
1349 val
= OMP_CLAUSE_SCHEDULE_KIND (t
);
1351 case OMP_CLAUSE_DEPEND
:
1352 val
= OMP_CLAUSE_DEPEND_KIND (t
);
1354 case OMP_CLAUSE_MAP
:
1355 val
= OMP_CLAUSE_MAP_KIND (t
);
1357 case OMP_CLAUSE_PROC_BIND
:
1358 val
= OMP_CLAUSE_PROC_BIND_KIND (t
);
1360 case OMP_CLAUSE_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 streamer_write_bitpack (&bp
);
2046 /* Collect all leaf BLOCKs beyond ROOT into LEAFS. */
2049 collect_block_tree_leafs (tree root
, vec
<tree
> &leafs
)
2051 for (root
= BLOCK_SUBBLOCKS (root
); root
; root
= BLOCK_CHAIN (root
))
2052 if (! BLOCK_SUBBLOCKS (root
))
2053 leafs
.safe_push (root
);
2055 collect_block_tree_leafs (BLOCK_SUBBLOCKS (root
), leafs
);
2058 /* Output the body of function NODE->DECL. */
2061 output_function (struct cgraph_node
*node
)
2064 struct function
*fn
;
2066 struct output_block
*ob
;
2068 if (streamer_dump_file
)
2069 fprintf (streamer_dump_file
, "\nStreaming body of %s\n",
2072 function
= node
->decl
;
2073 fn
= DECL_STRUCT_FUNCTION (function
);
2074 ob
= create_output_block (LTO_section_function_body
);
2076 clear_line_info (ob
);
2079 gcc_assert (current_function_decl
== NULL_TREE
&& cfun
== NULL
);
2081 /* Set current_function_decl and cfun. */
2084 /* Make string 0 be a NULL string. */
2085 streamer_write_char_stream (ob
->string_stream
, 0);
2087 streamer_write_record_start (ob
, LTO_function
);
2089 /* Output decls for parameters and args. */
2090 stream_write_tree (ob
, DECL_RESULT (function
), true);
2091 streamer_write_chain (ob
, DECL_ARGUMENTS (function
), true);
2093 /* Output debug args if available. */
2094 vec
<tree
, va_gc
> **debugargs
= decl_debug_args_lookup (function
);
2096 streamer_write_uhwi (ob
, 0);
2099 streamer_write_uhwi (ob
, (*debugargs
)->length ());
2100 for (unsigned i
= 0; i
< (*debugargs
)->length (); ++i
)
2101 stream_write_tree (ob
, (**debugargs
)[i
], true);
2104 /* Output DECL_INITIAL for the function, which contains the tree of
2106 stream_write_tree (ob
, DECL_INITIAL (function
), true);
2107 /* As we do not recurse into BLOCK_SUBBLOCKS but only BLOCK_SUPERCONTEXT
2108 collect block tree leafs and stream those. */
2109 auto_vec
<tree
> block_tree_leafs
;
2110 if (DECL_INITIAL (function
))
2111 collect_block_tree_leafs (DECL_INITIAL (function
), block_tree_leafs
);
2112 streamer_write_uhwi (ob
, block_tree_leafs
.length ());
2113 for (unsigned i
= 0; i
< block_tree_leafs
.length (); ++i
)
2114 stream_write_tree (ob
, block_tree_leafs
[i
], true);
2116 /* We also stream abstract functions where we stream only stuff needed for
2118 if (gimple_has_body_p (function
))
2120 /* Fixup loops if required to match discovery done in the reader. */
2121 loop_optimizer_init (AVOID_CFG_MODIFICATIONS
);
2123 streamer_write_uhwi (ob
, 1);
2124 output_struct_function_base (ob
, fn
);
2126 /* Output all the SSA names used in the function. */
2127 output_ssa_names (ob
, fn
);
2129 /* Output any exception handling regions. */
2130 output_eh_regions (ob
, fn
);
2133 /* We will renumber the statements. The code that does this uses
2134 the same ordering that we use for serializing them so we can use
2135 the same code on the other end and not have to write out the
2136 statement numbers. We do not assign UIDs to PHIs here because
2137 virtual PHIs get re-computed on-the-fly which would make numbers
2139 set_gimple_stmt_max_uid (cfun
, 0);
2140 FOR_ALL_BB_FN (bb
, cfun
)
2142 for (gphi_iterator gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
);
2145 gphi
*stmt
= gsi
.phi ();
2147 /* Virtual PHIs are not going to be streamed. */
2148 if (!virtual_operand_p (gimple_phi_result (stmt
)))
2149 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
2151 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);
2154 gimple
*stmt
= gsi_stmt (gsi
);
2155 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
2158 /* To avoid keeping duplicate gimple IDs in the statements, renumber
2159 virtual phis now. */
2160 FOR_ALL_BB_FN (bb
, cfun
)
2162 for (gphi_iterator gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
);
2165 gphi
*stmt
= gsi
.phi ();
2166 if (virtual_operand_p (gimple_phi_result (stmt
)))
2167 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
2171 /* Output the code for the function. */
2172 FOR_ALL_BB_FN (bb
, fn
)
2173 output_bb (ob
, bb
, fn
);
2175 /* The terminator for this function. */
2176 streamer_write_record_start (ob
, LTO_null
);
2178 output_cfg (ob
, fn
);
2180 loop_optimizer_finalize ();
2184 streamer_write_uhwi (ob
, 0);
2186 /* Create a section to hold the pickled output of this function. */
2187 produce_asm (ob
, function
);
2189 destroy_output_block (ob
);
2190 if (streamer_dump_file
)
2191 fprintf (streamer_dump_file
, "Finished streaming %s\n",
2195 /* Output the body of function NODE->DECL. */
2198 output_constructor (struct varpool_node
*node
)
2200 tree var
= node
->decl
;
2201 struct output_block
*ob
;
2203 if (streamer_dump_file
)
2204 fprintf (streamer_dump_file
, "\nStreaming constructor of %s\n",
2207 ob
= create_output_block (LTO_section_function_body
);
2209 clear_line_info (ob
);
2212 /* Make string 0 be a NULL string. */
2213 streamer_write_char_stream (ob
->string_stream
, 0);
2215 /* Output DECL_INITIAL for the function, which contains the tree of
2217 stream_write_tree (ob
, DECL_INITIAL (var
), true);
2219 /* Create a section to hold the pickled output of this function. */
2220 produce_asm (ob
, var
);
2222 destroy_output_block (ob
);
2223 if (streamer_dump_file
)
2224 fprintf (streamer_dump_file
, "Finished streaming %s\n",
2229 /* Emit toplevel asms. */
2232 lto_output_toplevel_asms (void)
2234 struct output_block
*ob
;
2235 struct asm_node
*can
;
2237 struct lto_simple_header_with_strings header
;
2239 if (!symtab
->first_asm_symbol ())
2242 ob
= create_output_block (LTO_section_asm
);
2244 /* Make string 0 be a NULL string. */
2245 streamer_write_char_stream (ob
->string_stream
, 0);
2247 for (can
= symtab
->first_asm_symbol (); can
; can
= can
->next
)
2249 streamer_write_string_cst (ob
, ob
->main_stream
, can
->asm_str
);
2250 streamer_write_hwi (ob
, can
->order
);
2253 streamer_write_string_cst (ob
, ob
->main_stream
, NULL_TREE
);
2255 section_name
= lto_get_section_name (LTO_section_asm
, NULL
, NULL
);
2256 lto_begin_section (section_name
, !flag_wpa
);
2257 free (section_name
);
2259 /* The entire header stream is computed here. */
2260 memset (&header
, 0, sizeof (header
));
2262 /* Write the header. */
2263 header
.major_version
= LTO_major_version
;
2264 header
.minor_version
= LTO_minor_version
;
2266 header
.main_size
= ob
->main_stream
->total_size
;
2267 header
.string_size
= ob
->string_stream
->total_size
;
2268 lto_write_data (&header
, sizeof header
);
2270 /* Put all of the gimple and the string table out the asm file as a
2272 lto_write_stream (ob
->main_stream
);
2273 lto_write_stream (ob
->string_stream
);
2277 destroy_output_block (ob
);
2281 /* Copy the function body or variable constructor of NODE without deserializing. */
2284 copy_function_or_variable (struct symtab_node
*node
)
2286 tree function
= node
->decl
;
2287 struct lto_file_decl_data
*file_data
= node
->lto_file_data
;
2290 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function
));
2291 char *section_name
=
2292 lto_get_section_name (LTO_section_function_body
, name
, NULL
);
2294 struct lto_in_decl_state
*in_state
;
2295 struct lto_out_decl_state
*out_state
= lto_get_out_decl_state ();
2297 lto_begin_section (section_name
, false);
2298 free (section_name
);
2300 /* We may have renamed the declaration, e.g., a static function. */
2301 name
= lto_get_decl_name_mapping (file_data
, name
);
2303 data
= lto_get_raw_section_data (file_data
, LTO_section_function_body
,
2307 /* Do a bit copy of the function body. */
2308 lto_write_raw_data (data
, len
);
2312 lto_get_function_in_decl_state (node
->lto_file_data
, function
);
2313 out_state
->compressed
= in_state
->compressed
;
2314 gcc_assert (in_state
);
2316 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2318 size_t n
= vec_safe_length (in_state
->streams
[i
]);
2319 vec
<tree
, va_gc
> *trees
= in_state
->streams
[i
];
2320 struct lto_tree_ref_encoder
*encoder
= &(out_state
->streams
[i
]);
2322 /* The out state must have the same indices and the in state.
2323 So just copy the vector. All the encoders in the in state
2324 must be empty where we reach here. */
2325 gcc_assert (lto_tree_ref_encoder_size (encoder
) == 0);
2326 encoder
->trees
.reserve_exact (n
);
2327 for (j
= 0; j
< n
; j
++)
2328 encoder
->trees
.safe_push ((*trees
)[j
]);
2331 lto_free_raw_section_data (file_data
, LTO_section_function_body
, name
,
2336 /* Wrap symbol references in *TP inside a type-preserving MEM_REF. */
2339 wrap_refs (tree
*tp
, int *ws
, void *)
2342 if (handled_component_p (t
)
2343 && TREE_CODE (TREE_OPERAND (t
, 0)) == VAR_DECL
2344 && TREE_PUBLIC (TREE_OPERAND (t
, 0)))
2346 tree decl
= TREE_OPERAND (t
, 0);
2347 tree ptrtype
= build_pointer_type (TREE_TYPE (decl
));
2348 TREE_OPERAND (t
, 0) = build2 (MEM_REF
, TREE_TYPE (decl
),
2349 build1 (ADDR_EXPR
, ptrtype
, decl
),
2350 build_int_cst (ptrtype
, 0));
2351 TREE_THIS_VOLATILE (TREE_OPERAND (t
, 0)) = TREE_THIS_VOLATILE (decl
);
2354 else if (TREE_CODE (t
) == CONSTRUCTOR
)
2356 else if (!EXPR_P (t
))
2361 /* Remove functions that are no longer used from offload_funcs, and mark the
2362 remaining ones with DECL_PRESERVE_P. */
2365 prune_offload_funcs (void)
2372 VEC_ORDERED_REMOVE_IF (*offload_funcs
, ix
, ix2
, elem_ptr
,
2373 cgraph_node::get (*elem_ptr
) == NULL
);
2376 FOR_EACH_VEC_ELT (*offload_funcs
, ix
, fn_decl
)
2377 DECL_PRESERVE_P (fn_decl
) = 1;
2380 /* Main entry point from the pass manager. */
2385 struct lto_out_decl_state
*decl_state
;
2386 bitmap output
= NULL
;
2388 lto_symtab_encoder_t encoder
= lto_get_out_decl_state ()->symtab_node_encoder
;
2390 prune_offload_funcs ();
2393 output
= lto_bitmap_alloc ();
2395 /* Initialize the streamer. */
2396 lto_streamer_init ();
2398 n_nodes
= lto_symtab_encoder_size (encoder
);
2399 /* Process only the functions with bodies. */
2400 for (i
= 0; i
< n_nodes
; i
++)
2402 symtab_node
*snode
= lto_symtab_encoder_deref (encoder
, i
);
2403 if (cgraph_node
*node
= dyn_cast
<cgraph_node
*> (snode
))
2405 if (lto_symtab_encoder_encode_body_p (encoder
, node
)
2407 && (!node
->thunk
.thunk_p
|| !node
->thunk
.add_pointer_bounds_args
))
2411 gcc_assert (!bitmap_bit_p (output
, DECL_UID (node
->decl
)));
2412 bitmap_set_bit (output
, DECL_UID (node
->decl
));
2414 decl_state
= lto_new_out_decl_state ();
2415 lto_push_out_decl_state (decl_state
);
2416 if (gimple_has_body_p (node
->decl
)
2418 && flag_incremental_link
!= INCREMENTAL_LINK_LTO
)
2419 /* Thunks have no body but they may be synthetized
2421 || DECL_ARGUMENTS (node
->decl
))
2422 output_function (node
);
2424 copy_function_or_variable (node
);
2425 gcc_assert (lto_get_out_decl_state () == decl_state
);
2426 lto_pop_out_decl_state ();
2427 lto_record_function_out_decl_state (node
->decl
, decl_state
);
2430 else if (varpool_node
*node
= dyn_cast
<varpool_node
*> (snode
))
2432 /* Wrap symbol references inside the ctor in a type
2433 preserving MEM_REF. */
2434 tree ctor
= DECL_INITIAL (node
->decl
);
2435 if (ctor
&& !in_lto_p
)
2436 walk_tree (&ctor
, wrap_refs
, NULL
, NULL
);
2437 if (get_symbol_initial_value (encoder
, node
->decl
) == error_mark_node
2438 && lto_symtab_encoder_encode_initializer_p (encoder
, node
)
2441 timevar_push (TV_IPA_LTO_CTORS_OUT
);
2444 gcc_assert (!bitmap_bit_p (output
, DECL_UID (node
->decl
)));
2445 bitmap_set_bit (output
, DECL_UID (node
->decl
));
2447 decl_state
= lto_new_out_decl_state ();
2448 lto_push_out_decl_state (decl_state
);
2449 if (DECL_INITIAL (node
->decl
) != error_mark_node
2451 && flag_incremental_link
!= INCREMENTAL_LINK_LTO
))
2452 output_constructor (node
);
2454 copy_function_or_variable (node
);
2455 gcc_assert (lto_get_out_decl_state () == decl_state
);
2456 lto_pop_out_decl_state ();
2457 lto_record_function_out_decl_state (node
->decl
, decl_state
);
2458 timevar_pop (TV_IPA_LTO_CTORS_OUT
);
2463 /* Emit the callgraph after emitting function bodies. This needs to
2464 be done now to make sure that all the statements in every function
2465 have been renumbered so that edges can be associated with call
2466 statements using the statement UIDs. */
2469 output_offload_tables ();
2472 lto_bitmap_free (output
);
2476 /* Write each node in encoded by ENCODER to OB, as well as those reachable
2477 from it and required for correct representation of its semantics.
2478 Each node in ENCODER must be a global declaration or a type. A node
2479 is written only once, even if it appears multiple times in the
2480 vector. Certain transitively-reachable nodes, such as those
2481 representing expressions, may be duplicated, but such nodes
2482 must not appear in ENCODER itself. */
2485 write_global_stream (struct output_block
*ob
,
2486 struct lto_tree_ref_encoder
*encoder
)
2490 const size_t size
= lto_tree_ref_encoder_size (encoder
);
2492 for (index
= 0; index
< size
; index
++)
2494 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2495 if (streamer_dump_file
)
2497 fprintf (streamer_dump_file
, " %i:", (int)index
);
2498 print_node_brief (streamer_dump_file
, "", t
, 4);
2499 fprintf (streamer_dump_file
, "\n");
2501 if (!streamer_tree_cache_lookup (ob
->writer_cache
, t
, NULL
))
2502 stream_write_tree (ob
, t
, false);
2507 /* Write a sequence of indices into the globals vector corresponding
2508 to the trees in ENCODER. These are used by the reader to map the
2509 indices used to refer to global entities within function bodies to
2513 write_global_references (struct output_block
*ob
,
2514 struct lto_tree_ref_encoder
*encoder
)
2518 const uint32_t size
= lto_tree_ref_encoder_size (encoder
);
2520 /* Write size and slot indexes as 32-bit unsigned numbers. */
2521 uint32_t *data
= XNEWVEC (uint32_t, size
+ 1);
2524 for (index
= 0; index
< size
; index
++)
2528 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2529 streamer_tree_cache_lookup (ob
->writer_cache
, t
, &slot_num
);
2530 gcc_assert (slot_num
!= (unsigned)-1);
2531 data
[index
+ 1] = slot_num
;
2534 lto_write_data (data
, sizeof (int32_t) * (size
+ 1));
2539 /* Write all the streams in an lto_out_decl_state STATE using
2540 output block OB and output stream OUT_STREAM. */
2543 lto_output_decl_state_streams (struct output_block
*ob
,
2544 struct lto_out_decl_state
*state
)
2548 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2549 write_global_stream (ob
, &state
->streams
[i
]);
2553 /* Write all the references in an lto_out_decl_state STATE using
2554 output block OB and output stream OUT_STREAM. */
2557 lto_output_decl_state_refs (struct output_block
*ob
,
2558 struct lto_out_decl_state
*state
)
2564 /* Write reference to FUNCTION_DECL. If there is not function,
2565 write reference to void_type_node. */
2566 decl
= (state
->fn_decl
) ? state
->fn_decl
: void_type_node
;
2567 streamer_tree_cache_lookup (ob
->writer_cache
, decl
, &ref
);
2568 gcc_assert (ref
!= (unsigned)-1);
2569 ref
= ref
* 2 + (state
->compressed
? 1 : 0);
2570 lto_write_data (&ref
, sizeof (uint32_t));
2572 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2573 write_global_references (ob
, &state
->streams
[i
]);
2577 /* Return the written size of STATE. */
2580 lto_out_decl_state_written_size (struct lto_out_decl_state
*state
)
2585 size
= sizeof (int32_t); /* fn_ref. */
2586 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2588 size
+= sizeof (int32_t); /* vector size. */
2589 size
+= (lto_tree_ref_encoder_size (&state
->streams
[i
])
2590 * sizeof (int32_t));
2596 /* Write symbol T into STREAM in CACHE. SEEN specifies symbols we wrote
2600 write_symbol (struct streamer_tree_cache_d
*cache
,
2601 tree t
, hash_set
<const char *> *seen
, bool alias
)
2604 enum gcc_plugin_symbol_kind kind
;
2605 enum gcc_plugin_symbol_visibility visibility
= GCCPV_DEFAULT
;
2611 gcc_checking_assert (TREE_PUBLIC (t
)
2612 && !is_builtin_fn (t
)
2613 && !DECL_ABSTRACT_P (t
)
2614 && (!VAR_P (t
) || !DECL_HARD_REGISTER (t
)));
2616 gcc_assert (VAR_OR_FUNCTION_DECL_P (t
));
2618 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t
));
2620 /* This behaves like assemble_name_raw in varasm.c, performing the
2621 same name manipulations that ASM_OUTPUT_LABELREF does. */
2622 name
= IDENTIFIER_POINTER ((*targetm
.asm_out
.mangle_assembler_name
) (name
));
2624 if (seen
->add (name
))
2627 streamer_tree_cache_lookup (cache
, t
, &slot_num
);
2628 gcc_assert (slot_num
!= (unsigned)-1);
2630 if (DECL_EXTERNAL (t
))
2633 kind
= GCCPK_WEAKUNDEF
;
2640 kind
= GCCPK_WEAKDEF
;
2641 else if (DECL_COMMON (t
))
2642 kind
= GCCPK_COMMON
;
2646 /* When something is defined, it should have node attached. */
2647 gcc_assert (alias
|| !VAR_P (t
) || varpool_node::get (t
)->definition
);
2648 gcc_assert (alias
|| TREE_CODE (t
) != FUNCTION_DECL
2649 || (cgraph_node::get (t
)
2650 && cgraph_node::get (t
)->definition
));
2653 /* Imitate what default_elf_asm_output_external do.
2654 When symbol is external, we need to output it with DEFAULT visibility
2655 when compiling with -fvisibility=default, while with HIDDEN visibility
2656 when symbol has attribute (visibility("hidden")) specified.
2657 targetm.binds_local_p check DECL_VISIBILITY_SPECIFIED and gets this
2660 if (DECL_EXTERNAL (t
)
2661 && !targetm
.binds_local_p (t
))
2662 visibility
= GCCPV_DEFAULT
;
2664 switch (DECL_VISIBILITY (t
))
2666 case VISIBILITY_DEFAULT
:
2667 visibility
= GCCPV_DEFAULT
;
2669 case VISIBILITY_PROTECTED
:
2670 visibility
= GCCPV_PROTECTED
;
2672 case VISIBILITY_HIDDEN
:
2673 visibility
= GCCPV_HIDDEN
;
2675 case VISIBILITY_INTERNAL
:
2676 visibility
= GCCPV_INTERNAL
;
2680 if (kind
== GCCPK_COMMON
2681 && DECL_SIZE_UNIT (t
)
2682 && TREE_CODE (DECL_SIZE_UNIT (t
)) == INTEGER_CST
)
2683 size
= TREE_INT_CST_LOW (DECL_SIZE_UNIT (t
));
2687 if (DECL_ONE_ONLY (t
))
2688 comdat
= IDENTIFIER_POINTER (decl_comdat_group_id (t
));
2692 lto_write_data (name
, strlen (name
) + 1);
2693 lto_write_data (comdat
, strlen (comdat
) + 1);
2694 c
= (unsigned char) kind
;
2695 lto_write_data (&c
, 1);
2696 c
= (unsigned char) visibility
;
2697 lto_write_data (&c
, 1);
2698 lto_write_data (&size
, 8);
2699 lto_write_data (&slot_num
, 4);
2702 /* Write an IL symbol table to OB.
2703 SET and VSET are cgraph/varpool node sets we are outputting. */
2706 produce_symtab (struct output_block
*ob
)
2708 struct streamer_tree_cache_d
*cache
= ob
->writer_cache
;
2709 char *section_name
= lto_get_section_name (LTO_section_symtab
, NULL
, NULL
);
2710 lto_symtab_encoder_t encoder
= ob
->decl_state
->symtab_node_encoder
;
2711 lto_symtab_encoder_iterator lsei
;
2713 lto_begin_section (section_name
, false);
2714 free (section_name
);
2716 hash_set
<const char *> seen
;
2718 /* Write the symbol table.
2719 First write everything defined and then all declarations.
2720 This is necessary to handle cases where we have duplicated symbols. */
2721 for (lsei
= lsei_start (encoder
);
2722 !lsei_end_p (lsei
); lsei_next (&lsei
))
2724 symtab_node
*node
= lsei_node (lsei
);
2726 if (DECL_EXTERNAL (node
->decl
) || !node
->output_to_lto_symbol_table_p ())
2728 write_symbol (cache
, node
->decl
, &seen
, false);
2730 for (lsei
= lsei_start (encoder
);
2731 !lsei_end_p (lsei
); lsei_next (&lsei
))
2733 symtab_node
*node
= lsei_node (lsei
);
2735 if (!DECL_EXTERNAL (node
->decl
) || !node
->output_to_lto_symbol_table_p ())
2737 write_symbol (cache
, node
->decl
, &seen
, false);
2744 /* Init the streamer_mode_table for output, where we collect info on what
2745 machine_mode values have been streamed. */
2747 lto_output_init_mode_table (void)
2749 memset (streamer_mode_table
, '\0', MAX_MACHINE_MODE
);
2753 /* Write the mode table. */
2755 lto_write_mode_table (void)
2757 struct output_block
*ob
;
2758 ob
= create_output_block (LTO_section_mode_table
);
2759 bitpack_d bp
= bitpack_create (ob
->main_stream
);
2761 /* Ensure that for GET_MODE_INNER (m) != m we have
2762 also the inner mode marked. */
2763 for (int i
= 0; i
< (int) MAX_MACHINE_MODE
; i
++)
2764 if (streamer_mode_table
[i
])
2766 machine_mode m
= (machine_mode
) i
;
2767 machine_mode inner_m
= GET_MODE_INNER (m
);
2769 streamer_mode_table
[(int) inner_m
] = 1;
2771 /* First stream modes that have GET_MODE_INNER (m) == m,
2772 so that we can refer to them afterwards. */
2773 for (int pass
= 0; pass
< 2; pass
++)
2774 for (int i
= 0; i
< (int) MAX_MACHINE_MODE
; i
++)
2775 if (streamer_mode_table
[i
] && i
!= (int) VOIDmode
&& i
!= (int) BLKmode
)
2777 machine_mode m
= (machine_mode
) i
;
2778 if ((GET_MODE_INNER (m
) == m
) ^ (pass
== 0))
2780 bp_pack_value (&bp
, m
, 8);
2781 bp_pack_enum (&bp
, mode_class
, MAX_MODE_CLASS
, GET_MODE_CLASS (m
));
2782 bp_pack_poly_value (&bp
, GET_MODE_SIZE (m
), 16);
2783 bp_pack_poly_value (&bp
, GET_MODE_PRECISION (m
), 16);
2784 bp_pack_value (&bp
, GET_MODE_INNER (m
), 8);
2785 bp_pack_poly_value (&bp
, GET_MODE_NUNITS (m
), 16);
2786 switch (GET_MODE_CLASS (m
))
2792 bp_pack_value (&bp
, GET_MODE_IBIT (m
), 8);
2793 bp_pack_value (&bp
, GET_MODE_FBIT (m
), 8);
2796 case MODE_DECIMAL_FLOAT
:
2797 bp_pack_string (ob
, &bp
, REAL_MODE_FORMAT (m
)->name
, true);
2802 bp_pack_string (ob
, &bp
, GET_MODE_NAME (m
), true);
2804 bp_pack_value (&bp
, VOIDmode
, 8);
2806 streamer_write_bitpack (&bp
);
2809 = lto_get_section_name (LTO_section_mode_table
, NULL
, NULL
);
2810 lto_begin_section (section_name
, !flag_wpa
);
2811 free (section_name
);
2813 /* The entire header stream is computed here. */
2814 struct lto_simple_header_with_strings header
;
2815 memset (&header
, 0, sizeof (header
));
2817 /* Write the header. */
2818 header
.major_version
= LTO_major_version
;
2819 header
.minor_version
= LTO_minor_version
;
2821 header
.main_size
= ob
->main_stream
->total_size
;
2822 header
.string_size
= ob
->string_stream
->total_size
;
2823 lto_write_data (&header
, sizeof header
);
2825 /* Put all of the gimple and the string table out the asm file as a
2827 lto_write_stream (ob
->main_stream
);
2828 lto_write_stream (ob
->string_stream
);
2831 destroy_output_block (ob
);
2835 /* This pass is run after all of the functions are serialized and all
2836 of the IPA passes have written their serialized forms. This pass
2837 causes the vector of all of the global decls and types used from
2838 this file to be written in to a section that can then be read in to
2839 recover these on other side. */
2842 produce_asm_for_decls (void)
2844 struct lto_out_decl_state
*out_state
;
2845 struct lto_out_decl_state
*fn_out_state
;
2846 struct lto_decl_header header
;
2848 struct output_block
*ob
;
2849 unsigned idx
, num_fns
;
2850 size_t decl_state_size
;
2851 int32_t num_decl_states
;
2853 ob
= create_output_block (LTO_section_decls
);
2855 memset (&header
, 0, sizeof (struct lto_decl_header
));
2857 section_name
= lto_get_section_name (LTO_section_decls
, NULL
, NULL
);
2858 lto_begin_section (section_name
, !flag_wpa
);
2859 free (section_name
);
2861 /* Make string 0 be a NULL string. */
2862 streamer_write_char_stream (ob
->string_stream
, 0);
2864 gcc_assert (!alias_pairs
);
2866 /* Get rid of the global decl state hash tables to save some memory. */
2867 out_state
= lto_get_out_decl_state ();
2868 for (int i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2869 if (out_state
->streams
[i
].tree_hash_table
)
2871 delete out_state
->streams
[i
].tree_hash_table
;
2872 out_state
->streams
[i
].tree_hash_table
= NULL
;
2875 /* Write the global symbols. */
2876 if (streamer_dump_file
)
2877 fprintf (streamer_dump_file
, "Outputting global stream\n");
2878 lto_output_decl_state_streams (ob
, out_state
);
2879 num_fns
= lto_function_decl_states
.length ();
2880 for (idx
= 0; idx
< num_fns
; idx
++)
2883 lto_function_decl_states
[idx
];
2884 if (streamer_dump_file
)
2885 fprintf (streamer_dump_file
, "Outputting stream for %s\n",
2887 (DECL_ASSEMBLER_NAME (fn_out_state
->fn_decl
)));
2888 lto_output_decl_state_streams (ob
, fn_out_state
);
2891 header
.major_version
= LTO_major_version
;
2892 header
.minor_version
= LTO_minor_version
;
2894 /* Currently not used. This field would allow us to preallocate
2895 the globals vector, so that it need not be resized as it is extended. */
2896 header
.num_nodes
= -1;
2898 /* Compute the total size of all decl out states. */
2899 decl_state_size
= sizeof (int32_t);
2900 decl_state_size
+= lto_out_decl_state_written_size (out_state
);
2901 for (idx
= 0; idx
< num_fns
; idx
++)
2904 lto_function_decl_states
[idx
];
2905 decl_state_size
+= lto_out_decl_state_written_size (fn_out_state
);
2907 header
.decl_state_size
= decl_state_size
;
2909 header
.main_size
= ob
->main_stream
->total_size
;
2910 header
.string_size
= ob
->string_stream
->total_size
;
2912 lto_write_data (&header
, sizeof header
);
2914 /* Write the main out-decl state, followed by out-decl states of
2916 num_decl_states
= num_fns
+ 1;
2917 lto_write_data (&num_decl_states
, sizeof (num_decl_states
));
2918 lto_output_decl_state_refs (ob
, out_state
);
2919 for (idx
= 0; idx
< num_fns
; idx
++)
2921 fn_out_state
= lto_function_decl_states
[idx
];
2922 lto_output_decl_state_refs (ob
, fn_out_state
);
2925 lto_write_stream (ob
->main_stream
);
2926 lto_write_stream (ob
->string_stream
);
2930 /* Write the symbol table. It is used by linker to determine dependencies
2931 and thus we can skip it for WPA. */
2933 produce_symtab (ob
);
2935 /* Write command line opts. */
2936 lto_write_options ();
2938 /* Deallocate memory and clean up. */
2939 for (idx
= 0; idx
< num_fns
; idx
++)
2942 lto_function_decl_states
[idx
];
2943 lto_delete_out_decl_state (fn_out_state
);
2945 lto_symtab_encoder_delete (ob
->decl_state
->symtab_node_encoder
);
2946 lto_function_decl_states
.release ();
2947 destroy_output_block (ob
);
2948 if (lto_stream_offload_p
)
2949 lto_write_mode_table ();