Branch data Line data Source code
1 : : /* Read the GIMPLE representation from a file stream.
2 : :
3 : : Copyright (C) 2009-2024 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 "cfghooks.h"
32 : : #include "tree-pass.h"
33 : : #include "ssa.h"
34 : : #include "gimple-streamer.h"
35 : : #include "toplev.h"
36 : : #include "gimple-iterator.h"
37 : : #include "tree-cfg.h"
38 : : #include "tree-into-ssa.h"
39 : : #include "tree-dfa.h"
40 : : #include "tree-ssa.h"
41 : : #include "except.h"
42 : : #include "cgraph.h"
43 : : #include "cfgloop.h"
44 : : #include "debug.h"
45 : : #include "alloc-pool.h"
46 : : #include "toplev.h"
47 : :
48 : : /* Allocator used to hold string slot entries for line map streaming. */
49 : : static struct object_allocator<struct string_slot> *string_slot_allocator;
50 : :
51 : : /* The table to hold the file names. */
52 : : static hash_table<string_slot_hasher> *file_name_hash_table;
53 : :
54 : : /* The table to hold the relative pathname prefixes. */
55 : :
56 : : /* This obstack holds file names used in locators. Line map datastructures
57 : : points here and thus it needs to be kept allocated as long as linemaps
58 : : exists. */
59 : : static struct obstack file_name_obstack;
60 : :
61 : : /* Map a pair of nul terminated strings where the first one can be
62 : : pointer compared, but the second can't, to another string. */
63 : : struct string_pair_map
64 : : {
65 : : const char *str1;
66 : : const char *str2;
67 : : const char *str3;
68 : : hashval_t hash;
69 : : bool prefix;
70 : : };
71 : :
72 : : /* Allocator used to hold string pair map entries for line map streaming. */
73 : : static struct object_allocator<struct string_pair_map>
74 : : *string_pair_map_allocator;
75 : :
76 : : struct string_pair_map_hasher : nofree_ptr_hash <string_pair_map>
77 : : {
78 : : static inline hashval_t hash (const string_pair_map *);
79 : : static inline bool equal (const string_pair_map *, const string_pair_map *);
80 : : };
81 : :
82 : : inline hashval_t
83 : 0 : string_pair_map_hasher::hash (const string_pair_map *spm)
84 : : {
85 : 0 : return spm->hash;
86 : : }
87 : :
88 : : inline bool
89 : 0 : string_pair_map_hasher::equal (const string_pair_map *spm1,
90 : : const string_pair_map *spm2)
91 : : {
92 : 0 : return (spm1->hash == spm2->hash
93 : 0 : && spm1->str1 == spm2->str1
94 : 0 : && spm1->prefix == spm2->prefix
95 : 0 : && strcmp (spm1->str2, spm2->str2) == 0);
96 : : }
97 : :
98 : : /* The table to hold the pairs of pathnames and corresponding
99 : : resulting pathname. Used for both mapping of get_src_pwd ()
100 : : and recorded source working directory to relative path prefix
101 : : from current working directory to the recorded one, and for
102 : : mapping of that relative path prefix and some relative path
103 : : to those concatenated. */
104 : : static hash_table<string_pair_map_hasher> *path_name_pair_hash_table;
105 : :
106 : :
107 : : /* Check that tag ACTUAL has one of the given values. NUM_TAGS is the
108 : : number of valid tag values to check. */
109 : :
110 : : void
111 : 1363029 : lto_tag_check_set (enum LTO_tags actual, int ntags, ...)
112 : : {
113 : 1363029 : va_list ap;
114 : 1363029 : int i;
115 : :
116 : 1363029 : va_start (ap, ntags);
117 : 2721456 : for (i = 0; i < ntags; i++)
118 : 2721456 : if ((unsigned) actual == va_arg (ap, unsigned))
119 : : {
120 : 1363029 : va_end (ap);
121 : 1363029 : return;
122 : : }
123 : :
124 : 0 : va_end (ap);
125 : 0 : internal_error ("bytecode stream: unexpected tag %s", lto_tag_name (actual));
126 : : }
127 : :
128 : :
129 : : /* Read LENGTH bytes from STREAM to ADDR. */
130 : :
131 : : void
132 : 0 : lto_input_data_block (class lto_input_block *ib, void *addr, size_t length)
133 : : {
134 : 0 : size_t i;
135 : 0 : unsigned char *const buffer = (unsigned char *) addr;
136 : :
137 : 0 : for (i = 0; i < length; i++)
138 : 0 : buffer[i] = streamer_read_uchar (ib);
139 : 0 : }
140 : :
141 : : /* Compute the relative path to get to DATA_WD (absolute directory name)
142 : : from CWD (another absolute directory name). E.g. for
143 : : DATA_WD of "/tmp/foo/bar" and CWD of "/tmp/baz/qux" return
144 : : "../../foo/bar". Returned string should be freed by the caller.
145 : : Return NULL if absolute file name needs to be used. */
146 : :
147 : : static char *
148 : 0 : relative_path_prefix (const char *data_wd, const char *cwd)
149 : : {
150 : 0 : const char *d = data_wd;
151 : 0 : const char *c = cwd;
152 : : #ifdef HAVE_DOS_BASED_FILE_SYSTEM
153 : : if (d[1] == ':')
154 : : {
155 : : if (!IS_DIR_SEPARATOR (d[2]))
156 : : return NULL;
157 : : if (c[0] == d[0] && c[1] == ':' && IS_DIR_SEPARATOR (c[2]))
158 : : {
159 : : c += 3;
160 : : d += 3;
161 : : }
162 : : else
163 : : return NULL;
164 : : }
165 : : else if (c[1] == ':')
166 : : return NULL;
167 : : #endif
168 : : do
169 : : {
170 : 0 : while (IS_DIR_SEPARATOR (*d))
171 : 0 : d++;
172 : 0 : while (IS_DIR_SEPARATOR (*c))
173 : 0 : c++;
174 : : size_t i;
175 : 0 : for (i = 0; c[i] && !IS_DIR_SEPARATOR (c[i]) && c[i] == d[i]; i++)
176 : : ;
177 : 0 : if ((c[i] == '\0' || IS_DIR_SEPARATOR (c[i]))
178 : 0 : && (d[i] == '\0' || IS_DIR_SEPARATOR (d[i])))
179 : : {
180 : 0 : c += i;
181 : 0 : d += i;
182 : 0 : if (*c == '\0' || *d == '\0')
183 : : break;
184 : : }
185 : : else
186 : : break;
187 : : }
188 : : while (1);
189 : 0 : size_t num_up = 0;
190 : : do
191 : : {
192 : 0 : while (IS_DIR_SEPARATOR (*c))
193 : 0 : c++;
194 : 0 : if (*c == '\0')
195 : : break;
196 : 0 : num_up++;
197 : 0 : while (*c && !IS_DIR_SEPARATOR (*c))
198 : 0 : c++;
199 : : }
200 : : while (1);
201 : 0 : while (IS_DIR_SEPARATOR (*d))
202 : 0 : d++;
203 : 0 : size_t len = strlen (d);
204 : 0 : if (len == 0 && num_up == 0)
205 : 0 : return xstrdup (".");
206 : 0 : char *ret = XNEWVEC (char, num_up * 3 + len + 1);
207 : 0 : char *p = ret;
208 : 0 : for (; num_up; num_up--)
209 : : {
210 : 0 : const char dir_up[3] = { '.', '.', DIR_SEPARATOR };
211 : 0 : memcpy (p, dir_up, 3);
212 : 0 : p += 3;
213 : : }
214 : 0 : memcpy (p, d, len + 1);
215 : 0 : return ret;
216 : : }
217 : :
218 : : /* Look up DATA_WD in hash table of relative prefixes. If found,
219 : : return relative path from CWD to DATA_WD from the hash table,
220 : : otherwise create it. */
221 : :
222 : : static const char *
223 : 0 : canon_relative_path_prefix (const char *data_wd, const char *cwd)
224 : : {
225 : 0 : if (!IS_ABSOLUTE_PATH (data_wd) || !IS_ABSOLUTE_PATH (cwd))
226 : : return NULL;
227 : :
228 : 0 : if (!path_name_pair_hash_table)
229 : : {
230 : 0 : path_name_pair_hash_table
231 : 0 : = new hash_table<string_pair_map_hasher> (37);
232 : 0 : string_pair_map_allocator
233 : 0 : = new object_allocator <struct string_pair_map>
234 : 0 : ("line map string pair map hash");
235 : : }
236 : :
237 : 0 : inchash::hash h;
238 : 0 : h.add_ptr (cwd);
239 : 0 : h.merge_hash (htab_hash_string (data_wd));
240 : 0 : h.add_int (true);
241 : :
242 : 0 : string_pair_map s_slot;
243 : 0 : s_slot.str1 = cwd;
244 : 0 : s_slot.str2 = data_wd;
245 : 0 : s_slot.str3 = NULL;
246 : 0 : s_slot.hash = h.end ();
247 : 0 : s_slot.prefix = true;
248 : :
249 : 0 : string_pair_map **slot
250 : 0 : = path_name_pair_hash_table->find_slot (&s_slot, INSERT);
251 : 0 : if (*slot == NULL)
252 : : {
253 : : /* Compute relative path from cwd directory to data_wd directory.
254 : : E.g. if cwd is /tmp/foo/bar and data_wd is /tmp/baz/qux ,
255 : : it will return ../../baz/qux . */
256 : 0 : char *relative_path = relative_path_prefix (data_wd, cwd);
257 : 0 : const char *relative = relative_path ? relative_path : data_wd;
258 : 0 : size_t relative_len = strlen (relative);
259 : 0 : gcc_assert (relative_len);
260 : :
261 : 0 : size_t data_wd_len = strlen (data_wd);
262 : 0 : bool add_separator = false;
263 : 0 : if (!IS_DIR_SEPARATOR (relative[relative_len - 1]))
264 : 0 : add_separator = true;
265 : :
266 : 0 : size_t len = relative_len + 1 + data_wd_len + 1 + add_separator;
267 : :
268 : 0 : char *saved_string = XOBNEWVEC (&file_name_obstack, char, len);
269 : 0 : struct string_pair_map *new_slot
270 : 0 : = string_pair_map_allocator->allocate ();
271 : 0 : memcpy (saved_string, data_wd, data_wd_len + 1);
272 : 0 : memcpy (saved_string + data_wd_len + 1, relative, relative_len);
273 : 0 : if (add_separator)
274 : 0 : saved_string[len - 2] = DIR_SEPARATOR;
275 : 0 : saved_string[len - 1] = '\0';
276 : 0 : new_slot->str1 = cwd;
277 : 0 : new_slot->str2 = saved_string;
278 : 0 : new_slot->str3 = saved_string + data_wd_len + 1;
279 : 0 : if (relative_len == 1 && relative[0] == '.')
280 : 0 : new_slot->str3 = NULL;
281 : 0 : new_slot->hash = s_slot.hash;
282 : 0 : new_slot->prefix = true;
283 : 0 : *slot = new_slot;
284 : 0 : free (relative_path);
285 : 0 : return new_slot->str3;
286 : : }
287 : : else
288 : : {
289 : 0 : string_pair_map *old_slot = *slot;
290 : 0 : return old_slot->str3;
291 : : }
292 : : }
293 : :
294 : : /* Look up the pair of RELATIVE_PREFIX and STRING strings in a hash table.
295 : : If found, return the concatenation of those from the hash table,
296 : : otherwise concatenate them. */
297 : :
298 : : static const char *
299 : 0 : canon_relative_file_name (const char *relative_prefix, const char *string)
300 : : {
301 : 0 : inchash::hash h;
302 : 0 : h.add_ptr (relative_prefix);
303 : 0 : h.merge_hash (htab_hash_string (string));
304 : :
305 : 0 : string_pair_map s_slot;
306 : 0 : s_slot.str1 = relative_prefix;
307 : 0 : s_slot.str2 = string;
308 : 0 : s_slot.str3 = NULL;
309 : 0 : s_slot.hash = h.end ();
310 : 0 : s_slot.prefix = false;
311 : :
312 : 0 : string_pair_map **slot
313 : 0 : = path_name_pair_hash_table->find_slot (&s_slot, INSERT);
314 : 0 : if (*slot == NULL)
315 : : {
316 : 0 : size_t relative_prefix_len = strlen (relative_prefix);
317 : 0 : size_t string_len = strlen (string);
318 : 0 : size_t len = relative_prefix_len + string_len + 1;
319 : :
320 : 0 : char *saved_string = XOBNEWVEC (&file_name_obstack, char, len);
321 : 0 : struct string_pair_map *new_slot
322 : 0 : = string_pair_map_allocator->allocate ();
323 : 0 : memcpy (saved_string, relative_prefix, relative_prefix_len);
324 : 0 : memcpy (saved_string + relative_prefix_len, string, string_len + 1);
325 : 0 : new_slot->str1 = relative_prefix;
326 : 0 : new_slot->str2 = saved_string + relative_prefix_len;
327 : 0 : new_slot->str3 = saved_string;
328 : 0 : new_slot->hash = s_slot.hash;
329 : 0 : new_slot->prefix = false;
330 : 0 : *slot = new_slot;
331 : 0 : return new_slot->str3;
332 : : }
333 : : else
334 : : {
335 : 0 : string_pair_map *old_slot = *slot;
336 : 0 : return old_slot->str3;
337 : : }
338 : : }
339 : :
340 : : /* Lookup STRING in file_name_hash_table. If found, return the existing
341 : : string, otherwise insert STRING as the canonical version.
342 : : If STRING is a relative pathname and RELATIVE_PREFIX is non-NULL, use
343 : : canon_relative_file_name instead. */
344 : :
345 : : static const char *
346 : 164414 : canon_file_name (const char *relative_prefix, const char *string)
347 : : {
348 : 164414 : if (relative_prefix && !IS_ABSOLUTE_PATH (string))
349 : 0 : return canon_relative_file_name (relative_prefix, string);
350 : :
351 : 164414 : string_slot **slot;
352 : 164414 : struct string_slot s_slot;
353 : 164414 : size_t len = strlen (string);
354 : :
355 : 164414 : s_slot.s = string;
356 : 164414 : s_slot.len = len;
357 : :
358 : 164414 : slot = file_name_hash_table->find_slot (&s_slot, INSERT);
359 : 164414 : if (*slot == NULL)
360 : : {
361 : 36879 : char *saved_string;
362 : 36879 : struct string_slot *new_slot;
363 : :
364 : 36879 : saved_string = XOBNEWVEC (&file_name_obstack, char, len + 1);
365 : 36879 : new_slot = string_slot_allocator->allocate ();
366 : 36879 : memcpy (saved_string, string, len + 1);
367 : 36879 : new_slot->s = saved_string;
368 : 36879 : new_slot->len = len;
369 : 36879 : *slot = new_slot;
370 : 36879 : return saved_string;
371 : : }
372 : : else
373 : : {
374 : 127535 : struct string_slot *old_slot = *slot;
375 : 127535 : return old_slot->s;
376 : : }
377 : : }
378 : :
379 : : /* Pointer to currently alive instance of lto_location_cache. */
380 : :
381 : : lto_location_cache *lto_location_cache::current_cache;
382 : :
383 : : /* Sort locations in source order. Start with file from last application. */
384 : :
385 : : int
386 : 57060351 : lto_location_cache::cmp_loc (const void *pa, const void *pb)
387 : : {
388 : 57060351 : const cached_location *a = ((const cached_location *)pa);
389 : 57060351 : const cached_location *b = ((const cached_location *)pb);
390 : 57060351 : const char *current_file = current_cache->current_file;
391 : 57060351 : int current_line = current_cache->current_line;
392 : :
393 : 57060351 : if (a->file == current_file && b->file != current_file)
394 : : return -1;
395 : 56963751 : if (a->file != current_file && b->file == current_file)
396 : : return 1;
397 : 56867577 : if (a->file == current_file && b->file == current_file)
398 : : {
399 : 9737033 : if (a->line == current_line && b->line != current_line)
400 : : return -1;
401 : 9357291 : if (a->line != current_line && b->line == current_line)
402 : : return 1;
403 : : }
404 : 56025859 : if (a->file != b->file)
405 : 1850038 : return strcmp (a->file, b->file);
406 : 54175821 : if (a->sysp != b->sysp)
407 : 0 : return a->sysp ? 1 : -1;
408 : 54175821 : if (a->line != b->line)
409 : 26368602 : return a->line - b->line;
410 : 27807219 : if (a->col != b->col)
411 : 3600006 : return a->col - b->col;
412 : 24207213 : if (a->discr != b->discr)
413 : 13778998 : return a->discr - b->discr;
414 : 10428215 : if ((a->block == NULL_TREE) != (b->block == NULL_TREE))
415 : 4960682 : return a->block ? 1 : -1;
416 : 7213917 : if (a->block)
417 : : {
418 : 3332979 : if (BLOCK_NUMBER (a->block) < BLOCK_NUMBER (b->block))
419 : : return -1;
420 : 3332979 : if (BLOCK_NUMBER (a->block) > BLOCK_NUMBER (b->block))
421 : 0 : return 1;
422 : : }
423 : : return 0;
424 : : }
425 : :
426 : : /* Apply all changes in location cache. Add locations into linemap and patch
427 : : trees. */
428 : :
429 : : bool
430 : 617693 : lto_location_cache::apply_location_cache ()
431 : : {
432 : 617693 : static const char *prev_file;
433 : 617693 : if (!loc_cache.length ())
434 : : return false;
435 : 320512 : if (loc_cache.length () > 1)
436 : 290829 : loc_cache.qsort (cmp_loc);
437 : :
438 : 6257232 : for (unsigned int i = 0; i < loc_cache.length (); i++)
439 : : {
440 : 2808104 : struct cached_location loc = loc_cache[i];
441 : :
442 : 2808104 : if (current_file != loc.file)
443 : 135521 : linemap_add (line_table, prev_file ? LC_RENAME : LC_ENTER,
444 : 135521 : loc.sysp, loc.file, loc.line);
445 : 2672583 : else if (current_line != loc.line)
446 : : {
447 : 718735 : int max = loc.col;
448 : :
449 : 1736200 : for (unsigned int j = i + 1; j < loc_cache.length (); j++)
450 : 1513860 : if (loc.file != loc_cache[j].file
451 : 1513860 : || loc.line != loc_cache[j].line)
452 : : break;
453 : 1017465 : else if (max < loc_cache[j].col)
454 : : max = loc_cache[j].col;
455 : 718735 : linemap_line_start (line_table, loc.line, max + 1);
456 : : }
457 : 2808104 : gcc_assert (*loc.loc == BUILTINS_LOCATION + 1);
458 : 2808104 : if (current_file != loc.file
459 : : || current_line != loc.line
460 : 2672583 : || current_col != loc.col)
461 : : {
462 : 1262304 : current_loc = linemap_position_for_column (line_table, loc.col);
463 : 1262304 : if (loc.block)
464 : 577547 : current_loc = set_block (current_loc, loc.block);
465 : 1262304 : if (loc.discr)
466 : 167415 : current_loc = location_with_discriminator (current_loc, loc.discr);
467 : : }
468 : 1545800 : else if (current_block != loc.block)
469 : : {
470 : 262369 : if (loc.block)
471 : 245191 : current_loc = set_block (current_loc, loc.block);
472 : : else
473 : 17178 : current_loc = LOCATION_LOCUS (current_loc);
474 : 262369 : if (loc.discr)
475 : 41825 : current_loc = location_with_discriminator (current_loc, loc.discr);
476 : : }
477 : 1283431 : else if (current_discr != loc.discr)
478 : 208155 : current_loc = location_with_discriminator (current_loc, loc.discr);
479 : 2808104 : *loc.loc = current_loc;
480 : 2808104 : current_line = loc.line;
481 : 2808104 : prev_file = current_file = loc.file;
482 : 2808104 : current_col = loc.col;
483 : 2808104 : current_block = loc.block;
484 : 2808104 : current_discr = loc.discr;
485 : : }
486 : 320512 : loc_cache.truncate (0);
487 : 320512 : accepted_length = 0;
488 : 320512 : return true;
489 : : }
490 : :
491 : : /* Tree merging did not succeed; mark all changes in the cache as accepted. */
492 : :
493 : : void
494 : 1709200 : lto_location_cache::accept_location_cache ()
495 : : {
496 : 1709200 : gcc_assert (current_cache == this);
497 : 1709200 : accepted_length = loc_cache.length ();
498 : 1709200 : }
499 : :
500 : : /* Tree merging did succeed; throw away recent changes. */
501 : :
502 : : void
503 : 142163 : lto_location_cache::revert_location_cache ()
504 : : {
505 : 142163 : loc_cache.truncate (accepted_length);
506 : 142163 : }
507 : :
508 : : /* Read a location bitpack from bit pack BP and either update *LOC directly
509 : : or add it to the location cache. If IB is non-NULL, stream in a block
510 : : afterwards.
511 : : It is neccesary to call apply_location_cache to get *LOC updated. */
512 : :
513 : : void
514 : 4810928 : lto_location_cache::input_location_and_block (location_t *loc,
515 : : struct bitpack_d *bp,
516 : : class lto_input_block *ib,
517 : : class data_in *data_in)
518 : : {
519 : 4810928 : static const char *stream_file;
520 : 4810928 : static int stream_line;
521 : 4810928 : static int stream_col;
522 : 4810928 : static bool stream_sysp;
523 : 4810928 : static tree stream_block;
524 : 4810928 : static unsigned stream_discr;
525 : 4810928 : static const char *stream_relative_path_prefix;
526 : :
527 : 4810928 : gcc_assert (current_cache == this);
528 : :
529 : 4810928 : *loc = bp_unpack_int_in_range (bp, "location", 0,
530 : : RESERVED_LOCATION_COUNT + 1);
531 : :
532 : 4810928 : if (*loc < RESERVED_LOCATION_COUNT)
533 : : {
534 : 1982349 : if (ib)
535 : : {
536 : 787669 : bool block_change = bp_unpack_value (bp, 1);
537 : 787669 : if (block_change)
538 : 299498 : stream_block = stream_read_tree (ib, data_in);
539 : 787669 : if (stream_block)
540 : 542571 : *loc = set_block (*loc, stream_block);
541 : : }
542 : 2001275 : return;
543 : : }
544 : :
545 : 2828579 : bool file_change = (*loc == RESERVED_LOCATION_COUNT + 1);
546 : : /* Keep value RESERVED_LOCATION_COUNT in *loc as linemap lookups will
547 : : ICE on it. */
548 : 2828579 : *loc = RESERVED_LOCATION_COUNT;
549 : 2828579 : bool line_change = bp_unpack_value (bp, 1);
550 : 2828579 : bool column_change = bp_unpack_value (bp, 1);
551 : 2828579 : bool discr_change = bp_unpack_value (bp, 1);
552 : :
553 : 2828579 : if (file_change)
554 : : {
555 : 164414 : bool pwd_change = bp_unpack_value (bp, 1);
556 : 164414 : if (pwd_change)
557 : : {
558 : 8968 : const char *pwd = bp_unpack_string (data_in, bp);
559 : 8968 : const char *src_pwd = get_src_pwd ();
560 : 8968 : if (strcmp (pwd, src_pwd) == 0)
561 : 8968 : stream_relative_path_prefix = NULL;
562 : : else
563 : 0 : stream_relative_path_prefix
564 : 0 : = canon_relative_path_prefix (pwd, src_pwd);
565 : : }
566 : 164414 : stream_file = canon_file_name (stream_relative_path_prefix,
567 : : bp_unpack_string (data_in, bp));
568 : 164414 : stream_sysp = bp_unpack_value (bp, 1);
569 : : }
570 : :
571 : 2828579 : if (line_change)
572 : 1080086 : stream_line = bp_unpack_var_len_unsigned (bp);
573 : :
574 : 2828579 : if (column_change)
575 : 1280419 : stream_col = bp_unpack_var_len_unsigned (bp);
576 : :
577 : 2828579 : if (discr_change)
578 : 901991 : stream_discr = bp_unpack_var_len_unsigned (bp);
579 : :
580 : 2828579 : tree block = NULL_TREE;
581 : 2828579 : if (ib)
582 : : {
583 : 1595129 : bool block_change = bp_unpack_value (bp, 1);
584 : 1595129 : if (block_change)
585 : 238000 : stream_block = stream_read_tree (ib, data_in);
586 : 1595129 : block = stream_block;
587 : : }
588 : :
589 : : /* This optimization saves location cache operations during gimple
590 : : streaming. */
591 : :
592 : 2828579 : if (current_file == stream_file
593 : 958950 : && current_line == stream_line
594 : 219997 : && current_col == stream_col
595 : 134974 : && current_sysp == stream_sysp
596 : 131970 : && current_discr == stream_discr)
597 : : {
598 : 18926 : if (current_block == block)
599 : 13479 : *loc = current_loc;
600 : 5447 : else if (block)
601 : 903 : *loc = set_block (current_loc, block);
602 : : else
603 : 4544 : *loc = LOCATION_LOCUS (current_loc);
604 : 18926 : return;
605 : : }
606 : :
607 : 2809653 : struct cached_location entry
608 : 2809653 : = {stream_file, loc, stream_line, stream_col, stream_sysp, block, stream_discr};
609 : 2809653 : loc_cache.safe_push (entry);
610 : : }
611 : :
612 : : /* Read a location bitpack from bit pack BP and either update *LOC directly
613 : : or add it to the location cache.
614 : : It is neccesary to call apply_location_cache to get *LOC updated. */
615 : :
616 : : void
617 : 2428130 : lto_location_cache::input_location (location_t *loc, struct bitpack_d *bp,
618 : : class data_in *data_in)
619 : : {
620 : 2428130 : return input_location_and_block (loc, bp, NULL, data_in);
621 : : }
622 : :
623 : : /* Read a location bitpack from input block IB and either update *LOC directly
624 : : or add it to the location cache.
625 : : It is neccesary to call apply_location_cache to get *LOC updated. */
626 : :
627 : : void
628 : 2428130 : lto_input_location (location_t *loc, struct bitpack_d *bp,
629 : : class data_in *data_in)
630 : : {
631 : 2428130 : data_in->location_cache.input_location (loc, bp, data_in);
632 : 2428130 : }
633 : :
634 : : /* Read a reference to a tree node from DATA_IN using input block IB.
635 : : TAG is the expected node that should be found in IB, if TAG belongs
636 : : to one of the indexable trees, expect to read a reference index to
637 : : be looked up in one of the symbol tables, otherwise read the pysical
638 : : representation of the tree using stream_read_tree. FN is the
639 : : function scope for the read tree. */
640 : :
641 : : tree
642 : 3885267 : lto_input_tree_ref (class lto_input_block *ib, class data_in *data_in,
643 : : struct function *fn, enum LTO_tags tag)
644 : : {
645 : 3885267 : unsigned HOST_WIDE_INT ix_u;
646 : 3885267 : tree result = NULL_TREE;
647 : :
648 : 3885267 : if (tag == LTO_ssa_name_ref)
649 : : {
650 : 1562659 : ix_u = streamer_read_uhwi (ib);
651 : 1562659 : result = (*SSANAMES (fn))[ix_u];
652 : : }
653 : : else
654 : : {
655 : 2322608 : gcc_checking_assert (tag == LTO_global_stream_ref);
656 : 2322608 : ix_u = streamer_read_uhwi (ib);
657 : 2322608 : result = (*data_in->file_data->current_decl_state
658 : 2322608 : ->streams[LTO_DECL_STREAM])[ix_u];
659 : : }
660 : :
661 : 3885267 : gcc_assert (result);
662 : :
663 : 3885267 : return result;
664 : : }
665 : :
666 : : /* Read VAR_DECL reference to DATA from IB. */
667 : :
668 : : tree
669 : 70969 : lto_input_var_decl_ref (lto_input_block *ib, lto_file_decl_data *file_data)
670 : : {
671 : 70969 : unsigned int ix_u = streamer_read_uhwi (ib);
672 : 70969 : tree result = (*file_data->current_decl_state
673 : 70969 : ->streams[LTO_DECL_STREAM])[ix_u];
674 : 70969 : gcc_assert (VAR_P (result));
675 : 70969 : return result;
676 : : }
677 : :
678 : : /* Read VAR_DECL reference to DATA from IB. */
679 : :
680 : : tree
681 : 188005 : lto_input_fn_decl_ref (lto_input_block *ib, lto_file_decl_data *file_data)
682 : : {
683 : 188005 : unsigned int ix_u = streamer_read_uhwi (ib);
684 : 188005 : tree result = (*file_data->current_decl_state
685 : 188005 : ->streams[LTO_DECL_STREAM])[ix_u];
686 : 188005 : gcc_assert (TREE_CODE (result) == FUNCTION_DECL);
687 : 188005 : return result;
688 : : }
689 : :
690 : :
691 : : /* Read and return a double-linked list of catch handlers from input
692 : : block IB, using descriptors in DATA_IN. */
693 : :
694 : : static struct eh_catch_d *
695 : 210 : lto_input_eh_catch_list (class lto_input_block *ib, class data_in *data_in,
696 : : eh_catch *last_p)
697 : : {
698 : 210 : eh_catch first;
699 : 210 : enum LTO_tags tag;
700 : :
701 : 210 : *last_p = first = NULL;
702 : 210 : tag = streamer_read_record_start (ib);
703 : 407 : while (tag)
704 : : {
705 : 197 : tree list;
706 : 197 : eh_catch n;
707 : :
708 : 197 : lto_tag_check_range (tag, LTO_eh_catch, LTO_eh_catch);
709 : :
710 : : /* Read the catch node. */
711 : 197 : n = ggc_cleared_alloc<eh_catch_d> ();
712 : 197 : n->type_list = stream_read_tree (ib, data_in);
713 : 197 : n->filter_list = stream_read_tree (ib, data_in);
714 : 197 : n->label = stream_read_tree (ib, data_in);
715 : :
716 : : /* Register all the types in N->FILTER_LIST. */
717 : 197 : for (list = n->filter_list; list; list = TREE_CHAIN (list))
718 : 0 : add_type_for_runtime (TREE_VALUE (list));
719 : :
720 : : /* Chain N to the end of the list. */
721 : 197 : if (*last_p)
722 : 4 : (*last_p)->next_catch = n;
723 : 197 : n->prev_catch = *last_p;
724 : 197 : *last_p = n;
725 : :
726 : : /* Set the head of the list the first time through the loop. */
727 : 197 : if (first == NULL)
728 : 193 : first = n;
729 : :
730 : 197 : tag = streamer_read_record_start (ib);
731 : : }
732 : :
733 : 210 : return first;
734 : : }
735 : :
736 : :
737 : : /* Read and return EH region IX from input block IB, using descriptors
738 : : in DATA_IN. */
739 : :
740 : : static eh_region
741 : 14015 : input_eh_region (class lto_input_block *ib, class data_in *data_in, int ix)
742 : : {
743 : 14015 : enum LTO_tags tag;
744 : 14015 : eh_region r;
745 : :
746 : : /* Read the region header. */
747 : 14015 : tag = streamer_read_record_start (ib);
748 : 14015 : if (tag == LTO_null)
749 : : return NULL;
750 : :
751 : 8669 : r = ggc_cleared_alloc<eh_region_d> ();
752 : 8669 : r->index = streamer_read_hwi (ib);
753 : :
754 : 8669 : gcc_assert (r->index == ix);
755 : :
756 : : /* Read all the region pointers as region numbers. We'll fix up
757 : : the pointers once the whole array has been read. */
758 : 8669 : r->outer = (eh_region) (intptr_t) streamer_read_hwi (ib);
759 : 8669 : r->inner = (eh_region) (intptr_t) streamer_read_hwi (ib);
760 : 8669 : r->next_peer = (eh_region) (intptr_t) streamer_read_hwi (ib);
761 : :
762 : 8669 : switch (tag)
763 : : {
764 : 3601 : case LTO_ert_cleanup:
765 : 3601 : r->type = ERT_CLEANUP;
766 : 3601 : break;
767 : :
768 : 210 : case LTO_ert_try:
769 : 210 : {
770 : 210 : struct eh_catch_d *last_catch;
771 : 210 : r->type = ERT_TRY;
772 : 210 : r->u.eh_try.first_catch = lto_input_eh_catch_list (ib, data_in,
773 : : &last_catch);
774 : 210 : r->u.eh_try.last_catch = last_catch;
775 : 210 : break;
776 : : }
777 : :
778 : 305 : case LTO_ert_allowed_exceptions:
779 : 305 : {
780 : 305 : tree l;
781 : :
782 : 305 : r->type = ERT_ALLOWED_EXCEPTIONS;
783 : 305 : r->u.allowed.type_list = stream_read_tree (ib, data_in);
784 : 305 : r->u.allowed.label = stream_read_tree (ib, data_in);
785 : 305 : r->u.allowed.filter = streamer_read_uhwi (ib);
786 : :
787 : 307 : for (l = r->u.allowed.type_list; l ; l = TREE_CHAIN (l))
788 : 2 : add_type_for_runtime (TREE_VALUE (l));
789 : : }
790 : : break;
791 : :
792 : 4553 : case LTO_ert_must_not_throw:
793 : 4553 : {
794 : 4553 : r->type = ERT_MUST_NOT_THROW;
795 : 4553 : r->u.must_not_throw.failure_decl = stream_read_tree (ib, data_in);
796 : 4553 : bitpack_d bp = streamer_read_bitpack (ib);
797 : 4553 : stream_input_location (&r->u.must_not_throw.failure_loc,
798 : : &bp, data_in);
799 : : }
800 : 4553 : break;
801 : :
802 : 0 : default:
803 : 0 : gcc_unreachable ();
804 : : }
805 : :
806 : 8669 : r->landing_pads = (eh_landing_pad) (intptr_t) streamer_read_hwi (ib);
807 : :
808 : 8669 : return r;
809 : : }
810 : :
811 : :
812 : : /* Read and return EH landing pad IX from input block IB, using descriptors
813 : : in DATA_IN. */
814 : :
815 : : static eh_landing_pad
816 : 6343 : input_eh_lp (class lto_input_block *ib, class data_in *data_in, int ix)
817 : : {
818 : 6343 : enum LTO_tags tag;
819 : 6343 : eh_landing_pad lp;
820 : :
821 : : /* Read the landing pad header. */
822 : 6343 : tag = streamer_read_record_start (ib);
823 : 6343 : if (tag == LTO_null)
824 : : return NULL;
825 : :
826 : 2228 : lto_tag_check_range (tag, LTO_eh_landing_pad, LTO_eh_landing_pad);
827 : :
828 : 2228 : lp = ggc_cleared_alloc<eh_landing_pad_d> ();
829 : 2228 : lp->index = streamer_read_hwi (ib);
830 : 2228 : gcc_assert (lp->index == ix);
831 : 2228 : lp->next_lp = (eh_landing_pad) (intptr_t) streamer_read_hwi (ib);
832 : 2228 : lp->region = (eh_region) (intptr_t) streamer_read_hwi (ib);
833 : 2228 : lp->post_landing_pad = stream_read_tree (ib, data_in);
834 : :
835 : 2228 : return lp;
836 : : }
837 : :
838 : :
839 : : /* After reading the EH regions, pointers to peer and children regions
840 : : are region numbers. This converts all these region numbers into
841 : : real pointers into the rematerialized regions for FN. ROOT_REGION
842 : : is the region number for the root EH region in FN. */
843 : :
844 : : static void
845 : 3528 : fixup_eh_region_pointers (struct function *fn, HOST_WIDE_INT root_region)
846 : : {
847 : 3528 : unsigned i;
848 : 3528 : vec<eh_region, va_gc> *eh_array = fn->eh->region_array;
849 : 3528 : vec<eh_landing_pad, va_gc> *lp_array = fn->eh->lp_array;
850 : 3528 : eh_region r;
851 : 3528 : eh_landing_pad lp;
852 : :
853 : 3528 : gcc_assert (eh_array && lp_array);
854 : :
855 : 3528 : gcc_assert (root_region >= 0);
856 : 3528 : fn->eh->region_tree = (*eh_array)[root_region];
857 : :
858 : : #define FIXUP_EH_REGION(r) (r) = (*eh_array)[(HOST_WIDE_INT) (intptr_t) (r)]
859 : : #define FIXUP_EH_LP(p) (p) = (*lp_array)[(HOST_WIDE_INT) (intptr_t) (p)]
860 : :
861 : : /* Convert all the index numbers stored in pointer fields into
862 : : pointers to the corresponding slots in the EH region array. */
863 : 17543 : FOR_EACH_VEC_ELT (*eh_array, i, r)
864 : : {
865 : : /* The array may contain NULL regions. */
866 : 14015 : if (r == NULL)
867 : 5346 : continue;
868 : :
869 : 8669 : gcc_assert (i == (unsigned) r->index);
870 : 8669 : FIXUP_EH_REGION (r->outer);
871 : 8669 : FIXUP_EH_REGION (r->inner);
872 : 8669 : FIXUP_EH_REGION (r->next_peer);
873 : 8669 : FIXUP_EH_LP (r->landing_pads);
874 : : }
875 : :
876 : : /* Convert all the index numbers stored in pointer fields into
877 : : pointers to the corresponding slots in the EH landing pad array. */
878 : 9871 : FOR_EACH_VEC_ELT (*lp_array, i, lp)
879 : : {
880 : : /* The array may contain NULL landing pads. */
881 : 10458 : if (lp == NULL)
882 : 4115 : continue;
883 : :
884 : 2228 : gcc_assert (i == (unsigned) lp->index);
885 : 2228 : FIXUP_EH_LP (lp->next_lp);
886 : 2228 : FIXUP_EH_REGION (lp->region);
887 : : }
888 : :
889 : : #undef FIXUP_EH_REGION
890 : : #undef FIXUP_EH_LP
891 : 3528 : }
892 : :
893 : :
894 : : /* Initialize EH support. */
895 : :
896 : : void
897 : 40341 : lto_init_eh (void)
898 : : {
899 : 40341 : static bool eh_initialized_p = false;
900 : :
901 : 40341 : if (eh_initialized_p)
902 : : return;
903 : :
904 : : /* Contrary to most other FEs, we only initialize EH support when at
905 : : least one of the files in the set contains exception regions in
906 : : it. Since this happens much later than the call to init_eh in
907 : : lang_dependent_init, we have to set flag_exceptions and call
908 : : init_eh again to initialize the EH tables. */
909 : 2667 : flag_exceptions = 1;
910 : 2667 : init_eh ();
911 : :
912 : 2667 : eh_initialized_p = true;
913 : : }
914 : :
915 : :
916 : : /* Read the exception table for FN from IB using the data descriptors
917 : : in DATA_IN. */
918 : :
919 : : static void
920 : 81892 : input_eh_regions (class lto_input_block *ib, class data_in *data_in,
921 : : struct function *fn)
922 : : {
923 : 81892 : HOST_WIDE_INT i, root_region, len;
924 : 81892 : enum LTO_tags tag;
925 : :
926 : 81892 : tag = streamer_read_record_start (ib);
927 : 81892 : if (tag == LTO_null)
928 : : return;
929 : :
930 : 3528 : lto_tag_check_range (tag, LTO_eh_table, LTO_eh_table);
931 : :
932 : 3528 : gcc_assert (fn->eh);
933 : :
934 : 3528 : root_region = streamer_read_hwi (ib);
935 : 3528 : gcc_assert (root_region == (int) root_region);
936 : :
937 : : /* Read the EH region array. */
938 : 3528 : len = streamer_read_hwi (ib);
939 : 3528 : gcc_assert (len == (int) len);
940 : 3528 : if (len > 0)
941 : : {
942 : 3528 : vec_safe_grow_cleared (fn->eh->region_array, len, true);
943 : 17543 : for (i = 0; i < len; i++)
944 : : {
945 : 14015 : eh_region r = input_eh_region (ib, data_in, i);
946 : 14015 : (*fn->eh->region_array)[i] = r;
947 : : }
948 : : }
949 : :
950 : : /* Read the landing pads. */
951 : 3528 : len = streamer_read_hwi (ib);
952 : 3528 : gcc_assert (len == (int) len);
953 : 3528 : if (len > 0)
954 : : {
955 : 3528 : vec_safe_grow_cleared (fn->eh->lp_array, len, true);
956 : 9871 : for (i = 0; i < len; i++)
957 : : {
958 : 6343 : eh_landing_pad lp = input_eh_lp (ib, data_in, i);
959 : 6343 : (*fn->eh->lp_array)[i] = lp;
960 : : }
961 : : }
962 : :
963 : : /* Read the runtime type data. */
964 : 3528 : len = streamer_read_hwi (ib);
965 : 3528 : gcc_assert (len == (int) len);
966 : 3528 : if (len > 0)
967 : : {
968 : 0 : vec_safe_grow_cleared (fn->eh->ttype_data, len, true);
969 : 0 : for (i = 0; i < len; i++)
970 : : {
971 : 0 : tree ttype = stream_read_tree (ib, data_in);
972 : 0 : (*fn->eh->ttype_data)[i] = ttype;
973 : : }
974 : : }
975 : :
976 : : /* Read the table of action chains. */
977 : 3528 : len = streamer_read_hwi (ib);
978 : 3528 : gcc_assert (len == (int) len);
979 : 3528 : if (len > 0)
980 : : {
981 : 0 : if (targetm.arm_eabi_unwinder)
982 : : {
983 : 0 : vec_safe_grow_cleared (fn->eh->ehspec_data.arm_eabi, len, true);
984 : 0 : for (i = 0; i < len; i++)
985 : : {
986 : 0 : tree t = stream_read_tree (ib, data_in);
987 : 0 : (*fn->eh->ehspec_data.arm_eabi)[i] = t;
988 : : }
989 : : }
990 : : else
991 : : {
992 : 0 : vec_safe_grow_cleared (fn->eh->ehspec_data.other, len, true);
993 : 0 : for (i = 0; i < len; i++)
994 : : {
995 : 0 : uchar c = streamer_read_uchar (ib);
996 : 0 : (*fn->eh->ehspec_data.other)[i] = c;
997 : : }
998 : : }
999 : : }
1000 : :
1001 : : /* Reconstruct the EH region tree by fixing up the peer/children
1002 : : pointers. */
1003 : 3528 : fixup_eh_region_pointers (fn, root_region);
1004 : :
1005 : 3528 : tag = streamer_read_record_start (ib);
1006 : 3528 : lto_tag_check_range (tag, LTO_null, LTO_null);
1007 : : }
1008 : :
1009 : :
1010 : : /* Make a new basic block with index INDEX in function FN. */
1011 : :
1012 : : static basic_block
1013 : 568439 : make_new_block (struct function *fn, unsigned int index)
1014 : : {
1015 : 568439 : basic_block bb = alloc_block ();
1016 : 568439 : bb->index = index;
1017 : 568439 : SET_BASIC_BLOCK_FOR_FN (fn, index, bb);
1018 : 568439 : n_basic_blocks_for_fn (fn)++;
1019 : 568439 : return bb;
1020 : : }
1021 : :
1022 : :
1023 : : /* Read the CFG for function FN from input block IB. */
1024 : :
1025 : : static void
1026 : 81892 : input_cfg (class lto_input_block *ib, class data_in *data_in,
1027 : : struct function *fn)
1028 : : {
1029 : 81892 : unsigned int bb_count;
1030 : 81892 : basic_block p_bb;
1031 : 81892 : unsigned int i;
1032 : 81892 : int index;
1033 : 81892 : bool full_profile = false;
1034 : :
1035 : 81892 : init_empty_tree_cfg_for_function (fn);
1036 : :
1037 : 81892 : profile_status_for_fn (fn) = streamer_read_enum (ib, profile_status_d,
1038 : : PROFILE_LAST);
1039 : :
1040 : 81892 : bb_count = streamer_read_uhwi (ib);
1041 : :
1042 : 81892 : last_basic_block_for_fn (fn) = bb_count;
1043 : 81892 : if (bb_count > basic_block_info_for_fn (fn)->length ())
1044 : 2075 : vec_safe_grow_cleared (basic_block_info_for_fn (fn), bb_count, true);
1045 : :
1046 : 81892 : if (bb_count > label_to_block_map_for_fn (fn)->length ())
1047 : 2075 : vec_safe_grow_cleared (label_to_block_map_for_fn (fn), bb_count, true);
1048 : :
1049 : 81892 : index = streamer_read_hwi (ib);
1050 : 814115 : while (index != -1)
1051 : : {
1052 : 732223 : basic_block bb = BASIC_BLOCK_FOR_FN (fn, index);
1053 : 732223 : unsigned int edge_count;
1054 : :
1055 : 732223 : if (bb == NULL)
1056 : 32464 : bb = make_new_block (fn, index);
1057 : :
1058 : 732223 : edge_count = streamer_read_uhwi (ib);
1059 : :
1060 : : /* Connect up the CFG. */
1061 : 1574761 : for (i = 0; i < edge_count; i++)
1062 : : {
1063 : 842538 : bitpack_d bp = streamer_read_bitpack (ib);
1064 : 842538 : unsigned int dest_index = bp_unpack_var_len_unsigned (&bp);
1065 : 842538 : unsigned int edge_flags = bp_unpack_var_len_unsigned (&bp);
1066 : 842538 : basic_block dest = BASIC_BLOCK_FOR_FN (fn, dest_index);
1067 : :
1068 : 842538 : if (dest == NULL)
1069 : 535975 : dest = make_new_block (fn, dest_index);
1070 : :
1071 : 842538 : edge e = make_edge (bb, dest, edge_flags);
1072 : 842538 : data_in->location_cache.input_location_and_block (&e->goto_locus,
1073 : : &bp, ib, data_in);
1074 : 842538 : e->probability = profile_probability::stream_in (ib);
1075 : 842538 : if (!e->probability.initialized_p ())
1076 : 842538 : full_profile = false;
1077 : :
1078 : : }
1079 : :
1080 : 732223 : index = streamer_read_hwi (ib);
1081 : : }
1082 : :
1083 : 81892 : p_bb = ENTRY_BLOCK_PTR_FOR_FN (fn);
1084 : 81892 : index = streamer_read_hwi (ib);
1085 : 732223 : while (index != -1)
1086 : : {
1087 : 650331 : basic_block bb = BASIC_BLOCK_FOR_FN (fn, index);
1088 : 650331 : bb->prev_bb = p_bb;
1089 : 650331 : p_bb->next_bb = bb;
1090 : 650331 : p_bb = bb;
1091 : 650331 : index = streamer_read_hwi (ib);
1092 : : }
1093 : :
1094 : : /* ??? The cfgloop interface is tied to cfun. */
1095 : 81892 : gcc_assert (cfun == fn);
1096 : :
1097 : : /* Input the loop tree. */
1098 : 81892 : unsigned n_loops = streamer_read_uhwi (ib);
1099 : 81892 : if (n_loops == 0)
1100 : : return;
1101 : :
1102 : 81892 : struct loops *loops = ggc_cleared_alloc<struct loops> ();
1103 : 81892 : init_loops_structure (fn, loops, n_loops);
1104 : 81892 : set_loops_for_fn (fn, loops);
1105 : :
1106 : : /* Input each loop and associate it with its loop header so
1107 : : flow_loops_find can rebuild the loop tree. */
1108 : 139407 : for (unsigned i = 1; i < n_loops; ++i)
1109 : : {
1110 : 57515 : int header_index = streamer_read_hwi (ib);
1111 : 57515 : if (header_index == -1)
1112 : : {
1113 : 21363 : loops->larray->quick_push (NULL);
1114 : 21363 : continue;
1115 : : }
1116 : :
1117 : 36152 : class loop *loop = alloc_loop ();
1118 : 36152 : loop->header = BASIC_BLOCK_FOR_FN (fn, header_index);
1119 : 36152 : loop->header->loop_father = loop;
1120 : :
1121 : : /* Read everything copy_loop_info copies. */
1122 : 36152 : loop->estimate_state = streamer_read_enum (ib, loop_estimation, EST_LAST);
1123 : 36152 : loop->any_upper_bound = streamer_read_hwi (ib);
1124 : 36152 : if (loop->any_upper_bound)
1125 : 31465 : loop->nb_iterations_upper_bound
1126 : 31465 : = bound_wide_int::from (streamer_read_widest_int (ib), SIGNED);
1127 : 36152 : loop->any_likely_upper_bound = streamer_read_hwi (ib);
1128 : 36152 : if (loop->any_likely_upper_bound)
1129 : 31465 : loop->nb_iterations_likely_upper_bound
1130 : 31465 : = bound_wide_int::from (streamer_read_widest_int (ib), SIGNED);
1131 : 36152 : loop->any_estimate = streamer_read_hwi (ib);
1132 : 36152 : if (loop->any_estimate)
1133 : 26756 : loop->nb_iterations_estimate
1134 : 26756 : = bound_wide_int::from (streamer_read_widest_int (ib), SIGNED);
1135 : :
1136 : : /* Read OMP SIMD related info. */
1137 : 36152 : loop->safelen = streamer_read_hwi (ib);
1138 : 36152 : loop->unroll = streamer_read_hwi (ib);
1139 : 36152 : loop->owned_clique = streamer_read_hwi (ib);
1140 : 36152 : loop->dont_vectorize = streamer_read_hwi (ib);
1141 : 36152 : loop->force_vectorize = streamer_read_hwi (ib);
1142 : 36152 : loop->finite_p = streamer_read_hwi (ib);
1143 : 36152 : loop->simduid = stream_read_tree (ib, data_in);
1144 : :
1145 : 36152 : place_new_loop (fn, loop);
1146 : :
1147 : : /* flow_loops_find doesn't like loops not in the tree, hook them
1148 : : all as siblings of the tree root temporarily. */
1149 : 36152 : flow_loop_tree_node_add (loops->tree_root, loop);
1150 : : }
1151 : :
1152 : : /* Rebuild the loop tree. */
1153 : 81892 : flow_loops_find (loops);
1154 : 81892 : cfun->cfg->full_profile = full_profile;
1155 : : }
1156 : :
1157 : :
1158 : : /* Read the SSA names array for function FN from DATA_IN using input
1159 : : block IB. */
1160 : :
1161 : : static void
1162 : 81892 : input_ssa_names (class lto_input_block *ib, class data_in *data_in,
1163 : : struct function *fn)
1164 : : {
1165 : 81892 : unsigned int i, size;
1166 : :
1167 : 81892 : size = streamer_read_uhwi (ib);
1168 : 81892 : init_tree_ssa (fn, size);
1169 : 81892 : cfun->gimple_df->in_ssa_p = true;
1170 : 81892 : init_ssa_operands (fn);
1171 : :
1172 : 81892 : i = streamer_read_uhwi (ib);
1173 : 880769 : while (i)
1174 : : {
1175 : : tree ssa_name, name;
1176 : : bool is_default_def;
1177 : :
1178 : : /* Skip over the elements that had been freed. */
1179 : 1047459 : while (SSANAMES (fn)->length () < i)
1180 : 248582 : SSANAMES (fn)->quick_push (NULL_TREE);
1181 : :
1182 : 798877 : is_default_def = (streamer_read_uchar (ib) != 0);
1183 : 798877 : name = stream_read_tree (ib, data_in);
1184 : 798877 : ssa_name = make_ssa_name_fn (fn, name, NULL);
1185 : :
1186 : 798877 : if (is_default_def)
1187 : : {
1188 : 80559 : set_ssa_default_def (cfun, SSA_NAME_VAR (ssa_name), ssa_name);
1189 : 80559 : SSA_NAME_DEF_STMT (ssa_name) = gimple_build_nop ();
1190 : : }
1191 : :
1192 : 798877 : i = streamer_read_uhwi (ib);
1193 : : }
1194 : 81892 : }
1195 : :
1196 : :
1197 : : /* Go through all NODE edges and fixup call_stmt pointers
1198 : : so they point to STMTS. */
1199 : :
1200 : : static void
1201 : 105651 : fixup_call_stmt_edges_1 (struct cgraph_node *node, gimple **stmts,
1202 : : struct function *fn)
1203 : : {
1204 : : #define STMT_UID_NOT_IN_RANGE(uid) \
1205 : : (gimple_stmt_max_uid (fn) < uid || uid == 0)
1206 : :
1207 : 105651 : struct cgraph_edge *cedge;
1208 : 105651 : struct ipa_ref *ref = NULL;
1209 : 105651 : unsigned int i;
1210 : :
1211 : 462080 : for (cedge = node->callees; cedge; cedge = cedge->next_callee)
1212 : : {
1213 : 356429 : if (STMT_UID_NOT_IN_RANGE (cedge->lto_stmt_uid))
1214 : 0 : fatal_error (input_location,
1215 : : "Cgraph edge statement index out of range");
1216 : 356429 : cedge->call_stmt = as_a <gcall *> (stmts[cedge->lto_stmt_uid - 1]);
1217 : 356429 : cedge->lto_stmt_uid = 0;
1218 : 356429 : if (!cedge->call_stmt)
1219 : 0 : fatal_error (input_location,
1220 : : "Cgraph edge statement index not found");
1221 : : }
1222 : 106858 : for (cedge = node->indirect_calls; cedge; cedge = cedge->next_callee)
1223 : : {
1224 : 1207 : if (STMT_UID_NOT_IN_RANGE (cedge->lto_stmt_uid))
1225 : 0 : fatal_error (input_location,
1226 : : "Cgraph edge statement index out of range");
1227 : 1207 : cedge->call_stmt = as_a <gcall *> (stmts[cedge->lto_stmt_uid - 1]);
1228 : 1207 : cedge->lto_stmt_uid = 0;
1229 : 1207 : if (!cedge->call_stmt)
1230 : 0 : fatal_error (input_location, "Cgraph edge statement index not found");
1231 : : }
1232 : 338892 : for (i = 0; node->iterate_reference (i, ref); i++)
1233 : 233241 : if (ref->lto_stmt_uid)
1234 : : {
1235 : 229512 : if (STMT_UID_NOT_IN_RANGE (ref->lto_stmt_uid))
1236 : 0 : fatal_error (input_location,
1237 : : "Reference statement index out of range");
1238 : 229512 : ref->stmt = stmts[ref->lto_stmt_uid - 1];
1239 : 229512 : ref->lto_stmt_uid = 0;
1240 : 229512 : if (!ref->stmt)
1241 : 0 : fatal_error (input_location, "Reference statement index not found");
1242 : : }
1243 : 105651 : }
1244 : :
1245 : :
1246 : : /* Fixup call_stmt pointers in NODE and all clones. */
1247 : :
1248 : : static void
1249 : 81892 : fixup_call_stmt_edges (struct cgraph_node *orig, gimple **stmts)
1250 : : {
1251 : 81892 : struct cgraph_node *node;
1252 : 81892 : struct function *fn;
1253 : :
1254 : 82025 : while (orig->clone_of)
1255 : : orig = orig->clone_of;
1256 : 81892 : fn = DECL_STRUCT_FUNCTION (orig->decl);
1257 : :
1258 : 81892 : if (!orig->thunk)
1259 : 81892 : fixup_call_stmt_edges_1 (orig, stmts, fn);
1260 : 81892 : if (orig->clones)
1261 : 27964 : for (node = orig->clones; node != orig;)
1262 : : {
1263 : 23761 : if (!node->thunk)
1264 : 23759 : fixup_call_stmt_edges_1 (node, stmts, fn);
1265 : 23761 : if (node->clones)
1266 : : node = node->clones;
1267 : 22638 : else if (node->next_sibling_clone)
1268 : : node = node->next_sibling_clone;
1269 : : else
1270 : : {
1271 : 9559 : while (node != orig && !node->next_sibling_clone)
1272 : 5326 : node = node->clone_of;
1273 : 4233 : if (node != orig)
1274 : 30 : node = node->next_sibling_clone;
1275 : : }
1276 : : }
1277 : 81892 : }
1278 : :
1279 : :
1280 : : /* Input the base body of struct function FN from DATA_IN
1281 : : using input block IB. */
1282 : :
1283 : : static void
1284 : 81892 : input_struct_function_base (struct function *fn, class data_in *data_in,
1285 : : class lto_input_block *ib)
1286 : : {
1287 : 81892 : struct bitpack_d bp;
1288 : 81892 : int len;
1289 : :
1290 : : /* Read the static chain and non-local goto save area. */
1291 : 81892 : fn->static_chain_decl = stream_read_tree (ib, data_in);
1292 : 81892 : fn->nonlocal_goto_save_area = stream_read_tree (ib, data_in);
1293 : :
1294 : : /* Read all the local symbols. */
1295 : 81892 : len = streamer_read_hwi (ib);
1296 : 81892 : if (len > 0)
1297 : : {
1298 : 21846 : int i;
1299 : 21846 : vec_safe_grow_cleared (fn->local_decls, len, true);
1300 : 174210 : for (i = 0; i < len; i++)
1301 : : {
1302 : 152364 : tree t = stream_read_tree (ib, data_in);
1303 : 152364 : (*fn->local_decls)[i] = t;
1304 : : }
1305 : : }
1306 : :
1307 : : /* Input the current IL state of the function. */
1308 : 81892 : fn->curr_properties = streamer_read_uhwi (ib);
1309 : :
1310 : : /* Read all the attributes for FN. */
1311 : 81892 : bp = streamer_read_bitpack (ib);
1312 : 81892 : fn->is_thunk = bp_unpack_value (&bp, 1);
1313 : 81892 : fn->has_local_explicit_reg_vars = bp_unpack_value (&bp, 1);
1314 : 81892 : fn->returns_pcc_struct = bp_unpack_value (&bp, 1);
1315 : 81892 : fn->returns_struct = bp_unpack_value (&bp, 1);
1316 : 81892 : fn->can_throw_non_call_exceptions = bp_unpack_value (&bp, 1);
1317 : 81892 : fn->can_delete_dead_exceptions = bp_unpack_value (&bp, 1);
1318 : 81892 : fn->always_inline_functions_inlined = bp_unpack_value (&bp, 1);
1319 : 81892 : fn->after_inlining = bp_unpack_value (&bp, 1);
1320 : 81892 : fn->stdarg = bp_unpack_value (&bp, 1);
1321 : 81892 : fn->has_nonlocal_label = bp_unpack_value (&bp, 1);
1322 : 81892 : fn->has_forced_label_in_static = bp_unpack_value (&bp, 1);
1323 : 81892 : fn->calls_alloca = bp_unpack_value (&bp, 1);
1324 : 81892 : fn->calls_setjmp = bp_unpack_value (&bp, 1);
1325 : 81892 : fn->calls_eh_return = bp_unpack_value (&bp, 1);
1326 : 81892 : fn->has_force_vectorize_loops = bp_unpack_value (&bp, 1);
1327 : 81892 : fn->has_simduid_loops = bp_unpack_value (&bp, 1);
1328 : 81892 : fn->assume_function = bp_unpack_value (&bp, 1);
1329 : 81892 : fn->va_list_fpr_size = bp_unpack_value (&bp, 8);
1330 : 81892 : fn->va_list_gpr_size = bp_unpack_value (&bp, 8);
1331 : 81892 : fn->last_clique = bp_unpack_value (&bp, sizeof (short) * 8);
1332 : :
1333 : : /* Input the function start and end loci. */
1334 : 81892 : stream_input_location (&fn->function_start_locus, &bp, data_in);
1335 : 81892 : stream_input_location (&fn->function_end_locus, &bp, data_in);
1336 : :
1337 : : /* Restore the instance discriminators if present. */
1338 : 81892 : int instance_number = bp_unpack_value (&bp, 1);
1339 : 81892 : if (instance_number)
1340 : : {
1341 : 0 : instance_number = bp_unpack_value (&bp, sizeof (int) * CHAR_BIT);
1342 : 0 : maybe_create_decl_to_instance_map ()->put (fn->decl, instance_number);
1343 : : }
1344 : 81892 : }
1345 : :
1346 : : /* Read a chain of tree nodes from input block IB. DATA_IN contains
1347 : : tables and descriptors for the file being read. */
1348 : :
1349 : : static tree
1350 : 81955 : streamer_read_chain (class lto_input_block *ib, class data_in *data_in)
1351 : : {
1352 : 81955 : tree first, prev, curr;
1353 : :
1354 : : /* The chain is written as NULL terminated list of trees. */
1355 : 81955 : first = prev = NULL_TREE;
1356 : 167256 : do
1357 : : {
1358 : 167256 : curr = stream_read_tree (ib, data_in);
1359 : 167256 : if (prev)
1360 : 85301 : TREE_CHAIN (prev) = curr;
1361 : : else
1362 : : first = curr;
1363 : :
1364 : 167256 : prev = curr;
1365 : : }
1366 : 167256 : while (curr);
1367 : :
1368 : 81955 : return first;
1369 : : }
1370 : :
1371 : : /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1372 : :
1373 : : static void
1374 : 81955 : input_function (tree fn_decl, class data_in *data_in,
1375 : : class lto_input_block *ib, class lto_input_block *ib_cfg,
1376 : : cgraph_node *node)
1377 : : {
1378 : 81955 : struct function *fn;
1379 : 81955 : enum LTO_tags tag;
1380 : 81955 : gimple **stmts;
1381 : 81955 : basic_block bb;
1382 : :
1383 : 81955 : tag = streamer_read_record_start (ib);
1384 : 81955 : lto_tag_check (tag, LTO_function);
1385 : :
1386 : : /* Read decls for parameters and args. */
1387 : 81955 : DECL_RESULT (fn_decl) = stream_read_tree (ib, data_in);
1388 : 81955 : DECL_ARGUMENTS (fn_decl) = streamer_read_chain (ib, data_in);
1389 : :
1390 : : /* Read debug args if available. */
1391 : 81955 : unsigned n_debugargs = streamer_read_uhwi (ib);
1392 : 81955 : if (n_debugargs)
1393 : : {
1394 : 23 : vec<tree, va_gc> **debugargs = decl_debug_args_insert (fn_decl);
1395 : 23 : vec_safe_grow (*debugargs, n_debugargs, true);
1396 : 85 : for (unsigned i = 0; i < n_debugargs; ++i)
1397 : 62 : (**debugargs)[i] = stream_read_tree (ib, data_in);
1398 : : }
1399 : :
1400 : : /* Read the tree of lexical scopes for the function. */
1401 : 81955 : DECL_INITIAL (fn_decl) = stream_read_tree (ib, data_in);
1402 : 81955 : unsigned block_leaf_count = streamer_read_uhwi (ib);
1403 : 138288 : while (block_leaf_count--)
1404 : 56333 : stream_read_tree (ib, data_in);
1405 : :
1406 : 81955 : if (!streamer_read_uhwi (ib))
1407 : : return;
1408 : :
1409 : 81892 : push_struct_function (fn_decl);
1410 : 81892 : fn = DECL_STRUCT_FUNCTION (fn_decl);
1411 : :
1412 : 81892 : gimple_register_cfg_hooks ();
1413 : :
1414 : 81892 : input_struct_function_base (fn, data_in, ib);
1415 : 81892 : input_cfg (ib_cfg, data_in, fn);
1416 : :
1417 : : /* Read all the SSA names. */
1418 : 81892 : input_ssa_names (ib, data_in, fn);
1419 : :
1420 : : /* Read the exception handling regions in the function. */
1421 : 81892 : input_eh_regions (ib, data_in, fn);
1422 : :
1423 : 81892 : gcc_assert (DECL_INITIAL (fn_decl));
1424 : 81892 : DECL_SAVED_TREE (fn_decl) = NULL_TREE;
1425 : :
1426 : : /* Read all the basic blocks. */
1427 : 81892 : tag = streamer_read_record_start (ib);
1428 : 814115 : while (tag)
1429 : : {
1430 : 732223 : input_bb (ib, tag, data_in, fn,
1431 : : node->count_materialization_scale);
1432 : 732223 : tag = streamer_read_record_start (ib);
1433 : : }
1434 : :
1435 : : /* Finalize gimple_location/gimple_block of stmts and phis. */
1436 : 81892 : data_in->location_cache.apply_location_cache ();
1437 : :
1438 : : /* Fix up the call statements that are mentioned in the callgraph
1439 : : edges. */
1440 : 81892 : set_gimple_stmt_max_uid (cfun, 0);
1441 : 814115 : FOR_ALL_BB_FN (bb, cfun)
1442 : : {
1443 : 732223 : gimple_stmt_iterator gsi;
1444 : 799736 : for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1445 : : {
1446 : 67513 : gimple *stmt = gsi_stmt (gsi);
1447 : 67513 : gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
1448 : : }
1449 : 2827475 : for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1450 : : {
1451 : 1363029 : gimple *stmt = gsi_stmt (gsi);
1452 : 1363029 : gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
1453 : : }
1454 : : }
1455 : 81892 : stmts = (gimple **) xcalloc (gimple_stmt_max_uid (fn), sizeof (gimple *));
1456 : 814115 : FOR_ALL_BB_FN (bb, cfun)
1457 : : {
1458 : 732223 : gimple_stmt_iterator bsi = gsi_start_phis (bb);
1459 : 799736 : while (!gsi_end_p (bsi))
1460 : : {
1461 : 67513 : gimple *stmt = gsi_stmt (bsi);
1462 : 67513 : gsi_next (&bsi);
1463 : 67513 : stmts[gimple_uid (stmt)] = stmt;
1464 : : }
1465 : 732223 : bsi = gsi_start_bb (bb);
1466 : 732223 : while (!gsi_end_p (bsi))
1467 : : {
1468 : 1363029 : gimple *stmt = gsi_stmt (bsi);
1469 : 1363029 : bool remove = false;
1470 : : /* If we're recompiling LTO objects with debug stmts but
1471 : : we're not supposed to have debug stmts, remove them now.
1472 : : We can't remove them earlier because this would cause uid
1473 : : mismatches in fixups, but we can do it at this point, as
1474 : : long as debug stmts don't require fixups.
1475 : : Similarly remove all IFN_*SAN_* internal calls */
1476 : 1363029 : if (!flag_wpa)
1477 : : {
1478 : 1271720 : if (is_gimple_debug (stmt)
1479 : 1271720 : && (gimple_debug_nonbind_marker_p (stmt)
1480 : 7552 : ? !MAY_HAVE_DEBUG_MARKER_STMTS
1481 : 5244 : : !MAY_HAVE_DEBUG_BIND_STMTS))
1482 : : remove = true;
1483 : : /* In case the linemap overflows locations can be dropped
1484 : : to zero. Thus do not keep nonsensical inline entry markers
1485 : : we'd later ICE on. */
1486 : 1271720 : tree block;
1487 : 1271720 : if (gimple_debug_inline_entry_p (stmt)
1488 : 12796 : && (((block = gimple_block (stmt))
1489 : 826 : && !inlined_function_outer_scope_p (block))
1490 : 826 : || !debug_inline_points))
1491 : : remove = true;
1492 : 1271720 : if (is_gimple_call (stmt)
1493 : 1271720 : && gimple_call_internal_p (stmt))
1494 : : {
1495 : 20847 : bool replace = false;
1496 : 20847 : switch (gimple_call_internal_fn (stmt))
1497 : : {
1498 : 229 : case IFN_UBSAN_NULL:
1499 : 229 : if ((flag_sanitize
1500 : 229 : & (SANITIZE_NULL | SANITIZE_ALIGNMENT)) == 0)
1501 : : replace = true;
1502 : : break;
1503 : 165 : case IFN_UBSAN_BOUNDS:
1504 : 165 : if ((flag_sanitize & SANITIZE_BOUNDS) == 0)
1505 : : replace = true;
1506 : : break;
1507 : 0 : case IFN_UBSAN_VPTR:
1508 : 0 : if ((flag_sanitize & SANITIZE_VPTR) == 0)
1509 : : replace = true;
1510 : : break;
1511 : 160 : case IFN_UBSAN_OBJECT_SIZE:
1512 : 160 : if ((flag_sanitize & SANITIZE_OBJECT_SIZE) == 0)
1513 : : replace = true;
1514 : : break;
1515 : 148 : case IFN_UBSAN_PTR:
1516 : 148 : if ((flag_sanitize & SANITIZE_POINTER_OVERFLOW) == 0)
1517 : : replace = true;
1518 : : break;
1519 : 730 : case IFN_ASAN_MARK:
1520 : 730 : if ((flag_sanitize & SANITIZE_ADDRESS) == 0)
1521 : : replace = true;
1522 : : break;
1523 : 0 : case IFN_TSAN_FUNC_EXIT:
1524 : 0 : if ((flag_sanitize & SANITIZE_THREAD) == 0)
1525 : : replace = true;
1526 : : break;
1527 : : default:
1528 : : break;
1529 : : }
1530 : : if (replace)
1531 : : {
1532 : 2 : gimple_call_set_internal_fn (as_a <gcall *> (stmt),
1533 : : IFN_NOP);
1534 : 2 : update_stmt (stmt);
1535 : : }
1536 : : }
1537 : : }
1538 : 1271720 : if (remove)
1539 : : {
1540 : 4 : gimple_stmt_iterator gsi = bsi;
1541 : 4 : gsi_next (&bsi);
1542 : 4 : unlink_stmt_vdef (stmt);
1543 : 4 : release_defs (stmt);
1544 : 4 : gsi_remove (&gsi, true);
1545 : : }
1546 : : else
1547 : : {
1548 : 1363025 : gsi_next (&bsi);
1549 : 1363025 : stmts[gimple_uid (stmt)] = stmt;
1550 : :
1551 : : /* Remember that the input function has begin stmt
1552 : : markers, so that we know to expect them when emitting
1553 : : debug info. */
1554 : 1363025 : if (!cfun->debug_nonbind_markers
1555 : 3459959 : && gimple_debug_nonbind_marker_p (stmt))
1556 : 1250 : cfun->debug_nonbind_markers = true;
1557 : : }
1558 : : }
1559 : : }
1560 : :
1561 : : /* Set the gimple body to the statement sequence in the entry
1562 : : basic block. FIXME lto, this is fairly hacky. The existence
1563 : : of a gimple body is used by the cgraph routines, but we should
1564 : : really use the presence of the CFG. */
1565 : 81892 : {
1566 : 81892 : edge_iterator ei = ei_start (ENTRY_BLOCK_PTR_FOR_FN (cfun)->succs);
1567 : 163784 : gimple_set_body (fn_decl, bb_seq (ei_edge (ei)->dest));
1568 : : }
1569 : :
1570 : 81892 : update_max_bb_count ();
1571 : 81892 : fixup_call_stmt_edges (node, stmts);
1572 : 81892 : execute_all_ipa_stmt_fixups (node, stmts);
1573 : :
1574 : 81892 : free_dominance_info (CDI_DOMINATORS);
1575 : 81892 : free_dominance_info (CDI_POST_DOMINATORS);
1576 : 81892 : free (stmts);
1577 : 81892 : pop_cfun ();
1578 : : }
1579 : :
1580 : : /* Read the body of function FN_DECL from DATA_IN using input block IB. */
1581 : :
1582 : : static void
1583 : 7110 : input_constructor (tree var, class data_in *data_in,
1584 : : class lto_input_block *ib)
1585 : : {
1586 : 7110 : DECL_INITIAL (var) = stream_read_tree (ib, data_in);
1587 : 7110 : }
1588 : :
1589 : :
1590 : : /* Read the body from DATA for function NODE and fill it in.
1591 : : FILE_DATA are the global decls and types. SECTION_TYPE is either
1592 : : LTO_section_function_body or LTO_section_static_initializer. If
1593 : : section type is LTO_section_function_body, FN must be the decl for
1594 : : that function. */
1595 : :
1596 : : static void
1597 : 89065 : lto_read_body_or_constructor (struct lto_file_decl_data *file_data, struct symtab_node *node,
1598 : : const char *data, enum lto_section_type section_type)
1599 : : {
1600 : 89065 : const struct lto_function_header *header;
1601 : 89065 : class data_in *data_in;
1602 : 89065 : int cfg_offset;
1603 : 89065 : int main_offset;
1604 : 89065 : int string_offset;
1605 : 89065 : tree fn_decl = node->decl;
1606 : :
1607 : 89065 : header = (const struct lto_function_header *) data;
1608 : 89065 : if (TREE_CODE (node->decl) == FUNCTION_DECL)
1609 : : {
1610 : 81955 : cfg_offset = sizeof (struct lto_function_header);
1611 : 81955 : main_offset = cfg_offset + header->cfg_size;
1612 : 81955 : string_offset = main_offset + header->main_size;
1613 : : }
1614 : : else
1615 : : {
1616 : 7110 : main_offset = sizeof (struct lto_function_header);
1617 : 7110 : string_offset = main_offset + header->main_size;
1618 : : }
1619 : :
1620 : 89065 : data_in = lto_data_in_create (file_data, data + string_offset,
1621 : 89065 : header->string_size, vNULL);
1622 : :
1623 : 89065 : if (section_type == LTO_section_function_body)
1624 : : {
1625 : 89065 : struct lto_in_decl_state *decl_state;
1626 : 89065 : unsigned from;
1627 : :
1628 : 89065 : gcc_checking_assert (node);
1629 : :
1630 : : /* Use the function's decl state. */
1631 : 89065 : decl_state = lto_get_function_in_decl_state (file_data, fn_decl);
1632 : 89065 : gcc_assert (decl_state);
1633 : 89065 : file_data->current_decl_state = decl_state;
1634 : :
1635 : :
1636 : : /* Set up the struct function. */
1637 : 89065 : from = data_in->reader_cache->nodes.length ();
1638 : 89065 : lto_input_block ib_main (data + main_offset, header->main_size,
1639 : 89065 : file_data);
1640 : 89065 : if (TREE_CODE (node->decl) == FUNCTION_DECL)
1641 : : {
1642 : 81955 : lto_input_block ib_cfg (data + cfg_offset, header->cfg_size,
1643 : 81955 : file_data);
1644 : 81955 : input_function (fn_decl, data_in, &ib_main, &ib_cfg,
1645 : : dyn_cast <cgraph_node *>(node));
1646 : : }
1647 : : else
1648 : 7110 : input_constructor (fn_decl, data_in, &ib_main);
1649 : 89065 : data_in->location_cache.apply_location_cache ();
1650 : : /* And fixup types we streamed locally. */
1651 : 89065 : {
1652 : 89065 : struct streamer_tree_cache_d *cache = data_in->reader_cache;
1653 : 89065 : unsigned len = cache->nodes.length ();
1654 : : unsigned i;
1655 : 2775762 : for (i = len; i-- > from;)
1656 : : {
1657 : 2686697 : tree t = streamer_tree_cache_get_tree (cache, i);
1658 : 2686697 : if (t == NULL_TREE)
1659 : 0 : continue;
1660 : :
1661 : 2686697 : if (TYPE_P (t))
1662 : : {
1663 : 1509 : gcc_assert (TYPE_STRUCTURAL_EQUALITY_P (t));
1664 : 1509 : if (type_with_alias_set_p (t)
1665 : 1509 : && canonical_type_used_p (t))
1666 : 496 : TYPE_CANONICAL (t) = TYPE_MAIN_VARIANT (t);
1667 : 1509 : if (TYPE_MAIN_VARIANT (t) != t)
1668 : : {
1669 : 109 : gcc_assert (TYPE_NEXT_VARIANT (t) == NULL_TREE);
1670 : 218 : TYPE_NEXT_VARIANT (t)
1671 : 109 : = TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t));
1672 : 109 : TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t)) = t;
1673 : : }
1674 : : }
1675 : : }
1676 : : }
1677 : :
1678 : : /* Restore decl state */
1679 : 89065 : file_data->current_decl_state = file_data->global_decl_state;
1680 : : }
1681 : :
1682 : 89065 : lto_data_in_delete (data_in);
1683 : 89065 : }
1684 : :
1685 : :
1686 : : /* Read the body of NODE using DATA. FILE_DATA holds the global
1687 : : decls and types. */
1688 : :
1689 : : void
1690 : 81955 : lto_input_function_body (struct lto_file_decl_data *file_data,
1691 : : struct cgraph_node *node, const char *data)
1692 : : {
1693 : 81955 : lto_read_body_or_constructor (file_data, node, data, LTO_section_function_body);
1694 : 81955 : }
1695 : :
1696 : : /* Read the body of NODE using DATA. FILE_DATA holds the global
1697 : : decls and types. */
1698 : :
1699 : : void
1700 : 7110 : lto_input_variable_constructor (struct lto_file_decl_data *file_data,
1701 : : struct varpool_node *node, const char *data)
1702 : : {
1703 : 7110 : lto_read_body_or_constructor (file_data, node, data, LTO_section_function_body);
1704 : 7110 : }
1705 : :
1706 : :
1707 : : /* Queue of acummulated decl -> DIE mappings. Similar to locations those
1708 : : are only applied to prevailing tree nodes during tree merging. */
1709 : : vec<dref_entry> dref_queue;
1710 : :
1711 : : /* Read the physical representation of a tree node EXPR from
1712 : : input block IB using the per-file context in DATA_IN. */
1713 : :
1714 : : static void
1715 : 4164727 : lto_read_tree_1 (class lto_input_block *ib, class data_in *data_in, tree expr)
1716 : : {
1717 : : /* Read all the bitfield values in EXPR. Note that for LTO, we
1718 : : only write language-independent bitfields, so no more unpacking is
1719 : : needed. */
1720 : 4164727 : streamer_read_tree_bitfields (ib, data_in, expr);
1721 : :
1722 : : /* Read all the pointer fields in EXPR. */
1723 : 4164727 : streamer_read_tree_body (ib, data_in, expr);
1724 : :
1725 : : /* Read any LTO-specific data not read by the tree streamer. Do not use
1726 : : stream_read_tree here since that flushes the dref_queue in mids of
1727 : : SCC reading. */
1728 : 4164727 : if (DECL_P (expr)
1729 : 720130 : && TREE_CODE (expr) != FUNCTION_DECL
1730 : 528887 : && TREE_CODE (expr) != TRANSLATION_UNIT_DECL)
1731 : 1010580 : DECL_INITIAL (expr)
1732 : 1010580 : = lto_input_tree_1 (ib, data_in, streamer_read_record_start (ib), 0);
1733 : :
1734 : : /* Stream references to early generated DIEs. Keep in sync with the
1735 : : trees handled in dwarf2out_register_external_die. */
1736 : 4164727 : if ((DECL_P (expr)
1737 : : && TREE_CODE (expr) != FIELD_DECL
1738 : : && TREE_CODE (expr) != DEBUG_EXPR_DECL
1739 : : && TREE_CODE (expr) != TYPE_DECL)
1740 : 3531811 : || TREE_CODE (expr) == BLOCK)
1741 : : {
1742 : 896977 : const char *str = streamer_read_string (data_in, ib);
1743 : 896977 : if (str)
1744 : : {
1745 : 41515 : unsigned HOST_WIDE_INT off = streamer_read_uhwi (ib);
1746 : 41515 : dref_entry e = { expr, str, off };
1747 : 41515 : dref_queue.safe_push (e);
1748 : : }
1749 : : /* When there's no early DIE to refer to but dwarf2out set up
1750 : : things in a way to expect that fixup. This tends to happen
1751 : : with -g1, see for example PR113488. */
1752 : 855462 : else if (DECL_P (expr) && DECL_ABSTRACT_ORIGIN (expr) == expr)
1753 : 0 : DECL_ABSTRACT_ORIGIN (expr) = NULL_TREE;
1754 : : }
1755 : 4164727 : }
1756 : :
1757 : : /* Read the physical representation of a tree node with tag TAG from
1758 : : input block IB using the per-file context in DATA_IN. */
1759 : :
1760 : : static tree
1761 : 3998750 : lto_read_tree (class lto_input_block *ib, class data_in *data_in,
1762 : : enum LTO_tags tag, hashval_t hash)
1763 : : {
1764 : : /* Instantiate a new tree node. */
1765 : 3998750 : tree result = streamer_alloc_tree (ib, data_in, tag);
1766 : :
1767 : : /* Enter RESULT in the reader cache. This will make RESULT
1768 : : available so that circular references in the rest of the tree
1769 : : structure can be resolved in subsequent calls to stream_read_tree. */
1770 : 3998750 : streamer_tree_cache_append (data_in->reader_cache, result, hash);
1771 : :
1772 : 3998750 : lto_read_tree_1 (ib, data_in, result);
1773 : :
1774 : 3998750 : return result;
1775 : : }
1776 : :
1777 : :
1778 : : /* Populate the reader cache with trees materialized from the SCC
1779 : : following in the IB, DATA_IN stream.
1780 : : If SHARED_SCC is true we input LTO_tree_scc. */
1781 : :
1782 : : hashval_t
1783 : 1965851 : lto_input_scc (class lto_input_block *ib, class data_in *data_in,
1784 : : unsigned *len, unsigned *entry_len, bool shared_scc)
1785 : : {
1786 : 1965851 : unsigned size = streamer_read_uhwi (ib);
1787 : 1965851 : hashval_t scc_hash = 0;
1788 : 1965851 : unsigned scc_entry_len = 1;
1789 : :
1790 : 1965851 : if (shared_scc)
1791 : : {
1792 : 703608 : if (size & 1)
1793 : 0 : scc_entry_len = streamer_read_uhwi (ib);
1794 : 703608 : size /= 2;
1795 : 703608 : scc_hash = streamer_read_uhwi (ib);
1796 : : }
1797 : :
1798 : 1965851 : if (size == 1)
1799 : : {
1800 : 1924442 : enum LTO_tags tag = streamer_read_record_start (ib);
1801 : 1924442 : lto_input_tree_1 (ib, data_in, tag, scc_hash);
1802 : : }
1803 : : else
1804 : : {
1805 : 41409 : unsigned int first = data_in->reader_cache->nodes.length ();
1806 : 41409 : tree result;
1807 : :
1808 : : /* Materialize size trees by reading their headers. */
1809 : 207386 : for (unsigned i = 0; i < size; ++i)
1810 : : {
1811 : 165977 : enum LTO_tags tag = streamer_read_record_start (ib);
1812 : 165977 : if (tag == LTO_null
1813 : 165977 : || tag == LTO_global_stream_ref
1814 : 165977 : || tag == LTO_tree_pickle_reference
1815 : 165977 : || tag == LTO_integer_cst
1816 : : || tag == LTO_tree_scc
1817 : 165977 : || tag == LTO_trees)
1818 : 0 : gcc_unreachable ();
1819 : :
1820 : 165977 : result = streamer_alloc_tree (ib, data_in, tag);
1821 : 165977 : streamer_tree_cache_append (data_in->reader_cache, result, 0);
1822 : : }
1823 : :
1824 : : /* Read the tree bitpacks and references. */
1825 : 207386 : for (unsigned i = 0; i < size; ++i)
1826 : : {
1827 : 165977 : result = streamer_tree_cache_get_tree (data_in->reader_cache,
1828 : : first + i);
1829 : 165977 : lto_read_tree_1 (ib, data_in, result);
1830 : : }
1831 : : }
1832 : :
1833 : 1965851 : *len = size;
1834 : 1965851 : *entry_len = scc_entry_len;
1835 : 1965851 : return scc_hash;
1836 : : }
1837 : :
1838 : : /* Read reference to tree from IB and DATA_IN.
1839 : : This is used for streaming tree bodies where we know that
1840 : : the tree is already in cache or is indexable and
1841 : : must be matched with stream_write_tree_ref. */
1842 : :
1843 : : tree
1844 : 18640530 : stream_read_tree_ref (lto_input_block *ib, data_in *data_in)
1845 : : {
1846 : 18640530 : int ix = streamer_read_hwi (ib);
1847 : 18640530 : if (!ix)
1848 : : return NULL_TREE;
1849 : 11463174 : if (ix > 0)
1850 : 8624939 : return streamer_tree_cache_get_tree (data_in->reader_cache, ix - 1);
1851 : :
1852 : 2838235 : ix = -ix - 1;
1853 : 2838235 : int id = ix & 1;
1854 : 2838235 : ix /= 2;
1855 : :
1856 : 2838235 : tree ret;
1857 : 2838235 : if (!id)
1858 : 2687095 : ret = (*data_in->file_data->current_decl_state
1859 : 2687095 : ->streams[LTO_DECL_STREAM])[ix];
1860 : : else
1861 : 151140 : ret = (*SSANAMES (cfun))[ix];
1862 : : return ret;
1863 : : }
1864 : :
1865 : : /* Read a tree from input block IB using the per-file context in
1866 : : DATA_IN. This context is used, for example, to resolve references
1867 : : to previously read nodes. */
1868 : :
1869 : : tree
1870 : 12218925 : lto_input_tree_1 (class lto_input_block *ib, class data_in *data_in,
1871 : : enum LTO_tags tag, hashval_t hash)
1872 : : {
1873 : 12218925 : tree result;
1874 : :
1875 : 12218925 : gcc_assert ((unsigned) tag < (unsigned) LTO_NUM_TAGS);
1876 : :
1877 : 12218925 : if (tag == LTO_null)
1878 : : result = NULL_TREE;
1879 : : else if (tag == LTO_global_stream_ref || tag == LTO_ssa_name_ref)
1880 : : {
1881 : : /* If TAG is a reference to an indexable tree, the next value
1882 : : in IB is the index into the table where we expect to find
1883 : : that tree. */
1884 : 3885267 : result = lto_input_tree_ref (ib, data_in, cfun, tag);
1885 : : }
1886 : : else if (tag == LTO_tree_pickle_reference)
1887 : : {
1888 : : /* If TAG is a reference to a previously read tree, look it up in
1889 : : the reader cache. */
1890 : 1575318 : result = streamer_get_pickled_tree (ib, data_in);
1891 : : }
1892 : : else if (tag == LTO_integer_cst)
1893 : : {
1894 : : /* For shared integer constants in singletons we can use the
1895 : : existing tree integer constant merging code. */
1896 : 620217 : tree type = stream_read_tree_ref (ib, data_in);
1897 : 620217 : unsigned HOST_WIDE_INT len = streamer_read_uhwi (ib);
1898 : 620217 : unsigned HOST_WIDE_INT i;
1899 : 620217 : HOST_WIDE_INT abuf[WIDE_INT_MAX_INL_ELTS], *a = abuf;
1900 : :
1901 : 620217 : if (UNLIKELY (len > WIDE_INT_MAX_INL_ELTS))
1902 : 0 : a = XALLOCAVEC (HOST_WIDE_INT, len);
1903 : 1245680 : for (i = 0; i < len; i++)
1904 : 625463 : a[i] = streamer_read_hwi (ib);
1905 : 620217 : gcc_assert (TYPE_PRECISION (type) <= WIDE_INT_MAX_PRECISION);
1906 : 620217 : result
1907 : 620217 : = wide_int_to_tree (type,
1908 : 620217 : wide_int::from_array (a, len,
1909 : 620217 : TYPE_PRECISION (type)));
1910 : 620217 : streamer_tree_cache_append (data_in->reader_cache, result, hash);
1911 : : }
1912 : : else if (tag == LTO_tree_scc || tag == LTO_trees)
1913 : 0 : gcc_unreachable ();
1914 : : else
1915 : : {
1916 : : /* Otherwise, materialize a new node from IB. */
1917 : 3998750 : result = lto_read_tree (ib, data_in, tag, hash);
1918 : : }
1919 : :
1920 : 12218925 : return result;
1921 : : }
1922 : :
1923 : : tree
1924 : 8654754 : lto_input_tree (class lto_input_block *ib, class data_in *data_in)
1925 : : {
1926 : 8654754 : enum LTO_tags tag;
1927 : :
1928 : : /* Input pickled trees needed to stream in the reference. */
1929 : 9903845 : while ((tag = streamer_read_record_start (ib)) == LTO_trees)
1930 : : {
1931 : 1249091 : unsigned len, entry_len;
1932 : 1249091 : lto_input_scc (ib, data_in, &len, &entry_len, false);
1933 : :
1934 : : /* Register DECLs with the debuginfo machinery. */
1935 : 2600457 : while (!dref_queue.is_empty ())
1936 : : {
1937 : 8693 : dref_entry e = dref_queue.pop ();
1938 : 8693 : debug_hooks->register_external_die (e.decl, e.sym, e.off);
1939 : : }
1940 : : }
1941 : 8654754 : tree t = lto_input_tree_1 (ib, data_in, tag, 0);
1942 : :
1943 : 8654754 : if (!dref_queue.is_empty ())
1944 : : {
1945 : 9150 : dref_entry e = dref_queue.pop ();
1946 : 9150 : debug_hooks->register_external_die (e.decl, e.sym, e.off);
1947 : 9150 : gcc_checking_assert (dref_queue.is_empty ());
1948 : : }
1949 : 8654754 : return t;
1950 : : }
1951 : :
1952 : :
1953 : : /* Input toplevel asms. */
1954 : :
1955 : : void
1956 : 23031 : lto_input_toplevel_asms (struct lto_file_decl_data *file_data, int order_base)
1957 : : {
1958 : 23031 : size_t len;
1959 : 23031 : const char *data
1960 : 23031 : = lto_get_summary_section_data (file_data, LTO_section_asm, &len);
1961 : 23031 : const struct lto_simple_header_with_strings *header
1962 : : = (const struct lto_simple_header_with_strings *) data;
1963 : 23031 : int string_offset;
1964 : 23031 : class data_in *data_in;
1965 : 23031 : tree str;
1966 : :
1967 : 23031 : if (! data)
1968 : 22967 : return;
1969 : :
1970 : 64 : string_offset = sizeof (*header) + header->main_size;
1971 : :
1972 : 64 : lto_input_block ib (data + sizeof (*header), header->main_size,
1973 : 64 : file_data);
1974 : :
1975 : 64 : data_in = lto_data_in_create (file_data, data + string_offset,
1976 : 64 : header->string_size, vNULL);
1977 : :
1978 : 192 : while ((str = streamer_read_string_cst (data_in, &ib)))
1979 : : {
1980 : 64 : asm_node *node = symtab->finalize_toplevel_asm (str);
1981 : 64 : node->order = streamer_read_hwi (&ib) + order_base;
1982 : 64 : if (node->order >= symtab->order)
1983 : 1 : symtab->order = node->order + 1;
1984 : : }
1985 : :
1986 : 64 : lto_data_in_delete (data_in);
1987 : :
1988 : 64 : lto_free_section_data (file_data, LTO_section_asm, NULL, data, len);
1989 : : }
1990 : :
1991 : :
1992 : : /* Input mode table. */
1993 : :
1994 : : void
1995 : 0 : lto_input_mode_table (struct lto_file_decl_data *file_data)
1996 : : {
1997 : 0 : size_t len;
1998 : 0 : const char *data
1999 : 0 : = lto_get_summary_section_data (file_data, LTO_section_mode_table, &len);
2000 : 0 : if (! data)
2001 : 0 : internal_error ("cannot read LTO mode table from %s",
2002 : : file_data->file_name);
2003 : :
2004 : 0 : const struct lto_simple_header_with_strings *header
2005 : : = (const struct lto_simple_header_with_strings *) data;
2006 : 0 : int string_offset;
2007 : 0 : class data_in *data_in;
2008 : 0 : string_offset = sizeof (*header) + header->main_size;
2009 : :
2010 : 0 : lto_input_block ib (data + sizeof (*header), header->main_size, NULL);
2011 : 0 : data_in = lto_data_in_create (file_data, data + string_offset,
2012 : 0 : header->string_size, vNULL);
2013 : 0 : bitpack_d bp = streamer_read_bitpack (&ib);
2014 : :
2015 : 0 : unsigned mode_bits = bp_unpack_value (&bp, 5);
2016 : 0 : unsigned char *table = ggc_cleared_vec_alloc<unsigned char> (1 << mode_bits);
2017 : :
2018 : 0 : file_data->mode_table = table;
2019 : 0 : file_data->mode_bits = mode_bits;
2020 : :
2021 : 0 : table[VOIDmode] = VOIDmode;
2022 : 0 : table[BLKmode] = BLKmode;
2023 : 0 : unsigned int m;
2024 : 0 : while ((m = bp_unpack_value (&bp, mode_bits)) != VOIDmode)
2025 : : {
2026 : 0 : enum mode_class mclass
2027 : 0 : = bp_unpack_enum (&bp, mode_class, MAX_MODE_CLASS);
2028 : 0 : poly_uint16 size = bp_unpack_poly_value (&bp, 16);
2029 : 0 : poly_uint16 prec = bp_unpack_poly_value (&bp, 16);
2030 : 0 : machine_mode inner = (machine_mode) bp_unpack_value (&bp, mode_bits);
2031 : 0 : poly_uint16 nunits = bp_unpack_poly_value (&bp, 16);
2032 : 0 : unsigned int ibit = 0, fbit = 0;
2033 : 0 : unsigned int real_fmt_len = 0;
2034 : 0 : const char *real_fmt_name = NULL;
2035 : 0 : switch (mclass)
2036 : : {
2037 : 0 : case MODE_FRACT:
2038 : 0 : case MODE_UFRACT:
2039 : 0 : case MODE_ACCUM:
2040 : 0 : case MODE_UACCUM:
2041 : 0 : ibit = bp_unpack_value (&bp, 8);
2042 : 0 : fbit = bp_unpack_value (&bp, 8);
2043 : 0 : break;
2044 : 0 : case MODE_FLOAT:
2045 : 0 : case MODE_DECIMAL_FLOAT:
2046 : 0 : real_fmt_name = bp_unpack_indexed_string (data_in, &bp,
2047 : : &real_fmt_len);
2048 : 0 : break;
2049 : : default:
2050 : : break;
2051 : : }
2052 : : /* First search just the GET_CLASS_NARROWEST_MODE to wider modes,
2053 : : if not found, fallback to all modes. */
2054 : 0 : int pass;
2055 : 0 : for (pass = 0; pass < 2; pass++)
2056 : 0 : for (machine_mode mr = pass ? VOIDmode
2057 : 0 : : GET_CLASS_NARROWEST_MODE (mclass);
2058 : 0 : pass ? mr < MAX_MACHINE_MODE : mr != VOIDmode;
2059 : 0 : pass ? mr = (machine_mode) (mr + 1)
2060 : 0 : : mr = GET_MODE_WIDER_MODE (mr).else_void ())
2061 : 0 : if (GET_MODE_CLASS (mr) != mclass
2062 : 0 : || maybe_ne (GET_MODE_SIZE (mr), size)
2063 : 0 : || maybe_ne (GET_MODE_PRECISION (mr), prec)
2064 : 0 : || (inner == m
2065 : 0 : ? GET_MODE_INNER (mr) != mr
2066 : 0 : : GET_MODE_INNER (mr) != table[(int) inner])
2067 : 0 : || GET_MODE_IBIT (mr) != ibit
2068 : 0 : || GET_MODE_FBIT (mr) != fbit
2069 : 0 : || maybe_ne (GET_MODE_NUNITS (mr), nunits))
2070 : 0 : continue;
2071 : 0 : else if ((mclass == MODE_FLOAT || mclass == MODE_DECIMAL_FLOAT)
2072 : 0 : && strcmp (REAL_MODE_FORMAT (mr)->name, real_fmt_name) != 0)
2073 : 0 : continue;
2074 : : else
2075 : : {
2076 : 0 : table[m] = mr;
2077 : 0 : pass = 2;
2078 : 0 : break;
2079 : : }
2080 : 0 : unsigned int mname_len;
2081 : 0 : const char *mname = bp_unpack_indexed_string (data_in, &bp, &mname_len);
2082 : 0 : if (pass == 2)
2083 : : {
2084 : 0 : switch (mclass)
2085 : : {
2086 : 0 : case MODE_VECTOR_BOOL:
2087 : 0 : case MODE_VECTOR_INT:
2088 : 0 : case MODE_VECTOR_FLOAT:
2089 : 0 : case MODE_VECTOR_FRACT:
2090 : 0 : case MODE_VECTOR_UFRACT:
2091 : 0 : case MODE_VECTOR_ACCUM:
2092 : 0 : case MODE_VECTOR_UACCUM:
2093 : : /* For unsupported vector modes just use BLKmode,
2094 : : if the scalar mode is supported. */
2095 : 0 : if (table[(int) inner] != VOIDmode)
2096 : : {
2097 : 0 : table[m] = BLKmode;
2098 : 0 : break;
2099 : : }
2100 : : /* FALLTHRU */
2101 : 0 : default:
2102 : : /* This is only used for offloading-target compilations and
2103 : : is a user-facing error. Give a better error message for
2104 : : the common modes; see also mode-classes.def. */
2105 : 0 : if (mclass == MODE_FLOAT)
2106 : 0 : fatal_error (UNKNOWN_LOCATION,
2107 : : "%s - %u-bit-precision floating-point numbers "
2108 : : "unsupported (mode %qs)", TARGET_MACHINE,
2109 : 0 : prec.to_constant (), mname);
2110 : 0 : else if (mclass == MODE_DECIMAL_FLOAT)
2111 : 0 : fatal_error (UNKNOWN_LOCATION,
2112 : : "%s - %u-bit-precision decimal floating-point "
2113 : : "numbers unsupported (mode %qs)", TARGET_MACHINE,
2114 : 0 : prec.to_constant (), mname);
2115 : 0 : else if (mclass == MODE_COMPLEX_FLOAT)
2116 : 0 : fatal_error (UNKNOWN_LOCATION,
2117 : : "%s - %u-bit-precision complex floating-point "
2118 : : "numbers unsupported (mode %qs)", TARGET_MACHINE,
2119 : 0 : prec.to_constant (), mname);
2120 : 0 : else if (mclass == MODE_INT)
2121 : 0 : fatal_error (UNKNOWN_LOCATION,
2122 : : "%s - %u-bit integer numbers unsupported (mode "
2123 : 0 : "%qs)", TARGET_MACHINE, prec.to_constant (), mname);
2124 : : else
2125 : 0 : fatal_error (UNKNOWN_LOCATION, "%s - unsupported mode %qs",
2126 : : TARGET_MACHINE, mname);
2127 : 0 : break;
2128 : : }
2129 : : }
2130 : : }
2131 : 0 : lto_data_in_delete (data_in);
2132 : :
2133 : 0 : lto_free_section_data (file_data, LTO_section_mode_table, NULL, data, len);
2134 : 0 : }
2135 : :
2136 : :
2137 : : /* Initialization for the LTO reader. */
2138 : :
2139 : : void
2140 : 22028 : lto_reader_init (void)
2141 : : {
2142 : 22028 : lto_streamer_init ();
2143 : 22028 : file_name_hash_table
2144 : 22028 : = new hash_table<string_slot_hasher> (37);
2145 : 44056 : string_slot_allocator = new object_allocator <struct string_slot>
2146 : 22028 : ("line map file name hash");
2147 : 22028 : gcc_obstack_init (&file_name_obstack);
2148 : 22028 : }
2149 : :
2150 : : /* Free hash table used to stream in location file names. */
2151 : :
2152 : : void
2153 : 8797 : lto_free_file_name_hash (void)
2154 : : {
2155 : 8797 : delete file_name_hash_table;
2156 : 8797 : file_name_hash_table = NULL;
2157 : 17594 : delete string_slot_allocator;
2158 : 8797 : string_slot_allocator = NULL;
2159 : 8797 : delete path_name_pair_hash_table;
2160 : 8797 : path_name_pair_hash_table = NULL;
2161 : 8797 : delete string_pair_map_allocator;
2162 : 8797 : string_pair_map_allocator = NULL;
2163 : : /* file_name_obstack must stay allocated since it is referred to by
2164 : : line map table. */
2165 : 8797 : }
2166 : :
2167 : :
2168 : : /* Create a new data_in object for FILE_DATA. STRINGS is the string
2169 : : table to use with LEN strings. RESOLUTIONS is the vector of linker
2170 : : resolutions (NULL if not using a linker plugin). */
2171 : :
2172 : : class data_in *
2173 : 201125 : lto_data_in_create (struct lto_file_decl_data *file_data, const char *strings,
2174 : : unsigned len,
2175 : : vec<ld_plugin_symbol_resolution_t> resolutions)
2176 : : {
2177 : 201125 : class data_in *data_in = new (class data_in);
2178 : 201125 : data_in->file_data = file_data;
2179 : 201125 : data_in->strings = strings;
2180 : 201125 : data_in->strings_len = len;
2181 : 201125 : data_in->globals_resolution = resolutions;
2182 : 201125 : data_in->reader_cache = streamer_tree_cache_create (false, false, true);
2183 : 201125 : return data_in;
2184 : : }
2185 : :
2186 : :
2187 : : /* Remove DATA_IN. */
2188 : :
2189 : : void
2190 : 201125 : lto_data_in_delete (class data_in *data_in)
2191 : : {
2192 : 201125 : data_in->globals_resolution.release ();
2193 : 201125 : streamer_tree_cache_delete (data_in->reader_cache);
2194 : 201125 : delete data_in;
2195 : 201125 : }
|