LCOV - code coverage report
Current view: top level - gcc/analyzer - engine.cc (source / functions) Hit Total Coverage
Test: gcc.info Lines: 1380 1857 74.3 %
Date: 2020-03-28 11:57:23 Functions: 97 119 81.5 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* The analysis "engine".
       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 "fold-const.h"
      26                 :            : #include "gcc-rich-location.h"
      27                 :            : #include "alloc-pool.h"
      28                 :            : #include "fibonacci_heap.h"
      29                 :            : #include "shortest-paths.h"
      30                 :            : #include "diagnostic-core.h"
      31                 :            : #include "diagnostic-event-id.h"
      32                 :            : #include "diagnostic-path.h"
      33                 :            : #include "function.h"
      34                 :            : #include "pretty-print.h"
      35                 :            : #include "sbitmap.h"
      36                 :            : #include "tristate.h"
      37                 :            : #include "ordered-hash-map.h"
      38                 :            : #include "selftest.h"
      39                 :            : #include "analyzer/analyzer.h"
      40                 :            : #include "analyzer/analyzer-logging.h"
      41                 :            : #include "analyzer/region-model.h"
      42                 :            : #include "analyzer/constraint-manager.h"
      43                 :            : #include "analyzer/sm.h"
      44                 :            : #include "analyzer/pending-diagnostic.h"
      45                 :            : #include "analyzer/diagnostic-manager.h"
      46                 :            : #include "cfg.h"
      47                 :            : #include "basic-block.h"
      48                 :            : #include "gimple.h"
      49                 :            : #include "gimple-iterator.h"
      50                 :            : #include "gimple-pretty-print.h"
      51                 :            : #include "cgraph.h"
      52                 :            : #include "digraph.h"
      53                 :            : #include "analyzer/supergraph.h"
      54                 :            : #include "analyzer/call-string.h"
      55                 :            : #include "analyzer/program-point.h"
      56                 :            : #include "analyzer/program-state.h"
      57                 :            : #include "analyzer/exploded-graph.h"
      58                 :            : #include "analyzer/analysis-plan.h"
      59                 :            : #include "analyzer/checker-path.h"
      60                 :            : #include "analyzer/state-purge.h"
      61                 :            : #include "analyzer/bar-chart.h"
      62                 :            : 
      63                 :            : /* For an overview, see gcc/doc/analyzer.texi.  */
      64                 :            : 
      65                 :            : #if ENABLE_ANALYZER
      66                 :            : 
      67                 :            : namespace ana {
      68                 :            : 
      69                 :            : static int readability_comparator (const void *p1, const void *p2);
      70                 :            : 
      71                 :            : /* class impl_region_model_context : public region_model_context.  */
      72                 :            : 
      73                 :     102694 : impl_region_model_context::
      74                 :            : impl_region_model_context (exploded_graph &eg,
      75                 :            :                            const exploded_node *enode_for_diag,
      76                 :            :                            const program_state *old_state,
      77                 :            :                            program_state *new_state,
      78                 :            :                            state_change *change,
      79                 :            :                            const gimple *stmt,
      80                 :     102694 :                            stmt_finder *stmt_finder)
      81                 :            : : m_eg (&eg), m_logger (eg.get_logger ()),
      82                 :            :   m_enode_for_diag (enode_for_diag),
      83                 :            :   m_old_state (old_state),
      84                 :            :   m_new_state (new_state),
      85                 :            :   m_change (change),
      86                 :            :   m_stmt (stmt),
      87                 :            :   m_stmt_finder (stmt_finder),
      88                 :     102694 :   m_ext_state (eg.get_ext_state ())
      89                 :            : {
      90                 :     102694 : }
      91                 :            : 
      92                 :       5574 : impl_region_model_context::
      93                 :            : impl_region_model_context (program_state *state,
      94                 :            :                            state_change *change,
      95                 :            :                            const extrinsic_state &ext_state,
      96                 :       5574 :                            logger *logger)
      97                 :            : : m_eg (NULL), m_logger (logger), m_enode_for_diag (NULL),
      98                 :            :   m_old_state (NULL),
      99                 :            :   m_new_state (state),
     100                 :            :   m_change (change),
     101                 :            :   m_stmt (NULL),
     102                 :            :   m_stmt_finder (NULL),
     103                 :       5574 :   m_ext_state (ext_state)
     104                 :            : {
     105                 :       5574 : }
     106                 :            : 
     107                 :            : void
     108                 :         15 : impl_region_model_context::warn (pending_diagnostic *d)
     109                 :            : {
     110                 :         30 :   LOG_FUNC (get_logger ());
     111                 :         15 :   if (m_eg)
     112                 :         15 :     m_eg->get_diagnostic_manager ().add_diagnostic
     113                 :         15 :       (m_enode_for_diag, m_enode_for_diag->get_supernode (),
     114                 :            :        m_stmt, m_stmt_finder, d);
     115                 :         15 : }
     116                 :            : 
     117                 :            : void
     118                 :      62772 : impl_region_model_context::remap_svalue_ids (const svalue_id_map &map)
     119                 :            : {
     120                 :      62772 :   m_new_state->remap_svalue_ids (map);
     121                 :      62772 :   if (m_change)
     122                 :      55244 :     m_change->remap_svalue_ids (map);
     123                 :      62772 : }
     124                 :            : 
     125                 :            : int
     126                 :      29848 : impl_region_model_context::on_svalue_purge (svalue_id first_unused_sid,
     127                 :            :                                             const svalue_id_map &map)
     128                 :            : {
     129                 :      29848 :   int total = 0;
     130                 :      29848 :   int sm_idx;
     131                 :      29848 :   sm_state_map *smap;
     132                 :     147155 :   FOR_EACH_VEC_ELT (m_new_state->m_checker_states, sm_idx, smap)
     133                 :            :     {
     134                 :     117307 :       const state_machine &sm = m_ext_state.get_sm (sm_idx);
     135                 :     117307 :       total += smap->on_svalue_purge (sm, sm_idx, first_unused_sid,
     136                 :            :                                       map, this);
     137                 :            :     }
     138                 :      29848 :   if (m_change)
     139                 :      27895 :     total += m_change->on_svalue_purge (first_unused_sid);
     140                 :      29848 :   return total;
     141                 :            : }
     142                 :            : 
     143                 :            : void
     144                 :       1526 : impl_region_model_context::on_unknown_change (svalue_id sid)
     145                 :            : {
     146                 :       1526 :   int sm_idx;
     147                 :       1526 :   sm_state_map *smap;
     148                 :       7630 :   FOR_EACH_VEC_ELT (m_new_state->m_checker_states, sm_idx, smap)
     149                 :       6104 :     smap->on_unknown_change (sid);
     150                 :       1526 : }
     151                 :            : 
     152                 :            : /* class setjmp_svalue : public svalue.  */
     153                 :            : 
     154                 :            : /* Compare the fields of this setjmp_svalue with OTHER, returning true
     155                 :            :    if they are equal.
     156                 :            :    For use by svalue::operator==.  */
     157                 :            : 
     158                 :            : bool
     159                 :        235 : setjmp_svalue::compare_fields (const setjmp_svalue &other) const
     160                 :            : {
     161                 :        235 :   return m_setjmp_record == other.m_setjmp_record;
     162                 :            : }
     163                 :            : 
     164                 :            : /* Implementation of svalue::add_to_hash vfunc for setjmp_svalue.  */
     165                 :            : 
     166                 :            : void
     167                 :        699 : setjmp_svalue::add_to_hash (inchash::hash &hstate) const
     168                 :            : {
     169                 :        699 :   hstate.add_int (m_setjmp_record.m_enode->m_index);
     170                 :        699 : }
     171                 :            : 
     172                 :            : /* Get the index of the stored exploded_node.  */
     173                 :            : 
     174                 :            : int
     175                 :          0 : setjmp_svalue::get_enode_index () const
     176                 :            : {
     177                 :          0 :   return m_setjmp_record.m_enode->m_index;
     178                 :            : }
     179                 :            : 
     180                 :            : /* Implementation of svalue::print_details vfunc for setjmp_svalue.  */
     181                 :            : 
     182                 :            : void
     183                 :          0 : setjmp_svalue::print_details (const region_model &model ATTRIBUTE_UNUSED,
     184                 :            :                               svalue_id this_sid ATTRIBUTE_UNUSED,
     185                 :            :                               pretty_printer *pp) const
     186                 :            : {
     187                 :          0 :   pp_printf (pp, "setjmp: EN: %i", get_enode_index ());
     188                 :          0 : }
     189                 :            : 
     190                 :            : /* Concrete implementation of sm_context, wiring it up to the rest of this
     191                 :            :    file.  */
     192                 :            : 
     193                 :      92502 : class impl_sm_context : public sm_context
     194                 :            : {
     195                 :            : public:
     196                 :      92502 :   impl_sm_context (exploded_graph &eg,
     197                 :            :                    int sm_idx,
     198                 :            :                    const state_machine &sm,
     199                 :            :                    const exploded_node *enode_for_diag,
     200                 :            :                    const program_state *old_state,
     201                 :            :                    program_state *new_state,
     202                 :            :                    state_change *change,
     203                 :            :                    const sm_state_map *old_smap,
     204                 :            :                    sm_state_map *new_smap,
     205                 :            :                    stmt_finder *stmt_finder = NULL)
     206                 :      92502 :   : sm_context (sm_idx, sm),
     207                 :            :     m_logger (eg.get_logger ()),
     208                 :            :     m_eg (eg), m_enode_for_diag (enode_for_diag),
     209                 :            :     m_old_state (old_state), m_new_state (new_state),
     210                 :            :     m_change (change),
     211                 :            :     m_old_smap (old_smap), m_new_smap (new_smap),
     212                 :     185004 :     m_stmt_finder (stmt_finder)
     213                 :            :   {
     214                 :            :   }
     215                 :            : 
     216                 :      15236 :   logger *get_logger () const { return m_logger.get_logger (); }
     217                 :            : 
     218                 :      14615 :   tree get_fndecl_for_call (const gcall *call) FINAL OVERRIDE
     219                 :            :   {
     220                 :      14615 :     impl_region_model_context old_ctxt
     221                 :            :       (m_eg, m_enode_for_diag, NULL, NULL/*m_enode->get_state ()*/,
     222                 :      14615 :        m_change, call);
     223                 :      14615 :     region_model *model = m_new_state->m_region_model;
     224                 :      14615 :     return model->get_fndecl_for_call (call, &old_ctxt);
     225                 :            :   }
     226                 :            : 
     227                 :       9610 :   void on_transition (const supernode *node  ATTRIBUTE_UNUSED,
     228                 :            :                       const gimple *stmt  ATTRIBUTE_UNUSED,
     229                 :            :                       tree var,
     230                 :            :                       state_machine::state_t from,
     231                 :            :                       state_machine::state_t to,
     232                 :            :                       tree origin) FINAL OVERRIDE
     233                 :            :   {
     234                 :       9610 :     logger * const logger = get_logger ();
     235                 :       9610 :     LOG_FUNC (logger);
     236                 :       9610 :     impl_region_model_context old_ctxt
     237                 :            :       (m_eg, m_enode_for_diag, NULL, NULL/*m_enode->get_state ()*/,
     238                 :      19220 :        m_change, stmt);
     239                 :       9610 :     svalue_id var_old_sid
     240                 :       9610 :       = m_old_state->m_region_model->get_rvalue (var, &old_ctxt);
     241                 :            : 
     242                 :       9610 :     impl_region_model_context new_ctxt (m_eg, m_enode_for_diag,
     243                 :            :                                         m_old_state, m_new_state,
     244                 :      19220 :                                         m_change, NULL);
     245                 :       9610 :     svalue_id var_new_sid
     246                 :       9610 :       = m_new_state->m_region_model->get_rvalue (var, &new_ctxt);
     247                 :       9610 :     svalue_id origin_new_sid
     248                 :       9610 :       = m_new_state->m_region_model->get_rvalue (origin, &new_ctxt);
     249                 :            : 
     250                 :       9610 :     state_machine::state_t current = m_old_smap->get_state (var_old_sid);
     251                 :       9610 :     if (current == from)
     252                 :            :       {
     253                 :       1508 :         if (logger)
     254                 :          0 :           logger->log ("%s: state transition of %qE: %s -> %s",
     255                 :          0 :                        m_sm.get_name (),
     256                 :            :                        var,
     257                 :          0 :                        m_sm.get_state_name (from),
     258                 :          0 :                        m_sm.get_state_name (to));
     259                 :       1508 :         m_new_smap->set_state (m_new_state->m_region_model, var_new_sid,
     260                 :            :                                to, origin_new_sid);
     261                 :       1508 :         if (m_change)
     262                 :       1508 :           m_change->add_sm_change (m_sm_idx, var_new_sid, from, to);
     263                 :            :       }
     264                 :       9610 :   }
     265                 :            : 
     266                 :       5626 :   void warn_for_state (const supernode *snode, const gimple *stmt,
     267                 :            :                        tree var, state_machine::state_t state,
     268                 :            :                        pending_diagnostic *d) FINAL OVERRIDE
     269                 :            :   {
     270                 :       5626 :     LOG_FUNC (get_logger ());
     271                 :       5626 :     gcc_assert (d); // take ownership
     272                 :            : 
     273                 :       5626 :     impl_region_model_context old_ctxt
     274                 :      11252 :       (m_eg, m_enode_for_diag, m_old_state, m_new_state, m_change, NULL);
     275                 :       5626 :     state_machine::state_t current;
     276                 :       5626 :     if (var)
     277                 :            :       {
     278                 :       5618 :         svalue_id var_old_sid
     279                 :       5618 :           = m_old_state->m_region_model->get_rvalue (var, &old_ctxt);
     280                 :       5618 :         current = m_old_smap->get_state (var_old_sid);
     281                 :            :       }
     282                 :            :     else
     283                 :          8 :       current = m_old_smap->get_global_state ();
     284                 :            : 
     285                 :       5626 :     if (state == current)
     286                 :            :       {
     287                 :        301 :         m_eg.get_diagnostic_manager ().add_diagnostic
     288                 :        301 :           (&m_sm, m_enode_for_diag, snode, stmt, m_stmt_finder,
     289                 :            :            var, state, d);
     290                 :            :       }
     291                 :            :     else
     292                 :       5325 :       delete d;
     293                 :       5626 :   }
     294                 :            : 
     295                 :            :   /* Hook for picking more readable trees for SSA names of temporaries,
     296                 :            :      so that rather than e.g.
     297                 :            :        "double-free of '<unknown>'"
     298                 :            :      we can print:
     299                 :            :        "double-free of 'inbuf.data'".  */
     300                 :            : 
     301                 :       2521 :   tree get_readable_tree (tree expr) FINAL OVERRIDE
     302                 :            :   {
     303                 :            :     /* Only for SSA_NAMEs of temporaries; otherwise, return EXPR, as it's
     304                 :            :        likely to be the least surprising tree to report.  */
     305                 :       2521 :     if (TREE_CODE (expr) != SSA_NAME)
     306                 :            :       return expr;
     307                 :       2422 :     if (SSA_NAME_VAR (expr) != NULL)
     308                 :            :       return expr;
     309                 :            : 
     310                 :        681 :     gcc_assert (m_new_state);
     311                 :        681 :     svalue_id sid = m_new_state->m_region_model->get_rvalue (expr, NULL);
     312                 :            :     /* Find trees for all regions storing the value.  */
     313                 :        681 :     auto_vec<path_var> pvs;
     314                 :        681 :     m_new_state->m_region_model->get_path_vars_for_svalue (sid, &pvs);
     315                 :        681 :     if (pvs.length () < 1)
     316                 :            :       return expr;
     317                 :            :     /* Pick the "best" such tree.  */
     318                 :            :     // TODO: should we also consider (and consolidate) equiv classes?
     319                 :        681 :     pvs.qsort (readability_comparator);
     320                 :        681 :     return pvs[0].m_tree;
     321                 :            :   }
     322                 :            : 
     323                 :      15270 :   state_machine::state_t get_global_state () const FINAL OVERRIDE
     324                 :            :   {
     325                 :      15270 :     return m_old_state->m_checker_states[m_sm_idx]->get_global_state ();
     326                 :            :   }
     327                 :            : 
     328                 :          0 :   void set_global_state (state_machine::state_t state) FINAL OVERRIDE
     329                 :            :   {
     330                 :          0 :     m_new_state->m_checker_states[m_sm_idx]->set_global_state (state);
     331                 :          0 :   }
     332                 :            : 
     333                 :          7 :   void on_custom_transition (custom_transition *transition) FINAL OVERRIDE
     334                 :            :   {
     335                 :          7 :     transition->impl_transition (&m_eg,
     336                 :          7 :                                  const_cast<exploded_node *> (m_enode_for_diag),
     337                 :          7 :                                  m_sm_idx);
     338                 :          7 :   }
     339                 :            : 
     340                 :            :   log_user m_logger;
     341                 :            :   exploded_graph &m_eg;
     342                 :            :   const exploded_node *m_enode_for_diag;
     343                 :            :   const program_state *m_old_state;
     344                 :            :   program_state *m_new_state;
     345                 :            :   state_change *m_change;
     346                 :            :   const sm_state_map *m_old_smap;
     347                 :            :   sm_state_map *m_new_smap;
     348                 :            :   stmt_finder *m_stmt_finder;
     349                 :            : };
     350                 :            : 
     351                 :            : /* Subclass of stmt_finder for finding the best stmt to report the leak at,
     352                 :            :    given the emission path.  */
     353                 :            : 
     354                 :        157 : class leak_stmt_finder : public stmt_finder
     355                 :            : {
     356                 :            : public:
     357                 :        304 :   leak_stmt_finder (const exploded_graph &eg, tree var)
     358                 :        304 :   : m_eg (eg), m_var (var) {}
     359                 :            : 
     360                 :        147 :   stmt_finder *clone () const FINAL OVERRIDE
     361                 :            :   {
     362                 :        147 :     return new leak_stmt_finder (m_eg, m_var);
     363                 :            :   }
     364                 :            : 
     365                 :         88 :   const gimple *find_stmt (const exploded_path &epath)
     366                 :            :     FINAL OVERRIDE
     367                 :            :   {
     368                 :         88 :     logger * const logger = m_eg.get_logger ();
     369                 :        176 :     LOG_FUNC (logger);
     370                 :            : 
     371                 :         88 :     if (TREE_CODE (m_var) == SSA_NAME)
     372                 :            :       {
     373                 :            :         /* Locate the final write to this SSA name in the path.  */
     374                 :         62 :         const gimple *def_stmt = SSA_NAME_DEF_STMT (m_var);
     375                 :            : 
     376                 :         62 :         int idx_of_def_stmt;
     377                 :         62 :         bool found = epath.find_stmt_backwards (def_stmt, &idx_of_def_stmt);
     378                 :         62 :         if (!found)
     379                 :          4 :           goto not_found;
     380                 :            : 
     381                 :            :         /* What was the next write to the underlying var
     382                 :            :            after the SSA name was set? (if any).  */
     383                 :            : 
     384                 :         58 :         for (unsigned idx = idx_of_def_stmt + 1;
     385                 :       1034 :              idx < epath.m_edges.length ();
     386                 :            :              ++idx)
     387                 :            :           {
     388                 :        470 :             const exploded_edge *eedge = epath.m_edges[idx];
     389                 :        470 :             if (logger)
     390                 :          0 :               logger->log ("eedge[%i]: EN %i -> EN %i",
     391                 :            :                            idx,
     392                 :          0 :                            eedge->m_src->m_index,
     393                 :          0 :                            eedge->m_dest->m_index);
     394                 :        470 :             const exploded_node *dst_node = eedge->m_dest;
     395                 :        470 :             const program_point &dst_point = dst_node->get_point ();
     396                 :        470 :             const gimple *stmt = dst_point.get_stmt ();
     397                 :        470 :             if (!stmt)
     398                 :        215 :               continue;
     399                 :        509 :             if (const gassign *assign = dyn_cast <const gassign *> (stmt))
     400                 :            :               {
     401                 :         50 :                 tree lhs = gimple_assign_lhs (assign);
     402                 :         50 :                 if (TREE_CODE (lhs) == SSA_NAME
     403                 :         71 :                     && SSA_NAME_VAR (lhs) == SSA_NAME_VAR (m_var))
     404                 :         11 :                   return assign;
     405                 :            :               }
     406                 :            :           }
     407                 :            :       }
     408                 :            : 
     409                 :         26 :   not_found:
     410                 :            : 
     411                 :            :     /* Look backwards for the first statement with a location.  */
     412                 :         77 :     int i;
     413                 :         77 :     const exploded_edge *eedge;
     414                 :        323 :     FOR_EACH_VEC_ELT_REVERSE (epath.m_edges, i, eedge)
     415                 :            :       {
     416                 :        246 :         if (logger)
     417                 :          0 :           logger->log ("eedge[%i]: EN %i -> EN %i",
     418                 :            :                        i,
     419                 :          0 :                        eedge->m_src->m_index,
     420                 :          0 :                        eedge->m_dest->m_index);
     421                 :        246 :         const exploded_node *dst_node = eedge->m_dest;
     422                 :        246 :         const program_point &dst_point = dst_node->get_point ();
     423                 :        246 :         const gimple *stmt = dst_point.get_stmt ();
     424                 :        246 :         if (stmt)
     425                 :         87 :           if (get_pure_location (stmt->location) != UNKNOWN_LOCATION)
     426                 :         77 :             return stmt;
     427                 :            :       }
     428                 :            : 
     429                 :          0 :     gcc_unreachable ();
     430                 :            :     return NULL;
     431                 :            :   }
     432                 :            : 
     433                 :            : private:
     434                 :            :   const exploded_graph &m_eg;
     435                 :            :   tree m_var;
     436                 :            : };
     437                 :            : 
     438                 :            : /* A measurement of how good EXPR is for presenting to the user, so
     439                 :            :    that e.g. we can say prefer printing
     440                 :            :      "leak of 'tmp.m_ptr'"
     441                 :            :    over:
     442                 :            :      "leak of '<unknown>'".  */
     443                 :            : 
     444                 :            : static int
     445                 :       4308 : readability (const_tree expr)
     446                 :            : {
     447                 :          0 :   gcc_assert (expr);
     448                 :       4860 :   switch (TREE_CODE (expr))
     449                 :            :     {
     450                 :        225 :     case COMPONENT_REF:
     451                 :        225 :     case MEM_REF:
     452                 :            :       /* Impose a slight readability penalty relative to that of
     453                 :            :          operand 0.  */
     454                 :        225 :       return readability (TREE_OPERAND (expr, 0)) - 1;
     455                 :            : 
     456                 :       3247 :     case SSA_NAME:
     457                 :       3247 :       {
     458                 :       8107 :         if (tree var = SSA_NAME_VAR (expr))
     459                 :            :           return readability (var);
     460                 :            :         /* Avoid printing '<unknown>' for SSA names for temporaries.  */
     461                 :            :         return -1;
     462                 :            :       }
     463                 :            :       break;
     464                 :            : 
     465                 :            :     case VAR_DECL:
     466                 :            :       /* Arbitrarily-chosen "high readability" value.  */
     467                 :            :       return 256;
     468                 :            : 
     469                 :        904 :     default:
     470                 :        904 :       return 0;
     471                 :            :     }
     472                 :            : 
     473                 :            :   return 0;
     474                 :            : }
     475                 :            : 
     476                 :            : /* A qsort comparator for trees to sort them into most user-readable to
     477                 :            :    least user-readable.  */
     478                 :            : 
     479                 :            : static int
     480                 :       2154 : readability_comparator (const void *p1, const void *p2)
     481                 :            : {
     482                 :       2154 :   path_var pv1 = *(path_var const *)p1;
     483                 :       2154 :   path_var pv2 = *(path_var const *)p2;
     484                 :            : 
     485                 :            :   /* TODO: should we consider stack depths?  */
     486                 :       2154 :   int r1 = readability (pv1.m_tree);
     487                 :       2154 :   int r2 = readability (pv2.m_tree);
     488                 :            : 
     489                 :       2154 :   return r2 - r1;
     490                 :            : }
     491                 :            : 
     492                 :            : /* Create an sm_context and use it to call SM's on_leak vfunc, so that
     493                 :            :    it can potentially complain about a leak of DST_SID (in a new region_model)
     494                 :            :    in the given STATE, where MAP can be used to map SID back to an "old"
     495                 :            :    region_model.  */
     496                 :            : 
     497                 :            : void
     498                 :        251 : impl_region_model_context::on_state_leak (const state_machine &sm,
     499                 :            :                                           int sm_idx,
     500                 :            :                                           svalue_id dst_sid,
     501                 :            :                                           svalue_id first_unused_sid,
     502                 :            :                                           const svalue_id_map &map,
     503                 :            :                                           state_machine::state_t state)
     504                 :            : {
     505                 :        251 :   logger * const logger = get_logger ();
     506                 :        251 :   LOG_SCOPE (logger);
     507                 :        251 :   if (logger)
     508                 :          0 :     logger->log ("considering leak of sv%i", dst_sid.as_int ());
     509                 :            : 
     510                 :        251 :   if (!m_eg)
     511                 :        104 :     return;
     512                 :            : 
     513                 :            :   /* m_old_state also needs to be non-NULL so that the sm_ctxt can look
     514                 :            :      up the old state of the sid.  */
     515                 :        251 :   gcc_assert (m_old_state);
     516                 :            : 
     517                 :            :   /* Don't report on sid leaking if it's equal to one of the used sids.
     518                 :            :      For example, given:
     519                 :            :        some_non_trivial_expression = malloc (sizeof (struct foo));
     520                 :            :      we have:
     521                 :            :        _1 = malloc;                         (void *)
     522                 :            :        some_non_trivial_expression = _1;    (struct foo *)
     523                 :            :      and at leak-detection time we may have:
     524                 :            :        sv5: {type: 'struct foo *', &r3}  (used)
     525                 :            :        sv6: {type: 'void *', &r3}         (unused)
     526                 :            :      where both point to the same region.  We don't want to report a
     527                 :            :      leak of sv6, so we reject the report due to its equality with sv5.  */
     528                 :        251 :   gcc_assert (m_new_state);
     529                 :        251 :   gcc_assert (!first_unused_sid.null_p ());
     530                 :       1924 :   for (int i = 0; i < first_unused_sid.as_int (); i++)
     531                 :            :     {
     532                 :       1700 :       svalue_id used_sid = svalue_id::from_int (i);
     533                 :            : 
     534                 :            :       /* Use the "_without_cm" form of eval_condition, since
     535                 :            :          we're half-way through purging - we don't want to introduce new
     536                 :            :          equivalence classes into the constraint_manager for "sid" and
     537                 :            :          for each of the used_sids.  */
     538                 :       1700 :       const region_model &rm = *m_new_state->m_region_model;
     539                 :       1700 :       tristate eq = rm.eval_condition_without_cm (dst_sid, EQ_EXPR, used_sid);
     540                 :       1700 :       if (eq.is_true ())
     541                 :            :         {
     542                 :         27 :           if (logger)
     543                 :          0 :             logger->log ("rejecting leak of sv%i due to equality with sv%i",
     544                 :            :                          dst_sid.as_int (), used_sid.as_int ());
     545                 :         27 :           return;
     546                 :            :         }
     547                 :            :     }
     548                 :            : 
     549                 :            :   /* SID has leaked within the new state: no regions use it.
     550                 :            :      We need to convert it back to a tree, but since no regions use it, we
     551                 :            :      have to use MAP to convert it back to an svalue_id within the old state.
     552                 :            :      We can then look that svalue_id up to locate regions and thus tree(s)
     553                 :            :      that use it.  */
     554                 :            : 
     555                 :        224 :   svalue_id old_sid = map.get_src_for_dst (dst_sid);
     556                 :            : 
     557                 :        371 :   auto_vec<path_var> leaked_pvs;
     558                 :        224 :   m_old_state->m_region_model->get_path_vars_for_svalue (old_sid, &leaked_pvs);
     559                 :            : 
     560                 :        224 :   if (leaked_pvs.length () < 1)
     561                 :        104 :     return;
     562                 :            : 
     563                 :            :   /* Find "best" leaked tree.
     564                 :            :      Sort the leaks into most human-readable first, through
     565                 :            :      to least user-readable.  Given that we only emit one
     566                 :            :      leak per EC, this ought to ensure that we pick the most
     567                 :            :      user-readable description of each leaking EC.
     568                 :            :      This assumes that all vars in the EC have the same state.  */
     569                 :        157 :   leaked_pvs.qsort (readability_comparator);
     570                 :            : 
     571                 :        157 :   tree leaked_tree = leaked_pvs[0].m_tree;
     572                 :        157 :   if (logger)
     573                 :          0 :     logger->log ("best leaked_tree: %qE", leaked_tree);
     574                 :            : 
     575                 :        304 :   leak_stmt_finder stmt_finder (*m_eg, leaked_tree);
     576                 :        314 :   impl_sm_context sm_ctxt (*m_eg, sm_idx, sm, m_enode_for_diag,
     577                 :            :                            m_old_state, m_new_state,
     578                 :            :                            m_change,
     579                 :        314 :                            m_old_state->m_checker_states[sm_idx],
     580                 :        157 :                            m_new_state->m_checker_states[sm_idx],
     581                 :        304 :                            &stmt_finder);
     582                 :        157 :   gcc_assert (m_enode_for_diag);
     583                 :            : 
     584                 :            :   /* Don't complain about leaks when returning from "main".  */
     585                 :        157 :   if (m_enode_for_diag->get_supernode ()
     586                 :        157 :       && m_enode_for_diag->get_supernode ()->return_p ())
     587                 :            :     {
     588                 :        154 :       tree fndecl = m_enode_for_diag->get_function ()->decl;
     589                 :        154 :       if (0 == strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main"))
     590                 :            :         {
     591                 :         10 :           if (logger)
     592                 :          0 :             logger->log ("not reporting leak from main");
     593                 :         10 :           return;
     594                 :            :         }
     595                 :            :     }
     596                 :            : 
     597                 :        147 :   pending_diagnostic *pd = sm.on_leak (leaked_tree);
     598                 :        147 :   if (pd)
     599                 :        147 :     m_eg->get_diagnostic_manager ().add_diagnostic
     600                 :        147 :       (&sm, m_enode_for_diag, m_enode_for_diag->get_supernode (),
     601                 :            :        m_stmt, &stmt_finder,
     602                 :            :        leaked_tree, state, pd);
     603                 :            : }
     604                 :            : 
     605                 :            : /* Implementation of region_model_context::on_inherited_svalue vfunc
     606                 :            :    for impl_region_model_context.
     607                 :            :    Notify all checkers that CHILD_SID has been created from PARENT_SID,
     608                 :            :    so that those state machines that inherit state can propagate the state
     609                 :            :    from parent to child.  */
     610                 :            : 
     611                 :            : void
     612                 :       3301 : impl_region_model_context::on_inherited_svalue (svalue_id parent_sid,
     613                 :            :                                                 svalue_id child_sid)
     614                 :            : {
     615                 :       3301 :   if (!m_new_state)
     616                 :       3301 :     return;
     617                 :            : 
     618                 :            :   int sm_idx;
     619                 :            :   sm_state_map *smap;
     620                 :       9724 :   FOR_EACH_VEC_ELT (m_new_state->m_checker_states, sm_idx, smap)
     621                 :            :     {
     622                 :       7742 :       const state_machine &sm = m_ext_state.get_sm (sm_idx);
     623                 :       7742 :       if (sm.inherited_state_p ())
     624                 :       1966 :         smap->on_inherited_svalue (parent_sid, child_sid);
     625                 :            :     }
     626                 :            : }
     627                 :            : 
     628                 :            : /* Implementation of region_model_context::on_cast vfunc
     629                 :            :    for impl_region_model_context.
     630                 :            :    Notify all checkers that DST_SID is a cast of SRC_SID, so that sm-state
     631                 :            :    can be propagated from src to dst.  */
     632                 :            : 
     633                 :            : void
     634                 :       1808 : impl_region_model_context::on_cast (svalue_id src_sid,
     635                 :            :                                     svalue_id dst_sid)
     636                 :            : {
     637                 :       1808 :   if (!m_new_state)
     638                 :       1808 :     return;
     639                 :            : 
     640                 :            :   int sm_idx;
     641                 :            :   sm_state_map *smap;
     642                 :       8995 :   FOR_EACH_VEC_ELT (m_new_state->m_checker_states, sm_idx, smap)
     643                 :       7187 :     smap->on_cast (src_sid, dst_sid);
     644                 :            : }
     645                 :            : 
     646                 :            : /* Implementation of region_model_context::on_condition vfunc.
     647                 :            :    Notify all state machines about the condition, which could lead to
     648                 :            :    state transitions.  */
     649                 :            : 
     650                 :            : void
     651                 :       5201 : impl_region_model_context::on_condition (tree lhs, enum tree_code op, tree rhs)
     652                 :            : {
     653                 :       5201 :   int sm_idx;
     654                 :       5201 :   sm_state_map *smap;
     655                 :      25849 :   FOR_EACH_VEC_ELT (m_new_state->m_checker_states, sm_idx, smap)
     656                 :            :     {
     657                 :      20648 :       const state_machine &sm = m_ext_state.get_sm (sm_idx);
     658                 :      41296 :       impl_sm_context sm_ctxt (*m_eg, sm_idx, sm, m_enode_for_diag,
     659                 :            :                                m_old_state, m_new_state,
     660                 :            :                                m_change,
     661                 :      20648 :                                m_old_state->m_checker_states[sm_idx],
     662                 :      41296 :                                m_new_state->m_checker_states[sm_idx]);
     663                 :      20648 :       sm.on_condition (&sm_ctxt,
     664                 :      20648 :                        m_enode_for_diag->get_supernode (), m_stmt,
     665                 :      20648 :                        lhs, op, rhs);
     666                 :            :     }
     667                 :       5201 : }
     668                 :            : 
     669                 :            : /* Implementation of region_model_context::on_phi vfunc.
     670                 :            :    Notify all state machines about the phi, which could lead to
     671                 :            :    state transitions.  */
     672                 :            : 
     673                 :            : void
     674                 :       2613 : impl_region_model_context::on_phi (const gphi *phi, tree rhs)
     675                 :            : {
     676                 :       2613 :   int sm_idx;
     677                 :       2613 :   sm_state_map *smap;
     678                 :      12999 :   FOR_EACH_VEC_ELT (m_new_state->m_checker_states, sm_idx, smap)
     679                 :            :     {
     680                 :      10386 :       const state_machine &sm = m_ext_state.get_sm (sm_idx);
     681                 :      20772 :       impl_sm_context sm_ctxt (*m_eg, sm_idx, sm, m_enode_for_diag,
     682                 :            :                                m_old_state, m_new_state,
     683                 :            :                                m_change,
     684                 :      10386 :                                m_old_state->m_checker_states[sm_idx],
     685                 :      20772 :                                m_new_state->m_checker_states[sm_idx]);
     686                 :      10386 :       sm.on_phi (&sm_ctxt, m_enode_for_diag->get_supernode (), phi, rhs);
     687                 :            :     }
     688                 :       2613 : }
     689                 :            : 
     690                 :            : /* Implementation of region_model_context::on_unexpected_tree_code vfunc.
     691                 :            :    Mark the new state as being invalid for further exploration.
     692                 :            :    TODO(stage1): introduce a warning for when this occurs.  */
     693                 :            : 
     694                 :            : void
     695                 :         55 : impl_region_model_context::on_unexpected_tree_code (tree t,
     696                 :            :                                                     const dump_location_t &loc)
     697                 :            : {
     698                 :         55 :   logger * const logger = get_logger ();
     699                 :         55 :   if (logger)
     700                 :          0 :     logger->log ("unhandled tree code: %qs in %qs at %s:%i",
     701                 :          0 :                  get_tree_code_name (TREE_CODE (t)),
     702                 :          0 :                  loc.get_impl_location ().m_function,
     703                 :          0 :                  loc.get_impl_location ().m_file,
     704                 :          0 :                  loc.get_impl_location ().m_line);
     705                 :         55 :   if (m_new_state)
     706                 :         55 :     m_new_state->m_valid = false;
     707                 :         55 : }
     708                 :            : 
     709                 :            : /* struct point_and_state.  */
     710                 :            : 
     711                 :            : /* Assert that this object is sane.  */
     712                 :            : 
     713                 :            : void
     714                 :      55472 : point_and_state::validate (const extrinsic_state &ext_state) const
     715                 :            : {
     716                 :            :   /* Skip this in a release build.  */
     717                 :            : #if !CHECKING_P
     718                 :            :   return;
     719                 :            : #endif
     720                 :            : 
     721                 :      55472 :   m_point.validate ();
     722                 :            : 
     723                 :      55472 :   m_state.validate (ext_state);
     724                 :            : 
     725                 :            :   /* Verify that the callstring's model of the stack corresponds to that
     726                 :            :      of the region_model.  */
     727                 :            :   /* They should have the same depth.  */
     728                 :     110190 :   gcc_assert (m_point.get_stack_depth ()
     729                 :            :               == m_state.m_region_model->get_stack_depth ());
     730                 :            :   /* Check the functions in the callstring vs those in the frames
     731                 :            :      at each depth.  */
     732                 :     261750 :   for (int depth = 0; depth < m_point.get_stack_depth (); ++depth)
     733                 :            :     {
     734                 :      75780 :       gcc_assert (m_point.get_function_at_depth (depth)
     735                 :            :                   == m_state.m_region_model->get_function_at_depth (depth));
     736                 :            :     }
     737                 :      55472 : }
     738                 :            : 
     739                 :            : /* Subroutine of print_enode_indices: print a run of indices from START_IDX
     740                 :            :    to END_IDX to PP, using and updating *FIRST_RUN.  */
     741                 :            : 
     742                 :            : static void
     743                 :        161 : print_run (pretty_printer *pp, int start_idx, int end_idx,
     744                 :            :            bool *first_run)
     745                 :            : {
     746                 :        161 :   if (!(*first_run))
     747                 :         33 :     pp_string (pp, ", ");
     748                 :        161 :   *first_run = false;
     749                 :        161 :   if (start_idx == end_idx)
     750                 :        120 :     pp_printf (pp, "EN: %i", start_idx);
     751                 :            :   else
     752                 :         41 :     pp_printf (pp, "EN: %i-%i", start_idx, end_idx);
     753                 :        161 : }
     754                 :            : 
     755                 :            : /* Print the indices within ENODES to PP, collecting them as
     756                 :            :    runs/singletons e.g. "EN: 4-7, EN: 20-23, EN: 42".  */
     757                 :            : 
     758                 :            : static void
     759                 :        128 : print_enode_indices (pretty_printer *pp,
     760                 :            :                      const auto_vec<exploded_node *> &enodes)
     761                 :            : {
     762                 :        128 :   int cur_start_idx = -1;
     763                 :        128 :   int cur_finish_idx = -1;
     764                 :        128 :   bool first_run = true;
     765                 :        128 :   unsigned i;
     766                 :        128 :   exploded_node *enode;
     767                 :        340 :   FOR_EACH_VEC_ELT (enodes, i, enode)
     768                 :            :     {
     769                 :        212 :       if (cur_start_idx == -1)
     770                 :            :         {
     771                 :        128 :           gcc_assert (cur_finish_idx == -1);
     772                 :        128 :           cur_start_idx = cur_finish_idx = enode->m_index;
     773                 :            :         }
     774                 :            :       else
     775                 :            :         {
     776                 :         84 :           if (enode->m_index == cur_finish_idx + 1)
     777                 :            :             /* Continuation of a run.  */
     778                 :            :             cur_finish_idx = enode->m_index;
     779                 :            :           else
     780                 :            :             {
     781                 :            :               /* Finish existing run, start a new one.  */
     782                 :         33 :               gcc_assert (cur_start_idx >= 0);
     783                 :         33 :               gcc_assert (cur_finish_idx >= 0);
     784                 :         33 :               print_run (pp, cur_start_idx, cur_finish_idx,
     785                 :            :                          &first_run);
     786                 :         33 :               cur_start_idx = cur_finish_idx = enode->m_index;
     787                 :            :             }
     788                 :            :         }
     789                 :            :     }
     790                 :            :   /* Finish any existing run.  */
     791                 :        128 :   if (cur_start_idx >= 0)
     792                 :            :     {
     793                 :        128 :       gcc_assert (cur_finish_idx >= 0);
     794                 :        128 :       print_run (pp, cur_start_idx, cur_finish_idx,
     795                 :            :                  &first_run);
     796                 :            :     }
     797                 :        128 : }
     798                 :            : 
     799                 :            : /* class exploded_node : public dnode<eg_traits>.  */
     800                 :            : 
     801                 :            : /* exploded_node's ctor.  */
     802                 :            : 
     803                 :      26835 : exploded_node::exploded_node (const point_and_state &ps,
     804                 :      26835 :                               int index)
     805                 :      26835 : : m_ps (ps), m_status (STATUS_WORKLIST), m_index (index)
     806                 :            : {
     807                 :      26835 :   gcc_checking_assert (ps.get_state ().m_region_model->canonicalized_p ());
     808                 :      26835 : }
     809                 :            : 
     810                 :            : /* For use by dump_dot, get a value for the .dot "fillcolor" attribute.
     811                 :            :    Colorize by sm-state, to make it easier to see how sm-state propagates
     812                 :            :    through the exploded_graph.  */
     813                 :            : 
     814                 :            : const char *
     815                 :        154 : exploded_node::get_dot_fillcolor () const
     816                 :            : {
     817                 :        154 :   const program_state &state = get_state ();
     818                 :            : 
     819                 :            :   /* We want to be able to easily distinguish the no-sm-state case,
     820                 :            :      and to be able to distinguish cases where there's a single state
     821                 :            :      from each other.
     822                 :            : 
     823                 :            :      Sum the sm_states, and use the result to choose from a table,
     824                 :            :      modulo table-size, special-casing the "no sm-state" case.   */
     825                 :        154 :   int total_sm_state = 0;
     826                 :        154 :   int i;
     827                 :        154 :   sm_state_map *smap;
     828                 :        770 :   FOR_EACH_VEC_ELT (state.m_checker_states, i, smap)
     829                 :            :     {
     830                 :       1313 :       for (sm_state_map::iterator_t iter = smap->begin ();
     831                 :       1394 :          iter != smap->end ();
     832                 :        697 :            ++iter)
     833                 :         81 :         total_sm_state += (*iter).second.m_state;
     834                 :        616 :       total_sm_state += smap->get_global_state ();
     835                 :            :     }
     836                 :            : 
     837                 :        154 :   if (total_sm_state > 0)
     838                 :            :     {
     839                 :            :       /* An arbitrarily-picked collection of light colors.  */
     840                 :         81 :       const char * const colors[]
     841                 :            :         = {"azure", "coral", "cornsilk", "lightblue", "yellow"};
     842                 :         81 :       const int num_colors = sizeof (colors) / sizeof (colors[0]);
     843                 :         81 :       return colors[total_sm_state % num_colors];
     844                 :            :     }
     845                 :            :   else
     846                 :            :     /* No sm-state.   */
     847                 :            :     return "lightgrey";
     848                 :            : }
     849                 :            : 
     850                 :            : /* Implementation of dnode::dump_dot vfunc for exploded_node.  */
     851                 :            : 
     852                 :            : void
     853                 :         77 : exploded_node::dump_dot (graphviz_out *gv, const dump_args_t &args) const
     854                 :            : {
     855                 :         77 :   pretty_printer *pp = gv->get_pp ();
     856                 :            : 
     857                 :         77 :   dump_dot_id (pp);
     858                 :         77 :   pp_printf (pp, " [shape=none,margin=0,style=filled,fillcolor=%s,label=\"",
     859                 :            :              get_dot_fillcolor ());
     860                 :         77 :   pp_write_text_to_stream (pp);
     861                 :            : 
     862                 :         77 :   pp_printf (pp, "EN: %i", m_index);
     863                 :         77 :   if (m_status == STATUS_MERGER)
     864                 :          1 :     pp_string (pp, " (merger)");
     865                 :         77 :   pp_newline (pp);
     866                 :            : 
     867                 :         77 :   format f (true);
     868                 :         77 :   m_ps.get_point ().print (pp, f);
     869                 :         77 :   pp_newline (pp);
     870                 :            : 
     871                 :         77 :   const extrinsic_state &ext_state = args.m_eg.get_ext_state ();
     872                 :         77 :   const program_state &state = m_ps.get_state ();
     873                 :         77 :   state.dump_to_pp (ext_state, true, pp);
     874                 :         77 :   pp_newline (pp);
     875                 :            : 
     876                 :         77 :   {
     877                 :         77 :     int i;
     878                 :         77 :     sm_state_map *smap;
     879                 :        385 :     FOR_EACH_VEC_ELT (state.m_checker_states, i, smap)
     880                 :            :       {
     881                 :        308 :         if (!smap->is_empty_p ())
     882                 :            :           {
     883                 :         40 :             pp_printf (pp, "%s: ", ext_state.get_name (i));
     884                 :         40 :             smap->print (ext_state.get_sm (i), state.m_region_model, pp);
     885                 :         40 :             pp_newline (pp);
     886                 :            :           }
     887                 :            :       }
     888                 :            :   }
     889                 :            : 
     890                 :            :   /* Dump any saved_diagnostics at this enode.  */
     891                 :         77 :   {
     892                 :         77 :     const diagnostic_manager &dm = args.m_eg.get_diagnostic_manager ();
     893                 :         77 :     for (unsigned i = 0; i < dm.get_num_diagnostics (); i++)
     894                 :            :       {
     895                 :          0 :         const saved_diagnostic *sd = dm.get_saved_diagnostic (i);
     896                 :          0 :         if (sd->m_enode == this)
     897                 :            :           {
     898                 :          0 :             pp_printf (pp, "DIAGNOSTIC: %s", sd->m_d->get_kind ());
     899                 :          0 :             pp_newline (pp);
     900                 :            :           }
     901                 :            :       }
     902                 :            :   }
     903                 :            : 
     904                 :         77 :   pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/true);
     905                 :            : 
     906                 :         77 :   pp_string (pp, "\"];\n\n");
     907                 :         77 :   pp_flush (pp);
     908                 :         77 : }
     909                 :            : 
     910                 :            : /* Dump this to PP in a form suitable for use as an id in .dot output.  */
     911                 :            : 
     912                 :            : void
     913                 :        235 : exploded_node::dump_dot_id (pretty_printer *pp) const
     914                 :            : {
     915                 :        235 :   pp_printf (pp, "exploded_node_%i", m_index);
     916                 :        235 : }
     917                 :            : 
     918                 :            : /* Dump a multiline representation of this node to PP.  */
     919                 :            : 
     920                 :            : void
     921                 :          0 : exploded_node::dump_to_pp (pretty_printer *pp,
     922                 :            :                            const extrinsic_state &ext_state) const
     923                 :            : {
     924                 :          0 :   pp_printf (pp, "EN: %i", m_index);
     925                 :          0 :   pp_newline (pp);
     926                 :            : 
     927                 :          0 :   format f (true);
     928                 :          0 :   m_ps.get_point ().print (pp, f);
     929                 :          0 :   pp_newline (pp);
     930                 :            : 
     931                 :          0 :   m_ps.get_state ().dump_to_pp (ext_state, false, pp);
     932                 :          0 :   pp_newline (pp);
     933                 :          0 : }
     934                 :            : 
     935                 :            : /* Dump a multiline representation of this node to FILE.  */
     936                 :            : 
     937                 :            : void
     938                 :          0 : exploded_node::dump (FILE *fp,
     939                 :            :                      const extrinsic_state &ext_state) const
     940                 :            : {
     941                 :          0 :   pretty_printer pp;
     942                 :          0 :   pp_format_decoder (&pp) = default_tree_printer;
     943                 :          0 :   pp_show_color (&pp) = pp_show_color (global_dc->printer);
     944                 :          0 :   pp.buffer->stream = fp;
     945                 :          0 :   dump_to_pp (&pp, ext_state);
     946                 :          0 :   pp_flush (&pp);
     947                 :          0 : }
     948                 :            : 
     949                 :            : /* Dump a multiline representation of this node to stderr.  */
     950                 :            : 
     951                 :            : DEBUG_FUNCTION void
     952                 :          0 : exploded_node::dump (const extrinsic_state &ext_state) const
     953                 :            : {
     954                 :          0 :   dump (stderr, ext_state);
     955                 :          0 : }
     956                 :            : 
     957                 :            : } // namespace ana
     958                 :            : 
     959                 :            : /* Return true if FNDECL has a gimple body.  */
     960                 :            : // TODO: is there a pre-canned way to do this?
     961                 :            : 
     962                 :            : bool
     963                 :      16138 : fndecl_has_gimple_body_p (tree fndecl)
     964                 :            : {
     965                 :      16138 :   if (fndecl == NULL_TREE)
     966                 :            :     return false;
     967                 :            : 
     968                 :      16034 :   cgraph_node *n = cgraph_node::get (fndecl);
     969                 :      16034 :   if (!n)
     970                 :            :     return false;
     971                 :            : 
     972                 :      16034 :   return n->has_gimple_body_p ();
     973                 :            : }
     974                 :            : 
     975                 :            : namespace ana {
     976                 :            : 
     977                 :            : /* A pending_diagnostic subclass for implementing "__analyzer_dump_path".  */
     978                 :            : 
     979                 :          5 : class dump_path_diagnostic
     980                 :            :   : public pending_diagnostic_subclass<dump_path_diagnostic>
     981                 :            : {
     982                 :            : public:
     983                 :          5 :   bool emit (rich_location *richloc) FINAL OVERRIDE
     984                 :            :   {
     985                 :          5 :     inform (richloc, "path");
     986                 :          5 :     return true;
     987                 :            :   }
     988                 :            : 
     989                 :         15 :   const char *get_kind () const FINAL OVERRIDE { return "dump_path_diagnostic"; }
     990                 :            : 
     991                 :          6 :   bool operator== (const dump_path_diagnostic &) const
     992                 :            :   {
     993                 :          6 :     return true;
     994                 :            :   }
     995                 :            : };
     996                 :            : 
     997                 :            : /* Modify STATE in place, applying the effects of the stmt at this node's
     998                 :            :    point.  */
     999                 :            : 
    1000                 :            : exploded_node::on_stmt_flags
    1001                 :      15516 : exploded_node::on_stmt (exploded_graph &eg,
    1002                 :            :                         const supernode *snode,
    1003                 :            :                         const gimple *stmt,
    1004                 :            :                         program_state *state,
    1005                 :            :                         state_change *change) const
    1006                 :            : {
    1007                 :            :   /* Preserve the old state.  It is used here for looking
    1008                 :            :      up old checker states, for determining state transitions, and
    1009                 :            :      also within impl_region_model_context and impl_sm_context for
    1010                 :            :      going from tree to svalue_id.  */
    1011                 :      15516 :   const program_state old_state (*state);
    1012                 :            : 
    1013                 :      15516 :   impl_region_model_context ctxt (eg, this,
    1014                 :            :                                   &old_state, state, change,
    1015                 :      31032 :                                   stmt);
    1016                 :            : 
    1017                 :      15516 :   if (const gassign *assign = dyn_cast <const gassign *> (stmt))
    1018                 :       6773 :     state->m_region_model->on_assignment (assign, &ctxt);
    1019                 :            : 
    1020                 :      15516 :   if (const greturn *return_ = dyn_cast <const greturn *> (stmt))
    1021                 :       1515 :     state->m_region_model->on_return (return_, &ctxt);
    1022                 :            : 
    1023                 :            :   /* Track whether we have a gcall to a function that's not recognized by
    1024                 :            :      anything, for which we don't have a function body, or for which we
    1025                 :            :      don't know the fndecl.  */
    1026                 :      15516 :   bool unknown_side_effects = false;
    1027                 :      15516 :   if (const gcall *call = dyn_cast <const gcall *> (stmt))
    1028                 :            :     {
    1029                 :            :       /* Debugging/test support.  */
    1030                 :       3699 :       if (is_special_named_call_p (call, "__analyzer_dump", 0))
    1031                 :            :         {
    1032                 :            :           /* Handle the builtin "__analyzer_dump" by dumping state
    1033                 :            :              to stderr.  */
    1034                 :          0 :           dump (eg.get_ext_state ());
    1035                 :            :         }
    1036                 :       3699 :       else if (is_special_named_call_p (call, "__analyzer_dump_path", 0))
    1037                 :            :         {
    1038                 :            :           /* Handle the builtin "__analyzer_dump_path" by queuing a
    1039                 :            :              diagnostic at this exploded_node.  */
    1040                 :          5 :           ctxt.warn (new dump_path_diagnostic ());
    1041                 :            :         }
    1042                 :       3694 :       else if (is_special_named_call_p (call, "__analyzer_dump_region_model", 0))
    1043                 :            :         {
    1044                 :            :           /* Handle the builtin "__analyzer_dump_region_model" by dumping
    1045                 :            :              the region model's state to stderr.  */
    1046                 :          0 :           state->m_region_model->dump (false);
    1047                 :            :         }
    1048                 :       3694 :       else if (is_special_named_call_p (call, "__analyzer_eval", 1))
    1049                 :            :         {
    1050                 :            :           /* Handle the builtin "__analyzer_eval" by evaluating the input
    1051                 :            :              and dumping as a dummy warning, so that test cases can use
    1052                 :            :              dg-warning to validate the result (and so unexpected warnings will
    1053                 :            :              lead to DejaGnu failures).  */
    1054                 :        542 :           tree t_arg = gimple_call_arg (call, 0);
    1055                 :        542 :           tristate t
    1056                 :        542 :             = state->m_region_model->eval_condition (t_arg,
    1057                 :            :                                                      NE_EXPR,
    1058                 :            :                                                      integer_zero_node,
    1059                 :        542 :                                                      &ctxt);
    1060                 :        542 :           warning_at (call->location, 0, "%s", t.as_string ());
    1061                 :            :         }
    1062                 :       3152 :       else if (is_special_named_call_p (call, "__analyzer_break", 0))
    1063                 :            :         {
    1064                 :            :           /* Handle the builtin "__analyzer_break" by triggering a
    1065                 :            :              breakpoint.  */
    1066                 :            :           /* TODO: is there a good cross-platform way to do this?  */
    1067                 :          0 :           raise (SIGINT);
    1068                 :            :         }
    1069                 :       3152 :       else if (is_special_named_call_p (call, "__analyzer_dump_exploded_nodes",
    1070                 :            :                                         1))
    1071                 :            :         {
    1072                 :            :           /* This is handled elsewhere.  */
    1073                 :            :         }
    1074                 :       2975 :       else if (is_setjmp_call_p (call))
    1075                 :         11 :         state->m_region_model->on_setjmp (call, this, &ctxt);
    1076                 :       2964 :       else if (is_longjmp_call_p (call))
    1077                 :            :         {
    1078                 :         15 :           on_longjmp (eg, call, state, &ctxt);
    1079                 :         15 :           return on_stmt_flags::terminate_path ();
    1080                 :            :         }
    1081                 :            :       else
    1082                 :       2949 :         unknown_side_effects = state->m_region_model->on_call_pre (call, &ctxt);
    1083                 :            :     }
    1084                 :            : 
    1085                 :            :   bool any_sm_changes = false;
    1086                 :            :   int sm_idx;
    1087                 :            :   sm_state_map *smap;
    1088                 :      76812 :   FOR_EACH_VEC_ELT (old_state.m_checker_states, sm_idx, smap)
    1089                 :            :     {
    1090                 :      61311 :       const state_machine &sm = eg.get_ext_state ().get_sm (sm_idx);
    1091                 :      61311 :       const sm_state_map *old_smap
    1092                 :      61311 :         = old_state.m_checker_states[sm_idx];
    1093                 :      61311 :       sm_state_map *new_smap = state->m_checker_states[sm_idx];
    1094                 :      61311 :       impl_sm_context sm_ctxt (eg, sm_idx, sm, this, &old_state, state,
    1095                 :            :                                change,
    1096                 :      61311 :                                old_smap, new_smap);
    1097                 :            :       /* Allow the state_machine to handle the stmt.  */
    1098                 :      61311 :       if (sm.on_stmt (&sm_ctxt, snode, stmt))
    1099                 :            :         unknown_side_effects = false;
    1100                 :            :       else
    1101                 :            :         {
    1102                 :            :           /* For those stmts that were not handled by the state machine.  */
    1103                 :      60208 :           if (const gcall *call = dyn_cast <const gcall *> (stmt))
    1104                 :            :             {
    1105                 :      13519 :               tree callee_fndecl
    1106                 :      13519 :                 = state->m_region_model->get_fndecl_for_call (call, &ctxt);
    1107                 :            : 
    1108                 :      13519 :               if (!fndecl_has_gimple_body_p (callee_fndecl))
    1109                 :      11325 :                 new_smap->purge_for_unknown_fncall (eg, sm, call, callee_fndecl,
    1110                 :            :                                                     state->m_region_model,
    1111                 :            :                                                     &ctxt);
    1112                 :            :             }
    1113                 :            :         }
    1114                 :      61311 :       if (*old_smap != *new_smap)
    1115                 :       1363 :         any_sm_changes = true;
    1116                 :            :     }
    1117                 :            : 
    1118                 :      15501 :   if (const gcall *call = dyn_cast <const gcall *> (stmt))
    1119                 :       3684 :     state->m_region_model->on_call_post (call, unknown_side_effects, &ctxt);
    1120                 :            : 
    1121                 :      15501 :   return on_stmt_flags (any_sm_changes);
    1122                 :            : }
    1123                 :            : 
    1124                 :            : /* Consider the effect of following superedge SUCC from this node.
    1125                 :            : 
    1126                 :            :    Return true if it's feasible to follow the edge, or false
    1127                 :            :    if it's infeasible.
    1128                 :            : 
    1129                 :            :    Examples: if it's the "true" branch within
    1130                 :            :    a CFG and we know the conditional is false, we know it's infeasible.
    1131                 :            :    If it's one of multiple interprocedual "return" edges, then only
    1132                 :            :    the edge back to the most recent callsite is feasible.
    1133                 :            : 
    1134                 :            :    Update NEXT_STATE accordingly (e.g. to record that a condition was
    1135                 :            :    true or false, or that the NULL-ness of a pointer has been checked,
    1136                 :            :    pushing/popping stack frames, etc).
    1137                 :            : 
    1138                 :            :    Update NEXT_POINT accordingly (updating the call string).  */
    1139                 :            : 
    1140                 :            : bool
    1141                 :      11448 : exploded_node::on_edge (exploded_graph &eg,
    1142                 :            :                         const superedge *succ,
    1143                 :            :                         program_point *next_point,
    1144                 :            :                         program_state *next_state,
    1145                 :            :                         state_change *change) const
    1146                 :            : {
    1147                 :      22896 :   LOG_FUNC (eg.get_logger ());
    1148                 :            : 
    1149                 :      11448 :   if (!next_point->on_edge (eg, succ))
    1150                 :            :     return false;
    1151                 :            : 
    1152                 :      10461 :   if (!next_state->on_edge (eg, *this, succ, change))
    1153                 :        345 :     return false;
    1154                 :            : 
    1155                 :            :   return true;
    1156                 :            : }
    1157                 :            : 
    1158                 :            : /* Verify that the stack at LONGJMP_POINT is still valid, given a call
    1159                 :            :    to "setjmp" at SETJMP_POINT - the stack frame that "setjmp" was
    1160                 :            :    called in must still be valid.
    1161                 :            : 
    1162                 :            :    Caveat: this merely checks the call_strings in the points; it doesn't
    1163                 :            :    detect the case where a frame returns and is then called again.  */
    1164                 :            : 
    1165                 :            : static bool
    1166                 :         10 : valid_longjmp_stack_p (const program_point &longjmp_point,
    1167                 :            :                        const program_point &setjmp_point)
    1168                 :            : {
    1169                 :         10 :   const call_string &cs_at_longjmp = longjmp_point.get_call_string ();
    1170                 :         10 :   const call_string &cs_at_setjmp = setjmp_point.get_call_string ();
    1171                 :            : 
    1172                 :         18 :   if (cs_at_longjmp.length () < cs_at_setjmp.length ())
    1173                 :            :     return false;
    1174                 :            : 
    1175                 :            :   /* Check that the call strings match, up to the depth of the
    1176                 :            :      setjmp point.  */
    1177                 :          9 :   for (unsigned depth = 0; depth < cs_at_setjmp.length (); depth++)
    1178                 :          0 :     if (cs_at_longjmp[depth] != cs_at_setjmp[depth])
    1179                 :            :       return false;
    1180                 :            : 
    1181                 :            :   return true;
    1182                 :            : }
    1183                 :            : 
    1184                 :            : /* A pending_diagnostic subclass for complaining about bad longjmps,
    1185                 :            :    where the enclosing function of the "setjmp" has returned (and thus
    1186                 :            :    the stack frame no longer exists).  */
    1187                 :            : 
    1188                 :            : class stale_jmp_buf : public pending_diagnostic_subclass<dump_path_diagnostic>
    1189                 :            : {
    1190                 :            : public:
    1191                 :          1 :   stale_jmp_buf (const gcall *setjmp_call, const gcall *longjmp_call)
    1192                 :          1 :   : m_setjmp_call (setjmp_call), m_longjmp_call (longjmp_call)
    1193                 :            :   {}
    1194                 :            : 
    1195                 :          1 :   bool emit (rich_location *richloc) FINAL OVERRIDE
    1196                 :            :   {
    1197                 :          1 :     return warning_at
    1198                 :          1 :       (richloc, OPT_Wanalyzer_stale_setjmp_buffer,
    1199                 :            :        "%qs called after enclosing function of %qs has returned",
    1200                 :            :        get_user_facing_name (m_longjmp_call),
    1201                 :          1 :        get_user_facing_name (m_setjmp_call));
    1202                 :            :   }
    1203                 :            : 
    1204                 :          3 :   const char *get_kind () const FINAL OVERRIDE
    1205                 :          3 :   { return "stale_jmp_buf"; }
    1206                 :            : 
    1207                 :            :   bool operator== (const stale_jmp_buf &other) const
    1208                 :            :   {
    1209                 :            :     return (m_setjmp_call == other.m_setjmp_call
    1210                 :            :             && m_longjmp_call == other.m_longjmp_call);
    1211                 :            :   }
    1212                 :            : 
    1213                 :            : private:
    1214                 :            :   const gcall *m_setjmp_call;
    1215                 :            :   const gcall *m_longjmp_call;
    1216                 :            : };
    1217                 :            : 
    1218                 :            : /* Handle LONGJMP_CALL, a call to longjmp or siglongjmp.
    1219                 :            : 
    1220                 :            :    Attempt to locate where setjmp/sigsetjmp was called on the jmp_buf and build
    1221                 :            :    an exploded_node and exploded_edge to it representing a rewind to that frame,
    1222                 :            :    handling the various kinds of failure that can occur.  */
    1223                 :            : 
    1224                 :            : void
    1225                 :         15 : exploded_node::on_longjmp (exploded_graph &eg,
    1226                 :            :                            const gcall *longjmp_call,
    1227                 :            :                            program_state *new_state,
    1228                 :            :                            region_model_context *ctxt) const
    1229                 :            : {
    1230                 :         15 :   tree buf_ptr = gimple_call_arg (longjmp_call, 0);
    1231                 :            : 
    1232                 :         15 :   region_model *new_region_model = new_state->m_region_model;
    1233                 :         15 :   region_id buf_rid = new_region_model->deref_rvalue (buf_ptr, ctxt);
    1234                 :         15 :   region *buf = new_region_model->get_region (buf_rid);
    1235                 :         15 :   if (!buf)
    1236                 :          6 :     return;
    1237                 :            : 
    1238                 :         15 :   svalue_id buf_content_sid
    1239                 :         15 :     = buf->get_value (*new_region_model, false, ctxt);
    1240                 :         15 :   svalue *buf_content_sval = new_region_model->get_svalue (buf_content_sid);
    1241                 :         15 :   if (!buf_content_sval)
    1242                 :            :     return;
    1243                 :         11 :   setjmp_svalue *setjmp_sval = buf_content_sval->dyn_cast_setjmp_svalue ();
    1244                 :         11 :   if (!setjmp_sval)
    1245                 :            :     return;
    1246                 :            : 
    1247                 :         10 :   const setjmp_record tmp_setjmp_record = setjmp_sval->get_setjmp_record ();
    1248                 :            : 
    1249                 :            :   /* Build a custom enode and eedge for rewinding from the longjmp/siglongjmp
    1250                 :            :      call back to the setjmp/sigsetjmp.  */
    1251                 :         19 :   rewind_info_t rewind_info (tmp_setjmp_record, longjmp_call);
    1252                 :            : 
    1253                 :         10 :   const gcall *setjmp_call = rewind_info.get_setjmp_call ();
    1254                 :         10 :   const program_point &setjmp_point = rewind_info.get_setjmp_point ();
    1255                 :            : 
    1256                 :         10 :   const program_point &longjmp_point = get_point ();
    1257                 :            : 
    1258                 :            :   /* Verify that the setjmp's call_stack hasn't been popped.  */
    1259                 :         10 :   if (!valid_longjmp_stack_p (longjmp_point, setjmp_point))
    1260                 :            :     {
    1261                 :          1 :       ctxt->warn (new stale_jmp_buf (setjmp_call, longjmp_call));
    1262                 :          7 :       return;
    1263                 :            :     }
    1264                 :            : 
    1265                 :         18 :   gcc_assert (longjmp_point.get_stack_depth ()
    1266                 :            :               >= setjmp_point.get_stack_depth ());
    1267                 :            : 
    1268                 :            :   /* Update the state for use by the destination node.  */
    1269                 :            : 
    1270                 :            :   /* Stash the current number of diagnostics so that we can update
    1271                 :            :      any that this adds to show where the longjmp is rewinding to.  */
    1272                 :            : 
    1273                 :          9 :   diagnostic_manager *dm = &eg.get_diagnostic_manager ();
    1274                 :          9 :   unsigned prev_num_diagnostics = dm->get_num_diagnostics ();
    1275                 :            : 
    1276                 :          9 :   new_region_model->on_longjmp (longjmp_call, setjmp_call,
    1277                 :            :                                 setjmp_point.get_stack_depth (), ctxt);
    1278                 :            : 
    1279                 :          9 :   program_point next_point
    1280                 :            :     = program_point::after_supernode (setjmp_point.get_supernode (),
    1281                 :         18 :                                       setjmp_point.get_call_string ());
    1282                 :            : 
    1283                 :         18 :   state_change change;
    1284                 :          9 :   exploded_node *next = eg.get_or_create_node (next_point, *new_state, &change);
    1285                 :            : 
    1286                 :            :   /* Create custom exploded_edge for a longjmp.  */
    1287                 :          9 :   if (next)
    1288                 :            :     {
    1289                 :          9 :       exploded_edge *eedge
    1290                 :          9 :         = eg.add_edge (const_cast<exploded_node *> (this), next, NULL,
    1291                 :            :                        change,
    1292                 :          9 :                        new rewind_info_t (tmp_setjmp_record, longjmp_call));
    1293                 :            : 
    1294                 :            :       /* For any diagnostics that were queued here (such as leaks) we want
    1295                 :            :          the checker_path to show the rewinding events after the "final event"
    1296                 :            :          so that the user sees where the longjmp is rewinding to (otherwise the
    1297                 :            :          path is meaningless).
    1298                 :            : 
    1299                 :            :          For example, we want to emit something like:
    1300                 :            :                         |   NN | {
    1301                 :            :                         |   NN |   longjmp (env, 1);
    1302                 :            :                         |      |   ~~~~~~~~~~~~~~~~
    1303                 :            :                         |      |   |
    1304                 :            :                         |      |   (10) 'ptr' leaks here; was allocated at (7)
    1305                 :            :                         |      |   (11) rewinding from 'longjmp' in 'inner'...
    1306                 :            :                         |
    1307                 :            :           <-------------+
    1308                 :            :           |
    1309                 :            :         'outer': event 12
    1310                 :            :           |
    1311                 :            :           |   NN |   i = setjmp(env);
    1312                 :            :           |      |       ^~~~~~
    1313                 :            :           |      |       |
    1314                 :            :           |      |       (12) ...to 'setjmp' in 'outer' (saved at (2))
    1315                 :            : 
    1316                 :            :          where the "final" event above is event (10), but we want to append
    1317                 :            :          events (11) and (12) afterwards.
    1318                 :            : 
    1319                 :            :          Do this by setting m_trailing_eedge on any diagnostics that were
    1320                 :            :          just saved.  */
    1321                 :          9 :       unsigned num_diagnostics = dm->get_num_diagnostics ();
    1322                 :         12 :       for (unsigned i = prev_num_diagnostics; i < num_diagnostics; i++)
    1323                 :            :         {
    1324                 :          3 :           saved_diagnostic *sd = dm->get_saved_diagnostic (i);
    1325                 :          3 :           sd->m_trailing_eedge = eedge;
    1326                 :            :         }
    1327                 :            :     }
    1328                 :            : }
    1329                 :            : 
    1330                 :            : /* Subroutine of exploded_graph::process_node for finding the successors
    1331                 :            :    of the supernode for a function exit basic block.
    1332                 :            : 
    1333                 :            :    Ensure that pop_frame is called, potentially queuing diagnostics about
    1334                 :            :    leaks.  */
    1335                 :            : 
    1336                 :            : void
    1337                 :       1468 : exploded_node::detect_leaks (exploded_graph &eg) const
    1338                 :            : {
    1339                 :       2510 :   LOG_FUNC_1 (eg.get_logger (), "EN: %i", m_index);
    1340                 :            : 
    1341                 :       1468 :   gcc_assert (get_point ().get_supernode ()->return_p ());
    1342                 :            : 
    1343                 :            :   /* If we're not a "top-level" function, do nothing; pop_frame
    1344                 :            :      will be called when handling the return superedge.  */
    1345                 :       2936 :   if (get_point ().get_stack_depth () > 1)
    1346                 :        426 :     return;
    1347                 :            : 
    1348                 :            :   /* We have a "top-level" function.  */
    1349                 :       2084 :   gcc_assert (get_point ().get_stack_depth () == 1);
    1350                 :            : 
    1351                 :       1042 :   const program_state &old_state = get_state ();
    1352                 :            : 
    1353                 :            :   /* Work with a temporary copy of the state: pop the frame, and see
    1354                 :            :      what leaks (via purge_unused_svalues).  */
    1355                 :       1042 :   program_state new_state (old_state);
    1356                 :            : 
    1357                 :       1042 :   gcc_assert (new_state.m_region_model);
    1358                 :            : 
    1359                 :       1042 :   purge_stats stats;
    1360                 :       1042 :   impl_region_model_context ctxt (eg, this,
    1361                 :            :                                   &old_state, &new_state,
    1362                 :            :                                   NULL,
    1363                 :       2084 :                                   get_stmt ());
    1364                 :       1042 :   new_state.m_region_model->pop_frame (true, &stats, &ctxt);
    1365                 :            : }
    1366                 :            : 
    1367                 :            : /* Dump the successors and predecessors of this enode to OUTF.  */
    1368                 :            : 
    1369                 :            : void
    1370                 :          0 : exploded_node::dump_succs_and_preds (FILE *outf) const
    1371                 :            : {
    1372                 :          0 :   unsigned i;
    1373                 :          0 :   exploded_edge *e;
    1374                 :          0 :   {
    1375                 :          0 :     auto_vec<exploded_node *> preds (m_preds.length ());
    1376                 :          0 :     FOR_EACH_VEC_ELT (m_preds, i, e)
    1377                 :          0 :       preds.quick_push (e->m_src);
    1378                 :          0 :     pretty_printer pp;
    1379                 :          0 :     print_enode_indices (&pp, preds);
    1380                 :          0 :     fprintf (outf, "preds: %s\n",
    1381                 :            :              pp_formatted_text (&pp));
    1382                 :            :   }
    1383                 :          0 :   {
    1384                 :          0 :     auto_vec<exploded_node *> succs (m_succs.length ());
    1385                 :          0 :     FOR_EACH_VEC_ELT (m_succs, i, e)
    1386                 :          0 :       succs.quick_push (e->m_dest);
    1387                 :          0 :     pretty_printer pp;
    1388                 :          0 :     print_enode_indices (&pp, succs);
    1389                 :          0 :     fprintf (outf, "succs: %s\n",
    1390                 :            :              pp_formatted_text (&pp));
    1391                 :            :   }
    1392                 :          0 : }
    1393                 :            : 
    1394                 :            : /* class rewind_info_t : public exploded_edge::custom_info_t.  */
    1395                 :            : 
    1396                 :            : /* Implementation of exploded_edge::custom_info_t::update_model vfunc
    1397                 :            :    for rewind_info_t.
    1398                 :            : 
    1399                 :            :    Update state for the special-case of a rewind of a longjmp
    1400                 :            :    to a setjmp (which doesn't have a superedge, but does affect
    1401                 :            :    state).  */
    1402                 :            : 
    1403                 :            : void
    1404                 :          5 : rewind_info_t::update_model (region_model *model,
    1405                 :            :                              const exploded_edge &eedge)
    1406                 :            : {
    1407                 :          5 :   const program_point &longjmp_point = eedge.m_src->get_point ();
    1408                 :          5 :   const program_point &setjmp_point = eedge.m_dest->get_point ();
    1409                 :            : 
    1410                 :         15 :   gcc_assert (longjmp_point.get_stack_depth ()
    1411                 :            :               >= setjmp_point.get_stack_depth ());
    1412                 :            : 
    1413                 :         10 :   model->on_longjmp (get_longjmp_call (),
    1414                 :            :                      get_setjmp_call (),
    1415                 :            :                      setjmp_point.get_stack_depth (), NULL);
    1416                 :          5 : }
    1417                 :            : 
    1418                 :            : /* Implementation of exploded_edge::custom_info_t::add_events_to_path vfunc
    1419                 :            :    for rewind_info_t.  */
    1420                 :            : 
    1421                 :            : void
    1422                 :          8 : rewind_info_t::add_events_to_path (checker_path *emission_path,
    1423                 :            :                                    const exploded_edge &eedge)
    1424                 :            : {
    1425                 :          8 :   const exploded_node *src_node = eedge.m_src;
    1426                 :          8 :   const program_point &src_point = src_node->get_point ();
    1427                 :          8 :   const int src_stack_depth = src_point.get_stack_depth ();
    1428                 :          8 :   const exploded_node *dst_node = eedge.m_dest;
    1429                 :          8 :   const program_point &dst_point = dst_node->get_point ();
    1430                 :          8 :   const int dst_stack_depth = dst_point.get_stack_depth ();
    1431                 :            : 
    1432                 :          8 :   emission_path->add_event
    1433                 :          8 :     (new rewind_from_longjmp_event
    1434                 :          8 :      (&eedge, get_longjmp_call ()->location,
    1435                 :          8 :       src_point.get_fndecl (),
    1436                 :          8 :       src_stack_depth, this));
    1437                 :          8 :   emission_path->add_event
    1438                 :          8 :     (new rewind_to_setjmp_event
    1439                 :          8 :      (&eedge, get_setjmp_call ()->location,
    1440                 :          8 :       dst_point.get_fndecl (),
    1441                 :          8 :       dst_stack_depth, this));
    1442                 :          8 : }
    1443                 :            : 
    1444                 :            : /* class exploded_edge : public dedge<eg_traits>.  */
    1445                 :            : 
    1446                 :            : /* exploded_edge's ctor.  */
    1447                 :            : 
    1448                 :      28362 : exploded_edge::exploded_edge (exploded_node *src, exploded_node *dest,
    1449                 :            :                               const extrinsic_state &ext_state,
    1450                 :            :                               const superedge *sedge,
    1451                 :            :                               const state_change &change,
    1452                 :      28362 :                               custom_info_t *custom_info)
    1453                 :            : : dedge<eg_traits> (src, dest), m_sedge (sedge), m_change (change),
    1454                 :      28362 :   m_custom_info (custom_info)
    1455                 :            : {
    1456                 :      28362 :   change.validate (dest->get_state (), ext_state);
    1457                 :      28362 : }
    1458                 :            : 
    1459                 :            : /* exploded_edge's dtor.  */
    1460                 :            : 
    1461                 :      56724 : exploded_edge::~exploded_edge ()
    1462                 :            : {
    1463                 :      28362 :   delete m_custom_info;
    1464                 :      56724 : }
    1465                 :            : 
    1466                 :            : /* Implementation of dedge::dump_dot vfunc for exploded_edge.
    1467                 :            :    Use the label of the underlying superedge, if any.  */
    1468                 :            : 
    1469                 :            : void
    1470                 :         79 : exploded_edge::dump_dot (graphviz_out *gv, const dump_args_t &args) const
    1471                 :            : {
    1472                 :         79 :   pretty_printer *pp = gv->get_pp ();
    1473                 :            : 
    1474                 :         79 :   const char *style = "\"solid,bold\"";
    1475                 :         79 :   const char *color = "black";
    1476                 :         79 :   int weight = 10;
    1477                 :         79 :   const char *constraint = "true";
    1478                 :            : 
    1479                 :         79 :   if (m_sedge)
    1480                 :         25 :     switch (m_sedge->m_kind)
    1481                 :            :       {
    1482                 :          0 :       default:
    1483                 :          0 :         gcc_unreachable ();
    1484                 :            :       case SUPEREDGE_CFG_EDGE:
    1485                 :            :         break;
    1486                 :          1 :       case SUPEREDGE_CALL:
    1487                 :          1 :         color = "red";
    1488                 :            :         //constraint = "false";
    1489                 :          1 :         break;
    1490                 :          1 :       case SUPEREDGE_RETURN:
    1491                 :          1 :         color = "green";
    1492                 :            :         //constraint = "false";
    1493                 :          1 :         break;
    1494                 :          0 :       case SUPEREDGE_INTRAPROCEDURAL_CALL:
    1495                 :          0 :         style = "\"dotted\"";
    1496                 :          0 :         break;
    1497                 :            :       }
    1498                 :         79 :   if (m_custom_info)
    1499                 :            :     {
    1500                 :          0 :       color = "red";
    1501                 :          0 :       style = "\"dotted\"";
    1502                 :            :     }
    1503                 :            : 
    1504                 :         79 :   m_src->dump_dot_id (pp);
    1505                 :         79 :   pp_string (pp, " -> ");
    1506                 :         79 :   m_dest->dump_dot_id (pp);
    1507                 :         79 :   pp_printf (pp,
    1508                 :            :              (" [style=%s, color=%s, weight=%d, constraint=%s,"
    1509                 :            :               " headlabel=\""),
    1510                 :            :              style, color, weight, constraint);
    1511                 :            : 
    1512                 :         79 :   if (m_sedge)
    1513                 :         25 :     m_sedge->dump_label_to_pp (pp, false);
    1514                 :         54 :   else if (m_custom_info)
    1515                 :          0 :     m_custom_info->print (pp);
    1516                 :            : 
    1517                 :         79 :   m_change.dump (pp, args.m_eg.get_ext_state ());
    1518                 :            :   //pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/false);
    1519                 :            : 
    1520                 :         79 :   pp_printf (pp, "\"];\n");
    1521                 :         79 : }
    1522                 :            : 
    1523                 :            : /* struct stats.  */
    1524                 :            : 
    1525                 :            : /* stats' ctor.  */
    1526                 :            : 
    1527                 :       2499 : stats::stats (int num_supernodes)
    1528                 :            : : m_node_reuse_count (0),
    1529                 :            :   m_node_reuse_after_merge_count (0),
    1530                 :       2499 :   m_num_supernodes (num_supernodes)
    1531                 :            : {
    1532                 :      17493 :   for (int i = 0; i < NUM_POINT_KINDS; i++)
    1533                 :      14994 :     m_num_nodes[i] = 0;
    1534                 :       2499 : }
    1535                 :            : 
    1536                 :            : /* Log these stats in multiline form to LOGGER.  */
    1537                 :            : 
    1538                 :            : void
    1539                 :          0 : stats::log (logger *logger) const
    1540                 :            : {
    1541                 :          0 :   gcc_assert (logger);
    1542                 :          0 :   for (int i = 0; i < NUM_POINT_KINDS; i++)
    1543                 :          0 :     if (m_num_nodes[i] > 0)
    1544                 :          0 :       logger->log ("m_num_nodes[%s]: %i",
    1545                 :            :                    point_kind_to_string (static_cast <enum point_kind> (i)),
    1546                 :            :                    m_num_nodes[i]);
    1547                 :          0 :   logger->log ("m_node_reuse_count: %i", m_node_reuse_count);
    1548                 :          0 :   logger->log ("m_node_reuse_after_merge_count: %i",
    1549                 :          0 :                m_node_reuse_after_merge_count);
    1550                 :          0 : }
    1551                 :            : 
    1552                 :            : /* Dump these stats in multiline form to OUT.  */
    1553                 :            : 
    1554                 :            : void
    1555                 :          0 : stats::dump (FILE *out) const
    1556                 :            : {
    1557                 :          0 :   for (int i = 0; i < NUM_POINT_KINDS; i++)
    1558                 :          0 :     if (m_num_nodes[i] > 0)
    1559                 :          0 :       fprintf (out, "m_num_nodes[%s]: %i\n",
    1560                 :            :                point_kind_to_string (static_cast <enum point_kind> (i)),
    1561                 :            :                m_num_nodes[i]);
    1562                 :          0 :   fprintf (out, "m_node_reuse_count: %i\n", m_node_reuse_count);
    1563                 :          0 :   fprintf (out, "m_node_reuse_after_merge_count: %i\n",
    1564                 :          0 :            m_node_reuse_after_merge_count);
    1565                 :            : 
    1566                 :          0 :   if (m_num_supernodes > 0)
    1567                 :          0 :     fprintf (out, "PK_AFTER_SUPERNODE nodes per supernode: %.2f\n",
    1568                 :          0 :              (float)m_num_nodes[PK_AFTER_SUPERNODE] / (float)m_num_supernodes);
    1569                 :          0 : }
    1570                 :            : 
    1571                 :            : /* Return the total number of enodes recorded within this object.  */
    1572                 :            : 
    1573                 :            : int
    1574                 :          0 : stats::get_total_enodes () const
    1575                 :            : {
    1576                 :          0 :   int result = 0;
    1577                 :          0 :   for (int i = 0; i < NUM_POINT_KINDS; i++)
    1578                 :          0 :     result += m_num_nodes[i];
    1579                 :          0 :   return result;
    1580                 :            : }
    1581                 :            : 
    1582                 :            : /* strongly_connected_components's ctor.  Tarjan's SCC algorithm.  */
    1583                 :            : 
    1584                 :        377 : strongly_connected_components::
    1585                 :        377 : strongly_connected_components (const supergraph &sg, logger *logger)
    1586                 :        754 : : m_sg (sg), m_per_node (m_sg.num_nodes ())
    1587                 :            : {
    1588                 :        377 :   LOG_SCOPE (logger);
    1589                 :        754 :   auto_timevar tv (TV_ANALYZER_SCC);
    1590                 :            : 
    1591                 :      10704 :   for (int i = 0; i < m_sg.num_nodes (); i++)
    1592                 :       4975 :     m_per_node.quick_push (per_node_data ());
    1593                 :            : 
    1594                 :      10704 :   for (int i = 0; i < m_sg.num_nodes (); i++)
    1595                 :       4975 :     if (m_per_node[i].m_index == -1)
    1596                 :        822 :       strong_connect (i);
    1597                 :            : 
    1598                 :        377 :   if (0)
    1599                 :            :     dump ();
    1600                 :        377 : }
    1601                 :            : 
    1602                 :            : /* Dump this object to stderr.  */
    1603                 :            : 
    1604                 :            : DEBUG_FUNCTION void
    1605                 :          0 : strongly_connected_components::dump () const
    1606                 :            : {
    1607                 :          0 :   for (int i = 0; i < m_sg.num_nodes (); i++)
    1608                 :            :     {
    1609                 :          0 :       const per_node_data &v = m_per_node[i];
    1610                 :          0 :       fprintf (stderr, "SN %i: index: %i lowlink: %i on_stack: %i\n",
    1611                 :          0 :                i, v.m_index, v.m_lowlink, v.m_on_stack);
    1612                 :            :     }
    1613                 :          0 : }
    1614                 :            : 
    1615                 :            : /* Subroutine of strongly_connected_components's ctor, part of Tarjan's
    1616                 :            :    SCC algorithm.  */
    1617                 :            : 
    1618                 :            : void
    1619                 :       4975 : strongly_connected_components::strong_connect (unsigned index)
    1620                 :            : {
    1621                 :       4975 :   supernode *v_snode = m_sg.get_node_by_index (index);
    1622                 :            : 
    1623                 :            :   /* Set the depth index for v to the smallest unused index.  */
    1624                 :       4975 :   per_node_data *v = &m_per_node[index];
    1625                 :       4975 :   v->m_index = index;
    1626                 :       4975 :   v->m_lowlink = index;
    1627                 :       4975 :   m_stack.safe_push (index);
    1628                 :       4975 :   v->m_on_stack = true;
    1629                 :       4975 :   index++;
    1630                 :            : 
    1631                 :            :   /* Consider successors of v.  */
    1632                 :       4975 :   unsigned i;
    1633                 :       4975 :   superedge *sedge;
    1634                 :      10188 :   FOR_EACH_VEC_ELT (v_snode->m_succs, i, sedge)
    1635                 :            :     {
    1636                 :       5213 :       supernode *w_snode = sedge->m_dest;
    1637                 :       5213 :       per_node_data *w = &m_per_node[w_snode->m_index];
    1638                 :       5213 :       if (w->m_index == -1)
    1639                 :            :         {
    1640                 :            :           /* Successor w has not yet been visited; recurse on it.  */
    1641                 :       4153 :           strong_connect (w_snode->m_index);
    1642                 :       4153 :           v->m_lowlink = MIN (v->m_lowlink, w->m_lowlink);
    1643                 :            :         }
    1644                 :       1060 :       else if (w->m_on_stack)
    1645                 :            :         {
    1646                 :            :           /* Successor w is in stack S and hence in the current SCC
    1647                 :            :              If w is not on stack, then (v, w) is a cross-edge in the DFS
    1648                 :            :              tree and must be ignored.  */
    1649                 :        306 :           v->m_lowlink = MIN (v->m_lowlink, w->m_index);
    1650                 :            :         }
    1651                 :            :     }
    1652                 :            : 
    1653                 :            :   /* If v is a root node, pop the stack and generate an SCC.  */
    1654                 :            : 
    1655                 :       4975 :   if (v->m_lowlink == v->m_index)
    1656                 :            :     {
    1657                 :       4975 :       per_node_data *w;
    1658                 :       4975 :       do {
    1659                 :       4975 :         int idx = m_stack.pop ();
    1660                 :       4975 :         w = &m_per_node[idx];
    1661                 :       4975 :         w->m_on_stack = false;
    1662                 :       4975 :       } while (w != v);
    1663                 :            :     }
    1664                 :       4975 : }
    1665                 :            : 
    1666                 :            : /* worklist's ctor.  */
    1667                 :            : 
    1668                 :        377 : worklist::worklist (const exploded_graph &eg, const analysis_plan &plan)
    1669                 :            : : m_scc (eg.get_supergraph (), eg.get_logger ()),
    1670                 :            :   m_plan (plan),
    1671                 :        377 :   m_queue (key_t (*this, NULL))
    1672                 :            : {
    1673                 :        377 : }
    1674                 :            : 
    1675                 :            : /* Return the number of nodes in the worklist.  */
    1676                 :            : 
    1677                 :            : unsigned
    1678                 :      26956 : worklist::length () const
    1679                 :            : {
    1680                 :      26956 :   return m_queue.nodes ();
    1681                 :            : }
    1682                 :            : 
    1683                 :            : /* Return the next node in the worklist, removing it.  */
    1684                 :            : 
    1685                 :            : exploded_node *
    1686                 :      26798 : worklist::take_next ()
    1687                 :            : {
    1688                 :      26798 :   return m_queue.extract_min ();
    1689                 :            : }
    1690                 :            : 
    1691                 :            : /* Return the next node in the worklist without removing it.  */
    1692                 :            : 
    1693                 :            : exploded_node *
    1694                 :      26133 : worklist::peek_next ()
    1695                 :            : {
    1696                 :      26133 :   return m_queue.min ();
    1697                 :            : }
    1698                 :            : 
    1699                 :            : /* Add ENODE to the worklist.  */
    1700                 :            : 
    1701                 :            : void
    1702                 :      26921 : worklist::add_node (exploded_node *enode)
    1703                 :            : {
    1704                 :      26921 :   gcc_assert (enode->get_status () == exploded_node::STATUS_WORKLIST);
    1705                 :      26921 :   m_queue.insert (key_t (*this, enode), enode);
    1706                 :      26921 : }
    1707                 :            : 
    1708                 :            : /* Comparator for implementing worklist::key_t comparison operators.
    1709                 :            :    Return negative if KA is before KB
    1710                 :            :    Return positive if KA is after KB
    1711                 :            :    Return 0 if they are equal.  */
    1712                 :            : 
    1713                 :            : int
    1714                 :      95257 : worklist::key_t::cmp (const worklist::key_t &ka, const worklist::key_t &kb)
    1715                 :            : {
    1716                 :      95257 :   const program_point &point_a = ka.m_enode->get_point ();
    1717                 :      95257 :   const program_point &point_b = kb.m_enode->get_point ();
    1718                 :      95257 :   const call_string &call_string_a = point_a.get_call_string ();
    1719                 :      95257 :   const call_string &call_string_b = point_b.get_call_string ();
    1720                 :            : 
    1721                 :            :   /* Order empty-callstring points with different functions based on the
    1722                 :            :      analysis_plan, so that we generate summaries before they are used.  */
    1723                 :      95257 :   if (flag_analyzer_call_summaries
    1724                 :      77314 :       && call_string_a.empty_p ()
    1725                 :      74944 :       && call_string_b.empty_p ()
    1726                 :      74944 :       && point_a.get_function () != NULL
    1727                 :      74082 :       && point_b.get_function () != NULL
    1728                 :     169339 :       && point_a.get_function () != point_b.get_function ())
    1729                 :            :     {
    1730                 :      23090 :       return ka.m_worklist.m_plan.cmp_function (point_a.get_function (),
    1731                 :      23090 :                                                 point_b.get_function ());
    1732                 :            :     }
    1733                 :            : 
    1734                 :            :   /* First, order by SCC.  */
    1735                 :      72167 :   int scc_id_a = ka.get_scc_id (ka.m_enode);
    1736                 :      72167 :   int scc_id_b = kb.get_scc_id (kb.m_enode);
    1737                 :      72167 :   if (scc_id_a != scc_id_b)
    1738                 :      37891 :     return scc_id_a - scc_id_b;
    1739                 :            : 
    1740                 :            :   /* If in same SCC, order by supernode index (an arbitrary but stable
    1741                 :            :      ordering).  */
    1742                 :      34276 :   const supernode *snode_a = ka.m_enode->get_supernode ();
    1743                 :      34276 :   const supernode *snode_b = kb.m_enode->get_supernode ();
    1744                 :      34276 :   if (snode_a == NULL)
    1745                 :            :     {
    1746                 :          0 :       if (snode_b != NULL)
    1747                 :            :         /* One is NULL.  */
    1748                 :            :         return -1;
    1749                 :            :       else
    1750                 :            :         /* Both are NULL.  */
    1751                 :          0 :         return 0;
    1752                 :            :     }
    1753                 :      34276 :   if (snode_b == NULL)
    1754                 :            :     /* One is NULL.  */
    1755                 :            :     return 1;
    1756                 :            :   /* Neither are NULL.  */
    1757                 :      33899 :   gcc_assert (snode_a && snode_b);
    1758                 :      33899 :   if (snode_a->m_index != snode_b->m_index)
    1759                 :       5383 :     return snode_a->m_index - snode_b->m_index;
    1760                 :            : 
    1761                 :      28516 :   gcc_assert (snode_a == snode_b);
    1762                 :            : 
    1763                 :            :   /* Order within supernode via program point.  */
    1764                 :      28516 :   int within_snode_cmp
    1765                 :      28516 :     = function_point::cmp_within_supernode (point_a.get_function_point (),
    1766                 :            :                                             point_b.get_function_point ());
    1767                 :      28516 :   if (within_snode_cmp)
    1768                 :            :     return within_snode_cmp;
    1769                 :            : 
    1770                 :            :   /* The points might vary by callstring; try sorting by callstring.  */
    1771                 :      19525 :   int cs_cmp = call_string::cmp (call_string_a, call_string_b);
    1772                 :      19525 :   if (cs_cmp)
    1773                 :            :     return cs_cmp;
    1774                 :            : 
    1775                 :            :   /* Otherwise, we ought to have the same program_point.  */
    1776                 :      18439 :   gcc_assert (point_a == point_b);
    1777                 :            : 
    1778                 :      18439 :   const program_state &state_a = ka.m_enode->get_state ();
    1779                 :      18439 :   const program_state &state_b = kb.m_enode->get_state ();
    1780                 :            : 
    1781                 :            :   /* Sort by sm-state, so that identical sm-states are grouped
    1782                 :            :      together in the worklist.
    1783                 :            :      For now, sort by the hash value (might not be deterministic).  */
    1784                 :      71134 :   for (unsigned sm_idx = 0; sm_idx < state_a.m_checker_states.length ();
    1785                 :            :        ++sm_idx)
    1786                 :            :     {
    1787                 :      31307 :       sm_state_map *smap_a = state_a.m_checker_states[sm_idx];
    1788                 :      31307 :       sm_state_map *smap_b = state_b.m_checker_states[sm_idx];
    1789                 :            : 
    1790                 :      31307 :       hashval_t hash_a = smap_a->hash ();
    1791                 :      31307 :       hashval_t hash_b = smap_b->hash ();
    1792                 :      31307 :       if (hash_a < hash_b)
    1793                 :            :         return -1;
    1794                 :      26670 :       else if (hash_a > hash_b)
    1795                 :            :         return 1;
    1796                 :            :     }
    1797                 :            : 
    1798                 :            :   /* Otherwise, we have two enodes at the same program point but with
    1799                 :            :      different states.  We don't have a good total ordering on states,
    1800                 :            :      so order them by enode index, so that we have at least have a
    1801                 :            :      stable sort.  */
    1802                 :       4260 :   return ka.m_enode->m_index - kb.m_enode->m_index;
    1803                 :            : }
    1804                 :            : 
    1805                 :            : /* exploded_graph's ctor.  */
    1806                 :            : 
    1807                 :        377 : exploded_graph::exploded_graph (const supergraph &sg, logger *logger,
    1808                 :            :                                 const extrinsic_state &ext_state,
    1809                 :            :                                 const state_purge_map *purge_map,
    1810                 :            :                                 const analysis_plan &plan,
    1811                 :        377 :                                 int verbosity)
    1812                 :            : : m_sg (sg), m_logger (logger),
    1813                 :            :   m_worklist (*this, plan),
    1814                 :            :   m_ext_state (ext_state),
    1815                 :            :   m_purge_map (purge_map),
    1816                 :            :   m_plan (plan),
    1817                 :            :   m_diagnostic_manager (logger, verbosity),
    1818                 :        377 :   m_global_stats (m_sg.num_nodes ()),
    1819                 :        377 :   m_functionless_stats (m_sg.num_nodes ()),
    1820                 :       1508 :   m_PK_AFTER_SUPERNODE_per_snode (m_sg.num_nodes ())
    1821                 :            : {
    1822                 :        377 :   m_origin = get_or_create_node (program_point (function_point (NULL, NULL,
    1823                 :            :                                                                 0, PK_ORIGIN),
    1824                 :        377 :                                                 call_string ()),
    1825                 :        754 :                                  program_state (ext_state), NULL);
    1826                 :      10704 :   for (int i = 0; i < m_sg.num_nodes (); i++)
    1827                 :       4975 :     m_PK_AFTER_SUPERNODE_per_snode.quick_push (i);
    1828                 :        377 : }
    1829                 :            : 
    1830                 :            : /* exploded_graph's dtor.  */
    1831                 :            : 
    1832                 :       1131 : exploded_graph::~exploded_graph ()
    1833                 :            : {
    1834                 :       1351 :   for (function_stat_map_t::iterator iter = m_per_function_stats.begin ();
    1835                 :       1351 :        iter != m_per_function_stats.end ();
    1836                 :       1351 :        ++iter)
    1837                 :        974 :     delete (*iter).second;
    1838                 :            : 
    1839                 :      36094 :   for (point_map_t::iterator iter = m_per_point_data.begin ();
    1840                 :        377 :        iter != m_per_point_data.end ();
    1841                 :      18047 :        ++iter)
    1842                 :      17670 :     delete (*iter).second;
    1843                 :        377 : }
    1844                 :            : 
    1845                 :            : /* Ensure that there is an exploded_node representing an external call to
    1846                 :            :    FUN, adding it to the worklist if creating it.
    1847                 :            : 
    1848                 :            :    Add an edge from the origin exploded_node to the function entrypoint
    1849                 :            :    exploded_node.
    1850                 :            : 
    1851                 :            :    Return the exploded_node for the entrypoint to the function.  */
    1852                 :            : 
    1853                 :            : exploded_node *
    1854                 :        910 : exploded_graph::add_function_entry (function *fun)
    1855                 :            : {
    1856                 :        910 :   program_point point = program_point::from_function_entry (m_sg, fun);
    1857                 :       1820 :   program_state state (m_ext_state);
    1858                 :       1820 :   impl_region_model_context ctxt (&state, NULL, m_ext_state, get_logger ());
    1859                 :        910 :   state.m_region_model->push_frame (fun, NULL, &ctxt);
    1860                 :            : 
    1861                 :        910 :   if (!state.m_valid)
    1862                 :            :     return NULL;
    1863                 :            : 
    1864                 :        904 :   exploded_node *enode = get_or_create_node (point, state, NULL);
    1865                 :            :   /* We should never fail to add such a node.  */
    1866                 :        904 :   gcc_assert (enode);
    1867                 :       1814 :   state_change change;
    1868                 :        904 :   add_edge (m_origin, enode, NULL, change);
    1869                 :        904 :   return enode;
    1870                 :            : }
    1871                 :            : 
    1872                 :            : /* Get or create an exploded_node for (POINT, STATE).
    1873                 :            :    If a new node is created, it is added to the worklist.
    1874                 :            :    If CHANGE is non-NULL, use it to suppress some purging of state,
    1875                 :            :    to make generation of state_change_event instances easier.  */
    1876                 :            : 
    1877                 :            : exploded_node *
    1878                 :      28664 : exploded_graph::get_or_create_node (const program_point &point,
    1879                 :            :                                     const program_state &state,
    1880                 :            :                                     state_change *change)
    1881                 :            : {
    1882                 :      28664 :   logger * const logger = get_logger ();
    1883                 :      57328 :   LOG_FUNC (logger);
    1884                 :      28664 :   if (logger)
    1885                 :            :     {
    1886                 :          0 :       format f (false);
    1887                 :          0 :       pretty_printer *pp = logger->get_printer ();
    1888                 :          0 :       logger->start_log_line ();
    1889                 :          0 :       pp_string (pp, "point: ");
    1890                 :          0 :       point.print (pp, f);
    1891                 :          0 :       logger->end_log_line ();
    1892                 :          0 :       logger->start_log_line ();
    1893                 :          0 :       pp_string (pp, "state: ");
    1894                 :          0 :       state.dump_to_pp (m_ext_state, true, pp);
    1895                 :          0 :       logger->end_log_line ();
    1896                 :            :     }
    1897                 :            : 
    1898                 :            :   /* Stop exploring paths for which we don't know how to effectively
    1899                 :            :      model the state.  */
    1900                 :      28664 :   if (!state.m_valid)
    1901                 :            :     {
    1902                 :         27 :       if (logger)
    1903                 :          0 :         logger->log ("invalid state; not creating node");
    1904                 :         27 :       return NULL;
    1905                 :            :     }
    1906                 :            : 
    1907                 :      56897 :   auto_cfun sentinel (point.get_function ());
    1908                 :            : 
    1909                 :      28637 :   state.validate (get_ext_state ());
    1910                 :            : 
    1911                 :            :   //state.dump (get_ext_state ());
    1912                 :            : 
    1913                 :            :   /* Prune state to try to improve the chances of a cache hit,
    1914                 :            :      avoiding generating redundant nodes.  */
    1915                 :      57274 :   program_state pruned_state = state.prune_for_point (*this, point, change);
    1916                 :            : 
    1917                 :      28637 :   pruned_state.validate (get_ext_state ());
    1918                 :            : 
    1919                 :            :   //pruned_state.dump (get_ext_state ());
    1920                 :            : 
    1921                 :      28637 :   if (logger)
    1922                 :            :     {
    1923                 :          0 :       pretty_printer *pp = logger->get_printer ();
    1924                 :          0 :       logger->start_log_line ();
    1925                 :          0 :       pp_string (pp, "pruned_state: ");
    1926                 :          0 :       pruned_state.dump_to_pp (m_ext_state, true, pp);
    1927                 :          0 :       logger->end_log_line ();
    1928                 :          0 :       pruned_state.m_region_model->dump_to_pp (logger->get_printer (), true);
    1929                 :            :     }
    1930                 :            : 
    1931                 :      56897 :   stats *per_fn_stats = get_or_create_function_stats (point.get_function ());
    1932                 :            : 
    1933                 :      28637 :   stats *per_cs_stats
    1934                 :      28637 :     = &get_or_create_per_call_string_data (point.get_call_string ())->m_stats;
    1935                 :            : 
    1936                 :      57274 :   point_and_state ps (point, pruned_state);
    1937                 :      28637 :   ps.validate (m_ext_state);
    1938                 :      28637 :   if (exploded_node **slot = m_point_and_state_to_node.get (&ps))
    1939                 :            :     {
    1940                 :            :       /* An exploded_node for PS already exists.  */
    1941                 :        337 :       if (logger)
    1942                 :          0 :         logger->log ("reused EN: %i", (*slot)->m_index);
    1943                 :        337 :       m_global_stats.m_node_reuse_count++;
    1944                 :        337 :       per_fn_stats->m_node_reuse_count++;
    1945                 :        337 :       per_cs_stats->m_node_reuse_count++;
    1946                 :        337 :       return *slot;
    1947                 :            :     }
    1948                 :            : 
    1949                 :      28300 :   per_program_point_data *per_point_data
    1950                 :      28300 :     = get_or_create_per_program_point_data (point);
    1951                 :            : 
    1952                 :            :   /* Consider merging state with another enode at this program_point.  */
    1953                 :      28300 :   if (flag_analyzer_state_merge)
    1954                 :            :     {
    1955                 :            :       exploded_node *existing_enode;
    1956                 :            :       unsigned i;
    1957                 :     196463 :       FOR_EACH_VEC_ELT (per_point_data->m_enodes, i, existing_enode)
    1958                 :            :         {
    1959                 :     169480 :           if (logger)
    1960                 :          0 :             logger->log ("considering merging with existing EN: %i for point",
    1961                 :          0 :                          existing_enode->m_index);
    1962                 :     169480 :           gcc_assert (existing_enode->get_point () == point);
    1963                 :     169480 :           const program_state &existing_state = existing_enode->get_state ();
    1964                 :            : 
    1965                 :            :           /* This merges successfully within the loop.  */
    1966                 :            : 
    1967                 :     337726 :           program_state merged_state (m_ext_state);
    1968                 :     169480 :           if (pruned_state.can_merge_with_p (existing_state, m_ext_state,
    1969                 :            :                                              &merged_state))
    1970                 :            :             {
    1971                 :       4237 :               if (logger)
    1972                 :          0 :                 logger->log ("merging new state with that of EN: %i",
    1973                 :          0 :                              existing_enode->m_index);
    1974                 :            : 
    1975                 :            :               /* Try again for a cache hit.
    1976                 :            :                  Whether we get one or not, merged_state's value_ids have no
    1977                 :            :                  relationship to those of the input state, and thus to those
    1978                 :            :                  of CHANGE, so we must purge any svalue_ids from *CHANGE.  */
    1979                 :       4237 :               ps.set_state (merged_state);
    1980                 :       4237 :               if (change)
    1981                 :       4237 :                 change->on_svalue_purge (svalue_id::from_int (0));
    1982                 :            : 
    1983                 :       4237 :               if (exploded_node **slot = m_point_and_state_to_node.get (&ps))
    1984                 :            :                 {
    1985                 :            :                   /* An exploded_node for PS already exists.  */
    1986                 :       1234 :                   if (logger)
    1987                 :          0 :                     logger->log ("reused EN: %i", (*slot)->m_index);
    1988                 :       1234 :                   m_global_stats.m_node_reuse_after_merge_count++;
    1989                 :       1234 :                   per_fn_stats->m_node_reuse_after_merge_count++;
    1990                 :       1234 :                   per_cs_stats->m_node_reuse_after_merge_count++;
    1991                 :       1234 :                   return *slot;
    1992                 :            :                 }
    1993                 :            :             }
    1994                 :            :           else
    1995                 :     165243 :             if (logger)
    1996                 :          0 :               logger->log ("not merging new state with that of EN: %i",
    1997                 :          0 :                            existing_enode->m_index);
    1998                 :            :         }
    1999                 :            :     }
    2000                 :            : 
    2001                 :            :   /* Impose a limit on the number of enodes per program point, and
    2002                 :            :      simply stop if we exceed it.  */
    2003                 :      27066 :   if ((int)per_point_data->m_enodes.length ()
    2004                 :      27066 :       > param_analyzer_max_enodes_per_program_point)
    2005                 :            :     {
    2006                 :        231 :       if (logger)
    2007                 :          0 :         logger->log ("not creating enode; too many at program point");
    2008                 :        231 :       warning_at (point.get_location (), OPT_Wanalyzer_too_complex,
    2009                 :            :                   "terminating analysis for this program point");
    2010                 :        231 :       per_point_data->m_excess_enodes++;
    2011                 :        231 :       return NULL;
    2012                 :            :     }
    2013                 :            : 
    2014                 :      26835 :   ps.validate (m_ext_state);
    2015                 :            : 
    2016                 :            :   /* An exploded_node for "ps" doesn't already exist; create one.  */
    2017                 :      53293 :   exploded_node *node = new exploded_node (ps, m_nodes.length ());
    2018                 :      26835 :   add_node (node);
    2019                 :      26835 :   m_point_and_state_to_node.put (node->get_ps_key (), node);
    2020                 :            : 
    2021                 :            :   /* Update per-program_point data.  */
    2022                 :      26835 :   per_point_data->m_enodes.safe_push (node);
    2023                 :            : 
    2024                 :      26835 :   const enum point_kind node_pk = node->get_point ().get_kind ();
    2025                 :      26835 :   m_global_stats.m_num_nodes[node_pk]++;
    2026                 :      26835 :   per_fn_stats->m_num_nodes[node_pk]++;
    2027                 :      26835 :   per_cs_stats->m_num_nodes[node_pk]++;
    2028                 :            : 
    2029                 :      26835 :   if (node_pk == PK_AFTER_SUPERNODE)
    2030                 :       8797 :     m_PK_AFTER_SUPERNODE_per_snode[point.get_supernode ()->m_index]++;
    2031                 :            : 
    2032                 :      26835 :   if (logger)
    2033                 :            :     {
    2034                 :          0 :       format f (false);
    2035                 :          0 :       pretty_printer *pp = logger->get_printer ();
    2036                 :          0 :       logger->log ("created EN: %i", node->m_index);
    2037                 :          0 :       logger->start_log_line ();
    2038                 :          0 :       pp_string (pp, "point: ");
    2039                 :          0 :       point.print (pp, f);
    2040                 :          0 :       logger->end_log_line ();
    2041                 :          0 :       logger->start_log_line ();
    2042                 :          0 :       pp_string (pp, "pruned_state: ");
    2043                 :          0 :       pruned_state.dump_to_pp (m_ext_state, true, pp);
    2044                 :          0 :       logger->end_log_line ();
    2045                 :            :     }
    2046                 :            : 
    2047                 :            :   /* Add the new node to the worlist.  */
    2048                 :      26835 :   m_worklist.add_node (node);
    2049                 :      26835 :   return node;
    2050                 :            : }
    2051                 :            : 
    2052                 :            : /* Add an exploded_edge from SRC to DEST, recording its association
    2053                 :            :    with SEDGE (which may be NULL), and, if non-NULL, taking ownership
    2054                 :            :    of REWIND_INFO.
    2055                 :            :    Return the newly-created eedge.  */
    2056                 :            : 
    2057                 :            : exploded_edge *
    2058                 :      28362 : exploded_graph::add_edge (exploded_node *src, exploded_node *dest,
    2059                 :            :                           const superedge *sedge,
    2060                 :            :                           const state_change &change,
    2061                 :            :                           exploded_edge::custom_info_t *custom_info)
    2062                 :            : {
    2063                 :      28362 :   exploded_edge *e = new exploded_edge (src, dest, m_ext_state,
    2064                 :      28362 :                                         sedge, change, custom_info);
    2065                 :      28362 :   digraph<eg_traits>::add_edge (e);
    2066                 :      28362 :   return e;
    2067                 :            : }
    2068                 :            : 
    2069                 :            : /* Ensure that this graph has per-program_point-data for POINT;
    2070                 :            :    borrow a pointer to it.  */
    2071                 :            : 
    2072                 :            : per_program_point_data *
    2073                 :      28300 : exploded_graph::
    2074                 :            : get_or_create_per_program_point_data (const program_point &point)
    2075                 :            : {
    2076                 :      28300 :   if (per_program_point_data **slot = m_per_point_data.get (&point))
    2077                 :      10630 :     return *slot;
    2078                 :            : 
    2079                 :      17670 :   per_program_point_data *per_point_data = new per_program_point_data (point);
    2080                 :      17670 :   m_per_point_data.put (&per_point_data->m_key, per_point_data);
    2081                 :      17670 :   return per_point_data;
    2082                 :            : }
    2083                 :            : 
    2084                 :            : /* Ensure that this graph has per-call_string-data for CS;
    2085                 :            :    borrow a pointer to it.  */
    2086                 :            : 
    2087                 :            : per_call_string_data *
    2088                 :      28637 : exploded_graph::get_or_create_per_call_string_data (const call_string &cs)
    2089                 :            : {
    2090                 :      28637 :   if (per_call_string_data **slot = m_per_call_string_data.get (&cs))
    2091                 :      27866 :     return *slot;
    2092                 :            : 
    2093                 :       1542 :   per_call_string_data *data = new per_call_string_data (cs, m_sg.num_nodes ());
    2094                 :        771 :   m_per_call_string_data.put (&data->m_key,
    2095                 :            :                               data);
    2096                 :        771 :   return data;
    2097                 :            : }
    2098                 :            : 
    2099                 :            : /* Ensure that this graph has per-function-data for FUN;
    2100                 :            :    borrow a pointer to it.  */
    2101                 :            : 
    2102                 :            : per_function_data *
    2103                 :        990 : exploded_graph::get_or_create_per_function_data (function *fun)
    2104                 :            : {
    2105                 :        990 :   if (per_function_data **slot = m_per_function_data.get (fun))
    2106                 :        191 :     return *slot;
    2107                 :            : 
    2108                 :        799 :   per_function_data *data = new per_function_data ();
    2109                 :        799 :   m_per_function_data.put (fun, data);
    2110                 :        799 :   return data;
    2111                 :            : }
    2112                 :            : 
    2113                 :            : /* Get this graph's per-function-data for FUN if there is any,
    2114                 :            :    otherwise NULL.  */
    2115                 :            : 
    2116                 :            : per_function_data *
    2117                 :          3 : exploded_graph::get_per_function_data (function *fun) const
    2118                 :            : {
    2119                 :          3 :   if (per_function_data **slot
    2120                 :          3 :         = const_cast <per_function_data_t &> (m_per_function_data).get (fun))
    2121                 :          3 :     return *slot;
    2122                 :            : 
    2123                 :            :   return NULL;
    2124                 :            : }
    2125                 :            : 
    2126                 :            : /* Return true if NODE and FUN should be traversed directly, rather than
    2127                 :            :    called via other functions.  */
    2128                 :            : 
    2129                 :            : static bool
    2130                 :       1003 : toplevel_function_p (cgraph_node *node, function *fun, logger *logger)
    2131                 :            : {
    2132                 :            :   /* TODO: better logic here
    2133                 :            :      e.g. only if more than one caller, and significantly complicated.
    2134                 :            :      Perhaps some whole-callgraph analysis to decide if it's worth summarizing
    2135                 :            :      an edge, and if so, we need summaries.  */
    2136                 :       1003 :   if (flag_analyzer_call_summaries)
    2137                 :            :     {
    2138                 :        956 :       int num_call_sites = 0;
    2139                 :       1239 :       for (cgraph_edge *edge = node->callers; edge; edge = edge->next_caller)
    2140                 :        283 :         ++num_call_sites;
    2141                 :            : 
    2142                 :            :       /* For now, if there's more than one in-edge, and we want call
    2143                 :            :          summaries, do it at the top level so that there's a chance
    2144                 :            :          we'll have a summary when we need one.  */
    2145                 :        956 :       if (num_call_sites > 1)
    2146                 :            :         {
    2147                 :         31 :           if (logger)
    2148                 :          0 :             logger->log ("traversing %qE (%i call sites)",
    2149                 :            :                          fun->decl, num_call_sites);
    2150                 :         31 :           return true;
    2151                 :            :         }
    2152                 :            :     }
    2153                 :            : 
    2154                 :        972 :   if (!TREE_PUBLIC (fun->decl))
    2155                 :            :     {
    2156                 :         93 :       if (logger)
    2157                 :          0 :         logger->log ("not traversing %qE (static)", fun->decl);
    2158                 :         93 :       return false;
    2159                 :            :     }
    2160                 :            : 
    2161                 :        879 :   if (logger)
    2162                 :          0 :     logger->log ("traversing %qE (all checks passed)", fun->decl);
    2163                 :            : 
    2164                 :            :   return true;
    2165                 :            : }
    2166                 :            : 
    2167                 :            : /* Add initial nodes to EG, with entrypoints for externally-callable
    2168                 :            :    functions.  */
    2169                 :            : 
    2170                 :            : void
    2171                 :        377 : exploded_graph::build_initial_worklist ()
    2172                 :            : {
    2173                 :        377 :   logger * const logger = get_logger ();
    2174                 :        754 :   LOG_SCOPE (logger);
    2175                 :            : 
    2176                 :        377 :   cgraph_node *node;
    2177                 :       2760 :   FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node)
    2178                 :            :   {
    2179                 :       1003 :     function *fun = node->get_fun ();
    2180                 :       1003 :     if (!toplevel_function_p (node, fun, logger))
    2181                 :         93 :       continue;
    2182                 :        910 :     exploded_node *enode = add_function_entry (fun);
    2183                 :        910 :     if (logger)
    2184                 :            :       {
    2185                 :          0 :         if (enode)
    2186                 :          0 :           logger->log ("created EN %i for %qE entrypoint",
    2187                 :          0 :                        enode->m_index, fun->decl);
    2188                 :            :         else
    2189                 :          0 :           logger->log ("did not create enode for %qE entrypoint", fun->decl);
    2190                 :            :       }
    2191                 :            :   }
    2192                 :        377 : }
    2193                 :            : 
    2194                 :            : /* The main loop of the analysis.
    2195                 :            :    Take freshly-created exploded_nodes from the worklist, calling
    2196                 :            :    process_node on them to explore the <point, state> graph.
    2197                 :            :    Add edges to their successors, potentially creating new successors
    2198                 :            :    (which are also added to the worklist).  */
    2199                 :            : 
    2200                 :            : void
    2201                 :        377 : exploded_graph::process_worklist ()
    2202                 :            : {
    2203                 :        377 :   logger * const logger = get_logger ();
    2204                 :        377 :   LOG_SCOPE (logger);
    2205                 :        742 :   auto_timevar tv (TV_ANALYZER_WORKLIST);
    2206                 :            : 
    2207                 :      26956 :   while (m_worklist.length () > 0)
    2208                 :            :     {
    2209                 :      26591 :       exploded_node *node = m_worklist.take_next ();
    2210                 :      26591 :       gcc_assert (node->get_status () == exploded_node::STATUS_WORKLIST);
    2211                 :      26591 :       gcc_assert (node->m_succs.length () == 0
    2212                 :            :                   || node == m_origin);
    2213                 :            : 
    2214                 :      26591 :       if (logger)
    2215                 :          0 :         logger->log ("next to process: EN: %i", node->m_index);
    2216                 :            : 
    2217                 :            :       /* Avoid exponential explosions of nodes by attempting to merge
    2218                 :            :          nodes that are at the same program point and which have
    2219                 :            :          sufficiently similar state.  */
    2220                 :      26591 :       if (flag_analyzer_state_merge && node != m_origin)
    2221                 :      26133 :         if (exploded_node *node_2 = m_worklist.peek_next ())
    2222                 :            :           {
    2223                 :      20936 :             gcc_assert (node_2->get_status ()
    2224                 :            :                         == exploded_node::STATUS_WORKLIST);
    2225                 :      20936 :             gcc_assert (node->m_succs.length () == 0);
    2226                 :      20936 :             gcc_assert (node_2->m_succs.length () == 0);
    2227                 :            : 
    2228                 :      20936 :             gcc_assert (node != node_2);
    2229                 :            : 
    2230                 :      20936 :             if (logger)
    2231                 :          0 :               logger->log ("peek worklist: EN: %i", node_2->m_index);
    2232                 :            : 
    2233                 :      20936 :             if (node->get_point () == node_2->get_point ())
    2234                 :            :               {
    2235                 :       3859 :                 if (logger)
    2236                 :            :                   {
    2237                 :          0 :                     format f (false);
    2238                 :          0 :                     pretty_printer *pp = logger->get_printer ();
    2239                 :          0 :                     logger->start_log_line ();
    2240                 :          0 :                     logger->log_partial
    2241                 :          0 :                       ("got potential merge EN: %i and EN: %i at ",
    2242                 :          0 :                        node->m_index, node_2->m_index);
    2243                 :          0 :                     node->get_point ().print (pp, f);
    2244                 :          0 :                     logger->end_log_line ();
    2245                 :            :                   }
    2246                 :            : 
    2247                 :       3859 :                 const program_state &state = node->get_state ();
    2248                 :       3859 :                 const program_state &state_2 = node_2->get_state ();
    2249                 :            : 
    2250                 :            :                 /* They shouldn't be equal, or we wouldn't have two
    2251                 :            :                    separate nodes.  */
    2252                 :       3859 :                 gcc_assert (state != state_2);
    2253                 :            : 
    2254                 :       3859 :                 program_state merged_state (m_ext_state);
    2255                 :       7326 :                 state_change change;
    2256                 :       3859 :                 if (state.can_merge_with_p (state_2, m_ext_state,
    2257                 :            :                                             &merged_state))
    2258                 :            :                   {
    2259                 :        421 :                     if (logger)
    2260                 :          0 :                       logger->log ("merging EN: %i and EN: %i",
    2261                 :          0 :                                    node->m_index, node_2->m_index);
    2262                 :            : 
    2263                 :        421 :                     if (merged_state == state)
    2264                 :            :                       {
    2265                 :            :                         /* Then merge node_2 into node by adding an edge.  */
    2266                 :         29 :                         add_edge (node_2, node, NULL, change);
    2267                 :            : 
    2268                 :            :                         /* Remove node_2 from the worklist.  */
    2269                 :         29 :                         m_worklist.take_next ();
    2270                 :       3496 :                         node_2->set_status (exploded_node::STATUS_MERGER);
    2271                 :            : 
    2272                 :            :                         /* Continue processing "node" below.  */
    2273                 :            :                       }
    2274                 :        392 :                     else if (merged_state == state_2)
    2275                 :            :                       {
    2276                 :            :                         /* Then merge node into node_2, and leave node_2
    2277                 :            :                            in the worklist, to be processed on the next
    2278                 :            :                            iteration.  */
    2279                 :        214 :                         add_edge (node, node_2, NULL, change);
    2280                 :        214 :                         node->set_status (exploded_node::STATUS_MERGER);
    2281                 :        606 :                         continue;
    2282                 :            :                       }
    2283                 :            :                     else
    2284                 :            :                       {
    2285                 :            :                         /* We have a merged state that differs from
    2286                 :            :                            both state and state_2.  */
    2287                 :            : 
    2288                 :            :                         /* Remove node_2 from the worklist.  */
    2289                 :        178 :                         m_worklist.take_next ();
    2290                 :            : 
    2291                 :            :                         /* Create (or get) an exploded node for the merged
    2292                 :            :                            states, adding to the worklist.  */
    2293                 :        178 :                         exploded_node *merged_enode
    2294                 :        178 :                           = get_or_create_node (node->get_point (),
    2295                 :            :                                                 merged_state, &change);
    2296                 :        178 :                         if (merged_enode == NULL)
    2297                 :          2 :                           continue;
    2298                 :            : 
    2299                 :        176 :                         if (logger)
    2300                 :          0 :                           logger->log ("merged EN: %i and EN: %i into EN: %i",
    2301                 :          0 :                                        node->m_index, node_2->m_index,
    2302                 :          0 :                                        merged_enode->m_index);
    2303                 :            : 
    2304                 :            :                         /* "node" and "node_2" have both now been removed
    2305                 :            :                            from the worklist; we should not process them.
    2306                 :            : 
    2307                 :            :                            "merged_enode" may be a new node; if so it will be
    2308                 :            :                            processed in a subsequent iteration.
    2309                 :            :                            Alternatively, "merged_enode" could be an existing
    2310                 :            :                            node; one way the latter can
    2311                 :            :                            happen is if we end up merging a succession of
    2312                 :            :                            similar nodes into one.  */
    2313                 :            : 
    2314                 :            :                         /* If merged_node is one of the two we were merging,
    2315                 :            :                            add it back to the worklist to ensure it gets
    2316                 :            :                            processed.
    2317                 :            : 
    2318                 :            :                            Add edges from the merged nodes to it (but not a
    2319                 :            :                            self-edge).  */
    2320                 :        176 :                         if (merged_enode == node)
    2321                 :         81 :                           m_worklist.add_node (merged_enode);
    2322                 :            :                         else
    2323                 :            :                           {
    2324                 :         95 :                             add_edge (node, merged_enode, NULL, change);
    2325                 :         95 :                             node->set_status (exploded_node::STATUS_MERGER);
    2326                 :            :                           }
    2327                 :            : 
    2328                 :        176 :                         if (merged_enode == node_2)
    2329                 :          5 :                           m_worklist.add_node (merged_enode);
    2330                 :            :                         else
    2331                 :            :                           {
    2332                 :        171 :                             add_edge (node_2, merged_enode, NULL, change);
    2333                 :        171 :                             node_2->set_status (exploded_node::STATUS_MERGER);
    2334                 :            :                           }
    2335                 :            : 
    2336                 :        176 :                         continue;
    2337                 :            :                       }
    2338                 :            :                   }
    2339                 :            : 
    2340                 :            :                 /* TODO: should we attempt more than two nodes,
    2341                 :            :                    or just do pairs of nodes?  (and hope that we get
    2342                 :            :                    a cascade of mergers).  */
    2343                 :            :               }
    2344                 :            :         }
    2345                 :            : 
    2346                 :      26199 :       process_node (node);
    2347                 :            : 
    2348                 :            :       /* Impose a hard limit on the number of exploded nodes, to ensure
    2349                 :            :          that the analysis terminates in the face of pathological state
    2350                 :            :          explosion (or bugs).
    2351                 :            : 
    2352                 :            :          Specifically, the limit is on the number of PK_AFTER_SUPERNODE
    2353                 :            :          exploded nodes, looking at supernode exit events.
    2354                 :            : 
    2355                 :            :          We use exit rather than entry since there can be multiple
    2356                 :            :          entry ENs, one per phi; the number of PK_AFTER_SUPERNODE ought
    2357                 :            :          to be equivalent to the number of supernodes multiplied by the
    2358                 :            :          number of states.  */
    2359                 :      26199 :       const int limit = m_sg.num_nodes () * param_analyzer_bb_explosion_factor;
    2360                 :      26199 :       if (m_global_stats.m_num_nodes[PK_AFTER_SUPERNODE] > limit)
    2361                 :            :         {
    2362                 :         12 :           if (logger)
    2363                 :          0 :             logger->log ("bailing out; too many nodes");
    2364                 :         24 :           warning_at (node->get_point ().get_location (),
    2365                 :            :                       OPT_Wanalyzer_too_complex,
    2366                 :            :                       "analysis bailed out early"
    2367                 :            :                       " (%i 'after-snode' enodes; %i enodes)",
    2368                 :            :                       m_global_stats.m_num_nodes[PK_AFTER_SUPERNODE],
    2369                 :            :                       m_nodes.length ());
    2370                 :         12 :           return;
    2371                 :            :         }
    2372                 :            :     }
    2373                 :            : }
    2374                 :            : 
    2375                 :            : /* Return true if STMT must appear at the start of its exploded node, and
    2376                 :            :    thus we can't consolidate its effects within a run of other statements,
    2377                 :            :    where PREV_STMT was the previous statement.  */
    2378                 :            : 
    2379                 :            : static bool
    2380                 :       8700 : stmt_requires_new_enode_p (const gimple *stmt,
    2381                 :            :                            const gimple *prev_stmt)
    2382                 :            : {
    2383                 :            :   /* Stop consolidating at calls to
    2384                 :            :      "__analyzer_dump_exploded_nodes", so they always appear at the
    2385                 :            :      start of an exploded_node.  */
    2386                 :       8700 :   if (const gcall *call = dyn_cast <const gcall *> (stmt))
    2387                 :       1773 :     if (is_special_named_call_p (call, "__analyzer_dump_exploded_nodes",
    2388                 :            :                          1))
    2389                 :            :       return true;
    2390                 :            : 
    2391                 :            :   /* If we had a PREV_STMT with an unknown location, and this stmt
    2392                 :            :      has a known location, then if a state change happens here, it
    2393                 :            :      could be consolidated into PREV_STMT, giving us an event with
    2394                 :            :      no location.  Ensure that STMT gets its own exploded_node to
    2395                 :            :      avoid this.  */
    2396                 :       8644 :   if (get_pure_location (prev_stmt->location) == UNKNOWN_LOCATION
    2397                 :       8644 :       && get_pure_location (stmt->location) != UNKNOWN_LOCATION)
    2398                 :        431 :     return true;
    2399                 :            : 
    2400                 :            :   return false;
    2401                 :            : }
    2402                 :            : 
    2403                 :            : /* The core of exploded_graph::process_worklist (the main analysis loop),
    2404                 :            :    handling one node in the worklist.
    2405                 :            : 
    2406                 :            :    Get successor <point, state> pairs for NODE, calling get_or_create on
    2407                 :            :    them, and adding an exploded_edge to each successors.
    2408                 :            : 
    2409                 :            :    Freshly-created nodes will be added to the worklist.  */
    2410                 :            : 
    2411                 :            : void
    2412                 :      26199 : exploded_graph::process_node (exploded_node *node)
    2413                 :            : {
    2414                 :      26199 :   logger * const logger = get_logger ();
    2415                 :      52383 :   LOG_FUNC_1 (logger, "EN: %i", node->m_index);
    2416                 :            : 
    2417                 :      26199 :   node->set_status (exploded_node::STATUS_PROCESSED);
    2418                 :            : 
    2419                 :      26199 :   const program_point &point = node->get_point ();
    2420                 :            : 
    2421                 :            :   /* Update cfun and input_location in case of an ICE: make it easier to
    2422                 :            :      track down which source construct we're failing to handle.  */
    2423                 :      52021 :   auto_cfun sentinel (node->get_function ());
    2424                 :      26199 :   const gimple *stmt = point.get_stmt ();
    2425                 :      26199 :   if (stmt)
    2426                 :      13014 :     input_location = stmt->location;
    2427                 :            : 
    2428                 :      26199 :   const program_state &state = node->get_state ();
    2429                 :      26199 :   if (logger)
    2430                 :            :     {
    2431                 :          0 :       pretty_printer *pp = logger->get_printer ();
    2432                 :          0 :       logger->start_log_line ();
    2433                 :          0 :       pp_string (pp, "point: ");
    2434                 :          0 :       point.print (pp, format (false));
    2435                 :          0 :       pp_string (pp, ", state: ");
    2436                 :          0 :       state.dump_to_pp (m_ext_state, true, pp);
    2437                 :          0 :       logger->end_log_line ();
    2438                 :            :     }
    2439                 :            : 
    2440                 :      26199 :   switch (point.get_kind ())
    2441                 :            :     {
    2442                 :          0 :     default:
    2443                 :          0 :       gcc_unreachable ();
    2444                 :            :     case PK_ORIGIN:
    2445                 :            :       /* This node exists to simplify finding the shortest path
    2446                 :            :          to an exploded_node.  */
    2447                 :            :       break;
    2448                 :            : 
    2449                 :       9785 :     case PK_BEFORE_SUPERNODE:
    2450                 :       9785 :       {
    2451                 :       9785 :         program_state next_state (state);
    2452                 :      19570 :         state_change change;
    2453                 :            : 
    2454                 :       9785 :         if (point.get_from_edge ())
    2455                 :            :           {
    2456                 :       7954 :             impl_region_model_context ctxt (*this, node,
    2457                 :            :                                             &state, &next_state, &change,
    2458                 :      15908 :                                             NULL);
    2459                 :       7954 :             const cfg_superedge *last_cfg_superedge
    2460                 :       7954 :               = point.get_from_edge ()->dyn_cast_cfg_superedge ();
    2461                 :       7954 :             if (last_cfg_superedge)
    2462                 :       7954 :               next_state.m_region_model->update_for_phis
    2463                 :       7954 :                 (node->get_supernode (),
    2464                 :            :                  last_cfg_superedge,
    2465                 :            :                  &ctxt);
    2466                 :            :           }
    2467                 :            : 
    2468                 :       9785 :         if (point.get_supernode ()->m_stmts.length () > 0)
    2469                 :            :           {
    2470                 :       6735 :             program_point next_point
    2471                 :            :               = program_point::before_stmt (point.get_supernode (), 0,
    2472                 :      13470 :                                             point.get_call_string ());
    2473                 :       6735 :             exploded_node *next
    2474                 :       6735 :               = get_or_create_node (next_point, next_state, &change);
    2475                 :       6735 :             if (next)
    2476                 :       6507 :               add_edge (node, next, NULL, change);
    2477                 :            :           }
    2478                 :            :         else
    2479                 :            :           {
    2480                 :       3050 :             program_point next_point
    2481                 :            :               = program_point::after_supernode (point.get_supernode (),
    2482                 :       6100 :                                                 point.get_call_string ());
    2483                 :       3050 :             exploded_node *next = get_or_create_node (next_point, next_state,
    2484                 :            :                                                       &change);
    2485                 :       3050 :             if (next)
    2486                 :       3050 :               add_edge (node, next, NULL, change);
    2487                 :            :           }
    2488                 :            :       }
    2489                 :       9785 :       break;
    2490                 :       7303 :     case PK_BEFORE_STMT:
    2491                 :       7303 :       {
    2492                 :            :         /* Determine the effect of a run of one or more statements
    2493                 :            :            within one supernode, generating an edge to the program_point
    2494                 :            :            after the last statement that's processed.
    2495                 :            : 
    2496                 :            :            Stop iterating statements and thus consolidating into one enode
    2497                 :            :            when:
    2498                 :            :            - reaching the end of the statements in the supernode
    2499                 :            :            - if an sm-state-change occurs (so that it gets its own
    2500                 :            :              exploded_node)
    2501                 :            :            - if "-fanalyzer-fine-grained" is active
    2502                 :            :            - encountering certain statements must appear at the start of
    2503                 :            :            their enode (for which stmt_requires_new_enode_p returns true)
    2504                 :            : 
    2505                 :            :            Update next_state in-place, to get the result of the one
    2506                 :            :            or more stmts that are processed.  */
    2507                 :       7303 :         program_state next_state (state);
    2508                 :      14591 :         state_change change;
    2509                 :       7303 :         const supernode *snode = point.get_supernode ();
    2510                 :       7303 :         unsigned stmt_idx;
    2511                 :       7303 :         const gimple *prev_stmt = NULL;
    2512                 :      21428 :         for (stmt_idx = point.get_stmt_idx ();
    2513                 :      42856 :              stmt_idx < snode->m_stmts.length ();
    2514                 :            :              stmt_idx++)
    2515                 :            :           {
    2516                 :      16003 :             const gimple *stmt = snode->m_stmts[stmt_idx];
    2517                 :            : 
    2518                 :      16003 :             if (stmt_idx > point.get_stmt_idx ())
    2519                 :       8700 :               if (stmt_requires_new_enode_p (stmt, prev_stmt))
    2520                 :            :                 {
    2521                 :        487 :                   stmt_idx--;
    2522                 :       1863 :                   break;
    2523                 :            :                 }
    2524                 :      15516 :             prev_stmt = stmt;
    2525                 :            : 
    2526                 :            :             /* Process the stmt.  */
    2527                 :      15516 :             exploded_node::on_stmt_flags flags
    2528                 :      15516 :               = node->on_stmt (*this, snode, stmt, &next_state, &change);
    2529                 :            : 
    2530                 :            :             /* If flags.m_terminate_path, stop analyzing; any nodes/edges
    2531                 :            :                will have been added by on_stmt (e.g. for handling longjmp).  */
    2532                 :      15516 :             if (flags.m_terminate_path)
    2533                 :         15 :               return;
    2534                 :            : 
    2535                 :      15501 :             if (flags.m_sm_changes || flag_analyzer_fine_grained)
    2536                 :            :               break;
    2537                 :            :           }
    2538                 :       7288 :         unsigned next_idx = stmt_idx + 1;
    2539                 :       7288 :         program_point next_point
    2540                 :       7288 :           = (next_idx < point.get_supernode ()->m_stmts.length ()
    2541                 :            :              ? program_point::before_stmt (point.get_supernode (), next_idx,
    2542                 :            :                                            point.get_call_string ())
    2543                 :            :              : program_point::after_supernode (point.get_supernode (),
    2544                 :      14576 :                                                point.get_call_string ()));
    2545                 :       7288 :         exploded_node *next = get_or_create_node (next_point,
    2546                 :            :                                                   next_state, &change);
    2547                 :       7288 :         if (next)
    2548                 :       7264 :           add_edge (node, next, NULL, change);
    2549                 :            :       }
    2550                 :            :       break;
    2551                 :       8734 :     case PK_AFTER_SUPERNODE:
    2552                 :       8734 :       {
    2553                 :            :         /* If this is an EXIT BB, detect leaks, and potentially
    2554                 :            :            create a function summary.  */
    2555                 :       8734 :         if (point.get_supernode ()->return_p ())
    2556                 :            :           {
    2557                 :       1468 :             node->detect_leaks (*this);
    2558                 :       1468 :             if (flag_analyzer_call_summaries
    2559                 :       1468 :                 && point.get_call_string ().empty_p ())
    2560                 :            :               {
    2561                 :            :                 /* TODO: create function summary
    2562                 :            :                    There can be more than one; each corresponds to a different
    2563                 :            :                    final enode in the function.  */
    2564                 :        990 :                 if (logger)
    2565                 :            :                   {
    2566                 :          0 :                     pretty_printer *pp = logger->get_printer ();
    2567                 :          0 :                     logger->start_log_line ();
    2568                 :          0 :                     logger->log_partial
    2569                 :          0 :                       ("would create function summary for %qE; state: ",
    2570                 :            :                        point.get_fndecl ());
    2571                 :          0 :                     state.dump_to_pp (m_ext_state, true, pp);
    2572                 :          0 :                     logger->end_log_line ();
    2573                 :            :                   }
    2574                 :        990 :                 per_function_data *per_fn_data
    2575                 :        990 :                   = get_or_create_per_function_data (point.get_function ());
    2576                 :        990 :                 per_fn_data->add_call_summary (node);
    2577                 :            :               }
    2578                 :            :           }
    2579                 :            :         /* Traverse into successors of the supernode.  */
    2580                 :            :         int i;
    2581                 :            :         superedge *succ;
    2582                 :      45414 :         FOR_EACH_VEC_ELT (point.get_supernode ()->m_succs, i, succ)
    2583                 :            :           {
    2584                 :      11448 :             if (logger)
    2585                 :          0 :               logger->log ("considering SN: %i -> SN: %i",
    2586                 :          0 :                            succ->m_src->m_index, succ->m_dest->m_index);
    2587                 :            : 
    2588                 :      21564 :             state_change change;
    2589                 :            : 
    2590                 :      11448 :             program_point next_point
    2591                 :      11448 :               = program_point::before_supernode (succ->m_dest, succ,
    2592                 :      21564 :                                                  point.get_call_string ());
    2593                 :      21564 :             program_state next_state (state);
    2594                 :            : 
    2595                 :      11448 :             if (!node->on_edge (*this, succ, &next_point, &next_state, &change))
    2596                 :            :               {
    2597                 :       1332 :                 if (logger)
    2598                 :          0 :                   logger->log ("skipping impossible edge to SN: %i",
    2599                 :          0 :                                succ->m_dest->m_index);
    2600                 :       1332 :                 continue;
    2601                 :            :               }
    2602                 :            : 
    2603                 :      10116 :             exploded_node *next = get_or_create_node (next_point, next_state,
    2604                 :            :                                                       &change);
    2605                 :      10116 :             if (next)
    2606                 :      10112 :               add_edge (node, next, succ, change);
    2607                 :            :           }
    2608                 :            :       }
    2609                 :            :       break;
    2610                 :            :     }
    2611                 :            : }
    2612                 :            : 
    2613                 :            : /* Ensure that this graph has a stats instance for FN, return it.
    2614                 :            :    FN can be NULL, in which case a stats instances is returned covering
    2615                 :            :    "functionless" parts of the graph (the origin node).  */
    2616                 :            : 
    2617                 :            : stats *
    2618                 :      28637 : exploded_graph::get_or_create_function_stats (function *fn)
    2619                 :            : {
    2620                 :      28637 :   if (!fn)
    2621                 :        377 :     return &m_functionless_stats;
    2622                 :            : 
    2623                 :      28260 :   if (stats **slot = m_per_function_stats.get (fn))
    2624                 :      27286 :     return *slot;
    2625                 :            :   else
    2626                 :            :     {
    2627                 :        974 :       int num_supernodes = fn ? n_basic_blocks_for_fn (fn) : 0;
    2628                 :            :       /* not quite the num supernodes, but nearly.  */
    2629                 :        974 :       stats *new_stats = new stats (num_supernodes);
    2630                 :        974 :       m_per_function_stats.put (fn, new_stats);
    2631                 :        974 :       return new_stats;
    2632                 :            :     }
    2633                 :            : }
    2634                 :            : 
    2635                 :            : /* Print bar charts to PP showing:
    2636                 :            :    - the number of enodes per function, and
    2637                 :            :    - for each function:
    2638                 :            :      - the number of enodes per supernode/BB
    2639                 :            :      - the number of excess enodes per supernode/BB beyond the
    2640                 :            :        per-program-point limit, if there were any.  */
    2641                 :            : 
    2642                 :            : void
    2643                 :          0 : exploded_graph::print_bar_charts (pretty_printer *pp) const
    2644                 :            : {
    2645                 :          0 :   cgraph_node *cgnode;
    2646                 :            : 
    2647                 :          0 :   pp_string (pp, "enodes per function:");
    2648                 :          0 :   pp_newline (pp);
    2649                 :          0 :   bar_chart enodes_per_function;
    2650                 :          0 :   FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (cgnode)
    2651                 :            :     {
    2652                 :          0 :       function *fn = cgnode->get_fun ();
    2653                 :          0 :       const stats * const *s_ptr
    2654                 :          0 :         = const_cast <function_stat_map_t &> (m_per_function_stats).get (fn);
    2655                 :          0 :       enodes_per_function.add_item (function_name (fn),
    2656                 :          0 :                                     s_ptr ? (*s_ptr)->get_total_enodes () : 0);
    2657                 :            :     }
    2658                 :          0 :   enodes_per_function.print (pp);
    2659                 :            : 
    2660                 :            :   /* Accumulate number of enodes per supernode.  */
    2661                 :          0 :   auto_vec<unsigned> enodes_per_supernode (m_sg.num_nodes ());
    2662                 :          0 :   for (int i = 0; i < m_sg.num_nodes (); i++)
    2663                 :          0 :     enodes_per_supernode.quick_push (0);
    2664                 :            :   int i;
    2665                 :            :   exploded_node *enode;
    2666                 :          0 :   FOR_EACH_VEC_ELT (m_nodes, i, enode)
    2667                 :            :     {
    2668                 :          0 :       const supernode *iter_snode = enode->get_supernode ();
    2669                 :          0 :       if (!iter_snode)
    2670                 :          0 :         continue;
    2671                 :          0 :       enodes_per_supernode[iter_snode->m_index]++;
    2672                 :            :     }
    2673                 :            : 
    2674                 :            :   /* Accumulate excess enodes per supernode.  */
    2675                 :          0 :   auto_vec<unsigned> excess_enodes_per_supernode (m_sg.num_nodes ());
    2676                 :          0 :   for (int i = 0; i < m_sg.num_nodes (); i++)
    2677                 :          0 :     excess_enodes_per_supernode.quick_push (0);
    2678                 :          0 :   for (point_map_t::iterator iter = m_per_point_data.begin ();
    2679                 :          0 :        iter != m_per_point_data.end (); ++iter)
    2680                 :            :     {
    2681                 :          0 :       const program_point *point = (*iter).first;
    2682                 :          0 :       const supernode *iter_snode = point->get_supernode ();
    2683                 :          0 :       if (!iter_snode)
    2684                 :          0 :         continue;
    2685                 :          0 :       const per_program_point_data *point_data = (*iter).second;
    2686                 :          0 :       excess_enodes_per_supernode[iter_snode->m_index]
    2687                 :          0 :         += point_data->m_excess_enodes;
    2688                 :            :     }
    2689                 :            : 
    2690                 :            :   /* Show per-function bar_charts of enodes per supernode/BB.  */
    2691                 :          0 :   pp_string (pp, "per-function enodes per supernode/BB:");
    2692                 :          0 :   pp_newline (pp);
    2693                 :          0 :   FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (cgnode)
    2694                 :            :     {
    2695                 :          0 :       function *fn = cgnode->get_fun ();
    2696                 :          0 :       pp_printf (pp, "function: %qs", function_name (fn));
    2697                 :          0 :       pp_newline (pp);
    2698                 :            : 
    2699                 :          0 :       bar_chart enodes_per_snode;
    2700                 :          0 :       bar_chart excess_enodes_per_snode;
    2701                 :          0 :       bool have_excess_enodes = false;
    2702                 :          0 :       for (int i = 0; i < m_sg.num_nodes (); i++)
    2703                 :            :         {
    2704                 :          0 :           const supernode *iter_snode = m_sg.get_node_by_index (i);
    2705                 :          0 :           if (iter_snode->get_function () != fn)
    2706                 :          0 :             continue;
    2707                 :          0 :           pretty_printer tmp_pp;
    2708                 :          0 :           pp_printf (&tmp_pp, "sn %i (bb %i)",
    2709                 :          0 :                      iter_snode->m_index, iter_snode->m_bb->index);
    2710                 :          0 :           enodes_per_snode.add_item (pp_formatted_text (&tmp_pp),
    2711                 :          0 :                                      enodes_per_supernode[iter_snode->m_index]);
    2712                 :          0 :           const int num_excess
    2713                 :          0 :             = excess_enodes_per_supernode[iter_snode->m_index];
    2714                 :          0 :           excess_enodes_per_snode.add_item (pp_formatted_text (&tmp_pp),
    2715                 :            :                                             num_excess);
    2716                 :          0 :           if (num_excess)
    2717                 :          0 :             have_excess_enodes = true;
    2718                 :            :         }
    2719                 :          0 :       enodes_per_snode.print (pp);
    2720                 :          0 :       if (have_excess_enodes)
    2721                 :            :         {
    2722                 :          0 :           pp_printf (pp, "EXCESS ENODES:");
    2723                 :          0 :           pp_newline (pp);
    2724                 :          0 :           excess_enodes_per_snode.print (pp);
    2725                 :            :         }
    2726                 :            :     }
    2727                 :          0 : }
    2728                 :            : 
    2729                 :            : /* Write all stats information to this graph's logger, if any.  */
    2730                 :            : 
    2731                 :            : void
    2732                 :        377 : exploded_graph::log_stats () const
    2733                 :            : {
    2734                 :        377 :   logger * const logger = get_logger ();
    2735                 :        377 :   if (!logger)
    2736                 :        377 :     return;
    2737                 :            : 
    2738                 :          0 :   LOG_SCOPE (logger);
    2739                 :            : 
    2740                 :          0 :   logger->log ("m_sg.num_nodes (): %i", m_sg.num_nodes ());
    2741                 :          0 :   logger->log ("m_nodes.length (): %i", m_nodes.length ());
    2742                 :          0 :   logger->log ("m_edges.length (): %i", m_edges.length ());
    2743                 :          0 :   logger->log ("remaining enodes in worklist: %i", m_worklist.length ());
    2744                 :            : 
    2745                 :          0 :   logger->log ("global stats:");
    2746                 :          0 :   m_global_stats.log (logger);
    2747                 :            : 
    2748                 :          0 :   for (function_stat_map_t::iterator iter = m_per_function_stats.begin ();
    2749                 :          0 :        iter != m_per_function_stats.end ();
    2750                 :          0 :        ++iter)
    2751                 :            :     {
    2752                 :          0 :       function *fn = (*iter).first;
    2753                 :          0 :       log_scope s (logger, function_name (fn));
    2754                 :          0 :       (*iter).second->log (logger);
    2755                 :            :     }
    2756                 :            : 
    2757                 :          0 :   print_bar_charts (logger->get_printer ());
    2758                 :            : }
    2759                 :            : 
    2760                 :            : /* Dump all stats information to OUT.  */
    2761                 :            : 
    2762                 :            : void
    2763                 :          0 : exploded_graph::dump_stats (FILE *out) const
    2764                 :            : {
    2765                 :          0 :   fprintf (out, "m_sg.num_nodes (): %i\n", m_sg.num_nodes ());
    2766                 :          0 :   fprintf (out, "m_nodes.length (): %i\n", m_nodes.length ());
    2767                 :          0 :   fprintf (out, "m_edges.length (): %i\n", m_edges.length ());
    2768                 :          0 :   fprintf (out, "remaining enodes in worklist: %i", m_worklist.length ());
    2769                 :            : 
    2770                 :          0 :   fprintf (out, "global stats:\n");
    2771                 :          0 :   m_global_stats.dump (out);
    2772                 :            : 
    2773                 :          0 :   for (function_stat_map_t::iterator iter = m_per_function_stats.begin ();
    2774                 :          0 :        iter != m_per_function_stats.end ();
    2775                 :          0 :        ++iter)
    2776                 :            :     {
    2777                 :          0 :       function *fn = (*iter).first;
    2778                 :          0 :       fprintf (out, "function: %s\n", function_name (fn));
    2779                 :          0 :       (*iter).second->dump (out);
    2780                 :            :     }
    2781                 :            : 
    2782                 :          0 :   fprintf (out, "PK_AFTER_SUPERNODE per supernode:\n");
    2783                 :          0 :   for (unsigned i = 0; i < m_PK_AFTER_SUPERNODE_per_snode.length (); i++)
    2784                 :          0 :     fprintf (out, "  SN %i: %3i\n", i, m_PK_AFTER_SUPERNODE_per_snode[i]);
    2785                 :          0 : }
    2786                 :            : 
    2787                 :            : void
    2788                 :          0 : exploded_graph::dump_states_for_supernode (FILE *out,
    2789                 :            :                                            const supernode *snode) const
    2790                 :            : {
    2791                 :          0 :   fprintf (out, "PK_AFTER_SUPERNODE nodes for SN: %i\n", snode->m_index);
    2792                 :          0 :   int i;
    2793                 :          0 :   exploded_node *enode;
    2794                 :          0 :   int state_idx = 0;
    2795                 :          0 :   FOR_EACH_VEC_ELT (m_nodes, i, enode)
    2796                 :            :     {
    2797                 :          0 :       const supernode *iter_snode = enode->get_supernode ();
    2798                 :          0 :       if (enode->get_point ().get_kind () == PK_AFTER_SUPERNODE
    2799                 :          0 :           && iter_snode == snode)
    2800                 :            :         {
    2801                 :          0 :           pretty_printer pp;
    2802                 :          0 :           pp_format_decoder (&pp) = default_tree_printer;
    2803                 :          0 :           enode->get_state ().dump_to_pp (m_ext_state, true, &pp);
    2804                 :          0 :           fprintf (out, "state %i: EN: %i\n  %s\n",
    2805                 :          0 :                    state_idx++, enode->m_index,
    2806                 :            :                    pp_formatted_text (&pp));
    2807                 :            :         }
    2808                 :            :     }
    2809                 :          0 :   fprintf (out, "#exploded_node for PK_AFTER_SUPERNODE for SN: %i = %i\n",
    2810                 :          0 :            snode->m_index, state_idx);
    2811                 :          0 : }
    2812                 :            : 
    2813                 :            : /* Look for the last use of SEARCH_STMT within this path.
    2814                 :            :    If found write the edge's index to *OUT_IDX and return true, otherwise
    2815                 :            :    return false.  */
    2816                 :            : 
    2817                 :            : bool
    2818                 :         62 : exploded_path::find_stmt_backwards (const gimple *search_stmt,
    2819                 :            :                                     int *out_idx) const
    2820                 :            : {
    2821                 :         62 :   int i;
    2822                 :         62 :   const exploded_edge *eedge;
    2823                 :        920 :   FOR_EACH_VEC_ELT_REVERSE (m_edges, i, eedge)
    2824                 :            :     {
    2825                 :        854 :       const exploded_node *dst_node = eedge->m_dest;
    2826                 :        854 :       const program_point &dst_point = dst_node->get_point ();
    2827                 :        854 :       const gimple *stmt = dst_point.get_stmt ();
    2828                 :        854 :       if (stmt == search_stmt)
    2829                 :            :         {
    2830                 :         58 :           *out_idx = i;
    2831                 :         58 :           return true;
    2832                 :            :         }
    2833                 :            :     }
    2834                 :            :   return false;
    2835                 :            : }
    2836                 :            : 
    2837                 :            : /* Get the final exploded_node in this path, which must be non-empty.  */
    2838                 :            : 
    2839                 :            : exploded_node *
    2840                 :        614 : exploded_path::get_final_enode () const
    2841                 :            : {
    2842                 :        614 :   gcc_assert (m_edges.length () > 0);
    2843                 :        614 :   return m_edges[m_edges.length () - 1]->m_dest;
    2844                 :            : }
    2845                 :            : 
    2846                 :            : /* Check state along this path, returning true if it is feasible.
    2847                 :            :    If OUT is non-NULL, and the path is infeasible, write a new
    2848                 :            :    feasibility_problem to *OUT.  */
    2849                 :            : 
    2850                 :            : bool
    2851                 :        463 : exploded_path::feasible_p (logger *logger, feasibility_problem **out) const
    2852                 :            : {
    2853                 :        926 :   LOG_SCOPE (logger);
    2854                 :            : 
    2855                 :            :   /* Traverse the path, updating this model.  */
    2856                 :        463 :   region_model model;
    2857                 :      16388 :   for (unsigned i = 0; i < m_edges.length (); i++)
    2858                 :            :     {
    2859                 :       7860 :       const exploded_edge *eedge = m_edges[i];
    2860                 :       7860 :       if (logger)
    2861                 :          0 :         logger->log ("considering edge %i: EN:%i -> EN:%i",
    2862                 :            :                      i,
    2863                 :          0 :                      eedge->m_src->m_index,
    2864                 :          0 :                      eedge->m_dest->m_index);
    2865                 :       7860 :       const exploded_node &src_enode = *eedge->m_src;
    2866                 :       7860 :       const program_point &src_point = src_enode.get_point ();
    2867                 :       7860 :       if (logger)
    2868                 :            :         {
    2869                 :          0 :           logger->start_log_line ();
    2870                 :          0 :           src_point.print (logger->get_printer (), format (false));
    2871                 :          0 :           logger->end_log_line ();
    2872                 :            :         }
    2873                 :            : 
    2874                 :       7860 :       if (const gimple *stmt = src_point.get_stmt ())
    2875                 :            :         {
    2876                 :            :           /* Update cfun and input_location in case of ICE: make it easier to
    2877                 :            :              track down which source construct we're failing to handle.  */
    2878                 :       7248 :           auto_cfun sentinel (src_point.get_function ());
    2879                 :       3624 :           input_location = stmt->location;
    2880                 :            : 
    2881                 :       3624 :           if (const gassign *assign = dyn_cast <const gassign *> (stmt))
    2882                 :        689 :             model.on_assignment (assign, NULL);
    2883                 :       3992 :           else if (const greturn *return_ = dyn_cast <const greturn *> (stmt))
    2884                 :        368 :             model.on_return (return_, NULL);
    2885                 :            :         }
    2886                 :            : 
    2887                 :       7860 :       const superedge *sedge = eedge->m_sedge;
    2888                 :       7860 :       if (sedge)
    2889                 :            :         {
    2890                 :       2423 :           if (logger)
    2891                 :          0 :             logger->log ("  sedge: SN:%i -> SN:%i %s",
    2892                 :          0 :                          sedge->m_src->m_index,
    2893                 :          0 :                          sedge->m_dest->m_index,
    2894                 :            :                          sedge->get_description (false));
    2895                 :            : 
    2896                 :       2423 :           const gimple *last_stmt = src_point.get_supernode ()->get_last_stmt ();
    2897                 :       2423 :           if (!model.maybe_update_for_edge (*sedge, last_stmt, NULL))
    2898                 :            :             {
    2899                 :        129 :               if (logger)
    2900                 :            :                 {
    2901                 :          0 :                   logger->log ("rejecting due to region model");
    2902                 :          0 :                   model.dump_to_pp (logger->get_printer (), false);
    2903                 :            :                 }
    2904                 :        129 :               if (out)
    2905                 :        129 :                 *out = new feasibility_problem (i, model, *eedge, last_stmt);
    2906                 :        129 :               return false;
    2907                 :            :             }
    2908                 :            :         }
    2909                 :            :       else
    2910                 :            :         {
    2911                 :            :           /* Special-case the initial eedge from the origin node to the
    2912                 :            :              initial function by pushing a frame for it.  */
    2913                 :       5437 :           if (i == 0)
    2914                 :            :             {
    2915                 :        463 :               gcc_assert (eedge->m_src->m_index == 0);
    2916                 :        463 :               gcc_assert (src_point.get_kind () == PK_ORIGIN);
    2917                 :        463 :               gcc_assert (eedge->m_dest->get_point ().get_kind ()
    2918                 :            :                           == PK_BEFORE_SUPERNODE);
    2919                 :        463 :               function *fun = eedge->m_dest->get_function ();
    2920                 :        463 :               gcc_assert (fun);
    2921                 :        463 :               model.push_frame (fun, NULL, NULL);
    2922                 :        463 :               if (logger)
    2923                 :          0 :                 logger->log ("  pushing frame for %qD", fun->decl);
    2924                 :            :             }
    2925                 :       4974 :           else if (eedge->m_custom_info)
    2926                 :         13 :             eedge->m_custom_info->update_model (&model, *eedge);
    2927                 :            :         }
    2928                 :            : 
    2929                 :            :       /* Handle phi nodes on an edge leaving a PK_BEFORE_SUPERNODE (to
    2930                 :            :          a PK_BEFORE_STMT, or a PK_AFTER_SUPERNODE if no stmts).
    2931                 :            :          This will typically not be associated with a superedge.  */
    2932                 :       7731 :       if (src_point.get_from_edge ())
    2933                 :            :         {
    2934                 :       2067 :           const cfg_superedge *last_cfg_superedge
    2935                 :       2067 :             = src_point.get_from_edge ()->dyn_cast_cfg_superedge ();
    2936                 :       2067 :           if (last_cfg_superedge)
    2937                 :            :             {
    2938                 :       2067 :               if (logger)
    2939                 :          0 :                 logger->log ("  update for phis");
    2940                 :       2067 :               model.update_for_phis (src_enode.get_supernode (),
    2941                 :            :                                      last_cfg_superedge,
    2942                 :            :                                      NULL);
    2943                 :            :             }
    2944                 :            :         }
    2945                 :            : 
    2946                 :       7731 :       if (logger)
    2947                 :            :         {
    2948                 :          0 :           logger->log ("state after edge %i: EN:%i -> EN:%i",
    2949                 :            :                        i,
    2950                 :          0 :                        eedge->m_src->m_index,
    2951                 :          0 :                        eedge->m_dest->m_index);
    2952                 :          0 :           logger->start_log_line ();
    2953                 :          0 :           model.dump_to_pp (logger->get_printer (), true);
    2954                 :          0 :           logger->end_log_line ();
    2955                 :            :         }
    2956                 :            :     }
    2957                 :            : 
    2958                 :            :   return true;
    2959                 :            : }
    2960                 :            : 
    2961                 :            : /* Dump this path in multiline form to PP.  */
    2962                 :            : 
    2963                 :            : void
    2964                 :          0 : exploded_path::dump_to_pp (pretty_printer *pp) const
    2965                 :            : {
    2966                 :          0 :   for (unsigned i = 0; i < m_edges.length (); i++)
    2967                 :            :     {
    2968                 :          0 :       const exploded_edge *eedge = m_edges[i];
    2969                 :          0 :       pp_printf (pp, "m_edges[%i]: EN %i -> EN %i",
    2970                 :            :                  i,
    2971                 :          0 :                  eedge->m_src->m_index,
    2972                 :          0 :                  eedge->m_dest->m_index);
    2973                 :          0 :       pp_newline (pp);
    2974                 :            :     }
    2975                 :          0 : }
    2976                 :            : 
    2977                 :            : /* Dump this path in multiline form to FP.  */
    2978                 :            : 
    2979                 :            : void
    2980                 :          0 : exploded_path::dump (FILE *fp) const
    2981                 :            : {
    2982                 :          0 :   pretty_printer pp;
    2983                 :          0 :   pp_format_decoder (&pp) = default_tree_printer;
    2984                 :          0 :   pp_show_color (&pp) = pp_show_color (global_dc->printer);
    2985                 :          0 :   pp.buffer->stream = fp;
    2986                 :          0 :   dump_to_pp (&pp);
    2987                 :          0 :   pp_flush (&pp);
    2988                 :          0 : }
    2989                 :            : 
    2990                 :            : /* Dump this path in multiline form to stderr.  */
    2991                 :            : 
    2992                 :            : DEBUG_FUNCTION void
    2993                 :          0 : exploded_path::dump () const
    2994                 :            : {
    2995                 :          0 :   dump (stderr);
    2996                 :          0 : }
    2997                 :            : 
    2998                 :            : /* A family of cluster subclasses for use when generating .dot output for
    2999                 :            :    exploded graphs (-fdump-analyzer-exploded-graph), for grouping the
    3000                 :            :    enodes into hierarchical boxes.
    3001                 :            : 
    3002                 :            :    All functionless enodes appear in the top-level graph.
    3003                 :            :    Every (function, call_string) pair gets its own cluster.  Within that
    3004                 :            :    cluster, each supernode gets its own cluster.
    3005                 :            : 
    3006                 :            :    Hence all enodes relating to a particular function with a particular
    3007                 :            :    callstring will be in a cluster together; all enodes for the same
    3008                 :            :    function but with a different callstring will be in a different
    3009                 :            :    cluster.  */
    3010                 :            : 
    3011                 :            : /* Base class of cluster for clustering exploded_node instances in .dot
    3012                 :            :    output, based on various subclass-specific criteria.  */
    3013                 :            : 
    3014                 :         33 : class exploded_cluster : public cluster<eg_traits>
    3015                 :            : {
    3016                 :            : };
    3017                 :            : 
    3018                 :            : /* Cluster containing all exploded_node instances for one supernode.  */
    3019                 :            : 
    3020                 :            : class supernode_cluster : public exploded_cluster
    3021                 :            : {
    3022                 :            : public:
    3023                 :         23 :   supernode_cluster (const supernode *supernode) : m_supernode (supernode) {}
    3024                 :            : 
    3025                 :            :   // TODO: dtor?
    3026                 :            : 
    3027                 :         23 :   void dump_dot (graphviz_out *gv, const dump_args_t &args) const FINAL OVERRIDE
    3028                 :            :   {
    3029                 :         23 :     gv->println ("subgraph \"cluster_supernode_%p\" {",
    3030                 :            :                  (const void *)this);
    3031                 :         23 :     gv->indent ();
    3032                 :         23 :     gv->println ("style=\"dashed\";");
    3033                 :         23 :     gv->println ("label=\"SN: %i (bb: %i)\";",
    3034                 :         23 :                  m_supernode->m_index, m_supernode->m_bb->index);
    3035                 :            : 
    3036                 :         23 :     int i;
    3037                 :         23 :     exploded_node *enode;
    3038                 :         99 :     FOR_EACH_VEC_ELT (m_enodes, i, enode)
    3039                 :         76 :       enode->dump_dot (gv, args);
    3040                 :            : 
    3041                 :            :     /* Terminate subgraph.  */
    3042                 :         23 :     gv->outdent ();
    3043                 :         23 :     gv->println ("}");
    3044                 :         23 :   }
    3045                 :            : 
    3046                 :         76 :   void add_node (exploded_node *en) FINAL OVERRIDE
    3047                 :            :   {
    3048                 :          0 :     m_enodes.safe_push (en);
    3049                 :          0 :   }
    3050                 :            : 
    3051                 :            : private:
    3052                 :            :   const supernode *m_supernode;
    3053                 :            :   auto_vec <exploded_node *> m_enodes;
    3054                 :            : };
    3055                 :            : 
    3056                 :            : /* Cluster containing all supernode_cluster instances for one
    3057                 :            :    (function, call_string) pair.  */
    3058                 :            : 
    3059                 :            : class function_call_string_cluster : public exploded_cluster
    3060                 :            : {
    3061                 :            : public:
    3062                 :          4 :   function_call_string_cluster (function *fun, call_string cs)
    3063                 :          4 :   : m_fun (fun), m_cs (cs) {}
    3064                 :            : 
    3065                 :          8 :   ~function_call_string_cluster ()
    3066                 :          4 :   {
    3067                 :         27 :     for (map_t::iterator iter = m_map.begin ();
    3068                 :         27 :          iter != m_map.end ();
    3069                 :         27 :          ++iter)
    3070                 :         23 :       delete (*iter).second;
    3071                 :          8 :   }
    3072                 :            : 
    3073                 :          4 :   void dump_dot (graphviz_out *gv, const dump_args_t &args) const FINAL OVERRIDE
    3074                 :            :   {
    3075                 :          4 :     const char *funcname = function_name (m_fun);
    3076                 :            : 
    3077                 :          4 :     gv->println ("subgraph \"cluster_function_%p\" {", (const void *)this);
    3078                 :          4 :     gv->indent ();
    3079                 :          4 :     gv->write_indent ();
    3080                 :          4 :     gv->print ("label=\"call string: ");
    3081                 :          4 :     m_cs.print (gv->get_pp ());
    3082                 :          4 :     gv->print (" function: %s \";", funcname);
    3083                 :          4 :     gv->print ("\n");
    3084                 :            : 
    3085                 :          4 :     for (map_t::iterator iter = m_map.begin ();
    3086                 :         27 :          iter != m_map.end ();
    3087                 :         27 :          ++iter)
    3088                 :         23 :       (*iter).second->dump_dot (gv, args);
    3089                 :            : 
    3090                 :            :     /* Terminate subgraph.  */
    3091                 :          4 :     gv->outdent ();
    3092                 :          4 :     gv->println ("}");
    3093                 :          4 :   }
    3094                 :            : 
    3095                 :         76 :   void add_node (exploded_node *en) FINAL OVERRIDE
    3096                 :            :   {
    3097                 :         76 :     const supernode *supernode = en->get_supernode ();
    3098                 :         76 :     gcc_assert (supernode);
    3099                 :         76 :     supernode_cluster **slot = m_map.get (supernode);
    3100                 :         53 :     if (slot)
    3101                 :         53 :       (*slot)->add_node (en);
    3102                 :            :     else
    3103                 :            :       {
    3104                 :         23 :         supernode_cluster *child = new supernode_cluster (supernode);
    3105                 :         23 :         m_map.put (supernode, child);
    3106                 :         23 :         child->add_node (en);
    3107                 :            :       }
    3108                 :         76 :   }
    3109                 :            : 
    3110                 :            : private:
    3111                 :            :   function *m_fun;
    3112                 :            :   call_string m_cs;
    3113                 :            :   typedef ordered_hash_map<const supernode *, supernode_cluster *> map_t;
    3114                 :            :   map_t m_map;
    3115                 :            : };
    3116                 :            : 
    3117                 :            : /* Keys for root_cluster.  */
    3118                 :            : 
    3119                 :        581 : struct function_call_string
    3120                 :            : {
    3121                 :         76 :   function_call_string (function *fun, call_string cs)
    3122                 :         76 :   : m_fun (fun), m_cs (cs)
    3123                 :            :   {
    3124                 :         76 :     gcc_assert (fun);
    3125                 :         76 :   }
    3126                 :            : 
    3127                 :            :   function *m_fun;
    3128                 :            :   call_string m_cs;
    3129                 :            : };
    3130                 :            : 
    3131                 :            : } // namespace ana
    3132                 :            : 
    3133                 :            : template <> struct default_hash_traits<function_call_string>
    3134                 :            : : public pod_hash_traits<function_call_string>
    3135                 :            : {
    3136                 :            :   static const bool empty_zero_p = false;
    3137                 :            : };
    3138                 :            : 
    3139                 :            : template <>
    3140                 :            : inline hashval_t
    3141                 :         86 : pod_hash_traits<function_call_string>::hash (value_type v)
    3142                 :            : {
    3143                 :         86 :   return pointer_hash <function>::hash (v.m_fun) ^ v.m_cs.hash ();
    3144                 :            : }
    3145                 :            : 
    3146                 :            : template <>
    3147                 :            : inline bool
    3148                 :         78 : pod_hash_traits<function_call_string>::equal (const value_type &existing,
    3149                 :            :                                               const value_type &candidate)
    3150                 :            : {
    3151                 :         78 :   return existing.m_fun == candidate.m_fun && existing.m_cs == candidate.m_cs;
    3152                 :            : }
    3153                 :            : template <>
    3154                 :            : inline void
    3155                 :            : pod_hash_traits<function_call_string>::mark_deleted (value_type &v)
    3156                 :            : {
    3157                 :            :   v.m_fun = reinterpret_cast<function *> (1);
    3158                 :            : }
    3159                 :            : template <>
    3160                 :            : inline void
    3161                 :         13 : pod_hash_traits<function_call_string>::mark_empty (value_type &v)
    3162                 :            : {
    3163                 :         13 :   v.m_fun = NULL;
    3164                 :            : }
    3165                 :            : template <>
    3166                 :            : inline bool
    3167                 :         90 : pod_hash_traits<function_call_string>::is_deleted (value_type v)
    3168                 :            : {
    3169                 :         90 :   return v.m_fun == reinterpret_cast<function *> (1);
    3170                 :            : }
    3171                 :            : template <>
    3172                 :            : inline bool
    3173                 :        239 : pod_hash_traits<function_call_string>::is_empty (value_type v)
    3174                 :            : {
    3175                 :        239 :   return v.m_fun == NULL;
    3176                 :            : }
    3177                 :            : 
    3178                 :            : namespace ana {
    3179                 :            : 
    3180                 :            : /* Top-level cluster for generating .dot output for exploded graphs,
    3181                 :            :    handling the functionless nodes, and grouping the remaining nodes by
    3182                 :            :    callstring.  */
    3183                 :            : 
    3184                 :          1 : class root_cluster : public exploded_cluster
    3185                 :            : {
    3186                 :            : public:
    3187                 :          1 :   ~root_cluster ()
    3188                 :          1 :   {
    3189                 :          5 :     for (map_t::iterator iter = m_map.begin ();
    3190                 :          1 :          iter != m_map.end ();
    3191                 :          5 :          ++iter)
    3192                 :          4 :       delete (*iter).second;
    3193                 :          1 :   }
    3194                 :            : 
    3195                 :          1 :   void dump_dot (graphviz_out *gv, const dump_args_t &args) const FINAL OVERRIDE
    3196                 :            :   {
    3197                 :          1 :     int i;
    3198                 :          1 :     exploded_node *enode;
    3199                 :          2 :     FOR_EACH_VEC_ELT (m_functionless_enodes, i, enode)
    3200                 :          1 :       enode->dump_dot (gv, args);
    3201                 :            : 
    3202                 :          5 :     for (map_t::iterator iter = m_map.begin ();
    3203                 :         10 :          iter != m_map.end ();
    3204                 :          5 :          ++iter)
    3205                 :          4 :       (*iter).second->dump_dot (gv, args);
    3206                 :          1 :   }
    3207                 :            : 
    3208                 :         77 :   void add_node (exploded_node *en) FINAL OVERRIDE
    3209                 :            :   {
    3210                 :         77 :     function *fun = en->get_function ();
    3211                 :         76 :     if (!fun)
    3212                 :            :       {
    3213                 :          1 :         m_functionless_enodes.safe_push (en);
    3214                 :          1 :         return;
    3215                 :            :       }
    3216                 :            : 
    3217                 :         76 :     const call_string &cs = en->get_point ().get_call_string ();
    3218                 :        152 :     function_call_string key (fun, cs);
    3219                 :         76 :     function_call_string_cluster **slot = m_map.get (key);
    3220                 :         76 :     if (slot)
    3221                 :         72 :       (*slot)->add_node (en);
    3222                 :            :     else
    3223                 :            :       {
    3224                 :          4 :         function_call_string_cluster *child
    3225                 :          8 :           = new function_call_string_cluster (fun, cs);
    3226                 :          4 :         m_map.put (key, child);
    3227                 :          4 :         child->add_node (en);
    3228                 :            :       }
    3229                 :            :   }
    3230                 :            : 
    3231                 :            : private:
    3232                 :            :   /* This can't be an ordered_hash_map, as we can't store vec<call_string>,
    3233                 :            :      since it's not a POD; vec<>::quick_push has:
    3234                 :            :        *slot = obj;
    3235                 :            :      and the slot isn't initialized, so the assignment op dies when cleaning up
    3236                 :            :      un-inited *slot (within the truncate call).  */
    3237                 :            :   typedef hash_map<function_call_string, function_call_string_cluster *> map_t;
    3238                 :            :   map_t m_map;
    3239                 :            : 
    3240                 :            :   /* This should just be the origin exploded_node.  */
    3241                 :            :   auto_vec <exploded_node *> m_functionless_enodes;
    3242                 :            : };
    3243                 :            : 
    3244                 :            : /* Subclass of range_label for use within
    3245                 :            :    exploded_graph::dump_exploded_nodes for implementing
    3246                 :            :    -fdump-analyzer-exploded-nodes: a label for a specific
    3247                 :            :    exploded_node.  */
    3248                 :            : 
    3249                 :            : class enode_label : public range_label
    3250                 :            : {
    3251                 :            :  public:
    3252                 :          0 :   enode_label (const extrinsic_state &ext_state,
    3253                 :            :                exploded_node *enode)
    3254                 :          0 :   : m_ext_state (ext_state), m_enode (enode) {}
    3255                 :            : 
    3256                 :          0 :   label_text get_text (unsigned) const FINAL OVERRIDE
    3257                 :            :   {
    3258                 :          0 :     pretty_printer pp;
    3259                 :          0 :     pp_format_decoder (&pp) = default_tree_printer;
    3260                 :          0 :     m_enode->get_state ().dump_to_pp (m_ext_state, true, &pp);
    3261                 :          0 :     return make_label_text (false, "EN: %i: %s",
    3262                 :          0 :                             m_enode->m_index, pp_formatted_text (&pp));
    3263                 :            :   }
    3264                 :            : 
    3265                 :            : private:
    3266                 :            :   const extrinsic_state &m_ext_state;
    3267                 :            :   exploded_node *m_enode;
    3268                 :            : };
    3269                 :            : 
    3270                 :            : /* Postprocessing support for dumping the exploded nodes.
    3271                 :            :    Handle -fdump-analyzer-exploded-nodes,
    3272                 :            :    -fdump-analyzer-exploded-nodes-2, and the
    3273                 :            :    "__analyzer_dump_exploded_nodes" builtin.  */
    3274                 :            : 
    3275                 :            : void
    3276                 :        377 : exploded_graph::dump_exploded_nodes () const
    3277                 :            : {
    3278                 :            :   // TODO
    3279                 :            :   /* Locate calls to __analyzer_dump_exploded_nodes.  */
    3280                 :            :   // Print how many egs there are for them?
    3281                 :            :   /* Better: log them as we go, and record the exploded nodes
    3282                 :            :      in question.  */
    3283                 :            : 
    3284                 :            :   /* Show every enode.  */
    3285                 :            : 
    3286                 :            :   /* Gather them by stmt, so that we can more clearly see the
    3287                 :            :      "hotspots" requiring numerous exploded nodes.  */
    3288                 :            : 
    3289                 :            :   /* Alternatively, simply throw them all into one big rich_location
    3290                 :            :      and see if the label-printing will sort it out...
    3291                 :            :      This requires them all to be in the same source file.  */
    3292                 :            : 
    3293                 :        377 :   if (flag_dump_analyzer_exploded_nodes)
    3294                 :            :     {
    3295                 :          0 :       auto_timevar tv (TV_ANALYZER_DUMP);
    3296                 :          0 :       gcc_rich_location richloc (UNKNOWN_LOCATION);
    3297                 :          0 :       unsigned i;
    3298                 :          0 :       exploded_node *enode;
    3299                 :          0 :       FOR_EACH_VEC_ELT (m_nodes, i, enode)
    3300                 :            :         {
    3301                 :          0 :           if (const gimple *stmt = enode->get_stmt ())
    3302                 :            :             {
    3303                 :          0 :               if (get_pure_location (richloc.get_loc ()) == UNKNOWN_LOCATION)
    3304                 :          0 :                 richloc.set_range (0, stmt->location, SHOW_RANGE_WITH_CARET);
    3305                 :            :               else
    3306                 :          0 :                 richloc.add_range (stmt->location,
    3307                 :            :                                    SHOW_RANGE_WITHOUT_CARET,
    3308                 :          0 :                                    new enode_label (m_ext_state, enode));
    3309                 :            :             }
    3310                 :            :         }
    3311                 :          0 :       warning_at (&richloc, 0, "%i exploded nodes", m_nodes.length ());
    3312                 :            : 
    3313                 :            :       /* Repeat the warning without all the labels, so that message is visible
    3314                 :            :          (the other one may well have scrolled past the terminal limit).  */
    3315                 :          0 :       warning_at (richloc.get_loc (), 0,
    3316                 :            :                   "%i exploded nodes", m_nodes.length ());
    3317                 :            : 
    3318                 :          0 :       if (m_worklist.length () > 0)
    3319                 :          0 :         warning_at (richloc.get_loc (), 0,
    3320                 :            :                     "worklist still contains %i nodes", m_worklist.length ());
    3321                 :            :     }
    3322                 :            : 
    3323                 :            :   /* Dump the egraph in textual form to a dump file.  */
    3324                 :        377 :   if (flag_dump_analyzer_exploded_nodes_2)
    3325                 :            :     {
    3326                 :          0 :       auto_timevar tv (TV_ANALYZER_DUMP);
    3327                 :          0 :       char *filename
    3328                 :          0 :         = concat (dump_base_name, ".eg.txt", NULL);
    3329                 :          0 :       FILE *outf = fopen (filename, "w");
    3330                 :          0 :       if (!outf)
    3331                 :          0 :         error_at (UNKNOWN_LOCATION, "unable to open %qs for writing", filename);
    3332                 :          0 :       free (filename);
    3333                 :            : 
    3334                 :          0 :       fprintf (outf, "exploded graph for %s\n", dump_base_name);
    3335                 :          0 :       fprintf (outf, "  nodes: %i\n", m_nodes.length ());
    3336                 :          0 :       fprintf (outf, "  edges: %i\n", m_edges.length ());
    3337                 :            : 
    3338                 :          0 :       unsigned i;
    3339                 :          0 :       exploded_node *enode;
    3340                 :          0 :       FOR_EACH_VEC_ELT (m_nodes, i, enode)
    3341                 :            :         {
    3342                 :          0 :           fprintf (outf, "\nEN %i:\n", enode->m_index);
    3343                 :          0 :           enode->dump_succs_and_preds (outf);
    3344                 :          0 :           pretty_printer pp;
    3345                 :          0 :           enode->get_point ().print (&pp, format (true));
    3346                 :          0 :           fprintf (outf, "%s\n", pp_formatted_text (&pp));
    3347                 :          0 :           enode->get_state ().dump_to_file (m_ext_state, false, outf);
    3348                 :            :         }
    3349                 :            : 
    3350                 :          0 :       fclose (outf);
    3351                 :            :     }
    3352                 :            : 
    3353                 :            :   /* Dump the egraph in textual form to multiple dump files, one per enode.  */
    3354                 :        377 :   if (flag_dump_analyzer_exploded_nodes_3)
    3355                 :            :     {
    3356                 :          0 :       auto_timevar tv (TV_ANALYZER_DUMP);
    3357                 :            : 
    3358                 :            :       unsigned i;
    3359                 :            :       exploded_node *enode;
    3360                 :          0 :       FOR_EACH_VEC_ELT (m_nodes, i, enode)
    3361                 :            :         {
    3362                 :          0 :           char *filename
    3363                 :          0 :             = xasprintf ("%s.en-%i.txt", dump_base_name, i);
    3364                 :          0 :           FILE *outf = fopen (filename, "w");
    3365                 :          0 :           if (!outf)
    3366                 :          0 :             error_at (UNKNOWN_LOCATION, "unable to open %qs for writing", filename);
    3367                 :          0 :           free (filename);
    3368                 :            : 
    3369                 :          0 :           fprintf (outf, "EN %i:\n", enode->m_index);
    3370                 :          0 :           enode->dump_succs_and_preds (outf);
    3371                 :          0 :           pretty_printer pp;
    3372                 :          0 :           enode->get_point ().print (&pp, format (true));
    3373                 :          0 :           fprintf (outf, "%s\n", pp_formatted_text (&pp));
    3374                 :          0 :           enode->get_state ().dump_to_file (m_ext_state, false, outf);
    3375                 :            : 
    3376                 :          0 :           fclose (outf);
    3377                 :            :         }
    3378                 :            :     }
    3379                 :            : 
    3380                 :            :   /* Emit a warning at any call to "__analyzer_dump_exploded_nodes",
    3381                 :            :      giving the number of processed exploded nodes for "before-stmt",
    3382                 :            :      and the IDs of processed, merger, and worklist enodes.
    3383                 :            : 
    3384                 :            :      We highlight the count of *processed* enodes since this is of most
    3385                 :            :      interest in DejaGnu tests for ensuring that state merger has
    3386                 :            :      happened.
    3387                 :            : 
    3388                 :            :      We don't show the count of merger and worklist enodes, as this is
    3389                 :            :      more of an implementation detail of the merging/worklist that we
    3390                 :            :      don't want to bake into our expected DejaGnu messages.  */
    3391                 :            : 
    3392                 :        377 :   unsigned i;
    3393                 :        377 :   exploded_node *enode;
    3394                 :        754 :   hash_set<const gimple *> seen;
    3395                 :      27589 :   FOR_EACH_VEC_ELT (m_nodes, i, enode)
    3396                 :            :     {
    3397                 :      26835 :       if (enode->get_point ().get_kind () != PK_BEFORE_STMT)
    3398                 :      19223 :         continue;
    3399                 :            : 
    3400                 :       7612 :       if (const gimple *stmt = enode->get_stmt ())
    3401                 :       9534 :         if (const gcall *call = dyn_cast <const gcall *> (stmt))
    3402                 :       2027 :           if (is_special_named_call_p (call, "__analyzer_dump_exploded_nodes",
    3403                 :            :                                        1))
    3404                 :            :             {
    3405                 :        212 :               if (seen.contains (stmt))
    3406                 :        105 :                 continue;
    3407                 :            : 
    3408                 :        214 :               auto_vec<exploded_node *> processed_enodes;
    3409                 :        107 :               auto_vec<exploded_node *> merger_enodes;
    3410                 :        107 :               auto_vec<exploded_node *> worklist_enodes;
    3411                 :            :               /* This is O(N^2).  */
    3412                 :        107 :               unsigned j;
    3413                 :        107 :               exploded_node *other_enode;
    3414                 :      24590 :               FOR_EACH_VEC_ELT (m_nodes, j, other_enode)
    3415                 :            :                 {
    3416                 :      24376 :                   if (other_enode->get_point ().get_kind () != PK_BEFORE_STMT)
    3417                 :      16467 :                     continue;
    3418                 :       7909 :                   if (other_enode->get_stmt () == stmt)
    3419                 :        212 :                     switch (other_enode->get_status ())
    3420                 :            :                       {
    3421                 :          0 :                       default:
    3422                 :          0 :                         gcc_unreachable ();
    3423                 :          2 :                       case exploded_node::STATUS_WORKLIST:
    3424                 :          2 :                         worklist_enodes.safe_push (other_enode);
    3425                 :          2 :                         break;
    3426                 :        177 :                       case exploded_node::STATUS_PROCESSED:
    3427                 :        177 :                         processed_enodes.safe_push (other_enode);
    3428                 :        177 :                         break;
    3429                 :         33 :                       case exploded_node::STATUS_MERGER:
    3430                 :         33 :                         merger_enodes.safe_push (other_enode);
    3431                 :         33 :                         break;
    3432                 :            :                       }
    3433                 :            :                 }
    3434                 :            : 
    3435                 :        214 :               pretty_printer pp;
    3436                 :        107 :               pp_character (&pp, '[');
    3437                 :        107 :               print_enode_indices (&pp, processed_enodes);
    3438                 :        107 :               if (merger_enodes.length () > 0)
    3439                 :            :                 {
    3440                 :         20 :                   pp_string (&pp, "] merger(s): [");
    3441                 :         20 :                   print_enode_indices (&pp, merger_enodes);
    3442                 :            :                 }
    3443                 :        107 :               if (worklist_enodes.length () > 0)
    3444                 :            :                 {
    3445                 :          1 :                   pp_string (&pp, "] worklist: [");
    3446                 :          1 :                   print_enode_indices (&pp, worklist_enodes);
    3447                 :            :                 }
    3448                 :        107 :               pp_character (&pp, ']');
    3449                 :            : 
    3450                 :        214 :               warning_n (stmt->location, 0, processed_enodes.length (),
    3451                 :            :                          "%i processed enode: %s",
    3452                 :            :                          "%i processed enodes: %s",
    3453                 :            :                          processed_enodes.length (), pp_formatted_text (&pp));
    3454                 :        107 :               seen.add (stmt);
    3455                 :            : 
    3456                 :            :               /* If the argument is non-zero, then print all of the states
    3457                 :            :                  of the various enodes.  */
    3458                 :        107 :               tree t_arg = fold (gimple_call_arg (call, 0));
    3459                 :        107 :               if (TREE_CODE (t_arg) != INTEGER_CST)
    3460                 :            :                 {
    3461                 :          0 :                   error_at (call->location,
    3462                 :            :                             "integer constant required for arg 1");
    3463                 :          0 :                   return;
    3464                 :            :                 }
    3465                 :        107 :               int i_arg = TREE_INT_CST_LOW (t_arg);
    3466                 :        107 :               if (i_arg)
    3467                 :            :                 {
    3468                 :            :                   exploded_node *other_enode;
    3469                 :        107 :                   FOR_EACH_VEC_ELT (processed_enodes, j, other_enode)
    3470                 :            :                     {
    3471                 :          0 :                       fprintf (stderr, "%i of %i: EN %i:\n",
    3472                 :            :                                j + 1, processed_enodes.length (),
    3473                 :          0 :                                other_enode->m_index);
    3474                 :          0 :                       other_enode->dump_succs_and_preds (stderr);
    3475                 :            :                       /* Dump state.  */
    3476                 :          0 :                       other_enode->get_state ().dump (m_ext_state, false);
    3477                 :            :                     }
    3478                 :            :                 }
    3479                 :            :             }
    3480                 :            :     }
    3481                 :            : }
    3482                 :            : 
    3483                 :            : /* A collection of classes for visualizing the callgraph in .dot form
    3484                 :            :    (as represented in the supergraph).  */
    3485                 :            : 
    3486                 :            : /* Forward decls.  */
    3487                 :            : class viz_callgraph_node;
    3488                 :            : class viz_callgraph_edge;
    3489                 :            : class viz_callgraph;
    3490                 :            : class viz_callgraph_cluster;
    3491                 :            : 
    3492                 :            : /* Traits for using "digraph.h" to visualize the callgraph.  */
    3493                 :            : 
    3494                 :            : struct viz_callgraph_traits
    3495                 :            : {
    3496                 :            :   typedef viz_callgraph_node node_t;
    3497                 :            :   typedef viz_callgraph_edge edge_t;
    3498                 :            :   typedef viz_callgraph graph_t;
    3499                 :            :   struct dump_args_t
    3500                 :            :   {
    3501                 :          1 :     dump_args_t (const exploded_graph *eg) : m_eg (eg) {}
    3502                 :            :     const exploded_graph *m_eg;
    3503                 :            :   };
    3504                 :            :   typedef viz_callgraph_cluster cluster_t;
    3505                 :            : };
    3506                 :            : 
    3507                 :            : /* Subclass of dnode representing a function within the callgraph.  */
    3508                 :            : 
    3509                 :            : class viz_callgraph_node : public dnode<viz_callgraph_traits>
    3510                 :            : {
    3511                 :            :   friend class viz_callgraph;
    3512                 :            : 
    3513                 :            : public:
    3514                 :          3 :   viz_callgraph_node (function *fun, int index)
    3515                 :          3 :   : m_fun (fun), m_index (index), m_num_supernodes (0), m_num_superedges (0)
    3516                 :            :   {
    3517                 :          3 :     gcc_assert (fun);
    3518                 :            :   }
    3519                 :            : 
    3520                 :          3 :   void dump_dot (graphviz_out *gv, const dump_args_t &args) const FINAL OVERRIDE
    3521                 :            :   {
    3522                 :          3 :     pretty_printer *pp = gv->get_pp ();
    3523                 :            : 
    3524                 :          6 :     dump_dot_id (pp);
    3525                 :          3 :     pp_printf (pp, " [shape=none,margin=0,style=filled,fillcolor=%s,label=<",
    3526                 :            :                "lightgrey");
    3527                 :          3 :     pp_string (pp, "<TABLE BORDER=\"0\">");
    3528                 :          3 :     pp_write_text_to_stream (pp);
    3529                 :            : 
    3530                 :          3 :     gv->begin_trtd ();
    3531                 :          3 :     pp_printf (pp, "VCG: %i: %s", m_index, function_name (m_fun));
    3532                 :          3 :     gv->end_tdtr ();
    3533                 :          3 :     pp_newline (pp);
    3534                 :            : 
    3535                 :          3 :     gv->begin_trtd ();
    3536                 :          3 :     pp_printf (pp, "supernodes: %i\n", m_num_supernodes);
    3537                 :          3 :     gv->end_tdtr ();
    3538                 :          3 :     pp_newline (pp);
    3539                 :            : 
    3540                 :          3 :     gv->begin_trtd ();
    3541                 :          3 :     pp_printf (pp, "superedges: %i\n", m_num_superedges);
    3542                 :          3 :     gv->end_tdtr ();
    3543                 :          3 :     pp_newline (pp);
    3544                 :            : 
    3545                 :          3 :     if (args.m_eg)
    3546                 :            :       {
    3547                 :            :         unsigned i;
    3548                 :            :         exploded_node *enode;
    3549                 :            :         unsigned num_enodes = 0;
    3550                 :        234 :         FOR_EACH_VEC_ELT (args.m_eg->m_nodes, i, enode)
    3551                 :            :           {
    3552                 :        459 :             if (enode->get_point ().get_function () == m_fun)
    3553                 :         76 :               num_enodes++;
    3554                 :            :           }
    3555                 :          3 :         gv->begin_trtd ();
    3556                 :          3 :         pp_printf (pp, "enodes: %i\n", num_enodes);
    3557                 :          3 :         gv->end_tdtr ();
    3558                 :          3 :         pp_newline (pp);
    3559                 :            : 
    3560                 :            :         // TODO: also show the per-callstring breakdown
    3561                 :          3 :         const exploded_graph::call_string_data_map_t *per_cs_data
    3562                 :          3 :           = args.m_eg->get_per_call_string_data ();
    3563                 :          9 :         for (exploded_graph::call_string_data_map_t::iterator iter
    3564                 :          9 :                = per_cs_data->begin ();
    3565                 :         18 :              iter != per_cs_data->end ();
    3566                 :          9 :              ++iter)
    3567                 :            :           {
    3568                 :          6 :             const call_string *cs = (*iter).first;
    3569                 :            :             //per_call_string_data *data = (*iter).second;
    3570                 :          6 :             num_enodes = 0;
    3571                 :        468 :             FOR_EACH_VEC_ELT (args.m_eg->m_nodes, i, enode)
    3572                 :            :               {
    3573                 :        462 :                 if (enode->get_point ().get_function () == m_fun
    3574                 :        462 :                     && enode->get_point ().get_call_string () == *cs)
    3575                 :         76 :                   num_enodes++;
    3576                 :            :               }
    3577                 :          6 :             if (num_enodes > 0)
    3578                 :            :               {
    3579                 :          4 :                 gv->begin_trtd ();
    3580                 :          4 :                 cs->print (pp);
    3581                 :          4 :                 pp_printf (pp, ": %i\n", num_enodes);
    3582                 :          4 :                 pp_write_text_as_html_like_dot_to_stream (pp);
    3583                 :          4 :                 gv->end_tdtr ();
    3584                 :            :               }
    3585                 :            :           }
    3586                 :            : 
    3587                 :            :         /* Show any summaries.  */
    3588                 :          3 :         per_function_data *data = args.m_eg->get_per_function_data (m_fun);
    3589                 :          3 :         if (data)
    3590                 :            :           {
    3591                 :          3 :             pp_newline (pp);
    3592                 :          3 :             gv->begin_trtd ();
    3593                 :          6 :             pp_printf (pp, "summaries: %i\n", data->m_summaries.length ());
    3594                 :          3 :             pp_write_text_as_html_like_dot_to_stream (pp);
    3595                 :          3 :             gv->end_tdtr ();
    3596                 :            :           }
    3597                 :            :       }
    3598                 :            : 
    3599                 :          3 :     pp_string (pp, "</TABLE>>];\n\n");
    3600                 :          3 :     pp_flush (pp);
    3601                 :          3 :   }
    3602                 :            : 
    3603                 :          5 :   void dump_dot_id (pretty_printer *pp) const
    3604                 :            :   {
    3605                 :          3 :     pp_printf (pp, "vcg_%i", m_index);
    3606                 :            :   }
    3607                 :            : 
    3608                 :            : private:
    3609                 :            :   function *m_fun;
    3610                 :            :   int m_index;
    3611                 :            :   int m_num_supernodes;
    3612                 :            :   int m_num_superedges;
    3613                 :            : };
    3614                 :            : 
    3615                 :            : /* Subclass of dedge representing a callgraph edge.  */
    3616                 :            : 
    3617                 :            : class viz_callgraph_edge : public dedge<viz_callgraph_traits>
    3618                 :            : {
    3619                 :            : public:
    3620                 :          1 :   viz_callgraph_edge (viz_callgraph_node *src, viz_callgraph_node *dest)
    3621                 :          1 :   : dedge<viz_callgraph_traits> (src, dest)
    3622                 :            :   {}
    3623                 :            : 
    3624                 :          1 :   void dump_dot (graphviz_out *gv, const dump_args_t &) const
    3625                 :            :     FINAL OVERRIDE
    3626                 :            :   {
    3627                 :          1 :     pretty_printer *pp = gv->get_pp ();
    3628                 :            : 
    3629                 :          1 :     const char *style = "\"solid,bold\"";
    3630                 :          1 :     const char *color = "black";
    3631                 :          1 :     int weight = 10;
    3632                 :          1 :     const char *constraint = "true";
    3633                 :            : 
    3634                 :          1 :     m_src->dump_dot_id (pp);
    3635                 :          1 :     pp_string (pp, " -> ");
    3636                 :          1 :     m_dest->dump_dot_id (pp);
    3637                 :          1 :     pp_printf (pp,
    3638                 :            :                (" [style=%s, color=%s, weight=%d, constraint=%s,"
    3639                 :            :                 " headlabel=\""),
    3640                 :            :                style, color, weight, constraint);
    3641                 :          1 :     pp_printf (pp, "\"];\n");
    3642                 :          1 :   }
    3643                 :            : };
    3644                 :            : 
    3645                 :            : /* Subclass of digraph representing the callgraph.  */
    3646                 :            : 
    3647                 :            : class viz_callgraph : public digraph<viz_callgraph_traits>
    3648                 :            : {
    3649                 :            : public:
    3650                 :            :   viz_callgraph (const supergraph &sg);
    3651                 :            : 
    3652                 :         62 :   viz_callgraph_node *get_vcg_node_for_function (function *fun)
    3653                 :            :   {
    3654                 :        124 :     return *m_map.get (fun);
    3655                 :            :   }
    3656                 :            : 
    3657                 :         22 :   viz_callgraph_node *get_vcg_node_for_snode (supernode *snode)
    3658                 :            :   {
    3659                 :         44 :     return get_vcg_node_for_function (snode->m_fun);
    3660                 :            :   }
    3661                 :            : 
    3662                 :            : private:
    3663                 :            :   hash_map<function *, viz_callgraph_node *> m_map;
    3664                 :            : };
    3665                 :            : 
    3666                 :            : /* Placeholder subclass of cluster.  */
    3667                 :            : 
    3668                 :            : class viz_callgraph_cluster : public cluster<viz_callgraph_traits>
    3669                 :            : {
    3670                 :            : };
    3671                 :            : 
    3672                 :            : /* viz_callgraph's ctor.  */
    3673                 :            : 
    3674                 :          1 : viz_callgraph::viz_callgraph (const supergraph &sg)
    3675                 :            : {
    3676                 :          1 :   cgraph_node *node;
    3677                 :          5 :   FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node)
    3678                 :            :     {
    3679                 :          3 :       function *fun = node->get_fun ();
    3680                 :          3 :       viz_callgraph_node *vcg_node
    3681                 :          5 :         = new viz_callgraph_node (fun, m_nodes.length ());
    3682                 :          3 :       m_map.put (fun, vcg_node);
    3683                 :          3 :       add_node (vcg_node);
    3684                 :            :     }
    3685                 :            : 
    3686                 :            :   unsigned i;
    3687                 :            :   superedge *sedge;
    3688                 :         22 :   FOR_EACH_VEC_ELT (sg.m_edges, i, sedge)
    3689                 :            :     {
    3690                 :         21 :       viz_callgraph_node *vcg_src = get_vcg_node_for_snode (sedge->m_src);
    3691                 :         21 :       if (vcg_src->m_fun)
    3692                 :         42 :         get_vcg_node_for_function (vcg_src->m_fun)->m_num_superedges++;
    3693                 :         21 :       if (sedge->dyn_cast_call_superedge ())
    3694                 :            :         {
    3695                 :          1 :           viz_callgraph_node *vcg_dest = get_vcg_node_for_snode (sedge->m_dest);
    3696                 :          1 :           viz_callgraph_edge *vcg_edge
    3697                 :          1 :             = new viz_callgraph_edge (vcg_src, vcg_dest);
    3698                 :          1 :           add_edge (vcg_edge);
    3699                 :            :         }
    3700                 :            :     }
    3701                 :            : 
    3702                 :            :   supernode *snode;
    3703                 :         20 :   FOR_EACH_VEC_ELT (sg.m_nodes, i, snode)
    3704                 :            :     {
    3705                 :         19 :       if (snode->m_fun)
    3706                 :         38 :         get_vcg_node_for_function (snode->m_fun)->m_num_supernodes++;
    3707                 :            :     }
    3708                 :          1 : }
    3709                 :            : 
    3710                 :            : /* Dump the callgraph to FILENAME.  */
    3711                 :            : 
    3712                 :            : static void
    3713                 :          1 : dump_callgraph (const supergraph &sg, const char *filename,
    3714                 :            :                 const exploded_graph *eg)
    3715                 :            : {
    3716                 :          1 :   FILE *outf = fopen (filename, "w");
    3717                 :          1 :   if (!outf)
    3718                 :          0 :     return;
    3719                 :            : 
    3720                 :            :   // TODO
    3721                 :          2 :   viz_callgraph vcg (sg);
    3722                 :          1 :   vcg.dump_dot (filename, NULL, viz_callgraph_traits::dump_args_t (eg));
    3723                 :            : 
    3724                 :          1 :   fclose (outf);
    3725                 :            : }
    3726                 :            : 
    3727                 :            : /* Dump the callgraph to "<srcfile>.callgraph.dot".  */
    3728                 :            : 
    3729                 :            : static void
    3730                 :          1 : dump_callgraph (const supergraph &sg, const exploded_graph *eg)
    3731                 :            : {
    3732                 :          1 :   auto_timevar tv (TV_ANALYZER_DUMP);
    3733                 :          1 :   char *filename = concat (dump_base_name, ".callgraph.dot", NULL);
    3734                 :          1 :   dump_callgraph (sg, filename, eg);
    3735                 :          1 :   free (filename);
    3736                 :          1 : }
    3737                 :            : 
    3738                 :            : /* Subclass of dot_annotator for implementing
    3739                 :            :    DUMP_BASE_NAME.supergraph-eg.dot, a post-analysis dump of the supergraph.
    3740                 :            : 
    3741                 :            :    Annotate the supergraph nodes by printing the exploded nodes in concise
    3742                 :            :    form within them, next to their pertinent statements where appropriate,
    3743                 :            :    colorizing the exploded nodes based on sm-state.
    3744                 :            :    Also show saved diagnostics within the exploded nodes, giving information
    3745                 :            :    on whether they were feasible, and, if infeasible, where the problem
    3746                 :            :    was.  */
    3747                 :            : 
    3748                 :          1 : class exploded_graph_annotator : public dot_annotator
    3749                 :            : {
    3750                 :            : public:
    3751                 :          1 :   exploded_graph_annotator (const exploded_graph &eg)
    3752                 :          1 :   : m_eg (eg)
    3753                 :            :   {
    3754                 :            :     /* Avoid O(N^2) by prepopulating m_enodes_per_snodes.  */
    3755                 :          1 :     unsigned i;
    3756                 :          1 :     supernode *snode;
    3757                 :         20 :     FOR_EACH_VEC_ELT (eg.get_supergraph ().m_nodes, i, snode)
    3758                 :         19 :       m_enodes_per_snodes.safe_push (new auto_vec <exploded_node *> ());
    3759                 :            :     exploded_node *enode;
    3760                 :         78 :     FOR_EACH_VEC_ELT (m_eg.m_nodes, i, enode)
    3761                 :         77 :       if (enode->get_supernode ())
    3762                 :         76 :         m_enodes_per_snodes[enode->get_supernode ()->m_index]->safe_push (enode);
    3763                 :          1 :   }
    3764                 :            : 
    3765                 :            :   /* Show exploded nodes for BEFORE_SUPERNODE points before N.  */
    3766                 :         38 :   bool add_node_annotations (graphviz_out *gv, const supernode &n,
    3767                 :            :                              bool within_table)
    3768                 :            :     const FINAL OVERRIDE
    3769                 :            :   {
    3770                 :         38 :     if (!within_table)
    3771                 :            :       return false;
    3772                 :         19 :     gv->begin_tr ();
    3773                 :         19 :     pretty_printer *pp = gv->get_pp ();
    3774                 :            : 
    3775                 :         19 :     gv->begin_td ();
    3776                 :         19 :     pp_string (pp, "BEFORE");
    3777                 :         19 :     gv->end_td ();
    3778                 :            : 
    3779                 :         19 :     unsigned i;
    3780                 :         19 :     exploded_node *enode;
    3781                 :         19 :     bool had_enode = false;
    3782                 :         95 :     FOR_EACH_VEC_ELT (*m_enodes_per_snodes[n.m_index], i, enode)
    3783                 :            :       {
    3784                 :         76 :         gcc_assert (enode->get_supernode () == &n);
    3785                 :         76 :         const program_point &point = enode->get_point ();
    3786                 :         76 :         if (point.get_kind () != PK_BEFORE_SUPERNODE)
    3787                 :         48 :           continue;
    3788                 :         28 :         print_enode (gv, enode);
    3789                 :         28 :         had_enode = true;
    3790                 :            :       }
    3791                 :         19 :     if (!had_enode)
    3792                 :          0 :       pp_string (pp, "<TD BGCOLOR=\"red\">UNREACHED</TD>");
    3793                 :         19 :     pp_flush (pp);
    3794                 :         19 :     gv->end_tr ();
    3795                 :         19 :     return true;
    3796                 :            :   }
    3797                 :            : 
    3798                 :            :   /* Show exploded nodes for STMT.  */
    3799                 :         66 :   void add_stmt_annotations (graphviz_out *gv, const gimple *stmt,
    3800                 :            :                              bool within_row)
    3801                 :            :     const FINAL OVERRIDE
    3802                 :            :   {
    3803                 :         66 :     if (!within_row)
    3804                 :         66 :       return;
    3805                 :         33 :     pretty_printer *pp = gv->get_pp ();
    3806                 :            : 
    3807                 :         33 :     const supernode *snode
    3808                 :         33 :       = m_eg.get_supergraph ().get_supernode_for_stmt (stmt);
    3809                 :         33 :     unsigned i;
    3810                 :         33 :     exploded_node *enode;
    3811                 :         33 :     bool had_td = false;
    3812                 :        206 :     FOR_EACH_VEC_ELT (*m_enodes_per_snodes[snode->m_index], i, enode)
    3813                 :            :       {
    3814                 :        173 :         const program_point &point = enode->get_point ();
    3815                 :        173 :         if (point.get_kind () != PK_BEFORE_STMT)
    3816                 :        106 :           continue;
    3817                 :         67 :         if (point.get_stmt () != stmt)
    3818                 :         43 :           continue;
    3819                 :         24 :         print_enode (gv, enode);
    3820                 :         24 :         had_td = true;
    3821                 :            :       }
    3822                 :         33 :     pp_flush (pp);
    3823                 :         33 :     if (!had_td)
    3824                 :            :       {
    3825                 :         16 :         gv->begin_td ();
    3826                 :         16 :         gv->end_td ();
    3827                 :            :       }
    3828                 :            :   }
    3829                 :            : 
    3830                 :            :   /* Show exploded nodes for AFTER_SUPERNODE points after N.  */
    3831                 :         19 :   bool add_after_node_annotations (graphviz_out *gv, const supernode &n)
    3832                 :            :     const FINAL OVERRIDE
    3833                 :            :   {
    3834                 :         19 :     gv->begin_tr ();
    3835                 :         19 :     pretty_printer *pp = gv->get_pp ();
    3836                 :            : 
    3837                 :         19 :     gv->begin_td ();
    3838                 :         19 :     pp_string (pp, "AFTER");
    3839                 :         19 :     gv->end_td ();
    3840                 :            : 
    3841                 :         19 :     unsigned i;
    3842                 :         19 :     exploded_node *enode;
    3843                 :         95 :     FOR_EACH_VEC_ELT (*m_enodes_per_snodes[n.m_index], i, enode)
    3844                 :            :       {
    3845                 :         76 :         gcc_assert (enode->get_supernode () == &n);
    3846                 :         76 :         const program_point &point = enode->get_point ();
    3847                 :         76 :         if (point.get_kind () != PK_AFTER_SUPERNODE)
    3848                 :         51 :           continue;
    3849                 :         25 :         print_enode (gv, enode);
    3850                 :            :       }
    3851                 :         19 :     pp_flush (pp);
    3852                 :         19 :     gv->end_tr ();
    3853                 :         19 :     return true;
    3854                 :            :   }
    3855                 :            : 
    3856                 :            : private:
    3857                 :            :   /* Concisely print a TD element for ENODE, showing the index, status,
    3858                 :            :      and any saved_diagnostics at the enode.  Colorize it to show sm-state.
    3859                 :            : 
    3860                 :            :      Ideally we'd dump ENODE's state here, hidden behind some kind of
    3861                 :            :      interactive disclosure method like a tooltip, so that the states
    3862                 :            :      can be explored without overwhelming the graph.
    3863                 :            :      However, I wasn't able to get graphviz/xdot to show tooltips on
    3864                 :            :      individual elements within a HTML-like label.  */
    3865                 :         77 :   void print_enode (graphviz_out *gv, const exploded_node *enode) const
    3866                 :            :   {
    3867                 :         77 :     pretty_printer *pp = gv->get_pp ();
    3868                 :         77 :     pp_printf (pp, "<TD BGCOLOR=\"%s\">",
    3869                 :            :                enode->get_dot_fillcolor ());
    3870                 :         77 :     pp_printf (pp, "<TABLE BORDER=\"0\">");
    3871                 :         77 :     gv->begin_trtd ();
    3872                 :         77 :     pp_printf (pp, "EN: %i", enode->m_index);
    3873                 :         77 :     switch (enode->get_status ())
    3874                 :            :       {
    3875                 :          0 :       default:
    3876                 :          0 :         gcc_unreachable ();
    3877                 :          0 :       case exploded_node::STATUS_WORKLIST:
    3878                 :          0 :         pp_string (pp, "(W)");
    3879                 :          0 :         break;
    3880                 :            :       case exploded_node::STATUS_PROCESSED:
    3881                 :            :         break;
    3882                 :          1 :       case exploded_node::STATUS_MERGER:
    3883                 :          1 :         pp_string (pp, "(M)");
    3884                 :          1 :         break;
    3885                 :            :       }
    3886                 :         77 :     gv->end_tdtr ();
    3887                 :            :     /* Dump any saved_diagnostics at this enode.  */
    3888                 :         77 :     {
    3889                 :         77 :       const diagnostic_manager &dm = m_eg.get_diagnostic_manager ();
    3890                 :         77 :       for (unsigned i = 0; i < dm.get_num_diagnostics (); i++)
    3891                 :            :         {
    3892                 :          0 :           const saved_diagnostic *sd = dm.get_saved_diagnostic (i);
    3893                 :          0 :           if (sd->m_enode == enode)
    3894                 :          0 :             print_saved_diagnostic (gv, sd);
    3895                 :            :         }
    3896                 :            :     }
    3897                 :         77 :     pp_printf (pp, "</TABLE>");
    3898                 :         77 :     pp_printf (pp, "</TD>");
    3899                 :         77 :   }
    3900                 :            : 
    3901                 :            :   /* Print a TABLE element for SD, showing the kind, the length of the
    3902                 :            :      exploded_path, whether the path was feasible, and if infeasible,
    3903                 :            :      what the problem was.  */
    3904                 :          0 :   void print_saved_diagnostic (graphviz_out *gv,
    3905                 :            :                                const saved_diagnostic *sd) const
    3906                 :            :   {
    3907                 :          0 :     pretty_printer *pp = gv->get_pp ();
    3908                 :          0 :     gv->begin_trtd ();
    3909                 :          0 :     pp_printf (pp, "<TABLE BORDER=\"0\">");
    3910                 :          0 :     gv->begin_tr ();
    3911                 :          0 :     pp_string (pp, "<TD BGCOLOR=\"green\">");
    3912                 :          0 :     pp_printf (pp, "DIAGNOSTIC: %s", sd->m_d->get_kind ());
    3913                 :          0 :     gv->end_tdtr ();
    3914                 :          0 :     gv->begin_trtd ();
    3915                 :          0 :     pp_printf (pp, "epath length: %i", sd->get_epath_length ());
    3916                 :          0 :     gv->end_tdtr ();
    3917                 :          0 :     switch (sd->get_status ())
    3918                 :            :       {
    3919                 :          0 :       default:
    3920                 :          0 :       case saved_diagnostic::STATUS_NEW:
    3921                 :          0 :         gcc_unreachable ();
    3922                 :          0 :         break;
    3923                 :          0 :       case saved_diagnostic::STATUS_INFEASIBLE_PATH:
    3924                 :          0 :         {
    3925                 :          0 :           gv->begin_trtd ();
    3926                 :          0 :           pp_printf (pp, "INFEASIBLE");
    3927                 :          0 :           gv->end_tdtr ();
    3928                 :          0 :           const feasibility_problem *p = sd->get_feasibility_problem ();
    3929                 :          0 :           gcc_assert (p);
    3930                 :          0 :           gv->begin_trtd ();
    3931                 :          0 :           pp_printf (pp, "at eedge %i: EN:%i -> EN:%i",
    3932                 :          0 :                      p->m_eedge_idx,
    3933                 :          0 :                      p->m_eedge.m_src->m_index,
    3934                 :          0 :                      p->m_eedge.m_dest->m_index);
    3935                 :          0 :           pp_write_text_as_html_like_dot_to_stream (pp);
    3936                 :          0 :           gv->end_tdtr ();
    3937                 :          0 :           gv->begin_trtd ();
    3938                 :          0 :           p->m_eedge.m_sedge->dump (pp);
    3939                 :          0 :           pp_write_text_as_html_like_dot_to_stream (pp);
    3940                 :          0 :           gv->end_tdtr ();
    3941                 :          0 :           gv->begin_trtd ();
    3942                 :          0 :           pp_gimple_stmt_1 (pp, p->m_last_stmt, 0, (dump_flags_t)0);
    3943                 :          0 :           pp_write_text_as_html_like_dot_to_stream (pp);
    3944                 :          0 :           gv->end_tdtr ();
    3945                 :            :           /* Ideally we'd print p->m_model here; see the notes above about
    3946                 :            :              tooltips.  */
    3947                 :            :         }
    3948                 :          0 :         break;
    3949                 :          0 :       case saved_diagnostic::STATUS_FEASIBLE_PATH:
    3950                 :          0 :         gv->begin_trtd ();
    3951                 :          0 :         pp_printf (pp, "FEASIBLE");
    3952                 :          0 :         gv->end_tdtr ();
    3953                 :          0 :         break;
    3954                 :            :       }
    3955                 :          0 :     pp_printf (pp, "</TABLE>");
    3956                 :          0 :     gv->end_tdtr ();
    3957                 :          0 :   }
    3958                 :            : 
    3959                 :            :   const exploded_graph &m_eg;
    3960                 :            :   auto_delete_vec<auto_vec <exploded_node *> > m_enodes_per_snodes;
    3961                 :            : };
    3962                 :            : 
    3963                 :            : /* Run the analysis "engine".  */
    3964                 :            : 
    3965                 :            : void
    3966                 :        377 : impl_run_checkers (logger *logger)
    3967                 :            : {
    3968                 :        754 :   LOG_SCOPE (logger);
    3969                 :            : 
    3970                 :            :   /* If using LTO, ensure that the cgraph nodes have function bodies.  */
    3971                 :        377 :   cgraph_node *node;
    3972                 :       2760 :   FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node)
    3973                 :       1003 :     node->get_untransformed_body ();
    3974                 :            : 
    3975                 :            :   /* Create the supergraph.  */
    3976                 :        754 :   supergraph sg (logger);
    3977                 :            : 
    3978                 :        377 :   state_purge_map *purge_map = NULL;
    3979                 :            : 
    3980                 :        377 :   if (flag_analyzer_state_purge)
    3981                 :        373 :     purge_map = new state_purge_map (sg, logger);
    3982                 :            : 
    3983                 :        377 :   if (flag_dump_analyzer_supergraph)
    3984                 :            :     {
    3985                 :            :       /* Dump supergraph pre-analysis.  */
    3986                 :          2 :       auto_timevar tv (TV_ANALYZER_DUMP);
    3987                 :          1 :       char *filename = concat (dump_base_name, ".supergraph.dot", NULL);
    3988                 :          1 :       supergraph::dump_args_t args ((enum supergraph_dot_flags)0, NULL);
    3989                 :          1 :       sg.dump_dot (filename, args);
    3990                 :          1 :       free (filename);
    3991                 :            :     }
    3992                 :            : 
    3993                 :        377 :   if (flag_dump_analyzer_state_purge)
    3994                 :            :     {
    3995                 :          2 :       auto_timevar tv (TV_ANALYZER_DUMP);
    3996                 :          2 :       state_purge_annotator a (purge_map);
    3997                 :          1 :       char *filename = concat (dump_base_name, ".state-purge.dot", NULL);
    3998                 :          1 :       supergraph::dump_args_t args ((enum supergraph_dot_flags)0, &a);
    3999                 :          1 :       sg.dump_dot (filename, args);
    4000                 :          1 :       free (filename);
    4001                 :            :     }
    4002                 :            : 
    4003                 :        754 :   auto_delete_vec <state_machine> checkers;
    4004                 :        377 :   make_checkers (checkers, logger);
    4005                 :            : 
    4006                 :        377 :   if (logger)
    4007                 :            :     {
    4008                 :            :       int i;
    4009                 :            :       state_machine *sm;
    4010                 :          0 :       FOR_EACH_VEC_ELT (checkers, i, sm)
    4011                 :          0 :         logger->log ("checkers[%i]: %s", i, sm->get_name ());
    4012                 :            :     }
    4013                 :            : 
    4014                 :            :   /* Extrinsic state shared by nodes in the graph.  */
    4015                 :        377 :   const extrinsic_state ext_state (checkers);
    4016                 :            : 
    4017                 :        754 :   const analysis_plan plan (sg, logger);
    4018                 :            : 
    4019                 :            :   /* The exploded graph.  */
    4020                 :        377 :   exploded_graph eg (sg, logger, ext_state, purge_map, plan,
    4021                 :        754 :                      analyzer_verbosity);
    4022                 :            : 
    4023                 :            :   /* Add entrypoints to the graph for externally-callable functions.  */
    4024                 :        377 :   eg.build_initial_worklist ();
    4025                 :            : 
    4026                 :            :   /* Now process the worklist, exploring the <point, state> graph.  */
    4027                 :        377 :   eg.process_worklist ();
    4028                 :            : 
    4029                 :        377 :   if (flag_dump_analyzer_exploded_graph)
    4030                 :            :     {
    4031                 :          2 :       auto_timevar tv (TV_ANALYZER_DUMP);
    4032                 :          1 :       char *filename
    4033                 :          1 :         = concat (dump_base_name, ".eg.dot", NULL);
    4034                 :          1 :       exploded_graph::dump_args_t args (eg);
    4035                 :          2 :       root_cluster c;
    4036                 :          1 :       eg.dump_dot (filename, &c, args);
    4037                 :          1 :       free (filename);
    4038                 :            :     }
    4039                 :            : 
    4040                 :            :   /* Now emit any saved diagnostics.  */
    4041                 :        377 :   eg.get_diagnostic_manager ().emit_saved_diagnostics (eg);
    4042                 :            : 
    4043                 :        377 :   eg.dump_exploded_nodes ();
    4044                 :            : 
    4045                 :        377 :   eg.log_stats ();
    4046                 :            : 
    4047                 :        377 :   if (flag_dump_analyzer_callgraph)
    4048                 :          1 :     dump_callgraph (sg, &eg);
    4049                 :            : 
    4050                 :        377 :   if (flag_dump_analyzer_supergraph)
    4051                 :            :     {
    4052                 :            :       /* Dump post-analysis form of supergraph.  */
    4053                 :          2 :       auto_timevar tv (TV_ANALYZER_DUMP);
    4054                 :          1 :       char *filename = concat (dump_base_name, ".supergraph-eg.dot", NULL);
    4055                 :          2 :       exploded_graph_annotator a (eg);
    4056                 :          1 :       supergraph::dump_args_t args ((enum supergraph_dot_flags)0, &a);
    4057                 :          1 :       sg.dump_dot (filename, args);
    4058                 :          1 :       free (filename);
    4059                 :            :     }
    4060                 :            : 
    4061                 :        377 :   delete purge_map;
    4062                 :        377 : }
    4063                 :            : 
    4064                 :            : /* External entrypoint to the analysis "engine".
    4065                 :            :    Set up any dumps, then call impl_run_checkers.  */
    4066                 :            : 
    4067                 :            : void
    4068                 :        377 : run_checkers ()
    4069                 :            : {
    4070                 :            :   /* Save input_location.  */
    4071                 :        377 :   location_t saved_input_location = input_location;
    4072                 :            : 
    4073                 :            :   /* Handle -fdump-analyzer and -fdump-analyzer-stderr.  */
    4074                 :        377 :   FILE *dump_fout = NULL;
    4075                 :            :   /* Track if we're responsible for closing dump_fout.  */
    4076                 :        377 :   bool owns_dump_fout = false;
    4077                 :        377 :   if (flag_dump_analyzer_stderr)
    4078                 :          0 :     dump_fout = stderr;
    4079                 :        377 :   else if (flag_dump_analyzer)
    4080                 :            :     {
    4081                 :          0 :       char *dump_filename = concat (dump_base_name, ".analyzer.txt", NULL);
    4082                 :          0 :       dump_fout = fopen (dump_filename, "w");
    4083                 :          0 :       free (dump_filename);
    4084                 :          0 :       if (dump_fout)
    4085                 :          0 :         owns_dump_fout = true;
    4086                 :            :     }
    4087                 :            : 
    4088                 :        377 :   {
    4089                 :        754 :     log_user the_logger (NULL);
    4090                 :        377 :     if (dump_fout)
    4091                 :          0 :       the_logger.set_logger (new logger (dump_fout, 0, 0,
    4092                 :          0 :                                          *global_dc->printer));
    4093                 :        754 :     LOG_SCOPE (the_logger.get_logger ());
    4094                 :            : 
    4095                 :        377 :     impl_run_checkers (the_logger.get_logger ());
    4096                 :            : 
    4097                 :            :     /* end of lifetime of the_logger (so that dump file is closed after the
    4098                 :            :        various dtors run).  */
    4099                 :            :   }
    4100                 :            : 
    4101                 :        377 :   if (owns_dump_fout)
    4102                 :          0 :     fclose (dump_fout);
    4103                 :            : 
    4104                 :            :   /* Restore input_location.  Subsequent passes may assume that input_location
    4105                 :            :      is some arbitrary value *not* in the block tree, which might be violated
    4106                 :            :      if we didn't restore it.  */
    4107                 :        377 :   input_location = saved_input_location;
    4108                 :        377 : }
    4109                 :            : 
    4110                 :            : } // namespace ana
    4111                 :            : 
    4112                 :            : #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.