LCOV - code coverage report
Current view: top level - gcc - tree-streamer-in.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 450 508 88.6 %
Date: 2020-04-04 11:58:09 Functions: 34 38 89.5 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Routines for reading trees from a file stream.
       2                 :            : 
       3                 :            :    Copyright (C) 2011-2020 Free Software Foundation, Inc.
       4                 :            :    Contributed by Diego Novillo <dnovillo@google.com>
       5                 :            : 
       6                 :            : This file is part of GCC.
       7                 :            : 
       8                 :            : GCC is free software; you can redistribute it and/or modify it under
       9                 :            : the terms of the GNU General Public License as published by the Free
      10                 :            : Software Foundation; either version 3, or (at your option) any later
      11                 :            : version.
      12                 :            : 
      13                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      14                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      15                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      16                 :            : for more details.
      17                 :            : 
      18                 :            : You should have received a copy of the GNU General Public License
      19                 :            : along with GCC; see the file COPYING3.  If not see
      20                 :            : <http://www.gnu.org/licenses/>.  */
      21                 :            : 
      22                 :            : #include "config.h"
      23                 :            : #include "system.h"
      24                 :            : #include "coretypes.h"
      25                 :            : #include "backend.h"
      26                 :            : #include "target.h"
      27                 :            : #include "tree.h"
      28                 :            : #include "gimple.h"
      29                 :            : #include "stringpool.h"
      30                 :            : #include "tree-streamer.h"
      31                 :            : #include "cgraph.h"
      32                 :            : #include "builtins.h"
      33                 :            : #include "gomp-constants.h"
      34                 :            : #include "stringpool.h"
      35                 :            : #include "attribs.h"
      36                 :            : #include "asan.h"
      37                 :            : #include "opts.h"
      38                 :            : 
      39                 :            : 
      40                 :            : /* Read a STRING_CST from the string table in DATA_IN using input
      41                 :            :    block IB.  */
      42                 :            : 
      43                 :            : tree
      44                 :      47754 : streamer_read_string_cst (class data_in *data_in, class lto_input_block *ib)
      45                 :            : {
      46                 :      47754 :   unsigned int len;
      47                 :      47754 :   const char * ptr;
      48                 :            : 
      49                 :      47754 :   ptr = streamer_read_indexed_string (data_in, ib, &len);
      50                 :      47754 :   if (!ptr)
      51                 :            :     return NULL;
      52                 :      47734 :   return build_string (len, ptr);
      53                 :            : }
      54                 :            : 
      55                 :            : 
      56                 :            : /* Read an IDENTIFIER from the string table in DATA_IN using input
      57                 :            :    block IB.  */
      58                 :            : 
      59                 :            : static tree
      60                 :     554192 : input_identifier (class data_in *data_in, class lto_input_block *ib)
      61                 :            : {
      62                 :     554192 :   unsigned int len;
      63                 :     554192 :   const char *ptr;
      64                 :            : 
      65                 :     554192 :   ptr = streamer_read_indexed_string (data_in, ib, &len);
      66                 :     554192 :   if (!ptr)
      67                 :            :     return NULL;
      68                 :     554192 :   return get_identifier_with_length (ptr, len);
      69                 :            : }
      70                 :            : 
      71                 :            : 
      72                 :            : /* Read a chain of tree nodes from input block IB. DATA_IN contains
      73                 :            :    tables and descriptors for the file being read.  */
      74                 :            : 
      75                 :            : tree
      76                 :     254913 : streamer_read_chain (class lto_input_block *ib, class data_in *data_in)
      77                 :            : {
      78                 :     254913 :   tree first, prev, curr;
      79                 :            : 
      80                 :            :   /* The chain is written as NULL terminated list of trees.  */
      81                 :     254913 :   first = prev = NULL_TREE;
      82                 :     465204 :   do
      83                 :            :     {
      84                 :     465204 :       curr = stream_read_tree (ib, data_in);
      85                 :     465204 :       if (prev)
      86                 :     210291 :         TREE_CHAIN (prev) = curr;
      87                 :            :       else
      88                 :            :         first = curr;
      89                 :            : 
      90                 :     465204 :       prev = curr;
      91                 :            :     }
      92                 :     465204 :   while (curr);
      93                 :            : 
      94                 :     254913 :   return first;
      95                 :            : }
      96                 :            : 
      97                 :            : 
      98                 :            : /* Unpack all the non-pointer fields of the TS_BASE structure of
      99                 :            :    expression EXPR from bitpack BP.  */
     100                 :            : 
     101                 :            : static inline void
     102                 :    2891080 : unpack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
     103                 :            : {
     104                 :            :   /* Note that the code for EXPR has already been unpacked to create EXPR in
     105                 :            :      streamer_alloc_tree.  */
     106                 :    2891080 :   if (!TYPE_P (expr))
     107                 :            :     {
     108                 :    2527410 :       TREE_SIDE_EFFECTS (expr) = (unsigned) bp_unpack_value (bp, 1);
     109                 :    2527410 :       TREE_CONSTANT (expr) = (unsigned) bp_unpack_value (bp, 1);
     110                 :    2527410 :       TREE_READONLY (expr) = (unsigned) bp_unpack_value (bp, 1);
     111                 :            : 
     112                 :            :       /* TREE_PUBLIC is used on types to indicate that the type
     113                 :            :          has a TYPE_CACHED_VALUES vector.  This is not streamed out,
     114                 :            :          so we skip it here.  */
     115                 :    2527410 :       TREE_PUBLIC (expr) = (unsigned) bp_unpack_value (bp, 1);
     116                 :            :     }
     117                 :            :   else
     118                 :     363668 :     bp_unpack_value (bp, 4);
     119                 :    2891080 :   TREE_ADDRESSABLE (expr) = (unsigned) bp_unpack_value (bp, 1);
     120                 :    2891080 :   TREE_THIS_VOLATILE (expr) = (unsigned) bp_unpack_value (bp, 1);
     121                 :    2891080 :   if (DECL_P (expr))
     122                 :            :     {
     123                 :     560705 :       DECL_UNSIGNED (expr) = (unsigned) bp_unpack_value (bp, 1);
     124                 :     560705 :       DECL_NAMELESS (expr) = (unsigned) bp_unpack_value (bp, 1);
     125                 :            :     }
     126                 :    2330380 :   else if (TYPE_P (expr))
     127                 :     363668 :     TYPE_UNSIGNED (expr) = (unsigned) bp_unpack_value (bp, 1);
     128                 :            :   else
     129                 :    1966710 :     bp_unpack_value (bp, 1);
     130                 :    2891080 :   TREE_ASM_WRITTEN (expr) = (unsigned) bp_unpack_value (bp, 1);
     131                 :    2891080 :   if (TYPE_P (expr))
     132                 :     363668 :     TYPE_ARTIFICIAL (expr) = (unsigned) bp_unpack_value (bp, 1);
     133                 :            :   else
     134                 :    2527410 :     TREE_NO_WARNING (expr) = (unsigned) bp_unpack_value (bp, 1);
     135                 :    2891080 :   TREE_NOTHROW (expr) = (unsigned) bp_unpack_value (bp, 1);
     136                 :    2891080 :   TREE_STATIC (expr) = (unsigned) bp_unpack_value (bp, 1);
     137                 :    2891080 :   if (TREE_CODE (expr) != TREE_BINFO)
     138                 :    2885310 :     TREE_PRIVATE (expr) = (unsigned) bp_unpack_value (bp, 1);
     139                 :            :   else
     140                 :       5772 :     bp_unpack_value (bp, 1);
     141                 :    2891080 :   TREE_PROTECTED (expr) = (unsigned) bp_unpack_value (bp, 1);
     142                 :    2891080 :   TREE_DEPRECATED (expr) = (unsigned) bp_unpack_value (bp, 1);
     143                 :    2891080 :   if (TYPE_P (expr))
     144                 :            :     {
     145                 :     363668 :       if (AGGREGATE_TYPE_P (expr))
     146                 :      73937 :         TYPE_REVERSE_STORAGE_ORDER (expr) = (unsigned) bp_unpack_value (bp, 1);
     147                 :            :       else
     148                 :     289731 :         TYPE_SATURATING (expr) = (unsigned) bp_unpack_value (bp, 1);
     149                 :     363668 :       TYPE_ADDR_SPACE (expr) = (unsigned) bp_unpack_value (bp, 8);
     150                 :            :     }
     151                 :    2527410 :   else if (TREE_CODE (expr) == BIT_FIELD_REF || TREE_CODE (expr) == MEM_REF)
     152                 :            :     {
     153                 :     178454 :       REF_REVERSE_STORAGE_ORDER (expr) = (unsigned) bp_unpack_value (bp, 1);
     154                 :     178454 :       bp_unpack_value (bp, 8);
     155                 :            :     }
     156                 :    2348960 :   else if (TREE_CODE (expr) == SSA_NAME)
     157                 :            :     {
     158                 :          0 :       SSA_NAME_IS_DEFAULT_DEF (expr) = (unsigned) bp_unpack_value (bp, 1);
     159                 :          0 :       bp_unpack_value (bp, 8);
     160                 :            :     }
     161                 :    2348960 :   else if (TREE_CODE (expr) == CALL_EXPR)
     162                 :            :     {
     163                 :          0 :       CALL_EXPR_BY_DESCRIPTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
     164                 :          0 :       bp_unpack_value (bp, 8);
     165                 :            :     }
     166                 :            :   else
     167                 :    2348960 :     bp_unpack_value (bp, 9);
     168                 :    2891080 : }
     169                 :            : 
     170                 :            : 
     171                 :            : /* Unpack all the non-pointer fields of the TS_INT_CST structure of
     172                 :            :    expression EXPR from bitpack BP.  */
     173                 :            : 
     174                 :            : static void
     175                 :      22735 : unpack_ts_int_cst_value_fields (struct bitpack_d *bp, tree expr)
     176                 :            : {
     177                 :      22735 :   int i;
     178                 :      45518 :   for (i = 0; i < TREE_INT_CST_EXT_NUNITS (expr); i++)
     179                 :      22783 :     TREE_INT_CST_ELT (expr, i) = bp_unpack_var_len_int (bp);
     180                 :      22735 : }
     181                 :            : 
     182                 :            : 
     183                 :            : /* Unpack all the non-pointer fields of the TS_REAL_CST structure of
     184                 :            :    expression EXPR from bitpack BP.  */
     185                 :            : 
     186                 :            : static void
     187                 :      83423 : unpack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
     188                 :            : {
     189                 :      83423 :   unsigned i;
     190                 :      83423 :   REAL_VALUE_TYPE r;
     191                 :      83423 :   REAL_VALUE_TYPE *rp;
     192                 :            : 
     193                 :            :   /* Clear all bits of the real value type so that we can later do
     194                 :            :      bitwise comparisons to see if two values are the same.  */
     195                 :      83423 :   memset (&r, 0, sizeof r);
     196                 :      83423 :   r.cl = (unsigned) bp_unpack_value (bp, 2);
     197                 :      83423 :   r.decimal = (unsigned) bp_unpack_value (bp, 1);
     198                 :      83423 :   r.sign = (unsigned) bp_unpack_value (bp, 1);
     199                 :      83423 :   r.signalling = (unsigned) bp_unpack_value (bp, 1);
     200                 :      83423 :   r.canonical = (unsigned) bp_unpack_value (bp, 1);
     201                 :      83423 :   r.uexp = (unsigned) bp_unpack_value (bp, EXP_BITS);
     202                 :     333692 :   for (i = 0; i < SIGSZ; i++)
     203                 :     250269 :     r.sig[i] = (unsigned long) bp_unpack_value (bp, HOST_BITS_PER_LONG);
     204                 :            : 
     205                 :      83423 :   rp = ggc_alloc<real_value> ();
     206                 :      83423 :   memcpy (rp, &r, sizeof (REAL_VALUE_TYPE));
     207                 :      83423 :   TREE_REAL_CST_PTR (expr) = rp;
     208                 :      83423 : }
     209                 :            : 
     210                 :            : 
     211                 :            : /* Unpack all the non-pointer fields of the TS_FIXED_CST structure of
     212                 :            :    expression EXPR from bitpack BP.  */
     213                 :            : 
     214                 :            : static void
     215                 :          0 : unpack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr)
     216                 :            : {
     217                 :          0 :   FIXED_VALUE_TYPE *fp = ggc_alloc<fixed_value> ();
     218                 :          0 :   fp->mode = as_a <scalar_mode> (bp_unpack_machine_mode (bp));
     219                 :          0 :   fp->data.low = bp_unpack_var_len_int (bp);
     220                 :          0 :   fp->data.high = bp_unpack_var_len_int (bp);
     221                 :          0 :   TREE_FIXED_CST_PTR (expr) = fp;
     222                 :          0 : }
     223                 :            : 
     224                 :            : /* Unpack all the non-pointer fields of the TS_DECL_COMMON structure
     225                 :            :    of expression EXPR from bitpack BP.  */
     226                 :            : 
     227                 :            : static void
     228                 :     560705 : unpack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr)
     229                 :            : {
     230                 :     560705 :   SET_DECL_MODE (expr, bp_unpack_machine_mode (bp));
     231                 :     560705 :   DECL_NONLOCAL (expr) = (unsigned) bp_unpack_value (bp, 1);
     232                 :     560705 :   DECL_VIRTUAL_P (expr) = (unsigned) bp_unpack_value (bp, 1);
     233                 :     560705 :   DECL_IGNORED_P (expr) = (unsigned) bp_unpack_value (bp, 1);
     234                 :     560705 :   DECL_ABSTRACT_P (expr) = (unsigned) bp_unpack_value (bp, 1);
     235                 :     560705 :   DECL_ARTIFICIAL (expr) = (unsigned) bp_unpack_value (bp, 1);
     236                 :     560705 :   DECL_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1);
     237                 :     560705 :   DECL_PRESERVE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
     238                 :     560705 :   DECL_EXTERNAL (expr) = (unsigned) bp_unpack_value (bp, 1);
     239                 :     560705 :   DECL_GIMPLE_REG_P (expr) = (unsigned) bp_unpack_value (bp, 1);
     240                 :     560705 :   SET_DECL_ALIGN (expr, (unsigned) bp_unpack_var_len_unsigned (bp));
     241                 :            : #ifdef ACCEL_COMPILER
     242                 :            :   if (DECL_ALIGN (expr) > targetm.absolute_biggest_alignment)
     243                 :            :     SET_DECL_ALIGN (expr, targetm.absolute_biggest_alignment);
     244                 :            : #endif
     245                 :     560705 :   if (TREE_CODE (expr) == LABEL_DECL)
     246                 :            :     {
     247                 :      13081 :       EH_LANDING_PAD_NR (expr) = (int) bp_unpack_var_len_unsigned (bp);
     248                 :            : 
     249                 :            :       /* Always assume an initial value of -1 for LABEL_DECL_UID to
     250                 :            :          force gimple_set_bb to recreate label_to_block_map.  */
     251                 :      13081 :       LABEL_DECL_UID (expr) = -1;
     252                 :            :     }
     253                 :            : 
     254                 :     547624 :   else if (TREE_CODE (expr) == FIELD_DECL)
     255                 :            :     {
     256                 :      62273 :       DECL_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
     257                 :      62273 :       DECL_NONADDRESSABLE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
     258                 :      62273 :       DECL_PADDING_P (expr) = (unsigned) bp_unpack_value (bp, 1);
     259                 :      62273 :       expr->decl_common.off_align = bp_unpack_value (bp, 8);
     260                 :            :     }
     261                 :            : 
     262                 :     485351 :   else if (VAR_P (expr))
     263                 :            :     {
     264                 :     131062 :       DECL_HAS_DEBUG_EXPR_P (expr) = (unsigned) bp_unpack_value (bp, 1);
     265                 :     131062 :       DECL_NONLOCAL_FRAME (expr) = (unsigned) bp_unpack_value (bp, 1);
     266                 :            :     }
     267                 :            : 
     268                 :     354289 :   else if (TREE_CODE (expr) == PARM_DECL)
     269                 :      84713 :     DECL_HIDDEN_STRING_LENGTH (expr) = (unsigned) bp_unpack_value (bp, 1);
     270                 :            : 
     271                 :     560705 :   if (TREE_CODE (expr) == RESULT_DECL
     272                 :     560705 :       || TREE_CODE (expr) == PARM_DECL
     273                 :     400950 :       || VAR_P (expr))
     274                 :            :     {
     275                 :     290817 :       DECL_BY_REFERENCE (expr) = (unsigned) bp_unpack_value (bp, 1);
     276                 :     290817 :       if (VAR_P (expr) || TREE_CODE (expr) == PARM_DECL)
     277                 :     300488 :         DECL_HAS_VALUE_EXPR_P (expr) = (unsigned) bp_unpack_value (bp, 1);
     278                 :            :     }
     279                 :     560705 : }
     280                 :            : 
     281                 :            : 
     282                 :            : /* Unpack all the non-pointer fields of the TS_DECL_WRTL structure
     283                 :            :    of expression EXPR from bitpack BP.  */
     284                 :            : 
     285                 :            : static void
     286                 :     482884 : unpack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
     287                 :            : {
     288                 :     482884 :   DECL_REGISTER (expr) = (unsigned) bp_unpack_value (bp, 1);
     289                 :     482884 : }
     290                 :            : 
     291                 :            : 
     292                 :            : /* Unpack all the non-pointer fields of the TS_DECL_WITH_VIS structure
     293                 :            :    of expression EXPR from bitpack BP.  */
     294                 :            : 
     295                 :            : static void
     296                 :     309642 : unpack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
     297                 :            : {
     298                 :     309642 :   DECL_COMMON (expr) = (unsigned) bp_unpack_value (bp, 1);
     299                 :     309642 :   DECL_DLLIMPORT_P (expr) = (unsigned) bp_unpack_value (bp, 1);
     300                 :     309642 :   DECL_WEAK (expr) = (unsigned) bp_unpack_value (bp, 1);
     301                 :     309642 :   DECL_SEEN_IN_BIND_EXPR_P (expr) = (unsigned) bp_unpack_value (bp,  1);
     302                 :     309642 :   DECL_COMDAT (expr) = (unsigned) bp_unpack_value (bp,  1);
     303                 :     309642 :   DECL_VISIBILITY (expr) = (enum symbol_visibility) bp_unpack_value (bp,  2);
     304                 :     309642 :   DECL_VISIBILITY_SPECIFIED (expr) = (unsigned) bp_unpack_value (bp,  1);
     305                 :            : 
     306                 :     309642 :   if (VAR_P (expr))
     307                 :            :     {
     308                 :     131062 :       DECL_HARD_REGISTER (expr) = (unsigned) bp_unpack_value (bp, 1);
     309                 :     131062 :       DECL_IN_CONSTANT_POOL (expr) = (unsigned) bp_unpack_value (bp, 1);
     310                 :            :     }
     311                 :            : 
     312                 :     309642 :   if (TREE_CODE (expr) == FUNCTION_DECL)
     313                 :            :     {
     314                 :     160238 :       DECL_FINAL_P (expr) = (unsigned) bp_unpack_value (bp, 1);
     315                 :     160238 :       DECL_CXX_CONSTRUCTOR_P (expr) = (unsigned) bp_unpack_value (bp, 1);
     316                 :     160238 :       DECL_CXX_DESTRUCTOR_P (expr) = (unsigned) bp_unpack_value (bp, 1);
     317                 :            :     }
     318                 :     309642 : }
     319                 :            : 
     320                 :            : 
     321                 :            : /* Unpack all the non-pointer fields of the TS_FUNCTION_DECL structure
     322                 :            :    of expression EXPR from bitpack BP.  */
     323                 :            : 
     324                 :            : static void
     325                 :     160238 : unpack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
     326                 :            : {
     327                 :     160238 :   built_in_class cl = bp_unpack_enum (bp, built_in_class, BUILT_IN_LAST);
     328                 :     160238 :   DECL_STATIC_CONSTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
     329                 :     160238 :   DECL_STATIC_DESTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
     330                 :     160238 :   DECL_UNINLINABLE (expr) = (unsigned) bp_unpack_value (bp, 1);
     331                 :     160238 :   DECL_POSSIBLY_INLINED (expr) = (unsigned) bp_unpack_value (bp, 1);
     332                 :     160238 :   DECL_IS_NOVOPS (expr) = (unsigned) bp_unpack_value (bp, 1);
     333                 :     160238 :   DECL_IS_RETURNS_TWICE (expr) = (unsigned) bp_unpack_value (bp, 1);
     334                 :     160238 :   DECL_IS_MALLOC (expr) = (unsigned) bp_unpack_value (bp, 1);
     335                 :     160238 :   DECL_SET_IS_OPERATOR_NEW (expr, (unsigned) bp_unpack_value (bp, 1));
     336                 :     160238 :   DECL_SET_IS_OPERATOR_DELETE (expr, (unsigned) bp_unpack_value (bp, 1));
     337                 :     160238 :   DECL_DECLARED_INLINE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
     338                 :     160238 :   DECL_STATIC_CHAIN (expr) = (unsigned) bp_unpack_value (bp, 1);
     339                 :     160238 :   DECL_NO_INLINE_WARNING_P (expr) = (unsigned) bp_unpack_value (bp, 1);
     340                 :     320476 :   DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr)
     341                 :     160238 :                         = (unsigned) bp_unpack_value (bp, 1);
     342                 :     160238 :   DECL_NO_LIMIT_STACK (expr) = (unsigned) bp_unpack_value (bp, 1);
     343                 :     160238 :   DECL_DISREGARD_INLINE_LIMITS (expr) = (unsigned) bp_unpack_value (bp, 1);
     344                 :     160238 :   DECL_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
     345                 :     160238 :   DECL_LOOPING_CONST_OR_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
     346                 :     160238 :   unsigned int fcode = 0;
     347                 :     160238 :   if (cl != NOT_BUILT_IN)
     348                 :            :     {
     349                 :      21866 :       fcode = bp_unpack_value (bp, 32);
     350                 :      21866 :       if (cl == BUILT_IN_NORMAL && fcode >= END_BUILTINS)
     351                 :          0 :         fatal_error (input_location,
     352                 :            :                      "machine independent builtin code out of range");
     353                 :      21866 :       else if (cl == BUILT_IN_MD)
     354                 :            :         {
     355                 :        128 :           tree result = targetm.builtin_decl (fcode, true);
     356                 :        128 :           if (!result || result == error_mark_node)
     357                 :          0 :             fatal_error (input_location,
     358                 :            :                          "target specific builtin not available");
     359                 :            :         }
     360                 :            :     }
     361                 :     160238 :   set_decl_built_in_function (expr, cl, fcode);
     362                 :     160238 : }
     363                 :            : 
     364                 :            : 
     365                 :            : /* Unpack all the non-pointer fields of the TS_TYPE_COMMON structure
     366                 :            :    of expression EXPR from bitpack BP.  */
     367                 :            : 
     368                 :            : static void
     369                 :     363668 : unpack_ts_type_common_value_fields (struct bitpack_d *bp, tree expr)
     370                 :            : {
     371                 :     363668 :   machine_mode mode;
     372                 :            : 
     373                 :     363668 :   mode = bp_unpack_machine_mode (bp);
     374                 :     363668 :   SET_TYPE_MODE (expr, mode);
     375                 :            :   /* TYPE_NO_FORCE_BLK is private to stor-layout and need
     376                 :            :      no streaming.  */
     377                 :     363668 :   TYPE_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
     378                 :     363668 :   TYPE_RESTRICT (expr) = (unsigned) bp_unpack_value (bp, 1);
     379                 :     363668 :   TYPE_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1);
     380                 :     363668 :   TYPE_READONLY (expr) = (unsigned) bp_unpack_value (bp, 1);
     381                 :     363668 :   TYPE_LANG_FLAG_0 (expr) = (unsigned) bp_unpack_value (bp, 1);
     382                 :     363668 :   if (RECORD_OR_UNION_TYPE_P (expr))
     383                 :            :     {
     384                 :      47926 :       TYPE_TRANSPARENT_AGGR (expr) = (unsigned) bp_unpack_value (bp, 1);
     385                 :      47926 :       TYPE_FINAL_P (expr) = (unsigned) bp_unpack_value (bp, 1);
     386                 :      48911 :       TYPE_CXX_ODR_P (expr) = (unsigned) bp_unpack_value (bp, 1);
     387                 :            :     }
     388                 :     315742 :   else if (TREE_CODE (expr) == ARRAY_TYPE)
     389                 :      26011 :     TYPE_NONALIASED_COMPONENT (expr) = (unsigned) bp_unpack_value (bp, 1);
     390                 :     363668 :   if (TREE_CODE (expr) == ARRAY_TYPE || TREE_CODE (expr) == INTEGER_TYPE)
     391                 :     101133 :     TYPE_STRING_FLAG (expr) = (unsigned) bp_unpack_value (bp, 1);
     392                 :     363668 :   if (AGGREGATE_TYPE_P (expr))
     393                 :      73937 :     TYPE_TYPELESS_STORAGE (expr) = (unsigned) bp_unpack_value (bp, 1);
     394                 :     363668 :   TYPE_EMPTY_P (expr) = (unsigned) bp_unpack_value (bp, 1);
     395                 :     363668 :   TYPE_PRECISION (expr) = bp_unpack_var_len_unsigned (bp);
     396                 :     363668 :   SET_TYPE_ALIGN (expr, bp_unpack_var_len_unsigned (bp));
     397                 :            : #ifdef ACCEL_COMPILER
     398                 :            :   if (TYPE_ALIGN (expr) > targetm.absolute_biggest_alignment)
     399                 :            :     SET_TYPE_ALIGN (expr, targetm.absolute_biggest_alignment);
     400                 :            : #endif
     401                 :     363668 : }
     402                 :            : 
     403                 :            : 
     404                 :            : /* Unpack all the non-pointer fields of the TS_BLOCK structure
     405                 :            :    of expression EXPR from bitpack BP.  */
     406                 :            : 
     407                 :            : static void
     408                 :     132292 : unpack_ts_block_value_fields (class data_in *data_in,
     409                 :            :                               struct bitpack_d *bp, tree expr)
     410                 :            : {
     411                 :            :   /* BLOCK_NUMBER is recomputed.  */
     412                 :     132292 :   stream_input_location (&BLOCK_SOURCE_LOCATION (expr), bp, data_in);
     413                 :     132292 : }
     414                 :            : 
     415                 :            : /* Unpack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL
     416                 :            :    structure of expression EXPR from bitpack BP.  */
     417                 :            : 
     418                 :            : static void
     419                 :      15424 : unpack_ts_translation_unit_decl_value_fields (class data_in *data_in,
     420                 :            :                                               struct bitpack_d *bp, tree expr)
     421                 :            : {
     422                 :      15424 :   TRANSLATION_UNIT_LANGUAGE (expr) = xstrdup (bp_unpack_string (data_in, bp));
     423                 :      15424 :   vec_safe_push (all_translation_units, expr);
     424                 :      15424 : }
     425                 :            : 
     426                 :            : 
     427                 :            : /* Unpack all the non-pointer fields of the TS_OMP_CLAUSE
     428                 :            :    structure of expression EXPR from bitpack BP.  */
     429                 :            : 
     430                 :            : static void
     431                 :        194 : unpack_ts_omp_clause_value_fields (class data_in *data_in,
     432                 :            :                                    struct bitpack_d *bp, tree expr)
     433                 :            : {
     434                 :        194 :   stream_input_location (&OMP_CLAUSE_LOCATION (expr), bp, data_in);
     435                 :        194 :   switch (OMP_CLAUSE_CODE (expr))
     436                 :            :     {
     437                 :          0 :     case OMP_CLAUSE_DEFAULT:
     438                 :          0 :       OMP_CLAUSE_DEFAULT_KIND (expr)
     439                 :          0 :         = bp_unpack_enum (bp, omp_clause_default_kind,
     440                 :            :                           OMP_CLAUSE_DEFAULT_LAST);
     441                 :          0 :       break;
     442                 :          0 :     case OMP_CLAUSE_SCHEDULE:
     443                 :          0 :       OMP_CLAUSE_SCHEDULE_KIND (expr)
     444                 :          0 :         = bp_unpack_enum (bp, omp_clause_schedule_kind,
     445                 :            :                           OMP_CLAUSE_SCHEDULE_LAST);
     446                 :          0 :       break;
     447                 :          0 :     case OMP_CLAUSE_DEPEND:
     448                 :          0 :       OMP_CLAUSE_DEPEND_KIND (expr)
     449                 :          0 :         = bp_unpack_enum (bp, omp_clause_depend_kind, OMP_CLAUSE_DEPEND_LAST);
     450                 :          0 :       break;
     451                 :          0 :     case OMP_CLAUSE_MAP:
     452                 :          0 :       OMP_CLAUSE_SET_MAP_KIND (expr, bp_unpack_enum (bp, gomp_map_kind,
     453                 :            :                                                      GOMP_MAP_LAST));
     454                 :          0 :       break;
     455                 :          0 :     case OMP_CLAUSE_PROC_BIND:
     456                 :          0 :       OMP_CLAUSE_PROC_BIND_KIND (expr)
     457                 :          0 :         = bp_unpack_enum (bp, omp_clause_proc_bind_kind,
     458                 :            :                           OMP_CLAUSE_PROC_BIND_LAST);
     459                 :          0 :       break;
     460                 :          0 :     case OMP_CLAUSE_REDUCTION:
     461                 :          0 :     case OMP_CLAUSE_TASK_REDUCTION:
     462                 :          0 :     case OMP_CLAUSE_IN_REDUCTION:
     463                 :          0 :       OMP_CLAUSE_REDUCTION_CODE (expr)
     464                 :          0 :         = bp_unpack_enum (bp, tree_code, MAX_TREE_CODES);
     465                 :          0 :       break;
     466                 :            :     default:
     467                 :            :       break;
     468                 :            :     }
     469                 :        194 : }
     470                 :            : 
     471                 :            : 
     472                 :            : /* Read all the language-independent bitfield values for EXPR from IB.
     473                 :            :    Return the partially unpacked bitpack so the caller can unpack any other
     474                 :            :    bitfield values that the writer may have written.  */
     475                 :            : 
     476                 :            : void
     477                 :    2891080 : streamer_read_tree_bitfields (class lto_input_block *ib,
     478                 :            :                               class data_in *data_in, tree expr)
     479                 :            : {
     480                 :    2891080 :   enum tree_code code;
     481                 :    2891080 :   struct bitpack_d bp;
     482                 :            : 
     483                 :            :   /* Read the bitpack of non-pointer values from IB.  */
     484                 :    2891080 :   bp = streamer_read_bitpack (ib);
     485                 :            : 
     486                 :            :   /* The first word in BP contains the code of the tree that we
     487                 :            :      are about to read.  */
     488                 :    2891080 :   code = (enum tree_code) bp_unpack_value (&bp, 16);
     489                 :    2891080 :   lto_tag_check (lto_tree_code_to_tag (code),
     490                 :    2891080 :                  lto_tree_code_to_tag (TREE_CODE (expr)));
     491                 :            : 
     492                 :            :   /* Note that all these functions are highly sensitive to changes in
     493                 :            :      the types and sizes of each of the fields being packed.  */
     494                 :    2891080 :   unpack_ts_base_value_fields (&bp, expr);
     495                 :            : 
     496                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
     497                 :      22735 :     unpack_ts_int_cst_value_fields (&bp, expr);
     498                 :            : 
     499                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
     500                 :      83423 :     unpack_ts_real_cst_value_fields (&bp, expr);
     501                 :            : 
     502                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
     503                 :          0 :     unpack_ts_fixed_cst_value_fields (&bp, expr);
     504                 :            : 
     505                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
     506                 :     560705 :     stream_input_location (&DECL_SOURCE_LOCATION (expr), &bp, data_in);
     507                 :            : 
     508                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
     509                 :     560705 :     unpack_ts_decl_common_value_fields (&bp, expr);
     510                 :            : 
     511                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
     512                 :     482884 :     unpack_ts_decl_wrtl_value_fields (&bp, expr);
     513                 :            : 
     514                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
     515                 :     309642 :     unpack_ts_decl_with_vis_value_fields (&bp, expr);
     516                 :            : 
     517                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
     518                 :     160238 :     unpack_ts_function_decl_value_fields (&bp, expr);
     519                 :            : 
     520                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
     521                 :     363668 :     unpack_ts_type_common_value_fields (&bp, expr);
     522                 :            : 
     523                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
     524                 :            :     {
     525                 :     762834 :       stream_input_location (&EXPR_CHECK (expr)->exp.locus, &bp, data_in);
     526                 :     762834 :       if (code == MEM_REF
     527                 :     762834 :           || code == TARGET_MEM_REF)
     528                 :            :         {
     529                 :     351078 :           MR_DEPENDENCE_CLIQUE (expr)
     530                 :     175539 :             = (unsigned)bp_unpack_value (&bp, sizeof (short) * 8);
     531                 :     175539 :           if (MR_DEPENDENCE_CLIQUE (expr) != 0)
     532                 :      19122 :             MR_DEPENDENCE_BASE (expr)
     533                 :       9561 :               = (unsigned)bp_unpack_value (&bp, sizeof (short) * 8);
     534                 :            :         }
     535                 :     587295 :       else if (code == CALL_EXPR)
     536                 :          0 :         CALL_EXPR_IFN (expr) = bp_unpack_enum (&bp, internal_fn, IFN_LAST);
     537                 :            :     }
     538                 :            : 
     539                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
     540                 :     132292 :     unpack_ts_block_value_fields (data_in, &bp, expr);
     541                 :            : 
     542                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
     543                 :      15424 :     unpack_ts_translation_unit_decl_value_fields (data_in, &bp, expr);
     544                 :            : 
     545                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
     546                 :      14796 :     cl_optimization_stream_in (data_in, &bp, TREE_OPTIMIZATION (expr));
     547                 :            : 
     548                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
     549                 :            :     {
     550                 :      28225 :       unsigned HOST_WIDE_INT length = bp_unpack_var_len_unsigned (&bp);
     551                 :      28225 :       if (length > 0)
     552                 :      15874 :         vec_safe_grow (CONSTRUCTOR_ELTS (expr), length);
     553                 :            :     }
     554                 :            : 
     555                 :            : #ifndef ACCEL_COMPILER
     556                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
     557                 :            :     {
     558                 :      14731 :       cl_target_option_stream_in (data_in, &bp, TREE_TARGET_OPTION (expr));
     559                 :      14731 :       if (targetm.target_option.post_stream_in)
     560                 :      14731 :         targetm.target_option.post_stream_in (TREE_TARGET_OPTION (expr));
     561                 :            :     }
     562                 :            : #endif
     563                 :            : 
     564                 :    2891080 :   if (code == OMP_CLAUSE)
     565                 :        194 :     unpack_ts_omp_clause_value_fields (data_in, &bp, expr);
     566                 :    2891080 : }
     567                 :            : 
     568                 :            : 
     569                 :            : /* Materialize a new tree from input block IB using descriptors in
     570                 :            :    DATA_IN.  The code for the new tree should match TAG.  Store in
     571                 :            :    *IX_P the index into the reader cache where the new tree is stored.  */
     572                 :            : 
     573                 :            : tree
     574                 :    2891080 : streamer_alloc_tree (class lto_input_block *ib, class data_in *data_in,
     575                 :            :                      enum LTO_tags tag)
     576                 :            : {
     577                 :    2891080 :   enum tree_code code;
     578                 :    2891080 :   tree result;
     579                 :            : 
     580                 :    2891080 :   result = NULL_TREE;
     581                 :            : 
     582                 :    2891080 :   code = lto_tag_to_tree_code (tag);
     583                 :            : 
     584                 :            :   /* We should never see an SSA_NAME tree.  Only the version numbers of
     585                 :            :      SSA names are ever written out.  See input_ssa_names.  */
     586                 :    2891080 :   gcc_assert (code != SSA_NAME);
     587                 :            : 
     588                 :            :   /* Instantiate a new tree using the header data.  */
     589                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_STRING))
     590                 :      42255 :     result = streamer_read_string_cst (data_in, ib);
     591                 :    2848830 :   else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
     592                 :     554192 :     result = input_identifier (data_in, ib);
     593                 :    2294630 :   else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
     594                 :            :     {
     595                 :          0 :       HOST_WIDE_INT len = streamer_read_hwi (ib);
     596                 :          0 :       result = make_tree_vec (len);
     597                 :            :     }
     598                 :    2294630 :   else if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
     599                 :            :     {
     600                 :       2634 :       bitpack_d bp = streamer_read_bitpack (ib);
     601                 :       2634 :       unsigned int log2_npatterns = bp_unpack_value (&bp, 8);
     602                 :       2634 :       unsigned int nelts_per_pattern = bp_unpack_value (&bp, 8);
     603                 :       2634 :       result = make_vector (log2_npatterns, nelts_per_pattern);
     604                 :            :     }
     605                 :    2292000 :   else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
     606                 :            :     {
     607                 :       5772 :       unsigned HOST_WIDE_INT len = streamer_read_uhwi (ib);
     608                 :       5772 :       result = make_tree_binfo (len);
     609                 :            :     }
     610                 :    2286230 :   else if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
     611                 :            :     {
     612                 :      22735 :       unsigned HOST_WIDE_INT len = streamer_read_uhwi (ib);
     613                 :      22735 :       unsigned HOST_WIDE_INT ext_len = streamer_read_uhwi (ib);
     614                 :      22735 :       result = make_int_cst (len, ext_len);
     615                 :            :     }
     616                 :    2263490 :   else if (code == CALL_EXPR)
     617                 :            :     {
     618                 :          0 :       unsigned HOST_WIDE_INT nargs = streamer_read_uhwi (ib);
     619                 :          0 :       return build_vl_exp (CALL_EXPR, nargs + 3);
     620                 :            :     }
     621                 :    2263490 :   else if (code == OMP_CLAUSE)
     622                 :            :     {
     623                 :        194 :       enum omp_clause_code subcode
     624                 :        194 :         = (enum omp_clause_code) streamer_read_uhwi (ib);
     625                 :        194 :       return build_omp_clause (UNKNOWN_LOCATION, subcode);
     626                 :            :     }
     627                 :            :   else
     628                 :            :     {
     629                 :            :       /* For all other nodes, materialize the tree with a raw
     630                 :            :          make_node call.  */
     631                 :    2263300 :       result = make_node (code);
     632                 :            :     }
     633                 :            : 
     634                 :            :   return result;
     635                 :            : }
     636                 :            : 
     637                 :            : 
     638                 :            : /* Read all pointer fields in the TS_COMMON structure of EXPR from input
     639                 :            :    block IB.  DATA_IN contains tables and descriptors for the
     640                 :            :    file being read.  */
     641                 :            : 
     642                 :            : 
     643                 :            : static void
     644                 :    2729260 : lto_input_ts_common_tree_pointers (class lto_input_block *ib,
     645                 :            :                                    class data_in *data_in, tree expr)
     646                 :            : {
     647                 :    2729260 :   if (TREE_CODE (expr) != IDENTIFIER_NODE)
     648                 :    2175070 :     TREE_TYPE (expr) = stream_read_tree (ib, data_in);
     649                 :    2729260 : }
     650                 :            : 
     651                 :            : 
     652                 :            : /* Read all pointer fields in the TS_VECTOR structure of EXPR from input
     653                 :            :    block IB.  DATA_IN contains tables and descriptors for the
     654                 :            :    file being read.  */
     655                 :            : 
     656                 :            : static void
     657                 :       2634 : lto_input_ts_vector_tree_pointers (class lto_input_block *ib,
     658                 :            :                                    class data_in *data_in, tree expr)
     659                 :            : {
     660                 :       2634 :   unsigned int count = vector_cst_encoded_nelts (expr);
     661                 :      13295 :   for (unsigned int i = 0; i < count; ++i)
     662                 :      10661 :     VECTOR_CST_ENCODED_ELT (expr, i) = stream_read_tree (ib, data_in);
     663                 :       2634 : }
     664                 :            : 
     665                 :            : 
     666                 :            : /* Read all pointer fields in the TS_POLY_INT_CST structure of EXPR from
     667                 :            :    input block IB.  DATA_IN contains tables and descriptors for the
     668                 :            :    file being read.  */
     669                 :            : 
     670                 :            : static void
     671                 :          0 : lto_input_ts_poly_tree_pointers (class lto_input_block *ib,
     672                 :            :                                  class data_in *data_in, tree expr)
     673                 :            : {
     674                 :          0 :   for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
     675                 :          0 :     POLY_INT_CST_COEFF (expr, i) = stream_read_tree (ib, data_in);
     676                 :          0 : }
     677                 :            : 
     678                 :            : 
     679                 :            : /* Read all pointer fields in the TS_COMPLEX structure of EXPR from input
     680                 :            :    block IB.  DATA_IN contains tables and descriptors for the
     681                 :            :    file being read.  */
     682                 :            : 
     683                 :            : static void
     684                 :       6812 : lto_input_ts_complex_tree_pointers (class lto_input_block *ib,
     685                 :            :                                     class data_in *data_in, tree expr)
     686                 :            : {
     687                 :       6812 :   TREE_REALPART (expr) = stream_read_tree (ib, data_in);
     688                 :       6812 :   TREE_IMAGPART (expr) = stream_read_tree (ib, data_in);
     689                 :       6812 : }
     690                 :            : 
     691                 :            : 
     692                 :            : /* Read all pointer fields in the TS_DECL_MINIMAL structure of EXPR
     693                 :            :    from input block IB.  DATA_IN contains tables and descriptors for the
     694                 :            :    file being read.  */
     695                 :            : 
     696                 :            : static void
     697                 :     560705 : lto_input_ts_decl_minimal_tree_pointers (class lto_input_block *ib,
     698                 :            :                                          class data_in *data_in, tree expr)
     699                 :            : {
     700                 :     560705 :   DECL_NAME (expr) = stream_read_tree (ib, data_in);
     701                 :     560705 :   DECL_CONTEXT (expr) = stream_read_tree (ib, data_in);
     702                 :     560705 : }
     703                 :            : 
     704                 :            : 
     705                 :            : /* Read all pointer fields in the TS_DECL_COMMON structure of EXPR from
     706                 :            :    input block IB.  DATA_IN contains tables and descriptors for the
     707                 :            :    file being read.  */
     708                 :            : 
     709                 :            : static void
     710                 :     560705 : lto_input_ts_decl_common_tree_pointers (class lto_input_block *ib,
     711                 :            :                                         class data_in *data_in, tree expr)
     712                 :            : {
     713                 :     560705 :   DECL_SIZE (expr) = stream_read_tree (ib, data_in);
     714                 :     560705 :   DECL_SIZE_UNIT (expr) = stream_read_tree (ib, data_in);
     715                 :     560705 :   DECL_ATTRIBUTES (expr) = stream_read_tree (ib, data_in);
     716                 :     560705 :   DECL_ABSTRACT_ORIGIN (expr) = stream_read_tree (ib, data_in);
     717                 :            : 
     718                 :     429643 :   if ((VAR_P (expr) || TREE_CODE (expr) == PARM_DECL)
     719                 :     776480 :       && DECL_HAS_VALUE_EXPR_P (expr))
     720                 :        682 :     SET_DECL_VALUE_EXPR (expr, stream_read_tree (ib, data_in));
     721                 :            : 
     722                 :     560705 :   if (VAR_P (expr)
     723                 :     560705 :       && DECL_HAS_DEBUG_EXPR_P (expr))
     724                 :            :     {
     725                 :        594 :       tree dexpr = stream_read_tree (ib, data_in);
     726                 :        594 :       if (dexpr)
     727                 :        594 :         SET_DECL_DEBUG_EXPR (expr, dexpr);
     728                 :            :     }
     729                 :     560705 : }
     730                 :            : 
     731                 :            : 
     732                 :            : /* Read all pointer fields in the TS_DECL_NON_COMMON structure of
     733                 :            :    EXPR from input block IB.  DATA_IN contains tables and descriptors for the
     734                 :            :    file being read.  */
     735                 :            : 
     736                 :            : static void
     737                 :          0 : lto_input_ts_decl_non_common_tree_pointers (class lto_input_block *,
     738                 :            :                                             class data_in *, tree)
     739                 :            : {
     740                 :          0 : }
     741                 :            : 
     742                 :            : 
     743                 :            : /* Read all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
     744                 :            :    from input block IB.  DATA_IN contains tables and descriptors for the
     745                 :            :    file being read.  */
     746                 :            : 
     747                 :            : static void
     748                 :     309642 : lto_input_ts_decl_with_vis_tree_pointers (class lto_input_block *ib,
     749                 :            :                                           class data_in *data_in, tree expr)
     750                 :            : {
     751                 :     309642 :   tree id;
     752                 :            : 
     753                 :     309642 :   id = stream_read_tree (ib, data_in);
     754                 :     309642 :   if (id)
     755                 :            :     {
     756                 :     238046 :       gcc_assert (TREE_CODE (id) == IDENTIFIER_NODE);
     757                 :     238046 :       SET_DECL_ASSEMBLER_NAME (expr, id);
     758                 :            :     }
     759                 :     309642 : }
     760                 :            : 
     761                 :            : 
     762                 :            : /* Read all pointer fields in the TS_FIELD_DECL structure of EXPR from
     763                 :            :    input block IB.  DATA_IN contains tables and descriptors for the
     764                 :            :    file being read.  */
     765                 :            : 
     766                 :            : static void
     767                 :      62273 : lto_input_ts_field_decl_tree_pointers (class lto_input_block *ib,
     768                 :            :                                        class data_in *data_in, tree expr)
     769                 :            : {
     770                 :      62273 :   DECL_FIELD_OFFSET (expr) = stream_read_tree (ib, data_in);
     771                 :      62273 :   DECL_BIT_FIELD_TYPE (expr) = stream_read_tree (ib, data_in);
     772                 :      62273 :   DECL_BIT_FIELD_REPRESENTATIVE (expr) = stream_read_tree (ib, data_in);
     773                 :      62273 :   DECL_FIELD_BIT_OFFSET (expr) = stream_read_tree (ib, data_in);
     774                 :      62273 : }
     775                 :            : 
     776                 :            : 
     777                 :            : /* Read all pointer fields in the TS_FUNCTION_DECL structure of EXPR
     778                 :            :    from input block IB.  DATA_IN contains tables and descriptors for the
     779                 :            :    file being read.  */
     780                 :            : 
     781                 :            : static void
     782                 :     160238 : lto_input_ts_function_decl_tree_pointers (class lto_input_block *ib,
     783                 :            :                                           class data_in *data_in, tree expr)
     784                 :            : {
     785                 :            :   /* DECL_STRUCT_FUNCTION is loaded on demand by cgraph_get_body.  */
     786                 :     160238 :   DECL_FUNCTION_PERSONALITY (expr) = stream_read_tree (ib, data_in);
     787                 :            : #ifndef ACCEL_COMPILER
     788                 :     160238 :   DECL_FUNCTION_SPECIFIC_TARGET (expr) = stream_read_tree (ib, data_in);
     789                 :            : #endif
     790                 :     160238 :   DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr) = stream_read_tree (ib, data_in);
     791                 :            : #ifdef ACCEL_COMPILER
     792                 :            :   {
     793                 :            :     tree opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr);
     794                 :            :     if (opts)
     795                 :            :       {
     796                 :            :         struct gcc_options tmp;
     797                 :            :         init_options_struct (&tmp, NULL);
     798                 :            :         cl_optimization_restore (&tmp, TREE_OPTIMIZATION (opts));
     799                 :            :         finish_options (&tmp, &global_options_set, UNKNOWN_LOCATION);
     800                 :            :         opts = build_optimization_node (&tmp);
     801                 :            :         DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr) = opts;
     802                 :            :       }
     803                 :            :   }
     804                 :            : #endif
     805                 :     160238 : }
     806                 :            : 
     807                 :            : 
     808                 :            : /* Read all pointer fields in the TS_TYPE_COMMON structure of EXPR from
     809                 :            :    input block IB.  DATA_IN contains tables and descriptors for the file
     810                 :            :    being read.  */
     811                 :            : 
     812                 :            : static void
     813                 :     363668 : lto_input_ts_type_common_tree_pointers (class lto_input_block *ib,
     814                 :            :                                         class data_in *data_in, tree expr)
     815                 :            : {
     816                 :     363668 :   TYPE_SIZE (expr) = stream_read_tree (ib, data_in);
     817                 :     363668 :   TYPE_SIZE_UNIT (expr) = stream_read_tree (ib, data_in);
     818                 :     363668 :   TYPE_ATTRIBUTES (expr) = stream_read_tree (ib, data_in);
     819                 :     363668 :   TYPE_NAME (expr) = stream_read_tree (ib, data_in);
     820                 :            :   /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO.  They will be
     821                 :            :      reconstructed during fixup.  */
     822                 :            :   /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
     823                 :            :      during fixup.  */
     824                 :     363668 :   TYPE_MAIN_VARIANT (expr) = stream_read_tree (ib, data_in);
     825                 :     363668 :   TYPE_CONTEXT (expr) = stream_read_tree (ib, data_in);
     826                 :            :   /* TYPE_CANONICAL gets re-computed during type merging.  */
     827                 :     363668 :   TYPE_CANONICAL (expr) = NULL_TREE;
     828                 :     363668 : }
     829                 :            : 
     830                 :            : /* Read all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
     831                 :            :    from input block IB.  DATA_IN contains tables and descriptors for the
     832                 :            :    file being read.  */
     833                 :            : 
     834                 :            : static void
     835                 :     363668 : lto_input_ts_type_non_common_tree_pointers (class lto_input_block *ib,
     836                 :            :                                             class data_in *data_in,
     837                 :            :                                             tree expr)
     838                 :            : {
     839                 :     363668 :   if (TREE_CODE (expr) == ENUMERAL_TYPE)
     840                 :        619 :     TYPE_VALUES (expr) = stream_read_tree (ib, data_in);
     841                 :     363049 :   else if (TREE_CODE (expr) == ARRAY_TYPE)
     842                 :      26011 :     TYPE_DOMAIN (expr) = stream_read_tree (ib, data_in);
     843                 :     337038 :   else if (RECORD_OR_UNION_TYPE_P (expr))
     844                 :      47926 :     TYPE_FIELDS (expr) = streamer_read_chain (ib, data_in);
     845                 :     289112 :   else if (TREE_CODE (expr) == FUNCTION_TYPE
     846                 :     289112 :            || TREE_CODE (expr) == METHOD_TYPE)
     847                 :     113250 :     TYPE_ARG_TYPES (expr) = stream_read_tree (ib, data_in);
     848                 :            : 
     849                 :     363668 :   if (!POINTER_TYPE_P (expr))
     850                 :     231083 :     TYPE_MIN_VALUE_RAW (expr) = stream_read_tree (ib, data_in);
     851                 :     363668 :   TYPE_MAX_VALUE_RAW (expr) = stream_read_tree (ib, data_in);
     852                 :     363668 : }
     853                 :            : 
     854                 :            : 
     855                 :            : /* Read all pointer fields in the TS_LIST structure of EXPR from input
     856                 :            :    block IB.  DATA_IN contains tables and descriptors for the
     857                 :            :    file being read.  */
     858                 :            : 
     859                 :            : static void
     860                 :     295813 : lto_input_ts_list_tree_pointers (class lto_input_block *ib,
     861                 :            :                                  class data_in *data_in, tree expr)
     862                 :            : {
     863                 :     295813 :   TREE_PURPOSE (expr) = stream_read_tree (ib, data_in);
     864                 :     295813 :   TREE_VALUE (expr) = stream_read_tree (ib, data_in);
     865                 :     295813 :   TREE_CHAIN (expr) = stream_read_tree (ib, data_in);
     866                 :     295813 : }
     867                 :            : 
     868                 :            : 
     869                 :            : /* Read all pointer fields in the TS_VEC structure of EXPR from input
     870                 :            :    block IB.  DATA_IN contains tables and descriptors for the
     871                 :            :    file being read.  */
     872                 :            : 
     873                 :            : static void
     874                 :          0 : lto_input_ts_vec_tree_pointers (class lto_input_block *ib,
     875                 :            :                                 class data_in *data_in, tree expr)
     876                 :            : {
     877                 :          0 :   int i;
     878                 :            : 
     879                 :            :   /* Note that TREE_VEC_LENGTH was read by streamer_alloc_tree to
     880                 :            :      instantiate EXPR.  */
     881                 :          0 :   for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
     882                 :          0 :     TREE_VEC_ELT (expr, i) = stream_read_tree (ib, data_in);
     883                 :          0 : }
     884                 :            : 
     885                 :            : 
     886                 :            : /* Read all pointer fields in the TS_EXP structure of EXPR from input
     887                 :            :    block IB.  DATA_IN contains tables and descriptors for the
     888                 :            :    file being read.  */
     889                 :            : 
     890                 :            : 
     891                 :            : static void
     892                 :     762834 : lto_input_ts_exp_tree_pointers (class lto_input_block *ib,
     893                 :            :                                 class data_in *data_in, tree expr)
     894                 :            : {
     895                 :     762834 :   int i;
     896                 :     762834 :   tree block;
     897                 :            : 
     898                 :    1909940 :   for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
     899                 :    1147100 :     TREE_OPERAND (expr, i) = stream_read_tree (ib, data_in);
     900                 :            : 
     901                 :     762834 :   block = stream_read_tree (ib, data_in);
     902                 :            : 
     903                 :            :   /* TODO: Block is stored in the locus information.  It may make more sense to
     904                 :            :      to make it go via the location cache.  */
     905                 :     762834 :   if (block)
     906                 :            :     {
     907                 :      62064 :       data_in->location_cache.apply_location_cache ();
     908                 :      62064 :       TREE_SET_BLOCK (expr, block);
     909                 :            :     }
     910                 :     762834 : }
     911                 :            : 
     912                 :            : 
     913                 :            : /* Read all pointer fields in the TS_BLOCK structure of EXPR from input
     914                 :            :    block IB.  DATA_IN contains tables and descriptors for the
     915                 :            :    file being read.  */
     916                 :            : 
     917                 :            : static void
     918                 :     132292 : lto_input_ts_block_tree_pointers (class lto_input_block *ib,
     919                 :            :                                   class data_in *data_in, tree expr)
     920                 :            : {
     921                 :     132292 :   BLOCK_VARS (expr) = streamer_read_chain (ib, data_in);
     922                 :            : 
     923                 :     132292 :   BLOCK_SUPERCONTEXT (expr) = stream_read_tree (ib, data_in);
     924                 :     132292 :   BLOCK_ABSTRACT_ORIGIN (expr) = stream_read_tree (ib, data_in);
     925                 :            :   /* We may end up prevailing a decl with DECL_ORIGIN (t) != t here
     926                 :            :      which breaks the invariant that BLOCK_ABSTRACT_ORIGIN is the
     927                 :            :      ultimate origin.  Fixup here.
     928                 :            :      ???  This should get fixed with moving to DIE references.  */
     929                 :     132292 :   if (DECL_P (BLOCK_ORIGIN (expr)))
     930                 :       7872 :     BLOCK_ABSTRACT_ORIGIN (expr) = DECL_ORIGIN (BLOCK_ABSTRACT_ORIGIN (expr));
     931                 :            :   /* Do not stream BLOCK_NONLOCALIZED_VARS.  We cannot handle debug information
     932                 :            :      for early inlined BLOCKs so drop it on the floor instead of ICEing in
     933                 :            :      dwarf2out.c.  */
     934                 :            : 
     935                 :            :   /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
     936                 :            :      streaming time.  */
     937                 :            : 
     938                 :            :   /* We re-compute BLOCK_SUBBLOCKS of our parent here instead
     939                 :            :      of streaming it.  For non-BLOCK BLOCK_SUPERCONTEXTs we still
     940                 :            :      stream the child relationship explicitly.  */
     941                 :     132292 :   if (BLOCK_SUPERCONTEXT (expr)
     942                 :     132292 :       && TREE_CODE (BLOCK_SUPERCONTEXT (expr)) == BLOCK)
     943                 :            :     {
     944                 :      47634 :       BLOCK_CHAIN (expr) = BLOCK_SUBBLOCKS (BLOCK_SUPERCONTEXT (expr));
     945                 :      47634 :       BLOCK_SUBBLOCKS (BLOCK_SUPERCONTEXT (expr)) = expr;
     946                 :            :     }
     947                 :            : 
     948                 :            :   /* The global block is rooted at the TU decl.  Hook it here to
     949                 :            :      avoid the need to stream in this block during WPA time.  */
     950                 :      84658 :   else if (BLOCK_SUPERCONTEXT (expr)
     951                 :      84658 :            && TREE_CODE (BLOCK_SUPERCONTEXT (expr)) == TRANSLATION_UNIT_DECL)
     952                 :          0 :     DECL_INITIAL (BLOCK_SUPERCONTEXT (expr)) = expr;
     953                 :            : 
     954                 :            :   /* The function-level block is connected at the time we read in
     955                 :            :      function bodies for the same reason.  */
     956                 :     132292 : }
     957                 :            : 
     958                 :            : 
     959                 :            : /* Read all pointer fields in the TS_BINFO structure of EXPR from input
     960                 :            :    block IB.  DATA_IN contains tables and descriptors for the
     961                 :            :    file being read.  */
     962                 :            : 
     963                 :            : static void
     964                 :       5772 : lto_input_ts_binfo_tree_pointers (class lto_input_block *ib,
     965                 :            :                                   class data_in *data_in, tree expr)
     966                 :            : {
     967                 :      11807 :   tree t;
     968                 :            : 
     969                 :            :   /* Note that the number of slots in EXPR was read in
     970                 :            :      streamer_alloc_tree when instantiating EXPR.  However, the
     971                 :            :      vector is empty so we cannot rely on vec::length to know how many
     972                 :            :      elements to read.  So, this list is emitted as a 0-terminated
     973                 :            :      list on the writer side.  */
     974                 :      11807 :   do
     975                 :            :     {
     976                 :      11807 :       t = stream_read_tree (ib, data_in);
     977                 :      11807 :       if (t)
     978                 :       6035 :         BINFO_BASE_BINFOS (expr)->quick_push (t);
     979                 :            :     }
     980                 :      11807 :   while (t);
     981                 :            : 
     982                 :       5772 :   BINFO_OFFSET (expr) = stream_read_tree (ib, data_in);
     983                 :       5772 :   BINFO_VTABLE (expr) = stream_read_tree (ib, data_in);
     984                 :            : 
     985                 :            :   /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX,
     986                 :            :      BINFO_BASE_ACCESSES and BINFO_VPTR_INDEX; these are used by C++ FE
     987                 :            :      only.  */
     988                 :       5772 : }
     989                 :            : 
     990                 :            : 
     991                 :            : /* Read all pointer fields in the TS_CONSTRUCTOR structure of EXPR from
     992                 :            :    input block IB.  DATA_IN contains tables and descriptors for the
     993                 :            :    file being read.  */
     994                 :            : 
     995                 :            : static void
     996                 :      28225 : lto_input_ts_constructor_tree_pointers (class lto_input_block *ib,
     997                 :            :                                         class data_in *data_in, tree expr)
     998                 :            : {
     999                 :      28225 :   unsigned i;
    1000                 :            : 
    1001                 :     231605 :   for (i = 0; i < CONSTRUCTOR_NELTS (expr); i++)
    1002                 :            :     {
    1003                 :      93753 :       constructor_elt e;
    1004                 :      93753 :       e.index = stream_read_tree (ib, data_in);
    1005                 :      93753 :       e.value = stream_read_tree (ib, data_in);
    1006                 :      93753 :       (*CONSTRUCTOR_ELTS (expr))[i] = e;
    1007                 :            :     }
    1008                 :      28225 : }
    1009                 :            : 
    1010                 :            : 
    1011                 :            : /* Read all pointer fields in the TS_OMP_CLAUSE structure of EXPR from
    1012                 :            :    input block IB.  DATA_IN contains tables and descriptors for the
    1013                 :            :    file being read.  */
    1014                 :            : 
    1015                 :            : static void
    1016                 :        194 : lto_input_ts_omp_clause_tree_pointers (class lto_input_block *ib,
    1017                 :            :                                        class data_in *data_in, tree expr)
    1018                 :            : {
    1019                 :        194 :   int i;
    1020                 :            : 
    1021                 :        465 :   for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (expr)]; i++)
    1022                 :        271 :     OMP_CLAUSE_OPERAND (expr, i) = stream_read_tree (ib, data_in);
    1023                 :        194 :   OMP_CLAUSE_CHAIN (expr) = stream_read_tree (ib, data_in);
    1024                 :        194 : }
    1025                 :            : 
    1026                 :            : 
    1027                 :            : /* Read all pointer fields in EXPR from input block IB.  DATA_IN
    1028                 :            :    contains tables and descriptors for the file being read.  */
    1029                 :            : 
    1030                 :            : void
    1031                 :    2891080 : streamer_read_tree_body (class lto_input_block *ib, class data_in *data_in,
    1032                 :            :                          tree expr)
    1033                 :            : {
    1034                 :    2891080 :   enum tree_code code;
    1035                 :            : 
    1036                 :    2891080 :   code = TREE_CODE (expr);
    1037                 :            : 
    1038                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
    1039                 :    2729260 :     lto_input_ts_common_tree_pointers (ib, data_in, expr);
    1040                 :            : 
    1041                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
    1042                 :       2634 :     lto_input_ts_vector_tree_pointers (ib, data_in, expr);
    1043                 :            : 
    1044                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_POLY_INT_CST))
    1045                 :          0 :     lto_input_ts_poly_tree_pointers (ib, data_in, expr);
    1046                 :            : 
    1047                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
    1048                 :       6812 :     lto_input_ts_complex_tree_pointers (ib, data_in, expr);
    1049                 :            : 
    1050                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
    1051                 :     560705 :     lto_input_ts_decl_minimal_tree_pointers (ib, data_in, expr);
    1052                 :            : 
    1053                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
    1054                 :     560705 :     lto_input_ts_decl_common_tree_pointers (ib, data_in, expr);
    1055                 :            : 
    1056                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
    1057                 :    2891080 :     lto_input_ts_decl_non_common_tree_pointers (ib, data_in, expr);
    1058                 :            : 
    1059                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
    1060                 :     309642 :     lto_input_ts_decl_with_vis_tree_pointers (ib, data_in, expr);
    1061                 :            : 
    1062                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
    1063                 :      62273 :     lto_input_ts_field_decl_tree_pointers (ib, data_in, expr);
    1064                 :            : 
    1065                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
    1066                 :     160238 :     lto_input_ts_function_decl_tree_pointers (ib, data_in, expr);
    1067                 :            : 
    1068                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
    1069                 :     363668 :     lto_input_ts_type_common_tree_pointers (ib, data_in, expr);
    1070                 :            : 
    1071                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
    1072                 :     363668 :     lto_input_ts_type_non_common_tree_pointers (ib, data_in, expr);
    1073                 :            : 
    1074                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_LIST))
    1075                 :     295813 :     lto_input_ts_list_tree_pointers (ib, data_in, expr);
    1076                 :            : 
    1077                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_VEC))
    1078                 :          0 :     lto_input_ts_vec_tree_pointers (ib, data_in, expr);
    1079                 :            : 
    1080                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
    1081                 :     762834 :     lto_input_ts_exp_tree_pointers (ib, data_in, expr);
    1082                 :            : 
    1083                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
    1084                 :     132292 :     lto_input_ts_block_tree_pointers (ib, data_in, expr);
    1085                 :            : 
    1086                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
    1087                 :       5772 :     lto_input_ts_binfo_tree_pointers (ib, data_in, expr);
    1088                 :            : 
    1089                 :    2891080 :   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
    1090                 :      28225 :     lto_input_ts_constructor_tree_pointers (ib, data_in, expr);
    1091                 :            : 
    1092                 :    2891080 :   if (code == OMP_CLAUSE)
    1093                 :        194 :     lto_input_ts_omp_clause_tree_pointers (ib, data_in, expr);
    1094                 :    2891080 : }
    1095                 :            : 
    1096                 :            : 
    1097                 :            : /* Read an index IX from input block IB and return the tree node at
    1098                 :            :    DATA_IN->FILE_DATA->GLOBALS_INDEX[IX].  */
    1099                 :            : 
    1100                 :            : tree
    1101                 :    8683370 : streamer_get_pickled_tree (class lto_input_block *ib, class data_in *data_in)
    1102                 :            : {
    1103                 :    8683370 :   unsigned HOST_WIDE_INT ix;
    1104                 :    8683370 :   tree result;
    1105                 :    8683370 :   enum LTO_tags expected_tag;
    1106                 :            : 
    1107                 :    8683370 :   ix = streamer_read_uhwi (ib);
    1108                 :    8683370 :   expected_tag = streamer_read_enum (ib, LTO_tags, LTO_NUM_TAGS);
    1109                 :            : 
    1110                 :    8683370 :   result = streamer_tree_cache_get_tree (data_in->reader_cache, ix);
    1111                 :    8683370 :   gcc_assert (result
    1112                 :            :               && TREE_CODE (result) == lto_tag_to_tree_code (expected_tag));
    1113                 :            : 
    1114                 :    8683370 :   return result;
    1115                 :            : }

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.