LCOV - code coverage report
Current view: top level - gcc - lto-streamer-in.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 75.8 % 1095 830
Test Date: 2024-03-23 14:05:01 Functions: 87.2 % 47 41
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: - 0 0

             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 : }
        

Generated by: LCOV version 2.0-1

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.