LCOV - code coverage report
Current view: top level - gcc - gimple-ssa-warn-access.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 94.0 % 1915 1801
Test Date: 2024-11-02 13:25:42 Functions: 96.7 % 90 87
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : /* Pass to detect and issue warnings for invalid accesses, including
       2                 :             :    invalid or mismatched allocation/deallocation calls.
       3                 :             : 
       4                 :             :    Copyright (C) 2020-2024 Free Software Foundation, Inc.
       5                 :             :    Contributed by Martin Sebor <msebor@redhat.com>.
       6                 :             : 
       7                 :             :    This file is part of GCC.
       8                 :             : 
       9                 :             :    GCC is free software; you can redistribute it and/or modify it under
      10                 :             :    the terms of the GNU General Public License as published by the Free
      11                 :             :    Software Foundation; either version 3, or (at your option) any later
      12                 :             :    version.
      13                 :             : 
      14                 :             :    GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      15                 :             :    WARRANTY; without even the implied warranty of MERCHANTABILITY or
      16                 :             :    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      17                 :             :    for more details.
      18                 :             : 
      19                 :             :    You should have received a copy of the GNU General Public License
      20                 :             :    along with GCC; see the file COPYING3.  If not see
      21                 :             :    <http://www.gnu.org/licenses/>.  */
      22                 :             : 
      23                 :             : #define INCLUDE_MEMORY
      24                 :             : #define INCLUDE_STRING
      25                 :             : #include "config.h"
      26                 :             : #include "system.h"
      27                 :             : #include "coretypes.h"
      28                 :             : #include "backend.h"
      29                 :             : #include "tree.h"
      30                 :             : #include "gimple.h"
      31                 :             : #include "tree-pass.h"
      32                 :             : #include "builtins.h"
      33                 :             : #include "diagnostic.h"
      34                 :             : #include "ssa.h"
      35                 :             : #include "gimple-pretty-print.h"
      36                 :             : #include "gimple-ssa-warn-access.h"
      37                 :             : #include "gimple-ssa-warn-restrict.h"
      38                 :             : #include "diagnostic-core.h"
      39                 :             : #include "fold-const.h"
      40                 :             : #include "gimple-iterator.h"
      41                 :             : #include "gimple-fold.h"
      42                 :             : #include "langhooks.h"
      43                 :             : #include "memmodel.h"
      44                 :             : #include "target.h"
      45                 :             : #include "tree-dfa.h"
      46                 :             : #include "tree-ssa.h"
      47                 :             : #include "tree-cfg.h"
      48                 :             : #include "tree-object-size.h"
      49                 :             : #include "tree-ssa-strlen.h"
      50                 :             : #include "calls.h"
      51                 :             : #include "cfganal.h"
      52                 :             : #include "intl.h"
      53                 :             : #include "gimple-range.h"
      54                 :             : #include "stringpool.h"
      55                 :             : #include "attribs.h"
      56                 :             : #include "demangle.h"
      57                 :             : #include "attr-fnspec.h"
      58                 :             : #include "pointer-query.h"
      59                 :             : #include "pretty-print-markup.h"
      60                 :             : 
      61                 :             : /* Return true if tree node X has an associated location.  */
      62                 :             : 
      63                 :             : static inline location_t
      64                 :         109 : has_location (const_tree x)
      65                 :             : {
      66                 :         109 :   if (DECL_P (x))
      67                 :          84 :     return DECL_SOURCE_LOCATION (x) != UNKNOWN_LOCATION;
      68                 :             : 
      69                 :          25 :   if (EXPR_P (x))
      70                 :           0 :     return EXPR_HAS_LOCATION (x);
      71                 :             : 
      72                 :             :   return false;
      73                 :             : }
      74                 :             : 
      75                 :             : /* Return the associated location of STMT.  */
      76                 :             : 
      77                 :             : static inline location_t
      78                 :     2189114 : get_location (const gimple *stmt)
      79                 :             : {
      80                 :     1934631 :   return gimple_location (stmt);
      81                 :             : }
      82                 :             : 
      83                 :             : /* Return the associated location of tree node X.  */
      84                 :             : 
      85                 :             : static inline location_t
      86                 :        2036 : get_location (tree x)
      87                 :             : {
      88                 :        2036 :   if (DECL_P (x))
      89                 :         973 :     return DECL_SOURCE_LOCATION (x);
      90                 :             : 
      91                 :        1063 :   if (EXPR_P (x))
      92                 :        1063 :     return EXPR_LOCATION (x);
      93                 :             : 
      94                 :             :   return UNKNOWN_LOCATION;
      95                 :             : }
      96                 :             : 
      97                 :             : /* Overload of the nascent tree function for GIMPLE STMT.  */
      98                 :             : 
      99                 :             : static inline tree
     100                 :     1208524 : get_callee_fndecl (const gimple *stmt)
     101                 :             : {
     102                 :         632 :   return gimple_call_fndecl (stmt);
     103                 :             : }
     104                 :             : 
     105                 :             : static inline unsigned
     106                 :    32791322 : call_nargs (const gimple *stmt)
     107                 :             : {
     108                 :     2240005 :   return gimple_call_num_args (stmt);
     109                 :             : }
     110                 :             : 
     111                 :             : static inline unsigned
     112                 :         356 : call_nargs (const_tree expr)
     113                 :             : {
     114                 :         356 :   return call_expr_nargs (expr);
     115                 :             : }
     116                 :             : 
     117                 :             : 
     118                 :             : static inline tree
     119                 :    12850353 : call_arg (const gimple *stmt, unsigned argno)
     120                 :             : {
     121                 :     1342422 :   return gimple_call_arg (stmt, argno);
     122                 :             : }
     123                 :             : 
     124                 :             : static inline tree
     125                 :         302 : call_arg (tree expr, unsigned argno)
     126                 :             : {
     127                 :         302 :   return CALL_EXPR_ARG (expr, argno);
     128                 :             : }
     129                 :             : 
     130                 :             : /* For a call EXPR at LOC to a function FNAME that expects a string
     131                 :             :    in the argument ARG, issue a diagnostic due to it being a called
     132                 :             :    with an argument that is a character array with no terminating
     133                 :             :    NUL.  SIZE is the EXACT size of the array, and BNDRNG the number
     134                 :             :    of characters in which the NUL is expected.  Either EXPR or FNAME
     135                 :             :    may be null but noth both.  SIZE may be null when BNDRNG is null.  */
     136                 :             : 
     137                 :             : template <class GimpleOrTree>
     138                 :             : static void
     139                 :        8030 : warn_string_no_nul (location_t loc, GimpleOrTree expr, const char *fname,
     140                 :             :                     tree arg, tree decl, tree size, bool exact,
     141                 :             :                     const wide_int bndrng[2] /* = NULL */)
     142                 :             : {
     143                 :        8030 :   const opt_code opt = OPT_Wstringop_overread;
     144                 :        1399 :   if ((expr && warning_suppressed_p (expr, opt))
     145                 :        8843 :       || warning_suppressed_p (arg, opt))
     146                 :        1139 :     return;
     147                 :             : 
     148                 :        6891 :   loc = expansion_point_location_if_in_system_header (loc);
     149                 :             :   bool warned;
     150                 :             : 
     151                 :             :   /* Format the bound range as a string to keep the number of messages
     152                 :             :      from exploding.  */
     153                 :             :   char bndstr[80];
     154                 :        6891 :   *bndstr = 0;
     155                 :        6891 :   if (bndrng)
     156                 :             :     {
     157                 :         144 :       if (bndrng[0] == bndrng[1])
     158                 :         132 :         sprintf (bndstr, "%llu", (unsigned long long) bndrng[0].to_uhwi ());
     159                 :             :       else
     160                 :          12 :         sprintf (bndstr, "[%llu, %llu]",
     161                 :          12 :                  (unsigned long long) bndrng[0].to_uhwi (),
     162                 :          12 :                  (unsigned long long) bndrng[1].to_uhwi ());
     163                 :             :     }
     164                 :             : 
     165                 :        6891 :   auto_diagnostic_group d;
     166                 :             : 
     167                 :        6891 :   const tree maxobjsize = max_object_size ();
     168                 :        6891 :   const wide_int maxsiz = wi::to_wide (maxobjsize);
     169                 :        6891 :   if (expr)
     170                 :             :     {
     171                 :         774 :       tree func = get_callee_fndecl (expr);
     172                 :         774 :       if (bndrng)
     173                 :             :         {
     174                 :         144 :           if (wi::ltu_p (maxsiz, bndrng[0]))
     175                 :           0 :             warned = warning_at (loc, opt,
     176                 :             :                                  "%qD specified bound %s exceeds "
     177                 :             :                                  "maximum object size %E",
     178                 :             :                                  func, bndstr, maxobjsize);
     179                 :             :           else
     180                 :             :             {
     181                 :         144 :               bool maybe = wi::to_wide (size) == bndrng[0];
     182                 :         191 :               warned = warning_at (loc, opt,
     183                 :             :                                    exact
     184                 :             :                                    ? G_("%qD specified bound %s exceeds "
     185                 :             :                                         "the size %E of unterminated array")
     186                 :             :                                    : (maybe
     187                 :          47 :                                       ? G_("%qD specified bound %s may "
     188                 :             :                                            "exceed the size of at most %E "
     189                 :             :                                            "of unterminated array")
     190                 :             :                                       : G_("%qD specified bound %s exceeds "
     191                 :             :                                            "the size of at most %E "
     192                 :             :                                            "of unterminated array")),
     193                 :             :                                    func, bndstr, size);
     194                 :             :             }
     195                 :             :         }
     196                 :             :       else
     197                 :         630 :         warned = warning_at (loc, opt,
     198                 :             :                              "%qD argument missing terminating nul",
     199                 :             :                              func);
     200                 :             :     }
     201                 :             :   else
     202                 :             :     {
     203                 :        6117 :       if (bndrng)
     204                 :             :         {
     205                 :           0 :           if (wi::ltu_p (maxsiz, bndrng[0]))
     206                 :           0 :             warned = warning_at (loc, opt,
     207                 :             :                                  "%qs specified bound %s exceeds "
     208                 :             :                                  "maximum object size %E",
     209                 :             :                                  fname, bndstr, maxobjsize);
     210                 :             :           else
     211                 :             :             {
     212                 :           0 :               bool maybe = wi::to_wide (size) == bndrng[0];
     213                 :           0 :               warned = warning_at (loc, opt,
     214                 :             :                                    exact
     215                 :             :                                    ? G_("%qs specified bound %s exceeds "
     216                 :             :                                         "the size %E of unterminated array")
     217                 :             :                                    : (maybe
     218                 :           0 :                                       ? G_("%qs specified bound %s may "
     219                 :             :                                            "exceed the size of at most %E "
     220                 :             :                                            "of unterminated array")
     221                 :             :                                       : G_("%qs specified bound %s exceeds "
     222                 :             :                                            "the size of at most %E "
     223                 :             :                                            "of unterminated array")),
     224                 :             :                                    fname, bndstr, size);
     225                 :             :             }
     226                 :             :         }
     227                 :             :       else
     228                 :        6117 :         warned = warning_at (loc, opt,
     229                 :             :                              "%qs argument missing terminating nul",
     230                 :             :                              fname);
     231                 :             :     }
     232                 :             : 
     233                 :        6891 :   if (warned)
     234                 :             :     {
     235                 :         521 :       inform (get_location (decl),
     236                 :             :               "referenced argument declared here");
     237                 :         521 :       suppress_warning (arg, opt);
     238                 :         521 :       if (expr)
     239                 :         441 :         suppress_warning (expr, opt);
     240                 :             :     }
     241                 :        6891 : }
     242                 :             : 
     243                 :             : void
     244                 :         828 : warn_string_no_nul (location_t loc, gimple *stmt, const char *fname,
     245                 :             :                     tree arg, tree decl, tree size /* = NULL_TREE */,
     246                 :             :                     bool exact /* = false */,
     247                 :             :                     const wide_int bndrng[2] /* = NULL */)
     248                 :             : {
     249                 :         828 :   return warn_string_no_nul<gimple *> (loc, stmt, fname,
     250                 :         828 :                                        arg, decl, size, exact, bndrng);
     251                 :             : }
     252                 :             : 
     253                 :             : void
     254                 :        7173 : warn_string_no_nul (location_t loc, tree expr, const char *fname,
     255                 :             :                     tree arg, tree decl, tree size /* = NULL_TREE */,
     256                 :             :                     bool exact /* = false */,
     257                 :             :                     const wide_int bndrng[2] /* = NULL */)
     258                 :             : {
     259                 :        7173 :   return warn_string_no_nul<tree> (loc, expr, fname,
     260                 :        7173 :                                    arg, decl, size, exact, bndrng);
     261                 :             : }
     262                 :             : 
     263                 :             : /* If EXP refers to an unterminated constant character array return
     264                 :             :    the declaration of the object of which the array is a member or
     265                 :             :    element and if SIZE is not null, set *SIZE to the size of
     266                 :             :    the unterminated array and set *EXACT if the size is exact or
     267                 :             :    clear it otherwise.  Otherwise return null.  */
     268                 :             : 
     269                 :             : tree
     270                 :      694289 : unterminated_array (tree exp, tree *size /* = NULL */, bool *exact /* = NULL */)
     271                 :             : {
     272                 :             :   /* C_STRLEN will return NULL and set DECL in the info
     273                 :             :      structure if EXP references a unterminated array.  */
     274                 :      694289 :   c_strlen_data lendata = { };
     275                 :      694289 :   tree len = c_strlen (exp, 1, &lendata);
     276                 :      694289 :   if (len || !lendata.minlen || !lendata.decl)
     277                 :             :     return NULL_TREE;
     278                 :             : 
     279                 :        1842 :   if (!size)
     280                 :             :     return lendata.decl;
     281                 :             : 
     282                 :        1842 :   len = lendata.minlen;
     283                 :        1842 :   if (lendata.off)
     284                 :             :     {
     285                 :             :       /* Constant offsets are already accounted for in LENDATA.MINLEN,
     286                 :             :          but not in a SSA_NAME + CST expression.  */
     287                 :        1842 :       if (TREE_CODE (lendata.off) == INTEGER_CST)
     288                 :        1446 :         *exact = true;
     289                 :         396 :       else if (TREE_CODE (lendata.off) == PLUS_EXPR
     290                 :         396 :                && TREE_CODE (TREE_OPERAND (lendata.off, 1)) == INTEGER_CST)
     291                 :             :         {
     292                 :             :           /* Subtract the offset from the size of the array.  */
     293                 :         121 :           *exact = false;
     294                 :         121 :           tree temp = TREE_OPERAND (lendata.off, 1);
     295                 :         121 :           temp = fold_convert (ssizetype, temp);
     296                 :         121 :           len = fold_build2 (MINUS_EXPR, ssizetype, len, temp);
     297                 :             :         }
     298                 :             :       else
     299                 :         275 :         *exact = false;
     300                 :             :     }
     301                 :             :   else
     302                 :           0 :     *exact = true;
     303                 :             : 
     304                 :        1842 :   *size = len;
     305                 :        1842 :   return lendata.decl;
     306                 :             : }
     307                 :             : 
     308                 :             : /* For a call EXPR (which may be null) that expects a string argument
     309                 :             :    SRC as an argument, returns false if SRC is a character array with
     310                 :             :    no terminating NUL.  When nonnull, BOUND is the number of characters
     311                 :             :    in which to expect the terminating NUL.  When EXPR is nonnull also
     312                 :             :    issues a warning.  */
     313                 :             : 
     314                 :             : template <class GimpleOrTree>
     315                 :             : static bool
     316                 :      687524 : check_nul_terminated_array (GimpleOrTree expr, tree src, tree bound)
     317                 :             : {
     318                 :             :   /* The constant size of the array SRC points to.  The actual size
     319                 :             :      may be less of EXACT is true, but not more.  */
     320                 :             :   tree size;
     321                 :             :   /* True if SRC involves a non-constant offset into the array.  */
     322                 :             :   bool exact;
     323                 :             :   /* The unterminated constant array SRC points to.  */
     324                 :      687524 :   tree nonstr = unterminated_array (src, &size, &exact);
     325                 :      687524 :   if (!nonstr)
     326                 :             :     return true;
     327                 :             : 
     328                 :             :   /* NONSTR refers to the non-nul terminated constant array and SIZE
     329                 :             :      is the constant size of the array in bytes.  EXACT is true when
     330                 :             :      SIZE is exact.  */
     331                 :             : 
     332                 :        5025 :   wide_int bndrng[2];
     333                 :        1005 :   if (bound)
     334                 :             :     {
     335                 :         339 :       int_range_max r (TREE_TYPE (bound));
     336                 :             : 
     337                 :         678 :       get_range_query (cfun)->range_of_expr (r, bound);
     338                 :             : 
     339                 :         339 :       if (r.undefined_p () || r.varying_p ())
     340                 :             :         return true;
     341                 :             : 
     342                 :         338 :       bndrng[0] = r.lower_bound ();
     343                 :         338 :       bndrng[1] = r.upper_bound ();
     344                 :             : 
     345                 :         338 :       if (exact)
     346                 :             :         {
     347                 :         188 :           if (wi::leu_p (bndrng[0], wi::to_wide (size)))
     348                 :             :             return true;
     349                 :             :         }
     350                 :         150 :       else if (wi::lt_p (bndrng[0], wi::to_wide (size), UNSIGNED))
     351                 :             :         return true;
     352                 :         339 :     }
     353                 :             : 
     354                 :         813 :   if (expr)
     355                 :        1077 :     warn_string_no_nul (get_location (expr), expr, NULL, src, nonstr,
     356                 :             :                         size, exact, bound ? bndrng : NULL);
     357                 :             : 
     358                 :             :   return false;
     359                 :        3015 : }
     360                 :             : 
     361                 :             : bool
     362                 :      397773 : check_nul_terminated_array (gimple *stmt, tree src, tree bound /* = NULL_TREE */)
     363                 :             : {
     364                 :      397773 :   return check_nul_terminated_array<gimple *>(stmt, src, bound);
     365                 :             : }
     366                 :             : 
     367                 :             : bool
     368                 :      278453 : check_nul_terminated_array (tree expr, tree src, tree bound /* = NULL_TREE */)
     369                 :             : {
     370                 :      278453 :   return check_nul_terminated_array<tree>(expr, src, bound);
     371                 :             : }
     372                 :             : 
     373                 :             : /* Warn about passing a non-string array/pointer to a built-in function
     374                 :             :    that expects a nul-terminated string argument.  Returns true if
     375                 :             :    a warning has been issued.*/
     376                 :             : 
     377                 :             : template <class GimpleOrTree>
     378                 :             : static bool
     379                 :     7098795 : maybe_warn_nonstring_arg (tree fndecl, GimpleOrTree exp)
     380                 :             : {
     381                 :     7098795 :   if (!fndecl || !fndecl_built_in_p (fndecl, BUILT_IN_NORMAL))
     382                 :             :     return false;
     383                 :             : 
     384                 :     2251815 :   if (!warn_stringop_overread
     385                 :     2251815 :       || warning_suppressed_p (exp, OPT_Wstringop_overread))
     386                 :       11454 :     return false;
     387                 :             : 
     388                 :             :   /* Avoid clearly invalid calls (more checking done below).  */
     389                 :     2240361 :   unsigned nargs = call_nargs (exp);
     390                 :     2240361 :   if (!nargs)
     391                 :             :     return false;
     392                 :             : 
     393                 :             :   /* The bound argument to a bounded string function like strncpy.  */
     394                 :     1934294 :   tree bound = NULL_TREE;
     395                 :             : 
     396                 :             :   /* The longest known or possible string argument to one of the comparison
     397                 :             :      functions.  If the length is less than the bound it is used instead.
     398                 :             :      Since the length is only used for warning and not for code generation
     399                 :             :      disable strict mode in the calls to get_range_strlen below.  */
     400                 :     1934294 :   tree maxlen = NULL_TREE;
     401                 :             : 
     402                 :             :   /* It's safe to call "bounded" string functions with a non-string
     403                 :             :      argument since the functions provide an explicit bound for this
     404                 :             :      purpose.  The exception is strncat where the bound may refer to
     405                 :             :      either the destination or the source.  */
     406                 :     1934294 :   int fncode = DECL_FUNCTION_CODE (fndecl);
     407                 :     1934294 :   switch (fncode)
     408                 :             :     {
     409                 :             :     case BUILT_IN_STRCMP:
     410                 :             :     case BUILT_IN_STRNCMP:
     411                 :             :     case BUILT_IN_STRNCASECMP:
     412                 :             :       {
     413                 :             :         /* For these, if one argument refers to one or more of a set
     414                 :             :            of string constants or arrays of known size, determine
     415                 :             :            the range of their known or possible lengths and use it
     416                 :             :            conservatively as the bound for the unbounded function,
     417                 :             :            and to adjust the range of the bound of the bounded ones.  */
     418                 :      390437 :         for (unsigned argno = 0;
     419                 :      780400 :              argno < MIN (nargs, 2)
     420                 :      780400 :                && !(maxlen && TREE_CODE (maxlen) == INTEGER_CST); argno++)
     421                 :             :           {
     422                 :      390437 :             tree arg = call_arg (exp, argno);
     423                 :      390437 :             if (!get_attr_nonstring_decl (arg))
     424                 :             :               {
     425                 :      389945 :                 c_strlen_data lendata = { };
     426                 :             :                 /* Set MAXBOUND to an arbitrary non-null non-integer
     427                 :             :                    node as a request to have it set to the length of
     428                 :             :                    the longest string in a PHI.  */
     429                 :      389945 :                 lendata.maxbound = arg;
     430                 :      389945 :                 get_range_strlen (arg, &lendata, /* eltsize = */ 1);
     431                 :      389945 :                 maxlen = lendata.maxbound;
     432                 :             :               }
     433                 :             :           }
     434                 :             :       }
     435                 :             :       /* Fall through.  */
     436                 :             : 
     437                 :             :     case BUILT_IN_STRNCAT:
     438                 :             :     case BUILT_IN_STPNCPY:
     439                 :             :     case BUILT_IN_STRNCPY:
     440                 :      394850 :       if (nargs > 2)
     441                 :        9712 :         bound = call_arg (exp, 2);
     442                 :             :       break;
     443                 :             : 
     444                 :         549 :     case BUILT_IN_STRNDUP:
     445                 :         549 :       if (nargs < 2)
     446                 :             :         return false;
     447                 :         549 :       bound = call_arg (exp, 1);
     448                 :         549 :       break;
     449                 :             : 
     450                 :        1396 :     case BUILT_IN_STRNLEN:
     451                 :             :       {
     452                 :        1396 :         tree arg = call_arg (exp, 0);
     453                 :        1396 :         if (!get_attr_nonstring_decl (arg))
     454                 :             :           {
     455                 :        1294 :             c_strlen_data lendata = { };
     456                 :             :             /* Set MAXBOUND to an arbitrary non-null non-integer
     457                 :             :                node as a request to have it set to the length of
     458                 :             :                the longest string in a PHI.  */
     459                 :        1294 :             lendata.maxbound = arg;
     460                 :        1294 :             get_range_strlen (arg, &lendata, /* eltsize = */ 1);
     461                 :        1294 :             maxlen = lendata.maxbound;
     462                 :             :           }
     463                 :        1396 :         if (nargs > 1)
     464                 :        1395 :           bound = call_arg (exp, 1);
     465                 :             :         break;
     466                 :             :       }
     467                 :             : 
     468                 :             :     default:
     469                 :             :       break;
     470                 :             :     }
     471                 :             : 
     472                 :             :   /* Determine the range of the bound argument (if specified).  */
     473                 :     1934294 :   tree bndrng[2] = { NULL_TREE, NULL_TREE };
     474                 :     1934294 :   if (bound)
     475                 :             :     {
     476                 :       11656 :       STRIP_NOPS (bound);
     477                 :       11656 :       get_size_range (bound, bndrng);
     478                 :             :     }
     479                 :             : 
     480                 :     1934294 :   location_t loc = get_location (exp);
     481                 :             : 
     482                 :     1934294 :   if (bndrng[0])
     483                 :             :     {
     484                 :             :       /* Diagnose excessive bound prior to the adjustment below and
     485                 :             :          regardless of attribute nonstring.  */
     486                 :       11636 :       tree maxobjsize = max_object_size ();
     487                 :       11636 :       if (tree_int_cst_lt (maxobjsize, bndrng[0]))
     488                 :             :         {
     489                 :         131 :           bool warned = false;
     490                 :         131 :           if (tree_int_cst_equal (bndrng[0], bndrng[1]))
     491                 :         114 :             warned = warning_at (loc, OPT_Wstringop_overread,
     492                 :             :                                  "%qD specified bound %E "
     493                 :             :                                  "exceeds maximum object size %E",
     494                 :             :                                  fndecl, bndrng[0], maxobjsize);
     495                 :             :           else
     496                 :          17 :             warned = warning_at (loc, OPT_Wstringop_overread,
     497                 :             :                                  "%qD specified bound [%E, %E] "
     498                 :             :                                  "exceeds maximum object size %E",
     499                 :             :                                  fndecl, bndrng[0], bndrng[1],
     500                 :             :                                  maxobjsize);
     501                 :         131 :           if (warned)
     502                 :          45 :             suppress_warning (exp, OPT_Wstringop_overread);
     503                 :             : 
     504                 :         131 :           return warned;
     505                 :             :         }
     506                 :             :     }
     507                 :             : 
     508                 :     1934163 :   if (maxlen && !integer_all_onesp (maxlen))
     509                 :             :     {
     510                 :             :       /* Add one for the nul.  */
     511                 :        6441 :       maxlen = const_binop (PLUS_EXPR, TREE_TYPE (maxlen), maxlen,
     512                 :             :                             size_one_node);
     513                 :             : 
     514                 :        6441 :       if (!bndrng[0])
     515                 :             :         {
     516                 :             :           /* Conservatively use the upper bound of the lengths for
     517                 :             :              both the lower and the upper bound of the operation.  */
     518                 :        4581 :           bndrng[0] = maxlen;
     519                 :        4581 :           bndrng[1] = maxlen;
     520                 :        4581 :           bound = void_type_node;
     521                 :             :         }
     522                 :        1860 :       else if (maxlen)
     523                 :             :         {
     524                 :             :           /* Replace the bound on the operation with the upper bound
     525                 :             :              of the length of the string if the latter is smaller.  */
     526                 :        1851 :           if (tree_int_cst_lt (maxlen, bndrng[0]))
     527                 :         188 :             bndrng[0] = maxlen;
     528                 :        1663 :           else if (tree_int_cst_lt (maxlen, bndrng[1]))
     529                 :         383 :             bndrng[1] = maxlen;
     530                 :             :         }
     531                 :             :     }
     532                 :             : 
     533                 :     1934163 :   bool any_arg_warned = false;
     534                 :             :   /* Iterate over the built-in function's formal arguments and check
     535                 :             :      each const char* against the actual argument.  If the actual
     536                 :             :      argument is declared attribute non-string issue a warning unless
     537                 :             :      the argument's maximum length is bounded.  */
     538                 :             :   function_args_iterator it;
     539                 :     1934163 :   function_args_iter_init (&it, TREE_TYPE (fndecl));
     540                 :             : 
     541                 :     6250016 :   for (unsigned argno = 0; ; ++argno, function_args_iter_next (&it))
     542                 :             :     {
     543                 :             :       /* Avoid iterating past the declared argument in a call
     544                 :             :          to function declared without a prototype.  */
     545                 :     6248478 :       if (argno >= nargs)
     546                 :             :         break;
     547                 :             : 
     548                 :     4453829 :       tree argtype = function_args_iter_cond (&it);
     549                 :     4453829 :       if (!argtype)
     550                 :             :         break;
     551                 :             : 
     552                 :     4314315 :       if (TREE_CODE (argtype) != POINTER_TYPE)
     553                 :     4312777 :         continue;
     554                 :             : 
     555                 :     2653576 :       argtype = TREE_TYPE (argtype);
     556                 :             : 
     557                 :     4343492 :       if (TREE_CODE (argtype) != INTEGER_TYPE
     558                 :     2653576 :           || !TYPE_READONLY (argtype))
     559                 :     1689916 :         continue;
     560                 :             : 
     561                 :      963660 :       argtype = TYPE_MAIN_VARIANT (argtype);
     562                 :      963660 :       if (argtype != char_type_node)
     563                 :       11617 :         continue;
     564                 :             : 
     565                 :      952043 :       tree callarg = call_arg (exp, argno);
     566                 :      952043 :       if (TREE_CODE (callarg) == ADDR_EXPR)
     567                 :      518656 :         callarg = TREE_OPERAND (callarg, 0);
     568                 :             : 
     569                 :             :       /* See if the destination is declared with attribute "nonstring".  */
     570                 :      952043 :       tree decl = get_attr_nonstring_decl (callarg);
     571                 :      952043 :       if (!decl)
     572                 :      950505 :         continue;
     573                 :             : 
     574                 :             :       /* The maximum number of array elements accessed.  */
     575                 :        1538 :       offset_int wibnd = 0;
     576                 :             : 
     577                 :        1538 :       if (argno && fncode == BUILT_IN_STRNCAT)
     578                 :             :         {
     579                 :             :           /* See if the bound in strncat is derived from the length
     580                 :             :              of the strlen of the destination (as it's expected to be).
     581                 :             :              If so, reset BOUND and FNCODE to trigger a warning.  */
     582                 :         244 :           tree dstarg = call_arg (exp, 0);
     583                 :         244 :           if (is_strlen_related_p (dstarg, bound))
     584                 :             :             {
     585                 :             :               /* The bound applies to the destination, not to the source,
     586                 :             :                  so reset these to trigger a warning without mentioning
     587                 :             :                  the bound.  */
     588                 :             :               bound = NULL;
     589                 :             :               fncode = 0;
     590                 :             :             }
     591                 :         240 :           else if (bndrng[1])
     592                 :             :             /* Use the upper bound of the range for strncat.  */
     593                 :         240 :             wibnd = wi::to_offset (bndrng[1]);
     594                 :             :         }
     595                 :        1294 :       else if (bndrng[0])
     596                 :             :         /* Use the lower bound of the range for functions other than
     597                 :             :            strncat.  */
     598                 :        1058 :         wibnd = wi::to_offset (bndrng[0]);
     599                 :             : 
     600                 :             :       /* Determine the size of the argument array if it is one.  */
     601                 :        1538 :       offset_int asize = wibnd;
     602                 :        1538 :       bool known_size = false;
     603                 :        1538 :       tree type = TREE_TYPE (decl);
     604                 :             : 
     605                 :             :       /* Determine the array size.  For arrays of unknown bound and
     606                 :             :          pointers reset BOUND to trigger the appropriate warning.  */
     607                 :        1538 :       if (TREE_CODE (type) == ARRAY_TYPE)
     608                 :             :         {
     609                 :        1298 :           if (tree arrbnd = TYPE_DOMAIN (type))
     610                 :             :             {
     611                 :        1236 :               if ((arrbnd = TYPE_MAX_VALUE (arrbnd))
     612                 :        1236 :                   && TREE_CODE (arrbnd) == INTEGER_CST)
     613                 :             :                 {
     614                 :        1234 :                   asize = wi::to_offset (arrbnd) + 1;
     615                 :        1234 :                   known_size = true;
     616                 :             :                 }
     617                 :             :             }
     618                 :          62 :           else if (bound == void_type_node)
     619                 :        1538 :             bound = NULL_TREE;
     620                 :             :         }
     621                 :         240 :       else if (bound == void_type_node)
     622                 :        1538 :         bound = NULL_TREE;
     623                 :             : 
     624                 :             :       /* In a call to strncat with a bound in a range whose lower but
     625                 :             :          not upper bound is less than the array size, reset ASIZE to
     626                 :             :          be the same as the bound and the other variable to trigger
     627                 :             :          the appropriate warning below.  */
     628                 :             :       if (fncode == BUILT_IN_STRNCAT
     629                 :         240 :           && bndrng[0] != bndrng[1]
     630                 :        1618 :           && wi::ltu_p (wi::to_offset (bndrng[0]), asize)
     631                 :        1634 :           && (!known_size
     632                 :          92 :               || wi::ltu_p (asize, wibnd)))
     633                 :             :         {
     634                 :          16 :           asize = wibnd;
     635                 :          16 :           bound = NULL_TREE;
     636                 :          16 :           fncode = 0;
     637                 :             :         }
     638                 :             : 
     639                 :        1538 :       bool warned = false;
     640                 :             : 
     641                 :        1538 :       auto_diagnostic_group d;
     642                 :        1538 :       if (wi::ltu_p (asize, wibnd))
     643                 :             :         {
     644                 :         193 :           if (bndrng[0] == bndrng[1])
     645                 :         160 :             warned = warning_at (loc, OPT_Wstringop_overread,
     646                 :             :                                  "%qD argument %i declared attribute "
     647                 :             :                                  "%<nonstring%> is smaller than the specified "
     648                 :             :                                  "bound %wu",
     649                 :             :                                  fndecl, argno + 1, wibnd.to_uhwi ());
     650                 :          33 :           else if (wi::ltu_p (asize, wi::to_offset (bndrng[0])))
     651                 :          25 :             warned = warning_at (loc, OPT_Wstringop_overread,
     652                 :             :                                  "%qD argument %i declared attribute "
     653                 :             :                                  "%<nonstring%> is smaller than "
     654                 :             :                                  "the specified bound [%E, %E]",
     655                 :             :                                  fndecl, argno + 1, bndrng[0], bndrng[1]);
     656                 :             :           else
     657                 :           8 :             warned = warning_at (loc, OPT_Wstringop_overread,
     658                 :             :                                  "%qD argument %i declared attribute "
     659                 :             :                                  "%<nonstring%> may be smaller than "
     660                 :             :                                  "the specified bound [%E, %E]",
     661                 :             :                                  fndecl, argno + 1, bndrng[0], bndrng[1]);
     662                 :             :         }
     663                 :        1345 :       else if (fncode == BUILT_IN_STRNCAT)
     664                 :             :         ; /* Avoid warning for calls to strncat() when the bound
     665                 :             :              is equal to the size of the non-string argument.  */
     666                 :        1141 :       else if (!bound)
     667                 :         276 :         warned = warning_at (loc, OPT_Wstringop_overread,
     668                 :             :                              "%qD argument %i declared attribute %<nonstring%>",
     669                 :             :                              fndecl, argno + 1);
     670                 :             : 
     671                 :         469 :       if (warned)
     672                 :             :         {
     673                 :         469 :           inform (DECL_SOURCE_LOCATION (decl),
     674                 :             :                   "argument %qD declared here", decl);
     675                 :         469 :           any_arg_warned = true;
     676                 :             :         }
     677                 :             :     }
     678                 :             : 
     679                 :     1934163 :   if (any_arg_warned)
     680                 :         469 :     suppress_warning (exp, OPT_Wstringop_overread);
     681                 :             : 
     682                 :             :   return any_arg_warned;
     683                 :             : }
     684                 :             : 
     685                 :             : bool
     686                 :      511328 : maybe_warn_nonstring_arg (tree fndecl, gimple *stmt)
     687                 :             : {
     688                 :      511328 :   return maybe_warn_nonstring_arg<gimple *>(fndecl, stmt);
     689                 :             : }
     690                 :             : 
     691                 :             : 
     692                 :             : bool
     693                 :         356 : maybe_warn_nonstring_arg (tree fndecl, tree expr)
     694                 :             : {
     695                 :         356 :   return maybe_warn_nonstring_arg<tree>(fndecl, expr);
     696                 :             : }
     697                 :             : 
     698                 :             : /* Issue a warning OPT for a bounded call EXP with a bound in RANGE
     699                 :             :    accessing an object with SIZE.  */
     700                 :             : 
     701                 :             : template <class GimpleOrTree>
     702                 :             : static bool
     703                 :         438 : maybe_warn_for_bound (opt_code opt, location_t loc, GimpleOrTree exp, tree func,
     704                 :             :                       tree bndrng[2], tree size, const access_data *pad)
     705                 :             : {
     706                 :         438 :   if (!bndrng[0] || warning_suppressed_p (exp, opt))
     707                 :          82 :     return false;
     708                 :             : 
     709                 :         356 :   tree maxobjsize = max_object_size ();
     710                 :             : 
     711                 :         356 :   bool warned = false;
     712                 :             : 
     713                 :         356 :   if (opt == OPT_Wstringop_overread)
     714                 :             :     {
     715                 :         162 :       bool maybe = pad && pad->src.phi ();
     716                 :             :       if (maybe)
     717                 :             :         {
     718                 :             :           /* Issue a "maybe" warning only if the PHI refers to objects
     719                 :             :              at least one of which has more space remaining than the bound.
     720                 :             :              Otherwise, if the bound is greater, use the definitive form.  */
     721                 :           2 :           offset_int remmax = pad->src.size_remaining ();
     722                 :           2 :           if (remmax < wi::to_offset (bndrng[0]))
     723                 :           2 :             maybe = false;
     724                 :             :         }
     725                 :             : 
     726                 :         162 :       auto_diagnostic_group d;
     727                 :         162 :       if (tree_int_cst_lt (maxobjsize, bndrng[0]))
     728                 :             :         {
     729                 :          75 :           if (bndrng[0] == bndrng[1])
     730                 :          73 :             warned = (func
     731                 :         146 :                       ? warning_at (loc, opt,
     732                 :             :                                     (maybe
     733                 :             :                                      ? G_("%qD specified bound %E may "
     734                 :             :                                           "exceed maximum object size %E")
     735                 :             :                                      : G_("%qD specified bound %E "
     736                 :             :                                           "exceeds maximum object size %E")),
     737                 :             :                                     func, bndrng[0], maxobjsize)
     738                 :          73 :                       : warning_at (loc, opt,
     739                 :             :                                     (maybe
     740                 :             :                                      ? G_("specified bound %E may "
     741                 :             :                                           "exceed maximum object size %E")
     742                 :             :                                      : G_("specified bound %E "
     743                 :             :                                           "exceeds maximum object size %E")),
     744                 :             :                                     bndrng[0], maxobjsize));
     745                 :             :           else
     746                 :           2 :             warned = (func
     747                 :           4 :                       ? warning_at (loc, opt,
     748                 :             :                                     (maybe
     749                 :             :                                      ? G_("%qD specified bound [%E, %E] may "
     750                 :             :                                           "exceed maximum object size %E")
     751                 :             :                                      : G_("%qD specified bound [%E, %E] "
     752                 :             :                                           "exceeds maximum object size %E")),
     753                 :             :                                     func,
     754                 :             :                                     bndrng[0], bndrng[1], maxobjsize)
     755                 :           2 :                       : warning_at (loc, opt,
     756                 :             :                                     (maybe
     757                 :             :                                      ? G_("specified bound [%E, %E] may "
     758                 :             :                                           "exceed maximum object size %E")
     759                 :             :                                      : G_("specified bound [%E, %E] "
     760                 :             :                                           "exceeds maximum object size %E")),
     761                 :             :                                     bndrng[0], bndrng[1], maxobjsize));
     762                 :             :         }
     763                 :          87 :       else if (!size || tree_int_cst_le (bndrng[0], size))
     764                 :           4 :         return false;
     765                 :          83 :       else if (tree_int_cst_equal (bndrng[0], bndrng[1]))
     766                 :          73 :         warned = (func
     767                 :         146 :                   ? warning_at (loc, opt,
     768                 :             :                                 (maybe
     769                 :             :                                  ? G_("%qD specified bound %E may exceed "
     770                 :             :                                       "source size %E")
     771                 :             :                                  : G_("%qD specified bound %E exceeds "
     772                 :             :                                       "source size %E")),
     773                 :             :                                 func, bndrng[0], size)
     774                 :          73 :                   : warning_at (loc, opt,
     775                 :             :                                 (maybe
     776                 :             :                                  ? G_("specified bound %E may exceed "
     777                 :             :                                       "source size %E")
     778                 :             :                                  : G_("specified bound %E exceeds "
     779                 :             :                                       "source size %E")),
     780                 :             :                                 bndrng[0], size));
     781                 :             :       else
     782                 :          10 :         warned = (func
     783                 :          20 :                   ? warning_at (loc, opt,
     784                 :             :                                 (maybe
     785                 :             :                                  ? G_("%qD specified bound [%E, %E] may "
     786                 :             :                                       "exceed source size %E")
     787                 :             :                                  : G_("%qD specified bound [%E, %E] exceeds "
     788                 :             :                                       "source size %E")),
     789                 :             :                                 func, bndrng[0], bndrng[1], size)
     790                 :          10 :                   : warning_at (loc, opt,
     791                 :             :                                 (maybe
     792                 :             :                                  ? G_("specified bound [%E, %E] may exceed "
     793                 :             :                                       "source size %E")
     794                 :             :                                  : G_("specified bound [%E, %E] exceeds "
     795                 :             :                                       "source size %E")),
     796                 :             :                                 bndrng[0], bndrng[1], size));
     797                 :         158 :       if (warned)
     798                 :             :         {
     799                 :          77 :           if (pad && pad->src.ref
     800                 :         150 :               && has_location (pad->src.ref))
     801                 :          49 :             inform (get_location (pad->src.ref),
     802                 :             :                     "source object allocated here");
     803                 :          78 :           suppress_warning (exp, opt);
     804                 :             :         }
     805                 :             : 
     806                 :         158 :       return warned;
     807                 :         162 :     }
     808                 :             : 
     809                 :         194 :   bool maybe = pad && pad->dst.phi ();
     810                 :             :   if (maybe)
     811                 :             :     {
     812                 :             :       /* Issue a "maybe" warning only if the PHI refers to objects
     813                 :             :          at least one of which has more space remaining than the bound.
     814                 :             :          Otherwise, if the bound is greater, use the definitive form.  */
     815                 :           5 :       offset_int remmax = pad->dst.size_remaining ();
     816                 :           5 :       if (remmax < wi::to_offset (bndrng[0]))
     817                 :           5 :         maybe = false;
     818                 :             :     }
     819                 :         194 :   if (tree_int_cst_lt (maxobjsize, bndrng[0]))
     820                 :             :     {
     821                 :          91 :       if (bndrng[0] == bndrng[1])
     822                 :          79 :         warned = (func
     823                 :         158 :                   ? warning_at (loc, opt,
     824                 :             :                                 (maybe
     825                 :             :                                  ? G_("%qD specified size %E may "
     826                 :             :                                       "exceed maximum object size %E")
     827                 :             :                                  : G_("%qD specified size %E "
     828                 :             :                                       "exceeds maximum object size %E")),
     829                 :             :                                 func, bndrng[0], maxobjsize)
     830                 :          79 :                   : warning_at (loc, opt,
     831                 :             :                                 (maybe
     832                 :             :                                  ? G_("specified size %E may exceed "
     833                 :             :                                       "maximum object size %E")
     834                 :             :                                  : G_("specified size %E exceeds "
     835                 :             :                                       "maximum object size %E")),
     836                 :             :                                 bndrng[0], maxobjsize));
     837                 :             :       else
     838                 :          12 :         warned = (func
     839                 :          24 :                   ? warning_at (loc, opt,
     840                 :             :                                 (maybe
     841                 :             :                                  ? G_("%qD specified size between %E and %E "
     842                 :             :                                       "may exceed maximum object size %E")
     843                 :             :                                  : G_("%qD specified size between %E and %E "
     844                 :             :                                       "exceeds maximum object size %E")),
     845                 :             :                                 func, bndrng[0], bndrng[1], maxobjsize)
     846                 :          12 :                   : warning_at (loc, opt,
     847                 :             :                                 (maybe
     848                 :             :                                  ? G_("specified size between %E and %E "
     849                 :             :                                       "may exceed maximum object size %E")
     850                 :             :                                  : G_("specified size between %E and %E "
     851                 :             :                                       "exceeds maximum object size %E")),
     852                 :             :                                 bndrng[0], bndrng[1], maxobjsize));
     853                 :             :     }
     854                 :         103 :   else if (!size || tree_int_cst_le (bndrng[0], size))
     855                 :           0 :     return false;
     856                 :         103 :   else if (tree_int_cst_equal (bndrng[0], bndrng[1]))
     857                 :          98 :     warned = (func
     858                 :         196 :               ? warning_at (loc, opt,
     859                 :             :                             (maybe
     860                 :             :                              ? G_("%qD specified bound %E may exceed "
     861                 :             :                                   "destination size %E")
     862                 :             :                              : G_("%qD specified bound %E exceeds "
     863                 :             :                                   "destination size %E")),
     864                 :             :                             func, bndrng[0], size)
     865                 :          98 :               : warning_at (loc, opt,
     866                 :             :                             (maybe
     867                 :             :                              ? G_("specified bound %E may exceed "
     868                 :             :                                   "destination size %E")
     869                 :             :                              : G_("specified bound %E exceeds "
     870                 :             :                                   "destination size %E")),
     871                 :             :                             bndrng[0], size));
     872                 :             :   else
     873                 :           5 :     warned = (func
     874                 :          10 :               ? warning_at (loc, opt,
     875                 :             :                             (maybe
     876                 :             :                              ? G_("%qD specified bound [%E, %E] may exceed "
     877                 :             :                                   "destination size %E")
     878                 :             :                              : G_("%qD specified bound [%E, %E] exceeds "
     879                 :             :                                   "destination size %E")),
     880                 :             :                             func, bndrng[0], bndrng[1], size)
     881                 :           5 :               : warning_at (loc, opt,
     882                 :             :                             (maybe
     883                 :             :                              ? G_("specified bound [%E, %E] exceeds "
     884                 :             :                                   "destination size %E")
     885                 :             :                              : G_("specified bound [%E, %E] exceeds "
     886                 :             :                                   "destination size %E")),
     887                 :             :                             bndrng[0], bndrng[1], size));
     888                 :             : 
     889                 :         194 :   if (warned)
     890                 :             :     {
     891                 :          40 :       if (pad && pad->dst.ref
     892                 :          81 :           && has_location (pad->dst.ref))
     893                 :          35 :         inform (get_location (pad->dst.ref),
     894                 :             :                 "destination object allocated here");
     895                 :          44 :       suppress_warning (exp, opt);
     896                 :             :     }
     897                 :             : 
     898                 :             :   return warned;
     899                 :             : }
     900                 :             : 
     901                 :             : bool
     902                 :         259 : maybe_warn_for_bound (opt_code opt, location_t loc, gimple *stmt, tree func,
     903                 :             :                       tree bndrng[2], tree size,
     904                 :             :                       const access_data *pad /* = NULL */)
     905                 :             : {
     906                 :         259 :   return maybe_warn_for_bound<gimple *> (opt, loc, stmt, func, bndrng, size,
     907                 :         259 :                                          pad);
     908                 :             : }
     909                 :             : 
     910                 :             : bool
     911                 :          73 : maybe_warn_for_bound (opt_code opt, location_t loc, tree expr, tree func,
     912                 :             :                       tree bndrng[2], tree size,
     913                 :             :                       const access_data *pad /* = NULL */)
     914                 :             : {
     915                 :          73 :   return maybe_warn_for_bound<tree> (opt, loc, expr, func, bndrng, size, pad);
     916                 :             : }
     917                 :             : 
     918                 :             : /* For an expression EXP issue an access warning controlled by option OPT
     919                 :             :    with access to a region SIZE bytes in size in the RANGE of sizes.
     920                 :             :    WRITE is true for a write access, READ for a read access, neither for
     921                 :             :    call that may or may not perform an access but for which the range
     922                 :             :    is expected to valid.
     923                 :             :    Returns true when a warning has been issued.  */
     924                 :             : 
     925                 :             : template <class GimpleOrTree>
     926                 :             : static bool
     927                 :        1883 : warn_for_access (location_t loc, tree func, GimpleOrTree exp, int opt,
     928                 :             :                  tree range[2], tree size, bool write, bool read, bool maybe)
     929                 :             : {
     930                 :        1883 :   bool warned = false;
     931                 :             : 
     932                 :        1883 :   if (write && read)
     933                 :             :     {
     934                 :         138 :       if (tree_int_cst_equal (range[0], range[1]))
     935                 :         138 :         warned = (func
     936                 :         264 :                   ? warning_n (loc, opt, tree_to_uhwi (range[0]),
     937                 :             :                                (maybe
     938                 :             :                                 ? G_("%qD may access %E byte in a region "
     939                 :             :                                      "of size %E")
     940                 :             :                                 : G_("%qD accessing %E byte in a region "
     941                 :             :                                      "of size %E")),
     942                 :             :                                 (maybe
     943                 :             :                                  ? G_ ("%qD may access %E bytes in a region "
     944                 :             :                                        "of size %E")
     945                 :             :                                  : G_ ("%qD accessing %E bytes in a region "
     946                 :             :                                        "of size %E")),
     947                 :             :                                func, range[0], size)
     948                 :         150 :                   : warning_n (loc, opt, tree_to_uhwi (range[0]),
     949                 :             :                                (maybe
     950                 :             :                                 ? G_("may access %E byte in a region "
     951                 :             :                                      "of size %E")
     952                 :             :                                 : G_("accessing %E byte in a region "
     953                 :             :                                      "of size %E")),
     954                 :             :                                (maybe
     955                 :             :                                 ? G_("may access %E bytes in a region "
     956                 :             :                                      "of size %E")
     957                 :             :                                 : G_("accessing %E bytes in a region "
     958                 :             :                                      "of size %E")),
     959                 :             :                                range[0], size));
     960                 :           0 :       else if (tree_int_cst_sign_bit (range[1]))
     961                 :             :         {
     962                 :             :           /* Avoid printing the upper bound if it's invalid.  */
     963                 :           0 :           warned = (func
     964                 :           0 :                     ? warning_at (loc, opt,
     965                 :             :                                   (maybe
     966                 :             :                                    ? G_("%qD may access %E or more bytes "
     967                 :             :                                         "in a region of size %E")
     968                 :             :                                    : G_("%qD accessing %E or more bytes "
     969                 :             :                                         "in a region of size %E")),
     970                 :             :                                   func, range[0], size)
     971                 :           0 :                     : warning_at (loc, opt,
     972                 :             :                                   (maybe
     973                 :             :                                    ? G_("may access %E or more bytes "
     974                 :             :                                         "in a region of size %E")
     975                 :             :                                    : G_("accessing %E or more bytes "
     976                 :             :                                         "in a region of size %E")),
     977                 :             :                                   range[0], size));
     978                 :             :         }
     979                 :             :       else
     980                 :           0 :         warned = (func
     981                 :           0 :                   ? warning_at (loc, opt,
     982                 :             :                                 (maybe
     983                 :             :                                  ? G_("%qD may access between %E and %E "
     984                 :             :                                       "bytes in a region of size %E")
     985                 :             :                                  : G_("%qD accessing between %E and %E "
     986                 :             :                                       "bytes in a region of size %E")),
     987                 :             :                                 func, range[0], range[1], size)
     988                 :           0 :                   : warning_at (loc, opt,
     989                 :             :                                 (maybe
     990                 :             :                                  ? G_("may access between %E and %E bytes "
     991                 :             :                                       "in a region of size %E")
     992                 :             :                                  : G_("accessing between %E and %E bytes "
     993                 :             :                                       "in a region of size %E")),
     994                 :             :                                 range[0], range[1], size));
     995                 :         138 :       return warned;
     996                 :             :     }
     997                 :             : 
     998                 :        1745 :   if (write)
     999                 :             :     {
    1000                 :        1169 :       if (tree_int_cst_equal (range[0], range[1]))
    1001                 :        1056 :         warned = (func
    1002                 :        2110 :                   ? warning_n (loc, opt, tree_to_uhwi (range[0]),
    1003                 :             :                                (maybe
    1004                 :             :                                 ? G_("%qD may write %E byte into a region "
    1005                 :             :                                      "of size %E")
    1006                 :             :                                 : G_("%qD writing %E byte into a region "
    1007                 :             :                                      "of size %E overflows the destination")),
    1008                 :             :                                (maybe
    1009                 :             :                                 ? G_("%qD may write %E bytes into a region "
    1010                 :             :                                      "of size %E")
    1011                 :             :                                 : G_("%qD writing %E bytes into a region "
    1012                 :             :                                      "of size %E overflows the destination")),
    1013                 :             :                                func, range[0], size)
    1014                 :        1058 :                   : warning_n (loc, opt, tree_to_uhwi (range[0]),
    1015                 :             :                                (maybe
    1016                 :             :                                 ? G_("may write %E byte into a region "
    1017                 :             :                                      "of size %E")
    1018                 :             :                                 : G_("writing %E byte into a region "
    1019                 :             :                                      "of size %E overflows the destination")),
    1020                 :             :                                (maybe
    1021                 :             :                                 ? G_("may write %E bytes into a region "
    1022                 :             :                                      "of size %E")
    1023                 :             :                                 : G_("writing %E bytes into a region "
    1024                 :             :                                      "of size %E overflows the destination")),
    1025                 :             :                                range[0], size));
    1026                 :         113 :       else if (tree_int_cst_sign_bit (range[1]))
    1027                 :             :         {
    1028                 :             :           /* Avoid printing the upper bound if it's invalid.  */
    1029                 :          51 :           warned = (func
    1030                 :         102 :                     ? warning_at (loc, opt,
    1031                 :             :                                   (maybe
    1032                 :             :                                    ? G_("%qD may write %E or more bytes "
    1033                 :             :                                         "into a region of size %E")
    1034                 :             :                                    : G_("%qD writing %E or more bytes "
    1035                 :             :                                         "into a region of size %E overflows "
    1036                 :             :                                         "the destination")),
    1037                 :             :                                   func, range[0], size)
    1038                 :          51 :                     : warning_at (loc, opt,
    1039                 :             :                                   (maybe
    1040                 :             :                                    ? G_("may write %E or more bytes into "
    1041                 :             :                                         "a region of size %E")
    1042                 :             :                                    : G_("writing %E or more bytes into "
    1043                 :             :                                         "a region of size %E overflows "
    1044                 :             :                                         "the destination")),
    1045                 :             :                                   range[0], size));
    1046                 :             :         }
    1047                 :             :       else
    1048                 :          62 :         warned = (func
    1049                 :         124 :                   ? warning_at (loc, opt,
    1050                 :             :                                 (maybe
    1051                 :             :                                  ? G_("%qD may write between %E and %E bytes "
    1052                 :             :                                       "into a region of size %E")
    1053                 :             :                                  : G_("%qD writing between %E and %E bytes "
    1054                 :             :                                       "into a region of size %E overflows "
    1055                 :             :                                       "the destination")),
    1056                 :             :                                 func, range[0], range[1], size)
    1057                 :          62 :                   : warning_at (loc, opt,
    1058                 :             :                                 (maybe
    1059                 :             :                                  ? G_("may write between %E and %E bytes "
    1060                 :             :                                       "into a region of size %E")
    1061                 :             :                                  : G_("writing between %E and %E bytes "
    1062                 :             :                                       "into a region of size %E overflows "
    1063                 :             :                                       "the destination")),
    1064                 :             :                                 range[0], range[1], size));
    1065                 :        1169 :       return warned;
    1066                 :             :     }
    1067                 :             : 
    1068                 :         576 :   if (read)
    1069                 :             :     {
    1070                 :         573 :       if (tree_int_cst_equal (range[0], range[1]))
    1071                 :         246 :         warned = (func
    1072                 :         490 :                   ? warning_n (loc, OPT_Wstringop_overread,
    1073                 :             :                                tree_to_uhwi (range[0]),
    1074                 :             :                                (maybe
    1075                 :             :                                 ? G_("%qD may read %E byte from a region "
    1076                 :             :                                      "of size %E")
    1077                 :             :                                 : G_("%qD reading %E byte from a region "
    1078                 :             :                                      "of size %E")),
    1079                 :             :                                (maybe
    1080                 :             :                                 ? G_("%qD may read %E bytes from a region "
    1081                 :             :                                      "of size %E")
    1082                 :             :                                 : G_("%qD reading %E bytes from a region "
    1083                 :             :                                      "of size %E")),
    1084                 :             :                                func, range[0], size)
    1085                 :         248 :                   : warning_n (loc, OPT_Wstringop_overread,
    1086                 :             :                                tree_to_uhwi (range[0]),
    1087                 :             :                                (maybe
    1088                 :             :                                 ? G_("may read %E byte from a region "
    1089                 :             :                                      "of size %E")
    1090                 :             :                                 : G_("reading %E byte from a region "
    1091                 :             :                                      "of size %E")),
    1092                 :             :                                (maybe
    1093                 :             :                                 ? G_("may read %E bytes from a region "
    1094                 :             :                                      "of size %E")
    1095                 :             :                                 : G_("reading %E bytes from a region "
    1096                 :             :                                      "of size %E")),
    1097                 :             :                                range[0], size));
    1098                 :         327 :       else if (tree_int_cst_sign_bit (range[1]))
    1099                 :             :         {
    1100                 :             :           /* Avoid printing the upper bound if it's invalid.  */
    1101                 :         304 :           warned = (func
    1102                 :         608 :                     ? warning_at (loc, OPT_Wstringop_overread,
    1103                 :             :                                   (maybe
    1104                 :             :                                    ? G_("%qD may read %E or more bytes "
    1105                 :             :                                         "from a region of size %E")
    1106                 :             :                                    : G_("%qD reading %E or more bytes "
    1107                 :             :                                         "from a region of size %E")),
    1108                 :             :                                   func, range[0], size)
    1109                 :         304 :                     : warning_at (loc, OPT_Wstringop_overread,
    1110                 :             :                                   (maybe
    1111                 :             :                                    ? G_("may read %E or more bytes "
    1112                 :             :                                         "from a region of size %E")
    1113                 :             :                                    : G_("reading %E or more bytes "
    1114                 :             :                                         "from a region of size %E")),
    1115                 :             :                                   range[0], size));
    1116                 :             :         }
    1117                 :             :       else
    1118                 :          23 :         warned = (func
    1119                 :          46 :                   ? warning_at (loc, OPT_Wstringop_overread,
    1120                 :             :                                 (maybe
    1121                 :             :                                  ? G_("%qD may read between %E and %E bytes "
    1122                 :             :                                       "from a region of size %E")
    1123                 :             :                                  : G_("%qD reading between %E and %E bytes "
    1124                 :             :                                       "from a region of size %E")),
    1125                 :             :                                 func, range[0], range[1], size)
    1126                 :          23 :                   : warning_at (loc, opt,
    1127                 :             :                                 (maybe
    1128                 :             :                                  ? G_("may read between %E and %E bytes "
    1129                 :             :                                       "from a region of size %E")
    1130                 :             :                                  : G_("reading between %E and %E bytes "
    1131                 :             :                                       "from a region of size %E")),
    1132                 :             :                                 range[0], range[1], size));
    1133                 :             : 
    1134                 :         573 :       if (warned)
    1135                 :         399 :         suppress_warning (exp, OPT_Wstringop_overread);
    1136                 :             : 
    1137                 :         573 :       return warned;
    1138                 :             :     }
    1139                 :             : 
    1140                 :           3 :   if (tree_int_cst_equal (range[0], range[1])
    1141                 :           3 :       || tree_int_cst_sign_bit (range[1]))
    1142                 :           3 :     warned = (func
    1143                 :           3 :               ? warning_n (loc, OPT_Wstringop_overread,
    1144                 :             :                            tree_to_uhwi (range[0]),
    1145                 :             :                            "%qD expecting %E byte in a region of size %E",
    1146                 :             :                            "%qD expecting %E bytes in a region of size %E",
    1147                 :             :                            func, range[0], size)
    1148                 :           3 :               : warning_n (loc, OPT_Wstringop_overread,
    1149                 :             :                            tree_to_uhwi (range[0]),
    1150                 :             :                            "expecting %E byte in a region of size %E",
    1151                 :             :                            "expecting %E bytes in a region of size %E",
    1152                 :             :                            range[0], size));
    1153                 :           0 :   else if (tree_int_cst_sign_bit (range[1]))
    1154                 :             :     {
    1155                 :             :       /* Avoid printing the upper bound if it's invalid.  */
    1156                 :           0 :       warned = (func
    1157                 :           0 :                 ? warning_at (loc, OPT_Wstringop_overread,
    1158                 :             :                               "%qD expecting %E or more bytes in a region "
    1159                 :             :                               "of size %E",
    1160                 :             :                               func, range[0], size)
    1161                 :           0 :                 : warning_at (loc, OPT_Wstringop_overread,
    1162                 :             :                               "expecting %E or more bytes in a region "
    1163                 :             :                               "of size %E",
    1164                 :             :                               range[0], size));
    1165                 :             :     }
    1166                 :             :   else
    1167                 :           0 :     warned = (func
    1168                 :           0 :               ? warning_at (loc, OPT_Wstringop_overread,
    1169                 :             :                             "%qD expecting between %E and %E bytes in "
    1170                 :             :                             "a region of size %E",
    1171                 :             :                             func, range[0], range[1], size)
    1172                 :           0 :               : warning_at (loc, OPT_Wstringop_overread,
    1173                 :             :                             "expecting between %E and %E bytes in "
    1174                 :             :                             "a region of size %E",
    1175                 :             :                             range[0], range[1], size));
    1176                 :             : 
    1177                 :           3 :   if (warned)
    1178                 :           3 :     suppress_warning (exp, OPT_Wstringop_overread);
    1179                 :             : 
    1180                 :             :   return warned;
    1181                 :             : }
    1182                 :             : 
    1183                 :             : static bool
    1184                 :        1439 : warn_for_access (location_t loc, tree func, gimple *stmt, int opt,
    1185                 :             :                  tree range[2], tree size, bool write, bool read, bool maybe)
    1186                 :             : {
    1187                 :           0 :   return warn_for_access<gimple *>(loc, func, stmt, opt, range, size,
    1188                 :           0 :                                    write, read, maybe);
    1189                 :             : }
    1190                 :             : 
    1191                 :             : static bool
    1192                 :         272 : warn_for_access (location_t loc, tree func, tree expr, int opt,
    1193                 :             :                  tree range[2], tree size, bool write, bool read, bool maybe)
    1194                 :             : {
    1195                 :           0 :   return warn_for_access<tree>(loc, func, expr, opt, range, size,
    1196                 :           0 :                                write, read, maybe);
    1197                 :             : }
    1198                 :             : 
    1199                 :             : /* Helper to set RANGE to the range of BOUND if it's nonnull, bounded
    1200                 :             :    by BNDRNG if nonnull and valid.  */
    1201                 :             : 
    1202                 :             : static void
    1203                 :     1497066 : get_size_range (range_query *query, tree bound, gimple *stmt, tree range[2],
    1204                 :             :                 int flags, const offset_int bndrng[2])
    1205                 :             : {
    1206                 :     1497066 :   if (bound)
    1207                 :      637042 :     get_size_range (query, bound, stmt, range, flags);
    1208                 :             : 
    1209                 :     1497066 :   if (!bndrng || (bndrng[0] == 0 && bndrng[1] == HOST_WIDE_INT_M1U))
    1210                 :      982004 :     return;
    1211                 :             : 
    1212                 :      515062 :   if (range[0] && TREE_CODE (range[0]) == INTEGER_CST)
    1213                 :             :     {
    1214                 :      515026 :       offset_int r[] =
    1215                 :      515026 :         { wi::to_offset (range[0]), wi::to_offset (range[1]) };
    1216                 :      515026 :       if (r[0] < bndrng[0])
    1217                 :           0 :         range[0] = wide_int_to_tree (sizetype, bndrng[0]);
    1218                 :      515026 :       if (bndrng[1] < r[1])
    1219                 :          19 :         range[1] = wide_int_to_tree (sizetype, bndrng[1]);
    1220                 :      515026 :     }
    1221                 :             :   else
    1222                 :             :     {
    1223                 :          36 :       range[0] = wide_int_to_tree (sizetype, bndrng[0]);
    1224                 :          36 :       range[1] = wide_int_to_tree (sizetype, bndrng[1]);
    1225                 :             :     }
    1226                 :             : }
    1227                 :             : 
    1228                 :             : /* Try to verify that the sizes and lengths of the arguments to a string
    1229                 :             :    manipulation function given by EXP are within valid bounds and that
    1230                 :             :    the operation does not lead to buffer overflow or read past the end.
    1231                 :             :    Arguments other than EXP may be null.  When non-null, the arguments
    1232                 :             :    have the following meaning:
    1233                 :             :    DST is the destination of a copy call or NULL otherwise.
    1234                 :             :    SRC is the source of a copy call or NULL otherwise.
    1235                 :             :    DSTWRITE is the number of bytes written into the destination obtained
    1236                 :             :    from the user-supplied size argument to the function (such as in
    1237                 :             :    memcpy(DST, SRCs, DSTWRITE) or strncpy(DST, DRC, DSTWRITE).
    1238                 :             :    MAXREAD is the user-supplied bound on the length of the source sequence
    1239                 :             :    (such as in strncat(d, s, N).  It specifies the upper limit on the number
    1240                 :             :    of bytes to write.  If NULL, it's taken to be the same as DSTWRITE.
    1241                 :             :    SRCSTR is the source string (such as in strcpy(DST, SRC)) when the
    1242                 :             :    expression EXP is a string function call (as opposed to a memory call
    1243                 :             :    like memcpy).  As an exception, SRCSTR can also be an integer denoting
    1244                 :             :    the precomputed size of the source string or object (for functions like
    1245                 :             :    memcpy).
    1246                 :             :    DSTSIZE is the size of the destination object.
    1247                 :             : 
    1248                 :             :    When DSTWRITE is null LEN is checked to verify that it doesn't exceed
    1249                 :             :    SIZE_MAX.
    1250                 :             : 
    1251                 :             :    WRITE is true for write accesses, READ is true for reads.  Both are
    1252                 :             :    false for simple size checks in calls to functions that neither read
    1253                 :             :    from nor write to the region.
    1254                 :             : 
    1255                 :             :    When nonnull, PAD points to a more detailed description of the access.
    1256                 :             : 
    1257                 :             :    If the call is successfully verified as safe return true, otherwise
    1258                 :             :    return false.  */
    1259                 :             : 
    1260                 :             : template <class GimpleOrTree>
    1261                 :             : static bool
    1262                 :      807732 : check_access (GimpleOrTree exp, tree dstwrite,
    1263                 :             :               tree maxread, tree srcstr, tree dstsize,
    1264                 :             :               access_mode mode, const access_data *pad,
    1265                 :             :               range_query *rvals)
    1266                 :             : {
    1267                 :             :   /* The size of the largest object is half the address space, or
    1268                 :             :      PTRDIFF_MAX.  (This is way too permissive.)  */
    1269                 :      807732 :   tree maxobjsize = max_object_size ();
    1270                 :             : 
    1271                 :             :   /* Either an approximate/minimum the length of the source string for
    1272                 :             :      string functions or the size of the source object for raw memory
    1273                 :             :      functions.  */
    1274                 :      807732 :   tree slen = NULL_TREE;
    1275                 :             : 
    1276                 :             :   /* The range of the access in bytes; first set to the write access
    1277                 :             :      for functions that write and then read for those that also (or
    1278                 :             :      just) read.  */
    1279                 :      807732 :   tree range[2] = { NULL_TREE, NULL_TREE };
    1280                 :             : 
    1281                 :             :   /* Set to true when the exact number of bytes written by a string
    1282                 :             :      function like strcpy is not known and the only thing that is
    1283                 :             :      known is that it must be at least one (for the terminating nul).  */
    1284                 :      807732 :   bool at_least_one = false;
    1285                 :      807732 :   if (srcstr)
    1286                 :             :     {
    1287                 :             :       /* SRCSTR is normally a pointer to string but as a special case
    1288                 :             :          it can be an integer denoting the length of a string.  */
    1289                 :      499026 :       if (POINTER_TYPE_P (TREE_TYPE (srcstr)))
    1290                 :             :         {
    1291                 :      404078 :           if (!check_nul_terminated_array (exp, srcstr, maxread))
    1292                 :             :             /* Return if the array is not nul-terminated and a warning
    1293                 :             :                has been issued.  */
    1294                 :         559 :             return false;
    1295                 :             : 
    1296                 :             :           /* Try to determine the range of lengths the source string
    1297                 :             :              refers to.  If it can be determined and is less than
    1298                 :             :              the upper bound given by MAXREAD add one to it for
    1299                 :             :              the terminating nul.  Otherwise, set it to one for
    1300                 :             :              the same reason, or to MAXREAD as appropriate.  */
    1301                 :      403519 :           c_strlen_data lendata = { };
    1302                 :      403519 :           get_range_strlen (srcstr, &lendata, /* eltsize = */ 1);
    1303                 :      403519 :           range[0] = lendata.minlen;
    1304                 :      403519 :           range[1] = lendata.maxbound ? lendata.maxbound : lendata.maxlen;
    1305                 :      403519 :           if (range[0]
    1306                 :      403519 :               && TREE_CODE (range[0]) == INTEGER_CST
    1307                 :      403514 :               && TREE_CODE (range[1]) == INTEGER_CST
    1308                 :      403514 :               && (!maxread || TREE_CODE (maxread) == INTEGER_CST))
    1309                 :             :             {
    1310                 :      106179 :               if (maxread && tree_int_cst_le (maxread, range[0]))
    1311                 :         467 :                 range[0] = range[1] = maxread;
    1312                 :             :               else
    1313                 :      393310 :                 range[0] = fold_build2 (PLUS_EXPR, size_type_node,
    1314                 :             :                                         range[0], size_one_node);
    1315                 :             : 
    1316                 :      393777 :               if (maxread && tree_int_cst_le (maxread, range[1]))
    1317                 :       84364 :                 range[1] = maxread;
    1318                 :      309413 :               else if (!integer_all_onesp (range[1]))
    1319                 :      163156 :                 range[1] = fold_build2 (PLUS_EXPR, size_type_node,
    1320                 :             :                                         range[1], size_one_node);
    1321                 :             : 
    1322                 :      393777 :               slen = range[0];
    1323                 :             :             }
    1324                 :             :           else
    1325                 :             :             {
    1326                 :        9742 :               at_least_one = true;
    1327                 :        9742 :               slen = size_one_node;
    1328                 :             :             }
    1329                 :             :         }
    1330                 :             :       else
    1331                 :             :         slen = srcstr;
    1332                 :             :     }
    1333                 :             : 
    1334                 :      807173 :   if (!dstwrite && !maxread)
    1335                 :             :     {
    1336                 :             :       /* When the only available piece of data is the object size
    1337                 :             :          there is nothing to do.  */
    1338                 :      287853 :       if (!slen)
    1339                 :             :         return true;
    1340                 :             : 
    1341                 :             :       /* Otherwise, when the length of the source sequence is known
    1342                 :             :          (as with strlen), set DSTWRITE to it.  */
    1343                 :      287435 :       if (!range[0])
    1344                 :          79 :         dstwrite = slen;
    1345                 :             :     }
    1346                 :             : 
    1347                 :      806755 :   if (!dstsize)
    1348                 :      399018 :     dstsize = maxobjsize;
    1349                 :             : 
    1350                 :             :   /* Set RANGE to that of DSTWRITE if non-null, bounded by PAD->DST_BNDRNG
    1351                 :             :      if valid.  */
    1352                 :      806755 :   gimple *stmt = pad ? pad->stmt : nullptr;
    1353                 :     2417804 :   get_size_range (rvals, dstwrite, stmt, range,
    1354                 :             :                   /* If the destination has known zero size prefer a zero
    1355                 :             :                      size range to avoid false positives if that's a
    1356                 :             :                      possibility.  */
    1357                 :      806755 :                   integer_zerop (dstsize) ? SR_ALLOW_ZERO : 0,
    1358                 :             :                   pad ? pad->dst_bndrng : NULL);
    1359                 :             : 
    1360                 :      806755 :   tree func = get_callee_fndecl (exp);
    1361                 :             :   /* Read vs write access by built-ins can be determined from the const
    1362                 :             :      qualifiers on the pointer argument.  In the absence of attribute
    1363                 :             :      access, non-const qualified pointer arguments to user-defined
    1364                 :             :      functions are assumed to both read and write the objects.  */
    1365                 :      806755 :   const bool builtin = func ? fndecl_built_in_p (func) : false;
    1366                 :             : 
    1367                 :             :   /* First check the number of bytes to be written against the maximum
    1368                 :             :      object size.  */
    1369                 :      806755 :   if (range[0]
    1370                 :      805779 :       && TREE_CODE (range[0]) == INTEGER_CST
    1371                 :     1612530 :       && tree_int_cst_lt (maxobjsize, range[0]))
    1372                 :             :     {
    1373                 :         128 :       location_t loc = get_location (exp);
    1374                 :         128 :       maybe_warn_for_bound (OPT_Wstringop_overflow_, loc, exp, func, range,
    1375                 :             :                             NULL_TREE, pad);
    1376                 :         128 :       return false;
    1377                 :             :     }
    1378                 :             : 
    1379                 :             :   /* The number of bytes to write is "exact" if DSTWRITE is non-null,
    1380                 :             :      constant, and in range of unsigned HOST_WIDE_INT.  */
    1381                 :      806627 :   bool exactwrite = dstwrite && tree_fits_uhwi_p (dstwrite);
    1382                 :             : 
    1383                 :             :   /* Next check the number of bytes to be written against the destination
    1384                 :             :      object size.  */
    1385                 :      806627 :   if (range[0] || !exactwrite || integer_all_onesp (dstwrite))
    1386                 :             :     {
    1387                 :      806627 :       if (range[0]
    1388                 :      805651 :           && TREE_CODE (range[0]) == INTEGER_CST
    1389                 :     1612274 :           && ((tree_fits_uhwi_p (dstsize)
    1390                 :      805337 :                && tree_int_cst_lt (dstsize, range[0]))
    1391                 :      804044 :               || (dstwrite
    1392                 :      402992 :                   && tree_fits_uhwi_p (dstwrite)
    1393                 :      336393 :                   && tree_int_cst_lt (dstwrite, range[0]))))
    1394                 :             :         {
    1395                 :        1603 :           const opt_code opt = OPT_Wstringop_overflow_;
    1396                 :        1603 :           if (warning_suppressed_p (exp, opt)
    1397                 :        1603 :               || (pad && pad->dst.ref
    1398                 :         897 :                   && warning_suppressed_p (pad->dst.ref, opt)))
    1399                 :         285 :             return false;
    1400                 :             : 
    1401                 :        1318 :           auto_diagnostic_group d;
    1402                 :        1318 :           location_t loc = get_location (exp);
    1403                 :        1318 :           bool warned = false;
    1404                 :        1318 :           if (dstwrite == slen && at_least_one)
    1405                 :             :             {
    1406                 :             :               /* This is a call to strcpy with a destination of 0 size
    1407                 :             :                  and a source of unknown length.  The call will write
    1408                 :             :                  at least one byte past the end of the destination.  */
    1409                 :           0 :               warned = (func
    1410                 :           0 :                         ? warning_at (loc, opt,
    1411                 :             :                                       "%qD writing %E or more bytes into "
    1412                 :             :                                       "a region of size %E overflows "
    1413                 :             :                                       "the destination",
    1414                 :             :                                       func, range[0], dstsize)
    1415                 :           0 :                         : warning_at (loc, opt,
    1416                 :             :                                       "writing %E or more bytes into "
    1417                 :             :                                       "a region of size %E overflows "
    1418                 :             :                                       "the destination",
    1419                 :             :                                       range[0], dstsize));
    1420                 :             :             }
    1421                 :             :           else
    1422                 :             :             {
    1423                 :        1318 :               const bool read
    1424                 :        1318 :                 = mode == access_read_only || mode == access_read_write;
    1425                 :        1318 :               const bool write
    1426                 :        1318 :                 = mode == access_write_only || mode == access_read_write;
    1427                 :        1318 :               const bool maybe = pad && pad->dst.parmarray;
    1428                 :        1318 :               warned = warn_for_access (loc, func, exp,
    1429                 :             :                                         OPT_Wstringop_overflow_,
    1430                 :             :                                         range, dstsize,
    1431                 :        1318 :                                         write, read && !builtin, maybe);
    1432                 :             :             }
    1433                 :             : 
    1434                 :        1318 :           if (warned)
    1435                 :             :             {
    1436                 :         916 :               suppress_warning (exp, OPT_Wstringop_overflow_);
    1437                 :         916 :               if (pad)
    1438                 :         830 :                 pad->dst.inform_access (pad->mode);
    1439                 :             :             }
    1440                 :             : 
    1441                 :             :           /* Return error when an overflow has been detected.  */
    1442                 :             :           return false;
    1443                 :        1318 :         }
    1444                 :             :     }
    1445                 :             : 
    1446                 :             :   /* Check the maximum length of the source sequence against the size
    1447                 :             :      of the destination object if known, or against the maximum size
    1448                 :             :      of an object.  */
    1449                 :      805024 :   if (maxread)
    1450                 :             :     {
    1451                 :             :       /* Set RANGE to that of MAXREAD, bounded by PAD->SRC_BNDRNG if
    1452                 :             :          PAD is nonnull and BNDRNG is valid.  */
    1453                 :      116790 :       get_size_range (rvals, maxread, stmt, range, 0,
    1454                 :             :                       pad ? pad->src_bndrng : NULL);
    1455                 :             : 
    1456                 :      116790 :       location_t loc = get_location (exp);
    1457                 :      116790 :       tree size = dstsize;
    1458                 :      116790 :       if (pad && pad->mode == access_read_only)
    1459                 :      113727 :         size = wide_int_to_tree (sizetype, pad->src.size_remaining ());
    1460                 :             : 
    1461                 :      116790 :       if (range[0] && maxread && tree_fits_uhwi_p (size))
    1462                 :             :         {
    1463                 :      116746 :           if (tree_int_cst_lt (maxobjsize, range[0]))
    1464                 :             :             {
    1465                 :          87 :               maybe_warn_for_bound (OPT_Wstringop_overread, loc, exp, func,
    1466                 :             :                                     range, size, pad);
    1467                 :          87 :               return false;
    1468                 :             :             }
    1469                 :             : 
    1470                 :      116659 :           if (size != maxobjsize && tree_int_cst_lt (size, range[0]))
    1471                 :             :             {
    1472                 :         404 :               opt_code opt = (dstwrite || mode != access_read_only
    1473                 :         202 :                               ? OPT_Wstringop_overflow_
    1474                 :             :                               : OPT_Wstringop_overread);
    1475                 :         202 :               maybe_warn_for_bound (opt, loc, exp, func, range, size, pad);
    1476                 :         202 :               return false;
    1477                 :             :             }
    1478                 :             :         }
    1479                 :             : 
    1480                 :      116501 :       maybe_warn_nonstring_arg (func, exp);
    1481                 :             :     }
    1482                 :             : 
    1483                 :             :   /* Check for reading past the end of SRC.  */
    1484                 :     1609470 :   bool overread = (slen
    1485                 :      804735 :                    && slen == srcstr
    1486                 :       94345 :                    && dstwrite
    1487                 :       93702 :                    && range[0]
    1488                 :       93702 :                    && TREE_CODE (slen) == INTEGER_CST
    1489                 :      898437 :                    && tree_int_cst_lt (slen, range[0]));
    1490                 :             :   /* If none is determined try to get a better answer based on the details
    1491                 :             :      in PAD.  */
    1492                 :      804735 :   if (!overread
    1493                 :      804735 :       && pad
    1494                 :      802899 :       && pad->src.sizrng[1] >= 0
    1495                 :      581399 :       && pad->src.offrng[0] >= 0
    1496                 :     1607634 :       && (pad->src.offrng[1] < 0
    1497                 :      571210 :           || pad->src.offrng[0] <= pad->src.offrng[1]))
    1498                 :             :     {
    1499                 :             :       /* Set RANGE to that of MAXREAD, bounded by PAD->SRC_BNDRNG if
    1500                 :             :          PAD is nonnull and BNDRNG is valid.  */
    1501                 :      571210 :       get_size_range (rvals, maxread, stmt, range, 0,
    1502                 :             :                       pad ? pad->src_bndrng : NULL);
    1503                 :             :       /* Set OVERREAD for reads starting just past the end of an object.  */
    1504                 :      571210 :       overread = pad->src.sizrng[1] - pad->src.offrng[0] < pad->src_bndrng[0];
    1505                 :      571210 :       range[0] = wide_int_to_tree (sizetype, pad->src_bndrng[0]);
    1506                 :      571210 :       slen = size_zero_node;
    1507                 :             :     }
    1508                 :             : 
    1509                 :      804735 :   if (overread)
    1510                 :             :     {
    1511                 :         660 :       const opt_code opt = OPT_Wstringop_overread;
    1512                 :         660 :       if (warning_suppressed_p (exp, opt)
    1513                 :         593 :           || (srcstr && warning_suppressed_p (srcstr, opt))
    1514                 :        1225 :           || (pad && pad->src.ref
    1515                 :         565 :               && warning_suppressed_p (pad->src.ref, opt)))
    1516                 :          95 :         return false;
    1517                 :             : 
    1518                 :         565 :       location_t loc = get_location (exp);
    1519                 :         565 :       const bool read
    1520                 :         565 :         = mode == access_read_only || mode == access_read_write;
    1521                 :         565 :       const bool maybe = pad && pad->dst.parmarray;
    1522                 :         565 :       auto_diagnostic_group d;
    1523                 :         565 :       if (warn_for_access (loc, func, exp, opt, range, slen, false, read,
    1524                 :             :                            maybe))
    1525                 :             :         {
    1526                 :         391 :           suppress_warning (exp, opt);
    1527                 :         391 :           if (pad)
    1528                 :         391 :             pad->src.inform_access (access_read_only);
    1529                 :             :         }
    1530                 :             :       return false;
    1531                 :         565 :     }
    1532                 :             : 
    1533                 :             :   return true;
    1534                 :             : }
    1535                 :             : 
    1536                 :             : static bool
    1537                 :      799555 : check_access (gimple *stmt, tree dstwrite,
    1538                 :             :               tree maxread, tree srcstr, tree dstsize,
    1539                 :             :               access_mode mode, const access_data *pad,
    1540                 :             :               range_query *rvals)
    1541                 :             : {
    1542                 :           0 :   return check_access<gimple *> (stmt, dstwrite, maxread, srcstr, dstsize,
    1543                 :           0 :                                  mode, pad, rvals);
    1544                 :             : }
    1545                 :             : 
    1546                 :             : bool
    1547                 :        1973 : check_access (tree expr, tree dstwrite,
    1548                 :             :               tree maxread, tree srcstr, tree dstsize,
    1549                 :             :               access_mode mode, const access_data *pad /* = NULL */)
    1550                 :             : {
    1551                 :        1973 :   return check_access<tree> (expr, dstwrite, maxread, srcstr, dstsize,
    1552                 :        1973 :                              mode, pad, nullptr);
    1553                 :             : }
    1554                 :             : 
    1555                 :             : /* Return true if STMT is a call to an allocation function.  Unless
    1556                 :             :    ALL_ALLOC is set, consider only functions that return dynamically
    1557                 :             :    allocated objects.  Otherwise return true even for all forms of
    1558                 :             :    alloca (including VLA).  */
    1559                 :             : 
    1560                 :             : static bool
    1561                 :       39911 : fndecl_alloc_p (tree fndecl, bool all_alloc)
    1562                 :             : {
    1563                 :       39911 :   if (!fndecl)
    1564                 :             :     return false;
    1565                 :             : 
    1566                 :             :   /* A call to operator new isn't recognized as one to a built-in.  */
    1567                 :       39888 :   if (DECL_IS_OPERATOR_NEW_P (fndecl))
    1568                 :             :     return true;
    1569                 :             : 
    1570                 :       31860 :   if (fndecl_built_in_p (fndecl, BUILT_IN_NORMAL))
    1571                 :             :     {
    1572                 :       27809 :       switch (DECL_FUNCTION_CODE (fndecl))
    1573                 :             :         {
    1574                 :             :         case BUILT_IN_ALLOCA:
    1575                 :             :         case BUILT_IN_ALLOCA_WITH_ALIGN:
    1576                 :             :           return all_alloc;
    1577                 :             :         case BUILT_IN_ALIGNED_ALLOC:
    1578                 :             :         case BUILT_IN_CALLOC:
    1579                 :             :         case BUILT_IN_GOMP_ALLOC:
    1580                 :             :         case BUILT_IN_GOMP_REALLOC:
    1581                 :             :         case BUILT_IN_MALLOC:
    1582                 :             :         case BUILT_IN_REALLOC:
    1583                 :             :         case BUILT_IN_STRDUP:
    1584                 :             :         case BUILT_IN_STRNDUP:
    1585                 :             :           return true;
    1586                 :             :         default:
    1587                 :             :           break;
    1588                 :             :         }
    1589                 :             :     }
    1590                 :             : 
    1591                 :             :   /* A function is considered an allocation function if it's declared
    1592                 :             :      with attribute malloc with an argument naming its associated
    1593                 :             :      deallocation function.  */
    1594                 :        4051 :   tree attrs = DECL_ATTRIBUTES (fndecl);
    1595                 :        4051 :   if (!attrs)
    1596                 :             :     return false;
    1597                 :             : 
    1598                 :         103 :   for (tree allocs = attrs;
    1599                 :        1523 :        (allocs = lookup_attribute ("malloc", allocs));
    1600                 :         103 :        allocs = TREE_CHAIN (allocs))
    1601                 :             :     {
    1602                 :         830 :       tree args = TREE_VALUE (allocs);
    1603                 :         830 :       if (!args)
    1604                 :         103 :         continue;
    1605                 :             : 
    1606                 :         727 :       if (TREE_VALUE (args))
    1607                 :             :         return true;
    1608                 :             :     }
    1609                 :             : 
    1610                 :             :   return false;
    1611                 :             : }
    1612                 :             : 
    1613                 :             : /* Return true if STMT is a call to an allocation function.  A wrapper
    1614                 :             :    around fndecl_alloc_p.  */
    1615                 :             : 
    1616                 :             : static bool
    1617                 :       39911 : gimple_call_alloc_p (gimple *stmt, bool all_alloc = false)
    1618                 :             : {
    1619                 :       39911 :   return fndecl_alloc_p (gimple_call_fndecl (stmt), all_alloc);
    1620                 :             : }
    1621                 :             : 
    1622                 :             : /* Return true if DELC doesn't refer to an operator delete that's
    1623                 :             :    suitable to call with a pointer returned from the operator new
    1624                 :             :    described by NEWC.  */
    1625                 :             : 
    1626                 :             : static bool
    1627                 :        1348 : new_delete_mismatch_p (const demangle_component &newc,
    1628                 :             :                        const demangle_component &delc)
    1629                 :             : {
    1630                 :        2067 :   if (newc.type != delc.type)
    1631                 :             :     return true;
    1632                 :             : 
    1633                 :        2036 :   switch (newc.type)
    1634                 :             :     {
    1635                 :         549 :     case DEMANGLE_COMPONENT_NAME:
    1636                 :         549 :       {
    1637                 :         549 :         int len = newc.u.s_name.len;
    1638                 :         549 :         const char *news = newc.u.s_name.s;
    1639                 :         549 :         const char *dels = delc.u.s_name.s;
    1640                 :         549 :         if (len != delc.u.s_name.len || memcmp (news, dels, len))
    1641                 :             :           return true;
    1642                 :             : 
    1643                 :         534 :         if (news[len] == 'n')
    1644                 :             :           {
    1645                 :         185 :             if (news[len + 1] == 'a')
    1646                 :          66 :               return dels[len] != 'd' || dels[len + 1] != 'a';
    1647                 :         131 :             if (news[len + 1] == 'w')
    1648                 :         137 :               return dels[len] != 'd' || dels[len + 1] != 'l';
    1649                 :             :           }
    1650                 :             :         return false;
    1651                 :             :       }
    1652                 :             : 
    1653                 :             :     case DEMANGLE_COMPONENT_OPERATOR:
    1654                 :             :       /* Operator mismatches are handled above.  */
    1655                 :             :       return false;
    1656                 :             : 
    1657                 :           0 :     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
    1658                 :           0 :       if (newc.u.s_extended_operator.args != delc.u.s_extended_operator.args)
    1659                 :             :         return true;
    1660                 :           0 :       return new_delete_mismatch_p (*newc.u.s_extended_operator.name,
    1661                 :           0 :                                     *delc.u.s_extended_operator.name);
    1662                 :             : 
    1663                 :           0 :     case DEMANGLE_COMPONENT_FIXED_TYPE:
    1664                 :           0 :       if (newc.u.s_fixed.accum != delc.u.s_fixed.accum
    1665                 :           0 :           || newc.u.s_fixed.sat != delc.u.s_fixed.sat)
    1666                 :             :         return true;
    1667                 :           0 :       return new_delete_mismatch_p (*newc.u.s_fixed.length,
    1668                 :           0 :                                     *delc.u.s_fixed.length);
    1669                 :             : 
    1670                 :           0 :     case DEMANGLE_COMPONENT_CTOR:
    1671                 :           0 :       if (newc.u.s_ctor.kind != delc.u.s_ctor.kind)
    1672                 :             :         return true;
    1673                 :           0 :       return new_delete_mismatch_p (*newc.u.s_ctor.name,
    1674                 :           0 :                                     *delc.u.s_ctor.name);
    1675                 :             : 
    1676                 :           0 :     case DEMANGLE_COMPONENT_DTOR:
    1677                 :           0 :       if (newc.u.s_dtor.kind != delc.u.s_dtor.kind)
    1678                 :             :         return true;
    1679                 :           0 :       return new_delete_mismatch_p (*newc.u.s_dtor.name,
    1680                 :           0 :                                     *delc.u.s_dtor.name);
    1681                 :             : 
    1682                 :         201 :     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
    1683                 :         201 :       {
    1684                 :             :         /* The demangler API provides no better way to compare built-in
    1685                 :             :            types except to by comparing their demangled names. */
    1686                 :         201 :         size_t nsz, dsz;
    1687                 :         201 :         demangle_component *pnc = const_cast<demangle_component *>(&newc);
    1688                 :         201 :         demangle_component *pdc = const_cast<demangle_component *>(&delc);
    1689                 :         201 :         char *nts = cplus_demangle_print (0, pnc, 16, &nsz);
    1690                 :         201 :         char *dts = cplus_demangle_print (0, pdc, 16, &dsz);
    1691                 :         201 :         if (!nts != !dts)
    1692                 :             :           return true;
    1693                 :         201 :         bool mismatch = strcmp (nts, dts);
    1694                 :         201 :         free (nts);
    1695                 :         201 :         free (dts);
    1696                 :         201 :         return mismatch;
    1697                 :             :       }
    1698                 :             : 
    1699                 :           0 :     case DEMANGLE_COMPONENT_SUB_STD:
    1700                 :           0 :       if (newc.u.s_string.len != delc.u.s_string.len)
    1701                 :             :         return true;
    1702                 :           0 :       return memcmp (newc.u.s_string.string, delc.u.s_string.string,
    1703                 :           0 :                      newc.u.s_string.len);
    1704                 :             : 
    1705                 :           3 :     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
    1706                 :           3 :     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
    1707                 :           3 :     case DEMANGLE_COMPONENT_UNNAMED_TYPE:
    1708                 :           3 :       return newc.u.s_number.number != delc.u.s_number.number;
    1709                 :             : 
    1710                 :           0 :     case DEMANGLE_COMPONENT_CHARACTER:
    1711                 :           0 :       return newc.u.s_character.character != delc.u.s_character.character;
    1712                 :             : 
    1713                 :           0 :     case DEMANGLE_COMPONENT_DEFAULT_ARG:
    1714                 :           0 :     case DEMANGLE_COMPONENT_LAMBDA:
    1715                 :           0 :       if (newc.u.s_unary_num.num != delc.u.s_unary_num.num)
    1716                 :             :         return true;
    1717                 :           0 :       return new_delete_mismatch_p (*newc.u.s_unary_num.sub,
    1718                 :           0 :                                     *delc.u.s_unary_num.sub);
    1719                 :        1002 :     default:
    1720                 :        1002 :       break;
    1721                 :             :     }
    1722                 :             : 
    1723                 :        1002 :   if (!newc.u.s_binary.left != !delc.u.s_binary.left)
    1724                 :             :     return true;
    1725                 :             : 
    1726                 :        1002 :   if (!newc.u.s_binary.left)
    1727                 :             :     return false;
    1728                 :             : 
    1729                 :         991 :   if (new_delete_mismatch_p (*newc.u.s_binary.left, *delc.u.s_binary.left)
    1730                 :         991 :       || !newc.u.s_binary.right != !delc.u.s_binary.right)
    1731                 :             :     return true;
    1732                 :             : 
    1733                 :         892 :   if (newc.u.s_binary.right)
    1734                 :             :     return new_delete_mismatch_p (*newc.u.s_binary.right,
    1735                 :             :                                   *delc.u.s_binary.right);
    1736                 :             :   return false;
    1737                 :             : }
    1738                 :             : 
    1739                 :             : /* Return true if DELETE_DECL is an operator delete that's not suitable
    1740                 :             :    to call with a pointer returned from NEW_DECL.  */
    1741                 :             : 
    1742                 :             : static bool
    1743                 :        8004 : new_delete_mismatch_p (tree new_decl, tree delete_decl)
    1744                 :             : {
    1745                 :        8004 :   tree new_name = DECL_ASSEMBLER_NAME (new_decl);
    1746                 :        8004 :   tree delete_name = DECL_ASSEMBLER_NAME (delete_decl);
    1747                 :             : 
    1748                 :             :   /* valid_new_delete_pair_p() returns a conservative result (currently
    1749                 :             :      it only handles global operators).  A true result is reliable but
    1750                 :             :      a false result doesn't necessarily mean the operators don't match
    1751                 :             :      unless CERTAIN is set.  */
    1752                 :        8004 :   bool certain;
    1753                 :        8004 :   if (valid_new_delete_pair_p (new_name, delete_name, &certain))
    1754                 :             :     return false;
    1755                 :             :   /* CERTAIN is set when the negative result is certain.  */
    1756                 :         406 :   if (certain)
    1757                 :             :     return true;
    1758                 :             : 
    1759                 :             :   /* For anything not handled by valid_new_delete_pair_p() such as member
    1760                 :             :      operators compare the individual demangled components of the mangled
    1761                 :             :      name.  */
    1762                 :         360 :   const char *new_str = IDENTIFIER_POINTER (new_name);
    1763                 :         360 :   const char *del_str = IDENTIFIER_POINTER (delete_name);
    1764                 :             : 
    1765                 :         360 :   void *np = NULL, *dp = NULL;
    1766                 :         360 :   demangle_component *ndc = cplus_demangle_v3_components (new_str, 0, &np);
    1767                 :         360 :   demangle_component *ddc = cplus_demangle_v3_components (del_str, 0, &dp);
    1768                 :         360 :   bool mismatch = ndc && ddc && new_delete_mismatch_p (*ndc, *ddc);
    1769                 :         360 :   free (np);
    1770                 :         360 :   free (dp);
    1771                 :         360 :   return mismatch;
    1772                 :             : }
    1773                 :             : 
    1774                 :             : /* ALLOC_DECL and DEALLOC_DECL are pair of allocation and deallocation
    1775                 :             :    functions.  Return true if the latter is suitable to deallocate objects
    1776                 :             :    allocated by calls to the former.  */
    1777                 :             : 
    1778                 :             : static bool
    1779                 :       38994 : matching_alloc_calls_p (tree alloc_decl, tree dealloc_decl)
    1780                 :             : {
    1781                 :             :   /* Set to alloc_kind_t::builtin if ALLOC_DECL is associated with
    1782                 :             :      a built-in deallocator.  */
    1783                 :       38994 :   enum class alloc_kind_t { none, builtin, user }
    1784                 :       38994 :   alloc_dealloc_kind = alloc_kind_t::none;
    1785                 :             : 
    1786                 :       38994 :   if (DECL_IS_OPERATOR_NEW_P (alloc_decl))
    1787                 :             :     {
    1788                 :        8028 :       if (DECL_IS_OPERATOR_DELETE_P (dealloc_decl))
    1789                 :             :         /* Return true iff both functions are of the same array or
    1790                 :             :            singleton form and false otherwise.  */
    1791                 :        8004 :         return !new_delete_mismatch_p (alloc_decl, dealloc_decl);
    1792                 :             : 
    1793                 :             :       /* Return false for deallocation functions that are known not
    1794                 :             :          to match.  */
    1795                 :          24 :       if (fndecl_built_in_p (dealloc_decl, BUILT_IN_FREE, BUILT_IN_REALLOC))
    1796                 :             :         return false;
    1797                 :             :       /* Otherwise proceed below to check the deallocation function's
    1798                 :             :          "*dealloc" attributes to look for one that mentions this operator
    1799                 :             :          new.  */
    1800                 :             :     }
    1801                 :       30966 :   else if (fndecl_built_in_p (alloc_decl, BUILT_IN_NORMAL))
    1802                 :             :     {
    1803                 :       30227 :       switch (DECL_FUNCTION_CODE (alloc_decl))
    1804                 :             :         {
    1805                 :             :         case BUILT_IN_ALLOCA:
    1806                 :             :         case BUILT_IN_ALLOCA_WITH_ALIGN:
    1807                 :             :           return false;
    1808                 :             : 
    1809                 :        1189 :         case BUILT_IN_GOMP_ALLOC:
    1810                 :        1189 :         case BUILT_IN_GOMP_REALLOC:
    1811                 :        1189 :           if (DECL_IS_OPERATOR_DELETE_P (dealloc_decl))
    1812                 :             :             return false;
    1813                 :             : 
    1814                 :        1189 :           if (fndecl_built_in_p (dealloc_decl, BUILT_IN_GOMP_FREE,
    1815                 :             :                                                BUILT_IN_GOMP_REALLOC))
    1816                 :             :             return true;
    1817                 :             : 
    1818                 :             :           alloc_dealloc_kind = alloc_kind_t::builtin;
    1819                 :             :           break;
    1820                 :             : 
    1821                 :       29038 :         case BUILT_IN_ALIGNED_ALLOC:
    1822                 :       29038 :         case BUILT_IN_CALLOC:
    1823                 :       29038 :         case BUILT_IN_MALLOC:
    1824                 :       29038 :         case BUILT_IN_REALLOC:
    1825                 :       29038 :         case BUILT_IN_STRDUP:
    1826                 :       29038 :         case BUILT_IN_STRNDUP:
    1827                 :       29038 :           if (DECL_IS_OPERATOR_DELETE_P (dealloc_decl))
    1828                 :             :             return false;
    1829                 :             : 
    1830                 :       28965 :           if (fndecl_built_in_p (dealloc_decl, BUILT_IN_FREE,
    1831                 :             :                                                BUILT_IN_REALLOC))
    1832                 :             :             return true;
    1833                 :             : 
    1834                 :             :           alloc_dealloc_kind = alloc_kind_t::builtin;
    1835                 :             :           break;
    1836                 :             : 
    1837                 :             :         default:
    1838                 :             :           break;
    1839                 :             :         }
    1840                 :             :     }
    1841                 :             : 
    1842                 :             :   /* Set if DEALLOC_DECL both allocates and deallocates.  */
    1843                 :         779 :   alloc_kind_t realloc_kind = alloc_kind_t::none;
    1844                 :             : 
    1845                 :         779 :   if (fndecl_built_in_p (dealloc_decl, BUILT_IN_NORMAL))
    1846                 :             :     {
    1847                 :         127 :       built_in_function dealloc_code = DECL_FUNCTION_CODE (dealloc_decl);
    1848                 :         127 :       if (dealloc_code == BUILT_IN_REALLOC
    1849                 :         127 :           || dealloc_code == BUILT_IN_GOMP_REALLOC)
    1850                 :          26 :         realloc_kind = alloc_kind_t::builtin;
    1851                 :             : 
    1852                 :         127 :       for (tree amats = DECL_ATTRIBUTES (alloc_decl);
    1853                 :         221 :            (amats = lookup_attribute ("malloc", amats));
    1854                 :          94 :            amats = TREE_CHAIN (amats))
    1855                 :             :         {
    1856                 :         160 :           tree args = TREE_VALUE (amats);
    1857                 :         160 :           if (!args)
    1858                 :           0 :             continue;
    1859                 :             : 
    1860                 :         160 :           tree fndecl = TREE_VALUE (args);
    1861                 :         160 :           if (!fndecl || !DECL_P (fndecl))
    1862                 :           0 :             continue;
    1863                 :             : 
    1864                 :         160 :           if (fndecl_built_in_p (fndecl, BUILT_IN_NORMAL)
    1865                 :         160 :               && dealloc_code == DECL_FUNCTION_CODE (fndecl))
    1866                 :             :             return true;
    1867                 :             :         }
    1868                 :             :     }
    1869                 :             : 
    1870                 :         713 :   const bool alloc_builtin = fndecl_built_in_p (alloc_decl, BUILT_IN_NORMAL);
    1871                 :         713 :   alloc_kind_t realloc_dealloc_kind = alloc_kind_t::none;
    1872                 :             : 
    1873                 :             :   /* If DEALLOC_DECL has an internal "*dealloc" attribute scan the list
    1874                 :             :      of its associated allocation functions for ALLOC_DECL.
    1875                 :             :      If the corresponding ALLOC_DECL is found they're a matching pair,
    1876                 :             :      otherwise they're not.
    1877                 :             :      With DDATS set to the Deallocator's *Dealloc ATtributes...  */
    1878                 :         713 :   for (tree ddats = DECL_ATTRIBUTES (dealloc_decl);
    1879                 :        2435 :        (ddats = lookup_attribute ("*dealloc", ddats));
    1880                 :        1722 :        ddats = TREE_CHAIN (ddats))
    1881                 :             :     {
    1882                 :        2268 :       tree args = TREE_VALUE (ddats);
    1883                 :        2268 :       if (!args)
    1884                 :           0 :         continue;
    1885                 :             : 
    1886                 :        2268 :       tree alloc = TREE_VALUE (args);
    1887                 :        2268 :       if (!alloc)
    1888                 :           0 :         continue;
    1889                 :             : 
    1890                 :        2268 :       if (alloc == DECL_NAME (dealloc_decl))
    1891                 :          44 :         realloc_kind = alloc_kind_t::user;
    1892                 :             : 
    1893                 :        2268 :       if (DECL_P (alloc))
    1894                 :             :         {
    1895                 :           0 :           gcc_checking_assert (fndecl_built_in_p (alloc, BUILT_IN_NORMAL));
    1896                 :             : 
    1897                 :           0 :           switch (DECL_FUNCTION_CODE (alloc))
    1898                 :             :             {
    1899                 :           0 :             case BUILT_IN_ALIGNED_ALLOC:
    1900                 :           0 :             case BUILT_IN_CALLOC:
    1901                 :           0 :             case BUILT_IN_GOMP_ALLOC:
    1902                 :           0 :             case BUILT_IN_GOMP_REALLOC:
    1903                 :           0 :             case BUILT_IN_MALLOC:
    1904                 :           0 :             case BUILT_IN_REALLOC:
    1905                 :           0 :             case BUILT_IN_STRDUP:
    1906                 :           0 :             case BUILT_IN_STRNDUP:
    1907                 :           0 :               realloc_dealloc_kind = alloc_kind_t::builtin;
    1908                 :           0 :               break;
    1909                 :             :             default:
    1910                 :             :               break;
    1911                 :             :             }
    1912                 :             : 
    1913                 :           0 :           if (!alloc_builtin)
    1914                 :           0 :             continue;
    1915                 :             : 
    1916                 :           0 :           if (DECL_FUNCTION_CODE (alloc) != DECL_FUNCTION_CODE (alloc_decl))
    1917                 :           0 :             continue;
    1918                 :             : 
    1919                 :             :           return true;
    1920                 :             :         }
    1921                 :             : 
    1922                 :        2268 :       if (alloc == DECL_NAME (alloc_decl))
    1923                 :             :         return true;
    1924                 :             :     }
    1925                 :             : 
    1926                 :         167 :   if (realloc_kind == alloc_kind_t::none)
    1927                 :             :     return false;
    1928                 :             : 
    1929                 :         108 :   hash_set<tree> common_deallocs;
    1930                 :             :   /* Special handling for deallocators.  Iterate over both the allocator's
    1931                 :             :      and the reallocator's associated deallocator functions looking for
    1932                 :             :      the first one in common.  If one is found, the de/reallocator is
    1933                 :             :      a match for the allocator even though the latter isn't directly
    1934                 :             :      associated with the former.  This simplifies declarations in system
    1935                 :             :      headers.
    1936                 :             :      With AMATS set to the Allocator's Malloc ATtributes,
    1937                 :             :      and  RMATS set to Reallocator's Malloc ATtributes...  */
    1938                 :          54 :   for (tree amats = DECL_ATTRIBUTES (alloc_decl),
    1939                 :          54 :          rmats = DECL_ATTRIBUTES (dealloc_decl);
    1940                 :         260 :        (amats = lookup_attribute ("malloc", amats))
    1941                 :         130 :          || (rmats = lookup_attribute ("malloc", rmats));
    1942                 :          59 :        amats = amats ? TREE_CHAIN (amats) : NULL_TREE,
    1943                 :          76 :          rmats = rmats ? TREE_CHAIN (rmats) : NULL_TREE)
    1944                 :             :     {
    1945                 :         171 :       if (tree args = amats ? TREE_VALUE (amats) : NULL_TREE)
    1946                 :          57 :         if (tree adealloc = TREE_VALUE (args))
    1947                 :             :           {
    1948                 :          57 :             if (DECL_P (adealloc)
    1949                 :          57 :                 && fndecl_built_in_p (adealloc, BUILT_IN_NORMAL))
    1950                 :             :               {
    1951                 :          12 :                 built_in_function fncode = DECL_FUNCTION_CODE (adealloc);
    1952                 :          12 :                 if (fncode == BUILT_IN_FREE || fncode == BUILT_IN_REALLOC)
    1953                 :             :                   {
    1954                 :          12 :                     if (realloc_kind == alloc_kind_t::builtin)
    1955                 :           8 :                       return true;
    1956                 :             :                     alloc_dealloc_kind = alloc_kind_t::builtin;
    1957                 :             :                   }
    1958                 :           4 :                 continue;
    1959                 :           4 :               }
    1960                 :             : 
    1961                 :          45 :             common_deallocs.add (adealloc);
    1962                 :             :           }
    1963                 :             : 
    1964                 :         228 :       if (tree args = rmats ? TREE_VALUE (rmats) : NULL_TREE)
    1965                 :          60 :         if (tree ddealloc = TREE_VALUE (args))
    1966                 :             :           {
    1967                 :          60 :             if (DECL_P (ddealloc)
    1968                 :          60 :                 && fndecl_built_in_p (ddealloc, BUILT_IN_NORMAL))
    1969                 :             :               {
    1970                 :          16 :                 built_in_function fncode = DECL_FUNCTION_CODE (ddealloc);
    1971                 :          16 :                 if (fncode == BUILT_IN_FREE || fncode == BUILT_IN_REALLOC)
    1972                 :             :                   {
    1973                 :          16 :                     if (alloc_dealloc_kind == alloc_kind_t::builtin)
    1974                 :          20 :                       return true;
    1975                 :             :                     realloc_dealloc_kind = alloc_kind_t::builtin;
    1976                 :             :                   }
    1977                 :           1 :                 continue;
    1978                 :           1 :               }
    1979                 :             : 
    1980                 :          44 :             if (common_deallocs.add (ddealloc))
    1981                 :             :               return true;
    1982                 :             :           }
    1983                 :             :     }
    1984                 :             : 
    1985                 :             :   /* Succeed only if ALLOC_DECL and the reallocator DEALLOC_DECL share
    1986                 :             :      a built-in deallocator.  */
    1987                 :          26 :   return  (alloc_dealloc_kind == alloc_kind_t::builtin
    1988                 :          26 :            && realloc_dealloc_kind == alloc_kind_t::builtin);
    1989                 :             : }
    1990                 :             : 
    1991                 :             : /* Return true if DEALLOC_DECL is a function suitable to deallocate
    1992                 :             :    objects allocated by the ALLOC call.  */
    1993                 :             : 
    1994                 :             : static bool
    1995                 :       38994 : matching_alloc_calls_p (gimple *alloc, tree dealloc_decl)
    1996                 :             : {
    1997                 :       38994 :   tree alloc_decl = gimple_call_fndecl (alloc);
    1998                 :       38994 :   if (!alloc_decl)
    1999                 :             :     return true;
    2000                 :             : 
    2001                 :       38994 :   return matching_alloc_calls_p (alloc_decl, dealloc_decl);
    2002                 :             : }
    2003                 :             : 
    2004                 :             : /* Diagnose a call EXP to deallocate a pointer referenced by AREF if it
    2005                 :             :    includes a nonzero offset.  Such a pointer cannot refer to the beginning
    2006                 :             :    of an allocated object.  A negative offset may refer to it only if
    2007                 :             :    the target pointer is unknown.  */
    2008                 :             : 
    2009                 :             : static bool
    2010                 :      145546 : warn_dealloc_offset (location_t loc, gimple *call, const access_ref &aref)
    2011                 :             : {
    2012                 :      145546 :   if (aref.deref || aref.offrng[0] <= 0 || aref.offrng[1] <= 0)
    2013                 :      145471 :     return false;
    2014                 :             : 
    2015                 :          75 :   tree dealloc_decl = gimple_call_fndecl (call);
    2016                 :          75 :   if (!dealloc_decl)
    2017                 :             :     return false;
    2018                 :             : 
    2019                 :          75 :   if (DECL_IS_OPERATOR_DELETE_P (dealloc_decl)
    2020                 :          75 :       && !DECL_IS_REPLACEABLE_OPERATOR (dealloc_decl))
    2021                 :             :     {
    2022                 :             :       /* A call to a user-defined operator delete with a pointer plus offset
    2023                 :             :          may be valid if it's returned from an unknown function (i.e., one
    2024                 :             :          that's not operator new).  */
    2025                 :           6 :       if (TREE_CODE (aref.ref) == SSA_NAME)
    2026                 :             :         {
    2027                 :           6 :           gimple *def_stmt = SSA_NAME_DEF_STMT (aref.ref);
    2028                 :           6 :           if (is_gimple_call (def_stmt))
    2029                 :             :             {
    2030                 :           6 :               tree alloc_decl = gimple_call_fndecl (def_stmt);
    2031                 :           9 :               if (!alloc_decl || !DECL_IS_OPERATOR_NEW_P (alloc_decl))
    2032                 :             :                 return false;
    2033                 :             :             }
    2034                 :             :         }
    2035                 :             :     }
    2036                 :             : 
    2037                 :          69 :   char offstr[80];
    2038                 :          69 :   offstr[0] = '\0';
    2039                 :          69 :   if (wi::fits_shwi_p (aref.offrng[0]))
    2040                 :             :     {
    2041                 :          69 :       if (aref.offrng[0] == aref.offrng[1]
    2042                 :          69 :           || !wi::fits_shwi_p (aref.offrng[1]))
    2043                 :          55 :         sprintf (offstr, " %lli",
    2044                 :          55 :                  (long long)aref.offrng[0].to_shwi ());
    2045                 :             :       else
    2046                 :          14 :         sprintf (offstr, " [%lli, %lli]",
    2047                 :          14 :                  (long long)aref.offrng[0].to_shwi (),
    2048                 :          14 :                  (long long)aref.offrng[1].to_shwi ());
    2049                 :             :     }
    2050                 :             : 
    2051                 :          69 :   auto_diagnostic_group d;
    2052                 :          69 :   if (!warning_at (loc, OPT_Wfree_nonheap_object,
    2053                 :             :                    "%qD called on pointer %qE with nonzero offset%s",
    2054                 :          69 :                    dealloc_decl, aref.ref, offstr))
    2055                 :             :     return false;
    2056                 :             : 
    2057                 :          69 :   if (DECL_P (aref.ref))
    2058                 :           8 :     inform (get_location (aref.ref), "declared here");
    2059                 :          61 :   else if (TREE_CODE (aref.ref) == SSA_NAME)
    2060                 :             :     {
    2061                 :          59 :       gimple *def_stmt = SSA_NAME_DEF_STMT (aref.ref);
    2062                 :          59 :       if (is_gimple_call (def_stmt))
    2063                 :             :         {
    2064                 :          53 :           location_t def_loc = get_location (def_stmt);
    2065                 :          53 :           tree alloc_decl = gimple_call_fndecl (def_stmt);
    2066                 :          53 :           if (alloc_decl)
    2067                 :          53 :             inform (def_loc,
    2068                 :             :                     "returned from %qD", alloc_decl);
    2069                 :           0 :           else if (tree alloc_fntype = gimple_call_fntype (def_stmt))
    2070                 :           0 :             inform (def_loc,
    2071                 :             :                     "returned from %qT", alloc_fntype);
    2072                 :             :           else
    2073                 :           0 :             inform (def_loc,  "obtained here");
    2074                 :             :         }
    2075                 :             :     }
    2076                 :             : 
    2077                 :             :   return true;
    2078                 :          69 : }
    2079                 :             : 
    2080                 :             : namespace {
    2081                 :             : 
    2082                 :             : const pass_data pass_data_waccess = {
    2083                 :             :   GIMPLE_PASS,
    2084                 :             :   "waccess",
    2085                 :             :   OPTGROUP_NONE,
    2086                 :             :   TV_WARN_ACCESS, /* timer variable */
    2087                 :             :   PROP_cfg, /* properties_required  */
    2088                 :             :   0,        /* properties_provided  */
    2089                 :             :   0,        /* properties_destroyed  */
    2090                 :             :   0,        /* properties_start */
    2091                 :             :   0,        /* properties_finish */
    2092                 :             : };
    2093                 :             : 
    2094                 :             : /* Pass to detect invalid accesses.  */
    2095                 :             : class pass_waccess : public gimple_opt_pass
    2096                 :             : {
    2097                 :             :  public:
    2098                 :             :   pass_waccess (gcc::context *);
    2099                 :             : 
    2100                 :             :   ~pass_waccess ();
    2101                 :             : 
    2102                 :             :   opt_pass *clone () final override;
    2103                 :             : 
    2104                 :             :   bool gate (function *) final override;
    2105                 :             : 
    2106                 :             :   void set_pass_param (unsigned, bool) final override;
    2107                 :             : 
    2108                 :             :   unsigned int execute (function *) final override;
    2109                 :             : 
    2110                 :             : private:
    2111                 :             :   /* Not copyable or assignable.  */
    2112                 :             :   pass_waccess (pass_waccess &) = delete;
    2113                 :             :   void operator= (pass_waccess &) = delete;
    2114                 :             : 
    2115                 :             :   /* Check a call to an atomic built-in function.  */
    2116                 :             :   bool check_atomic_builtin (gcall *);
    2117                 :             : 
    2118                 :             :   /* Check a call to a built-in function.  */
    2119                 :             :   bool check_builtin (gcall *);
    2120                 :             : 
    2121                 :             :   /* Check a call to an ordinary function for invalid accesses.  */
    2122                 :             :   bool check_call_access (gcall *);
    2123                 :             : 
    2124                 :             :   /* Check a non-call statement.  */
    2125                 :             :   void check_stmt (gimple *);
    2126                 :             : 
    2127                 :             :   /* Check statements in a basic block.  */
    2128                 :             :   void check_block (basic_block);
    2129                 :             : 
    2130                 :             :   /* Check a call to a function.  */
    2131                 :             :   void check_call (gcall *);
    2132                 :             : 
    2133                 :             :   /* Check a call to the named built-in function.  */
    2134                 :             :   void check_alloca (gcall *);
    2135                 :             :   void check_alloc_size_call (gcall *);
    2136                 :             :   void check_strcat (gcall *);
    2137                 :             :   void check_strncat (gcall *);
    2138                 :             :   void check_stxcpy (gcall *);
    2139                 :             :   void check_stxncpy (gcall *);
    2140                 :             :   void check_strncmp (gcall *);
    2141                 :             :   void check_memop_access (gimple *, tree, tree, tree);
    2142                 :             :   void check_read_access (gimple *, tree, tree = NULL_TREE, int = 1);
    2143                 :             : 
    2144                 :             :   void maybe_check_dealloc_call (gcall *);
    2145                 :             :   void maybe_check_access_sizes (rdwr_map *, tree, tree, gimple *);
    2146                 :             :   bool maybe_warn_memmodel (gimple *, tree, tree, const unsigned char *);
    2147                 :             :   void check_atomic_memmodel (gimple *, tree, tree, const unsigned char *);
    2148                 :             : 
    2149                 :             :   /* Check for uses of indeterminate pointers.  */
    2150                 :             :   void check_pointer_uses (gimple *, tree, tree = NULL_TREE, bool = false);
    2151                 :             : 
    2152                 :             :   /* Return the argument that a call returns.  */
    2153                 :             :   tree gimple_call_return_arg (gcall *);
    2154                 :             : 
    2155                 :             :   /* Check a call for uses of a dangling pointer arguments.  */
    2156                 :             :   void check_call_dangling (gcall *);
    2157                 :             : 
    2158                 :             :   /* Check uses of a dangling pointer or those derived from it.  */
    2159                 :             :   void check_dangling_uses (tree, tree, bool = false, bool = false);
    2160                 :             :   void check_dangling_uses ();
    2161                 :             :   void check_dangling_stores ();
    2162                 :             :   bool check_dangling_stores (basic_block, hash_set<tree> &);
    2163                 :             : 
    2164                 :             :   void warn_invalid_pointer (tree, gimple *, gimple *, tree, bool, bool = false);
    2165                 :             : 
    2166                 :             :   /* Return true if use follows an invalidating statement.  */
    2167                 :             :   bool use_after_inval_p (gimple *, gimple *, bool = false);
    2168                 :             : 
    2169                 :             :   /* A pointer_query object to store information about pointers and
    2170                 :             :      their targets in.  */
    2171                 :             :   pointer_query m_ptr_qry;
    2172                 :             :   /* Mapping from DECLs and their clobber statements in the function.  */
    2173                 :             :   hash_map<tree, gimple *> m_clobbers;
    2174                 :             :   /* A bit is set for each basic block whose statements have been assigned
    2175                 :             :      valid UIDs.  */
    2176                 :             :   bitmap m_bb_uids_set;
    2177                 :             :   /* The current function.  */
    2178                 :             :   function *m_func;
    2179                 :             :   /* True to run checks for uses of dangling pointers.  */
    2180                 :             :   bool m_check_dangling_p;
    2181                 :             :   /* True to run checks early on in the optimization pipeline.  */
    2182                 :             :   bool m_early_checks_p;
    2183                 :             : };
    2184                 :             : 
    2185                 :             : /* Construct the pass.  */
    2186                 :             : 
    2187                 :      813438 : pass_waccess::pass_waccess (gcc::context *ctxt)
    2188                 :             :   : gimple_opt_pass (pass_data_waccess, ctxt),
    2189                 :      813438 :     m_ptr_qry (NULL),
    2190                 :      813438 :     m_clobbers (),
    2191                 :      813438 :     m_bb_uids_set (),
    2192                 :      813438 :     m_func (),
    2193                 :      813438 :     m_check_dangling_p (),
    2194                 :      813438 :     m_early_checks_p ()
    2195                 :             : {
    2196                 :      813438 : }
    2197                 :             : 
    2198                 :             : /* Return a copy of the pass with RUN_NUMBER one greater than THIS.  */
    2199                 :             : 
    2200                 :             : opt_pass*
    2201                 :      542292 : pass_waccess::clone ()
    2202                 :             : {
    2203                 :      542292 :   return new pass_waccess (m_ctxt);
    2204                 :             : }
    2205                 :             : 
    2206                 :             : /* Release pointer_query cache.  */
    2207                 :             : 
    2208                 :     1465632 : pass_waccess::~pass_waccess ()
    2209                 :             : {
    2210                 :      732816 :   m_ptr_qry.flush_cache ();
    2211                 :     1465632 : }
    2212                 :             : 
    2213                 :             : void
    2214                 :      813438 : pass_waccess::set_pass_param (unsigned int n, bool early)
    2215                 :             : {
    2216                 :      813438 :   gcc_assert (n == 0);
    2217                 :             : 
    2218                 :      813438 :   m_early_checks_p = early;
    2219                 :      813438 : }
    2220                 :             : 
    2221                 :             : /* Return true when any checks performed by the pass are enabled.  */
    2222                 :             : 
    2223                 :             : bool
    2224                 :     5096506 : pass_waccess::gate (function *)
    2225                 :             : {
    2226                 :     5096506 :   return (warn_free_nonheap_object
    2227                 :             :           || warn_mismatched_alloc
    2228                 :     5096506 :           || warn_mismatched_new_delete);
    2229                 :             : }
    2230                 :             : 
    2231                 :             : /* Initialize ALLOC_OBJECT_SIZE_LIMIT based on the -Walloc-size-larger-than=
    2232                 :             :    setting if the option is specified, or to the maximum object size if it
    2233                 :             :    is not.  Return the initialized value.  */
    2234                 :             : 
    2235                 :             : static tree
    2236                 :       47085 : alloc_max_size (void)
    2237                 :             : {
    2238                 :       47085 :   HOST_WIDE_INT limit = warn_alloc_size_limit;
    2239                 :       47085 :   if (limit == HOST_WIDE_INT_MAX)
    2240                 :       46689 :     limit = tree_to_shwi (TYPE_MAX_VALUE (ptrdiff_type_node));
    2241                 :             : 
    2242                 :       47085 :   return build_int_cst (size_type_node, limit);
    2243                 :             : }
    2244                 :             : 
    2245                 :             : /* Diagnose a call EXP to function FN decorated with attribute alloc_size
    2246                 :             :    whose argument numbers given by IDX with values given by ARGS exceed
    2247                 :             :    the maximum object size or cause an unsigned overflow (wrapping) when
    2248                 :             :    multiplied.  FN is null when EXP is a call via a function pointer.
    2249                 :             :    When ARGS[0] is null the function does nothing.  ARGS[1] may be null
    2250                 :             :    for functions like malloc, and non-null for those like calloc that
    2251                 :             :    are decorated with a two-argument attribute alloc_size.  */
    2252                 :             : 
    2253                 :             : void
    2254                 :       47085 : maybe_warn_alloc_args_overflow (gimple *stmt, const tree args[2],
    2255                 :             :                                 const int idx[2])
    2256                 :             : {
    2257                 :             :   /* The range each of the (up to) two arguments is known to be in.  */
    2258                 :       47085 :   tree argrange[2][2] = { { NULL_TREE, NULL_TREE }, { NULL_TREE, NULL_TREE } };
    2259                 :             : 
    2260                 :             :   /* Maximum object size set by -Walloc-size-larger-than= or SIZE_MAX / 2.  */
    2261                 :       47085 :   tree maxobjsize = alloc_max_size ();
    2262                 :             : 
    2263                 :       47085 :   location_t loc = get_location (stmt);
    2264                 :             : 
    2265                 :       47085 :   tree fn = gimple_call_fndecl (stmt);
    2266                 :       47085 :   tree fntype = fn ? TREE_TYPE (fn) : gimple_call_fntype (stmt);
    2267                 :       47085 :   bool warned = false;
    2268                 :             : 
    2269                 :             :   /* Validate each argument individually.  */
    2270                 :       95353 :   for (unsigned i = 0; i != 2 && args[i]; ++i)
    2271                 :             :     {
    2272                 :       48268 :       if (TREE_CODE (args[i]) == INTEGER_CST)
    2273                 :             :         {
    2274                 :       30840 :           argrange[i][0] = args[i];
    2275                 :       30840 :           argrange[i][1] = args[i];
    2276                 :             : 
    2277                 :       30840 :           if (tree_int_cst_lt (args[i], integer_zero_node))
    2278                 :             :             {
    2279                 :          24 :               warned = warning_at (loc, OPT_Walloc_size_larger_than_,
    2280                 :             :                                    "argument %i value %qE is negative",
    2281                 :          24 :                                    idx[i] + 1, args[i]);
    2282                 :             :             }
    2283                 :       30816 :           else if (integer_zerop (args[i]))
    2284                 :             :             {
    2285                 :             :               /* Avoid issuing -Walloc-zero for allocation functions other
    2286                 :             :                  than __builtin_alloca that are declared with attribute
    2287                 :             :                  returns_nonnull because there's no portability risk.  This
    2288                 :             :                  avoids warning for such calls to libiberty's xmalloc and
    2289                 :             :                  friends.
    2290                 :             :                  Also avoid issuing the warning for calls to function named
    2291                 :             :                  "alloca".  */
    2292                 :         942 :               if (fn && fndecl_built_in_p (fn, BUILT_IN_ALLOCA)
    2293                 :         964 :                   ? IDENTIFIER_LENGTH (DECL_NAME (fn)) != 6
    2294                 :         482 :                   : !lookup_attribute ("returns_nonnull",
    2295                 :         482 :                                        TYPE_ATTRIBUTES (fntype)))
    2296                 :         475 :                 warned = warning_at (loc, OPT_Walloc_zero,
    2297                 :             :                                      "argument %i value is zero",
    2298                 :         475 :                                      idx[i] + 1);
    2299                 :             :             }
    2300                 :       30334 :           else if (tree_int_cst_lt (maxobjsize, args[i]))
    2301                 :             :             {
    2302                 :             :               /* G++ emits calls to ::operator new[](SIZE_MAX) in C++98
    2303                 :             :                  mode and with -fno-exceptions as a way to indicate array
    2304                 :             :                  size overflow.  There's no good way to detect C++98 here
    2305                 :             :                  so avoid diagnosing these calls for all C++ modes.  */
    2306                 :         112 :               if (i == 0
    2307                 :          95 :                   && fn
    2308                 :          79 :                   && !args[1]
    2309                 :          73 :                   && lang_GNU_CXX ()
    2310                 :          17 :                   && DECL_IS_OPERATOR_NEW_P (fn)
    2311                 :         112 :                   && integer_all_onesp (args[i]))
    2312                 :          17 :                 continue;
    2313                 :             : 
    2314                 :          78 :               warned = warning_at (loc, OPT_Walloc_size_larger_than_,
    2315                 :             :                                    "argument %i value %qE exceeds "
    2316                 :             :                                    "maximum object size %E",
    2317                 :          78 :                                    idx[i] + 1, args[i], maxobjsize);
    2318                 :             :             }
    2319                 :             :         }
    2320                 :       17428 :       else if (TREE_CODE (args[i]) == SSA_NAME
    2321                 :       17428 :                && get_size_range (args[i], argrange[i]))
    2322                 :             :         {
    2323                 :             :           /* Verify that the argument's range is not negative (including
    2324                 :             :              upper bound of zero).  */
    2325                 :       17415 :           if (tree_int_cst_lt (argrange[i][0], integer_zero_node)
    2326                 :       17415 :               && tree_int_cst_le (argrange[i][1], integer_zero_node))
    2327                 :             :             {
    2328                 :          31 :               warned = warning_at (loc, OPT_Walloc_size_larger_than_,
    2329                 :             :                                    "argument %i range [%E, %E] is negative",
    2330                 :          31 :                                    idx[i] + 1,
    2331                 :             :                                    argrange[i][0], argrange[i][1]);
    2332                 :             :             }
    2333                 :       17384 :           else if (tree_int_cst_lt (maxobjsize, argrange[i][0]))
    2334                 :             :             {
    2335                 :          31 :               warned = warning_at (loc, OPT_Walloc_size_larger_than_,
    2336                 :             :                                    "argument %i range [%E, %E] exceeds "
    2337                 :             :                                    "maximum object size %E",
    2338                 :          31 :                                    idx[i] + 1,
    2339                 :             :                                    argrange[i][0], argrange[i][1],
    2340                 :             :                                    maxobjsize);
    2341                 :             :             }
    2342                 :             :         }
    2343                 :             :     }
    2344                 :             : 
    2345                 :       47085 :   if (!argrange[0][0])
    2346                 :          10 :     return;
    2347                 :             : 
    2348                 :             :   /* For a two-argument alloc_size, validate the product of the two
    2349                 :             :      arguments if both of their values or ranges are known.  */
    2350                 :       46854 :   if (!warned && tree_fits_uhwi_p (argrange[0][0])
    2351                 :       46799 :       && argrange[1][0] && tree_fits_uhwi_p (argrange[1][0])
    2352                 :        1083 :       && !integer_onep (argrange[0][0])
    2353                 :       47847 :       && !integer_onep (argrange[1][0]))
    2354                 :             :     {
    2355                 :             :       /* Check for overflow in the product of a function decorated with
    2356                 :             :          attribute alloc_size (X, Y).  */
    2357                 :         395 :       unsigned szprec = TYPE_PRECISION (size_type_node);
    2358                 :         395 :       wide_int x = wi::to_wide (argrange[0][0], szprec);
    2359                 :         395 :       wide_int y = wi::to_wide (argrange[1][0], szprec);
    2360                 :             : 
    2361                 :         395 :       wi::overflow_type vflow;
    2362                 :         395 :       wide_int prod = wi::umul (x, y, &vflow);
    2363                 :             : 
    2364                 :         395 :       if (vflow)
    2365                 :           2 :         warned = warning_at (loc, OPT_Walloc_size_larger_than_,
    2366                 :             :                              "product %<%E * %E%> of arguments %i and %i "
    2367                 :             :                              "exceeds %<SIZE_MAX%>",
    2368                 :             :                              argrange[0][0], argrange[1][0],
    2369                 :           2 :                              idx[0] + 1, idx[1] + 1);
    2370                 :         393 :       else if (wi::ltu_p (wi::to_wide (maxobjsize, szprec), prod))
    2371                 :          14 :         warned = warning_at (loc, OPT_Walloc_size_larger_than_,
    2372                 :             :                              "product %<%E * %E%> of arguments %i and %i "
    2373                 :             :                              "exceeds maximum object size %E",
    2374                 :             :                              argrange[0][0], argrange[1][0],
    2375                 :          14 :                              idx[0] + 1, idx[1] + 1,
    2376                 :             :                              maxobjsize);
    2377                 :             : 
    2378                 :         395 :       if (warned)
    2379                 :             :         {
    2380                 :             :           /* Print the full range of each of the two arguments to make
    2381                 :             :              it clear when it is, in fact, in a range and not constant.  */
    2382                 :          16 :           if (argrange[0][0] != argrange [0][1])
    2383                 :           1 :             inform (loc, "argument %i in the range [%E, %E]",
    2384                 :           1 :                     idx[0] + 1, argrange[0][0], argrange[0][1]);
    2385                 :          16 :           if (argrange[1][0] != argrange [1][1])
    2386                 :           1 :             inform (loc, "argument %i in the range [%E, %E]",
    2387                 :           1 :                     idx[1] + 1, argrange[1][0], argrange[1][1]);
    2388                 :             :         }
    2389                 :         395 :     }
    2390                 :             : 
    2391                 :       47075 :   if (warned && fn)
    2392                 :             :     {
    2393                 :         212 :       location_t fnloc = DECL_SOURCE_LOCATION (fn);
    2394                 :             : 
    2395                 :         212 :       if (DECL_IS_UNDECLARED_BUILTIN (fn))
    2396                 :          64 :         inform (loc,
    2397                 :             :                 "in a call to built-in allocation function %qD", fn);
    2398                 :             :       else
    2399                 :         148 :         inform (fnloc,
    2400                 :             :                 "in a call to allocation function %qD declared here", fn);
    2401                 :             :     }
    2402                 :             : }
    2403                 :             : 
    2404                 :             : /* Check a call to an alloca function for an excessive size.  */
    2405                 :             : 
    2406                 :             : void
    2407                 :       40757 : pass_waccess::check_alloca (gcall *stmt)
    2408                 :             : {
    2409                 :       40757 :   if (m_early_checks_p)
    2410                 :             :     return;
    2411                 :             : 
    2412                 :       14275 :   if ((warn_vla_limit >= HOST_WIDE_INT_MAX
    2413                 :       14248 :        && warn_alloc_size_limit < warn_vla_limit)
    2414                 :       14265 :       || (warn_alloca_limit >= HOST_WIDE_INT_MAX
    2415                 :       14202 :           && warn_alloc_size_limit < warn_alloca_limit))
    2416                 :             :     {
    2417                 :             :       /* -Walloca-larger-than and -Wvla-larger-than settings of less
    2418                 :             :          than  HWI_MAX override the more general -Walloc-size-larger-than
    2419                 :             :          so unless either of the former options is smaller than the last
    2420                 :             :          one (which would imply that the call was already checked), check
    2421                 :             :          the alloca arguments for overflow.  */
    2422                 :          10 :       const tree alloc_args[] = { call_arg (stmt, 0), NULL_TREE };
    2423                 :          10 :       const int idx[] = { 0, -1 };
    2424                 :          10 :       maybe_warn_alloc_args_overflow (stmt, alloc_args, idx);
    2425                 :             :     }
    2426                 :             : }
    2427                 :             : 
    2428                 :             : /* Check a call to an allocation function for an excessive size.  */
    2429                 :             : 
    2430                 :             : void
    2431                 :     3981234 : pass_waccess::check_alloc_size_call (gcall *stmt)
    2432                 :             : {
    2433                 :     3981234 :   if (m_early_checks_p)
    2434                 :     3934159 :     return;
    2435                 :             : 
    2436                 :     1307870 :   if (gimple_call_num_args (stmt) < 1)
    2437                 :             :     /* Avoid invalid calls to functions without a prototype.  */
    2438                 :             :     return;
    2439                 :             : 
    2440                 :     1078147 :   tree fndecl = gimple_call_fndecl (stmt);
    2441                 :     1078147 :   if (fndecl && gimple_call_builtin_p (stmt, BUILT_IN_NORMAL))
    2442                 :             :     {
    2443                 :             :       /* Alloca is handled separately.  */
    2444                 :      532221 :       switch (DECL_FUNCTION_CODE (fndecl))
    2445                 :             :         {
    2446                 :             :         case BUILT_IN_ALLOCA:
    2447                 :             :         case BUILT_IN_ALLOCA_WITH_ALIGN:
    2448                 :             :         case BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX:
    2449                 :             :           return;
    2450                 :             :         default:
    2451                 :             :           break;
    2452                 :             :         }
    2453                 :             :     }
    2454                 :             : 
    2455                 :     1069013 :   tree fntype = gimple_call_fntype (stmt);
    2456                 :     1069013 :   tree fntypeattrs = TYPE_ATTRIBUTES (fntype);
    2457                 :             : 
    2458                 :     1069013 :   tree alloc_size = lookup_attribute ("alloc_size", fntypeattrs);
    2459                 :     1069013 :   if (!alloc_size)
    2460                 :             :     return;
    2461                 :             : 
    2462                 :             :   /* Extract attribute alloc_size from the type of the called expression
    2463                 :             :      (which could be a function or a function pointer) and if set, store
    2464                 :             :      the indices of the corresponding arguments in ALLOC_IDX, and then
    2465                 :             :      the actual argument(s) at those indices in ALLOC_ARGS.  */
    2466                 :       47080 :   int idx[2] = { -1, -1 };
    2467                 :       47080 :   tree alloc_args[] = { NULL_TREE, NULL_TREE };
    2468                 :       47080 :   unsigned nargs = gimple_call_num_args (stmt);
    2469                 :             : 
    2470                 :       47080 :   tree args = TREE_VALUE (alloc_size);
    2471                 :       47080 :   idx[0] = TREE_INT_CST_LOW (TREE_VALUE (args)) - 1;
    2472                 :             :   /* Avoid invalid calls to functions without a prototype.  */
    2473                 :       47080 :   if ((unsigned) idx[0] >= nargs)
    2474                 :             :     return;
    2475                 :       47075 :   alloc_args[0] = call_arg (stmt, idx[0]);
    2476                 :       47075 :   if (TREE_CHAIN (args))
    2477                 :             :     {
    2478                 :        1183 :       idx[1] = TREE_INT_CST_LOW (TREE_VALUE (TREE_CHAIN (args))) - 1;
    2479                 :        1183 :       if ((unsigned) idx[1] >= nargs)
    2480                 :             :         return;
    2481                 :        1183 :       alloc_args[1] = call_arg (stmt, idx[1]);
    2482                 :             :     }
    2483                 :             : 
    2484                 :       47075 :   maybe_warn_alloc_args_overflow (stmt, alloc_args, idx);
    2485                 :             : }
    2486                 :             : 
    2487                 :             : /* Check a call STMT to strcat() for overflow and warn if it does.  */
    2488                 :             : 
    2489                 :             : void
    2490                 :        2356 : pass_waccess::check_strcat (gcall *stmt)
    2491                 :             : {
    2492                 :        2356 :   if (m_early_checks_p)
    2493                 :        1657 :     return;
    2494                 :             : 
    2495                 :         699 :   if (!warn_stringop_overflow && !warn_stringop_overread)
    2496                 :             :     return;
    2497                 :             : 
    2498                 :         699 :   tree dest = call_arg (stmt, 0);
    2499                 :         699 :   tree src = call_arg (stmt, 1);
    2500                 :             : 
    2501                 :             :   /* There is no way here to determine the length of the string in
    2502                 :             :      the destination to which the SRC string is being appended so
    2503                 :             :      just diagnose cases when the source string is longer than
    2504                 :             :      the destination object.  */
    2505                 :         699 :   access_data data (m_ptr_qry.rvals, stmt, access_read_write, NULL_TREE,
    2506                 :         699 :                     true, NULL_TREE, true);
    2507                 :         699 :   const int ost = warn_stringop_overflow ? warn_stringop_overflow - 1 : 1;
    2508                 :         699 :   compute_objsize (src, stmt, ost, &data.src, &m_ptr_qry);
    2509                 :         699 :   tree destsize = compute_objsize (dest, stmt, ost, &data.dst, &m_ptr_qry);
    2510                 :             : 
    2511                 :         699 :   check_access (stmt, /*dstwrite=*/NULL_TREE, /*maxread=*/NULL_TREE,
    2512                 :             :                 src, destsize, data.mode, &data, m_ptr_qry.rvals);
    2513                 :             : }
    2514                 :             : 
    2515                 :             : /* Check a call STMT to strcat() for overflow and warn if it does.  */
    2516                 :             : 
    2517                 :             : void
    2518                 :        1886 : pass_waccess::check_strncat (gcall *stmt)
    2519                 :             : {
    2520                 :        1886 :   if (m_early_checks_p)
    2521                 :        1270 :     return;
    2522                 :             : 
    2523                 :         654 :   if (!warn_stringop_overflow && !warn_stringop_overread)
    2524                 :             :     return;
    2525                 :             : 
    2526                 :         635 :   tree dest = call_arg (stmt, 0);
    2527                 :         635 :   tree src = call_arg (stmt, 1);
    2528                 :             :   /* The upper bound on the number of bytes to write.  */
    2529                 :         635 :   tree maxread = call_arg (stmt, 2);
    2530                 :             : 
    2531                 :             :   /* Detect unterminated source (only).  */
    2532                 :         635 :   if (!check_nul_terminated_array (stmt, src, maxread))
    2533                 :             :     return;
    2534                 :             : 
    2535                 :             :   /* The length of the source sequence.  */
    2536                 :         629 :   tree slen = c_strlen (src, 1);
    2537                 :             : 
    2538                 :             :   /* Try to determine the range of lengths that the source expression
    2539                 :             :      refers to.  Since the lengths are only used for warning and not
    2540                 :             :      for code generation disable strict mode below.  */
    2541                 :         629 :   tree maxlen = slen;
    2542                 :         629 :   if (!maxlen)
    2543                 :             :     {
    2544                 :         522 :       c_strlen_data lendata = { };
    2545                 :         522 :       get_range_strlen (src, &lendata, /* eltsize = */ 1);
    2546                 :         522 :       maxlen = lendata.maxbound;
    2547                 :             :     }
    2548                 :             : 
    2549                 :         629 :   access_data data (m_ptr_qry.rvals, stmt, access_read_write);
    2550                 :             :   /* Try to verify that the destination is big enough for the shortest
    2551                 :             :      string.  First try to determine the size of the destination object
    2552                 :             :      into which the source is being copied.  */
    2553                 :         629 :   const int ost = warn_stringop_overflow - 1;
    2554                 :         629 :   tree destsize = compute_objsize (dest, stmt, ost, &data.dst, &m_ptr_qry);
    2555                 :             : 
    2556                 :             :   /* Add one for the terminating nul.  */
    2557                 :         629 :   tree srclen = (maxlen
    2558                 :         629 :                  ? fold_build2 (PLUS_EXPR, size_type_node, maxlen,
    2559                 :             :                                 size_one_node)
    2560                 :         629 :                  : NULL_TREE);
    2561                 :             : 
    2562                 :             :   /* The strncat function copies at most MAXREAD bytes and always appends
    2563                 :             :      the terminating nul so the specified upper bound should never be equal
    2564                 :             :      to (or greater than) the size of the destination.  */
    2565                 :         236 :   if (tree_fits_uhwi_p (maxread) && tree_fits_uhwi_p (destsize)
    2566                 :         865 :       && tree_int_cst_equal (destsize, maxread))
    2567                 :             :     {
    2568                 :          13 :       location_t loc = get_location (stmt);
    2569                 :          13 :       warning_at (loc, OPT_Wstringop_overflow_,
    2570                 :             :                   "%qD specified bound %E equals destination size",
    2571                 :             :                   get_callee_fndecl (stmt), maxread);
    2572                 :             : 
    2573                 :          13 :       return;
    2574                 :             :     }
    2575                 :             : 
    2576                 :         616 :   if (!srclen
    2577                 :         616 :       || (maxread && tree_fits_uhwi_p (maxread)
    2578                 :         157 :           && tree_fits_uhwi_p (srclen)
    2579                 :         157 :           && tree_int_cst_lt (maxread, srclen)))
    2580                 :             :     srclen = maxread;
    2581                 :             : 
    2582                 :         616 :   check_access (stmt, /*dstwrite=*/NULL_TREE, maxread, srclen,
    2583                 :             :                 destsize, data.mode, &data, m_ptr_qry.rvals);
    2584                 :             : }
    2585                 :             : 
    2586                 :             : /* Check a call STMT to stpcpy() or strcpy() for overflow and warn
    2587                 :             :    if it does.  */
    2588                 :             : 
    2589                 :             : void
    2590                 :       10070 : pass_waccess::check_stxcpy (gcall *stmt)
    2591                 :             : {
    2592                 :       10070 :   if (m_early_checks_p)
    2593                 :        7183 :     return;
    2594                 :             : 
    2595                 :        3029 :   tree dst = call_arg (stmt, 0);
    2596                 :        3029 :   tree src = call_arg (stmt, 1);
    2597                 :             : 
    2598                 :        3029 :   tree size;
    2599                 :        3029 :   bool exact;
    2600                 :        3029 :   if (tree nonstr = unterminated_array (src, &size, &exact))
    2601                 :             :     {
    2602                 :             :       /* NONSTR refers to the non-nul terminated constant array.  */
    2603                 :         142 :       warn_string_no_nul (get_location (stmt), stmt, NULL, src, nonstr,
    2604                 :             :                           size, exact);
    2605                 :         142 :       return;
    2606                 :             :     }
    2607                 :             : 
    2608                 :        2887 :   if (warn_stringop_overflow)
    2609                 :             :     {
    2610                 :        2682 :       access_data data (m_ptr_qry.rvals, stmt, access_read_write, NULL_TREE,
    2611                 :        2682 :                         true, NULL_TREE, true);
    2612                 :        2682 :       const int ost = warn_stringop_overflow ? warn_stringop_overflow - 1 : 1;
    2613                 :        2682 :       compute_objsize (src, stmt, ost, &data.src, &m_ptr_qry);
    2614                 :        2682 :       tree dstsize = compute_objsize (dst, stmt, ost, &data.dst, &m_ptr_qry);
    2615                 :        2682 :       check_access (stmt, /*dstwrite=*/ NULL_TREE,
    2616                 :             :                     /*maxread=*/ NULL_TREE, /*srcstr=*/ src,
    2617                 :             :                     dstsize, data.mode, &data, m_ptr_qry.rvals);
    2618                 :             :     }
    2619                 :             : 
    2620                 :             :   /* Check to see if the argument was declared attribute nonstring
    2621                 :             :      and if so, issue a warning since at this point it's not known
    2622                 :             :      to be nul-terminated.  */
    2623                 :        2887 :   tree fndecl = get_callee_fndecl (stmt);
    2624                 :        2887 :   maybe_warn_nonstring_arg (fndecl, stmt);
    2625                 :             : }
    2626                 :             : 
    2627                 :             : /* Check a call STMT to stpncpy() or strncpy() for overflow and warn
    2628                 :             :    if it does.  */
    2629                 :             : 
    2630                 :             : void
    2631                 :        7506 : pass_waccess::check_stxncpy (gcall *stmt)
    2632                 :             : {
    2633                 :        7506 :   if (m_early_checks_p || !warn_stringop_overflow)
    2634                 :        5299 :     return;
    2635                 :             : 
    2636                 :        2207 :   tree dst = call_arg (stmt, 0);
    2637                 :        2207 :   tree src = call_arg (stmt, 1);
    2638                 :             :   /* The number of bytes to write (not the maximum).  */
    2639                 :        2207 :   tree len = call_arg (stmt, 2);
    2640                 :             : 
    2641                 :        2207 :   access_data data (m_ptr_qry.rvals, stmt, access_read_write, len, true, len,
    2642                 :        2207 :                     true);
    2643                 :        2207 :   const int ost = warn_stringop_overflow ? warn_stringop_overflow - 1 : 1;
    2644                 :        2207 :   compute_objsize (src, stmt, ost, &data.src, &m_ptr_qry);
    2645                 :        2207 :   tree dstsize = compute_objsize (dst, stmt, ost, &data.dst, &m_ptr_qry);
    2646                 :             : 
    2647                 :        2207 :   check_access (stmt, /*dstwrite=*/len, /*maxread=*/len, src, dstsize,
    2648                 :             :                 data.mode, &data, m_ptr_qry.rvals);
    2649                 :             : }
    2650                 :             : 
    2651                 :             : /* Check a call STMT to stpncpy() or strncpy() for overflow and warn
    2652                 :             :    if it does.  */
    2653                 :             : 
    2654                 :             : void
    2655                 :        7573 : pass_waccess::check_strncmp (gcall *stmt)
    2656                 :             : {
    2657                 :        7573 :   if (m_early_checks_p || !warn_stringop_overread)
    2658                 :        5653 :     return;
    2659                 :             : 
    2660                 :        2539 :   tree arg1 = call_arg (stmt, 0);
    2661                 :        2539 :   tree arg2 = call_arg (stmt, 1);
    2662                 :        2539 :   tree bound = call_arg (stmt, 2);
    2663                 :             : 
    2664                 :             :   /* First check each argument separately, considering the bound.  */
    2665                 :        2539 :   if (!check_nul_terminated_array (stmt, arg1, bound)
    2666                 :        2539 :       || !check_nul_terminated_array (stmt, arg2, bound))
    2667                 :           6 :     return;
    2668                 :             : 
    2669                 :             :   /* A strncmp read from each argument is constrained not just by
    2670                 :             :      the bound but also by the length of the shorter string.  Specifying
    2671                 :             :      a bound that's larger than the size of either array makes no sense
    2672                 :             :      and is likely a bug.  When the length of neither of the two strings
    2673                 :             :      is known but the sizes of both of the arrays they are stored in is,
    2674                 :             :      issue a warning if the bound is larger than the size of
    2675                 :             :      the larger of the two arrays.  */
    2676                 :             : 
    2677                 :        2533 :   c_strlen_data lendata1{ }, lendata2{ };
    2678                 :        2533 :   tree len1 = c_strlen (arg1, 1, &lendata1);
    2679                 :        2533 :   tree len2 = c_strlen (arg2, 1, &lendata2);
    2680                 :             : 
    2681                 :        2533 :   if (len1 && TREE_CODE (len1) != INTEGER_CST)
    2682                 :        2316 :     len1 = NULL_TREE;
    2683                 :        2533 :   if (len2 && TREE_CODE (len2) != INTEGER_CST)
    2684                 :        1365 :     len2 = NULL_TREE;
    2685                 :             : 
    2686                 :        2533 :   if (len1 && len2)
    2687                 :             :     /* If the length of both arguments was computed they must both be
    2688                 :             :        nul-terminated and no further checking is necessary regardless
    2689                 :             :        of the bound.  */
    2690                 :             :     return;
    2691                 :             : 
    2692                 :             :   /* Check to see if the argument was declared with attribute nonstring
    2693                 :             :      and if so, issue a warning since at this point it's not known to be
    2694                 :             :      nul-terminated.  */
    2695                 :        2416 :   if (maybe_warn_nonstring_arg (get_callee_fndecl (stmt), stmt))
    2696                 :             :     return;
    2697                 :             : 
    2698                 :        2311 :   access_data adata1 (m_ptr_qry.rvals, stmt, access_read_only, NULL_TREE, false,
    2699                 :        2311 :                       bound, true);
    2700                 :        2311 :   access_data adata2 (m_ptr_qry.rvals, stmt, access_read_only, NULL_TREE, false,
    2701                 :        2311 :                       bound, true);
    2702                 :             : 
    2703                 :             :   /* Determine the range of the bound first and bail if it fails; it's
    2704                 :             :      cheaper than computing the size of the objects.  */
    2705                 :        2311 :   tree bndrng[2] = { NULL_TREE, NULL_TREE };
    2706                 :        2311 :   get_size_range (m_ptr_qry.rvals, bound, stmt, bndrng, 0, adata1.src_bndrng);
    2707                 :        2311 :   if (!bndrng[0] || integer_zerop (bndrng[0]))
    2708                 :         391 :     return;
    2709                 :             : 
    2710                 :        1920 :   if (len1 && tree_int_cst_lt (len1, bndrng[0]))
    2711                 :          12 :     bndrng[0] = len1;
    2712                 :        1920 :   if (len2 && tree_int_cst_lt (len2, bndrng[0]))
    2713                 :          38 :     bndrng[0] = len2;
    2714                 :             : 
    2715                 :             :   /* compute_objsize almost never fails (and ultimately should never
    2716                 :             :      fail).  Don't bother to handle the rare case when it does.  */
    2717                 :        1920 :   if (!compute_objsize (arg1, stmt, 1, &adata1.src, &m_ptr_qry)
    2718                 :        1920 :       || !compute_objsize (arg2, stmt, 1, &adata2.src, &m_ptr_qry))
    2719                 :           0 :     return;
    2720                 :             : 
    2721                 :             :   /* Compute the size of the remaining space in each array after
    2722                 :             :      subtracting any offset into it.  */
    2723                 :        1920 :   offset_int rem1 = adata1.src.size_remaining ();
    2724                 :        1920 :   offset_int rem2 = adata2.src.size_remaining ();
    2725                 :             : 
    2726                 :             :   /* Cap REM1 and REM2 at the other if the other's argument is known
    2727                 :             :      to be an unterminated array, either because there's no space
    2728                 :             :      left in it after adding its offset or because it's constant and
    2729                 :             :      has no nul.  */
    2730                 :        3837 :   if (rem1 == 0 || (rem1 < rem2 && lendata1.decl))
    2731                 :           5 :     rem2 = rem1;
    2732                 :        3829 :   else if (rem2 == 0 || (rem2 < rem1 && lendata2.decl))
    2733                 :           3 :     rem1 = rem2;
    2734                 :             : 
    2735                 :             :   /* Point PAD at the array to reference in the note if a warning
    2736                 :             :      is issued.  */
    2737                 :        1920 :   access_data *pad = len1 ? &adata2 : &adata1;
    2738                 :        1920 :   offset_int maxrem = wi::max (rem1, rem2, UNSIGNED);
    2739                 :        1918 :   if (lendata1.decl || lendata2.decl
    2740                 :        3836 :       || maxrem < wi::to_offset (bndrng[0]))
    2741                 :             :     {
    2742                 :             :       /* Warn when either argument isn't nul-terminated or the maximum
    2743                 :             :          remaining space in the two arrays is less than the bound.  */
    2744                 :          21 :       tree func = get_callee_fndecl (stmt);
    2745                 :          21 :       location_t loc = gimple_location (stmt);
    2746                 :          42 :       maybe_warn_for_bound (OPT_Wstringop_overread, loc, stmt, func,
    2747                 :          42 :                             bndrng, wide_int_to_tree (sizetype, maxrem),
    2748                 :             :                             pad);
    2749                 :             :     }
    2750                 :             : }
    2751                 :             : 
    2752                 :             : /* Determine and check the sizes of the source and the destination
    2753                 :             :    of calls to __builtin_{bzero,memcpy,mempcpy,memset} calls.  STMT is
    2754                 :             :    the call statement, DEST is the destination argument, SRC is the source
    2755                 :             :    argument or null, and SIZE is the number of bytes being accessed.  Use
    2756                 :             :    Object Size type-0 regardless of the OPT_Wstringop_overflow_ setting.
    2757                 :             :    Return true on success (no overflow or invalid sizes), false otherwise.  */
    2758                 :             : 
    2759                 :             : void
    2760                 :      796215 : pass_waccess::check_memop_access (gimple *stmt, tree dest, tree src, tree size)
    2761                 :             : {
    2762                 :      796215 :   if (m_early_checks_p)
    2763                 :      483564 :     return;
    2764                 :             : 
    2765                 :             :   /* For functions like memset and memcpy that operate on raw memory
    2766                 :             :      try to determine the size of the largest source and destination
    2767                 :             :      object using type-0 Object Size regardless of the object size
    2768                 :             :      type specified by the option.  */
    2769                 :      312651 :   access_data data (m_ptr_qry.rvals, stmt, access_read_write);
    2770                 :      312651 :   tree srcsize
    2771                 :      312651 :     = src ? compute_objsize (src, stmt, 0, &data.src, &m_ptr_qry) : NULL_TREE;
    2772                 :      312651 :   tree dstsize = compute_objsize (dest, stmt, 0, &data.dst, &m_ptr_qry);
    2773                 :             : 
    2774                 :      312651 :   check_access (stmt, size, /*maxread=*/NULL_TREE, srcsize, dstsize,
    2775                 :             :                 data.mode, &data, m_ptr_qry.rvals);
    2776                 :             : }
    2777                 :             : 
    2778                 :             : /* A convenience wrapper for check_access to check access by a read-only
    2779                 :             :    function like puts or strcmp.  */
    2780                 :             : 
    2781                 :             : void
    2782                 :     1398308 : pass_waccess::check_read_access (gimple *stmt, tree src,
    2783                 :             :                                  tree bound /* = NULL_TREE */,
    2784                 :             :                                  int ost /* = 1 */)
    2785                 :             : {
    2786                 :     1398308 :   if (m_early_checks_p || !warn_stringop_overread)
    2787                 :     1000535 :     return;
    2788                 :             : 
    2789                 :      397773 :   if (bound && !useless_type_conversion_p (size_type_node, TREE_TYPE (bound)))
    2790                 :           0 :     bound = fold_convert (size_type_node, bound);
    2791                 :             : 
    2792                 :      397773 :   tree fndecl = get_callee_fndecl (stmt);
    2793                 :      397773 :   maybe_warn_nonstring_arg (fndecl, stmt);
    2794                 :             : 
    2795                 :      397773 :   access_data data (m_ptr_qry.rvals, stmt, access_read_only, NULL_TREE,
    2796                 :      397773 :                    false, bound, true);
    2797                 :      397773 :   compute_objsize (src, stmt, ost, &data.src, &m_ptr_qry);
    2798                 :      397773 :   check_access (stmt, /*dstwrite=*/ NULL_TREE, /*maxread=*/ bound,
    2799                 :             :                 /*srcstr=*/ src, /*dstsize=*/ NULL_TREE, data.mode,
    2800                 :             :                 &data, m_ptr_qry.rvals);
    2801                 :             : }
    2802                 :             : 
    2803                 :             : /* Return true if memory model ORD is constant in the context of STMT and
    2804                 :             :    set *CSTVAL to the constant value.  Otherwise return false.  Warn for
    2805                 :             :    invalid ORD.  */
    2806                 :             : 
    2807                 :             : bool
    2808                 :      327129 : memmodel_to_uhwi (tree ord, gimple *stmt, unsigned HOST_WIDE_INT *cstval)
    2809                 :             : {
    2810                 :      327129 :   unsigned HOST_WIDE_INT val;
    2811                 :             : 
    2812                 :      327129 :   if (TREE_CODE (ord) == INTEGER_CST)
    2813                 :             :     {
    2814                 :      324730 :       if (!tree_fits_uhwi_p (ord))
    2815                 :             :         return false;
    2816                 :      324722 :       val = tree_to_uhwi (ord);
    2817                 :             :     }
    2818                 :             :   else
    2819                 :             :     {
    2820                 :             :       /* Use the range query to determine constant values in the absence
    2821                 :             :          of constant propagation (such as at -O0).  */
    2822                 :        2399 :       int_range_max rng (TREE_TYPE (ord));
    2823                 :        4798 :       if (!get_range_query (cfun)->range_of_expr (rng, ord, stmt)
    2824                 :        2399 :           || !rng.singleton_p (&ord))
    2825                 :        1944 :         return false;
    2826                 :             : 
    2827                 :         455 :       wide_int lob = rng.lower_bound ();
    2828                 :         455 :       if (!wi::fits_uhwi_p (lob))
    2829                 :           0 :         return false;
    2830                 :             : 
    2831                 :         455 :       val = lob.to_shwi ();
    2832                 :        2399 :     }
    2833                 :             : 
    2834                 :      325177 :   if (targetm.memmodel_check)
    2835                 :             :     /* This might warn for an invalid VAL but return a conservatively
    2836                 :             :        valid result.  */
    2837                 :      325177 :     val = targetm.memmodel_check (val);
    2838                 :           0 :   else if (val & ~MEMMODEL_MASK)
    2839                 :             :     {
    2840                 :           0 :       tree fndecl = gimple_call_fndecl (stmt);
    2841                 :           0 :       location_t loc = gimple_location (stmt);
    2842                 :           0 :       loc = expansion_point_location_if_in_system_header (loc);
    2843                 :             : 
    2844                 :           0 :       warning_at (loc, OPT_Winvalid_memory_model,
    2845                 :             :                   "unknown architecture specifier in memory model "
    2846                 :             :                   "%wi for %qD", val, fndecl);
    2847                 :           0 :       return false;
    2848                 :             :     }
    2849                 :             : 
    2850                 :      325177 :   *cstval = val;
    2851                 :             : 
    2852                 :      325177 :   return true;
    2853                 :             : }
    2854                 :             : 
    2855                 :             : /* Valid memory model for each set of atomic built-in functions.  */
    2856                 :             : 
    2857                 :             : struct memmodel_pair
    2858                 :             : {
    2859                 :             :   memmodel modval;
    2860                 :             :   const char* modname;
    2861                 :             : 
    2862                 :             : #define MEMMODEL_PAIR(val, str)                 \
    2863                 :             :   { MEMMODEL_ ## val, "memory_order_" str }
    2864                 :             : };
    2865                 :             : 
    2866                 :             : /* Valid memory models in the order of increasing strength.  */
    2867                 :             : 
    2868                 :             : static const memmodel_pair memory_models[] =
    2869                 :             :   { MEMMODEL_PAIR (RELAXED, "relaxed"),
    2870                 :             :     MEMMODEL_PAIR (SEQ_CST, "seq_cst"),
    2871                 :             :     MEMMODEL_PAIR (ACQUIRE, "acquire"),
    2872                 :             :     MEMMODEL_PAIR (CONSUME, "consume"),
    2873                 :             :     MEMMODEL_PAIR (RELEASE, "release"),
    2874                 :             :     MEMMODEL_PAIR (ACQ_REL, "acq_rel")
    2875                 :             :   };
    2876                 :             : 
    2877                 :             : /* Return the name of the memory model VAL.  */
    2878                 :             : 
    2879                 :             : static const char*
    2880                 :         230 : memmodel_name (unsigned HOST_WIDE_INT val)
    2881                 :             : {
    2882                 :         230 :   val = memmodel_base (val);
    2883                 :             : 
    2884                 :         988 :   for (unsigned i = 0; i != ARRAY_SIZE (memory_models); ++i)
    2885                 :             :     {
    2886                 :         971 :       if (val == memory_models[i].modval)
    2887                 :         213 :         return memory_models[i].modname;
    2888                 :             :     }
    2889                 :             :   return NULL;
    2890                 :             : }
    2891                 :             : 
    2892                 :             : /* Indices of valid MEMORY_MODELS above for corresponding atomic operations.  */
    2893                 :             : static const unsigned char load_models[] = { 0, 1, 2, 3, UCHAR_MAX };
    2894                 :             : static const unsigned char store_models[] = { 0, 1, 4, UCHAR_MAX };
    2895                 :             : static const unsigned char xchg_models[] = { 0, 1, 3, 4, 5, UCHAR_MAX };
    2896                 :             : static const unsigned char flag_clr_models[] = { 0, 1, 4, UCHAR_MAX };
    2897                 :             : static const unsigned char all_models[] = { 0, 1, 2, 3, 4, 5, UCHAR_MAX };
    2898                 :             : 
    2899                 :             : /* Check the success memory model argument ORD_SUCS to the call STMT to
    2900                 :             :    an atomic function and warn if it's invalid.  If nonnull, also check
    2901                 :             :    the failure memory model ORD_FAIL and warn if it's invalid.  Return
    2902                 :             :    true if a warning has been issued.  */
    2903                 :             : 
    2904                 :             : bool
    2905                 :      299903 : pass_waccess::maybe_warn_memmodel (gimple *stmt, tree ord_sucs,
    2906                 :             :                                    tree ord_fail, const unsigned char *valid)
    2907                 :             : {
    2908                 :      299903 :   unsigned HOST_WIDE_INT sucs, fail = 0;
    2909                 :      299903 :   if (!memmodel_to_uhwi (ord_sucs, stmt, &sucs)
    2910                 :      299903 :       || (ord_fail && !memmodel_to_uhwi (ord_fail, stmt, &fail)))
    2911                 :        1952 :     return false;
    2912                 :             : 
    2913                 :      297951 :   bool is_valid = false;
    2914                 :      297951 :   if (valid)
    2915                 :      663952 :     for (unsigned i = 0; valid[i] != UCHAR_MAX; ++i)
    2916                 :             :       {
    2917                 :      663870 :         memmodel model = memory_models[valid[i]].modval;
    2918                 :      663870 :         if (memmodel_base (sucs) == model)
    2919                 :             :           {
    2920                 :             :             is_valid = true;
    2921                 :             :             break;
    2922                 :             :           }
    2923                 :             :       }
    2924                 :             :   else
    2925                 :             :     is_valid = true;
    2926                 :             : 
    2927                 :      297951 :   tree fndecl = gimple_call_fndecl (stmt);
    2928                 :      297951 :   location_t loc = gimple_location (stmt);
    2929                 :      297951 :   loc = expansion_point_location_if_in_system_header (loc);
    2930                 :             : 
    2931                 :      297951 :   if (!is_valid)
    2932                 :             :     {
    2933                 :          82 :       bool warned = false;
    2934                 :          82 :       auto_diagnostic_group d;
    2935                 :          82 :       if (const char *modname = memmodel_name (sucs))
    2936                 :          65 :         warned = warning_at (loc, OPT_Winvalid_memory_model,
    2937                 :             :                              "invalid memory model %qs for %qD",
    2938                 :             :                              modname, fndecl);
    2939                 :             :       else
    2940                 :          17 :         warned = warning_at (loc, OPT_Winvalid_memory_model,
    2941                 :             :                              "invalid memory model %wi for %qD",
    2942                 :             :                              sucs, fndecl);
    2943                 :             : 
    2944                 :          82 :       if (!warned)
    2945                 :             :         return false;
    2946                 :             : 
    2947                 :             :       /* Print a note with the valid memory models.  */
    2948                 :          82 :       auto_vec<const char *> strings;
    2949                 :         401 :       for (unsigned i = 0; valid[i] != UCHAR_MAX; ++i)
    2950                 :             :         {
    2951                 :         319 :           const char *modname = memory_models[valid[i]].modname;
    2952                 :         319 :           strings.safe_push (modname);
    2953                 :             :         }
    2954                 :          82 :       pp_markup::comma_separated_quoted_strings e (strings);
    2955                 :          82 :       inform (loc, "valid models are %e", &e);
    2956                 :          82 :       return true;
    2957                 :          82 :     }
    2958                 :             : 
    2959                 :      297869 :   if (!ord_fail)
    2960                 :             :     return false;
    2961                 :             : 
    2962                 :       27214 :   if (fail == MEMMODEL_RELEASE || fail == MEMMODEL_ACQ_REL)
    2963                 :          60 :     if (const char *failname = memmodel_name (fail))
    2964                 :             :       {
    2965                 :             :         /* If both memory model arguments are valid but their combination
    2966                 :             :            is not, use their names in the warning.  */
    2967                 :          60 :         auto_diagnostic_group d;
    2968                 :          60 :         if (!warning_at (loc, OPT_Winvalid_memory_model,
    2969                 :             :                          "invalid failure memory model %qs for %qD",
    2970                 :             :                          failname, fndecl))
    2971                 :             :           return false;
    2972                 :             : 
    2973                 :          60 :         inform (loc,
    2974                 :             :                 "valid failure models are %qs, %qs, %qs, %qs",
    2975                 :             :                 "memory_order_relaxed", "memory_order_seq_cst",
    2976                 :             :                 "memory_order_acquire", "memory_order_consume");
    2977                 :          60 :         return true;
    2978                 :          60 :       }
    2979                 :             : 
    2980                 :       27154 :   if (memmodel_base (fail) <= memmodel_base (sucs))
    2981                 :             :     return false;
    2982                 :             : 
    2983                 :          44 :   if (const char *sucsname = memmodel_name (sucs))
    2984                 :          44 :     if (const char *failname = memmodel_name (fail))
    2985                 :             :       {
    2986                 :             :         /* If both memory model arguments are valid but their combination
    2987                 :             :            is not, use their names in the warning.  */
    2988                 :          44 :         auto_diagnostic_group d;
    2989                 :          44 :         if (!warning_at (loc, OPT_Winvalid_memory_model,
    2990                 :             :                          "failure memory model %qs cannot be stronger "
    2991                 :             :                          "than success memory model %qs for %qD",
    2992                 :             :                          failname, sucsname, fndecl))
    2993                 :             :           return false;
    2994                 :             : 
    2995                 :             :         /* Print a note with the valid failure memory models which are
    2996                 :             :            those with a value less than or equal to the success mode.  */
    2997                 :          44 :         auto_vec<const char *> strings;
    2998                 :          88 :         for (unsigned i = 0;
    2999                 :          88 :              memory_models[i].modval <= memmodel_base (sucs); ++i)
    3000                 :             :           {
    3001                 :          44 :             const char *modname = memory_models[valid[i]].modname;
    3002                 :          44 :             strings.safe_push (modname);
    3003                 :             :           }
    3004                 :          44 :         pp_markup::comma_separated_quoted_strings e (strings);
    3005                 :             : 
    3006                 :          44 :         inform (loc, "valid models are %e", &e);
    3007                 :          44 :         return true;
    3008                 :          44 :       }
    3009                 :             : 
    3010                 :             :   /* If either memory model argument value is invalid use the numerical
    3011                 :             :      value of both in the message.  */
    3012                 :           0 :   return warning_at (loc, OPT_Winvalid_memory_model,
    3013                 :             :                      "failure memory model %wi cannot be stronger "
    3014                 :             :                      "than success memory model %wi for %qD",
    3015                 :             :                      fail, sucs, fndecl);
    3016                 :             : }
    3017                 :             : 
    3018                 :             : /* Wrapper for the above.  */
    3019                 :             : 
    3020                 :             : void
    3021                 :      299964 : pass_waccess::check_atomic_memmodel (gimple *stmt, tree ord_sucs,
    3022                 :             :                                      tree ord_fail, const unsigned char *valid)
    3023                 :             : {
    3024                 :      299964 :   if (warning_suppressed_p (stmt, OPT_Winvalid_memory_model))
    3025                 :             :     return;
    3026                 :             : 
    3027                 :      299903 :   if (!maybe_warn_memmodel (stmt, ord_sucs, ord_fail, valid))
    3028                 :             :     return;
    3029                 :             : 
    3030                 :         186 :   suppress_warning (stmt, OPT_Winvalid_memory_model);
    3031                 :             : }
    3032                 :             : 
    3033                 :             : /* Check a call STMT to an atomic or sync built-in.  */
    3034                 :             : 
    3035                 :             : bool
    3036                 :     3330729 : pass_waccess::check_atomic_builtin (gcall *stmt)
    3037                 :             : {
    3038                 :     3330729 :   tree callee = gimple_call_fndecl (stmt);
    3039                 :     3330729 :   if (!callee)
    3040                 :             :     return false;
    3041                 :             : 
    3042                 :             :   /* The size in bytes of the access by the function, and the number
    3043                 :             :      of the second argument to check (if any).  */
    3044                 :     3330729 :   unsigned bytes = 0, arg2 = UINT_MAX;
    3045                 :     3330729 :   unsigned sucs_arg = UINT_MAX, fail_arg = UINT_MAX;
    3046                 :             :   /* Points to the array of indices of valid memory models.  */
    3047                 :     3330729 :   const unsigned char *pvalid_models = NULL;
    3048                 :             : 
    3049                 :     3330729 :   switch (DECL_FUNCTION_CODE (callee))
    3050                 :             :     {
    3051                 :             : #define BUILTIN_ACCESS_SIZE_FNSPEC(N)                   \
    3052                 :             :       BUILT_IN_SYNC_FETCH_AND_ADD_ ## N:                \
    3053                 :             :     case BUILT_IN_SYNC_FETCH_AND_SUB_ ## N:             \
    3054                 :             :     case BUILT_IN_SYNC_FETCH_AND_OR_ ## N:              \
    3055                 :             :     case BUILT_IN_SYNC_FETCH_AND_AND_ ## N:             \
    3056                 :             :     case BUILT_IN_SYNC_FETCH_AND_XOR_ ## N:             \
    3057                 :             :     case BUILT_IN_SYNC_FETCH_AND_NAND_ ## N:            \
    3058                 :             :     case BUILT_IN_SYNC_ADD_AND_FETCH_ ## N:             \
    3059                 :             :     case BUILT_IN_SYNC_SUB_AND_FETCH_ ## N:             \
    3060                 :             :     case BUILT_IN_SYNC_OR_AND_FETCH_ ## N:              \
    3061                 :             :     case BUILT_IN_SYNC_AND_AND_FETCH_ ## N:             \
    3062                 :             :     case BUILT_IN_SYNC_XOR_AND_FETCH_ ## N:             \
    3063                 :             :     case BUILT_IN_SYNC_NAND_AND_FETCH_ ## N:            \
    3064                 :             :     case BUILT_IN_SYNC_LOCK_TEST_AND_SET_ ## N:         \
    3065                 :             :     case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_ ## N:     \
    3066                 :             :     case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_ ## N:      \
    3067                 :             :     case BUILT_IN_SYNC_LOCK_RELEASE_ ## N:              \
    3068                 :             :       bytes = N;                                        \
    3069                 :             :       break;                                            \
    3070                 :             :     case BUILT_IN_ATOMIC_LOAD_ ## N:                    \
    3071                 :             :       pvalid_models = load_models;                      \
    3072                 :             :       sucs_arg = 1;                                     \
    3073                 :             :       /* FALLTHROUGH */                                 \
    3074                 :             :     case BUILT_IN_ATOMIC_STORE_ ## N:                   \
    3075                 :             :       if (!pvalid_models)                               \
    3076                 :             :         pvalid_models = store_models;                   \
    3077                 :             :       /* FALLTHROUGH */                                 \
    3078                 :             :     case BUILT_IN_ATOMIC_ADD_FETCH_ ## N:               \
    3079                 :             :     case BUILT_IN_ATOMIC_SUB_FETCH_ ## N:               \
    3080                 :             :     case BUILT_IN_ATOMIC_AND_FETCH_ ## N:               \
    3081                 :             :     case BUILT_IN_ATOMIC_NAND_FETCH_ ## N:              \
    3082                 :             :     case BUILT_IN_ATOMIC_XOR_FETCH_ ## N:               \
    3083                 :             :     case BUILT_IN_ATOMIC_OR_FETCH_ ## N:                \
    3084                 :             :     case BUILT_IN_ATOMIC_FETCH_ADD_ ## N:               \
    3085                 :             :     case BUILT_IN_ATOMIC_FETCH_SUB_ ## N:               \
    3086                 :             :     case BUILT_IN_ATOMIC_FETCH_AND_ ## N:               \
    3087                 :             :     case BUILT_IN_ATOMIC_FETCH_NAND_ ## N:              \
    3088                 :             :     case BUILT_IN_ATOMIC_FETCH_OR_ ## N:                \
    3089                 :             :     case BUILT_IN_ATOMIC_FETCH_XOR_ ## N:               \
    3090                 :             :         bytes = N;                                      \
    3091                 :             :         if (sucs_arg == UINT_MAX)                       \
    3092                 :             :           sucs_arg = 2;                                 \
    3093                 :             :         if (!pvalid_models)                             \
    3094                 :             :           pvalid_models = all_models;                   \
    3095                 :             :         break;                                          \
    3096                 :             :     case BUILT_IN_ATOMIC_EXCHANGE_ ## N:                \
    3097                 :             :         bytes = N;                                      \
    3098                 :             :         sucs_arg = 3;                                   \
    3099                 :             :         pvalid_models = xchg_models;                    \
    3100                 :             :         break;                                          \
    3101                 :             :     case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_ ## N:        \
    3102                 :             :         bytes = N;                                      \
    3103                 :             :         sucs_arg = 4;                                   \
    3104                 :             :         fail_arg = 5;                                   \
    3105                 :             :         pvalid_models = all_models;                     \
    3106                 :             :         arg2 = 1
    3107                 :             : 
    3108                 :       86295 :     case BUILTIN_ACCESS_SIZE_FNSPEC (1);
    3109                 :        5635 :       break;
    3110                 :       23730 :     case BUILTIN_ACCESS_SIZE_FNSPEC (2);
    3111                 :        1904 :       break;
    3112                 :      114119 :     case BUILTIN_ACCESS_SIZE_FNSPEC (4);
    3113                 :        6804 :       break;
    3114                 :       85275 :     case BUILTIN_ACCESS_SIZE_FNSPEC (8);
    3115                 :        8654 :       break;
    3116                 :       21347 :     case BUILTIN_ACCESS_SIZE_FNSPEC (16);
    3117                 :        4701 :       break;
    3118                 :             : 
    3119                 :         158 :     case BUILT_IN_ATOMIC_CLEAR:
    3120                 :         158 :       sucs_arg = 1;
    3121                 :         158 :       pvalid_models = flag_clr_models;
    3122                 :         158 :       break;
    3123                 :             : 
    3124                 :             :     default:
    3125                 :             :       return false;
    3126                 :             :     }
    3127                 :             : 
    3128                 :      321413 :   unsigned nargs = gimple_call_num_args (stmt);
    3129                 :      321413 :   if (sucs_arg < nargs)
    3130                 :             :     {
    3131                 :      299964 :       tree ord_sucs = gimple_call_arg (stmt, sucs_arg);
    3132                 :      299964 :       tree ord_fail = NULL_TREE;
    3133                 :      299964 :       if (fail_arg < nargs)
    3134                 :       27698 :         ord_fail = gimple_call_arg (stmt, fail_arg);
    3135                 :      299964 :       check_atomic_memmodel (stmt, ord_sucs, ord_fail, pvalid_models);
    3136                 :             :     }
    3137                 :             : 
    3138                 :      321413 :   if (!bytes)
    3139                 :             :     return true;
    3140                 :             : 
    3141                 :      321255 :   tree size = build_int_cstu (sizetype, bytes);
    3142                 :      321255 :   tree dst = gimple_call_arg (stmt, 0);
    3143                 :      321255 :   check_memop_access (stmt, dst, NULL_TREE, size);
    3144                 :             : 
    3145                 :      321255 :   if (arg2 != UINT_MAX)
    3146                 :             :     {
    3147                 :       27698 :       tree dst = gimple_call_arg (stmt, arg2);
    3148                 :       27698 :       check_memop_access (stmt, dst, NULL_TREE, size);
    3149                 :             :     }
    3150                 :             : 
    3151                 :             :   return true;
    3152                 :             : }
    3153                 :             : 
    3154                 :             : /* Check call STMT to a built-in function for invalid accesses.  Return
    3155                 :             :    true if a call has been handled.  */
    3156                 :             : 
    3157                 :             : bool
    3158                 :     4747184 : pass_waccess::check_builtin (gcall *stmt)
    3159                 :             : {
    3160                 :     4747184 :   tree callee = gimple_call_fndecl (stmt);
    3161                 :     4747184 :   if (!callee)
    3162                 :             :     return false;
    3163                 :             : 
    3164                 :     4747184 :   switch (DECL_FUNCTION_CODE (callee))
    3165                 :             :     {
    3166                 :       40757 :     case BUILT_IN_ALLOCA:
    3167                 :       40757 :     case BUILT_IN_ALLOCA_WITH_ALIGN:
    3168                 :       40757 :     case BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX:
    3169                 :       40757 :       check_alloca (stmt);
    3170                 :       40757 :       return true;
    3171                 :             : 
    3172                 :          73 :     case BUILT_IN_EXECL:
    3173                 :          73 :     case BUILT_IN_EXECLE:
    3174                 :          73 :     case BUILT_IN_EXECLP:
    3175                 :          73 :     case BUILT_IN_EXECV:
    3176                 :          73 :     case BUILT_IN_EXECVE:
    3177                 :          73 :     case BUILT_IN_EXECVP:
    3178                 :          73 :       check_read_access (stmt, call_arg (stmt, 0));
    3179                 :          73 :       return true;
    3180                 :             : 
    3181                 :      160367 :     case BUILT_IN_FREE:
    3182                 :      160367 :     case BUILT_IN_REALLOC:
    3183                 :      160367 :       if (!m_early_checks_p)
    3184                 :             :         {
    3185                 :       58049 :           tree arg = call_arg (stmt, 0);
    3186                 :       58049 :           if (TREE_CODE (arg) == SSA_NAME)
    3187                 :       57965 :             check_pointer_uses (stmt, arg);
    3188                 :             :         }
    3189                 :             :       return true;
    3190                 :             : 
    3191                 :       14919 :     case BUILT_IN_GETTEXT:
    3192                 :       14919 :     case BUILT_IN_PUTS:
    3193                 :       14919 :     case BUILT_IN_PUTS_UNLOCKED:
    3194                 :       14919 :     case BUILT_IN_STRDUP:
    3195                 :       14919 :       check_read_access (stmt, call_arg (stmt, 0));
    3196                 :       14919 :       return true;
    3197                 :             : 
    3198                 :       50281 :     case BUILT_IN_INDEX:
    3199                 :       50281 :     case BUILT_IN_RINDEX:
    3200                 :       50281 :     case BUILT_IN_STRCHR:
    3201                 :       50281 :     case BUILT_IN_STRRCHR:
    3202                 :       50281 :     case BUILT_IN_STRLEN:
    3203                 :       50281 :       check_read_access (stmt, call_arg (stmt, 0));
    3204                 :       50281 :       return true;
    3205                 :             : 
    3206                 :        4296 :     case BUILT_IN_FPUTS:
    3207                 :        4296 :     case BUILT_IN_FPUTS_UNLOCKED:
    3208                 :        4296 :       check_read_access (stmt, call_arg (stmt, 0));
    3209                 :        4296 :       return true;
    3210                 :             : 
    3211                 :        3280 :     case BUILT_IN_STRNDUP:
    3212                 :        3280 :     case BUILT_IN_STRNLEN:
    3213                 :        3280 :       {
    3214                 :        3280 :         tree str = call_arg (stmt, 0);
    3215                 :        3280 :         tree len = call_arg (stmt, 1);
    3216                 :        3280 :         check_read_access (stmt, str, len);
    3217                 :        3280 :         return true;
    3218                 :             :       }
    3219                 :             : 
    3220                 :        2356 :     case BUILT_IN_STRCAT:
    3221                 :        2356 :       check_strcat (stmt);
    3222                 :        2356 :       return true;
    3223                 :             : 
    3224                 :        1886 :     case BUILT_IN_STRNCAT:
    3225                 :        1886 :       check_strncat (stmt);
    3226                 :        1886 :       return true;
    3227                 :             : 
    3228                 :       10070 :     case BUILT_IN_STPCPY:
    3229                 :       10070 :     case BUILT_IN_STRCPY:
    3230                 :       10070 :       check_stxcpy (stmt);
    3231                 :       10070 :       return true;
    3232                 :             : 
    3233                 :        7506 :     case BUILT_IN_STPNCPY:
    3234                 :        7506 :     case BUILT_IN_STRNCPY:
    3235                 :        7506 :       check_stxncpy (stmt);
    3236                 :        7506 :       return true;
    3237                 :             : 
    3238                 :      386635 :     case BUILT_IN_STRCASECMP:
    3239                 :      386635 :     case BUILT_IN_STRCMP:
    3240                 :      386635 :     case BUILT_IN_STRPBRK:
    3241                 :      386635 :     case BUILT_IN_STRSPN:
    3242                 :      386635 :     case BUILT_IN_STRCSPN:
    3243                 :      386635 :     case BUILT_IN_STRSTR:
    3244                 :      386635 :       check_read_access (stmt, call_arg (stmt, 0));
    3245                 :      386635 :       check_read_access (stmt, call_arg (stmt, 1));
    3246                 :      386635 :       return true;
    3247                 :             : 
    3248                 :        7573 :     case BUILT_IN_STRNCASECMP:
    3249                 :        7573 :     case BUILT_IN_STRNCMP:
    3250                 :        7573 :       check_strncmp (stmt);
    3251                 :        7573 :       return true;
    3252                 :             : 
    3253                 :      272995 :     case BUILT_IN_MEMCMP:
    3254                 :      272995 :       {
    3255                 :      272995 :         tree a1 = call_arg (stmt, 0);
    3256                 :      272995 :         tree a2 = call_arg (stmt, 1);
    3257                 :      272995 :         tree len = call_arg (stmt, 2);
    3258                 :      272995 :         check_read_access (stmt, a1, len, 0);
    3259                 :      272995 :         check_read_access (stmt, a2, len, 0);
    3260                 :      272995 :         return true;
    3261                 :             :       }
    3262                 :             : 
    3263                 :      246666 :     case BUILT_IN_MEMCPY:
    3264                 :      246666 :     case BUILT_IN_MEMPCPY:
    3265                 :      246666 :     case BUILT_IN_MEMMOVE:
    3266                 :      246666 :       {
    3267                 :      246666 :         tree dst = call_arg (stmt, 0);
    3268                 :      246666 :         tree src = call_arg (stmt, 1);
    3269                 :      246666 :         tree len = call_arg (stmt, 2);
    3270                 :      246666 :         check_memop_access (stmt, dst, src, len);
    3271                 :      246666 :         return true;
    3272                 :             :       }
    3273                 :             : 
    3274                 :        6199 :     case BUILT_IN_MEMCHR:
    3275                 :        6199 :       {
    3276                 :        6199 :         tree src = call_arg (stmt, 0);
    3277                 :        6199 :         tree len = call_arg (stmt, 2);
    3278                 :        6199 :         check_read_access (stmt, src, len, 0);
    3279                 :        6199 :         return true;
    3280                 :             :       }
    3281                 :             : 
    3282                 :      200596 :     case BUILT_IN_MEMSET:
    3283                 :      200596 :       {
    3284                 :      200596 :         tree dst = call_arg (stmt, 0);
    3285                 :      200596 :         tree len = call_arg (stmt, 2);
    3286                 :      200596 :         check_memop_access (stmt, dst, NULL_TREE, len);
    3287                 :      200596 :         return true;
    3288                 :             :       }
    3289                 :             : 
    3290                 :     3330729 :     default:
    3291                 :     3330729 :       if (check_atomic_builtin (stmt))
    3292                 :             :         return true;
    3293                 :             :       break;
    3294                 :             :     }
    3295                 :             : 
    3296                 :             :   return false;
    3297                 :             : }
    3298                 :             : 
    3299                 :             : /* Returns the type of the argument ARGNO to function with type FNTYPE
    3300                 :             :    or null when the type cannot be determined or no such argument exists.  */
    3301                 :             : 
    3302                 :             : static tree
    3303                 :       89166 : fntype_argno_type (tree fntype, unsigned argno)
    3304                 :             : {
    3305                 :       89166 :   if (!prototype_p (fntype))
    3306                 :             :     return NULL_TREE;
    3307                 :             : 
    3308                 :       89162 :   tree argtype;
    3309                 :       89162 :   function_args_iterator it;
    3310                 :      175250 :   FOREACH_FUNCTION_ARGS (fntype, argtype, it)
    3311                 :      175250 :     if (argno-- == 0)
    3312                 :             :       return argtype;
    3313                 :             : 
    3314                 :             :   return NULL_TREE;
    3315                 :             : }
    3316                 :             : 
    3317                 :             : /* Helper to append the "human readable" attribute access specification
    3318                 :             :    described by ACCESS to the array ATTRSTR with size STRSIZE.  Used in
    3319                 :             :    diagnostics.  */
    3320                 :             : 
    3321                 :             : static inline void
    3322                 :         280 : append_attrname (const std::pair<int, attr_access> &access,
    3323                 :             :                  char *attrstr, size_t strsize)
    3324                 :             : {
    3325                 :         280 :   if (access.second.internal_p)
    3326                 :             :     return;
    3327                 :             : 
    3328                 :         262 :   tree str = access.second.to_external_string ();
    3329                 :         262 :   gcc_assert (strsize >= (size_t) TREE_STRING_LENGTH (str));
    3330                 :         262 :   strcpy (attrstr, TREE_STRING_POINTER (str));
    3331                 :             : }
    3332                 :             : 
    3333                 :             : /* Iterate over attribute access read-only, read-write, and write-only
    3334                 :             :    arguments and diagnose past-the-end accesses and related problems
    3335                 :             :    in the function call EXP.  */
    3336                 :             : 
    3337                 :             : void
    3338                 :     3981234 : pass_waccess::maybe_check_access_sizes (rdwr_map *rwm, tree fndecl, tree fntype,
    3339                 :             :                                         gimple *stmt)
    3340                 :             : {
    3341                 :     3981234 :   if (warning_suppressed_p (stmt, OPT_Wnonnull)
    3342                 :     3981234 :       || warning_suppressed_p (stmt, OPT_Wstringop_overflow_))
    3343                 :       14348 :     return;
    3344                 :             : 
    3345                 :     3966890 :   auto_diagnostic_group adg;
    3346                 :             : 
    3347                 :             :   /* Set if a warning has been issued for any argument (used to decide
    3348                 :             :      whether to emit an informational note at the end).  */
    3349                 :     3966890 :   opt_code opt_warned = no_warning;
    3350                 :             : 
    3351                 :             :   /* A string describing the attributes that the warnings issued by this
    3352                 :             :      function apply to.  Used to print one informational note per function
    3353                 :             :      call, rather than one per warning.  That reduces clutter.  */
    3354                 :     3966890 :   char attrstr[80];
    3355                 :     3966890 :   attrstr[0] = 0;
    3356                 :             : 
    3357                 :     4149744 :   for (rdwr_map::iterator it = rwm->begin (); it != rwm->end (); ++it)
    3358                 :             :     {
    3359                 :       91431 :       std::pair<int, attr_access> access = *it;
    3360                 :             : 
    3361                 :             :       /* Get the function call arguments corresponding to the attribute's
    3362                 :             :          positional arguments.  When both arguments have been specified
    3363                 :             :          there will be two entries in *RWM, one for each.  They are
    3364                 :             :          cross-referenced by their respective argument numbers in
    3365                 :             :          ACCESS.PTRARG and ACCESS.SIZARG.  */
    3366                 :       91431 :       const int ptridx = access.second.ptrarg;
    3367                 :       91431 :       const int sizidx = access.second.sizarg;
    3368                 :             : 
    3369                 :       91431 :       gcc_assert (ptridx != -1);
    3370                 :       91431 :       gcc_assert (access.first == ptridx || access.first == sizidx);
    3371                 :             : 
    3372                 :             :       /* The pointer is set to null for the entry corresponding to
    3373                 :             :          the size argument.  Skip it.  It's handled when the entry
    3374                 :             :          corresponding to the pointer argument comes up.  */
    3375                 :       91431 :       if (!access.second.ptr)
    3376                 :        2296 :         continue;
    3377                 :             : 
    3378                 :       89166 :       tree ptrtype = fntype_argno_type (fntype, ptridx);
    3379                 :       89166 :       if (!ptrtype)
    3380                 :             :         /* A function with a prototype was redeclared without one and
    3381                 :             :            the prototype has been lost.  See pr102759.  Avoid dealing
    3382                 :             :            with this pathological case.  */
    3383                 :           4 :         return;
    3384                 :             : 
    3385                 :       89162 :       tree argtype = TREE_TYPE (ptrtype);
    3386                 :             : 
    3387                 :             :       /* The size of the access by the call in elements.  */
    3388                 :       89162 :       tree access_nelts;
    3389                 :       89162 :       if (sizidx == -1)
    3390                 :             :         {
    3391                 :             :           /* If only the pointer attribute operand was specified and
    3392                 :             :              not size, set SIZE to the greater of MINSIZE or size of
    3393                 :             :              one element of the pointed to type to detect smaller
    3394                 :             :              objects (null pointers are diagnosed in this case only
    3395                 :             :              if the pointer is also declared with attribute nonnull.  */
    3396                 :       86897 :           if (access.second.minsize
    3397                 :       86897 :               && access.second.minsize != HOST_WIDE_INT_M1U)
    3398                 :       73712 :             access_nelts = build_int_cstu (sizetype, access.second.minsize);
    3399                 :       13185 :           else if (VOID_TYPE_P (argtype) && access.second.mode == access_none)
    3400                 :             :             /* Treat access mode none on a void* argument as expecting
    3401                 :             :                as little as zero bytes.  */
    3402                 :         364 :             access_nelts = size_zero_node;
    3403                 :             :           else
    3404                 :       12821 :             access_nelts = size_one_node;
    3405                 :             :         }
    3406                 :             :       else
    3407                 :        2265 :         access_nelts = rwm->get (sizidx)->size;
    3408                 :             : 
    3409                 :             :       /* If access_nelts is e.g. a PARM_DECL with larger precision than
    3410                 :             :          sizetype, such as __int128 or _BitInt(34123) parameters,
    3411                 :             :          cast it to sizetype.  */
    3412                 :       89162 :       if (access_nelts
    3413                 :       89162 :           && INTEGRAL_TYPE_P (TREE_TYPE (access_nelts))
    3414                 :      178324 :           && (TYPE_PRECISION (TREE_TYPE (access_nelts))
    3415                 :       89162 :               > TYPE_PRECISION (sizetype)))
    3416                 :           2 :         access_nelts = fold_convert (sizetype, access_nelts);
    3417                 :             : 
    3418                 :             :       /* Format the value or range to avoid an explosion of messages.  */
    3419                 :       89162 :       char sizstr[80];
    3420                 :       89162 :       tree sizrng[2] = { size_zero_node, build_all_ones_cst (sizetype) };
    3421                 :       89162 :       if (get_size_range (m_ptr_qry.rvals, access_nelts, stmt, sizrng, 1))
    3422                 :             :         {
    3423                 :       89162 :           char *s0 = print_generic_expr_to_str (sizrng[0]);
    3424                 :       89162 :           if (tree_int_cst_equal (sizrng[0], sizrng[1]))
    3425                 :             :             {
    3426                 :       88581 :               gcc_checking_assert (strlen (s0) < sizeof sizstr);
    3427                 :       88581 :               strcpy (sizstr, s0);
    3428                 :             :             }
    3429                 :             :           else
    3430                 :             :             {
    3431                 :         581 :               char *s1 = print_generic_expr_to_str (sizrng[1]);
    3432                 :         581 :               gcc_checking_assert (strlen (s0) + strlen (s1)
    3433                 :             :                                    < sizeof sizstr - 4);
    3434                 :         581 :               sprintf (sizstr, "[%.37s, %.37s]", s0, s1);
    3435                 :         581 :               free (s1);
    3436                 :             :             }
    3437                 :       89162 :           free (s0);
    3438                 :             :         }
    3439                 :             :       else
    3440                 :           0 :         *sizstr = '\0';
    3441                 :             : 
    3442                 :             :       /* Set if a warning has been issued for the current argument.  */
    3443                 :       89162 :       opt_code arg_warned = no_warning;
    3444                 :       89162 :       location_t loc = get_location (stmt);
    3445                 :       89162 :       tree ptr = access.second.ptr;
    3446                 :       89162 :       if (*sizstr
    3447                 :       89162 :           && tree_int_cst_sgn (sizrng[0]) < 0
    3448                 :       89357 :           && tree_int_cst_sgn (sizrng[1]) < 0)
    3449                 :             :         {
    3450                 :             :           /* Warn about negative sizes.  */
    3451                 :          67 :           if (access.second.internal_p)
    3452                 :             :             {
    3453                 :          18 :               const std::string argtypestr
    3454                 :          18 :                 = access.second.array_as_string (ptrtype);
    3455                 :             : 
    3456                 :          18 :               if (warning_at (loc, OPT_Wstringop_overflow_,
    3457                 :             :                               "bound argument %i value %s is "
    3458                 :             :                               "negative for a variable length array "
    3459                 :             :                               "argument %i of type %s",
    3460                 :             :                               sizidx + 1, sizstr,
    3461                 :             :                               ptridx + 1, argtypestr.c_str ()))
    3462                 :          18 :                 arg_warned = OPT_Wstringop_overflow_;
    3463                 :          18 :             }
    3464                 :          49 :           else if (warning_at (loc, OPT_Wstringop_overflow_,
    3465                 :             :                                "argument %i value %s is negative",
    3466                 :             :                                sizidx + 1, sizstr))
    3467                 :             :             arg_warned = OPT_Wstringop_overflow_;
    3468                 :             : 
    3469                 :          18 :           if (arg_warned != no_warning)
    3470                 :             :             {
    3471                 :          23 :               append_attrname (access, attrstr, sizeof attrstr);
    3472                 :             :               /* Remember a warning has been issued and avoid warning
    3473                 :             :                  again below for the same attribute.  */
    3474                 :          23 :               opt_warned = arg_warned;
    3475                 :          23 :               continue;
    3476                 :             :             }
    3477                 :             :         }
    3478                 :             : 
    3479                 :             :       /* The size of the access by the call in bytes.  */
    3480                 :       89139 :       tree access_size = NULL_TREE;
    3481                 :       89139 :       if (tree_int_cst_sgn (sizrng[0]) >= 0)
    3482                 :             :         {
    3483                 :       88967 :           if (COMPLETE_TYPE_P (argtype))
    3484                 :             :             {
    3485                 :             :               /* Multiply ACCESS_SIZE by the size of the type the pointer
    3486                 :             :                  argument points to.  If it's incomplete the size is used
    3487                 :             :                  as is.  */
    3488                 :       85105 :               if (tree argsize = TYPE_SIZE_UNIT (argtype))
    3489                 :       85105 :                 if (TREE_CODE (argsize) == INTEGER_CST)
    3490                 :             :                   {
    3491                 :       84814 :                     const int prec = TYPE_PRECISION (sizetype);
    3492                 :       84814 :                     wide_int minsize = wi::to_wide (sizrng[0], prec);
    3493                 :       84814 :                     minsize *= wi::to_wide (argsize, prec);
    3494                 :       84814 :                     access_size = wide_int_to_tree (sizetype, minsize);
    3495                 :       84814 :                   }
    3496                 :             :             }
    3497                 :             :           else
    3498                 :             :             access_size = access_nelts;
    3499                 :             :         }
    3500                 :             : 
    3501                 :       89139 :       if (integer_zerop (ptr))
    3502                 :             :         {
    3503                 :        1939 :           if (!access.second.internal_p
    3504                 :        1939 :               && sizidx >= 0 && tree_int_cst_sgn (sizrng[0]) > 0)
    3505                 :             :             {
    3506                 :             :               /* Warn about null pointers with positive sizes.  This is
    3507                 :             :                  different from also declaring the pointer argument with
    3508                 :             :                  attribute nonnull when the function accepts null pointers
    3509                 :             :                  only when the corresponding size is zero.  */
    3510                 :          27 :               if (warning_at (loc, OPT_Wnonnull,
    3511                 :             :                                    "argument %i is null but "
    3512                 :             :                                    "the corresponding size argument "
    3513                 :             :                                    "%i value is %s",
    3514                 :             :                                    ptridx + 1, sizidx + 1, sizstr))
    3515                 :           8 :                 arg_warned = OPT_Wnonnull;
    3516                 :             :             }
    3517                 :             : 
    3518                 :          16 :           if (arg_warned != no_warning)
    3519                 :             :             {
    3520                 :           8 :               append_attrname (access, attrstr, sizeof attrstr);
    3521                 :             :               /* Remember a warning has been issued and avoid warning
    3522                 :             :                  again below for the same attribute.  */
    3523                 :           8 :               opt_warned = OPT_Wnonnull;
    3524                 :           8 :               continue;
    3525                 :             :             }
    3526                 :             :         }
    3527                 :             : 
    3528                 :       89131 :       access_data data (m_ptr_qry.rvals, stmt, access.second.mode,
    3529                 :       89131 :                         NULL_TREE, false, NULL_TREE, false);
    3530                 :      178262 :       access_ref* const pobj = (access.second.mode == access_write_only
    3531                 :       89131 :                                 ? &data.dst : &data.src);
    3532                 :       89131 :       tree objsize = compute_objsize (ptr, stmt, 1, pobj, &m_ptr_qry);
    3533                 :             : 
    3534                 :             :       /* The size of the destination or source object.  */
    3535                 :       89131 :       tree dstsize = NULL_TREE, srcsize = NULL_TREE;
    3536                 :       89131 :       if (access.second.mode == access_read_only
    3537                 :             :           || access.second.mode == access_none)
    3538                 :             :         {
    3539                 :             :           /* For a read-only argument there is no destination.  For
    3540                 :             :              no access, set the source as well and differentiate via
    3541                 :             :              the access flag below.  */
    3542                 :        1784 :           srcsize = objsize;
    3543                 :        1784 :           if (access.second.mode == access_read_only
    3544                 :             :               || access.second.mode == access_none)
    3545                 :             :             {
    3546                 :             :               /* For a read-only attribute there is no destination so
    3547                 :             :                  clear OBJSIZE.  This emits "reading N bytes" kind of
    3548                 :             :                  diagnostics instead of the "writing N bytes" kind,
    3549                 :             :                  unless MODE is none.  */
    3550                 :        1784 :               objsize = NULL_TREE;
    3551                 :             :             }
    3552                 :             :         }
    3553                 :             :       else
    3554                 :             :         dstsize = objsize;
    3555                 :             : 
    3556                 :             :       /* Clear the no-warning bit in case it was set by check_access
    3557                 :             :          in a prior iteration so that accesses via different arguments
    3558                 :             :          are diagnosed.  */
    3559                 :       89131 :       suppress_warning (stmt, OPT_Wstringop_overflow_, false);
    3560                 :       89131 :       access_mode mode = data.mode;
    3561                 :       89131 :       if (mode == access_deferred)
    3562                 :       85442 :         mode = TYPE_READONLY (argtype) ? access_read_only : access_read_write;
    3563                 :       89131 :       check_access (stmt, access_size, /*maxread=*/ NULL_TREE, srcsize,
    3564                 :             :                     dstsize, mode, &data, m_ptr_qry.rvals);
    3565                 :             : 
    3566                 :       89131 :       if (warning_suppressed_p (stmt, OPT_Wstringop_overflow_))
    3567                 :             :         opt_warned = OPT_Wstringop_overflow_;
    3568                 :       88924 :       if (opt_warned != no_warning)
    3569                 :             :         {
    3570                 :         322 :           if (access.second.internal_p)
    3571                 :             :             {
    3572                 :         146 :               unsigned HOST_WIDE_INT nelts =
    3573                 :          73 :                 access_nelts ? access.second.minsize : HOST_WIDE_INT_M1U;
    3574                 :          73 :               tree arrtype = build_printable_array_type (argtype, nelts);
    3575                 :          73 :               inform (loc, "referencing argument %u of type %qT",
    3576                 :             :                       ptridx + 1, arrtype);
    3577                 :             :             }
    3578                 :             :           else
    3579                 :             :             /* If check_access issued a warning above, append the relevant
    3580                 :             :                attribute to the string.  */
    3581                 :         249 :             append_attrname (access, attrstr, sizeof attrstr);
    3582                 :             :         }
    3583                 :             :     }
    3584                 :             : 
    3585                 :     3966886 :   if (*attrstr)
    3586                 :             :     {
    3587                 :         145 :       if (fndecl)
    3588                 :         129 :         inform (get_location (fndecl),
    3589                 :             :                 "in a call to function %qD declared with attribute %qs",
    3590                 :             :                 fndecl, attrstr);
    3591                 :             :       else
    3592                 :          16 :         inform (get_location (stmt),
    3593                 :             :                 "in a call with type %qT and attribute %qs",
    3594                 :             :                 fntype, attrstr);
    3595                 :             :     }
    3596                 :     3966741 :   else if (opt_warned != no_warning)
    3597                 :             :     {
    3598                 :          91 :       if (fndecl)
    3599                 :          91 :         inform (get_location (fndecl),
    3600                 :             :                 "in a call to function %qD", fndecl);
    3601                 :             :       else
    3602                 :           0 :         inform (get_location (stmt),
    3603                 :             :                 "in a call with type %qT", fntype);
    3604                 :             :     }
    3605                 :             : 
    3606                 :             :   /* Set the bit in case it was cleared and not set above.  */
    3607                 :         236 :   if (opt_warned != no_warning)
    3608                 :         236 :     suppress_warning (stmt, opt_warned);
    3609                 :     3966890 : }
    3610                 :             : 
    3611                 :             : /* Check call STMT to an ordinary (non-built-in) function for invalid
    3612                 :             :    accesses.  Return true if a call has been handled.  */
    3613                 :             : 
    3614                 :             : bool
    3615                 :    21436186 : pass_waccess::check_call_access (gcall *stmt)
    3616                 :             : {
    3617                 :    21436186 :   tree fntype = gimple_call_fntype (stmt);
    3618                 :    20817321 :   if (!fntype)
    3619                 :             :     return false;
    3620                 :             : 
    3621                 :    20817321 :   tree fntypeattrs = TYPE_ATTRIBUTES (fntype);
    3622                 :    20817321 :   if (!fntypeattrs)
    3623                 :             :     return false;
    3624                 :             : 
    3625                 :             :   /* Map of attribute access specifications for function arguments.  */
    3626                 :     3981234 :   rdwr_map rdwr_idx;
    3627                 :     3981234 :   init_attr_rdwr_indices (&rdwr_idx, fntypeattrs);
    3628                 :             : 
    3629                 :     3981234 :   unsigned nargs = call_nargs (stmt);
    3630                 :    12078042 :   for (unsigned i = 0; i != nargs; ++i)
    3631                 :             :     {
    3632                 :     8096808 :       tree arg = call_arg (stmt, i);
    3633                 :             : 
    3634                 :             :       /* Save the actual argument that corresponds to the access attribute
    3635                 :             :          operand for later processing.  */
    3636                 :     8096808 :       if (attr_access *access = rdwr_idx.get (i))
    3637                 :             :         {
    3638                 :       92259 :           if (POINTER_TYPE_P (TREE_TYPE (arg)))
    3639                 :             :             {
    3640                 :       89897 :               access->ptr = arg;
    3641                 :             :               /* A nonnull ACCESS->SIZE contains VLA bounds.  */
    3642                 :             :             }
    3643                 :             :           else
    3644                 :             :             {
    3645                 :        2362 :               access->size = arg;
    3646                 :        2362 :               gcc_assert (access->ptr == NULL_TREE);
    3647                 :             :             }
    3648                 :             :         }
    3649                 :             :     }
    3650                 :             : 
    3651                 :             :   /* Check attribute access arguments.  */
    3652                 :     3981234 :   tree fndecl = gimple_call_fndecl (stmt);
    3653                 :     3981234 :   maybe_check_access_sizes (&rdwr_idx, fndecl, fntype, stmt);
    3654                 :             : 
    3655                 :     3981234 :   check_alloc_size_call (stmt);
    3656                 :     3981234 :   return true;
    3657                 :     3981234 : }
    3658                 :             : 
    3659                 :             : /* Check arguments in a call STMT for attribute nonstring.  */
    3660                 :             : 
    3661                 :             : static void
    3662                 :     6579184 : check_nonstring_args (gcall *stmt)
    3663                 :             : {
    3664                 :     6579184 :   tree fndecl = gimple_call_fndecl (stmt);
    3665                 :             : 
    3666                 :             :   /* Detect passing non-string arguments to functions expecting
    3667                 :             :      nul-terminated strings.  */
    3668                 :     6579184 :   maybe_warn_nonstring_arg (fndecl, stmt);
    3669                 :     6579184 : }
    3670                 :             : 
    3671                 :             : /* Issue a warning if a deallocation function such as free, realloc,
    3672                 :             :    or C++ operator delete is called with an argument not returned by
    3673                 :             :    a matching allocation function such as malloc or the corresponding
    3674                 :             :    form of C++ operator new.  */
    3675                 :             : 
    3676                 :             : void
    3677                 :     6579184 : pass_waccess::maybe_check_dealloc_call (gcall *call)
    3678                 :             : {
    3679                 :     6579184 :   tree fndecl = gimple_call_fndecl (call);
    3680                 :     6579184 :   if (!fndecl)
    3681                 :     6395445 :     return;
    3682                 :             : 
    3683                 :     6211822 :   unsigned argno = fndecl_dealloc_argno (fndecl);
    3684                 :     6211822 :   if ((unsigned) call_nargs (call) <= argno)
    3685                 :             :     return;
    3686                 :             : 
    3687                 :      184393 :   tree ptr = gimple_call_arg (call, argno);
    3688                 :      184393 :   if (integer_zerop (ptr))
    3689                 :             :     return;
    3690                 :             : 
    3691                 :      184302 :   access_ref aref;
    3692                 :      184302 :   if (!compute_objsize (ptr, call, 0, &aref, &m_ptr_qry))
    3693                 :             :     return;
    3694                 :             : 
    3695                 :      184302 :   tree ref = aref.ref;
    3696                 :      184302 :   if (integer_zerop (ref))
    3697                 :             :     return;
    3698                 :             : 
    3699                 :      184201 :   tree dealloc_decl = fndecl;
    3700                 :      184201 :   location_t loc = gimple_location (call);
    3701                 :             : 
    3702                 :      184201 :   if (DECL_P (ref) || EXPR_P (ref))
    3703                 :             :     {
    3704                 :             :       /* Diagnose freeing a declared object.  */
    3705                 :      106104 :       if (aref.ref_declared ())
    3706                 :             :         {
    3707                 :         152 :           auto_diagnostic_group d;
    3708                 :         152 :           if (warning_at (loc, OPT_Wfree_nonheap_object,
    3709                 :             :                           "%qD called on unallocated object %qD",
    3710                 :             :                           dealloc_decl, ref))
    3711                 :             :             {
    3712                 :         140 :               inform (get_location (ref), "declared here");
    3713                 :         140 :               return;
    3714                 :             :             }
    3715                 :         152 :         }
    3716                 :             : 
    3717                 :             :       /* Diagnose freeing a pointer that includes a positive offset.
    3718                 :             :          Such a pointer cannot refer to the beginning of an allocated
    3719                 :             :          object.  A negative offset may refer to it.  */
    3720                 :      105964 :       if (aref.sizrng[0] != aref.sizrng[1]
    3721                 :      105964 :           && warn_dealloc_offset (loc, call, aref))
    3722                 :             :         return;
    3723                 :             :     }
    3724                 :       78097 :   else if (CONSTANT_CLASS_P (ref))
    3725                 :             :     {
    3726                 :          38 :       auto_diagnostic_group d;
    3727                 :          38 :       if (warning_at (loc, OPT_Wfree_nonheap_object,
    3728                 :             :                       "%qD called on a pointer to an unallocated "
    3729                 :             :                       "object %qE", dealloc_decl, ref))
    3730                 :             :         {
    3731                 :          38 :           if (TREE_CODE (ptr) == SSA_NAME)
    3732                 :             :             {
    3733                 :          12 :               gimple *def_stmt = SSA_NAME_DEF_STMT (ptr);
    3734                 :          12 :               if (is_gimple_assign (def_stmt))
    3735                 :             :                 {
    3736                 :          12 :                   location_t loc = gimple_location (def_stmt);
    3737                 :          12 :                   inform (loc, "assigned here");
    3738                 :             :                 }
    3739                 :             :             }
    3740                 :          38 :           return;
    3741                 :             :         }
    3742                 :          38 :     }
    3743                 :       78059 :   else if (TREE_CODE (ref) == SSA_NAME)
    3744                 :             :     {
    3745                 :             :       /* Also warn if the pointer argument refers to the result
    3746                 :             :          of an allocation call like alloca or VLA.  */
    3747                 :       78059 :       gimple *def_stmt = SSA_NAME_DEF_STMT (ref);
    3748                 :       78059 :       if (!def_stmt)
    3749                 :             :         return;
    3750                 :             : 
    3751                 :       78059 :       if (is_gimple_call (def_stmt))
    3752                 :             :         {
    3753                 :       39911 :           bool warned = false;
    3754                 :       39911 :           if (gimple_call_alloc_p (def_stmt))
    3755                 :             :             {
    3756                 :       36544 :               if (matching_alloc_calls_p (def_stmt, dealloc_decl))
    3757                 :             :                 {
    3758                 :       36229 :                   if (warn_dealloc_offset (loc, call, aref))
    3759                 :             :                     return;
    3760                 :             :                 }
    3761                 :             :               else
    3762                 :             :                 {
    3763                 :         315 :                   tree alloc_decl = gimple_call_fndecl (def_stmt);
    3764                 :         315 :                   const opt_code opt =
    3765                 :         315 :                     (DECL_IS_OPERATOR_NEW_P (alloc_decl)
    3766                 :         169 :                      || DECL_IS_OPERATOR_DELETE_P (dealloc_decl)
    3767                 :         315 :                      ? OPT_Wmismatched_new_delete
    3768                 :         315 :                      : OPT_Wmismatched_dealloc);
    3769                 :         315 :                   warned = warning_at (loc, opt,
    3770                 :             :                                        "%qD called on pointer returned "
    3771                 :             :                                        "from a mismatched allocation "
    3772                 :             :                                        "function", dealloc_decl);
    3773                 :             :                 }
    3774                 :             :             }
    3775                 :        3367 :           else if (gimple_call_builtin_p (def_stmt, BUILT_IN_ALLOCA)
    3776                 :        3367 :                    || gimple_call_builtin_p (def_stmt,
    3777                 :             :                                              BUILT_IN_ALLOCA_WITH_ALIGN))
    3778                 :          20 :             warned = warning_at (loc, OPT_Wfree_nonheap_object,
    3779                 :             :                                  "%qD called on pointer to "
    3780                 :             :                                  "an unallocated object",
    3781                 :             :                                  dealloc_decl);
    3782                 :        3347 :           else if (warn_dealloc_offset (loc, call, aref))
    3783                 :             :             return;
    3784                 :             : 
    3785                 :         335 :           if (warned)
    3786                 :             :             {
    3787                 :         215 :               tree fndecl = gimple_call_fndecl (def_stmt);
    3788                 :         215 :               inform (gimple_location (def_stmt),
    3789                 :             :                       "returned from %qD", fndecl);
    3790                 :         215 :               return;
    3791                 :             :             }
    3792                 :             :         }
    3793                 :       38148 :       else if (gimple_nop_p (def_stmt))
    3794                 :             :         {
    3795                 :       13602 :           ref = SSA_NAME_VAR (ref);
    3796                 :             :           /* Diagnose freeing a pointer that includes a positive offset.  */
    3797                 :       13602 :           if (TREE_CODE (ref) == PARM_DECL
    3798                 :       13586 :               && !aref.deref
    3799                 :       13586 :               && aref.sizrng[0] != aref.sizrng[1]
    3800                 :       13602 :               && aref.offrng[0] > 0 && aref.offrng[1] > 0
    3801                 :       13608 :               && warn_dealloc_offset (loc, call, aref))
    3802                 :           6 :             return;
    3803                 :             :         }
    3804                 :             :     }
    3805                 :             : }
    3806                 :             : 
    3807                 :             : /* Return true if either USE_STMT's basic block (that of a pointer's use)
    3808                 :             :    is dominated by INVAL_STMT's (that of a pointer's invalidating statement,
    3809                 :             :    which is either a clobber or a deallocation call), or if they're in
    3810                 :             :    the same block, USE_STMT follows INVAL_STMT.  */
    3811                 :             : 
    3812                 :             : bool
    3813                 :     4811658 : pass_waccess::use_after_inval_p (gimple *inval_stmt, gimple *use_stmt,
    3814                 :             :                                  bool last_block /* = false */)
    3815                 :             : {
    3816                 :     4811658 :   tree clobvar =
    3817                 :     4811658 :     gimple_clobber_p (inval_stmt) ? gimple_assign_lhs (inval_stmt) : NULL_TREE;
    3818                 :             : 
    3819                 :     4811658 :   basic_block inval_bb = gimple_bb (inval_stmt);
    3820                 :     4811658 :   basic_block use_bb = gimple_bb (use_stmt);
    3821                 :             : 
    3822                 :     4811658 :   if (!inval_bb || !use_bb)
    3823                 :             :     return false;
    3824                 :             : 
    3825                 :     4811337 :   if (inval_bb != use_bb)
    3826                 :             :     {
    3827                 :     4200256 :       if (dominated_by_p (CDI_DOMINATORS, use_bb, inval_bb))
    3828                 :             :         return true;
    3829                 :             : 
    3830                 :     4198966 :       if (!clobvar || !last_block)
    3831                 :             :         return false;
    3832                 :             : 
    3833                 :             :       /* Proceed only when looking for uses of dangling pointers.  */
    3834                 :     2962876 :       auto gsi = gsi_for_stmt (use_stmt);
    3835                 :             : 
    3836                 :             :       /* A use statement in the last basic block in a function or one that
    3837                 :             :          falls through to it is after any other prior clobber of the used
    3838                 :             :          variable unless it's followed by a clobber of the same variable. */
    3839                 :     2962876 :       basic_block bb = use_bb;
    3840                 :     2962876 :       while (bb != inval_bb
    3841                 :     3570426 :              && single_succ_p (bb)
    3842                 :     5001569 :              && !(single_succ_edge (bb)->flags
    3843                 :     1152065 :                   & (EDGE_EH | EDGE_ABNORMAL | EDGE_DFS_BACK)))
    3844                 :             :         {
    3845                 :     9354400 :           for (; !gsi_end_p (gsi); gsi_next_nondebug (&gsi))
    3846                 :             :             {
    3847                 :     8467772 :               gimple *stmt = gsi_stmt (gsi);
    3848                 :     8467772 :               if (gimple_clobber_p (stmt))
    3849                 :             :                 {
    3850                 :      357254 :                   if (clobvar == gimple_assign_lhs (stmt))
    3851                 :             :                     /* The use is followed by a clobber.  */
    3852                 :             :                     return false;
    3853                 :             :                 }
    3854                 :             :             }
    3855                 :             : 
    3856                 :      886628 :           bb = single_succ (bb);
    3857                 :     1773256 :           gsi = gsi_start_bb (bb);
    3858                 :             :         }
    3859                 :             : 
    3860                 :             :       /* The use is one of a dangling pointer if a clobber of the variable
    3861                 :             :          [the pointer points to] has not been found before the function exit
    3862                 :             :          point.  */
    3863                 :     2948112 :       return bb == EXIT_BLOCK_PTR_FOR_FN (cfun);
    3864                 :             :     }
    3865                 :             : 
    3866                 :      611081 :   if (bitmap_set_bit (m_bb_uids_set, inval_bb->index))
    3867                 :             :     /* The first time this basic block is visited assign increasing ids
    3868                 :             :        to consecutive statements in it.  Use the ids to determine which
    3869                 :             :        precedes which.  This avoids the linear traversal on subsequent
    3870                 :             :        visits to the same block.  */
    3871                 :      313038 :     renumber_gimple_stmt_uids_in_block (m_func, inval_bb);
    3872                 :             : 
    3873                 :      611081 :   return gimple_uid (inval_stmt) < gimple_uid (use_stmt);
    3874                 :             : }
    3875                 :             : 
    3876                 :             : /* Issue a warning for the USE_STMT of pointer or reference REF rendered
    3877                 :             :    invalid by INVAL_STMT.  REF may be null when it's been optimized away.
    3878                 :             :    When nonnull, INVAL_STMT is the deallocation function that rendered
    3879                 :             :    the pointer or reference dangling.  Otherwise, VAR is the auto variable
    3880                 :             :    (including an unnamed temporary such as a compound literal) whose
    3881                 :             :    lifetime's rended it dangling.  MAYBE is true to issue the "maybe"
    3882                 :             :    kind of warning.  EQUALITY is true when the pointer is used in
    3883                 :             :    an equality expression.  */
    3884                 :             : 
    3885                 :             : void
    3886                 :       18060 : pass_waccess::warn_invalid_pointer (tree ref, gimple *use_stmt,
    3887                 :             :                                     gimple *inval_stmt, tree var,
    3888                 :             :                                     bool maybe, bool equality /* = false */)
    3889                 :             : {
    3890                 :             :   /* Avoid printing the unhelpful "<unknown>" in the diagnostics.  */
    3891                 :       18060 :   if (ref && TREE_CODE (ref) == SSA_NAME)
    3892                 :             :     {
    3893                 :       18032 :       tree var = SSA_NAME_VAR (ref);
    3894                 :       17913 :       if (!var)
    3895                 :             :         ref = NULL_TREE;
    3896                 :             :       /* Don't warn for cases like when a cdtor returns 'this' on ARM.  */
    3897                 :       17913 :       else if (warning_suppressed_p (var, OPT_Wuse_after_free))
    3898                 :             :         return;
    3899                 :       17910 :       else if (DECL_ARTIFICIAL (var))
    3900                 :         156 :         ref = NULL_TREE;
    3901                 :             :     }
    3902                 :             : 
    3903                 :       18057 :   location_t use_loc = gimple_location (use_stmt);
    3904                 :       18057 :   if (use_loc == UNKNOWN_LOCATION)
    3905                 :             :     {
    3906                 :           0 :       use_loc = m_func->function_end_locus;
    3907                 :           0 :       if (!ref)
    3908                 :             :         /* Avoid issuing a warning with no context other than
    3909                 :             :            the function.  That would make it difficult to debug
    3910                 :             :            in any but very simple cases.  */
    3911                 :             :         return;
    3912                 :             :     }
    3913                 :             : 
    3914                 :       18057 :   if (is_gimple_call (inval_stmt))
    3915                 :             :     {
    3916                 :       17861 :       if (!m_early_checks_p
    3917                 :        6419 :           || (equality && warn_use_after_free < 3)
    3918                 :        5885 :           || (maybe && warn_use_after_free < 2)
    3919                 :       23566 :           || warning_suppressed_p (use_stmt, OPT_Wuse_after_free))
    3920                 :       12213 :         return;
    3921                 :             : 
    3922                 :        5648 :       const tree inval_decl = gimple_call_fndecl (inval_stmt);
    3923                 :             : 
    3924                 :        5648 :       auto_diagnostic_group d;
    3925                 :       11150 :       if ((ref && warning_at (use_loc, OPT_Wuse_after_free,
    3926                 :             :                               (maybe
    3927                 :             :                                ? G_("pointer %qE may be used after %qD")
    3928                 :             :                                : G_("pointer %qE used after %qD")),
    3929                 :             :                               ref, inval_decl))
    3930                 :       10940 :           || (!ref && warning_at (use_loc, OPT_Wuse_after_free,
    3931                 :             :                               (maybe
    3932                 :             :                                ? G_("pointer may be used after %qD")
    3933                 :             :                                : G_("pointer used after %qD")),
    3934                 :             :                                   inval_decl)))
    3935                 :             :         {
    3936                 :         359 :           location_t loc = gimple_location (inval_stmt);
    3937                 :         359 :           inform (loc, "call to %qD here", inval_decl);
    3938                 :         359 :           suppress_warning (use_stmt, OPT_Wuse_after_free);
    3939                 :             :         }
    3940                 :        5648 :       return;
    3941                 :        5648 :     }
    3942                 :             : 
    3943                 :         196 :   if (equality
    3944                 :         190 :       || (maybe && warn_dangling_pointer < 2)
    3945                 :         381 :       || warning_suppressed_p (use_stmt, OPT_Wdangling_pointer_))
    3946                 :          70 :     return;
    3947                 :             : 
    3948                 :         126 :   if (DECL_NAME (var))
    3949                 :             :     {
    3950                 :         111 :       auto_diagnostic_group d;
    3951                 :         111 :       if ((ref
    3952                 :         174 :            && warning_at (use_loc, OPT_Wdangling_pointer_,
    3953                 :             :                           (maybe
    3954                 :             :                            ? G_("dangling pointer %qE to %qD may be used")
    3955                 :             :                            : G_("using dangling pointer %qE to %qD")),
    3956                 :             :                           ref, var))
    3957                 :         111 :           || (!ref
    3958                 :          22 :               && warning_at (use_loc, OPT_Wdangling_pointer_,
    3959                 :             :                              (maybe
    3960                 :             :                               ? G_("dangling pointer to %qD may be used")
    3961                 :             :                               : G_("using a dangling pointer to %qD")),
    3962                 :             :                              var)))
    3963                 :          98 :         inform (DECL_SOURCE_LOCATION (var),
    3964                 :             :                 "%qD declared here", var);
    3965                 :         111 :       suppress_warning (use_stmt, OPT_Wdangling_pointer_);
    3966                 :         111 :       return;
    3967                 :         111 :     }
    3968                 :             : 
    3969                 :          15 :   if ((ref
    3970                 :          14 :        && warning_at (use_loc, OPT_Wdangling_pointer_,
    3971                 :             :                       (maybe
    3972                 :             :                        ? G_("dangling pointer %qE to an unnamed temporary "
    3973                 :             :                             "may be used")
    3974                 :             :                        : G_("using dangling pointer %qE to an unnamed "
    3975                 :             :                             "temporary")),
    3976                 :             :                       ref))
    3977                 :          15 :       || (!ref
    3978                 :          14 :           && warning_at (use_loc, OPT_Wdangling_pointer_,
    3979                 :             :                          (maybe
    3980                 :             :                           ? G_("dangling pointer to an unnamed temporary "
    3981                 :             :                                "may be used")
    3982                 :             :                           : G_("using a dangling pointer to an unnamed "
    3983                 :             :                                "temporary")))))
    3984                 :             :     {
    3985                 :          14 :       inform (DECL_SOURCE_LOCATION (var),
    3986                 :             :               "unnamed temporary defined here");
    3987                 :          14 :       suppress_warning (use_stmt, OPT_Wdangling_pointer_);
    3988                 :             :     }
    3989                 :             : }
    3990                 :             : 
    3991                 :             : /* If STMT is a call to either the standard realloc or to a user-defined
    3992                 :             :    reallocation function returns its LHS and set *PTR to the reallocated
    3993                 :             :    pointer.  Otherwise return null.  */
    3994                 :             : 
    3995                 :             : static tree
    3996                 :      655538 : get_realloc_lhs (gimple *stmt, tree *ptr)
    3997                 :             : {
    3998                 :      655538 :   if (gimple_call_builtin_p (stmt, BUILT_IN_REALLOC))
    3999                 :             :     {
    4000                 :       15901 :       *ptr = gimple_call_arg (stmt, 0);
    4001                 :       15901 :       return gimple_call_lhs (stmt);
    4002                 :             :     }
    4003                 :             : 
    4004                 :     1127268 :   gcall *call = dyn_cast<gcall *>(stmt);
    4005                 :      487771 :   if (!call)
    4006                 :             :     return NULL_TREE;
    4007                 :             : 
    4008                 :      487771 :   tree fnattr = NULL_TREE;
    4009                 :      487771 :   tree fndecl = gimple_call_fndecl (call);
    4010                 :      487771 :   if (fndecl)
    4011                 :      487771 :     fnattr = DECL_ATTRIBUTES (fndecl);
    4012                 :             :   else
    4013                 :             :     {
    4014                 :           0 :       tree fntype = gimple_call_fntype (stmt);
    4015                 :           0 :       if (!fntype)
    4016                 :             :         return NULL_TREE;
    4017                 :           0 :       fnattr = TYPE_ATTRIBUTES (fntype);
    4018                 :             :     }
    4019                 :             : 
    4020                 :      487771 :   if (!fnattr)
    4021                 :             :     return NULL_TREE;
    4022                 :             : 
    4023                 :      484988 :   for (tree ats = fnattr;  (ats = lookup_attribute ("*dealloc", ats));
    4024                 :       14169 :        ats = TREE_CHAIN (ats))
    4025                 :             :     {
    4026                 :       14309 :       tree args = TREE_VALUE (ats);
    4027                 :       14309 :       if (!args)
    4028                 :           0 :         continue;
    4029                 :             : 
    4030                 :       14309 :       tree alloc = TREE_VALUE (args);
    4031                 :       14309 :       if (!alloc)
    4032                 :           0 :         continue;
    4033                 :             : 
    4034                 :       14309 :       if (alloc == DECL_NAME (fndecl))
    4035                 :             :         {
    4036                 :         140 :           unsigned argno = 0;
    4037                 :         140 :           if (tree index = TREE_CHAIN (args))
    4038                 :          82 :             argno = TREE_INT_CST_LOW (TREE_VALUE (index)) - 1;
    4039                 :         140 :           *ptr = gimple_call_arg (stmt, argno);
    4040                 :         140 :           return gimple_call_lhs (stmt);
    4041                 :             :         }
    4042                 :             :     }
    4043                 :             : 
    4044                 :             :   return NULL_TREE;
    4045                 :             : }
    4046                 :             : 
    4047                 :             : /* Warn if STMT is a call to a deallocation function that's not a match
    4048                 :             :    for the REALLOC_STMT call.  Return true if warned.  */
    4049                 :             : 
    4050                 :             : static bool
    4051                 :       74469 : maybe_warn_mismatched_realloc (tree ptr, gimple *realloc_stmt, gimple *stmt)
    4052                 :             : {
    4053                 :       74469 :   if (!is_gimple_call (stmt))
    4054                 :             :     return false;
    4055                 :             : 
    4056                 :       39791 :   tree fndecl = gimple_call_fndecl (stmt);
    4057                 :       39791 :   if (!fndecl)
    4058                 :             :     return false;
    4059                 :             : 
    4060                 :       39766 :   unsigned argno = fndecl_dealloc_argno (fndecl);
    4061                 :       39766 :   if (call_nargs (stmt) <= argno)
    4062                 :             :     return false;
    4063                 :             : 
    4064                 :        2450 :   if (matching_alloc_calls_p (realloc_stmt, fndecl))
    4065                 :             :     return false;
    4066                 :             : 
    4067                 :             :   /* Avoid printing the unhelpful "<unknown>" in the diagnostics.  */
    4068                 :          43 :   if (ptr && TREE_CODE (ptr) == SSA_NAME
    4069                 :          86 :       && (!SSA_NAME_VAR (ptr) || DECL_ARTIFICIAL (SSA_NAME_VAR (ptr))))
    4070                 :             :     ptr = NULL_TREE;
    4071                 :             : 
    4072                 :          43 :   location_t loc = gimple_location (stmt);
    4073                 :          43 :   tree realloc_decl = gimple_call_fndecl (realloc_stmt);
    4074                 :          43 :   tree dealloc_decl = gimple_call_fndecl (stmt);
    4075                 :          43 :   if (ptr && !warning_at (loc, OPT_Wmismatched_dealloc,
    4076                 :             :                           "%qD called on pointer %qE passed to mismatched "
    4077                 :             :                           "allocation function %qD",
    4078                 :             :                           dealloc_decl, ptr, realloc_decl))
    4079                 :           4 :     return false;
    4080                 :          39 :   if (!ptr && !warning_at (loc, OPT_Wmismatched_dealloc,
    4081                 :             :                            "%qD called on a pointer passed to mismatched "
    4082                 :             :                            "reallocation function %qD",
    4083                 :             :                            dealloc_decl, realloc_decl))
    4084                 :           0 :     return false;
    4085                 :             : 
    4086                 :          39 :   inform (gimple_location (realloc_stmt),
    4087                 :             :           "call to %qD", realloc_decl);
    4088                 :          39 :   return true;
    4089                 :             : }
    4090                 :             : 
    4091                 :             : /* Return true if P and Q point to the same object, and false if they
    4092                 :             :    either don't or their relationship cannot be determined.  */
    4093                 :             : 
    4094                 :             : static bool
    4095                 :       74358 : pointers_related_p (gimple *stmt, tree p, tree q, pointer_query &qry,
    4096                 :             :                     auto_bitmap &visited)
    4097                 :             : {
    4098                 :       74358 :   if (!ptr_derefs_may_alias_p (p, q))
    4099                 :             :     return false;
    4100                 :             : 
    4101                 :             :   /* TODO: Work harder to rule out relatedness.  */
    4102                 :       74358 :   access_ref pref, qref;
    4103                 :       74358 :   if (!qry.get_ref (p, stmt, &pref, 0)
    4104                 :       74358 :       || !qry.get_ref (q, stmt, &qref, 0))
    4105                 :             :     /* GET_REF() only rarely fails.  When it does, it's likely because
    4106                 :             :        it involves a self-referential PHI.  Return a conservative result.  */
    4107                 :           0 :     return false;
    4108                 :             : 
    4109                 :       74358 :   if (pref.ref == qref.ref)
    4110                 :             :     return true;
    4111                 :             : 
    4112                 :             :   /* If either pointer is a PHI, iterate over all its operands and
    4113                 :             :      return true if they're all related to the other pointer.  */
    4114                 :          48 :   tree ptr = q;
    4115                 :          48 :   unsigned version;
    4116                 :          48 :   gphi *phi = pref.phi ();
    4117                 :          48 :   if (phi)
    4118                 :          48 :     version = SSA_NAME_VERSION (pref.ref);
    4119                 :             :   else
    4120                 :             :     {
    4121                 :           0 :       phi = qref.phi ();
    4122                 :           0 :       if (!phi)
    4123                 :             :         return false;
    4124                 :             : 
    4125                 :           0 :       ptr = p;
    4126                 :           0 :       version = SSA_NAME_VERSION (qref.ref);
    4127                 :             :     }
    4128                 :             : 
    4129                 :          48 :   if (!bitmap_set_bit (visited, version))
    4130                 :             :     return true;
    4131                 :             : 
    4132                 :          24 :   unsigned nargs = gimple_phi_num_args (phi);
    4133                 :          72 :   for (unsigned i = 0; i != nargs; ++i)
    4134                 :             :     {
    4135                 :          48 :       tree arg = gimple_phi_arg_def (phi, i);
    4136                 :          48 :       if (!pointers_related_p (stmt, arg, ptr, qry, visited))
    4137                 :             :         return false;
    4138                 :             :     }
    4139                 :             : 
    4140                 :             :   return true;
    4141                 :             : }
    4142                 :             : 
    4143                 :             : /* Convenience wrapper for the above.  */
    4144                 :             : 
    4145                 :             : static bool
    4146                 :       74310 : pointers_related_p (gimple *stmt, tree p, tree q, pointer_query &qry)
    4147                 :             : {
    4148                 :       74310 :   auto_bitmap visited;
    4149                 :       74310 :   return pointers_related_p (stmt, p, q, qry, visited);
    4150                 :       74310 : }
    4151                 :             : 
    4152                 :             : /* For a STMT either a call to a deallocation function or a clobber, warn
    4153                 :             :    for uses of the pointer PTR it was called with (including its copies
    4154                 :             :    or others derived from it by pointer arithmetic).  If STMT is a clobber,
    4155                 :             :    VAR is the decl of the clobbered variable.  When MAYBE is true use
    4156                 :             :    a "maybe" form of diagnostic.  */
    4157                 :             : 
    4158                 :             : void
    4159                 :      655538 : pass_waccess::check_pointer_uses (gimple *stmt, tree ptr,
    4160                 :             :                                   tree var /* = NULL_TREE */,
    4161                 :             :                                   bool maybe /* = false */)
    4162                 :             : {
    4163                 :      655538 :   gcc_assert (TREE_CODE (ptr) == SSA_NAME);
    4164                 :             : 
    4165                 :      655538 :   const bool check_dangling = !is_gimple_call (stmt);
    4166                 :      655538 :   basic_block stmt_bb = gimple_bb (stmt);
    4167                 :             : 
    4168                 :             :   /* If STMT is a reallocation function set to the reallocated pointer
    4169                 :             :      and the LHS of the call, respectively.  */
    4170                 :      655538 :   tree realloc_ptr = NULL_TREE;
    4171                 :      655538 :   tree realloc_lhs = get_realloc_lhs (stmt, &realloc_ptr);
    4172                 :             : 
    4173                 :      655538 :   auto_bitmap visited;
    4174                 :             : 
    4175                 :      655538 :   auto_vec<tree, 8> pointers;
    4176                 :      655538 :   pointers.quick_push (ptr);
    4177                 :      655538 :   hash_map<tree, int> *phi_map = nullptr;
    4178                 :             : 
    4179                 :             :   /* Starting with PTR, iterate over POINTERS added by the loop, and
    4180                 :             :      either warn for their uses in basic blocks dominated by the STMT
    4181                 :             :      or in statements that follow it in the same basic block, or add
    4182                 :             :      them to POINTERS if they point into the same object as PTR (i.e.,
    4183                 :             :      are obtained by pointer arithmetic on PTR).  */
    4184                 :     2961250 :   for (unsigned i = 0; i != pointers.length (); ++i)
    4185                 :             :     {
    4186                 :      825087 :       tree ptr = pointers[i];
    4187                 :      825087 :       if (!bitmap_set_bit (visited, SSA_NAME_VERSION (ptr)))
    4188                 :             :         /* Avoid revisiting the same pointer.  */
    4189                 :          37 :         continue;
    4190                 :             : 
    4191                 :      825050 :       use_operand_p use_p;
    4192                 :      825050 :       imm_use_iterator iter;
    4193                 :     4075326 :       FOR_EACH_IMM_USE_FAST (use_p, iter, ptr)
    4194                 :             :         {
    4195                 :     3250276 :           gimple *use_stmt = USE_STMT (use_p);
    4196                 :     3250276 :           if (use_stmt == stmt || is_gimple_debug (use_stmt))
    4197                 :     1501599 :             continue;
    4198                 :             : 
    4199                 :             :           /* A clobber isn't a use.  */
    4200                 :     1748677 :           if (gimple_clobber_p (use_stmt))
    4201                 :       90767 :             continue;
    4202                 :             : 
    4203                 :     1657910 :           if (realloc_lhs)
    4204                 :             :             {
    4205                 :             :               /* Check to see if USE_STMT is a mismatched deallocation
    4206                 :             :                  call for the pointer passed to realloc.  That's a bug
    4207                 :             :                  regardless of the pointer's value and so warn.  */
    4208                 :       74469 :               if (maybe_warn_mismatched_realloc (*use_p->use, stmt, use_stmt))
    4209                 :         159 :                 continue;
    4210                 :             : 
    4211                 :             :               /* Pointers passed to realloc that are used in basic blocks
    4212                 :             :                  where the realloc call is known to have failed are valid.
    4213                 :             :                  Ignore pointers that nothing is known about.  Those could
    4214                 :             :                  have escaped along with their nullness.  */
    4215                 :       74430 :               prange vr;
    4216                 :       74430 :               if (m_ptr_qry.rvals->range_of_expr (vr, realloc_lhs, use_stmt))
    4217                 :             :                 {
    4218                 :       74430 :                   if (vr.zero_p ())
    4219                 :         120 :                     continue;
    4220                 :             : 
    4221                 :       74310 :                   if (!pointers_related_p (stmt, ptr, realloc_ptr, m_ptr_qry))
    4222                 :           0 :                     continue;
    4223                 :             :                 }
    4224                 :       74430 :             }
    4225                 :             : 
    4226                 :     1657992 :           if (check_dangling
    4227                 :     1657751 :               && gimple_code (use_stmt) == GIMPLE_RETURN)
    4228                 :             :             /* Avoid interfering with -Wreturn-local-addr (which runs only
    4229                 :             :                with optimization enabled so it won't diagnose cases that
    4230                 :             :                would be caught here when optimization is disabled).  */
    4231                 :         241 :             continue;
    4232                 :             : 
    4233                 :     1657510 :           bool equality = false;
    4234                 :     1657510 :           if (is_gimple_assign (use_stmt))
    4235                 :             :             {
    4236                 :      927403 :               tree_code code = gimple_assign_rhs_code (use_stmt);
    4237                 :      927403 :               equality = code == EQ_EXPR || code == NE_EXPR;
    4238                 :             :             }
    4239                 :      730107 :           else if (gcond *cond = dyn_cast<gcond *>(use_stmt))
    4240                 :             :             {
    4241                 :      298003 :               tree_code code = gimple_cond_code (cond);
    4242                 :      298003 :               equality = code == EQ_EXPR || code == NE_EXPR;
    4243                 :             :             }
    4244                 :      432104 :           else if (gphi *phi = dyn_cast <gphi *> (use_stmt))
    4245                 :             :             {
    4246                 :             :               /* Only add a PHI result to POINTERS if all its
    4247                 :             :                  operands are related to PTR, otherwise continue.  The
    4248                 :             :                  PHI result is related once we've reached all arguments
    4249                 :             :                  through this iteration.  That also means any invariant
    4250                 :             :                  argument will make the PHI not related.  For arguments
    4251                 :             :                  flowing over natural loop backedges we are optimistic
    4252                 :             :                  (and diagnose the first iteration).  */
    4253                 :      107613 :               tree lhs = gimple_phi_result (phi);
    4254                 :      107613 :               if (!phi_map)
    4255                 :       38203 :                 phi_map = new hash_map<tree, int>;
    4256                 :      107613 :               bool existed_p;
    4257                 :      107613 :               int &related = phi_map->get_or_insert (lhs, &existed_p);
    4258                 :      107613 :               if (!existed_p)
    4259                 :             :                 {
    4260                 :       52920 :                   related = gimple_phi_num_args (phi) - 1;
    4261                 :      263835 :                   for (unsigned j = 0; j < gimple_phi_num_args (phi); ++j)
    4262                 :             :                     {
    4263                 :      210915 :                       if ((unsigned) phi_arg_index_from_use (use_p) == j)
    4264                 :       52920 :                         continue;
    4265                 :      157995 :                       tree arg = gimple_phi_arg_def (phi, j);
    4266                 :      157995 :                       edge e = gimple_phi_arg_edge (phi, j);
    4267                 :      157995 :                       basic_block arg_bb;
    4268                 :      157995 :                       if (dominated_by_p (CDI_DOMINATORS, e->src, e->dest)
    4269                 :             :                           /* Make sure we are not forward visiting a
    4270                 :             :                              backedge argument.  */
    4271                 :      157995 :                           && (TREE_CODE (arg) != SSA_NAME
    4272                 :       15556 :                               || (!SSA_NAME_IS_DEFAULT_DEF (arg)
    4273                 :       15556 :                                   && ((arg_bb
    4274                 :       15556 :                                          = gimple_bb (SSA_NAME_DEF_STMT (arg)))
    4275                 :       15556 :                                       != e->dest)
    4276                 :       12671 :                                   && !dominated_by_p (CDI_DOMINATORS,
    4277                 :             :                                                       e->dest, arg_bb))))
    4278                 :       12671 :                         related--;
    4279                 :             :                     }
    4280                 :             :                 }
    4281                 :             :               else
    4282                 :       54693 :                 related--;
    4283                 :             : 
    4284                 :      107613 :               if (related == 0)
    4285                 :       20692 :                 pointers.safe_push (lhs);
    4286                 :      107613 :               continue;
    4287                 :      107613 :             }
    4288                 :             : 
    4289                 :             :           /* Warn if USE_STMT is dominated by the deallocation STMT.
    4290                 :             :              Otherwise, add the pointer to POINTERS so that the uses
    4291                 :             :              of any other pointers derived from it can be checked.  */
    4292                 :     1549897 :           if (use_after_inval_p (stmt, use_stmt, check_dangling))
    4293                 :             :             {
    4294                 :       18032 :               basic_block use_bb = gimple_bb (use_stmt);
    4295                 :       18032 :               bool this_maybe
    4296                 :             :                 = (maybe
    4297                 :       18032 :                    || !dominated_by_p (CDI_POST_DOMINATORS, stmt_bb, use_bb));
    4298                 :       18032 :               warn_invalid_pointer (*use_p->use, use_stmt, stmt, var,
    4299                 :             :                                     this_maybe, equality);
    4300                 :       18032 :               continue;
    4301                 :       18032 :             }
    4302                 :             : 
    4303                 :     1531865 :           if (is_gimple_assign (use_stmt))
    4304                 :             :             {
    4305                 :      925959 :               tree lhs = gimple_assign_lhs (use_stmt);
    4306                 :      925959 :               if (TREE_CODE (lhs) == SSA_NAME)
    4307                 :             :                 {
    4308                 :      608976 :                   tree_code rhs_code = gimple_assign_rhs_code (use_stmt);
    4309                 :      608976 :                   if (rhs_code == POINTER_PLUS_EXPR || rhs_code == SSA_NAME)
    4310                 :      147659 :                     pointers.safe_push (lhs);
    4311                 :             :                 }
    4312                 :      925959 :               continue;
    4313                 :      925959 :             }
    4314                 :             : 
    4315                 :     3856182 :           if (gcall *call = dyn_cast <gcall *>(use_stmt))
    4316                 :             :             {
    4317                 :      307547 :               if (gimple_call_return_arg (call) == ptr)
    4318                 :       36050 :                 if (tree lhs = gimple_call_lhs (call))
    4319                 :        1198 :                   if (TREE_CODE (lhs) == SSA_NAME)
    4320                 :        1198 :                     pointers.safe_push (lhs);
    4321                 :      307547 :               continue;
    4322                 :      307547 :             }
    4323                 :             :         }
    4324                 :             :     }
    4325                 :             : 
    4326                 :      655538 :   if (phi_map)
    4327                 :       38203 :     delete phi_map;
    4328                 :      655538 : }
    4329                 :             : 
    4330                 :             : /* Check call STMT for invalid accesses.  */
    4331                 :             : 
    4332                 :             : void
    4333                 :    21450648 : pass_waccess::check_call (gcall *stmt)
    4334                 :             : {
    4335                 :             :   /* Skip special calls generated by the compiler.  */
    4336                 :    21450648 :   if (gimple_call_from_thunk_p (stmt))
    4337                 :             :     return;
    4338                 :             : 
    4339                 :             :   /* .ASAN_MARK doesn't access any vars, only modifies shadow memory.  */
    4340                 :    21445867 :   if (gimple_call_internal_p (stmt)
    4341                 :    21445867 :       && gimple_call_internal_fn (stmt) == IFN_ASAN_MARK)
    4342                 :             :     return;
    4343                 :             : 
    4344                 :    21436186 :   if (gimple_call_builtin_p (stmt, BUILT_IN_NORMAL))
    4345                 :     4747184 :     check_builtin (stmt);
    4346                 :             : 
    4347                 :    21436186 :   if (tree callee = gimple_call_fndecl (stmt))
    4348                 :             :     {
    4349                 :             :       /* Check for uses of the pointer passed to either a standard
    4350                 :             :          or a user-defined deallocation function.  */
    4351                 :    20318495 :       unsigned argno = fndecl_dealloc_argno (callee);
    4352                 :    20318495 :       if (argno < (unsigned) call_nargs (stmt))
    4353                 :             :         {
    4354                 :      446183 :           tree arg = call_arg (stmt, argno);
    4355                 :      446183 :           if (TREE_CODE (arg) == SSA_NAME)
    4356                 :      445707 :             check_pointer_uses (stmt, arg);
    4357                 :             :         }
    4358                 :             :     }
    4359                 :             : 
    4360                 :    21436186 :   check_call_access (stmt);
    4361                 :    21436186 :   check_call_dangling (stmt);
    4362                 :             : 
    4363                 :    21436186 :   if (m_early_checks_p)
    4364                 :             :     return;
    4365                 :             : 
    4366                 :     6579184 :   maybe_check_dealloc_call (stmt);
    4367                 :     6579184 :   check_nonstring_args (stmt);
    4368                 :             : }
    4369                 :             : 
    4370                 :             : /* Check non-call STMT for invalid accesses.  */
    4371                 :             : 
    4372                 :             : void
    4373                 :   124150075 : pass_waccess::check_stmt (gimple *stmt)
    4374                 :             : {
    4375                 :   124150075 :   if (m_check_dangling_p
    4376                 :   124150075 :       && gimple_clobber_p (stmt, CLOBBER_STORAGE_END))
    4377                 :             :     {
    4378                 :             :       /* Ignore clobber statements in blocks with exceptional edges.  */
    4379                 :     3032655 :       basic_block bb = gimple_bb (stmt);
    4380                 :     3032655 :       edge e = EDGE_PRED (bb, 0);
    4381                 :     3032655 :       if (e->flags & EDGE_EH)
    4382                 :             :         return;
    4383                 :             : 
    4384                 :     2371496 :       tree var = gimple_assign_lhs (stmt);
    4385                 :     2371496 :       m_clobbers.put (var, stmt);
    4386                 :     2371496 :       return;
    4387                 :             :     }
    4388                 :             : 
    4389                 :   121117420 :   if (is_gimple_assign (stmt))
    4390                 :             :     {
    4391                 :             :       /* Clobbered unnamed temporaries such as compound literals can be
    4392                 :             :          revived.  Check for an assignment to one and remove it from
    4393                 :             :          M_CLOBBERS.  */
    4394                 :    90549553 :       tree lhs = gimple_assign_lhs (stmt);
    4395                 :   113251383 :       while (handled_component_p (lhs))
    4396                 :    22701830 :         lhs = TREE_OPERAND (lhs, 0);
    4397                 :             : 
    4398                 :    90549553 :       if (auto_var_p (lhs))
    4399                 :    14819031 :         m_clobbers.remove (lhs);
    4400                 :    90549553 :       return;
    4401                 :             :     }
    4402                 :             : 
    4403                 :    30567867 :   if (greturn *ret = dyn_cast <greturn *> (stmt))
    4404                 :             :     {
    4405                 :     5012755 :       if (optimize && flag_isolate_erroneous_paths_dereference)
    4406                 :             :         /* Avoid interfering with -Wreturn-local-addr (which runs only
    4407                 :             :            with optimization enabled).  */
    4408                 :     5012754 :         return;
    4409                 :             : 
    4410                 :     1045689 :       tree arg = gimple_return_retval (ret);
    4411                 :     1045689 :       if (!arg || TREE_CODE (arg) != ADDR_EXPR)
    4412                 :             :         return;
    4413                 :             : 
    4414                 :         311 :       arg = TREE_OPERAND (arg, 0);
    4415                 :         419 :       while (handled_component_p (arg))
    4416                 :         108 :         arg = TREE_OPERAND (arg, 0);
    4417                 :             : 
    4418                 :         311 :       if (!auto_var_p (arg))
    4419                 :             :         return;
    4420                 :             : 
    4421                 :           3 :       gimple **pclobber = m_clobbers.get (arg);
    4422                 :           3 :       if (!pclobber)
    4423                 :             :         return;
    4424                 :             : 
    4425                 :           1 :       if (!use_after_inval_p (*pclobber, stmt))
    4426                 :             :         return;
    4427                 :             : 
    4428                 :           1 :       warn_invalid_pointer (NULL_TREE, stmt, *pclobber, arg, false);
    4429                 :             :     }
    4430                 :             : }
    4431                 :             : 
    4432                 :             : /* Check basic block BB for invalid accesses.  */
    4433                 :             : 
    4434                 :             : void
    4435                 :    41056405 : pass_waccess::check_block (basic_block bb)
    4436                 :             : {
    4437                 :             :   /* Iterate over statements, looking for function calls.  */
    4438                 :   227713533 :   for (auto si = gsi_start_bb (bb); !gsi_end_p (si);
    4439                 :   145600723 :        gsi_next_nondebug (&si))
    4440                 :             :     {
    4441                 :   145600723 :       gimple *stmt = gsi_stmt (si);
    4442                 :   145600723 :       if (gcall *call = dyn_cast <gcall *> (stmt))
    4443                 :    21450648 :         check_call (call);
    4444                 :             :       else
    4445                 :   124150075 :         check_stmt (stmt);
    4446                 :             :     }
    4447                 :    41056405 : }
    4448                 :             : 
    4449                 :             : /* Return the argument that the call STMT to a built-in function returns
    4450                 :             :    (including with an offset) or null if it doesn't.  */
    4451                 :             : 
    4452                 :             : tree
    4453                 :     2100232 : pass_waccess::gimple_call_return_arg (gcall *call)
    4454                 :             : {
    4455                 :             :   /* Check for attribute fn spec to see if the function returns one
    4456                 :             :      of its arguments.  */
    4457                 :     2100232 :   attr_fnspec fnspec = gimple_call_fnspec (call);
    4458                 :     2100232 :   unsigned int argno;
    4459                 :     2100232 :   if (!fnspec.returns_arg (&argno))
    4460                 :             :     {
    4461                 :     2035320 :       if (gimple_call_num_args (call) < 1)
    4462                 :             :         return NULL_TREE;
    4463                 :             : 
    4464                 :     1961907 :       if (!gimple_call_builtin_p (call, BUILT_IN_NORMAL))
    4465                 :             :         return NULL_TREE;
    4466                 :             : 
    4467                 :      260963 :       tree fndecl = gimple_call_fndecl (call);
    4468                 :      260963 :       switch (DECL_FUNCTION_CODE (fndecl))
    4469                 :             :         {
    4470                 :             :         case BUILT_IN_MEMPCPY:
    4471                 :             :         case BUILT_IN_MEMPCPY_CHK:
    4472                 :             :         case BUILT_IN_MEMCHR:
    4473                 :             :         case BUILT_IN_STRCHR:
    4474                 :             :         case BUILT_IN_STRRCHR:
    4475                 :             :         case BUILT_IN_STRSTR:
    4476                 :             :         case BUILT_IN_STPCPY:
    4477                 :             :         case BUILT_IN_STPCPY_CHK:
    4478                 :             :         case BUILT_IN_STPNCPY:
    4479                 :             :         case BUILT_IN_STPNCPY_CHK:
    4480                 :             :           argno = 0;
    4481                 :             :           break;
    4482                 :             : 
    4483                 :             :         default:
    4484                 :             :           return NULL_TREE;
    4485                 :             :         }
    4486                 :             :     }
    4487                 :             : 
    4488                 :       77243 :   if (gimple_call_num_args (call) <= argno)
    4489                 :             :     return NULL_TREE;
    4490                 :             : 
    4491                 :       77243 :   return gimple_call_arg (call, argno);
    4492                 :             : }
    4493                 :             : 
    4494                 :             : /* Check for and diagnose all uses of the dangling pointer VAR to the auto
    4495                 :             :    object DECL whose lifetime has ended.  OBJREF is true when VAR denotes
    4496                 :             :    an access to a DECL that may have been clobbered.  */
    4497                 :             : 
    4498                 :             : void
    4499                 :    13862334 : pass_waccess::check_dangling_uses (tree var, tree decl, bool maybe /* = false */,
    4500                 :             :                                    bool objref /* = false */)
    4501                 :             : {
    4502                 :    13862334 :   if (!decl || !auto_var_p (decl))
    4503                 :     6201049 :     return;
    4504                 :             : 
    4505                 :     7661285 :   gimple **pclob = m_clobbers.get (decl);
    4506                 :     7661285 :   if (!pclob)
    4507                 :             :     return;
    4508                 :             : 
    4509                 :     3226217 :   if (!objref)
    4510                 :             :     {
    4511                 :      151866 :       check_pointer_uses (*pclob, var, decl, maybe);
    4512                 :      151866 :       return;
    4513                 :             :     }
    4514                 :             : 
    4515                 :     3074351 :   gimple *use_stmt = SSA_NAME_DEF_STMT (var);
    4516                 :     3074351 :   if (!use_after_inval_p (*pclob, use_stmt, true))
    4517                 :             :     return;
    4518                 :             : 
    4519                 :           0 :   basic_block use_bb = gimple_bb (use_stmt);
    4520                 :           0 :   basic_block clob_bb = gimple_bb (*pclob);
    4521                 :           0 :   maybe = maybe || !dominated_by_p (CDI_POST_DOMINATORS, clob_bb, use_bb);
    4522                 :           0 :   warn_invalid_pointer (var, use_stmt, *pclob, decl, maybe, false);
    4523                 :             : }
    4524                 :             : 
    4525                 :             : /* Diagnose stores in BB and (recursively) its predecessors of the addresses
    4526                 :             :    of local variables into nonlocal pointers that are left dangling after
    4527                 :             :    the function returns.  Returns true when we can continue walking
    4528                 :             :    the CFG to predecessors.  */
    4529                 :             : 
    4530                 :             : bool
    4531                 :    14562401 : pass_waccess::check_dangling_stores (basic_block bb,
    4532                 :             :                                      hash_set<tree> &stores)
    4533                 :             : {
    4534                 :             :   /* Iterate backwards over the statements looking for a store of
    4535                 :             :      the address of a local variable into a nonlocal pointer.  */
    4536                 :    48890021 :   for (auto gsi = gsi_last_nondebug_bb (bb); ; gsi_prev_nondebug (&gsi))
    4537                 :             :     {
    4538                 :    48890021 :       gimple *stmt = gsi_stmt (gsi);
    4539                 :    48890021 :       if (!stmt)
    4540                 :             :         break;
    4541                 :             : 
    4542                 :    37925928 :       if (warning_suppressed_p (stmt, OPT_Wdangling_pointer_))
    4543                 :    34327053 :         continue;
    4544                 :             : 
    4545                 :    37888715 :       if (is_gimple_call (stmt)
    4546                 :    37888715 :           && !(gimple_call_flags (stmt) & (ECF_CONST | ECF_PURE)))
    4547                 :             :         /* Avoid looking before nonconst, nonpure calls since those might
    4548                 :             :            use the escaped locals.  */
    4549                 :     3598308 :         return false;
    4550                 :             : 
    4551                 :    34433100 :       if (!is_gimple_assign (stmt) || gimple_clobber_p (stmt)
    4552                 :    56962903 :           || !gimple_store_p (stmt))
    4553                 :    29523990 :         continue;
    4554                 :             : 
    4555                 :     4909110 :       access_ref lhs_ref;
    4556                 :     4909110 :       tree lhs = gimple_assign_lhs (stmt);
    4557                 :     4909110 :       if (!m_ptr_qry.get_ref (lhs, stmt, &lhs_ref, 0))
    4558                 :        9252 :         continue;
    4559                 :             : 
    4560                 :     4899858 :       if (TREE_CODE (lhs_ref.ref) == MEM_REF)
    4561                 :             :         {
    4562                 :       17434 :           lhs_ref.ref = TREE_OPERAND (lhs_ref.ref, 0);
    4563                 :       17434 :           ++lhs_ref.deref;
    4564                 :             :         }
    4565                 :     4899858 :       if (TREE_CODE (lhs_ref.ref) == ADDR_EXPR)
    4566                 :             :         {
    4567                 :        5670 :           lhs_ref.ref = TREE_OPERAND (lhs_ref.ref, 0);
    4568                 :        5670 :           --lhs_ref.deref;
    4569                 :             :         }
    4570                 :     4899858 :       if (TREE_CODE (lhs_ref.ref) == SSA_NAME)
    4571                 :             :         {
    4572                 :     1004090 :           gimple *def_stmt = SSA_NAME_DEF_STMT (lhs_ref.ref);
    4573                 :     1004090 :           if (!gimple_nop_p (def_stmt))
    4574                 :             :             /* Avoid looking at or before stores into unknown objects.  */
    4575                 :             :             return false;
    4576                 :             : 
    4577                 :      861397 :           lhs_ref.ref = SSA_NAME_VAR (lhs_ref.ref);
    4578                 :             :         }
    4579                 :             : 
    4580                 :     4757165 :       if (TREE_CODE (lhs_ref.ref) == PARM_DECL
    4581                 :     4757165 :           && (lhs_ref.deref - DECL_BY_REFERENCE (lhs_ref.ref)) > 0)
    4582                 :             :         /* Assignment through a (real) pointer/reference parameter.  */;
    4583                 :     6869059 :       else if (VAR_P (lhs_ref.ref)
    4584                 :     3943344 :                && !auto_var_p (lhs_ref.ref))
    4585                 :             :         /* Assignment to/through a non-local variable.  */;
    4586                 :             :       else
    4587                 :             :         /* Something else, don't warn.  */
    4588                 :     2925715 :         continue;
    4589                 :             : 
    4590                 :     1831450 :       if (stores.add (lhs_ref.ref))
    4591                 :     1260974 :         continue;
    4592                 :             : 
    4593                 :             :       /* FIXME: Handle stores of alloca() and VLA.  */
    4594                 :      570476 :       access_ref rhs_ref;
    4595                 :      570476 :       tree rhs = gimple_assign_rhs1 (stmt);
    4596                 :      570476 :       if (!m_ptr_qry.get_ref (rhs, stmt, &rhs_ref, 0)
    4597                 :      570476 :           || rhs_ref.deref != -1)
    4598                 :      544407 :         continue;
    4599                 :             : 
    4600                 :       26069 :       if (!auto_var_p (rhs_ref.ref))
    4601                 :       25502 :         continue;
    4602                 :             : 
    4603                 :         567 :       auto_diagnostic_group d;
    4604                 :         567 :       location_t loc = gimple_location (stmt);
    4605                 :         567 :       if (warning_at (loc, OPT_Wdangling_pointer_,
    4606                 :             :                       "storing the address of local variable %qD in %qE",
    4607                 :             :                       rhs_ref.ref, lhs))
    4608                 :             :         {
    4609                 :          45 :           suppress_warning (stmt, OPT_Wdangling_pointer_);
    4610                 :             : 
    4611                 :          45 :           location_t loc = DECL_SOURCE_LOCATION (rhs_ref.ref);
    4612                 :          45 :           inform (loc, "%qD declared here", rhs_ref.ref);
    4613                 :             : 
    4614                 :          45 :           loc = DECL_SOURCE_LOCATION (lhs_ref.ref);
    4615                 :          45 :           inform (loc, "%qD declared here", lhs_ref.ref);
    4616                 :             :         }
    4617                 :    34328187 :     }
    4618                 :             : 
    4619                 :    10964093 :   return true;
    4620                 :             : }
    4621                 :             : 
    4622                 :             : /* Diagnose stores of the addresses of local variables into nonlocal
    4623                 :             :    pointers that are left dangling after the function returns.  */
    4624                 :             : 
    4625                 :             : void
    4626                 :     3683809 : pass_waccess::check_dangling_stores ()
    4627                 :             : {
    4628                 :     3683809 :   if (EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (m_func)->preds) == 0)
    4629                 :       55596 :     return;
    4630                 :             : 
    4631                 :     3628213 :   auto_bitmap bbs;
    4632                 :     3628213 :   hash_set<tree> stores;
    4633                 :     3628213 :   auto_vec<edge_iterator, 8> worklist (n_basic_blocks_for_fn (cfun) + 1);
    4634                 :     3628213 :   worklist.quick_push (ei_start (EXIT_BLOCK_PTR_FOR_FN (m_func)->preds));
    4635                 :    31653001 :   do
    4636                 :             :     {
    4637                 :    31653001 :       edge_iterator ei = worklist.last ();
    4638                 :    31653001 :       basic_block src = ei_edge (ei)->src;
    4639                 :    31653001 :       if (bitmap_set_bit (bbs, src->index))
    4640                 :             :         {
    4641                 :    14562401 :           if (check_dangling_stores (src, stores)
    4642                 :    14562401 :               && EDGE_COUNT (src->preds) > 0)
    4643                 :     9481433 :             worklist.quick_push (ei_start (src->preds));
    4644                 :             :         }
    4645                 :             :       else
    4646                 :             :         {
    4647                 :    17090600 :           if (ei_one_before_end_p (ei))
    4648                 :    13109646 :             worklist.pop ();
    4649                 :             :           else
    4650                 :     3980954 :             ei_next (&worklist.last ());
    4651                 :             :         }
    4652                 :             :     }
    4653                 :    63306002 :   while (!worklist.is_empty ());
    4654                 :     3628213 : }
    4655                 :             : 
    4656                 :             : /* Check for and diagnose uses of dangling pointers to auto objects
    4657                 :             :    whose lifetime has ended.  */
    4658                 :             : 
    4659                 :             : void
    4660                 :     3683809 : pass_waccess::check_dangling_uses ()
    4661                 :             : {
    4662                 :     3683809 :   tree var;
    4663                 :     3683809 :   unsigned i;
    4664                 :   107035015 :   FOR_EACH_SSA_NAME (i, var, m_func)
    4665                 :             :     {
    4666                 :             :       /* For each SSA_NAME pointer VAR find the object it points to.
    4667                 :             :          If the object is a clobbered local variable, check to see
    4668                 :             :          if any of VAR's uses (or those of other pointers derived
    4669                 :             :          from VAR) happens after the clobber.  If so, warn.  */
    4670                 :             : 
    4671                 :    99409463 :       gimple *def_stmt = SSA_NAME_DEF_STMT (var);
    4672                 :    99409463 :       if (is_gimple_assign (def_stmt))
    4673                 :             :         {
    4674                 :    63537930 :           tree rhs = gimple_assign_rhs1 (def_stmt);
    4675                 :    63537930 :           if (TREE_CODE (rhs) == ADDR_EXPR)
    4676                 :             :             {
    4677                 :     4302773 :               if (!POINTER_TYPE_P (TREE_TYPE (var)))
    4678                 :     1919616 :                 continue;
    4679                 :     2383157 :               check_dangling_uses (var, TREE_OPERAND (rhs, 0));
    4680                 :             :             }
    4681                 :             :           else
    4682                 :             :             {
    4683                 :             :               /* For other expressions, check the base DECL to see
    4684                 :             :                  if it's been clobbered, most likely as a result of
    4685                 :             :                  inlining a reference to it.  */
    4686                 :    59235157 :               tree decl = get_base_address (rhs);
    4687                 :    59235157 :               if (DECL_P (decl))
    4688                 :    11269295 :                 check_dangling_uses (var, decl, false, true);
    4689                 :             :             }
    4690                 :             :         }
    4691                 :    35871533 :       else if (POINTER_TYPE_P (TREE_TYPE (var)))
    4692                 :             :         {
    4693                 :     5876837 :           if (gcall *call = dyn_cast<gcall *>(def_stmt))
    4694                 :             :             {
    4695                 :     1792685 :               if (tree arg = gimple_call_return_arg (call))
    4696                 :             :                 {
    4697                 :       26336 :                   access_ref aref;
    4698                 :       26336 :                   if (m_ptr_qry.get_ref (arg, call, &aref, 0)
    4699                 :       26336 :                       && aref.deref < 0)
    4700                 :        8505 :                     check_dangling_uses (var, aref.ref);
    4701                 :             :                 }
    4702                 :             :             }
    4703                 :   103906986 :           else if (gphi *phi = dyn_cast <gphi *>(def_stmt))
    4704                 :             :             {
    4705                 :      555780 :               unsigned nargs = gimple_phi_num_args (phi);
    4706                 :     1905151 :               for (unsigned i = 0; i != nargs; ++i)
    4707                 :             :                 {
    4708                 :     1349371 :                   access_ref aref;
    4709                 :     1349371 :                   tree arg = gimple_phi_arg_def (phi, i);
    4710                 :     1349371 :                   if (m_ptr_qry.get_ref (arg, phi, &aref, 0)
    4711                 :     1349371 :                       && aref.deref < 0)
    4712                 :      201377 :                     check_dangling_uses (var, aref.ref, true);
    4713                 :             :                 }
    4714                 :             :             }
    4715                 :             :         }
    4716                 :             :     }
    4717                 :     3683809 : }
    4718                 :             : 
    4719                 :             : /* Check CALL arguments for dangling pointers (those that have been
    4720                 :             :    clobbered) and warn if found.  */
    4721                 :             : 
    4722                 :             : void
    4723                 :    21436186 : pass_waccess::check_call_dangling (gcall *call)
    4724                 :             : {
    4725                 :    21436186 :   unsigned nargs = gimple_call_num_args (call);
    4726                 :    63462549 :   for (unsigned i = 0; i != nargs; ++i)
    4727                 :             :     {
    4728                 :    42026363 :       tree arg = gimple_call_arg (call, i);
    4729                 :    42026363 :       if (TREE_CODE (arg) != ADDR_EXPR)
    4730                 :    42026336 :         continue;
    4731                 :             : 
    4732                 :    11828110 :       arg = TREE_OPERAND (arg, 0);
    4733                 :    11828110 :       if (!DECL_P (arg))
    4734                 :     3886159 :         continue;
    4735                 :             : 
    4736                 :     7941951 :       gimple **pclobber = m_clobbers.get (arg);
    4737                 :     7941951 :       if (!pclobber)
    4738                 :     7754542 :         continue;
    4739                 :             : 
    4740                 :      187409 :       if (!use_after_inval_p (*pclobber, call))
    4741                 :      187382 :         continue;
    4742                 :             : 
    4743                 :          27 :       warn_invalid_pointer (NULL_TREE, call, *pclobber, arg, false);
    4744                 :             :     }
    4745                 :    21436186 : }
    4746                 :             : 
    4747                 :             : /* Check function FUN for invalid accesses.  */
    4748                 :             : 
    4749                 :             : unsigned
    4750                 :     5096214 : pass_waccess::execute (function *fun)
    4751                 :             : {
    4752                 :     5096214 :   calculate_dominance_info (CDI_DOMINATORS);
    4753                 :     5096214 :   calculate_dominance_info (CDI_POST_DOMINATORS);
    4754                 :             : 
    4755                 :             :   /* Set or clear EDGE_DFS_BACK bits on back edges.  */
    4756                 :     5096214 :   mark_dfs_back_edges (fun);
    4757                 :             : 
    4758                 :             :   /* Create a new ranger instance and associate it with FUN.  */
    4759                 :     5096214 :   m_ptr_qry.rvals = enable_ranger (fun);
    4760                 :     5096214 :   m_func = fun;
    4761                 :             : 
    4762                 :             :   /* Check for dangling pointers in the earliest run of the pass.
    4763                 :             :      The latest point -Wdangling-pointer should run is just before
    4764                 :             :      loop unrolling which introduces uses after clobbers.  Most cases
    4765                 :             :      can be detected without optimization; cases where the address of
    4766                 :             :      the local variable is passed to and then returned from a user-
    4767                 :             :      defined function before its lifetime ends and the returned pointer
    4768                 :             :      becomes dangling depend on inlining.  */
    4769                 :     5096214 :   m_check_dangling_p = m_early_checks_p;
    4770                 :             : 
    4771                 :     5096214 :   auto_bitmap bb_uids_set (&bitmap_default_obstack);
    4772                 :     5096214 :   m_bb_uids_set = bb_uids_set;
    4773                 :             : 
    4774                 :     5096214 :   set_gimple_stmt_max_uid (m_func, 0);
    4775                 :             : 
    4776                 :     5096214 :   basic_block bb;
    4777                 :    46152619 :   FOR_EACH_BB_FN (bb, fun)
    4778                 :    41056405 :     check_block (bb);
    4779                 :             : 
    4780                 :     5096214 :   if (m_check_dangling_p)
    4781                 :             :     {
    4782                 :     3683809 :       check_dangling_uses ();
    4783                 :     3683809 :       check_dangling_stores ();
    4784                 :             :     }
    4785                 :             : 
    4786                 :     5096214 :   if (dump_file)
    4787                 :         149 :     m_ptr_qry.dump (dump_file, (dump_flags & TDF_DETAILS) != 0);
    4788                 :             : 
    4789                 :     5096214 :   m_ptr_qry.flush_cache ();
    4790                 :             : 
    4791                 :             :   /* Release the ranger instance and replace it with a global ranger.
    4792                 :             :      Also reset the pointer since calling disable_ranger() deletes it.  */
    4793                 :     5096214 :   disable_ranger (fun);
    4794                 :     5096214 :   m_ptr_qry.rvals = NULL;
    4795                 :             : 
    4796                 :     5096214 :   m_clobbers.empty ();
    4797                 :     5096214 :   m_bb_uids_set = NULL;
    4798                 :             : 
    4799                 :     5096214 :   free_dominance_info (CDI_POST_DOMINATORS);
    4800                 :     5096214 :   free_dominance_info (CDI_DOMINATORS);
    4801                 :     5096214 :   return 0;
    4802                 :     5096214 : }
    4803                 :             : 
    4804                 :             : }   // namespace
    4805                 :             : 
    4806                 :             : /* Return a new instance of the pass.  */
    4807                 :             : 
    4808                 :             : gimple_opt_pass *
    4809                 :      271146 : make_pass_warn_access (gcc::context *ctxt)
    4810                 :             : {
    4811                 :      271146 :   return new pass_waccess (ctxt);
    4812                 :             : }
        

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.