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

             Branch data     Line data    Source code
       1                 :             : /* Input functions for reading LTO sections.
       2                 :             : 
       3                 :             :    Copyright (C) 2009-2024 Free Software Foundation, Inc.
       4                 :             :    Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
       5                 :             : 
       6                 :             : This file is part of GCC.
       7                 :             : 
       8                 :             : GCC is free software; you can redistribute it and/or modify it under
       9                 :             : the terms of the GNU General Public License as published by the Free
      10                 :             : Software Foundation; either version 3, or (at your option) any later
      11                 :             : version.
      12                 :             : 
      13                 :             : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      14                 :             : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      15                 :             : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      16                 :             : for more details.
      17                 :             : 
      18                 :             : You should have received a copy of the GNU General Public License
      19                 :             : along with GCC; see the file COPYING3.  If not see
      20                 :             : <http://www.gnu.org/licenses/>.  */
      21                 :             : 
      22                 :             : #include "config.h"
      23                 :             : #include "system.h"
      24                 :             : #include "coretypes.h"
      25                 :             : #include "backend.h"
      26                 :             : #include "rtl.h"
      27                 :             : #include "tree.h"
      28                 :             : #include "gimple.h"
      29                 :             : #include "cgraph.h"
      30                 :             : #include "lto-streamer.h"
      31                 :             : #include "lto-compress.h"
      32                 :             : 
      33                 :             : /* Section names.  These must correspond to the values of
      34                 :             :    enum lto_section_type.  */
      35                 :             : const char *lto_section_name[LTO_N_SECTION_TYPES] =
      36                 :             : {
      37                 :             :   "decls",
      38                 :             :   "function_body",
      39                 :             :   "statics",
      40                 :             :   "symtab",
      41                 :             :   "ext_symtab",
      42                 :             :   "refs",
      43                 :             :   "asm",
      44                 :             :   "jmpfuncs",
      45                 :             :   "pureconst",
      46                 :             :   "reference",
      47                 :             :   "profile",
      48                 :             :   "symbol_nodes",
      49                 :             :   "opts",
      50                 :             :   "cgraphopt",
      51                 :             :   "inline",
      52                 :             :   "ipcp_trans",
      53                 :             :   "icf",
      54                 :             :   "offload_table",
      55                 :             :   "mode_table",
      56                 :             :   "lto",
      57                 :             :   "ipa_sra",
      58                 :             :   "odr_types",
      59                 :             :   "ipa_modref",
      60                 :             : };
      61                 :             : 
      62                 :             : /* Hooks so that the ipa passes can call into the lto front end to get
      63                 :             :    sections.  */
      64                 :             : 
      65                 :             : static struct lto_file_decl_data ** file_decl_data;
      66                 :             : static lto_get_section_data_f* get_section_f;
      67                 :             : static lto_free_section_data_f* free_section_f;
      68                 :             : 
      69                 :             : 
      70                 :             : /* This is called from the lto front end to set up the hooks that are
      71                 :             :    used by the ipa passes to get the data that they will
      72                 :             :    deserialize.  */
      73                 :             : 
      74                 :             : void
      75                 :       66084 : lto_set_in_hooks (struct lto_file_decl_data ** data,
      76                 :             :                   lto_get_section_data_f* get_f,
      77                 :             :                   lto_free_section_data_f* free_f)
      78                 :             : {
      79                 :       66084 :   file_decl_data = data;
      80                 :       66084 :   get_section_f = get_f;
      81                 :       66084 :   free_section_f = free_f;
      82                 :       66084 : }
      83                 :             : 
      84                 :             : 
      85                 :             : /* Return an array of file decl datas for all of the files passed to
      86                 :             :    this compilation.  */
      87                 :             : 
      88                 :             : struct lto_file_decl_data **
      89                 :      180046 : lto_get_file_decl_data (void)
      90                 :             : {
      91                 :      180046 :   gcc_assert (file_decl_data);
      92                 :      180046 :   return file_decl_data;
      93                 :             : }
      94                 :             : 
      95                 :             : /* Buffer structure for accumulating data from compression callbacks.  */
      96                 :             : 
      97                 :             : struct lto_buffer
      98                 :             : {
      99                 :             :   char *data;
     100                 :             :   size_t length;
     101                 :             : };
     102                 :             : 
     103                 :             : /* Compression callback, append LENGTH bytes from DATA to the buffer pointed
     104                 :             :    to by OPAQUE.  */
     105                 :             : 
     106                 :             : static void
     107                 :      206825 : lto_append_data (const char *data, unsigned length, void *opaque)
     108                 :             : {
     109                 :      206825 :   struct lto_buffer *buffer = (struct lto_buffer *) opaque;
     110                 :             : 
     111                 :      206825 :   buffer->data = (char *) xrealloc (buffer->data, buffer->length + length);
     112                 :      206825 :   memcpy (buffer->data + buffer->length, data, length);
     113                 :      206825 :   buffer->length += length;
     114                 :      206825 : }
     115                 :             : 
     116                 :             : /* Header placed in returned uncompressed data streams.  Allows the
     117                 :             :    uncompressed allocated data to be mapped back to the underlying
     118                 :             :    compressed data for use with free_section_f.  */
     119                 :             : 
     120                 :             : struct lto_data_header
     121                 :             : {
     122                 :             :   const char *data;
     123                 :             :   size_t len;
     124                 :             : };
     125                 :             : 
     126                 :             : /* Return a char pointer to the start of a data stream for an LTO pass
     127                 :             :    or function.  FILE_DATA indicates where to obtain the data.
     128                 :             :    SECTION_TYPE is the type of information to be obtained.  NAME is
     129                 :             :    the name of the function and is only used when finding a function
     130                 :             :    body; otherwise it is NULL.  LEN is the size of the data
     131                 :             :    returned.  */
     132                 :             : 
     133                 :             : const char *
     134                 :      370906 : lto_get_section_data (struct lto_file_decl_data *file_data,
     135                 :             :                       enum lto_section_type section_type,
     136                 :             :                       const char *name, int order,
     137                 :             :                       size_t *len, bool decompress)
     138                 :             : {
     139                 :      370906 :   const char *data = (get_section_f) (file_data, section_type, name, order,
     140                 :             :                                       len);
     141                 :      370906 :   const size_t header_length = sizeof (struct lto_data_header);
     142                 :      370906 :   struct lto_data_header *header;
     143                 :      370906 :   struct lto_buffer buffer;
     144                 :      370906 :   struct lto_compression_stream *stream;
     145                 :      370906 :   lto_stats.section_size[section_type] += *len;
     146                 :             : 
     147                 :      370906 :   if (data == NULL)
     148                 :             :     return NULL;
     149                 :             : 
     150                 :             :   /* WPA->ltrans streams are not compressed with exception of function bodies
     151                 :             :      and variable initializers that has been verbatim copied from earlier
     152                 :             :      compilations.  */
     153                 :      299396 :   if ((!flag_ltrans || decompress) && section_type != LTO_section_lto)
     154                 :             :     {
     155                 :             :       /* Create a mapping header containing the underlying data and length,
     156                 :             :          and prepend this to the uncompression buffer.  The uncompressed data
     157                 :             :          then follows, and a pointer to the start of the uncompressed data is
     158                 :             :          returned.  */
     159                 :      206825 :       header = (struct lto_data_header *) xmalloc (header_length);
     160                 :      206825 :       header->data = data;
     161                 :      206825 :       header->len = *len;
     162                 :             : 
     163                 :      206825 :       buffer.data = (char *) header;
     164                 :      206825 :       buffer.length = header_length;
     165                 :             : 
     166                 :      206825 :       stream = lto_start_uncompression (lto_append_data, &buffer);
     167                 :      206825 :       lto_uncompress_block (stream, data, *len);
     168                 :      206825 :       lto_end_uncompression (stream,
     169                 :             :                              file_data->lto_section_header.get_compression ());
     170                 :             : 
     171                 :      206825 :       *len = buffer.length - header_length;
     172                 :      206825 :       data = buffer.data + header_length;
     173                 :             :     }
     174                 :             : 
     175                 :             :   return data;
     176                 :             : }
     177                 :             : 
     178                 :             : /* Return a char pointer to the start of a data stream for an LTO pass.
     179                 :             :    FILE_DATA indicates where to obtain the data.
     180                 :             :    SECTION_TYPE is the type of information to be obtained.
     181                 :             :    LEN is the size of the data returned.  */
     182                 :             : 
     183                 :             : const char *
     184                 :      175840 : lto_get_summary_section_data (struct lto_file_decl_data *file_data,
     185                 :             :                               enum lto_section_type section_type, size_t *len)
     186                 :             : {
     187                 :      175840 :   return lto_get_section_data (file_data, section_type, NULL, 0, len);
     188                 :             : }
     189                 :             : 
     190                 :             : /* Get the section data without any header parsing or uncompression.  */
     191                 :             : 
     192                 :             : const char *
     193                 :       33472 : lto_get_raw_section_data (struct lto_file_decl_data *file_data,
     194                 :             :                           enum lto_section_type section_type,
     195                 :             :                           const char *name, int order,
     196                 :             :                           size_t *len)
     197                 :             : {
     198                 :       33472 :   return (get_section_f) (file_data, section_type, name, order, len);
     199                 :             : }
     200                 :             : 
     201                 :             : /* Free the data found from the above call.  The first three
     202                 :             :    parameters are the same as above.  DATA is the data to be freed and
     203                 :             :    LEN is the length of that data.  */
     204                 :             : 
     205                 :             : void
     206                 :      268019 : lto_free_section_data (struct lto_file_decl_data *file_data,
     207                 :             :                        enum lto_section_type section_type,
     208                 :             :                        const char *name,
     209                 :             :                        const char *data,
     210                 :             :                        size_t len, bool decompress)
     211                 :             : {
     212                 :      268019 :   const size_t header_length = sizeof (struct lto_data_header);
     213                 :      268019 :   const char *real_data = data - header_length;
     214                 :      268019 :   const struct lto_data_header *header
     215                 :             :     = (const struct lto_data_header *) real_data;
     216                 :             : 
     217                 :      268019 :   gcc_assert (free_section_f);
     218                 :             : 
     219                 :      268019 :   if (flag_ltrans && !decompress)
     220                 :             :     {
     221                 :       61194 :       (free_section_f) (file_data, section_type, name, data, len);
     222                 :       61194 :       return;
     223                 :             :     }
     224                 :             : 
     225                 :             :   /* The underlying data address has been extracted from the mapping header.
     226                 :             :      Free that, then free the allocated uncompression buffer.  */
     227                 :      206825 :   (free_section_f) (file_data, section_type, name, header->data, header->len);
     228                 :      206825 :   free (CONST_CAST (char *, real_data));
     229                 :             : }
     230                 :             : 
     231                 :             : /* Free data allocated by lto_get_raw_section_data.  */
     232                 :             : 
     233                 :             : void
     234                 :       33472 : lto_free_raw_section_data (struct lto_file_decl_data *file_data,
     235                 :             :                            enum lto_section_type section_type,
     236                 :             :                            const char *name,
     237                 :             :                            const char *data,
     238                 :             :                            size_t len)
     239                 :             : {
     240                 :       33472 :   (free_section_f) (file_data, section_type, name, data, len);
     241                 :       33472 : }
     242                 :             : 
     243                 :             : /* Load a section of type SECTION_TYPE from FILE_DATA, parse the
     244                 :             :    header and then return an input block pointing to the section.  The
     245                 :             :    raw pointer to the section is returned in DATAR and LEN.  These are
     246                 :             :    used to free the section.  Return NULL if the section is not present.  */
     247                 :             : 
     248                 :             : class lto_input_block *
     249                 :      106001 : lto_create_simple_input_block (struct lto_file_decl_data *file_data,
     250                 :             :                                enum lto_section_type section_type,
     251                 :             :                                const char **datar, size_t *len)
     252                 :             : {
     253                 :      106001 :   const char *data = lto_get_section_data (file_data, section_type, NULL, 0,
     254                 :             :                                            len);
     255                 :      106001 :   const struct lto_simple_header * header
     256                 :             :     = (const struct lto_simple_header *) data;
     257                 :             : 
     258                 :      106001 :   int main_offset = sizeof (struct lto_simple_header);
     259                 :             : 
     260                 :      106001 :   if (!data)
     261                 :             :     return NULL;
     262                 :             : 
     263                 :       75240 :   *datar = data;
     264                 :      150480 :   return new lto_input_block (data + main_offset, header->main_size,
     265                 :       75240 :                               file_data);
     266                 :             : }
     267                 :             : 
     268                 :             : 
     269                 :             : /* Close the section returned from a call to
     270                 :             :    LTO_CREATE_SIMPLE_INPUT_BLOCK.  IB is the input block returned from
     271                 :             :    that call.  The FILE_DATA and SECTION_TYPE are the same as what was
     272                 :             :    passed to that call and the DATA and LEN are what was returned from
     273                 :             :    that call.  */
     274                 :             : 
     275                 :             : void
     276                 :       66894 : lto_destroy_simple_input_block (struct lto_file_decl_data *file_data,
     277                 :             :                                 enum lto_section_type section_type,
     278                 :             :                                 class lto_input_block *ib,
     279                 :             :                                 const char *data, size_t len)
     280                 :             : {
     281                 :       66894 :   delete ib;
     282                 :       66894 :   lto_free_section_data (file_data, section_type, NULL, data, len);
     283                 :       66894 : }
     284                 :             : 
     285                 :             : /*****************************************************************************/
     286                 :             : /* Record renamings of static declarations                                   */
     287                 :             : /*****************************************************************************/
     288                 :             : 
     289                 :             : struct lto_renaming_slot
     290                 :             : {
     291                 :             :   const char *old_name;
     292                 :             :   const char *new_name;
     293                 :             : };
     294                 :             : 
     295                 :             : /* Returns a hash code for P.  */
     296                 :             : 
     297                 :             : static hashval_t
     298                 :      249486 : hash_name (const void *p)
     299                 :             : {
     300                 :      249486 :   const struct lto_renaming_slot *ds = (const struct lto_renaming_slot *) p;
     301                 :      249486 :   return (hashval_t) htab_hash_string (ds->new_name);
     302                 :             : }
     303                 :             : 
     304                 :             : /* Returns nonzero if P1 and P2 are equal.  */
     305                 :             : 
     306                 :             : static int
     307                 :         772 : eq_name (const void *p1, const void *p2)
     308                 :             : {
     309                 :         772 :   const struct lto_renaming_slot *s1 =
     310                 :             :     (const struct lto_renaming_slot *) p1;
     311                 :         772 :   const struct lto_renaming_slot *s2 =
     312                 :             :     (const struct lto_renaming_slot *) p2;
     313                 :             : 
     314                 :         772 :   return strcmp (s1->new_name, s2->new_name) == 0;
     315                 :             : }
     316                 :             : 
     317                 :             : /* Free a renaming table entry.  */
     318                 :             : 
     319                 :             : static void
     320                 :           0 : renaming_slot_free (void *slot)
     321                 :             : {
     322                 :           0 :   struct lto_renaming_slot *s = (struct lto_renaming_slot *) slot;
     323                 :             : 
     324                 :           0 :   free (CONST_CAST (void *, (const void *) s->old_name));
     325                 :           0 :   free (CONST_CAST (void *, (const void *) s->new_name));
     326                 :           0 :   free ((void *) s);
     327                 :           0 : }
     328                 :             : 
     329                 :             : /* Create an empty hash table for recording declaration renamings.  */
     330                 :             : 
     331                 :             : htab_t
     332                 :       23031 : lto_create_renaming_table (void)
     333                 :             : {
     334                 :       23031 :   return htab_create (37, hash_name, eq_name, renaming_slot_free);
     335                 :             : }
     336                 :             : 
     337                 :             : /* Record a declaration name mapping OLD_NAME -> NEW_NAME.  DECL_DATA
     338                 :             :    holds the renaming hash table to use.  */
     339                 :             : 
     340                 :             : void
     341                 :         320 : lto_record_renamed_decl (struct lto_file_decl_data *decl_data,
     342                 :             :                          const char *old_name, const char *new_name)
     343                 :             : {
     344                 :         320 :   void **slot;
     345                 :         320 :   struct lto_renaming_slot r_slot;
     346                 :             : 
     347                 :         320 :   r_slot.new_name = new_name;
     348                 :         320 :   slot = htab_find_slot (decl_data->renaming_hash_table, &r_slot, INSERT);
     349                 :         320 :   if (*slot == NULL)
     350                 :             :     {
     351                 :         320 :       struct lto_renaming_slot *new_slot = XNEW (struct lto_renaming_slot);
     352                 :         320 :       new_slot->old_name = xstrdup (old_name);
     353                 :         320 :       new_slot->new_name = xstrdup (new_name);
     354                 :         320 :       *slot = new_slot;
     355                 :             :     }
     356                 :             :   else
     357                 :           0 :     gcc_unreachable ();
     358                 :         320 : }
     359                 :             : 
     360                 :             : 
     361                 :             : /* Given a string NAME, return the string that it has been mapped to
     362                 :             :    by lto_record_renamed_decl.  If NAME was not renamed, it is
     363                 :             :    returned unchanged.  DECL_DATA holds the renaming hash table to use.  */
     364                 :             : 
     365                 :             : const char *
     366                 :      249166 : lto_get_decl_name_mapping (struct lto_file_decl_data *decl_data,
     367                 :             :                            const char *name)
     368                 :             : {
     369                 :      249166 :   htab_t renaming_hash_table = decl_data->renaming_hash_table;
     370                 :      249166 :   struct lto_renaming_slot *slot;
     371                 :      249166 :   struct lto_renaming_slot r_slot;
     372                 :             : 
     373                 :      249166 :   r_slot.new_name = name;
     374                 :      249166 :   slot = (struct lto_renaming_slot *) htab_find (renaming_hash_table, &r_slot);
     375                 :      249166 :   if (slot)
     376                 :         487 :     return slot->old_name;
     377                 :             :   else
     378                 :             :     return name;
     379                 :             : }
     380                 :             : 
     381                 :             : /*****************************************************************************/
     382                 :             : /* Input decl state object.                                                  */
     383                 :             : /*****************************************************************************/
     384                 :             : 
     385                 :             : /* Return a newly created in-decl state object. */
     386                 :             : 
     387                 :             : struct lto_in_decl_state *
     388                 :      154048 : lto_new_in_decl_state (void)
     389                 :             : {
     390                 :      154048 :   return ggc_cleared_alloc<lto_in_decl_state> ();
     391                 :             : }
     392                 :             : 
     393                 :             : /* Delete STATE and its components. */
     394                 :             : 
     395                 :             : void
     396                 :           0 : lto_delete_in_decl_state (struct lto_in_decl_state *state)
     397                 :             : {
     398                 :           0 :   int i;
     399                 :             : 
     400                 :           0 :   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
     401                 :           0 :     vec_free (state->streams[i]);
     402                 :           0 :   ggc_free (state);
     403                 :           0 : }
     404                 :             : 
     405                 :             : /* Search the in-decl state of a function FUNC contained in the file
     406                 :             :    associated with FILE_DATA.  Return NULL if not found.  */
     407                 :             : 
     408                 :             : struct lto_in_decl_state*
     409                 :      211602 : lto_get_function_in_decl_state (struct lto_file_decl_data *file_data,
     410                 :             :                                 tree func)
     411                 :             : {
     412                 :      211602 :   struct lto_in_decl_state temp;
     413                 :      211602 :   lto_in_decl_state **slot;
     414                 :             : 
     415                 :      211602 :   temp.fn_decl = func;
     416                 :      211602 :   slot = file_data->function_decl_states->find_slot (&temp, NO_INSERT);
     417                 :      211602 :   return slot? *slot : NULL;
     418                 :             : }
     419                 :             : 
     420                 :             : /* Free decl_states.  */
     421                 :             : 
     422                 :             : void
     423                 :      120641 : lto_free_function_in_decl_state (struct lto_in_decl_state *state)
     424                 :             : {
     425                 :      120641 :   int i;
     426                 :      241282 :   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
     427                 :      240866 :     vec_free (state->streams[i]);
     428                 :      120641 :   ggc_free (state);
     429                 :      120641 : }
     430                 :             : 
     431                 :             : /* Free decl_states associated with NODE.  This makes it possible to furhter
     432                 :             :    release trees needed by the NODE's body.  */
     433                 :             : 
     434                 :             : void
     435                 :      144246 : lto_free_function_in_decl_state_for_node (symtab_node *node)
     436                 :             : {
     437                 :      144246 :   struct lto_in_decl_state temp;
     438                 :      144246 :   lto_in_decl_state **slot;
     439                 :             : 
     440                 :      144246 :   if (!node->lto_file_data)
     441                 :        1973 :     return;
     442                 :             : 
     443                 :      142273 :   temp.fn_decl = node->decl;
     444                 :      142273 :   slot
     445                 :      142273 :     = node->lto_file_data->function_decl_states->find_slot (&temp, NO_INSERT);
     446                 :      142273 :   if (slot && *slot)
     447                 :             :     {
     448                 :       97610 :       lto_free_function_in_decl_state (*slot);
     449                 :       97610 :       node->lto_file_data->function_decl_states->clear_slot (slot);
     450                 :             :     }
     451                 :      142273 :   node->lto_file_data = NULL;
     452                 :             : }
     453                 :             : 
     454                 :             : 
     455                 :             : /* Report read pass end of the section.  */
     456                 :             : 
     457                 :             : void
     458                 :           0 : lto_section_overrun (class lto_input_block *ib)
     459                 :             : {
     460                 :           0 :   fatal_error (input_location, "bytecode stream: trying to read %d bytes "
     461                 :           0 :                "after the end of the input buffer", ib->p - ib->len);
     462                 :             : }
     463                 :             : 
     464                 :             : /* Report out of range value.  */
     465                 :             : 
     466                 :             : void
     467                 :           0 : lto_value_range_error (const char *purpose, HOST_WIDE_INT val,
     468                 :             :                        HOST_WIDE_INT min, HOST_WIDE_INT max)
     469                 :             : {
     470                 :           0 :   fatal_error (input_location,
     471                 :             :                "%s out of range: Range is %i to %i, value is %i",
     472                 :             :                purpose, (int)min, (int)max, (int)val);
     473                 :             : }
        

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.