LCOV - code coverage report
Current view: top level - gcc/analyzer - sm-malloc.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 91.6 % 971 889
Test Date: 2024-11-30 13:30:02 Functions: 87.0 % 131 114
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : /* A state machine for detecting misuses of the malloc/free API.
       2                 :             :    Copyright (C) 2019-2024 Free Software Foundation, Inc.
       3                 :             :    Contributed by David Malcolm <dmalcolm@redhat.com>.
       4                 :             : 
       5                 :             : This file is part of GCC.
       6                 :             : 
       7                 :             : GCC is free software; you can redistribute it and/or modify it
       8                 :             : under the terms of the GNU General Public License as published by
       9                 :             : the Free Software Foundation; either version 3, or (at your option)
      10                 :             : any later version.
      11                 :             : 
      12                 :             : GCC is distributed in the hope that it will be useful, but
      13                 :             : WITHOUT ANY WARRANTY; without even the implied warranty of
      14                 :             : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15                 :             : General Public License for more details.
      16                 :             : 
      17                 :             : You should have received a copy of the GNU General Public License
      18                 :             : along with GCC; see the file COPYING3.  If not see
      19                 :             : <http://www.gnu.org/licenses/>.  */
      20                 :             : 
      21                 :             : #include "config.h"
      22                 :             : #define INCLUDE_VECTOR
      23                 :             : #include "system.h"
      24                 :             : #include "coretypes.h"
      25                 :             : #include "make-unique.h"
      26                 :             : #include "tree.h"
      27                 :             : #include "function.h"
      28                 :             : #include "basic-block.h"
      29                 :             : #include "gimple.h"
      30                 :             : #include "options.h"
      31                 :             : #include "bitmap.h"
      32                 :             : #include "diagnostic-core.h"
      33                 :             : #include "diagnostic-path.h"
      34                 :             : #include "analyzer/analyzer.h"
      35                 :             : #include "diagnostic-event-id.h"
      36                 :             : #include "analyzer/analyzer-logging.h"
      37                 :             : #include "analyzer/sm.h"
      38                 :             : #include "analyzer/pending-diagnostic.h"
      39                 :             : #include "analyzer/call-string.h"
      40                 :             : #include "analyzer/program-point.h"
      41                 :             : #include "analyzer/store.h"
      42                 :             : #include "analyzer/region-model.h"
      43                 :             : #include "analyzer/call-details.h"
      44                 :             : #include "stringpool.h"
      45                 :             : #include "attribs.h"
      46                 :             : #include "analyzer/function-set.h"
      47                 :             : #include "analyzer/program-state.h"
      48                 :             : #include "analyzer/checker-event.h"
      49                 :             : #include "analyzer/exploded-graph.h"
      50                 :             : #include "analyzer/inlining-iterator.h"
      51                 :             : 
      52                 :             : #if ENABLE_ANALYZER
      53                 :             : 
      54                 :             : namespace ana {
      55                 :             : 
      56                 :             : namespace {
      57                 :             : 
      58                 :             : /* This state machine and its various support classes track allocations
      59                 :             :    and deallocations.
      60                 :             : 
      61                 :             :    It has a few standard allocation/deallocation pairs (e.g. new/delete),
      62                 :             :    and also supports user-defined ones via
      63                 :             :    __attribute__ ((malloc(DEALLOCATOR))).
      64                 :             : 
      65                 :             :    There can be more than one valid deallocator for a given allocator,
      66                 :             :    for example:
      67                 :             :      __attribute__ ((malloc (fclose)))
      68                 :             :      __attribute__ ((malloc (freopen, 3)))
      69                 :             :      FILE* fopen (const char*, const char*);
      70                 :             :    A deallocator_set represents a particular set of valid deallocators.
      71                 :             : 
      72                 :             :    We track the expected deallocator_set for a value, but not the allocation
      73                 :             :    function - there could be more than one allocator per deallocator_set.
      74                 :             :    For example, there could be dozens of allocators for "free" beyond just
      75                 :             :    malloc e.g. calloc, xstrdup, etc.  We don't want to explode the number
      76                 :             :    of states by tracking individual allocators in the exploded graph;
      77                 :             :    we merely want to track "this value expects to have 'free' called on it".
      78                 :             :    Perhaps we can reconstruct which allocator was used later, when emitting
      79                 :             :    the path, if it's necessary for precision of wording of diagnostics.  */
      80                 :             : 
      81                 :             : class deallocator;
      82                 :             : class deallocator_set;
      83                 :             : class malloc_state_machine;
      84                 :             : 
      85                 :             : /* An enum for discriminating between different kinds of allocation_state.  */
      86                 :             : 
      87                 :             : enum resource_state
      88                 :             : {
      89                 :             :   /* States that are independent of allocator/deallocator.  */
      90                 :             : 
      91                 :             :   /* The start state.  */
      92                 :             :   RS_START,
      93                 :             : 
      94                 :             :   /* State for a pointer that's been unconditionally dereferenced.  */
      95                 :             :   RS_ASSUMED_NON_NULL,
      96                 :             : 
      97                 :             :   /* State for a pointer that's known to be NULL.  */
      98                 :             :   RS_NULL,
      99                 :             : 
     100                 :             :   /* State for a pointer that's known to not be on the heap (e.g. to a local
     101                 :             :      or global).  */
     102                 :             :   RS_NON_HEAP,
     103                 :             : 
     104                 :             :   /* Stop state, for pointers we don't want to track any more.  */
     105                 :             :   RS_STOP,
     106                 :             : 
     107                 :             :   /* States that relate to a specific deallocator_set.  */
     108                 :             : 
     109                 :             :   /* State for a pointer returned from an allocator that hasn't
     110                 :             :      been checked for NULL.
     111                 :             :      It could be a pointer to heap-allocated memory, or could be NULL.  */
     112                 :             :   RS_UNCHECKED,
     113                 :             : 
     114                 :             :   /* State for a pointer returned from an allocator,
     115                 :             :      known to be non-NULL.  */
     116                 :             :   RS_NONNULL,
     117                 :             : 
     118                 :             :   /* State for a pointer passed to a deallocator.  */
     119                 :             :   RS_FREED
     120                 :             : };
     121                 :             : 
     122                 :             : /* Custom state subclass, which can optionally refer to an a
     123                 :             :    deallocator_set.  */
     124                 :             : 
     125                 :             : struct allocation_state : public state_machine::state
     126                 :             : {
     127                 :       44668 :   allocation_state (const char *name, unsigned id,
     128                 :             :                     enum resource_state rs,
     129                 :             :                     const deallocator_set *deallocators,
     130                 :             :                     const deallocator *deallocator)
     131                 :       44668 :   : state (name, id), m_rs (rs),
     132                 :       41929 :     m_deallocators (deallocators),
     133                 :       41929 :     m_deallocator (deallocator)
     134                 :             :   {}
     135                 :             : 
     136                 :             :   void dump_to_pp (pretty_printer *pp) const override;
     137                 :             : 
     138                 :             :   const allocation_state *get_nonnull () const;
     139                 :             : 
     140                 :             :   enum resource_state m_rs;
     141                 :             :   const deallocator_set *m_deallocators;
     142                 :             :   const deallocator *m_deallocator;
     143                 :             : };
     144                 :             : 
     145                 :             : /* Custom state subclass, for the "assumed-non-null" state
     146                 :             :    where the assumption happens in a particular frame.  */
     147                 :             : 
     148                 :             : struct assumed_non_null_state : public allocation_state
     149                 :             : {
     150                 :        2739 :   assumed_non_null_state (const char *name, unsigned id,
     151                 :             :                           const frame_region *frame)
     152                 :        2739 :   : allocation_state (name, id, RS_ASSUMED_NON_NULL,
     153                 :             :                       NULL, NULL),
     154                 :        2739 :     m_frame (frame)
     155                 :             :   {
     156                 :        2739 :     gcc_assert (m_frame);
     157                 :        2739 :   }
     158                 :             : 
     159                 :             :   void dump_to_pp (pretty_printer *pp) const final override;
     160                 :             : 
     161                 :             :   const frame_region *m_frame;
     162                 :             : };
     163                 :             : 
     164                 :             : /* An enum for choosing which wording to use in various diagnostics
     165                 :             :    when describing deallocations.  */
     166                 :             : 
     167                 :             : enum wording
     168                 :             : {
     169                 :             :   WORDING_FREED,
     170                 :             :   WORDING_DELETED,
     171                 :             :   WORDING_DEALLOCATED,
     172                 :             :   WORDING_REALLOCATED
     173                 :             : };
     174                 :             : 
     175                 :             : /* Base class representing a deallocation function,
     176                 :             :    either a built-in one we know about, or one exposed via
     177                 :             :    __attribute__((malloc(DEALLOCATOR))).  */
     178                 :             : 
     179                 :             : struct deallocator
     180                 :             : {
     181                 :             :   hashval_t hash () const;
     182                 :             :   void dump_to_pp (pretty_printer *pp) const;
     183                 :             :   static int cmp (const deallocator *a, const deallocator *b);
     184                 :             :   static int cmp_ptr_ptr (const void *, const void *);
     185                 :             : 
     186                 :             :   /* Name to use in diagnostics.  */
     187                 :             :   const char *m_name;
     188                 :             : 
     189                 :             :   /* Which wording to use in diagnostics.  */
     190                 :             :   enum wording m_wording;
     191                 :             : 
     192                 :             :   /* State for a value passed to one of the deallocators.  */
     193                 :             :   state_machine::state_t m_freed;
     194                 :             : 
     195                 :             : protected:
     196                 :             :   deallocator (malloc_state_machine *sm,
     197                 :             :                const char *name,
     198                 :             :                enum wording wording);
     199                 :             : };
     200                 :             : 
     201                 :             : /* Subclass representing a predefined deallocator.
     202                 :             :    e.g. "delete []", without needing a specific FUNCTION_DECL
     203                 :             :    ahead of time.  */
     204                 :             : 
     205                 :             : struct standard_deallocator : public deallocator
     206                 :             : {
     207                 :             :   standard_deallocator (malloc_state_machine *sm,
     208                 :             :                         const char *name,
     209                 :             :                         enum wording wording);
     210                 :             : };
     211                 :             : 
     212                 :             : /* Subclass representing a user-defined deallocator
     213                 :             :    via __attribute__((malloc(DEALLOCATOR))) given
     214                 :             :    a specific FUNCTION_DECL.  */
     215                 :             : 
     216                 :             : struct custom_deallocator : public deallocator
     217                 :             : {
     218                 :          70 :   custom_deallocator (malloc_state_machine *sm,
     219                 :             :                       tree deallocator_fndecl,
     220                 :             :                       enum wording wording)
     221                 :          70 :   : deallocator (sm, IDENTIFIER_POINTER (DECL_NAME (deallocator_fndecl)),
     222                 :         140 :                  wording)
     223                 :             :   {
     224                 :          70 :   }
     225                 :             : };
     226                 :             : 
     227                 :             : /* Base class representing a set of possible deallocators.
     228                 :             :    Often this will be just a single deallocator, but some
     229                 :             :    allocators have multiple valid deallocators (e.g. the result of
     230                 :             :    "fopen" can be closed by either "fclose" or "freopen").  */
     231                 :             : 
     232                 :             : struct deallocator_set
     233                 :             : {
     234                 :             :   deallocator_set (malloc_state_machine *sm,
     235                 :             :                    enum wording wording);
     236                 :        3204 :   virtual ~deallocator_set () {}
     237                 :             : 
     238                 :             :   virtual bool contains_p (const deallocator *d) const = 0;
     239                 :             :   virtual const deallocator *maybe_get_single () const = 0;
     240                 :             :   virtual void dump_to_pp (pretty_printer *pp) const = 0;
     241                 :             :   void dump () const;
     242                 :             : 
     243                 :             :   /* Which wording to use in diagnostics.  */
     244                 :             :   enum wording m_wording;
     245                 :             : 
     246                 :             :   /* Pointers to states.
     247                 :             :      These states are owned by the state_machine base class.  */
     248                 :             : 
     249                 :             :   /* State for an unchecked result from an allocator using this set.  */
     250                 :             :   state_machine::state_t m_unchecked;
     251                 :             : 
     252                 :             :   /* State for a known non-NULL result from such an allocator.  */
     253                 :             :   state_machine::state_t m_nonnull;
     254                 :             : };
     255                 :             : 
     256                 :             : /* Subclass of deallocator_set representing a set of deallocators
     257                 :             :    defined by one or more __attribute__((malloc(DEALLOCATOR))).  */
     258                 :             : 
     259                 :             : struct custom_deallocator_set : public deallocator_set
     260                 :             : {
     261                 :             :   typedef const auto_vec <const deallocator *> *key_t;
     262                 :             : 
     263                 :             :   custom_deallocator_set (malloc_state_machine *sm,
     264                 :             :                           const auto_vec <const deallocator *> *vec,
     265                 :             :                           //const char *name,
     266                 :             :                           //const char *dealloc_funcname,
     267                 :             :                           //unsigned arg_idx,
     268                 :             :                           enum wording wording);
     269                 :             : 
     270                 :             :   bool contains_p (const deallocator *d) const final override;
     271                 :             :   const deallocator *maybe_get_single () const final override;
     272                 :             :   void dump_to_pp (pretty_printer *pp) const final override;
     273                 :             : 
     274                 :             :   auto_vec <const deallocator *> m_deallocator_vec;
     275                 :             : };
     276                 :             : 
     277                 :             : /* Subclass of deallocator_set representing a set of deallocators
     278                 :             :    with a single standard_deallocator, e.g. "delete []".  */
     279                 :             : 
     280                 :        3204 : struct standard_deallocator_set : public deallocator_set
     281                 :             : {
     282                 :             :   standard_deallocator_set (malloc_state_machine *sm,
     283                 :             :                             const char *name,
     284                 :             :                             enum wording wording);
     285                 :             : 
     286                 :             :   bool contains_p (const deallocator *d) const final override;
     287                 :             :   const deallocator *maybe_get_single () const final override;
     288                 :             :   void dump_to_pp (pretty_printer *pp) const final override;
     289                 :             : 
     290                 :             :   standard_deallocator m_deallocator;
     291                 :             : };
     292                 :             : 
     293                 :             : /* Traits class for ensuring uniqueness of deallocator_sets within
     294                 :             :    malloc_state_machine.  */
     295                 :             : 
     296                 :             : struct deallocator_set_map_traits
     297                 :             : {
     298                 :             :   typedef custom_deallocator_set::key_t key_type;
     299                 :             :   typedef custom_deallocator_set *value_type;
     300                 :             :   typedef custom_deallocator_set *compare_type;
     301                 :             : 
     302                 :         199 :   static inline hashval_t hash (const key_type &k)
     303                 :             :   {
     304                 :         199 :     gcc_assert (k != NULL);
     305                 :         199 :     gcc_assert (k != reinterpret_cast<key_type> (1));
     306                 :             : 
     307                 :             :     hashval_t result = 0;
     308                 :             :     unsigned i;
     309                 :             :     const deallocator *d;
     310                 :         466 :     FOR_EACH_VEC_ELT (*k, i, d)
     311                 :         267 :       result ^= d->hash ();
     312                 :         199 :     return result;
     313                 :             :   }
     314                 :          44 :   static inline bool equal_keys (const key_type &k1, const key_type &k2)
     315                 :             :   {
     316                 :         132 :     if (k1->length () != k2->length ())
     317                 :             :       return false;
     318                 :             : 
     319                 :          65 :     for (unsigned i = 0; i < k1->length (); i++)
     320                 :          52 :       if ((*k1)[i] != (*k2)[i])
     321                 :             :         return false;
     322                 :             : 
     323                 :             :     return true;
     324                 :             :   }
     325                 :             :   template <typename T>
     326                 :             :   static inline void remove (T &)
     327                 :             :   {
     328                 :             :     /* empty; the nodes are handled elsewhere.  */
     329                 :             :   }
     330                 :             :   template <typename T>
     331                 :             :   static inline void mark_deleted (T &entry)
     332                 :             :   {
     333                 :             :     entry.m_key = reinterpret_cast<key_type> (1);
     334                 :             :   }
     335                 :             :   template <typename T>
     336                 :       41717 :   static inline void mark_empty (T &entry)
     337                 :             :   {
     338                 :       41717 :     entry.m_key = NULL;
     339                 :             :   }
     340                 :             :   template <typename T>
     341                 :         128 :   static inline bool is_deleted (const T &entry)
     342                 :             :   {
     343                 :         128 :     return entry.m_key == reinterpret_cast<key_type> (1);
     344                 :             :   }
     345                 :             :   template <typename T>
     346                 :       43782 :   static inline bool is_empty (const T &entry)
     347                 :             :   {
     348                 :       43782 :     return entry.m_key == NULL;
     349                 :             :   }
     350                 :             :   static const bool empty_zero_p = false;
     351                 :             : };
     352                 :             : 
     353                 :             : /* A state machine for detecting misuses of the malloc/free API.
     354                 :             : 
     355                 :             :    See sm-malloc.dot for an overview (keep this in-sync with that file).  */
     356                 :             : 
     357                 :             : class malloc_state_machine : public state_machine
     358                 :             : {
     359                 :             : public:
     360                 :             :   typedef allocation_state custom_data_t;
     361                 :             : 
     362                 :             :   malloc_state_machine (logger *logger);
     363                 :             :   ~malloc_state_machine ();
     364                 :             : 
     365                 :             :   state_t
     366                 :             :   add_state (const char *name, enum resource_state rs,
     367                 :             :              const deallocator_set *deallocators,
     368                 :             :              const deallocator *deallocator);
     369                 :             : 
     370                 :     1515031 :   bool inherited_state_p () const final override { return false; }
     371                 :             : 
     372                 :             :   state_machine::state_t
     373                 :     1381615 :   get_default_state (const svalue *sval) const final override
     374                 :             :   {
     375                 :     1381615 :     if (tree cst = sval->maybe_get_constant ())
     376                 :             :       {
     377                 :      165465 :         if (zerop (cst))
     378                 :       80562 :           return m_null;
     379                 :             :       }
     380                 :     1301053 :     if (const region_svalue *ptr = sval->dyn_cast_region_svalue ())
     381                 :             :       {
     382                 :      200575 :         const region *reg = ptr->get_pointee ();
     383                 :      200575 :         switch (reg->get_memory_space ())
     384                 :             :           {
     385                 :             :           default:
     386                 :             :             break;
     387                 :       27209 :           case MEMSPACE_CODE:
     388                 :       27209 :           case MEMSPACE_GLOBALS:
     389                 :       27209 :           case MEMSPACE_STACK:
     390                 :       27209 :           case MEMSPACE_READONLY_DATA:
     391                 :       27209 :             return m_non_heap;
     392                 :             :           }
     393                 :             :       }
     394                 :     1273844 :     return m_start;
     395                 :             :   }
     396                 :             : 
     397                 :             :   bool on_stmt (sm_context &sm_ctxt,
     398                 :             :                 const supernode *node,
     399                 :             :                 const gimple *stmt) const final override;
     400                 :             : 
     401                 :             :   void on_phi (sm_context &sm_ctxt,
     402                 :             :                const supernode *node,
     403                 :             :                const gphi *phi,
     404                 :             :                tree rhs) const final override;
     405                 :             : 
     406                 :             :   void on_condition (sm_context &sm_ctxt,
     407                 :             :                      const supernode *node,
     408                 :             :                      const gimple *stmt,
     409                 :             :                      const svalue *lhs,
     410                 :             :                      enum tree_code op,
     411                 :             :                      const svalue *rhs) const final override;
     412                 :             : 
     413                 :             :   void on_pop_frame (sm_state_map *smap,
     414                 :             :                      const frame_region *) const final override;
     415                 :             : 
     416                 :             :   bool can_purge_p (state_t s) const final override;
     417                 :             :   std::unique_ptr<pending_diagnostic> on_leak (tree var) const final override;
     418                 :             : 
     419                 :             :   bool reset_when_passed_to_unknown_fn_p (state_t s,
     420                 :             :                                           bool is_mutable) const final override;
     421                 :             : 
     422                 :             :   state_t
     423                 :             :   maybe_get_merged_states_nonequal (state_t state_a,
     424                 :             :                                     state_t state_b) const final override;
     425                 :             : 
     426                 :             :   static bool unaffected_by_call_p (tree fndecl);
     427                 :             : 
     428                 :             :   void maybe_assume_non_null (sm_context &sm_ctxt,
     429                 :             :                               tree ptr,
     430                 :             :                               const gimple *stmt) const;
     431                 :             : 
     432                 :             :   void on_realloc_with_move (region_model *model,
     433                 :             :                              sm_state_map *smap,
     434                 :             :                              const svalue *old_ptr_sval,
     435                 :             :                              const svalue *new_ptr_sval,
     436                 :             :                              const extrinsic_state &ext_state) const;
     437                 :             : 
     438                 :             :   void transition_ptr_sval_non_null (region_model *model,
     439                 :             :       sm_state_map *smap,
     440                 :             :       const svalue *new_ptr_sval,
     441                 :             :       const extrinsic_state &ext_state) const;
     442                 :             : 
     443                 :             :   standard_deallocator_set m_free;
     444                 :             :   standard_deallocator_set m_scalar_delete;
     445                 :             :   standard_deallocator_set m_vector_delete;
     446                 :             : 
     447                 :             :   standard_deallocator m_realloc;
     448                 :             : 
     449                 :             :   /* States that are independent of api.  */
     450                 :             : 
     451                 :             :   /* States for a pointer that's been unconditionally dereferenced
     452                 :             :      in a particular stack frame.  */
     453                 :             :   hash_map<const frame_region *, state_t> m_assumed_non_null;
     454                 :             : 
     455                 :             :   /* State for a pointer that's known to be NULL.  */
     456                 :             :   state_t m_null;
     457                 :             : 
     458                 :             :   /* State for a pointer that's known to not be on the heap (e.g. to a local
     459                 :             :      or global).  */
     460                 :             :   state_t m_non_heap; // TODO: or should this be a different state machine?
     461                 :             :   // or do we need child values etc?
     462                 :             : 
     463                 :             :   /* Stop state, for pointers we don't want to track any more.  */
     464                 :             :   state_t m_stop;
     465                 :             : 
     466                 :             : private:
     467                 :             :   const custom_deallocator_set *
     468                 :             :   get_or_create_custom_deallocator_set (tree allocator_fndecl);
     469                 :             :   custom_deallocator_set *
     470                 :             :   maybe_create_custom_deallocator_set (tree allocator_fndecl);
     471                 :             :   const deallocator *
     472                 :             :   get_or_create_deallocator (tree deallocator_fndecl);
     473                 :             : 
     474                 :             :   state_t
     475                 :             :   get_or_create_assumed_non_null_state_for_frame (const frame_region *frame);
     476                 :             : 
     477                 :             :   void
     478                 :             :   maybe_complain_about_deref_before_check (sm_context &sm_ctxt,
     479                 :             :                                            const supernode *node,
     480                 :             :                                            const gimple *stmt,
     481                 :             :                                            const assumed_non_null_state *,
     482                 :             :                                            tree ptr) const;
     483                 :             : 
     484                 :             :   void on_allocator_call (sm_context &sm_ctxt,
     485                 :             :                           const gcall *call,
     486                 :             :                           const deallocator_set *deallocators,
     487                 :             :                           bool returns_nonnull = false) const;
     488                 :             :   void handle_free_of_non_heap (sm_context &sm_ctxt,
     489                 :             :                                 const supernode *node,
     490                 :             :                                 const gcall *call,
     491                 :             :                                 tree arg,
     492                 :             :                                 const deallocator *d) const;
     493                 :             :   void on_deallocator_call (sm_context &sm_ctxt,
     494                 :             :                             const supernode *node,
     495                 :             :                             const gcall *call,
     496                 :             :                             const deallocator *d,
     497                 :             :                             unsigned argno) const;
     498                 :             :   void on_realloc_call (sm_context &sm_ctxt,
     499                 :             :                         const supernode *node,
     500                 :             :                         const gcall *call) const;
     501                 :             :   void on_zero_assignment (sm_context &sm_ctxt,
     502                 :             :                            const gimple *stmt,
     503                 :             :                            tree lhs) const;
     504                 :             : 
     505                 :             :   /* A map for consolidating deallocators so that they are
     506                 :             :      unique per deallocator FUNCTION_DECL.  */
     507                 :             :   typedef hash_map<tree, deallocator *> deallocator_map_t;
     508                 :             :   deallocator_map_t m_deallocator_map;
     509                 :             : 
     510                 :             :   /* Memoized lookups from FUNCTION_DECL to custom_deallocator_set *.  */
     511                 :             :   typedef hash_map<tree, custom_deallocator_set *> deallocator_set_cache_t;
     512                 :             :   deallocator_set_cache_t m_custom_deallocator_set_cache;
     513                 :             : 
     514                 :             :   /* A map for consolidating custom_deallocator_set instances.  */
     515                 :             :   typedef hash_map<custom_deallocator_set::key_t,
     516                 :             :                    custom_deallocator_set *,
     517                 :             :                    deallocator_set_map_traits> custom_deallocator_set_map_t;
     518                 :             :   custom_deallocator_set_map_t m_custom_deallocator_set_map;
     519                 :             : 
     520                 :             :   /* Record of dynamically-allocated objects,  for cleanup.  */
     521                 :             :   auto_vec <custom_deallocator_set *> m_dynamic_sets;
     522                 :             :   auto_vec <custom_deallocator *> m_dynamic_deallocators;
     523                 :             : };
     524                 :             : 
     525                 :             : /* struct deallocator.  */
     526                 :             : 
     527                 :       12906 : deallocator::deallocator (malloc_state_machine *sm,
     528                 :             :                           const char *name,
     529                 :       12906 :                           enum wording wording)
     530                 :       12906 : : m_name (name),
     531                 :       12906 :   m_wording (wording),
     532                 :       12906 :   m_freed (sm->add_state ("freed", RS_FREED, NULL, this))
     533                 :             : {
     534                 :       12906 : }
     535                 :             : 
     536                 :             : hashval_t
     537                 :         267 : deallocator::hash () const
     538                 :             : {
     539                 :         267 :   return (hashval_t)m_freed->get_id ();
     540                 :             : }
     541                 :             : 
     542                 :             : void
     543                 :           0 : deallocator::dump_to_pp (pretty_printer *pp) const
     544                 :             : {
     545                 :           0 :   pp_printf (pp, "%qs", m_name);
     546                 :           0 : }
     547                 :             : 
     548                 :             : int
     549                 :          80 : deallocator::cmp (const deallocator *a, const deallocator *b)
     550                 :             : {
     551                 :          80 :   return (int)a->m_freed->get_id () - (int)b->m_freed->get_id ();
     552                 :             : }
     553                 :             : 
     554                 :             : int
     555                 :          80 : deallocator::cmp_ptr_ptr (const void *a, const void *b)
     556                 :             : {
     557                 :          80 :   return cmp (*(const deallocator * const *)a,
     558                 :          80 :               *(const deallocator * const *)b);
     559                 :             : }
     560                 :             : 
     561                 :             : 
     562                 :             : /* struct standard_deallocator : public deallocator.  */
     563                 :             : 
     564                 :       12836 : standard_deallocator::standard_deallocator (malloc_state_machine *sm,
     565                 :             :                                             const char *name,
     566                 :       12836 :                                             enum wording wording)
     567                 :           0 : : deallocator (sm, name, wording)
     568                 :             : {
     569                 :           0 : }
     570                 :             : 
     571                 :             : /* struct deallocator_set.  */
     572                 :             : 
     573                 :        9698 : deallocator_set::deallocator_set (malloc_state_machine *sm,
     574                 :        9698 :                                   enum wording wording)
     575                 :        9698 : : m_wording (wording),
     576                 :       19396 :   m_unchecked (sm->add_state ("unchecked", RS_UNCHECKED, this, NULL)),
     577                 :        9698 :   m_nonnull (sm->add_state ("nonnull", RS_NONNULL, this, NULL))
     578                 :             : {
     579                 :        9698 : }
     580                 :             : 
     581                 :             : /* Dump a description of this deallocator_set to stderr.  */
     582                 :             : 
     583                 :             : DEBUG_FUNCTION void
     584                 :           0 : deallocator_set::dump () const
     585                 :             : {
     586                 :           0 :   tree_dump_pretty_printer pp (stderr);
     587                 :           0 :   dump_to_pp (&pp);
     588                 :           0 :   pp_newline (&pp);
     589                 :           0 : }
     590                 :             : 
     591                 :             : /* struct custom_deallocator_set : public deallocator_set.  */
     592                 :             : 
     593                 :          71 : custom_deallocator_set::
     594                 :             : custom_deallocator_set (malloc_state_machine *sm,
     595                 :             :                         const auto_vec <const deallocator *> *vec,
     596                 :          71 :                         enum wording wording)
     597                 :             : : deallocator_set (sm, wording),
     598                 :         142 :   m_deallocator_vec (vec->length ())
     599                 :             : {
     600                 :          71 :   unsigned i;
     601                 :          71 :   const deallocator *d;
     602                 :         221 :   FOR_EACH_VEC_ELT (*vec, i, d)
     603                 :          79 :     m_deallocator_vec.safe_push (d);
     604                 :          71 : }
     605                 :             : 
     606                 :             : bool
     607                 :         256 : custom_deallocator_set::contains_p (const deallocator *d) const
     608                 :             : {
     609                 :         256 :   unsigned i;
     610                 :         256 :   const deallocator *cd;
     611                 :         439 :   FOR_EACH_VEC_ELT (m_deallocator_vec, i, cd)
     612                 :         345 :     if (cd == d)
     613                 :             :       return true;
     614                 :             :   return false;
     615                 :             : }
     616                 :             : 
     617                 :             : const deallocator *
     618                 :         305 : custom_deallocator_set::maybe_get_single () const
     619                 :             : {
     620                 :         305 :   if (m_deallocator_vec.length () == 1)
     621                 :         125 :     return m_deallocator_vec[0];
     622                 :             :   return NULL;
     623                 :             : }
     624                 :             : 
     625                 :             : void
     626                 :           0 : custom_deallocator_set::dump_to_pp (pretty_printer *pp) const
     627                 :             : {
     628                 :           0 :   pp_character (pp, '{');
     629                 :           0 :   unsigned i;
     630                 :           0 :   const deallocator *d;
     631                 :           0 :   FOR_EACH_VEC_ELT (m_deallocator_vec, i, d)
     632                 :             :     {
     633                 :           0 :       if (i > 0)
     634                 :           0 :         pp_string (pp, ", ");
     635                 :           0 :       d->dump_to_pp (pp);
     636                 :             :     }
     637                 :           0 :   pp_character (pp, '}');
     638                 :           0 : }
     639                 :             : 
     640                 :             : /* struct standard_deallocator_set : public deallocator_set.  */
     641                 :             : 
     642                 :        9627 : standard_deallocator_set::standard_deallocator_set (malloc_state_machine *sm,
     643                 :             :                                                     const char *name,
     644                 :        9627 :                                                     enum wording wording)
     645                 :             : : deallocator_set (sm, wording),
     646                 :        9627 :   m_deallocator (sm, name, wording)
     647                 :             : {
     648                 :        9627 : }
     649                 :             : 
     650                 :             : bool
     651                 :        5783 : standard_deallocator_set::contains_p (const deallocator *d) const
     652                 :             : {
     653                 :        5783 :   return d == &m_deallocator;
     654                 :             : }
     655                 :             : 
     656                 :             : const deallocator *
     657                 :         111 : standard_deallocator_set::maybe_get_single () const
     658                 :             : {
     659                 :         111 :   return &m_deallocator;
     660                 :             : }
     661                 :             : 
     662                 :             : void
     663                 :         420 : standard_deallocator_set::dump_to_pp (pretty_printer *pp) const
     664                 :             : {
     665                 :         420 :   pp_character (pp, '{');
     666                 :         420 :   pp_string (pp, m_deallocator.m_name);
     667                 :         420 :   pp_character (pp, '}');
     668                 :         420 : }
     669                 :             : 
     670                 :             : /* Return STATE cast to the custom state subclass, or NULL for the start state.
     671                 :             :    Everything should be an allocation_state apart from the start state.  */
     672                 :             : 
     673                 :             : static const allocation_state *
     674                 :     1395385 : dyn_cast_allocation_state (state_machine::state_t state)
     675                 :             : {
     676                 :           0 :   if (state->get_id () == 0)
     677                 :           0 :     return NULL;
     678                 :             :   return static_cast <const allocation_state *> (state);
     679                 :             : }
     680                 :             : 
     681                 :             : /* Return STATE cast to the custom state subclass, for a state that is
     682                 :             :    already known to not be the start state .  */
     683                 :             : 
     684                 :             : static const allocation_state *
     685                 :       10626 : as_a_allocation_state (state_machine::state_t state)
     686                 :             : {
     687                 :       10626 :   gcc_assert (state->get_id () != 0);
     688                 :       10626 :   return static_cast <const allocation_state *> (state);
     689                 :             : }
     690                 :             : 
     691                 :             : /* Get the resource_state for STATE.  */
     692                 :             : 
     693                 :             : static enum resource_state
     694                 :     1395385 : get_rs (state_machine::state_t state)
     695                 :             : {
     696                 :           0 :   if (const allocation_state *astate = dyn_cast_allocation_state (state))
     697                 :      193060 :     return astate->m_rs;
     698                 :             :   else
     699                 :             :     return RS_START;
     700                 :             : }
     701                 :             : 
     702                 :             : /* Return true if STATE is the start state.  */
     703                 :             : 
     704                 :             : static bool
     705                 :         375 : start_p (state_machine::state_t state)
     706                 :             : {
     707                 :           0 :   return get_rs (state) == RS_START;
     708                 :             : }
     709                 :             : 
     710                 :             : /* Return true if STATE is an unchecked result from an allocator.  */
     711                 :             : 
     712                 :             : static bool
     713                 :       42828 : unchecked_p (state_machine::state_t state)
     714                 :             : {
     715                 :           0 :   return get_rs (state) == RS_UNCHECKED;
     716                 :             : }
     717                 :             : 
     718                 :             : /* Return true if STATE is a non-null result from an allocator.  */
     719                 :             : 
     720                 :             : static bool
     721                 :        7006 : nonnull_p (state_machine::state_t state)
     722                 :             : {
     723                 :           0 :   return get_rs (state) == RS_NONNULL;
     724                 :             : }
     725                 :             : 
     726                 :             : /* Return true if STATE is a value that has been passed to a deallocator.  */
     727                 :             : 
     728                 :             : static bool
     729                 :       13033 : freed_p (state_machine::state_t state)
     730                 :             : {
     731                 :           0 :   return get_rs (state) == RS_FREED;
     732                 :             : }
     733                 :             : 
     734                 :             : /* Return true if STATE is a value that has been assumed to be non-NULL.  */
     735                 :             : 
     736                 :             : static bool
     737                 :      260623 : assumed_non_null_p (state_machine::state_t state)
     738                 :             : {
     739                 :       61564 :   return get_rs (state) == RS_ASSUMED_NON_NULL;
     740                 :             : }
     741                 :             : 
     742                 :             : /* Class for diagnostics relating to malloc_state_machine.  */
     743                 :             : 
     744                 :           0 : class malloc_diagnostic : public pending_diagnostic
     745                 :             : {
     746                 :             : public:
     747                 :        7414 :   malloc_diagnostic (const malloc_state_machine &sm, tree arg)
     748                 :        7414 :   : m_sm (sm), m_arg (arg)
     749                 :             :   {}
     750                 :             : 
     751                 :        2214 :   bool subclass_equal_p (const pending_diagnostic &base_other) const override
     752                 :             :   {
     753                 :        2214 :     return same_tree_p (m_arg, ((const malloc_diagnostic &)base_other).m_arg);
     754                 :             :   }
     755                 :             : 
     756                 :             :   bool
     757                 :        1098 :   describe_state_change (pretty_printer &pp,
     758                 :             :                          const evdesc::state_change &change) override
     759                 :             :   {
     760                 :        1098 :     if (change.m_old_state == m_sm.get_start_state ()
     761                 :        1098 :         && (unchecked_p (change.m_new_state) || nonnull_p (change.m_new_state)))
     762                 :             :       // TODO: verify that it's the allocation stmt, not a copy
     763                 :             :       {
     764                 :         422 :         pp_string (&pp, "allocated here");
     765                 :         422 :         return true;
     766                 :             :       }
     767                 :         676 :     if (unchecked_p (change.m_old_state)
     768                 :         366 :         && nonnull_p (change.m_new_state))
     769                 :             :       {
     770                 :         342 :         if (change.m_expr)
     771                 :         316 :           pp_printf (&pp, "assuming %qE is non-NULL",
     772                 :             :                      change.m_expr);
     773                 :             :         else
     774                 :          26 :           pp_printf (&pp, "assuming %qs is non-NULL",
     775                 :             :                      "<unknown>");
     776                 :         342 :         return true;
     777                 :             :       }
     778                 :         334 :     if (change.m_new_state == m_sm.m_null)
     779                 :             :       {
     780                 :         332 :         if (unchecked_p (change.m_old_state))
     781                 :             :           {
     782                 :          24 :             if (change.m_expr)
     783                 :          24 :               pp_printf (&pp, "assuming %qE is NULL",
     784                 :             :                          change.m_expr);
     785                 :             :             else
     786                 :           0 :               pp_printf (&pp, "assuming %qs is NULL",
     787                 :             :                          "<unknown>");
     788                 :          24 :             return true;
     789                 :             :           }
     790                 :             :         else
     791                 :             :           {
     792                 :         308 :             if (change.m_expr)
     793                 :         308 :               pp_printf (&pp, "%qE is NULL",
     794                 :             :                          change.m_expr);
     795                 :             :             else
     796                 :           0 :               pp_printf (&pp, "%qs is NULL",
     797                 :             :                          "<unknown>");
     798                 :         308 :             return true;
     799                 :             :           }
     800                 :             :       }
     801                 :             : 
     802                 :             :     return false;
     803                 :             :   }
     804                 :             : 
     805                 :             :   diagnostic_event::meaning
     806                 :         195 :   get_meaning_for_state_change (const evdesc::state_change &change)
     807                 :             :     const final override
     808                 :             :   {
     809                 :         195 :     if (change.m_old_state == m_sm.get_start_state ()
     810                 :         195 :         && unchecked_p (change.m_new_state))
     811                 :          57 :       return diagnostic_event::meaning (diagnostic_event::VERB_acquire,
     812                 :          57 :                                         diagnostic_event::NOUN_memory);
     813                 :         138 :     if (freed_p (change.m_new_state))
     814                 :         122 :       return diagnostic_event::meaning (diagnostic_event::VERB_release,
     815                 :         122 :                                         diagnostic_event::NOUN_memory);
     816                 :          16 :     return diagnostic_event::meaning ();
     817                 :             :   }
     818                 :             : 
     819                 :             : protected:
     820                 :             :   const malloc_state_machine &m_sm;
     821                 :             :   tree m_arg;
     822                 :             : };
     823                 :             : 
     824                 :             : /* Concrete subclass for reporting mismatching allocator/deallocator
     825                 :             :    diagnostics.  */
     826                 :             : 
     827                 :           0 : class mismatching_deallocation : public malloc_diagnostic
     828                 :             : {
     829                 :             : public:
     830                 :         136 :   mismatching_deallocation (const malloc_state_machine &sm, tree arg,
     831                 :             :                             const deallocator_set *expected_deallocators,
     832                 :             :                             const deallocator *actual_dealloc)
     833                 :         136 :   : malloc_diagnostic (sm, arg),
     834                 :         136 :     m_expected_deallocators (expected_deallocators),
     835                 :         136 :     m_actual_dealloc (actual_dealloc)
     836                 :             :   {}
     837                 :             : 
     838                 :         496 :   const char *get_kind () const final override
     839                 :             :   {
     840                 :         496 :     return "mismatching_deallocation";
     841                 :             :   }
     842                 :             : 
     843                 :         224 :   int get_controlling_option () const final override
     844                 :             :   {
     845                 :         224 :     return OPT_Wanalyzer_mismatching_deallocation;
     846                 :             :   }
     847                 :             : 
     848                 :          88 :   bool emit (diagnostic_emission_context &ctxt) final override
     849                 :             :   {
     850                 :          88 :     auto_diagnostic_group d;
     851                 :          88 :     ctxt.add_cwe (762); /* CWE-762: Mismatched Memory Management Routines.  */
     852                 :         176 :     if (const deallocator *expected_dealloc
     853                 :          88 :           = m_expected_deallocators->maybe_get_single ())
     854                 :          52 :       return ctxt.warn ("%qE should have been deallocated with %qs"
     855                 :             :                         " but was deallocated with %qs",
     856                 :          52 :                         m_arg, expected_dealloc->m_name,
     857                 :          52 :                         m_actual_dealloc->m_name);
     858                 :             :     else
     859                 :          36 :       return ctxt.warn ("%qs called on %qE returned from a mismatched"
     860                 :             :                         " allocation function",
     861                 :          36 :                         m_actual_dealloc->m_name, m_arg);
     862                 :          88 :   }
     863                 :             : 
     864                 :             :   bool
     865                 :         206 :   describe_state_change (pretty_printer &pp,
     866                 :             :                          const evdesc::state_change &change) final override
     867                 :             :   {
     868                 :         206 :     if (unchecked_p (change.m_new_state))
     869                 :             :       {
     870                 :         176 :         m_alloc_event = change.m_event_id;
     871                 :         352 :         if (const deallocator *expected_dealloc
     872                 :         176 :             = m_expected_deallocators->maybe_get_single ())
     873                 :         104 :           pp_printf (&pp,
     874                 :             :                      "allocated here (expects deallocation with %qs)",
     875                 :         104 :                      expected_dealloc->m_name);
     876                 :             :         else
     877                 :          72 :           pp_string (&pp, "allocated here");
     878                 :         176 :         return true;
     879                 :             :       }
     880                 :          30 :     return malloc_diagnostic::describe_state_change (pp, change);
     881                 :             :   }
     882                 :             : 
     883                 :             :   bool
     884                 :         176 :   describe_final_event (pretty_printer &pp,
     885                 :             :                         const evdesc::final_event &) final override
     886                 :             :   {
     887                 :         176 :     if (m_alloc_event.known_p ())
     888                 :             :       {
     889                 :         304 :         if (const deallocator *expected_dealloc
     890                 :         152 :             = m_expected_deallocators->maybe_get_single ())
     891                 :          80 :           pp_printf (&pp,
     892                 :             :                      "deallocated with %qs here;"
     893                 :             :                      " allocation at %@ expects deallocation with %qs",
     894                 :          80 :                      m_actual_dealloc->m_name, &m_alloc_event,
     895                 :          80 :                      expected_dealloc->m_name);
     896                 :             :         else
     897                 :          72 :           pp_printf (&pp,
     898                 :             :                      "deallocated with %qs here;"
     899                 :             :                      " allocated at %@",
     900                 :          72 :                      m_actual_dealloc->m_name, &m_alloc_event);
     901                 :         152 :         return true;
     902                 :             :       }
     903                 :          24 :     pp_printf (&pp, "deallocated with %qs here",
     904                 :          24 :                m_actual_dealloc->m_name);
     905                 :          24 :     return true;
     906                 :             :   }
     907                 :             : 
     908                 :             : private:
     909                 :             :   diagnostic_event_id_t m_alloc_event;
     910                 :             :   const deallocator_set *m_expected_deallocators;
     911                 :             :   const deallocator *m_actual_dealloc;
     912                 :             : };
     913                 :             : 
     914                 :             : /* Concrete subclass for reporting double-free diagnostics.  */
     915                 :             : 
     916                 :           0 : class double_free : public malloc_diagnostic
     917                 :             : {
     918                 :             : public:
     919                 :        4476 :   double_free (const malloc_state_machine &sm, tree arg, const char *funcname)
     920                 :        4476 :   : malloc_diagnostic (sm, arg), m_funcname (funcname)
     921                 :             :   {}
     922                 :             : 
     923                 :        1857 :   const char *get_kind () const final override { return "double_free"; }
     924                 :             : 
     925                 :        4863 :   int get_controlling_option () const final override
     926                 :             :   {
     927                 :        4863 :     return OPT_Wanalyzer_double_free;
     928                 :             :   }
     929                 :             : 
     930                 :         387 :   bool emit (diagnostic_emission_context &ctxt) final override
     931                 :             :   {
     932                 :         387 :     auto_diagnostic_group d;
     933                 :         387 :     ctxt.add_cwe (415); /* CWE-415: Double Free.  */
     934                 :         387 :     return ctxt.warn ("double-%qs of %qE", m_funcname, m_arg);
     935                 :         387 :   }
     936                 :             : 
     937                 :             :   bool
     938                 :        1044 :   describe_state_change (pretty_printer &pp,
     939                 :             :                          const evdesc::state_change &change) final override
     940                 :             :   {
     941                 :        1044 :     if (freed_p (change.m_new_state))
     942                 :             :       {
     943                 :         778 :         m_first_free_event = change.m_event_id;
     944                 :         778 :         pp_printf (&pp, "first %qs here", m_funcname);
     945                 :         778 :         return true;
     946                 :             :       }
     947                 :         266 :     return malloc_diagnostic::describe_state_change (pp, change);
     948                 :             :   }
     949                 :             : 
     950                 :             :   bool
     951                 :         300 :   describe_call_with_state (pretty_printer &pp,
     952                 :             :                             const evdesc::call_with_state &info) final override
     953                 :             :   {
     954                 :         300 :     if (freed_p (info.m_state))
     955                 :             :       {
     956                 :         148 :         pp_printf (&pp,
     957                 :             :                    "passing freed pointer %qE in call to %qE from %qE",
     958                 :         148 :                    info.m_expr, info.m_callee_fndecl, info.m_caller_fndecl);
     959                 :         148 :         return true;
     960                 :             :       }
     961                 :             :     return false;
     962                 :             :   }
     963                 :             : 
     964                 :             :   bool
     965                 :         770 :   describe_final_event (pretty_printer &pp,
     966                 :             :                         const evdesc::final_event &) final override
     967                 :             :   {
     968                 :         770 :     if (m_first_free_event.known_p ())
     969                 :         770 :       pp_printf (&pp,
     970                 :             :                  "second %qs here; first %qs was at %@",
     971                 :             :                  m_funcname, m_funcname,
     972                 :             :                  &m_first_free_event);
     973                 :             :     else
     974                 :           0 :       pp_printf (&pp, "second %qs here", m_funcname);
     975                 :         770 :     return true;
     976                 :             :   }
     977                 :             : 
     978                 :             : private:
     979                 :             :   diagnostic_event_id_t m_first_free_event;
     980                 :             :   const char *m_funcname;
     981                 :             : };
     982                 :             : 
     983                 :             : /* Abstract subclass for describing possible bad uses of NULL.
     984                 :             :    Responsible for describing the call that could return NULL.  */
     985                 :             : 
     986                 :           0 : class possible_null : public malloc_diagnostic
     987                 :             : {
     988                 :             : public:
     989                 :        1087 :   possible_null (const malloc_state_machine &sm, tree arg)
     990                 :        1087 :   : malloc_diagnostic (sm, arg)
     991                 :             :   {}
     992                 :             : 
     993                 :             :   bool
     994                 :         376 :   describe_state_change (pretty_printer &pp,
     995                 :             :                          const evdesc::state_change &change) final override
     996                 :             :   {
     997                 :         376 :     if (change.m_old_state == m_sm.get_start_state ()
     998                 :         376 :         && unchecked_p (change.m_new_state))
     999                 :             :       {
    1000                 :         376 :         m_origin_of_unchecked_event = change.m_event_id;
    1001                 :         376 :         pp_string (&pp, "this call could return NULL");
    1002                 :         376 :         return true;
    1003                 :             :       }
    1004                 :           0 :     return malloc_diagnostic::describe_state_change (pp, change);
    1005                 :             :   }
    1006                 :             : 
    1007                 :             :   bool
    1008                 :          26 :   describe_return_of_state (pretty_printer &pp,
    1009                 :             :                             const evdesc::return_of_state &info) final override
    1010                 :             :   {
    1011                 :          26 :     if (unchecked_p (info.m_state))
    1012                 :             :       {
    1013                 :          26 :         pp_printf (&pp,
    1014                 :             :                    "possible return of NULL to %qE from %qE",
    1015                 :          26 :                    info.m_caller_fndecl, info.m_callee_fndecl);
    1016                 :          26 :         return true;
    1017                 :             :       }
    1018                 :             :     return false;
    1019                 :             :   }
    1020                 :             : 
    1021                 :             : protected:
    1022                 :             :   diagnostic_event_id_t m_origin_of_unchecked_event;
    1023                 :             : };
    1024                 :             : 
    1025                 :             : /* Concrete subclass for describing dereference of a possible NULL
    1026                 :             :    value.  */
    1027                 :             : 
    1028                 :           0 : class possible_null_deref : public possible_null
    1029                 :             : {
    1030                 :             : public:
    1031                 :        1014 :   possible_null_deref (const malloc_state_machine &sm, tree arg)
    1032                 :        1014 :   : possible_null (sm, arg)
    1033                 :             :   {}
    1034                 :             : 
    1035                 :        1134 :   const char *get_kind () const final override { return "possible_null_deref"; }
    1036                 :             : 
    1037                 :         430 :   int get_controlling_option () const final override
    1038                 :             :   {
    1039                 :         430 :     return OPT_Wanalyzer_possible_null_dereference;
    1040                 :             :   }
    1041                 :             : 
    1042                 :         142 :   bool emit (diagnostic_emission_context &ctxt) final override
    1043                 :             :   {
    1044                 :             :     /* CWE-690: Unchecked Return Value to NULL Pointer Dereference.  */
    1045                 :         142 :     ctxt.add_cwe (690);
    1046                 :         142 :     return ctxt.warn ("dereference of possibly-NULL %qE", m_arg);
    1047                 :             :   }
    1048                 :             : 
    1049                 :             :   bool
    1050                 :         284 :   describe_final_event (pretty_printer &pp,
    1051                 :             :                         const evdesc::final_event &ev) final override
    1052                 :             :   {
    1053                 :         284 :     if (m_origin_of_unchecked_event.known_p ())
    1054                 :         284 :       pp_printf (&pp,
    1055                 :             :                  "%qE could be NULL: unchecked value from %@",
    1056                 :         284 :                  ev.m_expr,
    1057                 :             :                  &m_origin_of_unchecked_event);
    1058                 :             :     else
    1059                 :           0 :       pp_printf (&pp,"%qE could be NULL", ev.m_expr);
    1060                 :         284 :     return true;
    1061                 :             :   }
    1062                 :             : 
    1063                 :             : };
    1064                 :             : 
    1065                 :             : /* Return true if FNDECL is a C++ method.  */
    1066                 :             : 
    1067                 :             : static bool
    1068                 :         666 : method_p (tree fndecl)
    1069                 :             : {
    1070                 :         666 :   return TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE;
    1071                 :             : }
    1072                 :             : 
    1073                 :             : /* Return a 1-based description of ARG_IDX (0-based) of FNDECL.
    1074                 :             :    Compare with %P in the C++ FE  (implemented in cp/error.cc: parm_to_string
    1075                 :             :    as called from cp_printer).  */
    1076                 :             : 
    1077                 :             : static label_text
    1078                 :         342 : describe_argument_index (tree fndecl, int arg_idx)
    1079                 :             : {
    1080                 :         342 :   if (method_p (fndecl))
    1081                 :          36 :     if (arg_idx == 0)
    1082                 :          18 :       return label_text::borrow ("'this'");
    1083                 :         324 :   pretty_printer pp;
    1084                 :         324 :   pp_printf (&pp, "%u", arg_idx + 1 - method_p (fndecl));
    1085                 :         324 :   return label_text::take (xstrdup (pp_formatted_text (&pp)));
    1086                 :         324 : }
    1087                 :             : 
    1088                 :             : /* Subroutine for use by possible_null_arg::emit and null_arg::emit.
    1089                 :             :    Issue a note informing that the pertinent argument must be non-NULL.  */
    1090                 :             : 
    1091                 :             : static void
    1092                 :         114 : inform_nonnull_attribute (tree fndecl, int arg_idx)
    1093                 :             : {
    1094                 :         114 :   label_text arg_desc = describe_argument_index (fndecl, arg_idx);
    1095                 :         114 :   inform (DECL_SOURCE_LOCATION (fndecl),
    1096                 :             :           "argument %s of %qD must be non-null",
    1097                 :             :           arg_desc.get (), fndecl);
    1098                 :             :   /* Ideally we would use the location of the parm and underline the
    1099                 :             :      attribute also - but we don't have the location_t values at this point
    1100                 :             :      in the middle-end.
    1101                 :             :      For reference, the C and C++ FEs have get_fndecl_argument_location.  */
    1102                 :         114 : }
    1103                 :             : 
    1104                 :             : /* Concrete subclass for describing passing a possibly-NULL value to a
    1105                 :             :    function marked with __attribute__((nonnull)).  */
    1106                 :             : 
    1107                 :           0 : class possible_null_arg : public possible_null
    1108                 :             : {
    1109                 :             : public:
    1110                 :          73 :   possible_null_arg (const malloc_state_machine &sm, tree arg,
    1111                 :             :                      tree fndecl, int arg_idx)
    1112                 :          73 :   : possible_null (sm, arg),
    1113                 :          73 :     m_fndecl (fndecl), m_arg_idx (arg_idx)
    1114                 :             :   {}
    1115                 :             : 
    1116                 :         261 :   const char *get_kind () const final override { return "possible_null_arg"; }
    1117                 :             : 
    1118                 :          73 :   bool subclass_equal_p (const pending_diagnostic &base_other)
    1119                 :             :     const final override
    1120                 :             :   {
    1121                 :          73 :     const possible_null_arg &sub_other
    1122                 :             :       = (const possible_null_arg &)base_other;
    1123                 :          73 :     return (same_tree_p (m_arg, sub_other.m_arg)
    1124                 :          73 :             && m_fndecl == sub_other.m_fndecl
    1125                 :         146 :             && m_arg_idx == sub_other.m_arg_idx);
    1126                 :             :   }
    1127                 :             : 
    1128                 :         115 :   int get_controlling_option () const final override
    1129                 :             :   {
    1130                 :         115 :     return OPT_Wanalyzer_possible_null_argument;
    1131                 :             :   }
    1132                 :             : 
    1133                 :          42 :   bool emit (diagnostic_emission_context &ctxt) final override
    1134                 :             :   {
    1135                 :             :     /* CWE-690: Unchecked Return Value to NULL Pointer Dereference.  */
    1136                 :          42 :     auto_diagnostic_group d;
    1137                 :          42 :     ctxt.add_cwe (690);
    1138                 :          42 :     bool warned
    1139                 :          42 :       = ctxt.warn ("use of possibly-NULL %qE where non-null expected",
    1140                 :             :                    m_arg);
    1141                 :          42 :     if (warned)
    1142                 :          42 :       inform_nonnull_attribute (m_fndecl, m_arg_idx);
    1143                 :          84 :     return warned;
    1144                 :          42 :   }
    1145                 :             : 
    1146                 :             :   bool
    1147                 :          84 :   describe_final_event (pretty_printer &pp,
    1148                 :             :                         const evdesc::final_event &ev) final override
    1149                 :             :   {
    1150                 :          84 :     label_text arg_desc = describe_argument_index (m_fndecl, m_arg_idx);
    1151                 :          84 :     if (m_origin_of_unchecked_event.known_p ())
    1152                 :          84 :       pp_printf (&pp,"argument %s (%qE) from %@ could be NULL"
    1153                 :             :                  " where non-null expected",
    1154                 :          84 :                  arg_desc.get (), ev.m_expr,
    1155                 :             :                  &m_origin_of_unchecked_event);
    1156                 :             :     else
    1157                 :           0 :       pp_printf (&pp,
    1158                 :             :                  "argument %s (%qE) could be NULL"
    1159                 :             :                  " where non-null expected",
    1160                 :           0 :                  arg_desc.get (), ev.m_expr);
    1161                 :          84 :     return true;
    1162                 :          84 :   }
    1163                 :             : 
    1164                 :             : private:
    1165                 :             :   tree m_fndecl;
    1166                 :             :   int m_arg_idx;
    1167                 :             : };
    1168                 :             : 
    1169                 :             : /* Concrete subclass for describing a dereference of a NULL value.  */
    1170                 :             : 
    1171                 :           0 : class null_deref : public malloc_diagnostic
    1172                 :             : {
    1173                 :             : public:
    1174                 :         301 :   null_deref (const malloc_state_machine &sm, tree arg)
    1175                 :         301 :   : malloc_diagnostic (sm, arg) {}
    1176                 :             : 
    1177                 :         565 :   const char *get_kind () const final override { return "null_deref"; }
    1178                 :             : 
    1179                 :         271 :   int get_controlling_option () const final override
    1180                 :             :   {
    1181                 :         271 :     return OPT_Wanalyzer_null_dereference;
    1182                 :             :   }
    1183                 :             : 
    1184                 :         153 :   bool terminate_path_p () const final override { return true; }
    1185                 :             : 
    1186                 :         118 :   bool emit (diagnostic_emission_context &ctxt) final override
    1187                 :             :   {
    1188                 :             :     /* CWE-476: NULL Pointer Dereference.  */
    1189                 :         118 :     ctxt.add_cwe (476);
    1190                 :         118 :     return ctxt.warn ("dereference of NULL %qE", m_arg);
    1191                 :             :   }
    1192                 :             : 
    1193                 :             :   bool
    1194                 :          22 :   describe_return_of_state (pretty_printer &pp,
    1195                 :             :                             const evdesc::return_of_state &info)
    1196                 :             :     final override
    1197                 :             :   {
    1198                 :          22 :     if (info.m_state == m_sm.m_null)
    1199                 :             :       {
    1200                 :          16 :         pp_printf (&pp, "return of NULL to %qE from %qE",
    1201                 :          16 :                    info.m_caller_fndecl, info.m_callee_fndecl);
    1202                 :          16 :         return true;
    1203                 :             :       }
    1204                 :             :     return false;
    1205                 :             :   }
    1206                 :             : 
    1207                 :             :   bool
    1208                 :         236 :   describe_final_event (pretty_printer &pp,
    1209                 :             :                         const evdesc::final_event &ev) final override
    1210                 :             :   {
    1211                 :         236 :     pp_printf (&pp, "dereference of NULL %qE", ev.m_expr);
    1212                 :         236 :     return true;
    1213                 :             :   }
    1214                 :             : 
    1215                 :             :   /* Implementation of pending_diagnostic::supercedes_p for
    1216                 :             :      null-deref.
    1217                 :             : 
    1218                 :             :      We want null-deref to supercede use-of-unitialized-value,
    1219                 :             :      so that if we have these at the same stmt, we don't emit
    1220                 :             :      a use-of-uninitialized, just the null-deref.  */
    1221                 :             : 
    1222                 :         135 :   bool supercedes_p (const pending_diagnostic &other) const final override
    1223                 :             :   {
    1224                 :         135 :     if (other.use_of_uninit_p ())
    1225                 :             :       return true;
    1226                 :             : 
    1227                 :             :     return false;
    1228                 :             :   }
    1229                 :             : };
    1230                 :             : 
    1231                 :             : /* Concrete subclass for describing passing a NULL value to a
    1232                 :             :    function marked with __attribute__((nonnull)).  */
    1233                 :             : 
    1234                 :           0 : class null_arg : public malloc_diagnostic
    1235                 :             : {
    1236                 :             : public:
    1237                 :          73 :   null_arg (const malloc_state_machine &sm, tree arg,
    1238                 :             :             tree fndecl, int arg_idx)
    1239                 :          73 :   : malloc_diagnostic (sm, arg),
    1240                 :          73 :     m_fndecl (fndecl), m_arg_idx (arg_idx)
    1241                 :             :   {}
    1242                 :             : 
    1243                 :         288 :   const char *get_kind () const final override { return "null_arg"; }
    1244                 :             : 
    1245                 :          72 :   bool subclass_equal_p (const pending_diagnostic &base_other)
    1246                 :             :     const final override
    1247                 :             :   {
    1248                 :          72 :     const null_arg &sub_other
    1249                 :             :       = (const null_arg &)base_other;
    1250                 :          72 :     return (same_tree_p (m_arg, sub_other.m_arg)
    1251                 :          72 :             && m_fndecl == sub_other.m_fndecl
    1252                 :         144 :             && m_arg_idx == sub_other.m_arg_idx);
    1253                 :             :   }
    1254                 :             : 
    1255                 :         145 :   int get_controlling_option () const final override
    1256                 :             :   {
    1257                 :         145 :     return OPT_Wanalyzer_null_argument;
    1258                 :             :   }
    1259                 :             : 
    1260                 :          73 :   bool terminate_path_p () const final override { return true; }
    1261                 :             : 
    1262                 :          72 :   bool emit (diagnostic_emission_context &ctxt) final override
    1263                 :             :   {
    1264                 :             :     /* CWE-476: NULL Pointer Dereference.  */
    1265                 :          72 :     auto_diagnostic_group d;
    1266                 :          72 :     ctxt.add_cwe (476);
    1267                 :             : 
    1268                 :          72 :     bool warned;
    1269                 :          72 :     if (zerop (m_arg))
    1270                 :          67 :       warned = ctxt.warn ("use of NULL where non-null expected");
    1271                 :             :     else
    1272                 :           5 :       warned = ctxt.warn ("use of NULL %qE where non-null expected",
    1273                 :             :                           m_arg);
    1274                 :          72 :     if (warned)
    1275                 :          72 :       inform_nonnull_attribute (m_fndecl, m_arg_idx);
    1276                 :         144 :     return warned;
    1277                 :          72 :   }
    1278                 :             : 
    1279                 :             :   bool
    1280                 :         144 :   describe_final_event (pretty_printer &pp,
    1281                 :             :                         const evdesc::final_event &ev) final override
    1282                 :             :   {
    1283                 :         144 :     label_text arg_desc = describe_argument_index (m_fndecl, m_arg_idx);
    1284                 :         144 :     if (zerop (ev.m_expr))
    1285                 :         112 :       pp_printf (&pp,
    1286                 :             :                  "argument %s NULL where non-null expected",
    1287                 :             :                  arg_desc.get ());
    1288                 :             :     else
    1289                 :          32 :       pp_printf (&pp,
    1290                 :             :                  "argument %s (%qE) NULL"
    1291                 :             :                  " where non-null expected",
    1292                 :          32 :                  arg_desc.get (), ev.m_expr);
    1293                 :         144 :     return true;
    1294                 :         144 :   }
    1295                 :             : 
    1296                 :             : private:
    1297                 :             :   tree m_fndecl;
    1298                 :             :   int m_arg_idx;
    1299                 :             : };
    1300                 :             : 
    1301                 :           0 : class use_after_free : public malloc_diagnostic
    1302                 :             : {
    1303                 :             : public:
    1304                 :         175 :   use_after_free (const malloc_state_machine &sm, tree arg,
    1305                 :             :                   const deallocator *deallocator)
    1306                 :         175 :   : malloc_diagnostic (sm, arg),
    1307                 :         175 :     m_deallocator (deallocator)
    1308                 :             :   {
    1309                 :         175 :     gcc_assert (deallocator);
    1310                 :         175 :   }
    1311                 :             : 
    1312                 :         368 :   const char *get_kind () const final override { return "use_after_free"; }
    1313                 :             : 
    1314                 :         174 :   int get_controlling_option () const final override
    1315                 :             :   {
    1316                 :         174 :     return OPT_Wanalyzer_use_after_free;
    1317                 :             :   }
    1318                 :             : 
    1319                 :          77 :   bool emit (diagnostic_emission_context &ctxt) final override
    1320                 :             :   {
    1321                 :             :     /* CWE-416: Use After Free.  */
    1322                 :          77 :     ctxt.add_cwe (416);
    1323                 :          77 :     return ctxt.warn ("use after %qs of %qE",
    1324                 :          77 :                       m_deallocator->m_name, m_arg);
    1325                 :             :   }
    1326                 :             : 
    1327                 :             :   bool
    1328                 :         340 :   describe_state_change (pretty_printer &pp,
    1329                 :             :                          const evdesc::state_change &change) final override
    1330                 :             :   {
    1331                 :         340 :     if (freed_p (change.m_new_state))
    1332                 :             :       {
    1333                 :         154 :         m_free_event = change.m_event_id;
    1334                 :         154 :         switch (m_deallocator->m_wording)
    1335                 :             :           {
    1336                 :           0 :           default:
    1337                 :           0 :           case WORDING_REALLOCATED:
    1338                 :           0 :             gcc_unreachable ();
    1339                 :         120 :           case WORDING_FREED:
    1340                 :         120 :             pp_string (&pp, "freed here");
    1341                 :         120 :             return true;
    1342                 :          32 :           case WORDING_DELETED:
    1343                 :          32 :             pp_string (&pp, "deleted here");
    1344                 :          32 :             return true;
    1345                 :           2 :           case WORDING_DEALLOCATED:
    1346                 :           2 :             pp_string (&pp, "deallocated here");
    1347                 :           2 :             return true;
    1348                 :             :           }
    1349                 :             :       }
    1350                 :         186 :     return malloc_diagnostic::describe_state_change (pp, change);
    1351                 :             :   }
    1352                 :             : 
    1353                 :             :   bool
    1354                 :         154 :   describe_final_event (pretty_printer &pp,
    1355                 :             :                         const evdesc::final_event &ev) final override
    1356                 :             :   {
    1357                 :         154 :     const char *funcname = m_deallocator->m_name;
    1358                 :         154 :     if (m_free_event.known_p ())
    1359                 :         154 :       switch (m_deallocator->m_wording)
    1360                 :             :         {
    1361                 :           0 :         default:
    1362                 :           0 :         case WORDING_REALLOCATED:
    1363                 :           0 :           gcc_unreachable ();
    1364                 :         120 :         case WORDING_FREED:
    1365                 :         120 :           pp_printf (&pp,
    1366                 :             :                      "use after %qs of %qE; freed at %@",
    1367                 :         120 :                      funcname, ev.m_expr, &m_free_event);
    1368                 :         120 :           return true;
    1369                 :          32 :         case WORDING_DELETED:
    1370                 :          32 :           pp_printf (&pp,
    1371                 :             :                      "use after %qs of %qE; deleted at %@",
    1372                 :          32 :                      funcname, ev.m_expr, &m_free_event);
    1373                 :          32 :           return true;
    1374                 :           2 :         case WORDING_DEALLOCATED:
    1375                 :           2 :           pp_printf (&pp,
    1376                 :             :                      "use after %qs of %qE;"
    1377                 :             :                      " deallocated at %@",
    1378                 :           2 :                      funcname, ev.m_expr, &m_free_event);
    1379                 :           2 :           return true;
    1380                 :             :         }
    1381                 :             :     else
    1382                 :             :       {
    1383                 :           0 :         pp_printf (&pp,
    1384                 :             :                    "use after %qs of %qE",
    1385                 :           0 :                    funcname, ev.m_expr);
    1386                 :           0 :         return true;
    1387                 :             :       }
    1388                 :             :   }
    1389                 :             : 
    1390                 :             :   /* Implementation of pending_diagnostic::supercedes_p for
    1391                 :             :      use_after_free.
    1392                 :             : 
    1393                 :             :      We want use-after-free to supercede use-of-unitialized-value,
    1394                 :             :      so that if we have these at the same stmt, we don't emit
    1395                 :             :      a use-of-uninitialized, just the use-after-free.
    1396                 :             :      (this is because we fully purge information about freed
    1397                 :             :      buffers when we free them to avoid state explosions, so
    1398                 :             :      that if they are accessed after the free, it looks like
    1399                 :             :      they are uninitialized).  */
    1400                 :             : 
    1401                 :         129 :   bool supercedes_p (const pending_diagnostic &other) const final override
    1402                 :             :   {
    1403                 :         129 :     if (other.use_of_uninit_p ())
    1404                 :             :       return true;
    1405                 :             : 
    1406                 :             :     return false;
    1407                 :             :   }
    1408                 :             : 
    1409                 :             : private:
    1410                 :             :   diagnostic_event_id_t m_free_event;
    1411                 :             :   const deallocator *m_deallocator;
    1412                 :             : };
    1413                 :             : 
    1414                 :           0 : class malloc_leak : public malloc_diagnostic
    1415                 :             : {
    1416                 :             : public:
    1417                 :         955 :   malloc_leak (const malloc_state_machine &sm, tree arg)
    1418                 :         955 :   : malloc_diagnostic (sm, arg) {}
    1419                 :             : 
    1420                 :        4385 :   const char *get_kind () const final override { return "malloc_leak"; }
    1421                 :             : 
    1422                 :         771 :   int get_controlling_option () const final override
    1423                 :             :   {
    1424                 :         771 :     return OPT_Wanalyzer_malloc_leak;
    1425                 :             :   }
    1426                 :             : 
    1427                 :         384 :   bool emit (diagnostic_emission_context &ctxt) final override
    1428                 :             :   {
    1429                 :             :     /* "CWE-401: Missing Release of Memory after Effective Lifetime".  */
    1430                 :         384 :     ctxt.add_cwe (401);
    1431                 :         384 :     if (m_arg)
    1432                 :         322 :       return ctxt.warn ("leak of %qE", m_arg);
    1433                 :             :     else
    1434                 :          62 :       return ctxt.warn ("leak of %qs", "<unknown>");
    1435                 :             :   }
    1436                 :             : 
    1437                 :             :   bool
    1438                 :         998 :   describe_state_change (pretty_printer &pp,
    1439                 :             :                          const evdesc::state_change &change) final override
    1440                 :             :   {
    1441                 :         998 :     if (unchecked_p (change.m_new_state)
    1442                 :         998 :         || (start_p (change.m_old_state) && nonnull_p (change.m_new_state)))
    1443                 :             :       {
    1444                 :         738 :         m_alloc_event = change.m_event_id;
    1445                 :         738 :         pp_string (&pp, "allocated here");
    1446                 :         738 :         return true;
    1447                 :             :       }
    1448                 :         260 :     return malloc_diagnostic::describe_state_change (pp, change);
    1449                 :             :   }
    1450                 :             : 
    1451                 :             :   bool
    1452                 :         756 :   describe_final_event (pretty_printer &pp,
    1453                 :             :                         const evdesc::final_event &ev) final override
    1454                 :             :   {
    1455                 :         756 :     if (ev.m_expr)
    1456                 :             :       {
    1457                 :         632 :         if (m_alloc_event.known_p ())
    1458                 :         632 :           pp_printf (&pp,
    1459                 :             :                      "%qE leaks here; was allocated at %@",
    1460                 :             :                      ev.m_expr, &m_alloc_event);
    1461                 :             :         else
    1462                 :           0 :           pp_printf (&pp,
    1463                 :             :                      "%qE leaks here", ev.m_expr);
    1464                 :             :       }
    1465                 :             :     else
    1466                 :             :       {
    1467                 :         124 :         if (m_alloc_event.known_p ())
    1468                 :         106 :           pp_printf (&pp,
    1469                 :             :                      "%qs leaks here; was allocated at %@",
    1470                 :             :                      "<unknown>", &m_alloc_event);
    1471                 :             :         else
    1472                 :          18 :           pp_printf (&pp,
    1473                 :             :                      "%qs leaks here", "<unknown>");
    1474                 :             :       }
    1475                 :         756 :     return true;
    1476                 :             :   }
    1477                 :             : 
    1478                 :             : private:
    1479                 :             :   diagnostic_event_id_t m_alloc_event;
    1480                 :             : };
    1481                 :             : 
    1482                 :           0 : class free_of_non_heap : public malloc_diagnostic
    1483                 :             : {
    1484                 :             : public:
    1485                 :          53 :   free_of_non_heap (const malloc_state_machine &sm, tree arg,
    1486                 :             :                     const region *freed_reg,
    1487                 :             :                     const char *funcname)
    1488                 :          53 :   : malloc_diagnostic (sm, arg), m_freed_reg (freed_reg), m_funcname (funcname)
    1489                 :             :   {
    1490                 :             :   }
    1491                 :             : 
    1492                 :         184 :   const char *get_kind () const final override { return "free_of_non_heap"; }
    1493                 :             : 
    1494                 :          45 :   bool subclass_equal_p (const pending_diagnostic &base_other) const
    1495                 :             :     final override
    1496                 :             :   {
    1497                 :          45 :     const free_of_non_heap &other = (const free_of_non_heap &)base_other;
    1498                 :          45 :     return (same_tree_p (m_arg, other.m_arg)
    1499                 :          45 :             && m_freed_reg == other.m_freed_reg);
    1500                 :             :   }
    1501                 :             : 
    1502                 :          94 :   int get_controlling_option () const final override
    1503                 :             :   {
    1504                 :          94 :     return OPT_Wanalyzer_free_of_non_heap;
    1505                 :             :   }
    1506                 :             : 
    1507                 :          41 :   bool emit (diagnostic_emission_context &ctxt) final override
    1508                 :             :   {
    1509                 :          41 :     auto_diagnostic_group d;
    1510                 :          41 :     ctxt.add_cwe (590); /* CWE-590: Free of Memory not on the Heap.  */
    1511                 :          41 :     switch (get_memory_space ())
    1512                 :             :       {
    1513                 :           0 :       default:
    1514                 :           0 :       case MEMSPACE_HEAP:
    1515                 :           0 :         gcc_unreachable ();
    1516                 :          10 :       case MEMSPACE_UNKNOWN:
    1517                 :          10 :       case MEMSPACE_CODE:
    1518                 :          10 :       case MEMSPACE_GLOBALS:
    1519                 :          10 :       case MEMSPACE_READONLY_DATA:
    1520                 :          10 :         return ctxt.warn ("%qs of %qE which points to memory"
    1521                 :             :                           " not on the heap",
    1522                 :          10 :                           m_funcname, m_arg);
    1523                 :          31 :         break;
    1524                 :          31 :       case MEMSPACE_STACK:
    1525                 :          31 :         return ctxt.warn ("%qs of %qE which points to memory"
    1526                 :             :                           " on the stack",
    1527                 :          31 :                           m_funcname, m_arg);
    1528                 :          41 :         break;
    1529                 :             :       }
    1530                 :          41 :   }
    1531                 :             : 
    1532                 :             :   bool
    1533                 :           0 :   describe_state_change (pretty_printer &pp,
    1534                 :             :                          const evdesc::state_change &) final override
    1535                 :             :   {
    1536                 :           0 :     pp_string (&pp, "pointer is from here");
    1537                 :           0 :     return true;
    1538                 :             :   }
    1539                 :             : 
    1540                 :             :   bool
    1541                 :          82 :   describe_final_event (pretty_printer &pp,
    1542                 :             :                         const evdesc::final_event &) final override
    1543                 :             :   {
    1544                 :          82 :     pp_printf (&pp, "call to %qs here", m_funcname);
    1545                 :          82 :     return true;
    1546                 :             :   }
    1547                 :             : 
    1548                 :          41 :   void mark_interesting_stuff (interesting_t *interest) final override
    1549                 :             :   {
    1550                 :          41 :     if (m_freed_reg)
    1551                 :          41 :       interest->add_region_creation (m_freed_reg);
    1552                 :          41 :   }
    1553                 :             : 
    1554                 :             : private:
    1555                 :          41 :   enum memory_space get_memory_space () const
    1556                 :             :   {
    1557                 :          41 :     if (m_freed_reg)
    1558                 :          41 :       return m_freed_reg->get_memory_space ();
    1559                 :             :     else
    1560                 :             :       return MEMSPACE_UNKNOWN;
    1561                 :             :   }
    1562                 :             : 
    1563                 :             :   const region *m_freed_reg;
    1564                 :             :   const char *m_funcname;
    1565                 :             : };
    1566                 :             : 
    1567                 :             : /* Concrete pending_diagnostic subclass for -Wanalyzer-deref-before-check.  */
    1568                 :             : 
    1569                 :           0 : class deref_before_check : public malloc_diagnostic
    1570                 :             : {
    1571                 :             : public:
    1572                 :         158 :   deref_before_check (const malloc_state_machine &sm, tree arg)
    1573                 :         158 :   : malloc_diagnostic (sm, arg),
    1574                 :         158 :     m_deref_enode (NULL),
    1575                 :         158 :     m_deref_expr (NULL),
    1576                 :         158 :     m_check_enode (NULL)
    1577                 :             :   {
    1578                 :         158 :     gcc_assert (arg);
    1579                 :         158 :   }
    1580                 :             : 
    1581                 :         590 :   const char *get_kind () const final override { return "deref_before_check"; }
    1582                 :             : 
    1583                 :         212 :   int get_controlling_option () const final override
    1584                 :             :   {
    1585                 :         212 :     return OPT_Wanalyzer_deref_before_check;
    1586                 :             :   }
    1587                 :             : 
    1588                 :         110 :   bool emit (diagnostic_emission_context &ctxt) final override
    1589                 :             :   {
    1590                 :             :     /* Don't emit the warning if we can't show where the deref
    1591                 :             :        and the check occur.  */
    1592                 :         110 :     if (!m_deref_enode)
    1593                 :             :       return false;
    1594                 :         110 :     if (!m_check_enode)
    1595                 :             :       return false;
    1596                 :             :     /* Only emit the warning for intraprocedural cases.  */
    1597                 :         110 :     const program_point &deref_point = m_deref_enode->get_point ();
    1598                 :         110 :     const program_point &check_point = m_check_enode->get_point ();
    1599                 :             : 
    1600                 :         110 :     if (!program_point::effectively_intraprocedural_p (deref_point,
    1601                 :             :                                                        check_point))
    1602                 :             :       return false;
    1603                 :             : 
    1604                 :             :     /* Reject the warning if the check occurs within a macro defintion.
    1605                 :             :        This avoids false positives for such code as:
    1606                 :             : 
    1607                 :             :         #define throw_error \
    1608                 :             :            do {             \
    1609                 :             :              if (p)         \
    1610                 :             :                cleanup (p); \
    1611                 :             :              return;        \
    1612                 :             :            } while (0)
    1613                 :             : 
    1614                 :             :         if (p->idx >= n)
    1615                 :             :           throw_error ();
    1616                 :             : 
    1617                 :             :        where the usage of "throw_error" implicitly adds a check
    1618                 :             :        on 'p'.
    1619                 :             : 
    1620                 :             :        We do warn when the check is in a macro expansion if we can get
    1621                 :             :        at the location of the condition and it is't part of the
    1622                 :             :        definition, so that we warn for checks such as:
    1623                 :             :            if (words[0][0] == '@')
    1624                 :             :              return;
    1625                 :             :            g_assert(words[0] != NULL); <--- here
    1626                 :             :        Unfortunately we don't have locations for individual gimple
    1627                 :             :        arguments, so in:
    1628                 :             :            g_assert (ptr);
    1629                 :             :        we merely have a gimple_cond
    1630                 :             :            if (p_2(D) == 0B)
    1631                 :             :        with no way of getting at the location of the condition separately
    1632                 :             :        from that of the gimple_cond (where the "if" is within the macro
    1633                 :             :        definition).  We reject the warning for such cases.
    1634                 :             : 
    1635                 :             :        We do warn when the *deref* occurs in a macro, since this can be
    1636                 :             :        a source of real bugs; see e.g. PR 77425.  */
    1637                 :          94 :     location_t check_loc = m_check_enode->get_point ().get_location ();
    1638                 :          94 :     if (linemap_location_from_macro_definition_p (line_table, check_loc))
    1639                 :             :       return false;
    1640                 :             : 
    1641                 :             :     /* Reject warning if the check is in a loop header within a
    1642                 :             :        macro expansion.  This rejects cases like:
    1643                 :             :        |  deref of x;
    1644                 :             :        |  [...snip...]
    1645                 :             :        |  FOR_EACH(x) {
    1646                 :             :        |    [...snip...]
    1647                 :             :        |  }
    1648                 :             :        where the FOR_EACH macro tests for non-nullness of x, since
    1649                 :             :        the user is hoping to encapsulate the details of iteration
    1650                 :             :        in the macro, and the extra check on the first iteration
    1651                 :             :        would just be noise if we reported it.  */
    1652                 :          88 :     if (loop_header_p (m_check_enode->get_point ())
    1653                 :          88 :         && linemap_location_from_macro_expansion_p (line_table, check_loc))
    1654                 :             :       return false;
    1655                 :             : 
    1656                 :             :     /* Reject if m_deref_expr is sufficiently different from m_arg
    1657                 :             :        for cases where the dereference is spelled differently from
    1658                 :             :        the check, which is probably two different ways to get the
    1659                 :             :        same svalue, and thus not worth reporting.  */
    1660                 :          84 :     if (!m_deref_expr)
    1661                 :             :       return false;
    1662                 :          66 :     if (!sufficiently_similar_p (m_deref_expr, m_arg))
    1663                 :             :       return false;
    1664                 :             : 
    1665                 :             :     /* Reject the warning if the deref's BB doesn't dominate that
    1666                 :             :        of the check, so that we don't warn e.g. for shared cleanup
    1667                 :             :        code that checks a pointer for NULL, when that code is sometimes
    1668                 :             :        used before a deref and sometimes after.
    1669                 :             :        Using the dominance code requires setting cfun.  */
    1670                 :          62 :     auto_cfun sentinel (m_deref_enode->get_function ());
    1671                 :          62 :     calculate_dominance_info (CDI_DOMINATORS);
    1672                 :          62 :     if (!dominated_by_p (CDI_DOMINATORS,
    1673                 :          62 :                          m_check_enode->get_supernode ()->m_bb,
    1674                 :          62 :                          m_deref_enode->get_supernode ()->m_bb))
    1675                 :             :       return false;
    1676                 :             : 
    1677                 :          54 :     return ctxt.warn ("check of %qE for NULL after already"
    1678                 :             :                       " dereferencing it",
    1679                 :          54 :                       m_arg);
    1680                 :             :   }
    1681                 :             : 
    1682                 :             :   bool
    1683                 :         164 :   describe_state_change (pretty_printer &pp,
    1684                 :             :                          const evdesc::state_change &change) final override
    1685                 :             :   {
    1686                 :         164 :     if (change.m_old_state == m_sm.get_start_state ()
    1687                 :         164 :         && assumed_non_null_p (change.m_new_state))
    1688                 :             :       {
    1689                 :         164 :         m_first_deref_event = change.m_event_id;
    1690                 :         164 :         m_deref_enode = change.m_event.get_exploded_node ();
    1691                 :         164 :         m_deref_expr = change.m_expr;
    1692                 :         164 :         pp_printf (&pp,
    1693                 :             :                    "pointer %qE is dereferenced here",
    1694                 :             :                    m_arg);
    1695                 :         164 :         return true;
    1696                 :             :       }
    1697                 :           0 :     return malloc_diagnostic::describe_state_change (pp, change);
    1698                 :             :   }
    1699                 :             : 
    1700                 :             :   bool
    1701                 :         164 :   describe_final_event (pretty_printer &pp,
    1702                 :             :                         const evdesc::final_event &ev) final override
    1703                 :             :   {
    1704                 :         164 :     m_check_enode = ev.m_event.get_exploded_node ();
    1705                 :         164 :     if (m_first_deref_event.known_p ())
    1706                 :         164 :       pp_printf (&pp,
    1707                 :             :                  "pointer %qE is checked for NULL here but"
    1708                 :             :                  " it was already dereferenced at %@",
    1709                 :             :                  m_arg, &m_first_deref_event);
    1710                 :             :     else
    1711                 :           0 :       pp_printf (&pp,
    1712                 :             :                  "pointer %qE is checked for NULL here but"
    1713                 :             :                  " it was already dereferenced",
    1714                 :             :                  m_arg);
    1715                 :         164 :     return true;
    1716                 :             :   }
    1717                 :             : 
    1718                 :             : private:
    1719                 :          88 :   static bool loop_header_p (const program_point &point)
    1720                 :             :   {
    1721                 :          88 :     const supernode *snode = point.get_supernode ();
    1722                 :          88 :     if (!snode)
    1723                 :             :       return false;
    1724                 :         382 :     for (auto &in_edge : snode->m_preds)
    1725                 :             :       {
    1726                 :         244 :         if (const cfg_superedge *cfg_in_edge
    1727                 :         122 :               = in_edge->dyn_cast_cfg_superedge ())
    1728                 :         120 :           if (cfg_in_edge->back_edge_p ())
    1729                 :             :             return true;
    1730                 :             :       }
    1731                 :             :     return false;
    1732                 :             :   }
    1733                 :             : 
    1734                 :          66 :   static bool sufficiently_similar_p (tree expr_a, tree expr_b)
    1735                 :             :   {
    1736                 :          66 :     auto pp_a = global_dc->clone_printer ();
    1737                 :          66 :     auto pp_b = global_dc->clone_printer ();
    1738                 :          66 :     pp_printf (pp_a.get (), "%qE", expr_a);
    1739                 :          66 :     pp_printf (pp_b.get (), "%qE", expr_b);
    1740                 :          66 :     bool result = (strcmp (pp_formatted_text (pp_a.get ()),
    1741                 :             :                            pp_formatted_text (pp_b.get ()))
    1742                 :          66 :                    == 0);
    1743                 :         132 :     return result;
    1744                 :          66 :   }
    1745                 :             : 
    1746                 :             :   diagnostic_event_id_t m_first_deref_event;
    1747                 :             :   const exploded_node *m_deref_enode;
    1748                 :             :   tree m_deref_expr;
    1749                 :             :   const exploded_node *m_check_enode;
    1750                 :             : };
    1751                 :             : 
    1752                 :             : /* struct allocation_state : public state_machine::state.  */
    1753                 :             : 
    1754                 :             : /* Implementation of state_machine::state::dump_to_pp vfunc
    1755                 :             :    for allocation_state: append the API that this allocation is
    1756                 :             :    associated with.  */
    1757                 :             : 
    1758                 :             : void
    1759                 :         806 : allocation_state::dump_to_pp (pretty_printer *pp) const
    1760                 :             : {
    1761                 :         806 :   state_machine::state::dump_to_pp (pp);
    1762                 :         806 :   if (m_deallocators)
    1763                 :             :     {
    1764                 :         420 :       pp_string (pp, " (");
    1765                 :         420 :       m_deallocators->dump_to_pp (pp);
    1766                 :         420 :       pp_character (pp, ')');
    1767                 :             :     }
    1768                 :         806 : }
    1769                 :             : 
    1770                 :             : /* Given a allocation_state for a deallocator_set, get the "nonnull" state
    1771                 :             :    for the corresponding allocator(s).  */
    1772                 :             : 
    1773                 :             : const allocation_state *
    1774                 :        2206 : allocation_state::get_nonnull () const
    1775                 :             : {
    1776                 :        2206 :   gcc_assert (m_deallocators);
    1777                 :        2206 :   return as_a_allocation_state (m_deallocators->m_nonnull);
    1778                 :             : }
    1779                 :             : 
    1780                 :             : /* struct assumed_non_null_state : public allocation_state.  */
    1781                 :             : 
    1782                 :             : void
    1783                 :         377 : assumed_non_null_state::dump_to_pp (pretty_printer *pp) const
    1784                 :             : {
    1785                 :         377 :   allocation_state::dump_to_pp (pp);
    1786                 :         377 :   pp_string (pp, " (in ");
    1787                 :         377 :   m_frame->dump_to_pp (pp, true);
    1788                 :         377 :   pp_character (pp, ')');
    1789                 :         377 : }
    1790                 :             : 
    1791                 :             : /* malloc_state_machine's ctor.  */
    1792                 :             : 
    1793                 :        3209 : malloc_state_machine::malloc_state_machine (logger *logger)
    1794                 :             : : state_machine ("malloc", logger),
    1795                 :        3209 :   m_free (this, "free", WORDING_FREED),
    1796                 :        3209 :   m_scalar_delete (this, "delete", WORDING_DELETED),
    1797                 :        3209 :   m_vector_delete (this, "delete[]", WORDING_DELETED),
    1798                 :        6418 :   m_realloc (this, "realloc", WORDING_REALLOCATED)
    1799                 :             : {
    1800                 :        3209 :   gcc_assert (m_start->get_id () == 0);
    1801                 :        3209 :   m_null = add_state ("null", RS_FREED, NULL, NULL);
    1802                 :        3209 :   m_non_heap = add_state ("non-heap", RS_NON_HEAP, NULL, NULL);
    1803                 :        3209 :   m_stop = add_state ("stop", RS_STOP, NULL, NULL);
    1804                 :        3209 : }
    1805                 :             : 
    1806                 :        6408 : malloc_state_machine::~malloc_state_machine ()
    1807                 :             : {
    1808                 :        3204 :   unsigned i;
    1809                 :        3204 :   custom_deallocator_set *set;
    1810                 :        3275 :   FOR_EACH_VEC_ELT (m_dynamic_sets, i, set)
    1811                 :          71 :     delete set;
    1812                 :             :   custom_deallocator *d;
    1813                 :        3274 :   FOR_EACH_VEC_ELT (m_dynamic_deallocators, i, d)
    1814                 :          70 :     delete d;
    1815                 :        6408 : }
    1816                 :             : 
    1817                 :             : state_machine::state_t
    1818                 :       41929 : malloc_state_machine::add_state (const char *name, enum resource_state rs,
    1819                 :             :                                  const deallocator_set *deallocators,
    1820                 :             :                                  const deallocator *deallocator)
    1821                 :             : {
    1822                 :       83858 :   return add_custom_state (new allocation_state (name, alloc_state_id (),
    1823                 :             :                                                  rs, deallocators,
    1824                 :       41929 :                                                  deallocator));
    1825                 :             : }
    1826                 :             : 
    1827                 :             : /* If ALLOCATOR_FNDECL has any "__attribute__((malloc(FOO)))",
    1828                 :             :    return a custom_deallocator_set for them, consolidating them
    1829                 :             :    to ensure uniqueness of the sets.
    1830                 :             : 
    1831                 :             :    Return NULL if it has no such attributes.  */
    1832                 :             : 
    1833                 :             : const custom_deallocator_set *
    1834                 :       34612 : malloc_state_machine::
    1835                 :             : get_or_create_custom_deallocator_set (tree allocator_fndecl)
    1836                 :             : {
    1837                 :             :   /* Early rejection of decls without attributes.  */
    1838                 :       34612 :   tree attrs = DECL_ATTRIBUTES (allocator_fndecl);
    1839                 :       34612 :   if (!attrs)
    1840                 :             :     return NULL;
    1841                 :             : 
    1842                 :             :   /* Otherwise, call maybe_create_custom_deallocator_set,
    1843                 :             :      memoizing the result.  */
    1844                 :       16170 :   if (custom_deallocator_set **slot
    1845                 :        8085 :       = m_custom_deallocator_set_cache.get (allocator_fndecl))
    1846                 :        6006 :     return *slot;
    1847                 :        2079 :   custom_deallocator_set *set
    1848                 :        2079 :     = maybe_create_custom_deallocator_set (allocator_fndecl);
    1849                 :        2079 :   m_custom_deallocator_set_cache.put (allocator_fndecl, set);
    1850                 :        2079 :   return set;
    1851                 :             : }
    1852                 :             : 
    1853                 :             : /* Given ALLOCATOR_FNDECL, a FUNCTION_DECL with attributes,
    1854                 :             :    look for any "__attribute__((malloc(FOO)))" and return a
    1855                 :             :    custom_deallocator_set for them, consolidating them
    1856                 :             :    to ensure uniqueness of the sets.
    1857                 :             : 
    1858                 :             :    Return NULL if it has no such attributes.
    1859                 :             : 
    1860                 :             :    Subroutine of get_or_create_custom_deallocator_set which
    1861                 :             :    memoizes the result.  */
    1862                 :             : 
    1863                 :             : custom_deallocator_set *
    1864                 :        2079 : malloc_state_machine::
    1865                 :             : maybe_create_custom_deallocator_set (tree allocator_fndecl)
    1866                 :             : {
    1867                 :        2079 :   tree attrs = DECL_ATTRIBUTES (allocator_fndecl);
    1868                 :        2079 :   gcc_assert (attrs);
    1869                 :             : 
    1870                 :             :   /* Look for instances of __attribute__((malloc(FOO))).  */
    1871                 :        2079 :   auto_vec<const deallocator *> deallocator_vec;
    1872                 :        2079 :   for (tree allocs = attrs;
    1873                 :        2297 :        (allocs = lookup_attribute ("malloc", allocs));
    1874                 :         218 :        allocs = TREE_CHAIN (allocs))
    1875                 :             :     {
    1876                 :         218 :       tree args = TREE_VALUE (allocs);
    1877                 :         218 :       if (!args)
    1878                 :         114 :         continue;
    1879                 :         104 :       if (TREE_VALUE (args))
    1880                 :             :         {
    1881                 :         104 :           const deallocator *d
    1882                 :         104 :             = get_or_create_deallocator (TREE_VALUE (args));
    1883                 :         104 :           deallocator_vec.safe_push (d);
    1884                 :             :         }
    1885                 :             :     }
    1886                 :             : 
    1887                 :             :   /* If there weren't any deallocators, bail.  */
    1888                 :        2163 :   if (deallocator_vec.length () == 0)
    1889                 :             :     return NULL;
    1890                 :             : 
    1891                 :             :   /* Consolidate, so that we reuse existing deallocator_set
    1892                 :             :      instances.  */
    1893                 :          84 :   deallocator_vec.qsort (deallocator::cmp_ptr_ptr);
    1894                 :          84 :   custom_deallocator_set **slot
    1895                 :          84 :     = m_custom_deallocator_set_map.get (&deallocator_vec);
    1896                 :          84 :   if (slot)
    1897                 :          13 :     return *slot;
    1898                 :          71 :   custom_deallocator_set *set
    1899                 :          71 :     = new custom_deallocator_set (this, &deallocator_vec, WORDING_DEALLOCATED);
    1900                 :          71 :   m_custom_deallocator_set_map.put (&set->m_deallocator_vec, set);
    1901                 :          71 :   m_dynamic_sets.safe_push (set);
    1902                 :          71 :   return set;
    1903                 :        2079 : }
    1904                 :             : 
    1905                 :             : /* Get the deallocator for DEALLOCATOR_FNDECL, creating it if necessary.  */
    1906                 :             : 
    1907                 :             : const deallocator *
    1908                 :         384 : malloc_state_machine::get_or_create_deallocator (tree deallocator_fndecl)
    1909                 :             : {
    1910                 :         384 :   deallocator **slot = m_deallocator_map.get (deallocator_fndecl);
    1911                 :         384 :   if (slot)
    1912                 :         308 :     return *slot;
    1913                 :             : 
    1914                 :             :   /* Reuse "free".  */
    1915                 :          76 :   deallocator *d;
    1916                 :          76 :   if (is_named_call_p (deallocator_fndecl, "free")
    1917                 :          71 :       || is_std_named_call_p (deallocator_fndecl, "free")
    1918                 :         147 :       || is_named_call_p (deallocator_fndecl, "__builtin_free"))
    1919                 :           6 :     d = &m_free.m_deallocator;
    1920                 :             :   else
    1921                 :             :     {
    1922                 :          70 :       custom_deallocator *cd
    1923                 :             :         = new custom_deallocator (this, deallocator_fndecl,
    1924                 :          70 :                                   WORDING_DEALLOCATED);
    1925                 :          70 :       m_dynamic_deallocators.safe_push (cd);
    1926                 :          70 :       d = cd;
    1927                 :             :     }
    1928                 :          76 :   m_deallocator_map.put (deallocator_fndecl, d);
    1929                 :          76 :   return d;
    1930                 :             : }
    1931                 :             : 
    1932                 :             : /* Get the "assumed-non-null" state for assumptions made within FRAME,
    1933                 :             :    creating it if necessary.  */
    1934                 :             : 
    1935                 :             : state_machine::state_t
    1936                 :       14560 : malloc_state_machine::
    1937                 :             : get_or_create_assumed_non_null_state_for_frame (const frame_region *frame)
    1938                 :             : {
    1939                 :       14560 :   if (state_t *slot = m_assumed_non_null.get (frame))
    1940                 :       11821 :     return *slot;
    1941                 :        2739 :   state_machine::state *new_state
    1942                 :        2739 :     = new assumed_non_null_state ("assumed-non-null", alloc_state_id (), frame);
    1943                 :        2739 :   add_custom_state (new_state);
    1944                 :        2739 :   m_assumed_non_null.put (frame, new_state);
    1945                 :        2739 :   return new_state;
    1946                 :             : }
    1947                 :             : 
    1948                 :             : /* Try to identify the function declaration either by name or as a known malloc
    1949                 :             :    builtin.  */
    1950                 :             : 
    1951                 :             : static bool
    1952                 :       54224 : known_allocator_p (const_tree fndecl, const gcall *call)
    1953                 :             : {
    1954                 :             :   /* Either it is a function we know by name and number of arguments... */
    1955                 :       54224 :   if (is_named_call_p (fndecl, "malloc", call, 1)
    1956                 :       52130 :       || is_named_call_p (fndecl, "calloc", call, 2)
    1957                 :       52013 :       || is_std_named_call_p (fndecl, "malloc", call, 1)
    1958                 :       52010 :       || is_std_named_call_p (fndecl, "calloc", call, 2)
    1959                 :       52007 :       || is_named_call_p (fndecl, "strdup", call, 1)
    1960                 :      106033 :       || is_named_call_p (fndecl, "strndup", call, 2))
    1961                 :        2429 :     return true;
    1962                 :             : 
    1963                 :             :   /* ... or it is a builtin allocator that allocates objects freed with
    1964                 :             :      __builtin_free.  */
    1965                 :       51795 :   if (fndecl_built_in_p (fndecl, BUILT_IN_NORMAL))
    1966                 :       22240 :     switch (DECL_FUNCTION_CODE (fndecl))
    1967                 :             :       {
    1968                 :             :       case BUILT_IN_MALLOC:
    1969                 :             :       case BUILT_IN_CALLOC:
    1970                 :             :       case BUILT_IN_STRDUP:
    1971                 :             :       case BUILT_IN_STRNDUP:
    1972                 :             :         return true;
    1973                 :             :       default:
    1974                 :             :         break;
    1975                 :             :       }
    1976                 :             : 
    1977                 :             :   return false;
    1978                 :             : }
    1979                 :             : 
    1980                 :             : /* If PTR's nullness is not known, transition it to the "assumed-non-null"
    1981                 :             :    state for the current frame.  */
    1982                 :             : 
    1983                 :             : void
    1984                 :       24332 : malloc_state_machine::maybe_assume_non_null (sm_context &sm_ctxt,
    1985                 :             :                                              tree ptr,
    1986                 :             :                                              const gimple *stmt) const
    1987                 :             : {
    1988                 :       24332 :   const region_model *old_model = sm_ctxt.get_old_region_model ();
    1989                 :       24332 :   if (!old_model)
    1990                 :           0 :     return;
    1991                 :             : 
    1992                 :       24332 :   tree null_ptr_cst = build_int_cst (TREE_TYPE (ptr), 0);
    1993                 :       24332 :   tristate known_non_null
    1994                 :       24332 :     = old_model->eval_condition (ptr, NE_EXPR, null_ptr_cst, NULL);
    1995                 :       24332 :   if (known_non_null.is_unknown ())
    1996                 :             :     {
    1997                 :             :       /* Cast away const-ness for cache-like operations.  */
    1998                 :       14560 :       malloc_state_machine *mut_this
    1999                 :             :         = const_cast <malloc_state_machine *> (this);
    2000                 :       14560 :       state_t next_state
    2001                 :             :         = mut_this->get_or_create_assumed_non_null_state_for_frame
    2002                 :       14560 :         (old_model->get_current_frame ());
    2003                 :       14560 :       sm_ctxt.set_next_state (stmt, ptr, next_state);
    2004                 :             :     }
    2005                 :             : }
    2006                 :             : 
    2007                 :             : /* Implementation of state_machine::on_stmt vfunc for malloc_state_machine.  */
    2008                 :             : 
    2009                 :             : bool
    2010                 :      267881 : malloc_state_machine::on_stmt (sm_context &sm_ctxt,
    2011                 :             :                                const supernode *node,
    2012                 :             :                                const gimple *stmt) const
    2013                 :             : {
    2014                 :      267881 :   if (const gcall *call = dyn_cast <const gcall *> (stmt))
    2015                 :       55585 :     if (tree callee_fndecl = sm_ctxt.get_fndecl_for_call (call))
    2016                 :             :       {
    2017                 :       54224 :         if (known_allocator_p (callee_fndecl, call))
    2018                 :             :           {
    2019                 :        7162 :             on_allocator_call (sm_ctxt, call, &m_free);
    2020                 :        7162 :             return true;
    2021                 :             :           }
    2022                 :             : 
    2023                 :       47062 :         if (!is_placement_new_p (call))
    2024                 :             :           {
    2025                 :       94010 :             bool returns_nonnull = !TREE_NOTHROW (callee_fndecl)
    2026                 :       47005 :                                    && flag_exceptions;
    2027                 :       47005 :             if (is_named_call_p (callee_fndecl, "operator new"))
    2028                 :         113 :               on_allocator_call (sm_ctxt, call,
    2029                 :             :                                  &m_scalar_delete, returns_nonnull);
    2030                 :       46892 :             else if (is_named_call_p (callee_fndecl, "operator new []"))
    2031                 :          54 :               on_allocator_call (sm_ctxt, call,
    2032                 :             :                                  &m_vector_delete, returns_nonnull);
    2033                 :             :           }
    2034                 :             : 
    2035                 :       47062 :         if (is_named_call_p (callee_fndecl, "operator delete", call, 1)
    2036                 :       47062 :             || is_named_call_p (callee_fndecl, "operator delete", call, 2))
    2037                 :             :           {
    2038                 :         112 :             on_deallocator_call (sm_ctxt, node, call,
    2039                 :             :                                  &m_scalar_delete.m_deallocator, 0);
    2040                 :         112 :             return true;
    2041                 :             :           }
    2042                 :       46950 :         else if (is_named_call_p (callee_fndecl, "operator delete []", call, 1))
    2043                 :             :           {
    2044                 :          36 :             on_deallocator_call (sm_ctxt, node, call,
    2045                 :             :                                  &m_vector_delete.m_deallocator, 0);
    2046                 :          36 :             return true;
    2047                 :             :           }
    2048                 :             : 
    2049                 :       46914 :         if (is_named_call_p (callee_fndecl, "alloca", call, 1)
    2050                 :       46914 :             || is_named_call_p (callee_fndecl, "__builtin_alloca", call, 1))
    2051                 :             :           {
    2052                 :         193 :             tree lhs = gimple_call_lhs (call);
    2053                 :         193 :             if (lhs)
    2054                 :         193 :               sm_ctxt.on_transition (node, stmt, lhs, m_start, m_non_heap);
    2055                 :         193 :             return true;
    2056                 :             :           }
    2057                 :             : 
    2058                 :       46721 :         if (is_named_call_p (callee_fndecl, "free", call, 1)
    2059                 :       43813 :             || is_std_named_call_p (callee_fndecl, "free", call, 1)
    2060                 :       90528 :             || is_named_call_p (callee_fndecl, "__builtin_free", call, 1))
    2061                 :             :           {
    2062                 :       11640 :             on_deallocator_call (sm_ctxt, node, call,
    2063                 :             :                                  &m_free.m_deallocator, 0);
    2064                 :       11640 :             return true;
    2065                 :             :           }
    2066                 :             : 
    2067                 :       35081 :         if (is_named_call_p (callee_fndecl, "realloc", call, 2)
    2068                 :       34642 :             || is_std_named_call_p (callee_fndecl, "realloc", call, 2)
    2069                 :       69723 :             || is_named_call_p (callee_fndecl, "__builtin_realloc", call, 2))
    2070                 :             :           {
    2071                 :         461 :             on_realloc_call (sm_ctxt, node, call);
    2072                 :         461 :             return true;
    2073                 :             :           }
    2074                 :             : 
    2075                 :       34620 :         if (unaffected_by_call_p (callee_fndecl))
    2076                 :             :           return true;
    2077                 :             : 
    2078                 :             :         /* Cast away const-ness for cache-like operations.  */
    2079                 :       34612 :         malloc_state_machine *mutable_this
    2080                 :             :           = const_cast <malloc_state_machine *> (this);
    2081                 :             : 
    2082                 :             :         /* Handle interesting attributes of the callee_fndecl,
    2083                 :             :            or prioritize those of the builtin that callee_fndecl is expected
    2084                 :             :            to be.
    2085                 :             :            Might want this to be controlled by a flag.  */
    2086                 :       34612 :         {
    2087                 :       34612 :           tree fndecl = callee_fndecl;
    2088                 :             :           /* If call is recognized as a builtin known_function, use that
    2089                 :             :              builtin's function_decl.  */
    2090                 :       34612 :           if (const region_model *old_model = sm_ctxt.get_old_region_model ())
    2091                 :       69224 :             if (const builtin_known_function *builtin_kf
    2092                 :       34612 :                 = old_model->get_builtin_kf (call))
    2093                 :        2287 :               fndecl = builtin_kf->builtin_decl ();
    2094                 :             : 
    2095                 :             :           /* Handle "__attribute__((malloc(FOO)))".   */
    2096                 :       69224 :           if (const deallocator_set *deallocators
    2097                 :             :               = mutable_this->get_or_create_custom_deallocator_set
    2098                 :       34612 :                   (fndecl))
    2099                 :             :             {
    2100                 :         260 :               tree attrs = TYPE_ATTRIBUTES (TREE_TYPE (fndecl));
    2101                 :         260 :               bool returns_nonnull
    2102                 :         260 :                 = lookup_attribute ("returns_nonnull", attrs);
    2103                 :         260 :               on_allocator_call (sm_ctxt, call, deallocators, returns_nonnull);
    2104                 :             :             }
    2105                 :             : 
    2106                 :       34612 :           {
    2107                 :             :             /* Handle "__attribute__((nonnull))".   */
    2108                 :       34612 :             tree fntype = TREE_TYPE (fndecl);
    2109                 :       34612 :             bitmap nonnull_args = get_nonnull_args (fntype);
    2110                 :       34612 :             if (nonnull_args)
    2111                 :             :               {
    2112                 :       16905 :                 for (unsigned i = 0; i < gimple_call_num_args (stmt); i++)
    2113                 :             :                   {
    2114                 :       11604 :                     tree arg = gimple_call_arg (stmt, i);
    2115                 :       11604 :                     if (TREE_CODE (TREE_TYPE (arg)) != POINTER_TYPE)
    2116                 :        2836 :                       continue;
    2117                 :             :                     /* If we have a nonnull-args, and either all pointers, or
    2118                 :             :                        just the specified pointers.  */
    2119                 :        8768 :                     if (bitmap_empty_p (nonnull_args)
    2120                 :        8768 :                         || bitmap_bit_p (nonnull_args, i))
    2121                 :             :                       {
    2122                 :        7499 :                         state_t state = sm_ctxt.get_state (stmt, arg);
    2123                 :             :                         /* Can't use a switch as the states are non-const.  */
    2124                 :             :                         /* Do use the fndecl that caused the warning so that the
    2125                 :             :                            misused attributes are printed and the user not
    2126                 :             :                            confused.  */
    2127                 :        7499 :                         if (unchecked_p (state))
    2128                 :             :                           {
    2129                 :          73 :                             tree diag_arg = sm_ctxt.get_diagnostic_tree (arg);
    2130                 :          73 :                             sm_ctxt.warn (node, stmt, arg,
    2131                 :             :                                           make_unique<possible_null_arg>
    2132                 :         146 :                                             (*this, diag_arg, fndecl, i));
    2133                 :          73 :                             const allocation_state *astate
    2134                 :          73 :                               = as_a_allocation_state (state);
    2135                 :          73 :                             sm_ctxt.set_next_state (stmt, arg,
    2136                 :          73 :                                                     astate->get_nonnull ());
    2137                 :             :                           }
    2138                 :        7426 :                         else if (state == m_null)
    2139                 :             :                           {
    2140                 :          73 :                             tree diag_arg = sm_ctxt.get_diagnostic_tree (arg);
    2141                 :          73 :                             sm_ctxt.warn (node, stmt, arg,
    2142                 :             :                                           make_unique<null_arg>
    2143                 :         146 :                                             (*this, diag_arg, fndecl, i));
    2144                 :          73 :                             sm_ctxt.set_next_state (stmt, arg, m_stop);
    2145                 :             :                           }
    2146                 :        7353 :                         else if (state == m_start)
    2147                 :        3492 :                           maybe_assume_non_null (sm_ctxt, arg, stmt);
    2148                 :             :                       }
    2149                 :             :                   }
    2150                 :        5301 :                 BITMAP_FREE (nonnull_args);
    2151                 :             :               }
    2152                 :             :           }
    2153                 :             : 
    2154                 :             :           /* Check for this after nonnull, so that if we have both
    2155                 :             :              then we transition to "freed", rather than "checked".  */
    2156                 :       34612 :           unsigned dealloc_argno = fndecl_dealloc_argno (fndecl);
    2157                 :       34612 :           if (dealloc_argno != UINT_MAX)
    2158                 :             :             {
    2159                 :         280 :               const deallocator *d
    2160                 :         280 :                 = mutable_this->get_or_create_deallocator (fndecl);
    2161                 :         280 :               on_deallocator_call (sm_ctxt, node, call, d, dealloc_argno);
    2162                 :             :             }
    2163                 :             :         }
    2164                 :             :       }
    2165                 :             : 
    2166                 :             :   /* Look for pointers explicitly being compared against zero
    2167                 :             :      that are in state assumed_non_null i.e. we already defererenced
    2168                 :             :      them.
    2169                 :             :      We have to do this check here, rather than in on_condition
    2170                 :             :      because we add a constraint that the pointer is non-null when
    2171                 :             :      dereferencing it, and this makes the apply_constraints_for_gcond
    2172                 :             :      find known-true and known-false conditions; on_condition is only
    2173                 :             :      called when adding new constraints.  */
    2174                 :      248269 :   if (const gcond *cond_stmt = dyn_cast <const gcond *> (stmt))
    2175                 :             :     {
    2176                 :       20020 :       enum tree_code op = gimple_cond_code (cond_stmt);
    2177                 :       20020 :       if (op == EQ_EXPR || op == NE_EXPR)
    2178                 :             :         {
    2179                 :       14703 :           tree lhs = gimple_cond_lhs (cond_stmt);
    2180                 :       14703 :           tree rhs = gimple_cond_rhs (cond_stmt);
    2181                 :       14703 :           if (any_pointer_p (lhs)
    2182                 :        6219 :               && any_pointer_p (rhs)
    2183                 :       20922 :               && zerop (rhs))
    2184                 :             :             {
    2185                 :        5711 :               state_t state = sm_ctxt.get_state (stmt, lhs);
    2186                 :        5711 :               if (assumed_non_null_p (state))
    2187                 :         227 :                 maybe_complain_about_deref_before_check
    2188                 :         227 :                   (sm_ctxt, node,
    2189                 :             :                    stmt,
    2190                 :             :                    (const assumed_non_null_state *)state,
    2191                 :             :                    lhs);
    2192                 :             :             }
    2193                 :             :         }
    2194                 :             :     }
    2195                 :             : 
    2196                 :      248269 :   if (tree lhs = sm_ctxt.is_zero_assignment (stmt))
    2197                 :       14942 :     if (any_pointer_p (lhs))
    2198                 :        3154 :       on_zero_assignment (sm_ctxt, stmt,lhs);
    2199                 :             : 
    2200                 :             :   /* Handle dereferences.  */
    2201                 :      899560 :   for (unsigned i = 0; i < gimple_num_ops (stmt); i++)
    2202                 :             :     {
    2203                 :      651291 :       tree op = gimple_op (stmt, i);
    2204                 :      651291 :       if (!op)
    2205                 :      125312 :         continue;
    2206                 :      525979 :       if (TREE_CODE (op) == COMPONENT_REF)
    2207                 :       19853 :         op = TREE_OPERAND (op, 0);
    2208                 :             : 
    2209                 :      525979 :       if (TREE_CODE (op) == MEM_REF)
    2210                 :             :         {
    2211                 :       33366 :           tree arg = TREE_OPERAND (op, 0);
    2212                 :             : 
    2213                 :       33366 :           state_t state = sm_ctxt.get_state (stmt, arg);
    2214                 :       33366 :           if (state == m_start)
    2215                 :       20840 :             maybe_assume_non_null (sm_ctxt, arg, stmt);
    2216                 :       12526 :           else if (unchecked_p (state))
    2217                 :             :             {
    2218                 :        1014 :               tree diag_arg = sm_ctxt.get_diagnostic_tree (arg);
    2219                 :        1014 :               sm_ctxt.warn (node, stmt, arg,
    2220                 :        2028 :                             make_unique<possible_null_deref> (*this,
    2221                 :             :                                                               diag_arg));
    2222                 :        1014 :               const allocation_state *astate = as_a_allocation_state (state);
    2223                 :        1014 :               sm_ctxt.set_next_state (stmt, arg, astate->get_nonnull ());
    2224                 :             :             }
    2225                 :       11512 :           else if (state == m_null)
    2226                 :             :             {
    2227                 :         301 :               tree diag_arg = sm_ctxt.get_diagnostic_tree (arg);
    2228                 :         301 :               sm_ctxt.warn (node, stmt, arg,
    2229                 :         602 :                             make_unique<null_deref> (*this, diag_arg));
    2230                 :         301 :               sm_ctxt.set_next_state (stmt, arg, m_stop);
    2231                 :             :             }
    2232                 :      651466 :           else if (freed_p (state))
    2233                 :             :             {
    2234                 :         175 :               tree diag_arg = sm_ctxt.get_diagnostic_tree (arg);
    2235                 :         175 :               const allocation_state *astate = as_a_allocation_state (state);
    2236                 :         175 :               sm_ctxt.warn (node, stmt, arg,
    2237                 :             :                             make_unique<use_after_free>
    2238                 :         350 :                               (*this, diag_arg, astate->m_deallocator));
    2239                 :         175 :               sm_ctxt.set_next_state (stmt, arg, m_stop);
    2240                 :             :             }
    2241                 :             :         }
    2242                 :             :     }
    2243                 :             :   return false;
    2244                 :             : }
    2245                 :             : 
    2246                 :             : /* Given a check against null of PTR in assumed-non-null state STATE,
    2247                 :             :    potentially add a deref_before_check warning to SM_CTXT.  */
    2248                 :             : 
    2249                 :             : void
    2250                 :         227 : malloc_state_machine::
    2251                 :             : maybe_complain_about_deref_before_check (sm_context &sm_ctxt,
    2252                 :             :                                          const supernode *node,
    2253                 :             :                                          const gimple *stmt,
    2254                 :             :                                          const assumed_non_null_state *state,
    2255                 :             :                                          tree ptr) const
    2256                 :             : {
    2257                 :         227 :   const region_model *model = sm_ctxt.get_old_region_model ();
    2258                 :         227 :   if (!model)
    2259                 :          69 :     return;
    2260                 :             : 
    2261                 :             :   /* Don't complain if the current frame (where the check is occurring) is
    2262                 :             :      deeper than the frame in which the "not null" assumption was made.
    2263                 :             :      This suppress false positives for cases like:
    2264                 :             : 
    2265                 :             :         void foo (struct s *p)
    2266                 :             :         {
    2267                 :             :           int val = s->some_field; // deref here
    2268                 :             :           shared_helper (p);
    2269                 :             :         }
    2270                 :             : 
    2271                 :             :      where "shared_helper" has:
    2272                 :             : 
    2273                 :             :         void shared_helper (struct s *p)
    2274                 :             :         {
    2275                 :             :           if (!p) // check here
    2276                 :             :             return;
    2277                 :             :           // etc
    2278                 :             :         }
    2279                 :             : 
    2280                 :             :      since the check in "shared_helper" is OK.  */
    2281                 :         227 :   const frame_region *checked_in_frame = model->get_current_frame ();
    2282                 :         227 :   const frame_region *assumed_nonnull_in_frame = state->m_frame;
    2283                 :         227 :   if (checked_in_frame->get_index () > assumed_nonnull_in_frame->get_index ())
    2284                 :             :     return;
    2285                 :             : 
    2286                 :             :   /* Don't complain if STMT was inlined from another function, to avoid
    2287                 :             :      similar false positives involving shared helper functions.  */
    2288                 :         166 :   if (stmt->location)
    2289                 :             :     {
    2290                 :         166 :       inlining_info info (stmt->location);
    2291                 :         166 :       if (info.get_extra_frames () > 0)
    2292                 :           8 :         return;
    2293                 :             :     }
    2294                 :             : 
    2295                 :         158 :   tree diag_ptr = sm_ctxt.get_diagnostic_tree (ptr);
    2296                 :         158 :   if (diag_ptr)
    2297                 :         158 :     sm_ctxt.warn
    2298                 :         158 :       (node, stmt, ptr,
    2299                 :         316 :        make_unique<deref_before_check> (*this, diag_ptr));
    2300                 :         158 :   sm_ctxt.set_next_state (stmt, ptr, m_stop);
    2301                 :             : }
    2302                 :             : 
    2303                 :             : /* Handle a call to an allocator.
    2304                 :             :    RETURNS_NONNULL is true if CALL is to a fndecl known to have
    2305                 :             :    __attribute__((returns_nonnull)).  */
    2306                 :             : 
    2307                 :             : void
    2308                 :        7589 : malloc_state_machine::on_allocator_call (sm_context &sm_ctxt,
    2309                 :             :                                          const gcall *call,
    2310                 :             :                                          const deallocator_set *deallocators,
    2311                 :             :                                          bool returns_nonnull) const
    2312                 :             : {
    2313                 :        7589 :   tree lhs = gimple_call_lhs (call);
    2314                 :        7589 :   if (lhs)
    2315                 :             :     {
    2316                 :        7589 :       if (sm_ctxt.get_state (call, lhs) == m_start)
    2317                 :        7563 :         sm_ctxt.set_next_state (call, lhs,
    2318                 :             :                                 (returns_nonnull
    2319                 :             :                                  ? deallocators->m_nonnull
    2320                 :             :                                  : deallocators->m_unchecked));
    2321                 :             :     }
    2322                 :             :   else
    2323                 :             :     {
    2324                 :             :       /* TODO: report leak.  */
    2325                 :             :     }
    2326                 :        7589 : }
    2327                 :             : 
    2328                 :             : /* Handle deallocations of non-heap pointers.
    2329                 :             :    non-heap -> stop, with warning.  */
    2330                 :             : 
    2331                 :             : void
    2332                 :          53 : malloc_state_machine::handle_free_of_non_heap (sm_context &sm_ctxt,
    2333                 :             :                                                const supernode *node,
    2334                 :             :                                                const gcall *call,
    2335                 :             :                                                tree arg,
    2336                 :             :                                                const deallocator *d) const
    2337                 :             : {
    2338                 :          53 :   tree diag_arg = sm_ctxt.get_diagnostic_tree (arg);
    2339                 :          53 :   const region *freed_reg = NULL;
    2340                 :          53 :   if (const program_state *old_state = sm_ctxt.get_old_program_state ())
    2341                 :             :     {
    2342                 :          53 :       const region_model *old_model = old_state->m_region_model;
    2343                 :          53 :       const svalue *ptr_sval = old_model->get_rvalue (arg, NULL);
    2344                 :          53 :       freed_reg = old_model->deref_rvalue (ptr_sval, arg, NULL);
    2345                 :             :     }
    2346                 :          53 :   sm_ctxt.warn (node, call, arg,
    2347                 :             :                 make_unique<free_of_non_heap>
    2348                 :         106 :                   (*this, diag_arg, freed_reg, d->m_name));
    2349                 :          53 :   sm_ctxt.set_next_state (call, arg, m_stop);
    2350                 :          53 : }
    2351                 :             : 
    2352                 :             : void
    2353                 :       12068 : malloc_state_machine::on_deallocator_call (sm_context &sm_ctxt,
    2354                 :             :                                            const supernode *node,
    2355                 :             :                                            const gcall *call,
    2356                 :             :                                            const deallocator *d,
    2357                 :             :                                            unsigned argno) const
    2358                 :             : {
    2359                 :       12068 :   if (argno >= gimple_call_num_args (call))
    2360                 :             :     return;
    2361                 :       12068 :   tree arg = gimple_call_arg (call, argno);
    2362                 :             : 
    2363                 :       12068 :   state_t state = sm_ctxt.get_state (call, arg);
    2364                 :             : 
    2365                 :             :   /* start/assumed_non_null/unchecked/nonnull -> freed.  */
    2366                 :       22772 :   if (state == m_start || assumed_non_null_p (state))
    2367                 :        1394 :     sm_ctxt.set_next_state (call, arg, d->m_freed);
    2368                 :       10674 :   else if (unchecked_p (state) || nonnull_p (state))
    2369                 :             :     {
    2370                 :        5833 :       const allocation_state *astate = as_a_allocation_state (state);
    2371                 :        5833 :       gcc_assert (astate->m_deallocators);
    2372                 :        5833 :       if (!astate->m_deallocators->contains_p (d))
    2373                 :             :         {
    2374                 :             :           /* Wrong allocator.  */
    2375                 :         120 :           tree diag_arg = sm_ctxt.get_diagnostic_tree (arg);
    2376                 :         120 :           sm_ctxt.warn (node, call, arg,
    2377                 :             :                         make_unique<mismatching_deallocation>
    2378                 :         240 :                           (*this, diag_arg,
    2379                 :         120 :                            astate->m_deallocators,
    2380                 :             :                            d));
    2381                 :             :         }
    2382                 :        5833 :       sm_ctxt.set_next_state (call, arg, d->m_freed);
    2383                 :             :     }
    2384                 :             : 
    2385                 :             :   /* Keep state "null" as-is, rather than transitioning to "freed";
    2386                 :             :      we don't want to complain about double-free of NULL.  */
    2387                 :        4841 :   else if (state == d->m_freed)
    2388                 :             :     {
    2389                 :             :       /* freed -> stop, with warning.  */
    2390                 :        4472 :       tree diag_arg = sm_ctxt.get_diagnostic_tree (arg);
    2391                 :        4472 :       sm_ctxt.warn (node, call, arg,
    2392                 :        8944 :                     make_unique<double_free> (*this, diag_arg, d->m_name));
    2393                 :        4472 :       sm_ctxt.set_next_state (call, arg, m_stop);
    2394                 :             :     }
    2395                 :         369 :   else if (state == m_non_heap)
    2396                 :             :     {
    2397                 :             :       /* non-heap -> stop, with warning.  */
    2398                 :          49 :       handle_free_of_non_heap (sm_ctxt, node, call, arg, d);
    2399                 :             :     }
    2400                 :             : }
    2401                 :             : 
    2402                 :             : /* Handle a call to "realloc".
    2403                 :             :    Check for free of non-heap or mismatching allocators,
    2404                 :             :    transitioning to the "stop" state for such cases.
    2405                 :             : 
    2406                 :             :    Otherwise, kf_realloc::impl_call_post will later
    2407                 :             :    get called (which will handle other sm-state transitions
    2408                 :             :    when the state is bifurcated).  */
    2409                 :             : 
    2410                 :             : void
    2411                 :         461 : malloc_state_machine::on_realloc_call (sm_context &sm_ctxt,
    2412                 :             :                                        const supernode *node,
    2413                 :             :                                        const gcall *call) const
    2414                 :             : {
    2415                 :         461 :   const unsigned argno = 0;
    2416                 :         461 :   const deallocator *d = &m_realloc;
    2417                 :             : 
    2418                 :         461 :   tree arg = gimple_call_arg (call, argno);
    2419                 :             : 
    2420                 :         461 :   state_t state = sm_ctxt.get_state (call, arg);
    2421                 :             : 
    2422                 :         461 :   if (unchecked_p (state) || nonnull_p (state))
    2423                 :             :     {
    2424                 :         206 :       const allocation_state *astate = as_a_allocation_state (state);
    2425                 :         206 :       gcc_assert (astate->m_deallocators);
    2426                 :         206 :       if (!astate->m_deallocators->contains_p (&m_free.m_deallocator))
    2427                 :             :         {
    2428                 :             :           /* Wrong allocator.  */
    2429                 :          16 :           tree diag_arg = sm_ctxt.get_diagnostic_tree (arg);
    2430                 :          16 :           sm_ctxt.warn (node, call, arg,
    2431                 :             :                         make_unique<mismatching_deallocation>
    2432                 :          32 :                           (*this, diag_arg,
    2433                 :          16 :                            astate->m_deallocators, d));
    2434                 :          16 :           sm_ctxt.set_next_state (call, arg, m_stop);
    2435                 :          16 :           if (path_context *path_ctxt = sm_ctxt.get_path_context ())
    2436                 :          16 :             path_ctxt->terminate_path ();
    2437                 :             :         }
    2438                 :             :     }
    2439                 :         255 :   else if (state == m_free.m_deallocator.m_freed)
    2440                 :             :     {
    2441                 :             :       /* freed -> stop, with warning.  */
    2442                 :           4 :       tree diag_arg = sm_ctxt.get_diagnostic_tree (arg);
    2443                 :           4 :       sm_ctxt.warn (node, call, arg,
    2444                 :           8 :                     make_unique<double_free> (*this, diag_arg, "free"));
    2445                 :           4 :       sm_ctxt.set_next_state (call, arg, m_stop);
    2446                 :           4 :       if (path_context *path_ctxt = sm_ctxt.get_path_context ())
    2447                 :           4 :         path_ctxt->terminate_path ();
    2448                 :             :     }
    2449                 :         251 :   else if (state == m_non_heap)
    2450                 :             :     {
    2451                 :             :       /* non-heap -> stop, with warning.  */
    2452                 :           4 :       handle_free_of_non_heap (sm_ctxt, node, call, arg, d);
    2453                 :           4 :       if (path_context *path_ctxt = sm_ctxt.get_path_context ())
    2454                 :           4 :         path_ctxt->terminate_path ();
    2455                 :             :     }
    2456                 :         461 : }
    2457                 :             : 
    2458                 :             : /* Implementation of state_machine::on_phi vfunc for malloc_state_machine.  */
    2459                 :             : 
    2460                 :             : void
    2461                 :       24089 : malloc_state_machine::on_phi (sm_context &sm_ctxt,
    2462                 :             :                               const supernode *node ATTRIBUTE_UNUSED,
    2463                 :             :                               const gphi *phi,
    2464                 :             :                               tree rhs) const
    2465                 :             : {
    2466                 :       24089 :   if (zerop (rhs))
    2467                 :             :     {
    2468                 :         783 :       tree lhs = gimple_phi_result (phi);
    2469                 :         783 :       on_zero_assignment (sm_ctxt, phi, lhs);
    2470                 :             :     }
    2471                 :       24089 : }
    2472                 :             : 
    2473                 :             : /* Implementation of state_machine::on_condition vfunc for malloc_state_machine.
    2474                 :             :    Potentially transition state 'unchecked' to 'nonnull' or to 'null'.  */
    2475                 :             : 
    2476                 :             : void
    2477                 :       30084 : malloc_state_machine::on_condition (sm_context &sm_ctxt,
    2478                 :             :                                     const supernode *node ATTRIBUTE_UNUSED,
    2479                 :             :                                     const gimple *stmt,
    2480                 :             :                                     const svalue *lhs,
    2481                 :             :                                     enum tree_code op,
    2482                 :             :                                     const svalue *rhs) const
    2483                 :             : {
    2484                 :       30084 :   if (!rhs->all_zeroes_p ())
    2485                 :             :     return;
    2486                 :             : 
    2487                 :       19398 :   if (!any_pointer_p (lhs))
    2488                 :             :     return;
    2489                 :        8183 :   if (!any_pointer_p (rhs))
    2490                 :             :     return;
    2491                 :             : 
    2492                 :        8183 :   if (op == NE_EXPR)
    2493                 :             :     {
    2494                 :        4486 :       log ("got 'ARG != 0' match");
    2495                 :        4486 :       state_t s = sm_ctxt.get_state (stmt, lhs);
    2496                 :        4486 :       if (unchecked_p (s))
    2497                 :             :         {
    2498                 :        1119 :           const allocation_state *astate = as_a_allocation_state (s);
    2499                 :        1119 :           sm_ctxt.set_next_state (stmt, lhs, astate->get_nonnull ());
    2500                 :             :         }
    2501                 :             :     }
    2502                 :        3697 :   else if (op == EQ_EXPR)
    2503                 :             :     {
    2504                 :        3697 :       log ("got 'ARG == 0' match");
    2505                 :        3697 :       state_t s = sm_ctxt.get_state (stmt, lhs);
    2506                 :        3697 :       if (unchecked_p (s))
    2507                 :        1102 :         sm_ctxt.set_next_state (stmt, lhs, m_null);
    2508                 :             :     }
    2509                 :             : }
    2510                 :             : 
    2511                 :             : /* Implementation of state_machine::on_pop_frame vfunc for malloc_state_machine.
    2512                 :             :    Clear any "assumed-non-null" state where the assumption happened in
    2513                 :             :    FRAME_REG.  */
    2514                 :             : 
    2515                 :             : void
    2516                 :       15960 : malloc_state_machine::on_pop_frame (sm_state_map *smap,
    2517                 :             :                                     const frame_region *frame_reg) const
    2518                 :             : {
    2519                 :       15960 :   hash_set<const svalue *> svals_to_clear;
    2520                 :       26533 :   for (auto kv : *smap)
    2521                 :             :     {
    2522                 :       10573 :       const svalue *sval = kv.first;
    2523                 :       10573 :       state_t state = kv.second.m_state;
    2524                 :       14766 :       if (assumed_non_null_p (state))
    2525                 :             :         {
    2526                 :        4193 :           const assumed_non_null_state *assumed_state
    2527                 :             :             = (const assumed_non_null_state *)state;
    2528                 :        4193 :           if (frame_reg == assumed_state->m_frame)
    2529                 :        2442 :             svals_to_clear.add (sval);
    2530                 :             :         }
    2531                 :             :     }
    2532                 :       34362 :   for (auto sval : svals_to_clear)
    2533                 :        2442 :     smap->clear_any_state (sval);
    2534                 :       15960 : }
    2535                 :             : 
    2536                 :             : /* Implementation of state_machine::can_purge_p vfunc for malloc_state_machine.
    2537                 :             :    Don't allow purging of pointers in state 'unchecked' or 'nonnull'
    2538                 :             :    (to avoid false leak reports).  */
    2539                 :             : 
    2540                 :             : bool
    2541                 :     1067583 : malloc_state_machine::can_purge_p (state_t s) const
    2542                 :             : {
    2543                 :     1067583 :   enum resource_state rs = get_rs (s);
    2544                 :     1067583 :   return rs != RS_UNCHECKED && rs != RS_NONNULL;
    2545                 :             : }
    2546                 :             : 
    2547                 :             : /* Implementation of state_machine::on_leak vfunc for malloc_state_machine
    2548                 :             :    (for complaining about leaks of pointers in state 'unchecked' and
    2549                 :             :    'nonnull').  */
    2550                 :             : 
    2551                 :             : std::unique_ptr<pending_diagnostic>
    2552                 :         955 : malloc_state_machine::on_leak (tree var) const
    2553                 :             : {
    2554                 :         955 :   return make_unique<malloc_leak> (*this, var);
    2555                 :             : }
    2556                 :             : 
    2557                 :             : /* Implementation of state_machine::reset_when_passed_to_unknown_fn_p vfunc
    2558                 :             :    for malloc_state_machine.  */
    2559                 :             : 
    2560                 :             : bool
    2561                 :       28932 : malloc_state_machine::reset_when_passed_to_unknown_fn_p (state_t s,
    2562                 :             :                                                          bool is_mutable) const
    2563                 :             : {
    2564                 :             :   /* An on-stack ptr doesn't stop being stack-allocated when passed to an
    2565                 :             :      unknown fn.  */
    2566                 :       28932 :   if (s == m_non_heap)
    2567                 :           0 :     return false;
    2568                 :             : 
    2569                 :             :   /* Otherwise, pointers passed as non-const can be freed.  */
    2570                 :             :   return is_mutable;
    2571                 :             : }
    2572                 :             : 
    2573                 :             : /* Implementation of state_machine::maybe_get_merged_states_nonequal vfunc
    2574                 :             :    for malloc_state_machine.
    2575                 :             : 
    2576                 :             :    Support discarding "assumed-non-null" states when merging with
    2577                 :             :    start state.  */
    2578                 :             : 
    2579                 :             : state_machine::state_t
    2580                 :      182611 : malloc_state_machine::maybe_get_merged_states_nonequal (state_t state_a,
    2581                 :             :                                                         state_t state_b) const
    2582                 :             : {
    2583                 :      182611 :   if (assumed_non_null_p (state_a) && state_b == m_start)
    2584                 :             :     return m_start;
    2585                 :      214201 :   if (state_a == m_start && assumed_non_null_p (state_b))
    2586                 :       17277 :     return m_start;
    2587                 :             :   return NULL;
    2588                 :             : }
    2589                 :             : 
    2590                 :             : /* Return true if calls to FNDECL are known to not affect this sm-state.  */
    2591                 :             : 
    2592                 :             : bool
    2593                 :       34620 : malloc_state_machine::unaffected_by_call_p (tree fndecl)
    2594                 :             : {
    2595                 :             :   /* A set of functions that are known to not affect allocation
    2596                 :             :      status, even if we haven't fully modelled the rest of their
    2597                 :             :      behavior yet.  */
    2598                 :       34620 :   static const char * const funcnames[] = {
    2599                 :             :     /* This array must be kept sorted.  */
    2600                 :             :     "strsep",
    2601                 :             :   };
    2602                 :       34620 :   const size_t count = ARRAY_SIZE (funcnames);
    2603                 :       34620 :   function_set fs (funcnames, count);
    2604                 :             : 
    2605                 :       34620 :   if (fs.contains_decl_p (fndecl))
    2606                 :             :     return true;
    2607                 :             : 
    2608                 :             :   return false;
    2609                 :             : }
    2610                 :             : 
    2611                 :             : /* Shared logic for handling GIMPLE_ASSIGNs and GIMPLE_PHIs that
    2612                 :             :    assign zero to LHS.  */
    2613                 :             : 
    2614                 :             : void
    2615                 :        3937 : malloc_state_machine::on_zero_assignment (sm_context &sm_ctxt,
    2616                 :             :                                           const gimple *stmt,
    2617                 :             :                                           tree lhs) const
    2618                 :             : {
    2619                 :        3937 :   state_t s = sm_ctxt.get_state (stmt, lhs);
    2620                 :        3937 :   enum resource_state rs = get_rs (s);
    2621                 :        3937 :   if (rs == RS_START
    2622                 :        3937 :       || rs == RS_UNCHECKED
    2623                 :             :       || rs == RS_NONNULL
    2624                 :         134 :       || rs == RS_FREED)
    2625                 :        3931 :     sm_ctxt.set_next_state (stmt, lhs, m_null);
    2626                 :        3937 : }
    2627                 :             : 
    2628                 :             : /* Special-case hook for handling realloc, for the "success with move to
    2629                 :             :    a new buffer" case, marking OLD_PTR_SVAL as freed and NEW_PTR_SVAL as
    2630                 :             :    non-null.
    2631                 :             : 
    2632                 :             :    This is similar to on_deallocator_call and on_allocator_call,
    2633                 :             :    but the checks happen in on_realloc_call, and by splitting the states.  */
    2634                 :             : 
    2635                 :             : void
    2636                 :         308 : malloc_state_machine::
    2637                 :             : on_realloc_with_move (region_model *model,
    2638                 :             :                       sm_state_map *smap,
    2639                 :             :                       const svalue *old_ptr_sval,
    2640                 :             :                       const svalue *new_ptr_sval,
    2641                 :             :                       const extrinsic_state &ext_state) const
    2642                 :             : {
    2643                 :         308 :   smap->set_state (model, old_ptr_sval,
    2644                 :         308 :                    m_free.m_deallocator.m_freed,
    2645                 :             :                    NULL, ext_state);
    2646                 :             : 
    2647                 :         308 :   smap->set_state (model, new_ptr_sval,
    2648                 :         308 :                    m_free.m_nonnull,
    2649                 :             :                    NULL, ext_state);
    2650                 :         308 : }
    2651                 :             : 
    2652                 :             : /*  Hook for get_or_create_region_for_heap_alloc for the case when we want
    2653                 :             :    ptr_sval to mark a newly created region as assumed non null on malloc SM.  */
    2654                 :             : void
    2655                 :           0 : malloc_state_machine::transition_ptr_sval_non_null (region_model *model,
    2656                 :             :     sm_state_map *smap,
    2657                 :             :     const svalue *new_ptr_sval,
    2658                 :             :     const extrinsic_state &ext_state) const
    2659                 :             : {
    2660                 :           0 :   smap->set_state (model, new_ptr_sval, m_free.m_nonnull, NULL, ext_state);
    2661                 :           0 : }
    2662                 :             : 
    2663                 :             : } // anonymous namespace
    2664                 :             : 
    2665                 :             : /* Internal interface to this file. */
    2666                 :             : 
    2667                 :             : state_machine *
    2668                 :        3209 : make_malloc_state_machine (logger *logger)
    2669                 :             : {
    2670                 :        3209 :   return new malloc_state_machine (logger);
    2671                 :             : }
    2672                 :             : 
    2673                 :             : /* Specialcase hook for handling realloc, for use by
    2674                 :             :    kf_realloc::impl_call_post::success_with_move::update_model.  */
    2675                 :             : 
    2676                 :             : void
    2677                 :         438 : region_model::on_realloc_with_move (const call_details &cd,
    2678                 :             :                                     const svalue *old_ptr_sval,
    2679                 :             :                                     const svalue *new_ptr_sval)
    2680                 :             : {
    2681                 :         438 :   region_model_context *ctxt = cd.get_ctxt ();
    2682                 :         438 :   if (!ctxt)
    2683                 :         130 :     return;
    2684                 :         310 :   const extrinsic_state *ext_state = ctxt->get_ext_state ();
    2685                 :         310 :   if (!ext_state)
    2686                 :             :     return;
    2687                 :             : 
    2688                 :         308 :   sm_state_map *smap;
    2689                 :         308 :   const state_machine *sm;
    2690                 :         308 :   unsigned sm_idx;
    2691                 :         308 :   if (!ctxt->get_malloc_map (&smap, &sm, &sm_idx))
    2692                 :             :     return;
    2693                 :             : 
    2694                 :         308 :   gcc_assert (smap);
    2695                 :         308 :   gcc_assert (sm);
    2696                 :             : 
    2697                 :         308 :   const malloc_state_machine &malloc_sm
    2698                 :             :     = (const malloc_state_machine &)*sm;
    2699                 :             : 
    2700                 :         308 :   malloc_sm.on_realloc_with_move (this,
    2701                 :             :                                   smap,
    2702                 :             :                                   old_ptr_sval,
    2703                 :             :                                   new_ptr_sval,
    2704                 :             :                                   *ext_state);
    2705                 :             : }
    2706                 :             : 
    2707                 :             : /* Moves ptr_sval from start to assumed non-null, for use by
    2708                 :             :    region_model::get_or_create_region_for_heap_alloc.  */
    2709                 :             : void
    2710                 :           0 : region_model::transition_ptr_sval_non_null (region_model_context *ctxt,
    2711                 :             : const svalue *ptr_sval)
    2712                 :             : {
    2713                 :           0 :   if (!ctxt)
    2714                 :           0 :     return;
    2715                 :           0 :   const extrinsic_state *ext_state = ctxt->get_ext_state ();
    2716                 :           0 :   if (!ext_state)
    2717                 :             :     return;
    2718                 :             : 
    2719                 :           0 :   sm_state_map *smap;
    2720                 :           0 :   const state_machine *sm;
    2721                 :           0 :   unsigned sm_idx;
    2722                 :           0 :   if (!ctxt->get_malloc_map (&smap, &sm, &sm_idx))
    2723                 :             :     return;
    2724                 :             : 
    2725                 :           0 :   gcc_assert (smap);
    2726                 :           0 :   gcc_assert (sm);
    2727                 :             : 
    2728                 :           0 :   const malloc_state_machine &malloc_sm = (const malloc_state_machine &)*sm;
    2729                 :             : 
    2730                 :           0 :   malloc_sm.transition_ptr_sval_non_null (this, smap, ptr_sval, *ext_state);
    2731                 :             : }
    2732                 :             : 
    2733                 :             : } // namespace ana
    2734                 :             : 
    2735                 :             : #endif /* #if ENABLE_ANALYZER */
        

Generated by: LCOV version 2.1-beta

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