LCOV - code coverage report
Current view: top level - gcc/analyzer - checker-event.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 81.1 % 434 352
Test Date: 2024-11-30 13:30:02 Functions: 89.5 % 57 51
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : /* Subclasses of diagnostic_event for analyzer diagnostics.
       2                 :             :    Copyright (C) 2019-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 "diagnostic-core.h"
      30                 :             : #include "gimple-pretty-print.h"
      31                 :             : #include "fold-const.h"
      32                 :             : #include "diagnostic-path.h"
      33                 :             : #include "options.h"
      34                 :             : #include "cgraph.h"
      35                 :             : #include "cfg.h"
      36                 :             : #include "digraph.h"
      37                 :             : #include "diagnostic-event-id.h"
      38                 :             : #include "analyzer/analyzer.h"
      39                 :             : #include "analyzer/analyzer-logging.h"
      40                 :             : #include "analyzer/sm.h"
      41                 :             : #include "sbitmap.h"
      42                 :             : #include "bitmap.h"
      43                 :             : #include "ordered-hash-map.h"
      44                 :             : #include "analyzer/call-string.h"
      45                 :             : #include "analyzer/program-point.h"
      46                 :             : #include "analyzer/store.h"
      47                 :             : #include "analyzer/region-model.h"
      48                 :             : #include "analyzer/program-state.h"
      49                 :             : #include "analyzer/checker-path.h"
      50                 :             : #include "gimple-iterator.h"
      51                 :             : #include "inlining-iterator.h"
      52                 :             : #include "analyzer/supergraph.h"
      53                 :             : #include "analyzer/pending-diagnostic.h"
      54                 :             : #include "analyzer/diagnostic-manager.h"
      55                 :             : #include "analyzer/constraint-manager.h"
      56                 :             : #include "analyzer/checker-event.h"
      57                 :             : #include "analyzer/exploded-graph.h"
      58                 :             : #include "diagnostic-format-sarif.h"
      59                 :             : #include "tree-logical-location.h"
      60                 :             : 
      61                 :             : #if ENABLE_ANALYZER
      62                 :             : 
      63                 :             : namespace ana {
      64                 :             : 
      65                 :             : /* Get a string for EK.  */
      66                 :             : 
      67                 :             : const char *
      68                 :          54 : event_kind_to_string (enum event_kind ek)
      69                 :             : {
      70                 :          54 :   switch (ek)
      71                 :             :     {
      72                 :           0 :     default:
      73                 :           0 :       gcc_unreachable ();
      74                 :             :     case EK_DEBUG:
      75                 :             :       return "EK_DEBUG";
      76                 :           0 :     case EK_CUSTOM:
      77                 :           0 :       return "EK_CUSTOM";
      78                 :           0 :     case EK_STMT:
      79                 :           0 :       return "EK_STMT";
      80                 :          12 :     case EK_REGION_CREATION:
      81                 :          12 :       return "EK_REGION_CREATION";
      82                 :           0 :     case EK_FUNCTION_ENTRY:
      83                 :           0 :       return "EK_FUNCTION_ENTRY";
      84                 :          17 :     case EK_STATE_CHANGE:
      85                 :          17 :       return "EK_STATE_CHANGE";
      86                 :           4 :     case EK_START_CFG_EDGE:
      87                 :           4 :       return "EK_START_CFG_EDGE";
      88                 :           4 :     case EK_END_CFG_EDGE:
      89                 :           4 :       return "EK_END_CFG_EDGE";
      90                 :           0 :     case EK_CALL_EDGE:
      91                 :           0 :       return "EK_CALL_EDGE";
      92                 :           0 :     case EK_RETURN_EDGE:
      93                 :           0 :       return "EK_RETURN_EDGE";
      94                 :           0 :     case EK_START_CONSOLIDATED_CFG_EDGES:
      95                 :           0 :       return "EK_START_CONSOLIDATED_CFG_EDGES";
      96                 :           0 :     case EK_END_CONSOLIDATED_CFG_EDGES:
      97                 :           0 :       return "EK_END_CONSOLIDATED_CFG_EDGES";
      98                 :           0 :     case EK_INLINED_CALL:
      99                 :           0 :       return "EK_INLINED_CALL";
     100                 :           0 :     case EK_SETJMP:
     101                 :           0 :       return "EK_SETJMP";
     102                 :           0 :     case EK_REWIND_FROM_LONGJMP:
     103                 :           0 :       return "EK_REWIND_FROM_LONGJMP";
     104                 :           0 :     case EK_REWIND_TO_SETJMP:
     105                 :           0 :       return "EK_REWIND_TO_SETJMP";
     106                 :          17 :     case EK_WARNING:
     107                 :          17 :       return "EK_WARNING";
     108                 :             :     }
     109                 :             : }
     110                 :             : 
     111                 :             : /* class checker_event : public diagnostic_event.  */
     112                 :             : 
     113                 :             : /* checker_event's ctor.  */
     114                 :             : 
     115                 :       56772 : checker_event::checker_event (enum event_kind kind,
     116                 :       56772 :                               const event_loc_info &loc_info)
     117                 :       56772 : : m_kind (kind), m_loc (loc_info.m_loc),
     118                 :       56772 :   m_original_fndecl (loc_info.m_fndecl),
     119                 :       56772 :   m_effective_fndecl (loc_info.m_fndecl),
     120                 :       56772 :   m_original_depth (loc_info.m_depth),
     121                 :       56772 :   m_effective_depth (loc_info.m_depth),
     122                 :       56772 :   m_pending_diagnostic (NULL), m_emission_id (),
     123                 :       56772 :   m_logical_loc (loc_info.m_fndecl)
     124                 :             : {
     125                 :             :   /* Update effective fndecl and depth if inlining has been recorded.  */
     126                 :       56772 :   if (flag_analyzer_undo_inlining)
     127                 :             :     {
     128                 :       56744 :       inlining_info info (m_loc);
     129                 :       56744 :       if (info.get_inner_fndecl ())
     130                 :             :         {
     131                 :       42795 :           m_effective_fndecl = info.get_inner_fndecl ();
     132                 :       42795 :           m_effective_depth += info.get_extra_frames ();
     133                 :       42795 :           m_logical_loc = tree_logical_location (m_effective_fndecl);
     134                 :             :         }
     135                 :             :     }
     136                 :       56772 : }
     137                 :             : 
     138                 :             : /* No-op implementation of diagnostic_event::get_meaning vfunc for
     139                 :             :    checker_event: checker events have no meaning by default.  */
     140                 :             : 
     141                 :             : diagnostic_event::meaning
     142                 :          92 : checker_event::get_meaning () const
     143                 :             : {
     144                 :          92 :   return meaning ();
     145                 :             : }
     146                 :             : 
     147                 :             : /* Implementation of diagnostic_event::maybe_add_sarif_properties
     148                 :             :    for checker_event.  */
     149                 :             : 
     150                 :             : void
     151                 :          54 : checker_event::
     152                 :             : maybe_add_sarif_properties (sarif_object &thread_flow_loc_obj) const
     153                 :             : {
     154                 :          54 :   sarif_property_bag &props = thread_flow_loc_obj.get_or_create_properties ();
     155                 :             : #define PROPERTY_PREFIX "gcc/analyzer/checker_event/"
     156                 :         108 :   props.set (PROPERTY_PREFIX "emission_id",
     157                 :          54 :              diagnostic_event_id_to_json  (m_emission_id));
     158                 :          54 :   props.set_string (PROPERTY_PREFIX "kind", event_kind_to_string (m_kind));
     159                 :             : 
     160                 :          54 :   if (m_original_fndecl != m_effective_fndecl)
     161                 :             :     {
     162                 :           0 :       tree_logical_location logical_loc (m_original_fndecl);
     163                 :           0 :       props.set<sarif_logical_location>
     164                 :           0 :         (PROPERTY_PREFIX "original_fndecl",
     165                 :           0 :          make_sarif_logical_location_object (logical_loc));
     166                 :           0 :     }
     167                 :          54 :   if (m_original_depth != m_effective_depth)
     168                 :           0 :     props.set_integer (PROPERTY_PREFIX "original_depth", m_original_depth);
     169                 :             : #undef PROPERTY_PREFIX
     170                 :          54 : }
     171                 :             : 
     172                 :             : /* Dump this event to PP (for debugging/logging purposes).  */
     173                 :             : 
     174                 :             : void
     175                 :           0 : checker_event::dump (pretty_printer *pp) const
     176                 :             : {
     177                 :           0 :   pp_character (pp, '"');
     178                 :           0 :   print_desc (*pp);
     179                 :           0 :   pp_printf (pp, "\" (depth %i", m_effective_depth);
     180                 :             : 
     181                 :           0 :   if (m_effective_depth != m_original_depth)
     182                 :           0 :     pp_printf (pp, " corrected from %i",
     183                 :             :                m_original_depth);
     184                 :           0 :   if (m_effective_fndecl)
     185                 :             :     {
     186                 :           0 :       pp_printf (pp, ", fndecl %qE", m_effective_fndecl);
     187                 :           0 :       if (m_effective_fndecl != m_original_fndecl)
     188                 :           0 :         pp_printf (pp, " corrected from %qE", m_original_fndecl);
     189                 :             :     }
     190                 :           0 :   pp_printf (pp, ", m_loc=%llx)",
     191                 :           0 :              (unsigned long long) get_location ());
     192                 :           0 : }
     193                 :             : 
     194                 :             : /* Dump this event to stderr (for debugging/logging purposes).  */
     195                 :             : 
     196                 :             : DEBUG_FUNCTION void
     197                 :           0 : checker_event::debug () const
     198                 :             : {
     199                 :           0 :   tree_dump_pretty_printer pp (stderr);
     200                 :           0 :   dump (&pp);
     201                 :           0 :   pp_newline (&pp);
     202                 :           0 : }
     203                 :             : 
     204                 :             : /* Hook for being notified when this event has its final id EMISSION_ID
     205                 :             :    and is about to emitted for PD.
     206                 :             : 
     207                 :             :    Base implementation of checker_event::prepare_for_emission vfunc;
     208                 :             :    subclasses that override this should chain up to it.
     209                 :             : 
     210                 :             :    Record PD and EMISSION_ID, and call the print_desc vfunc, so that any
     211                 :             :    side-effects of the call to print_desc take place before
     212                 :             :    pending_diagnostic::emit is called.
     213                 :             : 
     214                 :             :    For example, state_change_event::print_desc can call
     215                 :             :    pending_diagnostic::describe_state_change; free_of_non_heap can use this
     216                 :             :    to tweak the message (TODO: would be neater to simply capture the
     217                 :             :    pertinent data within the sm-state).  */
     218                 :             : 
     219                 :             : void
     220                 :       16485 : checker_event::prepare_for_emission (checker_path *,
     221                 :             :                                      pending_diagnostic *pd,
     222                 :             :                                      diagnostic_event_id_t emission_id)
     223                 :             : {
     224                 :       16485 :   m_pending_diagnostic = pd;
     225                 :       16485 :   m_emission_id = emission_id;
     226                 :             : 
     227                 :       16485 :   auto pp = global_dc->clone_printer ();
     228                 :       16485 :   print_desc (*pp.get ());
     229                 :       16485 : }
     230                 :             : 
     231                 :             : /* class debug_event : public checker_event.  */
     232                 :             : 
     233                 :             : /* Implementation of diagnostic_event::print_desc vfunc for
     234                 :             :    debug_event.
     235                 :             :    Use the saved string as the event's description.  */
     236                 :             : 
     237                 :             : void
     238                 :           0 : debug_event::print_desc (pretty_printer &pp) const
     239                 :             : {
     240                 :           0 :   pp_string (&pp, m_desc);
     241                 :           0 : }
     242                 :             : 
     243                 :             : /* class precanned_custom_event : public custom_event.  */
     244                 :             : 
     245                 :             : /* Implementation of diagnostic_event::print_desc vfunc for
     246                 :             :    precanned_custom_event.
     247                 :             :    Use the saved string as the event's description.  */
     248                 :             : 
     249                 :             : void
     250                 :          40 : precanned_custom_event::print_desc (pretty_printer &pp) const
     251                 :             : {
     252                 :          40 :   pp_string (&pp, m_desc);
     253                 :          40 : }
     254                 :             : 
     255                 :             : /* class statement_event : public checker_event.  */
     256                 :             : 
     257                 :             : /* statement_event's ctor.  */
     258                 :             : 
     259                 :       17588 : statement_event::statement_event (const gimple *stmt, tree fndecl, int depth,
     260                 :       17588 :                                   const program_state &dst_state)
     261                 :             : : checker_event (EK_STMT,
     262                 :       17588 :                  event_loc_info (gimple_location (stmt), fndecl, depth)),
     263                 :       17588 :   m_stmt (stmt),
     264                 :       17588 :   m_dst_state (dst_state)
     265                 :             : {
     266                 :       17588 : }
     267                 :             : 
     268                 :             : /* Implementation of diagnostic_event::print_desc vfunc for
     269                 :             :    statement_event.
     270                 :             :    Use the statement's dump form as the event's description.  */
     271                 :             : 
     272                 :             : void
     273                 :           0 : statement_event::print_desc (pretty_printer &pp) const
     274                 :             : {
     275                 :           0 :   pp_string (&pp, "stmt: ");
     276                 :           0 :   pp_gimple_stmt_1 (&pp, m_stmt, 0, (dump_flags_t)0);
     277                 :           0 : }
     278                 :             : 
     279                 :             : /* class region_creation_event : public checker_event.  */
     280                 :             : 
     281                 :        1536 : region_creation_event::region_creation_event (const event_loc_info &loc_info)
     282                 :        1536 : : checker_event (EK_REGION_CREATION, loc_info)
     283                 :             : {
     284                 :        1536 : }
     285                 :             : 
     286                 :             : /* The various region_creation_event subclasses' print_desc
     287                 :             :    implementations.  */
     288                 :             : 
     289                 :             : void
     290                 :        1182 : region_creation_event_memory_space::print_desc (pretty_printer &pp) const
     291                 :             : {
     292                 :        1182 :   switch (m_mem_space)
     293                 :             :     {
     294                 :          28 :     default:
     295                 :          28 :       pp_string (&pp, "region created here");
     296                 :          28 :       return;
     297                 :        1056 :     case MEMSPACE_STACK:
     298                 :        1056 :       pp_string (&pp, "region created on stack here");
     299                 :        1056 :       return;
     300                 :          98 :     case MEMSPACE_HEAP:
     301                 :          98 :       pp_string (&pp, "region created on heap here");
     302                 :          98 :       return;
     303                 :             :     }
     304                 :             : }
     305                 :             : 
     306                 :             : void
     307                 :        1590 : region_creation_event_capacity::print_desc (pretty_printer &pp) const
     308                 :             : {
     309                 :        1590 :   gcc_assert (m_capacity);
     310                 :        1590 :   if (TREE_CODE (m_capacity) == INTEGER_CST)
     311                 :             :     {
     312                 :        1394 :       unsigned HOST_WIDE_INT hwi = tree_to_uhwi (m_capacity);
     313                 :        1394 :       return pp_printf_n (&pp,
     314                 :             :                           hwi,
     315                 :             :                           "capacity: %wu byte",
     316                 :             :                           "capacity: %wu bytes",
     317                 :        1394 :                           hwi);
     318                 :             :     }
     319                 :             :   else
     320                 :         196 :     return pp_printf (&pp, "capacity: %qE bytes", m_capacity);
     321                 :             : }
     322                 :             : 
     323                 :             : void
     324                 :         188 : region_creation_event_allocation_size::print_desc (pretty_printer &pp) const
     325                 :             : {
     326                 :         188 :   if (m_capacity)
     327                 :             :     {
     328                 :         180 :       if (TREE_CODE (m_capacity) == INTEGER_CST)
     329                 :         124 :         pp_printf_n (&pp,
     330                 :             :                      tree_to_uhwi (m_capacity),
     331                 :             :                      "allocated %E byte here",
     332                 :             :                      "allocated %E bytes here",
     333                 :             :                      m_capacity);
     334                 :             :       else
     335                 :          56 :         pp_printf (&pp,
     336                 :             :                    "allocated %qE bytes here",
     337                 :             :                    m_capacity);
     338                 :             :     }
     339                 :         188 :   pp_printf (&pp, "allocated here");
     340                 :         188 : }
     341                 :             : 
     342                 :             : void
     343                 :           0 : region_creation_event_debug::print_desc (pretty_printer &pp) const
     344                 :             : {
     345                 :           0 :   pp_string (&pp, "region creation: ");
     346                 :           0 :   m_reg->dump_to_pp (&pp, true);
     347                 :           0 :   if (m_capacity)
     348                 :           0 :     pp_printf (&pp, " capacity: %qE", m_capacity);
     349                 :           0 : }
     350                 :             : 
     351                 :             : /* class function_entry_event : public checker_event.  */
     352                 :             : 
     353                 :        5016 : function_entry_event::function_entry_event (const program_point &dst_point)
     354                 :             : : checker_event (EK_FUNCTION_ENTRY,
     355                 :        5016 :                  event_loc_info (dst_point.get_supernode
     356                 :             :                                    ()->get_start_location (),
     357                 :             :                                  dst_point.get_fndecl (),
     358                 :       10032 :                                  dst_point.get_stack_depth ()))
     359                 :             : {
     360                 :        5016 : }
     361                 :             : 
     362                 :             : /* Implementation of diagnostic_event::print_desc vfunc for
     363                 :             :    function_entry_event.
     364                 :             : 
     365                 :             :    Use a string such as "entry to 'foo'" as the event's description.  */
     366                 :             : 
     367                 :             : void
     368                 :        2612 : function_entry_event::print_desc (pretty_printer &pp) const
     369                 :             : {
     370                 :        2612 :   pp_printf (&pp, "entry to %qE", m_effective_fndecl);
     371                 :        2612 : }
     372                 :             : 
     373                 :             : /* Implementation of diagnostic_event::get_meaning vfunc for
     374                 :             :    function entry.  */
     375                 :             : 
     376                 :             : diagnostic_event::meaning
     377                 :         199 : function_entry_event::get_meaning () const
     378                 :             : {
     379                 :         199 :   return meaning (VERB_enter, NOUN_function);
     380                 :             : }
     381                 :             : 
     382                 :             : /* class state_change_event : public checker_event.  */
     383                 :             : 
     384                 :             : /* state_change_event's ctor.  */
     385                 :             : 
     386                 :        4601 : state_change_event::state_change_event (const supernode *node,
     387                 :             :                                         const gimple *stmt,
     388                 :             :                                         int stack_depth,
     389                 :             :                                         const state_machine &sm,
     390                 :             :                                         const svalue *sval,
     391                 :             :                                         state_machine::state_t from,
     392                 :             :                                         state_machine::state_t to,
     393                 :             :                                         const svalue *origin,
     394                 :             :                                         const program_state &dst_state,
     395                 :        4601 :                                         const exploded_node *enode)
     396                 :             : : checker_event (EK_STATE_CHANGE,
     397                 :        9202 :                  event_loc_info (stmt->location,
     398                 :        4601 :                                  node->m_fun->decl,
     399                 :        4601 :                                  stack_depth)),
     400                 :        4601 :   m_node (node), m_stmt (stmt), m_sm (sm),
     401                 :        4601 :   m_sval (sval), m_from (from), m_to (to),
     402                 :        4601 :   m_origin (origin),
     403                 :        4601 :   m_dst_state (dst_state),
     404                 :        4601 :   m_enode (enode)
     405                 :             : {
     406                 :        4601 : }
     407                 :             : 
     408                 :             : /* Implementation of diagnostic_event::print_desc vfunc for
     409                 :             :    state_change_event.
     410                 :             : 
     411                 :             :    Attempt to generate a nicer human-readable description.
     412                 :             :    For greatest precision-of-wording, give the pending diagnostic
     413                 :             :    a chance to describe this state change (in terms of the
     414                 :             :    diagnostic).
     415                 :             :    Note that we only have a pending_diagnostic set on the event once
     416                 :             :    the diagnostic is about to being emitted, so the description for
     417                 :             :    an event can change.  */
     418                 :             : 
     419                 :             : void
     420                 :        4470 : state_change_event::print_desc (pretty_printer &pp) const
     421                 :             : {
     422                 :        4470 :   if (m_pending_diagnostic)
     423                 :             :     {
     424                 :        4470 :       region_model *model = m_dst_state.m_region_model;
     425                 :        4470 :       tree var = model->get_representative_tree (m_sval);
     426                 :        4470 :       tree origin = model->get_representative_tree (m_origin);
     427                 :        4470 :       evdesc::state_change evd (var, origin,
     428                 :        4470 :                                 m_from, m_to, m_emission_id, *this);
     429                 :        4470 :       if (m_pending_diagnostic->describe_state_change (pp, evd))
     430                 :             :         {
     431                 :        4468 :           if (flag_analyzer_verbose_state_changes)
     432                 :             :             {
     433                 :             :               /* Append debugging information about this event.  */
     434                 :             : 
     435                 :         144 :               if (var)
     436                 :         136 :                 pp_printf (&pp, " (state of %qE: ", var);
     437                 :             :               else
     438                 :           8 :                 pp_string (&pp, " (state: ");
     439                 :             : 
     440                 :         144 :               pp_printf (&pp, "%qs -> %qs, ",
     441                 :         144 :                          m_from->get_name (),
     442                 :         144 :                          m_to->get_name ());
     443                 :             : 
     444                 :         144 :               if (m_origin)
     445                 :           0 :                 pp_printf (&pp, "origin: %qE", origin);
     446                 :             :               else
     447                 :         144 :                 pp_string (&pp, "NULL origin");
     448                 :             : 
     449                 :             :               /* Get any "meaning" of event.  */
     450                 :         144 :               diagnostic_event::meaning meaning = get_meaning ();
     451                 :         144 :               pp_string (&pp, ", meaning: ");
     452                 :         144 :               meaning.dump_to_pp (&pp);
     453                 :         144 :               pp_string (&pp, ")");
     454                 :             :             }
     455                 :        4468 :           return;
     456                 :             :         }
     457                 :             :     }
     458                 :             : 
     459                 :             :   /* Fallback description.  */
     460                 :           2 :   if (m_sval)
     461                 :             :     {
     462                 :           2 :       label_text sval_desc = m_sval->get_desc ();
     463                 :           2 :       pp_printf (&pp,
     464                 :             :                  "state of %qs: %qs -> %qs",
     465                 :             :                  sval_desc.get (),
     466                 :           2 :                  m_from->get_name (),
     467                 :           2 :                  m_to->get_name ());
     468                 :           2 :       if (m_origin)
     469                 :             :         {
     470                 :           0 :           label_text origin_desc = m_origin->get_desc ();
     471                 :           0 :           pp_printf (&pp, " (origin: %qs)",
     472                 :             :                      origin_desc.get ());
     473                 :           0 :         }
     474                 :             :       else
     475                 :           2 :         pp_string (&pp, " (NULL origin)");
     476                 :           2 :     }
     477                 :             :   else
     478                 :             :     {
     479                 :           0 :       gcc_assert (m_origin == NULL);
     480                 :           0 :       pp_printf (&pp,
     481                 :             :                  "global state: %qs -> %qs",
     482                 :           0 :                  m_from->get_name (),
     483                 :           0 :                  m_to->get_name ());
     484                 :             :     }
     485                 :             : }
     486                 :             : 
     487                 :             : /* Implementation of diagnostic_event::get_meaning vfunc for
     488                 :             :    state change events: delegate to the pending_diagnostic to
     489                 :             :    get any meaning.  */
     490                 :             : 
     491                 :             : diagnostic_event::meaning
     492                 :         327 : state_change_event::get_meaning () const
     493                 :             : {
     494                 :         327 :   if (m_pending_diagnostic)
     495                 :             :     {
     496                 :         327 :       region_model *model = m_dst_state.m_region_model;
     497                 :         327 :       tree var = model->get_representative_tree (m_sval);
     498                 :         327 :       tree origin = model->get_representative_tree (m_origin);
     499                 :         327 :       evdesc::state_change evd (var, origin,
     500                 :         327 :                                 m_from, m_to, m_emission_id, *this);
     501                 :         327 :       return m_pending_diagnostic->get_meaning_for_state_change (evd);
     502                 :             :     }
     503                 :             :   else
     504                 :           0 :     return meaning ();
     505                 :             : }
     506                 :             : 
     507                 :             : /* class superedge_event : public checker_event.  */
     508                 :             : 
     509                 :             : /* Implementation of diagnostic_event::maybe_add_sarif_properties
     510                 :             :    for superedge_event.  */
     511                 :             : 
     512                 :             : void
     513                 :           8 : superedge_event::maybe_add_sarif_properties (sarif_object &thread_flow_loc_obj)
     514                 :             :   const
     515                 :             : {
     516                 :           8 :   checker_event::maybe_add_sarif_properties (thread_flow_loc_obj);
     517                 :           8 :   sarif_property_bag &props = thread_flow_loc_obj.get_or_create_properties ();
     518                 :             : #define PROPERTY_PREFIX "gcc/analyzer/superedge_event/"
     519                 :           8 :   if (m_sedge)
     520                 :           8 :     props.set (PROPERTY_PREFIX "superedge", m_sedge->to_json ());
     521                 :             : #undef PROPERTY_PREFIX
     522                 :           8 : }
     523                 :             : 
     524                 :             : /* Get the callgraph_superedge for this superedge_event, which must be
     525                 :             :    for an interprocedural edge, rather than a CFG edge.  */
     526                 :             : 
     527                 :             : const callgraph_superedge&
     528                 :        1572 : superedge_event::get_callgraph_superedge () const
     529                 :             : {
     530                 :        1572 :   gcc_assert (m_sedge->m_kind != SUPEREDGE_CFG_EDGE);
     531                 :        1572 :   return *m_sedge->dyn_cast_callgraph_superedge ();
     532                 :             : }
     533                 :             : 
     534                 :             : /* Determine if this event should be filtered at the given verbosity
     535                 :             :    level.  */
     536                 :             : 
     537                 :             : bool
     538                 :       10519 : superedge_event::should_filter_p (int verbosity) const
     539                 :             : {
     540                 :       10519 :   switch (m_sedge->m_kind)
     541                 :             :     {
     542                 :       10519 :     case SUPEREDGE_CFG_EDGE:
     543                 :       10519 :       {
     544                 :       10519 :         if (verbosity < 2)
     545                 :             :           return true;
     546                 :             : 
     547                 :       10322 :         if (verbosity < 4)
     548                 :             :           {
     549                 :             :             /* Filter events with empty descriptions.  This ought to filter
     550                 :             :                FALLTHRU, but retain true/false/switch edges.  */
     551                 :       10322 :             auto pp = global_dc->clone_printer ();
     552                 :       10322 :             print_desc (*pp.get ());
     553                 :       10322 :             if (pp_formatted_text (pp.get ()) [0] == '\0')
     554                 :        7763 :               return true;
     555                 :       10322 :           }
     556                 :             :       }
     557                 :             :       break;
     558                 :             : 
     559                 :             :     default:
     560                 :             :       break;
     561                 :             :     }
     562                 :             :   return false;
     563                 :             : }
     564                 :             : 
     565                 :             : /* superedge_event's ctor.  */
     566                 :             : 
     567                 :       23075 : superedge_event::superedge_event (enum event_kind kind,
     568                 :             :                                   const exploded_edge &eedge,
     569                 :       23075 :                                   const event_loc_info &loc_info)
     570                 :             : : checker_event (kind, loc_info),
     571                 :       23075 :   m_eedge (eedge), m_sedge (eedge.m_sedge),
     572                 :       23075 :   m_var (NULL_TREE), m_critical_state (0)
     573                 :             : {
     574                 :             :   /* Note that m_sedge can be nullptr for e.g. jumps through
     575                 :             :      function pointers.  */
     576                 :       23075 : }
     577                 :             : 
     578                 :             : /* class cfg_edge_event : public superedge_event.  */
     579                 :             : 
     580                 :             : /* Get the cfg_superedge for this cfg_edge_event.  */
     581                 :             : 
     582                 :             : const cfg_superedge &
     583                 :        7931 : cfg_edge_event::get_cfg_superedge () const
     584                 :             : {
     585                 :        7931 :   return *m_sedge->dyn_cast_cfg_superedge ();
     586                 :             : }
     587                 :             : 
     588                 :             : /* cfg_edge_event's ctor.  */
     589                 :             : 
     590                 :       21284 : cfg_edge_event::cfg_edge_event (enum event_kind kind,
     591                 :             :                                 const exploded_edge &eedge,
     592                 :       21284 :                                 const event_loc_info &loc_info)
     593                 :       21284 : : superedge_event (kind, eedge, loc_info)
     594                 :             : {
     595                 :       21284 :   gcc_assert (eedge.m_sedge->m_kind == SUPEREDGE_CFG_EDGE);
     596                 :       21284 : }
     597                 :             : 
     598                 :             : /* Implementation of diagnostic_event::get_meaning vfunc for
     599                 :             :    CFG edge events.  */
     600                 :             : 
     601                 :             : diagnostic_event::meaning
     602                 :         270 : cfg_edge_event::get_meaning () const
     603                 :             : {
     604                 :         270 :   const cfg_superedge& cfg_sedge = get_cfg_superedge ();
     605                 :         270 :   if (cfg_sedge.true_value_p ())
     606                 :         116 :     return meaning (VERB_branch, PROPERTY_true);
     607                 :         154 :   else if (cfg_sedge.false_value_p ())
     608                 :         114 :     return meaning (VERB_branch, PROPERTY_false);
     609                 :             :   else
     610                 :          40 :     return meaning ();
     611                 :             : }
     612                 :             : 
     613                 :             : /* class start_cfg_edge_event : public cfg_edge_event.  */
     614                 :             : 
     615                 :             : /* Implementation of diagnostic_event::print_desc vfunc for
     616                 :             :    start_cfg_edge_event.
     617                 :             : 
     618                 :             :    If -fanalyzer-verbose-edges, then generate low-level descriptions, such
     619                 :             :    as
     620                 :             :      "taking 'true' edge SN:7 -> SN:8".
     621                 :             : 
     622                 :             :    Otherwise, generate strings using the label of the underlying CFG if
     623                 :             :    any, such as:
     624                 :             :      "following 'true' branch..." or
     625                 :             :      "following 'case 3' branch..."
     626                 :             :      "following 'default' branch..."
     627                 :             : 
     628                 :             :    For conditionals, attempt to supply a description of the condition that
     629                 :             :    holds, such as:
     630                 :             :      "following 'false' branch (when 'ptr' is non-NULL)..."
     631                 :             : 
     632                 :             :    Failing that, print nothing (which will lead to this event
     633                 :             :    being filtered).  */
     634                 :             : 
     635                 :             : void
     636                 :       14976 : start_cfg_edge_event::print_desc (pretty_printer &pp) const
     637                 :             : {
     638                 :       14976 :   bool user_facing = !flag_analyzer_verbose_edges;
     639                 :       14976 :   label_text edge_desc (m_sedge->get_description (user_facing));
     640                 :       14976 :   if (user_facing)
     641                 :             :     {
     642                 :       14976 :       if (edge_desc.get () && strlen (edge_desc.get ()) > 0)
     643                 :             :         {
     644                 :        7213 :           label_text cond_desc = maybe_describe_condition (pp_show_color (&pp));
     645                 :        7213 :           label_text result;
     646                 :        7213 :           if (cond_desc.get ())
     647                 :        3939 :             pp_printf (&pp,
     648                 :             :                        "following %qs branch (%s)...",
     649                 :             :                        edge_desc.get (), cond_desc.get ());
     650                 :             :           else
     651                 :        3274 :             pp_printf (&pp,
     652                 :             :                        "following %qs branch...",
     653                 :             :                        edge_desc.get ());
     654                 :       11092 :         }
     655                 :             :     }
     656                 :             :   else
     657                 :             :     {
     658                 :           0 :       if (strlen (edge_desc.get ()) > 0)
     659                 :           0 :         return pp_printf (&pp,
     660                 :             :                           "taking %qs edge SN:%i -> SN:%i",
     661                 :             :                           edge_desc.get (),
     662                 :           0 :                           m_sedge->m_src->m_index,
     663                 :           0 :                           m_sedge->m_dest->m_index);
     664                 :             :       else
     665                 :           0 :         return pp_printf (&pp,
     666                 :             :                           "taking edge SN:%i -> SN:%i",
     667                 :           0 :                           m_sedge->m_src->m_index,
     668                 :           0 :                           m_sedge->m_dest->m_index);
     669                 :             :     }
     670                 :       14976 : }
     671                 :             : 
     672                 :             : /* Attempt to generate a description of any condition that holds at this edge.
     673                 :             : 
     674                 :             :    The intent is to make the user-facing messages more clear, especially for
     675                 :             :    cases where there's a single or double-negative, such as
     676                 :             :    when describing the false branch of an inverted condition.
     677                 :             : 
     678                 :             :    For example, rather than printing just:
     679                 :             : 
     680                 :             :       |  if (!ptr)
     681                 :             :       |     ~
     682                 :             :       |     |
     683                 :             :       |     (1) following 'false' branch...
     684                 :             : 
     685                 :             :    it's clearer to spell out the condition that holds:
     686                 :             : 
     687                 :             :       |  if (!ptr)
     688                 :             :       |     ~
     689                 :             :       |     |
     690                 :             :       |     (1) following 'false' branch (when 'ptr' is non-NULL)...
     691                 :             :                                           ^^^^^^^^^^^^^^^^^^^^^^
     692                 :             : 
     693                 :             :    In the above example, this function would generate the highlighted
     694                 :             :    string: "when 'ptr' is non-NULL".
     695                 :             : 
     696                 :             :    If the edge is not a condition, or it's not clear that a description of
     697                 :             :    the condition would be helpful to the user, return NULL.  */
     698                 :             : 
     699                 :             : label_text
     700                 :        7323 : start_cfg_edge_event::maybe_describe_condition (bool can_colorize) const
     701                 :             : {
     702                 :        7323 :   const cfg_superedge& cfg_sedge = get_cfg_superedge ();
     703                 :             : 
     704                 :        7323 :   if (cfg_sedge.true_value_p () || cfg_sedge.false_value_p ())
     705                 :             :     {
     706                 :        6909 :       const gimple *last_stmt = m_sedge->m_src->get_last_stmt ();
     707                 :        6909 :       if (const gcond *cond_stmt = dyn_cast <const gcond *> (last_stmt))
     708                 :             :         {
     709                 :        6909 :           enum tree_code op = gimple_cond_code (cond_stmt);
     710                 :        6909 :           tree lhs = gimple_cond_lhs (cond_stmt);
     711                 :        6909 :           tree rhs = gimple_cond_rhs (cond_stmt);
     712                 :        6909 :           if (cfg_sedge.false_value_p ())
     713                 :        3161 :             op = invert_tree_comparison (op, false /* honor_nans */);
     714                 :        6909 :           return maybe_describe_condition (can_colorize,
     715                 :        6909 :                                            lhs, op, rhs);
     716                 :             :         }
     717                 :             :     }
     718                 :         414 :   return label_text::borrow (NULL);
     719                 :             : }
     720                 :             : 
     721                 :             : /* Subroutine of maybe_describe_condition above.
     722                 :             : 
     723                 :             :    Attempt to generate a user-facing description of the condition
     724                 :             :    LHS OP RHS, but only if it is likely to make it easier for the
     725                 :             :    user to understand a condition.  */
     726                 :             : 
     727                 :             : label_text
     728                 :        6909 : start_cfg_edge_event::maybe_describe_condition (bool can_colorize,
     729                 :             :                                                 tree lhs,
     730                 :             :                                                 enum tree_code op,
     731                 :             :                                                 tree rhs)
     732                 :             : {
     733                 :             :   /* In theory we could just build a tree via
     734                 :             :        fold_build2 (op, boolean_type_node, lhs, rhs)
     735                 :             :      and print it with %qE on it, but this leads to warts such as
     736                 :             :      parenthesizing vars, such as '(i) <= 9', and uses of '<unknown>'.  */
     737                 :             : 
     738                 :             :   /* Special-case: describe testing the result of strcmp, as figuring
     739                 :             :      out what the "true" or "false" path is can be confusing to the user.  */
     740                 :        6909 :   if (TREE_CODE (lhs) == SSA_NAME
     741                 :        6909 :       && zerop (rhs))
     742                 :             :     {
     743                 :        5265 :       if (gcall *call = dyn_cast <gcall *> (SSA_NAME_DEF_STMT (lhs)))
     744                 :        1967 :         if (is_special_named_call_p (call, "strcmp", 2))
     745                 :             :           {
     746                 :          60 :             if (op == EQ_EXPR)
     747                 :           9 :               return label_text::borrow ("when the strings are equal");
     748                 :          51 :             if (op == NE_EXPR)
     749                 :          51 :               return label_text::borrow ("when the strings are non-equal");
     750                 :             :           }
     751                 :             :     }
     752                 :             : 
     753                 :             :   /* Only attempt to generate text for sufficiently simple expressions.  */
     754                 :        6849 :   if (!should_print_expr_p (lhs))
     755                 :        2820 :     return label_text::borrow (NULL);
     756                 :        4029 :   if (!should_print_expr_p (rhs))
     757                 :          58 :     return label_text::borrow (NULL);
     758                 :             : 
     759                 :             :   /* Special cases for pointer comparisons against NULL.  */
     760                 :        6418 :   if (POINTER_TYPE_P (TREE_TYPE (lhs))
     761                 :        1524 :       && POINTER_TYPE_P (TREE_TYPE (rhs))
     762                 :        5495 :       && zerop (rhs))
     763                 :             :     {
     764                 :        1455 :       if (op == EQ_EXPR)
     765                 :         393 :         return make_label_text (can_colorize, "when %qE is NULL",
     766                 :         393 :                                 lhs);
     767                 :        1062 :       if (op == NE_EXPR)
     768                 :        1062 :         return make_label_text (can_colorize, "when %qE is non-NULL",
     769                 :        1062 :                                 lhs);
     770                 :             :     }
     771                 :             : 
     772                 :        2516 :   return make_label_text (can_colorize, "when %<%E %s %E%>",
     773                 :        2516 :                           lhs, op_symbol_code (op), rhs);
     774                 :             : }
     775                 :             : 
     776                 :             : /* Subroutine of maybe_describe_condition.
     777                 :             : 
     778                 :             :    Return true if EXPR is we will get suitable user-facing output
     779                 :             :    from %E on it.  */
     780                 :             : 
     781                 :             : bool
     782                 :       10878 : start_cfg_edge_event::should_print_expr_p (tree expr)
     783                 :             : {
     784                 :       15239 :   if (TREE_CODE (expr) == SSA_NAME)
     785                 :             :     {
     786                 :        7239 :       if (SSA_NAME_VAR (expr))
     787                 :             :         return should_print_expr_p (SSA_NAME_VAR (expr));
     788                 :             :       else
     789                 :             :         return false;
     790                 :             :     }
     791                 :             : 
     792                 :        8000 :   if (DECL_P (expr))
     793                 :             :     return true;
     794                 :             : 
     795                 :        3639 :   if (CONSTANT_CLASS_P (expr))
     796                 :        3639 :     return true;
     797                 :             : 
     798                 :             :   return false;
     799                 :             : }
     800                 :             : 
     801                 :             : /* class call_event : public superedge_event.  */
     802                 :             : 
     803                 :             : /* call_event's ctor.  */
     804                 :             : 
     805                 :        1153 : call_event::call_event (const exploded_edge &eedge,
     806                 :        1153 :                         const event_loc_info &loc_info)
     807                 :        1153 : : superedge_event (EK_CALL_EDGE, eedge, loc_info)
     808                 :             : {
     809                 :        1153 :   if (eedge.m_sedge)
     810                 :        1120 :     gcc_assert (eedge.m_sedge->m_kind == SUPEREDGE_CALL);
     811                 :             : 
     812                 :        1153 :    m_src_snode = eedge.m_src->get_supernode ();
     813                 :        1153 :    m_dest_snode = eedge.m_dest->get_supernode ();
     814                 :        1153 : }
     815                 :             : 
     816                 :             : /* Implementation of diagnostic_event::print_desc vfunc for
     817                 :             :    call_event.
     818                 :             : 
     819                 :             :    If this call event passes critical state for an sm-based warning,
     820                 :             :    allow the diagnostic to generate a precise description, such as:
     821                 :             : 
     822                 :             :      "passing freed pointer 'ptr' in call to 'foo' from 'bar'"
     823                 :             : 
     824                 :             :    Otherwise, generate a description of the form
     825                 :             :    "calling 'foo' from 'bar'".  */
     826                 :             : 
     827                 :             : void
     828                 :        1646 : call_event::print_desc (pretty_printer &pp) const
     829                 :             : {
     830                 :        1646 :   if (m_critical_state && m_pending_diagnostic)
     831                 :             :     {
     832                 :         353 :       gcc_assert (m_var);
     833                 :         353 :       tree var = fixup_tree_for_diagnostic (m_var);
     834                 :         353 :       evdesc::call_with_state evd (m_src_snode->m_fun->decl,
     835                 :         353 :                                    m_dest_snode->m_fun->decl,
     836                 :             :                                    var,
     837                 :         353 :                                    m_critical_state);
     838                 :         353 :       if (m_pending_diagnostic->describe_call_with_state (pp, evd))
     839                 :         150 :         return;
     840                 :             :     }
     841                 :             : 
     842                 :        1496 :   pp_printf (&pp,
     843                 :             :              "calling %qE from %qE",
     844                 :             :              get_callee_fndecl (),
     845                 :             :              get_caller_fndecl ());
     846                 :             : }
     847                 :             : 
     848                 :             : /* Implementation of diagnostic_event::get_meaning vfunc for
     849                 :             :    function call events.  */
     850                 :             : 
     851                 :             : diagnostic_event::meaning
     852                 :         123 : call_event::get_meaning () const
     853                 :             : {
     854                 :         123 :   return meaning (VERB_call, NOUN_function);
     855                 :             : }
     856                 :             : 
     857                 :             : /* Override of checker_event::is_call_p for calls.  */
     858                 :             : 
     859                 :             : bool
     860                 :        1960 : call_event::is_call_p () const
     861                 :             : {
     862                 :        1960 :   return true;
     863                 :             : }
     864                 :             : 
     865                 :             : tree
     866                 :        1564 : call_event::get_caller_fndecl () const
     867                 :             : {
     868                 :        1564 :   return m_src_snode->m_fun->decl;
     869                 :             : }
     870                 :             : 
     871                 :             : tree
     872                 :        1564 : call_event::get_callee_fndecl () const
     873                 :             : {
     874                 :        1564 :   return m_dest_snode->m_fun->decl;
     875                 :             : }
     876                 :             : 
     877                 :             : /* class return_event : public superedge_event.  */
     878                 :             : 
     879                 :             : /* return_event's ctor.  */
     880                 :             : 
     881                 :         638 : return_event::return_event (const exploded_edge &eedge,
     882                 :         638 :                             const event_loc_info &loc_info)
     883                 :         638 : : superedge_event (EK_RETURN_EDGE, eedge, loc_info)
     884                 :             : {
     885                 :         638 :   if (eedge.m_sedge)
     886                 :         620 :     gcc_assert (eedge.m_sedge->m_kind == SUPEREDGE_RETURN);
     887                 :             : 
     888                 :         638 :   m_src_snode = eedge.m_src->get_supernode ();
     889                 :         638 :   m_dest_snode = eedge.m_dest->get_supernode ();
     890                 :         638 : }
     891                 :             : 
     892                 :             : /* Implementation of diagnostic_event::print_desc vfunc for
     893                 :             :    return_event.
     894                 :             : 
     895                 :             :    If this return event returns critical state for an sm-based warning,
     896                 :             :    allow the diagnostic to generate a precise description, such as:
     897                 :             : 
     898                 :             :       "possible of NULL to 'foo' from 'bar'"
     899                 :             : 
     900                 :             :    Otherwise, generate a description of the form
     901                 :             :    "returning to 'foo' from 'bar'.  */
     902                 :             : 
     903                 :             : void
     904                 :         692 : return_event::print_desc (pretty_printer &pp) const
     905                 :             : {
     906                 :             :   /*  For greatest precision-of-wording, if this is returning the
     907                 :             :       state involved in the pending diagnostic, give the pending
     908                 :             :       diagnostic a chance to describe this return (in terms of
     909                 :             :       itself).  */
     910                 :         692 :   if (m_critical_state && m_pending_diagnostic)
     911                 :             :     {
     912                 :          92 :       evdesc::return_of_state evd (m_dest_snode->m_fun->decl,
     913                 :          92 :                                    m_src_snode->m_fun->decl,
     914                 :          92 :                                    m_critical_state);
     915                 :          92 :       if (m_pending_diagnostic->describe_return_of_state (pp, evd))
     916                 :          44 :         return;
     917                 :             :     }
     918                 :         648 :   pp_printf (&pp,
     919                 :             :              "returning to %qE from %qE",
     920                 :         648 :              m_dest_snode->m_fun->decl,
     921                 :         648 :              m_src_snode->m_fun->decl);
     922                 :             : }
     923                 :             : 
     924                 :             : /* Implementation of diagnostic_event::get_meaning vfunc for
     925                 :             :    function return events.  */
     926                 :             : 
     927                 :             : diagnostic_event::meaning
     928                 :          51 : return_event::get_meaning () const
     929                 :             : {
     930                 :          51 :   return meaning (VERB_return, NOUN_function);
     931                 :             : }
     932                 :             : 
     933                 :             : /* Override of checker_event::is_return_p for returns.  */
     934                 :             : 
     935                 :             : bool
     936                 :         640 : return_event::is_return_p () const
     937                 :             : {
     938                 :         640 :   return true;
     939                 :             : }
     940                 :             : 
     941                 :             : /* class start_consolidated_cfg_edges_event : public checker_event.  */
     942                 :             : 
     943                 :             : void
     944                 :         117 : start_consolidated_cfg_edges_event::print_desc (pretty_printer &pp) const
     945                 :             : {
     946                 :         117 :   pp_printf (&pp,
     947                 :             :              "following %qs branch...",
     948                 :         117 :              m_edge_sense ? "true" : "false");
     949                 :         117 : }
     950                 :             : 
     951                 :             : /* Implementation of diagnostic_event::get_meaning vfunc for
     952                 :             :    start_consolidated_cfg_edges_event.  */
     953                 :             : 
     954                 :             : diagnostic_event::meaning
     955                 :           0 : start_consolidated_cfg_edges_event::get_meaning () const
     956                 :             : {
     957                 :           0 :   return meaning (VERB_branch,
     958                 :           0 :                   (m_edge_sense ? PROPERTY_true : PROPERTY_false));
     959                 :             : }
     960                 :             : 
     961                 :             : /* class inlined_call_event : public checker_event.  */
     962                 :             : 
     963                 :             : void
     964                 :         333 : inlined_call_event::print_desc (pretty_printer &pp) const
     965                 :             : {
     966                 :         333 :   pp_printf (&pp,
     967                 :             :              "inlined call to %qE from %qE",
     968                 :         333 :              m_apparent_callee_fndecl,
     969                 :         333 :              m_apparent_caller_fndecl);
     970                 :         333 : }
     971                 :             : 
     972                 :             : /* Implementation of diagnostic_event::get_meaning vfunc for
     973                 :             :    reconstructed inlined function calls.  */
     974                 :             : 
     975                 :             : diagnostic_event::meaning
     976                 :          72 : inlined_call_event::get_meaning () const
     977                 :             : {
     978                 :          72 :   return meaning (VERB_call, NOUN_function);
     979                 :             : }
     980                 :             : 
     981                 :             : /* class setjmp_event : public checker_event.  */
     982                 :             : 
     983                 :             : /* Implementation of diagnostic_event::print_desc vfunc for
     984                 :             :    setjmp_event.  */
     985                 :             : 
     986                 :             : void
     987                 :          40 : setjmp_event::print_desc (pretty_printer &pp) const
     988                 :             : {
     989                 :          40 :   pp_printf (&pp,
     990                 :             :              "%qs called here",
     991                 :          40 :              get_user_facing_name (m_setjmp_call));
     992                 :          40 : }
     993                 :             : 
     994                 :             : /* Implementation of checker_event::prepare_for_emission vfunc for setjmp_event.
     995                 :             : 
     996                 :             :    Record this setjmp's event ID into the path, so that rewind events can
     997                 :             :    use it.  */
     998                 :             : 
     999                 :             : void
    1000                 :          20 : setjmp_event::prepare_for_emission (checker_path *path,
    1001                 :             :                                     pending_diagnostic *pd,
    1002                 :             :                                     diagnostic_event_id_t emission_id)
    1003                 :             : {
    1004                 :          20 :   checker_event::prepare_for_emission (path, pd, emission_id);
    1005                 :          20 :   path->record_setjmp_event (m_enode, emission_id);
    1006                 :          20 : }
    1007                 :             : 
    1008                 :             : /* class rewind_event : public checker_event.  */
    1009                 :             : 
    1010                 :             : /* Get the fndecl containing the site of the longjmp call.  */
    1011                 :             : 
    1012                 :             : tree
    1013                 :          90 : rewind_event::get_longjmp_caller () const
    1014                 :             : {
    1015                 :          90 :   return m_eedge->m_src->get_function ()->decl;
    1016                 :             : }
    1017                 :             : 
    1018                 :             : /* Get the fndecl containing the site of the setjmp call.  */
    1019                 :             : 
    1020                 :             : tree
    1021                 :          82 : rewind_event::get_setjmp_caller () const
    1022                 :             : {
    1023                 :          82 :   return m_eedge->m_dest->get_function ()->decl;
    1024                 :             : }
    1025                 :             : 
    1026                 :             : /* rewind_event's ctor.  */
    1027                 :             : 
    1028                 :          30 : rewind_event::rewind_event (const exploded_edge *eedge,
    1029                 :             :                             enum event_kind kind,
    1030                 :             :                             const event_loc_info &loc_info,
    1031                 :          30 :                             const rewind_info_t *rewind_info)
    1032                 :             : : checker_event (kind, loc_info),
    1033                 :          30 :   m_rewind_info (rewind_info),
    1034                 :          30 :   m_eedge (eedge)
    1035                 :             : {
    1036                 :          30 :   gcc_assert (m_eedge->m_custom_info.get () == m_rewind_info);
    1037                 :          30 : }
    1038                 :             : 
    1039                 :             : /* class rewind_from_longjmp_event : public rewind_event.  */
    1040                 :             : 
    1041                 :             : /* Implementation of diagnostic_event::print_desc vfunc for
    1042                 :             :    rewind_from_longjmp_event.  */
    1043                 :             : 
    1044                 :             : void
    1045                 :          30 : rewind_from_longjmp_event::print_desc (pretty_printer &pp) const
    1046                 :             : {
    1047                 :          30 :   const char *src_name
    1048                 :          30 :     = get_user_facing_name (m_rewind_info->get_longjmp_call ());
    1049                 :             : 
    1050                 :          30 :   if (get_longjmp_caller () == get_setjmp_caller ())
    1051                 :             :     /* Special-case: purely intraprocedural rewind.  */
    1052                 :           8 :     pp_printf (&pp,
    1053                 :             :                "rewinding within %qE from %qs...",
    1054                 :             :                get_longjmp_caller (),
    1055                 :             :                src_name);
    1056                 :             :   else
    1057                 :          22 :     pp_printf (&pp,
    1058                 :             :                "rewinding from %qs in %qE...",
    1059                 :             :                src_name,
    1060                 :             :                get_longjmp_caller ());
    1061                 :          30 : }
    1062                 :             : 
    1063                 :             : /* class rewind_to_setjmp_event : public rewind_event.  */
    1064                 :             : 
    1065                 :             : /* Implementation of diagnostic_event::print_desc vfunc for
    1066                 :             :    rewind_to_setjmp_event.  */
    1067                 :             : 
    1068                 :             : void
    1069                 :          30 : rewind_to_setjmp_event::print_desc (pretty_printer &pp) const
    1070                 :             : {
    1071                 :          30 :   const char *dst_name
    1072                 :          30 :     = get_user_facing_name (m_rewind_info->get_setjmp_call ());
    1073                 :             : 
    1074                 :             :   /* If we can, identify the ID of the setjmp_event.  */
    1075                 :          30 :   if (m_original_setjmp_event_id.known_p ())
    1076                 :             :     {
    1077                 :          15 :       if (get_longjmp_caller () == get_setjmp_caller ())
    1078                 :             :         /* Special-case: purely intraprocedural rewind.  */
    1079                 :           4 :         pp_printf (&pp,
    1080                 :             :                    "...to %qs (saved at %@)",
    1081                 :             :                    dst_name,
    1082                 :             :                    &m_original_setjmp_event_id);
    1083                 :             :       else
    1084                 :          11 :         pp_printf (&pp,
    1085                 :             :                    "...to %qs in %qE (saved at %@)",
    1086                 :             :                    dst_name,
    1087                 :             :                    get_setjmp_caller (),
    1088                 :             :                    &m_original_setjmp_event_id);
    1089                 :             :     }
    1090                 :             :   else
    1091                 :             :     {
    1092                 :          15 :       if (get_longjmp_caller () == get_setjmp_caller ())
    1093                 :             :         /* Special-case: purely intraprocedural rewind.  */
    1094                 :           4 :         pp_printf (&pp,
    1095                 :             :                    "...to %qs",
    1096                 :             :                    dst_name);
    1097                 :             :       else
    1098                 :          11 :         pp_printf (&pp,
    1099                 :             :                    "...to %qs in %qE",
    1100                 :             :                    dst_name,
    1101                 :             :                    get_setjmp_caller ());
    1102                 :             :     }
    1103                 :          30 : }
    1104                 :             : 
    1105                 :             : /* Implementation of checker_event::prepare_for_emission vfunc for
    1106                 :             :    rewind_to_setjmp_event.
    1107                 :             : 
    1108                 :             :    Attempt to look up the setjmp event ID that recorded the jmp_buf
    1109                 :             :    for this rewind.  */
    1110                 :             : 
    1111                 :             : void
    1112                 :          15 : rewind_to_setjmp_event::prepare_for_emission (checker_path *path,
    1113                 :             :                                               pending_diagnostic *pd,
    1114                 :             :                                               diagnostic_event_id_t emission_id)
    1115                 :             : {
    1116                 :          15 :   checker_event::prepare_for_emission (path, pd, emission_id);
    1117                 :          15 :   path->get_setjmp_event (m_rewind_info->get_enode_origin (),
    1118                 :             :                           &m_original_setjmp_event_id);
    1119                 :          15 : }
    1120                 :             : 
    1121                 :             : /* class warning_event : public checker_event.  */
    1122                 :             : 
    1123                 :             : /* Implementation of diagnostic_event::print_desc vfunc for
    1124                 :             :    warning_event.
    1125                 :             : 
    1126                 :             :    If the pending diagnostic implements describe_final_event, use it,
    1127                 :             :    generating a precise description e.g.
    1128                 :             :      "second 'free' here; first 'free' was at (7)"
    1129                 :             : 
    1130                 :             :    Otherwise generate a generic description.  */
    1131                 :             : 
    1132                 :             : void
    1133                 :        7626 : warning_event::print_desc (pretty_printer &pp) const
    1134                 :             : {
    1135                 :        7626 :   if (m_pending_diagnostic)
    1136                 :             :     {
    1137                 :        7626 :       tree var = fixup_tree_for_diagnostic (m_var);
    1138                 :        7626 :       evdesc::final_event evd (var, m_state, *this);
    1139                 :        7626 :       if (m_pending_diagnostic->describe_final_event (pp, evd))
    1140                 :             :         {
    1141                 :        7244 :           if (m_sm && flag_analyzer_verbose_state_changes)
    1142                 :             :             {
    1143                 :          72 :               if (var)
    1144                 :          64 :                 pp_printf (&pp, " (%qE is in state %qs)",
    1145                 :          64 :                            var, m_state->get_name ());
    1146                 :             :               else
    1147                 :           8 :                 pp_printf (&pp, " (in global state %qs)",
    1148                 :           8 :                            m_state->get_name ());
    1149                 :             :             }
    1150                 :        7244 :           return;
    1151                 :             :         }
    1152                 :             :     }
    1153                 :             : 
    1154                 :         382 :   if (m_sm)
    1155                 :             :     {
    1156                 :          64 :       if (m_var)
    1157                 :          64 :         pp_printf (&pp, "here (%qE is in state %qs)",
    1158                 :          64 :                    m_var, m_state->get_name ());
    1159                 :             :       else
    1160                 :           0 :         pp_printf (&pp, "here (in global state %qs)",
    1161                 :           0 :                    m_state->get_name ());
    1162                 :          64 :       return;
    1163                 :             :     }
    1164                 :             :   else
    1165                 :         318 :     pp_string (&pp, "here");
    1166                 :             : }
    1167                 :             : 
    1168                 :             : /* Implementation of diagnostic_event::get_meaning vfunc for
    1169                 :             :    warning_event.  */
    1170                 :             : 
    1171                 :             : diagnostic_event::meaning
    1172                 :         216 : warning_event::get_meaning () const
    1173                 :             : {
    1174                 :         216 :   return meaning (VERB_danger, NOUN_unknown);
    1175                 :             : }
    1176                 :             : 
    1177                 :             : } // namespace ana
    1178                 :             : 
    1179                 :             : #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.