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

             Branch data     Line data    Source code
       1                 :             : /* Functions for writing 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 "data-streamer.h"
      31                 :             : #include "langhooks.h"
      32                 :             : #include "lto-compress.h"
      33                 :             : #include "print-tree.h"
      34                 :             : 
      35                 :             : static vec<lto_out_decl_state_ptr> decl_state_stack;
      36                 :             : 
      37                 :             : /* List of out decl states used by functions.  We use this to
      38                 :             :    generate the decl directory later. */
      39                 :             : 
      40                 :             : vec<lto_out_decl_state_ptr> lto_function_decl_states;
      41                 :             : 
      42                 :             : 
      43                 :             : /*****************************************************************************
      44                 :             :    Output routines shared by all of the serialization passes.
      45                 :             : *****************************************************************************/
      46                 :             : 
      47                 :             : 
      48                 :             : /* Flush compressed stream data function, sends NUM_CHARS from CHARS
      49                 :             :    to the append lang hook, OPAQUE is currently always NULL.  */
      50                 :             : 
      51                 :             : static void
      52                 :      325454 : lto_append_data (const char *chars, unsigned int num_chars, void *opaque)
      53                 :             : {
      54                 :      325454 :   gcc_assert (opaque == NULL);
      55                 :      325454 :   lang_hooks.lto.append_data (chars, num_chars, opaque);
      56                 :      325454 : }
      57                 :             : 
      58                 :             : /* Pointer to the current compression stream.  */
      59                 :             : 
      60                 :             : static struct lto_compression_stream *compression_stream = NULL;
      61                 :             : 
      62                 :             : /* Begin a new output section named NAME. If COMPRESS is true, zlib compress
      63                 :             :    the section. */
      64                 :             : 
      65                 :             : void
      66                 :      541324 : lto_begin_section (const char *name, bool compress)
      67                 :             : {
      68                 :      541324 :   lang_hooks.lto.begin_section (name);
      69                 :             : 
      70                 :      541324 :   if (streamer_dump_file)
      71                 :             :     {
      72                 :          68 :       if (flag_dump_unnumbered || flag_dump_noaddr)
      73                 :          84 :           fprintf (streamer_dump_file, "Creating %ssection\n",
      74                 :             :                    compress ? "compressed " : "");
      75                 :             :         else
      76                 :           0 :           fprintf (streamer_dump_file, "Creating %ssection %s\n",
      77                 :             :                    compress ? "compressed " : "", name);
      78                 :             :     }
      79                 :      541324 :   gcc_assert (compression_stream == NULL);
      80                 :      541324 :   if (compress)
      81                 :      325454 :     compression_stream = lto_start_compression (lto_append_data, NULL);
      82                 :      541324 : }
      83                 :             : 
      84                 :             : 
      85                 :             : /* End the current output section.  */
      86                 :             : 
      87                 :             : void
      88                 :      541324 : lto_end_section (void)
      89                 :             : {
      90                 :      541324 :   if (compression_stream)
      91                 :             :     {
      92                 :      325454 :       lto_end_compression (compression_stream);
      93                 :      325454 :       compression_stream = NULL;
      94                 :             :     }
      95                 :      541324 :   lang_hooks.lto.end_section ();
      96                 :      541324 : }
      97                 :             : 
      98                 :             : /* Write SIZE bytes starting at DATA to the assembler.  */
      99                 :             : 
     100                 :             : void
     101                 :     5178124 : lto_write_data (const void *data, unsigned int size)
     102                 :             : {
     103                 :     5178124 :   if (compression_stream)
     104                 :      616685 :     lto_compress_block (compression_stream, (const char *)data, size);
     105                 :             :   else
     106                 :     4561439 :     lang_hooks.lto.append_data ((const char *)data, size, NULL);
     107                 :     5178124 : }
     108                 :             : 
     109                 :             : /* Write SIZE bytes starting at DATA to the assembler.  */
     110                 :             : 
     111                 :             : void
     112                 :       33472 : lto_write_raw_data (const void *data, unsigned int size)
     113                 :             : {
     114                 :       33472 :   lang_hooks.lto.append_data ((const char *)data, size, NULL);
     115                 :       33472 : }
     116                 :             : 
     117                 :             : /* Write all of the chars in OBS to the assembler.  Recycle the blocks
     118                 :             :    in obs as this is being done.  */
     119                 :             : 
     120                 :             : void
     121                 :      793716 : lto_write_stream (struct lto_output_stream *obs)
     122                 :             : {
     123                 :      793716 :   unsigned int block_size = 1024;
     124                 :      793716 :   struct lto_char_ptr_base *block;
     125                 :      793716 :   struct lto_char_ptr_base *next_block;
     126                 :      793716 :   if (!obs->first_block)
     127                 :             :     return;
     128                 :             : 
     129                 :     1347048 :   for (block = obs->first_block; block; block = next_block)
     130                 :             :     {
     131                 :      694652 :       const char *base = ((char *)block) + sizeof (struct lto_char_ptr_base);
     132                 :      694652 :       unsigned int num_chars = block_size - sizeof (struct lto_char_ptr_base);
     133                 :             : 
     134                 :             :       /* If this is not the last block, it is full.  If it is the last
     135                 :             :          block, left_in_block indicates how many chars are unoccupied in
     136                 :             :          this block; subtract from num_chars to obtain occupancy.  */
     137                 :      694652 :       next_block = (struct lto_char_ptr_base *) block->ptr;
     138                 :      694652 :       if (!next_block)
     139                 :      652396 :         num_chars -= obs->left_in_block;
     140                 :             : 
     141                 :      694652 :       if (compression_stream)
     142                 :      598127 :         lto_compress_block (compression_stream, base, num_chars);
     143                 :             :       else
     144                 :       96525 :         lang_hooks.lto.append_data (base, num_chars, block);
     145                 :      694652 :       free (block);
     146                 :      694652 :       block_size *= 2;
     147                 :             :     }
     148                 :             : }
     149                 :             : 
     150                 :             : /* Create the output block and return it.  */
     151                 :             : 
     152                 :             : struct lto_simple_output_block *
     153                 :      111683 : lto_create_simple_output_block (enum lto_section_type section_type)
     154                 :             : {
     155                 :      111683 :   struct lto_simple_output_block *ob
     156                 :             :     = ((struct lto_simple_output_block *)
     157                 :      111683 :        xcalloc (1, sizeof (struct lto_simple_output_block)));
     158                 :             : 
     159                 :      111683 :   ob->section_type = section_type;
     160                 :      111683 :   ob->decl_state = lto_get_out_decl_state ();
     161                 :      223366 :   ob->main_stream = ((struct lto_output_stream *)
     162                 :      111683 :                      xcalloc (1, sizeof (struct lto_output_stream)));
     163                 :             : 
     164                 :      111683 :   return ob;
     165                 :             : }
     166                 :             : 
     167                 :             : 
     168                 :             : /* Produce a simple section for one of the ipa passes.  */
     169                 :             : 
     170                 :             : void
     171                 :      111683 : lto_destroy_simple_output_block (struct lto_simple_output_block *ob)
     172                 :             : {
     173                 :      111683 :   char *section_name;
     174                 :      111683 :   struct lto_simple_header header;
     175                 :             : 
     176                 :      111683 :   section_name = lto_get_section_name (ob->section_type, NULL, 0, NULL);
     177                 :      111683 :   lto_begin_section (section_name, !flag_wpa);
     178                 :      111683 :   free (section_name);
     179                 :             : 
     180                 :             :   /* Write the header which says how to decode the pieces of the
     181                 :             :      t.  */
     182                 :      111683 :   memset (&header, 0, sizeof (struct lto_simple_header));
     183                 :      111683 :   header.main_size = ob->main_stream->total_size;
     184                 :      111683 :   lto_write_data (&header, sizeof header);
     185                 :             : 
     186                 :      111683 :   lto_write_stream (ob->main_stream);
     187                 :             : 
     188                 :             :   /* Put back the assembly section that was there before we started
     189                 :             :      writing lto info.  */
     190                 :      111683 :   lto_end_section ();
     191                 :             : 
     192                 :      111683 :   free (ob->main_stream);
     193                 :      111683 :   free (ob);
     194                 :      111683 : }
     195                 :             : 
     196                 :             : 
     197                 :             : /* Return a new lto_out_decl_state. */
     198                 :             : 
     199                 :             : struct lto_out_decl_state *
     200                 :      181670 : lto_new_out_decl_state (void)
     201                 :             : {
     202                 :      181670 :   struct lto_out_decl_state *state = XCNEW (struct lto_out_decl_state);
     203                 :      181670 :   int i;
     204                 :             : 
     205                 :      545010 :   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
     206                 :      181670 :     lto_init_tree_ref_encoder (&state->streams[i]);
     207                 :             : 
     208                 :             :   /* At WPA time we do not compress sections by default.  */
     209                 :      181670 :   state->compressed = !flag_wpa;
     210                 :             : 
     211                 :      181670 :   return state;
     212                 :             : }
     213                 :             : 
     214                 :             : 
     215                 :             : /* Delete STATE and components.  */
     216                 :             : 
     217                 :             : void
     218                 :      181670 : lto_delete_out_decl_state (struct lto_out_decl_state *state)
     219                 :             : {
     220                 :      181670 :   int i;
     221                 :             : 
     222                 :      363340 :   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
     223                 :      181670 :     lto_destroy_tree_ref_encoder (&state->streams[i]);
     224                 :             : 
     225                 :      181670 :   free (state);
     226                 :      181670 : }
     227                 :             : 
     228                 :             : 
     229                 :             : /* Get the currently used lto_out_decl_state structure. */
     230                 :             : 
     231                 :             : struct lto_out_decl_state *
     232                 :      726975 : lto_get_out_decl_state (void)
     233                 :             : {
     234                 :      726975 :   return decl_state_stack.last ();
     235                 :             : }
     236                 :             : 
     237                 :             : /* Push STATE to top of out decl stack. */
     238                 :             : 
     239                 :             : void
     240                 :      181670 : lto_push_out_decl_state (struct lto_out_decl_state *state)
     241                 :             : {
     242                 :      181670 :   decl_state_stack.safe_push (state);
     243                 :      181670 : }
     244                 :             : 
     245                 :             : /* Pop the currently used out-decl state from top of stack. */
     246                 :             : 
     247                 :             : struct lto_out_decl_state *
     248                 :      181670 : lto_pop_out_decl_state (void)
     249                 :             : {
     250                 :      181670 :   return decl_state_stack.pop ();
     251                 :             : }
     252                 :             : 
     253                 :             : /* Record STATE after it has been used in serializing the body of
     254                 :             :    FN_DECL.  STATE should no longer be used by the caller.  The ownership
     255                 :             :    of it is taken over from this point.  */
     256                 :             : 
     257                 :             : void
     258                 :      148879 : lto_record_function_out_decl_state (tree fn_decl,
     259                 :             :                                     struct lto_out_decl_state *state)
     260                 :             : {
     261                 :      148879 :   int i;
     262                 :             : 
     263                 :             :   /* Strip all hash tables to save some memory. */
     264                 :      446637 :   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
     265                 :      148879 :     if (state->streams[i].tree_hash_table)
     266                 :             :       {
     267                 :      148879 :         delete state->streams[i].tree_hash_table;
     268                 :      148879 :         state->streams[i].tree_hash_table = NULL;
     269                 :             :       }
     270                 :      148879 :   state->fn_decl = fn_decl;
     271                 :      148879 :   lto_function_decl_states.safe_push (state);
     272                 :      148879 : }
        

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.