LCOV - code coverage report
Current view: top level - gcc - lto-streamer-out.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 1419 1558 91.1 %
Date: 2020-04-04 11:58:09 Functions: 50 53 94.3 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Write the GIMPLE representation to 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 "tree-pass.h"
      32                 :            : #include "ssa.h"
      33                 :            : #include "gimple-streamer.h"
      34                 :            : #include "alias.h"
      35                 :            : #include "stor-layout.h"
      36                 :            : #include "gimple-iterator.h"
      37                 :            : #include "except.h"
      38                 :            : #include "lto-symtab.h"
      39                 :            : #include "cgraph.h"
      40                 :            : #include "cfgloop.h"
      41                 :            : #include "builtins.h"
      42                 :            : #include "gomp-constants.h"
      43                 :            : #include "debug.h"
      44                 :            : #include "omp-offload.h"
      45                 :            : #include "print-tree.h"
      46                 :            : #include "tree-dfa.h"
      47                 :            : #include "file-prefix-map.h" /* remap_debug_filename()  */
      48                 :            : #include "output.h"
      49                 :            : 
      50                 :            : 
      51                 :            : static void lto_write_tree (struct output_block*, tree, bool);
      52                 :            : 
      53                 :            : /* Clear the line info stored in DATA_IN.  */
      54                 :            : 
      55                 :            : static void
      56                 :     324712 : clear_line_info (struct output_block *ob)
      57                 :            : {
      58                 :     324712 :   ob->current_file = NULL;
      59                 :     324712 :   ob->current_line = 0;
      60                 :     324712 :   ob->current_col = 0;
      61                 :     324712 :   ob->current_sysp = false;
      62                 :          0 : }
      63                 :            : 
      64                 :            : 
      65                 :            : /* Create the output block and return it.  SECTION_TYPE is
      66                 :            :    LTO_section_function_body or LTO_static_initializer.  */
      67                 :            : 
      68                 :            : struct output_block *
      69                 :     221074 : create_output_block (enum lto_section_type section_type)
      70                 :            : {
      71                 :     221074 :   struct output_block *ob = XCNEW (struct output_block);
      72                 :     221074 :   if (streamer_dump_file)
      73                 :         36 :     fprintf (streamer_dump_file, "Creating output block for %s\n",
      74                 :         36 :              lto_section_name [section_type]);
      75                 :            : 
      76                 :     221074 :   ob->section_type = section_type;
      77                 :     221074 :   ob->decl_state = lto_get_out_decl_state ();
      78                 :     221074 :   ob->main_stream = XCNEW (struct lto_output_stream);
      79                 :     221074 :   ob->string_stream = XCNEW (struct lto_output_stream);
      80                 :     221074 :   ob->writer_cache = streamer_tree_cache_create (!flag_wpa, true, false);
      81                 :            : 
      82                 :     221074 :   if (section_type == LTO_section_function_body)
      83                 :     103638 :     ob->cfg_stream = XCNEW (struct lto_output_stream);
      84                 :            : 
      85                 :     221074 :   clear_line_info (ob);
      86                 :            : 
      87                 :     221074 :   ob->string_hash_table = new hash_table<string_slot_hasher> (37);
      88                 :     221074 :   gcc_obstack_init (&ob->obstack);
      89                 :            : 
      90                 :     221074 :   return ob;
      91                 :            : }
      92                 :            : 
      93                 :            : 
      94                 :            : /* Destroy the output block OB.  */
      95                 :            : 
      96                 :            : void
      97                 :     221074 : destroy_output_block (struct output_block *ob)
      98                 :            : {
      99                 :     221074 :   enum lto_section_type section_type = ob->section_type;
     100                 :            : 
     101                 :     221074 :   delete ob->string_hash_table;
     102                 :     221074 :   ob->string_hash_table = NULL;
     103                 :            : 
     104                 :     221074 :   free (ob->main_stream);
     105                 :     221074 :   free (ob->string_stream);
     106                 :     221074 :   if (section_type == LTO_section_function_body)
     107                 :     103638 :     free (ob->cfg_stream);
     108                 :            : 
     109                 :     221074 :   streamer_tree_cache_delete (ob->writer_cache);
     110                 :     221074 :   obstack_free (&ob->obstack, NULL);
     111                 :            : 
     112                 :     221074 :   free (ob);
     113                 :     221074 : }
     114                 :            : 
     115                 :            : 
     116                 :            : /* Look up NODE in the type table and write the index for it to OB.  */
     117                 :            : 
     118                 :            : static void
     119                 :    4168700 : output_type_ref (struct output_block *ob, tree node)
     120                 :            : {
     121                 :    4168700 :   streamer_write_record_start (ob, LTO_type_ref);
     122                 :    4168700 :   lto_output_type_ref_index (ob->decl_state, ob->main_stream, node);
     123                 :    4168700 : }
     124                 :            : 
     125                 :            : /* Wrapper around variably_modified_type_p avoiding type modification
     126                 :            :    during WPA streaming.  */
     127                 :            : 
     128                 :            : static bool
     129                 :    9115150 : lto_variably_modified_type_p (tree type)
     130                 :            : {
     131                 :    9115150 :   return (in_lto_p
     132                 :   18230300 :           ? TYPE_LANG_FLAG_0 (TYPE_MAIN_VARIANT (type))
     133                 :    8920570 :           : variably_modified_type_p (type, NULL_TREE));
     134                 :            : }
     135                 :            : 
     136                 :            : 
     137                 :            : /* Return true if tree node T is written to various tables.  For these
     138                 :            :    nodes, we sometimes want to write their phyiscal representation
     139                 :            :    (via lto_output_tree), and sometimes we need to emit an index
     140                 :            :    reference into a table (via lto_output_tree_ref).  */
     141                 :            : 
     142                 :            : static bool
     143                 :   26079200 : tree_is_indexable (tree t)
     144                 :            : {
     145                 :            :   /* Parameters and return values of functions of variably modified types
     146                 :            :      must go to global stream, because they may be used in the type
     147                 :            :      definition.  */
     148                 :   26079200 :   if ((TREE_CODE (t) == PARM_DECL || TREE_CODE (t) == RESULT_DECL)
     149                 :   27401700 :       && DECL_CONTEXT (t))
     150                 :    1322530 :     return lto_variably_modified_type_p (TREE_TYPE (DECL_CONTEXT (t)));
     151                 :            :   /* IMPORTED_DECL is put into BLOCK and thus it never can be shared.
     152                 :            :      We should no longer need to stream it.  */
     153                 :   24756700 :   else if (TREE_CODE (t) == IMPORTED_DECL)
     154                 :          0 :     gcc_unreachable ();
     155                 :   24756700 :   else if (TREE_CODE (t) == LABEL_DECL)
     156                 :     100317 :     return FORCED_LABEL (t) || DECL_NONLOCAL (t);
     157                 :   24703900 :   else if (((VAR_P (t) && !TREE_STATIC (t))
     158                 :   24119400 :             || TREE_CODE (t) == TYPE_DECL
     159                 :   24119400 :             || TREE_CODE (t) == CONST_DECL
     160                 :   24119000 :             || TREE_CODE (t) == NAMELIST_DECL)
     161                 :   24704200 :            && decl_function_context (t))
     162                 :            :     return false;
     163                 :   24126300 :   else if (TREE_CODE (t) == DEBUG_EXPR_DECL)
     164                 :            :     return false;
     165                 :            :   /* Variably modified types need to be streamed alongside function
     166                 :            :      bodies because they can refer to local entities.  Together with
     167                 :            :      them we have to localize their members as well.
     168                 :            :      ???  In theory that includes non-FIELD_DECLs as well.  */
     169                 :   24123800 :   else if (TYPE_P (t)
     170                 :   24123800 :            && lto_variably_modified_type_p (t))
     171                 :            :     return false;
     172                 :   24108100 :   else if (TREE_CODE (t) == FIELD_DECL
     173                 :   24679600 :            && lto_variably_modified_type_p (DECL_CONTEXT (t)))
     174                 :            :     return false;
     175                 :            :   else
     176                 :   36295800 :     return (TYPE_P (t) || DECL_P (t) || TREE_CODE (t) == SSA_NAME);
     177                 :            : }
     178                 :            : 
     179                 :            : 
     180                 :            : /* Output info about new location into bitpack BP.
     181                 :            :    After outputting bitpack, lto_output_location_data has
     182                 :            :    to be done to output actual data.  */
     183                 :            : 
     184                 :            : void
     185                 :    4038410 : lto_output_location (struct output_block *ob, struct bitpack_d *bp,
     186                 :            :                      location_t loc)
     187                 :            : {
     188                 :    4038410 :   expanded_location xloc;
     189                 :            : 
     190                 :    4038410 :   loc = LOCATION_LOCUS (loc);
     191                 :    5033500 :   bp_pack_int_in_range (bp, 0, RESERVED_LOCATION_COUNT,
     192                 :            :                         loc < RESERVED_LOCATION_COUNT
     193                 :            :                         ? loc : RESERVED_LOCATION_COUNT);
     194                 :    4038410 :   if (loc < RESERVED_LOCATION_COUNT)
     195                 :     995088 :     return;
     196                 :            : 
     197                 :    3043320 :   xloc = expand_location (loc);
     198                 :            : 
     199                 :    3043320 :   bp_pack_value (bp, ob->current_file != xloc.file, 1);
     200                 :    3043320 :   bp_pack_value (bp, ob->current_line != xloc.line, 1);
     201                 :    3043320 :   bp_pack_value (bp, ob->current_col != xloc.column, 1);
     202                 :            : 
     203                 :    3043320 :   if (ob->current_file != xloc.file)
     204                 :            :     {
     205                 :     161821 :       bp_pack_string (ob, bp, remap_debug_filename (xloc.file), true);
     206                 :     161821 :       bp_pack_value (bp, xloc.sysp, 1);
     207                 :            :     }
     208                 :    3043320 :   ob->current_file = xloc.file;
     209                 :    3043320 :   ob->current_sysp = xloc.sysp;
     210                 :            : 
     211                 :    3043320 :   if (ob->current_line != xloc.line)
     212                 :     617715 :     bp_pack_var_len_unsigned (bp, xloc.line);
     213                 :    3043320 :   ob->current_line = xloc.line;
     214                 :            : 
     215                 :    3043320 :   if (ob->current_col != xloc.column)
     216                 :     748019 :     bp_pack_var_len_unsigned (bp, xloc.column);
     217                 :    3043320 :   ob->current_col = xloc.column;
     218                 :            : }
     219                 :            : 
     220                 :            : 
     221                 :            : /* If EXPR is an indexable tree node, output a reference to it to
     222                 :            :    output block OB.  Otherwise, output the physical representation of
     223                 :            :    EXPR to OB.  */
     224                 :            : 
     225                 :            : static void
     226                 :    7214410 : lto_output_tree_ref (struct output_block *ob, tree expr)
     227                 :            : {
     228                 :    7214410 :   enum tree_code code;
     229                 :            : 
     230                 :    7214410 :   if (TYPE_P (expr))
     231                 :            :     {
     232                 :    4168700 :       output_type_ref (ob, expr);
     233                 :    4168700 :       return;
     234                 :            :     }
     235                 :            : 
     236                 :    3045700 :   code = TREE_CODE (expr);
     237                 :    3045700 :   switch (code)
     238                 :            :     {
     239                 :    1477760 :     case SSA_NAME:
     240                 :    1477760 :       streamer_write_record_start (ob, LTO_ssa_name_ref);
     241                 :    1477760 :       streamer_write_uhwi (ob, SSA_NAME_VERSION (expr));
     242                 :    1477760 :       break;
     243                 :            : 
     244                 :     285294 :     case FIELD_DECL:
     245                 :     285294 :       streamer_write_record_start (ob, LTO_field_decl_ref);
     246                 :     285294 :       lto_output_field_decl_index (ob->decl_state, ob->main_stream, expr);
     247                 :     285294 :       break;
     248                 :            : 
     249                 :    1062320 :     case FUNCTION_DECL:
     250                 :    1062320 :       streamer_write_record_start (ob, LTO_function_decl_ref);
     251                 :    1062320 :       lto_output_fn_decl_index (ob->decl_state, ob->main_stream, expr);
     252                 :    1062320 :       break;
     253                 :            : 
     254                 :     216357 :     case VAR_DECL:
     255                 :     216357 :     case DEBUG_EXPR_DECL:
     256                 :     216357 :       gcc_assert (decl_function_context (expr) == NULL || TREE_STATIC (expr));
     257                 :            :       /* FALLTHRU */
     258                 :     216375 :     case PARM_DECL:
     259                 :     216375 :       streamer_write_record_start (ob, LTO_global_decl_ref);
     260                 :     216375 :       lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
     261                 :     216375 :       break;
     262                 :            : 
     263                 :          0 :     case CONST_DECL:
     264                 :          0 :       streamer_write_record_start (ob, LTO_const_decl_ref);
     265                 :          0 :       lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
     266                 :          0 :       break;
     267                 :            : 
     268                 :          0 :     case IMPORTED_DECL:
     269                 :          0 :       gcc_assert (decl_function_context (expr) == NULL);
     270                 :          0 :       streamer_write_record_start (ob, LTO_imported_decl_ref);
     271                 :          0 :       lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
     272                 :          0 :       break;
     273                 :            : 
     274                 :          0 :     case TYPE_DECL:
     275                 :          0 :       streamer_write_record_start (ob, LTO_type_decl_ref);
     276                 :          0 :       lto_output_type_decl_index (ob->decl_state, ob->main_stream, expr);
     277                 :          0 :       break;
     278                 :            : 
     279                 :          0 :     case NAMELIST_DECL:
     280                 :          0 :       streamer_write_record_start (ob, LTO_namelist_decl_ref);
     281                 :          0 :       lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
     282                 :          0 :       break;
     283                 :            : 
     284                 :          0 :     case NAMESPACE_DECL:
     285                 :          0 :       streamer_write_record_start (ob, LTO_namespace_decl_ref);
     286                 :          0 :       lto_output_namespace_decl_index (ob->decl_state, ob->main_stream, expr);
     287                 :          0 :       break;
     288                 :            : 
     289                 :       3455 :     case LABEL_DECL:
     290                 :       3455 :       streamer_write_record_start (ob, LTO_label_decl_ref);
     291                 :       3455 :       lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
     292                 :       3455 :       break;
     293                 :            : 
     294                 :         18 :     case RESULT_DECL:
     295                 :         18 :       streamer_write_record_start (ob, LTO_result_decl_ref);
     296                 :         18 :       lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
     297                 :         18 :       break;
     298                 :            : 
     299                 :        484 :     case TRANSLATION_UNIT_DECL:
     300                 :        484 :       streamer_write_record_start (ob, LTO_translation_unit_decl_ref);
     301                 :        484 :       lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
     302                 :        484 :       break;
     303                 :            : 
     304                 :          0 :     default:
     305                 :            :       /* No other node is indexable, so it should have been handled by
     306                 :            :          lto_output_tree.  */
     307                 :          0 :       gcc_unreachable ();
     308                 :            :     }
     309                 :            : }
     310                 :            : 
     311                 :            : 
     312                 :            : /* Return true if EXPR is a tree node that can be written to disk.  */
     313                 :            : 
     314                 :            : static inline bool
     315                 :    5372380 : lto_is_streamable (tree expr)
     316                 :            : {
     317                 :    5372380 :   enum tree_code code = TREE_CODE (expr);
     318                 :            : 
     319                 :            :   /* Notice that we reject SSA_NAMEs as well.  We only emit the SSA
     320                 :            :      name version in lto_output_tree_ref (see output_ssa_names).  */
     321                 :    5372380 :   return !is_lang_specific (expr)
     322                 :    5372380 :          && code != SSA_NAME
     323                 :    5372380 :          && code != LANG_TYPE
     324                 :            :          && code != MODIFY_EXPR
     325                 :    5372380 :          && code != INIT_EXPR
     326                 :    5372380 :          && code != TARGET_EXPR
     327                 :    5372380 :          && code != BIND_EXPR
     328                 :    5372380 :          && code != WITH_CLEANUP_EXPR
     329                 :    5372380 :          && code != STATEMENT_LIST
     330                 :    5372380 :          && (code == CASE_LABEL_EXPR
     331                 :    5372380 :              || code == DECL_EXPR
     332                 :    5368590 :              || TREE_CODE_CLASS (code) != tcc_statement);
     333                 :            : }
     334                 :            : 
     335                 :            : /* Very rough estimate of streaming size of the initializer.  If we ignored
     336                 :            :    presence of strings, we could simply just count number of non-indexable
     337                 :            :    tree nodes and number of references to indexable nodes.  Strings however
     338                 :            :    may be very large and we do not want to dump them int othe global stream.
     339                 :            : 
     340                 :            :    Count the size of initializer until the size in DATA is positive.  */
     341                 :            : 
     342                 :            : static tree
     343                 :     102855 : subtract_estimated_size (tree *tp, int *ws, void *data)
     344                 :            : {
     345                 :     102855 :   long *sum = (long *)data;
     346                 :     102855 :   if (tree_is_indexable (*tp))
     347                 :            :     {
     348                 :            :       /* Indexable tree is one reference to global stream.
     349                 :            :          Guess it may be about 4 bytes.  */
     350                 :       1143 :       *sum -= 4;
     351                 :       1143 :       *ws = 0;
     352                 :            :     }
     353                 :            :   /* String table entry + base of tree node needs to be streamed.  */
     354                 :     102855 :   if (TREE_CODE (*tp) == STRING_CST)
     355                 :       6465 :     *sum -= TREE_STRING_LENGTH (*tp) + 8;
     356                 :            :   else
     357                 :            :     {
     358                 :            :       /* Identifiers are also variable length but should not appear
     359                 :            :          naked in constructor.  */
     360                 :      96390 :       gcc_checking_assert (TREE_CODE (*tp) != IDENTIFIER_NODE);
     361                 :            :       /* We do not really make attempt to work out size of pickled tree, as
     362                 :            :          it is very variable. Make it bigger than the reference.  */
     363                 :      96390 :       *sum -= 16;
     364                 :            :     }
     365                 :     102855 :   if (*sum < 0)
     366                 :      36816 :     return *tp;
     367                 :            :   return NULL_TREE;
     368                 :            : }
     369                 :            : 
     370                 :            : 
     371                 :            : /* For EXPR lookup and return what we want to stream to OB as DECL_INITIAL.  */
     372                 :            : 
     373                 :            : static tree
     374                 :    2079160 : get_symbol_initial_value (lto_symtab_encoder_t encoder, tree expr)
     375                 :            : {
     376                 :    2079160 :   gcc_checking_assert (DECL_P (expr)
     377                 :            :                        && TREE_CODE (expr) != FUNCTION_DECL
     378                 :            :                        && TREE_CODE (expr) != TRANSLATION_UNIT_DECL);
     379                 :            : 
     380                 :            :   /* Handle DECL_INITIAL for symbols.  */
     381                 :    2079160 :   tree initial = DECL_INITIAL (expr);
     382                 :    2079160 :   if (VAR_P (expr)
     383                 :     994896 :       && (TREE_STATIC (expr) || DECL_EXTERNAL (expr))
     384                 :     821586 :       && !DECL_IN_CONSTANT_POOL (expr)
     385                 :    2900690 :       && initial)
     386                 :            :     {
     387                 :      85785 :       varpool_node *vnode;
     388                 :            :       /* Extra section needs about 30 bytes; do not produce it for simple
     389                 :            :          scalar values.  */
     390                 :      85785 :       if (!(vnode = varpool_node::get (expr))
     391                 :      85785 :           || !lto_symtab_encoder_encode_initializer_p (encoder, vnode))
     392                 :       2947 :         initial = error_mark_node;
     393                 :      85785 :       if (initial != error_mark_node)
     394                 :            :         {
     395                 :      66831 :           long max_size = 30;
     396                 :      66831 :           if (walk_tree (&initial, subtract_estimated_size, (void *)&max_size,
     397                 :            :                          NULL))
     398                 :      36816 :             initial = error_mark_node;
     399                 :            :         }
     400                 :            :     }
     401                 :            : 
     402                 :    2079160 :   return initial;
     403                 :            : }
     404                 :            : 
     405                 :            : 
     406                 :            : /* Write a physical representation of tree node EXPR to output block
     407                 :            :    OB.  If REF_P is true, the leaves of EXPR are emitted as references
     408                 :            :    via lto_output_tree_ref.  IX is the index into the streamer cache
     409                 :            :    where EXPR is stored.  */
     410                 :            : 
     411                 :            : static void
     412                 :    5372380 : lto_write_tree_1 (struct output_block *ob, tree expr, bool ref_p)
     413                 :            : {
     414                 :            :   /* Pack all the non-pointer fields in EXPR into a bitpack and write
     415                 :            :      the resulting bitpack.  */
     416                 :    5372380 :   streamer_write_tree_bitfields (ob, expr);
     417                 :            : 
     418                 :            :   /* Write all the pointer fields in EXPR.  */
     419                 :    5372380 :   streamer_write_tree_body (ob, expr, ref_p);
     420                 :            : 
     421                 :            :   /* Write any LTO-specific data to OB.  */
     422                 :    5372380 :   if (DECL_P (expr)
     423                 :    1305900 :       && TREE_CODE (expr) != FUNCTION_DECL
     424                 :     923764 :       && TREE_CODE (expr) != TRANSLATION_UNIT_DECL)
     425                 :            :     {
     426                 :            :       /* Handle DECL_INITIAL for symbols.  */
     427                 :     901568 :       tree initial = get_symbol_initial_value
     428                 :     901568 :                          (ob->decl_state->symtab_node_encoder, expr);
     429                 :     901568 :       stream_write_tree (ob, initial, ref_p);
     430                 :            :     }
     431                 :            : 
     432                 :            :   /* Stream references to early generated DIEs.  Keep in sync with the
     433                 :            :      trees handled in dwarf2out_die_ref_for_decl.  */
     434                 :    5372380 :   if ((DECL_P (expr)
     435                 :    1305900 :        && TREE_CODE (expr) != FIELD_DECL
     436                 :    1211550 :        && TREE_CODE (expr) != DEBUG_EXPR_DECL
     437                 :    1211070 :        && TREE_CODE (expr) != TYPE_DECL)
     438                 :    4184790 :       || TREE_CODE (expr) == BLOCK)
     439                 :            :     {
     440                 :    1350780 :       const char *sym;
     441                 :    1350780 :       unsigned HOST_WIDE_INT off;
     442                 :    1350780 :       if (debug_info_level > DINFO_LEVEL_NONE
     443                 :    1350780 :           && debug_hooks->die_ref_for_decl (expr, &sym, &off))
     444                 :            :         {
     445                 :      40778 :           streamer_write_string (ob, ob->main_stream, sym, true);
     446                 :      40778 :           streamer_write_uhwi (ob, off);
     447                 :            :         }
     448                 :            :       else
     449                 :    1310000 :         streamer_write_string (ob, ob->main_stream, NULL, true);
     450                 :            :     }
     451                 :    5372380 : }
     452                 :            : 
     453                 :            : /* Write a physical representation of tree node EXPR to output block
     454                 :            :    OB.  If REF_P is true, the leaves of EXPR are emitted as references
     455                 :            :    via lto_output_tree_ref.  IX is the index into the streamer cache
     456                 :            :    where EXPR is stored.  */
     457                 :            : 
     458                 :            : static void
     459                 :    5142560 : lto_write_tree (struct output_block *ob, tree expr, bool ref_p)
     460                 :            : {
     461                 :    5142560 :   if (!lto_is_streamable (expr))
     462                 :          0 :     internal_error ("tree code %qs is not supported in LTO streams",
     463                 :          0 :                     get_tree_code_name (TREE_CODE (expr)));
     464                 :            : 
     465                 :            :   /* Write the header, containing everything needed to materialize
     466                 :            :      EXPR on the reading side.  */
     467                 :    5142560 :   streamer_write_tree_header (ob, expr);
     468                 :            : 
     469                 :    5142560 :   lto_write_tree_1 (ob, expr, ref_p);
     470                 :            : 
     471                 :            :   /* Mark the end of EXPR.  */
     472                 :    5142560 :   streamer_write_zero (ob);
     473                 :    5142560 : }
     474                 :            : 
     475                 :            : /* Emit the physical representation of tree node EXPR to output block OB,
     476                 :            :    If THIS_REF_P is true, the leaves of EXPR are emitted as references via
     477                 :            :    lto_output_tree_ref.  REF_P is used for streaming siblings of EXPR.  */
     478                 :            : 
     479                 :            : static void
     480                 :    6041360 : lto_output_tree_1 (struct output_block *ob, tree expr, hashval_t hash,
     481                 :            :                    bool ref_p, bool this_ref_p)
     482                 :            : {
     483                 :    6041360 :   unsigned ix;
     484                 :            : 
     485                 :    6041360 :   gcc_checking_assert (expr != NULL_TREE
     486                 :            :                        && !(this_ref_p && tree_is_indexable (expr)));
     487                 :            : 
     488                 :    6041360 :   bool exists_p = streamer_tree_cache_insert (ob->writer_cache,
     489                 :            :                                               expr, hash, &ix);
     490                 :    6041360 :   gcc_assert (!exists_p);
     491                 :    6041360 :   if (TREE_CODE (expr) == INTEGER_CST
     492                 :    6940180 :       && !TREE_OVERFLOW (expr))
     493                 :            :     {
     494                 :            :       /* Shared INTEGER_CST nodes are special because they need their
     495                 :            :          original type to be materialized by the reader (to implement
     496                 :            :          TYPE_CACHED_VALUES).  */
     497                 :     898810 :       streamer_write_integer_cst (ob, expr, ref_p);
     498                 :            :     }
     499                 :            :   else
     500                 :            :     {
     501                 :            :       /* This is the first time we see EXPR, write its fields
     502                 :            :          to OB.  */
     503                 :    5142560 :       lto_write_tree (ob, expr, ref_p);
     504                 :            :     }
     505                 :    6041360 : }
     506                 :            : 
     507                 :            : class DFS
     508                 :            : {
     509                 :            : public:
     510                 :            :   DFS (struct output_block *ob, tree expr, bool ref_p, bool this_ref_p,
     511                 :            :        bool single_p);
     512                 :            :   ~DFS ();
     513                 :            : 
     514                 :            :   struct scc_entry
     515                 :            :   {
     516                 :            :     tree t;
     517                 :            :     hashval_t hash;
     518                 :            :   };
     519                 :            :   auto_vec<scc_entry,32> sccstack;
     520                 :            : 
     521                 :            : private:
     522                 :            :   struct sccs
     523                 :            :   {
     524                 :            :     unsigned int dfsnum;
     525                 :            :     unsigned int low;
     526                 :            :   };
     527                 :            :   struct worklist
     528                 :            :   {
     529                 :            :     tree expr;
     530                 :            :     sccs *from_state;
     531                 :            :     sccs *cstate;
     532                 :            :     bool ref_p;
     533                 :            :     bool this_ref_p;
     534                 :            :   };
     535                 :            : 
     536                 :            :   static int scc_entry_compare (const void *, const void *);
     537                 :            : 
     538                 :            :   void DFS_write_tree_body (struct output_block *ob,
     539                 :            :                             tree expr, sccs *expr_state, bool ref_p);
     540                 :            : 
     541                 :            :   void DFS_write_tree (struct output_block *ob, sccs *from_state,
     542                 :            :                        tree expr, bool ref_p, bool this_ref_p);
     543                 :            : 
     544                 :            :   hashval_t
     545                 :            :   hash_scc (struct output_block *ob, unsigned first, unsigned size,
     546                 :            :             bool ref_p, bool this_ref_p);
     547                 :            : 
     548                 :            :   hash_map<tree, sccs *> sccstate;
     549                 :            :   auto_vec<worklist, 32> worklist_vec;
     550                 :            :   struct obstack sccstate_obstack;
     551                 :            : };
     552                 :            : 
     553                 :            : /* Emit the physical representation of tree node EXPR to output block OB,
     554                 :            :    using depth-first search on the subgraph.  If THIS_REF_P is true, the
     555                 :            :    leaves of EXPR are emitted as references via lto_output_tree_ref.
     556                 :            :    REF_P is used for streaming siblings of EXPR.  If SINGLE_P is true,
     557                 :            :    this is for a rewalk of a single leaf SCC.  */
     558                 :            : 
     559                 :    2277540 : DFS::DFS (struct output_block *ob, tree expr, bool ref_p, bool this_ref_p,
     560                 :    2277540 :           bool single_p)
     561                 :            : {
     562                 :    2277540 :   unsigned int next_dfs_num = 1;
     563                 :    2277540 :   gcc_obstack_init (&sccstate_obstack);
     564                 :    2277540 :   DFS_write_tree (ob, NULL, expr, ref_p, this_ref_p);
     565                 :   16104700 :   while (!worklist_vec.is_empty ())
     566                 :            :     {
     567                 :   13827200 :       worklist &w = worklist_vec.last ();
     568                 :   13827200 :       expr = w.expr;
     569                 :   13827200 :       sccs *from_state = w.from_state;
     570                 :   13827200 :       sccs *cstate = w.cstate;
     571                 :   13827200 :       ref_p = w.ref_p;
     572                 :   13827200 :       this_ref_p = w.this_ref_p;
     573                 :   13827200 :       if (cstate == NULL)
     574                 :            :         {
     575                 :    7545560 :           sccs **slot = &sccstate.get_or_insert (expr);
     576                 :    7545560 :           cstate = *slot;
     577                 :    7545560 :           if (cstate)
     578                 :            :             {
     579                 :    1263920 :               gcc_checking_assert (from_state);
     580                 :    1263920 :               if (cstate->dfsnum < from_state->dfsnum)
     581                 :     157099 :                 from_state->low = MIN (cstate->dfsnum, from_state->low);
     582                 :    1263920 :               worklist_vec.pop ();
     583                 :    1263920 :               continue;
     584                 :            :             }
     585                 :            : 
     586                 :    6281640 :           scc_entry e = { expr, 0 };
     587                 :            :           /* Not yet visited.  DFS recurse and push it onto the stack.  */
     588                 :    6281640 :           *slot = cstate = XOBNEW (&sccstate_obstack, struct sccs);
     589                 :    6281640 :           sccstack.safe_push (e);
     590                 :    6281640 :           cstate->dfsnum = next_dfs_num++;
     591                 :    6281640 :           cstate->low = cstate->dfsnum;
     592                 :    6281640 :           w.cstate = cstate;
     593                 :            : 
     594                 :    6281640 :           if (TREE_CODE (expr) == INTEGER_CST
     595                 :    6281640 :               && !TREE_OVERFLOW (expr))
     596                 :     928687 :             DFS_write_tree (ob, cstate, TREE_TYPE (expr), ref_p, ref_p);
     597                 :            :           else
     598                 :            :             {
     599                 :    5352950 :               DFS_write_tree_body (ob, expr, cstate, ref_p);
     600                 :            : 
     601                 :            :               /* Walk any LTO-specific edges.  */
     602                 :    5352950 :               if (DECL_P (expr)
     603                 :    1309230 :                   && TREE_CODE (expr) != FUNCTION_DECL
     604                 :     927089 :                   && TREE_CODE (expr) != TRANSLATION_UNIT_DECL)
     605                 :            :                 {
     606                 :            :                   /* Handle DECL_INITIAL for symbols.  */
     607                 :     904893 :                   tree initial
     608                 :     904893 :                     = get_symbol_initial_value (ob->decl_state->symtab_node_encoder,
     609                 :            :                                                 expr);
     610                 :     904893 :                   DFS_write_tree (ob, cstate, initial, ref_p, ref_p);
     611                 :            :                 }
     612                 :            :             }
     613                 :    6281640 :           continue;
     614                 :            :         }
     615                 :            : 
     616                 :            :       /* See if we found an SCC.  */
     617                 :    6281640 :       if (cstate->low == cstate->dfsnum)
     618                 :            :         {
     619                 :    6112160 :           unsigned first, size;
     620                 :    6112160 :           tree x;
     621                 :            : 
     622                 :            :           /* If we are re-walking a single leaf SCC just pop it,
     623                 :            :              let earlier worklist item access the sccstack.  */
     624                 :    6112160 :           if (single_p)
     625                 :            :             {
     626                 :        323 :               worklist_vec.pop ();
     627                 :        323 :               continue;
     628                 :            :             }
     629                 :            : 
     630                 :            :           /* Pop the SCC and compute its size.  */
     631                 :   12223700 :           first = sccstack.length ();
     632                 :    6271190 :           do
     633                 :            :             {
     634                 :    6271190 :               x = sccstack[--first].t;
     635                 :            :             }
     636                 :    6271190 :           while (x != expr);
     637                 :    6111830 :           size = sccstack.length () - first;
     638                 :            : 
     639                 :            :           /* No need to compute hashes for LTRANS units, we don't perform
     640                 :            :              any merging there.  */
     641                 :    6111830 :           hashval_t scc_hash = 0;
     642                 :    6111830 :           unsigned scc_entry_len = 0;
     643                 :    6111830 :           if (!flag_wpa)
     644                 :            :             {
     645                 :    5541400 :               scc_hash = hash_scc (ob, first, size, ref_p, this_ref_p);
     646                 :            : 
     647                 :            :               /* Put the entries with the least number of collisions first.  */
     648                 :    5541400 :               unsigned entry_start = 0;
     649                 :    5541400 :               scc_entry_len = size + 1;
     650                 :   11213600 :               for (unsigned i = 0; i < size;)
     651                 :            :                 {
     652                 :    5672190 :                   unsigned from = i;
     653                 :    5672190 :                   for (i = i + 1; i < size
     654                 :    5672190 :                        && (sccstack[first + i].hash
     655                 :     130788 :                            == sccstack[first + from].hash); ++i)
     656                 :            :                     ;
     657                 :    5672190 :                   if (i - from < scc_entry_len)
     658                 :            :                     {
     659                 :    5541400 :                       scc_entry_len = i - from;
     660                 :    5541400 :                       entry_start = from;
     661                 :            :                     }
     662                 :            :                 }
     663                 :   11082800 :               for (unsigned i = 0; i < scc_entry_len; ++i)
     664                 :    5541400 :                 std::swap (sccstack[first + i],
     665                 :    5541400 :                            sccstack[first + entry_start + i]);
     666                 :            : 
     667                 :            :               /* We already sorted SCC deterministically in hash_scc.  */
     668                 :            : 
     669                 :            :               /* Check that we have only one SCC.
     670                 :            :                  Naturally we may have conflicts if hash function is not
     671                 :            :                  strong enough.  Lets see how far this gets.  */
     672                 :    5541400 :               gcc_checking_assert (scc_entry_len == 1);
     673                 :            :             }
     674                 :            : 
     675                 :            :           /* Write LTO_tree_scc.  */
     676                 :    6111830 :           streamer_write_record_start (ob, LTO_tree_scc);
     677                 :    6111830 :           streamer_write_uhwi (ob, size);
     678                 :    6111830 :           streamer_write_uhwi (ob, scc_hash);
     679                 :            : 
     680                 :            :           /* Write size-1 SCCs without wrapping them inside SCC bundles.
     681                 :            :              All INTEGER_CSTs need to be handled this way as we need
     682                 :            :              their type to materialize them.  Also builtins are handled
     683                 :            :              this way.
     684                 :            :              ???  We still wrap these in LTO_tree_scc so at the
     685                 :            :              input side we can properly identify the tree we want
     686                 :            :              to ultimatively return.  */
     687                 :    6111830 :           if (size == 1)
     688                 :    6041360 :             lto_output_tree_1 (ob, expr, scc_hash, ref_p, this_ref_p);
     689                 :            :           else
     690                 :            :             {
     691                 :            :               /* Write the size of the SCC entry candidates.  */
     692                 :      70469 :               streamer_write_uhwi (ob, scc_entry_len);
     693                 :            : 
     694                 :            :               /* Write all headers and populate the streamer cache.  */
     695                 :     300290 :               for (unsigned i = 0; i < size; ++i)
     696                 :            :                 {
     697                 :     229821 :                   hashval_t hash = sccstack[first+i].hash;
     698                 :     229821 :                   tree t = sccstack[first+i].t;
     699                 :     229821 :                   bool exists_p = streamer_tree_cache_insert (ob->writer_cache,
     700                 :            :                                                               t, hash, NULL);
     701                 :     229821 :                   gcc_assert (!exists_p);
     702                 :            : 
     703                 :     229821 :                   if (!lto_is_streamable (t))
     704                 :          0 :                     internal_error ("tree code %qs is not supported "
     705                 :            :                                     "in LTO streams",
     706                 :          0 :                                     get_tree_code_name (TREE_CODE (t)));
     707                 :            : 
     708                 :            :                   /* Write the header, containing everything needed to
     709                 :            :                      materialize EXPR on the reading side.  */
     710                 :     229821 :                   streamer_write_tree_header (ob, t);
     711                 :            :                 }
     712                 :            : 
     713                 :            :               /* Write the bitpacks and tree references.  */
     714                 :     300290 :               for (unsigned i = 0; i < size; ++i)
     715                 :            :                 {
     716                 :     229821 :                   lto_write_tree_1 (ob, sccstack[first+i].t, ref_p);
     717                 :            : 
     718                 :            :                   /* Mark the end of the tree.  */
     719                 :     229821 :                   streamer_write_zero (ob);
     720                 :            :                 }
     721                 :            :             }
     722                 :            : 
     723                 :            :           /* Finally truncate the vector.  */
     724                 :    6111830 :           sccstack.truncate (first);
     725                 :            : 
     726                 :    6111830 :           if (from_state)
     727                 :    3834620 :             from_state->low = MIN (from_state->low, cstate->low);
     728                 :    6111830 :           worklist_vec.pop ();
     729                 :    6111830 :           continue;
     730                 :            :         }
     731                 :            : 
     732                 :     169481 :       gcc_checking_assert (from_state);
     733                 :     169481 :       from_state->low = MIN (from_state->low, cstate->low);
     734                 :     169481 :       if (cstate->dfsnum < from_state->dfsnum)
     735                 :          0 :         from_state->low = MIN (cstate->dfsnum, from_state->low);
     736                 :     169481 :       worklist_vec.pop ();
     737                 :            :     }
     738                 :    2277540 : }
     739                 :            : 
     740                 :    4555080 : DFS::~DFS ()
     741                 :            : {
     742                 :    2277540 :   obstack_free (&sccstate_obstack, NULL);
     743                 :    2277540 : }
     744                 :            : 
     745                 :            : /* Handle the tree EXPR in the DFS walk with SCC state EXPR_STATE and
     746                 :            :    DFS recurse for all tree edges originating from it.  */
     747                 :            : 
     748                 :            : void
     749                 :    5352950 : DFS::DFS_write_tree_body (struct output_block *ob,
     750                 :            :                           tree expr, sccs *expr_state, bool ref_p)
     751                 :            : {
     752                 :            : #define DFS_follow_tree_edge(DEST) \
     753                 :            :   DFS_write_tree (ob, expr_state, DEST, ref_p, ref_p)
     754                 :            : 
     755                 :    5352950 :   enum tree_code code;
     756                 :            : 
     757                 :    5352950 :   if (streamer_dump_file)
     758                 :            :     {
     759                 :        408 :       print_node_brief (streamer_dump_file, "    Streaming ",
     760                 :            :                         expr, 4);
     761                 :        408 :       fprintf (streamer_dump_file, "  to %s\n",
     762                 :        408 :                lto_section_name [ob->section_type]);
     763                 :            :     }
     764                 :            : 
     765                 :    5352950 :   code = TREE_CODE (expr);
     766                 :            : 
     767                 :    5352950 :   if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
     768                 :            :     {
     769                 :    5147000 :       if (TREE_CODE (expr) != IDENTIFIER_NODE)
     770                 :    3859720 :         DFS_follow_tree_edge (TREE_TYPE (expr));
     771                 :            :     }
     772                 :            : 
     773                 :    5352950 :   if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
     774                 :            :     {
     775                 :       5499 :       unsigned int count = vector_cst_encoded_nelts (expr);
     776                 :      24636 :       for (unsigned int i = 0; i < count; ++i)
     777                 :      19137 :         DFS_follow_tree_edge (VECTOR_CST_ENCODED_ELT (expr, i));
     778                 :            :     }
     779                 :            : 
     780                 :    5352950 :   if (CODE_CONTAINS_STRUCT (code, TS_POLY_INT_CST))
     781                 :          0 :     for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
     782                 :          0 :       DFS_follow_tree_edge (POLY_INT_CST_COEFF (expr, i));
     783                 :            : 
     784                 :    5352950 :   if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
     785                 :            :     {
     786                 :       7903 :       DFS_follow_tree_edge (TREE_REALPART (expr));
     787                 :       7903 :       DFS_follow_tree_edge (TREE_IMAGPART (expr));
     788                 :            :     }
     789                 :            : 
     790                 :    5352950 :   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
     791                 :            :     {
     792                 :            :       /* Drop names that were created for anonymous entities.  */
     793                 :    1309230 :       if (DECL_NAME (expr)
     794                 :    1154670 :           && TREE_CODE (DECL_NAME (expr)) == IDENTIFIER_NODE
     795                 :    2463900 :           && IDENTIFIER_ANON_P (DECL_NAME (expr)))
     796                 :            :         ;
     797                 :            :       else
     798                 :    1308870 :         DFS_follow_tree_edge (DECL_NAME (expr));
     799                 :    1309230 :       if (TREE_CODE (expr) != TRANSLATION_UNIT_DECL
     800                 :    2596260 :           && ! DECL_CONTEXT (expr))
     801                 :      18966 :         DFS_follow_tree_edge ((*all_translation_units)[0]);
     802                 :            :       else
     803                 :    1290260 :         DFS_follow_tree_edge (DECL_CONTEXT (expr));
     804                 :            :     }
     805                 :            : 
     806                 :    5352950 :   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
     807                 :            :     {
     808                 :    1309230 :       DFS_follow_tree_edge (DECL_SIZE (expr));
     809                 :    1309230 :       DFS_follow_tree_edge (DECL_SIZE_UNIT (expr));
     810                 :            : 
     811                 :            :       /* Note, DECL_INITIAL is not handled here.  Since DECL_INITIAL needs
     812                 :            :          special handling in LTO, it must be handled by streamer hooks.  */
     813                 :            : 
     814                 :    1309230 :       DFS_follow_tree_edge (DECL_ATTRIBUTES (expr));
     815                 :            : 
     816                 :            :       /* We use DECL_ABSTRACT_ORIGIN == error_mark_node to mark
     817                 :            :          declarations which should be eliminated by decl merging. Be sure none
     818                 :            :          leaks to this point.  */
     819                 :    1309230 :       gcc_assert (DECL_ABSTRACT_ORIGIN (expr) != error_mark_node);
     820                 :    1309230 :       DFS_follow_tree_edge (DECL_ABSTRACT_ORIGIN (expr));
     821                 :            : 
     822                 :    1309230 :       if ((VAR_P (expr)
     823                 :    1309230 :            || TREE_CODE (expr) == PARM_DECL)
     824                 :    1982540 :           && DECL_HAS_VALUE_EXPR_P (expr))
     825                 :       1045 :         DFS_follow_tree_edge (DECL_VALUE_EXPR (expr));
     826                 :    1309230 :       if (VAR_P (expr)
     827                 :    1309230 :           && DECL_HAS_DEBUG_EXPR_P (expr))
     828                 :       1242 :         DFS_follow_tree_edge (DECL_DEBUG_EXPR (expr));
     829                 :            :     }
     830                 :            : 
     831                 :    5352950 :   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
     832                 :            :     {
     833                 :            :       /* Make sure we don't inadvertently set the assembler name.  */
     834                 :     769704 :       if (DECL_ASSEMBLER_NAME_SET_P (expr))
     835                 :     679879 :         DFS_follow_tree_edge (DECL_ASSEMBLER_NAME (expr));
     836                 :            :     }
     837                 :            : 
     838                 :    5352950 :   if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
     839                 :            :     {
     840                 :      96893 :       DFS_follow_tree_edge (DECL_FIELD_OFFSET (expr));
     841                 :      96893 :       DFS_follow_tree_edge (DECL_BIT_FIELD_TYPE (expr));
     842                 :      96893 :       DFS_follow_tree_edge (DECL_BIT_FIELD_REPRESENTATIVE (expr));
     843                 :      96893 :       DFS_follow_tree_edge (DECL_FIELD_BIT_OFFSET (expr));
     844                 :      96893 :       gcc_checking_assert (!DECL_FCONTEXT (expr));
     845                 :            :     }
     846                 :            : 
     847                 :    5352950 :   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
     848                 :            :     {
     849                 :     382137 :       gcc_checking_assert (DECL_VINDEX (expr) == NULL);
     850                 :     382137 :       DFS_follow_tree_edge (DECL_FUNCTION_PERSONALITY (expr));
     851                 :     382137 :       DFS_follow_tree_edge (DECL_FUNCTION_SPECIFIC_TARGET (expr));
     852                 :     382137 :       DFS_follow_tree_edge (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr));
     853                 :            :     }
     854                 :            : 
     855                 :    5352950 :   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
     856                 :            :     {
     857                 :     505257 :       DFS_follow_tree_edge (TYPE_SIZE (expr));
     858                 :     505257 :       DFS_follow_tree_edge (TYPE_SIZE_UNIT (expr));
     859                 :     505257 :       DFS_follow_tree_edge (TYPE_ATTRIBUTES (expr));
     860                 :     505257 :       DFS_follow_tree_edge (TYPE_NAME (expr));
     861                 :            :       /* Do not follow TYPE_POINTER_TO or TYPE_REFERENCE_TO.  They will be
     862                 :            :          reconstructed during fixup.  */
     863                 :            :       /* Do not follow TYPE_NEXT_VARIANT, we reconstruct the variant lists
     864                 :            :          during fixup.  */
     865                 :     505257 :       DFS_follow_tree_edge (TYPE_MAIN_VARIANT (expr));
     866                 :     505257 :       DFS_follow_tree_edge (TYPE_CONTEXT (expr));
     867                 :            :       /* TYPE_CANONICAL is re-computed during type merging, so no need
     868                 :            :          to follow it here.  */
     869                 :            :       /* Do not stream TYPE_STUB_DECL; it is not needed by LTO but currently
     870                 :            :          it cannot be freed by free_lang_data without triggering ICEs in
     871                 :            :          langhooks.  */
     872                 :            :     }
     873                 :            : 
     874                 :    5352950 :   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
     875                 :            :     {
     876                 :     505257 :       if (TREE_CODE (expr) == ENUMERAL_TYPE)
     877                 :        884 :         DFS_follow_tree_edge (TYPE_VALUES (expr));
     878                 :     504373 :       else if (TREE_CODE (expr) == ARRAY_TYPE)
     879                 :      31738 :         DFS_follow_tree_edge (TYPE_DOMAIN (expr));
     880                 :     472635 :       else if (RECORD_OR_UNION_TYPE_P (expr))
     881                 :     200557 :         for (tree t = TYPE_FIELDS (expr); t; t = TREE_CHAIN (t))
     882                 :     118084 :           DFS_follow_tree_edge (t);
     883                 :     390162 :       else if (TREE_CODE (expr) == FUNCTION_TYPE
     884                 :     390162 :                || TREE_CODE (expr) == METHOD_TYPE)
     885                 :     135371 :         DFS_follow_tree_edge (TYPE_ARG_TYPES (expr));
     886                 :            : 
     887                 :     505257 :       if (!POINTER_TYPE_P (expr))
     888                 :     304516 :         DFS_follow_tree_edge (TYPE_MIN_VALUE_RAW (expr));
     889                 :     505257 :       DFS_follow_tree_edge (TYPE_MAX_VALUE_RAW (expr));
     890                 :            :     }
     891                 :            : 
     892                 :    5352950 :   if (CODE_CONTAINS_STRUCT (code, TS_LIST))
     893                 :            :     {
     894                 :     526897 :       DFS_follow_tree_edge (TREE_PURPOSE (expr));
     895                 :     526897 :       DFS_follow_tree_edge (TREE_VALUE (expr));
     896                 :     526897 :       DFS_follow_tree_edge (TREE_CHAIN (expr));
     897                 :            :     }
     898                 :            : 
     899                 :    5352950 :   if (CODE_CONTAINS_STRUCT (code, TS_VEC))
     900                 :            :     {
     901                 :          0 :       for (int i = 0; i < TREE_VEC_LENGTH (expr); i++)
     902                 :          0 :         DFS_follow_tree_edge (TREE_VEC_ELT (expr, i));
     903                 :            :     }
     904                 :            : 
     905                 :    5352950 :   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
     906                 :            :     {
     907                 :    2735160 :       for (int i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
     908                 :    1613950 :         DFS_follow_tree_edge (TREE_OPERAND (expr, i));
     909                 :    1121210 :       DFS_follow_tree_edge (TREE_BLOCK (expr));
     910                 :            :     }
     911                 :            : 
     912                 :    5352950 :   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
     913                 :            :     {
     914                 :     225672 :       for (tree t = BLOCK_VARS (expr); t; t = TREE_CHAIN (t))
     915                 :            :         {
     916                 :            :           /* We would have to stream externals in the block chain as
     917                 :            :              non-references but we should have dropped them in
     918                 :            :              free-lang-data.  */
     919                 :     121406 :           gcc_assert (!VAR_OR_FUNCTION_DECL_P (t) || !DECL_EXTERNAL (t));
     920                 :      62481 :           DFS_follow_tree_edge (t);
     921                 :            :         }
     922                 :            : 
     923                 :     163191 :       DFS_follow_tree_edge (BLOCK_SUPERCONTEXT (expr));
     924                 :     163191 :       DFS_follow_tree_edge (BLOCK_ABSTRACT_ORIGIN (expr));
     925                 :            : 
     926                 :            :       /* Do not follow BLOCK_NONLOCALIZED_VARS.  We cannot handle debug
     927                 :            :          information for early inlined BLOCKs so drop it on the floor instead
     928                 :            :          of ICEing in dwarf2out.c.  */
     929                 :            : 
     930                 :            :       /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
     931                 :            :          streaming time.  */
     932                 :            : 
     933                 :            :       /* Do not output BLOCK_SUBBLOCKS.  Instead on streaming-in this
     934                 :            :          list is re-constructed from BLOCK_SUPERCONTEXT.  */
     935                 :            :     }
     936                 :            : 
     937                 :    5352950 :   if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
     938                 :            :     {
     939                 :            :       unsigned i;
     940                 :            :       tree t;
     941                 :            : 
     942                 :            :       /* Note that the number of BINFO slots has already been emitted in
     943                 :            :          EXPR's header (see streamer_write_tree_header) because this length
     944                 :            :          is needed to build the empty BINFO node on the reader side.  */
     945                 :      19845 :       FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr), i, t)
     946                 :      10583 :         DFS_follow_tree_edge (t);
     947                 :       9262 :       DFS_follow_tree_edge (BINFO_OFFSET (expr));
     948                 :       9262 :       DFS_follow_tree_edge (BINFO_VTABLE (expr));
     949                 :            : 
     950                 :            :       /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX,
     951                 :            :          BINFO_BASE_ACCESSES and BINFO_VPTR_INDEX; these are used
     952                 :            :          by C++ FE only.  */
     953                 :            :     }
     954                 :            : 
     955                 :    5352950 :   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
     956                 :            :     {
     957                 :            :       unsigned i;
     958                 :            :       tree index, value;
     959                 :            : 
     960                 :    1530930 :       FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value)
     961                 :            :         {
     962                 :     536717 :           DFS_follow_tree_edge (index);
     963                 :     536717 :           DFS_follow_tree_edge (value);
     964                 :            :         }
     965                 :            :     }
     966                 :            : 
     967                 :    5352950 :   if (code == OMP_CLAUSE)
     968                 :            :     {
     969                 :            :       int i;
     970                 :        467 :       for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (expr)]; i++)
     971                 :        271 :         DFS_follow_tree_edge (OMP_CLAUSE_OPERAND (expr, i));
     972                 :        196 :       DFS_follow_tree_edge (OMP_CLAUSE_CHAIN (expr));
     973                 :            :     }
     974                 :            : 
     975                 :            : #undef DFS_follow_tree_edge
     976                 :    5352950 : }
     977                 :            : 
     978                 :            : /* Return a hash value for the tree T.
     979                 :            :    CACHE holds hash values of trees outside current SCC.  MAP, if non-NULL,
     980                 :            :    may hold hash values if trees inside current SCC.  */
     981                 :            : 
     982                 :            : static hashval_t
     983                 :    5672190 : hash_tree (struct streamer_tree_cache_d *cache, hash_map<tree, hashval_t> *map, tree t)
     984                 :            : {
     985                 :    5672190 :   inchash::hash hstate;
     986                 :            : 
     987                 :            : #define visit(SIBLING) \
     988                 :            :   do { \
     989                 :            :     unsigned ix; \
     990                 :            :     if (!SIBLING) \
     991                 :            :       hstate.add_int (0); \
     992                 :            :     else if (streamer_tree_cache_lookup (cache, SIBLING, &ix)) \
     993                 :            :       hstate.add_int (streamer_tree_cache_get_hash (cache, ix)); \
     994                 :            :     else if (map) \
     995                 :            :       hstate.add_int (*map->get (SIBLING)); \
     996                 :            :     else \
     997                 :            :       hstate.add_int (1); \
     998                 :            :   } while (0)
     999                 :            : 
    1000                 :            :   /* Hash TS_BASE.  */
    1001                 :    5672190 :   enum tree_code code = TREE_CODE (t);
    1002                 :    5672190 :   hstate.add_int (code);
    1003                 :    5672190 :   if (!TYPE_P (t))
    1004                 :            :     {
    1005                 :    5302880 :       hstate.add_flag (TREE_SIDE_EFFECTS (t));
    1006                 :    5302880 :       hstate.add_flag (TREE_CONSTANT (t));
    1007                 :    5302880 :       hstate.add_flag (TREE_READONLY (t));
    1008                 :    5302880 :       hstate.add_flag (TREE_PUBLIC (t));
    1009                 :            :     }
    1010                 :    5672190 :   hstate.add_flag (TREE_ADDRESSABLE (t));
    1011                 :    5672190 :   hstate.add_flag (TREE_THIS_VOLATILE (t));
    1012                 :    5672190 :   if (DECL_P (t))
    1013                 :    1184340 :     hstate.add_flag (DECL_UNSIGNED (t));
    1014                 :    4487850 :   else if (TYPE_P (t))
    1015                 :     369305 :     hstate.add_flag (TYPE_UNSIGNED (t));
    1016                 :    5672190 :   if (TYPE_P (t))
    1017                 :     369305 :     hstate.add_flag (TYPE_ARTIFICIAL (t));
    1018                 :            :   else
    1019                 :    5302880 :     hstate.add_flag (TREE_NO_WARNING (t));
    1020                 :    5672190 :   hstate.add_flag (TREE_NOTHROW (t));
    1021                 :    5672190 :   hstate.add_flag (TREE_STATIC (t));
    1022                 :    5672190 :   hstate.add_flag (TREE_PROTECTED (t));
    1023                 :    5672190 :   hstate.add_flag (TREE_DEPRECATED (t));
    1024                 :    5672190 :   if (code != TREE_BINFO)
    1025                 :    5665960 :     hstate.add_flag (TREE_PRIVATE (t));
    1026                 :    5672190 :   if (TYPE_P (t))
    1027                 :            :     {
    1028                 :     369305 :       hstate.add_flag (AGGREGATE_TYPE_P (t)
    1029                 :     369305 :                        ? TYPE_REVERSE_STORAGE_ORDER (t) : TYPE_SATURATING (t));
    1030                 :     369305 :       hstate.add_flag (TYPE_ADDR_SPACE (t));
    1031                 :            :     }
    1032                 :    5302880 :   else if (code == SSA_NAME)
    1033                 :          0 :     hstate.add_flag (SSA_NAME_IS_DEFAULT_DEF (t));
    1034                 :    5672190 :   hstate.commit_flag ();
    1035                 :            : 
    1036                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
    1037                 :     851466 :     hstate.add_wide_int (wi::to_widest (t));
    1038                 :            : 
    1039                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
    1040                 :            :     {
    1041                 :      90901 :       REAL_VALUE_TYPE r = TREE_REAL_CST (t);
    1042                 :      90901 :       hstate.add_flag (r.cl);
    1043                 :      90901 :       hstate.add_flag (r.sign);
    1044                 :      90901 :       hstate.add_flag (r.signalling);
    1045                 :      90901 :       hstate.add_flag (r.canonical);
    1046                 :      90901 :       hstate.commit_flag ();
    1047                 :      90901 :       hstate.add_int (r.uexp);
    1048                 :      90901 :       hstate.add (r.sig, sizeof (r.sig));
    1049                 :            :     }
    1050                 :            : 
    1051                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
    1052                 :            :     {
    1053                 :          0 :       FIXED_VALUE_TYPE f = TREE_FIXED_CST (t);
    1054                 :          0 :       hstate.add_int (f.mode);
    1055                 :          0 :       hstate.add_int (f.data.low);
    1056                 :          0 :       hstate.add_int (f.data.high);
    1057                 :            :     }
    1058                 :            : 
    1059                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
    1060                 :            :     {
    1061                 :    1184340 :       hstate.add_hwi (DECL_MODE (t));
    1062                 :    1184340 :       hstate.add_flag (DECL_NONLOCAL (t));
    1063                 :    1184340 :       hstate.add_flag (DECL_VIRTUAL_P (t));
    1064                 :    1184340 :       hstate.add_flag (DECL_IGNORED_P (t));
    1065                 :    1184340 :       hstate.add_flag (DECL_ABSTRACT_P (t));
    1066                 :    1184340 :       hstate.add_flag (DECL_ARTIFICIAL (t));
    1067                 :    1184340 :       hstate.add_flag (DECL_USER_ALIGN (t));
    1068                 :    1184340 :       hstate.add_flag (DECL_PRESERVE_P (t));
    1069                 :    1184340 :       hstate.add_flag (DECL_EXTERNAL (t));
    1070                 :    1184340 :       hstate.add_flag (DECL_GIMPLE_REG_P (t));
    1071                 :    1184340 :       hstate.commit_flag ();
    1072                 :    1184340 :       hstate.add_int (DECL_ALIGN (t));
    1073                 :    1184340 :       if (code == LABEL_DECL)
    1074                 :            :         {
    1075                 :      14948 :           hstate.add_int (EH_LANDING_PAD_NR (t));
    1076                 :      14948 :           hstate.add_int (LABEL_DECL_UID (t));
    1077                 :            :         }
    1078                 :    1169390 :       else if (code == FIELD_DECL)
    1079                 :            :         {
    1080                 :      76273 :           hstate.add_flag (DECL_PACKED (t));
    1081                 :      76273 :           hstate.add_flag (DECL_NONADDRESSABLE_P (t));
    1082                 :      76273 :           hstate.add_flag (DECL_PADDING_P (t));
    1083                 :      76273 :           hstate.add_int (DECL_OFFSET_ALIGN (t));
    1084                 :            :         }
    1085                 :    1093120 :       else if (code == VAR_DECL)
    1086                 :            :         {
    1087                 :     339299 :           hstate.add_flag (DECL_HAS_DEBUG_EXPR_P (t));
    1088                 :     339299 :           hstate.add_flag (DECL_NONLOCAL_FRAME (t));
    1089                 :            :         }
    1090                 :    1184340 :       if (code == RESULT_DECL
    1091                 :    1184340 :           || code == PARM_DECL
    1092                 :     793124 :           || code == VAR_DECL)
    1093                 :            :         {
    1094                 :    1121720 :           hstate.add_flag (DECL_BY_REFERENCE (t));
    1095                 :     730512 :           if (code == VAR_DECL
    1096                 :     730512 :               || code == PARM_DECL)
    1097                 :     949329 :             hstate.add_flag (DECL_HAS_VALUE_EXPR_P (t));
    1098                 :            :         }
    1099                 :    1184340 :       hstate.commit_flag ();
    1100                 :            :     }
    1101                 :            : 
    1102                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
    1103                 :    1091660 :     hstate.add_int (DECL_REGISTER (t));
    1104                 :            : 
    1105                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
    1106                 :            :     {
    1107                 :     685019 :       hstate.add_flag (DECL_COMMON (t));
    1108                 :     685019 :       hstate.add_flag (DECL_DLLIMPORT_P (t));
    1109                 :     685019 :       hstate.add_flag (DECL_WEAK (t));
    1110                 :     685019 :       hstate.add_flag (DECL_SEEN_IN_BIND_EXPR_P (t));
    1111                 :     685019 :       hstate.add_flag (DECL_COMDAT (t));
    1112                 :     685019 :       hstate.add_flag (DECL_VISIBILITY_SPECIFIED (t));
    1113                 :     685019 :       hstate.add_int (DECL_VISIBILITY (t));
    1114                 :     685019 :       if (code == VAR_DECL)
    1115                 :            :         {
    1116                 :            :           /* DECL_IN_TEXT_SECTION is set during final asm output only.  */
    1117                 :     339299 :           hstate.add_flag (DECL_HARD_REGISTER (t));
    1118                 :     339299 :           hstate.add_flag (DECL_IN_CONSTANT_POOL (t));
    1119                 :            :         }
    1120                 :     685019 :       if (TREE_CODE (t) == FUNCTION_DECL)
    1121                 :            :         {
    1122                 :     325232 :           hstate.add_flag (DECL_FINAL_P (t));
    1123                 :     325232 :           hstate.add_flag (DECL_CXX_CONSTRUCTOR_P (t));
    1124                 :     325232 :           hstate.add_flag (DECL_CXX_DESTRUCTOR_P (t));
    1125                 :            :         }
    1126                 :     685019 :       hstate.commit_flag ();
    1127                 :            :     }
    1128                 :            : 
    1129                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
    1130                 :            :     {
    1131                 :     325232 :       hstate.add_int (DECL_BUILT_IN_CLASS (t));
    1132                 :     325232 :       hstate.add_flag (DECL_STATIC_CONSTRUCTOR (t));
    1133                 :     325232 :       hstate.add_flag (DECL_STATIC_DESTRUCTOR (t));
    1134                 :     325232 :       hstate.add_flag (FUNCTION_DECL_DECL_TYPE (t));
    1135                 :     325232 :       hstate.add_flag (DECL_UNINLINABLE (t));
    1136                 :     325232 :       hstate.add_flag (DECL_POSSIBLY_INLINED (t));
    1137                 :     325232 :       hstate.add_flag (DECL_IS_NOVOPS (t));
    1138                 :     325232 :       hstate.add_flag (DECL_IS_RETURNS_TWICE (t));
    1139                 :     325232 :       hstate.add_flag (DECL_IS_MALLOC (t));
    1140                 :     325232 :       hstate.add_flag (DECL_DECLARED_INLINE_P (t));
    1141                 :     325232 :       hstate.add_flag (DECL_STATIC_CHAIN (t));
    1142                 :     325232 :       hstate.add_flag (DECL_NO_INLINE_WARNING_P (t));
    1143                 :     325232 :       hstate.add_flag (DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (t));
    1144                 :     325232 :       hstate.add_flag (DECL_NO_LIMIT_STACK (t));
    1145                 :     325232 :       hstate.add_flag (DECL_DISREGARD_INLINE_LIMITS (t));
    1146                 :     325232 :       hstate.add_flag (DECL_PURE_P (t));
    1147                 :     325232 :       hstate.add_flag (DECL_LOOPING_CONST_OR_PURE_P (t));
    1148                 :     325232 :       hstate.commit_flag ();
    1149                 :     325232 :       if (DECL_BUILT_IN_CLASS (t) != NOT_BUILT_IN)
    1150                 :      16706 :         hstate.add_int (DECL_UNCHECKED_FUNCTION_CODE (t));
    1151                 :            :     }
    1152                 :            : 
    1153                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
    1154                 :            :     {
    1155                 :     369305 :       hstate.add_hwi (TYPE_MODE (t));
    1156                 :            :       /* TYPE_NO_FORCE_BLK is private to stor-layout and need
    1157                 :            :          no streaming.  */
    1158                 :     369305 :       hstate.add_flag (TYPE_PACKED (t));
    1159                 :     369305 :       hstate.add_flag (TYPE_RESTRICT (t));
    1160                 :     369305 :       hstate.add_flag (TYPE_USER_ALIGN (t));
    1161                 :     369305 :       hstate.add_flag (TYPE_READONLY (t));
    1162                 :     369305 :       if (RECORD_OR_UNION_TYPE_P (t))
    1163                 :            :         {
    1164                 :      66342 :           hstate.add_flag (TYPE_TRANSPARENT_AGGR (t));
    1165                 :      66342 :           hstate.add_flag (TYPE_FINAL_P (t));
    1166                 :      66342 :           hstate.add_flag (TYPE_CXX_ODR_P (t));
    1167                 :            :         }
    1168                 :     303902 :       else if (code == ARRAY_TYPE)
    1169                 :      21744 :         hstate.add_flag (TYPE_NONALIASED_COMPONENT (t));
    1170                 :     369305 :       if (code == ARRAY_TYPE || code == INTEGER_TYPE)
    1171                 :      87172 :         hstate.add_flag (TYPE_STRING_FLAG (t));
    1172                 :     369305 :       if (AGGREGATE_TYPE_P (t))
    1173                 :      87147 :         hstate.add_flag (TYPE_TYPELESS_STORAGE (t));
    1174                 :     369305 :       hstate.commit_flag ();
    1175                 :     369305 :       hstate.add_int (TYPE_PRECISION (t));
    1176                 :     369305 :       hstate.add_int (TYPE_ALIGN (t));
    1177                 :     369305 :       hstate.add_int (TYPE_EMPTY_P (t));
    1178                 :            :     }
    1179                 :            : 
    1180                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
    1181                 :      16289 :     hstate.add (TRANSLATION_UNIT_LANGUAGE (t),
    1182                 :      16289 :                         strlen (TRANSLATION_UNIT_LANGUAGE (t)));
    1183                 :            : 
    1184                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION)
    1185                 :            :       /* We don't stream these when passing things to a different target.  */
    1186                 :      16026 :       && !lto_stream_offload_p)
    1187                 :      16026 :     hstate.add_hwi (cl_target_option_hash (TREE_TARGET_OPTION (t)));
    1188                 :            : 
    1189                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
    1190                 :      16052 :     hstate.add_hwi (cl_optimization_hash (TREE_OPTIMIZATION (t)));
    1191                 :            : 
    1192                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
    1193                 :    1122840 :     hstate.merge_hash (IDENTIFIER_HASH_VALUE (t));
    1194                 :            : 
    1195                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_STRING))
    1196                 :      44842 :     hstate.add (TREE_STRING_POINTER (t), TREE_STRING_LENGTH (t));
    1197                 :            : 
    1198                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
    1199                 :            :     {
    1200                 :    5482920 :       if (code != IDENTIFIER_NODE)
    1201                 :    4360080 :         visit (TREE_TYPE (t));
    1202                 :            :     }
    1203                 :            : 
    1204                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
    1205                 :            :     {
    1206                 :       5397 :       unsigned int count = vector_cst_encoded_nelts (t);
    1207                 :      24230 :       for (unsigned int i = 0; i < count; ++i)
    1208                 :      18833 :         visit (VECTOR_CST_ENCODED_ELT (t, i));
    1209                 :            :     }
    1210                 :            : 
    1211                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_POLY_INT_CST))
    1212                 :          0 :     for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
    1213                 :          0 :       visit (POLY_INT_CST_COEFF (t, i));
    1214                 :            : 
    1215                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
    1216                 :            :     {
    1217                 :       7902 :       visit (TREE_REALPART (t));
    1218                 :       7902 :       visit (TREE_IMAGPART (t));
    1219                 :            :     }
    1220                 :            : 
    1221                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
    1222                 :            :     {
    1223                 :            :       /* Drop names that were created for anonymous entities.  */
    1224                 :    1184340 :       if (DECL_NAME (t)
    1225                 :    1040750 :           && TREE_CODE (DECL_NAME (t)) == IDENTIFIER_NODE
    1226                 :    2225090 :           && IDENTIFIER_ANON_P (DECL_NAME (t)))
    1227                 :            :         ;
    1228                 :            :       else
    1229                 :    1184020 :         visit (DECL_NAME (t));
    1230                 :    1184340 :       if (DECL_FILE_SCOPE_P (t))
    1231                 :            :         ;
    1232                 :            :       else
    1233                 :     615016 :         visit (DECL_CONTEXT (t));
    1234                 :            :     }
    1235                 :            : 
    1236                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
    1237                 :            :     {
    1238                 :    1184340 :       visit (DECL_SIZE (t));
    1239                 :    1184340 :       visit (DECL_SIZE_UNIT (t));
    1240                 :    1184340 :       visit (DECL_ATTRIBUTES (t));
    1241                 :    1184340 :       if ((code == VAR_DECL
    1242                 :    1184340 :            || code == PARM_DECL)
    1243                 :    1828650 :           && DECL_HAS_VALUE_EXPR_P (t))
    1244                 :        989 :         visit (DECL_VALUE_EXPR (t));
    1245                 :    1184340 :       if (code == VAR_DECL
    1246                 :    1523640 :           && DECL_HAS_DEBUG_EXPR_P (t))
    1247                 :       1242 :         visit (DECL_DEBUG_EXPR (t));
    1248                 :            :       /* ???  Hash DECL_INITIAL as streamed.  Needs the output-block to
    1249                 :            :          be able to call get_symbol_initial_value.  */
    1250                 :            :     }
    1251                 :            : 
    1252                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
    1253                 :            :     {
    1254                 :     685019 :       if (DECL_ASSEMBLER_NAME_SET_P (t))
    1255                 :     596384 :         visit (DECL_ASSEMBLER_NAME (t));
    1256                 :            :     }
    1257                 :            : 
    1258                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
    1259                 :            :     {
    1260                 :      76273 :       visit (DECL_FIELD_OFFSET (t));
    1261                 :      76273 :       visit (DECL_BIT_FIELD_TYPE (t));
    1262                 :      76273 :       visit (DECL_BIT_FIELD_REPRESENTATIVE (t));
    1263                 :      76273 :       visit (DECL_FIELD_BIT_OFFSET (t));
    1264                 :            :     }
    1265                 :            : 
    1266                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
    1267                 :            :     {
    1268                 :     325232 :       visit (DECL_FUNCTION_PERSONALITY (t));
    1269                 :     325232 :       visit (DECL_FUNCTION_SPECIFIC_TARGET (t));
    1270                 :     325232 :       visit (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t));
    1271                 :            :     }
    1272                 :            : 
    1273                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
    1274                 :            :     {
    1275                 :     369305 :       visit (TYPE_SIZE (t));
    1276                 :     369305 :       visit (TYPE_SIZE_UNIT (t));
    1277                 :     369305 :       visit (TYPE_ATTRIBUTES (t));
    1278                 :     369305 :       visit (TYPE_NAME (t));
    1279                 :     369305 :       visit (TYPE_MAIN_VARIANT (t));
    1280                 :     369305 :       if (TYPE_FILE_SCOPE_P (t))
    1281                 :            :         ;
    1282                 :            :       else
    1283                 :      14554 :         visit (TYPE_CONTEXT (t));
    1284                 :            :     }
    1285                 :            : 
    1286                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
    1287                 :            :     {
    1288                 :     369305 :       if (code == ENUMERAL_TYPE)
    1289                 :        619 :         visit (TYPE_VALUES (t));
    1290                 :     368686 :       else if (code == ARRAY_TYPE)
    1291                 :      21744 :         visit (TYPE_DOMAIN (t));
    1292                 :     346942 :       else if (RECORD_OR_UNION_TYPE_P (t))
    1293                 :     156337 :         for (tree f = TYPE_FIELDS (t); f; f = TREE_CHAIN (f))
    1294                 :      90934 :           visit (f);
    1295                 :     281539 :       else if (code == FUNCTION_TYPE
    1296                 :     281539 :                || code == METHOD_TYPE)
    1297                 :     124901 :         visit (TYPE_ARG_TYPES (t));
    1298                 :     369305 :       if (!POINTER_TYPE_P (t))
    1299                 :     218232 :         visit (TYPE_MIN_VALUE_RAW (t));
    1300                 :     369305 :       visit (TYPE_MAX_VALUE_RAW (t));
    1301                 :            :     }
    1302                 :            : 
    1303                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_LIST))
    1304                 :            :     {
    1305                 :     463807 :       visit (TREE_PURPOSE (t));
    1306                 :     463807 :       visit (TREE_VALUE (t));
    1307                 :     463807 :       visit (TREE_CHAIN (t));
    1308                 :            :     }
    1309                 :            : 
    1310                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_VEC))
    1311                 :          0 :     for (int i = 0; i < TREE_VEC_LENGTH (t); ++i)
    1312                 :          0 :       visit (TREE_VEC_ELT (t, i));
    1313                 :            : 
    1314                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
    1315                 :            :     {
    1316                 :    1099280 :       hstate.add_hwi (TREE_OPERAND_LENGTH (t));
    1317                 :    2687180 :       for (int i = 0; i < TREE_OPERAND_LENGTH (t); ++i)
    1318                 :    1587890 :         visit (TREE_OPERAND (t, i));
    1319                 :            :     }
    1320                 :            : 
    1321                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
    1322                 :            :     {
    1323                 :            :       unsigned i;
    1324                 :            :       tree b;
    1325                 :      12548 :       FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (t), i, b)
    1326                 :       6317 :         visit (b);
    1327                 :       6231 :       visit (BINFO_OFFSET (t));
    1328                 :       6231 :       visit (BINFO_VTABLE (t));
    1329                 :            :       /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
    1330                 :            :          BINFO_BASE_ACCESSES and BINFO_VPTR_INDEX; these are used
    1331                 :            :          by C++ FE only.  */
    1332                 :            :     }
    1333                 :            : 
    1334                 :    5672190 :   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
    1335                 :            :     {
    1336                 :     236488 :       unsigned i;
    1337                 :     236488 :       tree index, value;
    1338                 :     457189 :       hstate.add_hwi (CONSTRUCTOR_NELTS (t));
    1339                 :    1526880 :       FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), i, index, value)
    1340                 :            :         {
    1341                 :     534847 :           visit (index);
    1342                 :     534847 :           visit (value);
    1343                 :            :         }
    1344                 :            :     }
    1345                 :            : 
    1346                 :    5672190 :   if (code == OMP_CLAUSE)
    1347                 :            :     {
    1348                 :        122 :       int i;
    1349                 :        122 :       HOST_WIDE_INT val;
    1350                 :            : 
    1351                 :        122 :       hstate.add_hwi (OMP_CLAUSE_CODE (t));
    1352                 :        122 :       switch (OMP_CLAUSE_CODE (t))
    1353                 :            :         {
    1354                 :          0 :         case OMP_CLAUSE_DEFAULT:
    1355                 :          0 :           val = OMP_CLAUSE_DEFAULT_KIND (t);
    1356                 :          0 :           break;
    1357                 :          0 :         case OMP_CLAUSE_SCHEDULE:
    1358                 :          0 :           val = OMP_CLAUSE_SCHEDULE_KIND (t);
    1359                 :          0 :           break;
    1360                 :          0 :         case OMP_CLAUSE_DEPEND:
    1361                 :          0 :           val = OMP_CLAUSE_DEPEND_KIND (t);
    1362                 :          0 :           break;
    1363                 :          0 :         case OMP_CLAUSE_MAP:
    1364                 :          0 :           val = OMP_CLAUSE_MAP_KIND (t);
    1365                 :          0 :           break;
    1366                 :          0 :         case OMP_CLAUSE_PROC_BIND:
    1367                 :          0 :           val = OMP_CLAUSE_PROC_BIND_KIND (t);
    1368                 :          0 :           break;
    1369                 :          0 :         case OMP_CLAUSE_REDUCTION:
    1370                 :          0 :         case OMP_CLAUSE_TASK_REDUCTION:
    1371                 :          0 :         case OMP_CLAUSE_IN_REDUCTION:
    1372                 :          0 :           val = OMP_CLAUSE_REDUCTION_CODE (t);
    1373                 :          0 :           break;
    1374                 :            :         default:
    1375                 :            :           val = 0;
    1376                 :            :           break;
    1377                 :            :         }
    1378                 :        122 :       hstate.add_hwi (val);
    1379                 :        284 :       for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (t)]; i++)
    1380                 :        162 :         visit (OMP_CLAUSE_OPERAND (t, i));
    1381                 :        122 :       visit (OMP_CLAUSE_CHAIN (t));
    1382                 :            :     }
    1383                 :            : 
    1384                 :    5672190 :   return hstate.end ();
    1385                 :            : 
    1386                 :            : #undef visit
    1387                 :            : }
    1388                 :            : 
    1389                 :            : /* Compare two SCC entries by their hash value for qsorting them.  */
    1390                 :            : 
    1391                 :            : int
    1392                 :    1331760 : DFS::scc_entry_compare (const void *p1_, const void *p2_)
    1393                 :            : {
    1394                 :    1331760 :   const scc_entry *p1 = (const scc_entry *) p1_;
    1395                 :    1331760 :   const scc_entry *p2 = (const scc_entry *) p2_;
    1396                 :    1331760 :   if (p1->hash < p2->hash)
    1397                 :            :     return -1;
    1398                 :     591590 :   else if (p1->hash > p2->hash)
    1399                 :     570194 :     return 1;
    1400                 :            :   return 0;
    1401                 :            : }
    1402                 :            : 
    1403                 :            : /* Return a hash value for the SCC on the SCC stack from FIRST with SIZE.
    1404                 :            :    THIS_REF_P and REF_P are as passed to lto_output_tree for FIRST.  */
    1405                 :            : 
    1406                 :            : hashval_t
    1407                 :    5541400 : DFS::hash_scc (struct output_block *ob, unsigned first, unsigned size,
    1408                 :            :                bool ref_p, bool this_ref_p)
    1409                 :            : {
    1410                 :    5541400 :   unsigned int last_classes = 0, iterations = 0;
    1411                 :            : 
    1412                 :            :   /* Compute hash values for the SCC members.  */
    1413                 :   11213600 :   for (unsigned i = 0; i < size; ++i)
    1414                 :   11344400 :     sccstack[first+i].hash
    1415                 :    5672190 :       = hash_tree (ob->writer_cache, NULL, sccstack[first+i].t);
    1416                 :            : 
    1417                 :    5541400 :   if (size == 1)
    1418                 :    5480740 :     return sccstack[first].hash;
    1419                 :            : 
    1420                 :            :   /* We aim to get unique hash for every tree within SCC and compute hash value
    1421                 :            :      of the whole SCC by combining all values together in a stable (entry-point
    1422                 :            :      independent) order.  This guarantees that the same SCC regions within
    1423                 :            :      different translation units will get the same hash values and therefore
    1424                 :            :      will be merged at WPA time.
    1425                 :            : 
    1426                 :            :      Often the hashes are already unique.  In that case we compute the SCC hash
    1427                 :            :      by combining individual hash values in an increasing order.
    1428                 :            : 
    1429                 :            :      If there are duplicates, we seek at least one tree with unique hash (and
    1430                 :            :      pick one with minimal hash and this property).  Then we obtain a stable
    1431                 :            :      order by DFS walk starting from this unique tree and then use the index
    1432                 :            :      within this order to make individual hash values unique.
    1433                 :            : 
    1434                 :            :      If there is no tree with unique hash, we iteratively propagate the hash
    1435                 :            :      values across the internal edges of SCC.  This usually quickly leads
    1436                 :            :      to unique hashes.  Consider, for example, an SCC containing two pointers
    1437                 :            :      that are identical except for the types they point to and assume that
    1438                 :            :      these types are also part of the SCC.  The propagation will add the
    1439                 :            :      points-to type information into their hash values.  */
    1440                 :      60663 :   do
    1441                 :            :     {
    1442                 :            :       /* Sort the SCC so we can easily check for uniqueness.  */
    1443                 :      60663 :       qsort (&sccstack[first], size, sizeof (scc_entry), scc_entry_compare);
    1444                 :            : 
    1445                 :      60663 :       unsigned int classes = 1;
    1446                 :      60663 :       int firstunique = -1;
    1447                 :            : 
    1448                 :            :       /* Find the tree with lowest unique hash (if it exists) and compute
    1449                 :            :          the number of equivalence classes.  */
    1450                 :      60663 :       if (sccstack[first].hash != sccstack[first+1].hash)
    1451                 :      60655 :         firstunique = 0;
    1452                 :     191451 :       for (unsigned i = 1; i < size; ++i)
    1453                 :     130788 :         if (sccstack[first+i-1].hash != sccstack[first+i].hash)
    1454                 :            :           {
    1455                 :     128842 :             classes++;
    1456                 :     128842 :             if (firstunique == -1
    1457                 :     128842 :                 && (i == size - 1
    1458                 :          7 :                     || sccstack[first+i+1].hash != sccstack[first+i].hash))
    1459                 :          8 :               firstunique = i;
    1460                 :            :           }
    1461                 :            : 
    1462                 :            :       /* If we found a tree with unique hash, stop the iteration.  */
    1463                 :      60663 :       if (firstunique != -1
    1464                 :            :           /* Also terminate if we run out of iterations or if the number of
    1465                 :            :              equivalence classes is no longer increasing.
    1466                 :            :              For example a cyclic list of trees that are all equivalent will
    1467                 :            :              never have unique entry point; we however do not build such SCCs
    1468                 :            :              in our IL.  */
    1469                 :      60663 :           || classes <= last_classes || iterations > 16)
    1470                 :            :         {
    1471                 :      60663 :           hashval_t scc_hash;
    1472                 :            : 
    1473                 :            :           /* If some hashes are not unique (CLASSES != SIZE), use the DFS walk
    1474                 :            :              starting from FIRSTUNIQUE to obtain a stable order.  */
    1475                 :      60663 :           if (classes != size && firstunique != -1)
    1476                 :            :             {
    1477                 :        646 :               hash_map <tree, hashval_t> map(size*2);
    1478                 :            : 
    1479                 :            :               /* Store hash values into a map, so we can associate them with
    1480                 :            :                  the reordered SCC.  */
    1481                 :      10775 :               for (unsigned i = 0; i < size; ++i)
    1482                 :      10452 :                 map.put (sccstack[first+i].t, sccstack[first+i].hash);
    1483                 :            : 
    1484                 :        646 :               DFS again (ob, sccstack[first+firstunique].t, ref_p, this_ref_p,
    1485                 :        646 :                          true);
    1486                 :        646 :               gcc_assert (again.sccstack.length () == size);
    1487                 :            : 
    1488                 :        323 :               memcpy (sccstack.address () + first,
    1489                 :        323 :                       again.sccstack.address (),
    1490                 :            :                       sizeof (scc_entry) * size);
    1491                 :            : 
    1492                 :            :               /* Update hash values of individual members by hashing in the
    1493                 :            :                  index within the stable order.  This ensures uniqueness.
    1494                 :            :                  Also compute the SCC hash by mixing in all hash values in
    1495                 :            :                  the stable order we obtained.  */
    1496                 :        646 :               sccstack[first].hash = *map.get (sccstack[first].t);
    1497                 :        323 :               scc_hash = sccstack[first].hash;
    1498                 :      10452 :               for (unsigned i = 1; i < size; ++i)
    1499                 :            :                 {
    1500                 :      30387 :                   sccstack[first+i].hash
    1501                 :      20258 :                     = iterative_hash_hashval_t (i,
    1502                 :      20258 :                                                 *map.get (sccstack[first+i].t));
    1503                 :      10129 :                   scc_hash
    1504                 :      10129 :                     = iterative_hash_hashval_t (scc_hash,
    1505                 :      10129 :                                                 sccstack[first+i].hash);
    1506                 :            :                 }
    1507                 :            :             }
    1508                 :            :           /* If we got a unique hash value for each tree, then sort already
    1509                 :            :              ensured entry-point independent order.  Only compute the final
    1510                 :            :              SCC hash.
    1511                 :            : 
    1512                 :            :              If we failed to find the unique entry point, we go by the same
    1513                 :            :              route.  We will eventually introduce unwanted hash conflicts.  */
    1514                 :            :           else
    1515                 :            :             {
    1516                 :     180999 :               scc_hash = sccstack[first].hash;
    1517                 :     180999 :               for (unsigned i = 1; i < size; ++i)
    1518                 :     120659 :                 scc_hash
    1519                 :     120659 :                   = iterative_hash_hashval_t (scc_hash, sccstack[first+i].hash);
    1520                 :            : 
    1521                 :            :               /* We cannot 100% guarantee that the hash won't conflict so as
    1522                 :            :                  to make it impossible to find a unique hash.  This however
    1523                 :            :                  should be an extremely rare case.  ICE for now so possible
    1524                 :            :                  issues are found and evaluated.  */
    1525                 :      60340 :               gcc_checking_assert (classes == size);
    1526                 :            :             }
    1527                 :            : 
    1528                 :            :           /* To avoid conflicts across SCCs, iteratively hash the whole SCC
    1529                 :            :              hash into the hash of each element.  */
    1530                 :     252114 :           for (unsigned i = 0; i < size; ++i)
    1531                 :     382902 :             sccstack[first+i].hash
    1532                 :     191451 :               = iterative_hash_hashval_t (sccstack[first+i].hash, scc_hash);
    1533                 :      60663 :           return scc_hash;
    1534                 :            :         }
    1535                 :            : 
    1536                 :          0 :       last_classes = classes;
    1537                 :          0 :       iterations++;
    1538                 :            : 
    1539                 :            :       /* We failed to identify the entry point; propagate hash values across
    1540                 :            :          the edges.  */
    1541                 :          0 :       hash_map <tree, hashval_t> map(size*2);
    1542                 :            : 
    1543                 :          0 :       for (unsigned i = 0; i < size; ++i)
    1544                 :          0 :         map.put (sccstack[first+i].t, sccstack[first+i].hash);
    1545                 :            : 
    1546                 :          0 :       for (unsigned i = 0; i < size; i++)
    1547                 :          0 :         sccstack[first+i].hash
    1548                 :          0 :           = hash_tree (ob->writer_cache, &map, sccstack[first+i].t);
    1549                 :            :     }
    1550                 :            :   while (true);
    1551                 :            : }
    1552                 :            : 
    1553                 :            : /* DFS walk EXPR and stream SCCs of tree bodies if they are not
    1554                 :            :    already in the streamer cache.  Main routine called for
    1555                 :            :    each visit of EXPR.  */
    1556                 :            : 
    1557                 :            : void
    1558                 :   28012000 : DFS::DFS_write_tree (struct output_block *ob, sccs *from_state,
    1559                 :            :                      tree expr, bool ref_p, bool this_ref_p)
    1560                 :            : {
    1561                 :            :   /* Handle special cases.  */
    1562                 :   28012000 :   if (expr == NULL_TREE)
    1563                 :   20466500 :     return;
    1564                 :            : 
    1565                 :            :   /* Do not DFS walk into indexable trees.  */
    1566                 :   17974600 :   if (this_ref_p && tree_is_indexable (expr))
    1567                 :            :     return;
    1568                 :            : 
    1569                 :            :   /* Check if we already streamed EXPR.  */
    1570                 :   13265700 :   if (streamer_tree_cache_lookup (ob->writer_cache, expr, NULL))
    1571                 :            :     return;
    1572                 :            : 
    1573                 :    7545560 :   worklist w;
    1574                 :    7545560 :   w.expr = expr;
    1575                 :    7545560 :   w.from_state = from_state;
    1576                 :    7545560 :   w.cstate = NULL;
    1577                 :    7545560 :   w.ref_p = ref_p;
    1578                 :    7545560 :   w.this_ref_p = this_ref_p;
    1579                 :    7545560 :   worklist_vec.safe_push (w);
    1580                 :            : }
    1581                 :            : 
    1582                 :            : 
    1583                 :            : /* Emit the physical representation of tree node EXPR to output block OB.
    1584                 :            :    If THIS_REF_P is true, the leaves of EXPR are emitted as references via
    1585                 :            :    lto_output_tree_ref.  REF_P is used for streaming siblings of EXPR.  */
    1586                 :            : 
    1587                 :            : void
    1588                 :   34008600 : lto_output_tree (struct output_block *ob, tree expr,
    1589                 :            :                  bool ref_p, bool this_ref_p)
    1590                 :            : {
    1591                 :   34008600 :   unsigned ix;
    1592                 :   34008600 :   bool existed_p;
    1593                 :            : 
    1594                 :   34008600 :   if (expr == NULL_TREE)
    1595                 :            :     {
    1596                 :   11728000 :       streamer_write_record_start (ob, LTO_null);
    1597                 :   30670400 :       return;
    1598                 :            :     }
    1599                 :            : 
    1600                 :   22280600 :   if (this_ref_p && tree_is_indexable (expr))
    1601                 :            :     {
    1602                 :    7214410 :       lto_output_tree_ref (ob, expr);
    1603                 :    7214410 :       return;
    1604                 :            :     }
    1605                 :            : 
    1606                 :   15066200 :   existed_p = streamer_tree_cache_lookup (ob->writer_cache, expr, &ix);
    1607                 :   15066200 :   if (existed_p)
    1608                 :            :     {
    1609                 :            :       /* If a node has already been streamed out, make sure that
    1610                 :            :          we don't write it more than once.  Otherwise, the reader
    1611                 :            :          will instantiate two different nodes for the same object.  */
    1612                 :   12789000 :       streamer_write_record_start (ob, LTO_tree_pickle_reference);
    1613                 :   12789000 :       streamer_write_uhwi (ob, ix);
    1614                 :   12789000 :       streamer_write_enum (ob->main_stream, LTO_tags, LTO_NUM_TAGS,
    1615                 :            :                            lto_tree_code_to_tag (TREE_CODE (expr)));
    1616                 :   12789000 :       lto_stats.num_pickle_refs_output++;
    1617                 :            :     }
    1618                 :            :   else
    1619                 :            :     {
    1620                 :            :       /* This is the first time we see EXPR, write all reachable
    1621                 :            :          trees to OB.  */
    1622                 :    2277220 :       static bool in_dfs_walk;
    1623                 :            : 
    1624                 :            :       /* Protect against recursion which means disconnect between
    1625                 :            :          what tree edges we walk in the DFS walk and what edges
    1626                 :            :          we stream out.  */
    1627                 :    2277220 :       gcc_assert (!in_dfs_walk);
    1628                 :            : 
    1629                 :    2277220 :       if (streamer_dump_file)
    1630                 :            :         {
    1631                 :        180 :           print_node_brief (streamer_dump_file, "   Streaming SCC of ",
    1632                 :            :                             expr, 4);
    1633                 :        180 :           fprintf (streamer_dump_file, "\n");
    1634                 :            :         }
    1635                 :            : 
    1636                 :            :       /* Start the DFS walk.  */
    1637                 :            :       /* Save ob state ... */
    1638                 :            :       /* let's see ... */
    1639                 :    2277220 :       in_dfs_walk = true;
    1640                 :    2277220 :       DFS (ob, expr, ref_p, this_ref_p, false);
    1641                 :    2277220 :       in_dfs_walk = false;
    1642                 :            : 
    1643                 :            :       /* Finally append a reference to the tree we were writing.
    1644                 :            :          ???  If expr ended up as a singleton we could have
    1645                 :            :          inlined it here and avoid outputting a reference.  */
    1646                 :    2277220 :       existed_p = streamer_tree_cache_lookup (ob->writer_cache, expr, &ix);
    1647                 :    2277220 :       gcc_assert (existed_p);
    1648                 :    2277220 :       streamer_write_record_start (ob, LTO_tree_pickle_reference);
    1649                 :    2277220 :       streamer_write_uhwi (ob, ix);
    1650                 :    2277220 :       streamer_write_enum (ob->main_stream, LTO_tags, LTO_NUM_TAGS,
    1651                 :            :                            lto_tree_code_to_tag (TREE_CODE (expr)));
    1652                 :    2277220 :       if (streamer_dump_file)
    1653                 :            :         {
    1654                 :        180 :           print_node_brief (streamer_dump_file, "   Finished SCC of ",
    1655                 :            :                             expr, 4);
    1656                 :        180 :           fprintf (streamer_dump_file, "\n\n");
    1657                 :            :         }
    1658                 :    2277220 :       lto_stats.num_pickle_refs_output++;
    1659                 :            :     }
    1660                 :            : }
    1661                 :            : 
    1662                 :            : 
    1663                 :            : /* Output to OB a list of try/catch handlers starting with FIRST.  */
    1664                 :            : 
    1665                 :            : static void
    1666                 :        231 : output_eh_try_list (struct output_block *ob, eh_catch first)
    1667                 :            : {
    1668                 :        231 :   eh_catch n;
    1669                 :            : 
    1670                 :        508 :   for (n = first; n; n = n->next_catch)
    1671                 :            :     {
    1672                 :        277 :       streamer_write_record_start (ob, LTO_eh_catch);
    1673                 :        277 :       stream_write_tree (ob, n->type_list, true);
    1674                 :        277 :       stream_write_tree (ob, n->filter_list, true);
    1675                 :        277 :       stream_write_tree (ob, n->label, true);
    1676                 :            :     }
    1677                 :            : 
    1678                 :        231 :   streamer_write_record_start (ob, LTO_null);
    1679                 :        231 : }
    1680                 :            : 
    1681                 :            : 
    1682                 :            : /* Output EH region R in function FN to OB.  CURR_RN is the slot index
    1683                 :            :    that is being emitted in FN->EH->REGION_ARRAY.  This is used to
    1684                 :            :    detect EH region sharing.  */
    1685                 :            : 
    1686                 :            : static void
    1687                 :      14091 : output_eh_region (struct output_block *ob, eh_region r)
    1688                 :            : {
    1689                 :      14091 :   enum LTO_tags tag;
    1690                 :            : 
    1691                 :      14091 :   if (r == NULL)
    1692                 :            :     {
    1693                 :       6108 :       streamer_write_record_start (ob, LTO_null);
    1694                 :       6108 :       return;
    1695                 :            :     }
    1696                 :            : 
    1697                 :       7983 :   if (r->type == ERT_CLEANUP)
    1698                 :            :     tag = LTO_ert_cleanup;
    1699                 :       4252 :   else if (r->type == ERT_TRY)
    1700                 :            :     tag = LTO_ert_try;
    1701                 :       4021 :   else if (r->type == ERT_ALLOWED_EXCEPTIONS)
    1702                 :            :     tag = LTO_ert_allowed_exceptions;
    1703                 :       3845 :   else if (r->type == ERT_MUST_NOT_THROW)
    1704                 :            :     tag = LTO_ert_must_not_throw;
    1705                 :            :   else
    1706                 :          0 :     gcc_unreachable ();
    1707                 :            : 
    1708                 :       7983 :   streamer_write_record_start (ob, tag);
    1709                 :       7983 :   streamer_write_hwi (ob, r->index);
    1710                 :            : 
    1711                 :       7983 :   if (r->outer)
    1712                 :       2610 :     streamer_write_hwi (ob, r->outer->index);
    1713                 :            :   else
    1714                 :       5373 :     streamer_write_zero (ob);
    1715                 :            : 
    1716                 :       7983 :   if (r->inner)
    1717                 :       1453 :     streamer_write_hwi (ob, r->inner->index);
    1718                 :            :   else
    1719                 :       6530 :     streamer_write_zero (ob);
    1720                 :            : 
    1721                 :       7983 :   if (r->next_peer)
    1722                 :       2482 :     streamer_write_hwi (ob, r->next_peer->index);
    1723                 :            :   else
    1724                 :       5501 :     streamer_write_zero (ob);
    1725                 :            : 
    1726                 :       7983 :   if (r->type == ERT_TRY)
    1727                 :            :     {
    1728                 :        231 :       output_eh_try_list (ob, r->u.eh_try.first_catch);
    1729                 :            :     }
    1730                 :       7752 :   else if (r->type == ERT_ALLOWED_EXCEPTIONS)
    1731                 :            :     {
    1732                 :        176 :       stream_write_tree (ob, r->u.allowed.type_list, true);
    1733                 :        176 :       stream_write_tree (ob, r->u.allowed.label, true);
    1734                 :        176 :       streamer_write_uhwi (ob, r->u.allowed.filter);
    1735                 :            :     }
    1736                 :       7576 :   else if (r->type == ERT_MUST_NOT_THROW)
    1737                 :            :     {
    1738                 :       3845 :       stream_write_tree (ob, r->u.must_not_throw.failure_decl, true);
    1739                 :       3845 :       bitpack_d bp = bitpack_create (ob->main_stream);
    1740                 :       3845 :       stream_output_location (ob, &bp, r->u.must_not_throw.failure_loc);
    1741                 :       3845 :       streamer_write_bitpack (&bp);
    1742                 :            :     }
    1743                 :            : 
    1744                 :       7983 :   if (r->landing_pads)
    1745                 :       2304 :     streamer_write_hwi (ob, r->landing_pads->index);
    1746                 :            :   else
    1747                 :       5679 :     streamer_write_zero (ob);
    1748                 :            : }
    1749                 :            : 
    1750                 :            : 
    1751                 :            : /* Output landing pad LP to OB.  */
    1752                 :            : 
    1753                 :            : static void
    1754                 :       6948 : output_eh_lp (struct output_block *ob, eh_landing_pad lp)
    1755                 :            : {
    1756                 :       6948 :   if (lp == NULL)
    1757                 :            :     {
    1758                 :       4614 :       streamer_write_record_start (ob, LTO_null);
    1759                 :       4614 :       return;
    1760                 :            :     }
    1761                 :            : 
    1762                 :       2334 :   streamer_write_record_start (ob, LTO_eh_landing_pad);
    1763                 :       2334 :   streamer_write_hwi (ob, lp->index);
    1764                 :       2334 :   if (lp->next_lp)
    1765                 :         30 :     streamer_write_hwi (ob, lp->next_lp->index);
    1766                 :            :   else
    1767                 :       2304 :     streamer_write_zero (ob);
    1768                 :            : 
    1769                 :       2334 :   if (lp->region)
    1770                 :       2334 :     streamer_write_hwi (ob, lp->region->index);
    1771                 :            :   else
    1772                 :          0 :     streamer_write_zero (ob);
    1773                 :            : 
    1774                 :       2334 :   stream_write_tree (ob, lp->post_landing_pad, true);
    1775                 :            : }
    1776                 :            : 
    1777                 :            : 
    1778                 :            : /* Output the existing eh_table to OB.  */
    1779                 :            : 
    1780                 :            : static void
    1781                 :      91232 : output_eh_regions (struct output_block *ob, struct function *fn)
    1782                 :            : {
    1783                 :      91232 :   if (fn->eh && fn->eh->region_tree)
    1784                 :            :     {
    1785                 :       4048 :       unsigned i;
    1786                 :       4048 :       eh_region eh;
    1787                 :       4048 :       eh_landing_pad lp;
    1788                 :       4048 :       tree ttype;
    1789                 :            : 
    1790                 :       4048 :       streamer_write_record_start (ob, LTO_eh_table);
    1791                 :            : 
    1792                 :            :       /* Emit the index of the root of the EH region tree.  */
    1793                 :       4048 :       streamer_write_hwi (ob, fn->eh->region_tree->index);
    1794                 :            : 
    1795                 :            :       /* Emit all the EH regions in the region array.  */
    1796                 :       4048 :       streamer_write_hwi (ob, vec_safe_length (fn->eh->region_array));
    1797                 :      18139 :       FOR_EACH_VEC_SAFE_ELT (fn->eh->region_array, i, eh)
    1798                 :      14091 :         output_eh_region (ob, eh);
    1799                 :            : 
    1800                 :            :       /* Emit all landing pads.  */
    1801                 :       4048 :       streamer_write_hwi (ob, vec_safe_length (fn->eh->lp_array));
    1802                 :      10996 :       FOR_EACH_VEC_SAFE_ELT (fn->eh->lp_array, i, lp)
    1803                 :       6948 :         output_eh_lp (ob, lp);
    1804                 :            : 
    1805                 :            :       /* Emit all the runtime type data.  */
    1806                 :       4048 :       streamer_write_hwi (ob, vec_safe_length (fn->eh->ttype_data));
    1807                 :       4048 :       FOR_EACH_VEC_SAFE_ELT (fn->eh->ttype_data, i, ttype)
    1808                 :          0 :         stream_write_tree (ob, ttype, true);
    1809                 :            : 
    1810                 :            :       /* Emit the table of action chains.  */
    1811                 :       4048 :       if (targetm.arm_eabi_unwinder)
    1812                 :            :         {
    1813                 :          0 :           tree t;
    1814                 :          0 :           streamer_write_hwi (ob, vec_safe_length (fn->eh->ehspec_data.arm_eabi));
    1815                 :          0 :           FOR_EACH_VEC_SAFE_ELT (fn->eh->ehspec_data.arm_eabi, i, t)
    1816                 :          0 :             stream_write_tree (ob, t, true);
    1817                 :            :         }
    1818                 :            :       else
    1819                 :            :         {
    1820                 :       4048 :           uchar c;
    1821                 :       4048 :           streamer_write_hwi (ob, vec_safe_length (fn->eh->ehspec_data.other));
    1822                 :       4048 :           FOR_EACH_VEC_SAFE_ELT (fn->eh->ehspec_data.other, i, c)
    1823                 :          0 :             streamer_write_char_stream (ob->main_stream, c);
    1824                 :            :         }
    1825                 :            :     }
    1826                 :            : 
    1827                 :            :   /* The LTO_null either terminates the record or indicates that there
    1828                 :            :      are no eh_records at all.  */
    1829                 :      91232 :   streamer_write_record_start (ob, LTO_null);
    1830                 :      91232 : }
    1831                 :            : 
    1832                 :            : 
    1833                 :            : /* Output all of the active ssa names to the ssa_names stream.  */
    1834                 :            : 
    1835                 :            : static void
    1836                 :      91232 : output_ssa_names (struct output_block *ob, struct function *fn)
    1837                 :            : {
    1838                 :      91232 :   unsigned int i, len;
    1839                 :            : 
    1840                 :      91232 :   len = vec_safe_length (SSANAMES (fn));
    1841                 :      91232 :   streamer_write_uhwi (ob, len);
    1842                 :            : 
    1843                 :    1263000 :   for (i = 1; i < len; i++)
    1844                 :            :     {
    1845                 :    1171770 :       tree ptr = (*SSANAMES (fn))[i];
    1846                 :            : 
    1847                 :    1644780 :       if (ptr == NULL_TREE
    1848                 :    1166120 :           || SSA_NAME_IN_FREE_LIST (ptr)
    1849                 :    1166120 :           || virtual_operand_p (ptr)
    1850                 :            :           /* Simply skip unreleased SSA names.  */
    1851                 :    1871750 :           || (! SSA_NAME_IS_DEFAULT_DEF (ptr)
    1852                 :     607704 :               && (! SSA_NAME_DEF_STMT (ptr)
    1853                 :     607704 :                   || ! gimple_bb (SSA_NAME_DEF_STMT (ptr)))))
    1854                 :     473017 :         continue;
    1855                 :            : 
    1856                 :     698749 :       streamer_write_uhwi (ob, i);
    1857                 :     698749 :       streamer_write_char_stream (ob->main_stream,
    1858                 :     698749 :                                   SSA_NAME_IS_DEFAULT_DEF (ptr));
    1859                 :     698749 :       if (SSA_NAME_VAR (ptr))
    1860                 :     167013 :         stream_write_tree (ob, SSA_NAME_VAR (ptr), true);
    1861                 :            :       else
    1862                 :            :         /* ???  This drops SSA_NAME_IDENTIFIER on the floor.  */
    1863                 :     531736 :         stream_write_tree (ob, TREE_TYPE (ptr), true);
    1864                 :            :     }
    1865                 :            : 
    1866                 :      91232 :   streamer_write_zero (ob);
    1867                 :      91232 : }
    1868                 :            : 
    1869                 :            : 
    1870                 :            : 
    1871                 :            : /* Output the cfg.  */
    1872                 :            : 
    1873                 :            : static void
    1874                 :      91232 : output_cfg (struct output_block *ob, struct function *fn)
    1875                 :            : {
    1876                 :      91232 :   struct lto_output_stream *tmp_stream = ob->main_stream;
    1877                 :      91232 :   basic_block bb;
    1878                 :            : 
    1879                 :      91232 :   ob->main_stream = ob->cfg_stream;
    1880                 :            : 
    1881                 :      91232 :   streamer_write_enum (ob->main_stream, profile_status_d, PROFILE_LAST,
    1882                 :            :                        profile_status_for_fn (fn));
    1883                 :            : 
    1884                 :            :   /* Output the number of the highest basic block.  */
    1885                 :      91232 :   streamer_write_uhwi (ob, last_basic_block_for_fn (fn));
    1886                 :            : 
    1887                 :     717090 :   FOR_ALL_BB_FN (bb, fn)
    1888                 :            :     {
    1889                 :     625858 :       edge_iterator ei;
    1890                 :     625858 :       edge e;
    1891                 :            : 
    1892                 :     625858 :       streamer_write_hwi (ob, bb->index);
    1893                 :            : 
    1894                 :            :       /* Output the successors and the edge flags.  */
    1895                 :    1158590 :       streamer_write_uhwi (ob, EDGE_COUNT (bb->succs));
    1896                 :    1295710 :       FOR_EACH_EDGE (e, ei, bb->succs)
    1897                 :            :         {
    1898                 :     669856 :           streamer_write_uhwi (ob, e->dest->index);
    1899                 :     669856 :           e->probability.stream_out (ob);
    1900                 :     669856 :           streamer_write_uhwi (ob, e->flags);
    1901                 :            :         }
    1902                 :            :     }
    1903                 :            : 
    1904                 :      91232 :   streamer_write_hwi (ob, -1);
    1905                 :            : 
    1906                 :      91232 :   bb = ENTRY_BLOCK_PTR_FOR_FN (fn);
    1907                 :     625858 :   while (bb->next_bb)
    1908                 :            :     {
    1909                 :     534626 :       streamer_write_hwi (ob, bb->next_bb->index);
    1910                 :     534626 :       bb = bb->next_bb;
    1911                 :            :     }
    1912                 :            : 
    1913                 :      91232 :   streamer_write_hwi (ob, -1);
    1914                 :            : 
    1915                 :            :   /* Output the number of loops.  */
    1916                 :      91232 :   streamer_write_uhwi (ob, number_of_loops (fn));
    1917                 :            : 
    1918                 :            :   /* Output each loop, skipping the tree root which has number zero.  */
    1919                 :     220886 :   for (unsigned i = 1; i < number_of_loops (fn); ++i)
    1920                 :            :     {
    1921                 :      19211 :       class loop *loop = get_loop (fn, i);
    1922                 :            : 
    1923                 :            :       /* Write the index of the loop header.  That's enough to rebuild
    1924                 :            :          the loop tree on the reader side.  Stream -1 for an unused
    1925                 :            :          loop entry.  */
    1926                 :      19211 :       if (!loop)
    1927                 :            :         {
    1928                 :       1342 :           streamer_write_hwi (ob, -1);
    1929                 :       1342 :           continue;
    1930                 :            :         }
    1931                 :            :       else
    1932                 :      17869 :         streamer_write_hwi (ob, loop->header->index);
    1933                 :            : 
    1934                 :            :       /* Write everything copy_loop_info copies.  */
    1935                 :      17869 :       streamer_write_enum (ob->main_stream,
    1936                 :            :                            loop_estimation, EST_LAST, loop->estimate_state);
    1937                 :      17869 :       streamer_write_hwi (ob, loop->any_upper_bound);
    1938                 :      17869 :       if (loop->any_upper_bound)
    1939                 :      10347 :         streamer_write_widest_int (ob, loop->nb_iterations_upper_bound);
    1940                 :      17869 :       streamer_write_hwi (ob, loop->any_likely_upper_bound);
    1941                 :      17869 :       if (loop->any_likely_upper_bound)
    1942                 :      10349 :         streamer_write_widest_int (ob, loop->nb_iterations_likely_upper_bound);
    1943                 :      17869 :       streamer_write_hwi (ob, loop->any_estimate);
    1944                 :      17869 :       if (loop->any_estimate)
    1945                 :       5413 :         streamer_write_widest_int (ob, loop->nb_iterations_estimate);
    1946                 :            : 
    1947                 :            :       /* Write OMP SIMD related info.  */
    1948                 :      17869 :       streamer_write_hwi (ob, loop->safelen);
    1949                 :      17869 :       streamer_write_hwi (ob, loop->unroll);
    1950                 :      17869 :       streamer_write_hwi (ob, loop->owned_clique);
    1951                 :      17869 :       streamer_write_hwi (ob, loop->dont_vectorize);
    1952                 :      17869 :       streamer_write_hwi (ob, loop->force_vectorize);
    1953                 :      17869 :       streamer_write_hwi (ob, loop->finite_p);
    1954                 :      17869 :       stream_write_tree (ob, loop->simduid, true);
    1955                 :            :     }
    1956                 :            : 
    1957                 :      91232 :   ob->main_stream = tmp_stream;
    1958                 :      91232 : }
    1959                 :            : 
    1960                 :            : 
    1961                 :            : /* Create the header in the file using OB.  If the section type is for
    1962                 :            :    a function, set FN to the decl for that function.  */
    1963                 :            : 
    1964                 :            : void
    1965                 :     177376 : produce_asm (struct output_block *ob, tree fn)
    1966                 :            : {
    1967                 :     177376 :   enum lto_section_type section_type = ob->section_type;
    1968                 :     177376 :   struct lto_function_header header;
    1969                 :     177376 :   char *section_name;
    1970                 :            : 
    1971                 :     177376 :   if (section_type == LTO_section_function_body)
    1972                 :            :     {
    1973                 :     103638 :       const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn));
    1974                 :     103638 :       section_name = lto_get_section_name (section_type, name,
    1975                 :     103638 :                                            symtab_node::get (fn)->order,
    1976                 :            :                                            NULL);
    1977                 :            :     }
    1978                 :            :   else
    1979                 :      73738 :     section_name = lto_get_section_name (section_type, NULL, 0, NULL);
    1980                 :            : 
    1981                 :     177376 :   lto_begin_section (section_name, !flag_wpa);
    1982                 :     177376 :   free (section_name);
    1983                 :            : 
    1984                 :            :   /* The entire header is stream computed here.  */
    1985                 :     177376 :   memset (&header, 0, sizeof (struct lto_function_header));
    1986                 :            : 
    1987                 :     177376 :   if (section_type == LTO_section_function_body)
    1988                 :     103638 :     header.cfg_size = ob->cfg_stream->total_size;
    1989                 :     177376 :   header.main_size = ob->main_stream->total_size;
    1990                 :     177376 :   header.string_size = ob->string_stream->total_size;
    1991                 :     177376 :   lto_write_data (&header, sizeof header);
    1992                 :            : 
    1993                 :            :   /* Put all of the gimple and the string table out the asm file as a
    1994                 :            :      block of text.  */
    1995                 :     177376 :   if (section_type == LTO_section_function_body)
    1996                 :     103638 :     lto_write_stream (ob->cfg_stream);
    1997                 :     177376 :   lto_write_stream (ob->main_stream);
    1998                 :     177376 :   lto_write_stream (ob->string_stream);
    1999                 :            : 
    2000                 :     177376 :   lto_end_section ();
    2001                 :     177376 : }
    2002                 :            : 
    2003                 :            : 
    2004                 :            : /* Output the base body of struct function FN using output block OB.  */
    2005                 :            : 
    2006                 :            : static void
    2007                 :      91232 : output_struct_function_base (struct output_block *ob, struct function *fn)
    2008                 :            : {
    2009                 :      91232 :   struct bitpack_d bp;
    2010                 :      91232 :   unsigned i;
    2011                 :      91232 :   tree t;
    2012                 :            : 
    2013                 :            :   /* Output the static chain and non-local goto save area.  */
    2014                 :      91232 :   stream_write_tree (ob, fn->static_chain_decl, true);
    2015                 :      91232 :   stream_write_tree (ob, fn->nonlocal_goto_save_area, true);
    2016                 :            : 
    2017                 :            :   /* Output all the local variables in the function.  */
    2018                 :      91232 :   streamer_write_hwi (ob, vec_safe_length (fn->local_decls));
    2019                 :     182850 :   FOR_EACH_VEC_SAFE_ELT (fn->local_decls, i, t)
    2020                 :      91618 :     stream_write_tree (ob, t, true);
    2021                 :            : 
    2022                 :            :   /* Output current IL state of the function.  */
    2023                 :      91232 :   streamer_write_uhwi (ob, fn->curr_properties);
    2024                 :            : 
    2025                 :            :   /* Write all the attributes for FN.  */
    2026                 :      91232 :   bp = bitpack_create (ob->main_stream);
    2027                 :      91232 :   bp_pack_value (&bp, fn->is_thunk, 1);
    2028                 :      91232 :   bp_pack_value (&bp, fn->has_local_explicit_reg_vars, 1);
    2029                 :      91232 :   bp_pack_value (&bp, fn->returns_pcc_struct, 1);
    2030                 :      91232 :   bp_pack_value (&bp, fn->returns_struct, 1);
    2031                 :      91232 :   bp_pack_value (&bp, fn->can_throw_non_call_exceptions, 1);
    2032                 :      91232 :   bp_pack_value (&bp, fn->can_delete_dead_exceptions, 1);
    2033                 :      91232 :   bp_pack_value (&bp, fn->always_inline_functions_inlined, 1);
    2034                 :      91232 :   bp_pack_value (&bp, fn->after_inlining, 1);
    2035                 :      91232 :   bp_pack_value (&bp, fn->stdarg, 1);
    2036                 :      91232 :   bp_pack_value (&bp, fn->has_nonlocal_label, 1);
    2037                 :      91232 :   bp_pack_value (&bp, fn->has_forced_label_in_static, 1);
    2038                 :      91232 :   bp_pack_value (&bp, fn->calls_alloca, 1);
    2039                 :      91232 :   bp_pack_value (&bp, fn->calls_setjmp, 1);
    2040                 :      91232 :   bp_pack_value (&bp, fn->calls_eh_return, 1);
    2041                 :      91232 :   bp_pack_value (&bp, fn->has_force_vectorize_loops, 1);
    2042                 :      91232 :   bp_pack_value (&bp, fn->has_simduid_loops, 1);
    2043                 :      91232 :   bp_pack_value (&bp, fn->va_list_fpr_size, 8);
    2044                 :      91232 :   bp_pack_value (&bp, fn->va_list_gpr_size, 8);
    2045                 :      91232 :   bp_pack_value (&bp, fn->last_clique, sizeof (short) * 8);
    2046                 :            : 
    2047                 :            :   /* Output the function start and end loci.  */
    2048                 :      91232 :   stream_output_location (ob, &bp, fn->function_start_locus);
    2049                 :      91232 :   stream_output_location (ob, &bp, fn->function_end_locus);
    2050                 :            : 
    2051                 :            :   /* Save the instance discriminator if present.  */
    2052                 :      91232 :   int *instance_number_p = NULL;
    2053                 :      91232 :   if (decl_to_instance_map)
    2054                 :          0 :     instance_number_p = decl_to_instance_map->get (fn->decl);
    2055                 :      91232 :   bp_pack_value (&bp, !!instance_number_p, 1);
    2056                 :      91232 :   if (instance_number_p)
    2057                 :          0 :     bp_pack_value (&bp, *instance_number_p, sizeof (int) * CHAR_BIT);
    2058                 :            : 
    2059                 :      91232 :   streamer_write_bitpack (&bp);
    2060                 :      91232 : }
    2061                 :            : 
    2062                 :            : 
    2063                 :            : /* Collect all leaf BLOCKs beyond ROOT into LEAFS.  */
    2064                 :            : 
    2065                 :            : static void
    2066                 :     104639 : collect_block_tree_leafs (tree root, vec<tree> &leafs)
    2067                 :            : {
    2068                 :     144306 :   for (root = BLOCK_SUBBLOCKS (root); root; root = BLOCK_CHAIN (root))
    2069                 :      39667 :     if (! BLOCK_SUBBLOCKS (root))
    2070                 :      26260 :       leafs.safe_push (root);
    2071                 :            :     else
    2072                 :      13407 :       collect_block_tree_leafs (BLOCK_SUBBLOCKS (root), leafs);
    2073                 :     104639 : }
    2074                 :            : 
    2075                 :            : /* This performs function body modifications that are needed for streaming
    2076                 :            :    to work.  */
    2077                 :            : 
    2078                 :            : void
    2079                 :      91171 : lto_prepare_function_for_streaming (struct cgraph_node *node)
    2080                 :            : {
    2081                 :      91171 :   struct function *fn = DECL_STRUCT_FUNCTION (node->decl);
    2082                 :      91171 :   basic_block bb;
    2083                 :            : 
    2084                 :     182342 :   if (number_of_loops (fn))
    2085                 :            :     {
    2086                 :      91171 :       push_cfun (fn);
    2087                 :      91171 :       loop_optimizer_init (AVOID_CFG_MODIFICATIONS);
    2088                 :      91171 :       loop_optimizer_finalize ();
    2089                 :      91171 :       pop_cfun ();
    2090                 :            :     }
    2091                 :            :   /* We will renumber the statements.  The code that does this uses
    2092                 :            :      the same ordering that we use for serializing them so we can use
    2093                 :            :      the same code on the other end and not have to write out the
    2094                 :            :      statement numbers.  We do not assign UIDs to PHIs here because
    2095                 :            :      virtual PHIs get re-computed on-the-fly which would make numbers
    2096                 :            :      inconsistent.  */
    2097                 :      91171 :   set_gimple_stmt_max_uid (fn, 0);
    2098                 :     716824 :   FOR_ALL_BB_FN (bb, fn)
    2099                 :            :     {
    2100                 :     723404 :       for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
    2101                 :      97751 :            gsi_next (&gsi))
    2102                 :            :         {
    2103                 :      97751 :           gphi *stmt = gsi.phi ();
    2104                 :            : 
    2105                 :            :           /* Virtual PHIs are not going to be streamed.  */
    2106                 :     195502 :           if (!virtual_operand_p (gimple_phi_result (stmt)))
    2107                 :      97751 :             gimple_set_uid (stmt, inc_gimple_stmt_max_uid (fn));
    2108                 :            :         }
    2109                 :    2422960 :       for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);
    2110                 :    1171650 :            gsi_next (&gsi))
    2111                 :            :         {
    2112                 :    1171650 :           gimple *stmt = gsi_stmt (gsi);
    2113                 :    1171650 :           gimple_set_uid (stmt, inc_gimple_stmt_max_uid (fn));
    2114                 :            :         }
    2115                 :            :     }
    2116                 :            :   /* To avoid keeping duplicate gimple IDs in the statements, renumber
    2117                 :            :      virtual phis now.  */
    2118                 :     716824 :   FOR_ALL_BB_FN (bb, fn)
    2119                 :            :     {
    2120                 :     723404 :       for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
    2121                 :      97751 :            gsi_next (&gsi))
    2122                 :            :         {
    2123                 :      97751 :           gphi *stmt = gsi.phi ();
    2124                 :     195502 :           if (virtual_operand_p (gimple_phi_result (stmt)))
    2125                 :      97751 :             gimple_set_uid (stmt, inc_gimple_stmt_max_uid (fn));
    2126                 :            :         }
    2127                 :            :     }
    2128                 :            : 
    2129                 :      91171 : }
    2130                 :            : 
    2131                 :            : /* Output the body of function NODE->DECL.  */
    2132                 :            : 
    2133                 :            : static void
    2134                 :      91403 : output_function (struct cgraph_node *node)
    2135                 :            : {
    2136                 :      91403 :   tree function;
    2137                 :      91403 :   struct function *fn;
    2138                 :      91403 :   basic_block bb;
    2139                 :      91403 :   struct output_block *ob;
    2140                 :            : 
    2141                 :      91403 :   if (streamer_dump_file)
    2142                 :          8 :     fprintf (streamer_dump_file, "\nStreaming body of %s\n",
    2143                 :            :              node->dump_name ());
    2144                 :            : 
    2145                 :      91403 :   function = node->decl;
    2146                 :      91403 :   fn = DECL_STRUCT_FUNCTION (function);
    2147                 :      91403 :   ob = create_output_block (LTO_section_function_body);
    2148                 :            : 
    2149                 :      91403 :   clear_line_info (ob);
    2150                 :      91403 :   ob->symbol = node;
    2151                 :            : 
    2152                 :      91403 :   gcc_assert (current_function_decl == NULL_TREE && cfun == NULL);
    2153                 :            : 
    2154                 :            :   /* Make string 0 be a NULL string.  */
    2155                 :      91403 :   streamer_write_char_stream (ob->string_stream, 0);
    2156                 :            : 
    2157                 :      91403 :   streamer_write_record_start (ob, LTO_function);
    2158                 :            : 
    2159                 :            :   /* Output decls for parameters and args.  */
    2160                 :      91403 :   stream_write_tree (ob, DECL_RESULT (function), true);
    2161                 :      91403 :   streamer_write_chain (ob, DECL_ARGUMENTS (function), true);
    2162                 :            : 
    2163                 :            :   /* Output debug args if available. */
    2164                 :      91403 :   vec<tree, va_gc> **debugargs = decl_debug_args_lookup (function);
    2165                 :      91403 :   if (! debugargs)
    2166                 :      91383 :     streamer_write_uhwi (ob, 0);
    2167                 :            :   else
    2168                 :            :     {
    2169                 :         20 :       streamer_write_uhwi (ob, (*debugargs)->length ());
    2170                 :         76 :       for (unsigned i = 0; i < (*debugargs)->length (); ++i)
    2171                 :         56 :         stream_write_tree (ob, (**debugargs)[i], true);
    2172                 :            :     }
    2173                 :            : 
    2174                 :            :   /* Output DECL_INITIAL for the function, which contains the tree of
    2175                 :            :      lexical scopes.  */
    2176                 :      91403 :   stream_write_tree (ob, DECL_INITIAL (function), true);
    2177                 :            :   /* As we do not recurse into BLOCK_SUBBLOCKS but only BLOCK_SUPERCONTEXT
    2178                 :            :      collect block tree leafs and stream those.  */
    2179                 :      91403 :   auto_vec<tree> block_tree_leafs;
    2180                 :      91403 :   if (DECL_INITIAL (function))
    2181                 :      91232 :     collect_block_tree_leafs (DECL_INITIAL (function), block_tree_leafs);
    2182                 :      91403 :   streamer_write_uhwi (ob, block_tree_leafs.length ());
    2183                 :     153897 :   for (unsigned i = 0; i < block_tree_leafs.length (); ++i)
    2184                 :      26260 :     stream_write_tree (ob, block_tree_leafs[i], true);
    2185                 :            : 
    2186                 :            :   /* We also stream abstract functions where we stream only stuff needed for
    2187                 :            :      debug info.  */
    2188                 :      91403 :   if (gimple_has_body_p (function))
    2189                 :            :     {
    2190                 :      91232 :       streamer_write_uhwi (ob, 1);
    2191                 :      91232 :       output_struct_function_base (ob, fn);
    2192                 :            : 
    2193                 :            :       /* Output all the SSA names used in the function.  */
    2194                 :      91232 :       output_ssa_names (ob, fn);
    2195                 :            : 
    2196                 :            :       /* Output any exception handling regions.  */
    2197                 :      91232 :       output_eh_regions (ob, fn);
    2198                 :            : 
    2199                 :            :       /* Output the code for the function.  */
    2200                 :     717090 :       FOR_ALL_BB_FN (bb, fn)
    2201                 :     625858 :         output_bb (ob, bb, fn);
    2202                 :            : 
    2203                 :            :       /* The terminator for this function.  */
    2204                 :      91232 :       streamer_write_record_start (ob, LTO_null);
    2205                 :            : 
    2206                 :      91232 :       output_cfg (ob, fn);
    2207                 :            :    }
    2208                 :            :   else
    2209                 :        171 :     streamer_write_uhwi (ob, 0);
    2210                 :            : 
    2211                 :            :   /* Create a section to hold the pickled output of this function.   */
    2212                 :      91403 :   produce_asm (ob, function);
    2213                 :            : 
    2214                 :      91403 :   destroy_output_block (ob);
    2215                 :      91403 :   if (streamer_dump_file)
    2216                 :          8 :     fprintf (streamer_dump_file, "Finished streaming %s\n",
    2217                 :            :              node->dump_name ());
    2218                 :      91403 : }
    2219                 :            : 
    2220                 :            : /* Output the body of function NODE->DECL.  */
    2221                 :            : 
    2222                 :            : static void
    2223                 :      12235 : output_constructor (struct varpool_node *node)
    2224                 :            : {
    2225                 :      12235 :   tree var = node->decl;
    2226                 :      12235 :   struct output_block *ob;
    2227                 :            : 
    2228                 :      12235 :   if (streamer_dump_file)
    2229                 :          4 :     fprintf (streamer_dump_file, "\nStreaming constructor of %s\n",
    2230                 :            :              node->dump_name ());
    2231                 :            : 
    2232                 :      12235 :   timevar_push (TV_IPA_LTO_CTORS_OUT);
    2233                 :      12235 :   ob = create_output_block (LTO_section_function_body);
    2234                 :            : 
    2235                 :      12235 :   clear_line_info (ob);
    2236                 :      12235 :   ob->symbol = node;
    2237                 :            : 
    2238                 :            :   /* Make string 0 be a NULL string.  */
    2239                 :      12235 :   streamer_write_char_stream (ob->string_stream, 0);
    2240                 :            : 
    2241                 :            :   /* Output DECL_INITIAL for the function, which contains the tree of
    2242                 :            :      lexical scopes.  */
    2243                 :      12235 :   stream_write_tree (ob, DECL_INITIAL (var), true);
    2244                 :            : 
    2245                 :            :   /* Create a section to hold the pickled output of this function.   */
    2246                 :      12235 :   produce_asm (ob, var);
    2247                 :            : 
    2248                 :      12235 :   destroy_output_block (ob);
    2249                 :      12235 :   if (streamer_dump_file)
    2250                 :          4 :     fprintf (streamer_dump_file, "Finished streaming %s\n",
    2251                 :            :              node->dump_name ());
    2252                 :      12235 :   timevar_pop (TV_IPA_LTO_CTORS_OUT);
    2253                 :      12235 : }
    2254                 :            : 
    2255                 :            : 
    2256                 :            : /* Emit toplevel asms.  */
    2257                 :            : 
    2258                 :            : void
    2259                 :      21504 : lto_output_toplevel_asms (void)
    2260                 :            : {
    2261                 :      21504 :   struct output_block *ob;
    2262                 :      21504 :   struct asm_node *can;
    2263                 :      21504 :   char *section_name;
    2264                 :      21504 :   struct lto_simple_header_with_strings header;
    2265                 :            : 
    2266                 :      21504 :   if (!symtab->first_asm_symbol ())
    2267                 :      21482 :     return;
    2268                 :            : 
    2269                 :         22 :   ob = create_output_block (LTO_section_asm);
    2270                 :            : 
    2271                 :            :   /* Make string 0 be a NULL string.  */
    2272                 :         22 :   streamer_write_char_stream (ob->string_stream, 0);
    2273                 :            : 
    2274                 :         44 :   for (can = symtab->first_asm_symbol (); can; can = can->next)
    2275                 :            :     {
    2276                 :         22 :       streamer_write_string_cst (ob, ob->main_stream, can->asm_str);
    2277                 :         22 :       streamer_write_hwi (ob, can->order);
    2278                 :            :     }
    2279                 :            : 
    2280                 :         22 :   streamer_write_string_cst (ob, ob->main_stream, NULL_TREE);
    2281                 :            : 
    2282                 :         22 :   section_name = lto_get_section_name (LTO_section_asm, NULL, 0, NULL);
    2283                 :         22 :   lto_begin_section (section_name, !flag_wpa);
    2284                 :         22 :   free (section_name);
    2285                 :            : 
    2286                 :            :   /* The entire header stream is computed here.  */
    2287                 :         22 :   memset (&header, 0, sizeof (header));
    2288                 :            : 
    2289                 :         22 :   header.main_size = ob->main_stream->total_size;
    2290                 :         22 :   header.string_size = ob->string_stream->total_size;
    2291                 :         22 :   lto_write_data (&header, sizeof header);
    2292                 :            : 
    2293                 :            :   /* Put all of the gimple and the string table out the asm file as a
    2294                 :            :      block of text.  */
    2295                 :         22 :   lto_write_stream (ob->main_stream);
    2296                 :         22 :   lto_write_stream (ob->string_stream);
    2297                 :            : 
    2298                 :         22 :   lto_end_section ();
    2299                 :            : 
    2300                 :         22 :   destroy_output_block (ob);
    2301                 :            : }
    2302                 :            : 
    2303                 :            : 
    2304                 :            : /* Copy the function body or variable constructor of NODE without deserializing. */
    2305                 :            : 
    2306                 :            : static void
    2307                 :      27793 : copy_function_or_variable (struct symtab_node *node)
    2308                 :            : {
    2309                 :      27793 :   tree function = node->decl;
    2310                 :      27793 :   struct lto_file_decl_data *file_data = node->lto_file_data;
    2311                 :      27793 :   const char *data;
    2312                 :      27793 :   size_t len;
    2313                 :      27793 :   const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function));
    2314                 :      27793 :   char *section_name =
    2315                 :      27793 :     lto_get_section_name (LTO_section_function_body, name, node->order, NULL);
    2316                 :      27793 :   size_t i, j;
    2317                 :      27793 :   struct lto_in_decl_state *in_state;
    2318                 :      27793 :   struct lto_out_decl_state *out_state = lto_get_out_decl_state ();
    2319                 :            : 
    2320                 :      27793 :   if (streamer_dump_file)
    2321                 :          0 :     fprintf (streamer_dump_file, "Copying section for %s\n", name);
    2322                 :      27793 :   lto_begin_section (section_name, false);
    2323                 :      27793 :   free (section_name);
    2324                 :            : 
    2325                 :            :   /* We may have renamed the declaration, e.g., a static function.  */
    2326                 :      27793 :   name = lto_get_decl_name_mapping (file_data, name);
    2327                 :            : 
    2328                 :      55586 :   data = lto_get_raw_section_data (file_data, LTO_section_function_body,
    2329                 :      27793 :                                    name, node->order - file_data->order_base,
    2330                 :            :                                    &len);
    2331                 :      27793 :   gcc_assert (data);
    2332                 :            : 
    2333                 :            :   /* Do a bit copy of the function body.  */
    2334                 :      27793 :   lto_write_raw_data (data, len);
    2335                 :            : 
    2336                 :            :   /* Copy decls. */
    2337                 :      27793 :   in_state =
    2338                 :      27793 :     lto_get_function_in_decl_state (node->lto_file_data, function);
    2339                 :      27793 :   out_state->compressed = in_state->compressed;
    2340                 :      27793 :   gcc_assert (in_state);
    2341                 :            : 
    2342                 :     222344 :   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
    2343                 :            :     {
    2344                 :     194551 :       size_t n = vec_safe_length (in_state->streams[i]);
    2345                 :     194551 :       vec<tree, va_gc> *trees = in_state->streams[i];
    2346                 :     194551 :       struct lto_tree_ref_encoder *encoder = &(out_state->streams[i]);
    2347                 :            : 
    2348                 :            :       /* The out state must have the same indices and the in state.
    2349                 :            :          So just copy the vector.  All the encoders in the in state
    2350                 :            :          must be empty where we reach here. */
    2351                 :     194551 :       gcc_assert (lto_tree_ref_encoder_size (encoder) == 0);
    2352                 :     194551 :       encoder->trees.reserve_exact (n);
    2353                 :     614575 :       for (j = 0; j < n; j++)
    2354                 :     420024 :         encoder->trees.safe_push ((*trees)[j]);
    2355                 :            :     }
    2356                 :            : 
    2357                 :      27793 :   lto_free_raw_section_data (file_data, LTO_section_function_body, name,
    2358                 :            :                              data, len);
    2359                 :      27793 :   lto_end_section ();
    2360                 :      27793 : }
    2361                 :            : 
    2362                 :            : /* Wrap symbol references in *TP inside a type-preserving MEM_REF.  */
    2363                 :            : 
    2364                 :            : static tree
    2365                 :     803357 : wrap_refs (tree *tp, int *ws, void *)
    2366                 :            : {
    2367                 :     803357 :   tree t = *tp;
    2368                 :     803357 :   if (handled_component_p (t)
    2369                 :        152 :       && TREE_CODE (TREE_OPERAND (t, 0)) == VAR_DECL
    2370                 :        112 :       && TREE_PUBLIC (TREE_OPERAND (t, 0)))
    2371                 :            :     {
    2372                 :         79 :       tree decl = TREE_OPERAND (t, 0);
    2373                 :         79 :       tree ptrtype = build_pointer_type (TREE_TYPE (decl));
    2374                 :         79 :       TREE_OPERAND (t, 0) = build2 (MEM_REF, TREE_TYPE (decl),
    2375                 :            :                                     build1 (ADDR_EXPR, ptrtype, decl),
    2376                 :         79 :                                     build_int_cst (ptrtype, 0));
    2377                 :         79 :       TREE_THIS_VOLATILE (TREE_OPERAND (t, 0)) = TREE_THIS_VOLATILE (decl);
    2378                 :         79 :       *ws = 0;
    2379                 :            :     }
    2380                 :     803278 :   else if (TREE_CODE (t) == CONSTRUCTOR)
    2381                 :            :     ;
    2382                 :     582553 :   else if (!EXPR_P (t))
    2383                 :     337365 :     *ws = 0;
    2384                 :     803357 :   return NULL_TREE;
    2385                 :            : }
    2386                 :            : 
    2387                 :            : /* Remove functions that are no longer used from offload_funcs, and mark the
    2388                 :            :    remaining ones with DECL_PRESERVE_P.  */
    2389                 :            : 
    2390                 :            : static void
    2391                 :      21838 : prune_offload_funcs (void)
    2392                 :            : {
    2393                 :      21838 :   if (!offload_funcs)
    2394                 :      21838 :     return;
    2395                 :            : 
    2396                 :          0 :   unsigned ix, ix2;
    2397                 :          0 :   tree *elem_ptr;
    2398                 :          0 :   VEC_ORDERED_REMOVE_IF (*offload_funcs, ix, ix2, elem_ptr,
    2399                 :            :                          cgraph_node::get (*elem_ptr) == NULL);
    2400                 :            : 
    2401                 :            :   tree fn_decl;
    2402                 :          0 :   FOR_EACH_VEC_ELT (*offload_funcs, ix, fn_decl)
    2403                 :          0 :     DECL_PRESERVE_P (fn_decl) = 1;
    2404                 :            : }
    2405                 :            : 
    2406                 :            : /* Produce LTO section that contains global information
    2407                 :            :    about LTO bytecode.  */
    2408                 :            : 
    2409                 :            : static void
    2410                 :      21838 : produce_lto_section ()
    2411                 :            : {
    2412                 :            :   /* Stream LTO meta section.  */
    2413                 :      21838 :   output_block *ob = create_output_block (LTO_section_lto);
    2414                 :            : 
    2415                 :      21838 :   char * section_name = lto_get_section_name (LTO_section_lto, NULL, 0, NULL);
    2416                 :      21838 :   lto_begin_section (section_name, false);
    2417                 :      21838 :   free (section_name);
    2418                 :            : 
    2419                 :            : #ifdef HAVE_ZSTD_H
    2420                 :      21838 :   lto_compression compression = ZSTD;
    2421                 :            : #else
    2422                 :            :   lto_compression compression = ZLIB;
    2423                 :            : #endif
    2424                 :            : 
    2425                 :      21838 :   bool slim_object = flag_generate_lto && !flag_fat_lto_objects;
    2426                 :      21838 :   lto_section s
    2427                 :      21838 :     = { LTO_major_version, LTO_minor_version, slim_object, 0 };
    2428                 :      21838 :   s.set_compression (compression);
    2429                 :      21838 :   lto_write_data (&s, sizeof s);
    2430                 :      21838 :   lto_end_section ();
    2431                 :      21838 :   destroy_output_block (ob);
    2432                 :      21838 : }
    2433                 :            : 
    2434                 :            : /* Compare symbols to get them sorted by filename (to optimize streaming)  */
    2435                 :            : 
    2436                 :            : static int
    2437                 :    3284580 : cmp_symbol_files (const void *pn1, const void *pn2)
    2438                 :            : {
    2439                 :    3284580 :   const symtab_node *n1 = *(const symtab_node * const *)pn1;
    2440                 :    3284580 :   const symtab_node *n2 = *(const symtab_node * const *)pn2;
    2441                 :            : 
    2442                 :    3284580 :   int file_order1 = n1->lto_file_data ? n1->lto_file_data->order : -1;
    2443                 :    3284580 :   int file_order2 = n2->lto_file_data ? n2->lto_file_data->order : -1;
    2444                 :            : 
    2445                 :            :   /* Order files same way as they appeared in the command line to reduce
    2446                 :            :      seeking while copying sections.  */
    2447                 :    3284580 :   if (file_order1 != file_order2)
    2448                 :      42488 :     return file_order1 - file_order2;
    2449                 :            : 
    2450                 :            :   /* Order within static library.  */
    2451                 :    3242090 :   if (n1->lto_file_data && n1->lto_file_data->id != n2->lto_file_data->id)
    2452                 :            :     {
    2453                 :       8328 :       if (n1->lto_file_data->id > n2->lto_file_data->id)
    2454                 :            :         return 1;
    2455                 :       4486 :       if (n1->lto_file_data->id < n2->lto_file_data->id)
    2456                 :            :         return -1;
    2457                 :            :     }
    2458                 :            : 
    2459                 :            :   /* And finaly order by the definition order.  */
    2460                 :    3233760 :   return n1->order - n2->order;
    2461                 :            : }
    2462                 :            : 
    2463                 :            : /* Main entry point from the pass manager.  */
    2464                 :            : 
    2465                 :            : void
    2466                 :      21838 : lto_output (void)
    2467                 :            : {
    2468                 :      21838 :   struct lto_out_decl_state *decl_state;
    2469                 :      21838 :   bitmap output = NULL;
    2470                 :      21838 :   bitmap_obstack output_obstack;
    2471                 :      21838 :   unsigned int i, n_nodes;
    2472                 :      21838 :   lto_symtab_encoder_t encoder = lto_get_out_decl_state ()->symtab_node_encoder;
    2473                 :      21838 :   auto_vec<symtab_node *> symbols_to_copy;
    2474                 :            : 
    2475                 :      21838 :   prune_offload_funcs ();
    2476                 :            : 
    2477                 :      21838 :   if (flag_checking)
    2478                 :            :     {
    2479                 :      21836 :       bitmap_obstack_initialize (&output_obstack);
    2480                 :      21836 :       output = BITMAP_ALLOC (&output_obstack);
    2481                 :            :     }
    2482                 :            : 
    2483                 :            :   /* Initialize the streamer.  */
    2484                 :      21838 :   lto_streamer_init ();
    2485                 :            : 
    2486                 :      21838 :   produce_lto_section ();
    2487                 :            : 
    2488                 :      21838 :   n_nodes = lto_symtab_encoder_size (encoder);
    2489                 :            :   /* Prepare vector of functions to output and then sort it to optimize
    2490                 :            :      section copying.  */
    2491                 :     658707 :   for (i = 0; i < n_nodes; i++)
    2492                 :            :     {
    2493                 :     636869 :       symtab_node *snode = lto_symtab_encoder_deref (encoder, i);
    2494                 :     636869 :       if (snode->alias)
    2495                 :      12639 :         continue;
    2496                 :     624230 :       if (cgraph_node *node = dyn_cast <cgraph_node *> (snode))
    2497                 :            :         {
    2498                 :     351531 :           if (lto_symtab_encoder_encode_body_p (encoder, node))
    2499                 :     113861 :             symbols_to_copy.safe_push (node);
    2500                 :            :         }
    2501                 :     909568 :       else if (varpool_node *node = dyn_cast <varpool_node *> (snode))
    2502                 :            :         {
    2503                 :            :           /* Wrap symbol references inside the ctor in a type
    2504                 :            :              preserving MEM_REF.  */
    2505                 :     272699 :           tree ctor = DECL_INITIAL (node->decl);
    2506                 :     272699 :           if (ctor && !in_lto_p)
    2507                 :      19261 :             walk_tree (&ctor, wrap_refs, NULL, NULL);
    2508                 :     272699 :           if (get_symbol_initial_value (encoder, node->decl) == error_mark_node
    2509                 :     272699 :               && lto_symtab_encoder_encode_initializer_p (encoder, node))
    2510                 :      17570 :             symbols_to_copy.safe_push (node);
    2511                 :            :         }
    2512                 :            :     }
    2513                 :      21838 :   symbols_to_copy.qsort (cmp_symbol_files);
    2514                 :     306097 :   for (i = 0; i < symbols_to_copy.length (); i++)
    2515                 :            :     {
    2516                 :     131431 :       symtab_node *snode = symbols_to_copy[i];
    2517                 :     131431 :       cgraph_node *cnode;
    2518                 :     131431 :       varpool_node *vnode;
    2519                 :            : 
    2520                 :     131431 :       if (flag_checking)
    2521                 :     131429 :         gcc_assert (bitmap_set_bit (output, DECL_UID (snode->decl)));
    2522                 :            : 
    2523                 :     131431 :       decl_state = lto_new_out_decl_state ();
    2524                 :     131431 :       lto_push_out_decl_state (decl_state);
    2525                 :            : 
    2526                 :     131431 :       if ((cnode = dyn_cast <cgraph_node *> (snode))
    2527                 :     113861 :           && (gimple_has_body_p (cnode->decl)
    2528                 :      22629 :               || (!flag_wpa
    2529                 :        304 :                   && flag_incremental_link != INCREMENTAL_LINK_LTO)
    2530                 :            :               /* Thunks have no body but they may be synthetized
    2531                 :            :                  at WPA time.  */
    2532                 :      22459 :               || DECL_ARGUMENTS (cnode->decl)))
    2533                 :      91403 :         output_function (cnode);
    2534                 :      40028 :       else if ((vnode = dyn_cast <varpool_node *> (snode))
    2535                 :      17570 :                && (DECL_INITIAL (vnode->decl) != error_mark_node
    2536                 :       5335 :                    || (!flag_wpa
    2537                 :         42 :                        && flag_incremental_link != INCREMENTAL_LINK_LTO)))
    2538                 :      12235 :         output_constructor (vnode);
    2539                 :            :       else
    2540                 :      27793 :         copy_function_or_variable (snode);
    2541                 :     131431 :       gcc_assert (lto_get_out_decl_state () == decl_state);
    2542                 :     131431 :       lto_pop_out_decl_state ();
    2543                 :     131431 :       lto_record_function_out_decl_state (snode->decl, decl_state);
    2544                 :            :     }
    2545                 :            : 
    2546                 :            :   /* Emit the callgraph after emitting function bodies.  This needs to
    2547                 :            :      be done now to make sure that all the statements in every function
    2548                 :            :      have been renumbered so that edges can be associated with call
    2549                 :            :      statements using the statement UIDs.  */
    2550                 :      21838 :   output_symtab ();
    2551                 :            : 
    2552                 :      21838 :   output_offload_tables ();
    2553                 :            : 
    2554                 :      21838 :   if (flag_checking)
    2555                 :            :     {
    2556                 :      21836 :       BITMAP_FREE (output);
    2557                 :      21836 :       bitmap_obstack_release (&output_obstack);
    2558                 :            :     }
    2559                 :      21838 : }
    2560                 :            : 
    2561                 :            : /* Write each node in encoded by ENCODER to OB, as well as those reachable
    2562                 :            :    from it and required for correct representation of its semantics.
    2563                 :            :    Each node in ENCODER must be a global declaration or a type.  A node
    2564                 :            :    is written only once, even if it appears multiple times in the
    2565                 :            :    vector.  Certain transitively-reachable nodes, such as those
    2566                 :            :    representing expressions, may be duplicated, but such nodes
    2567                 :            :    must not appear in ENCODER itself.  */
    2568                 :            : 
    2569                 :            : static void
    2570                 :    1072880 : write_global_stream (struct output_block *ob,
    2571                 :            :                      struct lto_tree_ref_encoder *encoder)
    2572                 :            : {
    2573                 :    1072880 :   tree t;
    2574                 :    1072880 :   size_t index;
    2575                 :    1072880 :   const size_t size = lto_tree_ref_encoder_size (encoder);
    2576                 :            : 
    2577                 :    3654310 :   for (index = 0; index < size; index++)
    2578                 :            :     {
    2579                 :    2581430 :       t = lto_tree_ref_encoder_get_tree (encoder, index);
    2580                 :    2581430 :       if (streamer_dump_file)
    2581                 :            :         {
    2582                 :        176 :           fprintf (streamer_dump_file, " %i:", (int)index);
    2583                 :        176 :           print_node_brief (streamer_dump_file, "", t, 4);
    2584                 :        176 :           fprintf (streamer_dump_file, "\n");
    2585                 :            :         }
    2586                 :    2581430 :       if (!streamer_tree_cache_lookup (ob->writer_cache, t, NULL))
    2587                 :     806662 :         stream_write_tree (ob, t, false);
    2588                 :            :     }
    2589                 :    1072880 : }
    2590                 :            : 
    2591                 :            : 
    2592                 :            : /* Write a sequence of indices into the globals vector corresponding
    2593                 :            :    to the trees in ENCODER.  These are used by the reader to map the
    2594                 :            :    indices used to refer to global entities within function bodies to
    2595                 :            :    their referents.  */
    2596                 :            : 
    2597                 :            : static void
    2598                 :    1072880 : write_global_references (struct output_block *ob,
    2599                 :            :                          struct lto_tree_ref_encoder *encoder)
    2600                 :            : {
    2601                 :    1072880 :   tree t;
    2602                 :    1072880 :   uint32_t index;
    2603                 :    1072880 :   const uint32_t size = lto_tree_ref_encoder_size (encoder);
    2604                 :            : 
    2605                 :            :   /* Write size and slot indexes as 32-bit unsigned numbers. */
    2606                 :    1072880 :   uint32_t *data = XNEWVEC (uint32_t, size + 1);
    2607                 :    1072880 :   data[0] = size;
    2608                 :            : 
    2609                 :    3654310 :   for (index = 0; index < size; index++)
    2610                 :            :     {
    2611                 :    2581430 :       unsigned slot_num;
    2612                 :            : 
    2613                 :    2581430 :       t = lto_tree_ref_encoder_get_tree (encoder, index);
    2614                 :    2581430 :       streamer_tree_cache_lookup (ob->writer_cache, t, &slot_num);
    2615                 :    2581430 :       gcc_assert (slot_num != (unsigned)-1);
    2616                 :    2581430 :       data[index + 1] = slot_num;
    2617                 :            :     }
    2618                 :            : 
    2619                 :    1072880 :   lto_write_data (data, sizeof (int32_t) * (size + 1));
    2620                 :    1072880 :   free (data);
    2621                 :    1072880 : }
    2622                 :            : 
    2623                 :            : 
    2624                 :            : /* Write all the streams in an lto_out_decl_state STATE using
    2625                 :            :    output block OB and output stream OUT_STREAM.  */
    2626                 :            : 
    2627                 :            : void
    2628                 :     153269 : lto_output_decl_state_streams (struct output_block *ob,
    2629                 :            :                                struct lto_out_decl_state *state)
    2630                 :            : {
    2631                 :     153269 :   int i;
    2632                 :            : 
    2633                 :    1226150 :   for (i = 0;  i < LTO_N_DECL_STREAMS; i++)
    2634                 :    1072880 :     write_global_stream (ob, &state->streams[i]);
    2635                 :     153269 : }
    2636                 :            : 
    2637                 :            : 
    2638                 :            : /* Write all the references in an lto_out_decl_state STATE using
    2639                 :            :    output block OB and output stream OUT_STREAM.  */
    2640                 :            : 
    2641                 :            : void
    2642                 :     153269 : lto_output_decl_state_refs (struct output_block *ob,
    2643                 :            :                             struct lto_out_decl_state *state)
    2644                 :            : {
    2645                 :     153269 :   unsigned i;
    2646                 :     153269 :   unsigned ref;
    2647                 :     153269 :   tree decl;
    2648                 :            : 
    2649                 :            :   /* Write reference to FUNCTION_DECL.  If there is not function,
    2650                 :            :      write reference to void_type_node. */
    2651                 :     153269 :   decl = (state->fn_decl) ? state->fn_decl : void_type_node;
    2652                 :     153269 :   streamer_tree_cache_lookup (ob->writer_cache, decl, &ref);
    2653                 :     153269 :   gcc_assert (ref != (unsigned)-1);
    2654                 :     153269 :   ref = ref * 2 + (state->compressed ? 1 : 0);
    2655                 :     153269 :   lto_write_data (&ref, sizeof (uint32_t));
    2656                 :            : 
    2657                 :    1226150 :   for (i = 0;  i < LTO_N_DECL_STREAMS; i++)
    2658                 :    1072880 :     write_global_references (ob, &state->streams[i]);
    2659                 :     153269 : }
    2660                 :            : 
    2661                 :            : 
    2662                 :            : /* Return the written size of STATE. */
    2663                 :            : 
    2664                 :            : static size_t
    2665                 :     153269 : lto_out_decl_state_written_size (struct lto_out_decl_state *state)
    2666                 :            : {
    2667                 :      21838 :   int i;
    2668                 :      21838 :   size_t size;
    2669                 :            : 
    2670                 :      21838 :   size = sizeof (int32_t);      /* fn_ref. */
    2671                 :    1226150 :   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
    2672                 :            :     {
    2673                 :    1072880 :       size += sizeof (int32_t); /* vector size. */
    2674                 :    1072880 :       size += (lto_tree_ref_encoder_size (&state->streams[i])
    2675                 :    1072880 :                * sizeof (int32_t));
    2676                 :            :     }
    2677                 :     153269 :   return size;
    2678                 :            : }
    2679                 :            : 
    2680                 :            : 
    2681                 :            : /* Write symbol T into STREAM in CACHE. SEEN specifies symbols we wrote
    2682                 :            :    so far.  */
    2683                 :            : 
    2684                 :            : static void
    2685                 :     516397 : write_symbol (struct streamer_tree_cache_d *cache,
    2686                 :            :               tree t, hash_set<const char *> *seen, bool alias)
    2687                 :            : {
    2688                 :     516397 :   const char *name;
    2689                 :     516397 :   enum gcc_plugin_symbol_kind kind;
    2690                 :     516397 :   enum gcc_plugin_symbol_visibility visibility = GCCPV_DEFAULT;
    2691                 :     516397 :   unsigned slot_num;
    2692                 :     516397 :   uint64_t size;
    2693                 :     516397 :   const char *comdat;
    2694                 :     516397 :   unsigned char c;
    2695                 :            : 
    2696                 :     516397 :   gcc_assert (VAR_OR_FUNCTION_DECL_P (t));
    2697                 :            : 
    2698                 :     516397 :   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t));
    2699                 :            : 
    2700                 :            :   /* This behaves like assemble_name_raw in varasm.c, performing the
    2701                 :            :      same name manipulations that ASM_OUTPUT_LABELREF does. */
    2702                 :     516397 :   name = IDENTIFIER_POINTER ((*targetm.asm_out.mangle_assembler_name) (name));
    2703                 :            : 
    2704                 :     516397 :   if (seen->add (name))
    2705                 :        770 :     return;
    2706                 :            : 
    2707                 :     515627 :   streamer_tree_cache_lookup (cache, t, &slot_num);
    2708                 :     515627 :   gcc_assert (slot_num != (unsigned)-1);
    2709                 :            : 
    2710                 :     515627 :   if (DECL_EXTERNAL (t))
    2711                 :            :     {
    2712                 :     212178 :       if (DECL_WEAK (t))
    2713                 :            :         kind = GCCPK_WEAKUNDEF;
    2714                 :            :       else
    2715                 :     212171 :         kind = GCCPK_UNDEF;
    2716                 :            :     }
    2717                 :            :   else
    2718                 :            :     {
    2719                 :     303449 :       if (DECL_WEAK (t))
    2720                 :            :         kind = GCCPK_WEAKDEF;
    2721                 :     290747 :       else if (DECL_COMMON (t))
    2722                 :            :         kind = GCCPK_COMMON;
    2723                 :            :       else
    2724                 :     290699 :         kind = GCCPK_DEF;
    2725                 :            : 
    2726                 :            :       /* When something is defined, it should have node attached.  */
    2727                 :     303449 :       gcc_assert (alias || !VAR_P (t) || varpool_node::get (t)->definition);
    2728                 :     303449 :       gcc_assert (alias || TREE_CODE (t) != FUNCTION_DECL
    2729                 :            :                   || (cgraph_node::get (t)
    2730                 :            :                       && cgraph_node::get (t)->definition));
    2731                 :            :     }
    2732                 :            : 
    2733                 :            :   /* Imitate what default_elf_asm_output_external do.
    2734                 :            :      When symbol is external, we need to output it with DEFAULT visibility
    2735                 :            :      when compiling with -fvisibility=default, while with HIDDEN visibility
    2736                 :            :      when symbol has attribute (visibility("hidden")) specified.
    2737                 :            :      targetm.binds_local_p check DECL_VISIBILITY_SPECIFIED and gets this
    2738                 :            :      right. */
    2739                 :            : 
    2740                 :     515627 :   if (DECL_EXTERNAL (t)
    2741                 :     515627 :       && !targetm.binds_local_p (t))
    2742                 :            :     visibility = GCCPV_DEFAULT;
    2743                 :            :   else
    2744                 :     303512 :     switch (DECL_VISIBILITY (t))
    2745                 :            :       {
    2746                 :            :       case VISIBILITY_DEFAULT:
    2747                 :            :         visibility = GCCPV_DEFAULT;
    2748                 :            :         break;
    2749                 :            :       case VISIBILITY_PROTECTED:
    2750                 :            :         visibility = GCCPV_PROTECTED;
    2751                 :            :         break;
    2752                 :            :       case VISIBILITY_HIDDEN:
    2753                 :            :         visibility = GCCPV_HIDDEN;
    2754                 :            :         break;
    2755                 :            :       case VISIBILITY_INTERNAL:
    2756                 :            :         visibility = GCCPV_INTERNAL;
    2757                 :            :         break;
    2758                 :            :       }
    2759                 :            : 
    2760                 :     515627 :   if (kind == GCCPK_COMMON
    2761                 :         48 :       && DECL_SIZE_UNIT (t)
    2762                 :     515675 :       && TREE_CODE (DECL_SIZE_UNIT (t)) == INTEGER_CST)
    2763                 :         48 :     size = TREE_INT_CST_LOW (DECL_SIZE_UNIT (t));
    2764                 :            :   else
    2765                 :     515579 :     size = 0;
    2766                 :            : 
    2767                 :     515627 :   if (DECL_ONE_ONLY (t))
    2768                 :      12296 :     comdat = IDENTIFIER_POINTER (decl_comdat_group_id (t));
    2769                 :            :   else
    2770                 :            :     comdat = "";
    2771                 :            : 
    2772                 :     515627 :   lto_write_data (name, strlen (name) + 1);
    2773                 :     515627 :   lto_write_data (comdat, strlen (comdat) + 1);
    2774                 :     515627 :   c = (unsigned char) kind;
    2775                 :     515627 :   lto_write_data (&c, 1);
    2776                 :     515627 :   c = (unsigned char) visibility;
    2777                 :     515627 :   lto_write_data (&c, 1);
    2778                 :     515627 :   lto_write_data (&size, 8);
    2779                 :     515627 :   lto_write_data (&slot_num, 4);
    2780                 :            : }
    2781                 :            : 
    2782                 :            : /* Write extension information for symbols (symbol type, section flags).  */
    2783                 :            : 
    2784                 :            : static void
    2785                 :     516397 : write_symbol_extension_info (tree t)
    2786                 :            : {
    2787                 :     516397 :   unsigned char c;
    2788                 :     516397 :   c = ((unsigned char) TREE_CODE (t) == VAR_DECL
    2789                 :            :        ? GCCST_VARIABLE : GCCST_FUNCTION);
    2790                 :     516397 :   lto_write_data (&c, 1);
    2791                 :     516397 :   unsigned char section_kind = 0;
    2792                 :     516397 :   if (TREE_CODE (t) == VAR_DECL)
    2793                 :            :     {
    2794                 :     224499 :       section *s = get_variable_section (t, false);
    2795                 :     224499 :       if (s->common.flags & SECTION_BSS)
    2796                 :     216111 :         section_kind |= GCCSSK_BSS;
    2797                 :            :     }
    2798                 :     516397 :   lto_write_data (&section_kind, 1);
    2799                 :     516397 : }
    2800                 :            : 
    2801                 :            : /* Write an IL symbol table to OB.
    2802                 :            :    SET and VSET are cgraph/varpool node sets we are outputting.  */
    2803                 :            : 
    2804                 :            : static unsigned int
    2805                 :      16482 : produce_symtab (struct output_block *ob)
    2806                 :            : {
    2807                 :      16482 :   unsigned int streamed_symbols = 0;
    2808                 :      16482 :   struct streamer_tree_cache_d *cache = ob->writer_cache;
    2809                 :      16482 :   char *section_name = lto_get_section_name (LTO_section_symtab, NULL, 0, NULL);
    2810                 :      16482 :   lto_symtab_encoder_t encoder = ob->decl_state->symtab_node_encoder;
    2811                 :      16482 :   lto_symtab_encoder_iterator lsei;
    2812                 :            : 
    2813                 :      16482 :   lto_begin_section (section_name, false);
    2814                 :      16482 :   free (section_name);
    2815                 :            : 
    2816                 :      16482 :   hash_set<const char *> seen;
    2817                 :            : 
    2818                 :            :   /* Write the symbol table.
    2819                 :            :      First write everything defined and then all declarations.
    2820                 :            :      This is necessary to handle cases where we have duplicated symbols.  */
    2821                 :      16482 :   for (lsei = lsei_start (encoder);
    2822                 :    1163650 :        !lsei_end_p (lsei); lsei_next (&lsei))
    2823                 :            :     {
    2824                 :     565443 :       symtab_node *node = lsei_node (lsei);
    2825                 :            : 
    2826                 :     565443 :       if (DECL_EXTERNAL (node->decl) || !node->output_to_lto_symbol_table_p ())
    2827                 :     261994 :         continue;
    2828                 :     303449 :       write_symbol (cache, node->decl, &seen, false);
    2829                 :     303449 :       ++streamed_symbols;
    2830                 :            :     }
    2831                 :     581925 :   for (lsei = lsei_start (encoder);
    2832                 :    1163650 :        !lsei_end_p (lsei); lsei_next (&lsei))
    2833                 :            :     {
    2834                 :     565443 :       symtab_node *node = lsei_node (lsei);
    2835                 :            : 
    2836                 :     565443 :       if (!DECL_EXTERNAL (node->decl) || !node->output_to_lto_symbol_table_p ())
    2837                 :     352495 :         continue;
    2838                 :     212948 :       write_symbol (cache, node->decl, &seen, false);
    2839                 :     212948 :       ++streamed_symbols;
    2840                 :            :     }
    2841                 :            : 
    2842                 :      16482 :   lto_end_section ();
    2843                 :            : 
    2844                 :      16482 :   return streamed_symbols;
    2845                 :            : }
    2846                 :            : 
    2847                 :            : /* Symtab extension version.  */
    2848                 :            : #define LTO_SYMTAB_EXTENSION_VERSION 1
    2849                 :            : 
    2850                 :            : /* Write an IL symbol table extension to OB.
    2851                 :            :    SET and VSET are cgraph/varpool node sets we are outputting.  */
    2852                 :            : 
    2853                 :            : static void
    2854                 :      16482 : produce_symtab_extension (struct output_block *ob,
    2855                 :            :                           unsigned int previous_streamed_symbols)
    2856                 :            : {
    2857                 :      16482 :   unsigned int streamed_symbols = 0;
    2858                 :      16482 :   char *section_name = lto_get_section_name (LTO_section_symtab_extension,
    2859                 :            :                                              NULL, 0, NULL);
    2860                 :      16482 :   lto_symtab_encoder_t encoder = ob->decl_state->symtab_node_encoder;
    2861                 :      16482 :   lto_symtab_encoder_iterator lsei;
    2862                 :            : 
    2863                 :      16482 :   lto_begin_section (section_name, false);
    2864                 :      16482 :   free (section_name);
    2865                 :            : 
    2866                 :      16482 :   unsigned char version = LTO_SYMTAB_EXTENSION_VERSION;
    2867                 :      16482 :   lto_write_data (&version, 1);
    2868                 :            : 
    2869                 :            :   /* Write the symbol table.
    2870                 :            :      First write everything defined and then all declarations.
    2871                 :            :      This is necessary to handle cases where we have duplicated symbols.  */
    2872                 :      16482 :   for (lsei = lsei_start (encoder);
    2873                 :    1163650 :        !lsei_end_p (lsei); lsei_next (&lsei))
    2874                 :            :     {
    2875                 :     565443 :       symtab_node *node = lsei_node (lsei);
    2876                 :            : 
    2877                 :     565443 :       if (DECL_EXTERNAL (node->decl) || !node->output_to_lto_symbol_table_p ())
    2878                 :     261994 :         continue;
    2879                 :     303449 :       write_symbol_extension_info (node->decl);
    2880                 :     303449 :       ++streamed_symbols;
    2881                 :            :     }
    2882                 :     581925 :   for (lsei = lsei_start (encoder);
    2883                 :    1163650 :        !lsei_end_p (lsei); lsei_next (&lsei))
    2884                 :            :     {
    2885                 :     565443 :       symtab_node *node = lsei_node (lsei);
    2886                 :            : 
    2887                 :     565443 :       if (!DECL_EXTERNAL (node->decl) || !node->output_to_lto_symbol_table_p ())
    2888                 :     352495 :         continue;
    2889                 :     212948 :       write_symbol_extension_info (node->decl);
    2890                 :     212948 :       ++streamed_symbols;
    2891                 :            :     }
    2892                 :            : 
    2893                 :      16482 :   gcc_assert (previous_streamed_symbols == streamed_symbols);
    2894                 :      16482 :   lto_end_section ();
    2895                 :      16482 : }
    2896                 :            : 
    2897                 :            : 
    2898                 :            : /* Init the streamer_mode_table for output, where we collect info on what
    2899                 :            :    machine_mode values have been streamed.  */
    2900                 :            : void
    2901                 :      21838 : lto_output_init_mode_table (void)
    2902                 :            : {
    2903                 :      21838 :   memset (streamer_mode_table, '\0', MAX_MACHINE_MODE);
    2904                 :      21838 : }
    2905                 :            : 
    2906                 :            : 
    2907                 :            : /* Write the mode table.  */
    2908                 :            : static void
    2909                 :          0 : lto_write_mode_table (void)
    2910                 :            : {
    2911                 :          0 :   struct output_block *ob;
    2912                 :          0 :   ob = create_output_block (LTO_section_mode_table);
    2913                 :          0 :   bitpack_d bp = bitpack_create (ob->main_stream);
    2914                 :            : 
    2915                 :            :   /* Ensure that for GET_MODE_INNER (m) != m we have
    2916                 :            :      also the inner mode marked.  */
    2917                 :          0 :   for (int i = 0; i < (int) MAX_MACHINE_MODE; i++)
    2918                 :          0 :     if (streamer_mode_table[i])
    2919                 :            :       {
    2920                 :          0 :         machine_mode m = (machine_mode) i;
    2921                 :          0 :         machine_mode inner_m = GET_MODE_INNER (m);
    2922                 :          0 :         if (inner_m != m)
    2923                 :          0 :           streamer_mode_table[(int) inner_m] = 1;
    2924                 :            :       }
    2925                 :            :   /* First stream modes that have GET_MODE_INNER (m) == m,
    2926                 :            :      so that we can refer to them afterwards.  */
    2927                 :          0 :   for (int pass = 0; pass < 2; pass++)
    2928                 :          0 :     for (int i = 0; i < (int) MAX_MACHINE_MODE; i++)
    2929                 :          0 :       if (streamer_mode_table[i] && i != (int) VOIDmode && i != (int) BLKmode)
    2930                 :            :         {
    2931                 :          0 :           machine_mode m = (machine_mode) i;
    2932                 :          0 :           if ((GET_MODE_INNER (m) == m) ^ (pass == 0))
    2933                 :          0 :             continue;
    2934                 :          0 :           bp_pack_value (&bp, m, 8);
    2935                 :          0 :           bp_pack_enum (&bp, mode_class, MAX_MODE_CLASS, GET_MODE_CLASS (m));
    2936                 :          0 :           bp_pack_poly_value (&bp, GET_MODE_SIZE (m), 16);
    2937                 :          0 :           bp_pack_poly_value (&bp, GET_MODE_PRECISION (m), 16);
    2938                 :          0 :           bp_pack_value (&bp, GET_MODE_INNER (m), 8);
    2939                 :          0 :           bp_pack_poly_value (&bp, GET_MODE_NUNITS (m), 16);
    2940                 :          0 :           switch (GET_MODE_CLASS (m))
    2941                 :            :             {
    2942                 :          0 :             case MODE_FRACT:
    2943                 :          0 :             case MODE_UFRACT:
    2944                 :          0 :             case MODE_ACCUM:
    2945                 :          0 :             case MODE_UACCUM:
    2946                 :          0 :               bp_pack_value (&bp, GET_MODE_IBIT (m), 8);
    2947                 :          0 :               bp_pack_value (&bp, GET_MODE_FBIT (m), 8);
    2948                 :          0 :               break;
    2949                 :          0 :             case MODE_FLOAT:
    2950                 :          0 :             case MODE_DECIMAL_FLOAT:
    2951                 :          0 :               bp_pack_string (ob, &bp, REAL_MODE_FORMAT (m)->name, true);
    2952                 :          0 :               break;
    2953                 :            :             default:
    2954                 :            :               break;
    2955                 :            :             }
    2956                 :          0 :           bp_pack_string (ob, &bp, GET_MODE_NAME (m), true);
    2957                 :            :         }
    2958                 :          0 :   bp_pack_value (&bp, VOIDmode, 8);
    2959                 :            : 
    2960                 :          0 :   streamer_write_bitpack (&bp);
    2961                 :            : 
    2962                 :          0 :   char *section_name
    2963                 :          0 :     = lto_get_section_name (LTO_section_mode_table, NULL, 0, NULL);
    2964                 :          0 :   lto_begin_section (section_name, !flag_wpa);
    2965                 :          0 :   free (section_name);
    2966                 :            : 
    2967                 :            :   /* The entire header stream is computed here.  */
    2968                 :          0 :   struct lto_simple_header_with_strings header;
    2969                 :          0 :   memset (&header, 0, sizeof (header));
    2970                 :            : 
    2971                 :          0 :   header.main_size = ob->main_stream->total_size;
    2972                 :          0 :   header.string_size = ob->string_stream->total_size;
    2973                 :          0 :   lto_write_data (&header, sizeof header);
    2974                 :            : 
    2975                 :            :   /* Put all of the gimple and the string table out the asm file as a
    2976                 :            :      block of text.  */
    2977                 :          0 :   lto_write_stream (ob->main_stream);
    2978                 :          0 :   lto_write_stream (ob->string_stream);
    2979                 :            : 
    2980                 :          0 :   lto_end_section ();
    2981                 :          0 :   destroy_output_block (ob);
    2982                 :          0 : }
    2983                 :            : 
    2984                 :            : 
    2985                 :            : /* This pass is run after all of the functions are serialized and all
    2986                 :            :    of the IPA passes have written their serialized forms.  This pass
    2987                 :            :    causes the vector of all of the global decls and types used from
    2988                 :            :    this file to be written in to a section that can then be read in to
    2989                 :            :    recover these on other side.  */
    2990                 :            : 
    2991                 :            : void
    2992                 :      21838 : produce_asm_for_decls (void)
    2993                 :            : {
    2994                 :      21838 :   struct lto_out_decl_state *out_state;
    2995                 :      21838 :   struct lto_out_decl_state *fn_out_state;
    2996                 :      21838 :   struct lto_decl_header header;
    2997                 :      21838 :   char *section_name;
    2998                 :      21838 :   struct output_block *ob;
    2999                 :      21838 :   unsigned idx, num_fns;
    3000                 :      21838 :   size_t decl_state_size;
    3001                 :      21838 :   int32_t num_decl_states;
    3002                 :            : 
    3003                 :      21838 :   ob = create_output_block (LTO_section_decls);
    3004                 :            : 
    3005                 :      21838 :   memset (&header, 0, sizeof (struct lto_decl_header));
    3006                 :            : 
    3007                 :      21838 :   section_name = lto_get_section_name (LTO_section_decls, NULL, 0, NULL);
    3008                 :      21838 :   lto_begin_section (section_name, !flag_wpa);
    3009                 :      21838 :   free (section_name);
    3010                 :            : 
    3011                 :            :   /* Make string 0 be a NULL string.  */
    3012                 :      21838 :   streamer_write_char_stream (ob->string_stream, 0);
    3013                 :            : 
    3014                 :      21838 :   gcc_assert (!alias_pairs);
    3015                 :            : 
    3016                 :            :   /* Get rid of the global decl state hash tables to save some memory.  */
    3017                 :      21838 :   out_state = lto_get_out_decl_state ();
    3018                 :     174704 :   for (int i = 0; i < LTO_N_DECL_STREAMS; i++)
    3019                 :     152866 :     if (out_state->streams[i].tree_hash_table)
    3020                 :            :       {
    3021                 :     152866 :         delete out_state->streams[i].tree_hash_table;
    3022                 :     152866 :         out_state->streams[i].tree_hash_table = NULL;
    3023                 :            :       }
    3024                 :            : 
    3025                 :            :   /* Write the global symbols.  */
    3026                 :      21838 :   if (streamer_dump_file)
    3027                 :          4 :     fprintf (streamer_dump_file, "Outputting global stream\n");
    3028                 :      21838 :   lto_output_decl_state_streams (ob, out_state);
    3029                 :      21838 :   num_fns = lto_function_decl_states.length ();
    3030                 :     153269 :   for (idx = 0; idx < num_fns; idx++)
    3031                 :            :     {
    3032                 :     262862 :       fn_out_state =
    3033                 :     131431 :         lto_function_decl_states[idx];
    3034                 :     131431 :       if (streamer_dump_file)
    3035                 :         24 :         fprintf (streamer_dump_file, "Outputting stream for %s\n",
    3036                 :         12 :                  IDENTIFIER_POINTER
    3037                 :            :                     (DECL_ASSEMBLER_NAME (fn_out_state->fn_decl)));
    3038                 :     131431 :       lto_output_decl_state_streams (ob, fn_out_state);
    3039                 :            :     }
    3040                 :            : 
    3041                 :            :   /* Currently not used.  This field would allow us to preallocate
    3042                 :            :      the globals vector, so that it need not be resized as it is extended.  */
    3043                 :      21838 :   header.num_nodes = -1;
    3044                 :            : 
    3045                 :            :   /* Compute the total size of all decl out states. */
    3046                 :      21838 :   decl_state_size = sizeof (int32_t);
    3047                 :      21838 :   decl_state_size += lto_out_decl_state_written_size (out_state);
    3048                 :     153269 :   for (idx = 0; idx < num_fns; idx++)
    3049                 :            :     {
    3050                 :     262862 :       fn_out_state =
    3051                 :     131431 :         lto_function_decl_states[idx];
    3052                 :     262862 :       decl_state_size += lto_out_decl_state_written_size (fn_out_state);
    3053                 :            :     }
    3054                 :      21838 :   header.decl_state_size = decl_state_size;
    3055                 :            : 
    3056                 :      21838 :   header.main_size = ob->main_stream->total_size;
    3057                 :      21838 :   header.string_size = ob->string_stream->total_size;
    3058                 :            : 
    3059                 :      21838 :   lto_write_data (&header, sizeof header);
    3060                 :            : 
    3061                 :            :   /* Write the main out-decl state, followed by out-decl states of
    3062                 :            :      functions. */
    3063                 :      21838 :   num_decl_states = num_fns + 1;
    3064                 :      21838 :   lto_write_data (&num_decl_states, sizeof (num_decl_states));
    3065                 :      21838 :   lto_output_decl_state_refs (ob, out_state);
    3066                 :     153269 :   for (idx = 0; idx < num_fns; idx++)
    3067                 :            :     {
    3068                 :     131431 :       fn_out_state = lto_function_decl_states[idx];
    3069                 :     131431 :       lto_output_decl_state_refs (ob, fn_out_state);
    3070                 :            :     }
    3071                 :            : 
    3072                 :      21838 :   lto_write_stream (ob->main_stream);
    3073                 :      21838 :   lto_write_stream (ob->string_stream);
    3074                 :            : 
    3075                 :      21838 :   lto_end_section ();
    3076                 :            : 
    3077                 :            :   /* Write the symbol table.  It is used by linker to determine dependencies
    3078                 :            :      and thus we can skip it for WPA.  */
    3079                 :      21838 :   if (!flag_wpa)
    3080                 :            :     {
    3081                 :      16482 :       unsigned int streamed_symbols = produce_symtab (ob);
    3082                 :      16482 :       produce_symtab_extension (ob, streamed_symbols);
    3083                 :            :     }
    3084                 :            : 
    3085                 :            :   /* Write command line opts.  */
    3086                 :      21838 :   lto_write_options ();
    3087                 :            : 
    3088                 :            :   /* Deallocate memory and clean up.  */
    3089                 :     153269 :   for (idx = 0; idx < num_fns; idx++)
    3090                 :            :     {
    3091                 :     262862 :       fn_out_state =
    3092                 :     131431 :         lto_function_decl_states[idx];
    3093                 :     131431 :       lto_delete_out_decl_state (fn_out_state);
    3094                 :            :     }
    3095                 :      21838 :   lto_symtab_encoder_delete (ob->decl_state->symtab_node_encoder);
    3096                 :      21838 :   lto_function_decl_states.release ();
    3097                 :      21838 :   destroy_output_block (ob);
    3098                 :      21838 :   if (lto_stream_offload_p)
    3099                 :          0 :     lto_write_mode_table ();
    3100                 :      21838 : }

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.