LCOV - code coverage report
Current view: top level - gcc - lto-section-in.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 116 134 86.6 %
Date: 2020-04-04 11:58:09 Functions: 19 23 82.6 %
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-2020 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                 :            :   "hsa",
      57                 :            :   "lto",
      58                 :            :   "ipa_sra"
      59                 :            : };
      60                 :            : 
      61                 :            : /* Hooks so that the ipa passes can call into the lto front end to get
      62                 :            :    sections.  */
      63                 :            : 
      64                 :            : static struct lto_file_decl_data ** file_decl_data;
      65                 :            : static lto_get_section_data_f* get_section_f;
      66                 :            : static lto_free_section_data_f* free_section_f;
      67                 :            : 
      68                 :            : 
      69                 :            : /* This is called from the lto front end to set up the hooks that are
      70                 :            :    used by the ipa passes to get the data that they will
      71                 :            :    deserialize.  */
      72                 :            : 
      73                 :            : void
      74                 :      41961 : lto_set_in_hooks (struct lto_file_decl_data ** data,
      75                 :            :                   lto_get_section_data_f* get_f,
      76                 :            :                   lto_free_section_data_f* free_f)
      77                 :            : {
      78                 :      41961 :   file_decl_data = data;
      79                 :      41961 :   get_section_f = get_f;
      80                 :      41961 :   free_section_f = free_f;
      81                 :      41961 : }
      82                 :            : 
      83                 :            : 
      84                 :            : /* Return an array of file decl datas for all of the files passed to
      85                 :            :    this compilation.  */
      86                 :            : 
      87                 :            : struct lto_file_decl_data **
      88                 :      95821 : lto_get_file_decl_data (void)
      89                 :            : {
      90                 :      95821 :   gcc_assert (file_decl_data);
      91                 :      95821 :   return file_decl_data;
      92                 :            : }
      93                 :            : 
      94                 :            : /* Buffer structure for accumulating data from compression callbacks.  */
      95                 :            : 
      96                 :            : struct lto_buffer
      97                 :            : {
      98                 :            :   char *data;
      99                 :            :   size_t length;
     100                 :            : };
     101                 :            : 
     102                 :            : /* Compression callback, append LENGTH bytes from DATA to the buffer pointed
     103                 :            :    to by OPAQUE.  */
     104                 :            : 
     105                 :            : static void
     106                 :     161347 : lto_append_data (const char *data, unsigned length, void *opaque)
     107                 :            : {
     108                 :     161347 :   struct lto_buffer *buffer = (struct lto_buffer *) opaque;
     109                 :            : 
     110                 :     161347 :   buffer->data = (char *) xrealloc (buffer->data, buffer->length + length);
     111                 :     161347 :   memcpy (buffer->data + buffer->length, data, length);
     112                 :     161347 :   buffer->length += length;
     113                 :     161347 : }
     114                 :            : 
     115                 :            : /* Header placed in returned uncompressed data streams.  Allows the
     116                 :            :    uncompressed allocated data to be mapped back to the underlying
     117                 :            :    compressed data for use with free_section_f.  */
     118                 :            : 
     119                 :            : struct lto_data_header
     120                 :            : {
     121                 :            :   const char *data;
     122                 :            :   size_t len;
     123                 :            : };
     124                 :            : 
     125                 :            : /* Return a char pointer to the start of a data stream for an LTO pass
     126                 :            :    or function.  FILE_DATA indicates where to obtain the data.
     127                 :            :    SECTION_TYPE is the type of information to be obtained.  NAME is
     128                 :            :    the name of the function and is only used when finding a function
     129                 :            :    body; otherwise it is NULL.  LEN is the size of the data
     130                 :            :    returned.  */
     131                 :            : 
     132                 :            : const char *
     133                 :     247155 : lto_get_section_data (struct lto_file_decl_data *file_data,
     134                 :            :                       enum lto_section_type section_type,
     135                 :            :                       const char *name, int order,
     136                 :            :                       size_t *len, bool decompress)
     137                 :            : {
     138                 :     247155 :   const char *data = (get_section_f) (file_data, section_type, name, order,
     139                 :            :                                       len);
     140                 :     247155 :   const size_t header_length = sizeof (struct lto_data_header);
     141                 :     247155 :   struct lto_data_header *header;
     142                 :     247155 :   struct lto_buffer buffer;
     143                 :     247155 :   struct lto_compression_stream *stream;
     144                 :     247155 :   lto_stats.section_size[section_type] += *len;
     145                 :            : 
     146                 :     247155 :   if (data == NULL)
     147                 :            :     return NULL;
     148                 :            : 
     149                 :            :   /* WPA->ltrans streams are not compressed with exception of function bodies
     150                 :            :      and variable initializers that has been verbatim copied from earlier
     151                 :            :      compilations.  */
     152                 :     214319 :   if ((!flag_ltrans || decompress) && section_type != LTO_section_lto)
     153                 :            :     {
     154                 :            :       /* Create a mapping header containing the underlying data and length,
     155                 :            :          and prepend this to the uncompression buffer.  The uncompressed data
     156                 :            :          then follows, and a pointer to the start of the uncompressed data is
     157                 :            :          returned.  */
     158                 :     161347 :       header = (struct lto_data_header *) xmalloc (header_length);
     159                 :     161347 :       header->data = data;
     160                 :     161347 :       header->len = *len;
     161                 :            : 
     162                 :     161347 :       buffer.data = (char *) header;
     163                 :     161347 :       buffer.length = header_length;
     164                 :            : 
     165                 :     161347 :       stream = lto_start_uncompression (lto_append_data, &buffer);
     166                 :     161347 :       lto_uncompress_block (stream, data, *len);
     167                 :     161347 :       lto_end_uncompression (stream,
     168                 :            :                              file_data->lto_section_header.get_compression ());
     169                 :            : 
     170                 :     161347 :       *len = buffer.length - header_length;
     171                 :     161347 :       data = buffer.data + header_length;
     172                 :            :     }
     173                 :            : 
     174                 :            :   return data;
     175                 :            : }
     176                 :            : 
     177                 :            : /* Return a char pointer to the start of a data stream for an LTO pass.
     178                 :            :    FILE_DATA indicates where to obtain the data.
     179                 :            :    SECTION_TYPE is the type of information to be obtained.
     180                 :            :    LEN is the size of the data returned.  */
     181                 :            : 
     182                 :            : const char *
     183                 :      93748 : lto_get_summary_section_data (struct lto_file_decl_data *file_data,
     184                 :            :                               enum lto_section_type section_type, size_t *len)
     185                 :            : {
     186                 :      93748 :   return lto_get_section_data (file_data, section_type, NULL, 0, len);
     187                 :            : }
     188                 :            : 
     189                 :            : /* Get the section data without any header parsing or uncompression.  */
     190                 :            : 
     191                 :            : const char *
     192                 :      27793 : lto_get_raw_section_data (struct lto_file_decl_data *file_data,
     193                 :            :                           enum lto_section_type section_type,
     194                 :            :                           const char *name, int order,
     195                 :            :                           size_t *len)
     196                 :            : {
     197                 :      27793 :   return (get_section_f) (file_data, section_type, name, order, len);
     198                 :            : }
     199                 :            : 
     200                 :            : /* Free the data found from the above call.  The first three
     201                 :            :    parameters are the same as above.  DATA is the data to be freed and
     202                 :            :    LEN is the length of that data.  */
     203                 :            : 
     204                 :            : void
     205                 :     194645 : lto_free_section_data (struct lto_file_decl_data *file_data,
     206                 :            :                        enum lto_section_type section_type,
     207                 :            :                        const char *name,
     208                 :            :                        const char *data,
     209                 :            :                        size_t len, bool decompress)
     210                 :            : {
     211                 :     194645 :   const size_t header_length = sizeof (struct lto_data_header);
     212                 :     194645 :   const char *real_data = data - header_length;
     213                 :     194645 :   const struct lto_data_header *header
     214                 :            :     = (const struct lto_data_header *) real_data;
     215                 :            : 
     216                 :     194645 :   gcc_assert (free_section_f);
     217                 :            : 
     218                 :     194645 :   if (flag_ltrans && !decompress)
     219                 :            :     {
     220                 :      33298 :       (free_section_f) (file_data, section_type, name, data, len);
     221                 :      33298 :       return;
     222                 :            :     }
     223                 :            : 
     224                 :            :   /* The underlying data address has been extracted from the mapping header.
     225                 :            :      Free that, then free the allocated uncompression buffer.  */
     226                 :     161347 :   (free_section_f) (file_data, section_type, name, header->data, header->len);
     227                 :     161347 :   free (CONST_CAST (char *, real_data));
     228                 :            : }
     229                 :            : 
     230                 :            : /* Free data allocated by lto_get_raw_section_data.  */
     231                 :            : 
     232                 :            : void
     233                 :      27793 : lto_free_raw_section_data (struct lto_file_decl_data *file_data,
     234                 :            :                            enum lto_section_type section_type,
     235                 :            :                            const char *name,
     236                 :            :                            const char *data,
     237                 :            :                            size_t len)
     238                 :            : {
     239                 :      27793 :   (free_section_f) (file_data, section_type, name, data, len);
     240                 :      27793 : }
     241                 :            : 
     242                 :            : /* Load a section of type SECTION_TYPE from FILE_DATA, parse the
     243                 :            :    header and then return an input block pointing to the section.  The
     244                 :            :    raw pointer to the section is returned in DATAR and LEN.  These are
     245                 :            :    used to free the section.  Return NULL if the section is not present.  */
     246                 :            : 
     247                 :            : class lto_input_block *
     248                 :      69264 : lto_create_simple_input_block (struct lto_file_decl_data *file_data,
     249                 :            :                                enum lto_section_type section_type,
     250                 :            :                                const char **datar, size_t *len)
     251                 :            : {
     252                 :      69264 :   const char *data = lto_get_section_data (file_data, section_type, NULL, 0,
     253                 :            :                                            len);
     254                 :      69264 :   const struct lto_simple_header * header
     255                 :            :     = (const struct lto_simple_header *) data;
     256                 :            : 
     257                 :      69264 :   int main_offset = sizeof (struct lto_simple_header);
     258                 :            : 
     259                 :      69264 :   if (!data)
     260                 :            :     return NULL;
     261                 :            : 
     262                 :      52442 :   *datar = data;
     263                 :     104884 :   return new lto_input_block (data + main_offset, header->main_size,
     264                 :      52442 :                               file_data->mode_table);
     265                 :            : }
     266                 :            : 
     267                 :            : 
     268                 :            : /* Close the section returned from a call to
     269                 :            :    LTO_CREATE_SIMPLE_INPUT_BLOCK.  IB is the input block returned from
     270                 :            :    that call.  The FILE_DATA and SECTION_TYPE are the same as what was
     271                 :            :    passed to that call and the DATA and LEN are what was returned from
     272                 :            :    that call.  */
     273                 :            : 
     274                 :            : void
     275                 :      47692 : lto_destroy_simple_input_block (struct lto_file_decl_data *file_data,
     276                 :            :                                 enum lto_section_type section_type,
     277                 :            :                                 class lto_input_block *ib,
     278                 :            :                                 const char *data, size_t len)
     279                 :            : {
     280                 :      47692 :   delete ib;
     281                 :      47692 :   lto_free_section_data (file_data, section_type, NULL, data, len);
     282                 :      47692 : }
     283                 :            : 
     284                 :            : /*****************************************************************************/
     285                 :            : /* Record renamings of static declarations                                   */
     286                 :            : /*****************************************************************************/
     287                 :            : 
     288                 :            : struct lto_renaming_slot
     289                 :            : {
     290                 :            :   const char *old_name;
     291                 :            :   const char *new_name;
     292                 :            : };
     293                 :            : 
     294                 :            : /* Returns a hash code for P.  */
     295                 :            : 
     296                 :            : static hashval_t
     297                 :     207746 : hash_name (const void *p)
     298                 :            : {
     299                 :     207746 :   const struct lto_renaming_slot *ds = (const struct lto_renaming_slot *) p;
     300                 :     207746 :   return (hashval_t) htab_hash_string (ds->new_name);
     301                 :            : }
     302                 :            : 
     303                 :            : /* Returns nonzero if P1 and P2 are equal.  */
     304                 :            : 
     305                 :            : static int
     306                 :        750 : eq_name (const void *p1, const void *p2)
     307                 :            : {
     308                 :        750 :   const struct lto_renaming_slot *s1 =
     309                 :            :     (const struct lto_renaming_slot *) p1;
     310                 :        750 :   const struct lto_renaming_slot *s2 =
     311                 :            :     (const struct lto_renaming_slot *) p2;
     312                 :            : 
     313                 :        750 :   return strcmp (s1->new_name, s2->new_name) == 0;
     314                 :            : }
     315                 :            : 
     316                 :            : /* Free a renaming table entry.  */
     317                 :            : 
     318                 :            : static void
     319                 :          0 : renaming_slot_free (void *slot)
     320                 :            : {
     321                 :          0 :   struct lto_renaming_slot *s = (struct lto_renaming_slot *) slot;
     322                 :            : 
     323                 :          0 :   free (CONST_CAST (void *, (const void *) s->old_name));
     324                 :          0 :   free (CONST_CAST (void *, (const void *) s->new_name));
     325                 :          0 :   free ((void *) s);
     326                 :          0 : }
     327                 :            : 
     328                 :            : /* Create an empty hash table for recording declaration renamings.  */
     329                 :            : 
     330                 :            : htab_t
     331                 :      14924 : lto_create_renaming_table (void)
     332                 :            : {
     333                 :      14924 :   return htab_create (37, hash_name, eq_name, renaming_slot_free);
     334                 :            : }
     335                 :            : 
     336                 :            : /* Record a declaration name mapping OLD_NAME -> NEW_NAME.  DECL_DATA
     337                 :            :    holds the renaming hash table to use.  */
     338                 :            : 
     339                 :            : void
     340                 :        318 : lto_record_renamed_decl (struct lto_file_decl_data *decl_data,
     341                 :            :                          const char *old_name, const char *new_name)
     342                 :            : {
     343                 :        318 :   void **slot;
     344                 :        318 :   struct lto_renaming_slot r_slot;
     345                 :            : 
     346                 :        318 :   r_slot.new_name = new_name;
     347                 :        318 :   slot = htab_find_slot (decl_data->renaming_hash_table, &r_slot, INSERT);
     348                 :        318 :   if (*slot == NULL)
     349                 :            :     {
     350                 :        318 :       struct lto_renaming_slot *new_slot = XNEW (struct lto_renaming_slot);
     351                 :        318 :       new_slot->old_name = xstrdup (old_name);
     352                 :        318 :       new_slot->new_name = xstrdup (new_name);
     353                 :        318 :       *slot = new_slot;
     354                 :            :     }
     355                 :            :   else
     356                 :          0 :     gcc_unreachable ();
     357                 :        318 : }
     358                 :            : 
     359                 :            : 
     360                 :            : /* Given a string NAME, return the string that it has been mapped to
     361                 :            :    by lto_record_renamed_decl.  If NAME was not renamed, it is
     362                 :            :    returned unchanged.  DECL_DATA holds the renaming hash table to use.  */
     363                 :            : 
     364                 :            : const char *
     365                 :     207428 : lto_get_decl_name_mapping (struct lto_file_decl_data *decl_data,
     366                 :            :                            const char *name)
     367                 :            : {
     368                 :     207428 :   htab_t renaming_hash_table = decl_data->renaming_hash_table;
     369                 :     207428 :   struct lto_renaming_slot *slot;
     370                 :     207428 :   struct lto_renaming_slot r_slot;
     371                 :            : 
     372                 :     207428 :   r_slot.new_name = name;
     373                 :     207428 :   slot = (struct lto_renaming_slot *) htab_find (renaming_hash_table, &r_slot);
     374                 :     207428 :   if (slot)
     375                 :        485 :     return slot->old_name;
     376                 :            :   else
     377                 :            :     return name;
     378                 :            : }
     379                 :            : 
     380                 :            : /*****************************************************************************/
     381                 :            : /* Input decl state object.                                                  */
     382                 :            : /*****************************************************************************/
     383                 :            : 
     384                 :            : /* Return a newly created in-decl state object. */
     385                 :            : 
     386                 :            : struct lto_in_decl_state *
     387                 :     132343 : lto_new_in_decl_state (void)
     388                 :            : {
     389                 :     132343 :   return ggc_cleared_alloc<lto_in_decl_state> ();
     390                 :            : }
     391                 :            : 
     392                 :            : /* Delete STATE and its components. */
     393                 :            : 
     394                 :            : void
     395                 :          0 : lto_delete_in_decl_state (struct lto_in_decl_state *state)
     396                 :            : {
     397                 :          0 :   int i;
     398                 :            : 
     399                 :          0 :   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
     400                 :          0 :     vec_free (state->streams[i]);
     401                 :          0 :   ggc_free (state);
     402                 :          0 : }
     403                 :            : 
     404                 :            : /* Search the in-decl state of a function FUNC contained in the file
     405                 :            :    associated with FILE_DATA.  Return NULL if not found.  */
     406                 :            : 
     407                 :            : struct lto_in_decl_state*
     408                 :     196079 : lto_get_function_in_decl_state (struct lto_file_decl_data *file_data,
     409                 :            :                                 tree func)
     410                 :            : {
     411                 :     196079 :   struct lto_in_decl_state temp;
     412                 :     196079 :   lto_in_decl_state **slot;
     413                 :            : 
     414                 :     196079 :   temp.fn_decl = func;
     415                 :     196079 :   slot = file_data->function_decl_states->find_slot (&temp, NO_INSERT);
     416                 :     196079 :   return slot? *slot : NULL;
     417                 :            : }
     418                 :            : 
     419                 :            : /* Free decl_states.  */
     420                 :            : 
     421                 :            : void
     422                 :     104616 : lto_free_function_in_decl_state (struct lto_in_decl_state *state)
     423                 :            : {
     424                 :     104616 :   int i;
     425                 :     836928 :   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
     426                 :     970181 :     vec_free (state->streams[i]);
     427                 :     104616 :   ggc_free (state);
     428                 :     104616 : }
     429                 :            : 
     430                 :            : /* Free decl_states associated with NODE.  This makes it possible to furhter
     431                 :            :    release trees needed by the NODE's body.  */
     432                 :            : 
     433                 :            : void
     434                 :     126322 : lto_free_function_in_decl_state_for_node (symtab_node *node)
     435                 :            : {
     436                 :     126322 :   struct lto_in_decl_state temp;
     437                 :     126322 :   lto_in_decl_state **slot;
     438                 :            : 
     439                 :     126322 :   if (!node->lto_file_data)
     440                 :       1855 :     return;
     441                 :            : 
     442                 :     124467 :   temp.fn_decl = node->decl;
     443                 :     124467 :   slot
     444                 :     124467 :     = node->lto_file_data->function_decl_states->find_slot (&temp, NO_INSERT);
     445                 :     124467 :   if (slot && *slot)
     446                 :            :     {
     447                 :      89692 :       lto_free_function_in_decl_state (*slot);
     448                 :      89692 :       node->lto_file_data->function_decl_states->clear_slot (slot);
     449                 :            :     }
     450                 :     124467 :   node->lto_file_data = NULL;
     451                 :            : }
     452                 :            : 
     453                 :            : 
     454                 :            : /* Report read pass end of the section.  */
     455                 :            : 
     456                 :            : void
     457                 :          0 : lto_section_overrun (class lto_input_block *ib)
     458                 :            : {
     459                 :          0 :   fatal_error (input_location, "bytecode stream: trying to read %d bytes "
     460                 :          0 :                "after the end of the input buffer", ib->p - ib->len);
     461                 :            : }
     462                 :            : 
     463                 :            : /* Report out of range value.  */
     464                 :            : 
     465                 :            : void
     466                 :          0 : lto_value_range_error (const char *purpose, HOST_WIDE_INT val,
     467                 :            :                        HOST_WIDE_INT min, HOST_WIDE_INT max)
     468                 :            : {
     469                 :          0 :   fatal_error (input_location,
     470                 :            :                "%s out of range: Range is %i to %i, value is %i",
     471                 :            :                purpose, (int)min, (int)max, (int)val);
     472                 :            : }

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.