LCOV - code coverage report
Current view: top level - gcc - tree-streamer-out.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 426 476 89.5 %
Date: 2020-03-28 11:57:23 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 emitting trees to 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 "tree-streamer.h"
      30                 :            : #include "cgraph.h"
      31                 :            : #include "alias.h"
      32                 :            : #include "stor-layout.h"
      33                 :            : #include "gomp-constants.h"
      34                 :            : 
      35                 :            : 
      36                 :            : /* Output the STRING constant to the string
      37                 :            :    table in OB.  Then put the index onto the INDEX_STREAM.  */
      38                 :            : 
      39                 :            : void
      40                 :      46164 : streamer_write_string_cst (struct output_block *ob,
      41                 :            :                            struct lto_output_stream *index_stream,
      42                 :            :                            tree string)
      43                 :            : {
      44                 :     138448 :   streamer_write_string_with_length (ob, index_stream,
      45                 :      46142 :                                      string ? TREE_STRING_POINTER (string)
      46                 :            :                                             : NULL,
      47                 :      46142 :                                      string ? TREE_STRING_LENGTH (string) : 0,
      48                 :            :                                      true);
      49                 :      46164 : }
      50                 :            : 
      51                 :            : 
      52                 :            : /* Output the identifier ID to the string
      53                 :            :    table in OB.  Then put the index onto the INDEX_STREAM.  */
      54                 :            : 
      55                 :            : static void
      56                 :    1287090 : write_identifier (struct output_block *ob,
      57                 :            :                    struct lto_output_stream *index_stream,
      58                 :            :                    tree id)
      59                 :            : {
      60                 :    1287090 :   streamer_write_string_with_length (ob, index_stream,
      61                 :    1287090 :                                      IDENTIFIER_POINTER (id),
      62                 :    1287090 :                                      IDENTIFIER_LENGTH (id),
      63                 :            :                                      true);
      64                 :    1287090 : }
      65                 :            : 
      66                 :            : 
      67                 :            : /* Pack all the non-pointer fields of the TS_BASE structure of
      68                 :            :    expression EXPR into bitpack BP.  */
      69                 :            : 
      70                 :            : static inline void
      71                 :    5371350 : pack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
      72                 :            : {
      73                 :    5371350 :   bp_pack_value (bp, TREE_CODE (expr), 16);
      74                 :    5371350 :   if (!TYPE_P (expr))
      75                 :            :     {
      76                 :    4866820 :       bp_pack_value (bp, TREE_SIDE_EFFECTS (expr), 1);
      77                 :    4866820 :       bp_pack_value (bp, TREE_CONSTANT (expr), 1);
      78                 :    4866820 :       bp_pack_value (bp, TREE_READONLY (expr), 1);
      79                 :            : 
      80                 :            :       /* TREE_PUBLIC is used on types to indicate that the type
      81                 :            :          has a TYPE_CACHED_VALUES vector.  This is not streamed out,
      82                 :            :          so we skip it here.  */
      83                 :    4866820 :       bp_pack_value (bp, TREE_PUBLIC (expr), 1);
      84                 :            :     }
      85                 :            :   else
      86                 :     504537 :     bp_pack_value (bp, 0, 4);
      87                 :    5371350 :   bp_pack_value (bp, TREE_ADDRESSABLE (expr), 1);
      88                 :    5371350 :   bp_pack_value (bp, TREE_THIS_VOLATILE (expr), 1);
      89                 :    5371350 :   if (DECL_P (expr))
      90                 :            :     {
      91                 :    1305790 :       bp_pack_value (bp, DECL_UNSIGNED (expr), 1);
      92                 :    1305790 :       bp_pack_value (bp, DECL_NAMELESS (expr), 1);
      93                 :            :     }
      94                 :    4065560 :   else if (TYPE_P (expr))
      95                 :     504537 :     bp_pack_value (bp, TYPE_UNSIGNED (expr), 1);
      96                 :            :   else
      97                 :    3561030 :     bp_pack_value (bp, 0, 1);
      98                 :            :   /* We write debug info two times, do not confuse the second one.
      99                 :            :      The only relevant TREE_ASM_WRITTEN use is on SSA names.  */
     100                 :    5371350 :   bp_pack_value (bp, (TREE_CODE (expr) != SSA_NAME
     101                 :          0 :                       ? 0 : TREE_ASM_WRITTEN (expr)), 1);
     102                 :    5371350 :   if (TYPE_P (expr))
     103                 :     504537 :     bp_pack_value (bp, TYPE_ARTIFICIAL (expr), 1);
     104                 :            :   else
     105                 :    4866820 :     bp_pack_value (bp, TREE_NO_WARNING (expr), 1);
     106                 :    5371350 :   bp_pack_value (bp, TREE_NOTHROW (expr), 1);
     107                 :    5371350 :   bp_pack_value (bp, TREE_STATIC (expr), 1);
     108                 :    5371350 :   if (TREE_CODE (expr) != TREE_BINFO)
     109                 :    5364270 :     bp_pack_value (bp, TREE_PRIVATE (expr), 1);
     110                 :            :   else
     111                 :       7078 :     bp_pack_value (bp, 0, 1);
     112                 :    5371350 :   bp_pack_value (bp, TREE_PROTECTED (expr), 1);
     113                 :    5371350 :   bp_pack_value (bp, TREE_DEPRECATED (expr), 1);
     114                 :    5371350 :   if (TYPE_P (expr))
     115                 :            :     {
     116                 :     504537 :       if (AGGREGATE_TYPE_P (expr))
     117                 :     113679 :         bp_pack_value (bp, TYPE_REVERSE_STORAGE_ORDER (expr), 1);
     118                 :            :       else
     119                 :     390858 :         bp_pack_value (bp, TYPE_SATURATING (expr), 1);
     120                 :     504537 :       bp_pack_value (bp, TYPE_ADDR_SPACE (expr), 8);
     121                 :            :     }
     122                 :    4866820 :   else if (TREE_CODE (expr) == BIT_FIELD_REF || TREE_CODE (expr) == MEM_REF)
     123                 :            :     {
     124                 :     448900 :       bp_pack_value (bp, REF_REVERSE_STORAGE_ORDER (expr), 1);
     125                 :     226154 :       bp_pack_value (bp, 0, 8);
     126                 :            :     }
     127                 :    4640660 :   else if (TREE_CODE (expr) == SSA_NAME)
     128                 :            :     {
     129                 :          0 :       bp_pack_value (bp, SSA_NAME_IS_DEFAULT_DEF (expr), 1);
     130                 :          0 :       bp_pack_value (bp, 0, 8);
     131                 :            :     }
     132                 :    4640660 :   else if (TREE_CODE (expr) == CALL_EXPR)
     133                 :            :     {
     134                 :         24 :       bp_pack_value (bp, CALL_EXPR_BY_DESCRIPTOR (expr), 1);
     135                 :         24 :       bp_pack_value (bp, 0, 8);
     136                 :            :     }
     137                 :            :   else
     138                 :    4640640 :     bp_pack_value (bp, 0, 9);
     139                 :    5371350 : }
     140                 :            : 
     141                 :            : 
     142                 :            : /* Pack all the non-pointer fields of the TS_INTEGER_CST structure of
     143                 :            :    expression EXPR into bitpack BP.  */
     144                 :            : 
     145                 :            : static void
     146                 :      29752 : pack_ts_int_cst_value_fields (struct bitpack_d *bp, tree expr)
     147                 :            : {
     148                 :      29752 :   int i;
     149                 :            :   /* Note that the number of elements has already been written out in
     150                 :            :      streamer_write_tree_header.  */
     151                 :      59560 :   for (i = 0; i < TREE_INT_CST_EXT_NUNITS (expr); i++)
     152                 :      29808 :     bp_pack_var_len_int (bp, TREE_INT_CST_ELT (expr, i));
     153                 :      29752 : }
     154                 :            : 
     155                 :            : 
     156                 :            : /* Pack all the non-pointer fields of the TS_REAL_CST structure of
     157                 :            :    expression EXPR into bitpack BP.  */
     158                 :            : 
     159                 :            : static void
     160                 :      91409 : pack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
     161                 :            : {
     162                 :      91409 :   unsigned i;
     163                 :      91409 :   REAL_VALUE_TYPE r;
     164                 :            : 
     165                 :      91409 :   r = TREE_REAL_CST (expr);
     166                 :      91409 :   bp_pack_value (bp, r.cl, 2);
     167                 :      91409 :   bp_pack_value (bp, r.decimal, 1);
     168                 :      91409 :   bp_pack_value (bp, r.sign, 1);
     169                 :      91409 :   bp_pack_value (bp, r.signalling, 1);
     170                 :      91409 :   bp_pack_value (bp, r.canonical, 1);
     171                 :      91409 :   bp_pack_value (bp, r.uexp, EXP_BITS);
     172                 :     365636 :   for (i = 0; i < SIGSZ; i++)
     173                 :     274227 :     bp_pack_value (bp, r.sig[i], HOST_BITS_PER_LONG);
     174                 :      91409 : }
     175                 :            : 
     176                 :            : 
     177                 :            : /* Pack all the non-pointer fields of the TS_FIXED_CST structure of
     178                 :            :    expression EXPR into bitpack BP.  */
     179                 :            : 
     180                 :            : static void
     181                 :          0 : pack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr)
     182                 :            : {
     183                 :          0 :   struct fixed_value fv = TREE_FIXED_CST (expr);
     184                 :          0 :   bp_pack_machine_mode (bp, fv.mode);
     185                 :          0 :   bp_pack_var_len_int (bp, fv.data.low);
     186                 :          0 :   bp_pack_var_len_int (bp, fv.data.high);
     187                 :          0 : }
     188                 :            : 
     189                 :            : /* Pack all the non-pointer fields of the TS_DECL_COMMON structure
     190                 :            :    of expression EXPR into bitpack BP.  */
     191                 :            : 
     192                 :            : static void
     193                 :    1305790 : pack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr)
     194                 :            : {
     195                 :    1305790 :   bp_pack_machine_mode (bp, DECL_MODE (expr));
     196                 :    1305790 :   bp_pack_value (bp, DECL_NONLOCAL (expr), 1);
     197                 :    1305790 :   bp_pack_value (bp, DECL_VIRTUAL_P (expr), 1);
     198                 :    1305790 :   bp_pack_value (bp, DECL_IGNORED_P (expr), 1);
     199                 :    1305790 :   bp_pack_value (bp, DECL_ABSTRACT_P (expr), 1);
     200                 :    1305790 :   bp_pack_value (bp, DECL_ARTIFICIAL (expr), 1);
     201                 :    1305790 :   bp_pack_value (bp, DECL_USER_ALIGN (expr), 1);
     202                 :    1305790 :   bp_pack_value (bp, DECL_PRESERVE_P (expr), 1);
     203                 :    1305790 :   bp_pack_value (bp, DECL_EXTERNAL (expr), 1);
     204                 :    1305790 :   bp_pack_value (bp, DECL_GIMPLE_REG_P (expr), 1);
     205                 :    1305790 :   bp_pack_var_len_unsigned (bp, DECL_ALIGN (expr));
     206                 :            : 
     207                 :    1305790 :   if (TREE_CODE (expr) == LABEL_DECL)
     208                 :            :     {
     209                 :            :       /* Note that we do not write LABEL_DECL_UID.  The reader will
     210                 :            :          always assume an initial value of -1 so that the
     211                 :            :          label_to_block_map is recreated by gimple_set_bb.  */
     212                 :      15753 :       bp_pack_var_len_unsigned (bp, EH_LANDING_PAD_NR (expr));
     213                 :            :     }
     214                 :            : 
     215                 :    1290040 :   else if (TREE_CODE (expr) == FIELD_DECL)
     216                 :            :     {
     217                 :      94337 :       bp_pack_value (bp, DECL_PACKED (expr), 1);
     218                 :      94337 :       bp_pack_value (bp, DECL_NONADDRESSABLE_P (expr), 1);
     219                 :      94337 :       bp_pack_value (bp, DECL_PADDING_P (expr), 1);
     220                 :      94337 :       bp_pack_value (bp, expr->decl_common.off_align, 8);
     221                 :            :     }
     222                 :            : 
     223                 :    1195700 :   else if (VAR_P (expr))
     224                 :            :     {
     225                 :     360780 :       bp_pack_value (bp, DECL_HAS_DEBUG_EXPR_P (expr), 1);
     226                 :     360780 :       bp_pack_value (bp, DECL_NONLOCAL_FRAME (expr), 1);
     227                 :            :     }
     228                 :            : 
     229                 :     834919 :   else if (TREE_CODE (expr) == PARM_DECL)
     230                 :     312067 :     bp_pack_value (bp, DECL_HIDDEN_STRING_LENGTH (expr), 1);
     231                 :            : 
     232                 :    1305790 :   if (TREE_CODE (expr) == RESULT_DECL
     233                 :    1305790 :       || TREE_CODE (expr) == PARM_DECL
     234                 :     901690 :       || VAR_P (expr))
     235                 :            :     {
     236                 :    1168980 :       bp_pack_value (bp, DECL_BY_REFERENCE (expr), 1);
     237                 :     764879 :       if (VAR_P (expr) || TREE_CODE (expr) == PARM_DECL)
     238                 :     984914 :         bp_pack_value (bp, DECL_HAS_VALUE_EXPR_P (expr), 1);
     239                 :            :     }
     240                 :    1305790 : }
     241                 :            : 
     242                 :            : 
     243                 :            : /* Pack all the non-pointer fields of the TS_DECL_WRTL structure
     244                 :            :    of expression EXPR into bitpack BP.  */
     245                 :            : 
     246                 :            : static void
     247                 :    1189110 : pack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
     248                 :            : {
     249                 :    1189110 :   bp_pack_value (bp, DECL_REGISTER (expr), 1);
     250                 :    1189110 : }
     251                 :            : 
     252                 :            : 
     253                 :            : /* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
     254                 :            :    of expression EXPR into bitpack BP.  */
     255                 :            : 
     256                 :            : static void
     257                 :     768767 : pack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
     258                 :            : {
     259                 :     768767 :   bp_pack_value (bp, DECL_COMMON (expr), 1);
     260                 :     768767 :   bp_pack_value (bp, DECL_DLLIMPORT_P (expr), 1);
     261                 :     768767 :   bp_pack_value (bp, DECL_WEAK (expr), 1);
     262                 :     768767 :   bp_pack_value (bp, DECL_SEEN_IN_BIND_EXPR_P (expr),  1);
     263                 :     768767 :   bp_pack_value (bp, DECL_COMDAT (expr),  1);
     264                 :     768767 :   bp_pack_value (bp, DECL_VISIBILITY (expr),  2);
     265                 :     768767 :   bp_pack_value (bp, DECL_VISIBILITY_SPECIFIED (expr),  1);
     266                 :            : 
     267                 :     768767 :   if (VAR_P (expr))
     268                 :            :     {
     269                 :     360780 :       bp_pack_value (bp, DECL_HARD_REGISTER (expr), 1);
     270                 :            :       /* DECL_IN_TEXT_SECTION is set during final asm output only. */
     271                 :     360780 :       bp_pack_value (bp, DECL_IN_CONSTANT_POOL (expr), 1);
     272                 :            :     }
     273                 :            : 
     274                 :     768767 :   if (TREE_CODE (expr) == FUNCTION_DECL)
     275                 :            :     {
     276                 :     382135 :       bp_pack_value (bp, DECL_FINAL_P (expr), 1);
     277                 :     382135 :       bp_pack_value (bp, DECL_CXX_CONSTRUCTOR_P (expr), 1);
     278                 :     382135 :       bp_pack_value (bp, DECL_CXX_DESTRUCTOR_P (expr), 1);
     279                 :            :     }
     280                 :     768767 : }
     281                 :            : 
     282                 :            : 
     283                 :            : /* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure
     284                 :            :    of expression EXPR into bitpack BP.  */
     285                 :            : 
     286                 :            : static void
     287                 :     382135 : pack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
     288                 :            : {
     289                 :     382135 :   bp_pack_enum (bp, built_in_class, BUILT_IN_LAST,
     290                 :            :                 DECL_BUILT_IN_CLASS (expr));
     291                 :     382135 :   bp_pack_value (bp, DECL_STATIC_CONSTRUCTOR (expr), 1);
     292                 :     382135 :   bp_pack_value (bp, DECL_STATIC_DESTRUCTOR (expr), 1);
     293                 :     382135 :   bp_pack_value (bp, DECL_UNINLINABLE (expr), 1);
     294                 :     382135 :   bp_pack_value (bp, DECL_POSSIBLY_INLINED (expr), 1);
     295                 :     382135 :   bp_pack_value (bp, DECL_IS_NOVOPS (expr), 1);
     296                 :     382135 :   bp_pack_value (bp, DECL_IS_RETURNS_TWICE (expr), 1);
     297                 :     382135 :   bp_pack_value (bp, DECL_IS_MALLOC (expr), 1);
     298                 :     382135 :   bp_pack_value (bp, DECL_IS_OPERATOR_NEW_P (expr), 1);
     299                 :     382135 :   bp_pack_value (bp, DECL_IS_OPERATOR_DELETE_P (expr), 1);
     300                 :     382135 :   bp_pack_value (bp, DECL_DECLARED_INLINE_P (expr), 1);
     301                 :     382135 :   bp_pack_value (bp, DECL_STATIC_CHAIN (expr), 1);
     302                 :     382135 :   bp_pack_value (bp, DECL_NO_INLINE_WARNING_P (expr), 1);
     303                 :     382135 :   bp_pack_value (bp, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr), 1);
     304                 :     382135 :   bp_pack_value (bp, DECL_NO_LIMIT_STACK (expr), 1);
     305                 :     382135 :   bp_pack_value (bp, DECL_DISREGARD_INLINE_LIMITS (expr), 1);
     306                 :     382135 :   bp_pack_value (bp, DECL_PURE_P (expr), 1);
     307                 :     382135 :   bp_pack_value (bp, DECL_LOOPING_CONST_OR_PURE_P (expr), 1);
     308                 :     382135 :   if (DECL_BUILT_IN_CLASS (expr) != NOT_BUILT_IN)
     309                 :      24491 :     bp_pack_value (bp, DECL_UNCHECKED_FUNCTION_CODE (expr), 32);
     310                 :     382135 : }
     311                 :            : 
     312                 :            : 
     313                 :            : /* Pack all the non-pointer fields of the TS_TYPE_COMMON structure
     314                 :            :    of expression EXPR into bitpack BP.  */
     315                 :            : 
     316                 :            : static void
     317                 :     504537 : pack_ts_type_common_value_fields (struct bitpack_d *bp, tree expr)
     318                 :            : {
     319                 :            :   /* for VECTOR_TYPE, TYPE_MODE reevaluates the mode using target_flags
     320                 :            :      not necessary valid in a global context.
     321                 :            :      Use the raw value previously set by layout_type.  */
     322                 :     504537 :   bp_pack_machine_mode (bp, TYPE_MODE_RAW (expr));
     323                 :            :   /* TYPE_NO_FORCE_BLK is private to stor-layout and need
     324                 :            :      no streaming.  */
     325                 :     504537 :   bp_pack_value (bp, TYPE_PACKED (expr), 1);
     326                 :     504537 :   bp_pack_value (bp, TYPE_RESTRICT (expr), 1);
     327                 :     504537 :   bp_pack_value (bp, TYPE_USER_ALIGN (expr), 1);
     328                 :     504537 :   bp_pack_value (bp, TYPE_READONLY (expr), 1);
     329                 :     504537 :   unsigned vla_p;
     330                 :     504537 :   if (in_lto_p)
     331                 :     136945 :     vla_p = TYPE_LANG_FLAG_0 (TYPE_MAIN_VARIANT (expr));
     332                 :            :   else
     333                 :     367592 :     vla_p = variably_modified_type_p (expr, NULL_TREE);
     334                 :     504537 :   bp_pack_value (bp, vla_p, 1);
     335                 :            :   /* We used to stream TYPE_ALIAS_SET == 0 information to let frontends mark
     336                 :            :      types that are opaque for TBAA.  This however did not work as intended,
     337                 :            :      because TYPE_ALIAS_SET == 0 was regularly lost in type merging.  */
     338                 :     504537 :   if (RECORD_OR_UNION_TYPE_P (expr))
     339                 :            :     {
     340                 :      82000 :       bp_pack_value (bp, TYPE_TRANSPARENT_AGGR (expr), 1);
     341                 :      83289 :       bp_pack_value (bp, TYPE_FINAL_P (expr), 1);
     342                 :      83289 :       bp_pack_value (bp, TYPE_CXX_ODR_P (expr), 1);
     343                 :            :     }
     344                 :     422537 :   else if (TREE_CODE (expr) == ARRAY_TYPE)
     345                 :      31679 :     bp_pack_value (bp, TYPE_NONALIASED_COMPONENT (expr), 1);
     346                 :     504537 :   if (TREE_CODE (expr) == ARRAY_TYPE || TREE_CODE (expr) == INTEGER_TYPE)
     347                 :     124679 :     bp_pack_value (bp, TYPE_STRING_FLAG (expr), 1);
     348                 :     504537 :   if (AGGREGATE_TYPE_P (expr))
     349                 :     113679 :     bp_pack_value (bp, TYPE_TYPELESS_STORAGE (expr), 1);
     350                 :     504537 :   bp_pack_value (bp, TYPE_EMPTY_P (expr), 1);
     351                 :     504537 :   bp_pack_var_len_unsigned (bp, TYPE_PRECISION (expr));
     352                 :     504537 :   bp_pack_var_len_unsigned (bp, TYPE_ALIGN (expr));
     353                 :     504537 : }
     354                 :            : 
     355                 :            : 
     356                 :            : /* Pack all the non-pointer fields of the TS_BLOCK structure
     357                 :            :    of expression EXPR into bitpack BP.  */
     358                 :            : 
     359                 :            : static void
     360                 :     163192 : pack_ts_block_value_fields (struct output_block *ob,
     361                 :            :                             struct bitpack_d *bp, tree expr)
     362                 :            : {
     363                 :            :   /* BLOCK_NUMBER is recomputed.  */
     364                 :            :   /* Stream BLOCK_SOURCE_LOCATION for the limited cases we can handle - those
     365                 :            :      that represent inlined function scopes.
     366                 :            :      For the rest them on the floor instead of ICEing in dwarf2out.c.  */
     367                 :     163192 :   if (inlined_function_outer_scope_p (expr))
     368                 :      10472 :     stream_output_location (ob, bp, BLOCK_SOURCE_LOCATION (expr));
     369                 :            :   else
     370                 :     152720 :     stream_output_location (ob, bp, UNKNOWN_LOCATION);
     371                 :     163192 : }
     372                 :            : 
     373                 :            : /* Pack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL structure
     374                 :            :    of expression EXPR into bitpack BP.  */
     375                 :            : 
     376                 :            : static void
     377                 :      22221 : pack_ts_translation_unit_decl_value_fields (struct output_block *ob,
     378                 :            :                                             struct bitpack_d *bp, tree expr)
     379                 :            : {
     380                 :      22221 :   bp_pack_string (ob, bp, TRANSLATION_UNIT_LANGUAGE (expr), true);
     381                 :      22221 : }
     382                 :            : 
     383                 :            : 
     384                 :            : /* Pack all the non-pointer fields of the TS_OMP_CLAUSE structure
     385                 :            :    of expression EXPR into bitpack BP.  */
     386                 :            : 
     387                 :            : static void
     388                 :        196 : pack_ts_omp_clause_value_fields (struct output_block *ob,
     389                 :            :                                  struct bitpack_d *bp, tree expr)
     390                 :            : {
     391                 :        196 :   stream_output_location (ob, bp, OMP_CLAUSE_LOCATION (expr));
     392                 :        196 :   switch (OMP_CLAUSE_CODE (expr))
     393                 :            :     {
     394                 :          0 :     case OMP_CLAUSE_DEFAULT:
     395                 :          0 :       bp_pack_enum (bp, omp_clause_default_kind, OMP_CLAUSE_DEFAULT_LAST,
     396                 :            :                     OMP_CLAUSE_DEFAULT_KIND (expr));
     397                 :          0 :       break;
     398                 :          0 :     case OMP_CLAUSE_SCHEDULE:
     399                 :          0 :       bp_pack_enum (bp, omp_clause_schedule_kind, OMP_CLAUSE_SCHEDULE_LAST,
     400                 :            :                     OMP_CLAUSE_SCHEDULE_KIND (expr));
     401                 :          0 :       break;
     402                 :          0 :     case OMP_CLAUSE_DEPEND:
     403                 :          0 :       bp_pack_enum (bp, omp_clause_depend_kind, OMP_CLAUSE_DEPEND_LAST,
     404                 :            :                     OMP_CLAUSE_DEPEND_KIND (expr));
     405                 :          0 :       break;
     406                 :          0 :     case OMP_CLAUSE_MAP:
     407                 :          0 :       bp_pack_enum (bp, gomp_map_kind, GOMP_MAP_LAST,
     408                 :            :                     OMP_CLAUSE_MAP_KIND (expr));
     409                 :          0 :       break;
     410                 :          0 :     case OMP_CLAUSE_PROC_BIND:
     411                 :          0 :       bp_pack_enum (bp, omp_clause_proc_bind_kind, OMP_CLAUSE_PROC_BIND_LAST,
     412                 :            :                     OMP_CLAUSE_PROC_BIND_KIND (expr));
     413                 :          0 :       break;
     414                 :          0 :     case OMP_CLAUSE_REDUCTION:
     415                 :          0 :     case OMP_CLAUSE_TASK_REDUCTION:
     416                 :          0 :     case OMP_CLAUSE_IN_REDUCTION:
     417                 :          0 :       bp_pack_enum (bp, tree_code, MAX_TREE_CODES,
     418                 :            :                     OMP_CLAUSE_REDUCTION_CODE (expr));
     419                 :          0 :       break;
     420                 :            :     default:
     421                 :            :       break;
     422                 :            :     }
     423                 :        196 : }
     424                 :            : 
     425                 :            : 
     426                 :            : /* Pack all the bitfields in EXPR into a bit pack.  */
     427                 :            : 
     428                 :            : void
     429                 :    5371350 : streamer_write_tree_bitfields (struct output_block *ob, tree expr)
     430                 :            : {
     431                 :    5371350 :   bitpack_d bp = bitpack_create (ob->main_stream);
     432                 :    5371350 :   enum tree_code code;
     433                 :            : 
     434                 :    5371350 :   code = TREE_CODE (expr);
     435                 :            : 
     436                 :            :   /* Note that all these functions are highly sensitive to changes in
     437                 :            :      the types and sizes of each of the fields being packed.  */
     438                 :    5371350 :   pack_ts_base_value_fields (&bp, expr);
     439                 :            : 
     440                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
     441                 :      29752 :     pack_ts_int_cst_value_fields (&bp, expr);
     442                 :            : 
     443                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
     444                 :      91409 :     pack_ts_real_cst_value_fields (&bp, expr);
     445                 :            : 
     446                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
     447                 :          0 :     pack_ts_fixed_cst_value_fields (&bp, expr);
     448                 :            : 
     449                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
     450                 :    1305790 :     stream_output_location (ob, &bp, DECL_SOURCE_LOCATION (expr));
     451                 :            : 
     452                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
     453                 :    1305790 :     pack_ts_decl_common_value_fields (&bp, expr);
     454                 :            : 
     455                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
     456                 :    1189110 :     pack_ts_decl_wrtl_value_fields (&bp, expr);
     457                 :            : 
     458                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
     459                 :     768767 :     pack_ts_decl_with_vis_value_fields (&bp, expr);
     460                 :            : 
     461                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
     462                 :     382135 :     pack_ts_function_decl_value_fields (&bp, expr);
     463                 :            : 
     464                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
     465                 :     504537 :     pack_ts_type_common_value_fields (&bp, expr);
     466                 :            : 
     467                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
     468                 :            :     {
     469                 :    1116540 :       stream_output_location (ob, &bp, EXPR_LOCATION (expr));
     470                 :    1116540 :       if (code == MEM_REF
     471                 :    1116540 :           || code == TARGET_MEM_REF)
     472                 :            :         {
     473                 :     222746 :           bp_pack_value (&bp, MR_DEPENDENCE_CLIQUE (expr), sizeof (short) * 8);
     474                 :     222746 :           if (MR_DEPENDENCE_CLIQUE (expr) != 0)
     475                 :      15777 :             bp_pack_value (&bp, MR_DEPENDENCE_BASE (expr), sizeof (short) * 8);
     476                 :            :         }
     477                 :     893794 :       else if (code == CALL_EXPR)
     478                 :         24 :         bp_pack_enum (&bp, internal_fn, IFN_LAST, CALL_EXPR_IFN (expr));
     479                 :            :     }
     480                 :            : 
     481                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
     482                 :     163192 :     pack_ts_block_value_fields (ob, &bp, expr);
     483                 :            : 
     484                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
     485                 :      22221 :     pack_ts_translation_unit_decl_value_fields (ob, &bp, expr);
     486                 :            : 
     487                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
     488                 :      21447 :     cl_optimization_stream_out (ob, &bp, TREE_OPTIMIZATION (expr));
     489                 :            : 
     490                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
     491                 :     457475 :     bp_pack_var_len_unsigned (&bp, CONSTRUCTOR_NELTS (expr));
     492                 :            : 
     493                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION)
     494                 :            :       /* Don't stream these when passing things to a different target.  */
     495                 :      21368 :       && !lto_stream_offload_p)
     496                 :      21368 :     cl_target_option_stream_out (ob, &bp, TREE_TARGET_OPTION (expr));
     497                 :            : 
     498                 :    5371350 :   if (code == OMP_CLAUSE)
     499                 :        196 :     pack_ts_omp_clause_value_fields (ob, &bp, expr);
     500                 :            : 
     501                 :    5371350 :   streamer_write_bitpack (&bp);
     502                 :    5371350 : }
     503                 :            : 
     504                 :            : 
     505                 :            : /* Emit the chain of tree nodes starting at T.  OB is the output block
     506                 :            :    to write to.  REF_P is true if chain elements should be emitted
     507                 :            :    as references.  */
     508                 :            : 
     509                 :            : void
     510                 :     336617 : streamer_write_chain (struct output_block *ob, tree t, bool ref_p)
     511                 :            : {
     512                 :     818307 :   while (t)
     513                 :            :     {
     514                 :            :       /* We avoid outputting external vars or functions by reference
     515                 :            :          to the global decls section as we do not want to have them
     516                 :            :          enter decl merging.  We should not need to do this anymore because
     517                 :            :          free_lang_data removes them from block scopes.  */
     518                 :     540444 :       gcc_assert (!VAR_OR_FUNCTION_DECL_P (t) || !DECL_EXTERNAL (t));
     519                 :     481690 :       stream_write_tree (ob, t, ref_p);
     520                 :            : 
     521                 :     481690 :       t = TREE_CHAIN (t);
     522                 :            :     }
     523                 :            : 
     524                 :            :   /* Write a sentinel to terminate the chain.  */
     525                 :     336617 :   stream_write_tree (ob, NULL_TREE, ref_p);
     526                 :     336617 : }
     527                 :            : 
     528                 :            : 
     529                 :            : /* Write all pointer fields in the TS_COMMON structure of EXPR to output
     530                 :            :    block OB.  If REF_P is true, write a reference to EXPR's pointer
     531                 :            :    fields.  */
     532                 :            : 
     533                 :            : static void
     534                 :    5165340 : write_ts_common_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
     535                 :            : {
     536                 :    5165340 :   if (TREE_CODE (expr) != IDENTIFIER_NODE)
     537                 :    3878250 :     stream_write_tree (ob, TREE_TYPE (expr), ref_p);
     538                 :    5165340 : }
     539                 :            : 
     540                 :            : 
     541                 :            : /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
     542                 :            :    block OB.  If REF_P is true, write a reference to EXPR's pointer
     543                 :            :    fields.  */
     544                 :            : 
     545                 :            : static void
     546                 :       5493 : write_ts_vector_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
     547                 :            : {
     548                 :            :   /* Note that the number of elements for EXPR has already been emitted
     549                 :            :      in EXPR's header (see streamer_write_tree_header).  */
     550                 :       5493 :   unsigned int count = vector_cst_encoded_nelts (expr);
     551                 :      24622 :   for (unsigned int i = 0; i < count; ++i)
     552                 :      19129 :     stream_write_tree (ob, VECTOR_CST_ENCODED_ELT (expr, i), ref_p);
     553                 :       5493 : }
     554                 :            : 
     555                 :            : 
     556                 :            : /* Write all pointer fields in the TS_POLY_INT_CST structure of EXPR to
     557                 :            :    output block OB.  If REF_P is true, write a reference to EXPR's pointer
     558                 :            :    fields.  */
     559                 :            : 
     560                 :            : static void
     561                 :          0 : write_ts_poly_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
     562                 :            : {
     563                 :          0 :   for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
     564                 :          0 :     stream_write_tree (ob, POLY_INT_CST_COEFF (expr, i), ref_p);
     565                 :          0 : }
     566                 :            : 
     567                 :            : 
     568                 :            : /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
     569                 :            :    block OB.  If REF_P is true, write a reference to EXPR's pointer
     570                 :            :    fields.  */
     571                 :            : 
     572                 :            : static void
     573                 :       7903 : write_ts_complex_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
     574                 :            : {
     575                 :       7903 :   stream_write_tree (ob, TREE_REALPART (expr), ref_p);
     576                 :       7903 :   stream_write_tree (ob, TREE_IMAGPART (expr), ref_p);
     577                 :       7903 : }
     578                 :            : 
     579                 :            : 
     580                 :            : /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
     581                 :            :    to output block OB.  If REF_P is true, write a reference to EXPR's
     582                 :            :    pointer fields.  */
     583                 :            : 
     584                 :            : static void
     585                 :    1305790 : write_ts_decl_minimal_tree_pointers (struct output_block *ob, tree expr,
     586                 :            :                                      bool ref_p)
     587                 :            : {
     588                 :            :   /* Drop names that were created for anonymous entities.  */
     589                 :    1305790 :   if (DECL_NAME (expr)
     590                 :    1153280 :       && TREE_CODE (DECL_NAME (expr)) == IDENTIFIER_NODE
     591                 :    2459070 :       && IDENTIFIER_ANON_P (DECL_NAME (expr)))
     592                 :        319 :     stream_write_tree (ob, NULL_TREE, ref_p);
     593                 :            :   else
     594                 :    1305470 :     stream_write_tree (ob, DECL_NAME (expr), ref_p);
     595                 :    1305790 :   if (TREE_CODE (expr) != TRANSLATION_UNIT_DECL
     596                 :    2589360 :       && ! DECL_CONTEXT (expr))
     597                 :      18970 :     stream_write_tree (ob, (*all_translation_units)[0], ref_p);
     598                 :            :   else
     599                 :    1286820 :     stream_write_tree (ob, DECL_CONTEXT (expr), ref_p);
     600                 :    1305790 : }
     601                 :            : 
     602                 :            : 
     603                 :            : /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
     604                 :            :    output block OB.  If REF_P is true, write a reference to EXPR's
     605                 :            :    pointer fields.  */
     606                 :            : 
     607                 :            : static void
     608                 :    1305790 : write_ts_decl_common_tree_pointers (struct output_block *ob, tree expr,
     609                 :            :                                     bool ref_p)
     610                 :            : {
     611                 :    1305790 :   stream_write_tree (ob, DECL_SIZE (expr), ref_p);
     612                 :    1305790 :   stream_write_tree (ob, DECL_SIZE_UNIT (expr), ref_p);
     613                 :            : 
     614                 :            :   /* Note, DECL_INITIAL is not handled here.  Since DECL_INITIAL needs
     615                 :            :      special handling in LTO, it must be handled by streamer hooks.  */
     616                 :            : 
     617                 :    1305790 :   stream_write_tree (ob, DECL_ATTRIBUTES (expr), ref_p);
     618                 :            : 
     619                 :            :   /* On non-early-LTO enabled targets we claim we compiled with -g0
     620                 :            :      but dwarf2out still did its set_decl_origin_self game fooling
     621                 :            :      itself late.  Und that here since we won't have access to the
     622                 :            :      early generated abstract DIEs.  */
     623                 :    1305790 :   tree ao = DECL_ABSTRACT_ORIGIN (expr);
     624                 :    1305790 :   if (debug_info_level == DINFO_LEVEL_NONE
     625                 :    1202220 :       && ao == expr)
     626                 :          0 :     ao = NULL_TREE;
     627                 :    1305790 :   stream_write_tree (ob, ao, ref_p);
     628                 :            : 
     629                 :    1305790 :   if ((VAR_P (expr) || TREE_CODE (expr) == PARM_DECL)
     630                 :    1978640 :       && DECL_HAS_VALUE_EXPR_P (expr))
     631                 :       1045 :     stream_write_tree (ob, DECL_VALUE_EXPR (expr), ref_p);
     632                 :            : 
     633                 :    1305790 :   if (VAR_P (expr)
     634                 :    1305790 :       && DECL_HAS_DEBUG_EXPR_P (expr))
     635                 :       1244 :     stream_write_tree (ob, DECL_DEBUG_EXPR (expr), ref_p);
     636                 :    1305790 : }
     637                 :            : 
     638                 :            : 
     639                 :            : /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
     640                 :            :    EXPR to output block OB.  If REF_P is true, write a reference to EXPR's
     641                 :            :    pointer fields.  */
     642                 :            : 
     643                 :            : static void
     644                 :          0 : write_ts_decl_non_common_tree_pointers (struct output_block *, tree, bool)
     645                 :            : {
     646                 :          0 : }
     647                 :            : 
     648                 :            : 
     649                 :            : /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
     650                 :            :    to output block OB.  If REF_P is true, write a reference to EXPR's
     651                 :            :    pointer fields.  */
     652                 :            : 
     653                 :            : static void
     654                 :     768767 : write_ts_decl_with_vis_tree_pointers (struct output_block *ob, tree expr,
     655                 :            :                                       bool ref_p)
     656                 :            : {
     657                 :            :   /* Make sure we don't inadvertently set the assembler name.  */
     658                 :     768767 :   if (DECL_ASSEMBLER_NAME_SET_P (expr))
     659                 :     679132 :     stream_write_tree (ob, DECL_ASSEMBLER_NAME (expr), ref_p);
     660                 :            :   else
     661                 :      89635 :     stream_write_tree (ob, NULL_TREE, false);
     662                 :     768767 : }
     663                 :            : 
     664                 :            : 
     665                 :            : /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
     666                 :            :    output block OB.  If REF_P is true, write a reference to EXPR's
     667                 :            :    pointer fields.  */
     668                 :            : 
     669                 :            : static void
     670                 :      94337 : write_ts_field_decl_tree_pointers (struct output_block *ob, tree expr,
     671                 :            :                                    bool ref_p)
     672                 :            : {
     673                 :      94337 :   stream_write_tree (ob, DECL_FIELD_OFFSET (expr), ref_p);
     674                 :      94337 :   stream_write_tree (ob, DECL_BIT_FIELD_TYPE (expr), ref_p);
     675                 :      94337 :   stream_write_tree (ob, DECL_BIT_FIELD_REPRESENTATIVE (expr), ref_p);
     676                 :      94337 :   stream_write_tree (ob, DECL_FIELD_BIT_OFFSET (expr), ref_p);
     677                 :      94337 : }
     678                 :            : 
     679                 :            : 
     680                 :            : /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
     681                 :            :    to output block OB.  If REF_P is true, write a reference to EXPR's
     682                 :            :    pointer fields.  */
     683                 :            : 
     684                 :            : static void
     685                 :     382135 : write_ts_function_decl_tree_pointers (struct output_block *ob, tree expr,
     686                 :            :                                       bool ref_p)
     687                 :            : {
     688                 :            :   /* DECL_STRUCT_FUNCTION is handled by lto_output_function.  */
     689                 :     382135 :   stream_write_tree (ob, DECL_FUNCTION_PERSONALITY (expr), ref_p);
     690                 :            :   /* Don't stream these when passing things to a different target.  */
     691                 :     382135 :   if (!lto_stream_offload_p)
     692                 :     382135 :     stream_write_tree (ob, DECL_FUNCTION_SPECIFIC_TARGET (expr), ref_p);
     693                 :     382135 :   stream_write_tree (ob, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr), ref_p);
     694                 :     382135 : }
     695                 :            : 
     696                 :            : 
     697                 :            : /* Write all pointer fields in the TS_TYPE_COMMON structure of EXPR to
     698                 :            :    output block OB.  If REF_P is true, write a reference to EXPR's
     699                 :            :    pointer fields.  */
     700                 :            : 
     701                 :            : static void
     702                 :     504537 : write_ts_type_common_tree_pointers (struct output_block *ob, tree expr,
     703                 :            :                                     bool ref_p)
     704                 :            : {
     705                 :     504537 :   stream_write_tree (ob, TYPE_SIZE (expr), ref_p);
     706                 :     504537 :   stream_write_tree (ob, TYPE_SIZE_UNIT (expr), ref_p);
     707                 :     504537 :   stream_write_tree (ob, TYPE_ATTRIBUTES (expr), ref_p);
     708                 :     504537 :   stream_write_tree (ob, TYPE_NAME (expr), ref_p);
     709                 :            :   /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO.  They will be
     710                 :            :      reconstructed during fixup.  */
     711                 :            :   /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
     712                 :            :      during fixup.  */
     713                 :     504537 :   stream_write_tree (ob, TYPE_MAIN_VARIANT (expr), ref_p);
     714                 :     504537 :   stream_write_tree (ob, TYPE_CONTEXT (expr), ref_p);
     715                 :            :   /* TYPE_CANONICAL is re-computed during type merging, so no need
     716                 :            :      to stream it here.  */
     717                 :            :   /* Do not stream TYPE_STUB_DECL; it is not needed by LTO but currently
     718                 :            :      it cannot be freed by free_lang_data without triggering ICEs in
     719                 :            :      langhooks.  */
     720                 :     504537 : }
     721                 :            : 
     722                 :            : /* Write all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
     723                 :            :    to output block OB.  If REF_P is true, write a reference to EXPR's
     724                 :            :    pointer fields.  */
     725                 :            : 
     726                 :            : static void
     727                 :     504537 : write_ts_type_non_common_tree_pointers (struct output_block *ob, tree expr,
     728                 :            :                                         bool ref_p)
     729                 :            : {
     730                 :     504537 :   if (TREE_CODE (expr) == ENUMERAL_TYPE)
     731                 :        863 :     stream_write_tree (ob, TYPE_VALUES (expr), ref_p);
     732                 :     503674 :   else if (TREE_CODE (expr) == ARRAY_TYPE)
     733                 :      31679 :     stream_write_tree (ob, TYPE_DOMAIN (expr), ref_p);
     734                 :     471995 :   else if (RECORD_OR_UNION_TYPE_P (expr))
     735                 :      82000 :     streamer_write_chain (ob, TYPE_FIELDS (expr), ref_p);
     736                 :     389995 :   else if (TREE_CODE (expr) == FUNCTION_TYPE
     737                 :     389995 :            || TREE_CODE (expr) == METHOD_TYPE)
     738                 :     135414 :     stream_write_tree (ob, TYPE_ARG_TYPES (expr), ref_p);
     739                 :            : 
     740                 :     504537 :   if (!POINTER_TYPE_P (expr))
     741                 :     303937 :     stream_write_tree (ob, TYPE_MIN_VALUE_RAW (expr), ref_p);
     742                 :     504537 :   stream_write_tree (ob, TYPE_MAX_VALUE_RAW (expr), ref_p);
     743                 :     504537 : }
     744                 :            : 
     745                 :            : 
     746                 :            : /* Write all pointer fields in the TS_LIST structure of EXPR to output
     747                 :            :    block OB.  If REF_P is true, write a reference to EXPR's pointer
     748                 :            :    fields.  */
     749                 :            : 
     750                 :            : static void
     751                 :     526754 : write_ts_list_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
     752                 :            : {
     753                 :     526754 :   stream_write_tree (ob, TREE_PURPOSE (expr), ref_p);
     754                 :     526754 :   stream_write_tree (ob, TREE_VALUE (expr), ref_p);
     755                 :     526754 :   stream_write_tree (ob, TREE_CHAIN (expr), ref_p);
     756                 :     526754 : }
     757                 :            : 
     758                 :            : 
     759                 :            : /* Write all pointer fields in the TS_VEC structure of EXPR to output
     760                 :            :    block OB.  If REF_P is true, write a reference to EXPR's pointer
     761                 :            :    fields.  */
     762                 :            : 
     763                 :            : static void
     764                 :          0 : write_ts_vec_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
     765                 :            : {
     766                 :          0 :   int i;
     767                 :            : 
     768                 :            :   /* Note that the number of slots for EXPR has already been emitted
     769                 :            :      in EXPR's header (see streamer_write_tree_header).  */
     770                 :          0 :   for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
     771                 :          0 :     stream_write_tree (ob, TREE_VEC_ELT (expr, i), ref_p);
     772                 :          0 : }
     773                 :            : 
     774                 :            : 
     775                 :            : /* Write all pointer fields in the TS_EXP structure of EXPR to output
     776                 :            :    block OB.  If REF_P is true, write a reference to EXPR's pointer
     777                 :            :    fields.  */
     778                 :            : 
     779                 :            : static void
     780                 :    1116540 : write_ts_exp_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
     781                 :            : {
     782                 :    1116540 :   int i;
     783                 :            : 
     784                 :    2723170 :   for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
     785                 :    1606630 :     stream_write_tree (ob, TREE_OPERAND (expr, i), ref_p);
     786                 :    1116540 :   stream_write_tree (ob, TREE_BLOCK (expr), ref_p);
     787                 :    1116540 : }
     788                 :            : 
     789                 :            : 
     790                 :            : /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
     791                 :            :    block OB.  If REF_P is true, write a reference to EXPR's pointer
     792                 :            :    fields.  */
     793                 :            : 
     794                 :            : static void
     795                 :     163192 : write_ts_block_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
     796                 :            : {
     797                 :     163192 :   streamer_write_chain (ob, BLOCK_VARS (expr), ref_p);
     798                 :            : 
     799                 :     163192 :   stream_write_tree (ob, BLOCK_SUPERCONTEXT (expr), ref_p);
     800                 :     163192 :   stream_write_tree (ob, BLOCK_ABSTRACT_ORIGIN (expr), ref_p);
     801                 :            : 
     802                 :            :   /* Do not stream BLOCK_NONLOCALIZED_VARS.  We cannot handle debug information
     803                 :            :      for early inlined BLOCKs so drop it on the floor instead of ICEing in
     804                 :            :      dwarf2out.c.  */
     805                 :            : 
     806                 :            :   /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
     807                 :            :      streaming time.  */
     808                 :            : 
     809                 :            :   /* Do not output BLOCK_SUBBLOCKS.  Instead on streaming-in this
     810                 :            :      list is re-constructed from BLOCK_SUPERCONTEXT.  */
     811                 :     163192 : }
     812                 :            : 
     813                 :            : 
     814                 :            : /* Write all pointer fields in the TS_BINFO structure of EXPR to output
     815                 :            :    block OB.  If REF_P is true, write a reference to EXPR's pointer
     816                 :            :    fields.  */
     817                 :            : 
     818                 :            : static void
     819                 :       7078 : write_ts_binfo_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
     820                 :            : {
     821                 :       7078 :   unsigned i;
     822                 :       7078 :   tree t;
     823                 :            : 
     824                 :            :   /* Note that the number of BINFO slots has already been emitted in
     825                 :            :      EXPR's header (see streamer_write_tree_header) because this length
     826                 :            :      is needed to build the empty BINFO node on the reader side.  */
     827                 :      13848 :   FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr), i, t)
     828                 :       6770 :     stream_write_tree (ob, t, ref_p);
     829                 :       7078 :   stream_write_tree (ob, NULL_TREE, false);
     830                 :            : 
     831                 :       7078 :   stream_write_tree (ob, BINFO_OFFSET (expr), ref_p);
     832                 :       7078 :   stream_write_tree (ob, BINFO_VTABLE (expr), ref_p);
     833                 :            : 
     834                 :            :   /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX,
     835                 :            :      BINFO_BASE_ACCESSES and BINFO_VPTR_INDEX; these are used by C++ FE only.  */
     836                 :       7078 : }
     837                 :            : 
     838                 :            : 
     839                 :            : /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
     840                 :            :    output block OB.  If REF_P is true, write a reference to EXPR's
     841                 :            :    pointer fields.  */
     842                 :            : 
     843                 :            : static void
     844                 :     236681 : write_ts_constructor_tree_pointers (struct output_block *ob, tree expr,
     845                 :            :                                     bool ref_p)
     846                 :            : {
     847                 :     236681 :   unsigned i;
     848                 :     236681 :   tree index, value;
     849                 :            : 
     850                 :    1530920 :   FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value)
     851                 :            :     {
     852                 :     536721 :       stream_write_tree (ob, index, ref_p);
     853                 :     536721 :       stream_write_tree (ob, value, ref_p);
     854                 :            :     }
     855                 :     236681 : }
     856                 :            : 
     857                 :            : 
     858                 :            : /* Write all pointer fields in the TS_OMP_CLAUSE structure of EXPR
     859                 :            :    to output block OB.  If REF_P is true, write a reference to EXPR's
     860                 :            :    pointer fields.  */
     861                 :            : 
     862                 :            : static void
     863                 :        196 : write_ts_omp_clause_tree_pointers (struct output_block *ob, tree expr,
     864                 :            :                                    bool ref_p)
     865                 :            : {
     866                 :        196 :   int i;
     867                 :        467 :   for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (expr)]; i++)
     868                 :        271 :     stream_write_tree (ob, OMP_CLAUSE_OPERAND (expr, i), ref_p);
     869                 :        196 :   switch (OMP_CLAUSE_CODE (expr))
     870                 :            :     {
     871                 :          0 :     case OMP_CLAUSE_REDUCTION:
     872                 :          0 :     case OMP_CLAUSE_TASK_REDUCTION:
     873                 :          0 :     case OMP_CLAUSE_IN_REDUCTION:
     874                 :            :       /* We don't stream these right now, handle it if streaming
     875                 :            :          of them is needed.  */
     876                 :          0 :       gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (expr) == NULL);
     877                 :          0 :       gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (expr) == NULL);
     878                 :            :       break;
     879                 :            :     default:
     880                 :            :       break;
     881                 :            :     }
     882                 :        196 :   stream_write_tree (ob, OMP_CLAUSE_CHAIN (expr), ref_p);
     883                 :        196 : }
     884                 :            : 
     885                 :            : 
     886                 :            : /* Write all pointer fields in EXPR to output block OB.  If REF_P is true,
     887                 :            :    the leaves of EXPR are emitted as references.  */
     888                 :            : 
     889                 :            : void
     890                 :    5371350 : streamer_write_tree_body (struct output_block *ob, tree expr, bool ref_p)
     891                 :            : {
     892                 :    5371350 :   enum tree_code code;
     893                 :            : 
     894                 :    5371350 :   lto_stats.num_tree_bodies_output++;
     895                 :            : 
     896                 :    5371350 :   code = TREE_CODE (expr);
     897                 :            : 
     898                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
     899                 :    5165340 :     write_ts_common_tree_pointers (ob, expr, ref_p);
     900                 :            : 
     901                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
     902                 :       5493 :     write_ts_vector_tree_pointers (ob, expr, ref_p);
     903                 :            : 
     904                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_POLY_INT_CST))
     905                 :          0 :     write_ts_poly_tree_pointers (ob, expr, ref_p);
     906                 :            : 
     907                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
     908                 :       7903 :     write_ts_complex_tree_pointers (ob, expr, ref_p);
     909                 :            : 
     910                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
     911                 :    1305790 :     write_ts_decl_minimal_tree_pointers (ob, expr, ref_p);
     912                 :            : 
     913                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
     914                 :    1305790 :     write_ts_decl_common_tree_pointers (ob, expr, ref_p);
     915                 :            : 
     916                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
     917                 :    5371350 :     write_ts_decl_non_common_tree_pointers (ob, expr, ref_p);
     918                 :            : 
     919                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
     920                 :     768767 :     write_ts_decl_with_vis_tree_pointers (ob, expr, ref_p);
     921                 :            : 
     922                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
     923                 :      94337 :     write_ts_field_decl_tree_pointers (ob, expr, ref_p);
     924                 :            : 
     925                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
     926                 :     382135 :     write_ts_function_decl_tree_pointers (ob, expr, ref_p);
     927                 :            : 
     928                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
     929                 :     504537 :     write_ts_type_common_tree_pointers (ob, expr, ref_p);
     930                 :            : 
     931                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
     932                 :     504537 :     write_ts_type_non_common_tree_pointers (ob, expr, ref_p);
     933                 :            : 
     934                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_LIST))
     935                 :     526754 :     write_ts_list_tree_pointers (ob, expr, ref_p);
     936                 :            : 
     937                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_VEC))
     938                 :          0 :     write_ts_vec_tree_pointers (ob, expr, ref_p);
     939                 :            : 
     940                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
     941                 :    1116540 :     write_ts_exp_tree_pointers (ob, expr, ref_p);
     942                 :            : 
     943                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
     944                 :     163192 :     write_ts_block_tree_pointers (ob, expr, ref_p);
     945                 :            : 
     946                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
     947                 :       7078 :     write_ts_binfo_tree_pointers (ob, expr, ref_p);
     948                 :            : 
     949                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
     950                 :     236681 :     write_ts_constructor_tree_pointers (ob, expr, ref_p);
     951                 :            : 
     952                 :    5371350 :   if (code == OMP_CLAUSE)
     953                 :        196 :     write_ts_omp_clause_tree_pointers (ob, expr, ref_p);
     954                 :    5371350 : }
     955                 :            : 
     956                 :            : 
     957                 :            : /* Emit header information for tree EXPR to output block OB.  The header
     958                 :            :    contains everything needed to instantiate an empty skeleton for
     959                 :            :    EXPR on the reading side.  IX is the index into the streamer cache
     960                 :            :    where EXPR is stored.  */
     961                 :            : 
     962                 :            : void
     963                 :    5371350 : streamer_write_tree_header (struct output_block *ob, tree expr)
     964                 :            : {
     965                 :    5371350 :   enum LTO_tags tag;
     966                 :    5371350 :   enum tree_code code;
     967                 :            : 
     968                 :            :   /* We should not see any tree nodes not handled by the streamer.  */
     969                 :    5371350 :   code = TREE_CODE (expr);
     970                 :            : 
     971                 :            :   /* The header of a tree node consists of its tag, the size of
     972                 :            :      the node, and any other information needed to instantiate
     973                 :            :      EXPR on the reading side (such as the number of slots in
     974                 :            :      variable sized nodes).  */
     975                 :    5371350 :   tag = lto_tree_code_to_tag (code);
     976                 :    5371350 :   streamer_write_record_start (ob, tag);
     977                 :            : 
     978                 :            :   /* The text in strings and identifiers are completely emitted in
     979                 :            :      the header.  */
     980                 :    5371350 :   if (CODE_CONTAINS_STRUCT (code, TS_STRING))
     981                 :      46120 :     streamer_write_string_cst (ob, ob->main_stream, expr);
     982                 :    5325230 :   else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
     983                 :    1287090 :     write_identifier (ob, ob->main_stream, expr);
     984                 :    4038140 :   else if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
     985                 :            :     {
     986                 :       5493 :       bitpack_d bp = bitpack_create (ob->main_stream);
     987                 :       5493 :       bp_pack_value (&bp, VECTOR_CST_LOG2_NPATTERNS (expr), 8);
     988                 :       5493 :       bp_pack_value (&bp, VECTOR_CST_NELTS_PER_PATTERN (expr), 8);
     989                 :       5493 :       streamer_write_bitpack (&bp);
     990                 :            :     }
     991                 :    4032650 :   else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
     992                 :          0 :     streamer_write_hwi (ob, TREE_VEC_LENGTH (expr));
     993                 :    4032650 :   else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
     994                 :       7078 :     streamer_write_uhwi (ob, BINFO_N_BASE_BINFOS (expr));
     995                 :    4025570 :   else if (TREE_CODE (expr) == CALL_EXPR)
     996                 :         24 :     streamer_write_uhwi (ob, call_expr_nargs (expr));
     997                 :    4025540 :   else if (TREE_CODE (expr) == OMP_CLAUSE)
     998                 :        196 :     streamer_write_uhwi (ob, OMP_CLAUSE_CODE (expr));
     999                 :    4025350 :   else if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
    1000                 :            :     {
    1001                 :      29752 :       gcc_checking_assert (TREE_INT_CST_NUNITS (expr));
    1002                 :      29752 :       streamer_write_uhwi (ob, TREE_INT_CST_NUNITS (expr));
    1003                 :      29752 :       streamer_write_uhwi (ob, TREE_INT_CST_EXT_NUNITS (expr));
    1004                 :            :     }
    1005                 :    5371350 : }
    1006                 :            : 
    1007                 :            : 
    1008                 :            : /* Emit the integer constant CST to output block OB.  If REF_P is true,
    1009                 :            :    CST's type will be emitted as a reference.  */
    1010                 :            : 
    1011                 :            : void
    1012                 :     898261 : streamer_write_integer_cst (struct output_block *ob, tree cst, bool ref_p)
    1013                 :            : {
    1014                 :     898261 :   int i;
    1015                 :     898261 :   int len = TREE_INT_CST_NUNITS (cst);
    1016                 :     898261 :   gcc_assert (!TREE_OVERFLOW (cst));
    1017                 :     898261 :   streamer_write_record_start (ob, LTO_integer_cst);
    1018                 :     898261 :   stream_write_tree (ob, TREE_TYPE (cst), ref_p);
    1019                 :            :   /* We're effectively streaming a non-sign-extended wide_int here,
    1020                 :            :      so there's no need to stream TREE_INT_CST_EXT_NUNITS or any
    1021                 :            :      array members beyond LEN.  We'll recreate the tree from the
    1022                 :            :      wide_int and the type.  */
    1023                 :     898261 :   streamer_write_uhwi (ob, len);
    1024                 :    1800360 :   for (i = 0; i < len; i++)
    1025                 :     902097 :     streamer_write_hwi (ob, TREE_INT_CST_ELT (cst, i));
    1026                 :     898261 : }

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.