LCOV - code coverage report
Current view: top level - gcc/analyzer - checker-path.cc (source / functions) Hit Total Coverage
Test: gcc.info Lines: 235 332 70.8 %
Date: 2020-03-28 11:57:23 Functions: 32 38 84.2 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Subclasses of diagnostic_path and diagnostic_event for analyzer diagnostics.
       2                 :            :    Copyright (C) 2019-2020 Free Software Foundation, Inc.
       3                 :            :    Contributed by David Malcolm <dmalcolm@redhat.com>.
       4                 :            : 
       5                 :            : This file is part of GCC.
       6                 :            : 
       7                 :            : GCC is free software; you can redistribute it and/or modify it
       8                 :            : under the terms of the GNU General Public License as published by
       9                 :            : the Free Software Foundation; either version 3, or (at your option)
      10                 :            : any later version.
      11                 :            : 
      12                 :            : GCC is distributed in the hope that it will be useful, but
      13                 :            : WITHOUT ANY WARRANTY; without even the implied warranty of
      14                 :            : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15                 :            : General Public License for more details.
      16                 :            : 
      17                 :            : You should have received a copy of the GNU General Public License
      18                 :            : along with GCC; see the file COPYING3.  If not see
      19                 :            : <http://www.gnu.org/licenses/>.  */
      20                 :            : 
      21                 :            : #include "config.h"
      22                 :            : #include "system.h"
      23                 :            : #include "coretypes.h"
      24                 :            : #include "tree.h"
      25                 :            : #include "function.h"
      26                 :            : #include "basic-block.h"
      27                 :            : #include "gimple.h"
      28                 :            : #include "gimple-pretty-print.h"
      29                 :            : #include "fold-const.h"
      30                 :            : #include "function.h"
      31                 :            : #include "diagnostic-path.h"
      32                 :            : #include "options.h"
      33                 :            : #include "cgraph.h"
      34                 :            : #include "function.h"
      35                 :            : #include "cfg.h"
      36                 :            : #include "digraph.h"
      37                 :            : #include "alloc-pool.h"
      38                 :            : #include "fibonacci_heap.h"
      39                 :            : #include "diagnostic-event-id.h"
      40                 :            : #include "shortest-paths.h"
      41                 :            : #include "analyzer/analyzer.h"
      42                 :            : #include "analyzer/analyzer-logging.h"
      43                 :            : #include "analyzer/sm.h"
      44                 :            : #include "sbitmap.h"
      45                 :            : #include "tristate.h"
      46                 :            : #include "ordered-hash-map.h"
      47                 :            : #include "selftest.h"
      48                 :            : #include "analyzer/region-model.h"
      49                 :            : #include "analyzer/program-state.h"
      50                 :            : #include "analyzer/checker-path.h"
      51                 :            : #include "gimple-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/diagnostic-manager.h"
      57                 :            : #include "analyzer/checker-path.h"
      58                 :            : #include "analyzer/call-string.h"
      59                 :            : #include "analyzer/program-point.h"
      60                 :            : #include "analyzer/exploded-graph.h"
      61                 :            : 
      62                 :            : #if ENABLE_ANALYZER
      63                 :            : 
      64                 :            : namespace ana {
      65                 :            : 
      66                 :            : /* Get a string for EK.  */
      67                 :            : 
      68                 :            : const char *
      69                 :          0 : event_kind_to_string (enum event_kind ek)
      70                 :            : {
      71                 :          0 :   switch (ek)
      72                 :            :     {
      73                 :          0 :     default:
      74                 :          0 :       gcc_unreachable ();
      75                 :            :     case EK_DEBUG:
      76                 :            :       return "EK_DEBUG";
      77                 :          0 :     case EK_CUSTOM:
      78                 :          0 :       return "EK_CUSTOM";
      79                 :          0 :     case EK_STMT:
      80                 :          0 :       return "EK_STMT";
      81                 :          0 :     case EK_FUNCTION_ENTRY:
      82                 :          0 :       return "EK_FUNCTION_ENTRY";
      83                 :          0 :     case EK_STATE_CHANGE:
      84                 :          0 :       return "EK_STATE_CHANGE";
      85                 :          0 :     case EK_START_CFG_EDGE:
      86                 :          0 :       return "EK_START_CFG_EDGE";
      87                 :          0 :     case EK_END_CFG_EDGE:
      88                 :          0 :       return "EK_END_CFG_EDGE";
      89                 :          0 :     case EK_CALL_EDGE:
      90                 :          0 :       return "EK_CALL_EDGE";
      91                 :          0 :     case EK_RETURN_EDGE:
      92                 :          0 :       return "EK_RETURN_EDGE";
      93                 :          0 :     case EK_SETJMP:
      94                 :          0 :       return "EK_SETJMP";
      95                 :          0 :     case EK_REWIND_FROM_LONGJMP:
      96                 :          0 :       return "EK_REWIND_FROM_LONGJMP";
      97                 :          0 :     case EK_REWIND_TO_SETJMP:
      98                 :          0 :       return "EK_REWIND_TO_SETJMP";
      99                 :          0 :     case EK_WARNING:
     100                 :          0 :       return "EK_WARNING";
     101                 :            :     }
     102                 :            : }
     103                 :            : 
     104                 :            : /* class checker_event : public diagnostic_event.  */
     105                 :            : 
     106                 :            : /* Dump this event to PP (for debugging/logging purposes).  */
     107                 :            : 
     108                 :            : void
     109                 :          0 : checker_event::dump (pretty_printer *pp) const
     110                 :            : {
     111                 :          0 :   label_text event_desc (get_desc (false));
     112                 :          0 :   pp_printf (pp, "\"%s\" (depth %i, m_loc=%x)",
     113                 :            :              event_desc.m_buffer,
     114                 :            :              get_stack_depth (),
     115                 :            :              get_location ());
     116                 :          0 :   event_desc.maybe_free ();
     117                 :          0 : }
     118                 :            : 
     119                 :            : /* Hook for being notified when this event has its final id EMISSION_ID
     120                 :            :    and is about to emitted for PD.
     121                 :            : 
     122                 :            :    Base implementation of checker_event::prepare_for_emission vfunc;
     123                 :            :    subclasses that override this should chain up to it.
     124                 :            : 
     125                 :            :    Record PD and EMISSION_ID, and call the get_desc vfunc, so that any
     126                 :            :    side-effects of the call to get_desc take place before
     127                 :            :    pending_diagnostic::emit is called.
     128                 :            : 
     129                 :            :    For example, state_change_event::get_desc can call
     130                 :            :    pending_diagnostic::describe_state_change; free_of_non_heap can use this
     131                 :            :    to tweak the message (TODO: would be neater to simply capture the
     132                 :            :    pertinent data within the sm-state).  */
     133                 :            : 
     134                 :            : void
     135                 :       1384 : checker_event::prepare_for_emission (checker_path *,
     136                 :            :                                      pending_diagnostic *pd,
     137                 :            :                                      diagnostic_event_id_t emission_id)
     138                 :            : {
     139                 :       1384 :   m_pending_diagnostic = pd;
     140                 :       1384 :   m_emission_id = emission_id;
     141                 :            : 
     142                 :       1384 :   label_text desc = get_desc (false);
     143                 :       1384 :   desc.maybe_free ();
     144                 :       1384 : }
     145                 :            : 
     146                 :            : /* class debug_event : public checker_event.  */
     147                 :            : 
     148                 :            : /* Implementation of diagnostic_event::get_desc vfunc for
     149                 :            :    debug_event.
     150                 :            :    Use the saved string as the event's description.  */
     151                 :            : 
     152                 :            : label_text
     153                 :          0 : debug_event::get_desc (bool) const
     154                 :            : {
     155                 :          0 :   return label_text::borrow (m_desc);
     156                 :            : }
     157                 :            : 
     158                 :            : /* class custom_event : public checker_event.  */
     159                 :            : 
     160                 :            : /* Implementation of diagnostic_event::get_desc vfunc for
     161                 :            :    custom_event.
     162                 :            :    Use the saved string as the event's description.  */
     163                 :            : 
     164                 :            : label_text
     165                 :         16 : custom_event::get_desc (bool) const
     166                 :            : {
     167                 :         16 :   return label_text::borrow (m_desc);
     168                 :            : }
     169                 :            : 
     170                 :            : /* class statement_event : public checker_event.  */
     171                 :            : 
     172                 :            : /* statement_event's ctor.  */
     173                 :            : 
     174                 :       1334 : statement_event::statement_event (const gimple *stmt, tree fndecl, int depth,
     175                 :       1334 :                                   const program_state &dst_state)
     176                 :            : : checker_event (EK_STMT, gimple_location (stmt), fndecl, depth),
     177                 :            :   m_stmt (stmt),
     178                 :       1334 :   m_dst_state (dst_state)
     179                 :            : {
     180                 :       1334 : }
     181                 :            : 
     182                 :            : /* Implementation of diagnostic_event::get_desc vfunc for
     183                 :            :    statement_event.
     184                 :            :    Use the statement's dump form as the event's description.  */
     185                 :            : 
     186                 :            : label_text
     187                 :          0 : statement_event::get_desc (bool) const
     188                 :            : {
     189                 :          0 :   pretty_printer pp;
     190                 :          0 :   pp_string (&pp, "stmt: ");
     191                 :          0 :   pp_gimple_stmt_1 (&pp, m_stmt, 0, (dump_flags_t)0);
     192                 :          0 :   return label_text::take (xstrdup (pp_formatted_text (&pp)));
     193                 :            : }
     194                 :            : 
     195                 :            : /* class function_entry_event : public checker_event.  */
     196                 :            : 
     197                 :            : /* Implementation of diagnostic_event::get_desc vfunc for
     198                 :            :    function_entry_event.
     199                 :            : 
     200                 :            :    Use a string such as "entry to 'foo'" as the event's description.  */
     201                 :            : 
     202                 :            : label_text
     203                 :        385 : function_entry_event::get_desc (bool can_colorize) const
     204                 :            : {
     205                 :        385 :   return make_label_text (can_colorize, "entry to %qE", m_fndecl);
     206                 :            : }
     207                 :            : 
     208                 :            : /* class state_change_event : public checker_event.  */
     209                 :            : 
     210                 :            : /* state_change_event's ctor.  */
     211                 :            : 
     212                 :        815 : state_change_event::state_change_event (const supernode *node,
     213                 :            :                                         const gimple *stmt,
     214                 :            :                                         int stack_depth,
     215                 :            :                                         const state_machine &sm,
     216                 :            :                                         tree var,
     217                 :            :                                         state_machine::state_t from,
     218                 :            :                                         state_machine::state_t to,
     219                 :            :                                         tree origin,
     220                 :        815 :                                         const program_state &dst_state)
     221                 :            : : checker_event (EK_STATE_CHANGE,
     222                 :        815 :                  stmt->location, node->m_fun->decl,
     223                 :            :                  stack_depth),
     224                 :            :   m_node (node), m_stmt (stmt), m_sm (sm),
     225                 :            :   m_var (var), m_from (from), m_to (to),
     226                 :            :   m_origin (origin),
     227                 :        815 :   m_dst_state (dst_state)
     228                 :            : {
     229                 :        815 : }
     230                 :            : 
     231                 :            : /* Implementation of diagnostic_event::get_desc vfunc for
     232                 :            :    state_change_event.
     233                 :            : 
     234                 :            :    Attempt to generate a nicer human-readable description.
     235                 :            :    For greatest precision-of-wording, give the pending diagnostic
     236                 :            :    a chance to describe this state change (in terms of the
     237                 :            :    diagnostic).
     238                 :            :    Note that we only have a pending_diagnostic set on the event once
     239                 :            :    the diagnostic is about to being emitted, so the description for
     240                 :            :    an event can change.  */
     241                 :            : 
     242                 :            : label_text
     243                 :        697 : state_change_event::get_desc (bool can_colorize) const
     244                 :            : {
     245                 :        697 :   if (m_pending_diagnostic)
     246                 :            :     {
     247                 :        697 :       label_text custom_desc
     248                 :            :         = m_pending_diagnostic->describe_state_change
     249                 :       1394 :             (evdesc::state_change (can_colorize, m_var, m_origin,
     250                 :        697 :                                    m_from, m_to, m_emission_id, *this));
     251                 :        697 :       if (custom_desc.m_buffer)
     252                 :            :         {
     253                 :        654 :           if (flag_analyzer_verbose_state_changes)
     254                 :            :             {
     255                 :            :               /* Append debug version.  */
     256                 :          4 :               label_text result;
     257                 :          4 :               if (m_origin)
     258                 :          0 :                 result = make_label_text
     259                 :          0 :                   (can_colorize,
     260                 :            :                    "%s (state of %qE: %qs -> %qs, origin: %qE)",
     261                 :            :                    custom_desc.m_buffer,
     262                 :          0 :                    m_var,
     263                 :          0 :                    m_sm.get_state_name (m_from),
     264                 :          0 :                    m_sm.get_state_name (m_to),
     265                 :          0 :                    m_origin);
     266                 :            :               else
     267                 :          8 :                 result = make_label_text
     268                 :          4 :                   (can_colorize,
     269                 :            :                    "%s (state of %qE: %qs -> %qs, origin: NULL)",
     270                 :            :                    custom_desc.m_buffer,
     271                 :          4 :                    m_var,
     272                 :          4 :                    m_sm.get_state_name (m_from),
     273                 :          4 :                    m_sm.get_state_name (m_to));
     274                 :          4 :               custom_desc.maybe_free ();
     275                 :          4 :               return result;
     276                 :            :             }
     277                 :            :           else
     278                 :        650 :             return custom_desc;
     279                 :            :         }
     280                 :            :     }
     281                 :            : 
     282                 :            :   /* Fallback description.  */
     283                 :         43 :   if (m_var)
     284                 :            :     {
     285                 :         43 :       if (m_origin)
     286                 :          0 :         return make_label_text
     287                 :            :           (can_colorize,
     288                 :            :            "state of %qE: %qs -> %qs (origin: %qE)",
     289                 :          0 :            m_var,
     290                 :          0 :            m_sm.get_state_name (m_from),
     291                 :          0 :            m_sm.get_state_name (m_to),
     292                 :          0 :            m_origin);
     293                 :            :       else
     294                 :         43 :         return make_label_text
     295                 :            :           (can_colorize,
     296                 :            :            "state of %qE: %qs -> %qs (origin: NULL)",
     297                 :         43 :            m_var,
     298                 :         43 :            m_sm.get_state_name (m_from),
     299                 :         43 :            m_sm.get_state_name (m_to));
     300                 :            :     }
     301                 :            :   else
     302                 :            :     {
     303                 :          0 :       gcc_assert (m_origin == NULL_TREE);
     304                 :          0 :       return make_label_text
     305                 :            :         (can_colorize,
     306                 :            :          "global state: %qs -> %qs",
     307                 :          0 :          m_sm.get_state_name (m_from),
     308                 :          0 :          m_sm.get_state_name (m_to));
     309                 :            :     }
     310                 :            : }
     311                 :            : 
     312                 :            : /* class superedge_event : public checker_event.  */
     313                 :            : 
     314                 :            : /* Get the callgraph_superedge for this superedge_event, which must be
     315                 :            :    for an interprocedural edge, rather than a CFG edge.  */
     316                 :            : 
     317                 :            : const callgraph_superedge&
     318                 :        231 : superedge_event::get_callgraph_superedge () const
     319                 :            : {
     320                 :        231 :   gcc_assert (m_sedge->m_kind != SUPEREDGE_CFG_EDGE);
     321                 :        231 :   return *m_sedge->dyn_cast_callgraph_superedge ();
     322                 :            : }
     323                 :            : 
     324                 :            : /* Determine if this event should be filtered at the given verbosity
     325                 :            :    level.  */
     326                 :            : 
     327                 :            : bool
     328                 :        956 : superedge_event::should_filter_p (int verbosity) const
     329                 :            : {
     330                 :        956 :   switch (m_sedge->m_kind)
     331                 :            :     {
     332                 :        956 :     case SUPEREDGE_CFG_EDGE:
     333                 :        956 :       {
     334                 :        956 :         if (verbosity < 2)
     335                 :            :           return true;
     336                 :            : 
     337                 :        912 :         if (verbosity < 4)
     338                 :            :           {
     339                 :            :             /* Filter events with empty descriptions.  This ought to filter
     340                 :            :                FALLTHRU, but retain true/false/switch edges.  */
     341                 :        912 :             label_text desc = get_desc (false);
     342                 :        912 :             gcc_assert (desc.m_buffer);
     343                 :        912 :             if (desc.m_buffer[0] == '\0')
     344                 :        755 :               return true;
     345                 :        157 :             desc.maybe_free ();
     346                 :            :           }
     347                 :            :       }
     348                 :            :       break;
     349                 :            : 
     350                 :            :     default:
     351                 :            :       break;
     352                 :            :     }
     353                 :            :   return false;
     354                 :            : }
     355                 :            : 
     356                 :            : /* superedge_event's ctor.  */
     357                 :            : 
     358                 :       2148 : superedge_event::superedge_event (enum event_kind kind,
     359                 :            :                                   const exploded_edge &eedge,
     360                 :       2148 :                                   location_t loc, tree fndecl, int depth)
     361                 :            : : checker_event (kind, loc, fndecl, depth),
     362                 :       2148 :   m_eedge (eedge), m_sedge (eedge.m_sedge),
     363                 :       2148 :   m_var (NULL_TREE), m_critical_state (0)
     364                 :            : {
     365                 :       2148 : }
     366                 :            : 
     367                 :            : /* class cfg_edge_event : public superedge_event.  */
     368                 :            : 
     369                 :            : /* Get the cfg_superedge for this cfg_edge_event.  */
     370                 :            : 
     371                 :            : const cfg_superedge &
     372                 :       1415 : cfg_edge_event::get_cfg_superedge () const
     373                 :            : {
     374                 :       1415 :   return *m_sedge->dyn_cast_cfg_superedge ();
     375                 :            : }
     376                 :            : 
     377                 :            : /* cfg_edge_event's ctor.  */
     378                 :            : 
     379                 :       1912 : cfg_edge_event::cfg_edge_event (enum event_kind kind,
     380                 :            :                                 const exploded_edge &eedge,
     381                 :       1912 :                                 location_t loc, tree fndecl, int depth)
     382                 :       1912 : : superedge_event (kind, eedge, loc, fndecl, depth)
     383                 :            : {
     384                 :       1912 :   gcc_assert (eedge.m_sedge->m_kind == SUPEREDGE_CFG_EDGE);
     385                 :       1912 : }
     386                 :            : 
     387                 :            : /* class start_cfg_edge_event : public cfg_edge_event.  */
     388                 :            : 
     389                 :            : /* Implementation of diagnostic_event::get_desc vfunc for
     390                 :            :    start_cfg_edge_event.
     391                 :            : 
     392                 :            :    If -fanalyzer-verbose-edges, then generate low-level descriptions, such
     393                 :            :    as
     394                 :            :      "taking 'true' edge SN:7 -> SN:8".
     395                 :            : 
     396                 :            :    Otherwise, generate strings using the label of the underlying CFG if
     397                 :            :    any, such as:
     398                 :            :      "following 'true' branch..." or
     399                 :            :      "following 'case 3' branch..."
     400                 :            :      "following 'default' branch..."
     401                 :            : 
     402                 :            :    For conditionals, attempt to supply a description of the condition that
     403                 :            :    holds, such as:
     404                 :            :      "following 'false' branch (when 'ptr' is non-NULL)..."
     405                 :            : 
     406                 :            :    Failing that, return an empty description (which will lead to this event
     407                 :            :    being filtered).  */
     408                 :            : 
     409                 :            : label_text
     410                 :       1214 : start_cfg_edge_event::get_desc (bool can_colorize) const
     411                 :            : {
     412                 :       1214 :   bool user_facing = !flag_analyzer_verbose_edges;
     413                 :       1214 :   char *edge_desc = m_sedge->get_description (user_facing);
     414                 :       1214 :   if (user_facing)
     415                 :            :     {
     416                 :       1214 :       if (edge_desc && strlen (edge_desc) > 0)
     417                 :            :         {
     418                 :        459 :           label_text cond_desc = maybe_describe_condition (can_colorize);
     419                 :        459 :           label_text result;
     420                 :        459 :           if (cond_desc.m_buffer)
     421                 :            :             {
     422                 :        600 :               result = make_label_text (can_colorize,
     423                 :            :                                         "following %qs branch (%s)...",
     424                 :        300 :                                         edge_desc, cond_desc.m_buffer);
     425                 :        300 :               cond_desc.maybe_free ();
     426                 :            :             }
     427                 :            :           else
     428                 :            :             {
     429                 :        159 :               result = make_label_text (can_colorize,
     430                 :            :                                         "following %qs branch...",
     431                 :        159 :                                         edge_desc);
     432                 :            :             }
     433                 :        459 :           free (edge_desc);
     434                 :        459 :           return result;
     435                 :            :         }
     436                 :            :       else
     437                 :            :         {
     438                 :        755 :           free (edge_desc);
     439                 :        755 :           return label_text::borrow ("");
     440                 :            :         }
     441                 :            :     }
     442                 :            :   else
     443                 :            :     {
     444                 :          0 :       if (strlen (edge_desc) > 0)
     445                 :            :         {
     446                 :          0 :           label_text result
     447                 :            :             = make_label_text (can_colorize,
     448                 :            :                                "taking %qs edge SN:%i -> SN:%i",
     449                 :            :                                edge_desc,
     450                 :          0 :                                m_sedge->m_src->m_index,
     451                 :          0 :                                m_sedge->m_dest->m_index);
     452                 :          0 :           free (edge_desc);
     453                 :          0 :           return result;
     454                 :            :         }
     455                 :            :       else
     456                 :            :         {
     457                 :          0 :           free (edge_desc);
     458                 :          0 :           return make_label_text (can_colorize,
     459                 :            :                                   "taking edge SN:%i -> SN:%i",
     460                 :          0 :                                   m_sedge->m_src->m_index,
     461                 :          0 :                                   m_sedge->m_dest->m_index);
     462                 :            :         }
     463                 :            :     }
     464                 :            : }
     465                 :            : 
     466                 :            : /* Attempt to generate a description of any condition that holds at this edge.
     467                 :            : 
     468                 :            :    The intent is to make the user-facing messages more clear, especially for
     469                 :            :    cases where there's a single or double-negative, such as
     470                 :            :    when describing the false branch of an inverted condition.
     471                 :            : 
     472                 :            :    For example, rather than printing just:
     473                 :            : 
     474                 :            :       |  if (!ptr)
     475                 :            :       |     ~
     476                 :            :       |     |
     477                 :            :       |     (1) following 'false' branch...
     478                 :            : 
     479                 :            :    it's clearer to spell out the condition that holds:
     480                 :            : 
     481                 :            :       |  if (!ptr)
     482                 :            :       |     ~
     483                 :            :       |     |
     484                 :            :       |     (1) following 'false' branch (when 'ptr' is non-NULL)...
     485                 :            :                                           ^^^^^^^^^^^^^^^^^^^^^^
     486                 :            : 
     487                 :            :    In the above example, this function would generate the highlighted
     488                 :            :    string: "when 'ptr' is non-NULL".
     489                 :            : 
     490                 :            :    If the edge is not a condition, or it's not clear that a description of
     491                 :            :    the condition would be helpful to the user, return NULL.  */
     492                 :            : 
     493                 :            : label_text
     494                 :        459 : start_cfg_edge_event::maybe_describe_condition (bool can_colorize) const
     495                 :            : {
     496                 :        459 :   const cfg_superedge& cfg_sedge = get_cfg_superedge ();
     497                 :            : 
     498                 :        459 :   if (cfg_sedge.true_value_p () || cfg_sedge.false_value_p ())
     499                 :            :     {
     500                 :        447 :       const gimple *last_stmt = m_sedge->m_src->get_last_stmt ();
     501                 :        447 :       if (const gcond *cond_stmt = dyn_cast <const gcond *> (last_stmt))
     502                 :            :         {
     503                 :        447 :           enum tree_code op = gimple_cond_code (cond_stmt);
     504                 :        447 :           tree lhs = gimple_cond_lhs (cond_stmt);
     505                 :        447 :           tree rhs = gimple_cond_rhs (cond_stmt);
     506                 :        447 :           if (cfg_sedge.false_value_p ())
     507                 :        186 :             op = invert_tree_comparison (op, false /* honor_nans */);
     508                 :        447 :           return maybe_describe_condition (can_colorize,
     509                 :        447 :                                            lhs, op, rhs);
     510                 :            :         }
     511                 :            :     }
     512                 :         12 :   return label_text::borrow (NULL);
     513                 :            : }
     514                 :            : 
     515                 :            : /* Subroutine of maybe_describe_condition above.
     516                 :            : 
     517                 :            :    Attempt to generate a user-facing description of the condition
     518                 :            :    LHS OP RHS, but only if it is likely to make it easier for the
     519                 :            :    user to understand a condition.  */
     520                 :            : 
     521                 :            : label_text
     522                 :        447 : start_cfg_edge_event::maybe_describe_condition (bool can_colorize,
     523                 :            :                                                 tree lhs,
     524                 :            :                                                 enum tree_code op,
     525                 :            :                                                 tree rhs)
     526                 :            : {
     527                 :            :   /* In theory we could just build a tree via
     528                 :            :        fold_build2 (op, boolean_type_node, lhs, rhs)
     529                 :            :      and print it with %qE on it, but this leads to warts such as
     530                 :            :      parenthesizing vars, such as '(i) <= 9', and uses of '<unknown>'.  */
     531                 :            : 
     532                 :            :   /* Special-case: describe testing the result of strcmp, as figuring
     533                 :            :      out what the "true" or "false" path is can be confusing to the user.  */
     534                 :        447 :   if (TREE_CODE (lhs) == SSA_NAME
     535                 :        447 :       && zerop (rhs))
     536                 :            :     {
     537                 :        368 :       if (gcall *call = dyn_cast <gcall *> (SSA_NAME_DEF_STMT (lhs)))
     538                 :        132 :         if (is_special_named_call_p (call, "strcmp", 2))
     539                 :            :           {
     540                 :         12 :             if (op == EQ_EXPR)
     541                 :          9 :               return label_text::borrow ("when the strings are equal");
     542                 :          3 :             if (op == NE_EXPR)
     543                 :          3 :               return label_text::borrow ("when the strings are non-equal");
     544                 :            :           }
     545                 :            :     }
     546                 :            : 
     547                 :            :   /* Only attempt to generate text for sufficiently simple expressions.  */
     548                 :        435 :   if (!should_print_expr_p (lhs))
     549                 :        147 :     return label_text::borrow (NULL);
     550                 :        288 :   if (!should_print_expr_p (rhs))
     551                 :          0 :     return label_text::borrow (NULL);
     552                 :            : 
     553                 :            :   /* Special cases for pointer comparisons against NULL.  */
     554                 :        486 :   if (POINTER_TYPE_P (TREE_TYPE (lhs))
     555                 :         90 :       && POINTER_TYPE_P (TREE_TYPE (rhs))
     556                 :        378 :       && zerop (rhs))
     557                 :            :     {
     558                 :         90 :       if (op == EQ_EXPR)
     559                 :         33 :         return make_label_text (can_colorize, "when %qE is NULL",
     560                 :         33 :                                 lhs);
     561                 :         57 :       if (op == NE_EXPR)
     562                 :         57 :         return make_label_text (can_colorize, "when %qE is non-NULL",
     563                 :         57 :                                 lhs);
     564                 :            :     }
     565                 :            : 
     566                 :        198 :   return make_label_text (can_colorize, "when %<%E %s %E%>",
     567                 :        198 :                           lhs, op_symbol_code (op), rhs);
     568                 :            : }
     569                 :            : 
     570                 :            : /* Subroutine of maybe_describe_condition.
     571                 :            : 
     572                 :            :    Return true if EXPR is we will get suitable user-facing output
     573                 :            :    from %E on it.  */
     574                 :            : 
     575                 :            : bool
     576                 :        723 : start_cfg_edge_event::should_print_expr_p (tree expr)
     577                 :            : {
     578                 :       1017 :   if (TREE_CODE (expr) == SSA_NAME)
     579                 :            :     {
     580                 :        441 :       if (SSA_NAME_VAR (expr))
     581                 :       1017 :         return should_print_expr_p (SSA_NAME_VAR (expr));
     582                 :            :       else
     583                 :            :         return false;
     584                 :            :     }
     585                 :            : 
     586                 :        576 :   if (DECL_P (expr))
     587                 :            :     return true;
     588                 :            : 
     589                 :        282 :   if (CONSTANT_CLASS_P (expr))
     590                 :        282 :     return true;
     591                 :            : 
     592                 :            :   return false;
     593                 :            : }
     594                 :            : 
     595                 :            : /* class call_event : public superedge_event.  */
     596                 :            : 
     597                 :            : /* call_event's ctor.  */
     598                 :            : 
     599                 :        149 : call_event::call_event (const exploded_edge &eedge,
     600                 :        149 :                         location_t loc, tree fndecl, int depth)
     601                 :        149 : : superedge_event (EK_CALL_EDGE, eedge, loc, fndecl, depth)
     602                 :            : {
     603                 :        149 :   gcc_assert (eedge.m_sedge->m_kind == SUPEREDGE_CALL);
     604                 :        149 : }
     605                 :            : 
     606                 :            : /* Implementation of diagnostic_event::get_desc vfunc for
     607                 :            :    call_event.
     608                 :            : 
     609                 :            :    If this call event passes critical state for an sm-based warning,
     610                 :            :    allow the diagnostic to generate a precise description, such as:
     611                 :            : 
     612                 :            :      "passing freed pointer 'ptr' in call to 'foo' from 'bar'"
     613                 :            : 
     614                 :            :    Otherwise, generate a description of the form
     615                 :            :    "calling 'foo' from 'bar'".  */
     616                 :            : 
     617                 :            : label_text
     618                 :        226 : call_event::get_desc (bool can_colorize) const
     619                 :            : {
     620                 :        226 :   if (m_critical_state && m_pending_diagnostic)
     621                 :            :     {
     622                 :         83 :       gcc_assert (m_var);
     623                 :         83 :       label_text custom_desc
     624                 :            :         = m_pending_diagnostic->describe_call_with_state
     625                 :        166 :             (evdesc::call_with_state (can_colorize,
     626                 :         83 :                                       m_sedge->m_src->m_fun->decl,
     627                 :         83 :                                       m_sedge->m_dest->m_fun->decl,
     628                 :            :                                       m_var,
     629                 :         83 :                                       m_critical_state));
     630                 :         83 :       if (custom_desc.m_buffer)
     631                 :         48 :         return custom_desc;
     632                 :            :     }
     633                 :            : 
     634                 :        178 :   return make_label_text (can_colorize,
     635                 :            :                           "calling %qE from %qE",
     636                 :        178 :                           m_sedge->m_dest->m_fun->decl,
     637                 :        178 :                           m_sedge->m_src->m_fun->decl);
     638                 :            : }
     639                 :            : 
     640                 :            : /* Override of checker_event::is_call_p for calls.  */
     641                 :            : 
     642                 :            : bool
     643                 :        261 : call_event::is_call_p () const
     644                 :            : {
     645                 :        261 :   return true;
     646                 :            : }
     647                 :            : 
     648                 :            : /* class return_event : public superedge_event.  */
     649                 :            : 
     650                 :            : /* return_event's ctor.  */
     651                 :            : 
     652                 :         87 : return_event::return_event (const exploded_edge &eedge,
     653                 :         87 :                             location_t loc, tree fndecl, int depth)
     654                 :         87 : : superedge_event (EK_RETURN_EDGE, eedge, loc, fndecl, depth)
     655                 :            : {
     656                 :         87 :   gcc_assert (eedge.m_sedge->m_kind == SUPEREDGE_RETURN);
     657                 :         87 : }
     658                 :            : 
     659                 :            : /* Implementation of diagnostic_event::get_desc vfunc for
     660                 :            :    return_event.
     661                 :            : 
     662                 :            :    If this return event returns critical state for an sm-based warning,
     663                 :            :    allow the diagnostic to generate a precise description, such as:
     664                 :            : 
     665                 :            :       "possible of NULL to 'foo' from 'bar'"
     666                 :            : 
     667                 :            :    Otherwise, generate a description of the form
     668                 :            :    "returning to 'foo' from 'bar'.  */
     669                 :            : 
     670                 :            : label_text
     671                 :        108 : return_event::get_desc (bool can_colorize) const
     672                 :            : {
     673                 :            :   /*  For greatest precision-of-wording, if this is returning the
     674                 :            :       state involved in the pending diagnostic, give the pending
     675                 :            :       diagnostic a chance to describe this return (in terms of
     676                 :            :       itself).  */
     677                 :        108 :   if (m_critical_state && m_pending_diagnostic)
     678                 :            :     {
     679                 :         36 :       label_text custom_desc
     680                 :            :         = m_pending_diagnostic->describe_return_of_state
     681                 :         72 :             (evdesc::return_of_state (can_colorize,
     682                 :         36 :                                       m_sedge->m_dest->m_fun->decl,
     683                 :         36 :                                       m_sedge->m_src->m_fun->decl,
     684                 :         36 :                                       m_critical_state));
     685                 :         36 :       if (custom_desc.m_buffer)
     686                 :         18 :         return custom_desc;
     687                 :            :     }
     688                 :         90 :   return make_label_text (can_colorize,
     689                 :            :                           "returning to %qE from %qE",
     690                 :         90 :                           m_sedge->m_dest->m_fun->decl,
     691                 :         90 :                           m_sedge->m_src->m_fun->decl);
     692                 :            : }
     693                 :            : 
     694                 :            : /* Override of checker_event::is_return_p for returns.  */
     695                 :            : 
     696                 :            : bool
     697                 :         32 : return_event::is_return_p () const
     698                 :            : {
     699                 :         32 :   return true;
     700                 :            : }
     701                 :            : 
     702                 :            : /* class setjmp_event : public checker_event.  */
     703                 :            : 
     704                 :            : /* Implementation of diagnostic_event::get_desc vfunc for
     705                 :            :    setjmp_event.  */
     706                 :            : 
     707                 :            : label_text
     708                 :         18 : setjmp_event::get_desc (bool can_colorize) const
     709                 :            : {
     710                 :         18 :   return make_label_text (can_colorize,
     711                 :            :                           "%qs called here",
     712                 :         18 :                           get_user_facing_name (m_setjmp_call));
     713                 :            : }
     714                 :            : 
     715                 :            : /* Implementation of checker_event::prepare_for_emission vfunc for setjmp_event.
     716                 :            : 
     717                 :            :    Record this setjmp's event ID into the path, so that rewind events can
     718                 :            :    use it.  */
     719                 :            : 
     720                 :            : void
     721                 :          9 : setjmp_event::prepare_for_emission (checker_path *path,
     722                 :            :                                     pending_diagnostic *pd,
     723                 :            :                                     diagnostic_event_id_t emission_id)
     724                 :            : {
     725                 :          9 :   checker_event::prepare_for_emission (path, pd, emission_id);
     726                 :          9 :   path->record_setjmp_event (m_enode, emission_id);
     727                 :          9 : }
     728                 :            : 
     729                 :            : /* class rewind_event : public checker_event.  */
     730                 :            : 
     731                 :            : /* Get the fndecl containing the site of the longjmp call.  */
     732                 :            : 
     733                 :            : tree
     734                 :         48 : rewind_event::get_longjmp_caller () const
     735                 :            : {
     736                 :         48 :   return m_eedge->m_src->get_function ()->decl;
     737                 :            : }
     738                 :            : 
     739                 :            : /* Get the fndecl containing the site of the setjmp call.  */
     740                 :            : 
     741                 :            : tree
     742                 :         47 : rewind_event::get_setjmp_caller () const
     743                 :            : {
     744                 :         47 :   return m_eedge->m_dest->get_function ()->decl;
     745                 :            : }
     746                 :            : 
     747                 :            : /* rewind_event's ctor.  */
     748                 :            : 
     749                 :         16 : rewind_event::rewind_event (const exploded_edge *eedge,
     750                 :            :                             enum event_kind kind,
     751                 :            :                             location_t loc, tree fndecl, int depth,
     752                 :         16 :                             const rewind_info_t *rewind_info)
     753                 :            : : checker_event (kind, loc, fndecl, depth),
     754                 :            :   m_rewind_info (rewind_info),
     755                 :         16 :   m_eedge (eedge)
     756                 :            : {
     757                 :         16 :   gcc_assert (m_eedge->m_custom_info == m_rewind_info);
     758                 :         16 : }
     759                 :            : 
     760                 :            : /* class rewind_from_longjmp_event : public rewind_event.  */
     761                 :            : 
     762                 :            : /* Implementation of diagnostic_event::get_desc vfunc for
     763                 :            :    rewind_from_longjmp_event.  */
     764                 :            : 
     765                 :            : label_text
     766                 :         16 : rewind_from_longjmp_event::get_desc (bool can_colorize) const
     767                 :            : {
     768                 :         16 :   const char *src_name
     769                 :         16 :     = get_user_facing_name (m_rewind_info->get_longjmp_call ());
     770                 :            : 
     771                 :         16 :   if (get_longjmp_caller () == get_setjmp_caller ())
     772                 :            :     /* Special-case: purely intraprocedural rewind.  */
     773                 :          2 :     return make_label_text (can_colorize,
     774                 :            :                             "rewinding within %qE from %qs...",
     775                 :            :                             get_longjmp_caller (),
     776                 :          2 :                             src_name);
     777                 :            :   else
     778                 :         14 :     return make_label_text (can_colorize,
     779                 :            :                             "rewinding from %qs in %qE...",
     780                 :            :                             src_name,
     781                 :         14 :                             get_longjmp_caller ());
     782                 :            : }
     783                 :            : 
     784                 :            : /* class rewind_to_setjmp_event : public rewind_event.  */
     785                 :            : 
     786                 :            : /* Implementation of diagnostic_event::get_desc vfunc for
     787                 :            :    rewind_to_setjmp_event.  */
     788                 :            : 
     789                 :            : label_text
     790                 :         16 : rewind_to_setjmp_event::get_desc (bool can_colorize) const
     791                 :            : {
     792                 :         16 :   const char *dst_name
     793                 :         16 :     = get_user_facing_name (m_rewind_info->get_setjmp_call ());
     794                 :            : 
     795                 :            :   /* If we can, identify the ID of the setjmp_event.  */
     796                 :         16 :   if (m_original_setjmp_event_id.known_p ())
     797                 :            :     {
     798                 :          8 :       if (get_longjmp_caller () == get_setjmp_caller ())
     799                 :            :         /* Special-case: purely intraprocedural rewind.  */
     800                 :          1 :         return make_label_text (can_colorize,
     801                 :            :                                 "...to %qs (saved at %@)",
     802                 :            :                                 dst_name,
     803                 :          1 :                                 &m_original_setjmp_event_id);
     804                 :            :       else
     805                 :          7 :         return make_label_text (can_colorize,
     806                 :            :                                 "...to %qs in %qE (saved at %@)",
     807                 :            :                                 dst_name,
     808                 :            :                                 get_setjmp_caller (),
     809                 :          7 :                                 &m_original_setjmp_event_id);
     810                 :            :     }
     811                 :            :   else
     812                 :            :     {
     813                 :          8 :       if (get_longjmp_caller () == get_setjmp_caller ())
     814                 :            :         /* Special-case: purely intraprocedural rewind.  */
     815                 :          1 :         return make_label_text (can_colorize,
     816                 :            :                                 "...to %qs",
     817                 :            :                                 dst_name,
     818                 :          1 :                                 get_setjmp_caller ());
     819                 :            :       else
     820                 :          7 :         return make_label_text (can_colorize,
     821                 :            :                                 "...to %qs in %qE",
     822                 :            :                                 dst_name,
     823                 :          7 :                                 get_setjmp_caller ());
     824                 :            :     }
     825                 :            : }
     826                 :            : 
     827                 :            : /* Implementation of checker_event::prepare_for_emission vfunc for
     828                 :            :    rewind_to_setjmp_event.
     829                 :            : 
     830                 :            :    Attempt to look up the setjmp event ID that recorded the jmp_buf
     831                 :            :    for this rewind.  */
     832                 :            : 
     833                 :            : void
     834                 :          8 : rewind_to_setjmp_event::prepare_for_emission (checker_path *path,
     835                 :            :                                               pending_diagnostic *pd,
     836                 :            :                                               diagnostic_event_id_t emission_id)
     837                 :            : {
     838                 :          8 :   checker_event::prepare_for_emission (path, pd, emission_id);
     839                 :          8 :   path->get_setjmp_event (m_rewind_info->get_enode_origin (),
     840                 :            :                           &m_original_setjmp_event_id);
     841                 :          8 : }
     842                 :            : 
     843                 :            : /* class warning_event : public checker_event.  */
     844                 :            : 
     845                 :            : /* Implementation of diagnostic_event::get_desc vfunc for
     846                 :            :    warning_event.
     847                 :            : 
     848                 :            :    If the pending diagnostic implements describe_final_event, use it,
     849                 :            :    generating a precise description e.g.
     850                 :            :      "second 'free' here; first 'free' was at (7)"
     851                 :            : 
     852                 :            :    Otherwise generate a generic description.  */
     853                 :            : 
     854                 :            : label_text
     855                 :        608 : warning_event::get_desc (bool can_colorize) const
     856                 :            : {
     857                 :        608 :   if (m_pending_diagnostic)
     858                 :            :     {
     859                 :        608 :       label_text ev_desc
     860                 :            :         = m_pending_diagnostic->describe_final_event
     861                 :        608 :             (evdesc::final_event (can_colorize, m_var, m_state));
     862                 :        608 :       if (ev_desc.m_buffer)
     863                 :            :         {
     864                 :        556 :           if (m_sm && flag_analyzer_verbose_state_changes)
     865                 :            :             {
     866                 :          4 :               label_text result
     867                 :            :                 = make_label_text (can_colorize,
     868                 :            :                                    "%s (%qE is in state %qs)",
     869                 :            :                                    ev_desc.m_buffer,
     870                 :          4 :                                    m_var,m_sm->get_state_name (m_state));
     871                 :          4 :               ev_desc.maybe_free ();
     872                 :          4 :               return result;
     873                 :            :             }
     874                 :            :           else
     875                 :        552 :             return ev_desc;
     876                 :            :         }
     877                 :            :     }
     878                 :            : 
     879                 :         52 :   if (m_sm)
     880                 :         40 :     return make_label_text (can_colorize,
     881                 :            :                             "here (%qE is in state %qs)",
     882                 :         40 :                             m_var,
     883                 :         40 :                             m_sm->get_state_name (m_state));
     884                 :            :   else
     885                 :         12 :     return label_text::borrow ("here");
     886                 :            : }
     887                 :            : 
     888                 :            : /* Print a single-line representation of this path to PP.  */
     889                 :            : 
     890                 :            : void
     891                 :          0 : checker_path::dump (pretty_printer *pp) const
     892                 :            : {
     893                 :          0 :   pp_character (pp, '[');
     894                 :            : 
     895                 :          0 :   checker_event *e;
     896                 :          0 :   int i;
     897                 :          0 :   FOR_EACH_VEC_ELT (m_events, i, e)
     898                 :            :     {
     899                 :          0 :       if (i > 0)
     900                 :          0 :         pp_string (pp, ", ");
     901                 :          0 :       label_text event_desc (e->get_desc (false));
     902                 :          0 :       pp_printf (pp, "\"%s\"", event_desc.m_buffer);
     903                 :          0 :       event_desc.maybe_free ();
     904                 :            :     }
     905                 :          0 :   pp_character (pp, ']');
     906                 :          0 : }
     907                 :            : 
     908                 :            : /* Print a multiline form of this path to LOGGER, prefixing it with DESC.  */
     909                 :            : 
     910                 :            : void
     911                 :        614 : checker_path::maybe_log (logger *logger, const char *desc) const
     912                 :            : {
     913                 :        614 :   if (!logger)
     914                 :            :     return;
     915                 :          0 :   logger->start_log_line ();
     916                 :          0 :   logger->log_partial ("%s: ", desc);
     917                 :          0 :   dump (logger->get_printer ());
     918                 :          0 :   logger->end_log_line ();
     919                 :          0 :   for (unsigned i = 0; i < m_events.length (); i++)
     920                 :            :     {
     921                 :          0 :       logger->start_log_line ();
     922                 :          0 :       logger->log_partial ("%s[%i]: %s ", desc, i,
     923                 :          0 :                            event_kind_to_string (m_events[i]->m_kind));
     924                 :          0 :       m_events[i]->dump (logger->get_printer ());
     925                 :          0 :       logger->end_log_line ();
     926                 :            :     }
     927                 :            : }
     928                 :            : 
     929                 :            : /* Print a multiline form of this path to STDERR.  */
     930                 :            : 
     931                 :            : DEBUG_FUNCTION void
     932                 :          0 : checker_path::debug () const
     933                 :            : {
     934                 :          0 :   checker_event *e;
     935                 :          0 :   int i;
     936                 :          0 :   FOR_EACH_VEC_ELT (m_events, i, e)
     937                 :            :     {
     938                 :          0 :       label_text event_desc (e->get_desc (false));
     939                 :          0 :       fprintf (stderr,
     940                 :            :                "[%i]: %s \"%s\"\n",
     941                 :            :                i,
     942                 :          0 :                event_kind_to_string (m_events[i]->m_kind),
     943                 :            :                event_desc.m_buffer);
     944                 :          0 :       event_desc.maybe_free ();
     945                 :            :     }
     946                 :          0 : }
     947                 :            : 
     948                 :            : /* Add a warning_event to the end of this path.  */
     949                 :            : 
     950                 :            : void
     951                 :        307 : checker_path::add_final_event (const state_machine *sm,
     952                 :            :                                const exploded_node *enode, const gimple *stmt,
     953                 :            :                                tree var, state_machine::state_t state)
     954                 :            : {
     955                 :        307 :   checker_event *end_of_path
     956                 :        307 :     = new warning_event (stmt->location,
     957                 :        307 :                          enode->get_function ()->decl,
     958                 :        307 :                          enode->get_stack_depth (),
     959                 :        307 :                          sm, var, state);
     960                 :        307 :   add_event (end_of_path);
     961                 :        307 : }
     962                 :            : 
     963                 :            : } // namespace ana
     964                 :            : 
     965                 :            : #endif /* #if ENABLE_ANALYZER */

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.