1 /* Write the GIMPLE representation to a file stream.
3 Copyright (C) 2009-2015 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"
32 #include "fold-const.h"
33 #include "stor-layout.h"
35 #include "insn-config.h"
45 #include "internal-fn.h"
46 #include "gimple-iterator.h"
47 #include "tree-pass.h"
48 #include "diagnostic-core.h"
50 #include "lto-symtab.h"
53 #include "gimple-streamer.h"
56 #include "gomp-constants.h"
59 static void lto_write_tree (struct output_block
*, tree
, bool);
61 /* Clear the line info stored in DATA_IN. */
64 clear_line_info (struct output_block
*ob
)
66 ob
->current_file
= NULL
;
69 ob
->current_sysp
= false;
73 /* Create the output block and return it. SECTION_TYPE is
74 LTO_section_function_body or LTO_static_initializer. */
77 create_output_block (enum lto_section_type section_type
)
79 struct output_block
*ob
= XCNEW (struct output_block
);
81 ob
->section_type
= section_type
;
82 ob
->decl_state
= lto_get_out_decl_state ();
83 ob
->main_stream
= XCNEW (struct lto_output_stream
);
84 ob
->string_stream
= XCNEW (struct lto_output_stream
);
85 ob
->writer_cache
= streamer_tree_cache_create (!flag_wpa
, true, false);
87 if (section_type
== LTO_section_function_body
)
88 ob
->cfg_stream
= XCNEW (struct lto_output_stream
);
92 ob
->string_hash_table
= new hash_table
<string_slot_hasher
> (37);
93 gcc_obstack_init (&ob
->obstack
);
99 /* Destroy the output block OB. */
102 destroy_output_block (struct output_block
*ob
)
104 enum lto_section_type section_type
= ob
->section_type
;
106 delete ob
->string_hash_table
;
107 ob
->string_hash_table
= NULL
;
109 free (ob
->main_stream
);
110 free (ob
->string_stream
);
111 if (section_type
== LTO_section_function_body
)
112 free (ob
->cfg_stream
);
114 streamer_tree_cache_delete (ob
->writer_cache
);
115 obstack_free (&ob
->obstack
, NULL
);
121 /* Look up NODE in the type table and write the index for it to OB. */
124 output_type_ref (struct output_block
*ob
, tree node
)
126 streamer_write_record_start (ob
, LTO_type_ref
);
127 lto_output_type_ref_index (ob
->decl_state
, ob
->main_stream
, node
);
131 /* Return true if tree node T is written to various tables. For these
132 nodes, we sometimes want to write their phyiscal representation
133 (via lto_output_tree), and sometimes we need to emit an index
134 reference into a table (via lto_output_tree_ref). */
137 tree_is_indexable (tree t
)
139 /* Parameters and return values of functions of variably modified types
140 must go to global stream, because they may be used in the type
142 if ((TREE_CODE (t
) == PARM_DECL
|| TREE_CODE (t
) == RESULT_DECL
)
144 return variably_modified_type_p (TREE_TYPE (DECL_CONTEXT (t
)), NULL_TREE
);
145 /* IMPORTED_DECL is put into BLOCK and thus it never can be shared. */
146 else if (TREE_CODE (t
) == IMPORTED_DECL
)
148 else if (((TREE_CODE (t
) == VAR_DECL
&& !TREE_STATIC (t
))
149 || TREE_CODE (t
) == TYPE_DECL
150 || TREE_CODE (t
) == CONST_DECL
151 || TREE_CODE (t
) == NAMELIST_DECL
)
152 && decl_function_context (t
))
154 else if (TREE_CODE (t
) == DEBUG_EXPR_DECL
)
156 /* Variably modified types need to be streamed alongside function
157 bodies because they can refer to local entities. Together with
158 them we have to localize their members as well.
159 ??? In theory that includes non-FIELD_DECLs as well. */
161 && variably_modified_type_p (t
, NULL_TREE
))
163 else if (TREE_CODE (t
) == FIELD_DECL
164 && variably_modified_type_p (DECL_CONTEXT (t
), NULL_TREE
))
167 return (TYPE_P (t
) || DECL_P (t
) || TREE_CODE (t
) == SSA_NAME
);
171 /* Output info about new location into bitpack BP.
172 After outputting bitpack, lto_output_location_data has
173 to be done to output actual data. */
176 lto_output_location (struct output_block
*ob
, struct bitpack_d
*bp
,
179 expanded_location xloc
;
181 loc
= LOCATION_LOCUS (loc
);
182 bp_pack_int_in_range (bp
, 0, RESERVED_LOCATION_COUNT
,
183 loc
< RESERVED_LOCATION_COUNT
184 ? loc
: RESERVED_LOCATION_COUNT
);
185 if (loc
< RESERVED_LOCATION_COUNT
)
188 xloc
= expand_location (loc
);
190 bp_pack_value (bp
, ob
->current_file
!= xloc
.file
, 1);
191 bp_pack_value (bp
, ob
->current_line
!= xloc
.line
, 1);
192 bp_pack_value (bp
, ob
->current_col
!= xloc
.column
, 1);
194 if (ob
->current_file
!= xloc
.file
)
196 bp_pack_string (ob
, bp
, xloc
.file
, true);
197 bp_pack_value (bp
, xloc
.sysp
, 1);
199 ob
->current_file
= xloc
.file
;
200 ob
->current_sysp
= xloc
.sysp
;
202 if (ob
->current_line
!= xloc
.line
)
203 bp_pack_var_len_unsigned (bp
, xloc
.line
);
204 ob
->current_line
= xloc
.line
;
206 if (ob
->current_col
!= xloc
.column
)
207 bp_pack_var_len_unsigned (bp
, xloc
.column
);
208 ob
->current_col
= xloc
.column
;
212 /* If EXPR is an indexable tree node, output a reference to it to
213 output block OB. Otherwise, output the physical representation of
217 lto_output_tree_ref (struct output_block
*ob
, tree expr
)
223 output_type_ref (ob
, expr
);
227 code
= TREE_CODE (expr
);
231 streamer_write_record_start (ob
, LTO_ssa_name_ref
);
232 streamer_write_uhwi (ob
, SSA_NAME_VERSION (expr
));
236 streamer_write_record_start (ob
, LTO_field_decl_ref
);
237 lto_output_field_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
241 streamer_write_record_start (ob
, LTO_function_decl_ref
);
242 lto_output_fn_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
246 case DEBUG_EXPR_DECL
:
247 gcc_assert (decl_function_context (expr
) == NULL
|| TREE_STATIC (expr
));
249 streamer_write_record_start (ob
, LTO_global_decl_ref
);
250 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
254 streamer_write_record_start (ob
, LTO_const_decl_ref
);
255 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
259 gcc_assert (decl_function_context (expr
) == NULL
);
260 streamer_write_record_start (ob
, LTO_imported_decl_ref
);
261 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
265 streamer_write_record_start (ob
, LTO_type_decl_ref
);
266 lto_output_type_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
270 streamer_write_record_start (ob
, LTO_namelist_decl_ref
);
271 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
275 streamer_write_record_start (ob
, LTO_namespace_decl_ref
);
276 lto_output_namespace_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
280 streamer_write_record_start (ob
, LTO_label_decl_ref
);
281 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
285 streamer_write_record_start (ob
, LTO_result_decl_ref
);
286 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
289 case TRANSLATION_UNIT_DECL
:
290 streamer_write_record_start (ob
, LTO_translation_unit_decl_ref
);
291 lto_output_var_decl_index (ob
->decl_state
, ob
->main_stream
, expr
);
295 /* No other node is indexable, so it should have been handled by
302 /* Return true if EXPR is a tree node that can be written to disk. */
305 lto_is_streamable (tree expr
)
307 enum tree_code code
= TREE_CODE (expr
);
309 /* Notice that we reject SSA_NAMEs as well. We only emit the SSA
310 name version in lto_output_tree_ref (see output_ssa_names). */
311 return !is_lang_specific (expr
)
315 && code
!= MODIFY_EXPR
317 && code
!= TARGET_EXPR
319 && code
!= WITH_CLEANUP_EXPR
320 && code
!= STATEMENT_LIST
321 && (code
== CASE_LABEL_EXPR
323 || TREE_CODE_CLASS (code
) != tcc_statement
);
327 /* For EXPR lookup and return what we want to stream to OB as DECL_INITIAL. */
330 get_symbol_initial_value (lto_symtab_encoder_t encoder
, tree expr
)
332 gcc_checking_assert (DECL_P (expr
)
333 && TREE_CODE (expr
) != FUNCTION_DECL
334 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
);
336 /* Handle DECL_INITIAL for symbols. */
337 tree initial
= DECL_INITIAL (expr
);
338 if (TREE_CODE (expr
) == VAR_DECL
339 && (TREE_STATIC (expr
) || DECL_EXTERNAL (expr
))
340 && !DECL_IN_CONSTANT_POOL (expr
)
344 /* Extra section needs about 30 bytes; do not produce it for simple
346 if (TREE_CODE (DECL_INITIAL (expr
)) == CONSTRUCTOR
347 || !(vnode
= varpool_node::get (expr
))
348 || !lto_symtab_encoder_encode_initializer_p (encoder
, vnode
))
349 initial
= error_mark_node
;
356 /* Write a physical representation of tree node EXPR to output block
357 OB. If REF_P is true, the leaves of EXPR are emitted as references
358 via lto_output_tree_ref. IX is the index into the streamer cache
359 where EXPR is stored. */
362 lto_write_tree_1 (struct output_block
*ob
, tree expr
, bool ref_p
)
364 /* Pack all the non-pointer fields in EXPR into a bitpack and write
365 the resulting bitpack. */
366 streamer_write_tree_bitfields (ob
, expr
);
368 /* Write all the pointer fields in EXPR. */
369 streamer_write_tree_body (ob
, expr
, ref_p
);
371 /* Write any LTO-specific data to OB. */
373 && TREE_CODE (expr
) != FUNCTION_DECL
374 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
376 /* Handle DECL_INITIAL for symbols. */
377 tree initial
= get_symbol_initial_value
378 (ob
->decl_state
->symtab_node_encoder
, expr
);
379 stream_write_tree (ob
, initial
, ref_p
);
383 /* Write a physical representation of tree node EXPR to output block
384 OB. If REF_P is true, the leaves of EXPR are emitted as references
385 via lto_output_tree_ref. IX is the index into the streamer cache
386 where EXPR is stored. */
389 lto_write_tree (struct output_block
*ob
, tree expr
, bool ref_p
)
391 if (!lto_is_streamable (expr
))
392 internal_error ("tree code %qs is not supported in LTO streams",
393 get_tree_code_name (TREE_CODE (expr
)));
395 /* Write the header, containing everything needed to materialize
396 EXPR on the reading side. */
397 streamer_write_tree_header (ob
, expr
);
399 lto_write_tree_1 (ob
, expr
, ref_p
);
401 /* Mark the end of EXPR. */
402 streamer_write_zero (ob
);
405 /* Emit the physical representation of tree node EXPR to output block OB,
406 If THIS_REF_P is true, the leaves of EXPR are emitted as references via
407 lto_output_tree_ref. REF_P is used for streaming siblings of EXPR. */
410 lto_output_tree_1 (struct output_block
*ob
, tree expr
, hashval_t hash
,
411 bool ref_p
, bool this_ref_p
)
415 gcc_checking_assert (expr
!= NULL_TREE
416 && !(this_ref_p
&& tree_is_indexable (expr
)));
418 bool exists_p
= streamer_tree_cache_insert (ob
->writer_cache
,
420 gcc_assert (!exists_p
);
421 if (streamer_handle_as_builtin_p (expr
))
423 /* MD and NORMAL builtins do not need to be written out
424 completely as they are always instantiated by the
425 compiler on startup. The only builtins that need to
426 be written out are BUILT_IN_FRONTEND. For all other
427 builtins, we simply write the class and code. */
428 streamer_write_builtin (ob
, expr
);
430 else if (TREE_CODE (expr
) == INTEGER_CST
431 && !TREE_OVERFLOW (expr
))
433 /* Shared INTEGER_CST nodes are special because they need their
434 original type to be materialized by the reader (to implement
435 TYPE_CACHED_VALUES). */
436 streamer_write_integer_cst (ob
, expr
, ref_p
);
440 /* This is the first time we see EXPR, write its fields
442 lto_write_tree (ob
, expr
, ref_p
);
449 DFS (struct output_block
*ob
, tree expr
, bool ref_p
, bool this_ref_p
,
458 vec
<scc_entry
> sccstack
;
475 static int scc_entry_compare (const void *, const void *);
477 void DFS_write_tree_body (struct output_block
*ob
,
478 tree expr
, sccs
*expr_state
, bool ref_p
);
480 void DFS_write_tree (struct output_block
*ob
, sccs
*from_state
,
481 tree expr
, bool ref_p
, bool this_ref_p
);
484 hash_scc (struct output_block
*ob
, unsigned first
, unsigned size
,
485 bool ref_p
, bool this_ref_p
);
487 hash_map
<tree
, sccs
*> sccstate
;
488 vec
<worklist
> worklist_vec
;
489 struct obstack sccstate_obstack
;
492 /* Emit the physical representation of tree node EXPR to output block OB,
493 using depth-first search on the subgraph. If THIS_REF_P is true, the
494 leaves of EXPR are emitted as references via lto_output_tree_ref.
495 REF_P is used for streaming siblings of EXPR. If SINGLE_P is true,
496 this is for a rewalk of a single leaf SCC. */
498 DFS::DFS (struct output_block
*ob
, tree expr
, bool ref_p
, bool this_ref_p
,
501 unsigned int next_dfs_num
= 1;
503 gcc_obstack_init (&sccstate_obstack
);
504 worklist_vec
= vNULL
;
505 DFS_write_tree (ob
, NULL
, expr
, ref_p
, this_ref_p
);
506 while (!worklist_vec
.is_empty ())
508 worklist
&w
= worklist_vec
.last ();
510 sccs
*from_state
= w
.from_state
;
511 sccs
*cstate
= w
.cstate
;
513 this_ref_p
= w
.this_ref_p
;
516 sccs
**slot
= &sccstate
.get_or_insert (expr
);
520 gcc_checking_assert (from_state
);
521 if (cstate
->dfsnum
< from_state
->dfsnum
)
522 from_state
->low
= MIN (cstate
->dfsnum
, from_state
->low
);
527 scc_entry e
= { expr
, 0 };
528 /* Not yet visited. DFS recurse and push it onto the stack. */
529 *slot
= cstate
= XOBNEW (&sccstate_obstack
, struct sccs
);
530 sccstack
.safe_push (e
);
531 cstate
->dfsnum
= next_dfs_num
++;
532 cstate
->low
= cstate
->dfsnum
;
535 if (streamer_handle_as_builtin_p (expr
))
537 else if (TREE_CODE (expr
) == INTEGER_CST
538 && !TREE_OVERFLOW (expr
))
539 DFS_write_tree (ob
, cstate
, TREE_TYPE (expr
), ref_p
, ref_p
);
542 DFS_write_tree_body (ob
, expr
, cstate
, ref_p
);
544 /* Walk any LTO-specific edges. */
546 && TREE_CODE (expr
) != FUNCTION_DECL
547 && TREE_CODE (expr
) != TRANSLATION_UNIT_DECL
)
549 /* Handle DECL_INITIAL for symbols. */
551 = get_symbol_initial_value (ob
->decl_state
->symtab_node_encoder
,
553 DFS_write_tree (ob
, cstate
, initial
, ref_p
, ref_p
);
559 /* See if we found an SCC. */
560 if (cstate
->low
== cstate
->dfsnum
)
562 unsigned first
, size
;
565 /* If we are re-walking a single leaf SCC just pop it,
566 let earlier worklist item access the sccstack. */
573 /* Pop the SCC and compute its size. */
574 first
= sccstack
.length ();
577 x
= sccstack
[--first
].t
;
580 size
= sccstack
.length () - first
;
582 /* No need to compute hashes for LTRANS units, we don't perform
583 any merging there. */
584 hashval_t scc_hash
= 0;
585 unsigned scc_entry_len
= 0;
588 scc_hash
= hash_scc (ob
, first
, size
, ref_p
, this_ref_p
);
590 /* Put the entries with the least number of collisions first. */
591 unsigned entry_start
= 0;
592 scc_entry_len
= size
+ 1;
593 for (unsigned i
= 0; i
< size
;)
596 for (i
= i
+ 1; i
< size
597 && (sccstack
[first
+ i
].hash
598 == sccstack
[first
+ from
].hash
); ++i
)
600 if (i
- from
< scc_entry_len
)
602 scc_entry_len
= i
- from
;
606 for (unsigned i
= 0; i
< scc_entry_len
; ++i
)
607 std::swap (sccstack
[first
+ i
],
608 sccstack
[first
+ entry_start
+ i
]);
610 if (scc_entry_len
== 1)
611 ; /* We already sorted SCC deterministically in hash_scc. */
613 /* Check that we have only one SCC.
614 Naturally we may have conflicts if hash function is not
615 strong enough. Lets see how far this gets. */
617 #ifdef ENABLE_CHECKING
623 /* Write LTO_tree_scc. */
624 streamer_write_record_start (ob
, LTO_tree_scc
);
625 streamer_write_uhwi (ob
, size
);
626 streamer_write_uhwi (ob
, scc_hash
);
628 /* Write size-1 SCCs without wrapping them inside SCC bundles.
629 All INTEGER_CSTs need to be handled this way as we need
630 their type to materialize them. Also builtins are handled
632 ??? We still wrap these in LTO_tree_scc so at the
633 input side we can properly identify the tree we want
634 to ultimatively return. */
636 lto_output_tree_1 (ob
, expr
, scc_hash
, ref_p
, this_ref_p
);
639 /* Write the size of the SCC entry candidates. */
640 streamer_write_uhwi (ob
, scc_entry_len
);
642 /* Write all headers and populate the streamer cache. */
643 for (unsigned i
= 0; i
< size
; ++i
)
645 hashval_t hash
= sccstack
[first
+i
].hash
;
646 tree t
= sccstack
[first
+i
].t
;
647 bool exists_p
= streamer_tree_cache_insert (ob
->writer_cache
,
649 gcc_assert (!exists_p
);
651 if (!lto_is_streamable (t
))
652 internal_error ("tree code %qs is not supported "
654 get_tree_code_name (TREE_CODE (t
)));
656 gcc_checking_assert (!streamer_handle_as_builtin_p (t
));
658 /* Write the header, containing everything needed to
659 materialize EXPR on the reading side. */
660 streamer_write_tree_header (ob
, t
);
663 /* Write the bitpacks and tree references. */
664 for (unsigned i
= 0; i
< size
; ++i
)
666 lto_write_tree_1 (ob
, sccstack
[first
+i
].t
, ref_p
);
668 /* Mark the end of the tree. */
669 streamer_write_zero (ob
);
673 /* Finally truncate the vector. */
674 sccstack
.truncate (first
);
677 from_state
->low
= MIN (from_state
->low
, cstate
->low
);
682 gcc_checking_assert (from_state
);
683 from_state
->low
= MIN (from_state
->low
, cstate
->low
);
684 if (cstate
->dfsnum
< from_state
->dfsnum
)
685 from_state
->low
= MIN (cstate
->dfsnum
, from_state
->low
);
688 worklist_vec
.release ();
694 obstack_free (&sccstate_obstack
, NULL
);
697 /* Handle the tree EXPR in the DFS walk with SCC state EXPR_STATE and
698 DFS recurse for all tree edges originating from it. */
701 DFS::DFS_write_tree_body (struct output_block
*ob
,
702 tree expr
, sccs
*expr_state
, bool ref_p
)
704 #define DFS_follow_tree_edge(DEST) \
705 DFS_write_tree (ob, expr_state, DEST, ref_p, ref_p)
709 code
= TREE_CODE (expr
);
711 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
713 if (TREE_CODE (expr
) != IDENTIFIER_NODE
)
714 DFS_follow_tree_edge (TREE_TYPE (expr
));
717 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
719 for (unsigned i
= 0; i
< VECTOR_CST_NELTS (expr
); ++i
)
720 DFS_follow_tree_edge (VECTOR_CST_ELT (expr
, i
));
723 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
725 DFS_follow_tree_edge (TREE_REALPART (expr
));
726 DFS_follow_tree_edge (TREE_IMAGPART (expr
));
729 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
731 /* Drop names that were created for anonymous entities. */
733 && TREE_CODE (DECL_NAME (expr
)) == IDENTIFIER_NODE
734 && anon_aggrname_p (DECL_NAME (expr
)))
737 DFS_follow_tree_edge (DECL_NAME (expr
));
738 DFS_follow_tree_edge (DECL_CONTEXT (expr
));
741 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
743 DFS_follow_tree_edge (DECL_SIZE (expr
));
744 DFS_follow_tree_edge (DECL_SIZE_UNIT (expr
));
746 /* Note, DECL_INITIAL is not handled here. Since DECL_INITIAL needs
747 special handling in LTO, it must be handled by streamer hooks. */
749 DFS_follow_tree_edge (DECL_ATTRIBUTES (expr
));
751 /* Do not follow DECL_ABSTRACT_ORIGIN. We cannot handle debug information
752 for early inlining so drop it on the floor instead of ICEing in
755 if ((TREE_CODE (expr
) == VAR_DECL
756 || TREE_CODE (expr
) == PARM_DECL
)
757 && DECL_HAS_VALUE_EXPR_P (expr
))
758 DFS_follow_tree_edge (DECL_VALUE_EXPR (expr
));
759 if (TREE_CODE (expr
) == VAR_DECL
)
760 DFS_follow_tree_edge (DECL_DEBUG_EXPR (expr
));
763 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
765 if (TREE_CODE (expr
) == TYPE_DECL
)
766 DFS_follow_tree_edge (DECL_ORIGINAL_TYPE (expr
));
769 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
771 /* Make sure we don't inadvertently set the assembler name. */
772 if (DECL_ASSEMBLER_NAME_SET_P (expr
))
773 DFS_follow_tree_edge (DECL_ASSEMBLER_NAME (expr
));
776 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
778 DFS_follow_tree_edge (DECL_FIELD_OFFSET (expr
));
779 DFS_follow_tree_edge (DECL_BIT_FIELD_TYPE (expr
));
780 DFS_follow_tree_edge (DECL_BIT_FIELD_REPRESENTATIVE (expr
));
781 DFS_follow_tree_edge (DECL_FIELD_BIT_OFFSET (expr
));
782 DFS_follow_tree_edge (DECL_FCONTEXT (expr
));
785 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
787 DFS_follow_tree_edge (DECL_VINDEX (expr
));
788 DFS_follow_tree_edge (DECL_FUNCTION_PERSONALITY (expr
));
789 DFS_follow_tree_edge (DECL_FUNCTION_SPECIFIC_TARGET (expr
));
790 DFS_follow_tree_edge (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr
));
793 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
795 DFS_follow_tree_edge (TYPE_SIZE (expr
));
796 DFS_follow_tree_edge (TYPE_SIZE_UNIT (expr
));
797 DFS_follow_tree_edge (TYPE_ATTRIBUTES (expr
));
798 DFS_follow_tree_edge (TYPE_NAME (expr
));
799 /* Do not follow TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
800 reconstructed during fixup. */
801 /* Do not follow TYPE_NEXT_VARIANT, we reconstruct the variant lists
803 DFS_follow_tree_edge (TYPE_MAIN_VARIANT (expr
));
804 DFS_follow_tree_edge (TYPE_CONTEXT (expr
));
805 /* TYPE_CANONICAL is re-computed during type merging, so no need
806 to follow it here. */
807 DFS_follow_tree_edge (TYPE_STUB_DECL (expr
));
810 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
812 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
813 DFS_follow_tree_edge (TYPE_VALUES (expr
));
814 else if (TREE_CODE (expr
) == ARRAY_TYPE
)
815 DFS_follow_tree_edge (TYPE_DOMAIN (expr
));
816 else if (RECORD_OR_UNION_TYPE_P (expr
))
817 for (tree t
= TYPE_FIELDS (expr
); t
; t
= TREE_CHAIN (t
))
818 DFS_follow_tree_edge (t
);
819 else if (TREE_CODE (expr
) == FUNCTION_TYPE
820 || TREE_CODE (expr
) == METHOD_TYPE
)
821 DFS_follow_tree_edge (TYPE_ARG_TYPES (expr
));
823 if (!POINTER_TYPE_P (expr
))
824 DFS_follow_tree_edge (TYPE_MINVAL (expr
));
825 DFS_follow_tree_edge (TYPE_MAXVAL (expr
));
826 if (RECORD_OR_UNION_TYPE_P (expr
))
827 DFS_follow_tree_edge (TYPE_BINFO (expr
));
830 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
832 DFS_follow_tree_edge (TREE_PURPOSE (expr
));
833 DFS_follow_tree_edge (TREE_VALUE (expr
));
834 DFS_follow_tree_edge (TREE_CHAIN (expr
));
837 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
839 for (int i
= 0; i
< TREE_VEC_LENGTH (expr
); i
++)
840 DFS_follow_tree_edge (TREE_VEC_ELT (expr
, i
));
843 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
845 for (int i
= 0; i
< TREE_OPERAND_LENGTH (expr
); i
++)
846 DFS_follow_tree_edge (TREE_OPERAND (expr
, i
));
847 DFS_follow_tree_edge (TREE_BLOCK (expr
));
850 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
852 for (tree t
= BLOCK_VARS (expr
); t
; t
= TREE_CHAIN (t
))
853 if (VAR_OR_FUNCTION_DECL_P (t
)
854 && DECL_EXTERNAL (t
))
855 /* We have to stream externals in the block chain as
856 non-references. See also
857 tree-streamer-out.c:streamer_write_chain. */
858 DFS_write_tree (ob
, expr_state
, t
, ref_p
, false);
860 DFS_follow_tree_edge (t
);
862 DFS_follow_tree_edge (BLOCK_SUPERCONTEXT (expr
));
864 /* Follow BLOCK_ABSTRACT_ORIGIN for the limited cases we can
865 handle - those that represent inlined function scopes.
866 For the drop rest them on the floor instead of ICEing
868 if (inlined_function_outer_scope_p (expr
))
870 tree ultimate_origin
= block_ultimate_origin (expr
);
871 DFS_follow_tree_edge (ultimate_origin
);
873 /* Do not follow BLOCK_NONLOCALIZED_VARS. We cannot handle debug
874 information for early inlined BLOCKs so drop it on the floor instead
875 of ICEing in dwarf2out.c. */
877 /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
880 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
881 list is re-constructed from BLOCK_SUPERCONTEXT. */
884 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
889 /* Note that the number of BINFO slots has already been emitted in
890 EXPR's header (see streamer_write_tree_header) because this length
891 is needed to build the empty BINFO node on the reader side. */
892 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr
), i
, t
)
893 DFS_follow_tree_edge (t
);
894 DFS_follow_tree_edge (BINFO_OFFSET (expr
));
895 DFS_follow_tree_edge (BINFO_VTABLE (expr
));
896 DFS_follow_tree_edge (BINFO_VPTR_FIELD (expr
));
898 /* The number of BINFO_BASE_ACCESSES has already been emitted in
899 EXPR's bitfield section. */
900 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (expr
), i
, t
)
901 DFS_follow_tree_edge (t
);
903 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
904 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
907 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
912 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr
), i
, index
, value
)
914 DFS_follow_tree_edge (index
);
915 DFS_follow_tree_edge (value
);
919 if (code
== OMP_CLAUSE
)
922 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (expr
)]; i
++)
923 DFS_follow_tree_edge (OMP_CLAUSE_OPERAND (expr
, i
));
924 DFS_follow_tree_edge (OMP_CLAUSE_CHAIN (expr
));
927 #undef DFS_follow_tree_edge
930 /* Return a hash value for the tree T.
931 CACHE holds hash values of trees outside current SCC. MAP, if non-NULL,
932 may hold hash values if trees inside current SCC. */
935 hash_tree (struct streamer_tree_cache_d
*cache
, hash_map
<tree
, hashval_t
> *map
, tree t
)
937 inchash::hash hstate
;
939 #define visit(SIBLING) \
943 hstate.add_int (0); \
944 else if (streamer_tree_cache_lookup (cache, SIBLING, &ix)) \
945 hstate.add_int (streamer_tree_cache_get_hash (cache, ix)); \
947 hstate.add_int (*map->get (SIBLING)); \
949 hstate.add_int (1); \
953 enum tree_code code
= TREE_CODE (t
);
954 hstate
.add_int (code
);
957 hstate
.add_flag (TREE_SIDE_EFFECTS (t
));
958 hstate
.add_flag (TREE_CONSTANT (t
));
959 hstate
.add_flag (TREE_READONLY (t
));
960 hstate
.add_flag (TREE_PUBLIC (t
));
962 hstate
.add_flag (TREE_ADDRESSABLE (t
));
963 hstate
.add_flag (TREE_THIS_VOLATILE (t
));
965 hstate
.add_flag (DECL_UNSIGNED (t
));
967 hstate
.add_flag (TYPE_UNSIGNED (t
));
969 hstate
.add_flag (TYPE_ARTIFICIAL (t
));
971 hstate
.add_flag (TREE_NO_WARNING (t
));
972 hstate
.add_flag (TREE_NOTHROW (t
));
973 hstate
.add_flag (TREE_STATIC (t
));
974 hstate
.add_flag (TREE_PROTECTED (t
));
975 hstate
.add_flag (TREE_DEPRECATED (t
));
976 if (code
!= TREE_BINFO
)
977 hstate
.add_flag (TREE_PRIVATE (t
));
980 hstate
.add_flag (TYPE_SATURATING (t
));
981 hstate
.add_flag (TYPE_ADDR_SPACE (t
));
983 else if (code
== SSA_NAME
)
984 hstate
.add_flag (SSA_NAME_IS_DEFAULT_DEF (t
));
985 hstate
.commit_flag ();
987 if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
990 hstate
.add_wide_int (TREE_INT_CST_NUNITS (t
));
991 hstate
.add_wide_int (TREE_INT_CST_EXT_NUNITS (t
));
992 for (i
= 0; i
< TREE_INT_CST_NUNITS (t
); i
++)
993 hstate
.add_wide_int (TREE_INT_CST_ELT (t
, i
));
996 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
998 REAL_VALUE_TYPE r
= TREE_REAL_CST (t
);
999 hstate
.add_flag (r
.cl
);
1000 hstate
.add_flag (r
.sign
);
1001 hstate
.add_flag (r
.signalling
);
1002 hstate
.add_flag (r
.canonical
);
1003 hstate
.commit_flag ();
1004 hstate
.add_int (r
.uexp
);
1005 hstate
.add (r
.sig
, sizeof (r
.sig
));
1008 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
1010 FIXED_VALUE_TYPE f
= TREE_FIXED_CST (t
);
1011 hstate
.add_int (f
.mode
);
1012 hstate
.add_int (f
.data
.low
);
1013 hstate
.add_int (f
.data
.high
);
1016 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1018 hstate
.add_wide_int (DECL_MODE (t
));
1019 hstate
.add_flag (DECL_NONLOCAL (t
));
1020 hstate
.add_flag (DECL_VIRTUAL_P (t
));
1021 hstate
.add_flag (DECL_IGNORED_P (t
));
1022 hstate
.add_flag (DECL_ABSTRACT_P (t
));
1023 hstate
.add_flag (DECL_ARTIFICIAL (t
));
1024 hstate
.add_flag (DECL_USER_ALIGN (t
));
1025 hstate
.add_flag (DECL_PRESERVE_P (t
));
1026 hstate
.add_flag (DECL_EXTERNAL (t
));
1027 hstate
.add_flag (DECL_GIMPLE_REG_P (t
));
1028 hstate
.commit_flag ();
1029 hstate
.add_int (DECL_ALIGN (t
));
1030 if (code
== LABEL_DECL
)
1032 hstate
.add_int (EH_LANDING_PAD_NR (t
));
1033 hstate
.add_int (LABEL_DECL_UID (t
));
1035 else if (code
== FIELD_DECL
)
1037 hstate
.add_flag (DECL_PACKED (t
));
1038 hstate
.add_flag (DECL_NONADDRESSABLE_P (t
));
1039 hstate
.add_int (DECL_OFFSET_ALIGN (t
));
1041 else if (code
== VAR_DECL
)
1043 hstate
.add_flag (DECL_HAS_DEBUG_EXPR_P (t
));
1044 hstate
.add_flag (DECL_NONLOCAL_FRAME (t
));
1046 if (code
== RESULT_DECL
1047 || code
== PARM_DECL
1048 || code
== VAR_DECL
)
1050 hstate
.add_flag (DECL_BY_REFERENCE (t
));
1051 if (code
== VAR_DECL
1052 || code
== PARM_DECL
)
1053 hstate
.add_flag (DECL_HAS_VALUE_EXPR_P (t
));
1055 hstate
.commit_flag ();
1058 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
1059 hstate
.add_int (DECL_REGISTER (t
));
1061 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1063 hstate
.add_flag (DECL_COMMON (t
));
1064 hstate
.add_flag (DECL_DLLIMPORT_P (t
));
1065 hstate
.add_flag (DECL_WEAK (t
));
1066 hstate
.add_flag (DECL_SEEN_IN_BIND_EXPR_P (t
));
1067 hstate
.add_flag (DECL_COMDAT (t
));
1068 hstate
.add_flag (DECL_VISIBILITY_SPECIFIED (t
));
1069 hstate
.add_int (DECL_VISIBILITY (t
));
1070 if (code
== VAR_DECL
)
1072 /* DECL_IN_TEXT_SECTION is set during final asm output only. */
1073 hstate
.add_flag (DECL_HARD_REGISTER (t
));
1074 hstate
.add_flag (DECL_IN_CONSTANT_POOL (t
));
1076 if (TREE_CODE (t
) == FUNCTION_DECL
)
1078 hstate
.add_flag (DECL_FINAL_P (t
));
1079 hstate
.add_flag (DECL_CXX_CONSTRUCTOR_P (t
));
1080 hstate
.add_flag (DECL_CXX_DESTRUCTOR_P (t
));
1082 hstate
.commit_flag ();
1085 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1087 hstate
.add_int (DECL_BUILT_IN_CLASS (t
));
1088 hstate
.add_flag (DECL_STATIC_CONSTRUCTOR (t
));
1089 hstate
.add_flag (DECL_STATIC_DESTRUCTOR (t
));
1090 hstate
.add_flag (DECL_UNINLINABLE (t
));
1091 hstate
.add_flag (DECL_POSSIBLY_INLINED (t
));
1092 hstate
.add_flag (DECL_IS_NOVOPS (t
));
1093 hstate
.add_flag (DECL_IS_RETURNS_TWICE (t
));
1094 hstate
.add_flag (DECL_IS_MALLOC (t
));
1095 hstate
.add_flag (DECL_IS_OPERATOR_NEW (t
));
1096 hstate
.add_flag (DECL_DECLARED_INLINE_P (t
));
1097 hstate
.add_flag (DECL_STATIC_CHAIN (t
));
1098 hstate
.add_flag (DECL_NO_INLINE_WARNING_P (t
));
1099 hstate
.add_flag (DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (t
));
1100 hstate
.add_flag (DECL_NO_LIMIT_STACK (t
));
1101 hstate
.add_flag (DECL_DISREGARD_INLINE_LIMITS (t
));
1102 hstate
.add_flag (DECL_PURE_P (t
));
1103 hstate
.add_flag (DECL_LOOPING_CONST_OR_PURE_P (t
));
1104 hstate
.commit_flag ();
1105 if (DECL_BUILT_IN_CLASS (t
) != NOT_BUILT_IN
)
1106 hstate
.add_int (DECL_FUNCTION_CODE (t
));
1109 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
1111 hstate
.add_wide_int (TYPE_MODE (t
));
1112 hstate
.add_flag (TYPE_STRING_FLAG (t
));
1113 /* TYPE_NO_FORCE_BLK is private to stor-layout and need
1115 hstate
.add_flag (TYPE_NEEDS_CONSTRUCTING (t
));
1116 hstate
.add_flag (TYPE_PACKED (t
));
1117 hstate
.add_flag (TYPE_RESTRICT (t
));
1118 hstate
.add_flag (TYPE_USER_ALIGN (t
));
1119 hstate
.add_flag (TYPE_READONLY (t
));
1120 if (RECORD_OR_UNION_TYPE_P (t
))
1122 hstate
.add_flag (TYPE_TRANSPARENT_AGGR (t
));
1123 hstate
.add_flag (TYPE_FINAL_P (t
));
1125 else if (code
== ARRAY_TYPE
)
1126 hstate
.add_flag (TYPE_NONALIASED_COMPONENT (t
));
1127 hstate
.commit_flag ();
1128 hstate
.add_int (TYPE_PRECISION (t
));
1129 hstate
.add_int (TYPE_ALIGN (t
));
1130 hstate
.add_int ((TYPE_ALIAS_SET (t
) == 0
1132 && get_alias_set (t
) == 0))
1136 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
1137 hstate
.add (TRANSLATION_UNIT_LANGUAGE (t
),
1138 strlen (TRANSLATION_UNIT_LANGUAGE (t
)));
1140 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
)
1141 /* We don't stream these when passing things to a different target. */
1142 && !lto_stream_offload_p
)
1143 hstate
.add_wide_int (cl_target_option_hash (TREE_TARGET_OPTION (t
)));
1145 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
1146 hstate
.add_wide_int (cl_optimization_hash (TREE_OPTIMIZATION (t
)));
1148 if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
1149 hstate
.merge_hash (IDENTIFIER_HASH_VALUE (t
));
1151 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
1152 hstate
.add (TREE_STRING_POINTER (t
), TREE_STRING_LENGTH (t
));
1154 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
1156 if (code
!= IDENTIFIER_NODE
)
1157 visit (TREE_TYPE (t
));
1160 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
1161 for (unsigned i
= 0; i
< VECTOR_CST_NELTS (t
); ++i
)
1162 visit (VECTOR_CST_ELT (t
, i
));
1164 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
1166 visit (TREE_REALPART (t
));
1167 visit (TREE_IMAGPART (t
));
1170 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
1172 /* Drop names that were created for anonymous entities. */
1174 && TREE_CODE (DECL_NAME (t
)) == IDENTIFIER_NODE
1175 && anon_aggrname_p (DECL_NAME (t
)))
1178 visit (DECL_NAME (t
));
1179 if (DECL_FILE_SCOPE_P (t
))
1182 visit (DECL_CONTEXT (t
));
1185 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1187 visit (DECL_SIZE (t
));
1188 visit (DECL_SIZE_UNIT (t
));
1189 visit (DECL_ATTRIBUTES (t
));
1190 if ((code
== VAR_DECL
1191 || code
== PARM_DECL
)
1192 && DECL_HAS_VALUE_EXPR_P (t
))
1193 visit (DECL_VALUE_EXPR (t
));
1194 if (code
== VAR_DECL
1195 && DECL_HAS_DEBUG_EXPR_P (t
))
1196 visit (DECL_DEBUG_EXPR (t
));
1197 /* ??? Hash DECL_INITIAL as streamed. Needs the output-block to
1198 be able to call get_symbol_initial_value. */
1201 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
1203 if (code
== TYPE_DECL
)
1204 visit (DECL_ORIGINAL_TYPE (t
));
1207 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1209 if (DECL_ASSEMBLER_NAME_SET_P (t
))
1210 visit (DECL_ASSEMBLER_NAME (t
));
1213 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
1215 visit (DECL_FIELD_OFFSET (t
));
1216 visit (DECL_BIT_FIELD_TYPE (t
));
1217 visit (DECL_BIT_FIELD_REPRESENTATIVE (t
));
1218 visit (DECL_FIELD_BIT_OFFSET (t
));
1219 visit (DECL_FCONTEXT (t
));
1222 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1224 visit (DECL_VINDEX (t
));
1225 visit (DECL_FUNCTION_PERSONALITY (t
));
1226 visit (DECL_FUNCTION_SPECIFIC_TARGET (t
));
1227 visit (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t
));
1230 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
1232 visit (TYPE_SIZE (t
));
1233 visit (TYPE_SIZE_UNIT (t
));
1234 visit (TYPE_ATTRIBUTES (t
));
1235 visit (TYPE_NAME (t
));
1236 visit (TYPE_MAIN_VARIANT (t
));
1237 if (TYPE_FILE_SCOPE_P (t
))
1240 visit (TYPE_CONTEXT (t
));
1241 visit (TYPE_STUB_DECL (t
));
1244 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
1246 if (code
== ENUMERAL_TYPE
)
1247 visit (TYPE_VALUES (t
));
1248 else if (code
== ARRAY_TYPE
)
1249 visit (TYPE_DOMAIN (t
));
1250 else if (RECORD_OR_UNION_TYPE_P (t
))
1251 for (tree f
= TYPE_FIELDS (t
); f
; f
= TREE_CHAIN (f
))
1253 else if (code
== FUNCTION_TYPE
1254 || code
== METHOD_TYPE
)
1255 visit (TYPE_ARG_TYPES (t
));
1256 if (!POINTER_TYPE_P (t
))
1257 visit (TYPE_MINVAL (t
));
1258 visit (TYPE_MAXVAL (t
));
1259 if (RECORD_OR_UNION_TYPE_P (t
))
1260 visit (TYPE_BINFO (t
));
1263 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
1265 visit (TREE_PURPOSE (t
));
1266 visit (TREE_VALUE (t
));
1267 visit (TREE_CHAIN (t
));
1270 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1271 for (int i
= 0; i
< TREE_VEC_LENGTH (t
); ++i
)
1272 visit (TREE_VEC_ELT (t
, i
));
1274 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
1276 hstate
.add_wide_int (TREE_OPERAND_LENGTH (t
));
1277 for (int i
= 0; i
< TREE_OPERAND_LENGTH (t
); ++i
)
1278 visit (TREE_OPERAND (t
, i
));
1281 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1285 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (t
), i
, b
)
1287 visit (BINFO_OFFSET (t
));
1288 visit (BINFO_VTABLE (t
));
1289 visit (BINFO_VPTR_FIELD (t
));
1290 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (t
), i
, b
)
1292 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
1293 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
1296 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1300 hstate
.add_wide_int (CONSTRUCTOR_NELTS (t
));
1301 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), i
, index
, value
)
1308 if (code
== OMP_CLAUSE
)
1313 hstate
.add_wide_int (OMP_CLAUSE_CODE (t
));
1314 switch (OMP_CLAUSE_CODE (t
))
1316 case OMP_CLAUSE_DEFAULT
:
1317 val
= OMP_CLAUSE_DEFAULT_KIND (t
);
1319 case OMP_CLAUSE_SCHEDULE
:
1320 val
= OMP_CLAUSE_SCHEDULE_KIND (t
);
1322 case OMP_CLAUSE_DEPEND
:
1323 val
= OMP_CLAUSE_DEPEND_KIND (t
);
1325 case OMP_CLAUSE_MAP
:
1326 val
= OMP_CLAUSE_MAP_KIND (t
);
1328 case OMP_CLAUSE_PROC_BIND
:
1329 val
= OMP_CLAUSE_PROC_BIND_KIND (t
);
1331 case OMP_CLAUSE_REDUCTION
:
1332 val
= OMP_CLAUSE_REDUCTION_CODE (t
);
1338 hstate
.add_wide_int (val
);
1339 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (t
)]; i
++)
1340 visit (OMP_CLAUSE_OPERAND (t
, i
));
1341 visit (OMP_CLAUSE_CHAIN (t
));
1344 return hstate
.end ();
1349 /* Compare two SCC entries by their hash value for qsorting them. */
1352 DFS::scc_entry_compare (const void *p1_
, const void *p2_
)
1354 const scc_entry
*p1
= (const scc_entry
*) p1_
;
1355 const scc_entry
*p2
= (const scc_entry
*) p2_
;
1356 if (p1
->hash
< p2
->hash
)
1358 else if (p1
->hash
> p2
->hash
)
1363 /* Return a hash value for the SCC on the SCC stack from FIRST with SIZE.
1364 THIS_REF_P and REF_P are as passed to lto_output_tree for FIRST. */
1367 DFS::hash_scc (struct output_block
*ob
, unsigned first
, unsigned size
,
1368 bool ref_p
, bool this_ref_p
)
1370 unsigned int last_classes
= 0, iterations
= 0;
1372 /* Compute hash values for the SCC members. */
1373 for (unsigned i
= 0; i
< size
; ++i
)
1374 sccstack
[first
+i
].hash
1375 = hash_tree (ob
->writer_cache
, NULL
, sccstack
[first
+i
].t
);
1378 return sccstack
[first
].hash
;
1380 /* We aim to get unique hash for every tree within SCC and compute hash value
1381 of the whole SCC by combining all values together in a stable (entry-point
1382 independent) order. This guarantees that the same SCC regions within
1383 different translation units will get the same hash values and therefore
1384 will be merged at WPA time.
1386 Often the hashes are already unique. In that case we compute the SCC hash
1387 by combining individual hash values in an increasing order.
1389 If there are duplicates, we seek at least one tree with unique hash (and
1390 pick one with minimal hash and this property). Then we obtain a stable
1391 order by DFS walk starting from this unique tree and then use the index
1392 within this order to make individual hash values unique.
1394 If there is no tree with unique hash, we iteratively propagate the hash
1395 values across the internal edges of SCC. This usually quickly leads
1396 to unique hashes. Consider, for example, an SCC containing two pointers
1397 that are identical except for the types they point to and assume that
1398 these types are also part of the SCC. The propagation will add the
1399 points-to type information into their hash values. */
1402 /* Sort the SCC so we can easily check for uniqueness. */
1403 qsort (&sccstack
[first
], size
, sizeof (scc_entry
), scc_entry_compare
);
1405 unsigned int classes
= 1;
1406 int firstunique
= -1;
1408 /* Find the tree with lowest unique hash (if it exists) and compute
1409 the number of equivalence classes. */
1410 if (sccstack
[first
].hash
!= sccstack
[first
+1].hash
)
1412 for (unsigned i
= 1; i
< size
; ++i
)
1413 if (sccstack
[first
+i
-1].hash
!= sccstack
[first
+i
].hash
)
1416 if (firstunique
== -1
1418 || sccstack
[first
+i
+1].hash
!= sccstack
[first
+i
].hash
))
1422 /* If we found a tree with unique hash, stop the iteration. */
1423 if (firstunique
!= -1
1424 /* Also terminate if we run out of iterations or if the number of
1425 equivalence classes is no longer increasing.
1426 For example a cyclic list of trees that are all equivalent will
1427 never have unique entry point; we however do not build such SCCs
1429 || classes
<= last_classes
|| iterations
> 16)
1433 /* If some hashes are not unique (CLASSES != SIZE), use the DFS walk
1434 starting from FIRSTUNIQUE to obtain a stable order. */
1435 if (classes
!= size
&& firstunique
!= -1)
1437 hash_map
<tree
, hashval_t
> map(size
*2);
1439 /* Store hash values into a map, so we can associate them with
1440 the reordered SCC. */
1441 for (unsigned i
= 0; i
< size
; ++i
)
1442 map
.put (sccstack
[first
+i
].t
, sccstack
[first
+i
].hash
);
1444 DFS
again (ob
, sccstack
[first
+firstunique
].t
, ref_p
, this_ref_p
,
1446 gcc_assert (again
.sccstack
.length () == size
);
1448 memcpy (sccstack
.address () + first
,
1449 again
.sccstack
.address (),
1450 sizeof (scc_entry
) * size
);
1452 /* Update hash values of individual members by hashing in the
1453 index within the stable order. This ensures uniqueness.
1454 Also compute the SCC hash by mixing in all hash values in
1455 the stable order we obtained. */
1456 sccstack
[first
].hash
= *map
.get (sccstack
[first
].t
);
1457 scc_hash
= sccstack
[first
].hash
;
1458 for (unsigned i
= 1; i
< size
; ++i
)
1460 sccstack
[first
+i
].hash
1461 = iterative_hash_hashval_t (i
,
1462 *map
.get (sccstack
[first
+i
].t
));
1464 = iterative_hash_hashval_t (scc_hash
,
1465 sccstack
[first
+i
].hash
);
1468 /* If we got a unique hash value for each tree, then sort already
1469 ensured entry-point independent order. Only compute the final
1472 If we failed to find the unique entry point, we go by the same
1473 route. We will eventually introduce unwanted hash conflicts. */
1476 scc_hash
= sccstack
[first
].hash
;
1477 for (unsigned i
= 1; i
< size
; ++i
)
1479 = iterative_hash_hashval_t (scc_hash
, sccstack
[first
+i
].hash
);
1481 /* We cannot 100% guarantee that the hash won't conflict so as
1482 to make it impossible to find a unique hash. This however
1483 should be an extremely rare case. ICE for now so possible
1484 issues are found and evaluated. */
1485 gcc_checking_assert (classes
== size
);
1488 /* To avoid conflicts across SCCs, iteratively hash the whole SCC
1489 hash into the hash of each element. */
1490 for (unsigned i
= 0; i
< size
; ++i
)
1491 sccstack
[first
+i
].hash
1492 = iterative_hash_hashval_t (sccstack
[first
+i
].hash
, scc_hash
);
1496 last_classes
= classes
;
1499 /* We failed to identify the entry point; propagate hash values across
1501 hash_map
<tree
, hashval_t
> map(size
*2);
1503 for (unsigned i
= 0; i
< size
; ++i
)
1504 map
.put (sccstack
[first
+i
].t
, sccstack
[first
+i
].hash
);
1506 for (unsigned i
= 0; i
< size
; i
++)
1507 sccstack
[first
+i
].hash
1508 = hash_tree (ob
->writer_cache
, &map
, sccstack
[first
+i
].t
);
1513 /* DFS walk EXPR and stream SCCs of tree bodies if they are not
1514 already in the streamer cache. Main routine called for
1515 each visit of EXPR. */
1518 DFS::DFS_write_tree (struct output_block
*ob
, sccs
*from_state
,
1519 tree expr
, bool ref_p
, bool this_ref_p
)
1521 /* Handle special cases. */
1522 if (expr
== NULL_TREE
)
1525 /* Do not DFS walk into indexable trees. */
1526 if (this_ref_p
&& tree_is_indexable (expr
))
1529 /* Check if we already streamed EXPR. */
1530 if (streamer_tree_cache_lookup (ob
->writer_cache
, expr
, NULL
))
1535 w
.from_state
= from_state
;
1538 w
.this_ref_p
= this_ref_p
;
1539 worklist_vec
.safe_push (w
);
1543 /* Emit the physical representation of tree node EXPR to output block OB.
1544 If THIS_REF_P is true, the leaves of EXPR are emitted as references via
1545 lto_output_tree_ref. REF_P is used for streaming siblings of EXPR. */
1548 lto_output_tree (struct output_block
*ob
, tree expr
,
1549 bool ref_p
, bool this_ref_p
)
1554 if (expr
== NULL_TREE
)
1556 streamer_write_record_start (ob
, LTO_null
);
1560 if (this_ref_p
&& tree_is_indexable (expr
))
1562 lto_output_tree_ref (ob
, expr
);
1566 existed_p
= streamer_tree_cache_lookup (ob
->writer_cache
, expr
, &ix
);
1569 /* If a node has already been streamed out, make sure that
1570 we don't write it more than once. Otherwise, the reader
1571 will instantiate two different nodes for the same object. */
1572 streamer_write_record_start (ob
, LTO_tree_pickle_reference
);
1573 streamer_write_uhwi (ob
, ix
);
1574 streamer_write_enum (ob
->main_stream
, LTO_tags
, LTO_NUM_TAGS
,
1575 lto_tree_code_to_tag (TREE_CODE (expr
)));
1576 lto_stats
.num_pickle_refs_output
++;
1580 /* This is the first time we see EXPR, write all reachable
1582 static bool in_dfs_walk
;
1584 /* Protect against recursion which means disconnect between
1585 what tree edges we walk in the DFS walk and what edges
1587 gcc_assert (!in_dfs_walk
);
1589 /* Start the DFS walk. */
1590 /* Save ob state ... */
1593 DFS (ob
, expr
, ref_p
, this_ref_p
, false);
1594 in_dfs_walk
= false;
1596 /* Finally append a reference to the tree we were writing.
1597 ??? If expr ended up as a singleton we could have
1598 inlined it here and avoid outputting a reference. */
1599 existed_p
= streamer_tree_cache_lookup (ob
->writer_cache
, expr
, &ix
);
1600 gcc_assert (existed_p
);
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
++;
1610 /* Output to OB a list of try/catch handlers starting with FIRST. */
1613 output_eh_try_list (struct output_block
*ob
, eh_catch first
)
1617 for (n
= first
; n
; n
= n
->next_catch
)
1619 streamer_write_record_start (ob
, LTO_eh_catch
);
1620 stream_write_tree (ob
, n
->type_list
, true);
1621 stream_write_tree (ob
, n
->filter_list
, true);
1622 stream_write_tree (ob
, n
->label
, true);
1625 streamer_write_record_start (ob
, LTO_null
);
1629 /* Output EH region R in function FN to OB. CURR_RN is the slot index
1630 that is being emitted in FN->EH->REGION_ARRAY. This is used to
1631 detect EH region sharing. */
1634 output_eh_region (struct output_block
*ob
, eh_region r
)
1640 streamer_write_record_start (ob
, LTO_null
);
1644 if (r
->type
== ERT_CLEANUP
)
1645 tag
= LTO_ert_cleanup
;
1646 else if (r
->type
== ERT_TRY
)
1648 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
1649 tag
= LTO_ert_allowed_exceptions
;
1650 else if (r
->type
== ERT_MUST_NOT_THROW
)
1651 tag
= LTO_ert_must_not_throw
;
1655 streamer_write_record_start (ob
, tag
);
1656 streamer_write_hwi (ob
, r
->index
);
1659 streamer_write_hwi (ob
, r
->outer
->index
);
1661 streamer_write_zero (ob
);
1664 streamer_write_hwi (ob
, r
->inner
->index
);
1666 streamer_write_zero (ob
);
1669 streamer_write_hwi (ob
, r
->next_peer
->index
);
1671 streamer_write_zero (ob
);
1673 if (r
->type
== ERT_TRY
)
1675 output_eh_try_list (ob
, r
->u
.eh_try
.first_catch
);
1677 else if (r
->type
== ERT_ALLOWED_EXCEPTIONS
)
1679 stream_write_tree (ob
, r
->u
.allowed
.type_list
, true);
1680 stream_write_tree (ob
, r
->u
.allowed
.label
, true);
1681 streamer_write_uhwi (ob
, r
->u
.allowed
.filter
);
1683 else if (r
->type
== ERT_MUST_NOT_THROW
)
1685 stream_write_tree (ob
, r
->u
.must_not_throw
.failure_decl
, true);
1686 bitpack_d bp
= bitpack_create (ob
->main_stream
);
1687 stream_output_location (ob
, &bp
, r
->u
.must_not_throw
.failure_loc
);
1688 streamer_write_bitpack (&bp
);
1691 if (r
->landing_pads
)
1692 streamer_write_hwi (ob
, r
->landing_pads
->index
);
1694 streamer_write_zero (ob
);
1698 /* Output landing pad LP to OB. */
1701 output_eh_lp (struct output_block
*ob
, eh_landing_pad lp
)
1705 streamer_write_record_start (ob
, LTO_null
);
1709 streamer_write_record_start (ob
, LTO_eh_landing_pad
);
1710 streamer_write_hwi (ob
, lp
->index
);
1712 streamer_write_hwi (ob
, lp
->next_lp
->index
);
1714 streamer_write_zero (ob
);
1717 streamer_write_hwi (ob
, lp
->region
->index
);
1719 streamer_write_zero (ob
);
1721 stream_write_tree (ob
, lp
->post_landing_pad
, true);
1725 /* Output the existing eh_table to OB. */
1728 output_eh_regions (struct output_block
*ob
, struct function
*fn
)
1730 if (fn
->eh
&& fn
->eh
->region_tree
)
1737 streamer_write_record_start (ob
, LTO_eh_table
);
1739 /* Emit the index of the root of the EH region tree. */
1740 streamer_write_hwi (ob
, fn
->eh
->region_tree
->index
);
1742 /* Emit all the EH regions in the region array. */
1743 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->region_array
));
1744 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->region_array
, i
, eh
)
1745 output_eh_region (ob
, eh
);
1747 /* Emit all landing pads. */
1748 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->lp_array
));
1749 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->lp_array
, i
, lp
)
1750 output_eh_lp (ob
, lp
);
1752 /* Emit all the runtime type data. */
1753 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->ttype_data
));
1754 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->ttype_data
, i
, ttype
)
1755 stream_write_tree (ob
, ttype
, true);
1757 /* Emit the table of action chains. */
1758 if (targetm
.arm_eabi_unwinder
)
1761 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->ehspec_data
.arm_eabi
));
1762 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->ehspec_data
.arm_eabi
, i
, t
)
1763 stream_write_tree (ob
, t
, true);
1768 streamer_write_hwi (ob
, vec_safe_length (fn
->eh
->ehspec_data
.other
));
1769 FOR_EACH_VEC_SAFE_ELT (fn
->eh
->ehspec_data
.other
, i
, c
)
1770 streamer_write_char_stream (ob
->main_stream
, c
);
1774 /* The LTO_null either terminates the record or indicates that there
1775 are no eh_records at all. */
1776 streamer_write_record_start (ob
, LTO_null
);
1780 /* Output all of the active ssa names to the ssa_names stream. */
1783 output_ssa_names (struct output_block
*ob
, struct function
*fn
)
1785 unsigned int i
, len
;
1787 len
= vec_safe_length (SSANAMES (fn
));
1788 streamer_write_uhwi (ob
, len
);
1790 for (i
= 1; i
< len
; i
++)
1792 tree ptr
= (*SSANAMES (fn
))[i
];
1794 if (ptr
== NULL_TREE
1795 || SSA_NAME_IN_FREE_LIST (ptr
)
1796 || virtual_operand_p (ptr
))
1799 streamer_write_uhwi (ob
, i
);
1800 streamer_write_char_stream (ob
->main_stream
,
1801 SSA_NAME_IS_DEFAULT_DEF (ptr
));
1802 if (SSA_NAME_VAR (ptr
))
1803 stream_write_tree (ob
, SSA_NAME_VAR (ptr
), true);
1805 /* ??? This drops SSA_NAME_IDENTIFIER on the floor. */
1806 stream_write_tree (ob
, TREE_TYPE (ptr
), true);
1809 streamer_write_zero (ob
);
1813 /* Output a wide-int. */
1816 streamer_write_wi (struct output_block
*ob
,
1817 const widest_int
&w
)
1819 int len
= w
.get_len ();
1821 streamer_write_uhwi (ob
, w
.get_precision ());
1822 streamer_write_uhwi (ob
, len
);
1823 for (int i
= 0; i
< len
; i
++)
1824 streamer_write_hwi (ob
, w
.elt (i
));
1828 /* Output the cfg. */
1831 output_cfg (struct output_block
*ob
, struct function
*fn
)
1833 struct lto_output_stream
*tmp_stream
= ob
->main_stream
;
1836 ob
->main_stream
= ob
->cfg_stream
;
1838 streamer_write_enum (ob
->main_stream
, profile_status_d
, PROFILE_LAST
,
1839 profile_status_for_fn (fn
));
1841 /* Output the number of the highest basic block. */
1842 streamer_write_uhwi (ob
, last_basic_block_for_fn (fn
));
1844 FOR_ALL_BB_FN (bb
, fn
)
1849 streamer_write_hwi (ob
, bb
->index
);
1851 /* Output the successors and the edge flags. */
1852 streamer_write_uhwi (ob
, EDGE_COUNT (bb
->succs
));
1853 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1855 streamer_write_uhwi (ob
, e
->dest
->index
);
1856 streamer_write_hwi (ob
, e
->probability
);
1857 streamer_write_gcov_count (ob
, e
->count
);
1858 streamer_write_uhwi (ob
, e
->flags
);
1862 streamer_write_hwi (ob
, -1);
1864 bb
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
1867 streamer_write_hwi (ob
, bb
->next_bb
->index
);
1871 streamer_write_hwi (ob
, -1);
1873 /* ??? The cfgloop interface is tied to cfun. */
1874 gcc_assert (cfun
== fn
);
1876 /* Output the number of loops. */
1877 streamer_write_uhwi (ob
, number_of_loops (fn
));
1879 /* Output each loop, skipping the tree root which has number zero. */
1880 for (unsigned i
= 1; i
< number_of_loops (fn
); ++i
)
1882 struct loop
*loop
= get_loop (fn
, i
);
1884 /* Write the index of the loop header. That's enough to rebuild
1885 the loop tree on the reader side. Stream -1 for an unused
1889 streamer_write_hwi (ob
, -1);
1893 streamer_write_hwi (ob
, loop
->header
->index
);
1895 /* Write everything copy_loop_info copies. */
1896 streamer_write_enum (ob
->main_stream
,
1897 loop_estimation
, EST_LAST
, loop
->estimate_state
);
1898 streamer_write_hwi (ob
, loop
->any_upper_bound
);
1899 if (loop
->any_upper_bound
)
1900 streamer_write_wi (ob
, loop
->nb_iterations_upper_bound
);
1901 streamer_write_hwi (ob
, loop
->any_estimate
);
1902 if (loop
->any_estimate
)
1903 streamer_write_wi (ob
, loop
->nb_iterations_estimate
);
1905 /* Write OMP SIMD related info. */
1906 streamer_write_hwi (ob
, loop
->safelen
);
1907 streamer_write_hwi (ob
, loop
->dont_vectorize
);
1908 streamer_write_hwi (ob
, loop
->force_vectorize
);
1909 stream_write_tree (ob
, loop
->simduid
, true);
1912 ob
->main_stream
= tmp_stream
;
1916 /* Create the header in the file using OB. If the section type is for
1917 a function, set FN to the decl for that function. */
1920 produce_asm (struct output_block
*ob
, tree fn
)
1922 enum lto_section_type section_type
= ob
->section_type
;
1923 struct lto_function_header header
;
1926 if (section_type
== LTO_section_function_body
)
1928 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn
));
1929 section_name
= lto_get_section_name (section_type
, name
, NULL
);
1932 section_name
= lto_get_section_name (section_type
, NULL
, NULL
);
1934 lto_begin_section (section_name
, !flag_wpa
);
1935 free (section_name
);
1937 /* The entire header is stream computed here. */
1938 memset (&header
, 0, sizeof (struct lto_function_header
));
1940 /* Write the header. */
1941 header
.major_version
= LTO_major_version
;
1942 header
.minor_version
= LTO_minor_version
;
1944 if (section_type
== LTO_section_function_body
)
1945 header
.cfg_size
= ob
->cfg_stream
->total_size
;
1946 header
.main_size
= ob
->main_stream
->total_size
;
1947 header
.string_size
= ob
->string_stream
->total_size
;
1948 lto_write_data (&header
, sizeof header
);
1950 /* Put all of the gimple and the string table out the asm file as a
1952 if (section_type
== LTO_section_function_body
)
1953 lto_write_stream (ob
->cfg_stream
);
1954 lto_write_stream (ob
->main_stream
);
1955 lto_write_stream (ob
->string_stream
);
1961 /* Output the base body of struct function FN using output block OB. */
1964 output_struct_function_base (struct output_block
*ob
, struct function
*fn
)
1966 struct bitpack_d bp
;
1970 /* Output the static chain and non-local goto save area. */
1971 stream_write_tree (ob
, fn
->static_chain_decl
, true);
1972 stream_write_tree (ob
, fn
->nonlocal_goto_save_area
, true);
1974 /* Output all the local variables in the function. */
1975 streamer_write_hwi (ob
, vec_safe_length (fn
->local_decls
));
1976 FOR_EACH_VEC_SAFE_ELT (fn
->local_decls
, i
, t
)
1977 stream_write_tree (ob
, t
, true);
1979 /* Output current IL state of the function. */
1980 streamer_write_uhwi (ob
, fn
->curr_properties
);
1982 /* Write all the attributes for FN. */
1983 bp
= bitpack_create (ob
->main_stream
);
1984 bp_pack_value (&bp
, fn
->is_thunk
, 1);
1985 bp_pack_value (&bp
, fn
->has_local_explicit_reg_vars
, 1);
1986 bp_pack_value (&bp
, fn
->returns_pcc_struct
, 1);
1987 bp_pack_value (&bp
, fn
->returns_struct
, 1);
1988 bp_pack_value (&bp
, fn
->can_throw_non_call_exceptions
, 1);
1989 bp_pack_value (&bp
, fn
->can_delete_dead_exceptions
, 1);
1990 bp_pack_value (&bp
, fn
->always_inline_functions_inlined
, 1);
1991 bp_pack_value (&bp
, fn
->after_inlining
, 1);
1992 bp_pack_value (&bp
, fn
->stdarg
, 1);
1993 bp_pack_value (&bp
, fn
->has_nonlocal_label
, 1);
1994 bp_pack_value (&bp
, fn
->calls_alloca
, 1);
1995 bp_pack_value (&bp
, fn
->calls_setjmp
, 1);
1996 bp_pack_value (&bp
, fn
->has_force_vectorize_loops
, 1);
1997 bp_pack_value (&bp
, fn
->has_simduid_loops
, 1);
1998 bp_pack_value (&bp
, fn
->va_list_fpr_size
, 8);
1999 bp_pack_value (&bp
, fn
->va_list_gpr_size
, 8);
2000 bp_pack_value (&bp
, fn
->last_clique
, sizeof (short) * 8);
2002 /* Output the function start and end loci. */
2003 stream_output_location (ob
, &bp
, fn
->function_start_locus
);
2004 stream_output_location (ob
, &bp
, fn
->function_end_locus
);
2006 streamer_write_bitpack (&bp
);
2010 /* Output the body of function NODE->DECL. */
2013 output_function (struct cgraph_node
*node
)
2016 struct function
*fn
;
2018 struct output_block
*ob
;
2020 function
= node
->decl
;
2021 fn
= DECL_STRUCT_FUNCTION (function
);
2022 ob
= create_output_block (LTO_section_function_body
);
2024 clear_line_info (ob
);
2027 gcc_assert (current_function_decl
== NULL_TREE
&& cfun
== NULL
);
2029 /* Set current_function_decl and cfun. */
2032 /* Make string 0 be a NULL string. */
2033 streamer_write_char_stream (ob
->string_stream
, 0);
2035 streamer_write_record_start (ob
, LTO_function
);
2037 /* Output decls for parameters and args. */
2038 stream_write_tree (ob
, DECL_RESULT (function
), true);
2039 streamer_write_chain (ob
, DECL_ARGUMENTS (function
), true);
2041 /* Output DECL_INITIAL for the function, which contains the tree of
2043 stream_write_tree (ob
, DECL_INITIAL (function
), true);
2045 /* We also stream abstract functions where we stream only stuff needed for
2047 if (gimple_has_body_p (function
))
2049 streamer_write_uhwi (ob
, 1);
2050 output_struct_function_base (ob
, fn
);
2052 /* Output all the SSA names used in the function. */
2053 output_ssa_names (ob
, fn
);
2055 /* Output any exception handling regions. */
2056 output_eh_regions (ob
, fn
);
2059 /* We will renumber the statements. The code that does this uses
2060 the same ordering that we use for serializing them so we can use
2061 the same code on the other end and not have to write out the
2062 statement numbers. We do not assign UIDs to PHIs here because
2063 virtual PHIs get re-computed on-the-fly which would make numbers
2065 set_gimple_stmt_max_uid (cfun
, 0);
2066 FOR_ALL_BB_FN (bb
, cfun
)
2068 for (gphi_iterator gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
);
2071 gphi
*stmt
= gsi
.phi ();
2073 /* Virtual PHIs are not going to be streamed. */
2074 if (!virtual_operand_p (gimple_phi_result (stmt
)))
2075 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
2077 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);
2080 gimple
*stmt
= gsi_stmt (gsi
);
2081 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
2084 /* To avoid keeping duplicate gimple IDs in the statements, renumber
2085 virtual phis now. */
2086 FOR_ALL_BB_FN (bb
, cfun
)
2088 for (gphi_iterator gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
);
2091 gphi
*stmt
= gsi
.phi ();
2092 if (virtual_operand_p (gimple_phi_result (stmt
)))
2093 gimple_set_uid (stmt
, inc_gimple_stmt_max_uid (cfun
));
2097 /* Output the code for the function. */
2098 FOR_ALL_BB_FN (bb
, fn
)
2099 output_bb (ob
, bb
, fn
);
2101 /* The terminator for this function. */
2102 streamer_write_record_start (ob
, LTO_null
);
2104 output_cfg (ob
, fn
);
2109 streamer_write_uhwi (ob
, 0);
2111 /* Create a section to hold the pickled output of this function. */
2112 produce_asm (ob
, function
);
2114 destroy_output_block (ob
);
2117 /* Output the body of function NODE->DECL. */
2120 output_constructor (struct varpool_node
*node
)
2122 tree var
= node
->decl
;
2123 struct output_block
*ob
;
2125 ob
= create_output_block (LTO_section_function_body
);
2127 clear_line_info (ob
);
2130 /* Make string 0 be a NULL string. */
2131 streamer_write_char_stream (ob
->string_stream
, 0);
2133 /* Output DECL_INITIAL for the function, which contains the tree of
2135 stream_write_tree (ob
, DECL_INITIAL (var
), true);
2137 /* Create a section to hold the pickled output of this function. */
2138 produce_asm (ob
, var
);
2140 destroy_output_block (ob
);
2144 /* Emit toplevel asms. */
2147 lto_output_toplevel_asms (void)
2149 struct output_block
*ob
;
2150 struct asm_node
*can
;
2152 struct lto_simple_header_with_strings header
;
2154 if (!symtab
->first_asm_symbol ())
2157 ob
= create_output_block (LTO_section_asm
);
2159 /* Make string 0 be a NULL string. */
2160 streamer_write_char_stream (ob
->string_stream
, 0);
2162 for (can
= symtab
->first_asm_symbol (); can
; can
= can
->next
)
2164 streamer_write_string_cst (ob
, ob
->main_stream
, can
->asm_str
);
2165 streamer_write_hwi (ob
, can
->order
);
2168 streamer_write_string_cst (ob
, ob
->main_stream
, NULL_TREE
);
2170 section_name
= lto_get_section_name (LTO_section_asm
, NULL
, NULL
);
2171 lto_begin_section (section_name
, !flag_wpa
);
2172 free (section_name
);
2174 /* The entire header stream is computed here. */
2175 memset (&header
, 0, sizeof (header
));
2177 /* Write the header. */
2178 header
.major_version
= LTO_major_version
;
2179 header
.minor_version
= LTO_minor_version
;
2181 header
.main_size
= ob
->main_stream
->total_size
;
2182 header
.string_size
= ob
->string_stream
->total_size
;
2183 lto_write_data (&header
, sizeof header
);
2185 /* Put all of the gimple and the string table out the asm file as a
2187 lto_write_stream (ob
->main_stream
);
2188 lto_write_stream (ob
->string_stream
);
2192 destroy_output_block (ob
);
2196 /* Copy the function body or variable constructor of NODE without deserializing. */
2199 copy_function_or_variable (struct symtab_node
*node
)
2201 tree function
= node
->decl
;
2202 struct lto_file_decl_data
*file_data
= node
->lto_file_data
;
2205 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function
));
2206 char *section_name
=
2207 lto_get_section_name (LTO_section_function_body
, name
, NULL
);
2209 struct lto_in_decl_state
*in_state
;
2210 struct lto_out_decl_state
*out_state
= lto_get_out_decl_state ();
2212 lto_begin_section (section_name
, !flag_wpa
);
2213 free (section_name
);
2215 /* We may have renamed the declaration, e.g., a static function. */
2216 name
= lto_get_decl_name_mapping (file_data
, name
);
2218 data
= lto_get_section_data (file_data
, LTO_section_function_body
,
2222 /* Do a bit copy of the function body. */
2223 lto_write_data (data
, len
);
2227 lto_get_function_in_decl_state (node
->lto_file_data
, function
);
2228 gcc_assert (in_state
);
2230 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2232 size_t n
= vec_safe_length (in_state
->streams
[i
]);
2233 vec
<tree
, va_gc
> *trees
= in_state
->streams
[i
];
2234 struct lto_tree_ref_encoder
*encoder
= &(out_state
->streams
[i
]);
2236 /* The out state must have the same indices and the in state.
2237 So just copy the vector. All the encoders in the in state
2238 must be empty where we reach here. */
2239 gcc_assert (lto_tree_ref_encoder_size (encoder
) == 0);
2240 encoder
->trees
.reserve_exact (n
);
2241 for (j
= 0; j
< n
; j
++)
2242 encoder
->trees
.safe_push ((*trees
)[j
]);
2245 lto_free_section_data (file_data
, LTO_section_function_body
, name
,
2250 /* Wrap symbol references in *TP inside a type-preserving MEM_REF. */
2253 wrap_refs (tree
*tp
, int *ws
, void *)
2256 if (handled_component_p (t
)
2257 && TREE_CODE (TREE_OPERAND (t
, 0)) == VAR_DECL
)
2259 tree decl
= TREE_OPERAND (t
, 0);
2260 tree ptrtype
= build_pointer_type (TREE_TYPE (decl
));
2261 TREE_OPERAND (t
, 0) = build2 (MEM_REF
, TREE_TYPE (decl
),
2262 build1 (ADDR_EXPR
, ptrtype
, decl
),
2263 build_int_cst (ptrtype
, 0));
2264 TREE_THIS_VOLATILE (TREE_OPERAND (t
, 0)) = TREE_THIS_VOLATILE (decl
);
2267 else if (TREE_CODE (t
) == CONSTRUCTOR
)
2269 else if (!EXPR_P (t
))
2274 /* Main entry point from the pass manager. */
2279 struct lto_out_decl_state
*decl_state
;
2280 #ifdef ENABLE_CHECKING
2281 bitmap output
= lto_bitmap_alloc ();
2284 lto_symtab_encoder_t encoder
= lto_get_out_decl_state ()->symtab_node_encoder
;
2286 /* Initialize the streamer. */
2287 lto_streamer_init ();
2289 n_nodes
= lto_symtab_encoder_size (encoder
);
2290 /* Process only the functions with bodies. */
2291 for (i
= 0; i
< n_nodes
; i
++)
2293 symtab_node
*snode
= lto_symtab_encoder_deref (encoder
, i
);
2294 if (cgraph_node
*node
= dyn_cast
<cgraph_node
*> (snode
))
2296 if (lto_symtab_encoder_encode_body_p (encoder
, node
)
2299 #ifdef ENABLE_CHECKING
2300 gcc_assert (!bitmap_bit_p (output
, DECL_UID (node
->decl
)));
2301 bitmap_set_bit (output
, DECL_UID (node
->decl
));
2303 decl_state
= lto_new_out_decl_state ();
2304 lto_push_out_decl_state (decl_state
);
2305 if (gimple_has_body_p (node
->decl
) || !flag_wpa
2306 /* Thunks have no body but they may be synthetized
2308 || DECL_ARGUMENTS (node
->decl
))
2309 output_function (node
);
2311 copy_function_or_variable (node
);
2312 gcc_assert (lto_get_out_decl_state () == decl_state
);
2313 lto_pop_out_decl_state ();
2314 lto_record_function_out_decl_state (node
->decl
, decl_state
);
2317 else if (varpool_node
*node
= dyn_cast
<varpool_node
*> (snode
))
2319 /* Wrap symbol references inside the ctor in a type
2320 preserving MEM_REF. */
2321 tree ctor
= DECL_INITIAL (node
->decl
);
2322 if (ctor
&& !in_lto_p
)
2323 walk_tree (&ctor
, wrap_refs
, NULL
, NULL
);
2324 if (get_symbol_initial_value (encoder
, node
->decl
) == error_mark_node
2325 && lto_symtab_encoder_encode_initializer_p (encoder
, node
)
2328 timevar_push (TV_IPA_LTO_CTORS_OUT
);
2329 #ifdef ENABLE_CHECKING
2330 gcc_assert (!bitmap_bit_p (output
, DECL_UID (node
->decl
)));
2331 bitmap_set_bit (output
, DECL_UID (node
->decl
));
2333 decl_state
= lto_new_out_decl_state ();
2334 lto_push_out_decl_state (decl_state
);
2335 if (DECL_INITIAL (node
->decl
) != error_mark_node
2337 output_constructor (node
);
2339 copy_function_or_variable (node
);
2340 gcc_assert (lto_get_out_decl_state () == decl_state
);
2341 lto_pop_out_decl_state ();
2342 lto_record_function_out_decl_state (node
->decl
, decl_state
);
2343 timevar_pop (TV_IPA_LTO_CTORS_OUT
);
2348 /* Emit the callgraph after emitting function bodies. This needs to
2349 be done now to make sure that all the statements in every function
2350 have been renumbered so that edges can be associated with call
2351 statements using the statement UIDs. */
2354 output_offload_tables ();
2356 #ifdef ENABLE_CHECKING
2357 lto_bitmap_free (output
);
2361 /* Write each node in encoded by ENCODER to OB, as well as those reachable
2362 from it and required for correct representation of its semantics.
2363 Each node in ENCODER must be a global declaration or a type. A node
2364 is written only once, even if it appears multiple times in the
2365 vector. Certain transitively-reachable nodes, such as those
2366 representing expressions, may be duplicated, but such nodes
2367 must not appear in ENCODER itself. */
2370 write_global_stream (struct output_block
*ob
,
2371 struct lto_tree_ref_encoder
*encoder
)
2375 const size_t size
= lto_tree_ref_encoder_size (encoder
);
2377 for (index
= 0; index
< size
; index
++)
2379 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2380 if (!streamer_tree_cache_lookup (ob
->writer_cache
, t
, NULL
))
2381 stream_write_tree (ob
, t
, false);
2386 /* Write a sequence of indices into the globals vector corresponding
2387 to the trees in ENCODER. These are used by the reader to map the
2388 indices used to refer to global entities within function bodies to
2392 write_global_references (struct output_block
*ob
,
2393 struct lto_tree_ref_encoder
*encoder
)
2397 const uint32_t size
= lto_tree_ref_encoder_size (encoder
);
2399 /* Write size and slot indexes as 32-bit unsigned numbers. */
2400 uint32_t *data
= XNEWVEC (uint32_t, size
+ 1);
2403 for (index
= 0; index
< size
; index
++)
2407 t
= lto_tree_ref_encoder_get_tree (encoder
, index
);
2408 streamer_tree_cache_lookup (ob
->writer_cache
, t
, &slot_num
);
2409 gcc_assert (slot_num
!= (unsigned)-1);
2410 data
[index
+ 1] = slot_num
;
2413 lto_write_data (data
, sizeof (int32_t) * (size
+ 1));
2418 /* Write all the streams in an lto_out_decl_state STATE using
2419 output block OB and output stream OUT_STREAM. */
2422 lto_output_decl_state_streams (struct output_block
*ob
,
2423 struct lto_out_decl_state
*state
)
2427 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2428 write_global_stream (ob
, &state
->streams
[i
]);
2432 /* Write all the references in an lto_out_decl_state STATE using
2433 output block OB and output stream OUT_STREAM. */
2436 lto_output_decl_state_refs (struct output_block
*ob
,
2437 struct lto_out_decl_state
*state
)
2443 /* Write reference to FUNCTION_DECL. If there is not function,
2444 write reference to void_type_node. */
2445 decl
= (state
->fn_decl
) ? state
->fn_decl
: void_type_node
;
2446 streamer_tree_cache_lookup (ob
->writer_cache
, decl
, &ref
);
2447 gcc_assert (ref
!= (unsigned)-1);
2448 lto_write_data (&ref
, sizeof (uint32_t));
2450 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2451 write_global_references (ob
, &state
->streams
[i
]);
2455 /* Return the written size of STATE. */
2458 lto_out_decl_state_written_size (struct lto_out_decl_state
*state
)
2463 size
= sizeof (int32_t); /* fn_ref. */
2464 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2466 size
+= sizeof (int32_t); /* vector size. */
2467 size
+= (lto_tree_ref_encoder_size (&state
->streams
[i
])
2468 * sizeof (int32_t));
2474 /* Write symbol T into STREAM in CACHE. SEEN specifies symbols we wrote
2478 write_symbol (struct streamer_tree_cache_d
*cache
,
2479 tree t
, hash_set
<const char *> *seen
, bool alias
)
2482 enum gcc_plugin_symbol_kind kind
;
2483 enum gcc_plugin_symbol_visibility visibility
= GCCPV_DEFAULT
;
2489 /* None of the following kinds of symbols are needed in the
2491 if (!TREE_PUBLIC (t
)
2492 || is_builtin_fn (t
)
2493 || DECL_ABSTRACT_P (t
)
2494 || (TREE_CODE (t
) == VAR_DECL
&& DECL_HARD_REGISTER (t
)))
2496 gcc_assert (TREE_CODE (t
) != RESULT_DECL
);
2498 gcc_assert (TREE_CODE (t
) == VAR_DECL
2499 || TREE_CODE (t
) == FUNCTION_DECL
);
2501 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t
));
2503 /* This behaves like assemble_name_raw in varasm.c, performing the
2504 same name manipulations that ASM_OUTPUT_LABELREF does. */
2505 name
= IDENTIFIER_POINTER ((*targetm
.asm_out
.mangle_assembler_name
) (name
));
2507 if (seen
->add (name
))
2510 streamer_tree_cache_lookup (cache
, t
, &slot_num
);
2511 gcc_assert (slot_num
!= (unsigned)-1);
2513 if (DECL_EXTERNAL (t
))
2516 kind
= GCCPK_WEAKUNDEF
;
2523 kind
= GCCPK_WEAKDEF
;
2524 else if (DECL_COMMON (t
))
2525 kind
= GCCPK_COMMON
;
2529 /* When something is defined, it should have node attached. */
2530 gcc_assert (alias
|| TREE_CODE (t
) != VAR_DECL
2531 || varpool_node::get (t
)->definition
);
2532 gcc_assert (alias
|| TREE_CODE (t
) != FUNCTION_DECL
2533 || (cgraph_node::get (t
)
2534 && cgraph_node::get (t
)->definition
));
2537 /* Imitate what default_elf_asm_output_external do.
2538 When symbol is external, we need to output it with DEFAULT visibility
2539 when compiling with -fvisibility=default, while with HIDDEN visibility
2540 when symbol has attribute (visibility("hidden")) specified.
2541 targetm.binds_local_p check DECL_VISIBILITY_SPECIFIED and gets this
2544 if (DECL_EXTERNAL (t
)
2545 && !targetm
.binds_local_p (t
))
2546 visibility
= GCCPV_DEFAULT
;
2548 switch (DECL_VISIBILITY (t
))
2550 case VISIBILITY_DEFAULT
:
2551 visibility
= GCCPV_DEFAULT
;
2553 case VISIBILITY_PROTECTED
:
2554 visibility
= GCCPV_PROTECTED
;
2556 case VISIBILITY_HIDDEN
:
2557 visibility
= GCCPV_HIDDEN
;
2559 case VISIBILITY_INTERNAL
:
2560 visibility
= GCCPV_INTERNAL
;
2564 if (kind
== GCCPK_COMMON
2565 && DECL_SIZE_UNIT (t
)
2566 && TREE_CODE (DECL_SIZE_UNIT (t
)) == INTEGER_CST
)
2567 size
= TREE_INT_CST_LOW (DECL_SIZE_UNIT (t
));
2571 if (DECL_ONE_ONLY (t
))
2572 comdat
= IDENTIFIER_POINTER (decl_comdat_group_id (t
));
2576 lto_write_data (name
, strlen (name
) + 1);
2577 lto_write_data (comdat
, strlen (comdat
) + 1);
2578 c
= (unsigned char) kind
;
2579 lto_write_data (&c
, 1);
2580 c
= (unsigned char) visibility
;
2581 lto_write_data (&c
, 1);
2582 lto_write_data (&size
, 8);
2583 lto_write_data (&slot_num
, 4);
2586 /* Return true if NODE should appear in the plugin symbol table. */
2589 output_symbol_p (symtab_node
*node
)
2591 struct cgraph_node
*cnode
;
2592 if (!node
->real_symbol_p ())
2594 /* We keep external functions in symtab for sake of inlining
2595 and devirtualization. We do not want to see them in symbol table as
2596 references unless they are really used. */
2597 cnode
= dyn_cast
<cgraph_node
*> (node
);
2598 if (cnode
&& (!node
->definition
|| DECL_EXTERNAL (cnode
->decl
))
2602 /* Ignore all references from external vars initializers - they are not really
2603 part of the compilation unit until they are used by folding. Some symbols,
2604 like references to external construction vtables can not be referred to at all.
2605 We decide this at can_refer_decl_in_current_unit_p. */
2606 if (!node
->definition
|| DECL_EXTERNAL (node
->decl
))
2609 struct ipa_ref
*ref
;
2610 for (i
= 0; node
->iterate_referring (i
, ref
); i
++)
2612 if (ref
->use
== IPA_REF_ALIAS
)
2614 if (is_a
<cgraph_node
*> (ref
->referring
))
2616 if (!DECL_EXTERNAL (ref
->referring
->decl
))
2625 /* Write an IL symbol table to OB.
2626 SET and VSET are cgraph/varpool node sets we are outputting. */
2629 produce_symtab (struct output_block
*ob
)
2631 struct streamer_tree_cache_d
*cache
= ob
->writer_cache
;
2632 char *section_name
= lto_get_section_name (LTO_section_symtab
, NULL
, NULL
);
2633 lto_symtab_encoder_t encoder
= ob
->decl_state
->symtab_node_encoder
;
2634 lto_symtab_encoder_iterator lsei
;
2636 lto_begin_section (section_name
, false);
2637 free (section_name
);
2639 hash_set
<const char *> seen
;
2641 /* Write the symbol table.
2642 First write everything defined and then all declarations.
2643 This is necessary to handle cases where we have duplicated symbols. */
2644 for (lsei
= lsei_start (encoder
);
2645 !lsei_end_p (lsei
); lsei_next (&lsei
))
2647 symtab_node
*node
= lsei_node (lsei
);
2649 if (!output_symbol_p (node
) || DECL_EXTERNAL (node
->decl
))
2651 write_symbol (cache
, node
->decl
, &seen
, false);
2653 for (lsei
= lsei_start (encoder
);
2654 !lsei_end_p (lsei
); lsei_next (&lsei
))
2656 symtab_node
*node
= lsei_node (lsei
);
2658 if (!output_symbol_p (node
) || !DECL_EXTERNAL (node
->decl
))
2660 write_symbol (cache
, node
->decl
, &seen
, false);
2667 /* Init the streamer_mode_table for output, where we collect info on what
2668 machine_mode values have been streamed. */
2670 lto_output_init_mode_table (void)
2672 memset (streamer_mode_table
, '\0', MAX_MACHINE_MODE
);
2676 /* Write the mode table. */
2678 lto_write_mode_table (void)
2680 struct output_block
*ob
;
2681 ob
= create_output_block (LTO_section_mode_table
);
2682 bitpack_d bp
= bitpack_create (ob
->main_stream
);
2684 /* Ensure that for GET_MODE_INNER (m) != m we have
2685 also the inner mode marked. */
2686 for (int i
= 0; i
< (int) MAX_MACHINE_MODE
; i
++)
2687 if (streamer_mode_table
[i
])
2689 machine_mode m
= (machine_mode
) i
;
2690 if (GET_MODE_INNER (m
) != m
)
2691 streamer_mode_table
[(int) GET_MODE_INNER (m
)] = 1;
2693 /* First stream modes that have GET_MODE_INNER (m) == m,
2694 so that we can refer to them afterwards. */
2695 for (int pass
= 0; pass
< 2; pass
++)
2696 for (int i
= 0; i
< (int) MAX_MACHINE_MODE
; i
++)
2697 if (streamer_mode_table
[i
] && i
!= (int) VOIDmode
&& i
!= (int) BLKmode
)
2699 machine_mode m
= (machine_mode
) i
;
2700 if ((GET_MODE_INNER (m
) == m
) ^ (pass
== 0))
2702 bp_pack_value (&bp
, m
, 8);
2703 bp_pack_enum (&bp
, mode_class
, MAX_MODE_CLASS
, GET_MODE_CLASS (m
));
2704 bp_pack_value (&bp
, GET_MODE_SIZE (m
), 8);
2705 bp_pack_value (&bp
, GET_MODE_PRECISION (m
), 16);
2706 bp_pack_value (&bp
, GET_MODE_INNER (m
), 8);
2707 bp_pack_value (&bp
, GET_MODE_NUNITS (m
), 8);
2708 switch (GET_MODE_CLASS (m
))
2714 bp_pack_value (&bp
, GET_MODE_IBIT (m
), 8);
2715 bp_pack_value (&bp
, GET_MODE_FBIT (m
), 8);
2718 case MODE_DECIMAL_FLOAT
:
2719 bp_pack_string (ob
, &bp
, REAL_MODE_FORMAT (m
)->name
, true);
2724 bp_pack_string (ob
, &bp
, GET_MODE_NAME (m
), true);
2726 bp_pack_value (&bp
, VOIDmode
, 8);
2728 streamer_write_bitpack (&bp
);
2731 = lto_get_section_name (LTO_section_mode_table
, NULL
, NULL
);
2732 lto_begin_section (section_name
, !flag_wpa
);
2733 free (section_name
);
2735 /* The entire header stream is computed here. */
2736 struct lto_simple_header_with_strings header
;
2737 memset (&header
, 0, sizeof (header
));
2739 /* Write the header. */
2740 header
.major_version
= LTO_major_version
;
2741 header
.minor_version
= LTO_minor_version
;
2743 header
.main_size
= ob
->main_stream
->total_size
;
2744 header
.string_size
= ob
->string_stream
->total_size
;
2745 lto_write_data (&header
, sizeof header
);
2747 /* Put all of the gimple and the string table out the asm file as a
2749 lto_write_stream (ob
->main_stream
);
2750 lto_write_stream (ob
->string_stream
);
2753 destroy_output_block (ob
);
2757 /* This pass is run after all of the functions are serialized and all
2758 of the IPA passes have written their serialized forms. This pass
2759 causes the vector of all of the global decls and types used from
2760 this file to be written in to a section that can then be read in to
2761 recover these on other side. */
2764 produce_asm_for_decls (void)
2766 struct lto_out_decl_state
*out_state
;
2767 struct lto_out_decl_state
*fn_out_state
;
2768 struct lto_decl_header header
;
2770 struct output_block
*ob
;
2771 unsigned idx
, num_fns
;
2772 size_t decl_state_size
;
2773 int32_t num_decl_states
;
2775 ob
= create_output_block (LTO_section_decls
);
2777 memset (&header
, 0, sizeof (struct lto_decl_header
));
2779 section_name
= lto_get_section_name (LTO_section_decls
, NULL
, NULL
);
2780 lto_begin_section (section_name
, !flag_wpa
);
2781 free (section_name
);
2783 /* Make string 0 be a NULL string. */
2784 streamer_write_char_stream (ob
->string_stream
, 0);
2786 gcc_assert (!alias_pairs
);
2788 /* Get rid of the global decl state hash tables to save some memory. */
2789 out_state
= lto_get_out_decl_state ();
2790 for (int i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
2791 if (out_state
->streams
[i
].tree_hash_table
)
2793 delete out_state
->streams
[i
].tree_hash_table
;
2794 out_state
->streams
[i
].tree_hash_table
= NULL
;
2797 /* Write the global symbols. */
2798 lto_output_decl_state_streams (ob
, out_state
);
2799 num_fns
= lto_function_decl_states
.length ();
2800 for (idx
= 0; idx
< num_fns
; idx
++)
2803 lto_function_decl_states
[idx
];
2804 lto_output_decl_state_streams (ob
, fn_out_state
);
2807 header
.major_version
= LTO_major_version
;
2808 header
.minor_version
= LTO_minor_version
;
2810 /* Currently not used. This field would allow us to preallocate
2811 the globals vector, so that it need not be resized as it is extended. */
2812 header
.num_nodes
= -1;
2814 /* Compute the total size of all decl out states. */
2815 decl_state_size
= sizeof (int32_t);
2816 decl_state_size
+= lto_out_decl_state_written_size (out_state
);
2817 for (idx
= 0; idx
< num_fns
; idx
++)
2820 lto_function_decl_states
[idx
];
2821 decl_state_size
+= lto_out_decl_state_written_size (fn_out_state
);
2823 header
.decl_state_size
= decl_state_size
;
2825 header
.main_size
= ob
->main_stream
->total_size
;
2826 header
.string_size
= ob
->string_stream
->total_size
;
2828 lto_write_data (&header
, sizeof header
);
2830 /* Write the main out-decl state, followed by out-decl states of
2832 num_decl_states
= num_fns
+ 1;
2833 lto_write_data (&num_decl_states
, sizeof (num_decl_states
));
2834 lto_output_decl_state_refs (ob
, out_state
);
2835 for (idx
= 0; idx
< num_fns
; idx
++)
2837 fn_out_state
= lto_function_decl_states
[idx
];
2838 lto_output_decl_state_refs (ob
, fn_out_state
);
2841 lto_write_stream (ob
->main_stream
);
2842 lto_write_stream (ob
->string_stream
);
2846 /* Write the symbol table. It is used by linker to determine dependencies
2847 and thus we can skip it for WPA. */
2849 produce_symtab (ob
);
2851 /* Write command line opts. */
2852 lto_write_options ();
2854 /* Deallocate memory and clean up. */
2855 for (idx
= 0; idx
< num_fns
; idx
++)
2858 lto_function_decl_states
[idx
];
2859 lto_delete_out_decl_state (fn_out_state
);
2861 lto_symtab_encoder_delete (ob
->decl_state
->symtab_node_encoder
);
2862 lto_function_decl_states
.release ();
2863 destroy_output_block (ob
);
2864 if (lto_stream_offload_p
)
2865 lto_write_mode_table ();