LCOV - code coverage report
Current view: top level - gcc - lto-streamer-in.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 757 898 84.3 %
Date: 2020-03-28 11:57:23 Functions: 37 39 94.9 %
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-2020 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                 :            : 
      47                 :            : /* Allocator used to hold string slot entries for line map streaming.  */
      48                 :            : static struct object_allocator<struct string_slot> *string_slot_allocator;
      49                 :            : 
      50                 :            : /* The table to hold the file names.  */
      51                 :            : static hash_table<string_slot_hasher> *file_name_hash_table;
      52                 :            : 
      53                 :            : /* This obstack holds file names used in locators. Line map datastructures
      54                 :            :    points here and thus it needs to be kept allocated as long as linemaps
      55                 :            :    exists.  */
      56                 :            : static struct obstack file_name_obstack;
      57                 :            : 
      58                 :            : 
      59                 :            : /* Check that tag ACTUAL has one of the given values.  NUM_TAGS is the
      60                 :            :    number of valid tag values to check.  */
      61                 :            : 
      62                 :            : void
      63                 :     967861 : lto_tag_check_set (enum LTO_tags actual, int ntags, ...)
      64                 :            : {
      65                 :     967861 :   va_list ap;
      66                 :     967861 :   int i;
      67                 :            : 
      68                 :     967861 :   va_start (ap, ntags);
      69                 :    1931720 :   for (i = 0; i < ntags; i++)
      70                 :    1931720 :     if ((unsigned) actual == va_arg (ap, unsigned))
      71                 :            :       {
      72                 :     967861 :         va_end (ap);
      73                 :     967861 :         return;
      74                 :            :       }
      75                 :            : 
      76                 :          0 :   va_end (ap);
      77                 :          0 :   internal_error ("bytecode stream: unexpected tag %s", lto_tag_name (actual));
      78                 :            : }
      79                 :            : 
      80                 :            : 
      81                 :            : /* Read LENGTH bytes from STREAM to ADDR.  */
      82                 :            : 
      83                 :            : void
      84                 :          0 : lto_input_data_block (class lto_input_block *ib, void *addr, size_t length)
      85                 :            : {
      86                 :          0 :   size_t i;
      87                 :          0 :   unsigned char *const buffer = (unsigned char *) addr;
      88                 :            : 
      89                 :          0 :   for (i = 0; i < length; i++)
      90                 :          0 :     buffer[i] = streamer_read_uchar (ib);
      91                 :          0 : }
      92                 :            : 
      93                 :            : 
      94                 :            : /* Lookup STRING in file_name_hash_table.  If found, return the existing
      95                 :            :    string, otherwise insert STRING as the canonical version.  */
      96                 :            : 
      97                 :            : static const char *
      98                 :     136481 : canon_file_name (const char *string)
      99                 :            : {
     100                 :     136481 :   string_slot **slot;
     101                 :     136481 :   struct string_slot s_slot;
     102                 :     136481 :   size_t len = strlen (string);
     103                 :            : 
     104                 :     136481 :   s_slot.s = string;
     105                 :     136481 :   s_slot.len = len;
     106                 :            : 
     107                 :     136481 :   slot = file_name_hash_table->find_slot (&s_slot, INSERT);
     108                 :     136481 :   if (*slot == NULL)
     109                 :            :     {
     110                 :      24540 :       char *saved_string;
     111                 :      24540 :       struct string_slot *new_slot;
     112                 :            : 
     113                 :      24540 :       saved_string = XOBNEWVEC (&file_name_obstack, char, len + 1);
     114                 :      24540 :       new_slot = string_slot_allocator->allocate ();
     115                 :      24540 :       memcpy (saved_string, string, len + 1);
     116                 :      24540 :       new_slot->s = saved_string;
     117                 :      24540 :       new_slot->len = len;
     118                 :      24540 :       *slot = new_slot;
     119                 :      24540 :       return saved_string;
     120                 :            :     }
     121                 :            :   else
     122                 :            :     {
     123                 :     111941 :       struct string_slot *old_slot = *slot;
     124                 :     111941 :       return old_slot->s;
     125                 :            :     }
     126                 :            : }
     127                 :            : 
     128                 :            : /* Pointer to currently alive instance of lto_location_cache.  */
     129                 :            : 
     130                 :            : lto_location_cache *lto_location_cache::current_cache;
     131                 :            : 
     132                 :            : /* Sort locations in source order. Start with file from last application.  */
     133                 :            : 
     134                 :            : int
     135                 :    7260100 : lto_location_cache::cmp_loc (const void *pa, const void *pb)
     136                 :            : {
     137                 :    7260100 :   const cached_location *a = ((const cached_location *)pa);
     138                 :    7260100 :   const cached_location *b = ((const cached_location *)pb);
     139                 :    7260100 :   const char *current_file = current_cache->current_file;
     140                 :    7260100 :   int current_line = current_cache->current_line;
     141                 :            : 
     142                 :    7260100 :   if (a->file == current_file && b->file != current_file)
     143                 :            :     return -1;
     144                 :    7189480 :   if (a->file != current_file && b->file == current_file)
     145                 :            :     return 1;
     146                 :    7124080 :   if (a->file == current_file && b->file == current_file)
     147                 :            :     {
     148                 :     547921 :       if (a->line == current_line && b->line != current_line)
     149                 :            :         return -1;
     150                 :     509082 :       if (a->line != current_line && b->line == current_line)
     151                 :            :         return 1;
     152                 :            :     }
     153                 :    7048540 :   if (a->file != b->file)
     154                 :    1105540 :     return strcmp (a->file, b->file);
     155                 :    5943000 :   if (a->sysp != b->sysp)
     156                 :          0 :     return a->sysp ? 1 : -1;
     157                 :    5943000 :   if (a->line != b->line)
     158                 :    3856040 :     return a->line - b->line;
     159                 :    2086960 :   return a->col - b->col;
     160                 :            : }
     161                 :            : 
     162                 :            : /* Apply all changes in location cache.  Add locations into linemap and patch
     163                 :            :    trees.  */
     164                 :            : 
     165                 :            : bool
     166                 :    1490760 : lto_location_cache::apply_location_cache ()
     167                 :            : {
     168                 :    1490760 :   static const char *prev_file;
     169                 :    1490760 :   if (!loc_cache.length ())
     170                 :            :     return false;
     171                 :     404727 :   if (loc_cache.length () > 1)
     172                 :     123103 :     loc_cache.qsort (cmp_loc);
     173                 :            : 
     174                 :    2614770 :   for (unsigned int i = 0; i < loc_cache.length (); i++)
     175                 :            :     {
     176                 :     902656 :       struct cached_location loc = loc_cache[i];
     177                 :            : 
     178                 :     902656 :       if (current_file != loc.file)
     179                 :     121356 :         linemap_add (line_table, prev_file ? LC_RENAME : LC_ENTER,
     180                 :     121356 :                      loc.sysp, loc.file, loc.line);
     181                 :     781300 :       else if (current_line != loc.line)
     182                 :            :         {
     183                 :     323589 :           int max = loc.col;
     184                 :            : 
     185                 :     424558 :           for (unsigned int j = i + 1; j < loc_cache.length (); j++)
     186                 :     203994 :             if (loc.file != loc_cache[j].file
     187                 :     203994 :                 || loc.line != loc_cache[j].line)
     188                 :            :               break;
     189                 :     100969 :             else if (max < loc_cache[j].col)
     190                 :            :               max = loc_cache[j].col;
     191                 :     323589 :           linemap_line_start (line_table, loc.line, max + 1);
     192                 :            :         }
     193                 :     902656 :       gcc_assert (*loc.loc == BUILTINS_LOCATION + 1);
     194                 :     902656 :       if (current_file == loc.file && current_line == loc.line
     195                 :     781300 :           && current_col == loc.col)
     196                 :     282734 :         *loc.loc = current_loc;
     197                 :            :       else
     198                 :     619922 :         current_loc = *loc.loc = linemap_position_for_column (line_table,
     199                 :            :                                                               loc.col);
     200                 :     902656 :       current_line = loc.line;
     201                 :     902656 :       prev_file = current_file = loc.file;
     202                 :     902656 :       current_col = loc.col;
     203                 :            :     }
     204                 :     404727 :   loc_cache.truncate (0);
     205                 :     404727 :   accepted_length = 0;
     206                 :     404727 :   return true;
     207                 :            : }
     208                 :            : 
     209                 :            : /* Tree merging did not suceed; mark all changes in the cache as accepted.  */
     210                 :            : 
     211                 :            : void
     212                 :     786261 : lto_location_cache::accept_location_cache ()
     213                 :            : {
     214                 :     786261 :   gcc_assert (current_cache == this);
     215                 :     786261 :   accepted_length = loc_cache.length ();
     216                 :     786261 : }
     217                 :            : 
     218                 :            : /* Tree merging did suceed; throw away recent changes.  */
     219                 :            : 
     220                 :            : void
     221                 :     122222 : lto_location_cache::revert_location_cache ()
     222                 :            : {
     223                 :     122222 :   loc_cache.truncate (accepted_length);
     224                 :     122222 : }
     225                 :            : 
     226                 :            : /* Read a location bitpack from input block IB and either update *LOC directly
     227                 :            :    or add it to the location cache.
     228                 :            :    It is neccesary to call apply_location_cache to get *LOC updated.  */
     229                 :            : 
     230                 :            : void
     231                 :    2632000 : lto_location_cache::input_location (location_t *loc, struct bitpack_d *bp,
     232                 :            :                                     class data_in *data_in)
     233                 :            : {
     234                 :    2632000 :   static const char *stream_file;
     235                 :    2632000 :   static int stream_line;
     236                 :    2632000 :   static int stream_col;
     237                 :    2632000 :   static bool stream_sysp;
     238                 :    2632000 :   bool file_change, line_change, column_change;
     239                 :            : 
     240                 :    2632000 :   gcc_assert (current_cache == this);
     241                 :            : 
     242                 :    2632000 :   *loc = bp_unpack_int_in_range (bp, "location", 0, RESERVED_LOCATION_COUNT);
     243                 :            : 
     244                 :    2632000 :   if (*loc < RESERVED_LOCATION_COUNT)
     245                 :    1727900 :     return;
     246                 :            : 
     247                 :            :   /* Keep value RESERVED_LOCATION_COUNT in *loc as linemap lookups will
     248                 :            :      ICE on it.  */
     249                 :            : 
     250                 :    1808610 :   file_change = bp_unpack_value (bp, 1);
     251                 :    1808610 :   line_change = bp_unpack_value (bp, 1);
     252                 :    1808610 :   column_change = bp_unpack_value (bp, 1);
     253                 :            : 
     254                 :    1808610 :   if (file_change)
     255                 :            :     {
     256                 :     136481 :       stream_file = canon_file_name (bp_unpack_string (data_in, bp));
     257                 :     136481 :       stream_sysp = bp_unpack_value (bp, 1);
     258                 :            :     }
     259                 :            : 
     260                 :    1808610 :   if (line_change)
     261                 :     468948 :     stream_line = bp_unpack_var_len_unsigned (bp);
     262                 :            : 
     263                 :    1808610 :   if (column_change)
     264                 :     547410 :     stream_col = bp_unpack_var_len_unsigned (bp);
     265                 :            : 
     266                 :            :   /* This optimization saves location cache operations druing gimple
     267                 :            :      streaming.  */
     268                 :            :      
     269                 :    1808610 :   if (current_file == stream_file && current_line == stream_line
     270                 :    1057660 :       && current_col == stream_col && current_sysp == stream_sysp)
     271                 :            :     {
     272                 :     904515 :       *loc = current_loc;
     273                 :     904515 :       return;
     274                 :            :     }
     275                 :            : 
     276                 :     904096 :   struct cached_location entry
     277                 :     904096 :     = {stream_file, loc, stream_line, stream_col, stream_sysp};
     278                 :     904096 :   loc_cache.safe_push (entry);
     279                 :            : }
     280                 :            : 
     281                 :            : /* Read a location bitpack from input block IB and either update *LOC directly
     282                 :            :    or add it to the location cache.
     283                 :            :    It is neccesary to call apply_location_cache to get *LOC updated.  */
     284                 :            : 
     285                 :            : void
     286                 :    2632000 : lto_input_location (location_t *loc, struct bitpack_d *bp,
     287                 :            :                     class data_in *data_in)
     288                 :            : {
     289                 :    2632000 :   data_in->location_cache.input_location (loc, bp, data_in);
     290                 :    2632000 : }
     291                 :            : 
     292                 :            : /* Read location and return it instead of going through location caching.
     293                 :            :    This should be used only when the resulting location is not going to be
     294                 :            :    discarded.  */
     295                 :            : 
     296                 :            : location_t
     297                 :    1176240 : stream_input_location_now (struct bitpack_d *bp, class data_in *data_in)
     298                 :            : {
     299                 :    1176240 :   location_t loc;
     300                 :    1176240 :   stream_input_location (&loc, bp, data_in);
     301                 :    1176240 :   data_in->location_cache.apply_location_cache ();
     302                 :    1176240 :   return loc;
     303                 :            : }
     304                 :            : 
     305                 :            : /* Read a reference to a tree node from DATA_IN using input block IB.
     306                 :            :    TAG is the expected node that should be found in IB, if TAG belongs
     307                 :            :    to one of the indexable trees, expect to read a reference index to
     308                 :            :    be looked up in one of the symbol tables, otherwise read the pysical
     309                 :            :    representation of the tree using stream_read_tree.  FN is the
     310                 :            :    function scope for the read tree.  */
     311                 :            : 
     312                 :            : tree
     313                 :    4421090 : lto_input_tree_ref (class lto_input_block *ib, class data_in *data_in,
     314                 :            :                     struct function *fn, enum LTO_tags tag)
     315                 :            : {
     316                 :    4421090 :   unsigned HOST_WIDE_INT ix_u;
     317                 :    4421090 :   tree result = NULL_TREE;
     318                 :            : 
     319                 :    4421090 :   lto_tag_check_range (tag, LTO_field_decl_ref, LTO_namelist_decl_ref);
     320                 :            : 
     321                 :    4421090 :   switch (tag)
     322                 :            :     {
     323                 :    2445490 :     case LTO_type_ref:
     324                 :    2445490 :       ix_u = streamer_read_uhwi (ib);
     325                 :    2445490 :       result = lto_file_decl_data_get_type (data_in->file_data, ix_u);
     326                 :    2445490 :       break;
     327                 :            : 
     328                 :    1184480 :     case LTO_ssa_name_ref:
     329                 :    1184480 :       ix_u = streamer_read_uhwi (ib);
     330                 :    1184480 :       result = (*SSANAMES (fn))[ix_u];
     331                 :    1184480 :       break;
     332                 :            : 
     333                 :      58799 :     case LTO_field_decl_ref:
     334                 :      58799 :       ix_u = streamer_read_uhwi (ib);
     335                 :      58799 :       result = lto_file_decl_data_get_field_decl (data_in->file_data, ix_u);
     336                 :      58799 :       break;
     337                 :            : 
     338                 :     545737 :     case LTO_function_decl_ref:
     339                 :     545737 :       ix_u = streamer_read_uhwi (ib);
     340                 :     545737 :       result = lto_file_decl_data_get_fn_decl (data_in->file_data, ix_u);
     341                 :     545737 :       break;
     342                 :            : 
     343                 :          0 :     case LTO_type_decl_ref:
     344                 :          0 :       ix_u = streamer_read_uhwi (ib);
     345                 :          0 :       result = lto_file_decl_data_get_type_decl (data_in->file_data, ix_u);
     346                 :          0 :       break;
     347                 :            : 
     348                 :          0 :     case LTO_namespace_decl_ref:
     349                 :          0 :       ix_u = streamer_read_uhwi (ib);
     350                 :          0 :       result = lto_file_decl_data_get_namespace_decl (data_in->file_data, ix_u);
     351                 :          0 :       break;
     352                 :            : 
     353                 :     186590 :     case LTO_global_decl_ref:
     354                 :     186590 :     case LTO_result_decl_ref:
     355                 :     186590 :     case LTO_const_decl_ref:
     356                 :     186590 :     case LTO_imported_decl_ref:
     357                 :     186590 :     case LTO_label_decl_ref:
     358                 :     186590 :     case LTO_translation_unit_decl_ref:
     359                 :     186590 :     case LTO_namelist_decl_ref:
     360                 :     186590 :       ix_u = streamer_read_uhwi (ib);
     361                 :     186590 :       result = lto_file_decl_data_get_var_decl (data_in->file_data, ix_u);
     362                 :     186590 :       break;
     363                 :            : 
     364                 :          0 :     default:
     365                 :          0 :       gcc_unreachable ();
     366                 :            :     }
     367                 :            : 
     368                 :    4421090 :   gcc_assert (result);
     369                 :            : 
     370                 :    4421090 :   return result;
     371                 :            : }
     372                 :            : 
     373                 :            : 
     374                 :            : /* Read and return a double-linked list of catch handlers from input
     375                 :            :    block IB, using descriptors in DATA_IN.  */
     376                 :            : 
     377                 :            : static struct eh_catch_d *
     378                 :        173 : lto_input_eh_catch_list (class lto_input_block *ib, class data_in *data_in,
     379                 :            :                          eh_catch *last_p)
     380                 :            : {
     381                 :        173 :   eh_catch first;
     382                 :        173 :   enum LTO_tags tag;
     383                 :            : 
     384                 :        173 :   *last_p = first = NULL;
     385                 :        173 :   tag = streamer_read_record_start (ib);
     386                 :        332 :   while (tag)
     387                 :            :     {
     388                 :        159 :       tree list;
     389                 :        159 :       eh_catch n;
     390                 :            : 
     391                 :        159 :       lto_tag_check_range (tag, LTO_eh_catch, LTO_eh_catch);
     392                 :            : 
     393                 :            :       /* Read the catch node.  */
     394                 :        159 :       n = ggc_cleared_alloc<eh_catch_d> ();
     395                 :        159 :       n->type_list = stream_read_tree (ib, data_in);
     396                 :        159 :       n->filter_list = stream_read_tree (ib, data_in);
     397                 :        159 :       n->label = stream_read_tree (ib, data_in);
     398                 :            : 
     399                 :            :       /* Register all the types in N->FILTER_LIST.  */
     400                 :        159 :       for (list = n->filter_list; list; list = TREE_CHAIN (list))
     401                 :          0 :         add_type_for_runtime (TREE_VALUE (list));
     402                 :            : 
     403                 :            :       /* Chain N to the end of the list.  */
     404                 :        159 :       if (*last_p)
     405                 :          4 :         (*last_p)->next_catch = n;
     406                 :        159 :       n->prev_catch = *last_p;
     407                 :        159 :       *last_p = n;
     408                 :            : 
     409                 :            :       /* Set the head of the list the first time through the loop.  */
     410                 :        159 :       if (first == NULL)
     411                 :        155 :         first = n;
     412                 :            : 
     413                 :        159 :       tag = streamer_read_record_start (ib);
     414                 :            :     }
     415                 :            : 
     416                 :        173 :   return first;
     417                 :            : }
     418                 :            : 
     419                 :            : 
     420                 :            : /* Read and return EH region IX from input block IB, using descriptors
     421                 :            :    in DATA_IN.  */
     422                 :            : 
     423                 :            : static eh_region
     424                 :      11786 : input_eh_region (class lto_input_block *ib, class data_in *data_in, int ix)
     425                 :            : {
     426                 :      11786 :   enum LTO_tags tag;
     427                 :      11786 :   eh_region r;
     428                 :            : 
     429                 :            :   /* Read the region header.  */
     430                 :      11786 :   tag = streamer_read_record_start (ib);
     431                 :      11786 :   if (tag == LTO_null)
     432                 :            :     return NULL;
     433                 :            : 
     434                 :       6972 :   r = ggc_cleared_alloc<eh_region_d> ();
     435                 :       6972 :   r->index = streamer_read_hwi (ib);
     436                 :            : 
     437                 :       6972 :   gcc_assert (r->index == ix);
     438                 :            : 
     439                 :            :   /* Read all the region pointers as region numbers.  We'll fix up
     440                 :            :      the pointers once the whole array has been read.  */
     441                 :       6972 :   r->outer = (eh_region) (intptr_t) streamer_read_hwi (ib);
     442                 :       6972 :   r->inner = (eh_region) (intptr_t) streamer_read_hwi (ib);
     443                 :       6972 :   r->next_peer = (eh_region) (intptr_t) streamer_read_hwi (ib);
     444                 :            : 
     445                 :       6972 :   switch (tag)
     446                 :            :     {
     447                 :       3191 :       case LTO_ert_cleanup:
     448                 :       3191 :         r->type = ERT_CLEANUP;
     449                 :       3191 :         break;
     450                 :            : 
     451                 :        173 :       case LTO_ert_try:
     452                 :        173 :         {
     453                 :        173 :           struct eh_catch_d *last_catch;
     454                 :        173 :           r->type = ERT_TRY;
     455                 :        173 :           r->u.eh_try.first_catch = lto_input_eh_catch_list (ib, data_in,
     456                 :            :                                                              &last_catch);
     457                 :        173 :           r->u.eh_try.last_catch = last_catch;
     458                 :        173 :           break;
     459                 :            :         }
     460                 :            : 
     461                 :        150 :       case LTO_ert_allowed_exceptions:
     462                 :        150 :         {
     463                 :        150 :           tree l;
     464                 :            : 
     465                 :        150 :           r->type = ERT_ALLOWED_EXCEPTIONS;
     466                 :        150 :           r->u.allowed.type_list = stream_read_tree (ib, data_in);
     467                 :        150 :           r->u.allowed.label = stream_read_tree (ib, data_in);
     468                 :        150 :           r->u.allowed.filter = streamer_read_uhwi (ib);
     469                 :            : 
     470                 :        202 :           for (l = r->u.allowed.type_list; l ; l = TREE_CHAIN (l))
     471                 :         52 :             add_type_for_runtime (TREE_VALUE (l));
     472                 :            :         }
     473                 :            :         break;
     474                 :            : 
     475                 :       3458 :       case LTO_ert_must_not_throw:
     476                 :       3458 :         {
     477                 :       3458 :           r->type = ERT_MUST_NOT_THROW;
     478                 :       3458 :           r->u.must_not_throw.failure_decl = stream_read_tree (ib, data_in);
     479                 :       3458 :           bitpack_d bp = streamer_read_bitpack (ib);
     480                 :       3458 :           r->u.must_not_throw.failure_loc
     481                 :       3458 :            = stream_input_location_now (&bp, data_in);
     482                 :            :         }
     483                 :       3458 :         break;
     484                 :            : 
     485                 :          0 :       default:
     486                 :          0 :         gcc_unreachable ();
     487                 :            :     }
     488                 :            : 
     489                 :       6972 :   r->landing_pads = (eh_landing_pad) (intptr_t) streamer_read_hwi (ib);
     490                 :            : 
     491                 :       6972 :   return r;
     492                 :            : }
     493                 :            : 
     494                 :            : 
     495                 :            : /* Read and return EH landing pad IX from input block IB, using descriptors
     496                 :            :    in DATA_IN.  */
     497                 :            : 
     498                 :            : static eh_landing_pad
     499                 :       5726 : input_eh_lp (class lto_input_block *ib, class data_in *data_in, int ix)
     500                 :            : {
     501                 :       5726 :   enum LTO_tags tag;
     502                 :       5726 :   eh_landing_pad lp;
     503                 :            : 
     504                 :            :   /* Read the landing pad header.  */
     505                 :       5726 :   tag = streamer_read_record_start (ib);
     506                 :       5726 :   if (tag == LTO_null)
     507                 :            :     return NULL;
     508                 :            : 
     509                 :       1870 :   lto_tag_check_range (tag, LTO_eh_landing_pad, LTO_eh_landing_pad);
     510                 :            : 
     511                 :       1870 :   lp = ggc_cleared_alloc<eh_landing_pad_d> ();
     512                 :       1870 :   lp->index = streamer_read_hwi (ib);
     513                 :       1870 :   gcc_assert (lp->index == ix);
     514                 :       1870 :   lp->next_lp = (eh_landing_pad) (intptr_t) streamer_read_hwi (ib);
     515                 :       1870 :   lp->region = (eh_region) (intptr_t) streamer_read_hwi (ib);
     516                 :       1870 :   lp->post_landing_pad = stream_read_tree (ib, data_in);
     517                 :            : 
     518                 :       1870 :   return lp;
     519                 :            : }
     520                 :            : 
     521                 :            : 
     522                 :            : /* After reading the EH regions, pointers to peer and children regions
     523                 :            :    are region numbers.  This converts all these region numbers into
     524                 :            :    real pointers into the rematerialized regions for FN.  ROOT_REGION
     525                 :            :    is the region number for the root EH region in FN.  */
     526                 :            : 
     527                 :            : static void
     528                 :       3512 : fixup_eh_region_pointers (struct function *fn, HOST_WIDE_INT root_region)
     529                 :            : {
     530                 :       3512 :   unsigned i;
     531                 :       3512 :   vec<eh_region, va_gc> *eh_array = fn->eh->region_array;
     532                 :       3512 :   vec<eh_landing_pad, va_gc> *lp_array = fn->eh->lp_array;
     533                 :       3512 :   eh_region r;
     534                 :       3512 :   eh_landing_pad lp;
     535                 :            : 
     536                 :       3512 :   gcc_assert (eh_array && lp_array);
     537                 :            : 
     538                 :       3512 :   gcc_assert (root_region >= 0);
     539                 :       3512 :   fn->eh->region_tree = (*eh_array)[root_region];
     540                 :            : 
     541                 :            : #define FIXUP_EH_REGION(r) (r) = (*eh_array)[(HOST_WIDE_INT) (intptr_t) (r)]
     542                 :            : #define FIXUP_EH_LP(p) (p) = (*lp_array)[(HOST_WIDE_INT) (intptr_t) (p)]
     543                 :            : 
     544                 :            :   /* Convert all the index numbers stored in pointer fields into
     545                 :            :      pointers to the corresponding slots in the EH region array.  */
     546                 :      15298 :   FOR_EACH_VEC_ELT (*eh_array, i, r)
     547                 :            :     {
     548                 :            :       /* The array may contain NULL regions.  */
     549                 :      11786 :       if (r == NULL)
     550                 :       4814 :         continue;
     551                 :            : 
     552                 :       6972 :       gcc_assert (i == (unsigned) r->index);
     553                 :       6972 :       FIXUP_EH_REGION (r->outer);
     554                 :       6972 :       FIXUP_EH_REGION (r->inner);
     555                 :       6972 :       FIXUP_EH_REGION (r->next_peer);
     556                 :       6972 :       FIXUP_EH_LP (r->landing_pads);
     557                 :            :     }
     558                 :            : 
     559                 :            :   /* Convert all the index numbers stored in pointer fields into
     560                 :            :      pointers to the corresponding slots in the EH landing pad array.  */
     561                 :       9238 :   FOR_EACH_VEC_ELT (*lp_array, i, lp)
     562                 :            :     {
     563                 :            :       /* The array may contain NULL landing pads.  */
     564                 :       5726 :       if (lp == NULL)
     565                 :       3856 :         continue;
     566                 :            : 
     567                 :       1870 :       gcc_assert (i == (unsigned) lp->index);
     568                 :       1870 :       FIXUP_EH_LP (lp->next_lp);
     569                 :       1870 :       FIXUP_EH_REGION (lp->region);
     570                 :            :     }
     571                 :            : 
     572                 :            : #undef FIXUP_EH_REGION
     573                 :            : #undef FIXUP_EH_LP
     574                 :       3512 : }
     575                 :            : 
     576                 :            : 
     577                 :            : /* Initialize EH support.  */
     578                 :            : 
     579                 :            : void
     580                 :      42117 : lto_init_eh (void)
     581                 :            : {
     582                 :      42117 :   static bool eh_initialized_p = false;
     583                 :            : 
     584                 :      42117 :   if (eh_initialized_p)
     585                 :            :     return;
     586                 :            : 
     587                 :            :   /* Contrary to most other FEs, we only initialize EH support when at
     588                 :            :      least one of the files in the set contains exception regions in
     589                 :            :      it.  Since this happens much later than the call to init_eh in
     590                 :            :      lang_dependent_init, we have to set flag_exceptions and call
     591                 :            :      init_eh again to initialize the EH tables.  */
     592                 :       2579 :   flag_exceptions = 1;
     593                 :       2579 :   init_eh ();
     594                 :            : 
     595                 :       2579 :   eh_initialized_p = true;
     596                 :            : }
     597                 :            : 
     598                 :            : 
     599                 :            : /* Read the exception table for FN from IB using the data descriptors
     600                 :            :    in DATA_IN.  */
     601                 :            : 
     602                 :            : static void
     603                 :      74621 : input_eh_regions (class lto_input_block *ib, class data_in *data_in,
     604                 :            :                   struct function *fn)
     605                 :            : {
     606                 :      74621 :   HOST_WIDE_INT i, root_region, len;
     607                 :      74621 :   enum LTO_tags tag;
     608                 :            : 
     609                 :      74621 :   tag = streamer_read_record_start (ib);
     610                 :      74621 :   if (tag == LTO_null)
     611                 :            :     return;
     612                 :            : 
     613                 :       3512 :   lto_tag_check_range (tag, LTO_eh_table, LTO_eh_table);
     614                 :            : 
     615                 :       3512 :   gcc_assert (fn->eh);
     616                 :            : 
     617                 :       3512 :   root_region = streamer_read_hwi (ib);
     618                 :       3512 :   gcc_assert (root_region == (int) root_region);
     619                 :            : 
     620                 :            :   /* Read the EH region array.  */
     621                 :       3512 :   len = streamer_read_hwi (ib);
     622                 :       3512 :   gcc_assert (len == (int) len);
     623                 :       3512 :   if (len > 0)
     624                 :            :     {
     625                 :       3512 :       vec_safe_grow_cleared (fn->eh->region_array, len);
     626                 :      15298 :       for (i = 0; i < len; i++)
     627                 :            :         {
     628                 :      11786 :           eh_region r = input_eh_region (ib, data_in, i);
     629                 :      11786 :           (*fn->eh->region_array)[i] = r;
     630                 :            :         }
     631                 :            :     }
     632                 :            : 
     633                 :            :   /* Read the landing pads.  */
     634                 :       3512 :   len = streamer_read_hwi (ib);
     635                 :       3512 :   gcc_assert (len == (int) len);
     636                 :       3512 :   if (len > 0)
     637                 :            :     {
     638                 :       3512 :       vec_safe_grow_cleared (fn->eh->lp_array, len);
     639                 :       9238 :       for (i = 0; i < len; i++)
     640                 :            :         {
     641                 :       5726 :           eh_landing_pad lp = input_eh_lp (ib, data_in, i);
     642                 :       5726 :           (*fn->eh->lp_array)[i] = lp;
     643                 :            :         }
     644                 :            :     }
     645                 :            : 
     646                 :            :   /* Read the runtime type data.  */
     647                 :       3512 :   len = streamer_read_hwi (ib);
     648                 :       3512 :   gcc_assert (len == (int) len);
     649                 :       3512 :   if (len > 0)
     650                 :            :     {
     651                 :          0 :       vec_safe_grow_cleared (fn->eh->ttype_data, len);
     652                 :          0 :       for (i = 0; i < len; i++)
     653                 :            :         {
     654                 :          0 :           tree ttype = stream_read_tree (ib, data_in);
     655                 :          0 :           (*fn->eh->ttype_data)[i] = ttype;
     656                 :            :         }
     657                 :            :     }
     658                 :            : 
     659                 :            :   /* Read the table of action chains.  */
     660                 :       3512 :   len = streamer_read_hwi (ib);
     661                 :       3512 :   gcc_assert (len == (int) len);
     662                 :       3512 :   if (len > 0)
     663                 :            :     {
     664                 :          0 :       if (targetm.arm_eabi_unwinder)
     665                 :            :         {
     666                 :          0 :           vec_safe_grow_cleared (fn->eh->ehspec_data.arm_eabi, len);
     667                 :          0 :           for (i = 0; i < len; i++)
     668                 :            :             {
     669                 :          0 :               tree t = stream_read_tree (ib, data_in);
     670                 :          0 :               (*fn->eh->ehspec_data.arm_eabi)[i] = t;
     671                 :            :             }
     672                 :            :         }
     673                 :            :       else
     674                 :            :         {
     675                 :          0 :           vec_safe_grow_cleared (fn->eh->ehspec_data.other, len);
     676                 :          0 :           for (i = 0; i < len; i++)
     677                 :            :             {
     678                 :          0 :               uchar c = streamer_read_uchar (ib);
     679                 :          0 :               (*fn->eh->ehspec_data.other)[i] = c;
     680                 :            :             }
     681                 :            :         }
     682                 :            :     }
     683                 :            : 
     684                 :            :   /* Reconstruct the EH region tree by fixing up the peer/children
     685                 :            :      pointers.  */
     686                 :       3512 :   fixup_eh_region_pointers (fn, root_region);
     687                 :            : 
     688                 :       3512 :   tag = streamer_read_record_start (ib);
     689                 :       3512 :   lto_tag_check_range (tag, LTO_null, LTO_null);
     690                 :            : }
     691                 :            : 
     692                 :            : 
     693                 :            : /* Make a new basic block with index INDEX in function FN.  */
     694                 :            : 
     695                 :            : static basic_block
     696                 :     354343 : make_new_block (struct function *fn, unsigned int index)
     697                 :            : {
     698                 :     354343 :   basic_block bb = alloc_block ();
     699                 :     354343 :   bb->index = index;
     700                 :     354343 :   SET_BASIC_BLOCK_FOR_FN (fn, index, bb);
     701                 :     354343 :   n_basic_blocks_for_fn (fn)++;
     702                 :     354343 :   return bb;
     703                 :            : }
     704                 :            : 
     705                 :            : 
     706                 :            : /* Read the CFG for function FN from input block IB.  */
     707                 :            : 
     708                 :            : static void
     709                 :      74621 : input_cfg (class lto_input_block *ib, class data_in *data_in,
     710                 :            :            struct function *fn)
     711                 :            : {
     712                 :      74621 :   unsigned int bb_count;
     713                 :      74621 :   basic_block p_bb;
     714                 :      74621 :   unsigned int i;
     715                 :      74621 :   int index;
     716                 :            : 
     717                 :      74621 :   init_empty_tree_cfg_for_function (fn);
     718                 :      74621 :   init_ssa_operands (fn);
     719                 :            : 
     720                 :      74621 :   profile_status_for_fn (fn) = streamer_read_enum (ib, profile_status_d,
     721                 :            :                                                    PROFILE_LAST);
     722                 :            : 
     723                 :      74621 :   bb_count = streamer_read_uhwi (ib);
     724                 :            : 
     725                 :      74621 :   last_basic_block_for_fn (fn) = bb_count;
     726                 :      74621 :   if (bb_count > basic_block_info_for_fn (fn)->length ())
     727                 :       1393 :     vec_safe_grow_cleared (basic_block_info_for_fn (fn), bb_count);
     728                 :            : 
     729                 :      74621 :   if (bb_count > label_to_block_map_for_fn (fn)->length ())
     730                 :       1393 :     vec_safe_grow_cleared (label_to_block_map_for_fn (fn), bb_count);
     731                 :            : 
     732                 :      74621 :   index = streamer_read_hwi (ib);
     733                 :     578206 :   while (index != -1)
     734                 :            :     {
     735                 :     503585 :       basic_block bb = BASIC_BLOCK_FOR_FN (fn, index);
     736                 :     503585 :       unsigned int edge_count;
     737                 :            : 
     738                 :     503585 :       if (bb == NULL)
     739                 :       8245 :         bb = make_new_block (fn, index);
     740                 :            : 
     741                 :     503585 :       edge_count = streamer_read_uhwi (ib);
     742                 :            : 
     743                 :            :       /* Connect up the CFG.  */
     744                 :    1037770 :       for (i = 0; i < edge_count; i++)
     745                 :            :         {
     746                 :     534186 :           unsigned int dest_index;
     747                 :     534186 :           unsigned int edge_flags;
     748                 :     534186 :           basic_block dest;
     749                 :     534186 :           profile_probability probability;
     750                 :     534186 :           edge e;
     751                 :            : 
     752                 :     534186 :           dest_index = streamer_read_uhwi (ib);
     753                 :     534186 :           probability = profile_probability::stream_in (ib);
     754                 :     534186 :           edge_flags = streamer_read_uhwi (ib);
     755                 :            : 
     756                 :     534186 :           dest = BASIC_BLOCK_FOR_FN (fn, dest_index);
     757                 :            : 
     758                 :     534186 :           if (dest == NULL)
     759                 :     346098 :             dest = make_new_block (fn, dest_index);
     760                 :            : 
     761                 :     534186 :           e = make_edge (bb, dest, edge_flags);
     762                 :     534186 :           e->probability = probability;
     763                 :            :         }
     764                 :            : 
     765                 :     503585 :       index = streamer_read_hwi (ib);
     766                 :            :     }
     767                 :            : 
     768                 :      74621 :   p_bb = ENTRY_BLOCK_PTR_FOR_FN (fn);
     769                 :      74621 :   index = streamer_read_hwi (ib);
     770                 :     503585 :   while (index != -1)
     771                 :            :     {
     772                 :     428964 :       basic_block bb = BASIC_BLOCK_FOR_FN (fn, index);
     773                 :     428964 :       bb->prev_bb = p_bb;
     774                 :     428964 :       p_bb->next_bb = bb;
     775                 :     428964 :       p_bb = bb;
     776                 :     428964 :       index = streamer_read_hwi (ib);
     777                 :            :     }
     778                 :            : 
     779                 :            :   /* ???  The cfgloop interface is tied to cfun.  */
     780                 :      74621 :   gcc_assert (cfun == fn);
     781                 :            : 
     782                 :            :   /* Input the loop tree.  */
     783                 :      74621 :   unsigned n_loops = streamer_read_uhwi (ib);
     784                 :      74621 :   if (n_loops == 0)
     785                 :            :     return;
     786                 :            : 
     787                 :      74621 :   struct loops *loops = ggc_cleared_alloc<struct loops> ();
     788                 :      74621 :   init_loops_structure (fn, loops, n_loops);
     789                 :      74621 :   set_loops_for_fn (fn, loops);
     790                 :            : 
     791                 :            :   /* Input each loop and associate it with its loop header so
     792                 :            :      flow_loops_find can rebuild the loop tree.  */
     793                 :      87781 :   for (unsigned i = 1; i < n_loops; ++i)
     794                 :            :     {
     795                 :      13160 :       int header_index = streamer_read_hwi (ib);
     796                 :      13160 :       if (header_index == -1)
     797                 :            :         {
     798                 :        630 :           loops->larray->quick_push (NULL);
     799                 :        630 :           continue;
     800                 :            :         }
     801                 :            : 
     802                 :      12530 :       class loop *loop = alloc_loop ();
     803                 :      12530 :       loop->header = BASIC_BLOCK_FOR_FN (fn, header_index);
     804                 :      12530 :       loop->header->loop_father = loop;
     805                 :            : 
     806                 :            :       /* Read everything copy_loop_info copies.  */
     807                 :      12530 :       loop->estimate_state = streamer_read_enum (ib, loop_estimation, EST_LAST);
     808                 :      12530 :       loop->any_upper_bound = streamer_read_hwi (ib);
     809                 :      12530 :       if (loop->any_upper_bound)
     810                 :       8240 :         loop->nb_iterations_upper_bound = streamer_read_widest_int (ib);
     811                 :      12530 :       loop->any_likely_upper_bound = streamer_read_hwi (ib);
     812                 :      12530 :       if (loop->any_likely_upper_bound)
     813                 :       8240 :         loop->nb_iterations_likely_upper_bound = streamer_read_widest_int (ib);
     814                 :      12530 :       loop->any_estimate = streamer_read_hwi (ib);
     815                 :      12530 :       if (loop->any_estimate)
     816                 :       4387 :         loop->nb_iterations_estimate = streamer_read_widest_int (ib);
     817                 :            : 
     818                 :            :       /* Read OMP SIMD related info.  */
     819                 :      12530 :       loop->safelen = streamer_read_hwi (ib);
     820                 :      12530 :       loop->unroll = streamer_read_hwi (ib);
     821                 :      12530 :       loop->owned_clique = streamer_read_hwi (ib);
     822                 :      12530 :       loop->dont_vectorize = streamer_read_hwi (ib);
     823                 :      12530 :       loop->force_vectorize = streamer_read_hwi (ib);
     824                 :      12530 :       loop->simduid = stream_read_tree (ib, data_in);
     825                 :            : 
     826                 :      12530 :       place_new_loop (fn, loop);
     827                 :            : 
     828                 :            :       /* flow_loops_find doesn't like loops not in the tree, hook them
     829                 :            :          all as siblings of the tree root temporarily.  */
     830                 :      12530 :       flow_loop_tree_node_add (loops->tree_root, loop);
     831                 :            :     }
     832                 :            : 
     833                 :            :   /* Rebuild the loop tree.  */
     834                 :      74621 :   flow_loops_find (loops);
     835                 :            : }
     836                 :            : 
     837                 :            : 
     838                 :            : /* Read the SSA names array for function FN from DATA_IN using input
     839                 :            :    block IB.  */
     840                 :            : 
     841                 :            : static void
     842                 :      74621 : input_ssa_names (class lto_input_block *ib, class data_in *data_in,
     843                 :            :                  struct function *fn)
     844                 :            : {
     845                 :      74621 :   unsigned int i, size;
     846                 :            : 
     847                 :      74621 :   size = streamer_read_uhwi (ib);
     848                 :      74621 :   init_ssanames (fn, size);
     849                 :            : 
     850                 :      74621 :   i = streamer_read_uhwi (ib);
     851                 :     651301 :   while (i)
     852                 :            :     {
     853                 :     746745 :       tree ssa_name, name;
     854                 :     746745 :       bool is_default_def;
     855                 :            : 
     856                 :            :       /* Skip over the elements that had been freed.  */
     857                 :     746745 :       while (SSANAMES (fn)->length () < i)
     858                 :     170065 :         SSANAMES (fn)->quick_push (NULL_TREE);
     859                 :            : 
     860                 :     576680 :       is_default_def = (streamer_read_uchar (ib) != 0);
     861                 :     576680 :       name = stream_read_tree (ib, data_in);
     862                 :     576680 :       ssa_name = make_ssa_name_fn (fn, name, NULL);
     863                 :            : 
     864                 :     576680 :       if (is_default_def)
     865                 :            :         {
     866                 :     150026 :           set_ssa_default_def (cfun, SSA_NAME_VAR (ssa_name), ssa_name);
     867                 :      75013 :           SSA_NAME_DEF_STMT (ssa_name) = gimple_build_nop ();
     868                 :            :         }
     869                 :            : 
     870                 :     576680 :       i = streamer_read_uhwi (ib);
     871                 :            :     }
     872                 :      74621 : }
     873                 :            : 
     874                 :            : 
     875                 :            : /* Go through all NODE edges and fixup call_stmt pointers
     876                 :            :    so they point to STMTS.  */
     877                 :            : 
     878                 :            : static void
     879                 :      77809 : fixup_call_stmt_edges_1 (struct cgraph_node *node, gimple **stmts,
     880                 :            :                          struct function *fn)
     881                 :            : {
     882                 :            : #define STMT_UID_NOT_IN_RANGE(uid) \
     883                 :            :   (gimple_stmt_max_uid (fn) < uid || uid == 0)
     884                 :            : 
     885                 :      77809 :   struct cgraph_edge *cedge;
     886                 :      77809 :   struct ipa_ref *ref = NULL;
     887                 :      77809 :   unsigned int i;
     888                 :            : 
     889                 :     285537 :   for (cedge = node->callees; cedge; cedge = cedge->next_callee)
     890                 :            :     {
     891                 :     207728 :       if (STMT_UID_NOT_IN_RANGE (cedge->lto_stmt_uid))
     892                 :          0 :         fatal_error (input_location,
     893                 :            :                      "Cgraph edge statement index out of range");
     894                 :     207728 :       cedge->call_stmt = as_a <gcall *> (stmts[cedge->lto_stmt_uid - 1]);
     895                 :     207728 :       cedge->lto_stmt_uid = 0;
     896                 :     207728 :       if (!cedge->call_stmt)
     897                 :            :         fatal_error (input_location,
     898                 :            :                      "Cgraph edge statement index not found");
     899                 :            :     }
     900                 :      78885 :   for (cedge = node->indirect_calls; cedge; cedge = cedge->next_callee)
     901                 :            :     {
     902                 :       1076 :       if (STMT_UID_NOT_IN_RANGE (cedge->lto_stmt_uid))
     903                 :          0 :         fatal_error (input_location,
     904                 :            :                      "Cgraph edge statement index out of range");
     905                 :       1076 :       cedge->call_stmt = as_a <gcall *> (stmts[cedge->lto_stmt_uid - 1]);
     906                 :       1076 :       cedge->lto_stmt_uid = 0;
     907                 :       1076 :       if (!cedge->call_stmt)
     908                 :            :         fatal_error (input_location, "Cgraph edge statement index not found");
     909                 :            :     }
     910                 :     212591 :   for (i = 0; node->iterate_reference (i, ref); i++)
     911                 :     134782 :     if (ref->lto_stmt_uid)
     912                 :            :       {
     913                 :       7523 :         if (STMT_UID_NOT_IN_RANGE (ref->lto_stmt_uid))
     914                 :          0 :           fatal_error (input_location,
     915                 :            :                        "Reference statement index out of range");
     916                 :       7523 :         ref->stmt = stmts[ref->lto_stmt_uid - 1];
     917                 :       7523 :         ref->lto_stmt_uid = 0;
     918                 :       7523 :         if (!ref->stmt)
     919                 :          0 :           fatal_error (input_location, "Reference statement index not found");
     920                 :            :       }
     921                 :      77809 : }
     922                 :            : 
     923                 :            : 
     924                 :            : /* Fixup call_stmt pointers in NODE and all clones.  */
     925                 :            : 
     926                 :            : static void
     927                 :      74621 : fixup_call_stmt_edges (struct cgraph_node *orig, gimple **stmts)
     928                 :            : {
     929                 :      74713 :   struct cgraph_node *node;
     930                 :      74713 :   struct function *fn;
     931                 :            : 
     932                 :      74713 :   while (orig->clone_of)
     933                 :            :     orig = orig->clone_of;
     934                 :      74621 :   fn = DECL_STRUCT_FUNCTION (orig->decl);
     935                 :            : 
     936                 :      74621 :   if (!orig->thunk.thunk_p)
     937                 :      74621 :     fixup_call_stmt_edges_1 (orig, stmts, fn);
     938                 :      74621 :   if (orig->clones)
     939                 :       5402 :     for (node = orig->clones; node != orig;)
     940                 :            :       {
     941                 :       3191 :         if (!node->thunk.thunk_p)
     942                 :       3188 :           fixup_call_stmt_edges_1 (node, stmts, fn);
     943                 :       3191 :         if (node->clones)
     944                 :            :           node = node->clones;
     945                 :       2861 :         else if (node->next_sibling_clone)
     946                 :            :           node = node->next_sibling_clone;
     947                 :            :         else
     948                 :            :           {
     949                 :       4761 :             while (node != orig && !node->next_sibling_clone)
     950                 :       2541 :               node = node->clone_of;
     951                 :       2220 :             if (node != orig)
     952                 :          9 :               node = node->next_sibling_clone;
     953                 :            :           }
     954                 :            :       }
     955                 :      74621 : }
     956                 :            : 
     957                 :            : 
     958                 :            : /* Input the base body of struct function FN from DATA_IN
     959                 :            :    using input block IB.  */
     960                 :            : 
     961                 :            : static void
     962                 :      74621 : input_struct_function_base (struct function *fn, class data_in *data_in,
     963                 :            :                             class lto_input_block *ib)
     964                 :            : {
     965                 :      74621 :   struct bitpack_d bp;
     966                 :      74621 :   int len;
     967                 :            : 
     968                 :            :   /* Read the static chain and non-local goto save area.  */
     969                 :      74621 :   fn->static_chain_decl = stream_read_tree (ib, data_in);
     970                 :      74621 :   fn->nonlocal_goto_save_area = stream_read_tree (ib, data_in);
     971                 :            : 
     972                 :            :   /* Read all the local symbols.  */
     973                 :      74621 :   len = streamer_read_hwi (ib);
     974                 :      74621 :   if (len > 0)
     975                 :            :     {
     976                 :      15652 :       int i;
     977                 :      15652 :       vec_safe_grow_cleared (fn->local_decls, len);
     978                 :      92075 :       for (i = 0; i < len; i++)
     979                 :            :         {
     980                 :      76423 :           tree t = stream_read_tree (ib, data_in);
     981                 :      76423 :           (*fn->local_decls)[i] = t;
     982                 :            :         }
     983                 :            :     }
     984                 :            : 
     985                 :            :   /* Input the current IL state of the function.  */
     986                 :      74621 :   fn->curr_properties = streamer_read_uhwi (ib);
     987                 :            : 
     988                 :            :   /* Read all the attributes for FN.  */
     989                 :      74621 :   bp = streamer_read_bitpack (ib);
     990                 :      74621 :   fn->is_thunk = bp_unpack_value (&bp, 1);
     991                 :      74621 :   fn->has_local_explicit_reg_vars = bp_unpack_value (&bp, 1);
     992                 :      74621 :   fn->returns_pcc_struct = bp_unpack_value (&bp, 1);
     993                 :      74621 :   fn->returns_struct = bp_unpack_value (&bp, 1);
     994                 :      74621 :   fn->can_throw_non_call_exceptions = bp_unpack_value (&bp, 1);
     995                 :      74621 :   fn->can_delete_dead_exceptions = bp_unpack_value (&bp, 1);
     996                 :      74621 :   fn->always_inline_functions_inlined = bp_unpack_value (&bp, 1);
     997                 :      74621 :   fn->after_inlining = bp_unpack_value (&bp, 1);
     998                 :      74621 :   fn->stdarg = bp_unpack_value (&bp, 1);
     999                 :      74621 :   fn->has_nonlocal_label = bp_unpack_value (&bp, 1);
    1000                 :      74621 :   fn->has_forced_label_in_static = bp_unpack_value (&bp, 1);
    1001                 :      74621 :   fn->calls_alloca = bp_unpack_value (&bp, 1);
    1002                 :      74621 :   fn->calls_setjmp = bp_unpack_value (&bp, 1);
    1003                 :      74621 :   fn->calls_eh_return = bp_unpack_value (&bp, 1);
    1004                 :      74621 :   fn->has_force_vectorize_loops = bp_unpack_value (&bp, 1);
    1005                 :      74621 :   fn->has_simduid_loops = bp_unpack_value (&bp, 1);
    1006                 :      74621 :   fn->va_list_fpr_size = bp_unpack_value (&bp, 8);
    1007                 :      74621 :   fn->va_list_gpr_size = bp_unpack_value (&bp, 8);
    1008                 :      74621 :   fn->last_clique = bp_unpack_value (&bp, sizeof (short) * 8);
    1009                 :            : 
    1010                 :            :   /* Input the function start and end loci.  */
    1011                 :      74621 :   fn->function_start_locus = stream_input_location_now (&bp, data_in);
    1012                 :      74621 :   fn->function_end_locus = stream_input_location_now (&bp, data_in);
    1013                 :            : 
    1014                 :            :   /* Restore the instance discriminators if present.  */
    1015                 :      74621 :   int instance_number = bp_unpack_value (&bp, 1);
    1016                 :      74621 :   if (instance_number)
    1017                 :            :     {
    1018                 :          0 :       instance_number = bp_unpack_value (&bp, sizeof (int) * CHAR_BIT);
    1019                 :          0 :       maybe_create_decl_to_instance_map ()->put (fn->decl, instance_number);
    1020                 :            :     }
    1021                 :      74621 : }
    1022                 :            : 
    1023                 :            : 
    1024                 :            : /* Read the body of function FN_DECL from DATA_IN using input block IB.  */
    1025                 :            : 
    1026                 :            : static void
    1027                 :      74699 : input_function (tree fn_decl, class data_in *data_in,
    1028                 :            :                 class lto_input_block *ib, class lto_input_block *ib_cfg,
    1029                 :            :                 cgraph_node *node)
    1030                 :            : {
    1031                 :      74699 :   struct function *fn;
    1032                 :      74699 :   enum LTO_tags tag;
    1033                 :      74699 :   gimple **stmts;
    1034                 :      74699 :   basic_block bb;
    1035                 :            : 
    1036                 :      74699 :   tag = streamer_read_record_start (ib);
    1037                 :      74699 :   lto_tag_check (tag, LTO_function);
    1038                 :            : 
    1039                 :            :   /* Read decls for parameters and args.  */
    1040                 :      74699 :   DECL_RESULT (fn_decl) = stream_read_tree (ib, data_in);
    1041                 :      74699 :   DECL_ARGUMENTS (fn_decl) = streamer_read_chain (ib, data_in);
    1042                 :            : 
    1043                 :            :   /* Read debug args if available.  */
    1044                 :      74699 :   unsigned n_debugargs = streamer_read_uhwi (ib);
    1045                 :      74699 :   if (n_debugargs)
    1046                 :            :     {
    1047                 :         14 :       vec<tree, va_gc> **debugargs = decl_debug_args_insert (fn_decl);
    1048                 :         14 :       vec_safe_grow (*debugargs, n_debugargs);
    1049                 :         58 :       for (unsigned i = 0; i < n_debugargs; ++i)
    1050                 :         44 :         (**debugargs)[i] = stream_read_tree (ib, data_in);
    1051                 :            :     }
    1052                 :            : 
    1053                 :            :   /* Read the tree of lexical scopes for the function.  */
    1054                 :      74699 :   DECL_INITIAL (fn_decl) = stream_read_tree (ib, data_in);
    1055                 :      74699 :   unsigned block_leaf_count = streamer_read_uhwi (ib);
    1056                 :      96491 :   while (block_leaf_count--)
    1057                 :      21792 :     stream_read_tree (ib, data_in);
    1058                 :            : 
    1059                 :      74699 :   if (!streamer_read_uhwi (ib))
    1060                 :            :     return;
    1061                 :            : 
    1062                 :      74621 :   push_struct_function (fn_decl);
    1063                 :      74621 :   fn = DECL_STRUCT_FUNCTION (fn_decl);
    1064                 :      74621 :   init_tree_ssa (fn);
    1065                 :            :   /* We input IL in SSA form.  */
    1066                 :      74621 :   cfun->gimple_df->in_ssa_p = true;
    1067                 :            : 
    1068                 :      74621 :   gimple_register_cfg_hooks ();
    1069                 :            : 
    1070                 :      74621 :   input_struct_function_base (fn, data_in, ib);
    1071                 :      74621 :   input_cfg (ib_cfg, data_in, fn);
    1072                 :            : 
    1073                 :            :   /* Read all the SSA names.  */
    1074                 :      74621 :   input_ssa_names (ib, data_in, fn);
    1075                 :            : 
    1076                 :            :   /* Read the exception handling regions in the function.  */
    1077                 :      74621 :   input_eh_regions (ib, data_in, fn);
    1078                 :            : 
    1079                 :      74621 :   gcc_assert (DECL_INITIAL (fn_decl));
    1080                 :      74621 :   DECL_SAVED_TREE (fn_decl) = NULL_TREE;
    1081                 :            : 
    1082                 :            :   /* Read all the basic blocks.  */
    1083                 :      74621 :   tag = streamer_read_record_start (ib);
    1084                 :     578206 :   while (tag)
    1085                 :            :     {
    1086                 :     503585 :       input_bb (ib, tag, data_in, fn,
    1087                 :            :                 node->count_materialization_scale);
    1088                 :     503585 :       tag = streamer_read_record_start (ib);
    1089                 :            :     }
    1090                 :            : 
    1091                 :            :   /* Fix up the call statements that are mentioned in the callgraph
    1092                 :            :      edges.  */
    1093                 :      74621 :   set_gimple_stmt_max_uid (cfun, 0);
    1094                 :     578206 :   FOR_ALL_BB_FN (bb, cfun)
    1095                 :            :     {
    1096                 :     503585 :       gimple_stmt_iterator gsi;
    1097                 :     532348 :       for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
    1098                 :            :         {
    1099                 :      28763 :           gimple *stmt = gsi_stmt (gsi);
    1100                 :      28763 :           gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
    1101                 :            :         }
    1102                 :    1975030 :       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
    1103                 :            :         {
    1104                 :     967861 :           gimple *stmt = gsi_stmt (gsi);
    1105                 :     967861 :           gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
    1106                 :            :         }
    1107                 :            :     }
    1108                 :      74621 :   stmts = (gimple **) xcalloc (gimple_stmt_max_uid (fn), sizeof (gimple *));
    1109                 :     578206 :   FOR_ALL_BB_FN (bb, cfun)
    1110                 :            :     {
    1111                 :     503585 :       gimple_stmt_iterator bsi = gsi_start_phis (bb);
    1112                 :     532348 :       while (!gsi_end_p (bsi))
    1113                 :            :         {
    1114                 :      28763 :           gimple *stmt = gsi_stmt (bsi);
    1115                 :      28763 :           gsi_next (&bsi);
    1116                 :      28763 :           stmts[gimple_uid (stmt)] = stmt;
    1117                 :            :         }
    1118                 :    1007170 :       bsi = gsi_start_bb (bb);
    1119                 :    1471450 :       while (!gsi_end_p (bsi))
    1120                 :            :         {
    1121                 :     967861 :           gimple *stmt = gsi_stmt (bsi);
    1122                 :     967861 :           bool remove = false;
    1123                 :            :           /* If we're recompiling LTO objects with debug stmts but
    1124                 :            :              we're not supposed to have debug stmts, remove them now.
    1125                 :            :              We can't remove them earlier because this would cause uid
    1126                 :            :              mismatches in fixups, but we can do it at this point, as
    1127                 :            :              long as debug stmts don't require fixups.
    1128                 :            :              Similarly remove all IFN_*SAN_* internal calls   */
    1129                 :     967861 :           if (!flag_wpa)
    1130                 :            :             {
    1131                 :     862178 :               if (is_gimple_debug (stmt)
    1132                 :     862178 :                   && (gimple_debug_nonbind_marker_p (stmt)
    1133                 :       7836 :                       ? !MAY_HAVE_DEBUG_MARKER_STMTS
    1134                 :       6351 :                       : !MAY_HAVE_DEBUG_BIND_STMTS))
    1135                 :            :                 remove = true;
    1136                 :            :               /* In case the linemap overflows locations can be dropped
    1137                 :            :                  to zero.  Thus do not keep nonsensical inline entry markers
    1138                 :            :                  we'd later ICE on.  */
    1139                 :     862178 :               tree block;
    1140                 :     862178 :               if (gimple_debug_inline_entry_p (stmt)
    1141                 :      15083 :                   && (((block = gimple_block (stmt))
    1142                 :        896 :                        && !inlined_function_outer_scope_p (block))
    1143                 :       1290 :                       || !debug_inline_points))
    1144                 :            :                 remove = true;
    1145                 :     862178 :               if (is_gimple_call (stmt)
    1146                 :     862178 :                   && gimple_call_internal_p (stmt))
    1147                 :            :                 {
    1148                 :      23876 :                   bool replace = false;
    1149                 :      23876 :                   switch (gimple_call_internal_fn (stmt))
    1150                 :            :                     {
    1151                 :        573 :                     case IFN_UBSAN_NULL:
    1152                 :        573 :                       if ((flag_sanitize
    1153                 :        573 :                           & (SANITIZE_NULL | SANITIZE_ALIGNMENT)) == 0)
    1154                 :            :                         replace = true;
    1155                 :            :                       break;
    1156                 :        218 :                     case IFN_UBSAN_BOUNDS:
    1157                 :        218 :                       if ((flag_sanitize & SANITIZE_BOUNDS) == 0)
    1158                 :            :                         replace = true;
    1159                 :            :                       break;
    1160                 :        392 :                     case IFN_UBSAN_VPTR:
    1161                 :        392 :                       if ((flag_sanitize & SANITIZE_VPTR) == 0)
    1162                 :            :                         replace = true;
    1163                 :            :                       break;
    1164                 :        610 :                     case IFN_UBSAN_OBJECT_SIZE:
    1165                 :        610 :                       if ((flag_sanitize & SANITIZE_OBJECT_SIZE) == 0)
    1166                 :            :                         replace = true;
    1167                 :            :                       break;
    1168                 :        311 :                     case IFN_UBSAN_PTR:
    1169                 :        311 :                       if ((flag_sanitize & SANITIZE_POINTER_OVERFLOW) == 0)
    1170                 :            :                         replace = true;
    1171                 :            :                       break;
    1172                 :        696 :                     case IFN_ASAN_MARK:
    1173                 :        696 :                       if ((flag_sanitize & SANITIZE_ADDRESS) == 0)
    1174                 :            :                         replace = true;
    1175                 :            :                       break;
    1176                 :          0 :                     case IFN_TSAN_FUNC_EXIT:
    1177                 :          0 :                       if ((flag_sanitize & SANITIZE_THREAD) == 0)
    1178                 :            :                         replace = true;
    1179                 :            :                       break;
    1180                 :            :                     default:
    1181                 :            :                       break;
    1182                 :            :                     }
    1183                 :            :                   if (replace)
    1184                 :            :                     {
    1185                 :          2 :                       gimple_call_set_internal_fn (as_a <gcall *> (stmt),
    1186                 :            :                                                    IFN_NOP);
    1187                 :          2 :                       update_stmt (stmt);
    1188                 :            :                     }
    1189                 :            :                 }
    1190                 :            :             }
    1191                 :     862178 :           if (remove)
    1192                 :            :             {
    1193                 :          1 :               gimple_stmt_iterator gsi = bsi;
    1194                 :          1 :               gsi_next (&bsi);
    1195                 :          1 :               unlink_stmt_vdef (stmt);
    1196                 :          1 :               release_defs (stmt);
    1197                 :          1 :               gsi_remove (&gsi, true);
    1198                 :            :             }
    1199                 :            :           else
    1200                 :            :             {
    1201                 :     967860 :               gsi_next (&bsi);
    1202                 :     967860 :               stmts[gimple_uid (stmt)] = stmt;
    1203                 :            : 
    1204                 :            :               /* Remember that the input function has begin stmt
    1205                 :            :                  markers, so that we know to expect them when emitting
    1206                 :            :                  debug info.  */
    1207                 :     967860 :               if (!cfun->debug_nonbind_markers
    1208                 :    2440920 :                   && gimple_debug_nonbind_marker_p (stmt))
    1209                 :       1213 :                 cfun->debug_nonbind_markers = true;
    1210                 :            :             }
    1211                 :            :         }
    1212                 :            :     }
    1213                 :            : 
    1214                 :            :   /* Set the gimple body to the statement sequence in the entry
    1215                 :            :      basic block.  FIXME lto, this is fairly hacky.  The existence
    1216                 :            :      of a gimple body is used by the cgraph routines, but we should
    1217                 :            :      really use the presence of the CFG.  */
    1218                 :      74621 :   {
    1219                 :      74621 :     edge_iterator ei = ei_start (ENTRY_BLOCK_PTR_FOR_FN (cfun)->succs);
    1220                 :     149242 :     gimple_set_body (fn_decl, bb_seq (ei_edge (ei)->dest));
    1221                 :            :   }
    1222                 :            : 
    1223                 :      74621 :   update_max_bb_count ();
    1224                 :      74621 :   fixup_call_stmt_edges (node, stmts);
    1225                 :      74621 :   execute_all_ipa_stmt_fixups (node, stmts);
    1226                 :            : 
    1227                 :      74621 :   free_dominance_info (CDI_DOMINATORS);
    1228                 :      74621 :   free_dominance_info (CDI_POST_DOMINATORS);
    1229                 :      74621 :   free (stmts);
    1230                 :      74621 :   pop_cfun ();
    1231                 :            : }
    1232                 :            : 
    1233                 :            : /* Read the body of function FN_DECL from DATA_IN using input block IB.  */
    1234                 :            : 
    1235                 :            : static void
    1236                 :       9449 : input_constructor (tree var, class data_in *data_in,
    1237                 :            :                    class lto_input_block *ib)
    1238                 :            : {
    1239                 :       9449 :   DECL_INITIAL (var) = stream_read_tree (ib, data_in);
    1240                 :       9449 : }
    1241                 :            : 
    1242                 :            : 
    1243                 :            : /* Read the body from DATA for function NODE and fill it in.
    1244                 :            :    FILE_DATA are the global decls and types.  SECTION_TYPE is either
    1245                 :            :    LTO_section_function_body or LTO_section_static_initializer.  If
    1246                 :            :    section type is LTO_section_function_body, FN must be the decl for
    1247                 :            :    that function.  */
    1248                 :            : 
    1249                 :            : static void
    1250                 :      84148 : lto_read_body_or_constructor (struct lto_file_decl_data *file_data, struct symtab_node *node,
    1251                 :            :                               const char *data, enum lto_section_type section_type)
    1252                 :            : {
    1253                 :      84148 :   const struct lto_function_header *header;
    1254                 :      84148 :   class data_in *data_in;
    1255                 :      84148 :   int cfg_offset;
    1256                 :      84148 :   int main_offset;
    1257                 :      84148 :   int string_offset;
    1258                 :      84148 :   tree fn_decl = node->decl;
    1259                 :            : 
    1260                 :      84148 :   header = (const struct lto_function_header *) data;
    1261                 :      84148 :   if (TREE_CODE (node->decl) == FUNCTION_DECL)
    1262                 :            :     {
    1263                 :      74699 :       cfg_offset = sizeof (struct lto_function_header);
    1264                 :      74699 :       main_offset = cfg_offset + header->cfg_size;
    1265                 :      74699 :       string_offset = main_offset + header->main_size;
    1266                 :            :     }
    1267                 :            :   else
    1268                 :            :     {
    1269                 :       9449 :       main_offset = sizeof (struct lto_function_header);
    1270                 :       9449 :       string_offset = main_offset + header->main_size;
    1271                 :            :     }
    1272                 :            : 
    1273                 :     168296 :   data_in = lto_data_in_create (file_data, data + string_offset,
    1274                 :      84148 :                               header->string_size, vNULL);
    1275                 :            : 
    1276                 :      84148 :   if (section_type == LTO_section_function_body)
    1277                 :            :     {
    1278                 :      84148 :       struct lto_in_decl_state *decl_state;
    1279                 :      84148 :       unsigned from;
    1280                 :            : 
    1281                 :      84148 :       gcc_checking_assert (node);
    1282                 :            : 
    1283                 :            :       /* Use the function's decl state. */
    1284                 :      84148 :       decl_state = lto_get_function_in_decl_state (file_data, fn_decl);
    1285                 :      84148 :       gcc_assert (decl_state);
    1286                 :      84148 :       file_data->current_decl_state = decl_state;
    1287                 :            : 
    1288                 :            : 
    1289                 :            :       /* Set up the struct function.  */
    1290                 :      84148 :       from = data_in->reader_cache->nodes.length ();
    1291                 :      84148 :       lto_input_block ib_main (data + main_offset, header->main_size,
    1292                 :      84148 :                                file_data->mode_table);
    1293                 :      84148 :       if (TREE_CODE (node->decl) == FUNCTION_DECL)
    1294                 :            :         {
    1295                 :      74699 :           lto_input_block ib_cfg (data + cfg_offset, header->cfg_size,
    1296                 :      74699 :                                   file_data->mode_table);
    1297                 :      74699 :           input_function (fn_decl, data_in, &ib_main, &ib_cfg,
    1298                 :            :                           dyn_cast <cgraph_node *>(node));
    1299                 :            :         }
    1300                 :            :       else
    1301                 :       9449 :         input_constructor (fn_decl, data_in, &ib_main);
    1302                 :      84148 :       data_in->location_cache.apply_location_cache ();
    1303                 :            :       /* And fixup types we streamed locally.  */
    1304                 :      84148 :         {
    1305                 :      84148 :           struct streamer_tree_cache_d *cache = data_in->reader_cache;
    1306                 :      84148 :           unsigned len = cache->nodes.length ();
    1307                 :            :           unsigned i;
    1308                 :    1893280 :           for (i = len; i-- > from;)
    1309                 :            :             {
    1310                 :    1809130 :               tree t = streamer_tree_cache_get_tree (cache, i);
    1311                 :    1809130 :               if (t == NULL_TREE)
    1312                 :          0 :                 continue;
    1313                 :            : 
    1314                 :    1809130 :               if (TYPE_P (t))
    1315                 :            :                 {
    1316                 :       1268 :                   gcc_assert (TYPE_CANONICAL (t) == NULL_TREE);
    1317                 :       1268 :                   if (type_with_alias_set_p (t)
    1318                 :       1268 :                       && canonical_type_used_p (t))
    1319                 :        422 :                     TYPE_CANONICAL (t) = TYPE_MAIN_VARIANT (t);
    1320                 :       1268 :                   if (TYPE_MAIN_VARIANT (t) != t)
    1321                 :            :                     {
    1322                 :        120 :                       gcc_assert (TYPE_NEXT_VARIANT (t) == NULL_TREE);
    1323                 :        120 :                       TYPE_NEXT_VARIANT (t)
    1324                 :        120 :                         = TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t));
    1325                 :        120 :                       TYPE_NEXT_VARIANT (TYPE_MAIN_VARIANT (t)) = t;
    1326                 :            :                     }
    1327                 :            :                 }
    1328                 :            :             }
    1329                 :            :         }
    1330                 :            : 
    1331                 :            :       /* Restore decl state */
    1332                 :      84148 :       file_data->current_decl_state = file_data->global_decl_state;
    1333                 :            :     }
    1334                 :            : 
    1335                 :      84148 :   lto_data_in_delete (data_in);
    1336                 :      84148 : }
    1337                 :            : 
    1338                 :            : 
    1339                 :            : /* Read the body of NODE using DATA.  FILE_DATA holds the global
    1340                 :            :    decls and types.  */
    1341                 :            : 
    1342                 :            : void
    1343                 :      74699 : lto_input_function_body (struct lto_file_decl_data *file_data,
    1344                 :            :                          struct cgraph_node *node, const char *data)
    1345                 :            : {
    1346                 :      74699 :   lto_read_body_or_constructor (file_data, node, data, LTO_section_function_body);
    1347                 :      74699 : }
    1348                 :            : 
    1349                 :            : /* Read the body of NODE using DATA.  FILE_DATA holds the global
    1350                 :            :    decls and types.  */
    1351                 :            : 
    1352                 :            : void
    1353                 :       9449 : lto_input_variable_constructor (struct lto_file_decl_data *file_data,
    1354                 :            :                                 struct varpool_node *node, const char *data)
    1355                 :            : {
    1356                 :       9449 :   lto_read_body_or_constructor (file_data, node, data, LTO_section_function_body);
    1357                 :       9449 : }
    1358                 :            : 
    1359                 :            : 
    1360                 :            : /* Queue of acummulated decl -> DIE mappings.  Similar to locations those
    1361                 :            :    are only applied to prevailing tree nodes during tree merging.  */
    1362                 :            : vec<dref_entry> dref_queue;
    1363                 :            : 
    1364                 :            : /* Read the physical representation of a tree node EXPR from
    1365                 :            :    input block IB using the per-file context in DATA_IN.  */
    1366                 :            : 
    1367                 :            : static void
    1368                 :    2890740 : lto_read_tree_1 (class lto_input_block *ib, class data_in *data_in, tree expr)
    1369                 :            : {
    1370                 :            :   /* Read all the bitfield values in EXPR.  Note that for LTO, we
    1371                 :            :      only write language-independent bitfields, so no more unpacking is
    1372                 :            :      needed.  */
    1373                 :    2890740 :   streamer_read_tree_bitfields (ib, data_in, expr);
    1374                 :            : 
    1375                 :            :   /* Read all the pointer fields in EXPR.  */
    1376                 :    2890740 :   streamer_read_tree_body (ib, data_in, expr);
    1377                 :            : 
    1378                 :            :   /* Read any LTO-specific data not read by the tree streamer.  */
    1379                 :    2890740 :   if (DECL_P (expr)
    1380                 :     560669 :       && TREE_CODE (expr) != FUNCTION_DECL
    1381                 :     400424 :       && TREE_CODE (expr) != TRANSLATION_UNIT_DECL)
    1382                 :     384980 :     DECL_INITIAL (expr) = stream_read_tree (ib, data_in);
    1383                 :            : 
    1384                 :            :   /* Stream references to early generated DIEs.  Keep in sync with the
    1385                 :            :      trees handled in dwarf2out_register_external_die.  */
    1386                 :    2890740 :   if ((DECL_P (expr)
    1387                 :     560669 :        && TREE_CODE (expr) != FIELD_DECL
    1388                 :     498405 :        && TREE_CODE (expr) != DEBUG_EXPR_DECL
    1389                 :     497999 :        && TREE_CODE (expr) != TYPE_DECL)
    1390                 :    2409270 :       || TREE_CODE (expr) == BLOCK)
    1391                 :            :     {
    1392                 :     613747 :       const char *str = streamer_read_string (data_in, ib);
    1393                 :     613747 :       if (str)
    1394                 :            :         {
    1395                 :      38013 :           unsigned HOST_WIDE_INT off = streamer_read_uhwi (ib);
    1396                 :      38013 :           dref_entry e = { expr, str, off };
    1397                 :      38013 :           dref_queue.safe_push (e);
    1398                 :            :         }
    1399                 :            :     }
    1400                 :    2890740 : }
    1401                 :            : 
    1402                 :            : /* Read the physical representation of a tree node with tag TAG from
    1403                 :            :    input block IB using the per-file context in DATA_IN.  */
    1404                 :            : 
    1405                 :            : static tree
    1406                 :    2743510 : lto_read_tree (class lto_input_block *ib, class data_in *data_in,
    1407                 :            :                enum LTO_tags tag, hashval_t hash)
    1408                 :            : {
    1409                 :            :   /* Instantiate a new tree node.  */
    1410                 :    2743510 :   tree result = streamer_alloc_tree (ib, data_in, tag);
    1411                 :            : 
    1412                 :            :   /* Enter RESULT in the reader cache.  This will make RESULT
    1413                 :            :      available so that circular references in the rest of the tree
    1414                 :            :      structure can be resolved in subsequent calls to stream_read_tree.  */
    1415                 :    2743510 :   streamer_tree_cache_append (data_in->reader_cache, result, hash);
    1416                 :            : 
    1417                 :    2743510 :   lto_read_tree_1 (ib, data_in, result);
    1418                 :            : 
    1419                 :    2743510 :   /* end_marker = */ streamer_read_uchar (ib);
    1420                 :            : 
    1421                 :    2743510 :   return result;
    1422                 :            : }
    1423                 :            : 
    1424                 :            : 
    1425                 :            : /* Populate the reader cache with trees materialized from the SCC
    1426                 :            :    following in the IB, DATA_IN stream.  */
    1427                 :            : 
    1428                 :            : hashval_t
    1429                 :    3339290 : lto_input_scc (class lto_input_block *ib, class data_in *data_in,
    1430                 :            :                unsigned *len, unsigned *entry_len)
    1431                 :            : {
    1432                 :            :   /* A blob of unnamed tree nodes, fill the cache from it and
    1433                 :            :      recurse.  */
    1434                 :    3339290 :   unsigned size = streamer_read_uhwi (ib);
    1435                 :    3339290 :   hashval_t scc_hash = streamer_read_uhwi (ib);
    1436                 :    3339290 :   unsigned scc_entry_len = 1;
    1437                 :            : 
    1438                 :    3339290 :   if (size == 1)
    1439                 :            :     {
    1440                 :    3301940 :       enum LTO_tags tag = streamer_read_record_start (ib);
    1441                 :    3301940 :       lto_input_tree_1 (ib, data_in, tag, scc_hash);
    1442                 :            :     }
    1443                 :            :   else
    1444                 :            :     {
    1445                 :      37349 :       unsigned int first = data_in->reader_cache->nodes.length ();
    1446                 :      37349 :       tree result;
    1447                 :            : 
    1448                 :      37349 :       scc_entry_len = streamer_read_uhwi (ib);
    1449                 :            : 
    1450                 :            :       /* Materialize size trees by reading their headers.  */
    1451                 :     184579 :       for (unsigned i = 0; i < size; ++i)
    1452                 :            :         {
    1453                 :     147230 :           enum LTO_tags tag = streamer_read_record_start (ib);
    1454                 :     147230 :           if (tag == LTO_null
    1455                 :     147230 :               || (tag >= LTO_field_decl_ref && tag <= LTO_global_decl_ref)
    1456                 :     147230 :               || tag == LTO_tree_pickle_reference
    1457                 :     147230 :               || tag == LTO_integer_cst
    1458                 :     147230 :               || tag == LTO_tree_scc)
    1459                 :          0 :             gcc_unreachable ();
    1460                 :            : 
    1461                 :     147230 :           result = streamer_alloc_tree (ib, data_in, tag);
    1462                 :     147230 :           streamer_tree_cache_append (data_in->reader_cache, result, 0);
    1463                 :            :         }
    1464                 :            : 
    1465                 :            :       /* Read the tree bitpacks and references.  */
    1466                 :     184579 :       for (unsigned i = 0; i < size; ++i)
    1467                 :            :         {
    1468                 :     147230 :           result = streamer_tree_cache_get_tree (data_in->reader_cache,
    1469                 :            :                                                  first + i);
    1470                 :     147230 :           lto_read_tree_1 (ib, data_in, result);
    1471                 :     147230 :           /* end_marker = */ streamer_read_uchar (ib);
    1472                 :            :         }
    1473                 :            :     }
    1474                 :            : 
    1475                 :    3339290 :   *len = size;
    1476                 :    3339290 :   *entry_len = scc_entry_len;
    1477                 :    3339290 :   return scc_hash;
    1478                 :            : }
    1479                 :            : 
    1480                 :            : 
    1481                 :            : /* Read a tree from input block IB using the per-file context in
    1482                 :            :    DATA_IN.  This context is used, for example, to resolve references
    1483                 :            :    to previously read nodes.  */
    1484                 :            : 
    1485                 :            : tree
    1486                 :   23341900 : lto_input_tree_1 (class lto_input_block *ib, class data_in *data_in,
    1487                 :            :                   enum LTO_tags tag, hashval_t hash)
    1488                 :            : {
    1489                 :   23341900 :   tree result;
    1490                 :            : 
    1491                 :   23341900 :   gcc_assert ((unsigned) tag < (unsigned) LTO_NUM_TAGS);
    1492                 :            : 
    1493                 :   23341900 :   if (tag == LTO_null)
    1494                 :            :     result = NULL_TREE;
    1495                 :   16404700 :   else if (tag >= LTO_field_decl_ref && tag <= LTO_namelist_decl_ref)
    1496                 :            :     {
    1497                 :            :       /* If TAG is a reference to an indexable tree, the next value
    1498                 :            :          in IB is the index into the table where we expect to find
    1499                 :            :          that tree.  */
    1500                 :    4421090 :       result = lto_input_tree_ref (ib, data_in, cfun, tag);
    1501                 :            :     }
    1502                 :   11983600 :   else if (tag == LTO_tree_pickle_reference)
    1503                 :            :     {
    1504                 :            :       /* If TAG is a reference to a previously read tree, look it up in
    1505                 :            :          the reader cache.  */
    1506                 :    8681640 :       result = streamer_get_pickled_tree (ib, data_in);
    1507                 :            :     }
    1508                 :    3301940 :   else if (tag == LTO_integer_cst)
    1509                 :            :     {
    1510                 :            :       /* For shared integer constants in singletons we can use the
    1511                 :            :          existing tree integer constant merging code.  */
    1512                 :     558432 :       tree type = stream_read_tree (ib, data_in);
    1513                 :     558432 :       unsigned HOST_WIDE_INT len = streamer_read_uhwi (ib);
    1514                 :     558432 :       unsigned HOST_WIDE_INT i;
    1515                 :     558432 :       HOST_WIDE_INT a[WIDE_INT_MAX_ELTS];
    1516                 :            : 
    1517                 :    1120680 :       for (i = 0; i < len; i++)
    1518                 :     562245 :         a[i] = streamer_read_hwi (ib);
    1519                 :     558432 :       gcc_assert (TYPE_PRECISION (type) <= MAX_BITSIZE_MODE_ANY_INT);
    1520                 :     558432 :       result = wide_int_to_tree (type, wide_int::from_array
    1521                 :     558432 :                                  (a, len, TYPE_PRECISION (type)));
    1522                 :     558432 :       streamer_tree_cache_append (data_in->reader_cache, result, hash);
    1523                 :            :     }
    1524                 :    2743510 :   else if (tag == LTO_tree_scc)
    1525                 :          0 :     gcc_unreachable ();
    1526                 :            :   else
    1527                 :            :     {
    1528                 :            :       /* Otherwise, materialize a new node from IB.  */
    1529                 :    2743510 :       result = lto_read_tree (ib, data_in, tag, hash);
    1530                 :            :     }
    1531                 :            : 
    1532                 :   23341900 :   return result;
    1533                 :            : }
    1534                 :            : 
    1535                 :            : tree
    1536                 :   19690400 : lto_input_tree (class lto_input_block *ib, class data_in *data_in)
    1537                 :            : {
    1538                 :   21554600 :   enum LTO_tags tag;
    1539                 :            : 
    1540                 :            :   /* Input and skip SCCs.  */
    1541                 :   21554600 :   while ((tag = streamer_read_record_start (ib)) == LTO_tree_scc)
    1542                 :            :     {
    1543                 :    1864180 :       unsigned len, entry_len;
    1544                 :    1864180 :       lto_input_scc (ib, data_in, &len, &entry_len);
    1545                 :            : 
    1546                 :            :       /* Register DECLs with the debuginfo machinery.  */
    1547                 :    1881160 :       while (!dref_queue.is_empty ())
    1548                 :            :         {
    1549                 :      16983 :           dref_entry e = dref_queue.pop ();
    1550                 :      16983 :           debug_hooks->register_external_die (e.decl, e.sym, e.off);
    1551                 :            :         }
    1552                 :            :     }
    1553                 :   19690400 :   return lto_input_tree_1 (ib, data_in, tag, 0);
    1554                 :            : }
    1555                 :            : 
    1556                 :            : 
    1557                 :            : /* Input toplevel asms.  */
    1558                 :            : 
    1559                 :            : void
    1560                 :      14946 : lto_input_toplevel_asms (struct lto_file_decl_data *file_data, int order_base)
    1561                 :            : {
    1562                 :      14946 :   size_t len;
    1563                 :      14946 :   const char *data
    1564                 :      14946 :     = lto_get_summary_section_data (file_data, LTO_section_asm, &len);
    1565                 :      14946 :   const struct lto_simple_header_with_strings *header
    1566                 :            :     = (const struct lto_simple_header_with_strings *) data;
    1567                 :      14946 :   int string_offset;
    1568                 :      14946 :   class data_in *data_in;
    1569                 :      14946 :   tree str;
    1570                 :            : 
    1571                 :      14946 :   if (! data)
    1572                 :      14926 :     return;
    1573                 :            : 
    1574                 :         20 :   string_offset = sizeof (*header) + header->main_size;
    1575                 :            : 
    1576                 :         20 :   lto_input_block ib (data + sizeof (*header), header->main_size,
    1577                 :         20 :                       file_data->mode_table);
    1578                 :            : 
    1579                 :         20 :   data_in = lto_data_in_create (file_data, data + string_offset,
    1580                 :         20 :                               header->string_size, vNULL);
    1581                 :            : 
    1582                 :         40 :   while ((str = streamer_read_string_cst (data_in, &ib)))
    1583                 :            :     {
    1584                 :         20 :       asm_node *node = symtab->finalize_toplevel_asm (str);
    1585                 :         20 :       node->order = streamer_read_hwi (&ib) + order_base;
    1586                 :         20 :       if (node->order >= symtab->order)
    1587                 :          1 :         symtab->order = node->order + 1;
    1588                 :            :     }
    1589                 :            : 
    1590                 :         20 :   lto_data_in_delete (data_in);
    1591                 :            : 
    1592                 :         20 :   lto_free_section_data (file_data, LTO_section_asm, NULL, data, len);
    1593                 :            : }
    1594                 :            : 
    1595                 :            : 
    1596                 :            : /* Input mode table.  */
    1597                 :            : 
    1598                 :            : void
    1599                 :          0 : lto_input_mode_table (struct lto_file_decl_data *file_data)
    1600                 :            : {
    1601                 :          0 :   size_t len;
    1602                 :          0 :   const char *data
    1603                 :          0 :     = lto_get_summary_section_data (file_data, LTO_section_mode_table, &len);
    1604                 :          0 :   if (! data)
    1605                 :            :     {
    1606                 :          0 :       internal_error ("cannot read LTO mode table from %s",
    1607                 :            :                       file_data->file_name);
    1608                 :            :       return;
    1609                 :            :     }
    1610                 :            : 
    1611                 :          0 :   unsigned char *table = ggc_cleared_vec_alloc<unsigned char> (1 << 8);
    1612                 :          0 :   file_data->mode_table = table;
    1613                 :          0 :   const struct lto_simple_header_with_strings *header
    1614                 :            :     = (const struct lto_simple_header_with_strings *) data;
    1615                 :          0 :   int string_offset;
    1616                 :          0 :   class data_in *data_in;
    1617                 :          0 :   string_offset = sizeof (*header) + header->main_size;
    1618                 :            : 
    1619                 :          0 :   lto_input_block ib (data + sizeof (*header), header->main_size, NULL);
    1620                 :          0 :   data_in = lto_data_in_create (file_data, data + string_offset,
    1621                 :          0 :                                 header->string_size, vNULL);
    1622                 :          0 :   bitpack_d bp = streamer_read_bitpack (&ib);
    1623                 :            : 
    1624                 :          0 :   table[VOIDmode] = VOIDmode;
    1625                 :          0 :   table[BLKmode] = BLKmode;
    1626                 :          0 :   unsigned int m;
    1627                 :          0 :   while ((m = bp_unpack_value (&bp, 8)) != VOIDmode)
    1628                 :            :     {
    1629                 :          0 :       enum mode_class mclass
    1630                 :          0 :         = bp_unpack_enum (&bp, mode_class, MAX_MODE_CLASS);
    1631                 :          0 :       poly_uint16 size = bp_unpack_poly_value (&bp, 16);
    1632                 :          0 :       poly_uint16 prec = bp_unpack_poly_value (&bp, 16);
    1633                 :          0 :       machine_mode inner = (machine_mode) bp_unpack_value (&bp, 8);
    1634                 :          0 :       poly_uint16 nunits = bp_unpack_poly_value (&bp, 16);
    1635                 :          0 :       unsigned int ibit = 0, fbit = 0;
    1636                 :          0 :       unsigned int real_fmt_len = 0;
    1637                 :          0 :       const char *real_fmt_name = NULL;
    1638                 :          0 :       switch (mclass)
    1639                 :            :         {
    1640                 :          0 :         case MODE_FRACT:
    1641                 :          0 :         case MODE_UFRACT:
    1642                 :          0 :         case MODE_ACCUM:
    1643                 :          0 :         case MODE_UACCUM:
    1644                 :          0 :           ibit = bp_unpack_value (&bp, 8);
    1645                 :          0 :           fbit = bp_unpack_value (&bp, 8);
    1646                 :          0 :           break;
    1647                 :          0 :         case MODE_FLOAT:
    1648                 :          0 :         case MODE_DECIMAL_FLOAT:
    1649                 :          0 :           real_fmt_name = bp_unpack_indexed_string (data_in, &bp,
    1650                 :            :                                                     &real_fmt_len);
    1651                 :          0 :           break;
    1652                 :            :         default:
    1653                 :            :           break;
    1654                 :            :         }
    1655                 :            :       /* First search just the GET_CLASS_NARROWEST_MODE to wider modes,
    1656                 :            :          if not found, fallback to all modes.  */
    1657                 :          0 :       int pass;
    1658                 :          0 :       for (pass = 0; pass < 2; pass++)
    1659                 :          0 :         for (machine_mode mr = pass ? VOIDmode
    1660                 :          0 :                                     : GET_CLASS_NARROWEST_MODE (mclass);
    1661                 :          0 :              pass ? mr < MAX_MACHINE_MODE : mr != VOIDmode;
    1662                 :          0 :              pass ? mr = (machine_mode) (mr + 1)
    1663                 :          0 :                   : mr = GET_MODE_WIDER_MODE (mr).else_void ())
    1664                 :          0 :           if (GET_MODE_CLASS (mr) != mclass
    1665                 :          0 :               || maybe_ne (GET_MODE_SIZE (mr), size)
    1666                 :          0 :               || maybe_ne (GET_MODE_PRECISION (mr), prec)
    1667                 :          0 :               || (inner == m
    1668                 :          0 :                   ? GET_MODE_INNER (mr) != mr
    1669                 :          0 :                   : GET_MODE_INNER (mr) != table[(int) inner])
    1670                 :          0 :               || GET_MODE_IBIT (mr) != ibit
    1671                 :          0 :               || GET_MODE_FBIT (mr) != fbit
    1672                 :          0 :               || maybe_ne (GET_MODE_NUNITS (mr), nunits))
    1673                 :          0 :             continue;
    1674                 :          0 :           else if ((mclass == MODE_FLOAT || mclass == MODE_DECIMAL_FLOAT)
    1675                 :          0 :                    && strcmp (REAL_MODE_FORMAT (mr)->name, real_fmt_name) != 0)
    1676                 :          0 :             continue;
    1677                 :            :           else
    1678                 :            :             {
    1679                 :          0 :               table[m] = mr;
    1680                 :          0 :               pass = 2;
    1681                 :          0 :               break;
    1682                 :            :             }
    1683                 :          0 :       unsigned int mname_len;
    1684                 :          0 :       const char *mname = bp_unpack_indexed_string (data_in, &bp, &mname_len);
    1685                 :          0 :       if (pass == 2)
    1686                 :            :         {
    1687                 :          0 :           switch (mclass)
    1688                 :            :             {
    1689                 :          0 :             case MODE_VECTOR_BOOL:
    1690                 :          0 :             case MODE_VECTOR_INT:
    1691                 :          0 :             case MODE_VECTOR_FLOAT:
    1692                 :          0 :             case MODE_VECTOR_FRACT:
    1693                 :          0 :             case MODE_VECTOR_UFRACT:
    1694                 :          0 :             case MODE_VECTOR_ACCUM:
    1695                 :          0 :             case MODE_VECTOR_UACCUM:
    1696                 :            :               /* For unsupported vector modes just use BLKmode,
    1697                 :            :                  if the scalar mode is supported.  */
    1698                 :          0 :               if (table[(int) inner] != VOIDmode)
    1699                 :            :                 {
    1700                 :          0 :                   table[m] = BLKmode;
    1701                 :          0 :                   break;
    1702                 :            :                 }
    1703                 :            :               /* FALLTHRU */
    1704                 :          0 :             default:
    1705                 :            :               /* This is only used for offloading-target compilations and
    1706                 :            :                  is a user-facing error.  Give a better error message for
    1707                 :            :                  the common modes; see also mode-classes.def.   */
    1708                 :          0 :               if (mclass == MODE_FLOAT)
    1709                 :          0 :                 fatal_error (UNKNOWN_LOCATION,
    1710                 :            :                              "%s - %u-bit-precision floating-point numbers "
    1711                 :            :                              "unsupported (mode %qs)", TARGET_MACHINE,
    1712                 :          0 :                              prec.to_constant (), mname);
    1713                 :          0 :               else if (mclass == MODE_DECIMAL_FLOAT)
    1714                 :          0 :                 fatal_error (UNKNOWN_LOCATION,
    1715                 :            :                              "%s - %u-bit-precision decimal floating-point "
    1716                 :            :                              "numbers unsupported (mode %qs)", TARGET_MACHINE,
    1717                 :          0 :                              prec.to_constant (), mname);
    1718                 :          0 :               else if (mclass == MODE_COMPLEX_FLOAT)
    1719                 :          0 :                 fatal_error (UNKNOWN_LOCATION,
    1720                 :            :                              "%s - %u-bit-precision complex floating-point "
    1721                 :            :                              "numbers unsupported (mode %qs)", TARGET_MACHINE,
    1722                 :          0 :                              prec.to_constant (), mname);
    1723                 :          0 :               else if (mclass == MODE_INT)
    1724                 :          0 :                 fatal_error (UNKNOWN_LOCATION,
    1725                 :            :                              "%s - %u-bit integer numbers unsupported (mode "
    1726                 :          0 :                              "%qs)", TARGET_MACHINE, prec.to_constant (), mname);
    1727                 :            :               else
    1728                 :          0 :                 fatal_error (UNKNOWN_LOCATION, "%s - unsupported mode %qs",
    1729                 :            :                              TARGET_MACHINE, mname);
    1730                 :          0 :               break;
    1731                 :            :             }
    1732                 :            :         }
    1733                 :            :     }
    1734                 :          0 :   lto_data_in_delete (data_in);
    1735                 :            : 
    1736                 :          0 :   lto_free_section_data (file_data, LTO_section_mode_table, NULL, data, len);
    1737                 :            : }
    1738                 :            : 
    1739                 :            : 
    1740                 :            : /* Initialization for the LTO reader.  */
    1741                 :            : 
    1742                 :            : void
    1743                 :      14009 : lto_reader_init (void)
    1744                 :            : {
    1745                 :      14009 :   lto_streamer_init ();
    1746                 :      14009 :   file_name_hash_table
    1747                 :      14009 :     = new hash_table<string_slot_hasher> (37);
    1748                 :      28018 :   string_slot_allocator = new object_allocator <struct string_slot>
    1749                 :      14009 :                                 ("line map file name hash");
    1750                 :      14009 :   gcc_obstack_init (&file_name_obstack);
    1751                 :      14009 : }
    1752                 :            : 
    1753                 :            : /* Free hash table used to stream in location file names.  */
    1754                 :            : 
    1755                 :            : void
    1756                 :       5033 : lto_free_file_name_hash (void)
    1757                 :            : {
    1758                 :       5033 :   delete file_name_hash_table;
    1759                 :       5033 :   file_name_hash_table = NULL;
    1760                 :      10066 :   delete string_slot_allocator;
    1761                 :       5033 :   string_slot_allocator = NULL;
    1762                 :            :   /* file_name_obstack must stay allocated since it is referred to by
    1763                 :            :      line map table.  */
    1764                 :       5033 : }
    1765                 :            : 
    1766                 :            : 
    1767                 :            : /* Create a new data_in object for FILE_DATA. STRINGS is the string
    1768                 :            :    table to use with LEN strings.  RESOLUTIONS is the vector of linker
    1769                 :            :    resolutions (NULL if not using a linker plugin).  */
    1770                 :            : 
    1771                 :            : class data_in *
    1772                 :     147035 : lto_data_in_create (struct lto_file_decl_data *file_data, const char *strings,
    1773                 :            :                     unsigned len,
    1774                 :            :                     vec<ld_plugin_symbol_resolution_t> resolutions)
    1775                 :            : {
    1776                 :     147035 :   class data_in *data_in = new (class data_in);
    1777                 :     147035 :   data_in->file_data = file_data;
    1778                 :     147035 :   data_in->strings = strings;
    1779                 :     147035 :   data_in->strings_len = len;
    1780                 :     147035 :   data_in->globals_resolution = resolutions;
    1781                 :     147035 :   data_in->reader_cache = streamer_tree_cache_create (false, false, true);
    1782                 :     147035 :   return data_in;
    1783                 :            : }
    1784                 :            : 
    1785                 :            : 
    1786                 :            : /* Remove DATA_IN.  */
    1787                 :            : 
    1788                 :            : void
    1789                 :     147035 : lto_data_in_delete (class data_in *data_in)
    1790                 :            : {
    1791                 :     147035 :   data_in->globals_resolution.release ();
    1792                 :     147035 :   streamer_tree_cache_delete (data_in->reader_cache);
    1793                 :     147035 :   delete data_in;
    1794                 :     147035 : }

Generated by: LCOV version 1.0

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 --enable-host-shared. GCC test suite is run with the built compiler.