LCOV - code coverage report
Current view: top level - gcc - lto-streamer.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 38.5 % 109 42
Test Date: 2025-02-01 13:18:56 Functions: 57.1 % 7 4
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : /* Miscellaneous utilities for GIMPLE streaming.  Things that are used
       2                 :             :    in both input and output are here.
       3                 :             : 
       4                 :             :    Copyright (C) 2009-2025 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                 :             : #include "config.h"
      24                 :             : #include "system.h"
      25                 :             : #include "coretypes.h"
      26                 :             : #include "backend.h"
      27                 :             : #include "tree.h"
      28                 :             : #include "gimple.h"
      29                 :             : #include "tree-streamer.h"
      30                 :             : #include "cgraph.h"
      31                 :             : #include "lto-streamer.h"
      32                 :             : #include "toplev.h"
      33                 :             : #include "lto-section-names.h"
      34                 :             : 
      35                 :             : /* Statistics gathered during LTO, WPA and LTRANS.  */
      36                 :             : struct lto_stats_d lto_stats;
      37                 :             : 
      38                 :             : const char *section_name_prefix = LTO_SECTION_NAME_PREFIX;
      39                 :             : /* Set when streaming LTO for offloading compiler.  */
      40                 :             : bool lto_stream_offload_p;
      41                 :             : 
      42                 :             : FILE *streamer_dump_file;
      43                 :             : 
      44                 :             : /* Return a string representing LTO tag TAG.  */
      45                 :             : 
      46                 :             : const char *
      47                 :           0 : lto_tag_name (enum LTO_tags tag)
      48                 :             : {
      49                 :           0 :   if (lto_tag_is_tree_code_p (tag))
      50                 :             :     {
      51                 :             :       /* For tags representing tree nodes, return the name of the
      52                 :             :          associated tree code.  */
      53                 :           0 :       return get_tree_code_name (lto_tag_to_tree_code (tag));
      54                 :             :     }
      55                 :             : 
      56                 :           0 :   if (lto_tag_is_gimple_code_p (tag))
      57                 :             :     {
      58                 :             :       /* For tags representing gimple statements, return the name of
      59                 :             :          the associated gimple code.  */
      60                 :           0 :       return gimple_code_name[lto_tag_to_gimple_code (tag)];
      61                 :             :     }
      62                 :             : 
      63                 :           0 :   switch (tag)
      64                 :             :     {
      65                 :             :     case LTO_null:
      66                 :             :       return "LTO_null";
      67                 :           0 :     case LTO_bb0:
      68                 :           0 :       return "LTO_bb0";
      69                 :           0 :     case LTO_bb1:
      70                 :           0 :       return "LTO_bb1";
      71                 :           0 :     case LTO_eh_region:
      72                 :           0 :       return "LTO_eh_region";
      73                 :           0 :     case LTO_function:
      74                 :           0 :       return "LTO_function";
      75                 :           0 :     case LTO_eh_table:
      76                 :           0 :       return "LTO_eh_table";
      77                 :           0 :     case LTO_ert_cleanup:
      78                 :           0 :       return "LTO_ert_cleanup";
      79                 :           0 :     case LTO_ert_try:
      80                 :           0 :       return "LTO_ert_try";
      81                 :           0 :     case LTO_ert_allowed_exceptions:
      82                 :           0 :       return "LTO_ert_allowed_exceptions";
      83                 :           0 :     case LTO_ert_must_not_throw:
      84                 :           0 :       return "LTO_ert_must_not_throw";
      85                 :           0 :     case LTO_tree_pickle_reference:
      86                 :           0 :       return "LTO_tree_pickle_reference";
      87                 :           0 :     case LTO_global_stream_ref:
      88                 :           0 :       return "LTO_global_sream_ref";
      89                 :           0 :     case LTO_ssa_name_ref:
      90                 :           0 :       return "LTO_ssa_name_ref";
      91                 :           0 :     default:
      92                 :           0 :       return "LTO_UNKNOWN";
      93                 :             :     }
      94                 :             : }
      95                 :             : 
      96                 :             : 
      97                 :             : /* Get a section name for a particular type or name.  The NAME field
      98                 :             :    is only used if SECTION_TYPE is LTO_section_function_body. For all
      99                 :             :    others it is ignored.  The callee of this function is responsible
     100                 :             :    to free the returned name.  */
     101                 :             : 
     102                 :             : char *
     103                 :      948488 : lto_get_section_name (int section_type, const char *name,
     104                 :             :                       int node_order, struct lto_file_decl_data *f)
     105                 :             : {
     106                 :      948488 :   const char *add;
     107                 :      948488 :   char post[32];
     108                 :      948488 :   const char *sep;
     109                 :      948488 :   char *buffer = NULL;
     110                 :             : 
     111                 :      948488 :   if (section_type == LTO_section_function_body)
     112                 :             :     {
     113                 :      275223 :       gcc_assert (name != NULL);
     114                 :      275223 :       if (name[0] == '*')
     115                 :        8614 :         name++;
     116                 :             : 
     117                 :      275223 :       buffer = (char *)xmalloc (strlen (name) + 32);
     118                 :      275223 :       sprintf (buffer, "%s.%d", name, node_order);
     119                 :             : 
     120                 :      275223 :       add = buffer;
     121                 :      275223 :       sep = "";
     122                 :             :     }
     123                 :      673265 :   else if (section_type < LTO_N_SECTION_TYPES)
     124                 :             :     {
     125                 :      673265 :       add = lto_section_name[section_type];
     126                 :      673265 :       sep = ".";
     127                 :             :     }
     128                 :             :   else
     129                 :           0 :     internal_error ("bytecode stream: unexpected LTO section %s", name);
     130                 :             : 
     131                 :             :   /* Make the section name unique so that ld -r combining sections
     132                 :             :      doesn't confuse the reader with merged sections.
     133                 :             : 
     134                 :             :      For options don't add a ID, the option reader cannot deal with them
     135                 :             :      and merging should be ok here.
     136                 :             : 
     137                 :             :      LTRANS files (output of wpa, input and output of ltrans) are handled
     138                 :             :      directly inside of linker/lto-wrapper, so name uniqueness for external
     139                 :             :      tools is not needed.
     140                 :             :      Randomness would inhibit incremental LTO.  */
     141                 :      948488 :   if (section_type == LTO_section_opts || flag_ltrans)
     142                 :      161511 :     strcpy (post, "");
     143                 :      786977 :   else if (f != NULL)
     144                 :      275206 :     sprintf (post, "." HOST_WIDE_INT_PRINT_HEX_PURE, f->id);
     145                 :      511771 :   else if (flag_wpa)
     146                 :      111043 :     strcpy (post, "");
     147                 :             :   else
     148                 :      400728 :     sprintf (post, "." HOST_WIDE_INT_PRINT_HEX_PURE, get_random_seed (false));
     149                 :      948488 :   char *res = concat (section_name_prefix, sep, add, post, NULL);
     150                 :      948488 :   if (buffer)
     151                 :      275223 :     free (buffer);
     152                 :      948488 :   return res;
     153                 :             : }
     154                 :             : 
     155                 :             : 
     156                 :             : /* Show various memory usage statistics related to LTO.  */
     157                 :             : 
     158                 :             : void
     159                 :           0 : print_lto_report (const char *s)
     160                 :             : {
     161                 :           0 :   unsigned i;
     162                 :             : 
     163                 :           0 :   fprintf (stderr, "[%s] # of input files: "
     164                 :             :            HOST_WIDE_INT_PRINT_UNSIGNED "\n", s, lto_stats.num_input_files);
     165                 :             : 
     166                 :           0 :   fprintf (stderr, "[%s] # of input cgraph nodes: "
     167                 :             :            HOST_WIDE_INT_PRINT_UNSIGNED "\n", s,
     168                 :             :            lto_stats.num_input_cgraph_nodes);
     169                 :             : 
     170                 :           0 :   fprintf (stderr, "[%s] # of function bodies: "
     171                 :             :            HOST_WIDE_INT_PRINT_UNSIGNED "\n", s,
     172                 :             :            lto_stats.num_function_bodies);
     173                 :             : 
     174                 :           0 :   for (i = 0; i < NUM_TREE_CODES; i++)
     175                 :           0 :     if (lto_stats.num_trees[i])
     176                 :           0 :       fprintf (stderr, "[%s] # of '%s' objects read: "
     177                 :             :                HOST_WIDE_INT_PRINT_UNSIGNED "\n", s,
     178                 :             :                get_tree_code_name ((enum tree_code) i), lto_stats.num_trees[i]);
     179                 :             : 
     180                 :           0 :   if (flag_lto)
     181                 :             :     {
     182                 :           0 :       fprintf (stderr, "[%s] Compression: "
     183                 :             :                HOST_WIDE_INT_PRINT_UNSIGNED " output bytes, "
     184                 :             :                HOST_WIDE_INT_PRINT_UNSIGNED " compressed bytes", s,
     185                 :             :                lto_stats.num_output_il_bytes,
     186                 :             :                lto_stats.num_compressed_il_bytes);
     187                 :           0 :       if (lto_stats.num_output_il_bytes > 0)
     188                 :             :         {
     189                 :           0 :           const float dividend = (float) lto_stats.num_compressed_il_bytes;
     190                 :           0 :           const float divisor = (float) lto_stats.num_output_il_bytes;
     191                 :           0 :           fprintf (stderr, " (ratio: %f)", dividend / divisor);
     192                 :             :         }
     193                 :           0 :       fprintf (stderr, "\n");
     194                 :             :     }
     195                 :             : 
     196                 :           0 :   if (flag_wpa)
     197                 :             :     {
     198                 :           0 :       fprintf (stderr, "[%s] # of output files: "
     199                 :             :                HOST_WIDE_INT_PRINT_UNSIGNED "\n", s,
     200                 :             :                lto_stats.num_output_files);
     201                 :             : 
     202                 :           0 :       fprintf (stderr, "[%s] # of output symtab nodes: "
     203                 :             :                HOST_WIDE_INT_PRINT_UNSIGNED "\n", s,
     204                 :             :                lto_stats.num_output_symtab_nodes);
     205                 :             : 
     206                 :           0 :       fprintf (stderr, "[%s] # of output tree pickle references: "
     207                 :             :                HOST_WIDE_INT_PRINT_UNSIGNED "\n", s,
     208                 :             :                lto_stats.num_pickle_refs_output);
     209                 :           0 :       fprintf (stderr, "[%s] # of output tree bodies: "
     210                 :             :                HOST_WIDE_INT_PRINT_UNSIGNED "\n", s,
     211                 :             :                lto_stats.num_tree_bodies_output);
     212                 :             : 
     213                 :           0 :       fprintf (stderr, "[%s] # callgraph partitions: "
     214                 :             :                HOST_WIDE_INT_PRINT_UNSIGNED "\n", s,
     215                 :             :                lto_stats.num_cgraph_partitions);
     216                 :             : 
     217                 :           0 :       fprintf (stderr, "[%s] Compression: "
     218                 :             :                HOST_WIDE_INT_PRINT_UNSIGNED " input bytes, "
     219                 :             :                HOST_WIDE_INT_PRINT_UNSIGNED " uncompressed bytes", s,
     220                 :             :                lto_stats.num_input_il_bytes,
     221                 :             :                lto_stats.num_uncompressed_il_bytes);
     222                 :           0 :       if (lto_stats.num_input_il_bytes > 0)
     223                 :             :         {
     224                 :           0 :           const float dividend = (float) lto_stats.num_uncompressed_il_bytes;
     225                 :           0 :           const float divisor = (float) lto_stats.num_input_il_bytes;
     226                 :           0 :           fprintf (stderr, " (ratio: %f)", dividend / divisor);
     227                 :             :         }
     228                 :           0 :       fprintf (stderr, "\n");
     229                 :             :     }
     230                 :             : 
     231                 :           0 :   for (i = 0; i < LTO_N_SECTION_TYPES; i++)
     232                 :           0 :     fprintf (stderr, "[%s] Size of mmap'd section %s: "
     233                 :             :              HOST_WIDE_INT_PRINT_UNSIGNED " bytes\n", s,
     234                 :             :              lto_section_name[i], lto_stats.section_size[i]);
     235                 :           0 : }
     236                 :             : 
     237                 :             : /* Initialization common to the LTO reader and writer.  */
     238                 :             : 
     239                 :             : void
     240                 :       54420 : lto_streamer_init (void)
     241                 :             : {
     242                 :             :   /* Check that all the TS_* handled by the reader and writer routines
     243                 :             :      match exactly the structures defined in treestruct.def.  When a
     244                 :             :      new TS_* astructure is added, the streamer should be updated to
     245                 :             :      handle it.  */
     246                 :       54420 :   if (flag_checking)
     247                 :       54414 :     streamer_check_handled_ts_structures ();
     248                 :       54420 : }
     249                 :             : 
     250                 :             : 
     251                 :             : /* Gate function for all LTO streaming passes.  */
     252                 :             : 
     253                 :             : bool
     254                 :           0 : gate_lto_out (void)
     255                 :             : {
     256                 :           0 :   return ((flag_generate_lto || flag_generate_offload || in_lto_p)
     257                 :             :           /* Don't bother doing anything if the program has errors.  */
     258                 :           0 :           && !seen_error ());
     259                 :             : }
     260                 :             : 
     261                 :             : /* Check that the version MAJOR.MINOR is the correct version number.  */
     262                 :             : 
     263                 :             : void
     264                 :       22791 : lto_check_version (int major, int minor, const char *file_name)
     265                 :             : {
     266                 :       22791 :   if (major != LTO_major_version || minor != LTO_minor_version)
     267                 :           0 :     fatal_error (input_location,
     268                 :             :                  "bytecode stream in file %qs generated with LTO version "
     269                 :             :                  "%d.%d instead of the expected %d.%d",
     270                 :             :                  file_name,
     271                 :             :                  major, minor,
     272                 :             :                  LTO_major_version, LTO_minor_version);
     273                 :       22791 : }
     274                 :             : 
     275                 :             : 
     276                 :             : /* Initialize all the streamer hooks used for streaming GIMPLE.  */
     277                 :             : 
     278                 :             : void
     279                 :       45475 : lto_streamer_hooks_init (void)
     280                 :             : {
     281                 :       45475 :   streamer_hooks_init ();
     282                 :       45475 :   streamer_hooks.write_tree = lto_output_tree;
     283                 :       45475 :   streamer_hooks.read_tree = lto_input_tree;
     284                 :       45475 :   streamer_hooks.input_location = lto_input_location;
     285                 :       45475 :   streamer_hooks.output_location = lto_output_location;
     286                 :       45475 :   streamer_hooks.output_location_and_block = lto_output_location_and_block;
     287                 :       45475 : }
        

Generated by: LCOV version 2.1-beta

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.