LCOV - code coverage report
Current view: top level - gcc - lto-cgraph.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 1001 1073 93.3 %
Date: 2020-04-04 11:58:09 Functions: 47 50 94.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Write and read the cgraph to the memory mapped representation of a
       2                 :            :    .o file.
       3                 :            : 
       4                 :            :    Copyright (C) 2009-2020 Free Software Foundation, Inc.
       5                 :            :    Contributed by Kenneth Zadeck <zadeck@naturalbridge.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 "rtl.h"
      28                 :            : #include "tree.h"
      29                 :            : #include "gimple.h"
      30                 :            : #include "predict.h"
      31                 :            : #include "stringpool.h"
      32                 :            : #include "tree-streamer.h"
      33                 :            : #include "cgraph.h"
      34                 :            : #include "tree-pass.h"
      35                 :            : #include "profile.h"
      36                 :            : #include "context.h"
      37                 :            : #include "pass_manager.h"
      38                 :            : #include "ipa-utils.h"
      39                 :            : #include "omp-offload.h"
      40                 :            : #include "stringpool.h"
      41                 :            : #include "attribs.h"
      42                 :            : 
      43                 :            : /* True when asm nodes has been output.  */
      44                 :            : bool asm_nodes_output = false;
      45                 :            : 
      46                 :            : static void output_cgraph_opt_summary (void);
      47                 :            : static void input_cgraph_opt_summary (vec<symtab_node *>  nodes);
      48                 :            : 
      49                 :            : /* Number of LDPR values known to GCC.  */
      50                 :            : #define LDPR_NUM_KNOWN (LDPR_PREVAILING_DEF_IRONLY_EXP + 1)
      51                 :            : 
      52                 :            : /* Cgraph streaming is organized as set of record whose type
      53                 :            :    is indicated by a tag.  */
      54                 :            : enum LTO_symtab_tags
      55                 :            : {
      56                 :            :   /* Must leave 0 for the stopper.  */
      57                 :            : 
      58                 :            :   /* Cgraph node without body available.  */
      59                 :            :   LTO_symtab_unavail_node = 1,
      60                 :            :   /* Cgraph node with function body.  */
      61                 :            :   LTO_symtab_analyzed_node,
      62                 :            :   /* Cgraph edges.  */
      63                 :            :   LTO_symtab_edge,
      64                 :            :   LTO_symtab_indirect_edge,
      65                 :            :   LTO_symtab_variable,
      66                 :            :   LTO_symtab_last_tag
      67                 :            : };
      68                 :            : 
      69                 :            : /* Create a new symtab encoder.
      70                 :            :    if FOR_INPUT, the encoder allocate only datastructures needed
      71                 :            :    to read the symtab.  */
      72                 :            : 
      73                 :            : lto_symtab_encoder_t
      74                 :      58600 : lto_symtab_encoder_new (bool for_input)
      75                 :            : {
      76                 :      58600 :   lto_symtab_encoder_t encoder = XCNEW (struct lto_symtab_encoder_d);
      77                 :            : 
      78                 :      58600 :   if (!for_input)
      79                 :      43676 :     encoder->map = new hash_map<symtab_node *, size_t>;
      80                 :      58600 :   encoder->nodes.create (0);
      81                 :      58600 :   return encoder;
      82                 :            : }
      83                 :            : 
      84                 :            : 
      85                 :            : /* Delete ENCODER and its components.  */
      86                 :            : 
      87                 :            : void
      88                 :      58600 : lto_symtab_encoder_delete (lto_symtab_encoder_t encoder)
      89                 :            : {
      90                 :      58600 :    encoder->nodes.release ();
      91                 :      58600 :    if (encoder->map)
      92                 :      43676 :      delete encoder->map;
      93                 :      58600 :    free (encoder);
      94                 :      58600 : }
      95                 :            : 
      96                 :            : 
      97                 :            : /* Return the existing reference number of NODE in the symtab encoder in
      98                 :            :    output block OB.  Assign a new reference if this is the first time
      99                 :            :    NODE is encoded.  */
     100                 :            : 
     101                 :            : int
     102                 :    2528580 : lto_symtab_encoder_encode (lto_symtab_encoder_t encoder,
     103                 :            :                            symtab_node *node)
     104                 :            : {
     105                 :    2528580 :   int ref;
     106                 :            : 
     107                 :    2528580 :   if (!encoder->map)
     108                 :            :     {
     109                 :     205478 :       lto_encoder_entry entry = {node, false, false, false};
     110                 :            : 
     111                 :     205478 :       ref = encoder->nodes.length ();
     112                 :     205478 :       encoder->nodes.safe_push (entry);
     113                 :     205478 :       return ref;
     114                 :            :     }
     115                 :            : 
     116                 :    2323110 :   size_t *slot = encoder->map->get (node);
     117                 :    1290010 :   if (!slot || !*slot)
     118                 :            :     {
     119                 :    1033100 :       lto_encoder_entry entry = {node, false, false, false};
     120                 :    1033100 :       ref = encoder->nodes.length ();
     121                 :    1033100 :       if (!slot)
     122                 :    1033100 :         encoder->map->put (node, ref + 1);
     123                 :    1033100 :       encoder->nodes.safe_push (entry);
     124                 :            :     }
     125                 :            :   else
     126                 :    1290010 :     ref = *slot - 1;
     127                 :            : 
     128                 :            :   return ref;
     129                 :            : }
     130                 :            : 
     131                 :            : /* Remove NODE from encoder.  */
     132                 :            : 
     133                 :            : bool
     134                 :        224 : lto_symtab_encoder_delete_node (lto_symtab_encoder_t encoder,
     135                 :            :                                 symtab_node *node)
     136                 :            : {
     137                 :        224 :   int index;
     138                 :        224 :   lto_encoder_entry last_node;
     139                 :            : 
     140                 :        224 :   size_t *slot = encoder->map->get (node);
     141                 :        224 :   if (slot == NULL || !*slot)
     142                 :            :     return false;
     143                 :            : 
     144                 :        224 :   index = *slot - 1;
     145                 :        224 :   gcc_checking_assert (encoder->nodes[index].node == node);
     146                 :            : 
     147                 :            :   /* Remove from vector. We do this by swapping node with the last element
     148                 :            :      of the vector.  */
     149                 :        224 :   last_node = encoder->nodes.pop ();
     150                 :        224 :   if (last_node.node != node)
     151                 :            :     {
     152                 :        223 :       gcc_assert (encoder->map->put (last_node.node, index + 1));
     153                 :            : 
     154                 :            :       /* Move the last element to the original spot of NODE.  */
     155                 :        223 :       encoder->nodes[index] = last_node;
     156                 :            :     }
     157                 :            : 
     158                 :            :   /* Remove element from hash table.  */
     159                 :        224 :   encoder->map->remove (node);
     160                 :        224 :   return true;
     161                 :            : }
     162                 :            : 
     163                 :            : 
     164                 :            : /* Return TRUE if we should encode the body of NODE (if any).  */
     165                 :            : 
     166                 :            : bool
     167                 :     357159 : lto_symtab_encoder_encode_body_p (lto_symtab_encoder_t encoder,
     168                 :            :                                   struct cgraph_node *node)
     169                 :            : {
     170                 :     357159 :   int index = lto_symtab_encoder_lookup (encoder, node);
     171                 :     357159 :   return encoder->nodes[index].body;
     172                 :            : }
     173                 :            : 
     174                 :            : /* Specify that we encode the body of NODE in this partition.  */
     175                 :            : 
     176                 :            : static void
     177                 :     126696 : lto_set_symtab_encoder_encode_body (lto_symtab_encoder_t encoder,
     178                 :            :                                     struct cgraph_node *node)
     179                 :            : {
     180                 :     126696 :   int index = lto_symtab_encoder_encode (encoder, node);
     181                 :     126696 :   gcc_checking_assert (encoder->nodes[index].node == node);
     182                 :     126696 :   encoder->nodes[index].body = true;
     183                 :     126696 : }
     184                 :            : 
     185                 :            : /* Return TRUE if we should encode initializer of NODE (if any).  */
     186                 :            : 
     187                 :            : bool
     188                 :     643470 : lto_symtab_encoder_encode_initializer_p (lto_symtab_encoder_t encoder,
     189                 :            :                                          varpool_node *node)
     190                 :            : {
     191                 :     643470 :   int index = lto_symtab_encoder_lookup (encoder, node);
     192                 :     643470 :   if (index == LCC_NOT_FOUND)
     193                 :            :     return false;
     194                 :     643446 :   return encoder->nodes[index].initializer;
     195                 :            : }
     196                 :            : 
     197                 :            : /* Specify that we should encode initializer of NODE (if any).  */
     198                 :            : 
     199                 :            : static void
     200                 :     269445 : lto_set_symtab_encoder_encode_initializer (lto_symtab_encoder_t encoder,
     201                 :            :                                            varpool_node *node)
     202                 :            : {
     203                 :     269445 :   int index = lto_symtab_encoder_lookup (encoder, node);
     204                 :     269445 :   encoder->nodes[index].initializer = true;
     205                 :     269445 : }
     206                 :            : 
     207                 :            : /* Return TRUE if NODE is in this partition.  */
     208                 :            : 
     209                 :            : bool
     210                 :    7401220 : lto_symtab_encoder_in_partition_p (lto_symtab_encoder_t encoder,
     211                 :            :                                    symtab_node *node)
     212                 :            : {
     213                 :    7401220 :   int index = lto_symtab_encoder_lookup (encoder, node);
     214                 :    7401220 :   if (index == LCC_NOT_FOUND)
     215                 :            :     return false;
     216                 :    7300910 :   return encoder->nodes[index].in_partition;
     217                 :            : }
     218                 :            : 
     219                 :            : /* Specify that NODE is in this partition.  */
     220                 :            : 
     221                 :            : void
     222                 :     794847 : lto_set_symtab_encoder_in_partition (lto_symtab_encoder_t encoder,
     223                 :            :                                      symtab_node *node)
     224                 :            : {
     225                 :     794847 :   int index = lto_symtab_encoder_encode (encoder, node);
     226                 :     794847 :   encoder->nodes[index].in_partition = true;
     227                 :     794847 : }
     228                 :            : 
     229                 :            : /* Output the cgraph EDGE to OB using ENCODER.  */
     230                 :            : 
     231                 :            : static void
     232                 :     326733 : lto_output_edge (struct lto_simple_output_block *ob, struct cgraph_edge *edge,
     233                 :            :                  lto_symtab_encoder_t encoder)
     234                 :            : {
     235                 :     326733 :   unsigned int uid;
     236                 :     326733 :   intptr_t ref;
     237                 :     326733 :   struct bitpack_d bp;
     238                 :            : 
     239                 :     326733 :   if (edge->indirect_unknown_callee)
     240                 :       2143 :     streamer_write_enum (ob->main_stream, LTO_symtab_tags, LTO_symtab_last_tag,
     241                 :            :                          LTO_symtab_indirect_edge);
     242                 :            :   else
     243                 :     324590 :     streamer_write_enum (ob->main_stream, LTO_symtab_tags, LTO_symtab_last_tag,
     244                 :            :                          LTO_symtab_edge);
     245                 :            : 
     246                 :     326733 :   ref = lto_symtab_encoder_lookup (encoder, edge->caller);
     247                 :     326733 :   gcc_assert (ref != LCC_NOT_FOUND);
     248                 :     326733 :   streamer_write_hwi_stream (ob->main_stream, ref);
     249                 :            : 
     250                 :     326733 :   if (!edge->indirect_unknown_callee)
     251                 :            :     {
     252                 :     324590 :       ref = lto_symtab_encoder_lookup (encoder, edge->callee);
     253                 :     324590 :       gcc_assert (ref != LCC_NOT_FOUND);
     254                 :     324590 :       streamer_write_hwi_stream (ob->main_stream, ref);
     255                 :            :     }
     256                 :            : 
     257                 :     326733 :   edge->count.stream_out (ob->main_stream);
     258                 :            : 
     259                 :     326733 :   bp = bitpack_create (ob->main_stream);
     260                 :     326733 :   uid = !edge->call_stmt ? edge->lto_stmt_uid
     261                 :     234662 :                          : gimple_uid (edge->call_stmt) + 1;
     262                 :     326733 :   bp_pack_enum (&bp, cgraph_inline_failed_t,
     263                 :            :                 CIF_N_REASONS, edge->inline_failed);
     264                 :     326733 :   gcc_checking_assert (uid || edge->caller->thunk.thunk_p);
     265                 :     326733 :   bp_pack_var_len_unsigned (&bp, uid);
     266                 :     326733 :   bp_pack_value (&bp, edge->speculative_id, 16);
     267                 :     326733 :   bp_pack_value (&bp, edge->indirect_inlining_edge, 1);
     268                 :     326733 :   bp_pack_value (&bp, edge->speculative, 1);
     269                 :     326733 :   bp_pack_value (&bp, edge->call_stmt_cannot_inline_p, 1);
     270                 :     326733 :   gcc_assert (!edge->call_stmt_cannot_inline_p
     271                 :            :               || edge->inline_failed != CIF_BODY_NOT_AVAILABLE);
     272                 :     326733 :   bp_pack_value (&bp, edge->can_throw_external, 1);
     273                 :     326733 :   bp_pack_value (&bp, edge->in_polymorphic_cdtor, 1);
     274                 :     326733 :   if (edge->indirect_unknown_callee)
     275                 :            :     {
     276                 :       2143 :       int flags = edge->indirect_info->ecf_flags;
     277                 :       2143 :       bp_pack_value (&bp, (flags & ECF_CONST) != 0, 1);
     278                 :       2143 :       bp_pack_value (&bp, (flags & ECF_PURE) != 0, 1);
     279                 :       2143 :       bp_pack_value (&bp, (flags & ECF_NORETURN) != 0, 1);
     280                 :       2143 :       bp_pack_value (&bp, (flags & ECF_MALLOC) != 0, 1);
     281                 :       2143 :       bp_pack_value (&bp, (flags & ECF_NOTHROW) != 0, 1);
     282                 :       2143 :       bp_pack_value (&bp, (flags & ECF_RETURNS_TWICE) != 0, 1);
     283                 :            :       /* Flags that should not appear on indirect calls.  */
     284                 :       2143 :       gcc_assert (!(flags & (ECF_LOOPING_CONST_OR_PURE
     285                 :            :                              | ECF_MAY_BE_ALLOCA
     286                 :            :                              | ECF_SIBCALL
     287                 :            :                              | ECF_LEAF
     288                 :            :                              | ECF_NOVOPS)));
     289                 :            : 
     290                 :       2143 :       bp_pack_value (&bp, edge->indirect_info->num_speculative_call_targets,
     291                 :            :                      16);
     292                 :            :     }
     293                 :     326733 :   streamer_write_bitpack (&bp);
     294                 :     326733 : }
     295                 :            : 
     296                 :            : /* Return if NODE contain references from other partitions.  */
     297                 :            : 
     298                 :            : bool
     299                 :     382012 : referenced_from_other_partition_p (symtab_node *node, lto_symtab_encoder_t encoder)
     300                 :            : {
     301                 :     382012 :   int i;
     302                 :     382012 :   struct ipa_ref *ref = NULL;
     303                 :            : 
     304                 :     870063 :   for (i = 0; node->iterate_referring (i, ref); i++)
     305                 :            :     {
     306                 :            :       /* Ignore references from non-offloadable nodes while streaming NODE into
     307                 :            :          offload LTO section.  */
     308                 :     244167 :       if (!ref->referring->need_lto_streaming)
     309                 :          0 :         continue;
     310                 :            : 
     311                 :     244167 :       if (ref->referring->in_other_partition
     312                 :     244167 :           || !lto_symtab_encoder_in_partition_p (encoder, ref->referring))
     313                 :        283 :         return true;
     314                 :            :     }
     315                 :            :   return false;
     316                 :            : }
     317                 :            : 
     318                 :            : /* Return true when node is reachable from other partition.  */
     319                 :            : 
     320                 :            : bool
     321                 :     115478 : reachable_from_other_partition_p (struct cgraph_node *node, lto_symtab_encoder_t encoder)
     322                 :            : {
     323                 :     115478 :   struct cgraph_edge *e;
     324                 :     115478 :   if (!node->definition)
     325                 :            :     return false;
     326                 :     115478 :   if (node->inlined_to)
     327                 :            :     return false;
     328                 :     247567 :   for (e = node->callers; e; e = e->next_caller)
     329                 :            :     {
     330                 :            :       /* Ignore references from non-offloadable nodes while streaming NODE into
     331                 :            :          offload LTO section.  */
     332                 :     132181 :       if (!e->caller->need_lto_streaming)
     333                 :          0 :         continue;
     334                 :            : 
     335                 :     132181 :       if (e->caller->in_other_partition
     336                 :     132181 :           || !lto_symtab_encoder_in_partition_p (encoder, e->caller))
     337                 :         92 :         return true;
     338                 :            :     }
     339                 :            :   return false;
     340                 :            : }
     341                 :            : 
     342                 :            : /* Return if NODE contain references from other partitions.  */
     343                 :            : 
     344                 :            : bool
     345                 :       4715 : referenced_from_this_partition_p (symtab_node *node,
     346                 :            :                                   lto_symtab_encoder_t encoder)
     347                 :            : {
     348                 :       4715 :   int i;
     349                 :       4715 :   struct ipa_ref *ref = NULL;
     350                 :            : 
     351                 :       8208 :   for (i = 0; node->iterate_referring (i, ref); i++)
     352                 :       3481 :     if (lto_symtab_encoder_in_partition_p (encoder, ref->referring))
     353                 :            :       return true;
     354                 :            :   return false;
     355                 :            : }
     356                 :            : 
     357                 :            : /* Return true when node is reachable from other partition.  */
     358                 :            : 
     359                 :            : bool
     360                 :       5304 : reachable_from_this_partition_p (struct cgraph_node *node, lto_symtab_encoder_t encoder)
     361                 :            : {
     362                 :       5304 :   struct cgraph_edge *e;
     363                 :       5306 :   for (e = node->callers; e; e = e->next_caller)
     364                 :       3270 :     if (lto_symtab_encoder_in_partition_p (encoder, e->caller))
     365                 :            :       return true;
     366                 :            :   return false;
     367                 :            : }
     368                 :            : 
     369                 :            : /* Output the cgraph NODE to OB.  ENCODER is used to find the
     370                 :            :    reference number of NODE->inlined_to.  SET is the set of nodes we
     371                 :            :    are writing to the current file.  If NODE is not in SET, then NODE
     372                 :            :    is a boundary of a cgraph_node_set and we pretend NODE just has a
     373                 :            :    decl and no callees.  WRITTEN_DECLS is the set of FUNCTION_DECLs
     374                 :            :    that have had their callgraph node written so far.  This is used to
     375                 :            :    determine if NODE is a clone of a previously written node.  */
     376                 :            : 
     377                 :            : static void
     378                 :     363937 : lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
     379                 :            :                  lto_symtab_encoder_t encoder)
     380                 :            : {
     381                 :     363937 :   unsigned int tag;
     382                 :     363937 :   struct bitpack_d bp;
     383                 :     363937 :   bool boundary_p;
     384                 :     363937 :   intptr_t ref;
     385                 :     363937 :   bool in_other_partition = false;
     386                 :     363937 :   struct cgraph_node *clone_of, *ultimate_clone_of;
     387                 :     363937 :   ipa_opt_pass_d *pass;
     388                 :     363937 :   int i;
     389                 :     363937 :   const char *comdat;
     390                 :     363937 :   const char *section;
     391                 :     363937 :   tree group;
     392                 :            : 
     393                 :     363937 :   boundary_p = !lto_symtab_encoder_in_partition_p (encoder, node);
     394                 :            : 
     395                 :     126960 :   if (node->analyzed && (!boundary_p || node->alias
     396                 :     364135 :                          || (node->thunk.thunk_p && !node->inlined_to)))
     397                 :            :     tag = LTO_symtab_analyzed_node;
     398                 :            :   else
     399                 :     237171 :     tag = LTO_symtab_unavail_node;
     400                 :            : 
     401                 :     363937 :   streamer_write_enum (ob->main_stream, LTO_symtab_tags, LTO_symtab_last_tag,
     402                 :            :                        tag);
     403                 :     363937 :   streamer_write_hwi_stream (ob->main_stream, node->order);
     404                 :            : 
     405                 :            :   /* In WPA mode, we only output part of the call-graph.  Also, we
     406                 :            :      fake cgraph node attributes.  There are two cases that we care.
     407                 :            : 
     408                 :            :      Boundary nodes: There are nodes that are not part of SET but are
     409                 :            :      called from within SET.  We artificially make them look like
     410                 :            :      externally visible nodes with no function body.
     411                 :            : 
     412                 :            :      Cherry-picked nodes:  These are nodes we pulled from other
     413                 :            :      translation units into SET during IPA-inlining.  We make them as
     414                 :            :      local static nodes to prevent clashes with other local statics.  */
     415                 :     237241 :   if (boundary_p && node->analyzed
     416                 :     364201 :       && node->get_partitioning_class () == SYMBOL_PARTITION)
     417                 :            :     {
     418                 :            :       /* Inline clones cannot be part of boundary.  
     419                 :            :          gcc_assert (!node->inlined_to);
     420                 :            : 
     421                 :            :          FIXME: At the moment they can be, when partition contains an inline
     422                 :            :          clone that is clone of inline clone from outside partition.  We can
     423                 :            :          reshape the clone tree and make other tree to be the root, but it
     424                 :            :          needs a bit extra work and will be promplty done by cgraph_remove_node
     425                 :            :          after reading back.  */
     426                 :            :       in_other_partition = 1;
     427                 :            :     }
     428                 :            : 
     429                 :     363937 :   clone_of = node->clone_of;
     430                 :     363937 :   while (clone_of
     431                 :     363937 :          && (ref = lto_symtab_encoder_lookup (encoder, clone_of)) == LCC_NOT_FOUND)
     432                 :          0 :     if (clone_of->prev_sibling_clone)
     433                 :            :       clone_of = clone_of->prev_sibling_clone;
     434                 :            :     else
     435                 :          0 :       clone_of = clone_of->clone_of;
     436                 :            : 
     437                 :            :   /* See if body of the master function is output.  If not, we are seeing only
     438                 :            :      an declaration and we do not need to pass down clone tree. */
     439                 :     363937 :   ultimate_clone_of = clone_of;
     440                 :     364296 :   while (ultimate_clone_of && ultimate_clone_of->clone_of)
     441                 :            :     ultimate_clone_of = ultimate_clone_of->clone_of;
     442                 :            : 
     443                 :     363937 :   if (clone_of && !lto_symtab_encoder_encode_body_p (encoder, ultimate_clone_of))
     444                 :            :     clone_of = NULL;
     445                 :            : 
     446                 :     363937 :   if (tag == LTO_symtab_analyzed_node)
     447                 :     126766 :     gcc_assert (clone_of || !node->clone_of);
     448                 :     363937 :   if (!clone_of)
     449                 :     361715 :     streamer_write_hwi_stream (ob->main_stream, LCC_NOT_FOUND);
     450                 :            :   else
     451                 :       2222 :     streamer_write_hwi_stream (ob->main_stream, ref);
     452                 :            : 
     453                 :            : 
     454                 :     363937 :   lto_output_fn_decl_index (ob->decl_state, ob->main_stream, node->decl);
     455                 :     363937 :   node->count.stream_out (ob->main_stream);
     456                 :     363937 :   streamer_write_hwi_stream (ob->main_stream, node->count_materialization_scale);
     457                 :            : 
     458                 :     727874 :   streamer_write_hwi_stream (ob->main_stream,
     459                 :     363937 :                              node->ipa_transforms_to_apply.length ());
     460                 :     421503 :   FOR_EACH_VEC_ELT (node->ipa_transforms_to_apply, i, pass)
     461                 :      57566 :     streamer_write_hwi_stream (ob->main_stream, pass->static_pass_number);
     462                 :            : 
     463                 :     363937 :   if (tag == LTO_symtab_analyzed_node)
     464                 :            :     {
     465                 :     126766 :       if (node->inlined_to)
     466                 :            :         {
     467                 :       2055 :           ref = lto_symtab_encoder_lookup (encoder, node->inlined_to);
     468                 :       2055 :           gcc_assert (ref != LCC_NOT_FOUND);
     469                 :            :         }
     470                 :            :       else
     471                 :            :         ref = LCC_NOT_FOUND;
     472                 :            : 
     473                 :     126766 :       streamer_write_hwi_stream (ob->main_stream, ref);
     474                 :            :     }
     475                 :            : 
     476                 :     363937 :   group = node->get_comdat_group ();
     477                 :     363937 :   if (group)
     478                 :       9209 :     comdat = IDENTIFIER_POINTER (group);
     479                 :            :   else
     480                 :            :     comdat = "";
     481                 :     363937 :   streamer_write_data_stream (ob->main_stream, comdat, strlen (comdat) + 1);
     482                 :            : 
     483                 :     363937 :   if (group)
     484                 :            :     {
     485                 :       9209 :       if (node->same_comdat_group)
     486                 :            :         {
     487                 :            :           ref = LCC_NOT_FOUND;
     488                 :       4623 :           for (struct symtab_node *n = node->same_comdat_group; 
     489                 :       9245 :                ref == LCC_NOT_FOUND && n != node; n = n->same_comdat_group)
     490                 :       4623 :             ref = lto_symtab_encoder_lookup (encoder, n);
     491                 :            :         }
     492                 :            :       else
     493                 :            :         ref = LCC_NOT_FOUND;
     494                 :       9209 :       streamer_write_hwi_stream (ob->main_stream, ref);
     495                 :            :     }
     496                 :            : 
     497                 :     363937 :   section = node->get_section ();
     498                 :        392 :   if (!section)
     499                 :     363545 :     section = "";
     500                 :            : 
     501                 :     363937 :   streamer_write_hwi_stream (ob->main_stream, node->tp_first_run);
     502                 :            : 
     503                 :     363937 :   bp = bitpack_create (ob->main_stream);
     504                 :     363937 :   bp_pack_value (&bp, node->local, 1);
     505                 :     363937 :   bp_pack_value (&bp, node->externally_visible, 1);
     506                 :     363937 :   bp_pack_value (&bp, node->no_reorder, 1);
     507                 :     363937 :   bp_pack_value (&bp, node->definition, 1);
     508                 :     363937 :   bp_pack_value (&bp, node->versionable, 1);
     509                 :     363937 :   bp_pack_value (&bp, node->can_change_signature, 1);
     510                 :     363937 :   bp_pack_value (&bp, node->redefined_extern_inline, 1);
     511                 :     363937 :   bp_pack_value (&bp, node->force_output, 1);
     512                 :     363937 :   bp_pack_value (&bp, node->forced_by_abi, 1);
     513                 :     363937 :   bp_pack_value (&bp, node->unique_name, 1);
     514                 :     363937 :   bp_pack_value (&bp, node->body_removed, 1);
     515                 :     363937 :   bp_pack_value (&bp, node->implicit_section, 1);
     516                 :     363937 :   bp_pack_value (&bp, node->address_taken, 1);
     517                 :     363937 :   bp_pack_value (&bp, tag == LTO_symtab_analyzed_node
     518                 :     126766 :                  && node->get_partitioning_class () == SYMBOL_PARTITION
     519                 :     479415 :                  && (reachable_from_other_partition_p (node, encoder)
     520                 :     115386 :                      || referenced_from_other_partition_p (node, encoder)), 1);
     521                 :     363937 :   bp_pack_value (&bp, node->lowered, 1);
     522                 :     363937 :   bp_pack_value (&bp, in_other_partition, 1);
     523                 :     363937 :   bp_pack_value (&bp, node->alias, 1);
     524                 :     363937 :   bp_pack_value (&bp, node->transparent_alias, 1);
     525                 :     363937 :   bp_pack_value (&bp, node->weakref, 1);
     526                 :     363937 :   bp_pack_value (&bp, node->symver, 1);
     527                 :     363937 :   bp_pack_value (&bp, node->frequency, 2);
     528                 :     363937 :   bp_pack_value (&bp, node->only_called_at_startup, 1);
     529                 :     363937 :   bp_pack_value (&bp, node->only_called_at_exit, 1);
     530                 :     363937 :   bp_pack_value (&bp, node->tm_clone, 1);
     531                 :     363937 :   bp_pack_value (&bp, node->calls_comdat_local, 1);
     532                 :     363937 :   bp_pack_value (&bp, node->icf_merged, 1);
     533                 :     363937 :   bp_pack_value (&bp, node->nonfreeing_fn, 1);
     534                 :     363937 :   bp_pack_value (&bp, node->merged_comdat, 1);
     535                 :     363937 :   bp_pack_value (&bp, node->merged_extern_inline, 1);
     536                 :     363937 :   bp_pack_value (&bp, node->thunk.thunk_p, 1);
     537                 :     363937 :   bp_pack_value (&bp, node->parallelized_function, 1);
     538                 :     363937 :   bp_pack_enum (&bp, ld_plugin_symbol_resolution,
     539                 :            :                 LDPR_NUM_KNOWN,
     540                 :            :                 /* When doing incremental link, we will get new resolution
     541                 :            :                    info next time we process the file.  */
     542                 :            :                 flag_incremental_link ? LDPR_UNKNOWN : node->resolution);
     543                 :     363937 :   bp_pack_value (&bp, node->split_part, 1);
     544                 :     363937 :   streamer_write_bitpack (&bp);
     545                 :     363937 :   streamer_write_data_stream (ob->main_stream, section, strlen (section) + 1);
     546                 :            : 
     547                 :            :   /* Stream thunk info always because we use it in
     548                 :            :      ipa_polymorphic_call_context::ipa_polymorphic_call_context
     549                 :            :      to properly interpret THIS pointers for thunks that has been converted
     550                 :            :      to Gimple.  */
     551                 :     363937 :   if (node->definition)
     552                 :            :     {
     553                 :     126960 :       streamer_write_uhwi_stream
     554                 :     126960 :          (ob->main_stream,
     555                 :     126960 :           1 + (node->thunk.this_adjusting != 0) * 2
     556                 :     253842 :           + (node->thunk.virtual_offset_p != 0) * 4);
     557                 :     126960 :       streamer_write_uhwi_stream (ob->main_stream, node->thunk.fixed_offset);
     558                 :     126960 :       streamer_write_uhwi_stream (ob->main_stream, node->thunk.virtual_value);
     559                 :     126960 :       streamer_write_uhwi_stream (ob->main_stream, node->thunk.indirect_offset);
     560                 :            :     }
     561                 :     363937 :   streamer_write_hwi_stream (ob->main_stream, node->profile_id);
     562                 :     363937 :   streamer_write_hwi_stream (ob->main_stream, node->unit_id);
     563                 :     363937 :   if (DECL_STATIC_CONSTRUCTOR (node->decl))
     564                 :        220 :     streamer_write_hwi_stream (ob->main_stream, node->get_init_priority ());
     565                 :     363937 :   if (DECL_STATIC_DESTRUCTOR (node->decl))
     566                 :         39 :     streamer_write_hwi_stream (ob->main_stream, node->get_fini_priority ());
     567                 :     363937 : }
     568                 :            : 
     569                 :            : /* Output the varpool NODE to OB. 
     570                 :            :    If NODE is not in SET, then NODE is a boundary.  */
     571                 :            : 
     572                 :            : static void
     573                 :     272932 : lto_output_varpool_node (struct lto_simple_output_block *ob, varpool_node *node,
     574                 :            :                          lto_symtab_encoder_t encoder)
     575                 :            : {
     576                 :     272932 :   bool boundary_p = !lto_symtab_encoder_in_partition_p (encoder, node);
     577                 :     272932 :   bool encode_initializer_p
     578                 :            :          = (node->definition
     579                 :     272932 :             && lto_symtab_encoder_encode_initializer_p (encoder, node));
     580                 :     269325 :   struct bitpack_d bp;
     581                 :     269325 :   int ref;
     582                 :     269325 :   const char *comdat;
     583                 :     269325 :   const char *section;
     584                 :     269325 :   tree group;
     585                 :            : 
     586                 :     269325 :   gcc_assert (!encode_initializer_p || node->definition);
     587                 :     272932 :   gcc_assert (boundary_p || encode_initializer_p);
     588                 :            : 
     589                 :     272932 :   streamer_write_enum (ob->main_stream, LTO_symtab_tags, LTO_symtab_last_tag,
     590                 :            :                        LTO_symtab_variable);
     591                 :     272932 :   streamer_write_hwi_stream (ob->main_stream, node->order);
     592                 :     272932 :   lto_output_var_decl_index (ob->decl_state, ob->main_stream, node->decl);
     593                 :     272932 :   bp = bitpack_create (ob->main_stream);
     594                 :     272932 :   bp_pack_value (&bp, node->externally_visible, 1);
     595                 :     272932 :   bp_pack_value (&bp, node->no_reorder, 1);
     596                 :     272932 :   bp_pack_value (&bp, node->force_output, 1);
     597                 :     272932 :   bp_pack_value (&bp, node->forced_by_abi, 1);
     598                 :     272932 :   bp_pack_value (&bp, node->unique_name, 1);
     599                 :     272932 :   bp_pack_value (&bp,
     600                 :            :                  node->body_removed
     601                 :     272932 :                  || (!encode_initializer_p && !node->alias && node->definition),
     602                 :            :                  1);
     603                 :     272932 :   bp_pack_value (&bp, node->implicit_section, 1);
     604                 :     272932 :   bp_pack_value (&bp, node->writeonly, 1);
     605                 :     276537 :   bp_pack_value (&bp, node->definition && (encode_initializer_p || node->alias),
     606                 :            :                  1);
     607                 :     272932 :   bp_pack_value (&bp, node->alias, 1);
     608                 :     272932 :   bp_pack_value (&bp, node->transparent_alias, 1);
     609                 :     272932 :   bp_pack_value (&bp, node->weakref, 1);
     610                 :     272932 :   bp_pack_value (&bp, node->symver, 1);
     611                 :     276554 :   bp_pack_value (&bp, node->analyzed && (!boundary_p || node->alias), 1);
     612                 :     272932 :   gcc_assert (node->definition || !node->analyzed);
     613                 :            :   /* Constant pool initializers can be de-unified into individual ltrans units.
     614                 :            :      FIXME: Alternatively at -Os we may want to avoid generating for them the local
     615                 :            :      labels and share them across LTRANS partitions.  */
     616                 :     272932 :   if (node->get_partitioning_class () != SYMBOL_PARTITION)
     617                 :            :     {
     618                 :       6306 :       bp_pack_value (&bp, 0, 1);  /* used_from_other_parition.  */
     619                 :       6306 :       bp_pack_value (&bp, 0, 1);  /* in_other_partition.  */
     620                 :            :     }
     621                 :            :   else
     622                 :            :     {
     623                 :     266626 :       bp_pack_value (&bp, node->definition
     624                 :     266626 :                      && referenced_from_other_partition_p (node, encoder), 1);
     625                 :     266626 :       bp_pack_value (&bp, node->analyzed
     626                 :     266626 :                      && boundary_p && !DECL_EXTERNAL (node->decl), 1);
     627                 :            :           /* in_other_partition.  */
     628                 :            :     }
     629                 :     272932 :   bp_pack_value (&bp, node->tls_model, 3);
     630                 :     272932 :   bp_pack_value (&bp, node->used_by_single_function, 1);
     631                 :     272932 :   bp_pack_value (&bp, node->dynamically_initialized, 1);
     632                 :     272932 :   streamer_write_bitpack (&bp);
     633                 :            : 
     634                 :     272932 :   group = node->get_comdat_group ();
     635                 :     272932 :   if (group)
     636                 :       3514 :     comdat = IDENTIFIER_POINTER (group);
     637                 :            :   else
     638                 :            :     comdat = "";
     639                 :     272932 :   streamer_write_data_stream (ob->main_stream, comdat, strlen (comdat) + 1);
     640                 :            : 
     641                 :     272932 :   if (group)
     642                 :            :     {
     643                 :       3514 :       if (node->same_comdat_group)
     644                 :            :         {
     645                 :            :           ref = LCC_NOT_FOUND;
     646                 :        380 :           for (struct symtab_node *n = node->same_comdat_group; 
     647                 :        760 :                ref == LCC_NOT_FOUND && n != node; n = n->same_comdat_group)
     648                 :        380 :             ref = lto_symtab_encoder_lookup (encoder, n);
     649                 :            :         }
     650                 :            :       else
     651                 :            :         ref = LCC_NOT_FOUND;
     652                 :       3514 :       streamer_write_hwi_stream (ob->main_stream, ref);
     653                 :            :     }
     654                 :            : 
     655                 :     272932 :   section = node->get_section ();
     656                 :       1652 :   if (!section)
     657                 :     271280 :     section = "";
     658                 :     272932 :   streamer_write_data_stream (ob->main_stream, section, strlen (section) + 1);
     659                 :            : 
     660                 :     272932 :   streamer_write_enum (ob->main_stream, ld_plugin_symbol_resolution,
     661                 :            :                        LDPR_NUM_KNOWN, node->resolution);
     662                 :     272932 : }
     663                 :            : 
     664                 :            : /* Output the varpool NODE to OB. 
     665                 :            :    If NODE is not in SET, then NODE is a boundary.  */
     666                 :            : 
     667                 :            : static void
     668                 :     468629 : lto_output_ref (struct lto_simple_output_block *ob, struct ipa_ref *ref,
     669                 :            :                 lto_symtab_encoder_t encoder)
     670                 :            : {
     671                 :     468629 :   struct bitpack_d bp;
     672                 :     468629 :   int nref;
     673                 :     468629 :   int uid = !ref->stmt ? ref->lto_stmt_uid : gimple_uid (ref->stmt) + 1;
     674                 :     468629 :   struct cgraph_node *node;
     675                 :            : 
     676                 :     468629 :   bp = bitpack_create (ob->main_stream);
     677                 :     468629 :   bp_pack_value (&bp, ref->use, 3);
     678                 :     468629 :   bp_pack_value (&bp, ref->speculative, 1);
     679                 :     468629 :   streamer_write_bitpack (&bp);
     680                 :     468629 :   nref = lto_symtab_encoder_lookup (encoder, ref->referred);
     681                 :     468629 :   gcc_assert (nref != LCC_NOT_FOUND);
     682                 :     468629 :   streamer_write_hwi_stream (ob->main_stream, nref);
     683                 :            :   
     684                 :     468629 :   node = dyn_cast <cgraph_node *> (ref->referring);
     685                 :     237138 :   if (node)
     686                 :            :     {
     687                 :     237138 :       if (ref->stmt)
     688                 :     150932 :         uid = gimple_uid (ref->stmt) + 1;
     689                 :     237138 :       streamer_write_hwi_stream (ob->main_stream, uid);
     690                 :     237138 :       bp_pack_value (&bp, ref->speculative_id, 16);
     691                 :     237138 :       streamer_write_bitpack (&bp);
     692                 :            :     }
     693                 :     468629 : }
     694                 :            : 
     695                 :            : /* Stream out profile_summary to OB.  */
     696                 :            : 
     697                 :            : static void
     698                 :      21838 : output_profile_summary (struct lto_simple_output_block *ob)
     699                 :            : {
     700                 :      21838 :   if (profile_info)
     701                 :            :     {
     702                 :            :       /* We do not output num and run_max, they are not used by
     703                 :            :          GCC profile feedback and they are difficult to merge from multiple
     704                 :            :          units.  */
     705                 :         11 :       unsigned runs = (profile_info->runs);
     706                 :         11 :       streamer_write_uhwi_stream (ob->main_stream, runs);
     707                 :            : 
     708                 :            :       /* IPA-profile computes hot bb threshold based on cumulated
     709                 :            :          whole program profile.  We need to stream it down to ltrans.  */
     710                 :         11 :        if (flag_wpa)
     711                 :          4 :          streamer_write_gcov_count_stream (ob->main_stream,
     712                 :            :                                            get_hot_bb_threshold ());
     713                 :            :     }
     714                 :            :   else
     715                 :      21827 :     streamer_write_uhwi_stream (ob->main_stream, 0);
     716                 :      21838 : }
     717                 :            : 
     718                 :            : /* Output all callees or indirect outgoing edges.  EDGE must be the first such
     719                 :            :    edge.  */
     720                 :            : 
     721                 :            : static void
     722                 :     253400 : output_outgoing_cgraph_edges (struct cgraph_edge *edge,
     723                 :            :                               struct lto_simple_output_block *ob,
     724                 :            :                               lto_symtab_encoder_t encoder)
     725                 :            : {
     726                 :     253400 :   if (!edge)
     727                 :            :     return;
     728                 :            : 
     729                 :            :   /* Output edges in backward direction, so the reconstructed callgraph match
     730                 :            :      and it is easy to associate call sites in the IPA pass summaries.  */
     731                 :     326733 :   while (edge->next_callee)
     732                 :            :     edge = edge->next_callee;
     733                 :     411349 :   for (; edge; edge = edge->prev_callee)
     734                 :     326733 :     lto_output_edge (ob, edge, encoder);
     735                 :            : }
     736                 :            : 
     737                 :            : /* Output the part of the cgraph in SET.  */
     738                 :            : 
     739                 :            : static void
     740                 :      21838 : output_refs (lto_symtab_encoder_t encoder)
     741                 :            : {
     742                 :      21838 :   struct lto_simple_output_block *ob;
     743                 :      21838 :   int count;
     744                 :      21838 :   struct ipa_ref *ref;
     745                 :            : 
     746                 :      21838 :   ob = lto_create_simple_output_block (LTO_section_refs);
     747                 :            : 
     748                 :    1317200 :   for (int i = 0; i < lto_symtab_encoder_size (encoder); i++)
     749                 :            :     {
     750                 :     636869 :       symtab_node *node = lto_symtab_encoder_deref (encoder, i);
     751                 :            : 
     752                 :            :       /* IPA_REF_ALIAS references are always preserved
     753                 :            :          in the boundary.  Alias node can't have other references and
     754                 :            :          can be always handled as if it's not in the boundary.  */
     755                 :     636869 :       if (!node->alias && !lto_symtab_encoder_in_partition_p (encoder, node))
     756                 :     240759 :         continue;
     757                 :            : 
     758                 :     396110 :       count = node->ref_list.nreferences ();
     759                 :     396110 :       if (count)
     760                 :            :         {
     761                 :      62661 :           streamer_write_gcov_count_stream (ob->main_stream, count);
     762                 :     125322 :           streamer_write_uhwi_stream (ob->main_stream,
     763                 :      62661 :                                      lto_symtab_encoder_lookup (encoder, node));
     764                 :    1168160 :           for (int i = 0; node->iterate_reference (i, ref); i++)
     765                 :     468629 :             lto_output_ref (ob, ref, encoder);
     766                 :            :         }
     767                 :            :     }
     768                 :            : 
     769                 :      21838 :   streamer_write_uhwi_stream (ob->main_stream, 0);
     770                 :            : 
     771                 :      21838 :   lto_destroy_simple_output_block (ob);
     772                 :      21838 : }
     773                 :            : 
     774                 :            : /* Add NODE into encoder as well as nodes it is cloned from.
     775                 :            :    Do it in a way so clones appear first.  */
     776                 :            : 
     777                 :            : static void
     778                 :     545967 : add_node_to (lto_symtab_encoder_t encoder, struct cgraph_node *node,
     779                 :            :              bool include_body)
     780                 :            : {
     781                 :     545967 :   if (node->clone_of)
     782                 :       2378 :     add_node_to (encoder, node->clone_of, include_body);
     783                 :     543589 :   else if (include_body)
     784                 :     126696 :     lto_set_symtab_encoder_encode_body (encoder, node);
     785                 :     545967 :   lto_symtab_encoder_encode (encoder, node);
     786                 :     545967 : }
     787                 :            : 
     788                 :            : /* Add all references in NODE to encoders.  */
     789                 :            : 
     790                 :            : static void
     791                 :     408742 : create_references (lto_symtab_encoder_t encoder, symtab_node *node)
     792                 :            : {
     793                 :     408742 :   int i;
     794                 :     408742 :   struct ipa_ref *ref = NULL;
     795                 :     889922 :   for (i = 0; node->iterate_reference (i, ref); i++)
     796                 :     481180 :     if (is_a <cgraph_node *> (ref->referred))
     797                 :     236794 :       add_node_to (encoder, dyn_cast <cgraph_node *> (ref->referred), false);
     798                 :            :     else
     799                 :     244386 :       lto_symtab_encoder_encode (encoder, ref->referred);
     800                 :     408742 : }
     801                 :            : 
     802                 :            : /* Select what needs to be streamed out.  In regular lto mode stream everything.
     803                 :            :    In offload lto mode stream only nodes marked as offloadable.  */
     804                 :            : void
     805                 :      21504 : select_what_to_stream (void)
     806                 :            : {
     807                 :      21504 :   struct symtab_node *snode;
     808                 :     657932 :   FOR_EACH_SYMBOL (snode)
     809                 :     636428 :     snode->need_lto_streaming = !lto_stream_offload_p || snode->offloadable;
     810                 :      21504 : }
     811                 :            : 
     812                 :            : /* Find all symbols we want to stream into given partition and insert them
     813                 :            :    to encoders.
     814                 :            : 
     815                 :            :    The function actually replaces IN_ENCODER by new one.  The reason is that
     816                 :            :    streaming code needs clone's origin to be streamed before clone.  This
     817                 :            :    means that we need to insert the nodes in specific order.  This order is
     818                 :            :    ignored by the partitioning logic earlier.  */
     819                 :            : 
     820                 :            : lto_symtab_encoder_t 
     821                 :      21838 : compute_ltrans_boundary (lto_symtab_encoder_t in_encoder)
     822                 :            : {
     823                 :      21838 :   struct cgraph_edge *edge;
     824                 :      21838 :   int i;
     825                 :      21838 :   lto_symtab_encoder_t encoder;
     826                 :      21838 :   lto_symtab_encoder_iterator lsei;
     827                 :      21838 :   hash_set<void *> reachable_call_targets;
     828                 :            : 
     829                 :      21838 :   encoder = lto_symtab_encoder_new (false);
     830                 :            : 
     831                 :            :   /* Go over all entries in the IN_ENCODER and duplicate them to
     832                 :            :      ENCODER. At the same time insert masters of clones so
     833                 :            :      every master appears before clone.  */
     834                 :     148534 :   for (lsei = lsei_start_function_in_partition (in_encoder);
     835                 :     423553 :        !lsei_end_p (lsei); lsei_next_function_in_partition (&lsei))
     836                 :            :     {
     837                 :     126696 :       struct cgraph_node *node = lsei_cgraph_node (lsei);
     838                 :     126696 :       if (!node->need_lto_streaming)
     839                 :          0 :         continue;
     840                 :     126696 :       add_node_to (encoder, node, true);
     841                 :     126696 :       lto_set_symtab_encoder_in_partition (encoder, node);
     842                 :     126696 :       create_references (encoder, node);
     843                 :            :     }
     844                 :     291146 :   for (lsei = lsei_start_variable_in_partition (in_encoder);
     845                 :     851389 :        !lsei_end_p (lsei); lsei_next_variable_in_partition (&lsei))
     846                 :            :     {
     847                 :     269308 :       varpool_node *vnode = lsei_varpool_node (lsei);
     848                 :            : 
     849                 :     269308 :       if (!vnode->need_lto_streaming)
     850                 :          0 :         continue;
     851                 :     269308 :       lto_set_symtab_encoder_in_partition (encoder, vnode);
     852                 :     269308 :       lto_set_symtab_encoder_encode_initializer (encoder, vnode);
     853                 :     269308 :       create_references (encoder, vnode);
     854                 :            :     }
     855                 :            :   /* Pickle in also the initializer of all referenced readonly variables
     856                 :            :      to help folding.  Constant pool variables are not shared, so we must
     857                 :            :      pickle those too.  */
     858                 :    1248660 :   for (i = 0; i < lto_symtab_encoder_size (encoder); i++)
     859                 :            :     {
     860                 :    1205190 :       symtab_node *node = lto_symtab_encoder_deref (encoder, i);
     861                 :    1205190 :       if (varpool_node *vnode = dyn_cast <varpool_node *> (node))
     862                 :            :         {
     863                 :     272930 :           if (!lto_symtab_encoder_encode_initializer_p (encoder,
     864                 :            :                                                         vnode)
     865                 :     272930 :               && (((vnode->ctor_useable_for_folding_p ()
     866                 :        149 :                    && (!DECL_VIRTUAL_P (vnode->decl)
     867                 :        125 :                        || !flag_wpa
     868                 :         12 :                        || flag_ltrans_devirtualize)))))
     869                 :            :             {
     870                 :        137 :               lto_set_symtab_encoder_encode_initializer (encoder, vnode);
     871                 :        137 :               create_references (encoder, vnode);
     872                 :            :             }
     873                 :            :        }
     874                 :            :     }
     875                 :            : 
     876                 :            :   /* Go over all the nodes again to include callees that are not in
     877                 :            :      SET.  */
     878                 :     148534 :   for (lsei = lsei_start_function_in_partition (encoder);
     879                 :     423553 :        !lsei_end_p (lsei); lsei_next_function_in_partition (&lsei))
     880                 :            :     {
     881                 :     126696 :       struct cgraph_node *node = lsei_cgraph_node (lsei);
     882                 :     451282 :       for (edge = node->callees; edge; edge = edge->next_callee)
     883                 :            :         {
     884                 :     324586 :           struct cgraph_node *callee = edge->callee;
     885                 :     324586 :           if (!lto_symtab_encoder_in_partition_p (encoder, callee))
     886                 :            :             {
     887                 :            :               /* We should have moved all the inlines.  */
     888                 :     179895 :               gcc_assert (!callee->inlined_to);
     889                 :     179895 :               add_node_to (encoder, callee, false);
     890                 :            :             }
     891                 :            :         }
     892                 :            :       /* Add all possible targets for late devirtualization.  */
     893                 :     126696 :       if (flag_ltrans_devirtualize || !flag_wpa)
     894                 :      89902 :         for (edge = node->indirect_calls; edge; edge = edge->next_callee)
     895                 :       1561 :           if (edge->indirect_info->polymorphic)
     896                 :            :             {
     897                 :        361 :               unsigned int i;
     898                 :        361 :               void *cache_token;
     899                 :        361 :               bool final;
     900                 :        361 :               vec <cgraph_node *>targets
     901                 :            :                 = possible_polymorphic_call_targets
     902                 :        361 :                     (edge, &final, &cache_token);
     903                 :        361 :               if (!reachable_call_targets.add (cache_token))
     904                 :            :                 {
     905                 :       1180 :                   for (i = 0; i < targets.length (); i++)
     906                 :            :                     {
     907                 :        336 :                       struct cgraph_node *callee = targets[i];
     908                 :            : 
     909                 :            :                       /* Adding an external declarations into the unit serves
     910                 :            :                          no purpose and just increases its boundary.  */
     911                 :        336 :                       if (callee->definition
     912                 :        219 :                           && !lto_symtab_encoder_in_partition_p
     913                 :        336 :                                (encoder, callee))
     914                 :            :                         {
     915                 :          0 :                           gcc_assert (!callee->inlined_to);
     916                 :          0 :                           add_node_to (encoder, callee, false);
     917                 :            :                         }
     918                 :            :                     }
     919                 :            :                 }
     920                 :            :             }
     921                 :            :     }
     922                 :            :   /* Be sure to also insert alias targert and thunk callees.  These needs
     923                 :            :      to stay to aid local calling conventions.  */
     924                 :    1317200 :   for (i = 0; i < lto_symtab_encoder_size (encoder); i++)
     925                 :            :     {
     926                 :    1273740 :       symtab_node *node = lto_symtab_encoder_deref (encoder, i);
     927                 :     636869 :       cgraph_node *cnode = dyn_cast <cgraph_node *> (node);
     928                 :            : 
     929                 :     636869 :       if (node->alias && node->analyzed)
     930                 :      12601 :         create_references (encoder, node);
     931                 :     636869 :       if (cnode
     932                 :     363937 :           && cnode->thunk.thunk_p && !cnode->inlined_to)
     933                 :        193 :         add_node_to (encoder, cnode->callees->callee, false);
     934                 :     636880 :       while (node->transparent_alias && node->analyzed)
     935                 :            :         {
     936                 :         11 :           node = node->get_alias_target ();
     937                 :         11 :           if (is_a <cgraph_node *> (node))
     938                 :         11 :             add_node_to (encoder, dyn_cast <cgraph_node *> (node),
     939                 :            :                          false);
     940                 :            :           else
     941                 :          0 :             lto_symtab_encoder_encode (encoder, node);
     942                 :            :         }
     943                 :            :     }
     944                 :      21838 :   lto_symtab_encoder_delete (in_encoder);
     945                 :      21838 :   return encoder;
     946                 :            : }
     947                 :            : 
     948                 :            : /* Output the part of the symtab in SET and VSET.  */
     949                 :            : 
     950                 :            : void
     951                 :      21838 : output_symtab (void)
     952                 :            : {
     953                 :      21838 :   struct cgraph_node *node;
     954                 :      21838 :   struct lto_simple_output_block *ob;
     955                 :      21838 :   int i, n_nodes;
     956                 :      21838 :   lto_symtab_encoder_t encoder;
     957                 :            : 
     958                 :      21838 :   if (flag_wpa)
     959                 :       5356 :     output_cgraph_opt_summary ();
     960                 :            : 
     961                 :      21838 :   ob = lto_create_simple_output_block (LTO_section_symtab_nodes);
     962                 :            : 
     963                 :      21838 :   output_profile_summary (ob);
     964                 :            : 
     965                 :            :   /* An encoder for cgraph nodes should have been created by
     966                 :            :      ipa_write_summaries_1.  */
     967                 :      21838 :   gcc_assert (ob->decl_state->symtab_node_encoder);
     968                 :      21838 :   encoder = ob->decl_state->symtab_node_encoder;
     969                 :            : 
     970                 :            :   /* Write out the nodes.  We must first output a node and then its clones,
     971                 :            :      otherwise at a time reading back the node there would be nothing to clone
     972                 :            :      from.  */
     973                 :      21838 :   n_nodes = lto_symtab_encoder_size (encoder);
     974                 :     658707 :   for (i = 0; i < n_nodes; i++)
     975                 :            :     {
     976                 :     909801 :       symtab_node *node = lto_symtab_encoder_deref (encoder, i);
     977                 :     636869 :       if (cgraph_node *cnode = dyn_cast <cgraph_node *> (node))
     978                 :     363937 :         lto_output_node (ob, cnode, encoder);
     979                 :            :       else
     980                 :     545864 :         lto_output_varpool_node (ob, dyn_cast<varpool_node *> (node), encoder);
     981                 :            :     }
     982                 :            : 
     983                 :            :   /* Go over the nodes in SET again to write edges.  */
     984                 :    1317200 :   for (int i = 0; i < lto_symtab_encoder_size (encoder); i++)
     985                 :            :     {
     986                 :    1273740 :       node = dyn_cast <cgraph_node *> (lto_symtab_encoder_deref (encoder, i));
     987                 :     363937 :       if (node
     988                 :     363937 :           && ((node->thunk.thunk_p && !node->inlined_to)
     989                 :     363744 :               || lto_symtab_encoder_in_partition_p (encoder, node)))
     990                 :            :         {
     991                 :     126700 :           output_outgoing_cgraph_edges (node->callees, ob, encoder);
     992                 :     126700 :           output_outgoing_cgraph_edges (node->indirect_calls, ob, encoder);
     993                 :            :         }
     994                 :            :     }
     995                 :            : 
     996                 :      21838 :   streamer_write_uhwi_stream (ob->main_stream, 0);
     997                 :            : 
     998                 :      21838 :   lto_destroy_simple_output_block (ob);
     999                 :            : 
    1000                 :            :   /* Emit toplevel asms.
    1001                 :            :      When doing WPA we must output every asm just once.  Since we do not partition asm
    1002                 :            :      nodes at all, output them to first output.  This is kind of hack, but should work
    1003                 :            :      well.  */
    1004                 :      21838 :   if (!asm_nodes_output)
    1005                 :            :     {
    1006                 :      21504 :       asm_nodes_output = true;
    1007                 :      21504 :       lto_output_toplevel_asms ();
    1008                 :            :     }
    1009                 :            : 
    1010                 :      21838 :   output_refs (encoder);
    1011                 :      21838 : }
    1012                 :            : 
    1013                 :            : /* Return identifier encoded in IB as a plain string.  */
    1014                 :            : 
    1015                 :            : static tree
    1016                 :     205478 : read_identifier (class lto_input_block *ib)
    1017                 :            : {
    1018                 :     205478 :   unsigned int len = strnlen (ib->data + ib->p, ib->len - ib->p - 1);
    1019                 :     205478 :   tree id;
    1020                 :            : 
    1021                 :     205478 :   if (ib->data[ib->p + len])
    1022                 :          0 :     lto_section_overrun (ib);
    1023                 :     205478 :   if (!len)
    1024                 :            :     {
    1025                 :     195059 :       ib->p++;
    1026                 :     195059 :       return NULL;
    1027                 :            :     }
    1028                 :      10419 :   id = get_identifier (ib->data + ib->p);
    1029                 :      10419 :   ib->p += len + 1;
    1030                 :      10419 :   return id;
    1031                 :            : }
    1032                 :            : 
    1033                 :            : /* Return string encoded in IB, NULL if string is empty.  */
    1034                 :            : 
    1035                 :            : static const char *
    1036                 :     205478 : read_string (class lto_input_block *ib)
    1037                 :            : {
    1038                 :     205478 :   unsigned int len = strnlen (ib->data + ib->p, ib->len - ib->p - 1);
    1039                 :     205478 :   const char *str;
    1040                 :            : 
    1041                 :     205478 :   if (ib->data[ib->p + len])
    1042                 :          0 :     lto_section_overrun (ib);
    1043                 :     205478 :   if (!len)
    1044                 :            :     {
    1045                 :     203602 :       ib->p++;
    1046                 :     203602 :       return NULL;
    1047                 :            :     }
    1048                 :       1876 :   str = ib->data + ib->p;
    1049                 :       1876 :   ib->p += len + 1;
    1050                 :       1876 :   return str;
    1051                 :            : }
    1052                 :            : 
    1053                 :            : /* Output function/variable tables that will allow libgomp to look up offload
    1054                 :            :    target code.
    1055                 :            :    OFFLOAD_FUNCS is filled in expand_omp_target, OFFLOAD_VARS is filled in
    1056                 :            :    varpool_node::get_create.  In WHOPR (partitioned) mode during the WPA stage
    1057                 :            :    both OFFLOAD_FUNCS and OFFLOAD_VARS are filled by input_offload_tables.  */
    1058                 :            : 
    1059                 :            : void
    1060                 :      21838 : output_offload_tables (void)
    1061                 :            : {
    1062                 :      21838 :   if (vec_safe_is_empty (offload_funcs) && vec_safe_is_empty (offload_vars))
    1063                 :            :     return;
    1064                 :            : 
    1065                 :          0 :   struct lto_simple_output_block *ob
    1066                 :          0 :     = lto_create_simple_output_block (LTO_section_offload_table);
    1067                 :            : 
    1068                 :          0 :   for (unsigned i = 0; i < vec_safe_length (offload_funcs); i++)
    1069                 :            :     {
    1070                 :          0 :       streamer_write_enum (ob->main_stream, LTO_symtab_tags,
    1071                 :            :                            LTO_symtab_last_tag, LTO_symtab_unavail_node);
    1072                 :          0 :       lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
    1073                 :          0 :                                 (*offload_funcs)[i]);
    1074                 :            :     }
    1075                 :            : 
    1076                 :          0 :   for (unsigned i = 0; i < vec_safe_length (offload_vars); i++)
    1077                 :            :     {
    1078                 :          0 :       streamer_write_enum (ob->main_stream, LTO_symtab_tags,
    1079                 :            :                            LTO_symtab_last_tag, LTO_symtab_variable);
    1080                 :          0 :       lto_output_var_decl_index (ob->decl_state, ob->main_stream,
    1081                 :          0 :                                  (*offload_vars)[i]);
    1082                 :            :     }
    1083                 :            : 
    1084                 :          0 :   streamer_write_uhwi_stream (ob->main_stream, 0);
    1085                 :          0 :   lto_destroy_simple_output_block (ob);
    1086                 :            : 
    1087                 :            :   /* In WHOPR mode during the WPA stage the joint offload tables need to be
    1088                 :            :      streamed to one partition only.  That's why we free offload_funcs and
    1089                 :            :      offload_vars after the first call of output_offload_tables.  */
    1090                 :          0 :   if (flag_wpa)
    1091                 :            :     {
    1092                 :          0 :       vec_free (offload_funcs);
    1093                 :          0 :       vec_free (offload_vars);
    1094                 :            :     }
    1095                 :            : }
    1096                 :            : 
    1097                 :            : /* Verify the partitioning of NODE.  */
    1098                 :            : 
    1099                 :            : static inline void
    1100                 :     205478 : verify_node_partition (symtab_node *node)
    1101                 :            : {
    1102                 :     205478 :   if (flag_ltrans)
    1103                 :            :     return;
    1104                 :            : 
    1105                 :            : #ifdef ACCEL_COMPILER
    1106                 :            :   if (node->in_other_partition)
    1107                 :            :     {
    1108                 :            :       if (TREE_CODE (node->decl) == FUNCTION_DECL)
    1109                 :            :         error_at (DECL_SOURCE_LOCATION (node->decl),
    1110                 :            :                   "function %qs has been referenced in offloaded code but"
    1111                 :            :                   " hasn%'t been marked to be included in the offloaded code",
    1112                 :            :                   node->name ());
    1113                 :            :       else if (VAR_P (node->decl))
    1114                 :            :         error_at (DECL_SOURCE_LOCATION (node->decl),
    1115                 :            :                   "variable %qs has been referenced in offloaded code but"
    1116                 :            :                   " hasn%'t been marked to be included in the offloaded code",
    1117                 :            :                   node->name ());
    1118                 :            :       else
    1119                 :            :         gcc_unreachable ();
    1120                 :            :     }
    1121                 :            : #else
    1122                 :     134052 :   gcc_assert (!node->in_other_partition
    1123                 :            :               && !node->used_from_other_partition);
    1124                 :            : #endif
    1125                 :            : }
    1126                 :            : 
    1127                 :            : /* Overwrite the information in NODE based on FILE_DATA, TAG, FLAGS,
    1128                 :            :    STACK_SIZE, SELF_TIME and SELF_SIZE.  This is called either to initialize
    1129                 :            :    NODE or to replace the values in it, for instance because the first
    1130                 :            :    time we saw it, the function body was not available but now it
    1131                 :            :    is.  BP is a bitpack with all the bitflags for NODE read from the
    1132                 :            :    stream.  */
    1133                 :            : 
    1134                 :            : static void
    1135                 :     144624 : input_overwrite_node (struct lto_file_decl_data *file_data,
    1136                 :            :                       struct cgraph_node *node,
    1137                 :            :                       enum LTO_symtab_tags tag,
    1138                 :            :                       struct bitpack_d *bp)
    1139                 :            : {
    1140                 :     144624 :   node->aux = (void *) tag;
    1141                 :     144624 :   node->lto_file_data = file_data;
    1142                 :            : 
    1143                 :     144624 :   node->local = bp_unpack_value (bp, 1);
    1144                 :     144624 :   node->externally_visible = bp_unpack_value (bp, 1);
    1145                 :     144624 :   node->no_reorder = bp_unpack_value (bp, 1);
    1146                 :     144624 :   node->definition = bp_unpack_value (bp, 1);
    1147                 :     144624 :   node->versionable = bp_unpack_value (bp, 1);
    1148                 :     144624 :   node->can_change_signature = bp_unpack_value (bp, 1);
    1149                 :     144624 :   node->redefined_extern_inline = bp_unpack_value (bp, 1);
    1150                 :     144624 :   node->force_output = bp_unpack_value (bp, 1);
    1151                 :     144624 :   node->forced_by_abi = bp_unpack_value (bp, 1);
    1152                 :     144624 :   node->unique_name = bp_unpack_value (bp, 1);
    1153                 :     144624 :   node->body_removed = bp_unpack_value (bp, 1);
    1154                 :     144624 :   node->implicit_section = bp_unpack_value (bp, 1);
    1155                 :     144624 :   node->address_taken = bp_unpack_value (bp, 1);
    1156                 :     144624 :   node->used_from_other_partition = bp_unpack_value (bp, 1);
    1157                 :     144624 :   node->lowered = bp_unpack_value (bp, 1);
    1158                 :     144624 :   node->analyzed = tag == LTO_symtab_analyzed_node;
    1159                 :     144624 :   node->in_other_partition = bp_unpack_value (bp, 1);
    1160                 :     144624 :   if (node->in_other_partition
    1161                 :            :       /* Avoid updating decl when we are seeing just inline clone.
    1162                 :            :          When inlining function that has functions already inlined into it,
    1163                 :            :          we produce clones of inline clones.
    1164                 :            : 
    1165                 :            :          WPA partitioning might put each clone into different unit and
    1166                 :            :          we might end up streaming inline clone from other partition
    1167                 :            :          to support clone we are interested in. */
    1168                 :        204 :       && (!node->clone_of
    1169                 :     144624 :           || node->clone_of->decl != node->decl))
    1170                 :            :     {
    1171                 :        204 :       DECL_EXTERNAL (node->decl) = 1;
    1172                 :        204 :       TREE_STATIC (node->decl) = 0;
    1173                 :            :     }
    1174                 :     144624 :   node->alias = bp_unpack_value (bp, 1);
    1175                 :     144624 :   node->transparent_alias = bp_unpack_value (bp, 1);
    1176                 :     144624 :   node->weakref = bp_unpack_value (bp, 1);
    1177                 :     144624 :   node->symver = bp_unpack_value (bp, 1);
    1178                 :     144624 :   node->frequency = (enum node_frequency)bp_unpack_value (bp, 2);
    1179                 :     144624 :   node->only_called_at_startup = bp_unpack_value (bp, 1);
    1180                 :     144624 :   node->only_called_at_exit = bp_unpack_value (bp, 1);
    1181                 :     144624 :   node->tm_clone = bp_unpack_value (bp, 1);
    1182                 :     144624 :   node->calls_comdat_local = bp_unpack_value (bp, 1);
    1183                 :     144624 :   node->icf_merged = bp_unpack_value (bp, 1);
    1184                 :     144624 :   node->nonfreeing_fn = bp_unpack_value (bp, 1);
    1185                 :     144624 :   node->merged_comdat = bp_unpack_value (bp, 1);
    1186                 :     144624 :   node->merged_extern_inline = bp_unpack_value (bp, 1);
    1187                 :     144624 :   node->thunk.thunk_p = bp_unpack_value (bp, 1);
    1188                 :     144624 :   node->parallelized_function = bp_unpack_value (bp, 1);
    1189                 :     144624 :   node->resolution = bp_unpack_enum (bp, ld_plugin_symbol_resolution,
    1190                 :            :                                      LDPR_NUM_KNOWN);
    1191                 :     144624 :   node->split_part = bp_unpack_value (bp, 1);
    1192                 :     144624 :   verify_node_partition (node);
    1193                 :     144624 : }
    1194                 :            : 
    1195                 :            : /* Return string alias is alias of.  */
    1196                 :            : 
    1197                 :            : static tree
    1198                 :         28 : get_alias_symbol (tree decl)
    1199                 :            : {
    1200                 :         28 :   tree alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl));
    1201                 :         28 :   return get_identifier (TREE_STRING_POINTER
    1202                 :            :                           (TREE_VALUE (TREE_VALUE (alias))));
    1203                 :            : }
    1204                 :            : 
    1205                 :            : /* Read a node from input_block IB.  TAG is the node's tag just read.
    1206                 :            :    Return the node read or overwriten.  */
    1207                 :            : 
    1208                 :            : static struct cgraph_node *
    1209                 :     144624 : input_node (struct lto_file_decl_data *file_data,
    1210                 :            :             class lto_input_block *ib,
    1211                 :            :             enum LTO_symtab_tags tag,
    1212                 :            :             vec<symtab_node *> nodes)
    1213                 :            : {
    1214                 :     144624 :   gcc::pass_manager *passes = g->get_passes ();
    1215                 :     144624 :   tree fn_decl;
    1216                 :     144624 :   struct cgraph_node *node;
    1217                 :     144624 :   struct bitpack_d bp;
    1218                 :     144624 :   unsigned decl_index;
    1219                 :     144624 :   int ref = LCC_NOT_FOUND, ref2 = LCC_NOT_FOUND;
    1220                 :     144624 :   int clone_ref;
    1221                 :     144624 :   int order;
    1222                 :     144624 :   int i, count;
    1223                 :     144624 :   tree group;
    1224                 :     144624 :   const char *section;
    1225                 :     144624 :   order = streamer_read_hwi (ib) + file_data->order_base;
    1226                 :     144624 :   clone_ref = streamer_read_hwi (ib);
    1227                 :            : 
    1228                 :     144624 :   decl_index = streamer_read_uhwi (ib);
    1229                 :     144624 :   fn_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
    1230                 :            : 
    1231                 :     144624 :   if (clone_ref != LCC_NOT_FOUND)
    1232                 :            :     {
    1233                 :       4444 :       node = dyn_cast<cgraph_node *> (nodes[clone_ref])->create_clone (fn_decl,
    1234                 :            :         profile_count::uninitialized (), false,
    1235                 :            :         vNULL, false, NULL, NULL);
    1236                 :            :     }
    1237                 :            :   else
    1238                 :            :     {
    1239                 :            :       /* Declaration of functions can be already merged with a declaration
    1240                 :            :          from other input file.  We keep cgraph unmerged until after streaming
    1241                 :            :          of ipa passes is done.  Alays forcingly create a fresh node.  */
    1242                 :     142402 :       node = symtab->create_empty ();
    1243                 :     142402 :       node->decl = fn_decl;
    1244                 :     142402 :       if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (fn_decl)))
    1245                 :         20 :         node->ifunc_resolver = 1;
    1246                 :     142402 :       node->register_symbol ();
    1247                 :            :     }
    1248                 :            : 
    1249                 :     144624 :   node->order = order;
    1250                 :     144624 :   if (order >= symtab->order)
    1251                 :      16672 :     symtab->order = order + 1;
    1252                 :            : 
    1253                 :     144624 :   node->count = profile_count::stream_in (ib);
    1254                 :     144624 :   node->count_materialization_scale = streamer_read_hwi (ib);
    1255                 :            : 
    1256                 :     144624 :   count = streamer_read_hwi (ib);
    1257                 :     144624 :   node->ipa_transforms_to_apply = vNULL;
    1258                 :     202190 :   for (i = 0; i < count; i++)
    1259                 :            :     {
    1260                 :      57566 :       opt_pass *pass;
    1261                 :      57566 :       int pid = streamer_read_hwi (ib);
    1262                 :            : 
    1263                 :      57566 :       gcc_assert (pid < passes->passes_by_id_size);
    1264                 :      57566 :       pass = passes->passes_by_id[pid];
    1265                 :      57566 :       node->ipa_transforms_to_apply.safe_push ((ipa_opt_pass_d *) pass);
    1266                 :            :     }
    1267                 :            : 
    1268                 :     144624 :   if (tag == LTO_symtab_analyzed_node)
    1269                 :     114263 :     ref = streamer_read_hwi (ib);
    1270                 :            : 
    1271                 :     144624 :   group = read_identifier (ib);
    1272                 :     144624 :   if (group)
    1273                 :       7924 :     ref2 = streamer_read_hwi (ib);
    1274                 :            : 
    1275                 :            :   /* Make sure that we have not read this node before.  Nodes that
    1276                 :            :      have already been read will have their tag stored in the 'aux'
    1277                 :            :      field.  Since built-in functions can be referenced in multiple
    1278                 :            :      functions, they are expected to be read more than once.  */
    1279                 :     144624 :   if (node->aux && !fndecl_built_in_p (node->decl))
    1280                 :          0 :     internal_error ("bytecode stream: found multiple instances of cgraph "
    1281                 :            :                     "node with uid %d", node->get_uid ());
    1282                 :            : 
    1283                 :     144624 :   node->tp_first_run = streamer_read_uhwi (ib);
    1284                 :            : 
    1285                 :     144624 :   bp = streamer_read_bitpack (ib);
    1286                 :            : 
    1287                 :     144624 :   input_overwrite_node (file_data, node, tag, &bp);
    1288                 :            : 
    1289                 :            :   /* Store a reference for now, and fix up later to be a pointer.  */
    1290                 :     144624 :   node->inlined_to = (cgraph_node *) (intptr_t) ref;
    1291                 :            : 
    1292                 :     144624 :   if (group)
    1293                 :            :     {
    1294                 :       7924 :       node->set_comdat_group (group);
    1295                 :            :       /* Store a reference for now, and fix up later to be a pointer.  */
    1296                 :       7924 :       node->same_comdat_group = (symtab_node *) (intptr_t) ref2;
    1297                 :            :     }
    1298                 :            :   else
    1299                 :     136700 :     node->same_comdat_group = (symtab_node *) (intptr_t) LCC_NOT_FOUND;
    1300                 :     144624 :   section = read_string (ib);
    1301                 :     144624 :   if (section)
    1302                 :        232 :     node->set_section_for_node (section);
    1303                 :            : 
    1304                 :     144624 :   if (node->definition)
    1305                 :            :     {
    1306                 :     114457 :       int type = streamer_read_uhwi (ib);
    1307                 :     114457 :       HOST_WIDE_INT fixed_offset = streamer_read_uhwi (ib);
    1308                 :     114457 :       HOST_WIDE_INT virtual_value = streamer_read_uhwi (ib);
    1309                 :     114457 :       HOST_WIDE_INT indirect_offset = streamer_read_uhwi (ib);
    1310                 :            : 
    1311                 :     114457 :       node->thunk.fixed_offset = fixed_offset;
    1312                 :     114457 :       node->thunk.virtual_value = virtual_value;
    1313                 :     114457 :       node->thunk.indirect_offset = indirect_offset;
    1314                 :     114457 :       node->thunk.this_adjusting = (type & 2);
    1315                 :     114457 :       node->thunk.virtual_offset_p = (type & 4);
    1316                 :            :     }
    1317                 :     144624 :   if (node->alias && !node->analyzed && node->weakref)
    1318                 :         28 :     node->alias_target = get_alias_symbol (node->decl);
    1319                 :     144624 :   node->profile_id = streamer_read_hwi (ib);
    1320                 :     144624 :   node->unit_id = streamer_read_hwi (ib) + file_data->unit_base;
    1321                 :     144624 :   if (symtab->max_unit < node->unit_id)
    1322                 :      14871 :     symtab->max_unit = node->unit_id;
    1323                 :     144624 :   if (DECL_STATIC_CONSTRUCTOR (node->decl))
    1324                 :        134 :     node->set_init_priority (streamer_read_hwi (ib));
    1325                 :     144624 :   if (DECL_STATIC_DESTRUCTOR (node->decl))
    1326                 :         26 :     node->set_fini_priority (streamer_read_hwi (ib));
    1327                 :            : 
    1328                 :     144624 :   return node;
    1329                 :            : }
    1330                 :            : 
    1331                 :            : /* Read a node from input_block IB.  TAG is the node's tag just read.
    1332                 :            :    Return the node read or overwriten.  */
    1333                 :            : 
    1334                 :            : static varpool_node *
    1335                 :      60854 : input_varpool_node (struct lto_file_decl_data *file_data,
    1336                 :            :                     class lto_input_block *ib)
    1337                 :            : {
    1338                 :      60854 :   int decl_index;
    1339                 :      60854 :   tree var_decl;
    1340                 :      60854 :   varpool_node *node;
    1341                 :      60854 :   struct bitpack_d bp;
    1342                 :      60854 :   int ref = LCC_NOT_FOUND;
    1343                 :      60854 :   int order;
    1344                 :      60854 :   tree group;
    1345                 :      60854 :   const char *section;
    1346                 :            : 
    1347                 :      60854 :   order = streamer_read_hwi (ib) + file_data->order_base;
    1348                 :      60854 :   decl_index = streamer_read_uhwi (ib);
    1349                 :      60854 :   var_decl = lto_file_decl_data_get_var_decl (file_data, decl_index);
    1350                 :            : 
    1351                 :            :   /* Declaration of functions can be already merged with a declaration
    1352                 :            :      from other input file.  We keep cgraph unmerged until after streaming
    1353                 :            :      of ipa passes is done.  Alays forcingly create a fresh node.  */
    1354                 :      60854 :   node = varpool_node::create_empty ();
    1355                 :      60854 :   node->decl = var_decl;
    1356                 :      60854 :   node->register_symbol ();
    1357                 :            : 
    1358                 :      60854 :   node->order = order;
    1359                 :      60854 :   if (order >= symtab->order)
    1360                 :       1690 :     symtab->order = order + 1;
    1361                 :      60854 :   node->lto_file_data = file_data;
    1362                 :            : 
    1363                 :      60854 :   bp = streamer_read_bitpack (ib);
    1364                 :      60854 :   node->externally_visible = bp_unpack_value (&bp, 1);
    1365                 :      60854 :   node->no_reorder = bp_unpack_value (&bp, 1);
    1366                 :      60854 :   node->force_output = bp_unpack_value (&bp, 1);
    1367                 :      60854 :   node->forced_by_abi = bp_unpack_value (&bp, 1);
    1368                 :      60854 :   node->unique_name = bp_unpack_value (&bp, 1);
    1369                 :      60854 :   node->body_removed = bp_unpack_value (&bp, 1);
    1370                 :      60854 :   node->implicit_section = bp_unpack_value (&bp, 1);
    1371                 :      60854 :   node->writeonly = bp_unpack_value (&bp, 1);
    1372                 :      60854 :   node->definition = bp_unpack_value (&bp, 1);
    1373                 :      60854 :   node->alias = bp_unpack_value (&bp, 1);
    1374                 :      60854 :   node->transparent_alias = bp_unpack_value (&bp, 1);
    1375                 :      60854 :   node->weakref = bp_unpack_value (&bp, 1);
    1376                 :      60854 :   node->symver = bp_unpack_value (&bp, 1);
    1377                 :      60854 :   node->analyzed = bp_unpack_value (&bp, 1);
    1378                 :      60854 :   node->used_from_other_partition = bp_unpack_value (&bp, 1);
    1379                 :      60854 :   node->in_other_partition = bp_unpack_value (&bp, 1);
    1380                 :      60854 :   if (node->in_other_partition)
    1381                 :            :     {
    1382                 :        188 :       DECL_EXTERNAL (node->decl) = 1;
    1383                 :        188 :       TREE_STATIC (node->decl) = 0;
    1384                 :            :     }
    1385                 :      60854 :   if (node->alias && !node->analyzed && node->weakref)
    1386                 :          0 :     node->alias_target = get_alias_symbol (node->decl);
    1387                 :      60854 :   node->tls_model = (enum tls_model)bp_unpack_value (&bp, 3);
    1388                 :      60854 :   node->used_by_single_function = (enum tls_model)bp_unpack_value (&bp, 1);
    1389                 :      60854 :   node->dynamically_initialized = bp_unpack_value (&bp, 1);
    1390                 :      60854 :   group = read_identifier (ib);
    1391                 :      60854 :   if (group)
    1392                 :            :     {
    1393                 :       2495 :       node->set_comdat_group (group);
    1394                 :       2495 :       ref = streamer_read_hwi (ib);
    1395                 :            :       /* Store a reference for now, and fix up later to be a pointer.  */
    1396                 :       2495 :       node->same_comdat_group = (symtab_node *) (intptr_t) ref;
    1397                 :            :     }
    1398                 :            :   else
    1399                 :      58359 :     node->same_comdat_group = (symtab_node *) (intptr_t) LCC_NOT_FOUND;
    1400                 :      60854 :   section = read_string (ib);
    1401                 :      60854 :   if (section)
    1402                 :       1644 :     node->set_section_for_node (section);
    1403                 :      60854 :   node->resolution = streamer_read_enum (ib, ld_plugin_symbol_resolution,
    1404                 :            :                                                 LDPR_NUM_KNOWN);
    1405                 :      60854 :   verify_node_partition (node);
    1406                 :      60854 :   return node;
    1407                 :            : }
    1408                 :            : 
    1409                 :            : /* Read a node from input_block IB.  TAG is the node's tag just read.
    1410                 :            :    Return the node read or overwriten.  */
    1411                 :            : 
    1412                 :            : static void
    1413                 :     244704 : input_ref (class lto_input_block *ib,
    1414                 :            :            symtab_node *referring_node,
    1415                 :            :            vec<symtab_node *> nodes)
    1416                 :            : {
    1417                 :     244704 :   symtab_node *node = NULL;
    1418                 :     244704 :   struct bitpack_d bp;
    1419                 :     244704 :   enum ipa_ref_use use;
    1420                 :     244704 :   bool speculative;
    1421                 :     244704 :   struct ipa_ref *ref;
    1422                 :            : 
    1423                 :     244704 :   bp = streamer_read_bitpack (ib);
    1424                 :     244704 :   use = (enum ipa_ref_use) bp_unpack_value (&bp, 3);
    1425                 :     244704 :   speculative = (enum ipa_ref_use) bp_unpack_value (&bp, 1);
    1426                 :     244704 :   node = nodes[streamer_read_hwi (ib)];
    1427                 :     244704 :   ref = referring_node->create_reference (node, use);
    1428                 :     244704 :   ref->speculative = speculative;
    1429                 :     244704 :   if (is_a <cgraph_node *> (referring_node))
    1430                 :            :     {
    1431                 :     218278 :       ref->lto_stmt_uid = streamer_read_hwi (ib);
    1432                 :     218278 :       bp = streamer_read_bitpack (ib);
    1433                 :     218278 :       ref->speculative_id = bp_unpack_value (&bp, 16);
    1434                 :            :     }
    1435                 :     244704 : }
    1436                 :            : 
    1437                 :            : /* Read an edge from IB.  NODES points to a vector of previously read nodes for
    1438                 :            :    decoding caller and callee of the edge to be read.  If INDIRECT is true, the
    1439                 :            :    edge being read is indirect (in the sense that it has
    1440                 :            :    indirect_unknown_callee set).  */
    1441                 :            : 
    1442                 :            : static void
    1443                 :     299994 : input_edge (class lto_input_block *ib, vec<symtab_node *> nodes,
    1444                 :            :             bool indirect)
    1445                 :            : {
    1446                 :     299994 :   struct cgraph_node *caller, *callee;
    1447                 :     299994 :   struct cgraph_edge *edge;
    1448                 :     299994 :   unsigned int stmt_id, speculative_id;
    1449                 :     299994 :   profile_count count;
    1450                 :     299994 :   cgraph_inline_failed_t inline_failed;
    1451                 :     299994 :   struct bitpack_d bp;
    1452                 :     299994 :   int ecf_flags = 0;
    1453                 :            : 
    1454                 :     299994 :   caller = dyn_cast<cgraph_node *> (nodes[streamer_read_hwi (ib)]);
    1455                 :     299994 :   if (caller == NULL || caller->decl == NULL_TREE)
    1456                 :          0 :     internal_error ("bytecode stream: no caller found while reading edge");
    1457                 :            : 
    1458                 :     299994 :   if (!indirect)
    1459                 :            :     {
    1460                 :     298299 :       callee = dyn_cast<cgraph_node *> (nodes[streamer_read_hwi (ib)]);
    1461                 :     298299 :       if (callee == NULL || callee->decl == NULL_TREE)
    1462                 :          0 :         internal_error ("bytecode stream: no callee found while reading edge");
    1463                 :            :     }
    1464                 :            :   else
    1465                 :            :     callee = NULL;
    1466                 :            : 
    1467                 :     299994 :   count = profile_count::stream_in (ib);
    1468                 :            : 
    1469                 :     299994 :   bp = streamer_read_bitpack (ib);
    1470                 :     299994 :   inline_failed = bp_unpack_enum (&bp, cgraph_inline_failed_t, CIF_N_REASONS);
    1471                 :     299994 :   stmt_id = bp_unpack_var_len_unsigned (&bp);
    1472                 :     299994 :   speculative_id = bp_unpack_value (&bp, 16);
    1473                 :            : 
    1474                 :     299994 :   if (indirect)
    1475                 :       1695 :     edge = caller->create_indirect_edge (NULL, 0, count);
    1476                 :            :   else
    1477                 :     298299 :     edge = caller->create_edge (callee, NULL, count);
    1478                 :            : 
    1479                 :     299994 :   edge->indirect_inlining_edge = bp_unpack_value (&bp, 1);
    1480                 :     299994 :   edge->speculative = bp_unpack_value (&bp, 1);
    1481                 :     299994 :   edge->lto_stmt_uid = stmt_id;
    1482                 :     299994 :   edge->speculative_id = speculative_id;
    1483                 :     299994 :   edge->inline_failed = inline_failed;
    1484                 :     299994 :   edge->call_stmt_cannot_inline_p = bp_unpack_value (&bp, 1);
    1485                 :     299994 :   edge->can_throw_external = bp_unpack_value (&bp, 1);
    1486                 :     299994 :   edge->in_polymorphic_cdtor = bp_unpack_value (&bp, 1);
    1487                 :     299994 :   if (indirect)
    1488                 :            :     {
    1489                 :       1695 :       if (bp_unpack_value (&bp, 1))
    1490                 :          0 :         ecf_flags |= ECF_CONST;
    1491                 :       1695 :       if (bp_unpack_value (&bp, 1))
    1492                 :          0 :         ecf_flags |= ECF_PURE;
    1493                 :       1695 :       if (bp_unpack_value (&bp, 1))
    1494                 :          0 :         ecf_flags |= ECF_NORETURN;
    1495                 :       1695 :       if (bp_unpack_value (&bp, 1))
    1496                 :          0 :         ecf_flags |= ECF_MALLOC;
    1497                 :       1695 :       if (bp_unpack_value (&bp, 1))
    1498                 :         70 :         ecf_flags |= ECF_NOTHROW;
    1499                 :       1695 :       if (bp_unpack_value (&bp, 1))
    1500                 :          0 :         ecf_flags |= ECF_RETURNS_TWICE;
    1501                 :       1695 :       edge->indirect_info->ecf_flags = ecf_flags;
    1502                 :            : 
    1503                 :       3390 :       edge->indirect_info->num_speculative_call_targets
    1504                 :       1695 :         = bp_unpack_value (&bp, 16);
    1505                 :            :     }
    1506                 :     299994 : }
    1507                 :            : 
    1508                 :            : 
    1509                 :            : /* Read a cgraph from IB using the info in FILE_DATA.  */
    1510                 :            : 
    1511                 :            : static vec<symtab_node *> 
    1512                 :      14924 : input_cgraph_1 (struct lto_file_decl_data *file_data,
    1513                 :            :                 class lto_input_block *ib)
    1514                 :            : {
    1515                 :      14924 :   enum LTO_symtab_tags tag;
    1516                 :      14924 :   vec<symtab_node *> nodes = vNULL;
    1517                 :      14924 :   symtab_node *node;
    1518                 :      14924 :   unsigned i;
    1519                 :            : 
    1520                 :      14924 :   tag = streamer_read_enum (ib, LTO_symtab_tags, LTO_symtab_last_tag);
    1521                 :      14924 :   file_data->order_base = symtab->order;
    1522                 :      14924 :   file_data->unit_base = symtab->max_unit + 1;
    1523                 :     520396 :   while (tag)
    1524                 :            :     {
    1525                 :     505472 :       if (tag == LTO_symtab_edge)
    1526                 :     298299 :         input_edge (ib, nodes, false);
    1527                 :     207173 :       else if (tag == LTO_symtab_indirect_edge)
    1528                 :       1695 :         input_edge (ib, nodes, true);
    1529                 :     205478 :       else if (tag == LTO_symtab_variable)
    1530                 :            :         {
    1531                 :      60854 :           node = input_varpool_node (file_data, ib);
    1532                 :      60854 :           nodes.safe_push (node);
    1533                 :      60854 :           lto_symtab_encoder_encode (file_data->symtab_node_encoder, node);
    1534                 :            :         }
    1535                 :            :       else
    1536                 :            :         {
    1537                 :     144624 :           node = input_node (file_data, ib, tag, nodes);
    1538                 :     144624 :           if (node == NULL || node->decl == NULL_TREE)
    1539                 :          0 :             internal_error ("bytecode stream: found empty cgraph node");
    1540                 :     144624 :           nodes.safe_push (node);
    1541                 :     144624 :           lto_symtab_encoder_encode (file_data->symtab_node_encoder, node);
    1542                 :            :         }
    1543                 :            : 
    1544                 :     505472 :       tag = streamer_read_enum (ib, LTO_symtab_tags, LTO_symtab_last_tag);
    1545                 :            :     }
    1546                 :            : 
    1547                 :      14924 :   lto_input_toplevel_asms (file_data, file_data->order_base);
    1548                 :            : 
    1549                 :            :   /* AUX pointers should be all non-zero for function nodes read from the stream.  */
    1550                 :      14924 :   if (flag_checking)
    1551                 :            :     {
    1552                 :     235266 :       FOR_EACH_VEC_ELT (nodes, i, node)
    1553                 :     205478 :         gcc_assert (node->aux || !is_a <cgraph_node *> (node));
    1554                 :            :     }
    1555                 :     235266 :   FOR_EACH_VEC_ELT (nodes, i, node)
    1556                 :            :     {
    1557                 :     205478 :       int ref;
    1558                 :     205478 :       if (cgraph_node *cnode = dyn_cast <cgraph_node *> (node))
    1559                 :            :         {
    1560                 :     144624 :           ref = (int) (intptr_t) cnode->inlined_to;
    1561                 :            : 
    1562                 :            :           /* We share declaration of builtins, so we may read same node twice.  */
    1563                 :     144624 :           if (!node->aux)
    1564                 :          0 :             continue;
    1565                 :     144624 :           node->aux = NULL;
    1566                 :            : 
    1567                 :            :           /* Fixup inlined_to from reference to pointer.  */
    1568                 :     144624 :           if (ref != LCC_NOT_FOUND)
    1569                 :       4110 :             dyn_cast<cgraph_node *> (node)->inlined_to
    1570                 :       4110 :               = dyn_cast<cgraph_node *> (nodes[ref]);
    1571                 :            :           else
    1572                 :     142569 :             cnode->inlined_to = NULL;
    1573                 :            :         }
    1574                 :            : 
    1575                 :     205478 :       ref = (int) (intptr_t) node->same_comdat_group;
    1576                 :            : 
    1577                 :            :       /* Fixup same_comdat_group from reference to pointer.  */
    1578                 :     205478 :       if (ref != LCC_NOT_FOUND)
    1579                 :       4104 :         node->same_comdat_group = nodes[ref];
    1580                 :            :       else
    1581                 :     201374 :         node->same_comdat_group = NULL;
    1582                 :            :     }
    1583                 :     220402 :   FOR_EACH_VEC_ELT (nodes, i, node)
    1584                 :     410956 :     node->aux = is_a <cgraph_node *> (node) ? (void *)1 : NULL;
    1585                 :      14924 :   return nodes;
    1586                 :            : }
    1587                 :            : 
    1588                 :            : /* Input ipa_refs.  */
    1589                 :            : 
    1590                 :            : static void
    1591                 :      14924 : input_refs (class lto_input_block *ib,
    1592                 :            :             vec<symtab_node *> nodes)
    1593                 :            : {
    1594                 :      71915 :   int count;
    1595                 :      71915 :   int idx;
    1596                 :      71915 :   while (true)
    1597                 :            :     {
    1598                 :      71915 :       symtab_node *node;
    1599                 :      71915 :       count = streamer_read_uhwi (ib);
    1600                 :      71915 :       if (!count)
    1601                 :            :         break;
    1602                 :      56991 :       idx = streamer_read_uhwi (ib);
    1603                 :      56991 :       node = nodes[idx];
    1604                 :     301695 :       while (count)
    1605                 :            :         {
    1606                 :     244704 :           input_ref (ib, node, nodes);
    1607                 :     244704 :           count--;
    1608                 :            :         }
    1609                 :            :     }
    1610                 :      14924 : }
    1611                 :            :             
    1612                 :            : /* Input profile_info from IB.  */
    1613                 :            : static void
    1614                 :      14924 : input_profile_summary (class lto_input_block *ib,
    1615                 :            :                        struct lto_file_decl_data *file_data)
    1616                 :            : {
    1617                 :      14924 :   unsigned int runs = streamer_read_uhwi (ib);
    1618                 :      14924 :   if (runs)
    1619                 :            :     {
    1620                 :         11 :       file_data->profile_info.runs = runs;
    1621                 :            : 
    1622                 :            :       /* IPA-profile computes hot bb threshold based on cumulated
    1623                 :            :          whole program profile.  We need to stream it down to ltrans.  */
    1624                 :         11 :       if (flag_ltrans)
    1625                 :          4 :         set_hot_bb_threshold (streamer_read_gcov_count (ib));
    1626                 :            :     }
    1627                 :            : 
    1628                 :      14924 : }
    1629                 :            : 
    1630                 :            : /* Rescale profile summaries to the same number of runs in the whole unit.  */
    1631                 :            : 
    1632                 :            : static void
    1633                 :      13987 : merge_profile_summaries (struct lto_file_decl_data **file_data_vec)
    1634                 :            : {
    1635                 :      13987 :   struct lto_file_decl_data *file_data;
    1636                 :      13987 :   unsigned int j;
    1637                 :      13987 :   gcov_unsigned_t max_runs = 0;
    1638                 :      13987 :   struct cgraph_node *node;
    1639                 :      13987 :   struct cgraph_edge *edge;
    1640                 :            : 
    1641                 :            :   /* Find unit with maximal number of runs.  If we ever get serious about
    1642                 :            :      roundoff errors, we might also consider computing smallest common
    1643                 :            :      multiply.  */
    1644                 :      28911 :   for (j = 0; (file_data = file_data_vec[j]) != NULL; j++)
    1645                 :      14924 :     if (max_runs < file_data->profile_info.runs)
    1646                 :            :       max_runs = file_data->profile_info.runs;
    1647                 :            : 
    1648                 :      13987 :   if (!max_runs)
    1649                 :            :     return;
    1650                 :            : 
    1651                 :            :   /* Simple overflow check.  We probably don't need to support that many train
    1652                 :            :      runs. Such a large value probably imply data corruption anyway.  */
    1653                 :          8 :   if (max_runs > INT_MAX / REG_BR_PROB_BASE)
    1654                 :            :     {
    1655                 :          0 :       sorry ("At most %i profile runs is supported. Perhaps corrupted profile?",
    1656                 :            :              INT_MAX / REG_BR_PROB_BASE);
    1657                 :          0 :       return;
    1658                 :            :     }
    1659                 :            : 
    1660                 :          8 :   profile_info = XCNEW (gcov_summary);
    1661                 :          8 :   profile_info->runs = max_runs;
    1662                 :            : 
    1663                 :            :   /* If merging already happent at WPA time, we are done.  */
    1664                 :          8 :   if (flag_ltrans)
    1665                 :            :     return;
    1666                 :            : 
    1667                 :            :   /* Now compute count_materialization_scale of each node.
    1668                 :            :      During LTRANS we already have values of count_materialization_scale
    1669                 :            :      computed, so just update them.  */
    1670                 :         58 :   FOR_EACH_FUNCTION (node)
    1671                 :         25 :     if (node->lto_file_data
    1672                 :         25 :         && node->lto_file_data->profile_info.runs)
    1673                 :            :       {
    1674                 :         25 :         int scale;
    1675                 :            : 
    1676                 :         25 :         scale = RDIV (node->count_materialization_scale * max_runs,
    1677                 :            :                       node->lto_file_data->profile_info.runs);
    1678                 :         25 :         node->count_materialization_scale = scale;
    1679                 :         25 :         if (scale < 0)
    1680                 :          0 :           fatal_error (input_location, "Profile information in %s corrupted",
    1681                 :            :                        file_data->file_name);
    1682                 :            : 
    1683                 :         25 :         if (scale == REG_BR_PROB_BASE)
    1684                 :         25 :           continue;
    1685                 :          0 :         for (edge = node->callees; edge; edge = edge->next_callee)
    1686                 :          0 :           if (edge->count.ipa ().nonzero_p ())
    1687                 :          0 :             edge->count = edge->count.apply_scale (scale, REG_BR_PROB_BASE);
    1688                 :          0 :         for (edge = node->indirect_calls; edge; edge = edge->next_callee)
    1689                 :          0 :           if (edge->count.ipa ().nonzero_p ())
    1690                 :          0 :             edge->count = edge->count.apply_scale (scale, REG_BR_PROB_BASE);
    1691                 :          0 :         if (node->count.ipa ().nonzero_p ())
    1692                 :          0 :           node->count = node->count.apply_scale (scale, REG_BR_PROB_BASE);
    1693                 :            :       }
    1694                 :            : }
    1695                 :            : 
    1696                 :            : /* Input and merge the symtab from each of the .o files passed to
    1697                 :            :    lto1.  */
    1698                 :            : 
    1699                 :            : void
    1700                 :      13987 : input_symtab (void)
    1701                 :            : {
    1702                 :      13987 :   struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
    1703                 :      13987 :   struct lto_file_decl_data *file_data;
    1704                 :      13987 :   unsigned int j = 0;
    1705                 :      28911 :   struct cgraph_node *node;
    1706                 :            : 
    1707                 :      28911 :   while ((file_data = file_data_vec[j++]))
    1708                 :            :     {
    1709                 :      14924 :       const char *data;
    1710                 :      14924 :       size_t len;
    1711                 :      14924 :       class lto_input_block *ib;
    1712                 :      14924 :       vec<symtab_node *> nodes;
    1713                 :            : 
    1714                 :      14924 :       ib = lto_create_simple_input_block (file_data, LTO_section_symtab_nodes,
    1715                 :            :                                           &data, &len);
    1716                 :      14924 :       if (!ib) 
    1717                 :          0 :         fatal_error (input_location,
    1718                 :            :                      "cannot find LTO cgraph in %s", file_data->file_name);
    1719                 :      14924 :       input_profile_summary (ib, file_data);
    1720                 :      14924 :       file_data->symtab_node_encoder = lto_symtab_encoder_new (true);
    1721                 :      14924 :       nodes = input_cgraph_1 (file_data, ib);
    1722                 :      14924 :       lto_destroy_simple_input_block (file_data, LTO_section_symtab_nodes,
    1723                 :            :                                       ib, data, len);
    1724                 :            : 
    1725                 :      14924 :       ib = lto_create_simple_input_block (file_data, LTO_section_refs,
    1726                 :            :                                           &data, &len);
    1727                 :      14924 :       if (!ib)
    1728                 :          0 :         fatal_error (input_location, "cannot find LTO section refs in %s",
    1729                 :            :                      file_data->file_name);
    1730                 :      14924 :       input_refs (ib, nodes);
    1731                 :      14924 :       lto_destroy_simple_input_block (file_data, LTO_section_refs,
    1732                 :            :                                       ib, data, len);
    1733                 :      14924 :       if (flag_ltrans)
    1734                 :       5356 :         input_cgraph_opt_summary (nodes);
    1735                 :      29788 :       nodes.release ();
    1736                 :            :     }
    1737                 :            : 
    1738                 :      13987 :   merge_profile_summaries (file_data_vec);
    1739                 :            : 
    1740                 :            :   /* Clear out the aux field that was used to store enough state to
    1741                 :            :      tell which nodes should be overwritten.  */
    1742                 :     317222 :   FOR_EACH_FUNCTION (node)
    1743                 :            :     {
    1744                 :            :       /* Some nodes may have been created by cgraph_node.  This
    1745                 :            :          happens when the callgraph contains nested functions.  If the
    1746                 :            :          node for the parent function was never emitted to the gimple
    1747                 :            :          file, cgraph_node will create a node for it when setting the
    1748                 :            :          context of the nested function.  */
    1749                 :     144624 :       if (node->lto_file_data)
    1750                 :     144624 :         node->aux = NULL;
    1751                 :            :     }
    1752                 :      13987 : }
    1753                 :            : 
    1754                 :            : /* Input function/variable tables that will allow libgomp to look up offload
    1755                 :            :    target code, and store them into OFFLOAD_FUNCS and OFFLOAD_VARS.  */
    1756                 :            : 
    1757                 :            : void
    1758                 :      13987 : input_offload_tables (bool do_force_output)
    1759                 :            : {
    1760                 :      13987 :   struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
    1761                 :      13987 :   struct lto_file_decl_data *file_data;
    1762                 :      13987 :   unsigned int j = 0;
    1763                 :            : 
    1764                 :      28911 :   while ((file_data = file_data_vec[j++]))
    1765                 :            :     {
    1766                 :      14924 :       const char *data;
    1767                 :      14924 :       size_t len;
    1768                 :      14924 :       class lto_input_block *ib
    1769                 :      14924 :         = lto_create_simple_input_block (file_data, LTO_section_offload_table,
    1770                 :            :                                          &data, &len);
    1771                 :      14924 :       if (!ib)
    1772                 :      14924 :         continue;
    1773                 :            : 
    1774                 :          0 :       enum LTO_symtab_tags tag
    1775                 :          0 :         = streamer_read_enum (ib, LTO_symtab_tags, LTO_symtab_last_tag);
    1776                 :          0 :       while (tag)
    1777                 :            :         {
    1778                 :          0 :           if (tag == LTO_symtab_unavail_node)
    1779                 :            :             {
    1780                 :          0 :               int decl_index = streamer_read_uhwi (ib);
    1781                 :          0 :               tree fn_decl
    1782                 :          0 :                 = lto_file_decl_data_get_fn_decl (file_data, decl_index);
    1783                 :          0 :               vec_safe_push (offload_funcs, fn_decl);
    1784                 :            : 
    1785                 :            :               /* Prevent IPA from removing fn_decl as unreachable, since there
    1786                 :            :                  may be no refs from the parent function to child_fn in offload
    1787                 :            :                  LTO mode.  */
    1788                 :          0 :               if (do_force_output)
    1789                 :          0 :                 cgraph_node::get (fn_decl)->mark_force_output ();
    1790                 :            :             }
    1791                 :          0 :           else if (tag == LTO_symtab_variable)
    1792                 :            :             {
    1793                 :          0 :               int decl_index = streamer_read_uhwi (ib);
    1794                 :          0 :               tree var_decl
    1795                 :          0 :                 = lto_file_decl_data_get_var_decl (file_data, decl_index);
    1796                 :          0 :               vec_safe_push (offload_vars, var_decl);
    1797                 :            : 
    1798                 :            :               /* Prevent IPA from removing var_decl as unused, since there
    1799                 :            :                  may be no refs to var_decl in offload LTO mode.  */
    1800                 :          0 :               if (do_force_output)
    1801                 :          0 :                 varpool_node::get (var_decl)->force_output = 1;
    1802                 :            :             }
    1803                 :            :           else
    1804                 :          0 :             fatal_error (input_location,
    1805                 :            :                          "invalid offload table in %s", file_data->file_name);
    1806                 :            : 
    1807                 :          0 :           tag = streamer_read_enum (ib, LTO_symtab_tags, LTO_symtab_last_tag);
    1808                 :            :         }
    1809                 :            : 
    1810                 :          0 :       lto_destroy_simple_input_block (file_data, LTO_section_offload_table,
    1811                 :            :                                       ib, data, len);
    1812                 :            :     }
    1813                 :      13987 : }
    1814                 :            : 
    1815                 :            : /* True when we need optimization summary for NODE.  */
    1816                 :            : 
    1817                 :            : static int
    1818                 :     100872 : output_cgraph_opt_summary_p (struct cgraph_node *node)
    1819                 :            : {
    1820                 :      96422 :   return ((node->clone_of || node->former_clone_of)
    1821                 :       4452 :           && (node->clone.tree_map
    1822                 :       2506 :               || node->clone.param_adjustments));
    1823                 :            : }
    1824                 :            : 
    1825                 :            : /* Output optimization summary for EDGE to OB.  */
    1826                 :            : static void
    1827                 :       2768 : output_edge_opt_summary (struct output_block *ob ATTRIBUTE_UNUSED,
    1828                 :            :                          struct cgraph_edge *edge ATTRIBUTE_UNUSED)
    1829                 :            : {
    1830                 :          0 : }
    1831                 :            : 
    1832                 :            : /* Output optimization summary for NODE to OB.  */
    1833                 :            : 
    1834                 :            : static void
    1835                 :       1653 : output_node_opt_summary (struct output_block *ob,
    1836                 :            :                          struct cgraph_node *node,
    1837                 :            :                          lto_symtab_encoder_t encoder)
    1838                 :            : {
    1839                 :       1653 :   struct ipa_replace_map *map;
    1840                 :       1653 :   int i;
    1841                 :       1653 :   struct cgraph_edge *e;
    1842                 :            : 
    1843                 :            :   /* TODO: Should this code be moved to ipa-param-manipulation?  */
    1844                 :       1653 :   struct bitpack_d bp;
    1845                 :       1653 :   bp = bitpack_create (ob->main_stream);
    1846                 :       1653 :   bp_pack_value (&bp, (node->clone.param_adjustments != NULL), 1);
    1847                 :       1653 :   streamer_write_bitpack (&bp);
    1848                 :       1653 :   if (ipa_param_adjustments *adjustments = node->clone.param_adjustments)
    1849                 :            :     {
    1850                 :       1460 :       streamer_write_uhwi (ob, vec_safe_length (adjustments->m_adj_params));
    1851                 :       1460 :       ipa_adjusted_param *adj;
    1852                 :       2546 :       FOR_EACH_VEC_SAFE_ELT (adjustments->m_adj_params, i, adj)
    1853                 :            :         {
    1854                 :       1086 :           bp = bitpack_create (ob->main_stream);
    1855                 :       1086 :           bp_pack_value (&bp, adj->base_index, IPA_PARAM_MAX_INDEX_BITS);
    1856                 :       1086 :           bp_pack_value (&bp, adj->prev_clone_index, IPA_PARAM_MAX_INDEX_BITS);
    1857                 :       1086 :           bp_pack_value (&bp, adj->op, 2);
    1858                 :       1086 :           bp_pack_value (&bp, adj->param_prefix_index, 2);
    1859                 :       1086 :           bp_pack_value (&bp, adj->prev_clone_adjustment, 1);
    1860                 :       1086 :           bp_pack_value (&bp, adj->reverse, 1);
    1861                 :       1086 :           bp_pack_value (&bp, adj->user_flag, 1);
    1862                 :       1086 :           streamer_write_bitpack (&bp);
    1863                 :       1086 :           if (adj->op == IPA_PARAM_OP_SPLIT
    1864                 :       1086 :               || adj->op == IPA_PARAM_OP_NEW)
    1865                 :            :             {
    1866                 :        137 :               stream_write_tree (ob, adj->type, true);
    1867                 :        137 :               if (adj->op == IPA_PARAM_OP_SPLIT)
    1868                 :            :                 {
    1869                 :        137 :                   stream_write_tree (ob, adj->alias_ptr_type, true);
    1870                 :        137 :                   streamer_write_uhwi (ob, adj->unit_offset);
    1871                 :            :                 }
    1872                 :            :             }
    1873                 :            :         }
    1874                 :       1460 :       streamer_write_hwi (ob, adjustments->m_always_copy_start);
    1875                 :       1460 :       bp = bitpack_create (ob->main_stream);
    1876                 :       1460 :       bp_pack_value (&bp, node->clone.param_adjustments->m_skip_return, 1);
    1877                 :       1460 :       streamer_write_bitpack (&bp);
    1878                 :            :     }
    1879                 :            : 
    1880                 :       1653 :   streamer_write_uhwi (ob, vec_safe_length (node->clone.tree_map));
    1881                 :       3588 :   FOR_EACH_VEC_SAFE_ELT (node->clone.tree_map, i, map)
    1882                 :            :     {
    1883                 :       1935 :       streamer_write_uhwi (ob, map->parm_num);
    1884                 :       1935 :       gcc_assert (EXPR_LOCATION (map->new_tree) == UNKNOWN_LOCATION);
    1885                 :       1935 :       stream_write_tree (ob, map->new_tree, true);
    1886                 :            :     }
    1887                 :            : 
    1888                 :       1653 :   if (lto_symtab_encoder_in_partition_p (encoder, node))
    1889                 :            :     {
    1890                 :       4238 :       for (e = node->callees; e; e = e->next_callee)
    1891                 :       2756 :         output_edge_opt_summary (ob, e);
    1892                 :       1494 :       for (e = node->indirect_calls; e; e = e->next_callee)
    1893                 :         12 :         output_edge_opt_summary (ob, e);
    1894                 :            :     }
    1895                 :       1653 : }
    1896                 :            : 
    1897                 :            : /* Output optimization summaries stored in callgraph.
    1898                 :            :    At the moment it is the clone info structure.  */
    1899                 :            : 
    1900                 :            : static void
    1901                 :       5356 : output_cgraph_opt_summary (void)
    1902                 :            : {
    1903                 :       5356 :   int i, n_nodes;
    1904                 :       5356 :   lto_symtab_encoder_t encoder;
    1905                 :       5356 :   struct output_block *ob = create_output_block (LTO_section_cgraph_opt_sum);
    1906                 :       5356 :   unsigned count = 0;
    1907                 :            : 
    1908                 :       5356 :   ob->symbol = NULL;
    1909                 :       5356 :   encoder = ob->decl_state->symtab_node_encoder;
    1910                 :       5356 :   n_nodes = lto_symtab_encoder_size (encoder);
    1911                 :      76782 :   for (i = 0; i < n_nodes; i++)
    1912                 :            :     {
    1913                 :      71426 :       symtab_node *node = lto_symtab_encoder_deref (encoder, i);
    1914                 :     142852 :       cgraph_node *cnode = dyn_cast <cgraph_node *> (node);
    1915                 :     121862 :       if (cnode && output_cgraph_opt_summary_p (cnode))
    1916                 :       1653 :         count++;
    1917                 :            :     }
    1918                 :       5356 :   streamer_write_uhwi (ob, count);
    1919                 :      76782 :   for (i = 0; i < n_nodes; i++)
    1920                 :            :     {
    1921                 :      71426 :       symtab_node *node = lto_symtab_encoder_deref (encoder, i);
    1922                 :     142852 :       cgraph_node *cnode = dyn_cast <cgraph_node *> (node);
    1923                 :     121862 :       if (cnode && output_cgraph_opt_summary_p (cnode))
    1924                 :            :         {
    1925                 :       1653 :           streamer_write_uhwi (ob, i);
    1926                 :       1653 :           output_node_opt_summary (ob, cnode, encoder);
    1927                 :            :         }
    1928                 :            :     }
    1929                 :       5356 :   produce_asm (ob, NULL);
    1930                 :       5356 :   destroy_output_block (ob);
    1931                 :       5356 : }
    1932                 :            : 
    1933                 :            : /* Input optimisation summary of EDGE.  */
    1934                 :            : 
    1935                 :            : static void
    1936                 :       2768 : input_edge_opt_summary (struct cgraph_edge *edge ATTRIBUTE_UNUSED,
    1937                 :            :                         class lto_input_block *ib_main ATTRIBUTE_UNUSED)
    1938                 :            : {
    1939                 :          0 : }
    1940                 :            : 
    1941                 :            : /* Input optimisation summary of NODE.  */
    1942                 :            : 
    1943                 :            : static void
    1944                 :       1653 : input_node_opt_summary (struct cgraph_node *node,
    1945                 :            :                         class lto_input_block *ib_main,
    1946                 :            :                         class data_in *data_in)
    1947                 :            : {
    1948                 :       1653 :   int i;
    1949                 :       1653 :   int count;
    1950                 :       1653 :   struct cgraph_edge *e;
    1951                 :            : 
    1952                 :            :   /* TODO: Should this code be moved to ipa-param-manipulation?  */
    1953                 :       1653 :   struct bitpack_d bp;
    1954                 :       1653 :   bp = streamer_read_bitpack (ib_main);
    1955                 :       1653 :   bool have_adjustments = bp_unpack_value (&bp, 1);
    1956                 :       1653 :   if (have_adjustments)
    1957                 :            :     {
    1958                 :       1460 :       count = streamer_read_uhwi (ib_main);
    1959                 :       1460 :       vec<ipa_adjusted_param, va_gc> *new_params = NULL;
    1960                 :       2546 :       for (i = 0; i < count; i++)
    1961                 :            :         {
    1962                 :       1086 :           ipa_adjusted_param adj;
    1963                 :       1086 :           memset (&adj, 0, sizeof (adj));
    1964                 :       1086 :           bp = streamer_read_bitpack (ib_main);
    1965                 :       1086 :           adj.base_index = bp_unpack_value (&bp, IPA_PARAM_MAX_INDEX_BITS);
    1966                 :       1086 :           adj.prev_clone_index
    1967                 :       1086 :             = bp_unpack_value (&bp, IPA_PARAM_MAX_INDEX_BITS);
    1968                 :       1086 :           adj.op = (enum ipa_parm_op) bp_unpack_value (&bp, 2);
    1969                 :       1086 :           adj.param_prefix_index = bp_unpack_value (&bp, 2);
    1970                 :       1086 :           adj.prev_clone_adjustment = bp_unpack_value (&bp, 1);
    1971                 :       1086 :           adj.reverse = bp_unpack_value (&bp, 1);
    1972                 :       1086 :           adj.user_flag = bp_unpack_value (&bp, 1);
    1973                 :       1086 :           if (adj.op == IPA_PARAM_OP_SPLIT
    1974                 :       1086 :               || adj.op == IPA_PARAM_OP_NEW)
    1975                 :            :             {
    1976                 :        137 :               adj.type = stream_read_tree (ib_main, data_in);
    1977                 :        137 :               if (adj.op == IPA_PARAM_OP_SPLIT)
    1978                 :            :                 {
    1979                 :        137 :                   adj.alias_ptr_type = stream_read_tree (ib_main, data_in);
    1980                 :        137 :                   adj.unit_offset = streamer_read_uhwi (ib_main);
    1981                 :            :                 }
    1982                 :            :             }
    1983                 :       1086 :           vec_safe_push (new_params, adj);
    1984                 :            :         }
    1985                 :       1460 :       int always_copy_start = streamer_read_hwi (ib_main);
    1986                 :       1460 :       bp = streamer_read_bitpack (ib_main);
    1987                 :       1460 :       bool skip_return = bp_unpack_value (&bp, 1);
    1988                 :       1460 :       node->clone.param_adjustments
    1989                 :       1460 :         = (new (ggc_alloc <ipa_param_adjustments> ())
    1990                 :       1460 :            ipa_param_adjustments (new_params, always_copy_start, skip_return));
    1991                 :            :     }
    1992                 :            : 
    1993                 :       1653 :   count = streamer_read_uhwi (ib_main);
    1994                 :       3588 :   for (i = 0; i < count; i++)
    1995                 :            :     {
    1996                 :       1935 :       struct ipa_replace_map *map = ggc_alloc<ipa_replace_map> ();
    1997                 :            : 
    1998                 :       1935 :       vec_safe_push (node->clone.tree_map, map);
    1999                 :       1935 :       map->parm_num = streamer_read_uhwi (ib_main);
    2000                 :       1935 :       map->new_tree = stream_read_tree (ib_main, data_in);
    2001                 :            :     }
    2002                 :       4409 :   for (e = node->callees; e; e = e->next_callee)
    2003                 :       2756 :     input_edge_opt_summary (e, ib_main);
    2004                 :       1665 :   for (e = node->indirect_calls; e; e = e->next_callee)
    2005                 :         12 :     input_edge_opt_summary (e, ib_main);
    2006                 :       1653 : }
    2007                 :            : 
    2008                 :            : /* Read section in file FILE_DATA of length LEN with data DATA.  */
    2009                 :            : 
    2010                 :            : static void
    2011                 :       5356 : input_cgraph_opt_section (struct lto_file_decl_data *file_data,
    2012                 :            :                           const char *data, size_t len,
    2013                 :            :                           vec<symtab_node *> nodes)
    2014                 :            : {
    2015                 :       5356 :   const struct lto_function_header *header =
    2016                 :            :     (const struct lto_function_header *) data;
    2017                 :       5356 :   const int cfg_offset = sizeof (struct lto_function_header);
    2018                 :       5356 :   const int main_offset = cfg_offset + header->cfg_size;
    2019                 :       5356 :   const int string_offset = main_offset + header->main_size;
    2020                 :       5356 :   class data_in *data_in;
    2021                 :       5356 :   unsigned int i;
    2022                 :       5356 :   unsigned int count;
    2023                 :            : 
    2024                 :       5356 :   lto_input_block ib_main ((const char *) data + main_offset,
    2025                 :       5356 :                            header->main_size, file_data->mode_table);
    2026                 :            : 
    2027                 :       5356 :   data_in =
    2028                 :      10712 :     lto_data_in_create (file_data, (const char *) data + string_offset,
    2029                 :       5356 :                         header->string_size, vNULL);
    2030                 :       5356 :   count = streamer_read_uhwi (&ib_main);
    2031                 :            : 
    2032                 :       7009 :   for (i = 0; i < count; i++)
    2033                 :            :     {
    2034                 :       1653 :       int ref = streamer_read_uhwi (&ib_main);
    2035                 :       3306 :       input_node_opt_summary (dyn_cast<cgraph_node *> (nodes[ref]),
    2036                 :            :                               &ib_main, data_in);
    2037                 :            :     }
    2038                 :       5356 :   lto_free_section_data (file_data, LTO_section_cgraph_opt_sum, NULL, data,
    2039                 :            :                          len);
    2040                 :       5356 :   lto_data_in_delete (data_in);
    2041                 :       5356 : }
    2042                 :            : 
    2043                 :            : /* Input optimization summary of cgraph.  */
    2044                 :            : 
    2045                 :            : static void
    2046                 :       5356 : input_cgraph_opt_summary (vec<symtab_node *> nodes)
    2047                 :            : {
    2048                 :       5356 :   struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
    2049                 :       5356 :   struct lto_file_decl_data *file_data;
    2050                 :       5356 :   unsigned int j = 0;
    2051                 :            : 
    2052                 :      10712 :   while ((file_data = file_data_vec[j++]))
    2053                 :            :     {
    2054                 :       5356 :       size_t len;
    2055                 :       5356 :       const char *data
    2056                 :       5356 :         = lto_get_summary_section_data (file_data, LTO_section_cgraph_opt_sum,
    2057                 :            :                                         &len);
    2058                 :       5356 :       if (data)
    2059                 :       5356 :         input_cgraph_opt_section (file_data, data, len, nodes);
    2060                 :            :     }
    2061                 :       5356 : }

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.