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

           Branch data     Line data    Source code
       1                 :            : /* Classes for representing locations within the program.
       2                 :            :    Copyright (C) 2019-2020 Free Software Foundation, Inc.
       3                 :            :    Contributed by David Malcolm <dmalcolm@redhat.com>.
       4                 :            : 
       5                 :            : This file is part of GCC.
       6                 :            : 
       7                 :            : GCC is free software; you can redistribute it and/or modify it
       8                 :            : under the terms of the GNU General Public License as published by
       9                 :            : the Free Software Foundation; either version 3, or (at your option)
      10                 :            : any later version.
      11                 :            : 
      12                 :            : GCC is distributed in the hope that it will be useful, but
      13                 :            : WITHOUT ANY WARRANTY; without even the implied warranty of
      14                 :            : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15                 :            : General Public License for more details.
      16                 :            : 
      17                 :            : You should have received a copy of the GNU General Public License
      18                 :            : along with GCC; see the file COPYING3.  If not see
      19                 :            : <http://www.gnu.org/licenses/>.  */
      20                 :            : 
      21                 :            : #ifndef GCC_ANALYZER_PROGRAM_POINT_H
      22                 :            : #define GCC_ANALYZER_PROGRAM_POINT_H
      23                 :            : 
      24                 :            : namespace ana {
      25                 :            : 
      26                 :            : class exploded_graph;
      27                 :            : 
      28                 :            : /* An enum for distinguishing the various kinds of program_point.  */
      29                 :            : 
      30                 :            : enum point_kind {
      31                 :            :   /* A "fake" node which has edges to all entrypoints.  */
      32                 :            :   PK_ORIGIN,
      33                 :            : 
      34                 :            :   PK_BEFORE_SUPERNODE,
      35                 :            :   PK_BEFORE_STMT,
      36                 :            :   PK_AFTER_SUPERNODE,
      37                 :            : 
      38                 :            :   /* Special values used for hash_map:  */
      39                 :            :   PK_EMPTY,
      40                 :            :   PK_DELETED,
      41                 :            : 
      42                 :            :   NUM_POINT_KINDS
      43                 :            : };
      44                 :            : 
      45                 :            : extern const char *point_kind_to_string (enum point_kind pk);
      46                 :            : 
      47                 :            : class format
      48                 :            : {
      49                 :            : public:
      50                 :         77 :   format (bool newlines) : m_newlines (newlines) {}
      51                 :            : 
      52                 :        128 :   void spacer (pretty_printer *pp) const
      53                 :            :   {
      54                 :        128 :     if (m_newlines)
      55                 :        128 :       pp_newline (pp);
      56                 :            :     else
      57                 :          0 :       pp_space (pp);
      58                 :            :   }
      59                 :            : 
      60                 :            :   bool m_newlines;
      61                 :            : };
      62                 :            : 
      63                 :            : /* A class for representing a location within the program, without
      64                 :            :    interprocedural information.
      65                 :            : 
      66                 :            :    This represents a fine-grained location within the supergraph (or
      67                 :            :    within one of its nodes).  */
      68                 :            : 
      69                 :            : class function_point
      70                 :            : {
      71                 :            : public:
      72                 :     167234 :   function_point (const supernode *supernode,
      73                 :            :                   const superedge *from_edge,
      74                 :            :                   unsigned stmt_idx,
      75                 :            :                   enum point_kind kind)
      76                 :      46312 :   : m_supernode (supernode), m_from_edge (from_edge),
      77                 :      46312 :     m_stmt_idx (stmt_idx), m_kind (kind)
      78                 :            :   {
      79                 :      19537 :     if (from_edge)
      80                 :            :       {
      81                 :      15165 :         gcc_checking_assert (m_kind == PK_BEFORE_SUPERNODE);
      82                 :      15165 :         gcc_checking_assert (from_edge->get_kind () == SUPEREDGE_CFG_EDGE);
      83                 :            :       }
      84                 :      19916 :     if (stmt_idx)
      85                 :          0 :       gcc_checking_assert (m_kind == PK_BEFORE_STMT);
      86                 :      19537 :   }
      87                 :            : 
      88                 :            :   void print (pretty_printer *pp, const format &f) const;
      89                 :            :   void print_source_line (pretty_printer *pp) const;
      90                 :            :   void dump () const;
      91                 :            : 
      92                 :            :   hashval_t hash () const;
      93                 :    1144815 :   bool operator== (const function_point &other) const
      94                 :            :   {
      95                 :    1144815 :     return (m_supernode == other.m_supernode
      96                 :     386271 :             && m_from_edge == other.m_from_edge
      97                 :            :             && m_stmt_idx == other.m_stmt_idx
      98                 :     755336 :             && m_kind == other.m_kind);
      99                 :            :   }
     100                 :            : 
     101                 :            :   /* Accessors.  */
     102                 :            : 
     103                 :     261289 :   const supernode *get_supernode () const { return m_supernode; }
     104                 :     472276 :   function *get_function () const
     105                 :            :   {
     106                 :     458152 :     if (m_supernode)
     107                 :     372570 :       return m_supernode->m_fun;
     108                 :            :     else
     109                 :            :       return NULL;
     110                 :            :   }
     111                 :            :   const gimple *get_stmt () const;
     112                 :            :   location_t get_location () const;
     113                 :    1439797 :   enum point_kind get_kind () const { return m_kind; }
     114                 :      82435 :   const superedge *get_from_edge () const
     115                 :            :   {
     116                 :      67228 :     return m_from_edge;
     117                 :            :   }
     118                 :      47960 :   unsigned get_stmt_idx () const
     119                 :            :   {
     120                 :      14202 :     gcc_assert (m_kind == PK_BEFORE_STMT);
     121                 :      30205 :     return m_stmt_idx;
     122                 :            :   }
     123                 :            : 
     124                 :            :   /* Factory functions for making various kinds of program_point.  */
     125                 :            : 
     126                 :        917 :   static function_point from_function_entry (const supergraph &sg,
     127                 :            :                                             function *fun)
     128                 :            :   {
     129                 :        917 :     return before_supernode (sg.get_node_for_function_entry (fun),
     130                 :        917 :                              NULL);
     131                 :            :   }
     132                 :            : 
     133                 :      19537 :   static function_point before_supernode (const supernode *supernode,
     134                 :            :                                           const superedge *from_edge)
     135                 :            :   {
     136                 :      17825 :     if (from_edge && from_edge->get_kind () != SUPEREDGE_CFG_EDGE)
     137                 :            :       from_edge = NULL;
     138                 :      19537 :     return function_point (supernode, from_edge, 0, PK_BEFORE_SUPERNODE);
     139                 :            :   }
     140                 :            : 
     141                 :      28234 :   static function_point before_stmt (const supernode *supernode,
     142                 :            :                                      unsigned stmt_idx)
     143                 :            :   {
     144                 :      22931 :     return function_point (supernode, NULL, stmt_idx, PK_BEFORE_STMT);
     145                 :            :   }
     146                 :            : 
     147                 :      15621 :   static function_point after_supernode (const supernode *supernode)
     148                 :            :   {
     149                 :      15621 :     return function_point (supernode, NULL, 0, PK_AFTER_SUPERNODE);
     150                 :            :   }
     151                 :            : 
     152                 :            :   /* Support for hash_map.  */
     153                 :            : 
     154                 :     103463 :   static function_point empty ()
     155                 :            :   {
     156                 :     103463 :     return function_point (NULL, NULL, 0, PK_EMPTY);
     157                 :            :   }
     158                 :            :   static function_point deleted ()
     159                 :            :   {
     160                 :            :     return function_point (NULL, NULL, 0, PK_DELETED);
     161                 :            :   }
     162                 :            : 
     163                 :            :   static int cmp_within_supernode_1 (const function_point &point_a,
     164                 :            :                                      const function_point &point_b);
     165                 :            :   static int cmp_within_supernode (const function_point &point_a,
     166                 :            :                                    const function_point &point_b);
     167                 :            : 
     168                 :            :  private:
     169                 :            :   const supernode *m_supernode;
     170                 :            : 
     171                 :            :   /* For PK_BEFORE_SUPERNODE, and only for CFG edges.  */
     172                 :            :   const superedge *m_from_edge;
     173                 :            : 
     174                 :            :   /* Only for PK_BEFORE_STMT.  */
     175                 :            :   unsigned m_stmt_idx;
     176                 :            : 
     177                 :            :   enum point_kind m_kind;
     178                 :            : };
     179                 :            : 
     180                 :            : /* A class for representing a location within the program, including
     181                 :            :    interprocedural information.
     182                 :            : 
     183                 :            :    This represents a fine-grained location within the supergraph (or
     184                 :            :    within one of its nodes), along with a call string giving the
     185                 :            :    interprocedural context.  */
     186                 :            : 
     187                 :      84088 : class program_point
     188                 :            : {
     189                 :            : public:
     190                 :      29828 :   program_point (const function_point &fn_point,
     191                 :            :                  const call_string &call_string)
     192                 :        377 :   : m_function_point (fn_point),
     193                 :        388 :     m_call_string (call_string)
     194                 :            :   {
     195                 :            :   }
     196                 :            : 
     197                 :            :   void print (pretty_printer *pp, const format &f) const;
     198                 :            :   void print_source_line (pretty_printer *pp) const;
     199                 :            :   void dump () const;
     200                 :            : 
     201                 :            :   hashval_t hash () const;
     202                 :     732382 :   bool operator== (const program_point &other) const
     203                 :            :   {
     204                 :     732382 :     return (m_function_point == other.m_function_point
     205                 :     213660 :             && m_call_string == other.m_call_string);
     206                 :            :   }
     207                 :            : 
     208                 :            :   /* Accessors.  */
     209                 :            : 
     210                 :     113044 :   const function_point &get_function_point () const { return m_function_point; }
     211                 :     154059 :   const call_string &get_call_string () const { return m_call_string; }
     212                 :            : 
     213                 :     174910 :   const supernode *get_supernode () const
     214                 :            :   {
     215                 :     157131 :     return m_function_point.get_supernode ();
     216                 :            :   }
     217                 :     383676 :   function *get_function () const
     218                 :            :   {
     219                 :     360570 :     return m_function_point.get_function ();
     220                 :            :   }
     221                 :            :   function *get_function_at_depth (unsigned depth) const;
     222                 :       3971 :   tree get_fndecl () const
     223                 :            :   {
     224                 :          0 :     gcc_assert (get_kind () != PK_ORIGIN);
     225                 :       3971 :     return get_function ()->decl;
     226                 :            :   }
     227                 :      54562 :   const gimple *get_stmt () const
     228                 :            :   {
     229                 :      54562 :     return m_function_point.get_stmt ();
     230                 :            :   }
     231                 :        243 :   location_t get_location () const
     232                 :            :   {
     233                 :        243 :     return m_function_point.get_location ();
     234                 :            :   }
     235                 :     312370 :   enum point_kind get_kind () const
     236                 :            :   {
     237                 :     113524 :     return m_function_point.get_kind ();
     238                 :            :   }
     239                 :      27537 :   const superedge *get_from_edge () const
     240                 :            :   {
     241                 :      25470 :     return m_function_point.get_from_edge ();
     242                 :            :   }
     243                 :      23306 :   unsigned get_stmt_idx () const
     244                 :            :   {
     245                 :      23306 :     return m_function_point.get_stmt_idx ();
     246                 :            :   }
     247                 :            : 
     248                 :            :   /* Get the number of frames we expect at this program point.
     249                 :            :      This will be one more than the length of the call_string
     250                 :            :      (which stores the parent callsites), apart from the origin
     251                 :            :      node, which doesn't have any frames.  */
     252                 :     197146 :   int get_stack_depth () const
     253                 :            :   {
     254                 :     197128 :     if (get_kind () == PK_ORIGIN)
     255                 :            :       return 0;
     256                 :     262331 :     return m_call_string.length () + 1;
     257                 :            :   }
     258                 :            : 
     259                 :            :   /* Factory functions for making various kinds of program_point.  */
     260                 :            : 
     261                 :        917 :   static program_point from_function_entry (const supergraph &sg,
     262                 :            :                                             function *fun)
     263                 :            :   {
     264                 :        917 :     return program_point (function_point::from_function_entry (sg, fun),
     265                 :       1834 :                           call_string ());
     266                 :            :   }
     267                 :            : 
     268                 :      11452 :   static program_point before_supernode (const supernode *supernode,
     269                 :            :                                          const superedge *from_edge,
     270                 :            :                                          const call_string &call_string)
     271                 :            :   {
     272                 :      11452 :     return program_point (function_point::before_supernode (supernode,
     273                 :      11452 :                                                             from_edge),
     274                 :      11452 :                           call_string);
     275                 :            :   }
     276                 :            : 
     277                 :       8082 :   static program_point before_stmt (const supernode *supernode,
     278                 :            :                                     unsigned stmt_idx,
     279                 :            :                                     const call_string &call_string)
     280                 :            :   {
     281                 :       6735 :     return program_point (function_point::before_stmt (supernode, stmt_idx),
     282                 :       8082 :                           call_string);
     283                 :            :   }
     284                 :            : 
     285                 :       9000 :   static program_point after_supernode (const supernode *supernode,
     286                 :            :                                         const call_string &call_string)
     287                 :            :   {
     288                 :       3059 :     return program_point (function_point::after_supernode (supernode),
     289                 :       9000 :                           call_string);
     290                 :            :   }
     291                 :            : 
     292                 :            :   /* Support for hash_map.  */
     293                 :            : 
     294                 :            :   static program_point empty ()
     295                 :            :   {
     296                 :            :     return program_point (function_point::empty (), call_string ());
     297                 :            :   }
     298                 :            :   static program_point deleted ()
     299                 :            :   {
     300                 :            :     return program_point (function_point::deleted (), call_string ());
     301                 :            :   }
     302                 :            : 
     303                 :            :   bool on_edge (exploded_graph &eg, const superedge *succ);
     304                 :            : 
     305                 :            :   void validate () const;
     306                 :            : 
     307                 :            :  private:
     308                 :            :   const function_point m_function_point;
     309                 :            :   call_string m_call_string;
     310                 :            : };
     311                 :            : 
     312                 :            : } // namespace ana
     313                 :            : 
     314                 :            : #endif /* GCC_ANALYZER_PROGRAM_POINT_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.