Daily bump.
[official-gcc.git] / gcc / lto-streamer-out.c
blob9e28d678342c1d4a48293b8becef816a227472ea
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
12 version.
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
17 for more details.
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/>. */
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "backend.h"
27 #include "target.h"
28 #include "rtl.h"
29 #include "tree.h"
30 #include "gimple.h"
31 #include "tree-pass.h"
32 #include "ssa.h"
33 #include "gimple-streamer.h"
34 #include "alias.h"
35 #include "stor-layout.h"
36 #include "gimple-iterator.h"
37 #include "except.h"
38 #include "lto-symtab.h"
39 #include "cgraph.h"
40 #include "cfgloop.h"
41 #include "builtins.h"
42 #include "gomp-constants.h"
43 #include "debug.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. */
52 static void
53 clear_line_info (struct output_block *ob)
55 ob->current_file = NULL;
56 ob->current_line = 0;
57 ob->current_col = 0;
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. */
65 struct output_block *
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);
82 clear_line_info (ob);
84 ob->string_hash_table = new hash_table<string_slot_hasher> (37);
85 gcc_obstack_init (&ob->obstack);
87 return ob;
91 /* Destroy the output block OB. */
93 void
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);
109 free (ob);
113 /* Look up NODE in the type table and write the index for it to OB. */
115 static void
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). */
128 static bool
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
133 definition. */
134 if ((TREE_CODE (t) == PARM_DECL || TREE_CODE (t) == RESULT_DECL)
135 && DECL_CONTEXT (t))
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)
140 gcc_unreachable ();
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))
148 return false;
149 else if (TREE_CODE (t) == DEBUG_EXPR_DECL)
150 return false;
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. */
155 else if (TYPE_P (t)
156 && variably_modified_type_p (t, NULL_TREE))
157 return false;
158 else if (TREE_CODE (t) == FIELD_DECL
159 && variably_modified_type_p (DECL_CONTEXT (t), NULL_TREE))
160 return false;
161 else
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. */
170 void
171 lto_output_location (struct output_block *ob, struct bitpack_d *bp,
172 location_t loc)
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)
181 return;
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
209 EXPR to OB. */
211 static void
212 lto_output_tree_ref (struct output_block *ob, tree expr)
214 enum tree_code code;
216 if (TYPE_P (expr))
218 output_type_ref (ob, expr);
219 return;
222 code = TREE_CODE (expr);
223 switch (code)
225 case SSA_NAME:
226 streamer_write_record_start (ob, LTO_ssa_name_ref);
227 streamer_write_uhwi (ob, SSA_NAME_VERSION (expr));
228 break;
230 case FIELD_DECL:
231 streamer_write_record_start (ob, LTO_field_decl_ref);
232 lto_output_field_decl_index (ob->decl_state, ob->main_stream, expr);
233 break;
235 case FUNCTION_DECL:
236 streamer_write_record_start (ob, LTO_function_decl_ref);
237 lto_output_fn_decl_index (ob->decl_state, ob->main_stream, expr);
238 break;
240 case VAR_DECL:
241 case DEBUG_EXPR_DECL:
242 gcc_assert (decl_function_context (expr) == NULL || TREE_STATIC (expr));
243 /* FALLTHRU */
244 case PARM_DECL:
245 streamer_write_record_start (ob, LTO_global_decl_ref);
246 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
247 break;
249 case CONST_DECL:
250 streamer_write_record_start (ob, LTO_const_decl_ref);
251 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
252 break;
254 case IMPORTED_DECL:
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);
258 break;
260 case TYPE_DECL:
261 streamer_write_record_start (ob, LTO_type_decl_ref);
262 lto_output_type_decl_index (ob->decl_state, ob->main_stream, expr);
263 break;
265 case NAMELIST_DECL:
266 streamer_write_record_start (ob, LTO_namelist_decl_ref);
267 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
268 break;
270 case NAMESPACE_DECL:
271 streamer_write_record_start (ob, LTO_namespace_decl_ref);
272 lto_output_namespace_decl_index (ob->decl_state, ob->main_stream, expr);
273 break;
275 case LABEL_DECL:
276 streamer_write_record_start (ob, LTO_label_decl_ref);
277 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
278 break;
280 case RESULT_DECL:
281 streamer_write_record_start (ob, LTO_result_decl_ref);
282 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
283 break;
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);
288 break;
290 default:
291 /* No other node is indexable, so it should have been handled by
292 lto_output_tree. */
293 gcc_unreachable ();
298 /* Return true if EXPR is a tree node that can be written to disk. */
300 static inline bool
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)
308 && code != SSA_NAME
309 && code != CALL_EXPR
310 && code != LANG_TYPE
311 && code != MODIFY_EXPR
312 && code != INIT_EXPR
313 && code != TARGET_EXPR
314 && code != BIND_EXPR
315 && code != WITH_CLEANUP_EXPR
316 && code != STATEMENT_LIST
317 && (code == CASE_LABEL_EXPR
318 || code == DECL_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. */
329 static tree
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. */
337 *sum -= 4;
338 *ws = 0;
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;
343 else
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. */
350 *sum -= 16;
352 if (*sum < 0)
353 return *tp;
354 return NULL_TREE;
358 /* For EXPR lookup and return what we want to stream to OB as DECL_INITIAL. */
360 static tree
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);
369 if (VAR_P (expr)
370 && (TREE_STATIC (expr) || DECL_EXTERNAL (expr))
371 && !DECL_IN_CONSTANT_POOL (expr)
372 && initial)
374 varpool_node *vnode;
375 /* Extra section needs about 30 bytes; do not produce it for simple
376 scalar values. */
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)
382 long max_size = 30;
383 if (walk_tree (&initial, subtract_estimated_size, (void *)&max_size,
384 NULL))
385 initial = error_mark_node;
389 return initial;
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. */
398 static void
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. */
409 if (DECL_P (expr)
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. */
421 if ((DECL_P (expr)
422 && TREE_CODE (expr) != FIELD_DECL
423 && TREE_CODE (expr) != DEBUG_EXPR_DECL
424 && TREE_CODE (expr) != TYPE_DECL)
425 || TREE_CODE (expr) == BLOCK)
427 const char *sym;
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);
435 else
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. */
445 static void
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. */
466 static void
467 lto_output_tree_1 (struct output_block *ob, tree expr, hashval_t hash,
468 bool ref_p, bool this_ref_p)
470 unsigned ix;
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,
476 expr, hash, &ix);
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);
486 else
488 /* This is the first time we see EXPR, write its fields
489 to OB. */
490 lto_write_tree (ob, expr, ref_p);
494 class DFS
496 public:
497 DFS (struct output_block *ob, tree expr, bool ref_p, bool this_ref_p,
498 bool single_p);
499 ~DFS ();
501 struct scc_entry
503 tree t;
504 hashval_t hash;
506 vec<scc_entry> sccstack;
508 private:
509 struct sccs
511 unsigned int dfsnum;
512 unsigned int low;
514 struct worklist
516 tree expr;
517 sccs *from_state;
518 sccs *cstate;
519 bool ref_p;
520 bool this_ref_p;
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);
531 hashval_t
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,
547 bool single_p)
549 unsigned int next_dfs_num = 1;
550 sccstack.create (0);
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 ();
557 expr = w.expr;
558 sccs *from_state = w.from_state;
559 sccs *cstate = w.cstate;
560 ref_p = w.ref_p;
561 this_ref_p = w.this_ref_p;
562 if (cstate == NULL)
564 sccs **slot = &sccstate.get_or_insert (expr);
565 cstate = *slot;
566 if (cstate)
568 gcc_checking_assert (from_state);
569 if (cstate->dfsnum < from_state->dfsnum)
570 from_state->low = MIN (cstate->dfsnum, from_state->low);
571 worklist_vec.pop ();
572 continue;
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;
581 w.cstate = cstate;
583 if (TREE_CODE (expr) == INTEGER_CST
584 && !TREE_OVERFLOW (expr))
585 DFS_write_tree (ob, cstate, TREE_TYPE (expr), ref_p, ref_p);
586 else
588 DFS_write_tree_body (ob, expr, cstate, ref_p);
590 /* Walk any LTO-specific edges. */
591 if (DECL_P (expr)
592 && TREE_CODE (expr) != FUNCTION_DECL
593 && TREE_CODE (expr) != TRANSLATION_UNIT_DECL)
595 /* Handle DECL_INITIAL for symbols. */
596 tree initial
597 = get_symbol_initial_value (ob->decl_state->symtab_node_encoder,
598 expr);
599 DFS_write_tree (ob, cstate, initial, ref_p, ref_p);
602 continue;
605 /* See if we found an SCC. */
606 if (cstate->low == cstate->dfsnum)
608 unsigned first, size;
609 tree x;
611 /* If we are re-walking a single leaf SCC just pop it,
612 let earlier worklist item access the sccstack. */
613 if (single_p)
615 worklist_vec.pop ();
616 continue;
619 /* Pop the SCC and compute its size. */
620 first = sccstack.length ();
623 x = sccstack[--first].t;
625 while (x != expr);
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;
632 if (!flag_wpa)
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;)
641 unsigned from = i;
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;
649 entry_start = 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
672 this way.
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. */
676 if (size == 1)
677 lto_output_tree_1 (ob, expr, scc_hash, ref_p, this_ref_p);
678 else
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,
689 t, hash, NULL);
690 gcc_assert (!exists_p);
692 if (!lto_is_streamable (t))
693 internal_error ("tree code %qs is not supported "
694 "in LTO streams",
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);
715 if (from_state)
716 from_state->low = MIN (from_state->low, cstate->low);
717 worklist_vec.pop ();
718 continue;
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);
725 worklist_vec.pop ();
727 worklist_vec.release ();
730 DFS::~DFS ()
732 sccstack.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. */
739 void
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)
746 enum tree_code code;
748 if (streamer_dump_file)
750 print_node_brief (streamer_dump_file, " Streaming ",
751 expr, 4);
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. */
784 if (DECL_NAME (expr)
785 && TREE_CODE (DECL_NAME (expr)) == IDENTIFIER_NODE
786 && anon_aggrname_p (DECL_NAME (expr)))
788 else
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]);
793 else
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));
813 if ((VAR_P (expr)
814 || TREE_CODE (expr) == PARM_DECL)
815 && DECL_HAS_VALUE_EXPR_P (expr))
816 DFS_follow_tree_edge (DECL_VALUE_EXPR (expr));
817 if (VAR_P (expr)
818 && DECL_HAS_DEBUG_EXPR_P (expr))
819 DFS_follow_tree_edge (DECL_DEBUG_EXPR (expr));
822 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
824 /* Make sure we don't inadvertently set the assembler name. */
825 if (DECL_ASSEMBLER_NAME_SET_P (expr))
826 DFS_follow_tree_edge (DECL_ASSEMBLER_NAME (expr));
829 if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
831 DFS_follow_tree_edge (DECL_FIELD_OFFSET (expr));
832 DFS_follow_tree_edge (DECL_BIT_FIELD_TYPE (expr));
833 DFS_follow_tree_edge (DECL_BIT_FIELD_REPRESENTATIVE (expr));
834 DFS_follow_tree_edge (DECL_FIELD_BIT_OFFSET (expr));
835 gcc_checking_assert (!DECL_FCONTEXT (expr));
838 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
840 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
855 during fixup. */
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
907 free-lang-data. */
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
920 streaming time. */
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))
928 unsigned i;
929 tree t;
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
941 by C++ FE only. */
944 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
946 unsigned i;
947 tree index, value;
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)
958 int i;
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. */
971 static hashval_t
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) \
977 do { \
978 unsigned ix; \
979 if (!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)); \
983 else if (map) \
984 hstate.add_int (*map->get (SIBLING)); \
985 else \
986 hstate.add_int (1); \
987 } while (0)
989 /* Hash TS_BASE. */
990 enum tree_code code = TREE_CODE (t);
991 hstate.add_int (code);
992 if (!TYPE_P (t))
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));
1001 if (DECL_P (t))
1002 hstate.add_flag (DECL_UNSIGNED (t));
1003 else if (TYPE_P (t))
1004 hstate.add_flag (TYPE_UNSIGNED (t));
1005 if (TYPE_P (t))
1006 hstate.add_flag (TYPE_ARTIFICIAL (t));
1007 else
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));
1015 if (TYPE_P (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
1147 no streaming. */
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. */
1212 if (DECL_NAME (t)
1213 && TREE_CODE (DECL_NAME (t)) == IDENTIFIER_NODE
1214 && anon_aggrname_p (DECL_NAME (t)))
1216 else
1217 visit (DECL_NAME (t));
1218 if (DECL_FILE_SCOPE_P (t))
1220 else
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));
1254 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
1256 visit (DECL_VINDEX (t));
1257 visit (DECL_FUNCTION_PERSONALITY (t));
1258 visit (DECL_FUNCTION_SPECIFIC_TARGET (t));
1259 visit (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t));
1262 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
1264 visit (TYPE_SIZE (t));
1265 visit (TYPE_SIZE_UNIT (t));
1266 visit (TYPE_ATTRIBUTES (t));
1267 visit (TYPE_NAME (t));
1268 visit (TYPE_MAIN_VARIANT (t));
1269 if (TYPE_FILE_SCOPE_P (t))
1271 else
1272 visit (TYPE_CONTEXT (t));
1273 visit (TYPE_STUB_DECL (t));
1276 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
1278 if (code == ENUMERAL_TYPE)
1279 visit (TYPE_VALUES (t));
1280 else if (code == ARRAY_TYPE)
1281 visit (TYPE_DOMAIN (t));
1282 else if (RECORD_OR_UNION_TYPE_P (t))
1283 for (tree f = TYPE_FIELDS (t); f; f = TREE_CHAIN (f))
1284 visit (f);
1285 else if (code == FUNCTION_TYPE
1286 || code == METHOD_TYPE)
1287 visit (TYPE_ARG_TYPES (t));
1288 if (!POINTER_TYPE_P (t))
1289 visit (TYPE_MIN_VALUE_RAW (t));
1290 visit (TYPE_MAX_VALUE_RAW (t));
1293 if (CODE_CONTAINS_STRUCT (code, TS_LIST))
1295 visit (TREE_PURPOSE (t));
1296 visit (TREE_VALUE (t));
1297 visit (TREE_CHAIN (t));
1300 if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1301 for (int i = 0; i < TREE_VEC_LENGTH (t); ++i)
1302 visit (TREE_VEC_ELT (t, i));
1304 if (CODE_CONTAINS_STRUCT (code, TS_EXP))
1306 hstate.add_hwi (TREE_OPERAND_LENGTH (t));
1307 for (int i = 0; i < TREE_OPERAND_LENGTH (t); ++i)
1308 visit (TREE_OPERAND (t, i));
1311 if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1313 unsigned i;
1314 tree b;
1315 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (t), i, b)
1316 visit (b);
1317 visit (BINFO_OFFSET (t));
1318 visit (BINFO_VTABLE (t));
1319 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
1320 BINFO_BASE_ACCESSES and BINFO_VPTR_INDEX; these are used
1321 by C++ FE only. */
1324 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
1326 unsigned i;
1327 tree index, value;
1328 hstate.add_hwi (CONSTRUCTOR_NELTS (t));
1329 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), i, index, value)
1331 visit (index);
1332 visit (value);
1336 if (code == OMP_CLAUSE)
1338 int i;
1339 HOST_WIDE_INT val;
1341 hstate.add_hwi (OMP_CLAUSE_CODE (t));
1342 switch (OMP_CLAUSE_CODE (t))
1344 case OMP_CLAUSE_DEFAULT:
1345 val = OMP_CLAUSE_DEFAULT_KIND (t);
1346 break;
1347 case OMP_CLAUSE_SCHEDULE:
1348 val = OMP_CLAUSE_SCHEDULE_KIND (t);
1349 break;
1350 case OMP_CLAUSE_DEPEND:
1351 val = OMP_CLAUSE_DEPEND_KIND (t);
1352 break;
1353 case OMP_CLAUSE_MAP:
1354 val = OMP_CLAUSE_MAP_KIND (t);
1355 break;
1356 case OMP_CLAUSE_PROC_BIND:
1357 val = OMP_CLAUSE_PROC_BIND_KIND (t);
1358 break;
1359 case OMP_CLAUSE_REDUCTION:
1360 val = OMP_CLAUSE_REDUCTION_CODE (t);
1361 break;
1362 default:
1363 val = 0;
1364 break;
1366 hstate.add_hwi (val);
1367 for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (t)]; i++)
1368 visit (OMP_CLAUSE_OPERAND (t, i));
1369 visit (OMP_CLAUSE_CHAIN (t));
1372 return hstate.end ();
1374 #undef visit
1377 /* Compare two SCC entries by their hash value for qsorting them. */
1380 DFS::scc_entry_compare (const void *p1_, const void *p2_)
1382 const scc_entry *p1 = (const scc_entry *) p1_;
1383 const scc_entry *p2 = (const scc_entry *) p2_;
1384 if (p1->hash < p2->hash)
1385 return -1;
1386 else if (p1->hash > p2->hash)
1387 return 1;
1388 return 0;
1391 /* Return a hash value for the SCC on the SCC stack from FIRST with SIZE.
1392 THIS_REF_P and REF_P are as passed to lto_output_tree for FIRST. */
1394 hashval_t
1395 DFS::hash_scc (struct output_block *ob, unsigned first, unsigned size,
1396 bool ref_p, bool this_ref_p)
1398 unsigned int last_classes = 0, iterations = 0;
1400 /* Compute hash values for the SCC members. */
1401 for (unsigned i = 0; i < size; ++i)
1402 sccstack[first+i].hash
1403 = hash_tree (ob->writer_cache, NULL, sccstack[first+i].t);
1405 if (size == 1)
1406 return sccstack[first].hash;
1408 /* We aim to get unique hash for every tree within SCC and compute hash value
1409 of the whole SCC by combining all values together in a stable (entry-point
1410 independent) order. This guarantees that the same SCC regions within
1411 different translation units will get the same hash values and therefore
1412 will be merged at WPA time.
1414 Often the hashes are already unique. In that case we compute the SCC hash
1415 by combining individual hash values in an increasing order.
1417 If there are duplicates, we seek at least one tree with unique hash (and
1418 pick one with minimal hash and this property). Then we obtain a stable
1419 order by DFS walk starting from this unique tree and then use the index
1420 within this order to make individual hash values unique.
1422 If there is no tree with unique hash, we iteratively propagate the hash
1423 values across the internal edges of SCC. This usually quickly leads
1424 to unique hashes. Consider, for example, an SCC containing two pointers
1425 that are identical except for the types they point to and assume that
1426 these types are also part of the SCC. The propagation will add the
1427 points-to type information into their hash values. */
1430 /* Sort the SCC so we can easily check for uniqueness. */
1431 qsort (&sccstack[first], size, sizeof (scc_entry), scc_entry_compare);
1433 unsigned int classes = 1;
1434 int firstunique = -1;
1436 /* Find the tree with lowest unique hash (if it exists) and compute
1437 the number of equivalence classes. */
1438 if (sccstack[first].hash != sccstack[first+1].hash)
1439 firstunique = 0;
1440 for (unsigned i = 1; i < size; ++i)
1441 if (sccstack[first+i-1].hash != sccstack[first+i].hash)
1443 classes++;
1444 if (firstunique == -1
1445 && (i == size - 1
1446 || sccstack[first+i+1].hash != sccstack[first+i].hash))
1447 firstunique = i;
1450 /* If we found a tree with unique hash, stop the iteration. */
1451 if (firstunique != -1
1452 /* Also terminate if we run out of iterations or if the number of
1453 equivalence classes is no longer increasing.
1454 For example a cyclic list of trees that are all equivalent will
1455 never have unique entry point; we however do not build such SCCs
1456 in our IL. */
1457 || classes <= last_classes || iterations > 16)
1459 hashval_t scc_hash;
1461 /* If some hashes are not unique (CLASSES != SIZE), use the DFS walk
1462 starting from FIRSTUNIQUE to obtain a stable order. */
1463 if (classes != size && firstunique != -1)
1465 hash_map <tree, hashval_t> map(size*2);
1467 /* Store hash values into a map, so we can associate them with
1468 the reordered SCC. */
1469 for (unsigned i = 0; i < size; ++i)
1470 map.put (sccstack[first+i].t, sccstack[first+i].hash);
1472 DFS again (ob, sccstack[first+firstunique].t, ref_p, this_ref_p,
1473 true);
1474 gcc_assert (again.sccstack.length () == size);
1476 memcpy (sccstack.address () + first,
1477 again.sccstack.address (),
1478 sizeof (scc_entry) * size);
1480 /* Update hash values of individual members by hashing in the
1481 index within the stable order. This ensures uniqueness.
1482 Also compute the SCC hash by mixing in all hash values in
1483 the stable order we obtained. */
1484 sccstack[first].hash = *map.get (sccstack[first].t);
1485 scc_hash = sccstack[first].hash;
1486 for (unsigned i = 1; i < size; ++i)
1488 sccstack[first+i].hash
1489 = iterative_hash_hashval_t (i,
1490 *map.get (sccstack[first+i].t));
1491 scc_hash
1492 = iterative_hash_hashval_t (scc_hash,
1493 sccstack[first+i].hash);
1496 /* If we got a unique hash value for each tree, then sort already
1497 ensured entry-point independent order. Only compute the final
1498 SCC hash.
1500 If we failed to find the unique entry point, we go by the same
1501 route. We will eventually introduce unwanted hash conflicts. */
1502 else
1504 scc_hash = sccstack[first].hash;
1505 for (unsigned i = 1; i < size; ++i)
1506 scc_hash
1507 = iterative_hash_hashval_t (scc_hash, sccstack[first+i].hash);
1509 /* We cannot 100% guarantee that the hash won't conflict so as
1510 to make it impossible to find a unique hash. This however
1511 should be an extremely rare case. ICE for now so possible
1512 issues are found and evaluated. */
1513 gcc_checking_assert (classes == size);
1516 /* To avoid conflicts across SCCs, iteratively hash the whole SCC
1517 hash into the hash of each element. */
1518 for (unsigned i = 0; i < size; ++i)
1519 sccstack[first+i].hash
1520 = iterative_hash_hashval_t (sccstack[first+i].hash, scc_hash);
1521 return scc_hash;
1524 last_classes = classes;
1525 iterations++;
1527 /* We failed to identify the entry point; propagate hash values across
1528 the edges. */
1529 hash_map <tree, hashval_t> map(size*2);
1531 for (unsigned i = 0; i < size; ++i)
1532 map.put (sccstack[first+i].t, sccstack[first+i].hash);
1534 for (unsigned i = 0; i < size; i++)
1535 sccstack[first+i].hash
1536 = hash_tree (ob->writer_cache, &map, sccstack[first+i].t);
1538 while (true);
1541 /* DFS walk EXPR and stream SCCs of tree bodies if they are not
1542 already in the streamer cache. Main routine called for
1543 each visit of EXPR. */
1545 void
1546 DFS::DFS_write_tree (struct output_block *ob, sccs *from_state,
1547 tree expr, bool ref_p, bool this_ref_p)
1549 /* Handle special cases. */
1550 if (expr == NULL_TREE)
1551 return;
1553 /* Do not DFS walk into indexable trees. */
1554 if (this_ref_p && tree_is_indexable (expr))
1555 return;
1557 /* Check if we already streamed EXPR. */
1558 if (streamer_tree_cache_lookup (ob->writer_cache, expr, NULL))
1559 return;
1561 worklist w;
1562 w.expr = expr;
1563 w.from_state = from_state;
1564 w.cstate = NULL;
1565 w.ref_p = ref_p;
1566 w.this_ref_p = this_ref_p;
1567 worklist_vec.safe_push (w);
1571 /* Emit the physical representation of tree node EXPR to output block OB.
1572 If THIS_REF_P is true, the leaves of EXPR are emitted as references via
1573 lto_output_tree_ref. REF_P is used for streaming siblings of EXPR. */
1575 void
1576 lto_output_tree (struct output_block *ob, tree expr,
1577 bool ref_p, bool this_ref_p)
1579 unsigned ix;
1580 bool existed_p;
1582 if (expr == NULL_TREE)
1584 streamer_write_record_start (ob, LTO_null);
1585 return;
1588 if (this_ref_p && tree_is_indexable (expr))
1590 lto_output_tree_ref (ob, expr);
1591 return;
1594 existed_p = streamer_tree_cache_lookup (ob->writer_cache, expr, &ix);
1595 if (existed_p)
1597 /* If a node has already been streamed out, make sure that
1598 we don't write it more than once. Otherwise, the reader
1599 will instantiate two different nodes for the same object. */
1600 streamer_write_record_start (ob, LTO_tree_pickle_reference);
1601 streamer_write_uhwi (ob, ix);
1602 streamer_write_enum (ob->main_stream, LTO_tags, LTO_NUM_TAGS,
1603 lto_tree_code_to_tag (TREE_CODE (expr)));
1604 lto_stats.num_pickle_refs_output++;
1606 else
1608 /* This is the first time we see EXPR, write all reachable
1609 trees to OB. */
1610 static bool in_dfs_walk;
1612 /* Protect against recursion which means disconnect between
1613 what tree edges we walk in the DFS walk and what edges
1614 we stream out. */
1615 gcc_assert (!in_dfs_walk);
1617 if (streamer_dump_file)
1619 print_node_brief (streamer_dump_file, " Streaming SCC of ",
1620 expr, 4);
1621 fprintf (streamer_dump_file, "\n");
1624 /* Start the DFS walk. */
1625 /* Save ob state ... */
1626 /* let's see ... */
1627 in_dfs_walk = true;
1628 DFS (ob, expr, ref_p, this_ref_p, false);
1629 in_dfs_walk = false;
1631 /* Finally append a reference to the tree we were writing.
1632 ??? If expr ended up as a singleton we could have
1633 inlined it here and avoid outputting a reference. */
1634 existed_p = streamer_tree_cache_lookup (ob->writer_cache, expr, &ix);
1635 gcc_assert (existed_p);
1636 streamer_write_record_start (ob, LTO_tree_pickle_reference);
1637 streamer_write_uhwi (ob, ix);
1638 streamer_write_enum (ob->main_stream, LTO_tags, LTO_NUM_TAGS,
1639 lto_tree_code_to_tag (TREE_CODE (expr)));
1640 if (streamer_dump_file)
1642 print_node_brief (streamer_dump_file, " Finished SCC of ",
1643 expr, 4);
1644 fprintf (streamer_dump_file, "\n\n");
1646 lto_stats.num_pickle_refs_output++;
1651 /* Output to OB a list of try/catch handlers starting with FIRST. */
1653 static void
1654 output_eh_try_list (struct output_block *ob, eh_catch first)
1656 eh_catch n;
1658 for (n = first; n; n = n->next_catch)
1660 streamer_write_record_start (ob, LTO_eh_catch);
1661 stream_write_tree (ob, n->type_list, true);
1662 stream_write_tree (ob, n->filter_list, true);
1663 stream_write_tree (ob, n->label, true);
1666 streamer_write_record_start (ob, LTO_null);
1670 /* Output EH region R in function FN to OB. CURR_RN is the slot index
1671 that is being emitted in FN->EH->REGION_ARRAY. This is used to
1672 detect EH region sharing. */
1674 static void
1675 output_eh_region (struct output_block *ob, eh_region r)
1677 enum LTO_tags tag;
1679 if (r == NULL)
1681 streamer_write_record_start (ob, LTO_null);
1682 return;
1685 if (r->type == ERT_CLEANUP)
1686 tag = LTO_ert_cleanup;
1687 else if (r->type == ERT_TRY)
1688 tag = LTO_ert_try;
1689 else if (r->type == ERT_ALLOWED_EXCEPTIONS)
1690 tag = LTO_ert_allowed_exceptions;
1691 else if (r->type == ERT_MUST_NOT_THROW)
1692 tag = LTO_ert_must_not_throw;
1693 else
1694 gcc_unreachable ();
1696 streamer_write_record_start (ob, tag);
1697 streamer_write_hwi (ob, r->index);
1699 if (r->outer)
1700 streamer_write_hwi (ob, r->outer->index);
1701 else
1702 streamer_write_zero (ob);
1704 if (r->inner)
1705 streamer_write_hwi (ob, r->inner->index);
1706 else
1707 streamer_write_zero (ob);
1709 if (r->next_peer)
1710 streamer_write_hwi (ob, r->next_peer->index);
1711 else
1712 streamer_write_zero (ob);
1714 if (r->type == ERT_TRY)
1716 output_eh_try_list (ob, r->u.eh_try.first_catch);
1718 else if (r->type == ERT_ALLOWED_EXCEPTIONS)
1720 stream_write_tree (ob, r->u.allowed.type_list, true);
1721 stream_write_tree (ob, r->u.allowed.label, true);
1722 streamer_write_uhwi (ob, r->u.allowed.filter);
1724 else if (r->type == ERT_MUST_NOT_THROW)
1726 stream_write_tree (ob, r->u.must_not_throw.failure_decl, true);
1727 bitpack_d bp = bitpack_create (ob->main_stream);
1728 stream_output_location (ob, &bp, r->u.must_not_throw.failure_loc);
1729 streamer_write_bitpack (&bp);
1732 if (r->landing_pads)
1733 streamer_write_hwi (ob, r->landing_pads->index);
1734 else
1735 streamer_write_zero (ob);
1739 /* Output landing pad LP to OB. */
1741 static void
1742 output_eh_lp (struct output_block *ob, eh_landing_pad lp)
1744 if (lp == NULL)
1746 streamer_write_record_start (ob, LTO_null);
1747 return;
1750 streamer_write_record_start (ob, LTO_eh_landing_pad);
1751 streamer_write_hwi (ob, lp->index);
1752 if (lp->next_lp)
1753 streamer_write_hwi (ob, lp->next_lp->index);
1754 else
1755 streamer_write_zero (ob);
1757 if (lp->region)
1758 streamer_write_hwi (ob, lp->region->index);
1759 else
1760 streamer_write_zero (ob);
1762 stream_write_tree (ob, lp->post_landing_pad, true);
1766 /* Output the existing eh_table to OB. */
1768 static void
1769 output_eh_regions (struct output_block *ob, struct function *fn)
1771 if (fn->eh && fn->eh->region_tree)
1773 unsigned i;
1774 eh_region eh;
1775 eh_landing_pad lp;
1776 tree ttype;
1778 streamer_write_record_start (ob, LTO_eh_table);
1780 /* Emit the index of the root of the EH region tree. */
1781 streamer_write_hwi (ob, fn->eh->region_tree->index);
1783 /* Emit all the EH regions in the region array. */
1784 streamer_write_hwi (ob, vec_safe_length (fn->eh->region_array));
1785 FOR_EACH_VEC_SAFE_ELT (fn->eh->region_array, i, eh)
1786 output_eh_region (ob, eh);
1788 /* Emit all landing pads. */
1789 streamer_write_hwi (ob, vec_safe_length (fn->eh->lp_array));
1790 FOR_EACH_VEC_SAFE_ELT (fn->eh->lp_array, i, lp)
1791 output_eh_lp (ob, lp);
1793 /* Emit all the runtime type data. */
1794 streamer_write_hwi (ob, vec_safe_length (fn->eh->ttype_data));
1795 FOR_EACH_VEC_SAFE_ELT (fn->eh->ttype_data, i, ttype)
1796 stream_write_tree (ob, ttype, true);
1798 /* Emit the table of action chains. */
1799 if (targetm.arm_eabi_unwinder)
1801 tree t;
1802 streamer_write_hwi (ob, vec_safe_length (fn->eh->ehspec_data.arm_eabi));
1803 FOR_EACH_VEC_SAFE_ELT (fn->eh->ehspec_data.arm_eabi, i, t)
1804 stream_write_tree (ob, t, true);
1806 else
1808 uchar c;
1809 streamer_write_hwi (ob, vec_safe_length (fn->eh->ehspec_data.other));
1810 FOR_EACH_VEC_SAFE_ELT (fn->eh->ehspec_data.other, i, c)
1811 streamer_write_char_stream (ob->main_stream, c);
1815 /* The LTO_null either terminates the record or indicates that there
1816 are no eh_records at all. */
1817 streamer_write_record_start (ob, LTO_null);
1821 /* Output all of the active ssa names to the ssa_names stream. */
1823 static void
1824 output_ssa_names (struct output_block *ob, struct function *fn)
1826 unsigned int i, len;
1828 len = vec_safe_length (SSANAMES (fn));
1829 streamer_write_uhwi (ob, len);
1831 for (i = 1; i < len; i++)
1833 tree ptr = (*SSANAMES (fn))[i];
1835 if (ptr == NULL_TREE
1836 || SSA_NAME_IN_FREE_LIST (ptr)
1837 || virtual_operand_p (ptr)
1838 /* Simply skip unreleased SSA names. */
1839 || (! SSA_NAME_IS_DEFAULT_DEF (ptr)
1840 && (! SSA_NAME_DEF_STMT (ptr)
1841 || ! gimple_bb (SSA_NAME_DEF_STMT (ptr)))))
1842 continue;
1844 streamer_write_uhwi (ob, i);
1845 streamer_write_char_stream (ob->main_stream,
1846 SSA_NAME_IS_DEFAULT_DEF (ptr));
1847 if (SSA_NAME_VAR (ptr))
1848 stream_write_tree (ob, SSA_NAME_VAR (ptr), true);
1849 else
1850 /* ??? This drops SSA_NAME_IDENTIFIER on the floor. */
1851 stream_write_tree (ob, TREE_TYPE (ptr), true);
1854 streamer_write_zero (ob);
1859 /* Output the cfg. */
1861 static void
1862 output_cfg (struct output_block *ob, struct function *fn)
1864 struct lto_output_stream *tmp_stream = ob->main_stream;
1865 basic_block bb;
1867 ob->main_stream = ob->cfg_stream;
1869 streamer_write_enum (ob->main_stream, profile_status_d, PROFILE_LAST,
1870 profile_status_for_fn (fn));
1872 /* Output the number of the highest basic block. */
1873 streamer_write_uhwi (ob, last_basic_block_for_fn (fn));
1875 FOR_ALL_BB_FN (bb, fn)
1877 edge_iterator ei;
1878 edge e;
1880 streamer_write_hwi (ob, bb->index);
1882 /* Output the successors and the edge flags. */
1883 streamer_write_uhwi (ob, EDGE_COUNT (bb->succs));
1884 FOR_EACH_EDGE (e, ei, bb->succs)
1886 streamer_write_uhwi (ob, e->dest->index);
1887 e->probability.stream_out (ob);
1888 streamer_write_uhwi (ob, e->flags);
1892 streamer_write_hwi (ob, -1);
1894 bb = ENTRY_BLOCK_PTR_FOR_FN (cfun);
1895 while (bb->next_bb)
1897 streamer_write_hwi (ob, bb->next_bb->index);
1898 bb = bb->next_bb;
1901 streamer_write_hwi (ob, -1);
1903 /* ??? The cfgloop interface is tied to cfun. */
1904 gcc_assert (cfun == fn);
1906 /* Output the number of loops. */
1907 streamer_write_uhwi (ob, number_of_loops (fn));
1909 /* Output each loop, skipping the tree root which has number zero. */
1910 for (unsigned i = 1; i < number_of_loops (fn); ++i)
1912 struct loop *loop = get_loop (fn, i);
1914 /* Write the index of the loop header. That's enough to rebuild
1915 the loop tree on the reader side. Stream -1 for an unused
1916 loop entry. */
1917 if (!loop)
1919 streamer_write_hwi (ob, -1);
1920 continue;
1922 else
1923 streamer_write_hwi (ob, loop->header->index);
1925 /* Write everything copy_loop_info copies. */
1926 streamer_write_enum (ob->main_stream,
1927 loop_estimation, EST_LAST, loop->estimate_state);
1928 streamer_write_hwi (ob, loop->any_upper_bound);
1929 if (loop->any_upper_bound)
1930 streamer_write_widest_int (ob, loop->nb_iterations_upper_bound);
1931 streamer_write_hwi (ob, loop->any_likely_upper_bound);
1932 if (loop->any_likely_upper_bound)
1933 streamer_write_widest_int (ob, loop->nb_iterations_likely_upper_bound);
1934 streamer_write_hwi (ob, loop->any_estimate);
1935 if (loop->any_estimate)
1936 streamer_write_widest_int (ob, loop->nb_iterations_estimate);
1938 /* Write OMP SIMD related info. */
1939 streamer_write_hwi (ob, loop->safelen);
1940 streamer_write_hwi (ob, loop->unroll);
1941 streamer_write_hwi (ob, loop->dont_vectorize);
1942 streamer_write_hwi (ob, loop->force_vectorize);
1943 stream_write_tree (ob, loop->simduid, true);
1946 ob->main_stream = tmp_stream;
1950 /* Create the header in the file using OB. If the section type is for
1951 a function, set FN to the decl for that function. */
1953 void
1954 produce_asm (struct output_block *ob, tree fn)
1956 enum lto_section_type section_type = ob->section_type;
1957 struct lto_function_header header;
1958 char *section_name;
1960 if (section_type == LTO_section_function_body)
1962 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn));
1963 section_name = lto_get_section_name (section_type, name, NULL);
1965 else
1966 section_name = lto_get_section_name (section_type, NULL, NULL);
1968 lto_begin_section (section_name, !flag_wpa);
1969 free (section_name);
1971 /* The entire header is stream computed here. */
1972 memset (&header, 0, sizeof (struct lto_function_header));
1974 /* Write the header. */
1975 header.major_version = LTO_major_version;
1976 header.minor_version = LTO_minor_version;
1978 if (section_type == LTO_section_function_body)
1979 header.cfg_size = ob->cfg_stream->total_size;
1980 header.main_size = ob->main_stream->total_size;
1981 header.string_size = ob->string_stream->total_size;
1982 lto_write_data (&header, sizeof header);
1984 /* Put all of the gimple and the string table out the asm file as a
1985 block of text. */
1986 if (section_type == LTO_section_function_body)
1987 lto_write_stream (ob->cfg_stream);
1988 lto_write_stream (ob->main_stream);
1989 lto_write_stream (ob->string_stream);
1991 lto_end_section ();
1995 /* Output the base body of struct function FN using output block OB. */
1997 static void
1998 output_struct_function_base (struct output_block *ob, struct function *fn)
2000 struct bitpack_d bp;
2001 unsigned i;
2002 tree t;
2004 /* Output the static chain and non-local goto save area. */
2005 stream_write_tree (ob, fn->static_chain_decl, true);
2006 stream_write_tree (ob, fn->nonlocal_goto_save_area, true);
2008 /* Output all the local variables in the function. */
2009 streamer_write_hwi (ob, vec_safe_length (fn->local_decls));
2010 FOR_EACH_VEC_SAFE_ELT (fn->local_decls, i, t)
2011 stream_write_tree (ob, t, true);
2013 /* Output current IL state of the function. */
2014 streamer_write_uhwi (ob, fn->curr_properties);
2016 /* Write all the attributes for FN. */
2017 bp = bitpack_create (ob->main_stream);
2018 bp_pack_value (&bp, fn->is_thunk, 1);
2019 bp_pack_value (&bp, fn->has_local_explicit_reg_vars, 1);
2020 bp_pack_value (&bp, fn->returns_pcc_struct, 1);
2021 bp_pack_value (&bp, fn->returns_struct, 1);
2022 bp_pack_value (&bp, fn->can_throw_non_call_exceptions, 1);
2023 bp_pack_value (&bp, fn->can_delete_dead_exceptions, 1);
2024 bp_pack_value (&bp, fn->always_inline_functions_inlined, 1);
2025 bp_pack_value (&bp, fn->after_inlining, 1);
2026 bp_pack_value (&bp, fn->stdarg, 1);
2027 bp_pack_value (&bp, fn->has_nonlocal_label, 1);
2028 bp_pack_value (&bp, fn->has_forced_label_in_static, 1);
2029 bp_pack_value (&bp, fn->calls_alloca, 1);
2030 bp_pack_value (&bp, fn->calls_setjmp, 1);
2031 bp_pack_value (&bp, fn->has_force_vectorize_loops, 1);
2032 bp_pack_value (&bp, fn->has_simduid_loops, 1);
2033 bp_pack_value (&bp, fn->va_list_fpr_size, 8);
2034 bp_pack_value (&bp, fn->va_list_gpr_size, 8);
2035 bp_pack_value (&bp, fn->last_clique, sizeof (short) * 8);
2037 /* Output the function start and end loci. */
2038 stream_output_location (ob, &bp, fn->function_start_locus);
2039 stream_output_location (ob, &bp, fn->function_end_locus);
2041 /* Save the instance discriminator if present. */
2042 int *instance_number_p = NULL;
2043 if (decl_to_instance_map)
2044 instance_number_p = decl_to_instance_map->get (fn->decl);
2045 bp_pack_value (&bp, !!instance_number_p, 1);
2046 if (instance_number_p)
2047 bp_pack_value (&bp, *instance_number_p, sizeof (int) * CHAR_BIT);
2049 streamer_write_bitpack (&bp);
2053 /* Collect all leaf BLOCKs beyond ROOT into LEAFS. */
2055 static void
2056 collect_block_tree_leafs (tree root, vec<tree> &leafs)
2058 for (root = BLOCK_SUBBLOCKS (root); root; root = BLOCK_CHAIN (root))
2059 if (! BLOCK_SUBBLOCKS (root))
2060 leafs.safe_push (root);
2061 else
2062 collect_block_tree_leafs (BLOCK_SUBBLOCKS (root), leafs);
2065 /* Output the body of function NODE->DECL. */
2067 static void
2068 output_function (struct cgraph_node *node)
2070 tree function;
2071 struct function *fn;
2072 basic_block bb;
2073 struct output_block *ob;
2075 if (streamer_dump_file)
2076 fprintf (streamer_dump_file, "\nStreaming body of %s\n",
2077 node->name ());
2079 function = node->decl;
2080 fn = DECL_STRUCT_FUNCTION (function);
2081 ob = create_output_block (LTO_section_function_body);
2083 clear_line_info (ob);
2084 ob->symbol = node;
2086 gcc_assert (current_function_decl == NULL_TREE && cfun == NULL);
2088 /* Set current_function_decl and cfun. */
2089 push_cfun (fn);
2091 /* Make string 0 be a NULL string. */
2092 streamer_write_char_stream (ob->string_stream, 0);
2094 streamer_write_record_start (ob, LTO_function);
2096 /* Output decls for parameters and args. */
2097 stream_write_tree (ob, DECL_RESULT (function), true);
2098 streamer_write_chain (ob, DECL_ARGUMENTS (function), true);
2100 /* Output debug args if available. */
2101 vec<tree, va_gc> **debugargs = decl_debug_args_lookup (function);
2102 if (! debugargs)
2103 streamer_write_uhwi (ob, 0);
2104 else
2106 streamer_write_uhwi (ob, (*debugargs)->length ());
2107 for (unsigned i = 0; i < (*debugargs)->length (); ++i)
2108 stream_write_tree (ob, (**debugargs)[i], true);
2111 /* Output DECL_INITIAL for the function, which contains the tree of
2112 lexical scopes. */
2113 stream_write_tree (ob, DECL_INITIAL (function), true);
2114 /* As we do not recurse into BLOCK_SUBBLOCKS but only BLOCK_SUPERCONTEXT
2115 collect block tree leafs and stream those. */
2116 auto_vec<tree> block_tree_leafs;
2117 if (DECL_INITIAL (function))
2118 collect_block_tree_leafs (DECL_INITIAL (function), block_tree_leafs);
2119 streamer_write_uhwi (ob, block_tree_leafs.length ());
2120 for (unsigned i = 0; i < block_tree_leafs.length (); ++i)
2121 stream_write_tree (ob, block_tree_leafs[i], true);
2123 /* We also stream abstract functions where we stream only stuff needed for
2124 debug info. */
2125 if (gimple_has_body_p (function))
2127 /* Fixup loops if required to match discovery done in the reader. */
2128 loop_optimizer_init (AVOID_CFG_MODIFICATIONS);
2130 streamer_write_uhwi (ob, 1);
2131 output_struct_function_base (ob, fn);
2133 /* Output all the SSA names used in the function. */
2134 output_ssa_names (ob, fn);
2136 /* Output any exception handling regions. */
2137 output_eh_regions (ob, fn);
2140 /* We will renumber the statements. The code that does this uses
2141 the same ordering that we use for serializing them so we can use
2142 the same code on the other end and not have to write out the
2143 statement numbers. We do not assign UIDs to PHIs here because
2144 virtual PHIs get re-computed on-the-fly which would make numbers
2145 inconsistent. */
2146 set_gimple_stmt_max_uid (cfun, 0);
2147 FOR_ALL_BB_FN (bb, cfun)
2149 for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
2150 gsi_next (&gsi))
2152 gphi *stmt = gsi.phi ();
2154 /* Virtual PHIs are not going to be streamed. */
2155 if (!virtual_operand_p (gimple_phi_result (stmt)))
2156 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
2158 for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);
2159 gsi_next (&gsi))
2161 gimple *stmt = gsi_stmt (gsi);
2162 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
2165 /* To avoid keeping duplicate gimple IDs in the statements, renumber
2166 virtual phis now. */
2167 FOR_ALL_BB_FN (bb, cfun)
2169 for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
2170 gsi_next (&gsi))
2172 gphi *stmt = gsi.phi ();
2173 if (virtual_operand_p (gimple_phi_result (stmt)))
2174 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
2178 /* Output the code for the function. */
2179 FOR_ALL_BB_FN (bb, fn)
2180 output_bb (ob, bb, fn);
2182 /* The terminator for this function. */
2183 streamer_write_record_start (ob, LTO_null);
2185 output_cfg (ob, fn);
2187 loop_optimizer_finalize ();
2188 pop_cfun ();
2190 else
2191 streamer_write_uhwi (ob, 0);
2193 /* Create a section to hold the pickled output of this function. */
2194 produce_asm (ob, function);
2196 destroy_output_block (ob);
2197 if (streamer_dump_file)
2198 fprintf (streamer_dump_file, "Finished streaming %s\n",
2199 node->name ());
2202 /* Output the body of function NODE->DECL. */
2204 static void
2205 output_constructor (struct varpool_node *node)
2207 tree var = node->decl;
2208 struct output_block *ob;
2210 if (streamer_dump_file)
2211 fprintf (streamer_dump_file, "\nStreaming constructor of %s\n",
2212 node->name ());
2214 ob = create_output_block (LTO_section_function_body);
2216 clear_line_info (ob);
2217 ob->symbol = node;
2219 /* Make string 0 be a NULL string. */
2220 streamer_write_char_stream (ob->string_stream, 0);
2222 /* Output DECL_INITIAL for the function, which contains the tree of
2223 lexical scopes. */
2224 stream_write_tree (ob, DECL_INITIAL (var), true);
2226 /* Create a section to hold the pickled output of this function. */
2227 produce_asm (ob, var);
2229 destroy_output_block (ob);
2230 if (streamer_dump_file)
2231 fprintf (streamer_dump_file, "Finished streaming %s\n",
2232 node->name ());
2236 /* Emit toplevel asms. */
2238 void
2239 lto_output_toplevel_asms (void)
2241 struct output_block *ob;
2242 struct asm_node *can;
2243 char *section_name;
2244 struct lto_simple_header_with_strings header;
2246 if (!symtab->first_asm_symbol ())
2247 return;
2249 ob = create_output_block (LTO_section_asm);
2251 /* Make string 0 be a NULL string. */
2252 streamer_write_char_stream (ob->string_stream, 0);
2254 for (can = symtab->first_asm_symbol (); can; can = can->next)
2256 streamer_write_string_cst (ob, ob->main_stream, can->asm_str);
2257 streamer_write_hwi (ob, can->order);
2260 streamer_write_string_cst (ob, ob->main_stream, NULL_TREE);
2262 section_name = lto_get_section_name (LTO_section_asm, NULL, NULL);
2263 lto_begin_section (section_name, !flag_wpa);
2264 free (section_name);
2266 /* The entire header stream is computed here. */
2267 memset (&header, 0, sizeof (header));
2269 /* Write the header. */
2270 header.major_version = LTO_major_version;
2271 header.minor_version = LTO_minor_version;
2273 header.main_size = ob->main_stream->total_size;
2274 header.string_size = ob->string_stream->total_size;
2275 lto_write_data (&header, sizeof header);
2277 /* Put all of the gimple and the string table out the asm file as a
2278 block of text. */
2279 lto_write_stream (ob->main_stream);
2280 lto_write_stream (ob->string_stream);
2282 lto_end_section ();
2284 destroy_output_block (ob);
2288 /* Copy the function body or variable constructor of NODE without deserializing. */
2290 static void
2291 copy_function_or_variable (struct symtab_node *node)
2293 tree function = node->decl;
2294 struct lto_file_decl_data *file_data = node->lto_file_data;
2295 const char *data;
2296 size_t len;
2297 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function));
2298 char *section_name =
2299 lto_get_section_name (LTO_section_function_body, name, NULL);
2300 size_t i, j;
2301 struct lto_in_decl_state *in_state;
2302 struct lto_out_decl_state *out_state = lto_get_out_decl_state ();
2304 if (streamer_dump_file)
2305 fprintf (streamer_dump_file, "Copying section for %s\n", name);
2306 lto_begin_section (section_name, false);
2307 free (section_name);
2309 /* We may have renamed the declaration, e.g., a static function. */
2310 name = lto_get_decl_name_mapping (file_data, name);
2312 data = lto_get_raw_section_data (file_data, LTO_section_function_body,
2313 name, &len);
2314 gcc_assert (data);
2316 /* Do a bit copy of the function body. */
2317 lto_write_raw_data (data, len);
2319 /* Copy decls. */
2320 in_state =
2321 lto_get_function_in_decl_state (node->lto_file_data, function);
2322 out_state->compressed = in_state->compressed;
2323 gcc_assert (in_state);
2325 for (i = 0; i < LTO_N_DECL_STREAMS; i++)
2327 size_t n = vec_safe_length (in_state->streams[i]);
2328 vec<tree, va_gc> *trees = in_state->streams[i];
2329 struct lto_tree_ref_encoder *encoder = &(out_state->streams[i]);
2331 /* The out state must have the same indices and the in state.
2332 So just copy the vector. All the encoders in the in state
2333 must be empty where we reach here. */
2334 gcc_assert (lto_tree_ref_encoder_size (encoder) == 0);
2335 encoder->trees.reserve_exact (n);
2336 for (j = 0; j < n; j++)
2337 encoder->trees.safe_push ((*trees)[j]);
2340 lto_free_raw_section_data (file_data, LTO_section_function_body, name,
2341 data, len);
2342 lto_end_section ();
2345 /* Wrap symbol references in *TP inside a type-preserving MEM_REF. */
2347 static tree
2348 wrap_refs (tree *tp, int *ws, void *)
2350 tree t = *tp;
2351 if (handled_component_p (t)
2352 && TREE_CODE (TREE_OPERAND (t, 0)) == VAR_DECL
2353 && TREE_PUBLIC (TREE_OPERAND (t, 0)))
2355 tree decl = TREE_OPERAND (t, 0);
2356 tree ptrtype = build_pointer_type (TREE_TYPE (decl));
2357 TREE_OPERAND (t, 0) = build2 (MEM_REF, TREE_TYPE (decl),
2358 build1 (ADDR_EXPR, ptrtype, decl),
2359 build_int_cst (ptrtype, 0));
2360 TREE_THIS_VOLATILE (TREE_OPERAND (t, 0)) = TREE_THIS_VOLATILE (decl);
2361 *ws = 0;
2363 else if (TREE_CODE (t) == CONSTRUCTOR)
2365 else if (!EXPR_P (t))
2366 *ws = 0;
2367 return NULL_TREE;
2370 /* Remove functions that are no longer used from offload_funcs, and mark the
2371 remaining ones with DECL_PRESERVE_P. */
2373 static void
2374 prune_offload_funcs (void)
2376 if (!offload_funcs)
2377 return;
2379 unsigned ix, ix2;
2380 tree *elem_ptr;
2381 VEC_ORDERED_REMOVE_IF (*offload_funcs, ix, ix2, elem_ptr,
2382 cgraph_node::get (*elem_ptr) == NULL);
2384 tree fn_decl;
2385 FOR_EACH_VEC_ELT (*offload_funcs, ix, fn_decl)
2386 DECL_PRESERVE_P (fn_decl) = 1;
2389 /* Main entry point from the pass manager. */
2391 void
2392 lto_output (void)
2394 struct lto_out_decl_state *decl_state;
2395 bitmap output = NULL;
2396 int i, n_nodes;
2397 lto_symtab_encoder_t encoder = lto_get_out_decl_state ()->symtab_node_encoder;
2399 prune_offload_funcs ();
2401 if (flag_checking)
2402 output = lto_bitmap_alloc ();
2404 /* Initialize the streamer. */
2405 lto_streamer_init ();
2407 n_nodes = lto_symtab_encoder_size (encoder);
2408 /* Process only the functions with bodies. */
2409 for (i = 0; i < n_nodes; i++)
2411 symtab_node *snode = lto_symtab_encoder_deref (encoder, i);
2412 if (cgraph_node *node = dyn_cast <cgraph_node *> (snode))
2414 if (lto_symtab_encoder_encode_body_p (encoder, node)
2415 && !node->alias
2416 && (!node->thunk.thunk_p || !node->thunk.add_pointer_bounds_args))
2418 if (flag_checking)
2420 gcc_assert (!bitmap_bit_p (output, DECL_UID (node->decl)));
2421 bitmap_set_bit (output, DECL_UID (node->decl));
2423 decl_state = lto_new_out_decl_state ();
2424 lto_push_out_decl_state (decl_state);
2425 if (gimple_has_body_p (node->decl)
2426 || (!flag_wpa
2427 && flag_incremental_link != INCREMENTAL_LINK_LTO)
2428 /* Thunks have no body but they may be synthetized
2429 at WPA time. */
2430 || DECL_ARGUMENTS (node->decl))
2431 output_function (node);
2432 else
2433 copy_function_or_variable (node);
2434 gcc_assert (lto_get_out_decl_state () == decl_state);
2435 lto_pop_out_decl_state ();
2436 lto_record_function_out_decl_state (node->decl, decl_state);
2439 else if (varpool_node *node = dyn_cast <varpool_node *> (snode))
2441 /* Wrap symbol references inside the ctor in a type
2442 preserving MEM_REF. */
2443 tree ctor = DECL_INITIAL (node->decl);
2444 if (ctor && !in_lto_p)
2445 walk_tree (&ctor, wrap_refs, NULL, NULL);
2446 if (get_symbol_initial_value (encoder, node->decl) == error_mark_node
2447 && lto_symtab_encoder_encode_initializer_p (encoder, node)
2448 && !node->alias)
2450 timevar_push (TV_IPA_LTO_CTORS_OUT);
2451 if (flag_checking)
2453 gcc_assert (!bitmap_bit_p (output, DECL_UID (node->decl)));
2454 bitmap_set_bit (output, DECL_UID (node->decl));
2456 decl_state = lto_new_out_decl_state ();
2457 lto_push_out_decl_state (decl_state);
2458 if (DECL_INITIAL (node->decl) != error_mark_node
2459 || (!flag_wpa
2460 && flag_incremental_link != INCREMENTAL_LINK_LTO))
2461 output_constructor (node);
2462 else
2463 copy_function_or_variable (node);
2464 gcc_assert (lto_get_out_decl_state () == decl_state);
2465 lto_pop_out_decl_state ();
2466 lto_record_function_out_decl_state (node->decl, decl_state);
2467 timevar_pop (TV_IPA_LTO_CTORS_OUT);
2472 /* Emit the callgraph after emitting function bodies. This needs to
2473 be done now to make sure that all the statements in every function
2474 have been renumbered so that edges can be associated with call
2475 statements using the statement UIDs. */
2476 output_symtab ();
2478 output_offload_tables ();
2480 #if CHECKING_P
2481 lto_bitmap_free (output);
2482 #endif
2485 /* Write each node in encoded by ENCODER to OB, as well as those reachable
2486 from it and required for correct representation of its semantics.
2487 Each node in ENCODER must be a global declaration or a type. A node
2488 is written only once, even if it appears multiple times in the
2489 vector. Certain transitively-reachable nodes, such as those
2490 representing expressions, may be duplicated, but such nodes
2491 must not appear in ENCODER itself. */
2493 static void
2494 write_global_stream (struct output_block *ob,
2495 struct lto_tree_ref_encoder *encoder)
2497 tree t;
2498 size_t index;
2499 const size_t size = lto_tree_ref_encoder_size (encoder);
2501 for (index = 0; index < size; index++)
2503 t = lto_tree_ref_encoder_get_tree (encoder, index);
2504 if (streamer_dump_file)
2506 fprintf (streamer_dump_file, " %i:", (int)index);
2507 print_node_brief (streamer_dump_file, "", t, 4);
2508 fprintf (streamer_dump_file, "\n");
2510 if (!streamer_tree_cache_lookup (ob->writer_cache, t, NULL))
2511 stream_write_tree (ob, t, false);
2516 /* Write a sequence of indices into the globals vector corresponding
2517 to the trees in ENCODER. These are used by the reader to map the
2518 indices used to refer to global entities within function bodies to
2519 their referents. */
2521 static void
2522 write_global_references (struct output_block *ob,
2523 struct lto_tree_ref_encoder *encoder)
2525 tree t;
2526 uint32_t index;
2527 const uint32_t size = lto_tree_ref_encoder_size (encoder);
2529 /* Write size and slot indexes as 32-bit unsigned numbers. */
2530 uint32_t *data = XNEWVEC (uint32_t, size + 1);
2531 data[0] = size;
2533 for (index = 0; index < size; index++)
2535 unsigned slot_num;
2537 t = lto_tree_ref_encoder_get_tree (encoder, index);
2538 streamer_tree_cache_lookup (ob->writer_cache, t, &slot_num);
2539 gcc_assert (slot_num != (unsigned)-1);
2540 data[index + 1] = slot_num;
2543 lto_write_data (data, sizeof (int32_t) * (size + 1));
2544 free (data);
2548 /* Write all the streams in an lto_out_decl_state STATE using
2549 output block OB and output stream OUT_STREAM. */
2551 void
2552 lto_output_decl_state_streams (struct output_block *ob,
2553 struct lto_out_decl_state *state)
2555 int i;
2557 for (i = 0; i < LTO_N_DECL_STREAMS; i++)
2558 write_global_stream (ob, &state->streams[i]);
2562 /* Write all the references in an lto_out_decl_state STATE using
2563 output block OB and output stream OUT_STREAM. */
2565 void
2566 lto_output_decl_state_refs (struct output_block *ob,
2567 struct lto_out_decl_state *state)
2569 unsigned i;
2570 unsigned ref;
2571 tree decl;
2573 /* Write reference to FUNCTION_DECL. If there is not function,
2574 write reference to void_type_node. */
2575 decl = (state->fn_decl) ? state->fn_decl : void_type_node;
2576 streamer_tree_cache_lookup (ob->writer_cache, decl, &ref);
2577 gcc_assert (ref != (unsigned)-1);
2578 ref = ref * 2 + (state->compressed ? 1 : 0);
2579 lto_write_data (&ref, sizeof (uint32_t));
2581 for (i = 0; i < LTO_N_DECL_STREAMS; i++)
2582 write_global_references (ob, &state->streams[i]);
2586 /* Return the written size of STATE. */
2588 static size_t
2589 lto_out_decl_state_written_size (struct lto_out_decl_state *state)
2591 int i;
2592 size_t size;
2594 size = sizeof (int32_t); /* fn_ref. */
2595 for (i = 0; i < LTO_N_DECL_STREAMS; i++)
2597 size += sizeof (int32_t); /* vector size. */
2598 size += (lto_tree_ref_encoder_size (&state->streams[i])
2599 * sizeof (int32_t));
2601 return size;
2605 /* Write symbol T into STREAM in CACHE. SEEN specifies symbols we wrote
2606 so far. */
2608 static void
2609 write_symbol (struct streamer_tree_cache_d *cache,
2610 tree t, hash_set<const char *> *seen, bool alias)
2612 const char *name;
2613 enum gcc_plugin_symbol_kind kind;
2614 enum gcc_plugin_symbol_visibility visibility = GCCPV_DEFAULT;
2615 unsigned slot_num;
2616 uint64_t size;
2617 const char *comdat;
2618 unsigned char c;
2620 gcc_checking_assert (TREE_PUBLIC (t)
2621 && !is_builtin_fn (t)
2622 && !DECL_ABSTRACT_P (t)
2623 && (!VAR_P (t) || !DECL_HARD_REGISTER (t)));
2625 gcc_assert (VAR_OR_FUNCTION_DECL_P (t));
2627 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t));
2629 /* This behaves like assemble_name_raw in varasm.c, performing the
2630 same name manipulations that ASM_OUTPUT_LABELREF does. */
2631 name = IDENTIFIER_POINTER ((*targetm.asm_out.mangle_assembler_name) (name));
2633 if (seen->add (name))
2634 return;
2636 streamer_tree_cache_lookup (cache, t, &slot_num);
2637 gcc_assert (slot_num != (unsigned)-1);
2639 if (DECL_EXTERNAL (t))
2641 if (DECL_WEAK (t))
2642 kind = GCCPK_WEAKUNDEF;
2643 else
2644 kind = GCCPK_UNDEF;
2646 else
2648 if (DECL_WEAK (t))
2649 kind = GCCPK_WEAKDEF;
2650 else if (DECL_COMMON (t))
2651 kind = GCCPK_COMMON;
2652 else
2653 kind = GCCPK_DEF;
2655 /* When something is defined, it should have node attached. */
2656 gcc_assert (alias || !VAR_P (t) || varpool_node::get (t)->definition);
2657 gcc_assert (alias || TREE_CODE (t) != FUNCTION_DECL
2658 || (cgraph_node::get (t)
2659 && cgraph_node::get (t)->definition));
2662 /* Imitate what default_elf_asm_output_external do.
2663 When symbol is external, we need to output it with DEFAULT visibility
2664 when compiling with -fvisibility=default, while with HIDDEN visibility
2665 when symbol has attribute (visibility("hidden")) specified.
2666 targetm.binds_local_p check DECL_VISIBILITY_SPECIFIED and gets this
2667 right. */
2669 if (DECL_EXTERNAL (t)
2670 && !targetm.binds_local_p (t))
2671 visibility = GCCPV_DEFAULT;
2672 else
2673 switch (DECL_VISIBILITY (t))
2675 case VISIBILITY_DEFAULT:
2676 visibility = GCCPV_DEFAULT;
2677 break;
2678 case VISIBILITY_PROTECTED:
2679 visibility = GCCPV_PROTECTED;
2680 break;
2681 case VISIBILITY_HIDDEN:
2682 visibility = GCCPV_HIDDEN;
2683 break;
2684 case VISIBILITY_INTERNAL:
2685 visibility = GCCPV_INTERNAL;
2686 break;
2689 if (kind == GCCPK_COMMON
2690 && DECL_SIZE_UNIT (t)
2691 && TREE_CODE (DECL_SIZE_UNIT (t)) == INTEGER_CST)
2692 size = TREE_INT_CST_LOW (DECL_SIZE_UNIT (t));
2693 else
2694 size = 0;
2696 if (DECL_ONE_ONLY (t))
2697 comdat = IDENTIFIER_POINTER (decl_comdat_group_id (t));
2698 else
2699 comdat = "";
2701 lto_write_data (name, strlen (name) + 1);
2702 lto_write_data (comdat, strlen (comdat) + 1);
2703 c = (unsigned char) kind;
2704 lto_write_data (&c, 1);
2705 c = (unsigned char) visibility;
2706 lto_write_data (&c, 1);
2707 lto_write_data (&size, 8);
2708 lto_write_data (&slot_num, 4);
2711 /* Write an IL symbol table to OB.
2712 SET and VSET are cgraph/varpool node sets we are outputting. */
2714 static void
2715 produce_symtab (struct output_block *ob)
2717 struct streamer_tree_cache_d *cache = ob->writer_cache;
2718 char *section_name = lto_get_section_name (LTO_section_symtab, NULL, NULL);
2719 lto_symtab_encoder_t encoder = ob->decl_state->symtab_node_encoder;
2720 lto_symtab_encoder_iterator lsei;
2722 lto_begin_section (section_name, false);
2723 free (section_name);
2725 hash_set<const char *> seen;
2727 /* Write the symbol table.
2728 First write everything defined and then all declarations.
2729 This is necessary to handle cases where we have duplicated symbols. */
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 ())
2736 continue;
2737 write_symbol (cache, node->decl, &seen, false);
2739 for (lsei = lsei_start (encoder);
2740 !lsei_end_p (lsei); lsei_next (&lsei))
2742 symtab_node *node = lsei_node (lsei);
2744 if (!DECL_EXTERNAL (node->decl) || !node->output_to_lto_symbol_table_p ())
2745 continue;
2746 write_symbol (cache, node->decl, &seen, false);
2749 lto_end_section ();
2753 /* Init the streamer_mode_table for output, where we collect info on what
2754 machine_mode values have been streamed. */
2755 void
2756 lto_output_init_mode_table (void)
2758 memset (streamer_mode_table, '\0', MAX_MACHINE_MODE);
2762 /* Write the mode table. */
2763 static void
2764 lto_write_mode_table (void)
2766 struct output_block *ob;
2767 ob = create_output_block (LTO_section_mode_table);
2768 bitpack_d bp = bitpack_create (ob->main_stream);
2770 /* Ensure that for GET_MODE_INNER (m) != m we have
2771 also the inner mode marked. */
2772 for (int i = 0; i < (int) MAX_MACHINE_MODE; i++)
2773 if (streamer_mode_table[i])
2775 machine_mode m = (machine_mode) i;
2776 machine_mode inner_m = GET_MODE_INNER (m);
2777 if (inner_m != m)
2778 streamer_mode_table[(int) inner_m] = 1;
2780 /* First stream modes that have GET_MODE_INNER (m) == m,
2781 so that we can refer to them afterwards. */
2782 for (int pass = 0; pass < 2; pass++)
2783 for (int i = 0; i < (int) MAX_MACHINE_MODE; i++)
2784 if (streamer_mode_table[i] && i != (int) VOIDmode && i != (int) BLKmode)
2786 machine_mode m = (machine_mode) i;
2787 if ((GET_MODE_INNER (m) == m) ^ (pass == 0))
2788 continue;
2789 bp_pack_value (&bp, m, 8);
2790 bp_pack_enum (&bp, mode_class, MAX_MODE_CLASS, GET_MODE_CLASS (m));
2791 bp_pack_poly_value (&bp, GET_MODE_SIZE (m), 16);
2792 bp_pack_poly_value (&bp, GET_MODE_PRECISION (m), 16);
2793 bp_pack_value (&bp, GET_MODE_INNER (m), 8);
2794 bp_pack_poly_value (&bp, GET_MODE_NUNITS (m), 16);
2795 switch (GET_MODE_CLASS (m))
2797 case MODE_FRACT:
2798 case MODE_UFRACT:
2799 case MODE_ACCUM:
2800 case MODE_UACCUM:
2801 bp_pack_value (&bp, GET_MODE_IBIT (m), 8);
2802 bp_pack_value (&bp, GET_MODE_FBIT (m), 8);
2803 break;
2804 case MODE_FLOAT:
2805 case MODE_DECIMAL_FLOAT:
2806 bp_pack_string (ob, &bp, REAL_MODE_FORMAT (m)->name, true);
2807 break;
2808 default:
2809 break;
2811 bp_pack_string (ob, &bp, GET_MODE_NAME (m), true);
2813 bp_pack_value (&bp, VOIDmode, 8);
2815 streamer_write_bitpack (&bp);
2817 char *section_name
2818 = lto_get_section_name (LTO_section_mode_table, NULL, NULL);
2819 lto_begin_section (section_name, !flag_wpa);
2820 free (section_name);
2822 /* The entire header stream is computed here. */
2823 struct lto_simple_header_with_strings header;
2824 memset (&header, 0, sizeof (header));
2826 /* Write the header. */
2827 header.major_version = LTO_major_version;
2828 header.minor_version = LTO_minor_version;
2830 header.main_size = ob->main_stream->total_size;
2831 header.string_size = ob->string_stream->total_size;
2832 lto_write_data (&header, sizeof header);
2834 /* Put all of the gimple and the string table out the asm file as a
2835 block of text. */
2836 lto_write_stream (ob->main_stream);
2837 lto_write_stream (ob->string_stream);
2839 lto_end_section ();
2840 destroy_output_block (ob);
2844 /* This pass is run after all of the functions are serialized and all
2845 of the IPA passes have written their serialized forms. This pass
2846 causes the vector of all of the global decls and types used from
2847 this file to be written in to a section that can then be read in to
2848 recover these on other side. */
2850 void
2851 produce_asm_for_decls (void)
2853 struct lto_out_decl_state *out_state;
2854 struct lto_out_decl_state *fn_out_state;
2855 struct lto_decl_header header;
2856 char *section_name;
2857 struct output_block *ob;
2858 unsigned idx, num_fns;
2859 size_t decl_state_size;
2860 int32_t num_decl_states;
2862 ob = create_output_block (LTO_section_decls);
2864 memset (&header, 0, sizeof (struct lto_decl_header));
2866 section_name = lto_get_section_name (LTO_section_decls, NULL, NULL);
2867 lto_begin_section (section_name, !flag_wpa);
2868 free (section_name);
2870 /* Make string 0 be a NULL string. */
2871 streamer_write_char_stream (ob->string_stream, 0);
2873 gcc_assert (!alias_pairs);
2875 /* Get rid of the global decl state hash tables to save some memory. */
2876 out_state = lto_get_out_decl_state ();
2877 for (int i = 0; i < LTO_N_DECL_STREAMS; i++)
2878 if (out_state->streams[i].tree_hash_table)
2880 delete out_state->streams[i].tree_hash_table;
2881 out_state->streams[i].tree_hash_table = NULL;
2884 /* Write the global symbols. */
2885 if (streamer_dump_file)
2886 fprintf (streamer_dump_file, "Outputting global stream\n");
2887 lto_output_decl_state_streams (ob, out_state);
2888 num_fns = lto_function_decl_states.length ();
2889 for (idx = 0; idx < num_fns; idx++)
2891 fn_out_state =
2892 lto_function_decl_states[idx];
2893 if (streamer_dump_file)
2894 fprintf (streamer_dump_file, "Outputting stream for %s\n",
2895 IDENTIFIER_POINTER
2896 (DECL_ASSEMBLER_NAME (fn_out_state->fn_decl)));
2897 lto_output_decl_state_streams (ob, fn_out_state);
2900 header.major_version = LTO_major_version;
2901 header.minor_version = LTO_minor_version;
2903 /* Currently not used. This field would allow us to preallocate
2904 the globals vector, so that it need not be resized as it is extended. */
2905 header.num_nodes = -1;
2907 /* Compute the total size of all decl out states. */
2908 decl_state_size = sizeof (int32_t);
2909 decl_state_size += lto_out_decl_state_written_size (out_state);
2910 for (idx = 0; idx < num_fns; idx++)
2912 fn_out_state =
2913 lto_function_decl_states[idx];
2914 decl_state_size += lto_out_decl_state_written_size (fn_out_state);
2916 header.decl_state_size = decl_state_size;
2918 header.main_size = ob->main_stream->total_size;
2919 header.string_size = ob->string_stream->total_size;
2921 lto_write_data (&header, sizeof header);
2923 /* Write the main out-decl state, followed by out-decl states of
2924 functions. */
2925 num_decl_states = num_fns + 1;
2926 lto_write_data (&num_decl_states, sizeof (num_decl_states));
2927 lto_output_decl_state_refs (ob, out_state);
2928 for (idx = 0; idx < num_fns; idx++)
2930 fn_out_state = lto_function_decl_states[idx];
2931 lto_output_decl_state_refs (ob, fn_out_state);
2934 lto_write_stream (ob->main_stream);
2935 lto_write_stream (ob->string_stream);
2937 lto_end_section ();
2939 /* Write the symbol table. It is used by linker to determine dependencies
2940 and thus we can skip it for WPA. */
2941 if (!flag_wpa)
2942 produce_symtab (ob);
2944 /* Write command line opts. */
2945 lto_write_options ();
2947 /* Deallocate memory and clean up. */
2948 for (idx = 0; idx < num_fns; idx++)
2950 fn_out_state =
2951 lto_function_decl_states[idx];
2952 lto_delete_out_decl_state (fn_out_state);
2954 lto_symtab_encoder_delete (ob->decl_state->symtab_node_encoder);
2955 lto_function_decl_states.release ();
2956 destroy_output_block (ob);
2957 if (lto_stream_offload_p)
2958 lto_write_mode_table ();