LCOV - code coverage report
Current view: top level - gcc - data-streamer-in.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 78 87 89.7 %
Date: 2020-03-28 11:57:23 Functions: 10 11 90.9 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Routines for restoring various data types from a file stream.  This deals
       2                 :            :    with various data types like strings, integers, enums, etc.
       3                 :            : 
       4                 :            :    Copyright (C) 2011-2020 Free Software Foundation, Inc.
       5                 :            :    Contributed by Diego Novillo <dnovillo@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 "cgraph.h"
      30                 :            : #include "data-streamer.h"
      31                 :            : 
      32                 :            : /* Read a string from the string table in DATA_IN using input block
      33                 :            :    IB.  Write the length to RLEN.  */
      34                 :            : 
      35                 :            : static const char *
      36                 :    1515360 : string_for_index (class data_in *data_in, unsigned int loc, unsigned int *rlen)
      37                 :            : {
      38                 :    1515360 :   unsigned int len;
      39                 :    1515360 :   const char *result;
      40                 :            : 
      41                 :    1515360 :   if (!loc)
      42                 :            :     {
      43                 :     641630 :       *rlen = 0;
      44                 :     641630 :       return NULL;
      45                 :            :     }
      46                 :            : 
      47                 :            :   /* Get the string stored at location LOC in DATA_IN->STRINGS.  */
      48                 :     873728 :   lto_input_block str_tab (data_in->strings, loc - 1, data_in->strings_len, NULL);
      49                 :     873728 :   len = streamer_read_uhwi (&str_tab);
      50                 :     873728 :   *rlen = len;
      51                 :            : 
      52                 :     873728 :   if (str_tab.p + len > data_in->strings_len)
      53                 :          0 :     internal_error ("bytecode stream: string too long for the string table");
      54                 :            : 
      55                 :     873728 :   result = (const char *)(data_in->strings + str_tab.p);
      56                 :            : 
      57                 :     873728 :   return result;
      58                 :            : }
      59                 :            : 
      60                 :            : 
      61                 :            : /* Read a string from the string table in DATA_IN using input block
      62                 :            :    IB.  Write the length to RLEN.  */
      63                 :            : 
      64                 :            : const char *
      65                 :    1215640 : streamer_read_indexed_string (class data_in *data_in,
      66                 :            :                               class lto_input_block *ib, unsigned int *rlen)
      67                 :            : {
      68                 :    1215640 :   return string_for_index (data_in, streamer_read_uhwi (ib), rlen);
      69                 :            : }
      70                 :            : 
      71                 :            : 
      72                 :            : /* Read a NULL terminated string from the string table in DATA_IN.  */
      73                 :            : 
      74                 :            : const char *
      75                 :     613747 : streamer_read_string (class data_in *data_in, class lto_input_block *ib)
      76                 :            : {
      77                 :     613747 :   unsigned int len;
      78                 :     613747 :   const char *ptr;
      79                 :            : 
      80                 :     613747 :   ptr = streamer_read_indexed_string (data_in, ib, &len);
      81                 :     613747 :   if (!ptr)
      82                 :            :     return NULL;
      83                 :      38013 :   if (ptr[len - 1] != '\0')
      84                 :          0 :     internal_error ("bytecode stream: found non-null terminated string");
      85                 :            : 
      86                 :            :   return ptr;
      87                 :            : }
      88                 :            : 
      89                 :            : 
      90                 :            : /* Read a string from the string table in DATA_IN using the bitpack BP.
      91                 :            :    Write the length to RLEN.  */
      92                 :            : 
      93                 :            : const char *
      94                 :     299715 : bp_unpack_indexed_string (class data_in *data_in,
      95                 :            :                           struct bitpack_d *bp, unsigned int *rlen)
      96                 :            : {
      97                 :     299715 :   return string_for_index (data_in, bp_unpack_var_len_unsigned (bp), rlen);
      98                 :            : }
      99                 :            : 
     100                 :            : 
     101                 :            : /* Read a NULL terminated string from the string table in DATA_IN.  */
     102                 :            : 
     103                 :            : const char *
     104                 :     299715 : bp_unpack_string (class data_in *data_in, struct bitpack_d *bp)
     105                 :            : {
     106                 :     299715 :   unsigned int len;
     107                 :     299715 :   const char *ptr;
     108                 :            : 
     109                 :     299715 :   ptr = bp_unpack_indexed_string (data_in, bp, &len);
     110                 :     299715 :   if (!ptr)
     111                 :            :     return NULL;
     112                 :     233839 :   if (ptr[len - 1] != '\0')
     113                 :          0 :     internal_error ("bytecode stream: found non-null terminated string");
     114                 :            : 
     115                 :            :   return ptr;
     116                 :            : }
     117                 :            : 
     118                 :            : 
     119                 :            : /* Read an unsigned HOST_WIDE_INT number from IB.  */
     120                 :            : 
     121                 :            : unsigned HOST_WIDE_INT
     122                 :   87971900 : streamer_read_uhwi (class lto_input_block *ib)
     123                 :            : {
     124                 :   87971900 :   unsigned HOST_WIDE_INT result;
     125                 :   87971900 :   int shift;
     126                 :   87971900 :   unsigned HOST_WIDE_INT byte;
     127                 :   87971900 :   unsigned int p = ib->p;
     128                 :   87971900 :   unsigned int len = ib->len;
     129                 :            : 
     130                 :   87971900 :   const char *data = ib->data;
     131                 :   87971900 :   result = data[p++];
     132                 :   87971900 :   if ((result & 0x80) != 0)
     133                 :            :     {
     134                 :   29784600 :       result &= 0x7f;
     135                 :   29784600 :       shift = 7;
     136                 :   52665700 :       do
     137                 :            :         {
     138                 :   52665700 :           byte = data[p++];
     139                 :   52665700 :           result |= (byte & 0x7f) << shift;
     140                 :   52665700 :           shift += 7;
     141                 :            :         }
     142                 :   52665700 :       while ((byte & 0x80) != 0);
     143                 :            :     }
     144                 :            : 
     145                 :            :   /* We check for section overrun after the fact for performance reason.  */
     146                 :   87971900 :   if (p > len)
     147                 :          0 :     lto_section_overrun (ib);
     148                 :            : 
     149                 :   87971900 :   ib->p = p;
     150                 :   87971900 :   return result;
     151                 :            : }
     152                 :            : 
     153                 :            : 
     154                 :            : /* Read a HOST_WIDE_INT number from IB.  */
     155                 :            : 
     156                 :            : HOST_WIDE_INT
     157                 :    7080110 : streamer_read_hwi (class lto_input_block *ib)
     158                 :            : {
     159                 :    7080110 :   HOST_WIDE_INT result = 0;
     160                 :    7080110 :   int shift = 0;
     161                 :   14278600 :   unsigned HOST_WIDE_INT byte;
     162                 :            : 
     163                 :   14278600 :   while (true)
     164                 :            :     {
     165                 :   14278600 :       byte = streamer_read_uchar (ib);
     166                 :   14278600 :       result |= (byte & 0x7f) << shift;
     167                 :   14278600 :       shift += 7;
     168                 :   14278600 :       if ((byte & 0x80) == 0)
     169                 :            :         {
     170                 :    7080110 :           if ((shift < HOST_BITS_PER_WIDE_INT) && (byte & 0x40))
     171                 :     828210 :             result |= - (HOST_WIDE_INT_1U << shift);
     172                 :            : 
     173                 :    7080110 :           return result;
     174                 :            :         }
     175                 :            :     }
     176                 :            : }
     177                 :            : 
     178                 :            : /* Read a poly_uint64 from IB.  */
     179                 :            : 
     180                 :            : poly_uint64
     181                 :          0 : streamer_read_poly_uint64 (class lto_input_block *ib)
     182                 :            : {
     183                 :          0 :   poly_uint64 res;
     184                 :          0 :   for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
     185                 :          0 :     res.coeffs[i] = streamer_read_uhwi (ib);
     186                 :          0 :   return res;
     187                 :            : }
     188                 :            : 
     189                 :            : /* Read gcov_type value from IB.  */
     190                 :            : 
     191                 :            : gcov_type
     192                 :     948424 : streamer_read_gcov_count (class lto_input_block *ib)
     193                 :            : {
     194                 :     948424 :   gcov_type ret = streamer_read_hwi (ib);
     195                 :     948424 :   return ret;
     196                 :            : }
     197                 :            : 
     198                 :            : /* Read the physical representation of a wide_int val from
     199                 :            :    input block IB.  */
     200                 :            : 
     201                 :            : wide_int
     202                 :      19898 : streamer_read_wide_int (class lto_input_block *ib)
     203                 :            : {
     204                 :      19898 :   HOST_WIDE_INT a[WIDE_INT_MAX_ELTS];
     205                 :      19898 :   int i;
     206                 :      19898 :   int prec = streamer_read_uhwi (ib);
     207                 :      19898 :   int len = streamer_read_uhwi (ib);
     208                 :      40377 :   for (i = 0; i < len; i++)
     209                 :      20479 :     a[i] = streamer_read_hwi (ib);
     210                 :      19898 :   return wide_int::from_array (a, len, prec);
     211                 :            : }
     212                 :            : 
     213                 :            : /* Read the physical representation of a widest_int val from
     214                 :            :    input block IB.  */
     215                 :            : 
     216                 :            : widest_int
     217                 :     345231 : streamer_read_widest_int (class lto_input_block *ib)
     218                 :            : {
     219                 :     345231 :   HOST_WIDE_INT a[WIDE_INT_MAX_ELTS];
     220                 :     345231 :   int i;
     221                 :     345231 :   int prec ATTRIBUTE_UNUSED = streamer_read_uhwi (ib);
     222                 :     345231 :   int len = streamer_read_uhwi (ib);
     223                 :     762701 :   for (i = 0; i < len; i++)
     224                 :     417470 :     a[i] = streamer_read_hwi (ib);
     225                 :     345231 :   return widest_int::from_array (a, len);
     226                 :            : }
     227                 :            : 

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.