LCOV - code coverage report
Current view: top level - gcc - lto-streamer.h (source / functions) Coverage Total Hit
Test: gcc.info Lines: 97.8 % 134 131
Test Date: 2024-03-23 14:05:01 Functions: 100.0 % 19 19
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : /* Data structures and declarations used for reading and writing
       2                 :             :    GIMPLE to a file stream.
       3                 :             : 
       4                 :             :    Copyright (C) 2009-2024 Free Software Foundation, Inc.
       5                 :             :    Contributed by Doug Kwan <dougkwan@google.com>
       6                 :             : 
       7                 :             : This file is part of GCC.
       8                 :             : 
       9                 :             : GCC is free software; you can redistribute it and/or modify it under
      10                 :             : the terms of the GNU General Public License as published by the Free
      11                 :             : Software Foundation; either version 3, or (at your option) any later
      12                 :             : version.
      13                 :             : 
      14                 :             : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      15                 :             : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      16                 :             : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      17                 :             : for more details.
      18                 :             : 
      19                 :             : You should have received a copy of the GNU General Public License
      20                 :             : along with GCC; see the file COPYING3.  If not see
      21                 :             : <http://www.gnu.org/licenses/>.  */
      22                 :             : 
      23                 :             : #ifndef GCC_LTO_STREAMER_H
      24                 :             : #define GCC_LTO_STREAMER_H
      25                 :             : 
      26                 :             : #include "plugin-api.h"
      27                 :             : #include "gcov-io.h"
      28                 :             : #include "diagnostic.h"
      29                 :             : #include "version.h"
      30                 :             : 
      31                 :             : /* The encoding for a function consists of the following sections:
      32                 :             : 
      33                 :             :    1)    The header.
      34                 :             :    2)    FIELD_DECLS.
      35                 :             :    3)    FUNCTION_DECLS.
      36                 :             :    4)    global VAR_DECLS.
      37                 :             :    5)    type_decls
      38                 :             :    6)    types.
      39                 :             :    7)    Names for the labels that have names
      40                 :             :    8)    The SSA names.
      41                 :             :    9)    The control flow graph.
      42                 :             :    10-11)Gimple for local decls.
      43                 :             :    12)   Gimple for the function.
      44                 :             :    13)   Strings.
      45                 :             : 
      46                 :             :    1) THE HEADER.
      47                 :             :    2-6) THE GLOBAL DECLS AND TYPES.
      48                 :             : 
      49                 :             :       The global decls and types are encoded in the same way.  For each
      50                 :             :       entry, there is word with the offset within the section to the
      51                 :             :       entry.
      52                 :             : 
      53                 :             :    7) THE LABEL NAMES.
      54                 :             : 
      55                 :             :       Since most labels do not have names, this section my be of zero
      56                 :             :       length.  It consists of an array of string table references, one
      57                 :             :       per label.  In the lto code, the labels are given either
      58                 :             :       positive or negative indexes.  the positive ones have names and
      59                 :             :       the negative ones do not.  The positive index can be used to
      60                 :             :       find the name in this array.
      61                 :             : 
      62                 :             :    9) THE CFG.
      63                 :             : 
      64                 :             :    10) Index into the local decls.  Since local decls can have local
      65                 :             :       decls inside them, they must be read in randomly in order to
      66                 :             :       properly restore them.
      67                 :             : 
      68                 :             :    11-12) GIMPLE FOR THE LOCAL DECLS AND THE FUNCTION BODY.
      69                 :             : 
      70                 :             :      The gimple consists of a set of records.
      71                 :             : 
      72                 :             :      THE FUNCTION
      73                 :             : 
      74                 :             :      At the top level of (8) is the function. It consists of five
      75                 :             :      pieces:
      76                 :             : 
      77                 :             :      LTO_function     - The tag.
      78                 :             :      eh tree          - This is all of the exception handling regions
      79                 :             :                         put out in a post order traversial of the
      80                 :             :                         tree.  Siblings are output as lists terminated
      81                 :             :                         by a 0.  The set of fields matches the fields
      82                 :             :                         defined in except.cc.
      83                 :             : 
      84                 :             :      last_basic_block - in uleb128 form.
      85                 :             : 
      86                 :             :      basic blocks     - This is the set of basic blocks.
      87                 :             : 
      88                 :             :      zero             - The termination of the basic blocks.
      89                 :             : 
      90                 :             :      BASIC BLOCKS
      91                 :             : 
      92                 :             :      There are two forms of basic blocks depending on if they are
      93                 :             :      empty or not.
      94                 :             : 
      95                 :             :      The basic block consists of:
      96                 :             : 
      97                 :             :      LTO_bb1 or LTO_bb0 - The tag.
      98                 :             : 
      99                 :             :      bb->index          - the index in uleb128 form.
     100                 :             : 
     101                 :             :      #succs             - The number of successors un uleb128 form.
     102                 :             : 
     103                 :             :      the successors     - For each edge, a pair.  The first of the
     104                 :             :                           pair is the index of the successor in
     105                 :             :                           uleb128 form and the second are the flags in
     106                 :             :                           uleb128 form.
     107                 :             : 
     108                 :             :      the statements     - A gimple tree, as described above.
     109                 :             :                           These are only present for LTO_BB1.
     110                 :             :                           Following each statement is an optional
     111                 :             :                           exception handling record LTO_eh_region
     112                 :             :                           which contains the region number (for
     113                 :             :                           regions >= 0).
     114                 :             : 
     115                 :             :      zero               - This is only present for LTO_BB1 and is used
     116                 :             :                           to terminate the statements and exception
     117                 :             :                           regions within this block.
     118                 :             : 
     119                 :             :    12) STRINGS
     120                 :             : 
     121                 :             :      String are represented in the table as pairs, a length in ULEB128
     122                 :             :      form followed by the data for the string.  */
     123                 :             : 
     124                 :             : #define LTO_major_version GCC_major_version
     125                 :             : #define LTO_minor_version 0
     126                 :             : 
     127                 :             : typedef unsigned char   lto_decl_flags_t;
     128                 :             : 
     129                 :             : /* Stream additional data to LTO object files to make it easier to debug
     130                 :             :    streaming code.  This changes object files.  */
     131                 :             : static const bool streamer_debugging = false;
     132                 :             : 
     133                 :             : /* Tags representing the various IL objects written to the bytecode file
     134                 :             :    (GIMPLE statements, basic blocks, EH regions, tree nodes, etc).
     135                 :             : 
     136                 :             :    NOTE, when adding new LTO tags, also update lto_tag_name.  */
     137                 :             : enum LTO_tags
     138                 :             : {
     139                 :             :   LTO_null = 0,
     140                 :             : 
     141                 :             :   /* Reference to previously-streamed node.  */
     142                 :             :   LTO_tree_pickle_reference,
     143                 :             : 
     144                 :             :   /* References to indexable tree nodes.  These objects are stored in
     145                 :             :      tables that are written separately from the function bodies
     146                 :             :      and variable constructors that reference them.  This way they can be
     147                 :             :      instantiated even when the referencing functions aren't (e.g., during WPA)
     148                 :             :      and it also allows functions to be copied from one file to another without
     149                 :             :      having to unpickle the body first (the references are location
     150                 :             :      independent).  */
     151                 :             :   LTO_global_stream_ref,
     152                 :             : 
     153                 :             :   LTO_ssa_name_ref,
     154                 :             : 
     155                 :             :   /* Special for global streamer.  A blob of unnamed tree nodes.  */
     156                 :             :   LTO_tree_scc,
     157                 :             : 
     158                 :             :   /* Sequence of trees.  */
     159                 :             :   LTO_trees,
     160                 :             : 
     161                 :             :   /* Shared INTEGER_CST node.  */
     162                 :             :   LTO_integer_cst,
     163                 :             : 
     164                 :             :   /* Tags of trees are encoded as
     165                 :             :      LTO_first_tree_tag + TREE_CODE.  */
     166                 :             :   LTO_first_tree_tag,
     167                 :             :   /* Tags of gimple typles are encoded as
     168                 :             :      LTO_first_gimple_tag + gimple_code.  */
     169                 :             :   LTO_first_gimple_tag = LTO_first_tree_tag + MAX_TREE_CODES,
     170                 :             : 
     171                 :             :   /* Entry and exit basic blocks.  */
     172                 :             :   LTO_bb0 = LTO_first_gimple_tag + LAST_AND_UNUSED_GIMPLE_CODE,
     173                 :             :   LTO_bb1,
     174                 :             : 
     175                 :             :   /* EH region holding the previous statement.  */
     176                 :             :   LTO_eh_region,
     177                 :             : 
     178                 :             :   /* Function body.  */
     179                 :             :   LTO_function,
     180                 :             : 
     181                 :             :   /* EH table.  */
     182                 :             :   LTO_eh_table,
     183                 :             : 
     184                 :             :   /* EH region types.  These mirror enum eh_region_type.  */
     185                 :             :   LTO_ert_cleanup,
     186                 :             :   LTO_ert_try,
     187                 :             :   LTO_ert_allowed_exceptions,
     188                 :             :   LTO_ert_must_not_throw,
     189                 :             : 
     190                 :             :   /* EH landing pad.  */
     191                 :             :   LTO_eh_landing_pad,
     192                 :             : 
     193                 :             :   /* EH try/catch node.  */
     194                 :             :   LTO_eh_catch,
     195                 :             : 
     196                 :             :   /* This tag must always be last.  */
     197                 :             :   LTO_NUM_TAGS
     198                 :             : };
     199                 :             : 
     200                 :             : 
     201                 :             : /* Set of section types that are in an LTO file.  This list will grow
     202                 :             :    as the number of IPA passes grows since each IPA pass will need its
     203                 :             :    own section type to store its summary information.
     204                 :             : 
     205                 :             :    When adding a new section type, you must also extend the
     206                 :             :    LTO_SECTION_NAME array in lto-section-in.cc.  */
     207                 :             : enum lto_section_type
     208                 :             : {
     209                 :             :   LTO_section_decls = 0,
     210                 :             :   LTO_section_function_body,
     211                 :             :   LTO_section_static_initializer,
     212                 :             :   LTO_section_symtab,
     213                 :             :   LTO_section_symtab_extension,
     214                 :             :   LTO_section_refs,
     215                 :             :   LTO_section_asm,
     216                 :             :   LTO_section_jump_functions,
     217                 :             :   LTO_section_ipa_pure_const,
     218                 :             :   LTO_section_ipa_reference,
     219                 :             :   LTO_section_ipa_profile,
     220                 :             :   LTO_section_symtab_nodes,
     221                 :             :   LTO_section_opts,
     222                 :             :   LTO_section_cgraph_opt_sum,
     223                 :             :   LTO_section_ipa_fn_summary,
     224                 :             :   LTO_section_ipcp_transform,
     225                 :             :   LTO_section_ipa_icf,
     226                 :             :   LTO_section_offload_table,
     227                 :             :   LTO_section_mode_table,
     228                 :             :   LTO_section_lto,
     229                 :             :   LTO_section_ipa_sra,
     230                 :             :   LTO_section_odr_types,
     231                 :             :   LTO_section_ipa_modref,
     232                 :             :   LTO_N_SECTION_TYPES           /* Must be last.  */
     233                 :             : };
     234                 :             : 
     235                 :             : /* Indices to the various function, type and symbol streams. */
     236                 :             : enum lto_decl_stream_e_t
     237                 :             : {
     238                 :             :   LTO_DECL_STREAM = 0,          /* Must be first.  */
     239                 :             :   LTO_N_DECL_STREAMS
     240                 :             : };
     241                 :             : 
     242                 :             : typedef enum ld_plugin_symbol_resolution ld_plugin_symbol_resolution_t;
     243                 :             : 
     244                 :             : /* Return a char pointer to the start of a data stream for an lto pass
     245                 :             :    or function.  The first parameter is the file data that contains
     246                 :             :    the information.  The second parameter is the type of information
     247                 :             :    to be obtained.  The third parameter is the name of the function
     248                 :             :    and is only used when finding a function body; otherwise it is
     249                 :             :    NULL.  The fourth parameter is the length of the data returned.  */
     250                 :             : typedef const char* (lto_get_section_data_f) (struct lto_file_decl_data *,
     251                 :             :                                               enum lto_section_type,
     252                 :             :                                               const char *,
     253                 :             :                                               int,
     254                 :             :                                               size_t *);
     255                 :             : 
     256                 :             : /* Return the data found from the above call.  The first three
     257                 :             :    parameters are the same as above.  The fourth parameter is the data
     258                 :             :    itself and the fifth is the length of the data. */
     259                 :             : typedef void (lto_free_section_data_f) (struct lto_file_decl_data *,
     260                 :             :                                         enum lto_section_type,
     261                 :             :                                         const char *,
     262                 :             :                                         const char *,
     263                 :             :                                         size_t);
     264                 :             : 
     265                 :             : /* The location cache holds expanded locations for streamed in trees.
     266                 :             :    This is done to reduce memory usage of libcpp linemap that strongly prefers
     267                 :             :    locations to be inserted in the source order.  */
     268                 :             : 
     269                 :             : class lto_location_cache
     270                 :             : {
     271                 :             : public:
     272                 :             :   /* Apply all changes in location cache.  Add locations into linemap and patch
     273                 :             :      trees.  */
     274                 :             :   bool apply_location_cache ();
     275                 :             :   /* Tree merging did not suceed; mark all changes in the cache as accepted.  */
     276                 :             :   void accept_location_cache ();
     277                 :             :   /* Tree merging did suceed; throw away recent changes.  */
     278                 :             :   void revert_location_cache ();
     279                 :             :   void input_location (location_t *loc, struct bitpack_d *bp,
     280                 :             :                        class data_in *data_in);
     281                 :             :   void input_location_and_block (location_t *loc, struct bitpack_d *bp,
     282                 :             :                                  class lto_input_block *ib,
     283                 :             :                                  class data_in *data_in);
     284                 :      201125 :   lto_location_cache ()
     285                 :      201125 :      : loc_cache (), accepted_length (0), current_file (NULL), current_line (0),
     286                 :      201125 :        current_col (0), current_sysp (false), current_loc (UNKNOWN_LOCATION),
     287                 :      201125 :        current_block (NULL_TREE)
     288                 :             :   {
     289                 :      201125 :     gcc_assert (!current_cache);
     290                 :      201125 :     current_cache = this;
     291                 :      201125 :   }
     292                 :      201125 :   ~lto_location_cache ()
     293                 :             :   {
     294                 :      201125 :     apply_location_cache ();
     295                 :      201125 :     gcc_assert (current_cache == this);
     296                 :      201125 :     current_cache = NULL;
     297                 :      201125 :   }
     298                 :             : 
     299                 :             :   /* There can be at most one instance of location cache (combining multiple
     300                 :             :      would bring it out of sync with libcpp linemap); point to current
     301                 :             :      one.  */
     302                 :             :   static lto_location_cache *current_cache;
     303                 :             :   
     304                 :             : private:
     305                 :             :   static int cmp_loc (const void *pa, const void *pb);
     306                 :             : 
     307                 :             :   struct cached_location
     308                 :             :   {
     309                 :             :     const char *file;
     310                 :             :     location_t *loc;
     311                 :             :     int line, col;
     312                 :             :     bool sysp;
     313                 :             :     tree block;
     314                 :             :     unsigned discr;
     315                 :             :   };
     316                 :             : 
     317                 :             :   /* The location cache.  */
     318                 :             : 
     319                 :             :   auto_vec<cached_location> loc_cache;
     320                 :             : 
     321                 :             :   /* Accepted entries are ones used by trees that are known to be not unified
     322                 :             :      by tree merging.  */
     323                 :             : 
     324                 :             :   int accepted_length;
     325                 :             : 
     326                 :             :   /* Bookkeeping to remember state in between calls to lto_apply_location_cache
     327                 :             :      When streaming gimple, the location cache is not used and thus
     328                 :             :      lto_apply_location_cache happens per location basis.  It is then
     329                 :             :      useful to avoid redundant calls of linemap API.  */
     330                 :             : 
     331                 :             :   const char *current_file;
     332                 :             :   int current_line;
     333                 :             :   int current_col;
     334                 :             :   bool current_sysp;
     335                 :             :   location_t current_loc;
     336                 :             :   tree current_block;
     337                 :             :   unsigned current_discr;
     338                 :             : };
     339                 :             : 
     340                 :             : /* Structure used as buffer for reading an LTO file.  */
     341                 :             : class lto_input_block
     342                 :             : {
     343                 :             : public:
     344                 :             :   /* Special constructor for the string table, it abuses this to
     345                 :             :      do random access but use the uhwi decoder.  */
     346                 :     1269692 :   lto_input_block (const char *data_, unsigned int p_, unsigned int len_,
     347                 :             :                    const lto_file_decl_data *file_data_)
     348                 :     1269692 :       : data (data_), file_data (file_data_), p (p_), len (len_) {}
     349                 :      348432 :   lto_input_block (const char *data_, unsigned int len_,
     350                 :             :                    const lto_file_decl_data *file_data_)
     351                 :      266477 :       : data (data_), file_data (file_data_), p (0), len (len_) {}
     352                 :             : 
     353                 :             :   const char *data;
     354                 :             :   const lto_file_decl_data *file_data;
     355                 :             :   unsigned int p;
     356                 :             :   unsigned int len;
     357                 :             : };
     358                 :             : 
     359                 :             : /* Compression algorithm used for compression of LTO bytecode.  */
     360                 :             : 
     361                 :             : enum lto_compression
     362                 :             : {
     363                 :             :   ZLIB,
     364                 :             :   ZSTD
     365                 :             : };
     366                 :             : 
     367                 :             : /* Structure that represents LTO ELF section with information
     368                 :             :    about the format.  */
     369                 :             : 
     370                 :             : struct lto_section
     371                 :             : {
     372                 :             :   int16_t major_version;
     373                 :             :   int16_t minor_version;
     374                 :             :   unsigned char slim_object;
     375                 :             :   unsigned char _padding;
     376                 :             : 
     377                 :             :   /* Flags is a private field that is not defined publicly.  */
     378                 :             :   uint16_t flags;
     379                 :             : 
     380                 :             :   /* Set compression to FLAGS.  */
     381                 :       32791 :   inline void set_compression (lto_compression c)
     382                 :             :   {
     383                 :       32791 :     flags = c;
     384                 :             :   }
     385                 :             : 
     386                 :             :   /* Get compression from FLAGS.  */
     387                 :      206825 :   inline lto_compression get_compression ()
     388                 :             :   {
     389                 :      206825 :     return (lto_compression) flags;
     390                 :             :   }
     391                 :             : };
     392                 :             : 
     393                 :             : STATIC_ASSERT (sizeof (lto_section) == 8);
     394                 :             : 
     395                 :             : /* The is the first part of the record in an LTO file for many of the
     396                 :             :    IPA passes.  */
     397                 :             : struct lto_simple_header
     398                 :             : {
     399                 :             :   /* Size of main gimple body of function.  */
     400                 :             :   int32_t main_size;
     401                 :             : };
     402                 :             : 
     403                 :             : struct lto_simple_header_with_strings : lto_simple_header
     404                 :             : {
     405                 :             :   /* Size of the string table.  */
     406                 :             :   int32_t string_size;
     407                 :             : };
     408                 :             : 
     409                 :             : /* The header for a function body.  */
     410                 :             : struct lto_function_header : lto_simple_header_with_strings
     411                 :             : {
     412                 :             :   /* Size of the cfg.  */
     413                 :             :   int32_t cfg_size;
     414                 :             : };
     415                 :             : 
     416                 :             : 
     417                 :             : /* Structure describing a symbol section.  */
     418                 :             : struct lto_decl_header : lto_simple_header_with_strings
     419                 :             : {
     420                 :             :   /* Size of region for decl state. */
     421                 :             :   int32_t decl_state_size;
     422                 :             : 
     423                 :             :   /* Number of nodes in globals stream.  */
     424                 :             :   int32_t num_nodes;
     425                 :             : };
     426                 :             : 
     427                 :             : 
     428                 :             : /* Statistics gathered during LTO, WPA and LTRANS.  */
     429                 :             : struct lto_stats_d
     430                 :             : {
     431                 :             :   unsigned HOST_WIDE_INT num_input_cgraph_nodes;
     432                 :             :   unsigned HOST_WIDE_INT num_output_symtab_nodes;
     433                 :             :   unsigned HOST_WIDE_INT num_input_files;
     434                 :             :   unsigned HOST_WIDE_INT num_output_files;
     435                 :             :   unsigned HOST_WIDE_INT num_cgraph_partitions;
     436                 :             :   unsigned HOST_WIDE_INT section_size[LTO_N_SECTION_TYPES];
     437                 :             :   unsigned HOST_WIDE_INT num_function_bodies;
     438                 :             :   unsigned HOST_WIDE_INT num_trees[NUM_TREE_CODES];
     439                 :             :   unsigned HOST_WIDE_INT num_output_il_bytes;
     440                 :             :   unsigned HOST_WIDE_INT num_compressed_il_bytes;
     441                 :             :   unsigned HOST_WIDE_INT num_input_il_bytes;
     442                 :             :   unsigned HOST_WIDE_INT num_uncompressed_il_bytes;
     443                 :             :   unsigned HOST_WIDE_INT num_tree_bodies_output;
     444                 :             :   unsigned HOST_WIDE_INT num_pickle_refs_output;
     445                 :             : };
     446                 :             : 
     447                 :             : /* Entry of LTO symtab encoder.  */
     448                 :             : struct lto_encoder_entry
     449                 :             : {
     450                 :             :   symtab_node *node;
     451                 :             :   /* Is the node in this partition (i.e. ltrans of this partition will
     452                 :             :      be responsible for outputting it)? */
     453                 :             :   unsigned int in_partition:1;
     454                 :             :   /* Do we encode body in this partition?  */
     455                 :             :   unsigned int body:1;
     456                 :             :   /* Do we encode initializer in this partition?
     457                 :             :      For example the readonly variable initializers are encoded to aid
     458                 :             :      constant folding even if they are not in the partition.  */
     459                 :             :   unsigned int initializer:1;
     460                 :             : };
     461                 :             : 
     462                 :             : 
     463                 :             : /* Encoder data structure used to stream callgraph nodes.  */
     464                 :             : struct lto_symtab_encoder_d
     465                 :             : {
     466                 :             :   vec<lto_encoder_entry> nodes;
     467                 :             :   hash_map<symtab_node *, size_t> *map;
     468                 :             : };
     469                 :             : 
     470                 :             : typedef struct lto_symtab_encoder_d *lto_symtab_encoder_t;
     471                 :             : 
     472                 :             : /* Iterator structure for cgraph node sets.  */
     473                 :             : struct lto_symtab_encoder_iterator
     474                 :             : {
     475                 :             :   lto_symtab_encoder_t encoder;
     476                 :             :   unsigned index;
     477                 :             : };
     478                 :             : 
     479                 :             : 
     480                 :             : 
     481                 :             : /* The lto_tree_ref_encoder struct is used to encode trees into indices. */
     482                 :             : 
     483                 :             : struct lto_tree_ref_encoder
     484                 :             : {
     485                 :             :   hash_map<tree, unsigned> *tree_hash_table;      /* Maps pointers to indices. */
     486                 :             :   vec<tree> trees;                        /* Maps indices to pointers. */
     487                 :             : };
     488                 :             : 
     489                 :             : 
     490                 :             : /* Structure to hold states of input scope.  */
     491                 :             : struct GTY((for_user)) lto_in_decl_state
     492                 :             : {
     493                 :             :   /* Array of lto_in_decl_buffers to store type and decls streams. */
     494                 :             :   vec<tree, va_gc> *streams[LTO_N_DECL_STREAMS];
     495                 :             : 
     496                 :             :   /* If this in-decl state is associated with a function. FN_DECL
     497                 :             :      point to the FUNCTION_DECL. */
     498                 :             :   tree fn_decl;
     499                 :             : 
     500                 :             :   /* True if decl state is compressed.  */
     501                 :             :   bool compressed;
     502                 :             : };
     503                 :             : 
     504                 :             : typedef struct lto_in_decl_state *lto_in_decl_state_ptr;
     505                 :             : 
     506                 :             : struct decl_state_hasher : ggc_ptr_hash<lto_in_decl_state>
     507                 :             : {
     508                 :             :   static hashval_t
     509                 :     1557060 :   hash (lto_in_decl_state *s)
     510                 :             :   {
     511                 :     1557060 :     return htab_hash_pointer (s->fn_decl);
     512                 :             :   }
     513                 :             : 
     514                 :             :   static bool
     515                 :     1384718 :   equal (lto_in_decl_state *a, lto_in_decl_state *b)
     516                 :             :   {
     517                 :     1384718 :     return a->fn_decl == b->fn_decl;
     518                 :             :   }
     519                 :             : };
     520                 :             : 
     521                 :             : /* The structure that holds all of the vectors of global types,
     522                 :             :    decls and cgraph nodes used in the serialization of this file.  */
     523                 :             : struct lto_out_decl_state
     524                 :             : {
     525                 :             :   /* The buffers contain the sets of decls of various kinds and types we have
     526                 :             :      seen so far and the indexes assigned to them.  */
     527                 :             :   struct lto_tree_ref_encoder streams[LTO_N_DECL_STREAMS];
     528                 :             : 
     529                 :             :   /* Encoder for cgraph nodes.  */
     530                 :             :   lto_symtab_encoder_t symtab_node_encoder;
     531                 :             : 
     532                 :             :   /* If this out-decl state belongs to a function, fn_decl points to that
     533                 :             :      function.  Otherwise, it is NULL. */
     534                 :             :   tree fn_decl;
     535                 :             : 
     536                 :             :   /* True if decl state is compressed.  */
     537                 :             :   bool compressed;
     538                 :             : };
     539                 :             : 
     540                 :             : typedef struct lto_out_decl_state *lto_out_decl_state_ptr;
     541                 :             : 
     542                 :             : 
     543                 :             : /* Compact representation of a index <-> resolution pair. Unpacked to an 
     544                 :             :    vector later. */
     545                 :             : struct res_pair 
     546                 :             : {
     547                 :             :   ld_plugin_symbol_resolution_t res;
     548                 :             :   unsigned index;
     549                 :             : };
     550                 :             : 
     551                 :             : 
     552                 :             : /* One of these is allocated for each object file that being compiled
     553                 :             :    by lto.  This structure contains the tables that are needed by the
     554                 :             :    serialized functions and ipa passes to connect themselves to the
     555                 :             :    global types and decls as they are reconstituted.  */
     556                 :             : struct GTY(()) lto_file_decl_data
     557                 :             : {
     558                 :             :   /* Decl state currently used. */
     559                 :             :   struct lto_in_decl_state *current_decl_state;
     560                 :             : 
     561                 :             :   /* Decl state corresponding to regions outside of any functions
     562                 :             :      in the compilation unit. */
     563                 :             :   struct lto_in_decl_state *global_decl_state;
     564                 :             : 
     565                 :             :   /* Table of cgraph nodes present in this file.  */
     566                 :             :   lto_symtab_encoder_t GTY((skip)) symtab_node_encoder;
     567                 :             : 
     568                 :             :   /* Hash table maps lto-related section names to location in file.  */
     569                 :             :   hash_table<decl_state_hasher> *function_decl_states;
     570                 :             : 
     571                 :             :   /* The .o file that these offsets relate to.  */
     572                 :             :   const char *GTY((skip)) file_name;
     573                 :             : 
     574                 :             :   /* Hash table maps lto-related section names to location in file.  */
     575                 :             :   htab_t GTY((skip)) section_hash_table;
     576                 :             : 
     577                 :             :   /* Hash new name of renamed global declaration to its original name.  */
     578                 :             :   htab_t GTY((skip)) renaming_hash_table;
     579                 :             : 
     580                 :             :   /* Linked list used temporarily in reader */
     581                 :             :   struct lto_file_decl_data *next;
     582                 :             : 
     583                 :             :   /* Order in which the file appears on the command line.  */
     584                 :             :   int order;
     585                 :             : 
     586                 :             :   /* Sub ID for merged objects. */
     587                 :             :   unsigned HOST_WIDE_INT id;
     588                 :             : 
     589                 :             :   /* Symbol resolutions for this file */
     590                 :             :   vec<res_pair>  GTY((skip)) respairs;
     591                 :             :   unsigned max_index;
     592                 :             : 
     593                 :             :   gcov_summary GTY((skip)) profile_info;
     594                 :             : 
     595                 :             :   /* Map assigning declarations their resolutions.  */
     596                 :             :   hash_map<tree, ld_plugin_symbol_resolution> * GTY((skip)) resolution_map;
     597                 :             : 
     598                 :             :   /* Mode translation table.  */
     599                 :             :   const unsigned char *mode_table;
     600                 :             : 
     601                 :             :   /* Read LTO section.  */
     602                 :             :   lto_section lto_section_header;
     603                 :             : 
     604                 :             :   int order_base;
     605                 :             : 
     606                 :             :   int unit_base;
     607                 :             : 
     608                 :             :   unsigned mode_bits;
     609                 :             : };
     610                 :             : 
     611                 :             : typedef struct lto_file_decl_data *lto_file_decl_data_ptr;
     612                 :             : 
     613                 :             : struct lto_char_ptr_base
     614                 :             : {
     615                 :             :   char *ptr;
     616                 :             : };
     617                 :             : 
     618                 :             : /* An incore byte stream to buffer the various parts of the function.
     619                 :             :    The entire structure should be zeroed when created.  The record
     620                 :             :    consists of a set of blocks.  The first sizeof (ptr) bytes are used
     621                 :             :    as a chain, and the rest store the bytes to be written.  */
     622                 :             : struct lto_output_stream
     623                 :             : {
     624                 :             :   /* The pointer to the first block in the stream.  */
     625                 :             :   struct lto_char_ptr_base * first_block;
     626                 :             : 
     627                 :             :   /* The pointer to the last and current block in the stream.  */
     628                 :             :   struct lto_char_ptr_base * current_block;
     629                 :             : 
     630                 :             :   /* The pointer to where the next char should be written.  */
     631                 :             :   char * current_pointer;
     632                 :             : 
     633                 :             :   /* The number of characters left in the current block.  */
     634                 :             :   unsigned int left_in_block;
     635                 :             : 
     636                 :             :   /* The block size of the last block allocated.  */
     637                 :             :   unsigned int block_size;
     638                 :             : 
     639                 :             :   /* The total number of characters written.  */
     640                 :             :   unsigned int total_size;
     641                 :             : };
     642                 :             : 
     643                 :             : /* A simple output block.  This can be used for simple IPA passes that
     644                 :             :    do not need more than one stream.  */
     645                 :             : struct lto_simple_output_block
     646                 :             : {
     647                 :             :   enum lto_section_type section_type;
     648                 :             :   struct lto_out_decl_state *decl_state;
     649                 :             : 
     650                 :             :   /* The stream that the main tree codes are written to.  */
     651                 :             :   struct lto_output_stream *main_stream;
     652                 :             : };
     653                 :             : 
     654                 :             : /* String hashing.  */
     655                 :             : 
     656                 :             : struct string_slot
     657                 :             : {
     658                 :             :   const char *s;
     659                 :             :   int len;
     660                 :             :   unsigned int slot_num;
     661                 :             : };
     662                 :             : 
     663                 :             : /* Hashtable helpers.  */
     664                 :             : 
     665                 :             : struct string_slot_hasher : nofree_ptr_hash <string_slot>
     666                 :             : {
     667                 :             :   static inline hashval_t hash (const string_slot *);
     668                 :             :   static inline bool equal (const string_slot *, const string_slot *);
     669                 :             : };
     670                 :             : 
     671                 :             : /* Returns a hash code for DS.  Adapted from libiberty's htab_hash_string
     672                 :             :    to support strings that may not end in '\0'.  */
     673                 :             : 
     674                 :             : inline hashval_t
     675                 :    10759529 : string_slot_hasher::hash (const string_slot *ds)
     676                 :             : {
     677                 :    10759529 :   hashval_t r = ds->len;
     678                 :    10759529 :   int i;
     679                 :             : 
     680                 :   268919181 :   for (i = 0; i < ds->len; i++)
     681                 :   258159652 :      r = r * 67 + (unsigned)ds->s[i] - 113;
     682                 :    10759529 :   return r;
     683                 :             : }
     684                 :             : 
     685                 :             : /* Returns nonzero if DS1 and DS2 are equal.  */
     686                 :             : 
     687                 :             : inline bool
     688                 :     8527991 : string_slot_hasher::equal (const string_slot *ds1, const string_slot *ds2)
     689                 :             : {
     690                 :     8527991 :   if (ds1->len == ds2->len)
     691                 :     4894580 :     return memcmp (ds1->s, ds2->s, ds1->len) == 0;
     692                 :             : 
     693                 :             :   return 0;
     694                 :             : }
     695                 :             : 
     696                 :             : /* Data structure holding all the data and descriptors used when writing
     697                 :             :    an LTO file.  */
     698                 :             : struct output_block
     699                 :             : {
     700                 :             :   enum lto_section_type section_type;
     701                 :             :   struct lto_out_decl_state *decl_state;
     702                 :             : 
     703                 :             :   /* The stream that the main tree codes are written to.  */
     704                 :             :   struct lto_output_stream *main_stream;
     705                 :             : 
     706                 :             :   /* The stream that contains the string table.  */
     707                 :             :   struct lto_output_stream *string_stream;
     708                 :             : 
     709                 :             :   /* The stream that contains the cfg.  */
     710                 :             :   struct lto_output_stream *cfg_stream;
     711                 :             : 
     712                 :             :   /* The hash table that contains the set of strings we have seen so
     713                 :             :      far and the indexes assigned to them.  */
     714                 :             :   hash_table<string_slot_hasher> *string_hash_table;
     715                 :             : 
     716                 :             :   /* The current symbol that we are currently serializing.  Null
     717                 :             :      if we are serializing something else.  */
     718                 :             :   symtab_node *symbol;
     719                 :             : 
     720                 :             :   /* These are the last file and line that were seen in the stream.
     721                 :             :      If the current node differs from these, it needs to insert
     722                 :             :      something into the stream and fix these up.  */
     723                 :             :   const char *current_file;
     724                 :             :   int current_line;
     725                 :             :   int current_col;
     726                 :             :   bool current_sysp;
     727                 :             :   bool reset_locus;
     728                 :             :   bool emit_pwd;
     729                 :             :   tree current_block;
     730                 :             :   unsigned current_discr;
     731                 :             : 
     732                 :             :   /* Cache of nodes written in this section.  */
     733                 :             :   struct streamer_tree_cache_d *writer_cache;
     734                 :             : 
     735                 :             :   /* All trees identified as local to the unit streamed.  */
     736                 :             :   hash_set<tree> *local_trees;
     737                 :             : 
     738                 :             :   /* All data persistent across whole duration of output block
     739                 :             :      can go here.  */
     740                 :             :   struct obstack obstack;
     741                 :             : };
     742                 :             : 
     743                 :             : 
     744                 :             : /* Data and descriptors used when reading from an LTO file.  */
     745                 :      402250 : class data_in
     746                 :             : {
     747                 :             : public:
     748                 :             :   /* The global decls and types.  */
     749                 :             :   struct lto_file_decl_data *file_data;
     750                 :             : 
     751                 :             :   /* The string table.  */
     752                 :             :   const char *strings;
     753                 :             : 
     754                 :             :   /* The length of the string table.  */
     755                 :             :   unsigned int strings_len;
     756                 :             : 
     757                 :             :   /* Maps each reference number to the resolution done by the linker. */
     758                 :             :   vec<ld_plugin_symbol_resolution_t> globals_resolution;
     759                 :             : 
     760                 :             :   /* Cache of pickled nodes.  */
     761                 :             :   struct streamer_tree_cache_d *reader_cache;
     762                 :             : 
     763                 :             :   /* Cache of source code location.  */
     764                 :             :   lto_location_cache location_cache;
     765                 :             : };
     766                 :             : 
     767                 :             : 
     768                 :             : /* In lto-section-in.cc  */
     769                 :             : extern class lto_input_block * lto_create_simple_input_block (
     770                 :             :                                struct lto_file_decl_data *,
     771                 :             :                                enum lto_section_type, const char **, size_t *);
     772                 :             : extern void
     773                 :             : lto_destroy_simple_input_block (struct lto_file_decl_data *,
     774                 :             :                                 enum lto_section_type,
     775                 :             :                                 class lto_input_block *, const char *, size_t);
     776                 :             : extern void lto_set_in_hooks (struct lto_file_decl_data **,
     777                 :             :                               lto_get_section_data_f *,
     778                 :             :                               lto_free_section_data_f *);
     779                 :             : extern struct lto_file_decl_data **lto_get_file_decl_data (void);
     780                 :             : extern const char *lto_get_section_data (struct lto_file_decl_data *,
     781                 :             :                                          enum lto_section_type,
     782                 :             :                                          const char *, int, size_t *,
     783                 :             :                                          bool decompress = false);
     784                 :             : extern const char *lto_get_summary_section_data (struct lto_file_decl_data *,
     785                 :             :                                                  enum lto_section_type,
     786                 :             :                                                  size_t *);
     787                 :             : extern const char *lto_get_raw_section_data (struct lto_file_decl_data *,
     788                 :             :                                              enum lto_section_type,
     789                 :             :                                              const char *, int, size_t *);
     790                 :             : extern void lto_free_section_data (struct lto_file_decl_data *,
     791                 :             :                                    enum lto_section_type,
     792                 :             :                                    const char *, const char *, size_t,
     793                 :             :                                    bool decompress = false);
     794                 :             : extern void lto_free_raw_section_data (struct lto_file_decl_data *,
     795                 :             :                                        enum lto_section_type,
     796                 :             :                                        const char *, const char *, size_t);
     797                 :             : extern htab_t lto_create_renaming_table (void);
     798                 :             : extern void lto_record_renamed_decl (struct lto_file_decl_data *,
     799                 :             :                                      const char *, const char *);
     800                 :             : extern const char *lto_get_decl_name_mapping (struct lto_file_decl_data *,
     801                 :             :                                               const char *);
     802                 :             : extern struct lto_in_decl_state *lto_new_in_decl_state (void);
     803                 :             : extern void lto_delete_in_decl_state (struct lto_in_decl_state *);
     804                 :             : extern struct lto_in_decl_state *lto_get_function_in_decl_state (
     805                 :             :                                       struct lto_file_decl_data *, tree);
     806                 :             : extern void lto_free_function_in_decl_state (struct lto_in_decl_state *);
     807                 :             : extern void lto_free_function_in_decl_state_for_node (symtab_node *);
     808                 :             : extern void lto_section_overrun (class lto_input_block *) ATTRIBUTE_NORETURN;
     809                 :             : extern void lto_value_range_error (const char *,
     810                 :             :                                    HOST_WIDE_INT, HOST_WIDE_INT,
     811                 :             :                                    HOST_WIDE_INT) ATTRIBUTE_NORETURN;
     812                 :             : 
     813                 :             : /* In lto-section-out.cc  */
     814                 :             : extern void lto_begin_section (const char *, bool);
     815                 :             : extern void lto_end_section (void);
     816                 :             : extern void lto_write_data (const void *, unsigned int);
     817                 :             : extern void lto_write_raw_data (const void *, unsigned int);
     818                 :             : extern void lto_write_stream (struct lto_output_stream *);
     819                 :             : extern struct lto_simple_output_block *lto_create_simple_output_block (
     820                 :             :                                 enum lto_section_type);
     821                 :             : extern void lto_destroy_simple_output_block (struct lto_simple_output_block *);
     822                 :             : extern struct lto_out_decl_state *lto_new_out_decl_state (void);
     823                 :             : extern void lto_delete_out_decl_state (struct lto_out_decl_state *);
     824                 :             : extern struct lto_out_decl_state *lto_get_out_decl_state (void);
     825                 :             : extern void lto_push_out_decl_state (struct lto_out_decl_state *);
     826                 :             : extern struct lto_out_decl_state *lto_pop_out_decl_state (void);
     827                 :             : extern void lto_record_function_out_decl_state (tree,
     828                 :             :                                                 struct lto_out_decl_state *);
     829                 :             : extern void lto_append_block (struct lto_output_stream *);
     830                 :             : 
     831                 :             : 
     832                 :             : /* In lto-streamer.cc.  */
     833                 :             : 
     834                 :             : /* Set when streaming LTO for offloading compiler.  */
     835                 :             : extern bool lto_stream_offload_p;
     836                 :             : 
     837                 :             : extern const char *lto_tag_name (enum LTO_tags);
     838                 :             : extern char *lto_get_section_name (int, const char *, int,
     839                 :             :                                    struct lto_file_decl_data *);
     840                 :             : extern void print_lto_report (const char *);
     841                 :             : extern void lto_streamer_init (void);
     842                 :             : extern bool gate_lto_out (void);
     843                 :             : extern void lto_check_version (int, int, const char *);
     844                 :             : extern void lto_streamer_hooks_init (void);
     845                 :             : 
     846                 :             : /* In lto-streamer-in.cc */
     847                 :             : extern void lto_input_cgraph (struct lto_file_decl_data *, const char *);
     848                 :             : extern void lto_reader_init (void);
     849                 :             : extern void lto_free_file_name_hash (void);
     850                 :             : extern void lto_input_function_body (struct lto_file_decl_data *,
     851                 :             :                                      struct cgraph_node *,
     852                 :             :                                      const char *);
     853                 :             : extern void lto_input_variable_constructor (struct lto_file_decl_data *,
     854                 :             :                                             struct varpool_node *,
     855                 :             :                                             const char *);
     856                 :             : extern void lto_input_constructors_and_inits (struct lto_file_decl_data *,
     857                 :             :                                               const char *);
     858                 :             : extern void lto_input_toplevel_asms (struct lto_file_decl_data *, int);
     859                 :             : extern void lto_input_mode_table (struct lto_file_decl_data *);
     860                 :             : extern class data_in *lto_data_in_create (struct lto_file_decl_data *,
     861                 :             :                                     const char *, unsigned,
     862                 :             :                                     vec<ld_plugin_symbol_resolution_t> );
     863                 :             : extern void lto_data_in_delete (class data_in *);
     864                 :             : extern void lto_input_data_block (class lto_input_block *, void *, size_t);
     865                 :             : void lto_input_location (location_t *, struct bitpack_d *, class data_in *);
     866                 :             : tree lto_input_tree_ref (class lto_input_block *, class data_in *,
     867                 :             :                          struct function *, enum LTO_tags);
     868                 :             : void lto_tag_check_set (enum LTO_tags, int, ...);
     869                 :             : void lto_init_eh (void);
     870                 :             : hashval_t lto_input_scc (class lto_input_block *, class data_in *,
     871                 :             :                          unsigned *, unsigned *, bool);
     872                 :             : tree lto_input_tree_1 (class lto_input_block *, class data_in *,
     873                 :             :                        enum LTO_tags, hashval_t hash);
     874                 :             : tree lto_input_tree (class lto_input_block *, class data_in *);
     875                 :             : tree stream_read_tree_ref (class lto_input_block *, class data_in *);
     876                 :             : 
     877                 :             : 
     878                 :             : /* In lto-streamer-out.cc  */
     879                 :             : extern void lto_register_decl_definition (tree, struct lto_file_decl_data *);
     880                 :             : extern struct output_block *create_output_block (enum lto_section_type);
     881                 :             : extern void destroy_output_block (struct output_block *);
     882                 :             : extern void lto_output_tree (struct output_block *, tree, bool, bool);
     883                 :             : extern void stream_write_tree_ref (struct output_block *, tree);
     884                 :             : extern void lto_output_var_decl_ref (struct lto_out_decl_state *,
     885                 :             :                                      struct lto_output_stream *, tree);
     886                 :             : extern void lto_output_fn_decl_ref (struct lto_out_decl_state *,
     887                 :             :                                     struct lto_output_stream *, tree);
     888                 :             : extern tree lto_input_var_decl_ref (lto_input_block *, lto_file_decl_data *);
     889                 :             : extern tree lto_input_fn_decl_ref (lto_input_block *, lto_file_decl_data *);
     890                 :             : extern void lto_output_toplevel_asms (void);
     891                 :             : extern void produce_asm (struct output_block *ob, tree fn);
     892                 :             : extern void lto_output ();
     893                 :             : extern void produce_asm_for_decls ();
     894                 :             : void lto_output_decl_state_streams (struct output_block *,
     895                 :             :                                     struct lto_out_decl_state *);
     896                 :             : void lto_output_decl_state_refs (struct output_block *,
     897                 :             :                                  struct lto_output_stream *,
     898                 :             :                                  struct lto_out_decl_state *);
     899                 :             : void lto_output_location (struct output_block *, struct bitpack_d *,
     900                 :             :                           location_t);
     901                 :             : void lto_output_location_and_block (struct output_block *, struct bitpack_d *,
     902                 :             :                                     location_t);
     903                 :             : void lto_output_init_mode_table (void);
     904                 :             : void lto_prepare_function_for_streaming (cgraph_node *);
     905                 :             : 
     906                 :             : 
     907                 :             : /* In lto-cgraph.cc  */
     908                 :             : extern bool asm_nodes_output;
     909                 :             : lto_symtab_encoder_t lto_symtab_encoder_new (bool);
     910                 :             : int lto_symtab_encoder_encode (lto_symtab_encoder_t, symtab_node *);
     911                 :             : void lto_symtab_encoder_delete (lto_symtab_encoder_t);
     912                 :             : bool lto_symtab_encoder_delete_node (lto_symtab_encoder_t, symtab_node *);
     913                 :             : bool lto_symtab_encoder_encode_body_p (lto_symtab_encoder_t,
     914                 :             :                                        struct cgraph_node *);
     915                 :             : bool lto_symtab_encoder_in_partition_p (lto_symtab_encoder_t,
     916                 :             :                                         symtab_node *);
     917                 :             : void lto_set_symtab_encoder_in_partition (lto_symtab_encoder_t,
     918                 :             :                                           symtab_node *);
     919                 :             : 
     920                 :             : bool lto_symtab_encoder_encode_initializer_p (lto_symtab_encoder_t,
     921                 :             :                                               varpool_node *);
     922                 :             : void output_symtab (void);
     923                 :             : void input_symtab (void);
     924                 :             : void output_offload_tables (void);
     925                 :             : void input_offload_tables (bool);
     926                 :             : bool referenced_from_other_partition_p (struct ipa_ref_list *,
     927                 :             :                                         lto_symtab_encoder_t);
     928                 :             : bool reachable_from_other_partition_p (struct cgraph_node *,
     929                 :             :                                        lto_symtab_encoder_t);
     930                 :             : bool referenced_from_this_partition_p (symtab_node *,
     931                 :             :                                         lto_symtab_encoder_t);
     932                 :             : bool reachable_from_this_partition_p (struct cgraph_node *,
     933                 :             :                                       lto_symtab_encoder_t);
     934                 :             : lto_symtab_encoder_t compute_ltrans_boundary (lto_symtab_encoder_t encoder);
     935                 :             : void select_what_to_stream (void);
     936                 :             : 
     937                 :             : /* In omp-general.cc.  */
     938                 :             : void omp_lto_output_declare_variant_alt (lto_simple_output_block *,
     939                 :             :                                          cgraph_node *, lto_symtab_encoder_t);
     940                 :             : void omp_lto_input_declare_variant_alt (lto_input_block *, cgraph_node *,
     941                 :             :                                         vec<symtab_node *>);
     942                 :             : 
     943                 :             : /* In options-save.cc.  */
     944                 :             : void cl_target_option_stream_out (struct output_block *, struct bitpack_d *,
     945                 :             :                                   struct cl_target_option *);
     946                 :             : 
     947                 :             : void cl_target_option_stream_in (class data_in *,
     948                 :             :                                  struct bitpack_d *,
     949                 :             :                                  struct cl_target_option *);
     950                 :             : 
     951                 :             : void cl_optimization_stream_out (struct output_block *,
     952                 :             :                                  struct bitpack_d *, struct cl_optimization *);
     953                 :             : 
     954                 :             : void cl_optimization_stream_in (class data_in *,
     955                 :             :                                 struct bitpack_d *, struct cl_optimization *);
     956                 :             : 
     957                 :             : 
     958                 :             : 
     959                 :             : /* In lto-opts.cc.  */
     960                 :             : extern void lto_write_options (void);
     961                 :             : 
     962                 :             : 
     963                 :             : /* Statistics gathered during LTO, WPA and LTRANS.  */
     964                 :             : extern struct lto_stats_d lto_stats;
     965                 :             : 
     966                 :             : /* Section names corresponding to the values of enum lto_section_type.  */
     967                 :             : extern const char *lto_section_name[];
     968                 :             : 
     969                 :             : /* Holds all the out decl states of functions output so far in the
     970                 :             :    current output file.  */
     971                 :             : extern vec<lto_out_decl_state_ptr> lto_function_decl_states;
     972                 :             : 
     973                 :             : /* Return true if LTO tag TAG corresponds to a tree code.  */
     974                 :             : inline bool
     975                 :     4164727 : lto_tag_is_tree_code_p (enum LTO_tags tag)
     976                 :             : {
     977                 :     4164727 :   return tag > LTO_first_tree_tag && (unsigned) tag <= MAX_TREE_CODES;
     978                 :             : }
     979                 :             : 
     980                 :             : 
     981                 :             : /* Return true if LTO tag TAG corresponds to a gimple code.  */
     982                 :             : inline bool
     983                 :     1363029 : lto_tag_is_gimple_code_p (enum LTO_tags tag)
     984                 :             : {
     985                 :     1363029 :   return (unsigned) tag >= LTO_first_gimple_tag
     986                 :     1363029 :          && (unsigned) tag
     987                 :             :             < LTO_first_gimple_tag + LAST_AND_UNUSED_GIMPLE_CODE;
     988                 :             : }
     989                 :             : 
     990                 :             : 
     991                 :             : /* Return the LTO tag corresponding to gimple code CODE.  See enum
     992                 :             :    LTO_tags for details on the conversion.  */
     993                 :             : inline enum LTO_tags
     994                 :     1627451 : lto_gimple_code_to_tag (enum gimple_code code)
     995                 :             : {
     996                 :     1627451 :   return (enum LTO_tags) ((unsigned) code + LTO_first_gimple_tag);
     997                 :             : }
     998                 :             : 
     999                 :             : 
    1000                 :             : /* Return the GIMPLE code corresponding to TAG.  See enum LTO_tags for
    1001                 :             :    details on the conversion.  */
    1002                 :             : inline enum gimple_code
    1003                 :     1363029 : lto_tag_to_gimple_code (enum LTO_tags tag)
    1004                 :             : {
    1005                 :     1363029 :   gcc_assert (lto_tag_is_gimple_code_p (tag));
    1006                 :     1363029 :   return (enum gimple_code) ((unsigned) tag - LTO_first_gimple_tag);
    1007                 :             : }
    1008                 :             : 
    1009                 :             : 
    1010                 :             : /* Return the LTO tag corresponding to tree code CODE.  See enum
    1011                 :             :    LTO_tags for details on the conversion.  */
    1012                 :             : inline enum LTO_tags
    1013                 :     6843375 : lto_tree_code_to_tag (enum tree_code code)
    1014                 :             : {
    1015                 :     6843375 :   return (enum LTO_tags) ((unsigned) code + LTO_first_tree_tag);
    1016                 :             : }
    1017                 :             : 
    1018                 :             : 
    1019                 :             : /* Return the tree code corresponding to TAG.  See enum LTO_tags for
    1020                 :             :    details on the conversion.  */
    1021                 :             : inline enum tree_code
    1022                 :     4164727 : lto_tag_to_tree_code (enum LTO_tags tag)
    1023                 :             : {
    1024                 :     4164727 :   gcc_assert (lto_tag_is_tree_code_p (tag));
    1025                 :     4164727 :   return (enum tree_code) ((unsigned) tag - LTO_first_tree_tag);
    1026                 :             : }
    1027                 :             : 
    1028                 :             : /* Check that tag ACTUAL == EXPECTED.  */
    1029                 :             : inline void
    1030                 :       81955 : lto_tag_check (enum LTO_tags actual, enum LTO_tags expected)
    1031                 :             : {
    1032                 :       81955 :   if (actual != expected)
    1033                 :           0 :     internal_error ("bytecode stream: expected tag %s instead of %s",
    1034                 :             :                     lto_tag_name (expected), lto_tag_name (actual));
    1035                 :       81955 : }
    1036                 :             : 
    1037                 :             : /* Check that tag ACTUAL is in the range [TAG1, TAG2].  */
    1038                 :             : inline void
    1039                 :        9481 : lto_tag_check_range (enum LTO_tags actual, enum LTO_tags tag1,
    1040                 :             :                      enum LTO_tags tag2)
    1041                 :             : {
    1042                 :        9481 :   if (actual < tag1 || actual > tag2)
    1043                 :           0 :     internal_error ("bytecode stream: tag %s is not in the expected range "
    1044                 :             :                     "[%s, %s]",
    1045                 :             :                     lto_tag_name (actual),
    1046                 :             :                     lto_tag_name (tag1),
    1047                 :             :                     lto_tag_name (tag2));
    1048                 :        9481 : }
    1049                 :             : 
    1050                 :             : /* Initialize an lto_out_decl_buffer ENCODER.  */
    1051                 :             : inline void
    1052                 :      181670 : lto_init_tree_ref_encoder (struct lto_tree_ref_encoder *encoder)
    1053                 :             : {
    1054                 :      181670 :   encoder->tree_hash_table = new hash_map<tree, unsigned> (251);
    1055                 :      181670 :   encoder->trees.create (0);
    1056                 :      181670 : }
    1057                 :             : 
    1058                 :             : 
    1059                 :             : /* Destroy an lto_tree_ref_encoder ENCODER by freeing its contents.  The
    1060                 :             :    memory used by ENCODER is not freed by this function.  */
    1061                 :             : inline void
    1062                 :      181670 : lto_destroy_tree_ref_encoder (struct lto_tree_ref_encoder *encoder)
    1063                 :             : {
    1064                 :             :   /* Hash table may be delete already.  */
    1065                 :      181670 :   delete encoder->tree_hash_table;
    1066                 :      181670 :   encoder->tree_hash_table = NULL;
    1067                 :      181670 :   encoder->trees.release ();
    1068                 :      181670 : }
    1069                 :             : 
    1070                 :             : /* Return the number of trees encoded in ENCODER. */
    1071                 :             : inline unsigned int
    1072                 :      578482 : lto_tree_ref_encoder_size (struct lto_tree_ref_encoder *encoder)
    1073                 :             : {
    1074                 :     1120744 :   return encoder->trees.length ();
    1075                 :             : }
    1076                 :             : 
    1077                 :             : /* Return the IDX-th tree in ENCODER. */
    1078                 :             : inline tree
    1079                 :     5045374 : lto_tree_ref_encoder_get_tree (struct lto_tree_ref_encoder *encoder,
    1080                 :             :                                unsigned int idx)
    1081                 :             : {
    1082                 :     5045374 :   return encoder->trees[idx];
    1083                 :             : }
    1084                 :             : 
    1085                 :             : /* Return number of encoded nodes in ENCODER.  */
    1086                 :             : inline int
    1087                 :    17655231 : lto_symtab_encoder_size (lto_symtab_encoder_t encoder)
    1088                 :             : {
    1089                 :    27758699 :   return encoder->nodes.length ();
    1090                 :             : }
    1091                 :             : 
    1092                 :             : /* Value used to represent failure of lto_symtab_encoder_lookup.  */
    1093                 :             : #define LCC_NOT_FOUND   (-1)
    1094                 :             : 
    1095                 :             : /* Look up NODE in encoder.  Return NODE's reference if it has been encoded
    1096                 :             :    or LCC_NOT_FOUND if it is not there.  */
    1097                 :             : 
    1098                 :             : inline int
    1099                 :    12378286 : lto_symtab_encoder_lookup (lto_symtab_encoder_t encoder,
    1100                 :             :                            symtab_node *node)
    1101                 :             : {
    1102                 :    12378286 :   size_t *slot = encoder->map->get (node);
    1103                 :    12378286 :   return (slot && *slot ? *(slot) - 1 : LCC_NOT_FOUND);
    1104                 :             : }
    1105                 :             : 
    1106                 :             : /* Return true if iterator LSE points to nothing.  */
    1107                 :             : inline bool
    1108                 :    13750449 : lsei_end_p (lto_symtab_encoder_iterator lsei)
    1109                 :             : {
    1110                 :    10069618 :   return lsei.index >= (unsigned)lto_symtab_encoder_size (lsei.encoder);
    1111                 :             : }
    1112                 :             : 
    1113                 :             : /* Advance iterator LSE.  */
    1114                 :             : inline void
    1115                 :    10816320 : lsei_next (lto_symtab_encoder_iterator *lsei)
    1116                 :             : {
    1117                 :    10816320 :   lsei->index++;
    1118                 :    10816313 : }
    1119                 :             : 
    1120                 :             : /* Return the node pointed to by LSI.  */
    1121                 :             : inline symtab_node *
    1122                 :    15509434 : lsei_node (lto_symtab_encoder_iterator lsei)
    1123                 :             : {
    1124                 :    11177535 :   return lsei.encoder->nodes[lsei.index].node;
    1125                 :             : }
    1126                 :             : 
    1127                 :             : /* Return the node pointed to by LSI.  */
    1128                 :             : inline struct cgraph_node *
    1129                 :     1192629 : lsei_cgraph_node (lto_symtab_encoder_iterator lsei)
    1130                 :             : {
    1131                 :     1192629 :   return dyn_cast<cgraph_node *> (lsei.encoder->nodes[lsei.index].node);
    1132                 :             : }
    1133                 :             : 
    1134                 :             : /* Return the node pointed to by LSI.  */
    1135                 :             : inline varpool_node *
    1136                 :      277598 : lsei_varpool_node (lto_symtab_encoder_iterator lsei)
    1137                 :             : {
    1138                 :      277598 :   return dyn_cast<varpool_node *> (lsei.encoder->nodes[lsei.index].node);
    1139                 :             : }
    1140                 :             : 
    1141                 :             : /* Return the cgraph node corresponding to REF using ENCODER.  */
    1142                 :             : 
    1143                 :             : inline symtab_node *
    1144                 :     5830279 : lto_symtab_encoder_deref (lto_symtab_encoder_t encoder, int ref)
    1145                 :             : {
    1146                 :     5828613 :   if (ref == LCC_NOT_FOUND)
    1147                 :             :     return NULL;
    1148                 :             : 
    1149                 :     5830279 :   return encoder->nodes[ref].node;
    1150                 :             : }
    1151                 :             : 
    1152                 :             : /* Return an iterator to the first node in LSI.  */
    1153                 :             : inline lto_symtab_encoder_iterator
    1154                 :             : lsei_start (lto_symtab_encoder_t encoder)
    1155                 :             : {
    1156                 :             :   lto_symtab_encoder_iterator lsei;
    1157                 :             : 
    1158                 :      396229 :   lsei.encoder = encoder;
    1159                 :      396228 :   lsei.index = 0;
    1160                 :             :   return lsei;
    1161                 :             : }
    1162                 :             : 
    1163                 :             : /* Advance iterator LSE.  */
    1164                 :             : inline void
    1165                 :      680599 : lsei_next_in_partition (lto_symtab_encoder_iterator *lsei)
    1166                 :             : {
    1167                 :      680599 :   lsei_next (lsei);
    1168                 :      680599 :   while (!lsei_end_p (*lsei)
    1169                 :     3382250 :          && !lto_symtab_encoder_in_partition_p (lsei->encoder, lsei_node (*lsei)))
    1170                 :      458860 :     lsei_next (lsei);
    1171                 :      680599 : }
    1172                 :             : 
    1173                 :             : /* Return an iterator to the first node in LSI.  */
    1174                 :             : inline lto_symtab_encoder_iterator
    1175                 :       36515 : lsei_start_in_partition (lto_symtab_encoder_t encoder)
    1176                 :             : {
    1177                 :       36515 :   lto_symtab_encoder_iterator lsei = lsei_start (encoder);
    1178                 :             : 
    1179                 :       72642 :   if (lsei_end_p (lsei))
    1180                 :         388 :     return lsei;
    1181                 :       36127 :   if (!lto_symtab_encoder_in_partition_p (encoder, lsei_node (lsei)))
    1182                 :           0 :     lsei_next_in_partition (&lsei);
    1183                 :             : 
    1184                 :       36127 :   return lsei;
    1185                 :             : }
    1186                 :             : 
    1187                 :             : /* Advance iterator LSE.  */
    1188                 :             : inline void
    1189                 :     1196073 : lsei_next_function_in_partition (lto_symtab_encoder_iterator *lsei)
    1190                 :             : {
    1191                 :     1196073 :   lsei_next (lsei);
    1192                 :     1196073 :   while (!lsei_end_p (*lsei)
    1193                 :    23504248 :          && (!is_a <cgraph_node *> (lsei_node (*lsei))
    1194                 :     3453168 :              || !lto_symtab_encoder_in_partition_p (lsei->encoder, lsei_node (*lsei))))
    1195                 :     5571188 :     lsei_next (lsei);
    1196                 :     1196073 : }
    1197                 :             : 
    1198                 :             : /* Return an iterator to the first node in LSI.  */
    1199                 :             : inline lto_symtab_encoder_iterator
    1200                 :      270494 : lsei_start_function_in_partition (lto_symtab_encoder_t encoder)
    1201                 :             : {
    1202                 :      270494 :   lto_symtab_encoder_iterator lsei = lsei_start (encoder);
    1203                 :             : 
    1204                 :      538438 :   if (lsei_end_p (lsei))
    1205                 :        2550 :     return lsei;
    1206                 :      532452 :   if (!is_a <cgraph_node *> (lsei_node (lsei))
    1207                 :      264508 :       || !lto_symtab_encoder_in_partition_p (encoder, lsei_node (lsei)))
    1208                 :        3444 :     lsei_next_function_in_partition (&lsei);
    1209                 :             : 
    1210                 :      267944 :   return lsei;
    1211                 :             : }
    1212                 :             : 
    1213                 :             : /* Advance iterator LSE.  */
    1214                 :             : inline void
    1215                 :      309559 : lsei_next_variable_in_partition (lto_symtab_encoder_iterator *lsei)
    1216                 :             : {
    1217                 :      309559 :   lsei_next (lsei);
    1218                 :      309559 :   while (!lsei_end_p (*lsei)
    1219                 :     1574756 :          && (!is_a <varpool_node *> (lsei_node (*lsei))
    1220                 :      277005 :              || !lto_symtab_encoder_in_partition_p (lsei->encoder, lsei_node (*lsei))))
    1221                 :      133876 :     lsei_next (lsei);
    1222                 :      309559 : }
    1223                 :             : 
    1224                 :             : /* Return an iterator to the first node in LSI.  */
    1225                 :             : inline lto_symtab_encoder_iterator
    1226                 :       32791 : lsei_start_variable_in_partition (lto_symtab_encoder_t encoder)
    1227                 :             : {
    1228                 :       32791 :   lto_symtab_encoder_iterator lsei = lsei_start (encoder);
    1229                 :             : 
    1230                 :       65345 :   if (lsei_end_p (lsei))
    1231                 :         237 :     return lsei;
    1232                 :       33147 :   if (!is_a <varpool_node *> (lsei_node (lsei))
    1233                 :         593 :       || !lto_symtab_encoder_in_partition_p (encoder, lsei_node (lsei)))
    1234                 :       31961 :     lsei_next_variable_in_partition (&lsei);
    1235                 :             : 
    1236                 :       32554 :   return lsei;
    1237                 :             : }
    1238                 :             : 
    1239                 :             : /* Entry for the delayed registering of decl -> DIE references.  */
    1240                 :             : struct dref_entry {
    1241                 :             :     tree decl;
    1242                 :             :     const char *sym;
    1243                 :             :     unsigned HOST_WIDE_INT off;
    1244                 :             : };
    1245                 :             : 
    1246                 :             : extern vec<dref_entry> dref_queue;
    1247                 :             : 
    1248                 :             : extern FILE *streamer_dump_file;
    1249                 :             : 
    1250                 :             : #endif /* GCC_LTO_STREAMER_H  */
        

Generated by: LCOV version 2.0-1

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