Branch data Line data Source code
1 : : /* Write the GIMPLE representation to a file stream.
2 : :
3 : : Copyright (C) 2009-2025 Free Software Foundation, Inc.
4 : : Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
5 : : Re-implemented by Diego Novillo <dnovillo@google.com>
6 : :
7 : : This file is part of GCC.
8 : :
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.
13 : :
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.
18 : :
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/>. */
22 : :
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"
46 : : #include "tree-dfa.h"
47 : : #include "file-prefix-map.h" /* remap_debug_filename() */
48 : : #include "output.h"
49 : : #include "ipa-utils.h"
50 : : #include "toplev.h"
51 : :
52 : :
53 : : static void lto_write_tree (struct output_block*, tree, bool);
54 : :
55 : : /* Clear the line info stored in DATA_IN. */
56 : :
57 : : static void
58 : 325469 : clear_line_info (struct output_block *ob)
59 : : {
60 : 325469 : ob->current_file = NULL;
61 : 325469 : ob->current_line = 0;
62 : 325469 : ob->current_col = 0;
63 : 325469 : ob->current_sysp = false;
64 : 325469 : ob->reset_locus = true;
65 : 325469 : ob->emit_pwd = true;
66 : : /* Initialize to something that will never appear as block,
67 : : so that the first location with block in a function etc.
68 : : always streams a change_block bit and the first block. */
69 : 325469 : ob->current_block = void_node;
70 : 325469 : ob->current_discr = UINT_MAX;
71 : 0 : }
72 : :
73 : :
74 : : /* Create the output block and return it. SECTION_TYPE is
75 : : LTO_section_function_body or LTO_static_initializer. */
76 : :
77 : : struct output_block *
78 : 325469 : create_output_block (enum lto_section_type section_type)
79 : : {
80 : 325469 : struct output_block *ob = XCNEW (struct output_block);
81 : 325469 : if (streamer_dump_file)
82 : 40 : fprintf (streamer_dump_file, "Creating output block for %s\n",
83 : 40 : lto_section_name[section_type]);
84 : :
85 : 325469 : ob->section_type = section_type;
86 : 325469 : ob->decl_state = lto_get_out_decl_state ();
87 : : /* Only global decl stream in non-wpa will ever be considered by tree
88 : : merging. */
89 : 325469 : if (!flag_wpa && section_type == LTO_section_decls)
90 : 24263 : ob->local_trees = new (hash_set <tree>);
91 : 325469 : ob->main_stream = XCNEW (struct lto_output_stream);
92 : 325469 : ob->string_stream = XCNEW (struct lto_output_stream);
93 : 325469 : ob->writer_cache = streamer_tree_cache_create (!flag_wpa, true, false);
94 : :
95 : 325469 : if (section_type == LTO_section_function_body)
96 : 119051 : ob->cfg_stream = XCNEW (struct lto_output_stream);
97 : :
98 : 325469 : clear_line_info (ob);
99 : :
100 : 325469 : ob->string_hash_table = new hash_table<string_slot_hasher> (37);
101 : 325469 : gcc_obstack_init (&ob->obstack);
102 : :
103 : 325469 : return ob;
104 : : }
105 : :
106 : :
107 : : /* Destroy the output block OB. */
108 : :
109 : : void
110 : 325469 : destroy_output_block (struct output_block *ob)
111 : : {
112 : 325469 : enum lto_section_type section_type = ob->section_type;
113 : :
114 : 325469 : delete ob->string_hash_table;
115 : 325469 : ob->string_hash_table = NULL;
116 : 349732 : delete ob->local_trees;
117 : :
118 : 325469 : free (ob->main_stream);
119 : 325469 : free (ob->string_stream);
120 : 325469 : if (section_type == LTO_section_function_body)
121 : 119051 : free (ob->cfg_stream);
122 : :
123 : 325469 : streamer_tree_cache_delete (ob->writer_cache);
124 : 325469 : obstack_free (&ob->obstack, NULL);
125 : :
126 : 325469 : free (ob);
127 : 325469 : }
128 : :
129 : :
130 : : /* Wrapper around variably_modified_type_p avoiding type modification
131 : : during WPA streaming. */
132 : :
133 : : bool
134 : 14193801 : lto_variably_modified_type_p (tree type)
135 : : {
136 : 14193801 : return (in_lto_p
137 : 14193801 : ? TYPE_LANG_FLAG_0 (TYPE_MAIN_VARIANT (type))
138 : 13903448 : : variably_modified_type_p (type, NULL_TREE));
139 : : }
140 : :
141 : :
142 : : /* Return true if tree node T is written to various tables. For these
143 : : nodes, we sometimes want to write their phyiscal representation
144 : : (via lto_output_tree), and sometimes we need to emit an index
145 : : reference into a table (via lto_output_tree_ref). */
146 : :
147 : : static bool
148 : 35485582 : tree_is_indexable (tree t)
149 : : {
150 : : /* Parameters and return values of functions of variably modified types
151 : : must go to global stream, because they may be used in the type
152 : : definition. */
153 : 34389129 : if ((TREE_CODE (t) == PARM_DECL || TREE_CODE (t) == RESULT_DECL)
154 : 35816258 : && DECL_CONTEXT (t))
155 : 1427129 : return lto_variably_modified_type_p (TREE_TYPE (DECL_CONTEXT (t)));
156 : : /* IMPORTED_DECL is put into BLOCK and thus it never can be shared.
157 : : We should no longer need to stream it. */
158 : 34058453 : else if (TREE_CODE (t) == IMPORTED_DECL)
159 : 0 : gcc_unreachable ();
160 : 34058453 : else if (TREE_CODE (t) == LABEL_DECL)
161 : 83608 : return FORCED_LABEL (t) || DECL_NONLOCAL (t);
162 : 1643869 : else if (((VAR_P (t) && !TREE_STATIC (t))
163 : : || TREE_CODE (t) == TYPE_DECL
164 : : || TREE_CODE (t) == CONST_DECL
165 : : || TREE_CODE (t) == NAMELIST_DECL)
166 : 34845016 : && decl_function_context (t))
167 : : return false;
168 : 33114331 : else if (TREE_CODE (t) == DEBUG_EXPR_DECL)
169 : : return false;
170 : : /* Variably modified types need to be streamed alongside function
171 : : bodies because they can refer to local entities. Together with
172 : : them we have to localize their members as well.
173 : : ??? In theory that includes non-FIELD_DECLs as well. */
174 : 33112443 : else if (TYPE_P (t)
175 : 33112443 : && lto_variably_modified_type_p (t))
176 : : return false;
177 : 33101110 : else if (TREE_CODE (t) == FIELD_DECL
178 : 33101110 : && lto_variably_modified_type_p (DECL_CONTEXT (t)))
179 : : return false;
180 : : else
181 : 53689164 : return (IS_TYPE_OR_DECL_P (t) || TREE_CODE (t) == SSA_NAME);
182 : : }
183 : :
184 : :
185 : : /* Output info about new location into bitpack BP.
186 : : After outputting bitpack, lto_output_location_data has
187 : : to be done to output actual data. */
188 : :
189 : : static void
190 : 6756480 : lto_output_location_1 (struct output_block *ob, struct bitpack_d *bp,
191 : : location_t orig_loc, bool block_p)
192 : : {
193 : 6756480 : location_t loc = LOCATION_LOCUS (orig_loc);
194 : :
195 : 6756480 : if (loc >= RESERVED_LOCATION_COUNT)
196 : : {
197 : 4355028 : expanded_location xloc = expand_location (loc);
198 : 4355028 : unsigned discr = get_discriminator_from_loc (orig_loc);
199 : :
200 : 4355028 : if (ob->reset_locus)
201 : : {
202 : 141735 : if (xloc.file == NULL)
203 : 0 : ob->current_file = "";
204 : 141735 : if (xloc.line == 0)
205 : 0 : ob->current_line = 1;
206 : 141735 : if (xloc.column == 0)
207 : 4 : ob->current_col = 1;
208 : 141735 : ob->reset_locus = false;
209 : : }
210 : :
211 : : /* As RESERVED_LOCATION_COUNT is 2, we can use the spare value of
212 : : 3 without wasting additional bits to signalize file change.
213 : : If RESERVED_LOCATION_COUNT changes, reconsider this. */
214 : 4355028 : gcc_checking_assert (RESERVED_LOCATION_COUNT == 2);
215 : 4355028 : bp_pack_int_in_range (bp, 0, RESERVED_LOCATION_COUNT + 1,
216 : : RESERVED_LOCATION_COUNT
217 : 4355028 : + (ob->current_file != xloc.file));
218 : :
219 : 4355028 : bp_pack_value (bp, ob->current_line != xloc.line, 1);
220 : 4355028 : bp_pack_value (bp, ob->current_col != xloc.column, 1);
221 : 4355028 : bp_pack_value (bp, ob->current_discr != discr, 1);
222 : :
223 : 4355028 : if (ob->current_file != xloc.file)
224 : : {
225 : 217365 : bool stream_pwd = false;
226 : 217365 : const char *remapped = remap_debug_filename (xloc.file);
227 : 217365 : if (ob->emit_pwd && remapped && !IS_ABSOLUTE_PATH (remapped))
228 : : {
229 : 9736 : stream_pwd = true;
230 : 9736 : ob->emit_pwd = false;
231 : : }
232 : 217365 : bp_pack_value (bp, stream_pwd, 1);
233 : 217365 : if (stream_pwd)
234 : 9736 : bp_pack_string (ob, bp, get_src_pwd (), true);
235 : 217365 : bp_pack_string (ob, bp, remapped, true);
236 : 217365 : bp_pack_value (bp, xloc.sysp, 1);
237 : : }
238 : 4355028 : ob->current_file = xloc.file;
239 : 4355028 : ob->current_sysp = xloc.sysp;
240 : :
241 : 4355028 : if (ob->current_line != xloc.line)
242 : 1406502 : bp_pack_var_len_unsigned (bp, xloc.line);
243 : 4355028 : ob->current_line = xloc.line;
244 : :
245 : 4355028 : if (ob->current_col != xloc.column)
246 : 1692001 : bp_pack_var_len_unsigned (bp, xloc.column);
247 : 4355028 : ob->current_col = xloc.column;
248 : :
249 : 4355028 : if (ob->current_discr != discr)
250 : 1311813 : bp_pack_var_len_unsigned (bp, discr);
251 : 4355028 : ob->current_discr = discr;
252 : : }
253 : : else
254 : 2401452 : bp_pack_int_in_range (bp, 0, RESERVED_LOCATION_COUNT + 1, loc);
255 : :
256 : 6756480 : if (block_p)
257 : : {
258 : 2950070 : tree block = LOCATION_BLOCK (orig_loc);
259 : 2950070 : bp_pack_value (bp, ob->current_block != block, 1);
260 : 2950070 : streamer_write_bitpack (bp);
261 : 2950070 : if (ob->current_block != block)
262 : 749329 : lto_output_tree (ob, block, true, true);
263 : 2950070 : ob->current_block = block;
264 : : }
265 : 6756480 : }
266 : :
267 : : /* Output info about new location into bitpack BP.
268 : : After outputting bitpack, lto_output_location_data has
269 : : to be done to output actual data. */
270 : :
271 : : void
272 : 3806410 : lto_output_location (struct output_block *ob, struct bitpack_d *bp,
273 : : location_t loc)
274 : : {
275 : 3806410 : lto_output_location_1 (ob, bp, loc, false);
276 : 3806410 : }
277 : :
278 : : /* Output info about new location into bitpack BP.
279 : : After outputting bitpack, lto_output_location_data has
280 : : to be done to output actual data. Like lto_output_location, but
281 : : additionally output LOCATION_BLOCK info too and write the BP bitpack. */
282 : :
283 : : void
284 : 2950070 : lto_output_location_and_block (struct output_block *ob, struct bitpack_d *bp,
285 : : location_t loc)
286 : : {
287 : 2950070 : lto_output_location_1 (ob, bp, loc, true);
288 : 2950070 : }
289 : :
290 : :
291 : : /* Lookup NAME in ENCODER. If NAME is not found, create a new entry in
292 : : ENCODER for NAME with the next available index of ENCODER, then
293 : : print the index to OBS.
294 : : Return the index. */
295 : :
296 : :
297 : : static unsigned
298 : 7916790 : lto_get_index (struct lto_tree_ref_encoder *encoder, tree t)
299 : : {
300 : 7916790 : bool existed_p;
301 : :
302 : 7916790 : unsigned int &index
303 : 7916790 : = encoder->tree_hash_table->get_or_insert (t, &existed_p);
304 : 7916790 : if (!existed_p)
305 : : {
306 : 2170720 : index = encoder->trees.length ();
307 : 2170720 : if (streamer_dump_file)
308 : : {
309 : 176 : print_node_brief (streamer_dump_file, " Encoding indexable ",
310 : : t, 4);
311 : 176 : fprintf (streamer_dump_file, " as %i \n", index);
312 : : }
313 : 2170720 : encoder->trees.safe_push (t);
314 : : }
315 : :
316 : 7916790 : return index;
317 : : }
318 : :
319 : :
320 : : /* If EXPR is an indexable tree node, output a reference to it to
321 : : output block OB. Otherwise, output the physical representation of
322 : : EXPR to OB. */
323 : :
324 : : static void
325 : 9387701 : lto_indexable_tree_ref (struct output_block *ob, tree expr,
326 : : enum LTO_tags *tag, unsigned *index)
327 : : {
328 : 9387701 : gcc_checking_assert (tree_is_indexable (expr));
329 : :
330 : 9387701 : if (TREE_CODE (expr) == SSA_NAME)
331 : : {
332 : 2185574 : *tag = LTO_ssa_name_ref;
333 : 2185574 : *index = SSA_NAME_VERSION (expr);
334 : : }
335 : : else
336 : : {
337 : 7202127 : *tag = LTO_global_stream_ref;
338 : 7202127 : *index = lto_get_index (&ob->decl_state->streams[LTO_DECL_STREAM], expr);
339 : : }
340 : 9387701 : }
341 : :
342 : :
343 : : /* Output a static or extern var DECL to OBS. */
344 : :
345 : : void
346 : 288126 : lto_output_var_decl_ref (struct lto_out_decl_state *decl_state,
347 : : struct lto_output_stream * obs, tree decl)
348 : : {
349 : 288126 : gcc_checking_assert (VAR_P (decl));
350 : 288126 : streamer_write_uhwi_stream
351 : 288126 : (obs, lto_get_index (&decl_state->streams[LTO_DECL_STREAM],
352 : : decl));
353 : 288126 : }
354 : :
355 : :
356 : : /* Output a static or extern var DECL to OBS. */
357 : :
358 : : void
359 : 426537 : lto_output_fn_decl_ref (struct lto_out_decl_state *decl_state,
360 : : struct lto_output_stream * obs, tree decl)
361 : : {
362 : 426537 : gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL);
363 : 426537 : streamer_write_uhwi_stream
364 : 426537 : (obs, lto_get_index (&decl_state->streams[LTO_DECL_STREAM], decl));
365 : 426537 : }
366 : :
367 : : /* Return true if EXPR is a tree node that can be written to disk. */
368 : :
369 : : static inline bool
370 : 7023147 : lto_is_streamable (tree expr)
371 : : {
372 : 7023147 : enum tree_code code = TREE_CODE (expr);
373 : :
374 : : /* Notice that we reject SSA_NAMEs as well. We only emit the SSA
375 : : name version in lto_output_tree_ref (see output_ssa_names). */
376 : 7023147 : return !is_lang_specific (expr)
377 : 7023147 : && code != SSA_NAME
378 : 7023147 : && code != LANG_TYPE
379 : : && code != MODIFY_EXPR
380 : 7023147 : && code != INIT_EXPR
381 : 7023147 : && code != TARGET_EXPR
382 : 7023147 : && code != BIND_EXPR
383 : 7023147 : && code != WITH_CLEANUP_EXPR
384 : 7023147 : && code != STATEMENT_LIST
385 : 7023147 : && (code == CASE_LABEL_EXPR
386 : 7023147 : || code == DECL_EXPR
387 : 7015268 : || TREE_CODE_CLASS (code) != tcc_statement);
388 : : }
389 : :
390 : : /* Very rough estimate of streaming size of the initializer. If we ignored
391 : : presence of strings, we could simply just count number of non-indexable
392 : : tree nodes and number of references to indexable nodes. Strings however
393 : : may be very large and we do not want to dump them int othe global stream.
394 : :
395 : : Count the size of initializer until the size in DATA is positive. */
396 : :
397 : : static tree
398 : 100131 : subtract_estimated_size (tree *tp, int *ws, void *data)
399 : : {
400 : 100131 : long *sum = (long *)data;
401 : 100131 : if (tree_is_indexable (*tp))
402 : : {
403 : : /* Indexable tree is one reference to global stream.
404 : : Guess it may be about 4 bytes. */
405 : 1557 : *sum -= 4;
406 : 1557 : *ws = 0;
407 : : }
408 : : /* String table entry + base of tree node needs to be streamed. */
409 : 100131 : if (TREE_CODE (*tp) == STRING_CST)
410 : 7590 : *sum -= TREE_STRING_LENGTH (*tp) + 8;
411 : : else
412 : : {
413 : : /* Identifiers are also variable length but should not appear
414 : : naked in constructor. */
415 : 92541 : gcc_checking_assert (TREE_CODE (*tp) != IDENTIFIER_NODE);
416 : : /* We do not really make attempt to work out size of pickled tree, as
417 : : it is very variable. Make it bigger than the reference. */
418 : 92541 : *sum -= 16;
419 : : }
420 : 100131 : if (*sum < 0)
421 : 32772 : return *tp;
422 : : return NULL_TREE;
423 : : }
424 : :
425 : :
426 : : /* For EXPR lookup and return what we want to stream to OB as DECL_INITIAL. */
427 : :
428 : : static tree
429 : 2415705 : get_symbol_initial_value (lto_symtab_encoder_t encoder, tree expr)
430 : : {
431 : 2415705 : gcc_checking_assert (DECL_P (expr)
432 : : && TREE_CODE (expr) != FUNCTION_DECL
433 : : && TREE_CODE (expr) != TRANSLATION_UNIT_DECL);
434 : :
435 : : /* Handle DECL_INITIAL for symbols. */
436 : 2415705 : tree initial = DECL_INITIAL (expr);
437 : 2415705 : if (VAR_P (expr)
438 : 1200993 : && (TREE_STATIC (expr) || DECL_EXTERNAL (expr))
439 : 856993 : && !DECL_IN_CONSTANT_POOL (expr)
440 : 3272566 : && initial)
441 : : {
442 : 84779 : varpool_node *vnode;
443 : : /* Extra section needs about 30 bytes; do not produce it for simple
444 : : scalar values. */
445 : 84779 : if (!(vnode = varpool_node::get (expr))
446 : 84779 : || !lto_symtab_encoder_encode_initializer_p (encoder, vnode))
447 : 3195 : initial = error_mark_node;
448 : 84779 : if (initial != error_mark_node)
449 : : {
450 : 68232 : long max_size = 30;
451 : 68232 : if (walk_tree (&initial, subtract_estimated_size, (void *)&max_size,
452 : : NULL))
453 : 32772 : initial = error_mark_node;
454 : : }
455 : : }
456 : :
457 : 2415705 : return initial;
458 : : }
459 : :
460 : :
461 : : /* Output reference to tree T to the stream.
462 : : Assume that T is already in encoder cache.
463 : : This is used to stream tree bodies where we know the DFS walk arranged
464 : : everything to cache. Must be matched with stream_read_tree_ref. */
465 : :
466 : : void
467 : 31774258 : stream_write_tree_ref (struct output_block *ob, tree t)
468 : : {
469 : 31774258 : if (!t)
470 : 12128649 : streamer_write_zero (ob);
471 : : else
472 : : {
473 : 19645609 : unsigned int ix;
474 : 19645609 : bool existed_p = streamer_tree_cache_lookup (ob->writer_cache, t, &ix);
475 : 19645609 : if (existed_p)
476 : 15232696 : streamer_write_hwi (ob, ix + 1);
477 : : else
478 : : {
479 : 4412913 : enum LTO_tags tag;
480 : 4412913 : unsigned ix;
481 : 4412913 : int id = 0;
482 : :
483 : 4412913 : lto_indexable_tree_ref (ob, t, &tag, &ix);
484 : 4412913 : if (tag == LTO_ssa_name_ref)
485 : : id = 1;
486 : : else
487 : 4212350 : gcc_checking_assert (tag == LTO_global_stream_ref);
488 : 4412913 : streamer_write_hwi (ob, -(int)(ix * 2 + id + 1));
489 : : }
490 : : }
491 : 31774258 : }
492 : :
493 : :
494 : :
495 : : /* Write a physical representation of tree node EXPR to output block
496 : : OB. If REF_P is true, the leaves of EXPR are emitted as references
497 : : via lto_output_tree_ref. IX is the index into the streamer cache
498 : : where EXPR is stored. */
499 : :
500 : : static void
501 : 7023147 : lto_write_tree_1 (struct output_block *ob, tree expr, bool ref_p)
502 : : {
503 : 7023147 : if (streamer_dump_file)
504 : : {
505 : 416 : print_node_brief (streamer_dump_file, " Streaming body of ",
506 : : expr, 4);
507 : 416 : fprintf (streamer_dump_file, " to %s\n",
508 : 416 : lto_section_name[ob->section_type]);
509 : : }
510 : :
511 : : /* Pack all the non-pointer fields in EXPR into a bitpack and write
512 : : the resulting bitpack. */
513 : 7023147 : streamer_write_tree_bitfields (ob, expr);
514 : :
515 : : /* Write all the pointer fields in EXPR. */
516 : 7023147 : streamer_write_tree_body (ob, expr);
517 : :
518 : : /* Write any LTO-specific data to OB. */
519 : 7023147 : if (DECL_P (expr)
520 : 1528311 : && TREE_CODE (expr) != FUNCTION_DECL
521 : 1097716 : && TREE_CODE (expr) != TRANSLATION_UNIT_DECL)
522 : : {
523 : : /* Handle DECL_INITIAL for symbols. */
524 : 1063845 : tree initial = get_symbol_initial_value
525 : 1063845 : (ob->decl_state->symtab_node_encoder, expr);
526 : 1063845 : stream_write_tree (ob, initial, ref_p);
527 : : }
528 : :
529 : : /* Stream references to early generated DIEs. Keep in sync with the
530 : : trees handled in dwarf2out_die_ref_for_decl. */
531 : 7023147 : if ((DECL_P (expr)
532 : : && TREE_CODE (expr) != FIELD_DECL
533 : : && TREE_CODE (expr) != DEBUG_EXPR_DECL
534 : : && TREE_CODE (expr) != TYPE_DECL)
535 : 5631454 : || TREE_CODE (expr) == BLOCK)
536 : : {
537 : 1734975 : const char *sym;
538 : 1734975 : unsigned HOST_WIDE_INT off;
539 : 1734975 : if (debug_info_level > DINFO_LEVEL_NONE
540 : 1734975 : && debug_hooks->die_ref_for_decl (expr, &sym, &off))
541 : : {
542 : 48886 : streamer_write_string (ob, ob->main_stream, sym, true);
543 : 48886 : streamer_write_uhwi (ob, off);
544 : : }
545 : : else
546 : 1686089 : streamer_write_string (ob, ob->main_stream, NULL, true);
547 : : }
548 : 7023147 : }
549 : :
550 : : /* Write a physical representation of tree node EXPR to output block
551 : : OB. If REF_P is true, the leaves of EXPR are emitted as references
552 : : via lto_output_tree_ref. IX is the index into the streamer cache
553 : : where EXPR is stored. */
554 : :
555 : : static void
556 : 6753120 : lto_write_tree (struct output_block *ob, tree expr, bool ref_p)
557 : : {
558 : 6753120 : if (!lto_is_streamable (expr))
559 : 0 : internal_error ("tree code %qs is not supported in LTO streams",
560 : 0 : get_tree_code_name (TREE_CODE (expr)));
561 : :
562 : : /* Write the header, containing everything needed to materialize
563 : : EXPR on the reading side. */
564 : 6753120 : streamer_write_tree_header (ob, expr);
565 : :
566 : 6753120 : lto_write_tree_1 (ob, expr, ref_p);
567 : 6753120 : }
568 : :
569 : : /* Emit the physical representation of tree node EXPR to output block OB,
570 : : If THIS_REF_P is true, the leaves of EXPR are emitted as references via
571 : : lto_output_tree_ref. REF_P is used for streaming siblings of EXPR. */
572 : :
573 : : static void
574 : 7801097 : lto_output_tree_1 (struct output_block *ob, tree expr, hashval_t hash,
575 : : bool ref_p, bool this_ref_p)
576 : : {
577 : 7801097 : unsigned ix;
578 : :
579 : 7801097 : gcc_checking_assert (expr != NULL_TREE
580 : : && !(this_ref_p && tree_is_indexable (expr)));
581 : :
582 : 7801097 : bool exists_p = streamer_tree_cache_insert (ob->writer_cache,
583 : : expr, hash, &ix);
584 : 7801097 : gcc_assert (!exists_p);
585 : 7801097 : if (TREE_CODE (expr) == INTEGER_CST
586 : 7801097 : && !TREE_OVERFLOW (expr))
587 : : {
588 : : /* Shared INTEGER_CST nodes are special because they need their
589 : : original type to be materialized by the reader (to implement
590 : : TYPE_CACHED_VALUES). */
591 : 1047977 : streamer_write_integer_cst (ob, expr);
592 : : }
593 : : else
594 : : {
595 : : /* This is the first time we see EXPR, write its fields
596 : : to OB. */
597 : 6753120 : lto_write_tree (ob, expr, ref_p);
598 : : }
599 : 7801097 : }
600 : :
601 : : class DFS
602 : : {
603 : : public:
604 : : DFS (struct output_block *ob, tree expr, bool ref_p, bool this_ref_p,
605 : : bool single_p);
606 : : ~DFS ();
607 : :
608 : : struct scc_entry
609 : : {
610 : : tree t;
611 : : hashval_t hash;
612 : : };
613 : : auto_vec<scc_entry,32> sccstack;
614 : :
615 : : private:
616 : : struct sccs
617 : : {
618 : : unsigned int dfsnum;
619 : : unsigned int low;
620 : : };
621 : : struct worklist
622 : : {
623 : : tree expr;
624 : : sccs *from_state;
625 : : sccs *cstate;
626 : : bool ref_p;
627 : : bool this_ref_p;
628 : : };
629 : : /* Maximum index of scc stack containing a local tree. */
630 : : int max_local_entry;
631 : :
632 : : static int scc_entry_compare (const void *, const void *);
633 : :
634 : : void DFS_write_tree_body (struct output_block *ob,
635 : : tree expr, sccs *expr_state, bool ref_p);
636 : :
637 : : void DFS_write_tree (struct output_block *ob, sccs *from_state,
638 : : tree expr, bool ref_p, bool this_ref_p);
639 : :
640 : : hashval_t
641 : : hash_scc (struct output_block *ob, unsigned first, unsigned size,
642 : : bool ref_p, bool this_ref_p);
643 : :
644 : : hash_map<tree, sccs *> sccstate;
645 : : auto_vec<worklist, 32> worklist_vec;
646 : : struct obstack sccstate_obstack;
647 : : };
648 : :
649 : : /* Return true if type can not be merged with structurally same tree in
650 : : other translation unit. During stream out this information is propagated
651 : : to all trees referring to T and they are not streamed with additional
652 : : information needed by the tree merging in lto-common.cc (in particular,
653 : : scc hash codes are not streamed).
654 : :
655 : : TRANSLATION_UNIT_DECL is handled specially since references to it does
656 : : not make other trees local as well. */
657 : :
658 : : static bool
659 : 2847319 : local_tree_p (tree t)
660 : : {
661 : 2847319 : switch (TREE_CODE (t))
662 : : {
663 : : case LABEL_DECL:
664 : : return true;
665 : 1592 : case NAMESPACE_DECL:
666 : 1592 : return !DECL_NAME (t);
667 : 617067 : case VAR_DECL:
668 : 617067 : case FUNCTION_DECL:
669 : 617067 : return !TREE_PUBLIC (t) && !DECL_EXTERNAL (t);
670 : 73070 : case RECORD_TYPE:
671 : 73070 : case UNION_TYPE:
672 : 73070 : case ENUMERAL_TYPE:
673 : : /* Anonymous namespace types are local.
674 : : Only work hard for main variants;
675 : : variant types will inherit locality. */
676 : 73070 : return TYPE_MAIN_VARIANT (t) == t
677 : 58496 : && odr_type_p (t) && type_with_linkage_p (t)
678 : 92562 : && type_in_anonymous_namespace_p (t);
679 : : default:
680 : : return false;
681 : : }
682 : : }
683 : :
684 : : /* Emit the physical representation of tree node EXPR to output block OB,
685 : : using depth-first search on the subgraph. If THIS_REF_P is true, the
686 : : leaves of EXPR are emitted as references via lto_output_tree_ref.
687 : : REF_P is used for streaming siblings of EXPR. If SINGLE_P is true,
688 : : this is for a rewalk of a single leaf SCC. */
689 : :
690 : 2969764 : DFS::DFS (struct output_block *ob, tree expr, bool ref_p, bool this_ref_p,
691 : 2969764 : bool single_p)
692 : : {
693 : 2969764 : unsigned int next_dfs_num = 1;
694 : :
695 : 2969764 : max_local_entry = -1;
696 : 2969764 : gcc_obstack_init (&sccstate_obstack);
697 : 2969764 : DFS_write_tree (ob, NULL, expr, ref_p, this_ref_p);
698 : 21557179 : while (!worklist_vec.is_empty ())
699 : : {
700 : 17663553 : worklist &w = worklist_vec.last ();
701 : 17663553 : expr = w.expr;
702 : 17663553 : sccs *from_state = w.from_state;
703 : 17663553 : sccs *cstate = w.cstate;
704 : 17663553 : ref_p = w.ref_p;
705 : 17663553 : this_ref_p = w.this_ref_p;
706 : 17663553 : if (cstate == NULL)
707 : : {
708 : 9581679 : sccs **slot = &sccstate.get_or_insert (expr);
709 : 9581679 : cstate = *slot;
710 : 9581679 : if (cstate)
711 : : {
712 : 1499805 : gcc_checking_assert (from_state);
713 : 1499805 : if (cstate->dfsnum < from_state->dfsnum)
714 : 188702 : from_state->low = MIN (cstate->dfsnum, from_state->low);
715 : 1499805 : worklist_vec.pop ();
716 : 1499805 : continue;
717 : : }
718 : :
719 : 8081874 : scc_entry e = { expr, 0 };
720 : : /* Not yet visited. DFS recurse and push it onto the stack. */
721 : 8081874 : *slot = cstate = XOBNEW (&sccstate_obstack, struct sccs);
722 : 8081874 : if (ob->local_trees && local_tree_p (expr))
723 : 84810 : max_local_entry = sccstack.length ();
724 : 8081874 : sccstack.safe_push (e);
725 : 8081874 : cstate->dfsnum = next_dfs_num++;
726 : 8081874 : cstate->low = cstate->dfsnum;
727 : 8081874 : w.cstate = cstate;
728 : :
729 : 8081874 : if (TREE_CODE (expr) == INTEGER_CST
730 : 8081874 : && !TREE_OVERFLOW (expr))
731 : 1090631 : DFS_write_tree (ob, cstate, TREE_TYPE (expr), ref_p, ref_p);
732 : : else
733 : : {
734 : 6991243 : DFS_write_tree_body (ob, expr, cstate, ref_p);
735 : :
736 : : /* Walk any LTO-specific edges. */
737 : 6991243 : if (DECL_P (expr)
738 : 1531928 : && TREE_CODE (expr) != FUNCTION_DECL
739 : 1101333 : && TREE_CODE (expr) != TRANSLATION_UNIT_DECL)
740 : : {
741 : : /* Handle DECL_INITIAL for symbols. */
742 : 1067462 : tree initial
743 : 1067462 : = get_symbol_initial_value (ob->decl_state->symtab_node_encoder,
744 : : expr);
745 : 1067462 : DFS_write_tree (ob, cstate, initial, ref_p, ref_p);
746 : : }
747 : : }
748 : 8081874 : continue;
749 : 8081874 : }
750 : :
751 : : /* See if we found an SCC. */
752 : 8081874 : if (cstate->low == cstate->dfsnum)
753 : : {
754 : 7881765 : unsigned first, size;
755 : 7881765 : tree x;
756 : :
757 : : /* If we are re-walking a single leaf SCC just pop it,
758 : : let earlier worklist item access the sccstack. */
759 : 7881765 : if (single_p)
760 : : {
761 : 334 : worklist_vec.pop ();
762 : 334 : continue;
763 : : }
764 : :
765 : : /* Pop the SCC and compute its size. */
766 : 15762862 : first = sccstack.length ();
767 : 8071124 : do
768 : : {
769 : 8071124 : x = sccstack[--first].t;
770 : : }
771 : 8071124 : while (x != expr);
772 : 7881431 : size = sccstack.length () - first;
773 : :
774 : : /* No need to compute hashes for LTRANS units, we don't perform
775 : : any merging there. */
776 : 7881431 : hashval_t scc_hash = 0;
777 : 7881431 : unsigned scc_entry_len = 0;
778 : 20999189 : bool local_to_unit = !ob->local_trees
779 : 7881431 : || max_local_entry >= (int)first;
780 : :
781 : : /* Remember that trees are local so info gets propagated to other
782 : : SCCs. */
783 : 5236327 : if (local_to_unit && ob->local_trees)
784 : : {
785 : 93866 : for (unsigned i = 0; i < size; ++i)
786 : 48314 : ob->local_trees->add (sccstack[first + i].t);
787 : : }
788 : :
789 : : /* As a special case do not stream TRANSLATION_UNIT_DECL as shared
790 : : tree. We can not mark it local because references to it does not
791 : : make other trees local (all global decls reffer to it via
792 : : CONTEXT). */
793 : 7881431 : if (size == 1
794 : 7881431 : && TREE_CODE (sccstack[first].t) == TRANSLATION_UNIT_DECL)
795 : : local_to_unit = true;
796 : :
797 : 7847560 : if (!local_to_unit)
798 : : {
799 : 2621061 : scc_hash = hash_scc (ob, first, size, ref_p, this_ref_p);
800 : :
801 : : /* Put the entries with the least number of collisions first. */
802 : 2621061 : unsigned entry_start = 0;
803 : 2621061 : scc_entry_len = size + 1;
804 : 5385273 : for (unsigned i = 0; i < size;)
805 : : {
806 : 2764212 : unsigned from = i;
807 : 2764212 : for (i = i + 1; i < size
808 : 2764212 : && (sccstack[first + i].hash
809 : 143151 : == sccstack[first + from].hash); ++i)
810 : : ;
811 : 2764212 : if (i - from < scc_entry_len)
812 : : {
813 : 2621061 : scc_entry_len = i - from;
814 : 2621061 : entry_start = from;
815 : : }
816 : : }
817 : 5242122 : for (unsigned i = 0; i < scc_entry_len; ++i)
818 : 2621061 : std::swap (sccstack[first + i],
819 : 2621061 : sccstack[first + entry_start + i]);
820 : :
821 : : /* We already sorted SCC deterministically in hash_scc. */
822 : :
823 : : /* Check that we have only one SCC.
824 : : Naturally we may have conflicts if hash function is not
825 : : strong enough. Lets see how far this gets. */
826 : 2621061 : gcc_checking_assert (scc_entry_len == 1);
827 : : }
828 : :
829 : 7881431 : worklist_vec.pop ();
830 : :
831 : 7881431 : unsigned int prev_size = ob->main_stream->total_size;
832 : :
833 : : /* Only global decl sections are considered by tree merging. */
834 : 7881431 : if (ob->section_type != LTO_section_decls)
835 : : {
836 : : /* If this is the original tree we stream and it forms SCC
837 : : by itself then we do not need to stream SCC at all. */
838 : 4478076 : if (worklist_vec.is_empty () && first == 0 && size == 1)
839 : : return;
840 : 2432174 : if (streamer_dump_file)
841 : : {
842 : 140 : fprintf (streamer_dump_file,
843 : : " Start of LTO_trees of size %i\n", size);
844 : : }
845 : 2432174 : streamer_write_record_start (ob, LTO_trees);
846 : 2432174 : streamer_write_uhwi (ob, size);
847 : : }
848 : : /* Write LTO_tree_scc if tree merging is going to be performed. */
849 : 3403355 : else if (!local_to_unit
850 : : /* These are special since sharing is not done by tree
851 : : merging machinery. We can not special case them earlier
852 : : because we still need to compute hash for further sharing
853 : : of trees referring to them. */
854 : 3403355 : && (size != 1
855 : 2555723 : || (TREE_CODE (sccstack[first].t) != IDENTIFIER_NODE
856 : 1685903 : && (TREE_CODE (sccstack[first].t) != INTEGER_CST
857 : 151108 : || TREE_OVERFLOW (sccstack[first].t)))))
858 : :
859 : : {
860 : 1600135 : gcc_checking_assert (ob->section_type == LTO_section_decls);
861 : 1600135 : if (streamer_dump_file)
862 : : {
863 : 172 : fprintf (streamer_dump_file,
864 : : " Start of LTO_tree_scc of size %i\n", size);
865 : : }
866 : 1600135 : streamer_write_record_start (ob, LTO_tree_scc);
867 : : /* In wast majority of cases scc_entry_len is 1 and size is small
868 : : integer. Use extra bit of size to stream info about
869 : : exceptions. */
870 : 1600135 : streamer_write_uhwi (ob, size * 2 + (scc_entry_len != 1));
871 : 1600135 : if (scc_entry_len != 1)
872 : 0 : streamer_write_uhwi (ob, scc_entry_len);
873 : 1600135 : streamer_write_uhwi (ob, scc_hash);
874 : : }
875 : : /* Non-trivial SCCs must be packed to trees blocks so forward
876 : : references work correctly. */
877 : 1803220 : else if (size != 1)
878 : : {
879 : 14862 : if (streamer_dump_file)
880 : : {
881 : 0 : fprintf (streamer_dump_file,
882 : : " Start of LTO_trees of size %i\n", size);
883 : : }
884 : 14862 : streamer_write_record_start (ob, LTO_trees);
885 : 14862 : streamer_write_uhwi (ob, size);
886 : : }
887 : 1788358 : else if (streamer_dump_file)
888 : : {
889 : 108 : fprintf (streamer_dump_file, " Streaming single tree\n");
890 : : }
891 : :
892 : : /* Write size-1 SCCs without wrapping them inside SCC bundles.
893 : : All INTEGER_CSTs need to be handled this way as we need
894 : : their type to materialize them. Also builtins are handled
895 : : this way. */
896 : 5835529 : if (size == 1)
897 : 5755195 : lto_output_tree_1 (ob, expr, scc_hash, ref_p, this_ref_p);
898 : : else
899 : : {
900 : :
901 : : /* Write all headers and populate the streamer cache. */
902 : 350361 : for (unsigned i = 0; i < size; ++i)
903 : : {
904 : 270027 : hashval_t hash = sccstack[first+i].hash;
905 : 270027 : tree t = sccstack[first+i].t;
906 : 270027 : bool exists_p = streamer_tree_cache_insert (ob->writer_cache,
907 : : t, hash, NULL);
908 : 270027 : gcc_assert (!exists_p);
909 : :
910 : 270027 : if (!lto_is_streamable (t))
911 : 0 : internal_error ("tree code %qs is not supported "
912 : : "in LTO streams",
913 : 0 : get_tree_code_name (TREE_CODE (t)));
914 : :
915 : : /* Write the header, containing everything needed to
916 : : materialize EXPR on the reading side. */
917 : 270027 : streamer_write_tree_header (ob, t);
918 : : }
919 : :
920 : : /* Write the bitpacks and tree references. */
921 : 350361 : for (unsigned i = 0; i < size; ++i)
922 : 270027 : lto_write_tree_1 (ob, sccstack[first+i].t, ref_p);
923 : : }
924 : 5835529 : if (streamer_dump_file)
925 : 420 : fprintf (streamer_dump_file, " %u bytes\n",
926 : 420 : ob->main_stream->total_size - prev_size);
927 : :
928 : : /* Finally truncate the vector. */
929 : 5835529 : sccstack.truncate (first);
930 : 5835529 : if ((int)first <= max_local_entry)
931 : 45552 : max_local_entry = first - 1;
932 : :
933 : 5835529 : if (from_state)
934 : 4912001 : from_state->low = MIN (from_state->low, cstate->low);
935 : 5835529 : continue;
936 : 5835529 : }
937 : :
938 : 200109 : gcc_checking_assert (from_state);
939 : 200109 : from_state->low = MIN (from_state->low, cstate->low);
940 : 200109 : if (cstate->dfsnum < from_state->dfsnum)
941 : 0 : from_state->low = MIN (cstate->dfsnum, from_state->low);
942 : 200109 : worklist_vec.pop ();
943 : : }
944 : : }
945 : :
946 : 2969764 : DFS::~DFS ()
947 : : {
948 : 2969764 : obstack_free (&sccstate_obstack, NULL);
949 : 2969764 : }
950 : :
951 : : /* Handle the tree EXPR in the DFS walk with SCC state EXPR_STATE and
952 : : DFS recurse for all tree edges originating from it. */
953 : :
954 : : void
955 : 6991243 : DFS::DFS_write_tree_body (struct output_block *ob,
956 : : tree expr, sccs *expr_state, bool ref_p)
957 : : {
958 : : #define DFS_follow_tree_edge(DEST) \
959 : : DFS_write_tree (ob, expr_state, DEST, ref_p, ref_p)
960 : :
961 : 6991243 : enum tree_code code;
962 : :
963 : 6991243 : code = TREE_CODE (expr);
964 : :
965 : 6991243 : if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
966 : : {
967 : 6581721 : if (TREE_CODE (expr) != IDENTIFIER_NODE)
968 : 5104699 : DFS_follow_tree_edge (TREE_TYPE (expr));
969 : : }
970 : :
971 : 6991243 : if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
972 : : {
973 : 5719 : unsigned int count = vector_cst_encoded_nelts (expr);
974 : 23692 : for (unsigned int i = 0; i < count; ++i)
975 : 17973 : DFS_follow_tree_edge (VECTOR_CST_ENCODED_ELT (expr, i));
976 : : }
977 : :
978 : 6991243 : if (CODE_CONTAINS_STRUCT (code, TS_POLY_INT_CST))
979 : 0 : for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
980 : 0 : DFS_follow_tree_edge (POLY_INT_CST_COEFF (expr, i));
981 : :
982 : 6991243 : if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
983 : : {
984 : 8007 : DFS_follow_tree_edge (TREE_REALPART (expr));
985 : 8007 : DFS_follow_tree_edge (TREE_IMAGPART (expr));
986 : : }
987 : :
988 : 6991243 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
989 : : {
990 : : /* Drop names that were created for anonymous entities. */
991 : 1531928 : if (DECL_NAME (expr)
992 : 1346231 : && TREE_CODE (DECL_NAME (expr)) == IDENTIFIER_NODE
993 : 2878159 : && IDENTIFIER_ANON_P (DECL_NAME (expr)))
994 : : ;
995 : : else
996 : 1531354 : DFS_follow_tree_edge (DECL_NAME (expr));
997 : 1531928 : if (TREE_CODE (expr) != TRANSLATION_UNIT_DECL
998 : 1531928 : && ! DECL_CONTEXT (expr))
999 : 15109 : DFS_follow_tree_edge ((*all_translation_units)[0]);
1000 : : else
1001 : 1516819 : DFS_follow_tree_edge (DECL_CONTEXT (expr));
1002 : : }
1003 : :
1004 : 6991243 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
1005 : : {
1006 : 1531928 : DFS_follow_tree_edge (DECL_SIZE (expr));
1007 : 1531928 : DFS_follow_tree_edge (DECL_SIZE_UNIT (expr));
1008 : :
1009 : : /* Note, DECL_INITIAL is not handled here. Since DECL_INITIAL needs
1010 : : special handling in LTO, it must be handled by streamer hooks. */
1011 : :
1012 : 1531928 : DFS_follow_tree_edge (DECL_ATTRIBUTES (expr));
1013 : :
1014 : : /* We use DECL_ABSTRACT_ORIGIN == error_mark_node to mark
1015 : : declarations which should be eliminated by decl merging. Be sure none
1016 : : leaks to this point. */
1017 : 1531928 : gcc_assert (DECL_ABSTRACT_ORIGIN (expr) != error_mark_node);
1018 : 1531928 : DFS_follow_tree_edge (DECL_ABSTRACT_ORIGIN (expr));
1019 : :
1020 : 1531928 : if ((VAR_P (expr)
1021 : 1531928 : || TREE_CODE (expr) == PARM_DECL)
1022 : 1531928 : && DECL_HAS_VALUE_EXPR_P (expr))
1023 : 6465 : DFS_follow_tree_edge (DECL_VALUE_EXPR (expr));
1024 : 1531928 : if (VAR_P (expr)
1025 : 1531928 : && DECL_HAS_DEBUG_EXPR_P (expr))
1026 : 1495 : DFS_follow_tree_edge (DECL_DEBUG_EXPR (expr));
1027 : : }
1028 : :
1029 : 6991243 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
1030 : : {
1031 : : /* Make sure we don't inadvertently set the assembler name. */
1032 : 918241 : if (DECL_ASSEMBLER_NAME_SET_P (expr))
1033 : 742871 : DFS_follow_tree_edge (DECL_ASSEMBLER_NAME (expr));
1034 : : }
1035 : :
1036 : 6991243 : if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
1037 : : {
1038 : 112575 : DFS_follow_tree_edge (DECL_FIELD_OFFSET (expr));
1039 : 112575 : DFS_follow_tree_edge (DECL_BIT_FIELD_TYPE (expr));
1040 : 112575 : DFS_follow_tree_edge (DECL_BIT_FIELD_REPRESENTATIVE (expr));
1041 : 112575 : DFS_follow_tree_edge (DECL_FIELD_BIT_OFFSET (expr));
1042 : 112575 : gcc_checking_assert (!DECL_FCONTEXT (expr));
1043 : : }
1044 : :
1045 : 6991243 : if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
1046 : : {
1047 : 430595 : gcc_checking_assert (DECL_VINDEX (expr) == NULL);
1048 : 430595 : DFS_follow_tree_edge (DECL_FUNCTION_PERSONALITY (expr));
1049 : 430595 : DFS_follow_tree_edge (DECL_FUNCTION_SPECIFIC_TARGET (expr));
1050 : 430595 : DFS_follow_tree_edge (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr));
1051 : : }
1052 : :
1053 : 6991243 : if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
1054 : : {
1055 : 640971 : DFS_follow_tree_edge (TYPE_SIZE (expr));
1056 : 640971 : DFS_follow_tree_edge (TYPE_SIZE_UNIT (expr));
1057 : 640971 : DFS_follow_tree_edge (TYPE_ATTRIBUTES (expr));
1058 : 640971 : DFS_follow_tree_edge (TYPE_NAME (expr));
1059 : : /* Do not follow TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
1060 : : reconstructed during fixup. */
1061 : : /* Do not follow TYPE_NEXT_VARIANT, we reconstruct the variant lists
1062 : : during fixup. */
1063 : 640971 : DFS_follow_tree_edge (TYPE_MAIN_VARIANT (expr));
1064 : 640971 : DFS_follow_tree_edge (TYPE_CONTEXT (expr));
1065 : : /* TYPE_CANONICAL is re-computed during type merging, so no need
1066 : : to follow it here. */
1067 : : /* Do not stream TYPE_STUB_DECL; it is not needed by LTO but currently
1068 : : it cannot be freed by free_lang_data without triggering ICEs in
1069 : : langhooks. */
1070 : : }
1071 : :
1072 : 6991243 : if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
1073 : : {
1074 : 640971 : if (TREE_CODE (expr) == ARRAY_TYPE)
1075 : 44934 : DFS_follow_tree_edge (TYPE_DOMAIN (expr));
1076 : 596037 : else if (RECORD_OR_UNION_TYPE_P (expr))
1077 : 242280 : for (tree t = TYPE_FIELDS (expr); t; t = TREE_CHAIN (t))
1078 : 149068 : DFS_follow_tree_edge (t);
1079 : 502825 : else if (FUNC_OR_METHOD_TYPE_P (expr))
1080 : 169609 : DFS_follow_tree_edge (TYPE_ARG_TYPES (expr));
1081 : :
1082 : 640971 : if (!POINTER_TYPE_P (expr))
1083 : 386828 : DFS_follow_tree_edge (TYPE_MIN_VALUE_RAW (expr));
1084 : 640971 : DFS_follow_tree_edge (TYPE_MAX_VALUE_RAW (expr));
1085 : : }
1086 : :
1087 : 6991243 : if (CODE_CONTAINS_STRUCT (code, TS_LIST))
1088 : : {
1089 : 667653 : DFS_follow_tree_edge (TREE_PURPOSE (expr));
1090 : 667653 : DFS_follow_tree_edge (TREE_VALUE (expr));
1091 : 667653 : DFS_follow_tree_edge (TREE_CHAIN (expr));
1092 : : }
1093 : :
1094 : 6991243 : if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1095 : : {
1096 : 10 : for (int i = 0; i < TREE_VEC_LENGTH (expr); i++)
1097 : 8 : DFS_follow_tree_edge (TREE_VEC_ELT (expr, i));
1098 : : }
1099 : :
1100 : 6991243 : if (CODE_CONTAINS_STRUCT (code, TS_EXP))
1101 : : {
1102 : 4153572 : for (int i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
1103 : 2438373 : DFS_follow_tree_edge (TREE_OPERAND (expr, i));
1104 : 1715199 : DFS_follow_tree_edge (TREE_BLOCK (expr));
1105 : : }
1106 : :
1107 : 6991243 : if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
1108 : : {
1109 : 485411 : for (tree t = BLOCK_VARS (expr); t; t = TREE_CHAIN (t))
1110 : : {
1111 : : /* We would have to stream externals in the block chain as
1112 : : non-references but we should have dropped them in
1113 : : free-lang-data. */
1114 : 142129 : gcc_assert (!VAR_OR_FUNCTION_DECL_P (t) || !DECL_EXTERNAL (t));
1115 : 142129 : DFS_follow_tree_edge (t);
1116 : : }
1117 : :
1118 : 343282 : DFS_follow_tree_edge (BLOCK_SUPERCONTEXT (expr));
1119 : 343282 : DFS_follow_tree_edge (BLOCK_ABSTRACT_ORIGIN (expr));
1120 : :
1121 : : /* Do not follow BLOCK_NONLOCALIZED_VARS. We cannot handle debug
1122 : : information for early inlined BLOCKs so drop it on the floor instead
1123 : : of ICEing in dwarf2out.cc. */
1124 : :
1125 : : /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
1126 : : streaming time. */
1127 : :
1128 : : /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
1129 : : list is re-constructed from BLOCK_SUPERCONTEXT. */
1130 : : }
1131 : :
1132 : 6991243 : if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1133 : : {
1134 : : unsigned i;
1135 : : tree t;
1136 : :
1137 : : /* Note that the number of BINFO slots has already been emitted in
1138 : : EXPR's header (see streamer_write_tree_header) because this length
1139 : : is needed to build the empty BINFO node on the reader side. */
1140 : 20196 : FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr), i, t)
1141 : 10759 : DFS_follow_tree_edge (t);
1142 : 9437 : DFS_follow_tree_edge (BINFO_OFFSET (expr));
1143 : 9437 : DFS_follow_tree_edge (BINFO_VTABLE (expr));
1144 : :
1145 : : /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX,
1146 : : BINFO_BASE_ACCESSES and BINFO_VPTR_INDEX; these are used
1147 : : by C++ FE only. */
1148 : : }
1149 : :
1150 : 6991243 : if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
1151 : : {
1152 : : unsigned i;
1153 : : tree index, value;
1154 : :
1155 : 767098 : FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value)
1156 : : {
1157 : 530267 : DFS_follow_tree_edge (index);
1158 : 530267 : DFS_follow_tree_edge (value);
1159 : : }
1160 : : }
1161 : :
1162 : 6991243 : if (code == RAW_DATA_CST)
1163 : 21 : DFS_follow_tree_edge (RAW_DATA_OWNER (expr));
1164 : :
1165 : 6991243 : if (code == OMP_CLAUSE)
1166 : : {
1167 : : int i;
1168 : 494 : for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (expr)]; i++)
1169 : 280 : DFS_follow_tree_edge (OMP_CLAUSE_OPERAND (expr, i));
1170 : 214 : DFS_follow_tree_edge (OMP_CLAUSE_CHAIN (expr));
1171 : : }
1172 : :
1173 : : #undef DFS_follow_tree_edge
1174 : 6991243 : }
1175 : :
1176 : : /* Return a hash value for the tree T.
1177 : : CACHE holds hash values of trees outside current SCC. MAP, if non-NULL,
1178 : : may hold hash values if trees inside current SCC. */
1179 : :
1180 : : static hashval_t
1181 : 2764212 : hash_tree (struct streamer_tree_cache_d *cache, hash_map<tree, hashval_t> *map, tree t)
1182 : : {
1183 : 2764212 : inchash::hash hstate;
1184 : :
1185 : : #define visit(SIBLING) \
1186 : : do { \
1187 : : unsigned ix; \
1188 : : if (!SIBLING) \
1189 : : hstate.add_int (0); \
1190 : : else if (streamer_tree_cache_lookup (cache, SIBLING, &ix)) \
1191 : : hstate.add_int (streamer_tree_cache_get_hash (cache, ix)); \
1192 : : else if (map) \
1193 : : hstate.add_int (*map->get (SIBLING)); \
1194 : : else \
1195 : : hstate.add_int (1); \
1196 : : } while (0)
1197 : :
1198 : : /* Hash TS_BASE. */
1199 : 2764212 : enum tree_code code = TREE_CODE (t);
1200 : 2764212 : hstate.add_int (code);
1201 : 2764212 : if (!TYPE_P (t))
1202 : : {
1203 : 2317456 : hstate.add_flag (TREE_SIDE_EFFECTS (t));
1204 : 2317456 : hstate.add_flag (TREE_CONSTANT (t));
1205 : 2317456 : hstate.add_flag (TREE_READONLY (t));
1206 : 2317456 : hstate.add_flag (TREE_PUBLIC (t));
1207 : : }
1208 : 2764212 : hstate.add_flag (TREE_ADDRESSABLE (t));
1209 : 2764212 : hstate.add_flag (TREE_THIS_VOLATILE (t));
1210 : 2764212 : if (DECL_P (t))
1211 : 680151 : hstate.add_flag (DECL_UNSIGNED (t));
1212 : 2084061 : else if (TYPE_P (t))
1213 : 446756 : hstate.add_flag (TYPE_UNSIGNED (t));
1214 : 2764212 : if (TYPE_P (t))
1215 : 446756 : hstate.add_flag (TYPE_ARTIFICIAL (t));
1216 : : else
1217 : 2317456 : hstate.add_flag (TREE_NO_WARNING (t));
1218 : 2764212 : hstate.add_flag (TREE_NOTHROW (t));
1219 : 2764212 : hstate.add_flag (TREE_STATIC (t));
1220 : 2764212 : hstate.add_flag (TREE_PROTECTED (t));
1221 : 2764212 : hstate.add_flag (TREE_DEPRECATED (t));
1222 : 2764212 : if (code != TREE_BINFO)
1223 : 2757959 : hstate.add_flag (TREE_PRIVATE (t));
1224 : 2764212 : if (TYPE_P (t))
1225 : : {
1226 : 446756 : hstate.add_flag (AGGREGATE_TYPE_P (t)
1227 : 446756 : ? TYPE_REVERSE_STORAGE_ORDER (t) : TYPE_SATURATING (t));
1228 : 446756 : hstate.add_flag (TYPE_ADDR_SPACE (t));
1229 : : }
1230 : 2317456 : else if (code == SSA_NAME)
1231 : 0 : hstate.add_flag (SSA_NAME_IS_DEFAULT_DEF (t));
1232 : 2764212 : hstate.commit_flag ();
1233 : :
1234 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
1235 : 180690 : hstate.add_wide_int (wi::to_widest (t));
1236 : :
1237 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
1238 : : {
1239 : 1710 : REAL_VALUE_TYPE r = TREE_REAL_CST (t);
1240 : 1710 : hstate.add_flag (r.cl);
1241 : 1710 : hstate.add_flag (r.sign);
1242 : 1710 : hstate.add_flag (r.signalling);
1243 : 1710 : hstate.add_flag (r.canonical);
1244 : 1710 : hstate.commit_flag ();
1245 : 1710 : hstate.add_int (r.uexp);
1246 : 1710 : hstate.add (r.sig, sizeof (r.sig));
1247 : : }
1248 : :
1249 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
1250 : : {
1251 : 0 : FIXED_VALUE_TYPE f = TREE_FIXED_CST (t);
1252 : 0 : hstate.add_int (f.mode);
1253 : 0 : hstate.add_int (f.data.low);
1254 : 0 : hstate.add_int (f.data.high);
1255 : : }
1256 : :
1257 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
1258 : : {
1259 : : /* Similar to TYPE_MODE, avoid streaming out host-specific DECL_MODE
1260 : : for aggregate type with offloading enabled, and while streaming-in
1261 : : recompute appropriate DECL_MODE for accelerator. */
1262 : 680151 : if (lto_stream_offload_p
1263 : 0 : && (VAR_P (t)
1264 : 0 : || TREE_CODE (t) == PARM_DECL
1265 : 0 : || TREE_CODE (t) == FIELD_DECL)
1266 : 680151 : && AGGREGATE_TYPE_P (TREE_TYPE (t)))
1267 : 0 : hstate.add_hwi (VOIDmode);
1268 : : else
1269 : 680151 : hstate.add_hwi (DECL_MODE (t));
1270 : 680151 : hstate.add_flag (DECL_NONLOCAL (t));
1271 : 680151 : hstate.add_flag (DECL_VIRTUAL_P (t));
1272 : 680151 : hstate.add_flag (DECL_IGNORED_P (t));
1273 : 680151 : hstate.add_flag (DECL_ABSTRACT_P (t));
1274 : 680151 : hstate.add_flag (DECL_ARTIFICIAL (t));
1275 : 680151 : hstate.add_flag (DECL_USER_ALIGN (t));
1276 : 680151 : hstate.add_flag (DECL_PRESERVE_P (t));
1277 : 680151 : hstate.add_flag (DECL_EXTERNAL (t));
1278 : 680151 : hstate.add_flag (DECL_NOT_GIMPLE_REG_P (t));
1279 : 680151 : hstate.commit_flag ();
1280 : 680151 : hstate.add_int (DECL_ALIGN (t));
1281 : 680151 : if (code == LABEL_DECL)
1282 : : {
1283 : 0 : hstate.add_int (EH_LANDING_PAD_NR (t));
1284 : 0 : hstate.add_int (LABEL_DECL_UID (t));
1285 : : }
1286 : 680151 : else if (code == FIELD_DECL)
1287 : : {
1288 : 80922 : hstate.add_flag (DECL_PACKED (t));
1289 : 80922 : hstate.add_flag (DECL_NONADDRESSABLE_P (t));
1290 : 80922 : hstate.add_flag (DECL_PADDING_P (t));
1291 : 80922 : if (DECL_BIT_FIELD (t))
1292 : 4908 : hstate.add_flag (DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD (t));
1293 : : else
1294 : 155763 : hstate.add_flag (DECL_FIELD_ABI_IGNORED (t));
1295 : 80922 : hstate.add_int (DECL_OFFSET_ALIGN (t));
1296 : : }
1297 : 599229 : else if (code == VAR_DECL)
1298 : : {
1299 : 234263 : hstate.add_flag (DECL_HAS_DEBUG_EXPR_P (t));
1300 : 234263 : hstate.add_flag (DECL_NONLOCAL_FRAME (t));
1301 : : }
1302 : 680151 : if (code == RESULT_DECL
1303 : 680151 : || code == PARM_DECL
1304 : : || code == VAR_DECL)
1305 : : {
1306 : 234275 : hstate.add_flag (DECL_BY_REFERENCE (t));
1307 : 234275 : if (code == VAR_DECL
1308 : 234275 : || code == PARM_DECL)
1309 : 234275 : hstate.add_flag (DECL_HAS_VALUE_EXPR_P (t));
1310 : : }
1311 : 680151 : hstate.commit_flag ();
1312 : : }
1313 : :
1314 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
1315 : 599226 : hstate.add_int (DECL_REGISTER (t));
1316 : :
1317 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
1318 : : {
1319 : 599214 : hstate.add_flag (DECL_COMMON (t));
1320 : 599214 : hstate.add_flag (DECL_DLLIMPORT_P (t));
1321 : 599214 : hstate.add_flag (DECL_WEAK (t));
1322 : 599214 : hstate.add_flag (DECL_SEEN_IN_BIND_EXPR_P (t));
1323 : 599214 : hstate.add_flag (DECL_COMDAT (t));
1324 : 599214 : hstate.add_flag (DECL_VISIBILITY_SPECIFIED (t));
1325 : 599214 : hstate.add_int (DECL_VISIBILITY (t));
1326 : 599214 : if (code == VAR_DECL)
1327 : : {
1328 : : /* DECL_IN_TEXT_SECTION is set during final asm output only. */
1329 : 234263 : hstate.add_flag (DECL_HARD_REGISTER (t));
1330 : 234263 : hstate.add_flag (DECL_IN_CONSTANT_POOL (t));
1331 : : }
1332 : 599214 : if (TREE_CODE (t) == FUNCTION_DECL)
1333 : : {
1334 : 343113 : hstate.add_flag (DECL_FINAL_P (t));
1335 : 343113 : hstate.add_flag (DECL_CXX_CONSTRUCTOR_P (t));
1336 : 343113 : hstate.add_flag (DECL_CXX_DESTRUCTOR_P (t));
1337 : : }
1338 : 599214 : hstate.commit_flag ();
1339 : : }
1340 : :
1341 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
1342 : : {
1343 : 343113 : hstate.add_int (DECL_BUILT_IN_CLASS (t));
1344 : 343113 : hstate.add_flag (DECL_STATIC_CONSTRUCTOR (t));
1345 : 343113 : hstate.add_flag (DECL_STATIC_DESTRUCTOR (t));
1346 : 343113 : hstate.add_int ((unsigned)FUNCTION_DECL_DECL_TYPE (t));
1347 : 343113 : hstate.add_flag (DECL_UNINLINABLE (t));
1348 : 343113 : hstate.add_flag (DECL_POSSIBLY_INLINED (t));
1349 : 343113 : hstate.add_flag (DECL_IS_NOVOPS (t));
1350 : 343113 : hstate.add_flag (DECL_IS_RETURNS_TWICE (t));
1351 : 343113 : hstate.add_flag (DECL_IS_MALLOC (t));
1352 : 343113 : hstate.add_flag (DECL_DECLARED_INLINE_P (t));
1353 : 343113 : hstate.add_flag (DECL_STATIC_CHAIN (t));
1354 : 343113 : hstate.add_flag (DECL_NO_INLINE_WARNING_P (t));
1355 : 343113 : hstate.add_flag (DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (t));
1356 : 343113 : hstate.add_flag (DECL_NO_LIMIT_STACK (t));
1357 : 343113 : hstate.add_flag (DECL_DISREGARD_INLINE_LIMITS (t));
1358 : 343113 : hstate.add_flag (DECL_PURE_P (t));
1359 : 343113 : hstate.add_flag (DECL_LOOPING_CONST_OR_PURE_P (t));
1360 : 343113 : hstate.commit_flag ();
1361 : 343113 : if (DECL_BUILT_IN_CLASS (t) != NOT_BUILT_IN)
1362 : 21681 : hstate.add_int (DECL_UNCHECKED_FUNCTION_CODE (t));
1363 : : }
1364 : :
1365 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
1366 : : {
1367 : : /* For offloading, avoid streaming out TYPE_MODE for aggregate type since
1368 : : it may be host-specific. For eg, aarch64 uses OImode for ARRAY_TYPE
1369 : : whose size is 256-bits, which is not representable on accelerator.
1370 : : Instead stream out VOIDmode, and while streaming-in, recompute
1371 : : appropriate TYPE_MODE for accelerator. */
1372 : 446756 : if (lto_stream_offload_p
1373 : 0 : && (AGGREGATE_TYPE_P (t) || VECTOR_TYPE_P (t)))
1374 : 0 : hstate.add_hwi (VOIDmode);
1375 : : /* for VECTOR_TYPE, TYPE_MODE reevaluates the mode using target_flags
1376 : : not necessary valid in a global context.
1377 : : Use the raw value previously set by layout_type. */
1378 : : else
1379 : 446756 : hstate.add_hwi (TYPE_MODE_RAW (t));
1380 : : /* TYPE_NO_FORCE_BLK is private to stor-layout and need
1381 : : no streaming. */
1382 : 446756 : hstate.add_flag (TYPE_PACKED (t));
1383 : 446756 : hstate.add_flag (TYPE_RESTRICT (t));
1384 : 446756 : hstate.add_flag (TYPE_USER_ALIGN (t));
1385 : 446756 : hstate.add_flag (TYPE_READONLY (t));
1386 : 446756 : if (RECORD_OR_UNION_TYPE_P (t))
1387 : : {
1388 : 70430 : hstate.add_flag (TYPE_TRANSPARENT_AGGR (t));
1389 : 70430 : hstate.add_flag (TYPE_FINAL_P (t));
1390 : 70430 : hstate.add_flag (TYPE_CXX_ODR_P (t));
1391 : : }
1392 : 376326 : else if (code == ARRAY_TYPE)
1393 : 28359 : hstate.add_flag (TYPE_NONALIASED_COMPONENT (t));
1394 : 446756 : if (code == ARRAY_TYPE || code == INTEGER_TYPE)
1395 : 71882 : hstate.add_flag (TYPE_STRING_FLAG (t));
1396 : 446756 : if (AGGREGATE_TYPE_P (t))
1397 : 98789 : hstate.add_flag (TYPE_TYPELESS_STORAGE (t));
1398 : 446756 : hstate.commit_flag ();
1399 : 446756 : hstate.add_int (TYPE_PRECISION_RAW (t));
1400 : 446756 : hstate.add_int (TYPE_ALIGN (t));
1401 : 446756 : if (!lto_stream_offload_p)
1402 : 446756 : hstate.add_int (TYPE_EMPTY_P (t));
1403 : : }
1404 : :
1405 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
1406 : 0 : hstate.add (TRANSLATION_UNIT_LANGUAGE (t),
1407 : 0 : strlen (TRANSLATION_UNIT_LANGUAGE (t)));
1408 : :
1409 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION)
1410 : : /* We don't stream these when passing things to a different target. */
1411 : 23756 : && !lto_stream_offload_p)
1412 : 23756 : hstate.add_hwi (cl_target_option_hash (TREE_TARGET_OPTION (t)));
1413 : :
1414 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
1415 : 23968 : hstate.add_hwi (cl_optimization_hash (TREE_OPTIMIZATION (t)));
1416 : :
1417 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
1418 : 869820 : hstate.merge_hash (IDENTIFIER_HASH_VALUE (t));
1419 : :
1420 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_STRING))
1421 : 4179 : hstate.add (TREE_STRING_POINTER (t), TREE_STRING_LENGTH (t));
1422 : :
1423 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
1424 : : {
1425 : 2716488 : if (code != IDENTIFIER_NODE)
1426 : 1846668 : visit (TREE_TYPE (t));
1427 : : }
1428 : :
1429 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
1430 : : {
1431 : 0 : unsigned int count = vector_cst_encoded_nelts (t);
1432 : 0 : for (unsigned int i = 0; i < count; ++i)
1433 : 0 : visit (VECTOR_CST_ENCODED_ELT (t, i));
1434 : : }
1435 : :
1436 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_POLY_INT_CST))
1437 : 0 : for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
1438 : 0 : visit (POLY_INT_CST_COEFF (t, i));
1439 : :
1440 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
1441 : : {
1442 : 0 : visit (TREE_REALPART (t));
1443 : 0 : visit (TREE_IMAGPART (t));
1444 : : }
1445 : :
1446 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
1447 : : {
1448 : : /* Drop names that were created for anonymous entities. */
1449 : 680151 : if (DECL_NAME (t)
1450 : 662978 : && TREE_CODE (DECL_NAME (t)) == IDENTIFIER_NODE
1451 : 1343129 : && IDENTIFIER_ANON_P (DECL_NAME (t)))
1452 : : ;
1453 : : else
1454 : 679811 : visit (DECL_NAME (t));
1455 : 680151 : if (DECL_FILE_SCOPE_P (t))
1456 : : ;
1457 : : else
1458 : 109117 : visit (DECL_CONTEXT (t));
1459 : : }
1460 : :
1461 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
1462 : : {
1463 : 680151 : visit (DECL_SIZE (t));
1464 : 680151 : visit (DECL_SIZE_UNIT (t));
1465 : 680151 : visit (DECL_ATTRIBUTES (t));
1466 : 680151 : if ((code == VAR_DECL
1467 : 680151 : || code == PARM_DECL)
1468 : 680151 : && DECL_HAS_VALUE_EXPR_P (t))
1469 : 0 : visit (DECL_VALUE_EXPR (t));
1470 : 680151 : if (code == VAR_DECL
1471 : 914414 : && DECL_HAS_DEBUG_EXPR_P (t))
1472 : 0 : visit (DECL_DEBUG_EXPR (t));
1473 : : /* ??? Hash DECL_INITIAL as streamed. Needs the output-block to
1474 : : be able to call get_symbol_initial_value. */
1475 : : }
1476 : :
1477 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
1478 : : {
1479 : 599214 : if (DECL_ASSEMBLER_NAME_SET_P (t))
1480 : 596820 : visit (DECL_ASSEMBLER_NAME (t));
1481 : : }
1482 : :
1483 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
1484 : : {
1485 : 80922 : visit (DECL_FIELD_OFFSET (t));
1486 : 80922 : visit (DECL_BIT_FIELD_TYPE (t));
1487 : 80922 : visit (DECL_BIT_FIELD_REPRESENTATIVE (t));
1488 : 80922 : visit (DECL_FIELD_BIT_OFFSET (t));
1489 : : }
1490 : :
1491 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
1492 : : {
1493 : 343113 : visit (DECL_FUNCTION_PERSONALITY (t));
1494 : 343113 : visit (DECL_FUNCTION_SPECIFIC_TARGET (t));
1495 : 343113 : visit (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t));
1496 : : }
1497 : :
1498 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
1499 : : {
1500 : 446756 : visit (TYPE_SIZE (t));
1501 : 446756 : visit (TYPE_SIZE_UNIT (t));
1502 : 446756 : visit (TYPE_ATTRIBUTES (t));
1503 : 446756 : visit (TYPE_NAME (t));
1504 : 446756 : visit (TYPE_MAIN_VARIANT (t));
1505 : 446756 : if (TYPE_FILE_SCOPE_P (t))
1506 : : ;
1507 : : else
1508 : 15219 : visit (TYPE_CONTEXT (t));
1509 : : }
1510 : :
1511 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
1512 : : {
1513 : 446756 : if (code == ARRAY_TYPE)
1514 : 28359 : visit (TYPE_DOMAIN (t));
1515 : 418397 : else if (RECORD_OR_UNION_TYPE_P (t))
1516 : 174519 : for (tree f = TYPE_FIELDS (t); f; f = TREE_CHAIN (f))
1517 : 104089 : visit (f);
1518 : 347967 : else if (code == FUNCTION_TYPE
1519 : 347967 : || code == METHOD_TYPE)
1520 : 111144 : visit (TYPE_ARG_TYPES (t));
1521 : 446756 : if (!POINTER_TYPE_P (t))
1522 : 262750 : visit (TYPE_MIN_VALUE_RAW (t));
1523 : 446756 : visit (TYPE_MAX_VALUE_RAW (t));
1524 : : }
1525 : :
1526 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_LIST))
1527 : : {
1528 : 518952 : visit (TREE_PURPOSE (t));
1529 : 518952 : visit (TREE_VALUE (t));
1530 : 518952 : visit (TREE_CHAIN (t));
1531 : : }
1532 : :
1533 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1534 : 0 : for (int i = 0; i < TREE_VEC_LENGTH (t); ++i)
1535 : 0 : visit (TREE_VEC_ELT (t, i));
1536 : :
1537 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_EXP))
1538 : : {
1539 : 7449 : hstate.add_hwi (TREE_OPERAND_LENGTH (t));
1540 : 18630 : for (int i = 0; i < TREE_OPERAND_LENGTH (t); ++i)
1541 : 11181 : visit (TREE_OPERAND (t, i));
1542 : : }
1543 : :
1544 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1545 : : {
1546 : : unsigned i;
1547 : : tree b;
1548 : 12623 : FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (t), i, b)
1549 : 6370 : visit (b);
1550 : 6253 : visit (BINFO_OFFSET (t));
1551 : 6253 : visit (BINFO_VTABLE (t));
1552 : : /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
1553 : : BINFO_BASE_ACCESSES and BINFO_VPTR_INDEX; these are used
1554 : : by C++ FE only. */
1555 : : }
1556 : :
1557 : 2764212 : if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
1558 : : {
1559 : 388 : unsigned i;
1560 : 388 : tree index, value;
1561 : 591 : hstate.add_hwi (CONSTRUCTOR_NELTS (t));
1562 : 1730 : FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), i, index, value)
1563 : : {
1564 : 1342 : visit (index);
1565 : 1342 : visit (value);
1566 : : }
1567 : : }
1568 : :
1569 : 2764212 : if (code == OMP_CLAUSE)
1570 : : {
1571 : 134 : int i;
1572 : 134 : HOST_WIDE_INT val;
1573 : :
1574 : 134 : hstate.add_hwi (OMP_CLAUSE_CODE (t));
1575 : 134 : switch (OMP_CLAUSE_CODE (t))
1576 : : {
1577 : 0 : case OMP_CLAUSE_DEFAULT:
1578 : 0 : val = OMP_CLAUSE_DEFAULT_KIND (t);
1579 : 0 : break;
1580 : 0 : case OMP_CLAUSE_SCHEDULE:
1581 : 0 : val = OMP_CLAUSE_SCHEDULE_KIND (t);
1582 : 0 : break;
1583 : 0 : case OMP_CLAUSE_DEPEND:
1584 : 0 : val = OMP_CLAUSE_DEPEND_KIND (t);
1585 : 0 : break;
1586 : 0 : case OMP_CLAUSE_DOACROSS:
1587 : 0 : val = OMP_CLAUSE_DOACROSS_KIND (t);
1588 : 0 : break;
1589 : 0 : case OMP_CLAUSE_MAP:
1590 : 0 : val = OMP_CLAUSE_MAP_KIND (t);
1591 : 0 : break;
1592 : 0 : case OMP_CLAUSE_PROC_BIND:
1593 : 0 : val = OMP_CLAUSE_PROC_BIND_KIND (t);
1594 : 0 : break;
1595 : 0 : case OMP_CLAUSE_REDUCTION:
1596 : 0 : case OMP_CLAUSE_TASK_REDUCTION:
1597 : 0 : case OMP_CLAUSE_IN_REDUCTION:
1598 : 0 : val = OMP_CLAUSE_REDUCTION_CODE (t);
1599 : 0 : break;
1600 : : default:
1601 : : val = 0;
1602 : : break;
1603 : : }
1604 : 134 : hstate.add_hwi (val);
1605 : 302 : for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (t)]; i++)
1606 : 168 : visit (OMP_CLAUSE_OPERAND (t, i));
1607 : 134 : visit (OMP_CLAUSE_CHAIN (t));
1608 : : }
1609 : :
1610 : 2764212 : return hstate.end ();
1611 : :
1612 : : #undef visit
1613 : : }
1614 : :
1615 : : /* Compare two SCC entries by their hash value for qsorting them. */
1616 : :
1617 : : int
1618 : 1539370 : DFS::scc_entry_compare (const void *p1_, const void *p2_)
1619 : : {
1620 : 1539370 : const scc_entry *p1 = (const scc_entry *) p1_;
1621 : 1539370 : const scc_entry *p2 = (const scc_entry *) p2_;
1622 : 1539370 : if (p1->hash < p2->hash)
1623 : : return -1;
1624 : 695365 : else if (p1->hash > p2->hash)
1625 : 673985 : return 1;
1626 : : return 0;
1627 : : }
1628 : :
1629 : : /* Return a hash value for the SCC on the SCC stack from FIRST with SIZE.
1630 : : THIS_REF_P and REF_P are as passed to lto_output_tree for FIRST. */
1631 : :
1632 : : hashval_t
1633 : 2621061 : DFS::hash_scc (struct output_block *ob, unsigned first, unsigned size,
1634 : : bool ref_p, bool this_ref_p)
1635 : : {
1636 : 2621061 : unsigned int last_classes = 0, iterations = 0;
1637 : :
1638 : : /* Compute hash values for the SCC members. */
1639 : 5385273 : for (unsigned i = 0; i < size; ++i)
1640 : 2764212 : sccstack[first+i].hash
1641 : 5528424 : = hash_tree (ob->writer_cache, NULL, sccstack[first+i].t);
1642 : :
1643 : 2621061 : if (size == 1)
1644 : 2555723 : return sccstack[first].hash;
1645 : :
1646 : : /* We aim to get unique hash for every tree within SCC and compute hash value
1647 : : of the whole SCC by combining all values together in a stable (entry-point
1648 : : independent) order. This guarantees that the same SCC regions within
1649 : : different translation units will get the same hash values and therefore
1650 : : will be merged at WPA time.
1651 : :
1652 : : Often the hashes are already unique. In that case we compute the SCC hash
1653 : : by combining individual hash values in an increasing order.
1654 : :
1655 : : If there are duplicates, we seek at least one tree with unique hash (and
1656 : : pick one with minimal hash and this property). Then we obtain a stable
1657 : : order by DFS walk starting from this unique tree and then use the index
1658 : : within this order to make individual hash values unique.
1659 : :
1660 : : If there is no tree with unique hash, we iteratively propagate the hash
1661 : : values across the internal edges of SCC. This usually quickly leads
1662 : : to unique hashes. Consider, for example, an SCC containing two pointers
1663 : : that are identical except for the types they point to and assume that
1664 : : these types are also part of the SCC. The propagation will add the
1665 : : points-to type information into their hash values. */
1666 : 65338 : do
1667 : : {
1668 : : /* Sort the SCC so we can easily check for uniqueness. */
1669 : 65338 : qsort (&sccstack[first], size, sizeof (scc_entry), scc_entry_compare);
1670 : :
1671 : 65338 : unsigned int classes = 1;
1672 : 65338 : int firstunique = -1;
1673 : :
1674 : : /* Find the tree with lowest unique hash (if it exists) and compute
1675 : : the number of equivalence classes. */
1676 : 65338 : if (sccstack[first].hash != sccstack[first+1].hash)
1677 : 65335 : firstunique = 0;
1678 : 208489 : for (unsigned i = 1; i < size; ++i)
1679 : 143151 : if (sccstack[first+i-1].hash != sccstack[first+i].hash)
1680 : : {
1681 : 141201 : classes++;
1682 : 141201 : if (firstunique == -1
1683 : 141201 : && (i == size - 1
1684 : 3 : || sccstack[first+i+1].hash != sccstack[first+i].hash))
1685 : 3 : firstunique = i;
1686 : : }
1687 : :
1688 : : /* If we found a tree with unique hash, stop the iteration. */
1689 : 65338 : if (firstunique != -1
1690 : : /* Also terminate if we run out of iterations or if the number of
1691 : : equivalence classes is no longer increasing.
1692 : : For example a cyclic list of trees that are all equivalent will
1693 : : never have unique entry point; we however do not build such SCCs
1694 : : in our IL. */
1695 : 65338 : || classes <= last_classes || iterations > 16)
1696 : : {
1697 : 65338 : hashval_t scc_hash;
1698 : :
1699 : : /* If some hashes are not unique (CLASSES != SIZE), use the DFS walk
1700 : : starting from FIRSTUNIQUE to obtain a stable order. */
1701 : 65338 : if (classes != size && firstunique != -1)
1702 : : {
1703 : 334 : hash_map <tree, hashval_t> map(size*2);
1704 : :
1705 : : /* Store hash values into a map, so we can associate them with
1706 : : the reordered SCC. */
1707 : 11084 : for (unsigned i = 0; i < size; ++i)
1708 : 10750 : map.put (sccstack[first+i].t, sccstack[first+i].hash);
1709 : :
1710 : 668 : DFS again (ob, sccstack[first+firstunique].t, ref_p, this_ref_p,
1711 : 334 : true);
1712 : 668 : gcc_assert (again.sccstack.length () == size);
1713 : :
1714 : 334 : memcpy (sccstack.address () + first,
1715 : 334 : again.sccstack.address (),
1716 : : sizeof (scc_entry) * size);
1717 : :
1718 : : /* Update hash values of individual members by hashing in the
1719 : : index within the stable order. This ensures uniqueness.
1720 : : Also compute the SCC hash by mixing in all hash values in
1721 : : the stable order we obtained. */
1722 : 334 : sccstack[first].hash = *map.get (sccstack[first].t);
1723 : 334 : scc_hash = sccstack[first].hash;
1724 : 10750 : for (unsigned i = 1; i < size; ++i)
1725 : : {
1726 : 31248 : sccstack[first+i].hash
1727 : 10416 : = iterative_hash_hashval_t (i,
1728 : 10416 : *map.get (sccstack[first+i].t));
1729 : 10416 : scc_hash
1730 : 10416 : = iterative_hash_hashval_t (scc_hash,
1731 : 10416 : sccstack[first+i].hash);
1732 : : }
1733 : 334 : }
1734 : : /* If we got a unique hash value for each tree, then sort already
1735 : : ensured entry-point independent order. Only compute the final
1736 : : SCC hash.
1737 : :
1738 : : If we failed to find the unique entry point, we go by the same
1739 : : route. We will eventually introduce unwanted hash conflicts. */
1740 : : else
1741 : : {
1742 : : scc_hash = sccstack[first].hash;
1743 : 197739 : for (unsigned i = 1; i < size; ++i)
1744 : 132735 : scc_hash
1745 : 132735 : = iterative_hash_hashval_t (scc_hash, sccstack[first+i].hash);
1746 : :
1747 : : /* We cannot 100% guarantee that the hash won't conflict so as
1748 : : to make it impossible to find a unique hash. This however
1749 : : should be an extremely rare case. ICE for now so possible
1750 : : issues are found and evaluated. */
1751 : 65004 : gcc_checking_assert (classes == size);
1752 : : }
1753 : :
1754 : : /* To avoid conflicts across SCCs, iteratively hash the whole SCC
1755 : : hash into the hash of each element. */
1756 : 273827 : for (unsigned i = 0; i < size; ++i)
1757 : 416978 : sccstack[first+i].hash
1758 : 208489 : = iterative_hash_hashval_t (sccstack[first+i].hash, scc_hash);
1759 : 65338 : return scc_hash;
1760 : : }
1761 : :
1762 : 0 : last_classes = classes;
1763 : 0 : iterations++;
1764 : :
1765 : : /* We failed to identify the entry point; propagate hash values across
1766 : : the edges. */
1767 : 0 : hash_map <tree, hashval_t> map(size*2);
1768 : :
1769 : 0 : for (unsigned i = 0; i < size; ++i)
1770 : 0 : map.put (sccstack[first+i].t, sccstack[first+i].hash);
1771 : :
1772 : 0 : for (unsigned i = 0; i < size; i++)
1773 : 0 : sccstack[first+i].hash
1774 : 0 : = hash_tree (ob->writer_cache, &map, sccstack[first+i].t);
1775 : 0 : }
1776 : : while (true);
1777 : : }
1778 : :
1779 : : /* DFS walk EXPR and stream SCCs of tree bodies if they are not
1780 : : already in the streamer cache. Main routine called for
1781 : : each visit of EXPR. */
1782 : :
1783 : : void
1784 : 35263603 : DFS::DFS_write_tree (struct output_block *ob, sccs *from_state,
1785 : : tree expr, bool ref_p, bool this_ref_p)
1786 : : {
1787 : : /* Handle special cases. */
1788 : 35263603 : if (expr == NULL_TREE)
1789 : 25681924 : return;
1790 : :
1791 : : /* Do not DFS walk into indexable trees. */
1792 : 23029300 : if (this_ref_p && tree_is_indexable (expr))
1793 : : return;
1794 : :
1795 : : /* Check if we already streamed EXPR. */
1796 : 16790133 : if (streamer_tree_cache_lookup (ob->writer_cache, expr, NULL))
1797 : : {
1798 : : /* Reference to a local tree makes entry also local. We always process
1799 : : top of stack entry, so set max to number of entries in stack - 1. */
1800 : 7208454 : if (ob->local_trees
1801 : 7208454 : && ob->local_trees->contains (expr))
1802 : 17010 : max_local_entry = sccstack.length () - 1;
1803 : 7208454 : return;
1804 : : }
1805 : :
1806 : 9581679 : worklist w;
1807 : 9581679 : w.expr = expr;
1808 : 9581679 : w.from_state = from_state;
1809 : 9581679 : w.cstate = NULL;
1810 : 9581679 : w.ref_p = ref_p;
1811 : 9581679 : w.this_ref_p = this_ref_p;
1812 : 9581679 : worklist_vec.safe_push (w);
1813 : : }
1814 : :
1815 : :
1816 : : /* Emit the physical representation of tree node EXPR to output block OB.
1817 : : If THIS_REF_P is true, the leaves of EXPR are emitted as references via
1818 : : lto_output_tree_ref. REF_P is used for streaming siblings of EXPR. */
1819 : :
1820 : : void
1821 : 12697159 : lto_output_tree (struct output_block *ob, tree expr,
1822 : : bool ref_p, bool this_ref_p)
1823 : : {
1824 : 12697159 : unsigned ix;
1825 : 12697159 : bool existed_p;
1826 : 12697159 : unsigned int size = ob->main_stream->total_size;
1827 : : /* This is the first time we see EXPR, write all reachable
1828 : : trees to OB. */
1829 : 12697159 : static bool in_dfs_walk;
1830 : :
1831 : 12697159 : if (expr == NULL_TREE)
1832 : : {
1833 : 2860419 : streamer_write_record_start (ob, LTO_null);
1834 : 10695626 : return;
1835 : : }
1836 : :
1837 : 9836740 : if (this_ref_p && tree_is_indexable (expr))
1838 : : {
1839 : 4974788 : enum LTO_tags tag;
1840 : 4974788 : unsigned ix;
1841 : :
1842 : 4974788 : lto_indexable_tree_ref (ob, expr, &tag, &ix);
1843 : 4974788 : streamer_write_record_start (ob, tag);
1844 : 4974788 : streamer_write_uhwi (ob, ix);
1845 : 4974788 : return;
1846 : : }
1847 : :
1848 : 4861952 : existed_p = streamer_tree_cache_lookup (ob->writer_cache, expr, &ix);
1849 : 4861952 : if (existed_p)
1850 : : {
1851 : 1892522 : if (streamer_dump_file)
1852 : : {
1853 : 88 : if (in_dfs_walk)
1854 : 8 : print_node_brief (streamer_dump_file, " Streaming ref to ",
1855 : : expr, 4);
1856 : : else
1857 : 80 : print_node_brief (streamer_dump_file, " Streaming ref to ",
1858 : : expr, 4);
1859 : 88 : fprintf (streamer_dump_file, "\n");
1860 : : }
1861 : : /* If a node has already been streamed out, make sure that
1862 : : we don't write it more than once. Otherwise, the reader
1863 : : will instantiate two different nodes for the same object. */
1864 : 1892522 : streamer_write_record_start (ob, LTO_tree_pickle_reference);
1865 : 1892522 : streamer_write_uhwi (ob, ix);
1866 : 1892522 : lto_stats.num_pickle_refs_output++;
1867 : : }
1868 : : else
1869 : : {
1870 : : /* Protect against recursion which means disconnect between
1871 : : what tree edges we walk in the DFS walk and what edges
1872 : : we stream out. */
1873 : 2969430 : gcc_assert (!in_dfs_walk);
1874 : :
1875 : 2969430 : if (streamer_dump_file)
1876 : : {
1877 : 168 : print_node_brief (streamer_dump_file, " Streaming tree ",
1878 : : expr, 4);
1879 : 168 : fprintf (streamer_dump_file, "\n");
1880 : : }
1881 : :
1882 : : /* Start the DFS walk. */
1883 : : /* Save ob state ... */
1884 : : /* let's see ... */
1885 : 2969430 : in_dfs_walk = true;
1886 : 2969430 : DFS (ob, expr, ref_p, this_ref_p, false);
1887 : :
1888 : : /* Finally append a reference to the tree we were writing. */
1889 : 2969430 : existed_p = streamer_tree_cache_lookup (ob->writer_cache, expr, &ix);
1890 : :
1891 : : /* DFS walk above possibly skipped streaming EXPR itself to let us inline
1892 : : it. */
1893 : 2969430 : if (!existed_p)
1894 : 2045902 : lto_output_tree_1 (ob, expr, 0, ref_p, this_ref_p);
1895 : 923528 : else if (this_ref_p)
1896 : : {
1897 : 10 : if (streamer_dump_file)
1898 : : {
1899 : 0 : print_node_brief (streamer_dump_file,
1900 : : " Streaming final ref to ",
1901 : : expr, 4);
1902 : 0 : fprintf (streamer_dump_file, "\n");
1903 : : }
1904 : 10 : streamer_write_record_start (ob, LTO_tree_pickle_reference);
1905 : 10 : streamer_write_uhwi (ob, ix);
1906 : : }
1907 : 2969430 : in_dfs_walk = false;
1908 : 2969430 : lto_stats.num_pickle_refs_output++;
1909 : : }
1910 : 4861952 : if (streamer_dump_file && !in_dfs_walk)
1911 : 248 : fprintf (streamer_dump_file, " %u bytes\n",
1912 : 248 : ob->main_stream->total_size - size);
1913 : : }
1914 : :
1915 : :
1916 : : /* Output to OB a list of try/catch handlers starting with FIRST. */
1917 : :
1918 : : static void
1919 : 308 : output_eh_try_list (struct output_block *ob, eh_catch first)
1920 : : {
1921 : 308 : eh_catch n;
1922 : :
1923 : 705 : for (n = first; n; n = n->next_catch)
1924 : : {
1925 : 397 : streamer_write_record_start (ob, LTO_eh_catch);
1926 : 397 : stream_write_tree (ob, n->type_list, true);
1927 : 397 : stream_write_tree (ob, n->filter_list, true);
1928 : 397 : stream_write_tree (ob, n->label, true);
1929 : : }
1930 : :
1931 : 308 : streamer_write_record_start (ob, LTO_null);
1932 : 308 : }
1933 : :
1934 : :
1935 : : /* Output EH region R in function FN to OB. CURR_RN is the slot index
1936 : : that is being emitted in FN->EH->REGION_ARRAY. This is used to
1937 : : detect EH region sharing. */
1938 : :
1939 : : static void
1940 : 18316 : output_eh_region (struct output_block *ob, eh_region r)
1941 : : {
1942 : 18316 : enum LTO_tags tag;
1943 : :
1944 : 18316 : if (r == NULL)
1945 : : {
1946 : 7604 : streamer_write_record_start (ob, LTO_null);
1947 : 7604 : return;
1948 : : }
1949 : :
1950 : 10712 : if (r->type == ERT_CLEANUP)
1951 : : tag = LTO_ert_cleanup;
1952 : : else if (r->type == ERT_TRY)
1953 : : tag = LTO_ert_try;
1954 : : else if (r->type == ERT_ALLOWED_EXCEPTIONS)
1955 : : tag = LTO_ert_allowed_exceptions;
1956 : : else if (r->type == ERT_MUST_NOT_THROW)
1957 : : tag = LTO_ert_must_not_throw;
1958 : : else
1959 : 0 : gcc_unreachable ();
1960 : :
1961 : 10712 : streamer_write_record_start (ob, tag);
1962 : 10712 : streamer_write_hwi (ob, r->index);
1963 : :
1964 : 10712 : if (r->outer)
1965 : 3166 : streamer_write_hwi (ob, r->outer->index);
1966 : : else
1967 : 7546 : streamer_write_zero (ob);
1968 : :
1969 : 10712 : if (r->inner)
1970 : 1857 : streamer_write_hwi (ob, r->inner->index);
1971 : : else
1972 : 8855 : streamer_write_zero (ob);
1973 : :
1974 : 10712 : if (r->next_peer)
1975 : 4534 : streamer_write_hwi (ob, r->next_peer->index);
1976 : : else
1977 : 6178 : streamer_write_zero (ob);
1978 : :
1979 : 10712 : if (r->type == ERT_TRY)
1980 : : {
1981 : 308 : output_eh_try_list (ob, r->u.eh_try.first_catch);
1982 : : }
1983 : 10404 : else if (r->type == ERT_ALLOWED_EXCEPTIONS)
1984 : : {
1985 : 324 : stream_write_tree (ob, r->u.allowed.type_list, true);
1986 : 324 : stream_write_tree (ob, r->u.allowed.label, true);
1987 : 324 : streamer_write_uhwi (ob, r->u.allowed.filter);
1988 : : }
1989 : 10080 : else if (r->type == ERT_MUST_NOT_THROW)
1990 : : {
1991 : 5428 : stream_write_tree (ob, r->u.must_not_throw.failure_decl, true);
1992 : 5428 : bitpack_d bp = bitpack_create (ob->main_stream);
1993 : 5428 : stream_output_location (ob, &bp, r->u.must_not_throw.failure_loc);
1994 : 5428 : streamer_write_bitpack (&bp);
1995 : : }
1996 : :
1997 : 10712 : if (r->landing_pads)
1998 : 3166 : streamer_write_hwi (ob, r->landing_pads->index);
1999 : : else
2000 : 7546 : streamer_write_zero (ob);
2001 : : }
2002 : :
2003 : :
2004 : : /* Output landing pad LP to OB. */
2005 : :
2006 : : static void
2007 : 8387 : output_eh_lp (struct output_block *ob, eh_landing_pad lp)
2008 : : {
2009 : 8387 : if (lp == NULL)
2010 : : {
2011 : 5171 : streamer_write_record_start (ob, LTO_null);
2012 : 5171 : return;
2013 : : }
2014 : :
2015 : 3216 : streamer_write_record_start (ob, LTO_eh_landing_pad);
2016 : 3216 : streamer_write_hwi (ob, lp->index);
2017 : 3216 : if (lp->next_lp)
2018 : 50 : streamer_write_hwi (ob, lp->next_lp->index);
2019 : : else
2020 : 3166 : streamer_write_zero (ob);
2021 : :
2022 : 3216 : if (lp->region)
2023 : 3216 : streamer_write_hwi (ob, lp->region->index);
2024 : : else
2025 : 0 : streamer_write_zero (ob);
2026 : :
2027 : 3216 : stream_write_tree (ob, lp->post_landing_pad, true);
2028 : : }
2029 : :
2030 : :
2031 : : /* Output the existing eh_table to OB. */
2032 : :
2033 : : static void
2034 : 108014 : output_eh_regions (struct output_block *ob, struct function *fn)
2035 : : {
2036 : 108014 : if (fn->eh && fn->eh->region_tree)
2037 : : {
2038 : 4321 : unsigned i;
2039 : 4321 : eh_region eh;
2040 : 4321 : eh_landing_pad lp;
2041 : 4321 : tree ttype;
2042 : :
2043 : 4321 : streamer_write_record_start (ob, LTO_eh_table);
2044 : :
2045 : : /* Emit the index of the root of the EH region tree. */
2046 : 4321 : streamer_write_hwi (ob, fn->eh->region_tree->index);
2047 : :
2048 : : /* Emit all the EH regions in the region array. */
2049 : 4321 : streamer_write_hwi (ob, vec_safe_length (fn->eh->region_array));
2050 : 26958 : FOR_EACH_VEC_SAFE_ELT (fn->eh->region_array, i, eh)
2051 : 18316 : output_eh_region (ob, eh);
2052 : :
2053 : : /* Emit all landing pads. */
2054 : 4321 : streamer_write_hwi (ob, vec_safe_length (fn->eh->lp_array));
2055 : 17029 : FOR_EACH_VEC_SAFE_ELT (fn->eh->lp_array, i, lp)
2056 : 8387 : output_eh_lp (ob, lp);
2057 : :
2058 : : /* Emit all the runtime type data. */
2059 : 4321 : streamer_write_hwi (ob, vec_safe_length (fn->eh->ttype_data));
2060 : 8642 : FOR_EACH_VEC_SAFE_ELT (fn->eh->ttype_data, i, ttype)
2061 : 0 : stream_write_tree (ob, ttype, true);
2062 : :
2063 : : /* Emit the table of action chains. */
2064 : 4321 : if (targetm.arm_eabi_unwinder)
2065 : : {
2066 : 0 : tree t;
2067 : 0 : streamer_write_hwi (ob, vec_safe_length (fn->eh->ehspec_data.arm_eabi));
2068 : 0 : FOR_EACH_VEC_SAFE_ELT (fn->eh->ehspec_data.arm_eabi, i, t)
2069 : 0 : stream_write_tree (ob, t, true);
2070 : : }
2071 : : else
2072 : : {
2073 : 4321 : uchar c;
2074 : 4321 : streamer_write_hwi (ob, vec_safe_length (fn->eh->ehspec_data.other));
2075 : 8642 : FOR_EACH_VEC_SAFE_ELT (fn->eh->ehspec_data.other, i, c)
2076 : 0 : streamer_write_char_stream (ob->main_stream, c);
2077 : : }
2078 : : }
2079 : :
2080 : : /* The LTO_null either terminates the record or indicates that there
2081 : : are no eh_records at all. */
2082 : 108014 : streamer_write_record_start (ob, LTO_null);
2083 : 108014 : }
2084 : :
2085 : :
2086 : : /* Output all of the active ssa names to the ssa_names stream. */
2087 : :
2088 : : static void
2089 : 108014 : output_ssa_names (struct output_block *ob, struct function *fn)
2090 : : {
2091 : 108014 : unsigned int i, len;
2092 : :
2093 : 108014 : len = vec_safe_length (SSANAMES (fn));
2094 : 108014 : streamer_write_uhwi (ob, len);
2095 : :
2096 : 1717060 : for (i = 1; i < len; i++)
2097 : : {
2098 : 1609046 : tree ptr = (*SSANAMES (fn))[i];
2099 : :
2100 : 2209725 : if (ptr == NULL_TREE
2101 : 1602831 : || SSA_NAME_IN_FREE_LIST (ptr)
2102 : 1602831 : || virtual_operand_p (ptr)
2103 : : /* Simply skip unreleased SSA names. */
2104 : 2620309 : || (! SSA_NAME_IS_DEFAULT_DEF (ptr)
2105 : 906242 : && (! SSA_NAME_DEF_STMT (ptr)
2106 : 906242 : || ! gimple_bb (SSA_NAME_DEF_STMT (ptr)))))
2107 : 600679 : continue;
2108 : :
2109 : 1008367 : streamer_write_uhwi (ob, i);
2110 : 1008367 : streamer_write_char_stream (ob->main_stream,
2111 : 1008367 : SSA_NAME_IS_DEFAULT_DEF (ptr));
2112 : 1008367 : if (SSA_NAME_VAR (ptr))
2113 : 293498 : stream_write_tree (ob, SSA_NAME_VAR (ptr), true);
2114 : : else
2115 : : /* ??? This drops SSA_NAME_IDENTIFIER on the floor. */
2116 : 714869 : stream_write_tree (ob, TREE_TYPE (ptr), true);
2117 : : }
2118 : :
2119 : 108014 : streamer_write_zero (ob);
2120 : 108014 : }
2121 : :
2122 : :
2123 : :
2124 : : /* Output the cfg. */
2125 : :
2126 : : static void
2127 : 108014 : output_cfg (struct output_block *ob, struct function *fn)
2128 : : {
2129 : 108014 : struct lto_output_stream *tmp_stream = ob->main_stream;
2130 : 108014 : basic_block bb;
2131 : :
2132 : 108014 : ob->main_stream = ob->cfg_stream;
2133 : :
2134 : 108014 : streamer_write_enum (ob->main_stream, profile_status_d, PROFILE_LAST,
2135 : : profile_status_for_fn (fn));
2136 : :
2137 : : /* Output the number of the highest basic block. */
2138 : 108014 : streamer_write_uhwi (ob, last_basic_block_for_fn (fn));
2139 : :
2140 : 1019605 : FOR_ALL_BB_FN (bb, fn)
2141 : : {
2142 : 911591 : edge_iterator ei;
2143 : 911591 : edge e;
2144 : :
2145 : 911591 : streamer_write_hwi (ob, bb->index);
2146 : :
2147 : : /* Output the successors and the edge flags. */
2148 : 1712518 : streamer_write_uhwi (ob, EDGE_COUNT (bb->succs));
2149 : 1947205 : FOR_EACH_EDGE (e, ei, bb->succs)
2150 : : {
2151 : 1035614 : bitpack_d bp = bitpack_create (ob->main_stream);
2152 : 1035614 : bp_pack_var_len_unsigned (&bp, e->dest->index);
2153 : 1035614 : bp_pack_var_len_unsigned (&bp, e->flags);
2154 : 1035614 : stream_output_location_and_block (ob, &bp, e->goto_locus);
2155 : 1035614 : e->probability.stream_out (ob);
2156 : : }
2157 : : }
2158 : :
2159 : 108014 : streamer_write_hwi (ob, -1);
2160 : :
2161 : 108014 : bb = ENTRY_BLOCK_PTR_FOR_FN (fn);
2162 : 911591 : while (bb->next_bb)
2163 : : {
2164 : 803577 : streamer_write_hwi (ob, bb->next_bb->index);
2165 : 803577 : bb = bb->next_bb;
2166 : : }
2167 : :
2168 : 108014 : streamer_write_hwi (ob, -1);
2169 : :
2170 : : /* Output the number of loops. */
2171 : 108014 : streamer_write_uhwi (ob, number_of_loops (fn));
2172 : :
2173 : : /* Output each loop, skipping the tree root which has number zero. */
2174 : 363532 : for (unsigned i = 1; i < number_of_loops (fn); ++i)
2175 : : {
2176 : 73752 : class loop *loop = get_loop (fn, i);
2177 : :
2178 : : /* Write the index of the loop header. That's enough to rebuild
2179 : : the loop tree on the reader side. Stream -1 for an unused
2180 : : loop entry. */
2181 : 73752 : if (!loop)
2182 : : {
2183 : 25281 : streamer_write_hwi (ob, -1);
2184 : 25281 : continue;
2185 : : }
2186 : : else
2187 : 48471 : streamer_write_hwi (ob, loop->header->index);
2188 : :
2189 : : /* Write everything copy_loop_info copies. */
2190 : 48471 : streamer_write_enum (ob->main_stream,
2191 : : loop_estimation, EST_LAST, loop->estimate_state);
2192 : 48471 : streamer_write_hwi (ob, loop->any_upper_bound);
2193 : 48471 : if (loop->any_upper_bound)
2194 : : {
2195 : 39625 : widest_int w = widest_int::from (loop->nb_iterations_upper_bound,
2196 : 39625 : SIGNED);
2197 : 39625 : streamer_write_widest_int (ob, w);
2198 : 39625 : }
2199 : 48471 : streamer_write_hwi (ob, loop->any_likely_upper_bound);
2200 : 48471 : if (loop->any_likely_upper_bound)
2201 : : {
2202 : 39627 : widest_int w
2203 : 39627 : = widest_int::from (loop->nb_iterations_likely_upper_bound,
2204 : 39627 : SIGNED);
2205 : 39627 : streamer_write_widest_int (ob, w);
2206 : 39627 : }
2207 : 48471 : streamer_write_hwi (ob, loop->any_estimate);
2208 : 48471 : if (loop->any_estimate)
2209 : : {
2210 : 32942 : widest_int w = widest_int::from (loop->nb_iterations_estimate,
2211 : 32942 : SIGNED);
2212 : 32942 : streamer_write_widest_int (ob, w);
2213 : 32942 : }
2214 : :
2215 : : /* Write OMP SIMD related info. */
2216 : 48471 : streamer_write_hwi (ob, loop->safelen);
2217 : 48471 : streamer_write_hwi (ob, loop->unroll);
2218 : 48471 : streamer_write_hwi (ob, loop->owned_clique);
2219 : 48471 : streamer_write_hwi (ob, loop->dont_vectorize);
2220 : 48471 : streamer_write_hwi (ob, loop->force_vectorize);
2221 : 48471 : streamer_write_hwi (ob, loop->finite_p);
2222 : 48471 : stream_write_tree (ob, loop->simduid, true);
2223 : : }
2224 : :
2225 : 108014 : ob->main_stream = tmp_stream;
2226 : 108014 : }
2227 : :
2228 : : /* Create the header in the file using OB. If the section type is for
2229 : : a function, set FN to the decl for that function. */
2230 : :
2231 : : void
2232 : 258463 : produce_symbol_asm (struct output_block *ob, tree fn, int output_order)
2233 : : {
2234 : 258463 : enum lto_section_type section_type = ob->section_type;
2235 : 258463 : struct lto_function_header header;
2236 : 258463 : char *section_name;
2237 : :
2238 : 258463 : if (section_type == LTO_section_function_body)
2239 : : {
2240 : 119051 : const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn));
2241 : 119051 : section_name = lto_get_section_name (section_type, name,
2242 : : output_order, NULL);
2243 : : }
2244 : : else
2245 : 139412 : section_name = lto_get_section_name (section_type, NULL, 0, NULL);
2246 : :
2247 : 258463 : lto_begin_section (section_name, !flag_wpa);
2248 : 258463 : free (section_name);
2249 : :
2250 : : /* The entire header is stream computed here. */
2251 : 258463 : memset (&header, 0, sizeof (struct lto_function_header));
2252 : :
2253 : 258463 : if (section_type == LTO_section_function_body)
2254 : 119051 : header.cfg_size = ob->cfg_stream->total_size;
2255 : 258463 : header.main_size = ob->main_stream->total_size;
2256 : 258463 : header.string_size = ob->string_stream->total_size;
2257 : 258463 : lto_write_data (&header, sizeof header);
2258 : :
2259 : : /* Put all of the gimple and the string table out the asm file as a
2260 : : block of text. */
2261 : 258463 : if (section_type == LTO_section_function_body)
2262 : 119051 : lto_write_stream (ob->cfg_stream);
2263 : 258463 : lto_write_stream (ob->main_stream);
2264 : 258463 : lto_write_stream (ob->string_stream);
2265 : :
2266 : 258463 : lto_end_section ();
2267 : 258463 : }
2268 : :
2269 : : /* Wrapper for unused arguments. */
2270 : :
2271 : : void
2272 : 139412 : produce_asm (struct output_block *ob)
2273 : : {
2274 : 139412 : produce_symbol_asm (ob, NULL, -1);
2275 : 139412 : }
2276 : :
2277 : :
2278 : : /* Output the base body of struct function FN using output block OB. */
2279 : :
2280 : : static void
2281 : 108014 : output_struct_function_base (struct output_block *ob, struct function *fn)
2282 : : {
2283 : 108014 : struct bitpack_d bp;
2284 : 108014 : unsigned i;
2285 : 108014 : tree t;
2286 : :
2287 : : /* Output the static chain and non-local goto save area. */
2288 : 108014 : stream_write_tree (ob, fn->static_chain_decl, true);
2289 : 108014 : stream_write_tree (ob, fn->nonlocal_goto_save_area, true);
2290 : :
2291 : : /* Output all the local variables in the function. */
2292 : 108014 : streamer_write_hwi (ob, vec_safe_length (fn->local_decls));
2293 : 380295 : FOR_EACH_VEC_SAFE_ELT (fn->local_decls, i, t)
2294 : 164267 : stream_write_tree (ob, t, true);
2295 : :
2296 : : /* Output current IL state of the function. */
2297 : 108014 : streamer_write_uhwi (ob, fn->curr_properties);
2298 : :
2299 : : /* Write all the attributes for FN. */
2300 : 108014 : bp = bitpack_create (ob->main_stream);
2301 : 108014 : bp_pack_value (&bp, fn->is_thunk, 1);
2302 : 108014 : bp_pack_value (&bp, fn->has_local_explicit_reg_vars, 1);
2303 : 108014 : bp_pack_value (&bp, fn->returns_pcc_struct, 1);
2304 : 108014 : bp_pack_value (&bp, fn->returns_struct, 1);
2305 : 108014 : bp_pack_value (&bp, fn->can_throw_non_call_exceptions, 1);
2306 : 108014 : bp_pack_value (&bp, fn->can_delete_dead_exceptions, 1);
2307 : 108014 : bp_pack_value (&bp, fn->always_inline_functions_inlined, 1);
2308 : 108014 : bp_pack_value (&bp, fn->after_inlining, 1);
2309 : 108014 : bp_pack_value (&bp, fn->stdarg, 1);
2310 : 108014 : bp_pack_value (&bp, fn->has_nonlocal_label, 1);
2311 : 108014 : bp_pack_value (&bp, fn->has_forced_label_in_static, 1);
2312 : 108014 : bp_pack_value (&bp, fn->calls_alloca, 1);
2313 : 108014 : bp_pack_value (&bp, fn->calls_setjmp, 1);
2314 : 108014 : bp_pack_value (&bp, fn->calls_eh_return, 1);
2315 : 108014 : bp_pack_value (&bp, fn->has_force_vectorize_loops, 1);
2316 : 108014 : bp_pack_value (&bp, fn->has_simduid_loops, 1);
2317 : 108014 : bp_pack_value (&bp, fn->has_musttail, 1);
2318 : 108014 : bp_pack_value (&bp, fn->has_unroll, 1);
2319 : 108014 : bp_pack_value (&bp, fn->assume_function, 1);
2320 : 108014 : bp_pack_value (&bp, fn->va_list_fpr_size, 8);
2321 : 108014 : bp_pack_value (&bp, fn->va_list_gpr_size, 8);
2322 : 108014 : bp_pack_value (&bp, fn->last_clique, sizeof (short) * 8);
2323 : :
2324 : : /* Output the function start and end loci. */
2325 : 108014 : stream_output_location (ob, &bp, fn->function_start_locus);
2326 : 108014 : stream_output_location (ob, &bp, fn->function_end_locus);
2327 : :
2328 : : /* Save the instance discriminator if present. */
2329 : 108014 : int *instance_number_p = NULL;
2330 : 108014 : if (decl_to_instance_map)
2331 : 0 : instance_number_p = decl_to_instance_map->get (fn->decl);
2332 : 108014 : bp_pack_value (&bp, !!instance_number_p, 1);
2333 : 108014 : if (instance_number_p)
2334 : 0 : bp_pack_value (&bp, *instance_number_p, sizeof (int) * CHAR_BIT);
2335 : :
2336 : 108014 : streamer_write_bitpack (&bp);
2337 : 108014 : }
2338 : :
2339 : :
2340 : : /* Collect all leaf BLOCKs beyond ROOT into LEAFS. */
2341 : :
2342 : : static void
2343 : 242423 : collect_block_tree_leafs (tree root, vec<tree> &leafs)
2344 : : {
2345 : 450953 : for (root = BLOCK_SUBBLOCKS (root); root; root = BLOCK_CHAIN (root))
2346 : 208530 : if (! BLOCK_SUBBLOCKS (root))
2347 : 74121 : leafs.safe_push (root);
2348 : : else
2349 : 134409 : collect_block_tree_leafs (root, leafs);
2350 : 242423 : }
2351 : :
2352 : : /* This performs function body modifications that are needed for streaming
2353 : : to work. */
2354 : :
2355 : : void
2356 : 108004 : lto_prepare_function_for_streaming (struct cgraph_node *node)
2357 : : {
2358 : 108004 : struct function *fn = DECL_STRUCT_FUNCTION (node->decl);
2359 : 108004 : basic_block bb;
2360 : :
2361 : 216008 : if (number_of_loops (fn))
2362 : : {
2363 : 108004 : push_cfun (fn);
2364 : 108004 : loop_optimizer_init (AVOID_CFG_MODIFICATIONS);
2365 : 108004 : loop_optimizer_finalize ();
2366 : 108004 : pop_cfun ();
2367 : : }
2368 : : /* We will renumber the statements. The code that does this uses
2369 : : the same ordering that we use for serializing them so we can use
2370 : : the same code on the other end and not have to write out the
2371 : : statement numbers. We do not assign UIDs to PHIs here because
2372 : : virtual PHIs get re-computed on-the-fly which would make numbers
2373 : : inconsistent. */
2374 : 108004 : set_gimple_stmt_max_uid (fn, 0);
2375 : 1019565 : FOR_ALL_BB_FN (bb, fn)
2376 : : {
2377 : 1067714 : for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
2378 : 156153 : gsi_next (&gsi))
2379 : : {
2380 : 156153 : gphi *stmt = gsi.phi ();
2381 : :
2382 : : /* Virtual PHIs are not going to be streamed. */
2383 : 312306 : if (!virtual_operand_p (gimple_phi_result (stmt)))
2384 : 90405 : gimple_set_uid (stmt, inc_gimple_stmt_max_uid (fn));
2385 : : }
2386 : 3498835 : for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);
2387 : 1675713 : gsi_next (&gsi))
2388 : : {
2389 : 1675713 : gimple *stmt = gsi_stmt (gsi);
2390 : 1675713 : gimple_set_uid (stmt, inc_gimple_stmt_max_uid (fn));
2391 : : }
2392 : : }
2393 : : /* To avoid keeping duplicate gimple IDs in the statements, renumber
2394 : : virtual phis now. */
2395 : 1019565 : FOR_ALL_BB_FN (bb, fn)
2396 : : {
2397 : 1067714 : for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
2398 : 156153 : gsi_next (&gsi))
2399 : : {
2400 : 156153 : gphi *stmt = gsi.phi ();
2401 : 378054 : if (virtual_operand_p (gimple_phi_result (stmt)))
2402 : 65748 : gimple_set_uid (stmt, inc_gimple_stmt_max_uid (fn));
2403 : : }
2404 : : }
2405 : :
2406 : 108004 : }
2407 : :
2408 : : /* Emit the chain of tree nodes starting at T. OB is the output block
2409 : : to write to. REF_P is true if chain elements should be emitted
2410 : : as references. */
2411 : :
2412 : : static void
2413 : 108161 : streamer_write_chain (struct output_block *ob, tree t, bool ref_p)
2414 : : {
2415 : 425820 : while (t)
2416 : : {
2417 : : /* We avoid outputting external vars or functions by reference
2418 : : to the global decls section as we do not want to have them
2419 : : enter decl merging. We should not need to do this anymore because
2420 : : free_lang_data removes them from block scopes. */
2421 : 317659 : gcc_assert (!VAR_OR_FUNCTION_DECL_P (t) || !DECL_EXTERNAL (t));
2422 : 317659 : stream_write_tree (ob, t, ref_p);
2423 : :
2424 : 317659 : t = TREE_CHAIN (t);
2425 : : }
2426 : :
2427 : : /* Write a sentinel to terminate the chain. */
2428 : 108161 : stream_write_tree (ob, NULL_TREE, ref_p);
2429 : 108161 : }
2430 : :
2431 : : /* Output the body of function NODE->DECL. */
2432 : :
2433 : : static void
2434 : 108161 : output_function (struct cgraph_node *node, int output_order)
2435 : : {
2436 : 108161 : tree function;
2437 : 108161 : struct function *fn;
2438 : 108161 : basic_block bb;
2439 : 108161 : struct output_block *ob;
2440 : :
2441 : 108161 : if (streamer_dump_file)
2442 : 8 : fprintf (streamer_dump_file, "\nStreaming body of %s\n",
2443 : : node->dump_name ());
2444 : :
2445 : 108161 : function = node->decl;
2446 : 108161 : fn = DECL_STRUCT_FUNCTION (function);
2447 : 108161 : ob = create_output_block (LTO_section_function_body);
2448 : :
2449 : 108161 : ob->symbol = node;
2450 : :
2451 : 108161 : gcc_assert (current_function_decl == NULL_TREE && cfun == NULL);
2452 : :
2453 : : /* Make string 0 be a NULL string. */
2454 : 108161 : streamer_write_char_stream (ob->string_stream, 0);
2455 : :
2456 : 108161 : streamer_write_record_start (ob, LTO_function);
2457 : :
2458 : : /* Output decls for parameters and args. */
2459 : 108161 : stream_write_tree (ob, DECL_RESULT (function), true);
2460 : 108161 : streamer_write_chain (ob, DECL_ARGUMENTS (function), true);
2461 : :
2462 : : /* Output debug args if available. */
2463 : 108161 : vec<tree, va_gc> **debugargs = decl_debug_args_lookup (function);
2464 : 108161 : if (! debugargs)
2465 : 108132 : streamer_write_uhwi (ob, 0);
2466 : : else
2467 : : {
2468 : 29 : streamer_write_uhwi (ob, (*debugargs)->length ());
2469 : 103 : for (unsigned i = 0; i < (*debugargs)->length (); ++i)
2470 : 74 : stream_write_tree (ob, (**debugargs)[i], true);
2471 : : }
2472 : :
2473 : : /* Output DECL_INITIAL for the function, which contains the tree of
2474 : : lexical scopes. */
2475 : 108161 : stream_write_tree (ob, DECL_INITIAL (function), true);
2476 : : /* As we do not recurse into BLOCK_SUBBLOCKS but only BLOCK_SUPERCONTEXT
2477 : : collect block tree leafs and stream those. */
2478 : 108161 : auto_vec<tree> block_tree_leafs;
2479 : 108161 : if (DECL_INITIAL (function) && DECL_INITIAL (function) != error_mark_node)
2480 : 108014 : collect_block_tree_leafs (DECL_INITIAL (function), block_tree_leafs);
2481 : 108161 : streamer_write_uhwi (ob, block_tree_leafs.length ());
2482 : 182282 : for (unsigned i = 0; i < block_tree_leafs.length (); ++i)
2483 : 74121 : stream_write_tree (ob, block_tree_leafs[i], true);
2484 : :
2485 : : /* We also stream abstract functions where we stream only stuff needed for
2486 : : debug info. */
2487 : 108161 : if (gimple_has_body_p (function))
2488 : : {
2489 : 108014 : streamer_write_uhwi (ob, 1);
2490 : 108014 : output_struct_function_base (ob, fn);
2491 : :
2492 : 108014 : output_cfg (ob, fn);
2493 : :
2494 : : /* Output all the SSA names used in the function. */
2495 : 108014 : output_ssa_names (ob, fn);
2496 : :
2497 : : /* Output any exception handling regions. */
2498 : 108014 : output_eh_regions (ob, fn);
2499 : :
2500 : : /* Output the code for the function. */
2501 : 1019605 : FOR_ALL_BB_FN (bb, fn)
2502 : 911591 : output_bb (ob, bb, fn);
2503 : :
2504 : : /* The terminator for this function. */
2505 : 108014 : streamer_write_record_start (ob, LTO_null);
2506 : : }
2507 : : else
2508 : 147 : streamer_write_uhwi (ob, 0);
2509 : :
2510 : : /* Create a section to hold the pickled output of this function. */
2511 : 108161 : produce_symbol_asm (ob, function, output_order);
2512 : :
2513 : 108161 : destroy_output_block (ob);
2514 : 108161 : if (streamer_dump_file)
2515 : 8 : fprintf (streamer_dump_file, "Finished streaming %s\n",
2516 : : node->dump_name ());
2517 : 108161 : }
2518 : :
2519 : : /* Output the body of function NODE->DECL. */
2520 : :
2521 : : static void
2522 : 10890 : output_constructor (struct varpool_node *node, int output_order)
2523 : : {
2524 : 10890 : tree var = node->decl;
2525 : 10890 : struct output_block *ob;
2526 : :
2527 : 10890 : if (streamer_dump_file)
2528 : 4 : fprintf (streamer_dump_file, "\nStreaming constructor of %s\n",
2529 : : node->dump_name ());
2530 : :
2531 : 10890 : timevar_push (TV_IPA_LTO_CTORS_OUT);
2532 : 10890 : ob = create_output_block (LTO_section_function_body);
2533 : :
2534 : 10890 : ob->symbol = node;
2535 : :
2536 : : /* Make string 0 be a NULL string. */
2537 : 10890 : streamer_write_char_stream (ob->string_stream, 0);
2538 : :
2539 : : /* Output DECL_INITIAL for the function, which contains the tree of
2540 : : lexical scopes. */
2541 : 10890 : stream_write_tree (ob, DECL_INITIAL (var), true);
2542 : :
2543 : : /* Create a section to hold the pickled output of this function. */
2544 : 10890 : produce_symbol_asm (ob, var, output_order);
2545 : :
2546 : 10890 : destroy_output_block (ob);
2547 : 10890 : if (streamer_dump_file)
2548 : 4 : fprintf (streamer_dump_file, "Finished streaming %s\n",
2549 : : node->dump_name ());
2550 : 10890 : timevar_pop (TV_IPA_LTO_CTORS_OUT);
2551 : 10890 : }
2552 : :
2553 : :
2554 : : /* Emit toplevel asms. */
2555 : :
2556 : : void
2557 : 33469 : lto_output_toplevel_asms (lto_symtab_encoder_t encoder)
2558 : : {
2559 : 33469 : struct output_block *ob;
2560 : 33469 : char *section_name;
2561 : 33469 : struct lto_simple_header_with_strings header;
2562 : :
2563 : 33469 : bool any_asm = false;
2564 : 1489262 : for (int i = 0; i < lto_symtab_encoder_size (encoder); i++)
2565 : 1422562 : if (is_a <asm_node*> (lto_symtab_encoder_deref (encoder, i)))
2566 : : any_asm = true;
2567 : :
2568 : 33469 : if (!any_asm)
2569 : 33401 : return;
2570 : :
2571 : 68 : ob = create_output_block (LTO_section_asm);
2572 : :
2573 : : /* Make string 0 be a NULL string. */
2574 : 68 : streamer_write_char_stream (ob->string_stream, 0);
2575 : :
2576 : 13404 : for (int i = 0; i < lto_symtab_encoder_size (encoder); i++)
2577 : : {
2578 : 6634 : toplevel_node *tnode = lto_symtab_encoder_deref (encoder, i);
2579 : 6634 : asm_node *anode = dyn_cast <asm_node*> (tnode);
2580 : 6634 : if (!anode)
2581 : 6566 : continue;
2582 : :
2583 : 68 : if (TREE_CODE (anode->asm_str) != STRING_CST)
2584 : : {
2585 : 0 : sorry_at (EXPR_LOCATION (anode->asm_str),
2586 : : "LTO streaming of toplevel extended %<asm%> "
2587 : : "unimplemented");
2588 : 0 : continue;
2589 : : }
2590 : 68 : streamer_write_string_cst (ob, ob->main_stream, anode->asm_str);
2591 : 68 : streamer_write_hwi (ob, anode->order);
2592 : : }
2593 : :
2594 : 68 : streamer_write_string_cst (ob, ob->main_stream, NULL_TREE);
2595 : :
2596 : 68 : section_name = lto_get_section_name (LTO_section_asm, NULL, 0, NULL);
2597 : 68 : lto_begin_section (section_name, !flag_wpa);
2598 : 68 : free (section_name);
2599 : :
2600 : : /* The entire header stream is computed here. */
2601 : 68 : memset (&header, 0, sizeof (header));
2602 : :
2603 : 68 : header.main_size = ob->main_stream->total_size;
2604 : 68 : header.string_size = ob->string_stream->total_size;
2605 : 68 : lto_write_data (&header, sizeof header);
2606 : :
2607 : : /* Put all of the gimple and the string table out the asm file as a
2608 : : block of text. */
2609 : 68 : lto_write_stream (ob->main_stream);
2610 : 68 : lto_write_stream (ob->string_stream);
2611 : :
2612 : 68 : lto_end_section ();
2613 : :
2614 : 68 : destroy_output_block (ob);
2615 : : }
2616 : :
2617 : :
2618 : : /* Copy the function body or variable constructor of NODE without deserializing. */
2619 : :
2620 : : static void
2621 : 34702 : copy_function_or_variable (struct symtab_node *node, int output_order)
2622 : : {
2623 : 34702 : tree function = node->decl;
2624 : 34702 : struct lto_file_decl_data *file_data = node->lto_file_data;
2625 : 34702 : const char *data;
2626 : 34702 : size_t len;
2627 : 34702 : const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function));
2628 : 34702 : char *section_name =
2629 : 34702 : lto_get_section_name (LTO_section_function_body, name, output_order, NULL);
2630 : 34702 : size_t i, j;
2631 : 34702 : struct lto_in_decl_state *in_state;
2632 : 34702 : struct lto_out_decl_state *out_state = lto_get_out_decl_state ();
2633 : :
2634 : 34702 : if (streamer_dump_file)
2635 : 0 : fprintf (streamer_dump_file, "Copying section for %s\n", name);
2636 : 34702 : lto_begin_section (section_name, false);
2637 : 34702 : free (section_name);
2638 : :
2639 : : /* We may have renamed the declaration, e.g., a static function. */
2640 : 34702 : name = lto_get_decl_name_mapping (file_data, name);
2641 : :
2642 : 69404 : data = lto_get_raw_section_data (file_data, LTO_section_function_body,
2643 : 34702 : name, node->order - file_data->order_base,
2644 : : &len);
2645 : 34702 : gcc_assert (data);
2646 : :
2647 : : /* Do a bit copy of the function body. */
2648 : 34702 : lto_write_raw_data (data, len);
2649 : :
2650 : : /* Copy decls. */
2651 : 34702 : in_state =
2652 : 34702 : lto_get_function_in_decl_state (node->lto_file_data, function);
2653 : 34702 : out_state->compressed = in_state->compressed;
2654 : 34702 : gcc_assert (in_state);
2655 : :
2656 : 69404 : for (i = 0; i < LTO_N_DECL_STREAMS; i++)
2657 : : {
2658 : 34702 : size_t n = vec_safe_length (in_state->streams[i]);
2659 : 34702 : vec<tree, va_gc> *trees = in_state->streams[i];
2660 : 34702 : struct lto_tree_ref_encoder *encoder = &(out_state->streams[i]);
2661 : :
2662 : : /* The out state must have the same indices and the in state.
2663 : : So just copy the vector. All the encoders in the in state
2664 : : must be empty where we reach here. */
2665 : 34702 : gcc_assert (lto_tree_ref_encoder_size (encoder) == 0);
2666 : 34702 : encoder->trees.reserve_exact (n);
2667 : 517311 : for (j = 0; j < n; j++)
2668 : 447907 : encoder->trees.safe_push ((*trees)[j]);
2669 : : }
2670 : :
2671 : 34702 : lto_free_raw_section_data (file_data, LTO_section_function_body, name,
2672 : : data, len);
2673 : 34702 : lto_end_section ();
2674 : 34702 : }
2675 : :
2676 : : /* Wrap symbol references in *TP inside a type-preserving MEM_REF. */
2677 : :
2678 : : static tree
2679 : 790414 : wrap_refs (tree *tp, int *ws, void *)
2680 : : {
2681 : 790414 : tree t = *tp;
2682 : 790414 : if (handled_component_p (t)
2683 : 174 : && VAR_P (TREE_OPERAND (t, 0))
2684 : 118 : && TREE_PUBLIC (TREE_OPERAND (t, 0)))
2685 : : {
2686 : 81 : tree decl = TREE_OPERAND (t, 0);
2687 : 81 : tree ptrtype = build_pointer_type (TREE_TYPE (decl));
2688 : 81 : TREE_OPERAND (t, 0) = build2 (MEM_REF, TREE_TYPE (decl),
2689 : : build1 (ADDR_EXPR, ptrtype, decl),
2690 : : build_int_cst (ptrtype, 0));
2691 : 81 : TREE_THIS_VOLATILE (TREE_OPERAND (t, 0)) = TREE_THIS_VOLATILE (decl);
2692 : 81 : *ws = 0;
2693 : : }
2694 : 790333 : else if (TREE_CODE (t) == CONSTRUCTOR)
2695 : : ;
2696 : 572932 : else if (!EXPR_P (t))
2697 : 333409 : *ws = 0;
2698 : 790414 : return NULL_TREE;
2699 : : }
2700 : :
2701 : : /* Remove functions that are no longer used from offload_funcs, and mark the
2702 : : remaining ones with DECL_PRESERVE_P. */
2703 : :
2704 : : static void
2705 : 33469 : prune_offload_funcs (void)
2706 : : {
2707 : 33469 : if (!offload_funcs)
2708 : 33469 : return;
2709 : :
2710 : 0 : unsigned ix, ix2;
2711 : 0 : tree *elem_ptr;
2712 : 0 : VEC_ORDERED_REMOVE_IF (*offload_funcs, ix, ix2, elem_ptr,
2713 : : cgraph_node::get (*elem_ptr) == NULL);
2714 : :
2715 : : tree fn_decl;
2716 : 0 : FOR_EACH_VEC_ELT (*offload_funcs, ix, fn_decl)
2717 : 0 : DECL_PRESERVE_P (fn_decl) = 1;
2718 : : }
2719 : :
2720 : : /* Produce LTO section that contains global information
2721 : : about LTO bytecode. */
2722 : :
2723 : : static void
2724 : 33469 : produce_lto_section ()
2725 : : {
2726 : : /* Stream LTO meta section. */
2727 : 33469 : output_block *ob = create_output_block (LTO_section_lto);
2728 : :
2729 : 33469 : char * section_name = lto_get_section_name (LTO_section_lto, NULL, 0, NULL);
2730 : 33469 : lto_begin_section (section_name, false);
2731 : 33469 : free (section_name);
2732 : :
2733 : : #ifdef HAVE_ZSTD_H
2734 : 33469 : lto_compression compression = ZSTD;
2735 : : #else
2736 : : lto_compression compression = ZLIB;
2737 : : #endif
2738 : :
2739 : 33469 : bool slim_object = flag_generate_lto && !flag_fat_lto_objects;
2740 : 33469 : lto_section s
2741 : 33469 : = { LTO_major_version, LTO_minor_version, slim_object, 0, 0 };
2742 : 33469 : s.set_compression (compression);
2743 : 33469 : lto_write_data (&s, sizeof s);
2744 : 33469 : lto_end_section ();
2745 : 33469 : destroy_output_block (ob);
2746 : 33469 : }
2747 : :
2748 : : /* Compare symbols to get them sorted by filename (to optimize streaming) */
2749 : :
2750 : : static int
2751 : 3327269 : cmp_symbol_files (const void *pn1, const void *pn2, void *id_map_)
2752 : : {
2753 : 3327269 : const symtab_node *n1 = *(const symtab_node * const *)pn1;
2754 : 3327269 : const symtab_node *n2 = *(const symtab_node * const *)pn2;
2755 : 3327269 : hash_map<lto_file_decl_data *, int> *id_map
2756 : : = (hash_map<lto_file_decl_data *, int> *)id_map_;
2757 : :
2758 : 3327269 : int file_order1 = n1->lto_file_data ? n1->lto_file_data->order : -1;
2759 : 3327269 : int file_order2 = n2->lto_file_data ? n2->lto_file_data->order : -1;
2760 : :
2761 : : /* Order files same way as they appeared in the command line to reduce
2762 : : seeking while copying sections. */
2763 : 3327269 : if (file_order1 != file_order2)
2764 : 306 : return file_order1 - file_order2;
2765 : :
2766 : : /* Order within static library. */
2767 : 3326963 : if (n1->lto_file_data && n1->lto_file_data->id != n2->lto_file_data->id)
2768 : 9406 : return *id_map->get (n1->lto_file_data) - *id_map->get (n2->lto_file_data);
2769 : :
2770 : : /* And finaly order by the definition order. */
2771 : 3317557 : return n1->order - n2->order;
2772 : : }
2773 : :
2774 : : /* Compare ints, callback for qsort. */
2775 : :
2776 : : static int
2777 : 31903336 : cmp_int (const void *a, const void *b)
2778 : : {
2779 : 31903336 : int ia = *(int const*) a;
2780 : 31903336 : int ib = *(int const*) b;
2781 : 31903336 : return ia - ib;
2782 : : }
2783 : :
2784 : : /* Create order mapping independent on symbols outside of the partition.
2785 : : Results in stable order values for incremental LTO.
2786 : :
2787 : : Remapping is not done in place, because symbols can be used
2788 : : by multiple partitions. */
2789 : :
2790 : : static void
2791 : 33469 : create_order_remap (lto_symtab_encoder_t encoder)
2792 : : {
2793 : 33469 : auto_vec<int> orders;
2794 : 33469 : unsigned i;
2795 : 33469 : encoder->order_remap = new hash_map<int_hash<int, -1, -2>, int>;
2796 : 33469 : unsigned n_nodes = lto_symtab_encoder_size (encoder);
2797 : :
2798 : 744750 : for (i = 0; i < n_nodes; i++)
2799 : 711281 : orders.safe_push (lto_symtab_encoder_deref (encoder, i)->order);
2800 : :
2801 : 33469 : orders.qsort (cmp_int);
2802 : 33469 : int ord = 0;
2803 : 33469 : int last_order = -1;
2804 : 744750 : for (i = 0; i < orders.length (); i++)
2805 : : {
2806 : 711281 : int order = orders[i];
2807 : 711281 : if (order != last_order)
2808 : : {
2809 : 682298 : last_order = order;
2810 : 682298 : encoder->order_remap->put (order, ord);
2811 : 682298 : ord++;
2812 : : }
2813 : : }
2814 : 33469 : }
2815 : :
2816 : : /* Main entry point from the pass manager. */
2817 : :
2818 : : void
2819 : 33469 : lto_output (void)
2820 : : {
2821 : 33469 : struct lto_out_decl_state *decl_state;
2822 : 33469 : bitmap output = NULL;
2823 : 33469 : bitmap_obstack output_obstack;
2824 : 33469 : unsigned int i, n_nodes;
2825 : 33469 : lto_symtab_encoder_t encoder = lto_get_out_decl_state ()->symtab_node_encoder;
2826 : 33469 : auto_vec<symtab_node *> symbols_to_copy;
2827 : :
2828 : 33469 : if (!flag_wpa)
2829 : : {
2830 : 24263 : asm_node *anode;
2831 : 24301 : for (anode = symtab->first_asm_symbol (); anode; anode = anode->next)
2832 : 38 : lto_set_symtab_encoder_in_partition (encoder, anode);
2833 : : }
2834 : :
2835 : 33469 : create_order_remap (encoder);
2836 : :
2837 : 33469 : prune_offload_funcs ();
2838 : :
2839 : 33469 : if (flag_checking)
2840 : : {
2841 : 33463 : bitmap_obstack_initialize (&output_obstack);
2842 : 33463 : output = BITMAP_ALLOC (&output_obstack);
2843 : : }
2844 : :
2845 : : /* Initialize the streamer. */
2846 : 33469 : lto_streamer_init ();
2847 : :
2848 : 33469 : produce_lto_section ();
2849 : :
2850 : 33469 : n_nodes = lto_symtab_encoder_size (encoder);
2851 : : /* Prepare vector of functions to output and then sort it to optimize
2852 : : section copying. */
2853 : 744750 : for (i = 0; i < n_nodes; i++)
2854 : : {
2855 : 711281 : toplevel_node *tnode = lto_symtab_encoder_deref (encoder, i);
2856 : 711281 : symtab_node *node = dyn_cast <symtab_node *> (tnode);
2857 : 711213 : if (!node || node->alias)
2858 : 12874 : continue;
2859 : :
2860 : 698407 : if (cgraph_node *node = dyn_cast <cgraph_node *> (tnode))
2861 : : {
2862 : 414009 : if (lto_symtab_encoder_encode_body_p (encoder, node)
2863 : 414009 : && !node->clone_of)
2864 : 138413 : symbols_to_copy.safe_push (node);
2865 : : }
2866 : 995679 : else if (varpool_node *node = dyn_cast <varpool_node *> (tnode))
2867 : : {
2868 : : /* Wrap symbol references inside the ctor in a type
2869 : : preserving MEM_REF. */
2870 : 284398 : tree ctor = DECL_INITIAL (node->decl);
2871 : 284398 : if (ctor && !in_lto_p)
2872 : 19130 : walk_tree (&ctor, wrap_refs, NULL, NULL);
2873 : 284398 : if (get_symbol_initial_value (encoder, node->decl) == error_mark_node
2874 : 284398 : && lto_symtab_encoder_encode_initializer_p (encoder, node))
2875 : 15340 : symbols_to_copy.safe_push (node);
2876 : : }
2877 : : }
2878 : : /* Map the section hash to an order it appears in symbols_to_copy
2879 : : since we want to sort same ID symbols next to each other but need
2880 : : to avoid making overall order depend on the actual hash value. */
2881 : 33469 : int order = 0;
2882 : 33469 : hash_map<lto_file_decl_data *, int> id_map;
2883 : 187222 : for (i = 0; i < symbols_to_copy.length (); ++i)
2884 : : {
2885 : 153753 : symtab_node *snode = symbols_to_copy[i];
2886 : 153753 : if (snode->lto_file_data)
2887 : : {
2888 : 40276 : bool existed_p = false;
2889 : 40276 : int &ord = id_map.get_or_insert (snode->lto_file_data, &existed_p);
2890 : 40276 : if (!existed_p)
2891 : 9647 : ord = order++;
2892 : : }
2893 : : }
2894 : 33469 : symbols_to_copy.sort (cmp_symbol_files, (void *)&id_map);
2895 : 187222 : for (i = 0; i < symbols_to_copy.length (); i++)
2896 : : {
2897 : 153753 : symtab_node *snode = symbols_to_copy[i];
2898 : 153753 : cgraph_node *cnode;
2899 : 153753 : varpool_node *vnode;
2900 : :
2901 : 153753 : int output_order = *encoder->order_remap->get (snode->order);
2902 : :
2903 : 153753 : if (flag_checking)
2904 : 153751 : gcc_assert (bitmap_set_bit (output, DECL_UID (snode->decl)));
2905 : :
2906 : 153753 : decl_state = lto_new_out_decl_state ();
2907 : 153753 : lto_push_out_decl_state (decl_state);
2908 : :
2909 : 153753 : if ((cnode = dyn_cast <cgraph_node *> (snode))
2910 : 138413 : && (gimple_has_body_p (cnode->decl)
2911 : 30399 : || (!flag_wpa
2912 : 289 : && flag_incremental_link != INCREMENTAL_LINK_LTO)
2913 : : /* Thunks have no body but they may be synthetized
2914 : : at WPA time. */
2915 : 30253 : || DECL_ARGUMENTS (cnode->decl)))
2916 : 108161 : output_function (cnode, output_order);
2917 : 45592 : else if ((vnode = dyn_cast <varpool_node *> (snode))
2918 : 15340 : && (DECL_INITIAL (vnode->decl) != error_mark_node
2919 : 4450 : || (!flag_wpa
2920 : 43 : && flag_incremental_link != INCREMENTAL_LINK_LTO)))
2921 : 10890 : output_constructor (vnode, output_order);
2922 : : else
2923 : 34702 : copy_function_or_variable (snode, output_order);
2924 : 153753 : gcc_assert (lto_get_out_decl_state () == decl_state);
2925 : 153753 : lto_pop_out_decl_state ();
2926 : 153753 : lto_record_function_out_decl_state (snode->decl, decl_state);
2927 : : }
2928 : :
2929 : : /* Emit the callgraph after emitting function bodies. This needs to
2930 : : be done now to make sure that all the statements in every function
2931 : : have been renumbered so that edges can be associated with call
2932 : : statements using the statement UIDs. */
2933 : 33469 : output_symtab ();
2934 : :
2935 : 33469 : if (lto_get_out_decl_state ()->output_offload_tables_p)
2936 : 8818 : output_offload_tables ();
2937 : :
2938 : 33469 : if (flag_checking)
2939 : : {
2940 : 33463 : BITMAP_FREE (output);
2941 : 33463 : bitmap_obstack_release (&output_obstack);
2942 : : }
2943 : 33469 : }
2944 : :
2945 : : /* Write each node in encoded by ENCODER to OB, as well as those reachable
2946 : : from it and required for correct representation of its semantics.
2947 : : Each node in ENCODER must be a global declaration or a type. A node
2948 : : is written only once, even if it appears multiple times in the
2949 : : vector. Certain transitively-reachable nodes, such as those
2950 : : representing expressions, may be duplicated, but such nodes
2951 : : must not appear in ENCODER itself. */
2952 : :
2953 : : static void
2954 : 187222 : write_global_stream (struct output_block *ob,
2955 : : struct lto_tree_ref_encoder *encoder)
2956 : : {
2957 : 187222 : tree t;
2958 : 187222 : size_t index;
2959 : 187222 : const size_t size = lto_tree_ref_encoder_size (encoder);
2960 : :
2961 : 2805849 : for (index = 0; index < size; index++)
2962 : : {
2963 : 2618627 : t = lto_tree_ref_encoder_get_tree (encoder, index);
2964 : 2618627 : if (streamer_dump_file)
2965 : : {
2966 : 176 : fprintf (streamer_dump_file, " %i:", (int)index);
2967 : 176 : print_node_brief (streamer_dump_file, "", t, 4);
2968 : 176 : fprintf (streamer_dump_file, "\n");
2969 : : }
2970 : 2618627 : if (!streamer_tree_cache_lookup (ob->writer_cache, t, NULL))
2971 : 923518 : stream_write_tree (ob, t, false);
2972 : : }
2973 : 187222 : }
2974 : :
2975 : :
2976 : : /* Write a sequence of indices into the globals vector corresponding
2977 : : to the trees in ENCODER. These are used by the reader to map the
2978 : : indices used to refer to global entities within function bodies to
2979 : : their referents. */
2980 : :
2981 : : static void
2982 : 187222 : write_global_references (struct output_block *ob,
2983 : : struct lto_tree_ref_encoder *encoder)
2984 : : {
2985 : 187222 : tree t;
2986 : 187222 : uint32_t index;
2987 : 187222 : const uint32_t size = lto_tree_ref_encoder_size (encoder);
2988 : :
2989 : : /* Write size and slot indexes as 32-bit unsigned numbers. */
2990 : 187222 : uint32_t *data = XNEWVEC (uint32_t, size + 1);
2991 : 187222 : data[0] = size;
2992 : :
2993 : 2805849 : for (index = 0; index < size; index++)
2994 : : {
2995 : 2618627 : unsigned slot_num;
2996 : :
2997 : 2618627 : t = lto_tree_ref_encoder_get_tree (encoder, index);
2998 : 2618627 : streamer_tree_cache_lookup (ob->writer_cache, t, &slot_num);
2999 : 2618627 : gcc_assert (slot_num != (unsigned)-1);
3000 : 2618627 : data[index + 1] = slot_num;
3001 : : }
3002 : :
3003 : 187222 : lto_write_data (data, sizeof (int32_t) * (size + 1));
3004 : 187222 : free (data);
3005 : 187222 : }
3006 : :
3007 : :
3008 : : /* Write all the streams in an lto_out_decl_state STATE using
3009 : : output block OB and output stream OUT_STREAM. */
3010 : :
3011 : : void
3012 : 187222 : lto_output_decl_state_streams (struct output_block *ob,
3013 : : struct lto_out_decl_state *state)
3014 : : {
3015 : 187222 : int i;
3016 : :
3017 : 374444 : for (i = 0; i < LTO_N_DECL_STREAMS; i++)
3018 : 187222 : write_global_stream (ob, &state->streams[i]);
3019 : 187222 : }
3020 : :
3021 : :
3022 : : /* Write all the references in an lto_out_decl_state STATE using
3023 : : output block OB and output stream OUT_STREAM. */
3024 : :
3025 : : void
3026 : 187222 : lto_output_decl_state_refs (struct output_block *ob,
3027 : : struct lto_out_decl_state *state)
3028 : : {
3029 : 187222 : unsigned i;
3030 : 187222 : unsigned ref;
3031 : 187222 : tree decl;
3032 : :
3033 : : /* Write reference to FUNCTION_DECL. If there is not function,
3034 : : write reference to void_type_node. */
3035 : 187222 : decl = (state->fn_decl) ? state->fn_decl : void_type_node;
3036 : 187222 : streamer_tree_cache_lookup (ob->writer_cache, decl, &ref);
3037 : 187222 : gcc_assert (ref != (unsigned)-1);
3038 : 187222 : ref = ref * 2 + (state->compressed ? 1 : 0);
3039 : 187222 : lto_write_data (&ref, sizeof (uint32_t));
3040 : :
3041 : 561666 : for (i = 0; i < LTO_N_DECL_STREAMS; i++)
3042 : 187222 : write_global_references (ob, &state->streams[i]);
3043 : 187222 : }
3044 : :
3045 : :
3046 : : /* Return the written size of STATE. */
3047 : :
3048 : : static size_t
3049 : 187222 : lto_out_decl_state_written_size (struct lto_out_decl_state *state)
3050 : : {
3051 : 187222 : int i;
3052 : 187222 : size_t size;
3053 : :
3054 : 187222 : size = sizeof (int32_t); /* fn_ref. */
3055 : 0 : for (i = 0; i < LTO_N_DECL_STREAMS; i++)
3056 : : {
3057 : 187222 : size += sizeof (int32_t); /* vector size. */
3058 : 0 : size += (lto_tree_ref_encoder_size (&state->streams[i])
3059 : 0 : * sizeof (int32_t));
3060 : : }
3061 : 187222 : return size;
3062 : : }
3063 : :
3064 : :
3065 : : /* Write symbol T into STREAM in CACHE. SEEN specifies symbols we wrote
3066 : : so far. */
3067 : :
3068 : : static void
3069 : 542943 : write_symbol (struct streamer_tree_cache_d *cache,
3070 : : tree t, hash_set<const char *> *seen, bool alias)
3071 : : {
3072 : 542943 : const char *name;
3073 : 542943 : enum gcc_plugin_symbol_kind kind;
3074 : 542943 : enum gcc_plugin_symbol_visibility visibility = GCCPV_DEFAULT;
3075 : 542943 : unsigned slot_num;
3076 : 542943 : uint64_t size;
3077 : 542943 : const char *comdat;
3078 : 542943 : unsigned char c;
3079 : :
3080 : 542943 : gcc_assert (VAR_OR_FUNCTION_DECL_P (t));
3081 : :
3082 : 542943 : name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t));
3083 : :
3084 : : /* This behaves like assemble_name_raw in varasm.cc, performing the
3085 : : same name manipulations that ASM_OUTPUT_LABELREF does. */
3086 : 542943 : name = IDENTIFIER_POINTER ((*targetm.asm_out.mangle_assembler_name) (name));
3087 : :
3088 : 542943 : if (seen->add (name))
3089 : 769 : return;
3090 : :
3091 : 542174 : streamer_tree_cache_lookup (cache, t, &slot_num);
3092 : 542174 : gcc_assert (slot_num != (unsigned)-1);
3093 : :
3094 : 542174 : if (DECL_EXTERNAL (t))
3095 : : {
3096 : 214940 : if (DECL_WEAK (t))
3097 : : kind = GCCPK_WEAKUNDEF;
3098 : : else
3099 : 214911 : kind = GCCPK_UNDEF;
3100 : : }
3101 : : else
3102 : : {
3103 : 327234 : if (DECL_WEAK (t))
3104 : : kind = GCCPK_WEAKDEF;
3105 : 315438 : else if (DECL_COMMON (t))
3106 : : kind = GCCPK_COMMON;
3107 : : else
3108 : 315377 : kind = GCCPK_DEF;
3109 : :
3110 : : /* When something is defined, it should have node attached. */
3111 : 327234 : gcc_assert (alias || !VAR_P (t) || varpool_node::get (t)->definition);
3112 : 327234 : gcc_assert (alias || TREE_CODE (t) != FUNCTION_DECL
3113 : : || (cgraph_node::get (t)
3114 : : && cgraph_node::get (t)->definition));
3115 : : }
3116 : :
3117 : : /* Imitate what default_elf_asm_output_external do.
3118 : : When symbol is external, we need to output it with DEFAULT visibility
3119 : : when compiling with -fvisibility=default, while with HIDDEN visibility
3120 : : when symbol has attribute (visibility("hidden")) specified.
3121 : : targetm.binds_local_p check DECL_VISIBILITY_SPECIFIED and gets this
3122 : : right. */
3123 : :
3124 : 542174 : if (DECL_EXTERNAL (t)
3125 : 542174 : && !targetm.binds_local_p (t))
3126 : : visibility = GCCPV_DEFAULT;
3127 : : else
3128 : 327287 : switch (DECL_VISIBILITY (t))
3129 : : {
3130 : : case VISIBILITY_DEFAULT:
3131 : : visibility = GCCPV_DEFAULT;
3132 : : break;
3133 : : case VISIBILITY_PROTECTED:
3134 : 542174 : visibility = GCCPV_PROTECTED;
3135 : : break;
3136 : : case VISIBILITY_HIDDEN:
3137 : : visibility = GCCPV_HIDDEN;
3138 : : break;
3139 : : case VISIBILITY_INTERNAL:
3140 : : visibility = GCCPV_INTERNAL;
3141 : : break;
3142 : : }
3143 : :
3144 : 542174 : if (kind == GCCPK_COMMON
3145 : 61 : && DECL_SIZE_UNIT (t)
3146 : 542235 : && TREE_CODE (DECL_SIZE_UNIT (t)) == INTEGER_CST)
3147 : 61 : size = TREE_INT_CST_LOW (DECL_SIZE_UNIT (t));
3148 : : else
3149 : 542113 : size = 0;
3150 : :
3151 : 542174 : if (DECL_ONE_ONLY (t))
3152 : 11754 : comdat = IDENTIFIER_POINTER (decl_comdat_group_id (t));
3153 : : else
3154 : : comdat = "";
3155 : :
3156 : 542174 : lto_write_data (name, strlen (name) + 1);
3157 : 542174 : lto_write_data (comdat, strlen (comdat) + 1);
3158 : 542174 : c = (unsigned char) kind;
3159 : 542174 : lto_write_data (&c, 1);
3160 : 542174 : c = (unsigned char) visibility;
3161 : 542174 : lto_write_data (&c, 1);
3162 : 542174 : lto_write_data (&size, 8);
3163 : 542174 : lto_write_data (&slot_num, 4);
3164 : : }
3165 : :
3166 : : /* Write extension information for symbols (symbol type, section flags). */
3167 : :
3168 : : static void
3169 : 542943 : write_symbol_extension_info (tree t)
3170 : : {
3171 : 542943 : unsigned char c;
3172 : 542943 : c = ((unsigned char) TREE_CODE (t) == VAR_DECL
3173 : : ? GCCST_VARIABLE : GCCST_FUNCTION);
3174 : 542943 : lto_write_data (&c, 1);
3175 : 542943 : unsigned char section_kind = 0;
3176 : 542943 : if (VAR_P (t))
3177 : : {
3178 : 233243 : section *s = get_variable_section (t, false);
3179 : 233243 : if (s->common.flags & SECTION_BSS)
3180 : 223420 : section_kind |= GCCSSK_BSS;
3181 : : }
3182 : 542943 : lto_write_data (§ion_kind, 1);
3183 : 542943 : }
3184 : :
3185 : : /* Write an IL symbol table to OB.
3186 : : SET and VSET are cgraph/varpool node sets we are outputting. */
3187 : :
3188 : : static unsigned int
3189 : 24263 : produce_symtab (struct output_block *ob)
3190 : : {
3191 : 24263 : unsigned int streamed_symbols = 0;
3192 : 24263 : struct streamer_tree_cache_d *cache = ob->writer_cache;
3193 : 24263 : char *section_name = lto_get_section_name (LTO_section_symtab, NULL, 0, NULL);
3194 : 24263 : lto_symtab_encoder_t encoder = ob->decl_state->symtab_node_encoder;
3195 : 24263 : lto_symtab_encoder_iterator lsei;
3196 : :
3197 : 24263 : lto_begin_section (section_name, false);
3198 : 24263 : free (section_name);
3199 : :
3200 : 24263 : hash_set<const char *> seen;
3201 : :
3202 : : /* Write the symbol table.
3203 : : First write everything defined and then all declarations.
3204 : : This is necessary to handle cases where we have duplicated symbols. */
3205 : 24263 : for (lsei = lsei_start (encoder);
3206 : 621947 : !lsei_end_p (lsei); lsei_next (&lsei))
3207 : : {
3208 : 597684 : toplevel_node *tnode = lsei_node (lsei);
3209 : 597684 : symtab_node *node = dyn_cast<symtab_node*> (tnode);
3210 : 597684 : if (!node)
3211 : 38 : continue;
3212 : :
3213 : 597646 : if (DECL_EXTERNAL (node->decl) || !node->output_to_lto_symbol_table_p ())
3214 : 270412 : continue;
3215 : 327234 : write_symbol (cache, node->decl, &seen, false);
3216 : 327234 : ++streamed_symbols;
3217 : : }
3218 : 621947 : for (lsei = lsei_start (encoder);
3219 : 621947 : !lsei_end_p (lsei); lsei_next (&lsei))
3220 : : {
3221 : 597684 : toplevel_node *tnode = lsei_node (lsei);
3222 : 597684 : symtab_node *node = dyn_cast<symtab_node*> (tnode);
3223 : 597684 : if (!node)
3224 : 38 : continue;
3225 : :
3226 : 597646 : if (!DECL_EXTERNAL (node->decl) || !node->output_to_lto_symbol_table_p ())
3227 : 381937 : continue;
3228 : 215709 : write_symbol (cache, node->decl, &seen, false);
3229 : 215709 : ++streamed_symbols;
3230 : : }
3231 : :
3232 : 24263 : lto_end_section ();
3233 : :
3234 : 24263 : return streamed_symbols;
3235 : 24263 : }
3236 : :
3237 : : /* Symtab extension version. */
3238 : : #define LTO_SYMTAB_EXTENSION_VERSION 1
3239 : :
3240 : : /* Write an IL symbol table extension to OB.
3241 : : SET and VSET are cgraph/varpool node sets we are outputting. */
3242 : :
3243 : : static void
3244 : 24263 : produce_symtab_extension (struct output_block *ob,
3245 : : unsigned int previous_streamed_symbols)
3246 : : {
3247 : 24263 : unsigned int streamed_symbols = 0;
3248 : 24263 : char *section_name = lto_get_section_name (LTO_section_symtab_extension,
3249 : : NULL, 0, NULL);
3250 : 24263 : lto_symtab_encoder_t encoder = ob->decl_state->symtab_node_encoder;
3251 : 24263 : lto_symtab_encoder_iterator lsei;
3252 : :
3253 : 24263 : lto_begin_section (section_name, false);
3254 : 24263 : free (section_name);
3255 : :
3256 : 24263 : unsigned char version = LTO_SYMTAB_EXTENSION_VERSION;
3257 : 24263 : lto_write_data (&version, 1);
3258 : :
3259 : : /* Write the symbol table.
3260 : : First write everything defined and then all declarations.
3261 : : This is necessary to handle cases where we have duplicated symbols. */
3262 : 24263 : for (lsei = lsei_start (encoder);
3263 : 621947 : !lsei_end_p (lsei); lsei_next (&lsei))
3264 : : {
3265 : 597684 : toplevel_node *tnode = lsei_node (lsei);
3266 : 597684 : symtab_node *node = dyn_cast<symtab_node*> (tnode);
3267 : 597684 : if (!node)
3268 : 38 : continue;
3269 : :
3270 : 597646 : if (DECL_EXTERNAL (node->decl) || !node->output_to_lto_symbol_table_p ())
3271 : 270412 : continue;
3272 : 327234 : write_symbol_extension_info (node->decl);
3273 : 327234 : ++streamed_symbols;
3274 : : }
3275 : 621947 : for (lsei = lsei_start (encoder);
3276 : 621947 : !lsei_end_p (lsei); lsei_next (&lsei))
3277 : : {
3278 : 597684 : toplevel_node *tnode = lsei_node (lsei);
3279 : 597684 : symtab_node *node = dyn_cast<symtab_node*> (tnode);
3280 : 597684 : if (!node)
3281 : 38 : continue;
3282 : :
3283 : 597646 : if (!DECL_EXTERNAL (node->decl) || !node->output_to_lto_symbol_table_p ())
3284 : 381937 : continue;
3285 : 215709 : write_symbol_extension_info (node->decl);
3286 : 215709 : ++streamed_symbols;
3287 : : }
3288 : :
3289 : 24263 : gcc_assert (previous_streamed_symbols == streamed_symbols);
3290 : 24263 : lto_end_section ();
3291 : 24263 : }
3292 : :
3293 : :
3294 : : /* Init the streamer_mode_table for output, where we collect info on what
3295 : : machine_mode values have been streamed. */
3296 : : void
3297 : 33469 : lto_output_init_mode_table (void)
3298 : : {
3299 : 33469 : memset (streamer_mode_table, '\0', MAX_MACHINE_MODE);
3300 : 33469 : }
3301 : :
3302 : :
3303 : : /* Write the mode table. */
3304 : : static void
3305 : 0 : lto_write_mode_table (void)
3306 : : {
3307 : 0 : struct output_block *ob;
3308 : 0 : ob = create_output_block (LTO_section_mode_table);
3309 : 0 : bitpack_d bp = bitpack_create (ob->main_stream);
3310 : :
3311 : 0 : if (lto_stream_offload_p)
3312 : 0 : bp_pack_value (&bp, NUM_POLY_INT_COEFFS, MAX_NUM_POLY_INT_COEFFS_BITS);
3313 : :
3314 : : /* Ensure that for GET_MODE_INNER (m) != m we have
3315 : : also the inner mode marked. */
3316 : 0 : for (int i = 0; i < (int) MAX_MACHINE_MODE; i++)
3317 : 0 : if (streamer_mode_table[i])
3318 : : {
3319 : 0 : machine_mode m = (machine_mode) i;
3320 : 0 : machine_mode inner_m = GET_MODE_INNER (m);
3321 : 0 : if (inner_m != m)
3322 : 0 : streamer_mode_table[(int) inner_m] = 1;
3323 : : }
3324 : :
3325 : : /* Pack the mode_bits value within 5 bits (up to 31) in the beginning. */
3326 : 0 : unsigned mode_bits = ceil_log2 (MAX_MACHINE_MODE);
3327 : 0 : bp_pack_value (&bp, mode_bits, 5);
3328 : :
3329 : : /* First stream modes that have GET_MODE_INNER (m) == m,
3330 : : so that we can refer to them afterwards. */
3331 : 0 : for (int pass = 0; pass < 2; pass++)
3332 : 0 : for (int i = 0; i < (int) MAX_MACHINE_MODE; i++)
3333 : 0 : if (streamer_mode_table[i] && i != (int) VOIDmode && i != (int) BLKmode)
3334 : : {
3335 : 0 : machine_mode m = (machine_mode) i;
3336 : 0 : if ((GET_MODE_INNER (m) == m) ^ (pass == 0))
3337 : 0 : continue;
3338 : 0 : bp_pack_value (&bp, m, mode_bits);
3339 : 0 : bp_pack_enum (&bp, mode_class, MAX_MODE_CLASS, GET_MODE_CLASS (m));
3340 : 0 : bp_pack_poly_value (&bp, GET_MODE_SIZE (m), 16);
3341 : 0 : bp_pack_poly_value (&bp, GET_MODE_PRECISION (m), 16);
3342 : 0 : bp_pack_value (&bp, GET_MODE_INNER (m), mode_bits);
3343 : 0 : bp_pack_poly_value (&bp, GET_MODE_NUNITS (m), 16);
3344 : 0 : switch (GET_MODE_CLASS (m))
3345 : : {
3346 : 0 : case MODE_FRACT:
3347 : 0 : case MODE_UFRACT:
3348 : 0 : case MODE_ACCUM:
3349 : 0 : case MODE_UACCUM:
3350 : 0 : bp_pack_value (&bp, GET_MODE_IBIT (m), 8);
3351 : 0 : bp_pack_value (&bp, GET_MODE_FBIT (m), 8);
3352 : 0 : break;
3353 : 0 : case MODE_FLOAT:
3354 : 0 : case MODE_DECIMAL_FLOAT:
3355 : 0 : bp_pack_string (ob, &bp, REAL_MODE_FORMAT (m)->name, true);
3356 : 0 : break;
3357 : : default:
3358 : : break;
3359 : : }
3360 : 0 : bp_pack_string (ob, &bp, GET_MODE_NAME (m), true);
3361 : : }
3362 : 0 : bp_pack_value (&bp, VOIDmode, mode_bits);
3363 : :
3364 : 0 : streamer_write_bitpack (&bp);
3365 : :
3366 : 0 : char *section_name
3367 : 0 : = lto_get_section_name (LTO_section_mode_table, NULL, 0, NULL);
3368 : 0 : lto_begin_section (section_name, !flag_wpa);
3369 : 0 : free (section_name);
3370 : :
3371 : : /* The entire header stream is computed here. */
3372 : 0 : struct lto_simple_header_with_strings header;
3373 : 0 : memset (&header, 0, sizeof (header));
3374 : :
3375 : 0 : header.main_size = ob->main_stream->total_size;
3376 : 0 : header.string_size = ob->string_stream->total_size;
3377 : 0 : lto_write_data (&header, sizeof header);
3378 : :
3379 : : /* Put all of the gimple and the string table out the asm file as a
3380 : : block of text. */
3381 : 0 : lto_write_stream (ob->main_stream);
3382 : 0 : lto_write_stream (ob->string_stream);
3383 : :
3384 : 0 : lto_end_section ();
3385 : 0 : destroy_output_block (ob);
3386 : 0 : }
3387 : :
3388 : :
3389 : : /* This pass is run after all of the functions are serialized and all
3390 : : of the IPA passes have written their serialized forms. This pass
3391 : : causes the vector of all of the global decls and types used from
3392 : : this file to be written in to a section that can then be read in to
3393 : : recover these on other side. */
3394 : :
3395 : : void
3396 : 33469 : produce_asm_for_decls (void)
3397 : : {
3398 : 33469 : struct lto_out_decl_state *out_state;
3399 : 33469 : struct lto_out_decl_state *fn_out_state;
3400 : 33469 : struct lto_decl_header header;
3401 : 33469 : char *section_name;
3402 : 33469 : struct output_block *ob;
3403 : 33469 : unsigned idx, num_fns;
3404 : 33469 : size_t decl_state_size;
3405 : 33469 : int32_t num_decl_states;
3406 : :
3407 : 33469 : ob = create_output_block (LTO_section_decls);
3408 : :
3409 : 33469 : memset (&header, 0, sizeof (struct lto_decl_header));
3410 : :
3411 : 33469 : section_name = lto_get_section_name (LTO_section_decls, NULL, 0, NULL);
3412 : 33469 : lto_begin_section (section_name, !flag_wpa);
3413 : 33469 : free (section_name);
3414 : :
3415 : : /* Make string 0 be a NULL string. */
3416 : 33469 : streamer_write_char_stream (ob->string_stream, 0);
3417 : :
3418 : 33469 : gcc_assert (!alias_pairs);
3419 : :
3420 : : /* Get rid of the global decl state hash tables to save some memory. */
3421 : 33469 : out_state = lto_get_out_decl_state ();
3422 : 100407 : for (int i = 0; i < LTO_N_DECL_STREAMS; i++)
3423 : 33469 : if (out_state->streams[i].tree_hash_table)
3424 : : {
3425 : 33469 : delete out_state->streams[i].tree_hash_table;
3426 : 33469 : out_state->streams[i].tree_hash_table = NULL;
3427 : : }
3428 : :
3429 : : /* Write the global symbols. */
3430 : 33469 : if (streamer_dump_file)
3431 : 4 : fprintf (streamer_dump_file, "Outputting global stream\n");
3432 : 33469 : lto_output_decl_state_streams (ob, out_state);
3433 : 33469 : num_fns = lto_function_decl_states.length ();
3434 : 187222 : for (idx = 0; idx < num_fns; idx++)
3435 : : {
3436 : 153753 : fn_out_state =
3437 : 153753 : lto_function_decl_states[idx];
3438 : 153753 : if (streamer_dump_file)
3439 : 24 : fprintf (streamer_dump_file, "Outputting stream for %s\n",
3440 : 12 : IDENTIFIER_POINTER
3441 : : (DECL_ASSEMBLER_NAME (fn_out_state->fn_decl)));
3442 : 153753 : lto_output_decl_state_streams (ob, fn_out_state);
3443 : : }
3444 : :
3445 : : /* Currently not used. This field would allow us to preallocate
3446 : : the globals vector, so that it need not be resized as it is extended. */
3447 : 33469 : header.num_nodes = -1;
3448 : :
3449 : : /* Compute the total size of all decl out states. */
3450 : 33469 : decl_state_size = sizeof (int32_t);
3451 : 33469 : decl_state_size += lto_out_decl_state_written_size (out_state);
3452 : 187222 : for (idx = 0; idx < num_fns; idx++)
3453 : : {
3454 : 153753 : fn_out_state =
3455 : 153753 : lto_function_decl_states[idx];
3456 : 306829 : decl_state_size += lto_out_decl_state_written_size (fn_out_state);
3457 : : }
3458 : 33469 : header.decl_state_size = decl_state_size;
3459 : :
3460 : 33469 : header.main_size = ob->main_stream->total_size;
3461 : 33469 : header.string_size = ob->string_stream->total_size;
3462 : :
3463 : 33469 : lto_write_data (&header, sizeof header);
3464 : :
3465 : : /* Write the main out-decl state, followed by out-decl states of
3466 : : functions. */
3467 : 33469 : num_decl_states = num_fns + 1;
3468 : 33469 : lto_write_data (&num_decl_states, sizeof (num_decl_states));
3469 : 33469 : lto_output_decl_state_refs (ob, out_state);
3470 : 220691 : for (idx = 0; idx < num_fns; idx++)
3471 : : {
3472 : 153753 : fn_out_state = lto_function_decl_states[idx];
3473 : 153753 : lto_output_decl_state_refs (ob, fn_out_state);
3474 : : }
3475 : :
3476 : 33469 : lto_write_stream (ob->main_stream);
3477 : 33469 : lto_write_stream (ob->string_stream);
3478 : :
3479 : 33469 : lto_end_section ();
3480 : :
3481 : : /* Write the symbol table. It is used by linker to determine dependencies
3482 : : and thus we can skip it for WPA. */
3483 : 33469 : if (!flag_wpa)
3484 : : {
3485 : 24263 : unsigned int streamed_symbols = produce_symtab (ob);
3486 : 24263 : produce_symtab_extension (ob, streamed_symbols);
3487 : : }
3488 : :
3489 : : /* Write command line opts. */
3490 : 33469 : lto_write_options ();
3491 : :
3492 : : /* Deallocate memory and clean up. */
3493 : 220691 : for (idx = 0; idx < num_fns; idx++)
3494 : : {
3495 : 153753 : fn_out_state =
3496 : 153753 : lto_function_decl_states[idx];
3497 : 153753 : lto_delete_out_decl_state (fn_out_state);
3498 : : }
3499 : 33469 : lto_symtab_encoder_delete (ob->decl_state->symtab_node_encoder);
3500 : 33469 : lto_function_decl_states.release ();
3501 : 33469 : destroy_output_block (ob);
3502 : 33469 : if (lto_stream_offload_p)
3503 : 0 : lto_write_mode_table ();
3504 : 33469 : }
|
