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

           Branch data     Line data    Source code
       1                 :            : /* Data structures and functions for streaming trees.
       2                 :            : 
       3                 :            :    Copyright (C) 2011-2020 Free Software Foundation, Inc.
       4                 :            :    Contributed by Diego Novillo <dnovillo@google.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                 :            : #ifndef GCC_TREE_STREAMER_H
      23                 :            : #define GCC_TREE_STREAMER_H
      24                 :            : 
      25                 :            : #include "streamer-hooks.h"
      26                 :            : #include "data-streamer.h"
      27                 :            : 
      28                 :            : /* Cache of pickled nodes.  Used to avoid writing the same node more
      29                 :            :    than once.  The first time a tree node is streamed out, it is
      30                 :            :    entered in this cache.  Subsequent references to the same node are
      31                 :            :    resolved by looking it up in this cache.
      32                 :            : 
      33                 :            :    This is used in two ways:
      34                 :            : 
      35                 :            :    - On the writing side, the first time T is added to STREAMER_CACHE,
      36                 :            :      a new reference index is created for T and T is emitted on the
      37                 :            :      stream.  If T needs to be emitted again to the stream, instead of
      38                 :            :      pickling it again, the reference index is emitted.
      39                 :            : 
      40                 :            :    - On the reading side, the first time T is read from the stream, it
      41                 :            :      is reconstructed in memory and a new reference index created for
      42                 :            :      T.  The reconstructed T is inserted in some array so that when
      43                 :            :      the reference index for T is found in the input stream, it can be
      44                 :            :      used to look up into the array to get the reconstructed T.  */
      45                 :            : 
      46                 :            : struct streamer_tree_cache_d
      47                 :            : {
      48                 :            :   /* The mapping between tree nodes and slots into the nodes array.  */
      49                 :            :   hash_map<tree, unsigned> *node_map;
      50                 :            : 
      51                 :            :   /* The nodes pickled so far.  */
      52                 :            :   vec<tree> nodes;
      53                 :            :   /* The node hashes (if available).  */
      54                 :            :   vec<hashval_t> hashes;
      55                 :            : 
      56                 :            :   /* Next index to assign.  */
      57                 :            :   unsigned next_idx;
      58                 :            : };
      59                 :            : 
      60                 :            : /* In tree-streamer-in.c.  */
      61                 :            : tree streamer_read_string_cst (class data_in *, class lto_input_block *);
      62                 :            : tree streamer_read_chain (class lto_input_block *, class data_in *);
      63                 :            : tree streamer_alloc_tree (class lto_input_block *, class data_in *,
      64                 :            :                           enum LTO_tags);
      65                 :            : void streamer_read_tree_body (class lto_input_block *, class data_in *, tree);
      66                 :            : tree streamer_get_pickled_tree (class lto_input_block *, class data_in *);
      67                 :            : void streamer_read_tree_bitfields (class lto_input_block *,
      68                 :            :                                    class data_in *, tree);
      69                 :            : 
      70                 :            : /* In tree-streamer-out.c.  */
      71                 :            : void streamer_write_string_cst (struct output_block *,
      72                 :            :                                 struct lto_output_stream *, tree);
      73                 :            : void streamer_write_chain (struct output_block *, tree, bool);
      74                 :            : void streamer_write_tree_header (struct output_block *, tree);
      75                 :            : void streamer_write_tree_bitfields (struct output_block *, tree);
      76                 :            : void streamer_write_tree_body (struct output_block *, tree, bool);
      77                 :            : void streamer_write_integer_cst (struct output_block *, tree, bool);
      78                 :            : 
      79                 :            : /* In tree-streamer.c.  */
      80                 :            : extern unsigned char streamer_mode_table[1 << 8];
      81                 :            : void streamer_check_handled_ts_structures (void);
      82                 :            : bool streamer_tree_cache_insert (struct streamer_tree_cache_d *, tree,
      83                 :            :                                  hashval_t, unsigned *);
      84                 :            : void streamer_tree_cache_replace_tree (struct streamer_tree_cache_d *, tree,
      85                 :            :                                        unsigned);
      86                 :            : void streamer_tree_cache_append (struct streamer_tree_cache_d *, tree,
      87                 :            :                                  hashval_t);
      88                 :            : bool streamer_tree_cache_lookup (struct streamer_tree_cache_d *, tree,
      89                 :            :                                  unsigned *);
      90                 :            : struct streamer_tree_cache_d *streamer_tree_cache_create (bool, bool, bool);
      91                 :            : void streamer_tree_cache_delete (struct streamer_tree_cache_d *);
      92                 :            : 
      93                 :            : /* Return the tree node at slot IX in CACHE.  */
      94                 :            : 
      95                 :            : static inline tree
      96                 :   15591120 : streamer_tree_cache_get_tree (struct streamer_tree_cache_d *cache, unsigned ix)
      97                 :            : {
      98                 :   15591120 :   return cache->nodes[ix];
      99                 :            : }
     100                 :            : 
     101                 :            : /* Return the tree hash value at slot IX in CACHE.  */
     102                 :            : 
     103                 :            : static inline hashval_t
     104                 :    9247150 : streamer_tree_cache_get_hash (struct streamer_tree_cache_d *cache, unsigned ix)
     105                 :            : {
     106                 :    9247150 :   return cache->hashes[ix];
     107                 :            : }
     108                 :            : 
     109                 :            : static inline void
     110                 :    1810330 : bp_pack_machine_mode (struct bitpack_d *bp, machine_mode mode)
     111                 :            : {
     112                 :    1810330 :   streamer_mode_table[mode] = 1;
     113                 :    1810330 :   bp_pack_enum (bp, machine_mode, 1 << 8, mode);
     114                 :            : }
     115                 :            : 
     116                 :            : static inline machine_mode
     117                 :     924293 : bp_unpack_machine_mode (struct bitpack_d *bp)
     118                 :            : {
     119                 :     924293 :   return (machine_mode)
     120                 :            :            ((class lto_input_block *)
     121                 :     924293 :             bp->stream)->mode_table[bp_unpack_enum (bp, machine_mode, 1 << 8)];
     122                 :            : }
     123                 :            : 
     124                 :            : #endif  /* GCC_TREE_STREAMER_H  */

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.