LCOV - code coverage report
Current view: top level - gcc/analyzer - call-info.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 87.8 % 41 36
Test Date: 2024-12-21 13:15:12 Functions: 87.5 % 8 7
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : /* Subclasses of custom_edge_info for describing outcomes of function calls.
       2                 :             :    Copyright (C) 2021-2024 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                 :             : #include "config.h"
      22                 :             : #define INCLUDE_VECTOR
      23                 :             : #include "system.h"
      24                 :             : #include "coretypes.h"
      25                 :             : #include "tree.h"
      26                 :             : #include "function.h"
      27                 :             : #include "basic-block.h"
      28                 :             : #include "gimple.h"
      29                 :             : #include "gimple-iterator.h"
      30                 :             : #include "diagnostic-core.h"
      31                 :             : #include "options.h"
      32                 :             : #include "cgraph.h"
      33                 :             : #include "tree-pretty-print.h"
      34                 :             : #include "bitmap.h"
      35                 :             : #include "analyzer/analyzer.h"
      36                 :             : #include "analyzer/analyzer-logging.h"
      37                 :             : #include "ordered-hash-map.h"
      38                 :             : #include "cfg.h"
      39                 :             : #include "digraph.h"
      40                 :             : #include "analyzer/supergraph.h"
      41                 :             : #include "sbitmap.h"
      42                 :             : #include "analyzer/call-string.h"
      43                 :             : #include "analyzer/program-point.h"
      44                 :             : #include "analyzer/store.h"
      45                 :             : #include "analyzer/region-model.h"
      46                 :             : #include "analyzer/constraint-manager.h"
      47                 :             : #include "diagnostic-event-id.h"
      48                 :             : #include "analyzer/sm.h"
      49                 :             : #include "analyzer/pending-diagnostic.h"
      50                 :             : #include "analyzer/region-model-reachability.h"
      51                 :             : #include "analyzer/analyzer-selftests.h"
      52                 :             : #include "analyzer/program-state.h"
      53                 :             : #include "diagnostic-path.h"
      54                 :             : #include "analyzer/checker-path.h"
      55                 :             : #include "analyzer/diagnostic-manager.h"
      56                 :             : #include "analyzer/exploded-graph.h"
      57                 :             : #include "analyzer/call-details.h"
      58                 :             : #include "analyzer/call-info.h"
      59                 :             : #include "make-unique.h"
      60                 :             : 
      61                 :             : #if ENABLE_ANALYZER
      62                 :             : 
      63                 :             : namespace ana {
      64                 :             : 
      65                 :             : /* class custom_edge_info.  */
      66                 :             : 
      67                 :             : bool
      68                 :        2894 : custom_edge_info::update_state (program_state *state,
      69                 :             :                                 const exploded_edge *eedge,
      70                 :             :                                 region_model_context *ctxt) const
      71                 :             : {
      72                 :        2894 :   return update_model (state->m_region_model, eedge, ctxt);
      73                 :             : }
      74                 :             : 
      75                 :             : /* class call_info : public custom_edge_info.  */
      76                 :             : 
      77                 :             : /* Implementation of custom_edge_info::print vfunc for call_info.  */
      78                 :             : 
      79                 :             : void
      80                 :           0 : call_info::print (pretty_printer *pp) const
      81                 :             : {
      82                 :           0 :   gcc_assert (pp);
      83                 :           0 :   print_desc (*pp);
      84                 :           0 : }
      85                 :             : 
      86                 :             : /* Implementation of custom_edge_info::add_events_to_path vfunc for
      87                 :             :    call_info: add a custom_event using call_info::get_desc as its
      88                 :             :    description.  */
      89                 :             : 
      90                 :             : void
      91                 :         292 : call_info::add_events_to_path (checker_path *emission_path,
      92                 :             :                                const exploded_edge &eedge) const
      93                 :             : {
      94                 :           0 :   class call_event : public custom_event
      95                 :             :   {
      96                 :             :   public:
      97                 :         292 :     call_event (const event_loc_info &loc_info,
      98                 :             :                 const call_info *call_info)
      99                 :         292 :     : custom_event (loc_info),
     100                 :         292 :       m_call_info (call_info)
     101                 :             :     {}
     102                 :             : 
     103                 :         576 :     void print_desc (pretty_printer &pp) const final override
     104                 :             :     {
     105                 :         576 :       m_call_info->print_desc (pp);
     106                 :         576 :     }
     107                 :             : 
     108                 :             :   private:
     109                 :             :     const call_info *m_call_info;
     110                 :             :   };
     111                 :             : 
     112                 :         292 :   const exploded_node *src_node = eedge.m_src;
     113                 :         292 :   const program_point &src_point = src_node->get_point ();
     114                 :         292 :   tree caller_fndecl = src_point.get_fndecl ();
     115                 :         292 :   const int stack_depth = src_point.get_stack_depth ();
     116                 :             : 
     117                 :         292 :   emission_path->add_event
     118                 :         292 :     (make_unique<call_event> (event_loc_info (get_call_stmt ()->location,
     119                 :             :                                               caller_fndecl,
     120                 :         292 :                                               stack_depth),
     121                 :         292 :                               this));
     122                 :         292 : }
     123                 :             : 
     124                 :             : /* Recreate a call_details instance from this call_info.  */
     125                 :             : 
     126                 :             : call_details
     127                 :        6967 : call_info::get_call_details (region_model *model,
     128                 :             :                              region_model_context *ctxt) const
     129                 :             : {
     130                 :        6967 :   return call_details (m_call_stmt, model, ctxt);
     131                 :             : }
     132                 :             : 
     133                 :             : /* call_info's ctor.
     134                 :             : 
     135                 :             :    The call_info instance will outlive the call_details instance;
     136                 :             :    call_details instances are typically created on the stack.  */
     137                 :             : 
     138                 :        4535 : call_info::call_info (const call_details &cd)
     139                 :        4535 : : m_call_stmt (cd.get_call_stmt ()),
     140                 :        4535 :   m_fndecl (cd.get_fndecl_for_call ())
     141                 :             : {
     142                 :        4535 :   gcc_assert (m_fndecl);
     143                 :        4535 : }
     144                 :             : 
     145                 :        2361 : call_info::call_info (const call_details &cd,
     146                 :        2361 :                       const function &called_fn)
     147                 :        2361 : : m_call_stmt (cd.get_call_stmt ()),
     148                 :        2361 :   m_fndecl (called_fn.decl)
     149                 :             : {
     150                 :        2361 :   gcc_assert (m_fndecl);
     151                 :        2361 : }
     152                 :             : 
     153                 :             : /* class succeed_or_fail_call_info : public call_info.  */
     154                 :             : 
     155                 :             : void
     156                 :         276 : succeed_or_fail_call_info::print_desc (pretty_printer &pp) const
     157                 :             : {
     158                 :         276 :   if (m_success)
     159                 :         158 :     pp_printf (&pp, "when %qE succeeds", get_fndecl ());
     160                 :             :   else
     161                 :         118 :     pp_printf (&pp, "when %qE fails", get_fndecl ());
     162                 :         276 : }
     163                 :             : 
     164                 :             : } // namespace ana
     165                 :             : 
     166                 :             : #endif /* #if ENABLE_ANALYZER */
        

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.