LCOV - code coverage report
Current view: top level - gcc/c-family - c-format.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 1756 1881 93.4 %
Date: 2020-03-28 11:57:23 Functions: 66 68 97.1 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Check calls to formatted I/O functions (-Wformat).
       2                 :            :    Copyright (C) 1992-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            : This file is part of GCC.
       5                 :            : 
       6                 :            : GCC is free software; you can redistribute it and/or modify it under
       7                 :            : the terms of the GNU General Public License as published by the Free
       8                 :            : Software Foundation; either version 3, or (at your option) any later
       9                 :            : version.
      10                 :            : 
      11                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      12                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14                 :            : for more details.
      15                 :            : 
      16                 :            : You should have received a copy of the GNU General Public License
      17                 :            : along with GCC; see the file COPYING3.  If not see
      18                 :            : <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : #include "config.h"
      21                 :            : #include "system.h"
      22                 :            : #include "coretypes.h"
      23                 :            : #include "tm.h"
      24                 :            : #include "c-target.h"
      25                 :            : #include "c-common.h"
      26                 :            : #include "alloc-pool.h"
      27                 :            : #include "stringpool.h"
      28                 :            : #include "c-objc.h"
      29                 :            : #include "intl.h"
      30                 :            : #include "langhooks.h"
      31                 :            : #include "c-format.h"
      32                 :            : #include "diagnostic.h"
      33                 :            : #include "substring-locations.h"
      34                 :            : #include "selftest.h"
      35                 :            : #include "selftest-diagnostic.h"
      36                 :            : #include "builtins.h"
      37                 :            : #include "attribs.h"
      38                 :            : #include "gcc-rich-location.h"
      39                 :            : 
      40                 :            : /* Handle attributes associated with format checking.  */
      41                 :            : 
      42                 :            : /* This must be in the same order as format_types, except for
      43                 :            :    format_type_error.  Target-specific format types do not have
      44                 :            :    matching enum values.  */
      45                 :            : enum format_type { printf_format_type, asm_fprintf_format_type,
      46                 :            :                    gcc_diag_format_type, gcc_tdiag_format_type,
      47                 :            :                    gcc_cdiag_format_type,
      48                 :            :                    gcc_cxxdiag_format_type, gcc_gfc_format_type,
      49                 :            :                    gcc_dump_printf_format_type,
      50                 :            :                    gcc_objc_string_format_type,
      51                 :            :                    format_type_error = -1};
      52                 :            : 
      53                 :            : struct function_format_info
      54                 :            : {
      55                 :            :   enum format_type format_type;         /* type of format (printf, scanf, etc.) */
      56                 :            :   /* IS_RAW is relevant only for GCC diagnostic format functions.
      57                 :            :      It is set for "raw" formatting functions like pp_printf that
      58                 :            :      are not intended to produce complete diagnostics according to
      59                 :            :      GCC guidelines, and clear for others like error and warning
      60                 :            :      whose format string is checked for proper quoting and spelling.  */
      61                 :            :   bool is_raw;
      62                 :            :   unsigned HOST_WIDE_INT format_num;    /* number of format argument */
      63                 :            :   unsigned HOST_WIDE_INT first_arg_num; /* number of first arg (zero for varargs) */
      64                 :            : };
      65                 :            : 
      66                 :            : /* Initialized in init_dynamic_diag_info.  */
      67                 :            : static GTY(()) tree local_tree_type_node;
      68                 :            : static GTY(()) tree local_event_ptr_node;
      69                 :            : static GTY(()) tree local_gimple_ptr_node;
      70                 :            : static GTY(()) tree local_cgraph_node_ptr_node;
      71                 :            : static GTY(()) tree locus;
      72                 :            : 
      73                 :            : static bool decode_format_attr (const_tree, tree, tree, function_format_info *,
      74                 :            :                                 bool);
      75                 :            : static format_type decode_format_type (const char *, bool * = NULL);
      76                 :            : 
      77                 :            : static bool check_format_string (const_tree argument,
      78                 :            :                                  unsigned HOST_WIDE_INT format_num,
      79                 :            :                                  int flags, bool *no_add_attrs,
      80                 :            :                                  int expected_format_type);
      81                 :            : static tree get_constant (const_tree fntype, const_tree atname, tree expr,
      82                 :            :                           int argno, unsigned HOST_WIDE_INT *value,
      83                 :            :                           int flags, bool validated_p);
      84                 :            : static const char *convert_format_name_to_system_name (const char *attr_name);
      85                 :            : 
      86                 :            : static int first_target_format_type;
      87                 :            : static const char *format_name (int format_num);
      88                 :            : static int format_flags (int format_num);
      89                 :            : 
      90                 :            : /* Emit a warning as per format_warning_va, but construct the substring_loc
      91                 :            :    for the character at offset (CHAR_IDX - 1) within a string constant
      92                 :            :    FORMAT_STRING_CST at FMT_STRING_LOC.  */
      93                 :            : 
      94                 :            : ATTRIBUTE_GCC_DIAG (5,6)
      95                 :            : static bool
      96                 :       2109 : format_warning_at_char (location_t fmt_string_loc, tree format_string_cst,
      97                 :            :                         int char_idx, int opt, const char *gmsgid, ...)
      98                 :            : {
      99                 :       2109 :   va_list ap;
     100                 :       2109 :   va_start (ap, gmsgid);
     101                 :       2109 :   tree string_type = TREE_TYPE (format_string_cst);
     102                 :            : 
     103                 :            :   /* The callers are of the form:
     104                 :            :        format_warning (format_string_loc, format_string_cst,
     105                 :            :                        format_chars - orig_format_chars,
     106                 :            :       where format_chars has already been incremented, so that
     107                 :            :       CHAR_IDX is one character beyond where the warning should
     108                 :            :       be emitted.  Fix it.  */
     109                 :       2109 :   char_idx -= 1;
     110                 :            : 
     111                 :       2109 :   substring_loc fmt_loc (fmt_string_loc, string_type, char_idx, char_idx,
     112                 :       2109 :                          char_idx);
     113                 :       2109 :   format_string_diagnostic_t diag (fmt_loc, NULL, UNKNOWN_LOCATION, NULL,
     114                 :       2109 :                                    NULL);
     115                 :       2109 :   bool warned = diag.emit_warning_va (opt, gmsgid, &ap);
     116                 :       2109 :   va_end (ap);
     117                 :            : 
     118                 :       2109 :   return warned;
     119                 :            : }
     120                 :            : 
     121                 :            : 
     122                 :            : /* Emit a warning as per format_warning_va, but construct the substring_loc
     123                 :            :    for the substring at offset (POS1, POS2 - 1) within a string constant
     124                 :            :    FORMAT_STRING_CST at FMT_STRING_LOC.  */
     125                 :            : 
     126                 :            : ATTRIBUTE_GCC_DIAG (6,7)
     127                 :            : static bool
     128                 :        334 : format_warning_substr (location_t fmt_string_loc, tree format_string_cst,
     129                 :            :                        int pos1, int pos2, int opt, const char *gmsgid, ...)
     130                 :            : {
     131                 :        334 :   va_list ap;
     132                 :        334 :   va_start (ap, gmsgid);
     133                 :        334 :   tree string_type = TREE_TYPE (format_string_cst);
     134                 :            : 
     135                 :        334 :   pos2 -= 1;
     136                 :            : 
     137                 :        334 :   substring_loc fmt_loc (fmt_string_loc, string_type, pos1, pos1, pos2);
     138                 :        334 :   format_string_diagnostic_t diag (fmt_loc, NULL, UNKNOWN_LOCATION, NULL,
     139                 :        334 :                                    NULL);
     140                 :        334 :   bool warned = diag.emit_warning_va (opt, gmsgid, &ap);
     141                 :        334 :   va_end (ap);
     142                 :            : 
     143                 :        334 :   return warned;
     144                 :            : }
     145                 :            : 
     146                 :            : 
     147                 :            : /* Check that we have a pointer to a string suitable for use as a format.
     148                 :            :    The default is to check for a char type.
     149                 :            :    For objective-c dialects, this is extended to include references to string
     150                 :            :    objects validated by objc_string_ref_type_p ().  
     151                 :            :    Targets may also provide a string object type that can be used within c and 
     152                 :            :    c++ and shared with their respective objective-c dialects. In this case the
     153                 :            :    reference to a format string is checked for validity via a hook.
     154                 :            :    
     155                 :            :    The function returns true if strref points to any string type valid for the 
     156                 :            :    language dialect and target.  */
     157                 :            : 
     158                 :            : bool
     159                 :   18090900 : valid_format_string_type_p (tree strref)
     160                 :            : {
     161                 :   18090900 :   return (strref != NULL
     162                 :   18090900 :           && TREE_CODE (strref) == POINTER_TYPE
     163                 :   36181800 :           && (TYPE_MAIN_VARIANT (TREE_TYPE (strref)) == char_type_node
     164                 :         18 :               || objc_string_ref_type_p (strref)
     165                 :         18 :               || (*targetcm.string_object_ref_type_p) ((const_tree) strref)));
     166                 :            : }
     167                 :            : 
     168                 :            : /* Handle a "format_arg" attribute; arguments as in
     169                 :            :    struct attribute_spec.handler.  */
     170                 :            : tree
     171                 :     818721 : handle_format_arg_attribute (tree *node, tree atname,
     172                 :            :                              tree args, int flags, bool *no_add_attrs)
     173                 :            : {
     174                 :     818721 :   tree type = *node;
     175                 :            :   /* Note that TREE_VALUE (args) is changed in place below.  */
     176                 :     818721 :   tree *format_num_expr = &TREE_VALUE (args);
     177                 :     818721 :   unsigned HOST_WIDE_INT format_num = 0;
     178                 :            : 
     179                 :     818721 :   if (tree val = get_constant (type, atname, *format_num_expr, 0, &format_num,
     180                 :            :                                0, false))
     181                 :     818713 :     *format_num_expr = val;
     182                 :            :   else
     183                 :            :     {
     184                 :          8 :       *no_add_attrs = true;
     185                 :          8 :       return NULL_TREE;
     186                 :            :     }
     187                 :            : 
     188                 :     818713 :   if (prototype_p (type))
     189                 :            :     {
     190                 :            :       /* The format arg can be any string reference valid for the language and
     191                 :            :         target.  We cannot be more specific in this case.  */
     192                 :     818713 :       if (!check_format_string (type, format_num, flags, no_add_attrs, -1))
     193                 :            :         return NULL_TREE;
     194                 :            :     }
     195                 :            : 
     196                 :     818713 :   if (!valid_format_string_type_p (TREE_TYPE (type)))
     197                 :            :     {
     198                 :          6 :       if (!(flags & (int) ATTR_FLAG_BUILT_IN))
     199                 :          6 :         error ("function does not return string type");
     200                 :          6 :       *no_add_attrs = true;
     201                 :          6 :       return NULL_TREE;
     202                 :            :     }
     203                 :            : 
     204                 :            :   return NULL_TREE;
     205                 :            : }
     206                 :            : 
     207                 :            : /* Verify that the format_num argument is actually a string reference suitable,
     208                 :            :    for the language dialect and target (in case the format attribute is in 
     209                 :            :    error).  When we know the specific reference type expected, this is also 
     210                 :            :    checked.  */
     211                 :            : static bool
     212                 :    8620240 : check_format_string (const_tree fntype, unsigned HOST_WIDE_INT format_num,
     213                 :            :                      int flags, bool *no_add_attrs, int expected_format_type)
     214                 :            : {
     215                 :    8620240 :   unsigned HOST_WIDE_INT i;
     216                 :    8620240 :   bool is_objc_sref, is_target_sref, is_char_ref;
     217                 :    8620240 :   tree ref;
     218                 :    8620240 :   int fmt_flags;
     219                 :    8620240 :   function_args_iterator iter;
     220                 :            : 
     221                 :    8620240 :   i = 1;
     222                 :   19892100 :   FOREACH_FUNCTION_ARGS (fntype, ref, iter)
     223                 :            :     {
     224                 :   19892100 :       if (i == format_num)
     225                 :            :         break;
     226                 :   11271800 :       i++;
     227                 :            :     }
     228                 :            : 
     229                 :    8620240 :   if (!ref
     230                 :    8620240 :       || !valid_format_string_type_p (ref))
     231                 :            :     {
     232                 :          0 :       if (!(flags & (int) ATTR_FLAG_BUILT_IN))
     233                 :          0 :         error ("format string argument is not a string type");
     234                 :          0 :       *no_add_attrs = true;
     235                 :          0 :       return false;
     236                 :            :     }
     237                 :            : 
     238                 :            :   /* We only know that we want a suitable string reference.  */
     239                 :    8620240 :   if (expected_format_type < 0)
     240                 :            :     return true;
     241                 :            : 
     242                 :            :   /* Now check that the arg matches the expected type.  */
     243                 :    7801520 :   is_char_ref = 
     244                 :    7801520 :     (TYPE_MAIN_VARIANT (TREE_TYPE (ref)) == char_type_node);
     245                 :            : 
     246                 :    7801520 :   fmt_flags = format_flags (expected_format_type);
     247                 :    7801520 :   is_objc_sref = is_target_sref = false;
     248                 :    7801520 :   if (!is_char_ref)
     249                 :          0 :     is_objc_sref = objc_string_ref_type_p (ref);
     250                 :            : 
     251                 :    7801520 :   if (!(fmt_flags & FMT_FLAG_PARSE_ARG_CONVERT_EXTERNAL))
     252                 :            :     {
     253                 :    7801520 :       if (is_char_ref)
     254                 :            :         return true; /* OK, we expected a char and found one.  */
     255                 :            :       else
     256                 :            :         {
     257                 :            :           /* We expected a char but found an extended string type.  */
     258                 :          0 :           if (is_objc_sref)
     259                 :          0 :             error ("found a %qs reference but the format argument should"
     260                 :            :                    " be a string", format_name (gcc_objc_string_format_type));
     261                 :            :           else
     262                 :          0 :             error ("found a %qT but the format argument should be a string",
     263                 :            :                    ref);
     264                 :          0 :           *no_add_attrs = true;
     265                 :          0 :           return false;
     266                 :            :         }
     267                 :            :     }
     268                 :            : 
     269                 :            :   /* We expect a string object type as the format arg.  */
     270                 :          0 :   if (is_char_ref)
     271                 :            :     {
     272                 :          0 :       error ("format argument should be a %qs reference but"
     273                 :            :              " a string was found", format_name (expected_format_type));
     274                 :          0 :       *no_add_attrs = true;
     275                 :          0 :       return false;
     276                 :            :     }
     277                 :            :   
     278                 :            :   /* We will assert that objective-c will support either its own string type
     279                 :            :      or the target-supplied variant.  */
     280                 :          0 :   if (!is_objc_sref)
     281                 :          0 :     is_target_sref = (*targetcm.string_object_ref_type_p) ((const_tree) ref);
     282                 :            : 
     283                 :          0 :   if (expected_format_type == (int) gcc_objc_string_format_type 
     284                 :          0 :       && (is_objc_sref || is_target_sref))
     285                 :            :     return true;
     286                 :            : 
     287                 :            :   /* We will allow a target string ref to match only itself.  */
     288                 :          0 :   if (first_target_format_type 
     289                 :          0 :       && expected_format_type >= first_target_format_type
     290                 :          0 :       && is_target_sref)
     291                 :            :     return true;
     292                 :            :   else
     293                 :            :     {
     294                 :          0 :       error ("format argument should be a %qs reference",
     295                 :            :               format_name (expected_format_type));
     296                 :          0 :       *no_add_attrs = true;
     297                 :          0 :       return false;
     298                 :            :     }
     299                 :            : 
     300                 :            :   gcc_unreachable ();
     301                 :            : }
     302                 :            : 
     303                 :            : /* Under the control of FLAGS, verify EXPR is a valid constant that
     304                 :            :    refers to a positional argument ARGNO having a string type (char*
     305                 :            :    or, for targets like Darwin, a pointer to struct CFString) to
     306                 :            :    a function type FNTYPE declared with attribute ATNAME.
     307                 :            :    If valid, store the constant's integer value in *VALUE and return
     308                 :            :    the value.
     309                 :            :    If VALIDATED_P is true assert the validation is successful.
     310                 :            :    Returns the converted constant value on success, null otherwise.  */
     311                 :            : 
     312                 :            : static tree
     313                 :   16485300 : get_constant (const_tree fntype, const_tree atname, tree expr, int argno,
     314                 :            :               unsigned HOST_WIDE_INT *value, int flags, bool validated_p)
     315                 :            : {
     316                 :            :   /* Require the referenced argument to have a string type.  For targets
     317                 :            :      like Darwin, also accept pointers to struct CFString.  */
     318                 :   16485300 :   if (tree val = positional_argument (fntype, atname, expr, STRING_CST,
     319                 :            :                                       argno, flags))
     320                 :            :     {
     321                 :   16485300 :       *value = TREE_INT_CST_LOW (val);
     322                 :   16485300 :       return val;
     323                 :            :     }
     324                 :            : 
     325                 :         30 :   gcc_assert (!validated_p);
     326                 :            :   return NULL_TREE;
     327                 :            : }
     328                 :            : 
     329                 :            : /* Decode the arguments to a "format" attribute into a
     330                 :            :    function_format_info structure.  It is already known that the list
     331                 :            :    is of the right length.  If VALIDATED_P is true, then these
     332                 :            :    attributes have already been validated and must not be erroneous;
     333                 :            :    if false, it will give an error message.  Returns true if the
     334                 :            :    attributes are successfully decoded, false otherwise.  */
     335                 :            : 
     336                 :            : static bool
     337                 :    7833310 : decode_format_attr (const_tree fntype, tree atname, tree args,
     338                 :            :                     function_format_info *info, bool validated_p)
     339                 :            : {
     340                 :    7833310 :   tree format_type_id = TREE_VALUE (args);
     341                 :            :   /* Note that TREE_VALUE (args) is changed in place below.  Ditto
     342                 :            :      for the value of the next element on the list.  */
     343                 :    7833310 :   tree *format_num_expr = &TREE_VALUE (TREE_CHAIN (args));
     344                 :    7833310 :   tree *first_arg_num_expr = &TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args)));
     345                 :            : 
     346                 :    7833310 :   if (TREE_CODE (format_type_id) != IDENTIFIER_NODE)
     347                 :            :     {
     348                 :          2 :       gcc_assert (!validated_p);
     349                 :          2 :       error ("unrecognized format specifier");
     350                 :          2 :       return false;
     351                 :            :     }
     352                 :            :   else
     353                 :            :     {
     354                 :    7833300 :       const char *p = IDENTIFIER_POINTER (format_type_id);
     355                 :            : 
     356                 :    7833300 :       info->format_type = decode_format_type (p, &info->is_raw);
     357                 :            : 
     358                 :    7833300 :       if (!c_dialect_objc ()
     359                 :    7833300 :            && info->format_type == gcc_objc_string_format_type)
     360                 :            :         {
     361                 :          2 :           gcc_assert (!validated_p);
     362                 :          2 :           warning (OPT_Wformat_, "%qE is only allowed in Objective-C dialects",
     363                 :            :                    format_type_id);
     364                 :          2 :           info->format_type = format_type_error;
     365                 :          2 :           return false;
     366                 :            :         }
     367                 :            : 
     368                 :    7833300 :       if (info->format_type == format_type_error)
     369                 :            :         {
     370                 :          2 :           gcc_assert (!validated_p);
     371                 :          2 :           warning (OPT_Wformat_, "%qE is an unrecognized format function type",
     372                 :            :                    format_type_id);
     373                 :          2 :           return false;
     374                 :            :         }
     375                 :            :     }
     376                 :            : 
     377                 :    7833300 :   if (tree val = get_constant (fntype, atname, *format_num_expr,
     378                 :            :                                2, &info->format_num, 0, validated_p))
     379                 :    7833280 :     *format_num_expr = val;
     380                 :            :   else
     381                 :            :     return false;
     382                 :            : 
     383                 :    7833280 :   if (tree val = get_constant (fntype, atname, *first_arg_num_expr,
     384                 :            :                                3, &info->first_arg_num,
     385                 :            :                                (POSARG_ZERO | POSARG_ELLIPSIS), validated_p))
     386                 :    7833280 :     *first_arg_num_expr = val;
     387                 :            :   else
     388                 :            :     return false;
     389                 :            : 
     390                 :    7833280 :   if (info->first_arg_num != 0 && info->first_arg_num <= info->format_num)
     391                 :            :     {
     392                 :          4 :       gcc_assert (!validated_p);
     393                 :          4 :       error ("format string argument follows the arguments to be formatted");
     394                 :          4 :       return false;
     395                 :            :     }
     396                 :            : 
     397                 :            :   return true;
     398                 :            : }
     399                 :            : 
     400                 :            : /* Check a call to a format function against a parameter list.  */
     401                 :            : 
     402                 :            : /* The C standard version C++ is treated as equivalent to
     403                 :            :    or inheriting from, for the purpose of format features supported.  */
     404                 :            : #define CPLUSPLUS_STD_VER       (cxx_dialect < cxx11 ? STD_C94 : STD_C99)
     405                 :            : /* The C standard version we are checking formats against when pedantic.  */
     406                 :            : #define C_STD_VER               ((int) (c_dialect_cxx ()                   \
     407                 :            :                                  ? CPLUSPLUS_STD_VER                       \
     408                 :            :                                  : (flag_isoc2x                            \
     409                 :            :                                     ? STD_C2X                              \
     410                 :            :                                     : (flag_isoc99                         \
     411                 :            :                                        ? STD_C99                           \
     412                 :            :                                        : (flag_isoc94 ? STD_C94 : STD_C89)))))
     413                 :            : /* The name to give to the standard version we are warning about when
     414                 :            :    pedantic.  FEATURE_VER is the version in which the feature warned out
     415                 :            :    appeared, which is higher than C_STD_VER.  */
     416                 :            : #define C_STD_NAME(FEATURE_VER) (c_dialect_cxx ()               \
     417                 :            :                                  ? (cxx_dialect < cxx11 ? "ISO C++98" \
     418                 :            :                                     : "ISO C++11")            \
     419                 :            :                                  : ((FEATURE_VER) == STD_EXT    \
     420                 :            :                                     ? "ISO C"                 \
     421                 :            :                                     : ((FEATURE_VER) == STD_C2X \
     422                 :            :                                        ? "ISO C17"            \
     423                 :            :                                        : "ISO C90")))
     424                 :            : /* Adjust a C standard version, which may be STD_C9L, to account for
     425                 :            :    -Wno-long-long.  Returns other standard versions unchanged.  */
     426                 :            : #define ADJ_STD(VER)            ((int) ((VER) == STD_C9L                      \
     427                 :            :                                        ? (warn_long_long ? STD_C99 : STD_C89) \
     428                 :            :                                        : (VER)))
     429                 :            : 
     430                 :            : /* Enum describing the kind of specifiers present in the format and
     431                 :            :    requiring an argument.  */
     432                 :            : enum format_specifier_kind {
     433                 :            :   CF_KIND_FORMAT,
     434                 :            :   CF_KIND_FIELD_WIDTH,
     435                 :            :   CF_KIND_FIELD_PRECISION
     436                 :            : };
     437                 :            : 
     438                 :            : static const char *kind_descriptions[] = {
     439                 :            :   N_("format"),
     440                 :            :   N_("field width specifier"),
     441                 :            :   N_("field precision specifier")
     442                 :            : };
     443                 :            : 
     444                 :            : /* Structure describing details of a type expected in format checking,
     445                 :            :    and the type to check against it.  */
     446                 :            : struct format_wanted_type
     447                 :            : {
     448                 :            :   /* The type wanted.  */
     449                 :            :   tree wanted_type;
     450                 :            :   /* The name of this type to use in diagnostics.  */
     451                 :            :   const char *wanted_type_name;
     452                 :            :   /* Should be type checked just for scalar width identity.  */
     453                 :            :   int scalar_identity_flag;
     454                 :            :   /* The level of indirection through pointers at which this type occurs.  */
     455                 :            :   int pointer_count;
     456                 :            :   /* Whether, when pointer_count is 1, to allow any character type when
     457                 :            :      pedantic, rather than just the character or void type specified.  */
     458                 :            :   int char_lenient_flag;
     459                 :            :   /* Whether the argument, dereferenced once, is written into and so the
     460                 :            :      argument must not be a pointer to a const-qualified type.  */
     461                 :            :   int writing_in_flag;
     462                 :            :   /* Whether the argument, dereferenced once, is read from and so
     463                 :            :      must not be a NULL pointer.  */
     464                 :            :   int reading_from_flag;
     465                 :            :   /* The kind of specifier that this type is used for.  */
     466                 :            :   enum format_specifier_kind kind;
     467                 :            :   /* The starting character of the specifier.  This never includes the
     468                 :            :      initial percent sign.  */
     469                 :            :   const char *format_start;
     470                 :            :   /* The length of the specifier.  */
     471                 :            :   int format_length;
     472                 :            :   /* The actual parameter to check against the wanted type.  */
     473                 :            :   tree param;
     474                 :            :   /* The argument number of that parameter.  */
     475                 :            :   int arg_num;
     476                 :            :   /* The offset location of this argument with respect to the format
     477                 :            :      string location.  */
     478                 :            :   unsigned int offset_loc;
     479                 :            :   /* The next type to check for this format conversion, or NULL if none.  */
     480                 :            :   struct format_wanted_type *next;
     481                 :            : };
     482                 :            : 
     483                 :            : /* Convenience macro for format_length_info meaning unused.  */
     484                 :            : #define NO_FMT NULL, FMT_LEN_none, STD_C89
     485                 :            : 
     486                 :            : static const format_length_info printf_length_specs[] =
     487                 :            : {
     488                 :            :   { "h", FMT_LEN_h, STD_C89, "hh", FMT_LEN_hh, STD_C99, 0 },
     489                 :            :   { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C9L, 0 },
     490                 :            :   { "q", FMT_LEN_ll, STD_EXT, NO_FMT, 0 },
     491                 :            :   { "L", FMT_LEN_L, STD_C89, NO_FMT, 0 },
     492                 :            :   { "z", FMT_LEN_z, STD_C99, NO_FMT, 0 },
     493                 :            :   { "Z", FMT_LEN_z, STD_EXT, NO_FMT, 0 },
     494                 :            :   { "t", FMT_LEN_t, STD_C99, NO_FMT, 0 },
     495                 :            :   { "j", FMT_LEN_j, STD_C99, NO_FMT, 0 },
     496                 :            :   { "H", FMT_LEN_H, STD_EXT, NO_FMT, 0 },
     497                 :            :   { "D", FMT_LEN_D, STD_EXT, "DD", FMT_LEN_DD, STD_EXT, 0 },
     498                 :            :   { NO_FMT, NO_FMT, 0 }
     499                 :            : };
     500                 :            : 
     501                 :            : /* Length specifiers valid for asm_fprintf.  */
     502                 :            : static const format_length_info asm_fprintf_length_specs[] =
     503                 :            : {
     504                 :            :   { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C89, 0 },
     505                 :            :   { "w", FMT_LEN_w, STD_C89, NO_FMT, 0 },
     506                 :            :   { NO_FMT, NO_FMT, 0 }
     507                 :            : };
     508                 :            : 
     509                 :            : /* Length specifiers valid for GCC diagnostics.  */
     510                 :            : static const format_length_info gcc_diag_length_specs[] =
     511                 :            : {
     512                 :            :   { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C89, 0 },
     513                 :            :   { "w", FMT_LEN_w, STD_C89, NO_FMT, 0 },
     514                 :            :   { NO_FMT, NO_FMT, 0 }
     515                 :            : };
     516                 :            : 
     517                 :            : /* The custom diagnostics all accept the same length specifiers.  */
     518                 :            : #define gcc_tdiag_length_specs gcc_diag_length_specs
     519                 :            : #define gcc_cdiag_length_specs gcc_diag_length_specs
     520                 :            : #define gcc_cxxdiag_length_specs gcc_diag_length_specs
     521                 :            : #define gcc_dump_printf_length_specs gcc_diag_length_specs
     522                 :            : 
     523                 :            : /* This differs from printf_length_specs only in that "Z" is not accepted.  */
     524                 :            : static const format_length_info scanf_length_specs[] =
     525                 :            : {
     526                 :            :   { "h", FMT_LEN_h, STD_C89, "hh", FMT_LEN_hh, STD_C99, 0 },
     527                 :            :   { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C9L, 0 },
     528                 :            :   { "q", FMT_LEN_ll, STD_EXT, NO_FMT, 0 },
     529                 :            :   { "L", FMT_LEN_L, STD_C89, NO_FMT, 0 },
     530                 :            :   { "z", FMT_LEN_z, STD_C99, NO_FMT, 0 },
     531                 :            :   { "t", FMT_LEN_t, STD_C99, NO_FMT, 0 },
     532                 :            :   { "j", FMT_LEN_j, STD_C99, NO_FMT, 0 },
     533                 :            :   { "H", FMT_LEN_H, STD_EXT, NO_FMT, 0 },
     534                 :            :   { "D", FMT_LEN_D, STD_EXT, "DD", FMT_LEN_DD, STD_EXT, 0 },
     535                 :            :   { NO_FMT, NO_FMT, 0 }
     536                 :            : };
     537                 :            : 
     538                 :            : 
     539                 :            : /* All tables for strfmon use STD_C89 everywhere, since -pedantic warnings
     540                 :            :    make no sense for a format type not part of any C standard version.  */
     541                 :            : static const format_length_info strfmon_length_specs[] =
     542                 :            : {
     543                 :            :   /* A GNU extension.  */
     544                 :            :   { "L", FMT_LEN_L, STD_C89, NO_FMT, 0 },
     545                 :            :   { NO_FMT, NO_FMT, 0 }
     546                 :            : };
     547                 :            : 
     548                 :            : 
     549                 :            : /* For now, the Fortran front-end routines only use l as length modifier.  */
     550                 :            : static const format_length_info gcc_gfc_length_specs[] =
     551                 :            : {
     552                 :            :   { "l", FMT_LEN_l, STD_C89, NO_FMT, 0 },
     553                 :            :   { NO_FMT, NO_FMT, 0 }
     554                 :            : };
     555                 :            : 
     556                 :            : 
     557                 :            : static const format_flag_spec printf_flag_specs[] =
     558                 :            : {
     559                 :            :   { ' ',  0, 0, 0, N_("' ' flag"),        N_("the ' ' printf flag"),              STD_C89 },
     560                 :            :   { '+',  0, 0, 0, N_("'+' flag"),        N_("the '+' printf flag"),              STD_C89 },
     561                 :            :   { '#',  0, 0, 0, N_("'#' flag"),        N_("the '#' printf flag"),              STD_C89 },
     562                 :            :   { '0',  0, 0, 0, N_("'0' flag"),        N_("the '0' printf flag"),              STD_C89 },
     563                 :            :   { '-',  0, 0, 0, N_("'-' flag"),        N_("the '-' printf flag"),              STD_C89 },
     564                 :            :   { '\'', 0, 0, 0, N_("''' flag"),        N_("the ''' printf flag"),              STD_EXT },
     565                 :            :   { 'I',  0, 0, 0, N_("'I' flag"),        N_("the 'I' printf flag"),              STD_EXT },
     566                 :            :   { 'w',  0, 0, 0, N_("field width"),     N_("field width in printf format"),     STD_C89 },
     567                 :            :   { 'p',  0, 0, 0, N_("precision"),       N_("precision in printf format"),       STD_C89 },
     568                 :            :   { 'L',  0, 0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
     569                 :            :   { 0, 0, 0, 0, NULL, NULL, STD_C89 }
     570                 :            : };
     571                 :            : 
     572                 :            : 
     573                 :            : static const format_flag_pair printf_flag_pairs[] =
     574                 :            : {
     575                 :            :   { ' ', '+', 1, 0   },
     576                 :            :   { '0', '-', 1, 0   },
     577                 :            :   { '0', 'p', 1, 'i' },
     578                 :            :   { 0, 0, 0, 0 }
     579                 :            : };
     580                 :            : 
     581                 :            : static const format_flag_spec asm_fprintf_flag_specs[] =
     582                 :            : {
     583                 :            :   { ' ',  0, 0, 0, N_("' ' flag"),        N_("the ' ' printf flag"),              STD_C89 },
     584                 :            :   { '+',  0, 0, 0, N_("'+' flag"),        N_("the '+' printf flag"),              STD_C89 },
     585                 :            :   { '#',  0, 0, 0, N_("'#' flag"),        N_("the '#' printf flag"),              STD_C89 },
     586                 :            :   { '0',  0, 0, 0, N_("'0' flag"),        N_("the '0' printf flag"),              STD_C89 },
     587                 :            :   { '-',  0, 0, 0, N_("'-' flag"),        N_("the '-' printf flag"),              STD_C89 },
     588                 :            :   { 'w',  0, 0, 0, N_("field width"),     N_("field width in printf format"),     STD_C89 },
     589                 :            :   { 'p',  0, 0, 0, N_("precision"),       N_("precision in printf format"),       STD_C89 },
     590                 :            :   { 'L',  0, 0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
     591                 :            :   { 0, 0, 0, 0, NULL, NULL, STD_C89 }
     592                 :            : };
     593                 :            : 
     594                 :            : static const format_flag_pair asm_fprintf_flag_pairs[] =
     595                 :            : {
     596                 :            :   { ' ', '+', 1, 0   },
     597                 :            :   { '0', '-', 1, 0   },
     598                 :            :   { '0', 'p', 1, 'i' },
     599                 :            :   { 0, 0, 0, 0 }
     600                 :            : };
     601                 :            : 
     602                 :            : static const format_flag_pair gcc_diag_flag_pairs[] =
     603                 :            : {
     604                 :            :   { 0, 0, 0, 0 }
     605                 :            : };
     606                 :            : 
     607                 :            : #define gcc_tdiag_flag_pairs gcc_diag_flag_pairs
     608                 :            : #define gcc_cdiag_flag_pairs gcc_diag_flag_pairs
     609                 :            : #define gcc_cxxdiag_flag_pairs gcc_diag_flag_pairs
     610                 :            : #define gcc_gfc_flag_pairs gcc_diag_flag_pairs
     611                 :            : #define gcc_dump_printf_flag_pairs gcc_diag_flag_pairs
     612                 :            : 
     613                 :            : static const format_flag_spec gcc_diag_flag_specs[] =
     614                 :            : {
     615                 :            :   { '+',  0, 0, 0, N_("'+' flag"),        N_("the '+' printf flag"),              STD_C89 },
     616                 :            :   { '#',  0, 0, 0, N_("'#' flag"),        N_("the '#' printf flag"),              STD_C89 },
     617                 :            :   { 'q',  0, 0, 1, N_("'q' flag"),        N_("the 'q' diagnostic flag"),          STD_C89 },
     618                 :            :   { 'p',  0, 0, 0, N_("precision"),       N_("precision in printf format"),       STD_C89 },
     619                 :            :   { 'L',  0, 0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
     620                 :            :   { 0, 0, 0, 0, NULL, NULL, STD_C89 }
     621                 :            : };
     622                 :            : 
     623                 :            : #define gcc_tdiag_flag_specs gcc_diag_flag_specs
     624                 :            : #define gcc_cdiag_flag_specs gcc_diag_flag_specs
     625                 :            : #define gcc_cxxdiag_flag_specs gcc_diag_flag_specs
     626                 :            : #define gcc_gfc_flag_specs gcc_diag_flag_specs
     627                 :            : #define gcc_dump_printf_flag_specs gcc_diag_flag_specs
     628                 :            : 
     629                 :            : static const format_flag_spec scanf_flag_specs[] =
     630                 :            : {
     631                 :            :   { '*',  0, 0, 0, N_("assignment suppression"), N_("the assignment suppression scanf feature"), STD_C89 },
     632                 :            :   { 'a',  0, 0, 0, N_("'a' flag"),               N_("the 'a' scanf flag"),                       STD_EXT },
     633                 :            :   { 'm',  0, 0, 0, N_("'m' flag"),               N_("the 'm' scanf flag"),                       STD_EXT },
     634                 :            :   { 'w',  0, 0, 0, N_("field width"),            N_("field width in scanf format"),              STD_C89 },
     635                 :            :   { 'L',  0, 0, 0, N_("length modifier"),        N_("length modifier in scanf format"),          STD_C89 },
     636                 :            :   { '\'', 0, 0, 0, N_("''' flag"),               N_("the ''' scanf flag"),                       STD_EXT },
     637                 :            :   { 'I',  0, 0, 0, N_("'I' flag"),               N_("the 'I' scanf flag"),                       STD_EXT },
     638                 :            :   { 0, 0, 0, 0, NULL, NULL, STD_C89 }
     639                 :            : };
     640                 :            : 
     641                 :            : 
     642                 :            : static const format_flag_pair scanf_flag_pairs[] =
     643                 :            : {
     644                 :            :   { '*', 'L', 0, 0 },
     645                 :            :   { 'a', 'm', 0, 0 },
     646                 :            :   { 0, 0, 0, 0 }
     647                 :            : };
     648                 :            : 
     649                 :            : 
     650                 :            : static const format_flag_spec strftime_flag_specs[] =
     651                 :            : {
     652                 :            :   { '_', 0,   0, 0, N_("'_' flag"),     N_("the '_' strftime flag"),          STD_EXT },
     653                 :            :   { '-', 0,   0, 0, N_("'-' flag"),     N_("the '-' strftime flag"),          STD_EXT },
     654                 :            :   { '0', 0,   0, 0, N_("'0' flag"),     N_("the '0' strftime flag"),          STD_EXT },
     655                 :            :   { '^', 0,   0, 0, N_("'^' flag"),     N_("the '^' strftime flag"),          STD_EXT },
     656                 :            :   { '#', 0,   0, 0, N_("'#' flag"),     N_("the '#' strftime flag"),          STD_EXT },
     657                 :            :   { 'w', 0,   0, 0, N_("field width"),  N_("field width in strftime format"), STD_EXT },
     658                 :            :   { 'E', 0,   0, 0, N_("'E' modifier"), N_("the 'E' strftime modifier"),      STD_C99 },
     659                 :            :   { 'O', 0,   0, 0, N_("'O' modifier"), N_("the 'O' strftime modifier"),      STD_C99 },
     660                 :            :   { 'O', 'o', 0, 0, NULL,               N_("the 'O' modifier"),               STD_EXT },
     661                 :            :   { 'O', 'p', 0, 0, NULL,               N_("the 'O' modifier"),               STD_C2X },
     662                 :            :   { 0, 0, 0, 0, NULL, NULL, STD_C89 }
     663                 :            : };
     664                 :            : 
     665                 :            : 
     666                 :            : static const format_flag_pair strftime_flag_pairs[] =
     667                 :            : {
     668                 :            :   { 'E', 'O', 0, 0 },
     669                 :            :   { '_', '-', 0, 0 },
     670                 :            :   { '_', '0', 0, 0 },
     671                 :            :   { '-', '0', 0, 0 },
     672                 :            :   { '^', '#', 0, 0 },
     673                 :            :   { 0, 0, 0, 0 }
     674                 :            : };
     675                 :            : 
     676                 :            : 
     677                 :            : static const format_flag_spec strfmon_flag_specs[] =
     678                 :            : {
     679                 :            :   { '=',  0, 1, 0, N_("fill character"),  N_("fill character in strfmon format"),  STD_C89 },
     680                 :            :   { '^',  0, 0, 0, N_("'^' flag"),        N_("the '^' strfmon flag"),              STD_C89 },
     681                 :            :   { '+',  0, 0, 0, N_("'+' flag"),        N_("the '+' strfmon flag"),              STD_C89 },
     682                 :            :   { '(',  0, 0, 0, N_("'(' flag"),        N_("the '(' strfmon flag"),              STD_C89 },
     683                 :            :   { '!',  0, 0, 0, N_("'!' flag"),        N_("the '!' strfmon flag"),              STD_C89 },
     684                 :            :   { '-',  0, 0, 0, N_("'-' flag"),        N_("the '-' strfmon flag"),              STD_C89 },
     685                 :            :   { 'w',  0, 0, 0, N_("field width"),     N_("field width in strfmon format"),     STD_C89 },
     686                 :            :   { '#',  0, 0, 0, N_("left precision"),  N_("left precision in strfmon format"),  STD_C89 },
     687                 :            :   { 'p',  0, 0, 0, N_("right precision"), N_("right precision in strfmon format"), STD_C89 },
     688                 :            :   { 'L',  0, 0, 0, N_("length modifier"), N_("length modifier in strfmon format"), STD_C89 },
     689                 :            :   { 0, 0, 0, 0, NULL, NULL, STD_C89 }
     690                 :            : };
     691                 :            : 
     692                 :            : static const format_flag_pair strfmon_flag_pairs[] =
     693                 :            : {
     694                 :            :   { '+', '(', 0, 0 },
     695                 :            :   { 0, 0, 0, 0 }
     696                 :            : };
     697                 :            : 
     698                 :            : 
     699                 :            : static const format_char_info print_char_table[] =
     700                 :            : {
     701                 :            :   /* C89 conversion specifiers.  */
     702                 :            :   { "di",  0, STD_C89, { T89_I,   T99_SC,  T89_S,   T89_L,   T9L_LL,  TEX_LL,  T99_SST, T99_PD,  T99_IM,  BADLEN,  BADLEN,  BADLEN  }, "-wp0 +'I",  "i",  NULL },
     703                 :            :   { "oxX", 0, STD_C89, { T89_UI,  T99_UC,  T89_US,  T89_UL,  T9L_ULL, TEX_ULL, T99_ST,  T99_UPD, T99_UIM, BADLEN,  BADLEN,  BADLEN }, "-wp0#",     "i",  NULL },
     704                 :            :   { "u",   0, STD_C89, { T89_UI,  T99_UC,  T89_US,  T89_UL,  T9L_ULL, TEX_ULL, T99_ST,  T99_UPD, T99_UIM, BADLEN,  BADLEN,  BADLEN }, "-wp0'I",    "i",  NULL },
     705                 :            :   { "fgG", 0, STD_C89, { T89_D,   BADLEN,  BADLEN,  T99_D,   BADLEN,  T89_LD,  BADLEN,  BADLEN,  BADLEN,  TEX_D32, TEX_D64, TEX_D128 }, "-wp0 +#'I", "",   NULL },
     706                 :            :   { "eE",  0, STD_C89, { T89_D,   BADLEN,  BADLEN,  T99_D,   BADLEN,  T89_LD,  BADLEN,  BADLEN,  BADLEN,  TEX_D32, TEX_D64, TEX_D128 }, "-wp0 +#I",  "",   NULL },
     707                 :            :   { "c",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  T94_WI,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "-w",        "",   NULL },
     708                 :            :   { "s",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  T94_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "-wp",       "cR", NULL },
     709                 :            :   { "p",   1, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "-w",        "c",  NULL },
     710                 :            :   { "n",   1, STD_C89, { T89_I,   T99_SC,  T89_S,   T89_L,   T9L_LL,  BADLEN,  T99_SST, T99_PD,  T99_IM,  BADLEN,  BADLEN,  BADLEN }, "",          "W",  NULL },
     711                 :            :   /* C99 conversion specifiers.  */
     712                 :            :   { "F",   0, STD_C99, { T99_D,   BADLEN,  BADLEN,  T99_D,   BADLEN,  T99_LD,  BADLEN,  BADLEN,  BADLEN,  TEX_D32, TEX_D64, TEX_D128 }, "-wp0 +#'I", "",   NULL },
     713                 :            :   { "aA",  0, STD_C99, { T99_D,   BADLEN,  BADLEN,  T99_D,   BADLEN,  T99_LD,  BADLEN,  BADLEN,  BADLEN,  TEX_D32, TEX_D64,  TEX_D128 }, "-wp0 +#",   "",   NULL },
     714                 :            :   /* X/Open conversion specifiers.  */
     715                 :            :   { "C",   0, STD_EXT, { TEX_WI,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "-w",        "",   NULL },
     716                 :            :   { "S",   1, STD_EXT, { TEX_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "-wp",       "R",  NULL },
     717                 :            :   /* GNU conversion specifiers.  */
     718                 :            :   { "m",   0, STD_EXT, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "-wp",       "",   NULL },
     719                 :            :   { NULL,  0, STD_C89, NOLENGTHS, NULL, NULL, NULL }
     720                 :            : };
     721                 :            : 
     722                 :            : static const format_char_info asm_fprintf_char_table[] =
     723                 :            : {
     724                 :            :   /* C89 conversion specifiers.  */
     725                 :            :   { "di",  0, STD_C89, { T89_I,   BADLEN,  BADLEN,  T89_L,   T9L_LL,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-wp0 +",  "i", NULL },
     726                 :            :   { "oxX", 0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-wp0#",   "i", NULL },
     727                 :            :   { "u",   0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-wp0",    "i", NULL },
     728                 :            :   { "c",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-w",       "", NULL },
     729                 :            :   { "s",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-wp",    "cR", NULL },
     730                 :            : 
     731                 :            :   /* asm_fprintf conversion specifiers.  */
     732                 :            :   { "O",   0, STD_C89, NOARGUMENTS, "",      "",   NULL },
     733                 :            :   { "R",   0, STD_C89, NOARGUMENTS, "",      "",   NULL },
     734                 :            :   { "I",   0, STD_C89, NOARGUMENTS, "",      "",   NULL },
     735                 :            :   { "L",   0, STD_C89, NOARGUMENTS, "",      "",   NULL },
     736                 :            :   { "U",   0, STD_C89, NOARGUMENTS, "",      "",   NULL },
     737                 :            :   { "r",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "",  "", NULL },
     738                 :            :   { "z",   0, STD_C89, NOARGUMENTS, "",      "",   NULL },
     739                 :            :   { "@",   0, STD_C89, NOARGUMENTS, "",      "",   NULL },
     740                 :            :   { NULL,  0, STD_C89, NOLENGTHS, NULL, NULL, NULL }
     741                 :            : };
     742                 :            : 
     743                 :            : /* GCC-specific format_char_info arrays.  */
     744                 :            : 
     745                 :            : /* The conversion specifiers implemented within pp_format, and thus supported
     746                 :            :    by all pretty_printer instances within GCC.  */
     747                 :            : 
     748                 :            : #define PP_FORMAT_CHAR_TABLE \
     749                 :            :   { "di",  0, STD_C89, { T89_I,   BADLEN,  BADLEN,  T89_L,   T9L_LL,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL }, \
     750                 :            :   { "ox",  0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL }, \
     751                 :            :   { "u",   0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL }, \
     752                 :            :   { "c",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL }, \
     753                 :            :   { "s",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "pq", "cR", NULL }, \
     754                 :            :   { "p",   1, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "c",  NULL }, \
     755                 :            :   { "r",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "",    "//cR",   NULL }, \
     756                 :            :   { "@",   1, STD_C89, { T_EVENT_PTR,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "", "\"",   NULL }, \
     757                 :            :   { "<",   0, STD_C89, NOARGUMENTS, "",      "<",   NULL }, \
     758                 :            :   { ">",   0, STD_C89, NOARGUMENTS, "",      ">",   NULL }, \
     759                 :            :   { "'" ,  0, STD_C89, NOARGUMENTS, "",      "",    NULL }, \
     760                 :            :   { "R",   0, STD_C89, NOARGUMENTS, "",     "\\",   NULL }, \
     761                 :            :   { "m",   0, STD_C89, NOARGUMENTS, "q",     "",   NULL }, \
     762                 :            :   { "Z",   1, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "",    "", &gcc_diag_char_table[0] }
     763                 :            : 
     764                 :            : static const format_char_info gcc_diag_char_table[] =
     765                 :            : {
     766                 :            :   /* The conversion specifiers implemented within pp_format.  */
     767                 :            :   PP_FORMAT_CHAR_TABLE,
     768                 :            : 
     769                 :            :   { NULL,  0, STD_C89, NOLENGTHS, NULL, NULL, NULL }
     770                 :            : };
     771                 :            : 
     772                 :            : static const format_char_info gcc_tdiag_char_table[] =
     773                 :            : {
     774                 :            :   /* The conversion specifiers implemented within pp_format.  */
     775                 :            :   PP_FORMAT_CHAR_TABLE,
     776                 :            : 
     777                 :            :   /* Custom conversion specifiers implemented by default_tree_printer.  */
     778                 :            : 
     779                 :            :   /* These will require a "tree" at runtime.  */
     780                 :            :   { "DFTV", 1, STD_C89, { T89_T,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q+", "'",   NULL },
     781                 :            :   { "E", 1, STD_C89, { T89_T,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q+", "",   NULL },
     782                 :            :   { "K", 1, STD_C89, { T89_T,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "", "\"",   NULL },
     783                 :            : 
     784                 :            :   /* G requires a "gimple*" argument at runtime.  */
     785                 :            :   { "G", 1, STD_C89, { T89_G,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "", "\"",   NULL },
     786                 :            : 
     787                 :            :   { NULL,  0, STD_C89, NOLENGTHS, NULL, NULL, NULL }
     788                 :            : };
     789                 :            : 
     790                 :            : static const format_char_info gcc_cdiag_char_table[] =
     791                 :            : {
     792                 :            :   /* The conversion specifiers implemented within pp_format.  */
     793                 :            :   PP_FORMAT_CHAR_TABLE,
     794                 :            : 
     795                 :            :   /* Custom conversion specifiers implemented by c_tree_printer.  */
     796                 :            : 
     797                 :            :   /* These will require a "tree" at runtime.  */
     798                 :            :   { "DFTV", 1, STD_C89, { T89_T,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q+", "'",   NULL },
     799                 :            :   { "E",   1, STD_C89, { T89_T,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q+", "",   NULL },
     800                 :            :   { "K",   1, STD_C89, { T89_T,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "", "\"",   NULL },
     801                 :            : 
     802                 :            :   /* G requires a "gimple*" argument at runtime.  */
     803                 :            :   { "G",   1, STD_C89, { T89_G,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "", "\"",   NULL },
     804                 :            : 
     805                 :            :   { "v",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q#",  "",   NULL },
     806                 :            : 
     807                 :            :   { NULL,  0, STD_C89, NOLENGTHS, NULL, NULL, NULL }
     808                 :            : };
     809                 :            : 
     810                 :            : static const format_char_info gcc_cxxdiag_char_table[] =
     811                 :            : {
     812                 :            :   /* The conversion specifiers implemented within pp_format.  */
     813                 :            :   PP_FORMAT_CHAR_TABLE,
     814                 :            : 
     815                 :            :   /* Custom conversion specifiers implemented by cp_printer.  */
     816                 :            : 
     817                 :            :   /* These will require a "tree" at runtime.  */
     818                 :            :   { "ADFHISTVX",1,STD_C89,{ T89_T,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q+#",   "'",   NULL },
     819                 :            :   { "E", 1,STD_C89,{ T89_T,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q+#",   "",   NULL },
     820                 :            :   { "K", 1, STD_C89,{ T89_T,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "",   "\"",   NULL },
     821                 :            : 
     822                 :            :   /* G requires a "gimple*" argument at runtime.  */
     823                 :            :   { "G", 1, STD_C89,{ T89_G,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "",   "\"",   NULL },
     824                 :            : 
     825                 :            :   /* These accept either an 'int' or an 'enum tree_code' (which is handled as an 'int'.)  */
     826                 :            :   { "CLOPQ",0,STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
     827                 :            : 
     828                 :            :   { NULL,  0, STD_C89, NOLENGTHS, NULL, NULL, NULL }
     829                 :            : };
     830                 :            : 
     831                 :            : static const format_char_info gcc_gfc_char_table[] =
     832                 :            : {
     833                 :            :   /* C89 conversion specifiers.  */
     834                 :            :   { "di",  0, STD_C89, { T89_I,   BADLEN,  BADLEN,  T89_L,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q", "", NULL },
     835                 :            :   { "u",   0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q", "", NULL },
     836                 :            :   { "c",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q", "", NULL },
     837                 :            :   { "s",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q", "cR", NULL },
     838                 :            : 
     839                 :            :   /* gfc conversion specifiers.  */
     840                 :            : 
     841                 :            :   { "C",   0, STD_C89, NOARGUMENTS, "",      "",   NULL },
     842                 :            : 
     843                 :            :   /* This will require a "locus" at runtime.  */
     844                 :            :   { "L",   0, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "", "R", NULL },
     845                 :            : 
     846                 :            :   /* These will require nothing.  */
     847                 :            :   { "<>",0, STD_C89, NOARGUMENTS, "",      "",   NULL },
     848                 :            :   { NULL,  0, STD_C89, NOLENGTHS, NULL, NULL, NULL }
     849                 :            : };
     850                 :            : 
     851                 :            : static const format_char_info gcc_dump_printf_char_table[] =
     852                 :            : {
     853                 :            :   /* The conversion specifiers implemented within pp_format.  */
     854                 :            :   PP_FORMAT_CHAR_TABLE,
     855                 :            : 
     856                 :            :   /* Custom conversion specifiers implemented by dump_pretty_printer.  */
     857                 :            : 
     858                 :            :   /* E and G require a "gimple *" argument at runtime.  */
     859                 :            :   { "EG",   1, STD_C89, { T89_G,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "", "\"",   NULL },
     860                 :            : 
     861                 :            :   /* C requires a "cgraph_node *" argument at runtime.  */
     862                 :            :   { "C",   1, STD_C89, { T_CGRAPH_NODE,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "", "\"",   NULL },
     863                 :            : 
     864                 :            :   /* T requires a "tree" at runtime.  */
     865                 :            :   { "T",   1, STD_C89, { T89_T,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "", "\"",   NULL },
     866                 :            : 
     867                 :            :   /* %f requires a "double"; it doesn't support modifiers.  */
     868                 :            :   { "f",   0, STD_C89, { T89_D,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "", "\"",   NULL },
     869                 :            : 
     870                 :            :   { NULL,  0, STD_C89, NOLENGTHS, NULL, NULL, NULL }
     871                 :            : };
     872                 :            : 
     873                 :            : static const format_char_info scan_char_table[] =
     874                 :            : {
     875                 :            :   /* C89 conversion specifiers.  */
     876                 :            :   { "di",    1, STD_C89, { T89_I,   T99_SC,  T89_S,   T89_L,   T9L_LL,  TEX_LL,  T99_SST, T99_PD,  T99_IM,  BADLEN,  BADLEN,  BADLEN }, "*w'I", "W",   NULL },
     877                 :            :   { "u",     1, STD_C89, { T89_UI,  T99_UC,  T89_US,  T89_UL,  T9L_ULL, TEX_ULL, T99_ST,  T99_UPD, T99_UIM, BADLEN,  BADLEN,  BADLEN }, "*w'I", "W",   NULL },
     878                 :            :   { "oxX",   1, STD_C89, { T89_UI,  T99_UC,  T89_US,  T89_UL,  T9L_ULL, TEX_ULL, T99_ST,  T99_UPD, T99_UIM, BADLEN,  BADLEN,  BADLEN }, "*w",   "W",   NULL },
     879                 :            :   { "efgEG", 1, STD_C89, { T89_F,   BADLEN,  BADLEN,  T89_D,   BADLEN,  T89_LD,  BADLEN,  BADLEN,  BADLEN,  TEX_D32, TEX_D64, TEX_D128 }, "*w'",  "W",   NULL },
     880                 :            :   { "c",     1, STD_C89, { T89_C,   BADLEN,  BADLEN,  T94_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "*mw",   "cW",  NULL },
     881                 :            :   { "s",     1, STD_C89, { T89_C,   BADLEN,  BADLEN,  T94_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "*amw",  "cW",  NULL },
     882                 :            :   { "[",     1, STD_C89, { T89_C,   BADLEN,  BADLEN,  T94_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "*amw",  "cW[", NULL },
     883                 :            :   { "p",     2, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "*w",   "W",   NULL },
     884                 :            :   { "n",     1, STD_C89, { T89_I,   T99_SC,  T89_S,   T89_L,   T9L_LL,  BADLEN,  T99_SST, T99_PD,  T99_IM,  BADLEN,  BADLEN,  BADLEN }, "",     "W",   NULL },
     885                 :            :   /* C99 conversion specifiers.  */
     886                 :            :   { "F",   1, STD_C99, { T99_F,   BADLEN,  BADLEN,  T99_D,   BADLEN,  T99_LD,  BADLEN,  BADLEN,  BADLEN,  TEX_D32, TEX_D64, TEX_D128 }, "*w'",  "W",   NULL },
     887                 :            :   { "aA",   1, STD_C99, { T99_F,   BADLEN,  BADLEN,  T99_D,   BADLEN,  T99_LD,  BADLEN,  BADLEN,  BADLEN,  TEX_D32,  TEX_D64,  TEX_D128 }, "*w'",  "W",   NULL },
     888                 :            :   /* X/Open conversion specifiers.  */
     889                 :            :   { "C",     1, STD_EXT, { TEX_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "*mw",   "W",   NULL },
     890                 :            :   { "S",     1, STD_EXT, { TEX_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "*amw",  "W",   NULL },
     891                 :            :   { NULL, 0, STD_C89, NOLENGTHS, NULL, NULL, NULL }
     892                 :            : };
     893                 :            : 
     894                 :            : static const format_char_info time_char_table[] =
     895                 :            : {
     896                 :            :   /* C89 conversion specifiers.  */
     897                 :            :   { "AZa",            0, STD_C89, NOLENGTHS, "^#",     "",   NULL },
     898                 :            :   { "Bb",             0, STD_C89, NOLENGTHS, "O^#",    "p",  NULL },
     899                 :            :   { "cx",             0, STD_C89, NOLENGTHS, "E",      "3",  NULL },
     900                 :            :   { "HIMSUWdmw",      0, STD_C89, NOLENGTHS, "-_0Ow",  "",   NULL },
     901                 :            :   { "j",              0, STD_C89, NOLENGTHS, "-_0Ow",  "o",  NULL },
     902                 :            :   { "p",              0, STD_C89, NOLENGTHS, "#",      "",   NULL },
     903                 :            :   { "X",              0, STD_C89, NOLENGTHS, "E",      "",   NULL },
     904                 :            :   { "y",              0, STD_C89, NOLENGTHS, "EO-_0w", "4",  NULL },
     905                 :            :   { "Y",              0, STD_C89, NOLENGTHS, "-_0EOw", "o",  NULL },
     906                 :            :   { "%",              0, STD_C89, NOLENGTHS, "",       "",   NULL },
     907                 :            :   /* C99 conversion specifiers.  */
     908                 :            :   { "C",              0, STD_C99, NOLENGTHS, "-_0EOw", "o",  NULL },
     909                 :            :   { "D",              0, STD_C99, NOLENGTHS, "",       "2",  NULL },
     910                 :            :   { "eVu",            0, STD_C99, NOLENGTHS, "-_0Ow",  "",   NULL },
     911                 :            :   { "FRTnrt",         0, STD_C99, NOLENGTHS, "",       "",   NULL },
     912                 :            :   { "g",              0, STD_C99, NOLENGTHS, "O-_0w",  "2o", NULL },
     913                 :            :   { "G",              0, STD_C99, NOLENGTHS, "-_0Ow",  "o",  NULL },
     914                 :            :   { "h",              0, STD_C99, NOLENGTHS, "^#",     "",   NULL },
     915                 :            :   { "z",              0, STD_C99, NOLENGTHS, "O",      "o",  NULL },
     916                 :            :   /* GNU conversion specifiers.  */
     917                 :            :   { "kls",            0, STD_EXT, NOLENGTHS, "-_0Ow",  "",   NULL },
     918                 :            :   { "P",              0, STD_EXT, NOLENGTHS, "",       "",   NULL },
     919                 :            :   { NULL,               0, STD_C89, NOLENGTHS, NULL, NULL, NULL }
     920                 :            : };
     921                 :            : 
     922                 :            : static const format_char_info monetary_char_table[] =
     923                 :            : {
     924                 :            :   { "in", 0, STD_C89, { T89_D, BADLEN, BADLEN, BADLEN, BADLEN, T89_LD, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "=^+(!-w#p", "", NULL },
     925                 :            :   { NULL, 0, STD_C89, NOLENGTHS, NULL, NULL, NULL }
     926                 :            : };
     927                 :            : 
     928                 :            : /* This must be in the same order as enum format_type.  */
     929                 :            : static const format_kind_info format_types_orig[] =
     930                 :            : {
     931                 :            :   { "gnu_printf",   printf_length_specs,  print_char_table, " +#0-'I", NULL,
     932                 :            :     printf_flag_specs, printf_flag_pairs,
     933                 :            :     FMT_FLAG_ARG_CONVERT|FMT_FLAG_DOLLAR_MULTIPLE|FMT_FLAG_USE_DOLLAR|FMT_FLAG_EMPTY_PREC_OK,
     934                 :            :     'w', 0, 'p', 0, 'L', 0,
     935                 :            :     &integer_type_node, &integer_type_node
     936                 :            :   },
     937                 :            :   { "asm_fprintf",   asm_fprintf_length_specs,  asm_fprintf_char_table, " +#0-", NULL,
     938                 :            :     asm_fprintf_flag_specs, asm_fprintf_flag_pairs,
     939                 :            :     FMT_FLAG_ARG_CONVERT|FMT_FLAG_EMPTY_PREC_OK,
     940                 :            :     'w', 0, 'p', 0, 'L', 0,
     941                 :            :     NULL, NULL
     942                 :            :   },
     943                 :            :   { "gcc_diag",   gcc_diag_length_specs,  gcc_diag_char_table, "q+#", NULL,
     944                 :            :     gcc_diag_flag_specs, gcc_diag_flag_pairs,
     945                 :            :     FMT_FLAG_ARG_CONVERT,
     946                 :            :     0, 0, 'p', 0, 'L', 0,
     947                 :            :     NULL, &integer_type_node
     948                 :            :   },
     949                 :            :   { "gcc_tdiag",   gcc_tdiag_length_specs,  gcc_tdiag_char_table, "q+#", NULL,
     950                 :            :     gcc_tdiag_flag_specs, gcc_tdiag_flag_pairs,
     951                 :            :     FMT_FLAG_ARG_CONVERT,
     952                 :            :     0, 0, 'p', 0, 'L', 0,
     953                 :            :     NULL, &integer_type_node
     954                 :            :   },
     955                 :            :   { "gcc_cdiag",   gcc_cdiag_length_specs,  gcc_cdiag_char_table, "q+#", NULL,
     956                 :            :     gcc_cdiag_flag_specs, gcc_cdiag_flag_pairs,
     957                 :            :     FMT_FLAG_ARG_CONVERT,
     958                 :            :     0, 0, 'p', 0, 'L', 0,
     959                 :            :     NULL, &integer_type_node
     960                 :            :   },
     961                 :            :   { "gcc_cxxdiag",   gcc_cxxdiag_length_specs,  gcc_cxxdiag_char_table, "q+#", NULL,
     962                 :            :     gcc_cxxdiag_flag_specs, gcc_cxxdiag_flag_pairs,
     963                 :            :     FMT_FLAG_ARG_CONVERT,
     964                 :            :     0, 0, 'p', 0, 'L', 0,
     965                 :            :     NULL, &integer_type_node
     966                 :            :   },
     967                 :            :   { "gcc_gfc", gcc_gfc_length_specs, gcc_gfc_char_table, "q+#", NULL,
     968                 :            :     gcc_gfc_flag_specs, gcc_gfc_flag_pairs,
     969                 :            :     FMT_FLAG_ARG_CONVERT,
     970                 :            :     0, 0, 0, 0, 0, 0,
     971                 :            :     NULL, NULL
     972                 :            :   },
     973                 :            :   { "gcc_dump_printf",   gcc_dump_printf_length_specs,
     974                 :            :     gcc_dump_printf_char_table, "q+#", NULL,
     975                 :            :     gcc_dump_printf_flag_specs, gcc_dump_printf_flag_pairs,
     976                 :            :     FMT_FLAG_ARG_CONVERT,
     977                 :            :     0, 0, 'p', 0, 'L', 0,
     978                 :            :     NULL, &integer_type_node
     979                 :            :   },
     980                 :            :   { "NSString",   NULL,  NULL, NULL, NULL,
     981                 :            :     NULL, NULL,
     982                 :            :     FMT_FLAG_ARG_CONVERT|FMT_FLAG_PARSE_ARG_CONVERT_EXTERNAL, 0, 0, 0, 0, 0, 0,
     983                 :            :     NULL, NULL
     984                 :            :   },
     985                 :            :   { "gnu_scanf",    scanf_length_specs,   scan_char_table,  "*'I", NULL,
     986                 :            :     scanf_flag_specs, scanf_flag_pairs,
     987                 :            :     FMT_FLAG_ARG_CONVERT|FMT_FLAG_SCANF_A_KLUDGE|FMT_FLAG_USE_DOLLAR|FMT_FLAG_ZERO_WIDTH_BAD|FMT_FLAG_DOLLAR_GAP_POINTER_OK,
     988                 :            :     'w', 0, 0, '*', 'L', 'm',
     989                 :            :     NULL, NULL
     990                 :            :   },
     991                 :            :   { "gnu_strftime", NULL,                 time_char_table,  "_-0^#", "EO",
     992                 :            :     strftime_flag_specs, strftime_flag_pairs,
     993                 :            :     FMT_FLAG_FANCY_PERCENT_OK, 'w', 0, 0, 0, 0, 0,
     994                 :            :     NULL, NULL
     995                 :            :   },
     996                 :            :   { "gnu_strfmon",  strfmon_length_specs, monetary_char_table, "=^+(!-", NULL,
     997                 :            :     strfmon_flag_specs, strfmon_flag_pairs,
     998                 :            :     FMT_FLAG_ARG_CONVERT, 'w', '#', 'p', 0, 'L', 0,
     999                 :            :     NULL, NULL
    1000                 :            :   }
    1001                 :            : };
    1002                 :            : 
    1003                 :            : /* This layer of indirection allows GCC to reassign format_types with
    1004                 :            :    new data if necessary, while still allowing the original data to be
    1005                 :            :    const.  */
    1006                 :            : static const format_kind_info *format_types = format_types_orig;
    1007                 :            : /* We can modify this one.  We also add target-specific format types
    1008                 :            :    to the end of the array.  */
    1009                 :            : static format_kind_info *dynamic_format_types;
    1010                 :            : 
    1011                 :            : static int n_format_types = ARRAY_SIZE (format_types_orig);
    1012                 :            : 
    1013                 :            : /* Structure detailing the results of checking a format function call
    1014                 :            :    where the format expression may be a conditional expression with
    1015                 :            :    many leaves resulting from nested conditional expressions.  */
    1016                 :            : struct format_check_results
    1017                 :            : {
    1018                 :            :   /* Number of leaves of the format argument that could not be checked
    1019                 :            :      as they were not string literals.  */
    1020                 :            :   int number_non_literal;
    1021                 :            :   /* Number of leaves of the format argument that were null pointers or
    1022                 :            :      string literals, but had extra format arguments.  */
    1023                 :            :   int number_extra_args;
    1024                 :            :   location_t extra_arg_loc;
    1025                 :            :   /* Number of leaves of the format argument that were null pointers or
    1026                 :            :      string literals, but had extra format arguments and used $ operand
    1027                 :            :      numbers.  */
    1028                 :            :   int number_dollar_extra_args;
    1029                 :            :   /* Number of leaves of the format argument that were wide string
    1030                 :            :      literals.  */
    1031                 :            :   int number_wide;
    1032                 :            :   /* Number of leaves of the format argument that are not array of "char".  */
    1033                 :            :   int number_non_char;
    1034                 :            :   /* Number of leaves of the format argument that were empty strings.  */
    1035                 :            :   int number_empty;
    1036                 :            :   /* Number of leaves of the format argument that were unterminated
    1037                 :            :      strings.  */
    1038                 :            :   int number_unterminated;
    1039                 :            :   /* Number of leaves of the format argument that were not counted above.  */
    1040                 :            :   int number_other;
    1041                 :            :   /* Location of the format string.  */
    1042                 :            :   location_t format_string_loc;
    1043                 :            : };
    1044                 :            : 
    1045                 :            : struct format_check_context
    1046                 :            : {
    1047                 :            :   format_check_results *res;
    1048                 :            :   function_format_info *info;
    1049                 :            :   tree params;
    1050                 :            :   vec<location_t> *arglocs;
    1051                 :            : };
    1052                 :            : 
    1053                 :            : /* Return the format name (as specified in the original table) for the format
    1054                 :            :    type indicated by format_num.  */
    1055                 :            : static const char *
    1056                 :          0 : format_name (int format_num)
    1057                 :            : {
    1058                 :          0 :   if (format_num >= 0 && format_num < n_format_types)
    1059                 :          0 :     return format_types[format_num].name;
    1060                 :          0 :   gcc_unreachable ();
    1061                 :            : }
    1062                 :            : 
    1063                 :            : /* Return the format flags (as specified in the original table) for the format
    1064                 :            :    type indicated by format_num.  */
    1065                 :            : static int
    1066                 :    7801520 : format_flags (int format_num)
    1067                 :            : {
    1068                 :    7801520 :   if (format_num >= 0 && format_num < n_format_types)
    1069                 :    7801520 :     return format_types[format_num].flags;
    1070                 :          0 :   gcc_unreachable ();
    1071                 :            : }
    1072                 :            : 
    1073                 :            : static void check_format_info (function_format_info *, tree,
    1074                 :            :                                vec<location_t> *);
    1075                 :            : static void check_format_arg (void *, tree, unsigned HOST_WIDE_INT);
    1076                 :            : static void check_format_info_main (format_check_results *,
    1077                 :            :                                     function_format_info *, const char *,
    1078                 :            :                                     location_t, tree,
    1079                 :            :                                     int, tree,
    1080                 :            :                                     unsigned HOST_WIDE_INT,
    1081                 :            :                                     object_allocator<format_wanted_type> &,
    1082                 :            :                                     vec<location_t> *);
    1083                 :            : 
    1084                 :            : static void init_dollar_format_checking (int, tree);
    1085                 :            : static int maybe_read_dollar_number (const char **, int,
    1086                 :            :                                      tree, tree *, const format_kind_info *);
    1087                 :            : static bool avoid_dollar_number (const char *);
    1088                 :            : static void finish_dollar_format_checking (format_check_results *, int);
    1089                 :            : 
    1090                 :            : static const format_flag_spec *get_flag_spec (const format_flag_spec *,
    1091                 :            :                                               int, const char *);
    1092                 :            : 
    1093                 :            : static void check_format_types (const substring_loc &fmt_loc,
    1094                 :            :                                 format_wanted_type *,
    1095                 :            :                                 const format_kind_info *fki,
    1096                 :            :                                 int offset_to_type_start,
    1097                 :            :                                 char conversion_char,
    1098                 :            :                                 vec<location_t> *arglocs);
    1099                 :            : static void format_type_warning (const substring_loc &fmt_loc,
    1100                 :            :                                  location_t param_loc,
    1101                 :            :                                  format_wanted_type *, tree,
    1102                 :            :                                  tree,
    1103                 :            :                                  const format_kind_info *fki,
    1104                 :            :                                  int offset_to_type_start,
    1105                 :            :                                  char conversion_char);
    1106                 :            : 
    1107                 :            : /* Decode a format type from a string, returning the type, or
    1108                 :            :    format_type_error if not valid, in which case the caller should
    1109                 :            :    print an error message.  On success, when IS_RAW is non-null, set
    1110                 :            :    *IS_RAW when the format type corresponds to a GCC "raw" diagnostic
    1111                 :            :    formatting function and clear it otherwise.  */
    1112                 :            : static format_type
    1113                 :    7833470 : decode_format_type (const char *s, bool *is_raw /* = NULL */)
    1114                 :            : {
    1115                 :    7833470 :   bool is_raw_buf;
    1116                 :            : 
    1117                 :    7833470 :   if (!is_raw)
    1118                 :        166 :     is_raw = &is_raw_buf;
    1119                 :            : 
    1120                 :    7833470 :   *is_raw = false;
    1121                 :            : 
    1122                 :    7833470 :   s = convert_format_name_to_system_name (s);
    1123                 :            : 
    1124                 :    7833470 :   size_t slen = strlen (s);
    1125                 :   31289100 :   for (int i = 0; i < n_format_types; i++)
    1126                 :            :     {
    1127                 :            :       /* Check for a match with no underscores.  */
    1128                 :   31289000 :       if (!strcmp (s, format_types[i].name))
    1129                 :    7833440 :         return static_cast<format_type> (i);
    1130                 :            : 
    1131                 :            :       /* Check for leading and trailing underscores.  */
    1132                 :   23455600 :       size_t alen = strlen (format_types[i].name);
    1133                 :   23455600 :       if (slen == alen + 4 && s[0] == '_' && s[1] == '_'
    1134                 :          0 :           && s[slen - 1] == '_' && s[slen - 2] == '_'
    1135                 :          0 :           && !strncmp (s + 2, format_types[i].name, alen))
    1136                 :          0 :         return static_cast<format_type>(i);
    1137                 :            : 
    1138                 :            :       /* Check for the "_raw" suffix and no leading underscores.  */
    1139                 :   23455600 :       if (slen == alen + 4
    1140                 :     898436 :           && !strncmp (s, format_types[i].name, alen)
    1141                 :         30 :           && !strcmp (s + alen, "_raw"))
    1142                 :            :         {
    1143                 :         30 :           *is_raw = true;
    1144                 :         30 :           return static_cast<format_type>(i);
    1145                 :            :         }
    1146                 :            : 
    1147                 :            :       /* Check for the "_raw__" suffix and leading underscores.  */
    1148                 :   23455600 :       if (slen == alen + 8 && s[0] == '_' && s[1] == '_'
    1149                 :          0 :           && !strncmp (s + 2, format_types[i].name, alen)
    1150                 :          0 :           && !strcmp (s + 2 + alen, "_raw__"))
    1151                 :            :         {
    1152                 :          0 :           *is_raw = true;
    1153                 :          0 :           return static_cast<format_type>(i);
    1154                 :            :         }
    1155                 :            :     }
    1156                 :            : 
    1157                 :            :   return format_type_error;
    1158                 :            : }
    1159                 :            : 
    1160                 :            : 
    1161                 :            : /* Check the argument list of a call to printf, scanf, etc.
    1162                 :            :    ATTRS are the attributes on the function type.  There are NARGS argument
    1163                 :            :    values in the array ARGARRAY.
    1164                 :            :    Also, if -Wsuggest-attribute=format,
    1165                 :            :    warn for calls to vprintf or vscanf in functions with no such format
    1166                 :            :    attribute themselves.  */
    1167                 :            : 
    1168                 :            : void
    1169                 :    2277250 : check_function_format (const_tree fntype, tree attrs, int nargs,
    1170                 :            :                        tree *argarray, vec<location_t> *arglocs)
    1171                 :            : {
    1172                 :    2277250 :   tree a;
    1173                 :            : 
    1174                 :    2277250 :   tree atname = get_identifier ("format");
    1175                 :            : 
    1176                 :            :   /* See if this function has any format attributes.  */
    1177                 :    2512420 :   for (a = attrs; a; a = TREE_CHAIN (a))
    1178                 :            :     {
    1179                 :     235175 :       if (is_attribute_p ("format", get_attribute_name (a)))
    1180                 :            :         {
    1181                 :            :           /* Yup; check it.  */
    1182                 :      31720 :           function_format_info info;
    1183                 :      31720 :           decode_format_attr (fntype, atname, TREE_VALUE (a), &info,
    1184                 :            :                               /*validated=*/true);
    1185                 :      31720 :           if (warn_format)
    1186                 :            :             {
    1187                 :            :               /* FIXME: Rewrite all the internal functions in this file
    1188                 :            :                  to use the ARGARRAY directly instead of constructing this
    1189                 :            :                  temporary list.  */
    1190                 :      31677 :               tree params = NULL_TREE;
    1191                 :      31677 :               int i;
    1192                 :     126471 :               for (i = nargs - 1; i >= 0; i--)
    1193                 :      94794 :                 params = tree_cons (NULL_TREE, argarray[i], params);
    1194                 :      31677 :               check_format_info (&info, params, arglocs);
    1195                 :            :             }
    1196                 :            : 
    1197                 :            :           /* Attempt to detect whether the current function might benefit
    1198                 :            :              from the format attribute if the called function is decorated
    1199                 :            :              with it.  Avoid using calls with string literal formats for
    1200                 :            :              guidance since those are unlikely to be viable candidates.  */
    1201                 :      31720 :           if (warn_suggest_attribute_format
    1202                 :        933 :               && current_function_decl != NULL_TREE
    1203                 :        931 :               && info.first_arg_num == 0
    1204                 :        197 :               && (format_types[info.format_type].flags
    1205                 :        197 :                   & (int) FMT_FLAG_ARG_CONVERT)
    1206                 :            :               /* c_strlen will fail for a function parameter but succeed
    1207                 :            :                  for a literal or constant array.  */
    1208                 :      31917 :               && !c_strlen (argarray[info.format_num - 1], 1))
    1209                 :            :             {
    1210                 :        187 :               tree c;
    1211                 :        343 :               for (c = TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl));
    1212                 :        343 :                    c;
    1213                 :        156 :                    c = TREE_CHAIN (c))
    1214                 :        318 :                 if (is_attribute_p ("format", TREE_PURPOSE (c))
    1215                 :        318 :                     && (decode_format_type (IDENTIFIER_POINTER
    1216                 :            :                                             (TREE_VALUE (TREE_VALUE (c))))
    1217                 :        162 :                         == info.format_type))
    1218                 :            :                   break;
    1219                 :        187 :               if (c == NULL_TREE)
    1220                 :            :                 {
    1221                 :            :                   /* Check if the current function has a parameter to which
    1222                 :            :                      the format attribute could be attached; if not, it
    1223                 :            :                      can't be a candidate for a format attribute, despite
    1224                 :            :                      the vprintf-like or vscanf-like call.  */
    1225                 :         25 :                   tree args;
    1226                 :         25 :                   for (args = DECL_ARGUMENTS (current_function_decl);
    1227                 :         25 :                        args != 0;
    1228                 :          0 :                        args = DECL_CHAIN (args))
    1229                 :            :                     {
    1230                 :         25 :                       if (TREE_CODE (TREE_TYPE (args)) == POINTER_TYPE
    1231                 :         25 :                           && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (args)))
    1232                 :         25 :                               == char_type_node))
    1233                 :            :                         break;
    1234                 :            :                     }
    1235                 :         25 :                   if (args != 0)
    1236                 :         25 :                     warning (OPT_Wsuggest_attribute_format, "function %qD "
    1237                 :            :                              "might be a candidate for %qs format attribute",
    1238                 :            :                              current_function_decl,
    1239                 :         25 :                              format_types[info.format_type].name);
    1240                 :            :                 }
    1241                 :            :             }
    1242                 :            :         }
    1243                 :            :     }
    1244                 :    2277250 : }
    1245                 :            : 
    1246                 :            : 
    1247                 :            : /* Variables used by the checking of $ operand number formats.  */
    1248                 :            : static char *dollar_arguments_used = NULL;
    1249                 :            : static char *dollar_arguments_pointer_p = NULL;
    1250                 :            : static int dollar_arguments_alloc = 0;
    1251                 :            : static int dollar_arguments_count;
    1252                 :            : static int dollar_first_arg_num;
    1253                 :            : static int dollar_max_arg_used;
    1254                 :            : static int dollar_format_warned;
    1255                 :            : 
    1256                 :            : /* Initialize the checking for a format string that may contain $
    1257                 :            :    parameter number specifications; we will need to keep track of whether
    1258                 :            :    each parameter has been used.  FIRST_ARG_NUM is the number of the first
    1259                 :            :    argument that is a parameter to the format, or 0 for a vprintf-style
    1260                 :            :    function; PARAMS is the list of arguments starting at this argument.  */
    1261                 :            : 
    1262                 :            : static void
    1263                 :      26682 : init_dollar_format_checking (int first_arg_num, tree params)
    1264                 :            : {
    1265                 :      26682 :   tree oparams = params;
    1266                 :            : 
    1267                 :      26682 :   dollar_first_arg_num = first_arg_num;
    1268                 :      26682 :   dollar_arguments_count = 0;
    1269                 :      26682 :   dollar_max_arg_used = 0;
    1270                 :      26682 :   dollar_format_warned = 0;
    1271                 :      26682 :   if (first_arg_num > 0)
    1272                 :            :     {
    1273                 :      64613 :       while (params)
    1274                 :            :         {
    1275                 :      38859 :           dollar_arguments_count++;
    1276                 :      38859 :           params = TREE_CHAIN (params);
    1277                 :            :         }
    1278                 :            :     }
    1279                 :      26682 :   if (dollar_arguments_alloc < dollar_arguments_count)
    1280                 :            :     {
    1281                 :       3391 :       free (dollar_arguments_used);
    1282                 :       3391 :       free (dollar_arguments_pointer_p);
    1283                 :       3391 :       dollar_arguments_alloc = dollar_arguments_count;
    1284                 :       3391 :       dollar_arguments_used = XNEWVEC (char, dollar_arguments_alloc);
    1285                 :       3391 :       dollar_arguments_pointer_p = XNEWVEC (char, dollar_arguments_alloc);
    1286                 :            :     }
    1287                 :      26682 :   if (dollar_arguments_alloc)
    1288                 :            :     {
    1289                 :      24334 :       memset (dollar_arguments_used, 0, dollar_arguments_alloc);
    1290                 :      24334 :       if (first_arg_num > 0)
    1291                 :            :         {
    1292                 :            :           int i = 0;
    1293                 :            :           params = oparams;
    1294                 :      62785 :           while (params)
    1295                 :            :             {
    1296                 :      38859 :               dollar_arguments_pointer_p[i] = (TREE_CODE (TREE_TYPE (TREE_VALUE (params)))
    1297                 :      38859 :                                                == POINTER_TYPE);
    1298                 :      38859 :               params = TREE_CHAIN (params);
    1299                 :      38859 :               i++;
    1300                 :            :             }
    1301                 :            :         }
    1302                 :            :     }
    1303                 :      26682 : }
    1304                 :            : 
    1305                 :            : 
    1306                 :            : /* Look for a decimal number followed by a $ in *FORMAT.  If DOLLAR_NEEDED
    1307                 :            :    is set, it is an error if one is not found; otherwise, it is OK.  If
    1308                 :            :    such a number is found, check whether it is within range and mark that
    1309                 :            :    numbered operand as being used for later checking.  Returns the operand
    1310                 :            :    number if found and within range, zero if no such number was found and
    1311                 :            :    this is OK, or -1 on error.  PARAMS points to the first operand of the
    1312                 :            :    format; PARAM_PTR is made to point to the parameter referred to.  If
    1313                 :            :    a $ format is found, *FORMAT is updated to point just after it.  */
    1314                 :            : 
    1315                 :            : static int
    1316                 :      20916 : maybe_read_dollar_number (const char **format,
    1317                 :            :                           int dollar_needed, tree params, tree *param_ptr,
    1318                 :            :                           const format_kind_info *fki)
    1319                 :            : {
    1320                 :      20916 :   int argnum;
    1321                 :      20916 :   int overflow_flag;
    1322                 :      20916 :   const char *fcp = *format;
    1323                 :      20916 :   if (!ISDIGIT (*fcp))
    1324                 :            :     {
    1325                 :      20188 :       if (dollar_needed)
    1326                 :            :         {
    1327                 :          2 :           warning (OPT_Wformat_, "missing $ operand number in format");
    1328                 :          2 :           return -1;
    1329                 :            :         }
    1330                 :            :       else
    1331                 :            :         return 0;
    1332                 :            :     }
    1333                 :            :   argnum = 0;
    1334                 :            :   overflow_flag = 0;
    1335                 :       2236 :   while (ISDIGIT (*fcp))
    1336                 :            :     {
    1337                 :       1508 :       HOST_WIDE_INT nargnum
    1338                 :       1508 :         = HOST_WIDE_INT_UC (10) * argnum + (*fcp - '0');
    1339                 :       1508 :       if ((int) nargnum != nargnum)
    1340                 :         30 :         overflow_flag = 1;
    1341                 :       1508 :       argnum = nargnum;
    1342                 :       1508 :       fcp++;
    1343                 :            :     }
    1344                 :        728 :   if (*fcp != '$')
    1345                 :            :     {
    1346                 :        531 :       if (dollar_needed)
    1347                 :            :         {
    1348                 :          0 :           warning (OPT_Wformat_, "missing $ operand number in format");
    1349                 :          0 :           return -1;
    1350                 :            :         }
    1351                 :            :       else
    1352                 :            :         return 0;
    1353                 :            :     }
    1354                 :        197 :   *format = fcp + 1;
    1355                 :        197 :   if (pedantic && !dollar_format_warned)
    1356                 :            :     {
    1357                 :          4 :       warning (OPT_Wformat_, "%s does not support %%n$ operand number formats",
    1358                 :          4 :                C_STD_NAME (STD_EXT));
    1359                 :          4 :       dollar_format_warned = 1;
    1360                 :            :     }
    1361                 :        197 :   if (overflow_flag || argnum == 0
    1362                 :        195 :       || (dollar_first_arg_num && argnum > dollar_arguments_count))
    1363                 :            :     {
    1364                 :          6 :       warning (OPT_Wformat_, "operand number out of range in format");
    1365                 :          6 :       return -1;
    1366                 :            :     }
    1367                 :        191 :   if (argnum > dollar_max_arg_used)
    1368                 :        109 :     dollar_max_arg_used = argnum;
    1369                 :            :   /* For vprintf-style functions we may need to allocate more memory to
    1370                 :            :      track which arguments are used.  */
    1371                 :        191 :   while (dollar_arguments_alloc < dollar_max_arg_used)
    1372                 :            :     {
    1373                 :          0 :       int nalloc;
    1374                 :          0 :       nalloc = 2 * dollar_arguments_alloc + 16;
    1375                 :          0 :       dollar_arguments_used = XRESIZEVEC (char, dollar_arguments_used,
    1376                 :            :                                           nalloc);
    1377                 :          0 :       dollar_arguments_pointer_p = XRESIZEVEC (char, dollar_arguments_pointer_p,
    1378                 :            :                                                nalloc);
    1379                 :          0 :       memset (dollar_arguments_used + dollar_arguments_alloc, 0,
    1380                 :          0 :               nalloc - dollar_arguments_alloc);
    1381                 :          0 :       dollar_arguments_alloc = nalloc;
    1382                 :            :     }
    1383                 :        191 :   if (!(fki->flags & (int) FMT_FLAG_DOLLAR_MULTIPLE)
    1384                 :         64 :       && dollar_arguments_used[argnum - 1] == 1)
    1385                 :            :     {
    1386                 :          2 :       dollar_arguments_used[argnum - 1] = 2;
    1387                 :          2 :       warning (OPT_Wformat_, "format argument %d used more than once in %s format",
    1388                 :          2 :                argnum, fki->name);
    1389                 :            :     }
    1390                 :            :   else
    1391                 :        189 :     dollar_arguments_used[argnum - 1] = 1;
    1392                 :        191 :   if (dollar_first_arg_num)
    1393                 :            :     {
    1394                 :        175 :       int i;
    1395                 :        175 :       *param_ptr = params;
    1396                 :        344 :       for (i = 1; i < argnum && *param_ptr != 0; i++)
    1397                 :        169 :         *param_ptr = TREE_CHAIN (*param_ptr);
    1398                 :            : 
    1399                 :            :       /* This case shouldn't be caught here.  */
    1400                 :        175 :       gcc_assert (*param_ptr);
    1401                 :            :     }
    1402                 :            :   else
    1403                 :         16 :     *param_ptr = 0;
    1404                 :            :   return argnum;
    1405                 :            : }
    1406                 :            : 
    1407                 :            : /* Ensure that FORMAT does not start with a decimal number followed by
    1408                 :            :    a $; give a diagnostic and return true if it does, false otherwise.  */
    1409                 :            : 
    1410                 :            : static bool
    1411                 :      17373 : avoid_dollar_number (const char *format)
    1412                 :            : {
    1413                 :      17373 :   if (!ISDIGIT (*format))
    1414                 :            :     return false;
    1415                 :        969 :   while (ISDIGIT (*format))
    1416                 :        650 :     format++;
    1417                 :        319 :   if (*format == '$')
    1418                 :            :     {
    1419                 :          8 :       warning (OPT_Wformat_,
    1420                 :            :                "%<$%>operand number used after format without operand number");
    1421                 :          8 :       return true;
    1422                 :            :     }
    1423                 :            :   return false;
    1424                 :            : }
    1425                 :            : 
    1426                 :            : 
    1427                 :            : /* Finish the checking for a format string that used $ operand number formats
    1428                 :            :    instead of non-$ formats.  We check for unused operands before used ones
    1429                 :            :    (a serious error, since the implementation of the format function
    1430                 :            :    can't know what types to pass to va_arg to find the later arguments).
    1431                 :            :    and for unused operands at the end of the format (if we know how many
    1432                 :            :    arguments the format had, so not for vprintf).  If there were operand
    1433                 :            :    numbers out of range on a non-vprintf-style format, we won't have reached
    1434                 :            :    here.  If POINTER_GAP_OK, unused arguments are OK if all arguments are
    1435                 :            :    pointers.  */
    1436                 :            : 
    1437                 :            : static void
    1438                 :         80 : finish_dollar_format_checking (format_check_results *res, int pointer_gap_ok)
    1439                 :            : {
    1440                 :         80 :   int i;
    1441                 :         80 :   bool found_pointer_gap = false;
    1442                 :        273 :   for (i = 0; i < dollar_max_arg_used; i++)
    1443                 :            :     {
    1444                 :        193 :       if (!dollar_arguments_used[i])
    1445                 :            :         {
    1446                 :         25 :           if (pointer_gap_ok && (dollar_first_arg_num == 0
    1447                 :         12 :                                  || dollar_arguments_pointer_p[i]))
    1448                 :            :             found_pointer_gap = true;
    1449                 :            :           else
    1450                 :         13 :             warning_at (res->format_string_loc, OPT_Wformat_,
    1451                 :            :                         "format argument %d unused before used argument %d "
    1452                 :            :                         "in %<$%>-style format",
    1453                 :            :                         i + 1, dollar_max_arg_used);
    1454                 :            :         }
    1455                 :            :     }
    1456                 :         80 :   if (found_pointer_gap
    1457                 :         68 :       || (dollar_first_arg_num
    1458                 :         68 :           && dollar_max_arg_used < dollar_arguments_count))
    1459                 :            :     {
    1460                 :         18 :       res->number_other--;
    1461                 :         18 :       res->number_dollar_extra_args++;
    1462                 :            :     }
    1463                 :         80 : }
    1464                 :            : 
    1465                 :            : 
    1466                 :            : /* Retrieve the specification for a format flag.  SPEC contains the
    1467                 :            :    specifications for format flags for the applicable kind of format.
    1468                 :            :    FLAG is the flag in question.  If PREDICATES is NULL, the basic
    1469                 :            :    spec for that flag must be retrieved and must exist.  If
    1470                 :            :    PREDICATES is not NULL, it is a string listing possible predicates
    1471                 :            :    for the spec entry; if an entry predicated on any of these is
    1472                 :            :    found, it is returned, otherwise NULL is returned.  */
    1473                 :            : 
    1474                 :            : static const format_flag_spec *
    1475                 :      28184 : get_flag_spec (const format_flag_spec *spec, int flag, const char *predicates)
    1476                 :            : {
    1477                 :      28184 :   int i;
    1478                 :     225021 :   for (i = 0; spec[i].flag_char != 0; i++)
    1479                 :            :     {
    1480                 :     224111 :       if (spec[i].flag_char != flag)
    1481                 :     195831 :         continue;
    1482                 :      28280 :       if (predicates != NULL)
    1483                 :            :         {
    1484                 :       1026 :           if (spec[i].predicate != 0
    1485                 :         96 :               && strchr (predicates, spec[i].predicate) != 0)
    1486                 :         20 :             return &spec[i];
    1487                 :            :         }
    1488                 :      27254 :       else if (spec[i].predicate == 0)
    1489                 :      27254 :         return &spec[i];
    1490                 :            :     }
    1491                 :        910 :   gcc_assert (predicates);
    1492                 :            :   return NULL;
    1493                 :            : }
    1494                 :            : 
    1495                 :            : 
    1496                 :            : /* Check the argument list of a call to printf, scanf, etc.
    1497                 :            :    INFO points to the function_format_info structure.
    1498                 :            :    PARAMS is the list of argument values.  */
    1499                 :            : 
    1500                 :            : static void
    1501                 :      31677 : check_format_info (function_format_info *info, tree params,
    1502                 :            :                    vec<location_t> *arglocs)
    1503                 :            : {
    1504                 :      31677 :   format_check_context format_ctx;
    1505                 :      31677 :   unsigned HOST_WIDE_INT arg_num;
    1506                 :      31677 :   tree format_tree;
    1507                 :      31677 :   format_check_results res;
    1508                 :            :   /* Skip to format argument.  If the argument isn't available, there's
    1509                 :            :      no work for us to do; prototype checking will catch the problem.  */
    1510                 :      31677 :   for (arg_num = 1; ; ++arg_num)
    1511                 :            :     {
    1512                 :      49893 :       if (params == 0)
    1513                 :          0 :         return;
    1514                 :      49893 :       if (arg_num == info->format_num)
    1515                 :            :         break;
    1516                 :      18216 :       params = TREE_CHAIN (params);
    1517                 :            :     }
    1518                 :      31677 :   format_tree = TREE_VALUE (params);
    1519                 :      31677 :   params = TREE_CHAIN (params);
    1520                 :      31677 :   if (format_tree == 0)
    1521                 :            :     return;
    1522                 :            : 
    1523                 :      31677 :   res.number_non_literal = 0;
    1524                 :      31677 :   res.number_extra_args = 0;
    1525                 :      31677 :   res.extra_arg_loc = UNKNOWN_LOCATION;
    1526                 :      31677 :   res.number_dollar_extra_args = 0;
    1527                 :      31677 :   res.number_wide = 0;
    1528                 :      31677 :   res.number_non_char = 0;
    1529                 :      31677 :   res.number_empty = 0;
    1530                 :      31677 :   res.number_unterminated = 0;
    1531                 :      31677 :   res.number_other = 0;
    1532                 :      31677 :   res.format_string_loc = input_location;
    1533                 :            : 
    1534                 :      31677 :   format_ctx.res = &res;
    1535                 :      31677 :   format_ctx.info = info;
    1536                 :      31677 :   format_ctx.params = params;
    1537                 :      31677 :   format_ctx.arglocs = arglocs;
    1538                 :            : 
    1539                 :      31677 :   check_function_arguments_recurse (check_format_arg, &format_ctx,
    1540                 :            :                                     format_tree, arg_num);
    1541                 :            : 
    1542                 :      31677 :   location_t loc = format_ctx.res->format_string_loc;
    1543                 :            : 
    1544                 :      31677 :   if (res.number_non_literal > 0)
    1545                 :            :     {
    1546                 :            :       /* Functions taking a va_list normally pass a non-literal format
    1547                 :            :          string.  These functions typically are declared with
    1548                 :            :          first_arg_num == 0, so avoid warning in those cases.  */
    1549                 :       4992 :       if (!(format_types[info->format_type].flags & (int) FMT_FLAG_ARG_CONVERT))
    1550                 :            :         {
    1551                 :            :           /* For strftime-like formats, warn for not checking the format
    1552                 :            :              string; but there are no arguments to check.  */
    1553                 :          2 :           warning_at (loc, OPT_Wformat_nonliteral,
    1554                 :            :                       "format not a string literal, format string not checked");
    1555                 :            :         }
    1556                 :       4990 :       else if (info->first_arg_num != 0)
    1557                 :            :         {
    1558                 :            :           /* If there are no arguments for the format at all, we may have
    1559                 :            :              printf (foo) which is likely to be a security hole.  */
    1560                 :        155 :           while (arg_num + 1 < info->first_arg_num)
    1561                 :            :             {
    1562                 :          0 :               if (params == 0)
    1563                 :            :                 break;
    1564                 :          0 :               params = TREE_CHAIN (params);
    1565                 :          0 :               ++arg_num;
    1566                 :            :             }
    1567                 :        155 :           if (params == 0 && warn_format_security)
    1568                 :          9 :             warning_at (loc, OPT_Wformat_security,
    1569                 :            :                         "format not a string literal and no format arguments");
    1570                 :        146 :           else if (params == 0 && warn_format_nonliteral)
    1571                 :          0 :             warning_at (loc, OPT_Wformat_nonliteral,
    1572                 :            :                         "format not a string literal and no format arguments");
    1573                 :            :           else
    1574                 :        146 :             warning_at (loc, OPT_Wformat_nonliteral,
    1575                 :            :                         "format not a string literal, argument types not checked");
    1576                 :            :         }
    1577                 :            :     }
    1578                 :            : 
    1579                 :            :   /* If there were extra arguments to the format, normally warn.  However,
    1580                 :            :      the standard does say extra arguments are ignored, so in the specific
    1581                 :            :      case where we have multiple leaves (conditional expressions or
    1582                 :            :      ngettext) allow extra arguments if at least one leaf didn't have extra
    1583                 :            :      arguments, but was otherwise OK (either non-literal or checked OK).
    1584                 :            :      If the format is an empty string, this should be counted similarly to the
    1585                 :            :      case of extra format arguments.  */
    1586                 :      31677 :   if (res.number_extra_args > 0 && res.number_non_literal == 0
    1587                 :        215 :       && res.number_other == 0)
    1588                 :            :     {
    1589                 :        201 :       if (res.extra_arg_loc == UNKNOWN_LOCATION)
    1590                 :        191 :         res.extra_arg_loc = loc;
    1591                 :        201 :       warning_at (res.extra_arg_loc, OPT_Wformat_extra_args,
    1592                 :            :                   "too many arguments for format");
    1593                 :            :     }
    1594                 :      31677 :   if (res.number_dollar_extra_args > 0 && res.number_non_literal == 0
    1595                 :         18 :       && res.number_other == 0)
    1596                 :         18 :     warning_at (loc, OPT_Wformat_extra_args,
    1597                 :            :                 "unused arguments in %<$%>-style format");
    1598                 :      31677 :   if (res.number_empty > 0 && res.number_non_literal == 0
    1599                 :         25 :       && res.number_other == 0)
    1600                 :         21 :     warning_at (loc, OPT_Wformat_zero_length, "zero-length %s format string",
    1601                 :         21 :              format_types[info->format_type].name);
    1602                 :            : 
    1603                 :      31677 :   if (res.number_wide > 0)
    1604                 :         11 :     warning_at (loc, OPT_Wformat_, "format is a wide character string");
    1605                 :            : 
    1606                 :      31677 :   if (res.number_non_char > 0)
    1607                 :          5 :     warning_at (loc, OPT_Wformat_,
    1608                 :            :                 "format string is not an array of type %qs", "char");
    1609                 :            : 
    1610                 :      31677 :   if (res.number_unterminated > 0)
    1611                 :          6 :     warning_at (loc, OPT_Wformat_, "unterminated format string");
    1612                 :            : }
    1613                 :            : 
    1614                 :            : /* Callback from check_function_arguments_recurse to check a
    1615                 :            :    format string.  FORMAT_TREE is the format parameter.  ARG_NUM
    1616                 :            :    is the number of the format argument.  CTX points to a
    1617                 :            :    format_check_context.  */
    1618                 :            : 
    1619                 :            : static void
    1620                 :      31747 : check_format_arg (void *ctx, tree format_tree,
    1621                 :            :                   unsigned HOST_WIDE_INT arg_num)
    1622                 :            : {
    1623                 :      31747 :   format_check_context *format_ctx = (format_check_context *) ctx;
    1624                 :      31747 :   format_check_results *res = format_ctx->res;
    1625                 :      31747 :   function_format_info *info = format_ctx->info;
    1626                 :      31747 :   tree params = format_ctx->params;
    1627                 :      31747 :   vec<location_t> *arglocs = format_ctx->arglocs;
    1628                 :            : 
    1629                 :      31747 :   int format_length;
    1630                 :      31747 :   HOST_WIDE_INT offset;
    1631                 :      31747 :   const char *format_chars;
    1632                 :      31747 :   tree array_size = 0;
    1633                 :      31747 :   tree array_init;
    1634                 :            : 
    1635                 :      31747 :   location_t fmt_param_loc = EXPR_LOC_OR_LOC (format_tree, input_location);
    1636                 :            : 
    1637                 :            :   /* Pull out a constant value if the front end didn't, and handle location
    1638                 :            :      wrappers.  */
    1639                 :      31747 :   format_tree = fold_for_warn (format_tree);
    1640                 :      31747 :   STRIP_NOPS (format_tree);
    1641                 :            : 
    1642                 :      31747 :   if (integer_zerop (format_tree))
    1643                 :            :     {
    1644                 :            :       /* Skip to first argument to check, so we can see if this format
    1645                 :            :          has any arguments (it shouldn't).  */
    1646                 :         26 :       while (arg_num + 1 < info->first_arg_num)
    1647                 :            :         {
    1648                 :          0 :           if (params == 0)
    1649                 :       5065 :             return;
    1650                 :          0 :           params = TREE_CHAIN (params);
    1651                 :          0 :           ++arg_num;
    1652                 :            :         }
    1653                 :            : 
    1654                 :         26 :       if (params == 0)
    1655                 :         16 :         res->number_other++;
    1656                 :            :       else 
    1657                 :            :         {
    1658                 :         10 :           if (res->number_extra_args == 0)
    1659                 :         12 :             res->extra_arg_loc = EXPR_LOC_OR_LOC (TREE_VALUE (params),
    1660                 :            :                                                   input_location);
    1661                 :         10 :           res->number_extra_args++;
    1662                 :            :         }
    1663                 :         26 :       return;
    1664                 :            :     }
    1665                 :            : 
    1666                 :      31721 :   offset = 0;
    1667                 :      31721 :   if (TREE_CODE (format_tree) == POINTER_PLUS_EXPR)
    1668                 :            :     {
    1669                 :         30 :       tree arg0, arg1;
    1670                 :            : 
    1671                 :         30 :       arg0 = TREE_OPERAND (format_tree, 0);
    1672                 :         30 :       arg1 = TREE_OPERAND (format_tree, 1);
    1673                 :         30 :       STRIP_NOPS (arg0);
    1674                 :         30 :       STRIP_NOPS (arg1);
    1675                 :         30 :       if (TREE_CODE (arg1) == INTEGER_CST)
    1676                 :         28 :         format_tree = arg0;
    1677                 :            :       else
    1678                 :            :         {
    1679                 :          2 :           res->number_non_literal++;
    1680                 :          2 :           return;
    1681                 :            :         }
    1682                 :            :       /* POINTER_PLUS_EXPR offsets are to be interpreted signed.  */
    1683                 :         28 :       if (!cst_and_fits_in_hwi (arg1))
    1684                 :            :         {
    1685                 :          0 :           res->number_non_literal++;
    1686                 :          0 :           return;
    1687                 :            :         }
    1688                 :         28 :       offset = int_cst_value (arg1);
    1689                 :            :     }
    1690                 :      31719 :   if (TREE_CODE (format_tree) != ADDR_EXPR)
    1691                 :            :     {
    1692                 :       4963 :       res->number_non_literal++;
    1693                 :       4963 :       return;
    1694                 :            :     }
    1695                 :      26756 :   res->format_string_loc = EXPR_LOC_OR_LOC (format_tree, input_location);
    1696                 :      26756 :   format_tree = TREE_OPERAND (format_tree, 0);
    1697                 :      26756 :   if (format_types[info->format_type].flags 
    1698                 :      26756 :       & (int) FMT_FLAG_PARSE_ARG_CONVERT_EXTERNAL)
    1699                 :            :     {
    1700                 :          0 :       bool objc_str = (info->format_type == gcc_objc_string_format_type);
    1701                 :            :       /* We cannot examine this string here - but we can check that it is
    1702                 :            :          a valid type.  */
    1703                 :          0 :       if (TREE_CODE (format_tree) != CONST_DECL
    1704                 :          0 :           || !((objc_str && objc_string_ref_type_p (TREE_TYPE (format_tree)))
    1705                 :          0 :                 || (*targetcm.string_object_ref_type_p) 
    1706                 :          0 :                                      ((const_tree) TREE_TYPE (format_tree))))
    1707                 :            :         {
    1708                 :          0 :           res->number_non_literal++;
    1709                 :          0 :           return;
    1710                 :            :         }
    1711                 :            :       /* Skip to first argument to check.  */
    1712                 :          0 :       while (arg_num + 1 < info->first_arg_num)
    1713                 :            :         {
    1714                 :          0 :           if (params == 0)
    1715                 :            :             return;
    1716                 :          0 :           params = TREE_CHAIN (params);
    1717                 :          0 :           ++arg_num;
    1718                 :            :         }
    1719                 :            :       /* So, we have a valid literal string object and one or more params.
    1720                 :            :          We need to use an external helper to parse the string into format
    1721                 :            :          info.  For Objective-C variants we provide the resource within the
    1722                 :            :          objc tree, for target variants, via a hook.  */
    1723                 :          0 :       if (objc_str)
    1724                 :          0 :         objc_check_format_arg (format_tree, params);
    1725                 :          0 :       else if (targetcm.check_string_object_format_arg)
    1726                 :          0 :         (*targetcm.check_string_object_format_arg) (format_tree, params);
    1727                 :            :       /* Else we can't handle it and retire quietly.  */
    1728                 :          0 :       return;
    1729                 :            :     }
    1730                 :      26756 :   if (TREE_CODE (format_tree) == ARRAY_REF
    1731                 :         16 :       && tree_fits_shwi_p (TREE_OPERAND (format_tree, 1))
    1732                 :      26772 :       && (offset += tree_to_shwi (TREE_OPERAND (format_tree, 1))) >= 0)
    1733                 :         16 :     format_tree = TREE_OPERAND (format_tree, 0);
    1734                 :      26756 :   if (offset < 0)
    1735                 :            :     {
    1736                 :          4 :       res->number_non_literal++;
    1737                 :          4 :       return;
    1738                 :            :     }
    1739                 :      26752 :   if (VAR_P (format_tree)
    1740                 :         75 :       && TREE_CODE (TREE_TYPE (format_tree)) == ARRAY_TYPE
    1741                 :         75 :       && (array_init = decl_constant_value (format_tree)) != format_tree
    1742                 :      26806 :       && TREE_CODE (array_init) == STRING_CST)
    1743                 :            :     {
    1744                 :            :       /* Extract the string constant initializer.  Note that this may include
    1745                 :            :          a trailing NUL character that is not in the array (e.g.
    1746                 :            :          const char a[3] = "foo";).  */
    1747                 :         54 :       array_size = DECL_SIZE_UNIT (format_tree);
    1748                 :         54 :       format_tree = array_init;
    1749                 :            :     }
    1750                 :      26752 :   if (TREE_CODE (format_tree) != STRING_CST)
    1751                 :            :     {
    1752                 :         21 :       res->number_non_literal++;
    1753                 :         21 :       return;
    1754                 :            :     }
    1755                 :      26731 :   tree underlying_type
    1756                 :      26731 :     = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (format_tree)));
    1757                 :      26731 :   if (underlying_type != char_type_node)
    1758                 :            :     {
    1759                 :         16 :       if (underlying_type == char16_type_node
    1760                 :         16 :           || underlying_type == char32_type_node
    1761                 :         16 :           || underlying_type == wchar_type_node)
    1762                 :         11 :         res->number_wide++;
    1763                 :            :       else
    1764                 :          5 :         res->number_non_char++;
    1765                 :         16 :       return;
    1766                 :            :     }
    1767                 :      26715 :   format_chars = TREE_STRING_POINTER (format_tree);
    1768                 :      26715 :   format_length = TREE_STRING_LENGTH (format_tree);
    1769                 :      26715 :   if (array_size != 0)
    1770                 :            :     {
    1771                 :            :       /* Variable length arrays can't be initialized.  */
    1772                 :         49 :       gcc_assert (TREE_CODE (array_size) == INTEGER_CST);
    1773                 :            : 
    1774                 :         49 :       if (tree_fits_shwi_p (array_size))
    1775                 :            :         {
    1776                 :         49 :           HOST_WIDE_INT array_size_value = tree_to_shwi (array_size);
    1777                 :         49 :           if (array_size_value > 0
    1778                 :         49 :               && array_size_value == (int) array_size_value
    1779                 :         49 :               && format_length > array_size_value)
    1780                 :          0 :             format_length = array_size_value;
    1781                 :            :         }
    1782                 :            :     }
    1783                 :      26715 :   if (offset)
    1784                 :            :     {
    1785                 :         34 :       if (offset >= format_length)
    1786                 :            :         {
    1787                 :          2 :           res->number_non_literal++;
    1788                 :          2 :           return;
    1789                 :            :         }
    1790                 :         32 :       format_chars += offset;
    1791                 :         32 :       format_length -= offset;
    1792                 :            :     }
    1793                 :      26713 :   if (format_length < 1 || format_chars[--format_length] != 0)
    1794                 :            :     {
    1795                 :          6 :       res->number_unterminated++;
    1796                 :          6 :       return;
    1797                 :            :     }
    1798                 :      26707 :   if (format_length == 0)
    1799                 :            :     {
    1800                 :         25 :       res->number_empty++;
    1801                 :         25 :       return;
    1802                 :            :     }
    1803                 :            : 
    1804                 :            :   /* Skip to first argument to check.  */
    1805                 :      26684 :   while (arg_num + 1 < info->first_arg_num)
    1806                 :            :     {
    1807                 :          2 :       if (params == 0)
    1808                 :            :         return;
    1809                 :          2 :       params = TREE_CHAIN (params);
    1810                 :          2 :       ++arg_num;
    1811                 :            :     }
    1812                 :            :   /* Provisionally increment res->number_other; check_format_info_main
    1813                 :            :      will decrement it if it finds there are extra arguments, but this way
    1814                 :            :      need not adjust it for every return.  */
    1815                 :      26682 :   res->number_other++;
    1816                 :      53364 :   object_allocator <format_wanted_type> fwt_pool ("format_wanted_type pool");
    1817                 :      26682 :   check_format_info_main (res, info, format_chars, fmt_param_loc, format_tree,
    1818                 :            :                           format_length, params, arg_num, fwt_pool, arglocs);
    1819                 :            : }
    1820                 :            : 
    1821                 :            : /* Support class for argument_parser and check_format_info_main.
    1822                 :            :    Tracks any flag characters that have been applied to the
    1823                 :            :    current argument.  */
    1824                 :            : 
    1825                 :            : class flag_chars_t
    1826                 :            : {
    1827                 :            :  public:
    1828                 :            :   flag_chars_t ();
    1829                 :            :   bool has_char_p (char ch) const;
    1830                 :            :   void add_char (char ch);
    1831                 :            :   void validate (const format_kind_info *fki,
    1832                 :            :                  const format_char_info *fci,
    1833                 :            :                  const format_flag_spec *flag_specs,
    1834                 :            :                  const char * const format_chars,
    1835                 :            :                  tree format_string_cst,
    1836                 :            :                  location_t format_string_loc,
    1837                 :            :                  const char * const orig_format_chars,
    1838                 :            :                  char format_char,
    1839                 :            :                  bool quoted);
    1840                 :            :   int get_alloc_flag (const format_kind_info *fki);
    1841                 :            :   int assignment_suppression_p (const format_kind_info *fki);
    1842                 :            : 
    1843                 :            :  private:
    1844                 :            :   char m_flag_chars[256];
    1845                 :            : };
    1846                 :            : 
    1847                 :            : /* Support struct for argument_parser and check_format_info_main.
    1848                 :            :    Encapsulates any length modifier applied to the current argument.  */
    1849                 :            : 
    1850                 :            : class length_modifier
    1851                 :            : {
    1852                 :            : public:
    1853                 :      39338 :   length_modifier ()
    1854                 :      39338 :   : chars (NULL), val (FMT_LEN_none), std (STD_C89),
    1855                 :      39338 :     scalar_identity_flag (0)
    1856                 :            :   {
    1857                 :            :   }
    1858                 :            : 
    1859                 :      16530 :   length_modifier (const char *chars_,
    1860                 :            :                    enum format_lengths val_,
    1861                 :            :                    enum format_std_version std_,
    1862                 :            :                    int scalar_identity_flag_)
    1863                 :            :   : chars (chars_), val (val_), std (std_),
    1864                 :            :     scalar_identity_flag (scalar_identity_flag_)
    1865                 :            :   {
    1866                 :            :   }
    1867                 :            : 
    1868                 :            :   const char *chars;
    1869                 :            :   enum format_lengths val;
    1870                 :            :   enum format_std_version std;
    1871                 :            :   int scalar_identity_flag;
    1872                 :            : };
    1873                 :            : 
    1874                 :            : /* Parsing one argument within a format string.  */
    1875                 :            : 
    1876                 :            : class argument_parser
    1877                 :            : {
    1878                 :            :  public:
    1879                 :            :   argument_parser (function_format_info *info, const char *&format_chars,
    1880                 :            :                    tree format_string_cst,
    1881                 :            :                    const char * const orig_format_chars,
    1882                 :            :                    location_t format_string_loc, flag_chars_t &flag_chars,
    1883                 :            :                    int &has_operand_number, tree first_fillin_param,
    1884                 :            :                    object_allocator <format_wanted_type> &fwt_pool_,
    1885                 :            :                    vec<location_t> *arglocs);
    1886                 :            : 
    1887                 :            :   bool read_any_dollar ();
    1888                 :            : 
    1889                 :            :   bool read_format_flags ();
    1890                 :            : 
    1891                 :            :   bool
    1892                 :            :   read_any_format_width (tree &params,
    1893                 :            :                          unsigned HOST_WIDE_INT &arg_num);
    1894                 :            : 
    1895                 :            :   void
    1896                 :            :   read_any_format_left_precision ();
    1897                 :            : 
    1898                 :            :   bool
    1899                 :            :   read_any_format_precision (tree &params,
    1900                 :            :                              unsigned HOST_WIDE_INT &arg_num);
    1901                 :            : 
    1902                 :            :   void handle_alloc_chars ();
    1903                 :            : 
    1904                 :            :   length_modifier read_any_length_modifier ();
    1905                 :            : 
    1906                 :            :   void read_any_other_modifier ();
    1907                 :            : 
    1908                 :            :   const format_char_info *find_format_char_info (char format_char);
    1909                 :            : 
    1910                 :            :   void
    1911                 :            :   validate_flag_pairs (const format_char_info *fci,
    1912                 :            :                        char format_char);
    1913                 :            : 
    1914                 :            :   void
    1915                 :            :   give_y2k_warnings (const format_char_info *fci,
    1916                 :            :                      char format_char);
    1917                 :            : 
    1918                 :            :   void parse_any_scan_set (const format_char_info *fci);
    1919                 :            : 
    1920                 :            :   bool handle_conversions (const format_char_info *fci,
    1921                 :            :                            const length_modifier &len_modifier,
    1922                 :            :                            tree &wanted_type,
    1923                 :            :                            const char *&wanted_type_name,
    1924                 :            :                            unsigned HOST_WIDE_INT &arg_num,
    1925                 :            :                            tree &params,
    1926                 :            :                            char format_char);
    1927                 :            : 
    1928                 :            :   bool
    1929                 :            :   check_argument_type (const format_char_info *fci,
    1930                 :            :                        const length_modifier &len_modifier,
    1931                 :            :                        tree &wanted_type,
    1932                 :            :                        const char *&wanted_type_name,
    1933                 :            :                        const bool suppressed,
    1934                 :            :                        unsigned HOST_WIDE_INT &arg_num,
    1935                 :            :                        tree &params,
    1936                 :            :                        const int alloc_flag,
    1937                 :            :                        const char * const format_start,
    1938                 :            :                        const char * const type_start,
    1939                 :            :                        location_t fmt_param_loc,
    1940                 :            :                        char conversion_char);
    1941                 :            : 
    1942                 :            :  private:
    1943                 :            :   const function_format_info *const info;
    1944                 :            :   const format_kind_info * const fki;
    1945                 :            :   const format_flag_spec * const flag_specs;
    1946                 :            :   const char *start_of_this_format;
    1947                 :            :   const char *&format_chars;
    1948                 :            :   const tree format_string_cst;
    1949                 :            :   const char * const orig_format_chars;
    1950                 :            :   const location_t format_string_loc;
    1951                 :            :   object_allocator <format_wanted_type> &fwt_pool;
    1952                 :            :   flag_chars_t &flag_chars;
    1953                 :            :   int main_arg_num;
    1954                 :            :   tree main_arg_params;
    1955                 :            :   int &has_operand_number;
    1956                 :            :   const tree first_fillin_param;
    1957                 :            :   format_wanted_type width_wanted_type;
    1958                 :            :   format_wanted_type precision_wanted_type;
    1959                 :            :  public:
    1960                 :            :   format_wanted_type main_wanted_type;
    1961                 :            :  private:
    1962                 :            :   format_wanted_type *first_wanted_type;
    1963                 :            :   format_wanted_type *last_wanted_type;
    1964                 :            :   vec<location_t> *arglocs;
    1965                 :            : };
    1966                 :            : 
    1967                 :            : /* flag_chars_t's constructor.  */
    1968                 :            : 
    1969                 :      39356 : flag_chars_t::flag_chars_t ()
    1970                 :            : {
    1971                 :      39356 :   m_flag_chars[0] = 0;
    1972                 :      39356 : }
    1973                 :            : 
    1974                 :            : /* Has CH been seen as a flag within the current argument?  */
    1975                 :            : 
    1976                 :            : bool
    1977                 :     122477 : flag_chars_t::has_char_p (char ch) const
    1978                 :            : {
    1979                 :     122477 :   return strchr (m_flag_chars, ch) != 0;
    1980                 :            : }
    1981                 :            : 
    1982                 :            : /* Add CH to the flags seen within the current argument.  */
    1983                 :            : 
    1984                 :            : void
    1985                 :      23968 : flag_chars_t::add_char (char ch)
    1986                 :            : {
    1987                 :      23968 :   int i = strlen (m_flag_chars);
    1988                 :      23968 :   m_flag_chars[i++] = ch;
    1989                 :      23968 :   m_flag_chars[i] = 0;
    1990                 :      23968 : }
    1991                 :            : 
    1992                 :            : /* Validate the individual flags used, removing any that are invalid.  */
    1993                 :            : 
    1994                 :            : void
    1995                 :      39107 : flag_chars_t::validate (const format_kind_info *fki,
    1996                 :            :                         const format_char_info *fci,
    1997                 :            :                         const format_flag_spec *flag_specs,
    1998                 :            :                         const char * const format_chars,
    1999                 :            :                         tree format_string_cst,
    2000                 :            :                         location_t format_string_loc,
    2001                 :            :                         const char * const orig_format_chars,
    2002                 :            :                         char format_char,
    2003                 :            :                         bool quoted)
    2004                 :            : {
    2005                 :      39107 :   int i;
    2006                 :      39107 :   int d = 0;
    2007                 :      39107 :   bool quotflag = false;
    2008                 :            : 
    2009                 :      63000 :   for (i = 0; m_flag_chars[i] != 0; i++)
    2010                 :            :     {
    2011                 :      23893 :       const format_flag_spec *s = get_flag_spec (flag_specs,
    2012                 :            :                                                  m_flag_chars[i], NULL);
    2013                 :      23893 :       m_flag_chars[i - d] = m_flag_chars[i];
    2014                 :      23893 :       if (m_flag_chars[i] == fki->length_code_char)
    2015                 :      16504 :         continue;
    2016                 :            : 
    2017                 :            :       /* Remember if a quoting flag is seen.  */
    2018                 :       7389 :       quotflag |= s->quoting;
    2019                 :            : 
    2020                 :       7389 :       if (strchr (fci->flag_chars, m_flag_chars[i]) == 0)
    2021                 :            :         {
    2022                 :        778 :           format_warning_at_char (format_string_loc, format_string_cst,
    2023                 :        778 :                                   format_chars - orig_format_chars,
    2024                 :            :                                   OPT_Wformat_,
    2025                 :            :                                   "%s used with %<%%%c%> %s format",
    2026                 :        778 :                                   _(s->name), format_char, fki->name);
    2027                 :        778 :           d++;
    2028                 :        778 :           continue;
    2029                 :            :         }
    2030                 :       6611 :       if (pedantic)
    2031                 :            :         {
    2032                 :        930 :           const format_flag_spec *t;
    2033                 :       1352 :           if (ADJ_STD (s->std) > C_STD_VER)
    2034                 :         42 :             warning_at (format_string_loc, OPT_Wformat_,
    2035                 :            :                         "%s does not support %s",
    2036                 :         42 :                         C_STD_NAME (s->std), _(s->long_name));
    2037                 :        930 :           t = get_flag_spec (flag_specs, m_flag_chars[i], fci->flags2);
    2038                 :        930 :           if (t != NULL && ADJ_STD (t->std) > ADJ_STD (s->std))
    2039                 :            :             {
    2040                 :         20 :               const char *long_name = (t->long_name != NULL
    2041                 :            :                                        ? t->long_name
    2042                 :            :                                        : s->long_name);
    2043                 :         20 :               if (ADJ_STD (t->std) > C_STD_VER)
    2044                 :         16 :                 warning_at (format_string_loc, OPT_Wformat_,
    2045                 :            :                             "%s does not support %s with"
    2046                 :            :                             " the %<%%%c%> %s format",
    2047                 :         16 :                             C_STD_NAME (t->std), _(long_name),
    2048                 :         16 :                             format_char, fki->name);
    2049                 :            :             }
    2050                 :            :         }
    2051                 :            : 
    2052                 :            :       /* Detect quoting directives used within a quoted sequence, such
    2053                 :            :          as GCC's "%<...%qE".  */
    2054                 :       6611 :       if (quoted && s->quoting)
    2055                 :            :         {
    2056                 :         12 :           format_warning_at_char (format_string_loc, format_string_cst,
    2057                 :         12 :                                   format_chars - orig_format_chars - 1,
    2058                 :            :                                   OPT_Wformat_,
    2059                 :            :                                   "%s used within a quoted sequence",
    2060                 :         12 :                                   _(s->name));
    2061                 :            :         }
    2062                 :            :     }
    2063                 :      39107 :   m_flag_chars[i - d] = 0;
    2064                 :            : 
    2065                 :      39107 :   if (!quoted
    2066                 :            :       && !quotflag
    2067                 :      38579 :       && strchr (fci->flags2, '\''))
    2068                 :            :     {
    2069                 :         54 :       format_warning_at_char (format_string_loc, format_string_cst,
    2070                 :         54 :                               format_chars - orig_format_chars,
    2071                 :            :                               OPT_Wformat_,
    2072                 :            :                               "%qc conversion used unquoted",
    2073                 :            :                               format_char);
    2074                 :            :     }
    2075                 :      39107 : }
    2076                 :            : 
    2077                 :            : /* Determine if an assignment-allocation has been set, requiring
    2078                 :            :    an extra char ** for writing back a dynamically-allocated char *.
    2079                 :            :    This is for handling the optional 'm' character in scanf.  */
    2080                 :            : 
    2081                 :            : int
    2082                 :      39107 : flag_chars_t::get_alloc_flag (const format_kind_info *fki)
    2083                 :            : {
    2084                 :      39107 :   if ((fki->flags & (int) FMT_FLAG_SCANF_A_KLUDGE)
    2085                 :      39107 :       && has_char_p ('a'))
    2086                 :            :     return 1;
    2087                 :      39065 :   if (fki->alloc_char && has_char_p (fki->alloc_char))
    2088                 :        148 :     return 1;
    2089                 :            :   return 0;
    2090                 :            : }
    2091                 :            : 
    2092                 :            : /* Determine if an assignment-suppression character was seen.
    2093                 :            :    ('*' in scanf, for discarding the converted input).  */
    2094                 :            : 
    2095                 :            : int
    2096                 :      39107 : flag_chars_t::assignment_suppression_p (const format_kind_info *fki)
    2097                 :            : {
    2098                 :      39107 :   if (fki->suppression_char
    2099                 :      39107 :       && has_char_p (fki->suppression_char))
    2100                 :        178 :     return 1;
    2101                 :            :   return 0;
    2102                 :            : }
    2103                 :            : 
    2104                 :            : /* Constructor for argument_parser.  Initialize for parsing one
    2105                 :            :    argument within a format string.  */
    2106                 :            : 
    2107                 :      39356 : argument_parser::
    2108                 :            : argument_parser (function_format_info *info_, const char *&format_chars_,
    2109                 :            :                  tree format_string_cst_,
    2110                 :            :                  const char * const orig_format_chars_,
    2111                 :            :                  location_t format_string_loc_,
    2112                 :            :                  flag_chars_t &flag_chars_,
    2113                 :            :                  int &has_operand_number_,
    2114                 :            :                  tree first_fillin_param_,
    2115                 :            :                  object_allocator <format_wanted_type> &fwt_pool_,
    2116                 :      39356 :                  vec<location_t> *arglocs_)
    2117                 :            : : info (info_),
    2118                 :      39356 :   fki (&format_types[info->format_type]),
    2119                 :      39356 :   flag_specs (fki->flag_specs),
    2120                 :            :   start_of_this_format (format_chars_),
    2121                 :            :   format_chars (format_chars_),
    2122                 :            :   format_string_cst (format_string_cst_),
    2123                 :            :   orig_format_chars (orig_format_chars_),
    2124                 :            :   format_string_loc (format_string_loc_),
    2125                 :            :   fwt_pool (fwt_pool_),
    2126                 :            :   flag_chars (flag_chars_),
    2127                 :            :   main_arg_num (0),
    2128                 :            :   main_arg_params (NULL),
    2129                 :            :   has_operand_number (has_operand_number_),
    2130                 :            :   first_fillin_param (first_fillin_param_),
    2131                 :            :   first_wanted_type (NULL),
    2132                 :            :   last_wanted_type (NULL),
    2133                 :      39356 :   arglocs (arglocs_)
    2134                 :            : {
    2135                 :      39356 : }
    2136                 :            : 
    2137                 :            : /* Handle dollars at the start of format arguments, setting up main_arg_params
    2138                 :            :    and main_arg_num.
    2139                 :            : 
    2140                 :            :    Return true if format parsing is to continue, false otherwise.  */
    2141                 :            : 
    2142                 :            : bool
    2143                 :      39356 : argument_parser::read_any_dollar ()
    2144                 :            : {
    2145                 :      39356 :   if ((fki->flags & (int) FMT_FLAG_USE_DOLLAR) && has_operand_number != 0)
    2146                 :            :     {
    2147                 :            :       /* Possibly read a $ operand number at the start of the format.
    2148                 :            :          If one was previously used, one is required here.  If one
    2149                 :            :          is not used here, we can't immediately conclude this is a
    2150                 :            :          format without them, since it could be printf %m or scanf %*.  */
    2151                 :      19667 :       int opnum;
    2152                 :      39334 :       opnum = maybe_read_dollar_number (&format_chars, 0,
    2153                 :      19667 :                                         first_fillin_param,
    2154                 :            :                                         &main_arg_params, fki);
    2155                 :      19667 :       if (opnum == -1)
    2156                 :            :         return false;
    2157                 :      19661 :       else if (opnum > 0)
    2158                 :            :         {
    2159                 :        167 :           has_operand_number = 1;
    2160                 :        167 :           main_arg_num = opnum + info->first_arg_num - 1;
    2161                 :            :         }
    2162                 :            :     }
    2163                 :      19689 :   else if (fki->flags & FMT_FLAG_USE_DOLLAR)
    2164                 :            :     {
    2165                 :      17083 :       if (avoid_dollar_number (format_chars))
    2166                 :          4 :         return false;
    2167                 :            :     }
    2168                 :            :   return true;
    2169                 :            : }
    2170                 :            : 
    2171                 :            : /* Read any format flags, but do not yet validate them beyond removing
    2172                 :            :    duplicates, since in general validation depends on the rest of
    2173                 :            :    the format.
    2174                 :            : 
    2175                 :            :    Return true if format parsing is to continue, false otherwise.  */
    2176                 :            : 
    2177                 :            : bool
    2178                 :      39346 : argument_parser::read_format_flags ()
    2179                 :            : {
    2180                 :      42367 :   while (*format_chars != 0
    2181                 :      42367 :          && strchr (fki->flag_chars, *format_chars) != 0)
    2182                 :            :     {
    2183                 :       3023 :       const format_flag_spec *s = get_flag_spec (flag_specs,
    2184                 :            :                                                  *format_chars, NULL);
    2185                 :       3023 :       if (flag_chars.has_char_p (*format_chars))
    2186                 :            :         {
    2187                 :         17 :           format_warning_at_char (format_string_loc, format_string_cst,
    2188                 :         17 :                                   format_chars + 1 - orig_format_chars,
    2189                 :            :                                   OPT_Wformat_,
    2190                 :         17 :                                   "repeated %s in format", _(s->name));
    2191                 :            :         }
    2192                 :            :       else
    2193                 :       3006 :         flag_chars.add_char (*format_chars);
    2194                 :            : 
    2195                 :       3023 :       if (s->skip_next_char)
    2196                 :            :         {
    2197                 :         16 :           ++format_chars;
    2198                 :         16 :           if (*format_chars == 0)
    2199                 :            :             {
    2200                 :          2 :               warning_at (format_string_loc, OPT_Wformat_,
    2201                 :            :                           "missing fill character at end of strfmon format");
    2202                 :          2 :               return false;
    2203                 :            :             }
    2204                 :            :         }
    2205                 :       3021 :       ++format_chars;
    2206                 :            :     }
    2207                 :            : 
    2208                 :            :   return true;
    2209                 :            : }
    2210                 :            : 
    2211                 :            : /* Read any format width, possibly * or *m$.
    2212                 :            : 
    2213                 :            :    Return true if format parsing is to continue, false otherwise.  */
    2214                 :            : 
    2215                 :            : bool
    2216                 :      39344 : argument_parser::
    2217                 :            : read_any_format_width (tree &params,
    2218                 :            :                        unsigned HOST_WIDE_INT &arg_num)
    2219                 :            : {
    2220                 :      39344 :   if (!fki->width_char)
    2221                 :            :     return true;
    2222                 :            : 
    2223                 :      37840 :   if (fki->width_type != NULL && *format_chars == '*')
    2224                 :            :     {
    2225                 :        757 :       flag_chars.add_char (fki->width_char);
    2226                 :            :       /* "...a field width...may be indicated by an asterisk.
    2227                 :            :          In this case, an int argument supplies the field width..."  */
    2228                 :        757 :       ++format_chars;
    2229                 :        757 :       if (has_operand_number != 0)
    2230                 :            :         {
    2231                 :        706 :           int opnum;
    2232                 :       1412 :           opnum = maybe_read_dollar_number (&format_chars,
    2233                 :            :                                             has_operand_number == 1,
    2234                 :        706 :                                             first_fillin_param,
    2235                 :        706 :                                             &params, fki);
    2236                 :        706 :           if (opnum == -1)
    2237                 :            :             return false;
    2238                 :        704 :           else if (opnum > 0)
    2239                 :            :             {
    2240                 :         16 :               has_operand_number = 1;
    2241                 :         16 :               arg_num = opnum + info->first_arg_num - 1;
    2242                 :            :             }
    2243                 :            :           else
    2244                 :        688 :             has_operand_number = 0;
    2245                 :            :         }
    2246                 :            :       else
    2247                 :            :         {
    2248                 :         51 :           if (avoid_dollar_number (format_chars))
    2249                 :            :             return false;
    2250                 :            :         }
    2251                 :        753 :       if (info->first_arg_num != 0)
    2252                 :            :         {
    2253                 :        741 :           tree cur_param;
    2254                 :        741 :           if (params == 0)
    2255                 :            :             cur_param = NULL;
    2256                 :            :           else
    2257                 :            :             {
    2258                 :        739 :               cur_param = TREE_VALUE (params);
    2259                 :        739 :               if (has_operand_number <= 0)
    2260                 :            :                 {
    2261                 :        723 :                   params = TREE_CHAIN (params);
    2262                 :        723 :                   ++arg_num;
    2263                 :            :                 }
    2264                 :            :             }
    2265                 :        741 :           width_wanted_type.wanted_type = *fki->width_type;
    2266                 :        741 :           width_wanted_type.wanted_type_name = NULL;
    2267                 :        741 :           width_wanted_type.pointer_count = 0;
    2268                 :        741 :           width_wanted_type.char_lenient_flag = 0;
    2269                 :        741 :           width_wanted_type.scalar_identity_flag = 0;
    2270                 :        741 :           width_wanted_type.writing_in_flag = 0;
    2271                 :        741 :           width_wanted_type.reading_from_flag = 0;
    2272                 :        741 :           width_wanted_type.kind = CF_KIND_FIELD_WIDTH;
    2273                 :        741 :           width_wanted_type.format_start = format_chars - 1;
    2274                 :        741 :           width_wanted_type.format_length = 1;
    2275                 :        741 :           width_wanted_type.param = cur_param;
    2276                 :        741 :           width_wanted_type.arg_num = arg_num;
    2277                 :        741 :           width_wanted_type.offset_loc =
    2278                 :        741 :             format_chars - orig_format_chars;
    2279                 :        741 :           width_wanted_type.next = NULL;
    2280                 :        741 :           if (last_wanted_type != 0)
    2281                 :          0 :             last_wanted_type->next = &width_wanted_type;
    2282                 :        741 :           if (first_wanted_type == 0)
    2283                 :        741 :             first_wanted_type = &width_wanted_type;
    2284                 :        741 :           last_wanted_type = &width_wanted_type;
    2285                 :            :         }
    2286                 :            :     }
    2287                 :            :   else
    2288                 :            :     {
    2289                 :            :       /* Possibly read a numeric width.  If the width is zero,
    2290                 :            :          we complain if appropriate.  */
    2291                 :            :       int non_zero_width_char = FALSE;
    2292                 :            :       int found_width = FALSE;
    2293                 :      39254 :       while (ISDIGIT (*format_chars))
    2294                 :            :         {
    2295                 :       2171 :           found_width = TRUE;
    2296                 :       2171 :           if (*format_chars != '0')
    2297                 :       2112 :             non_zero_width_char = TRUE;
    2298                 :       2171 :           ++format_chars;
    2299                 :            :         }
    2300                 :      37083 :       if (found_width && !non_zero_width_char &&
    2301                 :          6 :           (fki->flags & (int) FMT_FLAG_ZERO_WIDTH_BAD))
    2302                 :          4 :         warning_at (format_string_loc, OPT_Wformat_,
    2303                 :          4 :                     "zero width in %s format", fki->name);
    2304                 :      37083 :       if (found_width)
    2305                 :       1304 :         flag_chars.add_char (fki->width_char);
    2306                 :            :     }
    2307                 :            : 
    2308                 :            :   return true;
    2309                 :            : }
    2310                 :            : 
    2311                 :            : /* Read any format left precision (must be a number, not *).  */
    2312                 :            : void
    2313                 :      39340 : argument_parser::read_any_format_left_precision ()
    2314                 :            : {
    2315                 :      39340 :   if (fki->left_precision_char == 0)
    2316                 :            :     return;
    2317                 :        118 :   if (*format_chars != '#')
    2318                 :            :     return;
    2319                 :            : 
    2320                 :         60 :   ++format_chars;
    2321                 :         60 :   flag_chars.add_char (fki->left_precision_char);
    2322                 :         60 :   if (!ISDIGIT (*format_chars))
    2323                 :          8 :     format_warning_at_char (format_string_loc, format_string_cst,
    2324                 :          8 :                             format_chars - orig_format_chars,
    2325                 :            :                             OPT_Wformat_,
    2326                 :          8 :                             "empty left precision in %s format", fki->name);
    2327                 :        112 :   while (ISDIGIT (*format_chars))
    2328                 :         52 :     ++format_chars;
    2329                 :            : }
    2330                 :            : 
    2331                 :            : /* Read any format precision, possibly * or *m$.
    2332                 :            : 
    2333                 :            :    Return true if format parsing is to continue, false otherwise.  */
    2334                 :            : 
    2335                 :            : bool
    2336                 :      39340 : argument_parser::
    2337                 :            : read_any_format_precision (tree &params,
    2338                 :            :                            unsigned HOST_WIDE_INT &arg_num)
    2339                 :            : {
    2340                 :      39340 :   if (fki->precision_char == 0)
    2341                 :            :     return true;
    2342                 :      36803 :   if (*format_chars != '.')
    2343                 :            :     return true;
    2344                 :            : 
    2345                 :       1885 :   ++format_chars;
    2346                 :       1885 :   flag_chars.add_char (fki->precision_char);
    2347                 :       1885 :   if (fki->precision_type != NULL && *format_chars == '*')
    2348                 :            :     {
    2349                 :            :       /* "...a...precision...may be indicated by an asterisk.
    2350                 :            :          In this case, an int argument supplies the...precision."  */
    2351                 :        782 :       ++format_chars;
    2352                 :        782 :       if (has_operand_number != 0)
    2353                 :            :         {
    2354                 :        543 :           int opnum;
    2355                 :       1086 :           opnum = maybe_read_dollar_number (&format_chars,
    2356                 :            :                                             has_operand_number == 1,
    2357                 :        543 :                                             first_fillin_param,
    2358                 :            :                                             &params, fki);
    2359                 :        543 :           if (opnum == -1)
    2360                 :            :             return false;
    2361                 :        543 :           else if (opnum > 0)
    2362                 :            :             {
    2363                 :          8 :               has_operand_number = 1;
    2364                 :          8 :               arg_num = opnum + info->first_arg_num - 1;
    2365                 :            :             }
    2366                 :            :           else
    2367                 :        535 :             has_operand_number = 0;
    2368                 :            :         }
    2369                 :            :       else
    2370                 :            :         {
    2371                 :        239 :           if (avoid_dollar_number (format_chars))
    2372                 :            :             return false;
    2373                 :            :         }
    2374                 :        780 :       if (info->first_arg_num != 0)
    2375                 :            :         {
    2376                 :        759 :           tree cur_param;
    2377                 :        759 :           if (params == 0)
    2378                 :            :             cur_param = NULL;
    2379                 :            :           else
    2380                 :            :             {
    2381                 :        757 :               cur_param = TREE_VALUE (params);
    2382                 :        757 :               if (has_operand_number <= 0)
    2383                 :            :                 {
    2384                 :        749 :                   params = TREE_CHAIN (params);
    2385                 :        749 :                   ++arg_num;
    2386                 :            :                 }
    2387                 :            :             }
    2388                 :        759 :           precision_wanted_type.wanted_type = *fki->precision_type;
    2389                 :        759 :           precision_wanted_type.wanted_type_name = NULL;
    2390                 :        759 :           precision_wanted_type.pointer_count = 0;
    2391                 :        759 :           precision_wanted_type.char_lenient_flag = 0;
    2392                 :        759 :           precision_wanted_type.scalar_identity_flag = 0;
    2393                 :        759 :           precision_wanted_type.writing_in_flag = 0;
    2394                 :        759 :           precision_wanted_type.reading_from_flag = 0;
    2395                 :        759 :           precision_wanted_type.kind = CF_KIND_FIELD_PRECISION;
    2396                 :        759 :           precision_wanted_type.param = cur_param;
    2397                 :        759 :           precision_wanted_type.format_start = format_chars - 2;
    2398                 :        759 :           precision_wanted_type.format_length = 2;
    2399                 :        759 :           precision_wanted_type.arg_num = arg_num;
    2400                 :        759 :           precision_wanted_type.offset_loc =
    2401                 :        759 :             format_chars - orig_format_chars;
    2402                 :        759 :           precision_wanted_type.next = NULL;
    2403                 :        759 :           if (last_wanted_type != 0)
    2404                 :        172 :             last_wanted_type->next = &precision_wanted_type;
    2405                 :        759 :           if (first_wanted_type == 0)
    2406                 :        587 :             first_wanted_type = &precision_wanted_type;
    2407                 :        759 :           last_wanted_type = &precision_wanted_type;
    2408                 :            :         }
    2409                 :            :     }
    2410                 :            :   else
    2411                 :            :     {
    2412                 :       1103 :       if (!(fki->flags & (int) FMT_FLAG_EMPTY_PREC_OK)
    2413                 :         52 :           && !ISDIGIT (*format_chars))
    2414                 :          8 :         format_warning_at_char (format_string_loc, format_string_cst,
    2415                 :          8 :                                 format_chars - orig_format_chars,
    2416                 :            :                                 OPT_Wformat_,
    2417                 :          8 :                                 "empty precision in %s format", fki->name);
    2418                 :       2244 :       while (ISDIGIT (*format_chars))
    2419                 :       1141 :         ++format_chars;
    2420                 :            :     }
    2421                 :            : 
    2422                 :            :   return true;
    2423                 :            : }
    2424                 :            : 
    2425                 :            : /* Parse any assignment-allocation flags, which request an extra
    2426                 :            :    char ** for writing back a dynamically-allocated char *.
    2427                 :            :    This is for handling the optional 'm' character in scanf,
    2428                 :            :    and, before C99, 'a' (for compatibility with a non-standard
    2429                 :            :    GNU libc extension).  */
    2430                 :            : 
    2431                 :            : void
    2432                 :      39338 : argument_parser::handle_alloc_chars ()
    2433                 :            : {
    2434                 :      39338 :   if (fki->alloc_char && fki->alloc_char == *format_chars)
    2435                 :            :     {
    2436                 :        194 :       flag_chars.add_char (fki->alloc_char);
    2437                 :        194 :       format_chars++;
    2438                 :            :     }
    2439                 :            : 
    2440                 :            :   /* Handle the scanf allocation kludge.  */
    2441                 :      39338 :   if (fki->flags & (int) FMT_FLAG_SCANF_A_KLUDGE)
    2442                 :            :     {
    2443                 :       1691 :       if (*format_chars == 'a' && !flag_isoc99)
    2444                 :            :         {
    2445                 :         44 :           if (format_chars[1] == 's' || format_chars[1] == 'S'
    2446                 :         16 :               || format_chars[1] == '[')
    2447                 :            :             {
    2448                 :            :               /* 'a' is used as a flag.  */
    2449                 :         42 :               flag_chars.add_char ('a');
    2450                 :         42 :               format_chars++;
    2451                 :            :             }
    2452                 :            :         }
    2453                 :            :     }
    2454                 :      39338 : }
    2455                 :            : 
    2456                 :            : /* Look for length modifiers within the current format argument,
    2457                 :            :    returning a length_modifier instance describing it (or the
    2458                 :            :    default if one is not found).
    2459                 :            : 
    2460                 :            :    Issue warnings about non-standard modifiers.  */
    2461                 :            : 
    2462                 :            : length_modifier
    2463                 :      39338 : argument_parser::read_any_length_modifier ()
    2464                 :            : {
    2465                 :      39338 :   length_modifier result;
    2466                 :            : 
    2467                 :      39338 :   const format_length_info *fli = fki->length_char_specs;
    2468                 :      39338 :   if (!fli)
    2469                 :            :     return result;
    2470                 :            : 
    2471                 :     269547 :   while (fli->name != 0
    2472                 :     269547 :          && strncmp (fli->name, format_chars, strlen (fli->name)))
    2473                 :     231023 :     fli++;
    2474                 :      38524 :   if (fli->name != 0)
    2475                 :            :     {
    2476                 :      16530 :       format_chars += strlen (fli->name);
    2477                 :      16530 :       if (fli->double_name != 0 && fli->name[0] == *format_chars)
    2478                 :            :         {
    2479                 :       1088 :           format_chars++;
    2480                 :       1088 :           result = length_modifier (fli->double_name, fli->double_index,
    2481                 :       1088 :                                     fli->double_std, 0);
    2482                 :            :         }
    2483                 :            :       else
    2484                 :            :         {
    2485                 :      15442 :           result = length_modifier (fli->name, fli->index, fli->std,
    2486                 :      15442 :                                     fli->scalar_identity_flag);
    2487                 :            :         }
    2488                 :      16530 :       flag_chars.add_char (fki->length_code_char);
    2489                 :            :     }
    2490                 :      38524 :   if (pedantic)
    2491                 :            :     {
    2492                 :            :       /* Warn if the length modifier is non-standard.  */
    2493                 :       3100 :       if (ADJ_STD (result.std) > C_STD_VER)
    2494                 :         54 :         warning_at (format_string_loc, OPT_Wformat_,
    2495                 :            :                     "%s does not support the %qs %s length modifier",
    2496                 :         54 :                     C_STD_NAME (result.std), result.chars,
    2497                 :         54 :                     fki->name);
    2498                 :            :     }
    2499                 :            : 
    2500                 :            :   return result;
    2501                 :            : }
    2502                 :            : 
    2503                 :            : /* Read any other modifier (strftime E/O).  */
    2504                 :            : 
    2505                 :            : void
    2506                 :      39338 : argument_parser::read_any_other_modifier ()
    2507                 :            : {
    2508                 :      39338 :   if (fki->modifier_chars == NULL)
    2509                 :            :     return;
    2510                 :            : 
    2511                 :       1008 :   while (*format_chars != 0
    2512                 :       1008 :          && strchr (fki->modifier_chars, *format_chars) != 0)
    2513                 :            :     {
    2514                 :        194 :       if (flag_chars.has_char_p (*format_chars))
    2515                 :            :         {
    2516                 :          8 :           const format_flag_spec *s = get_flag_spec (flag_specs,
    2517                 :          4 :                                                      *format_chars, NULL);
    2518                 :          4 :           format_warning_at_char (format_string_loc, format_string_cst,
    2519                 :          4 :                                   format_chars - orig_format_chars,
    2520                 :            :                                   OPT_Wformat_,
    2521                 :          4 :                                   "repeated %s in format", _(s->name));
    2522                 :            :         }
    2523                 :            :       else
    2524                 :        190 :         flag_chars.add_char (*format_chars);
    2525                 :        194 :       ++format_chars;
    2526                 :            :     }
    2527                 :            : }
    2528                 :            : 
    2529                 :            : /* Return the format_char_info corresponding to FORMAT_CHAR,
    2530                 :            :    potentially issuing a warning if the format char is
    2531                 :            :    not supported in the C standard version we are checking
    2532                 :            :    against.
    2533                 :            : 
    2534                 :            :    Issue a warning and return NULL if it is not found.
    2535                 :            : 
    2536                 :            :    Issue warnings about non-standard modifiers.  */
    2537                 :            : 
    2538                 :            : const format_char_info *
    2539                 :      39296 : argument_parser::find_format_char_info (char format_char)
    2540                 :            : {
    2541                 :      39296 :   const format_char_info *fci = fki->conversion_specs;
    2542                 :            : 
    2543                 :     133288 :   while (fci->format_chars != 0
    2544                 :     133288 :          && strchr (fci->format_chars, format_char) == 0)
    2545                 :      93992 :     ++fci;
    2546                 :      39296 :   if (fci->format_chars == 0)
    2547                 :            :     {
    2548                 :        189 :       format_warning_at_char (format_string_loc, format_string_cst,
    2549                 :        189 :                               format_chars - orig_format_chars,
    2550                 :            :                               OPT_Wformat_,
    2551                 :            :                               "unknown conversion type character"
    2552                 :            :                               " %qc in format",
    2553                 :            :                               format_char);
    2554                 :        189 :       return NULL;
    2555                 :            :     }
    2556                 :            : 
    2557                 :      39107 :   if (pedantic)
    2558                 :            :     {
    2559                 :       3274 :       if (ADJ_STD (fci->std) > C_STD_VER)
    2560                 :        132 :         format_warning_at_char (format_string_loc, format_string_cst,
    2561                 :         66 :                                 format_chars - orig_format_chars,
    2562                 :            :                                 OPT_Wformat_,
    2563                 :            :                                 "%s does not support the %<%%%c%> %s format",
    2564                 :         66 :                                 C_STD_NAME (fci->std), format_char, fki->name);
    2565                 :            :     }
    2566                 :            : 
    2567                 :            :   return fci;
    2568                 :            : }
    2569                 :            : 
    2570                 :            : /* Validate the pairs of flags used.
    2571                 :            :    Issue warnings about incompatible combinations of flags.  */
    2572                 :            : 
    2573                 :            : void
    2574                 :      39107 : argument_parser::validate_flag_pairs (const format_char_info *fci,
    2575                 :            :                                       char format_char)
    2576                 :            : {
    2577                 :      39107 :   const format_flag_pair * const bad_flag_pairs = fki->bad_flag_pairs;
    2578                 :            : 
    2579                 :     151987 :   for (int i = 0; bad_flag_pairs[i].flag_char1 != 0; i++)
    2580                 :            :     {
    2581                 :     112880 :       const format_flag_spec *s, *t;
    2582                 :     112880 :       if (!flag_chars.has_char_p (bad_flag_pairs[i].flag_char1))
    2583                 :     111451 :         continue;
    2584                 :       1429 :       if (!flag_chars.has_char_p (bad_flag_pairs[i].flag_char2))
    2585                 :       1232 :         continue;
    2586                 :        197 :       if (bad_flag_pairs[i].predicate != 0
    2587                 :         70 :           && strchr (fci->flags2, bad_flag_pairs[i].predicate) == 0)
    2588                 :         30 :         continue;
    2589                 :        167 :       s = get_flag_spec (flag_specs, bad_flag_pairs[i].flag_char1, NULL);
    2590                 :        167 :       t = get_flag_spec (flag_specs, bad_flag_pairs[i].flag_char2, NULL);
    2591                 :        167 :       if (bad_flag_pairs[i].ignored)
    2592                 :            :         {
    2593                 :        109 :           if (bad_flag_pairs[i].predicate != 0)
    2594                 :         40 :             warning_at (format_string_loc, OPT_Wformat_,
    2595                 :            :                         "%s ignored with %s and %<%%%c%> %s format",
    2596                 :         40 :                         _(s->name), _(t->name), format_char,
    2597                 :         40 :                         fki->name);
    2598                 :            :           else
    2599                 :         69 :             warning_at (format_string_loc, OPT_Wformat_,
    2600                 :            :                         "%s ignored with %s in %s format",
    2601                 :         69 :                         _(s->name), _(t->name), fki->name);
    2602                 :            :         }
    2603                 :            :       else
    2604                 :            :         {
    2605                 :         58 :           if (bad_flag_pairs[i].predicate != 0)
    2606                 :          0 :             warning_at (format_string_loc, OPT_Wformat_,
    2607                 :            :                         "use of %s and %s together with %<%%%c%> %s format",
    2608                 :          0 :                         _(s->name), _(t->name), format_char,
    2609                 :          0 :                         fki->name);
    2610                 :            :           else
    2611                 :         58 :             warning_at (format_string_loc, OPT_Wformat_,
    2612                 :            :                         "use of %s and %s together in %s format",
    2613                 :         58 :                         _(s->name), _(t->name), fki->name);
    2614                 :            :         }
    2615                 :            :     }
    2616                 :      39107 : }
    2617                 :            : 
    2618                 :            : /* Give Y2K warnings.  */
    2619                 :            : 
    2620                 :            : void
    2621                 :      39107 : argument_parser::give_y2k_warnings (const format_char_info *fci,
    2622                 :            :                                     char format_char)
    2623                 :            : {
    2624                 :      39107 :   if (!warn_format_y2k)
    2625                 :            :     return;
    2626                 :            : 
    2627                 :        830 :   int y2k_level = 0;
    2628                 :        830 :   if (strchr (fci->flags2, '4') != 0)
    2629                 :         22 :     if (flag_chars.has_char_p ('E'))
    2630                 :            :       y2k_level = 3;
    2631                 :            :     else
    2632                 :            :       y2k_level = 2;
    2633                 :        808 :   else if (strchr (fci->flags2, '3') != 0)
    2634                 :            :     y2k_level = 3;
    2635                 :        768 :   else if (strchr (fci->flags2, '2') != 0)
    2636                 :            :     y2k_level = 2;
    2637                 :            :   if (y2k_level == 3)
    2638                 :         46 :     warning_at (format_string_loc, OPT_Wformat_y2k,
    2639                 :            :                 "%<%%%c%> yields only last 2 digits of "
    2640                 :            :                 "year in some locales", format_char);
    2641                 :        784 :   else if (y2k_level == 2)
    2642                 :         56 :     warning_at (format_string_loc, OPT_Wformat_y2k,
    2643                 :            :                 "%<%%%c%> yields only last 2 digits of year",
    2644                 :            :                 format_char);
    2645                 :            : }
    2646                 :            : 
    2647                 :            : /* Parse any "scan sets" enclosed in square brackets, e.g.
    2648                 :            :    for scanf-style calls.  */
    2649                 :            : 
    2650                 :            : void
    2651                 :      39107 : argument_parser::parse_any_scan_set (const format_char_info *fci)
    2652                 :            : {
    2653                 :      39107 :   if (strchr (fci->flags2, '[') == NULL)
    2654                 :            :     return;
    2655                 :            : 
    2656                 :            :   /* Skip over scan set, in case it happens to have '%' in it.  */
    2657                 :        116 :   if (*format_chars == '^')
    2658                 :          4 :     ++format_chars;
    2659                 :            :   /* Find closing bracket; if one is hit immediately, then
    2660                 :            :      it's part of the scan set rather than a terminator.  */
    2661                 :        116 :   if (*format_chars == ']')
    2662                 :          6 :     ++format_chars;
    2663                 :        434 :   while (*format_chars && *format_chars != ']')
    2664                 :        318 :     ++format_chars;
    2665                 :        116 :   if (*format_chars != ']')
    2666                 :            :     /* The end of the format string was reached.  */
    2667                 :          2 :     format_warning_at_char (format_string_loc, format_string_cst,
    2668                 :          2 :                             format_chars - orig_format_chars,
    2669                 :            :                             OPT_Wformat_,
    2670                 :            :                             "no closing %<]%> for %<%%[%> format");
    2671                 :            : }
    2672                 :            : 
    2673                 :            : /* Return true if this argument is to be continued to be parsed,
    2674                 :            :    false to skip to next argument.  */
    2675                 :            : 
    2676                 :            : bool
    2677                 :      39107 : argument_parser::handle_conversions (const format_char_info *fci,
    2678                 :            :                                      const length_modifier &len_modifier,
    2679                 :            :                                      tree &wanted_type,
    2680                 :            :                                      const char *&wanted_type_name,
    2681                 :            :                                      unsigned HOST_WIDE_INT &arg_num,
    2682                 :            :                                      tree &params,
    2683                 :            :                                      char format_char)
    2684                 :            : {
    2685                 :      39107 :   enum format_std_version wanted_type_std;
    2686                 :            : 
    2687                 :      39107 :   if (!(fki->flags & (int) FMT_FLAG_ARG_CONVERT))
    2688                 :            :     return true;
    2689                 :            : 
    2690                 :      76586 :   wanted_type = (fci->types[len_modifier.val].type
    2691                 :      38293 :                  ? *fci->types[len_modifier.val].type : 0);
    2692                 :      38293 :   wanted_type_name = fci->types[len_modifier.val].name;
    2693                 :      38293 :   wanted_type_std = fci->types[len_modifier.val].std;
    2694                 :      38293 :   if (wanted_type == 0)
    2695                 :            :     {
    2696                 :        566 :       format_warning_at_char (format_string_loc, format_string_cst,
    2697                 :        566 :                               format_chars - orig_format_chars,
    2698                 :            :                               OPT_Wformat_,
    2699                 :            :                               "use of %qs length modifier with %qc type"
    2700                 :            :                               " character has either no effect"
    2701                 :            :                               " or undefined behavior",
    2702                 :        566 :                               len_modifier.chars, format_char);
    2703                 :            :       /* Heuristic: skip one argument when an invalid length/type
    2704                 :            :          combination is encountered.  */
    2705                 :        566 :       arg_num++;
    2706                 :        566 :       if (params != 0)
    2707                 :        566 :         params = TREE_CHAIN (params);
    2708                 :        566 :       return false;
    2709                 :            :     }
    2710                 :      37727 :   else if (pedantic
    2711                 :            :            /* Warn if non-standard, provided it is more non-standard
    2712                 :            :               than the length and type characters that may already
    2713                 :            :               have been warned for.  */
    2714                 :       1784 :            && ADJ_STD (wanted_type_std) > ADJ_STD (len_modifier.std)
    2715                 :        278 :            && ADJ_STD (wanted_type_std) > ADJ_STD (fci->std))
    2716                 :            :     {
    2717                 :        233 :       if (ADJ_STD (wanted_type_std) > C_STD_VER)
    2718                 :        203 :         format_warning_at_char (format_string_loc, format_string_cst,
    2719                 :        101 :                                 format_chars - orig_format_chars,
    2720                 :            :                                 OPT_Wformat_,
    2721                 :            :                                 "%s does not support the %<%%%s%c%> %s format",
    2722                 :        101 :                                 C_STD_NAME (wanted_type_std),
    2723                 :        101 :                                 len_modifier.chars,
    2724                 :        101 :                                 format_char, fki->name);
    2725                 :            :     }
    2726                 :            : 
    2727                 :            :   return true;
    2728                 :            : }
    2729                 :            : 
    2730                 :            : /* Check type of argument against desired type.
    2731                 :            : 
    2732                 :            :    Return true if format parsing is to continue, false otherwise.  */
    2733                 :            : 
    2734                 :            : bool
    2735                 :      38541 : argument_parser::
    2736                 :            : check_argument_type (const format_char_info *fci,
    2737                 :            :                      const length_modifier &len_modifier,
    2738                 :            :                      tree &wanted_type,
    2739                 :            :                      const char *&wanted_type_name,
    2740                 :            :                      const bool suppressed,
    2741                 :            :                      unsigned HOST_WIDE_INT &arg_num,
    2742                 :            :                      tree &params,
    2743                 :            :                      const int alloc_flag,
    2744                 :            :                      const char * const format_start,
    2745                 :            :                      const char * const type_start,
    2746                 :            :                      location_t fmt_param_loc,
    2747                 :            :                      char conversion_char)
    2748                 :            : {
    2749                 :      38541 :   if (info->first_arg_num == 0)
    2750                 :            :     return true;
    2751                 :            : 
    2752                 :      37365 :   if ((fci->pointer_count == 0 && wanted_type == void_type_node)
    2753                 :      36763 :       || suppressed)
    2754                 :            :     {
    2755                 :        780 :       if (main_arg_num != 0)
    2756                 :            :         {
    2757                 :          4 :           if (suppressed)
    2758                 :          2 :             warning_at (format_string_loc, OPT_Wformat_,
    2759                 :            :                         "operand number specified with "
    2760                 :            :                         "suppressed assignment");
    2761                 :            :           else
    2762                 :          2 :             warning_at (format_string_loc, OPT_Wformat_,
    2763                 :            :                         "operand number specified for format "
    2764                 :            :                         "taking no argument");
    2765                 :            :         }
    2766                 :            :     }
    2767                 :            :   else
    2768                 :            :     {
    2769                 :      36585 :       format_wanted_type *wanted_type_ptr;
    2770                 :            : 
    2771                 :      36585 :       if (main_arg_num != 0)
    2772                 :            :         {
    2773                 :        145 :           arg_num = main_arg_num;
    2774                 :        145 :           params = main_arg_params;
    2775                 :            :         }
    2776                 :            :       else
    2777                 :            :         {
    2778                 :      36440 :           ++arg_num;
    2779                 :      36440 :           if (has_operand_number > 0)
    2780                 :            :             {
    2781                 :          6 :               warning_at (format_string_loc, OPT_Wformat_,
    2782                 :            :                           "missing $ operand number in format");
    2783                 :          6 :               return false;
    2784                 :            :             }
    2785                 :            :           else
    2786                 :      36434 :             has_operand_number = 0;
    2787                 :            :         }
    2788                 :            : 
    2789                 :      36579 :       wanted_type_ptr = &main_wanted_type;
    2790                 :      73170 :       while (fci)
    2791                 :            :         {
    2792                 :      36591 :           tree cur_param;
    2793                 :      36591 :           if (params == 0)
    2794                 :            :             cur_param = NULL;
    2795                 :            :           else
    2796                 :            :             {
    2797                 :      36532 :               cur_param = TREE_VALUE (params);
    2798                 :      36532 :               params = TREE_CHAIN (params);
    2799                 :            :             }
    2800                 :            : 
    2801                 :      36591 :           wanted_type_ptr->wanted_type = wanted_type;
    2802                 :      36591 :           wanted_type_ptr->wanted_type_name = wanted_type_name;
    2803                 :      36591 :           wanted_type_ptr->pointer_count = fci->pointer_count + alloc_flag;
    2804                 :      36591 :           wanted_type_ptr->char_lenient_flag = 0;
    2805                 :      36591 :           if (strchr (fci->flags2, 'c') != 0)
    2806                 :       6762 :             wanted_type_ptr->char_lenient_flag = 1;
    2807                 :      36591 :           wanted_type_ptr->scalar_identity_flag = 0;
    2808                 :      36591 :           if (len_modifier.scalar_identity_flag)
    2809                 :          0 :             wanted_type_ptr->scalar_identity_flag = 1;
    2810                 :      36591 :           wanted_type_ptr->writing_in_flag = 0;
    2811                 :      36591 :           wanted_type_ptr->reading_from_flag = 0;
    2812                 :      36591 :           if (alloc_flag)
    2813                 :        114 :             wanted_type_ptr->writing_in_flag = 1;
    2814                 :            :           else
    2815                 :            :             {
    2816                 :      36477 :               if (strchr (fci->flags2, 'W') != 0)
    2817                 :       1160 :                 wanted_type_ptr->writing_in_flag = 1;
    2818                 :      36477 :               if (strchr (fci->flags2, 'R') != 0)
    2819                 :       6274 :                 wanted_type_ptr->reading_from_flag = 1;
    2820                 :            :             }
    2821                 :      36591 :           wanted_type_ptr->kind = CF_KIND_FORMAT;
    2822                 :      36591 :           wanted_type_ptr->param = cur_param;
    2823                 :      36591 :           wanted_type_ptr->arg_num = arg_num;
    2824                 :      36591 :           wanted_type_ptr->format_start = format_start;
    2825                 :      36591 :           wanted_type_ptr->format_length = format_chars - format_start;
    2826                 :      36591 :           wanted_type_ptr->offset_loc = format_chars - orig_format_chars;
    2827                 :      36591 :           wanted_type_ptr->next = NULL;
    2828                 :      36591 :           if (last_wanted_type != 0)
    2829                 :       1323 :             last_wanted_type->next = wanted_type_ptr;
    2830                 :      36591 :           if (first_wanted_type == 0)
    2831                 :      35268 :             first_wanted_type = wanted_type_ptr;
    2832                 :      36591 :           last_wanted_type = wanted_type_ptr;
    2833                 :            : 
    2834                 :      36591 :           fci = fci->chain;
    2835                 :      36591 :           if (fci)
    2836                 :            :             {
    2837                 :         12 :               wanted_type_ptr = fwt_pool.allocate ();
    2838                 :         12 :               arg_num++;
    2839                 :         12 :               wanted_type = *fci->types[len_modifier.val].type;
    2840                 :         12 :               wanted_type_name = fci->types[len_modifier.val].name;
    2841                 :            :             }
    2842                 :            :         }
    2843                 :            :     }
    2844                 :            : 
    2845                 :      37359 :   if (first_wanted_type != 0)
    2846                 :            :     {
    2847                 :      36593 :       ptrdiff_t offset_to_format_start = (start_of_this_format - 1) - orig_format_chars;
    2848                 :      36593 :       ptrdiff_t offset_to_format_end = (format_chars - 1) - orig_format_chars;
    2849                 :            :       /* By default, use the end of the range for the caret location.  */
    2850                 :      73186 :       substring_loc fmt_loc (fmt_param_loc, TREE_TYPE (format_string_cst),
    2851                 :            :                              offset_to_format_end,
    2852                 :      36593 :                              offset_to_format_start, offset_to_format_end);
    2853                 :      36593 :       ptrdiff_t offset_to_type_start = type_start - orig_format_chars;
    2854                 :      36593 :       check_format_types (fmt_loc, first_wanted_type, fki,
    2855                 :            :                           offset_to_type_start,
    2856                 :            :                           conversion_char, arglocs);
    2857                 :            :     }
    2858                 :            : 
    2859                 :            :   return true;
    2860                 :            : }
    2861                 :            : 
    2862                 :            : /* Describes "paired tokens" within the format string that are
    2863                 :            :    expected to be balanced.  */
    2864                 :            : 
    2865                 :            : class baltoks_t
    2866                 :            : {
    2867                 :            : public:
    2868                 :      26682 :   baltoks_t (): singlequote (), doublequote () { }
    2869                 :            : 
    2870                 :            :   typedef auto_vec<const char *> balanced_tokens_t;
    2871                 :            :   /* Vectors of pointers to opening brackets ('['), curly brackets ('{'),
    2872                 :            :      quoting directives (like GCC "%<"), parentheses, and angle brackets
    2873                 :            :      ('<').  Used to detect unbalanced tokens.  */
    2874                 :            :   balanced_tokens_t brackets;
    2875                 :            :   balanced_tokens_t curly;
    2876                 :            :   balanced_tokens_t quotdirs;
    2877                 :            :   balanced_tokens_t parens;
    2878                 :            :   balanced_tokens_t pointy;
    2879                 :            :   /* Pointer to the last opening quote.  */
    2880                 :            :   const char *singlequote;
    2881                 :            :   const char *doublequote;
    2882                 :            : };
    2883                 :            : 
    2884                 :            : /* Describes a keyword, operator, or other name.  */
    2885                 :            : 
    2886                 :            : struct token_t
    2887                 :            : {
    2888                 :            :   const char *name;   /* Keyword/operator name.  */
    2889                 :            :   unsigned char len;  /* Its length.  */
    2890                 :            :   const char *alt;    /* Alternate spelling.  */
    2891                 :            : };
    2892                 :            : 
    2893                 :            : /* Helper for initializing global token_t arrays below.  */
    2894                 :            : #define NAME(name) { name, sizeof name - 1, NULL }
    2895                 :            : 
    2896                 :            : /* C/C++ operators that are expected to be quoted within the format
    2897                 :            :    string.  */
    2898                 :            : 
    2899                 :            : static const token_t c_opers[] =
    2900                 :            :   {
    2901                 :            :    NAME ("!="), NAME ("%="),  NAME ("&&"),  NAME ("&="), NAME ("*="),
    2902                 :            :    NAME ("++"), NAME ("+="),  NAME ("--"),  NAME ("-="), NAME ("->"),
    2903                 :            :    NAME ("/="), NAME ("<<"),  NAME ("<<="), NAME ("<="), NAME ("=="),
    2904                 :            :    NAME (">="), NAME (">>="), NAME (">>"),  NAME ("?:"),  NAME ("^="),
    2905                 :            :    NAME ("|="), NAME ("||")
    2906                 :            :   };
    2907                 :            : 
    2908                 :            : static const token_t cxx_opers[] =
    2909                 :            :   {
    2910                 :            :    NAME ("->*"), NAME (".*"),  NAME ("::"),  NAME ("<=>")
    2911                 :            :   };
    2912                 :            : 
    2913                 :            : /* Common C/C++ keywords that are expected to be quoted within the format
    2914                 :            :    string.  Keywords like auto, inline, or volatile are exccluded because
    2915                 :            :    they are sometimes used in common terms like /auto variables/, /inline
    2916                 :            :    function/, or /volatile access/ where they should not be quoted.  */
    2917                 :            : 
    2918                 :            : static const token_t c_keywords[] =
    2919                 :            :   {
    2920                 :            : #undef NAME
    2921                 :            : #define NAME(name, alt)  { name, sizeof name - 1, alt }
    2922                 :            : 
    2923                 :            :    NAME ("alignas", NULL),
    2924                 :            :    NAME ("alignof", NULL),
    2925                 :            :    NAME ("asm", NULL),
    2926                 :            :    NAME ("bool", NULL),
    2927                 :            :    NAME ("char", NULL),
    2928                 :            :    NAME ("const %", NULL),
    2929                 :            :    NAME ("const-qualified", "%<const%>-qualified"),
    2930                 :            :    NAME ("float", NULL),
    2931                 :            :    NAME ("ifunc", NULL),
    2932                 :            :    NAME ("int", NULL),
    2933                 :            :    NAME ("long double", NULL),
    2934                 :            :    NAME ("long int", NULL),
    2935                 :            :    NAME ("long long", NULL),
    2936                 :            :    NAME ("malloc", NULL),
    2937                 :            :    NAME ("noclone", NULL),
    2938                 :            :    NAME ("noinline", NULL),
    2939                 :            :    NAME ("nonnull", NULL),
    2940                 :            :    NAME ("noreturn", NULL),
    2941                 :            :    NAME ("nothrow", NULL),
    2942                 :            :    NAME ("offsetof", NULL),
    2943                 :            :    NAME ("readonly", "read-only"),
    2944                 :            :    NAME ("readwrite", "read-write"),
    2945                 :            :    NAME ("restrict %", NULL),
    2946                 :            :    NAME ("restrict-qualified", "%<restrict%>-qualified"),
    2947                 :            :    NAME ("short int", NULL),
    2948                 :            :    NAME ("signed char", NULL),
    2949                 :            :    NAME ("signed int", NULL),
    2950                 :            :    NAME ("signed long", NULL),
    2951                 :            :    NAME ("signed short", NULL),
    2952                 :            :    NAME ("sizeof", NULL),
    2953                 :            :    NAME ("typeof", NULL),
    2954                 :            :    NAME ("unsigned char", NULL),
    2955                 :            :    NAME ("unsigned int", NULL),
    2956                 :            :    NAME ("unsigned long", NULL),
    2957                 :            :    NAME ("unsigned short", NULL),
    2958                 :            :    NAME ("volatile %", NULL),
    2959                 :            :    NAME ("volatile-qualified", "%<volatile%>-qualified"),
    2960                 :            :    NAME ("weakref", NULL),
    2961                 :            :   };
    2962                 :            : 
    2963                 :            : static const token_t cxx_keywords[] =
    2964                 :            :   {
    2965                 :            :    /* C++ only keywords and operators.  */
    2966                 :            :    NAME ("catch", NULL),
    2967                 :            :    NAME ("constexpr if", NULL),
    2968                 :            :    NAME ("constexpr", NULL),
    2969                 :            :    NAME ("constinit", NULL),
    2970                 :            :    NAME ("consteval", NULL),
    2971                 :            :    NAME ("decltype", NULL),
    2972                 :            :    NAME ("nullptr", NULL),
    2973                 :            :    NAME ("operator delete", NULL),
    2974                 :            :    NAME ("operator new", NULL),
    2975                 :            :    NAME ("typeid", NULL),
    2976                 :            :    NAME ("typeinfo", NULL)
    2977                 :            :   };
    2978                 :            : 
    2979                 :            : /* Blacklisted words such as misspellings that should be avoided in favor
    2980                 :            :    of the specified alternatives.  */
    2981                 :            : static const struct
    2982                 :            : {
    2983                 :            :   const char *name;   /* Bad word.  */
    2984                 :            :   unsigned char len;  /* Its length.  */
    2985                 :            :   const char *alt;    /* Preferred alternative.  */
    2986                 :            : } badwords[] =
    2987                 :            :   {
    2988                 :            :    NAME ("arg", "argument"),
    2989                 :            :    NAME ("bitfield", "bit-field"),
    2990                 :            :    NAME ("builtin function", "built-in function"),
    2991                 :            :    NAME ("can not", "cannot"),
    2992                 :            :    NAME ("commandline option", "command-line option"),
    2993                 :            :    NAME ("commandline", "command line"),
    2994                 :            :    NAME ("command line option", "command-line option"),
    2995                 :            :    NAME ("decl", "declaration"),
    2996                 :            :    NAME ("enumeral", "enumerated"),
    2997                 :            :    NAME ("floating point", "floating-point"),
    2998                 :            :    NAME ("non-zero", "nonzero"),
    2999                 :            :    NAME ("reg", "register"),
    3000                 :            :    NAME ("stmt", "statement"),
    3001                 :            :   };
    3002                 :            : 
    3003                 :            : /* Common contractions that should be avoided in favor of the specified
    3004                 :            :    alternatives.  */
    3005                 :            : 
    3006                 :            : static const struct
    3007                 :            : {
    3008                 :            :   const char *name;   /* Contraction.  */
    3009                 :            :   unsigned char len;  /* Its length.  */
    3010                 :            :   const char *alt;    /* Preferred alternative.  */
    3011                 :            : } contrs[] =
    3012                 :            :   {
    3013                 :            :    NAME ("can't", "cannot"),
    3014                 :            :    NAME ("didn't", "did not"),
    3015                 :            :    /* These are commonly abused.  Avoid diagnosing them for now.
    3016                 :            :       NAME ("isn't", "is not"),
    3017                 :            :       NAME ("don't", "is not"),
    3018                 :            :    */
    3019                 :            :    NAME ("mustn't", "must not"),
    3020                 :            :    NAME ("needn't", "need not"),
    3021                 :            :    NAME ("should't", "should not"),
    3022                 :            :    NAME ("that's", "that is"),
    3023                 :            :    NAME ("there's", "there is"),
    3024                 :            :    NAME ("they're", "they are"),
    3025                 :            :    NAME ("what's", "what is"),
    3026                 :            :    NAME ("won't", "will not")
    3027                 :            :   };
    3028                 :            : 
    3029                 :            : /* Check for unquoted TOKENS.  FORMAT_STRING_LOC is the location of
    3030                 :            :    the format string, FORMAT_STRING_CST the format string itself (as
    3031                 :            :    a tree), ORIG_FORMAT_CHARS and FORMAT_CHARS are pointers to
    3032                 :            :    the beginning of the format string and the character currently
    3033                 :            :    being processed, and BALTOKS describes paired "tokens" within
    3034                 :            :    the format string that are expected to be balanced.
    3035                 :            :    Returns a pointer to the last processed character or null when
    3036                 :            :    nothing was done.  */
    3037                 :            : 
    3038                 :            : static const char*
    3039                 :       1656 : check_tokens (const token_t *tokens, unsigned ntoks,
    3040                 :            :               location_t format_string_loc, tree format_string_cst,
    3041                 :            :               const char *orig_format_chars, const char *format_chars,
    3042                 :            :               baltoks_t &baltoks)
    3043                 :            : {
    3044                 :            :   /* For brevity.  */
    3045                 :       1656 :   const int opt = OPT_Wformat_diag;
    3046                 :            :   /* Zero-based starting position of a problem sequence.  */
    3047                 :       1656 :   int fmtchrpos = format_chars - orig_format_chars;
    3048                 :            : 
    3049                 :            :   /* For identifier-like "words," set to the word length.  */
    3050                 :       1656 :   unsigned wlen = 0;
    3051                 :            :   /* Set for an operator, clear for an identifier/word.  */
    3052                 :       1656 :   bool is_oper = false;
    3053                 :       1656 :   bool underscore = false;
    3054                 :            : 
    3055                 :       1656 :   if (format_chars[0] == '_' || ISALPHA (format_chars[0]))
    3056                 :            :     {
    3057                 :       5572 :       while (format_chars[wlen] == '_' || ISALNUM (format_chars[wlen]))
    3058                 :            :         {
    3059                 :       4462 :           underscore |= format_chars[wlen] == '_';
    3060                 :       4462 :           ++wlen;
    3061                 :            :         }
    3062                 :            :     }
    3063                 :            :   else
    3064                 :            :     is_oper = true;
    3065                 :            : 
    3066                 :      48482 :   for (unsigned i = 0; i != ntoks; ++i)
    3067                 :            :     {
    3068                 :      46884 :       unsigned toklen = tokens[i].len;
    3069                 :            : 
    3070                 :      46884 :       if (toklen < wlen
    3071                 :      42490 :           || strncmp (format_chars, tokens[i].name, toklen))
    3072                 :      46826 :         continue;
    3073                 :            : 
    3074                 :         58 :       if (toklen == 2
    3075                 :         20 :           && format_chars - orig_format_chars > 0
    3076                 :         14 :           && (TOUPPER (format_chars[-1]) == 'C'
    3077                 :         14 :               || TOUPPER (format_chars[-1]) == 'G'))
    3078                 :          0 :         return format_chars + toklen - 1;   /* Reference to C++ or G++.  */
    3079                 :            : 
    3080                 :         58 :       if (ISPUNCT (format_chars[toklen - 1]))
    3081                 :            :         {
    3082                 :         32 :           if (format_chars[toklen - 1] == format_chars[toklen])
    3083                 :            :             return NULL;   /* Operator followed by another punctuator.  */
    3084                 :            :         }
    3085                 :         26 :       else if (ISALNUM (format_chars[toklen]))
    3086                 :            :         return NULL;   /* Keyword prefix for a longer word.  */
    3087                 :            : 
    3088                 :         56 :       if (toklen == 2
    3089                 :         20 :           && format_chars[0] == '-'
    3090                 :          4 :           && format_chars[1] == '-'
    3091                 :          4 :           && ISALNUM (format_chars[2]))
    3092                 :            :         return NULL;   /* Probably option like --help.  */
    3093                 :            : 
    3094                 :            :       /* Allow this ugly warning for the time being.  */
    3095                 :         54 :       if (toklen == 2
    3096                 :         18 :           && format_chars - orig_format_chars > 6
    3097                 :          4 :           && !strncmp (format_chars - 7, " count >= width of ", 19))
    3098                 :          0 :         return format_chars + 10;
    3099                 :            : 
    3100                 :            :       /* The token is a type if it ends in an alphabetic character.  */
    3101                 :        108 :       bool is_type = (ISALPHA (tokens[i].name[toklen - 1])
    3102                 :         54 :                       && strchr (tokens[i].name, ' '));
    3103                 :            : 
    3104                 :            :       /* Backtrack to the last alphabetic character (for tokens whose
    3105                 :            :          names end in '%').  */
    3106                 :         54 :       if (!is_oper)
    3107                 :         60 :         while (!ISALPHA (tokens[i].name[toklen - 1]))
    3108                 :            :           --toklen;
    3109                 :            : 
    3110                 :         54 :       if (format_warning_substr (format_string_loc, format_string_cst,
    3111                 :         54 :                                  fmtchrpos, fmtchrpos + toklen, opt,
    3112                 :            :                                  (is_type
    3113                 :            :                                   ? G_("unquoted type name %<%.*s%> in format")
    3114                 :            :                                   : (is_oper
    3115                 :         46 :                                      ? G_("unquoted operator %<%.*s%> in format")
    3116                 :            :                                      : G_("unquoted keyword %<%.*s%> in format"))),
    3117                 :            :                                  toklen, format_chars)
    3118                 :         54 :           && tokens[i].alt)
    3119                 :          2 :         inform (format_string_loc, "use %qs instead", tokens[i].alt);
    3120                 :            : 
    3121                 :         54 :       return format_chars + toklen - 1;
    3122                 :            :     }
    3123                 :            : 
    3124                 :            :   /* Diagnose unquoted __attribute__.  Consider any parenthesized
    3125                 :            :      argument to the attribute to avoid redundant warnings for
    3126                 :            :      the double parentheses that might follow.  */
    3127                 :       1598 :   if (!strncmp (format_chars, "__attribute", sizeof "__attribute" - 1))
    3128                 :            :     {
    3129                 :            :       unsigned nchars = sizeof "__attribute" - 1;
    3130                 :         38 :       while ('_' == format_chars[nchars])
    3131                 :         24 :         ++nchars;
    3132                 :            : 
    3133                 :         28 :       for (int i = nchars; format_chars[i]; ++i)
    3134                 :         28 :         if (' ' != format_chars[i])
    3135                 :            :           {
    3136                 :         14 :             nchars = i;
    3137                 :         14 :             break;
    3138                 :            :           }
    3139                 :            : 
    3140                 :         14 :       if (format_chars[nchars] == '(')
    3141                 :            :         {
    3142                 :         12 :           baltoks.parens.safe_push (format_chars + nchars);
    3143                 :            : 
    3144                 :         12 :           ++nchars;
    3145                 :         12 :           bool close = false;
    3146                 :         12 :           if (format_chars[nchars] == '(')
    3147                 :            :             {
    3148                 :          8 :               baltoks.parens.safe_push (format_chars + nchars);
    3149                 :          8 :               close = true;
    3150                 :          8 :               ++nchars;
    3151                 :            :             }
    3152                 :         56 :           for (int i = nchars; format_chars[i]; ++i)
    3153                 :         54 :             if (')' == format_chars[i])
    3154                 :            :               {
    3155                 :         10 :                 if (baltoks.parens.length () > 0)
    3156                 :         10 :                   baltoks.parens.pop ();
    3157                 :         10 :                 nchars = i + 1;
    3158                 :         10 :                 break;
    3159                 :            :               }
    3160                 :            : 
    3161                 :         12 :           if (close && format_chars[nchars] == ')')
    3162                 :            :             {
    3163                 :          4 :               if (baltoks.parens.length () > 0)
    3164                 :          4 :                 baltoks.parens.pop ();
    3165                 :          4 :               ++nchars;
    3166                 :            :             }
    3167                 :            :         }
    3168                 :            : 
    3169                 :         14 :       format_warning_substr (format_string_loc, format_string_cst,
    3170                 :         14 :                              fmtchrpos, fmtchrpos + nchars, opt,
    3171                 :            :                               "unquoted attribute in format");
    3172                 :         14 :       return format_chars + nchars - 1;
    3173                 :            :     }
    3174                 :            : 
    3175                 :            :   /* Diagnose unquoted built-ins.  */
    3176                 :       1584 :   if (format_chars[0] == '_'
    3177                 :         16 :       && format_chars[1] == '_'
    3178                 :         10 :       && (!strncmp (format_chars + 2, "atomic", sizeof "atomic" - 1)
    3179                 :         10 :           || !strncmp (format_chars + 2, "builtin", sizeof "builtin" - 1)
    3180                 :          2 :           || !strncmp (format_chars + 2, "sync", sizeof "sync" - 1)))
    3181                 :            :     {
    3182                 :          8 :       format_warning_substr (format_string_loc, format_string_cst,
    3183                 :          8 :                              fmtchrpos, fmtchrpos + wlen, opt,
    3184                 :            :                              "unquoted name of built-in function %<%.*s%> "
    3185                 :            :                              "in format",
    3186                 :            :                              wlen, format_chars);
    3187                 :          8 :       return format_chars + wlen - 1;
    3188                 :            :     }
    3189                 :            : 
    3190                 :            :   /* Diagnose unquoted substrings of alphanumeric characters containing
    3191                 :            :      underscores.  They most likely refer to identifiers and should be
    3192                 :            :      quoted.  */
    3193                 :       1576 :   if (underscore)
    3194                 :         22 :     format_warning_substr (format_string_loc, format_string_cst,
    3195                 :            :                            format_chars - orig_format_chars,
    3196                 :         22 :                            format_chars + wlen - orig_format_chars,
    3197                 :            :                            opt,
    3198                 :            :                            "unquoted identifier or keyword %<%.*s%> in format",
    3199                 :            :                            wlen, format_chars);
    3200                 :            :   else
    3201                 :            :     {
    3202                 :            :       /* Diagnose some common missspellings.  */
    3203                 :      21334 :       for (unsigned i = 0; i != sizeof badwords / sizeof *badwords; ++i)
    3204                 :            :         {
    3205                 :      19822 :           unsigned badwlen = strspn (badwords[i].name, " -");
    3206                 :      19822 :           if (wlen >= badwlen
    3207                 :      19822 :               && (wlen <= badwords[i].len
    3208                 :       1656 :                   || (wlen == badwords[i].len + 1U
    3209                 :        596 :                       && TOUPPER (format_chars[wlen - 1]) == 'S'))
    3210                 :      18282 :               && !strncasecmp (format_chars, badwords[i].name, badwords[i].len))
    3211                 :            :             {
    3212                 :            :               /* Handle singular as well as plural forms of all bad words
    3213                 :            :                  even though the latter don't necessarily make sense for
    3214                 :            :                  all of the former (like "can nots").  */
    3215                 :         42 :               badwlen = badwords[i].len;
    3216                 :         42 :               const char *plural = "";
    3217                 :         42 :               if (TOUPPER (format_chars[badwlen]) == 'S')
    3218                 :            :                 {
    3219                 :         18 :                   ++badwlen;
    3220                 :         18 :                   plural = "s";
    3221                 :            :                 }
    3222                 :            : 
    3223                 :         42 :               format_warning_substr (format_string_loc, format_string_cst,
    3224                 :         42 :                                      fmtchrpos, fmtchrpos + badwords[i].len,
    3225                 :            :                                      opt,
    3226                 :            :                                      "misspelled term %<%.*s%> in format; "
    3227                 :            :                                      "use %<%s%s%> instead",
    3228                 :            :                                      badwlen, format_chars,
    3229                 :         42 :                                      badwords[i].alt, plural);
    3230                 :            : 
    3231                 :         42 :               return format_chars + badwords[i].len - 1;
    3232                 :            :             }
    3233                 :            :         }
    3234                 :            : 
    3235                 :            :       /* Skip C++/G++.  */
    3236                 :       1512 :       if (!strncasecmp (format_chars, "c++", 3)
    3237                 :       1506 :           || !strncasecmp (format_chars, "g++", 3))
    3238                 :         14 :         return format_chars + 2;
    3239                 :            :     }
    3240                 :            : 
    3241                 :       1520 :   return wlen ? format_chars + wlen - 1 : NULL;
    3242                 :            : }
    3243                 :            : 
    3244                 :            : /* Check plain text in a format string of a GCC diagnostic function
    3245                 :            :    for common quoting, punctuation, and spelling mistakes, and issue
    3246                 :            :    -Wformat-diag warnings if they are found.   FORMAT_STRING_LOC is
    3247                 :            :    the location of the format string, FORMAT_STRING_CST the format
    3248                 :            :    string itself (as a tree), ORIG_FORMAT_CHARS and FORMAT_CHARS are
    3249                 :            :    pointers to the beginning of the format string and the character
    3250                 :            :    currently being processed, and BALTOKS describes paired "tokens"
    3251                 :            :    within the format string that are expected to be balanced.
    3252                 :            :    Returns a pointer to the last processed character.  */
    3253                 :            : 
    3254                 :            : static const char*
    3255                 :       2878 : check_plain (location_t format_string_loc, tree format_string_cst,
    3256                 :            :              const char *orig_format_chars, const char *format_chars,
    3257                 :            :              baltoks_t &baltoks)
    3258                 :            : {
    3259                 :            :   /* For brevity.  */
    3260                 :       2878 :   const int opt = OPT_Wformat_diag;
    3261                 :            :   /* Zero-based starting position of a problem sequence.  */
    3262                 :       2878 :   int fmtchrpos = format_chars - orig_format_chars;
    3263                 :            : 
    3264                 :       2878 :   if (*format_chars == '%')
    3265                 :            :     {
    3266                 :            :       /* Diagnose %<%s%> and suggest using %qs instead.  */
    3267                 :       1220 :       if (!strncmp (format_chars, "%<%s%>", 6))
    3268                 :          2 :         format_warning_substr (format_string_loc, format_string_cst,
    3269                 :            :                                fmtchrpos, fmtchrpos + 6, opt,
    3270                 :            :                                "quoted %qs directive in format; "
    3271                 :            :                                "use %qs instead", "%s", "%qs");
    3272                 :       1218 :       else if (format_chars - orig_format_chars > 2
    3273                 :        494 :                && !strncasecmp (format_chars - 3, "can%'t", 6))
    3274                 :          4 :         format_warning_substr (format_string_loc,
    3275                 :            :                                format_string_cst,
    3276                 :            :                                fmtchrpos - 3, fmtchrpos + 3, opt,
    3277                 :            :                                "contraction %<%.*s%> in format; "
    3278                 :            :                                "use %qs instead",
    3279                 :            :                                6, format_chars - 3, "cannot");
    3280                 :            : 
    3281                 :       1220 :       return format_chars;
    3282                 :            :     }
    3283                 :            : 
    3284                 :       1658 :   if (baltoks.quotdirs.length ())
    3285                 :            :     {
    3286                 :            :       /* Skip over all plain text within a quoting directive until
    3287                 :            :          the next directive.  */
    3288                 :        212 :       while (*format_chars && '%' != *format_chars)
    3289                 :        136 :         ++format_chars;
    3290                 :            : 
    3291                 :         76 :       return format_chars;
    3292                 :            :     }
    3293                 :            : 
    3294                 :            :   /* The length of the problem sequence.  */
    3295                 :            :   int nchars = 0;
    3296                 :            : 
    3297                 :            :   /* Diagnose any whitespace characters other than <space> but only
    3298                 :            :      leading, trailing, and two or more consecutive <space>s.  Do
    3299                 :            :      this before diagnosing control characters because whitespace
    3300                 :            :      is a subset of controls.  */
    3301                 :            :   const char *other_than_space = NULL;
    3302                 :       2456 :   while (ISSPACE (format_chars[nchars]))
    3303                 :            :     {
    3304                 :        874 :       if (format_chars[nchars] != ' ' && !other_than_space)
    3305                 :         86 :         other_than_space = format_chars + nchars;
    3306                 :        874 :       ++nchars;
    3307                 :            :     }
    3308                 :            : 
    3309                 :       1582 :   if (nchars)
    3310                 :            :     {
    3311                 :            :       /* This is the most common problem: go the extra mile to describe
    3312                 :            :          the problem in as much helpful detail as possible.  */
    3313                 :        852 :       if (other_than_space)
    3314                 :            :         {
    3315                 :         86 :           format_warning_substr (format_string_loc, format_string_cst,
    3316                 :            :                                  fmtchrpos, fmtchrpos + nchars, opt,
    3317                 :            :                                  "unquoted whitespace character %qc in format",
    3318                 :         86 :                                  *other_than_space);
    3319                 :         86 :           return format_chars + nchars - 1;
    3320                 :            :         }
    3321                 :            : 
    3322                 :        766 :       if (fmtchrpos == 0)
    3323                 :            :         /* Accept strings of leading spaces with no warning.  */
    3324                 :          6 :         return format_chars + nchars - 1;
    3325                 :            : 
    3326                 :        760 :       if (!format_chars[nchars])
    3327                 :            :         {
    3328                 :          6 :           format_warning_substr (format_string_loc, format_string_cst,
    3329                 :            :                                  fmtchrpos, fmtchrpos + nchars, opt,
    3330                 :            :                                  "spurious trailing space in format");
    3331                 :          6 :           return format_chars + nchars - 1;
    3332                 :            :         }
    3333                 :            : 
    3334                 :        754 :       if (nchars > 1)
    3335                 :            :         {
    3336                 :         10 :           if (nchars == 2
    3337                 :         10 :               && orig_format_chars < format_chars
    3338                 :          8 :               && format_chars[-1] == '.'
    3339                 :          4 :               && format_chars[0] == ' '
    3340                 :          4 :               && format_chars[1] == ' ')
    3341                 :            :             {
    3342                 :            :               /* A period followed by two spaces.  */
    3343                 :          4 :               if (ISUPPER (*orig_format_chars))
    3344                 :            :                 {
    3345                 :            :                   /* If the part before the period is a capitalized
    3346                 :            :                      sentence check to make sure that what follows
    3347                 :            :                      is also capitalized.  */
    3348                 :          4 :                   if (ISLOWER (format_chars[2]))
    3349                 :          2 :                     format_warning_substr (format_string_loc, format_string_cst,
    3350                 :            :                                            fmtchrpos, fmtchrpos + nchars, opt,
    3351                 :            :                                            "inconsistent capitalization in "
    3352                 :            :                                            "format");
    3353                 :            :                 }
    3354                 :            :             }
    3355                 :            :           else
    3356                 :          6 :             format_warning_substr (format_string_loc, format_string_cst,
    3357                 :            :                                    fmtchrpos, fmtchrpos + nchars, opt,
    3358                 :            :                                    "unquoted sequence of %i consecutive "
    3359                 :            :                                    "space characters in format", nchars);
    3360                 :         10 :           return format_chars + nchars - 1;
    3361                 :            :         }
    3362                 :            : 
    3363                 :            :       format_chars += nchars;
    3364                 :            :       nchars = 0;
    3365                 :            :     }
    3366                 :            : 
    3367                 :       1474 :   fmtchrpos = format_chars - orig_format_chars;
    3368                 :            : 
    3369                 :            :   /* Diagnose any unquoted control characters other than the terminating
    3370                 :            :      NUL.  */
    3371                 :       1482 :   while (format_chars[nchars] && ISCNTRL (format_chars[nchars]))
    3372                 :          8 :     ++nchars;
    3373                 :            : 
    3374                 :       1474 :   if (nchars > 1)
    3375                 :            :     {
    3376                 :          0 :       format_warning_substr (format_string_loc, format_string_cst,
    3377                 :            :                              fmtchrpos, fmtchrpos + nchars, opt,
    3378                 :            :                              "unquoted control characters in format");
    3379                 :          0 :       return format_chars + nchars - 1;
    3380                 :            :     }
    3381                 :       1474 :   if (nchars)
    3382                 :            :     {
    3383                 :          8 :       format_warning_substr (format_string_loc, format_string_cst,
    3384                 :            :                              fmtchrpos, fmtchrpos + nchars, opt,
    3385                 :            :                              "unquoted control character %qc in format",
    3386                 :          8 :                              *format_chars);
    3387                 :          8 :       return format_chars + nchars - 1;
    3388                 :            :     }
    3389                 :            : 
    3390                 :       1466 :   if (ISPUNCT (format_chars[0]))
    3391                 :            :     {
    3392                 :        312 :       size_t nelts = sizeof c_opers / sizeof *c_opers;
    3393                 :        312 :       if (const char *ret = check_tokens (c_opers, nelts,
    3394                 :            :                                           format_string_loc, format_string_cst,
    3395                 :            :                                           orig_format_chars, format_chars,
    3396                 :            :                                           baltoks))
    3397                 :            :         return ret;
    3398                 :            : 
    3399                 :        264 :       nelts = c_dialect_cxx () ? sizeof cxx_opers / sizeof *cxx_opers : 0;
    3400                 :        264 :       if (const char *ret = check_tokens (cxx_opers, nelts,
    3401                 :            :                                           format_string_loc, format_string_cst,
    3402                 :            :                                           orig_format_chars, format_chars,
    3403                 :            :                                           baltoks))
    3404                 :            :         return ret;
    3405                 :            :     }
    3406                 :            : 
    3407                 :       1418 :   if (ISALPHA (format_chars[0]))
    3408                 :            :     {
    3409                 :       1078 :       size_t nelts = sizeof c_keywords / sizeof *c_keywords;
    3410                 :       1078 :       if (const char *ret = check_tokens (c_keywords, nelts,
    3411                 :            :                                           format_string_loc, format_string_cst,
    3412                 :            :                                           orig_format_chars, format_chars,
    3413                 :            :                                           baltoks))
    3414                 :            :         return ret;
    3415                 :            : 
    3416                 :          2 :       nelts = c_dialect_cxx () ? sizeof cxx_keywords / sizeof *cxx_keywords : 0;
    3417                 :          2 :       if (const char *ret = check_tokens (cxx_keywords, nelts,
    3418                 :            :                                           format_string_loc, format_string_cst,
    3419                 :            :                                           orig_format_chars, format_chars,
    3420                 :            :                                           baltoks))
    3421                 :            :         return ret;
    3422                 :            :     }
    3423                 :            : 
    3424                 :        340 :   nchars = 0;
    3425                 :            : 
    3426                 :            :   /* Diagnose unquoted options.  */
    3427                 :        340 :   if  ((format_chars == orig_format_chars
    3428                 :        300 :         || format_chars[-1] == ' ')
    3429                 :        174 :        && format_chars[0] == '-'
    3430                 :         12 :        && ((format_chars[1] == '-'
    3431                 :          2 :             && ISALPHA (format_chars[2]))
    3432                 :         10 :            || ISALPHA (format_chars[1])))
    3433                 :            :     {
    3434                 :            :       nchars = 1;
    3435                 :         32 :       while (ISALNUM (format_chars[nchars])
    3436                 :         10 :              || '_' == format_chars[nchars]
    3437                 :         10 :              || '-' == format_chars[nchars]
    3438                 :         40 :              || '+' == format_chars[nchars])
    3439                 :         24 :         ++nchars;
    3440                 :            : 
    3441                 :          8 :       format_warning_substr (format_string_loc, format_string_cst,
    3442                 :            :                              fmtchrpos, fmtchrpos + nchars, opt,
    3443                 :            :                              "unquoted option name %<%.*s%> in format",
    3444                 :            :                              nchars, format_chars);
    3445                 :          8 :       return format_chars + nchars - 1;
    3446                 :            :     }
    3447                 :            : 
    3448                 :            :   /* Diagnose leading, trailing, and two or more consecutive punctuation
    3449                 :            :      characters.  */
    3450                 :            :   const char *unbalanced = NULL;
    3451                 :        590 :   while ('%' != format_chars[nchars]
    3452                 :        542 :          && ISPUNCT (format_chars[nchars])
    3453                 :        850 :          && !unbalanced)
    3454                 :            :     {
    3455                 :        258 :       switch (format_chars[nchars])
    3456                 :            :         {
    3457                 :          0 :         case '[':
    3458                 :          0 :           baltoks.brackets.safe_push (format_chars + nchars);
    3459                 :          0 :           break;
    3460                 :          0 :         case '{':
    3461                 :          0 :           baltoks.curly.safe_push (format_chars + nchars);
    3462                 :          0 :           break;
    3463                 :         42 :         case '(':
    3464                 :         42 :           baltoks.parens.safe_push (format_chars + nchars);
    3465                 :         42 :           break;
    3466                 :          2 :         case '<':
    3467                 :          2 :           baltoks.pointy.safe_push (format_chars + nchars);
    3468                 :          2 :           break;
    3469                 :            : 
    3470                 :          0 :         case ']':
    3471                 :          0 :           if (baltoks.brackets.length () > 0)
    3472                 :          0 :             baltoks.brackets.pop ();
    3473                 :            :           else
    3474                 :            :             unbalanced = format_chars + nchars;
    3475                 :            :           break;
    3476                 :          0 :         case '}':
    3477                 :          0 :           if (baltoks.curly.length () > 0)
    3478                 :          0 :             baltoks.curly.pop ();
    3479                 :            :           else
    3480                 :            :             unbalanced = format_chars + nchars;
    3481                 :            :           break;
    3482                 :         46 :         case ')':
    3483                 :         46 :           if (baltoks.parens.length () > 0)
    3484                 :         38 :             baltoks.parens.pop ();
    3485                 :            :           else
    3486                 :            :             unbalanced = format_chars + nchars;
    3487                 :            :           break;
    3488                 :          2 :         case '>':
    3489                 :          2 :           if (baltoks.pointy.length () > 0)
    3490                 :          0 :             baltoks.pointy.pop ();
    3491                 :            :           else
    3492                 :            :             unbalanced = format_chars + nchars;
    3493                 :            :           break;
    3494                 :            :         }
    3495                 :            : 
    3496                 :        258 :       ++nchars;
    3497                 :            :     }
    3498                 :            : 
    3499                 :        332 :   if (unbalanced)
    3500                 :            :     {
    3501                 :         10 :       format_warning_substr (format_string_loc, format_string_cst,
    3502                 :            :                              fmtchrpos, fmtchrpos + nchars, opt,
    3503                 :            :                              "unbalanced punctuation character %qc in format",
    3504                 :         10 :                              *unbalanced);
    3505                 :         10 :       return format_chars + nchars - 1;
    3506                 :            :     }
    3507                 :            : 
    3508                 :        322 :   if (nchars)
    3509                 :            :     {
    3510                 :            :       /* Consider any identifier that follows the pound ('#') sign
    3511                 :            :          a preprocessing directive.  */
    3512                 :        200 :       if (nchars == 1
    3513                 :        158 :           && format_chars[0] == '#'
    3514                 :         12 :           && ISALPHA (format_chars[1]))
    3515                 :            :         {
    3516                 :         42 :           while (ISALNUM (format_chars[nchars])
    3517                 :         42 :                  || format_chars[nchars] == '_')
    3518                 :         36 :             ++nchars;
    3519                 :            : 
    3520                 :          6 :           format_warning_substr (format_string_loc, format_string_cst,
    3521                 :            :                                  fmtchrpos, fmtchrpos + nchars, opt,
    3522                 :            :                                  "unquoted preprocessing directive %<%.*s%> "
    3523                 :            :                                  "in format", nchars, format_chars);
    3524                 :          6 :           return format_chars + nchars - 1;
    3525                 :            :         }
    3526                 :            : 
    3527                 :            :       /* Diagnose a bare single quote.  */
    3528                 :        194 :       if (nchars == 1
    3529                 :        152 :           && format_chars[0] == '\''
    3530                 :          8 :           && format_chars - orig_format_chars
    3531                 :          8 :           && ISALPHA (format_chars[-1])
    3532                 :          8 :           && ISALPHA (format_chars[1]))
    3533                 :            :         {
    3534                 :            :           /* Diagnose a subset of contractions that are best avoided.  */
    3535                 :         52 :           for (unsigned i = 0; i != sizeof contrs / sizeof *contrs; ++i)
    3536                 :            :             {
    3537                 :         48 :               const char *apos = strchr (contrs[i].name, '\'');
    3538                 :         48 :               gcc_assert (apos != NULL);
    3539                 :         48 :               int off = apos - contrs[i].name;
    3540                 :            : 
    3541                 :         48 :               if (format_chars - orig_format_chars >= off
    3542                 :         24 :                   && !strncmp (format_chars - off,
    3543                 :         24 :                                contrs[i].name, contrs[i].len))
    3544                 :            :                 {
    3545                 :          4 :                   format_warning_substr (format_string_loc,
    3546                 :            :                                          format_string_cst,
    3547                 :            :                                          fmtchrpos, fmtchrpos + nchars, opt,
    3548                 :            :                                          "contraction %<%.*s%> in format; "
    3549                 :            :                                          "use %qs instead",
    3550                 :            :                                          contrs[i].len, contrs[i].name,
    3551                 :          4 :                                          contrs[i].alt);
    3552                 :          4 :                   return format_chars + nchars - 1;
    3553                 :            :                 }
    3554                 :            :             }
    3555                 :            : 
    3556                 :          4 :           if (format_warning_substr (format_string_loc, format_string_cst,
    3557                 :            :                                      fmtchrpos, fmtchrpos + nchars, opt,
    3558                 :            :                                      "bare apostrophe %<'%> in format"))
    3559                 :          4 :             inform (format_string_loc,
    3560                 :            :                     "if avoiding the apostrophe is not feasible, enclose "
    3561                 :            :                     "it in a pair of %qs and %qs directives instead",
    3562                 :            :                     "%<", "%>");
    3563                 :          4 :           return format_chars + nchars - 1;
    3564                 :            :         }
    3565                 :            : 
    3566                 :            :       /* Diagnose a backtick (grave accent).  */
    3567                 :        186 :       if (nchars == 1
    3568                 :        144 :           && format_chars[0] == '`')
    3569                 :            :         {
    3570                 :          0 :           if (format_warning_substr (format_string_loc, format_string_cst,
    3571                 :            :                                      fmtchrpos, fmtchrpos + nchars, opt,
    3572                 :            :                                      "grave accent %<`%> in format"))
    3573                 :          0 :             inform (format_string_loc,
    3574                 :            :                     "use the apostrophe directive %qs instead", "%'");
    3575                 :          0 :           return format_chars + nchars - 1;
    3576                 :            :         }
    3577                 :            : 
    3578                 :            :       /* Diagnose a punctuation character after a space.  */
    3579                 :        186 :       if (nchars == 1
    3580                 :        186 :           && format_chars - orig_format_chars
    3581                 :        128 :           && format_chars[-1] == ' '
    3582                 :         54 :           && strspn (format_chars, "!?:;.,") == 1)
    3583                 :            :         {
    3584                 :         10 :           format_warning_substr (format_string_loc, format_string_cst,
    3585                 :            :                                  fmtchrpos - 1, fmtchrpos, opt,
    3586                 :            :                                  "space followed by punctuation character "
    3587                 :         10 :                                  "%<%c%>", format_chars[0]);
    3588                 :         10 :           return format_chars;
    3589                 :            :         }
    3590                 :            : 
    3591                 :        176 :       if (nchars == 1)
    3592                 :            :         {
    3593                 :        134 :           if (!strncmp (format_chars, "\"%s\"", 4))
    3594                 :            :             {
    3595                 :          2 :               if (format_warning_substr (format_string_loc, format_string_cst,
    3596                 :            :                                          fmtchrpos, fmtchrpos + 4, opt,
    3597                 :            :                                          "quoted %qs directive in format",
    3598                 :            :                                          "%s"))
    3599                 :          2 :                 inform (format_string_loc, "if using %qs is not feasible, "
    3600                 :            :                         "use %qs instead", "%qs", "\"%-s\"");
    3601                 :            :             }
    3602                 :            : 
    3603                 :        134 :           if (format_chars[0] == '"')
    3604                 :            :             {
    3605                 :         18 :               baltoks.doublequote = baltoks.doublequote ? NULL : format_chars;
    3606                 :         18 :               return format_chars + nchars - 1;
    3607                 :            :             }
    3608                 :        116 :           if (format_chars[0] == '\'')
    3609                 :            :             {
    3610                 :          0 :               baltoks.singlequote = baltoks.singlequote ? NULL : format_chars;
    3611                 :          0 :               return format_chars + nchars - 1;
    3612                 :            :             }
    3613                 :            :         }
    3614                 :            : 
    3615                 :        158 :       if (fmtchrpos == 0)
    3616                 :            :         {
    3617                 :         16 :           if (nchars == 1
    3618                 :          8 :               && format_chars[0] == '(')
    3619                 :            :             ;   /* Text beginning in an open parenthesis.  */
    3620                 :         12 :           else if (nchars == 3
    3621                 :          2 :               && !strncmp (format_chars, "...", 3)
    3622                 :          2 :               && format_chars[3])
    3623                 :            :             ;   /* Text beginning in an ellipsis.  */
    3624                 :            :           else
    3625                 :            :             {
    3626                 :         10 :               format_warning_substr (format_string_loc, format_string_cst,
    3627                 :            :                                      fmtchrpos, fmtchrpos + nchars, opt,
    3628                 :            :                                      "spurious leading punctuation sequence "
    3629                 :            :                                      "%<%.*s%> in format",
    3630                 :            :                                      nchars, format_chars);
    3631                 :         10 :               return format_chars + nchars - 1;
    3632                 :            :             }
    3633                 :            :         }
    3634                 :        142 :       else if (!format_chars[nchars])
    3635                 :            :         {
    3636                 :         56 :           if (nchars == 1
    3637                 :         38 :               && (format_chars[nchars - 1] == ':'
    3638                 :         36 :                   || format_chars[nchars - 1] == ')'))
    3639                 :            :             ;   /* Text ending in a colon or a closing parenthesis.  */
    3640                 :         44 :           else if (nchars == 1
    3641                 :         26 :                    && ((ISUPPER (*orig_format_chars)
    3642                 :         16 :                         && format_chars[nchars - 1] == '.')
    3643                 :         14 :                        || strspn (format_chars + nchars - 1, "?])") == 1))
    3644                 :            :                   ;   /* Capitalized sentence terminated by a single period,
    3645                 :            :                          or text ending in a question mark, closing bracket,
    3646                 :            :                          or parenthesis.  */
    3647                 :         26 :           else if (nchars == 2
    3648                 :         16 :                    && format_chars[0] == '?'
    3649                 :          4 :                    && format_chars[1] == ')')
    3650                 :            :             ;   /* A question mark after a closing parenthetical note.  */
    3651                 :         22 :           else if (nchars == 2
    3652                 :         12 :                    && format_chars[0] == ')'
    3653                 :          6 :                    && (format_chars[1] == '?'
    3654                 :          6 :                        || format_chars[1] == ';'
    3655                 :          4 :                        || format_chars[1] == ':'
    3656                 :          2 :                        || (ISUPPER (*orig_format_chars)
    3657                 :          2 :                            && format_chars[1] == '.')))
    3658                 :            :             ;   /* Closing parenthetical note followed by a question mark,
    3659                 :            :                    semicolon, or colon at the end of the string, or by
    3660                 :            :                    a period at the end of a capitalized sentence.  */
    3661                 :         16 :           else if (nchars == 3
    3662                 :          2 :                    && format_chars - orig_format_chars > 0
    3663                 :          2 :                    && !strncmp (format_chars, "...", 3))
    3664                 :            :             ;   /* Text ending in the ellipsis.  */
    3665                 :            :           else
    3666                 :         14 :             format_warning_substr (format_string_loc, format_string_cst,
    3667                 :            :                                    fmtchrpos, fmtchrpos + nchars, opt,
    3668                 :            :                                    "spurious trailing punctuation sequence "
    3669                 :            :                                    "%<%.*s%> in format",
    3670                 :            :                                    nchars, format_chars);
    3671                 :            : 
    3672                 :         56 :           return format_chars + nchars - 1;
    3673                 :            :         }
    3674                 :         86 :       else if (nchars == 2
    3675                 :         14 :                && format_chars[0] == ')'
    3676                 :          8 :                && (format_chars[1] == ':'
    3677                 :            :                    || format_chars[1] == ';'
    3678                 :          8 :                    || format_chars[1] == ',')
    3679                 :          8 :                && format_chars[2] == ' ')
    3680                 :            :         ;   /* Closing parenthetical note followed by a colon, semicolon
    3681                 :            :                or a comma followed by a space in the middle of the string.  */
    3682                 :         78 :       else if (nchars > 1)
    3683                 :          8 :         format_warning_substr (format_string_loc, format_string_cst,
    3684                 :            :                                fmtchrpos, fmtchrpos + nchars, opt,
    3685                 :            :                                "unquoted sequence of %i consecutive "
    3686                 :            :                                "punctuation characters %q.*s in format",
    3687                 :            :                                nchars, nchars, format_chars);
    3688                 :         92 :       return format_chars + nchars - 1;
    3689                 :            :     }
    3690                 :            : 
    3691                 :            :   nchars = 0;
    3692                 :            : 
    3693                 :            :   /* Finally, diagnose any unquoted non-graph, non-punctuation characters
    3694                 :            :      other than the terminating NUL.  */
    3695                 :        126 :   while (format_chars[nchars]
    3696                 :        126 :          && '%' != format_chars[nchars]
    3697                 :         80 :          && !ISPUNCT (format_chars[nchars])
    3698                 :        126 :          && !ISGRAPH (format_chars[nchars]))
    3699                 :          4 :     ++nchars;
    3700                 :            : 
    3701                 :        122 :   if (nchars > 1)
    3702                 :            :     {
    3703                 :          0 :       format_warning_substr (format_string_loc, format_string_cst,
    3704                 :            :                              fmtchrpos, fmtchrpos + nchars, opt,
    3705                 :            :                              "unquoted non-graph characters in format");
    3706                 :          0 :       return format_chars + nchars - 1;
    3707                 :            :     }
    3708                 :        122 :   if (nchars)
    3709                 :            :     {
    3710                 :          4 :       format_warning_substr (format_string_loc, format_string_cst,
    3711                 :            :                              fmtchrpos, fmtchrpos + nchars, opt,
    3712                 :            :                              "unquoted non-graph character %qc in format",
    3713                 :          4 :                              *format_chars);
    3714                 :          4 :       return format_chars + nchars - 1;
    3715                 :            :     }
    3716                 :            : 
    3717                 :            :   return format_chars;
    3718                 :            : }
    3719                 :            : 
    3720                 :            : /* Diagnose unbalanced tokens described by BALTOKS in format string
    3721                 :            :    ORIG_FORMAT_CHARS and the corresponding FORMAT_STRING_CST.  */
    3722                 :            : 
    3723                 :            : static void
    3724                 :      26658 : maybe_diag_unbalanced_tokens (location_t format_string_loc,
    3725                 :            :                               const char *orig_format_chars,
    3726                 :            :                               tree format_string_cst,
    3727                 :            :                               baltoks_t &baltoks)
    3728                 :            : {
    3729                 :      26658 :   const char *unbalanced = NULL;
    3730                 :            : 
    3731                 :      26658 :   if (baltoks.brackets.length ())
    3732                 :          0 :     unbalanced = baltoks.brackets.pop ();
    3733                 :      26658 :   else if (baltoks.curly.length ())
    3734                 :          0 :     unbalanced = baltoks.curly.pop ();
    3735                 :      26658 :   else if (baltoks.parens.length ())
    3736                 :          6 :     unbalanced = baltoks.parens.pop ();
    3737                 :      26652 :   else if (baltoks.pointy.length ())
    3738                 :          2 :     unbalanced = baltoks.pointy.pop ();
    3739                 :            : 
    3740                 :          8 :   if (unbalanced)
    3741                 :          8 :     format_warning_at_char (format_string_loc, format_string_cst,
    3742                 :          8 :                             unbalanced - orig_format_chars + 1,
    3743                 :            :                             OPT_Wformat_diag,
    3744                 :            :                             "unbalanced punctuation character %<%c%> in format",
    3745                 :          8 :                             *unbalanced);
    3746                 :            : 
    3747                 :      26658 :   if (baltoks.quotdirs.length ())
    3748                 :          8 :     format_warning_at_char (format_string_loc, format_string_cst,
    3749                 :          8 :                             baltoks.quotdirs.pop () - orig_format_chars,
    3750                 :            :                             OPT_Wformat_,
    3751                 :            :                             "unterminated quoting directive");
    3752                 :            : 
    3753                 :      53316 :   const char *quote
    3754                 :      26658 :     = baltoks.singlequote ? baltoks.singlequote : baltoks.doublequote;
    3755                 :            : 
    3756                 :      26658 :   if (quote)
    3757                 :          2 :     format_warning_at_char (format_string_loc, format_string_cst,
    3758                 :          2 :                             quote - orig_format_chars + 1,
    3759                 :            :                             OPT_Wformat_diag,
    3760                 :            :                             "unterminated quote character %<%c%> in format",
    3761                 :          2 :                             *quote);
    3762                 :      26658 : }
    3763                 :            : 
    3764                 :            : /* Do the main part of checking a call to a format function.  FORMAT_CHARS
    3765                 :            :    is the NUL-terminated format string (which at this point may contain
    3766                 :            :    internal NUL characters); FORMAT_LENGTH is its length (excluding the
    3767                 :            :    terminating NUL character).  ARG_NUM is one less than the number of
    3768                 :            :    the first format argument to check; PARAMS points to that format
    3769                 :            :    argument in the list of arguments.  */
    3770                 :            : 
    3771                 :            : static void
    3772                 :      26682 : check_format_info_main (format_check_results *res,
    3773                 :            :                         function_format_info *info, const char *format_chars,
    3774                 :            :                         location_t fmt_param_loc, tree format_string_cst,
    3775                 :            :                         int format_length, tree params,
    3776                 :            :                         unsigned HOST_WIDE_INT arg_num,
    3777                 :            :                         object_allocator <format_wanted_type> &fwt_pool,
    3778                 :            :                         vec<location_t> *arglocs)
    3779                 :            : {
    3780                 :      26682 :   const char * const orig_format_chars = format_chars;
    3781                 :      26682 :   const tree first_fillin_param = params;
    3782                 :            : 
    3783                 :      26682 :   const format_kind_info * const fki = &format_types[info->format_type];
    3784                 :      26682 :   const format_flag_spec * const flag_specs = fki->flag_specs;
    3785                 :      26682 :   const location_t format_string_loc = res->format_string_loc;
    3786                 :            : 
    3787                 :            :   /* -1 if no conversions taking an operand have been found; 0 if one has
    3788                 :            :      and it didn't use $; 1 if $ formats are in use.  */
    3789                 :      26682 :   int has_operand_number = -1;
    3790                 :            : 
    3791                 :            :   /* Vectors of pointers to opening quoting directives (like GCC "%<"),
    3792                 :            :      opening braces, brackets, and parentheses.  Used to detect unbalanced
    3793                 :            :      tokens.  */
    3794                 :      53340 :   baltoks_t baltoks;
    3795                 :            : 
    3796                 :            :   /* Pointers to the most recent color directives (like GCC's "%r or %R").
    3797                 :            :      A starting color directive much be terminated before the end of
    3798                 :            :      the format string.  A terminating directive makes no sense without
    3799                 :            :      a prior starting directive.  */
    3800                 :      26682 :   const char *color_begin = NULL;
    3801                 :      26682 :   const char *color_end = NULL;
    3802                 :            : 
    3803                 :      26682 :   init_dollar_format_checking (info->first_arg_num, first_fillin_param);
    3804                 :            : 
    3805                 :            :   /* In GCC diagnostic functions check plain directives (substrings within
    3806                 :            :      the format string that don't start with %) for quoting and punctuations
    3807                 :            :      problems.  */
    3808                 :      26682 :   bool ck_plain = (!info->is_raw
    3809                 :      26682 :                    && (info->format_type == gcc_diag_format_type
    3810                 :            :                        || info->format_type == gcc_tdiag_format_type
    3811                 :            :                        || info->format_type == gcc_cdiag_format_type
    3812                 :      26660 :                        || info->format_type == gcc_cxxdiag_format_type));
    3813                 :            : 
    3814                 :     682782 :   while (*format_chars != 0)
    3815                 :            :     {
    3816                 :     656124 :       if (ck_plain)
    3817                 :       2878 :         format_chars = check_plain (format_string_loc,
    3818                 :            :                                     format_string_cst,
    3819                 :            :                                     orig_format_chars, format_chars,
    3820                 :            :                                     baltoks);
    3821                 :            : 
    3822                 :     656124 :       if (*format_chars == 0 || *format_chars++ != '%')
    3823                 :     617565 :         continue;
    3824                 :            : 
    3825                 :      39597 :       if (*format_chars == 0)
    3826                 :            :         {
    3827                 :        136 :           format_warning_at_char (format_string_loc, format_string_cst,
    3828                 :        136 :                                   format_chars - orig_format_chars,
    3829                 :            :                                   OPT_Wformat_,
    3830                 :            :                                   "spurious trailing %<%%%> in format");
    3831                 :        136 :           continue;
    3832                 :            :         }
    3833                 :      39461 :       if (*format_chars == '%')
    3834                 :            :         {
    3835                 :        105 :           ++format_chars;
    3836                 :        105 :           continue;
    3837                 :            :         }
    3838                 :            : 
    3839                 :            :       /* ARGUMENT_PARSER ctor takes FORMAT_CHARS by reference and calls
    3840                 :            :          to ARG_PARSER members may modify the variable.  */
    3841                 :      39356 :       flag_chars_t flag_chars;
    3842                 :      39356 :       argument_parser arg_parser (info, format_chars, format_string_cst,
    3843                 :            :                                   orig_format_chars, format_string_loc,
    3844                 :            :                                   flag_chars, has_operand_number,
    3845                 :      39356 :                                   first_fillin_param, fwt_pool, arglocs);
    3846                 :            : 
    3847                 :      39356 :       if (!arg_parser.read_any_dollar ())
    3848                 :         24 :         return;
    3849                 :            : 
    3850                 :      39346 :       if (!arg_parser.read_format_flags ())
    3851                 :            :         return;
    3852                 :            : 
    3853                 :            :       /* Read any format width, possibly * or *m$.  */
    3854                 :      39344 :       if (!arg_parser.read_any_format_width (params, arg_num))
    3855                 :            :         return;
    3856                 :            : 
    3857                 :            :       /* Read any format left precision (must be a number, not *).  */
    3858                 :      39340 :       arg_parser.read_any_format_left_precision ();
    3859                 :            : 
    3860                 :            :       /* Read any format precision, possibly * or *m$.  */
    3861                 :      39340 :       if (!arg_parser.read_any_format_precision (params, arg_num))
    3862                 :            :         return;
    3863                 :            : 
    3864                 :      39338 :       const char *format_start = format_chars;
    3865                 :            : 
    3866                 :      39338 :       arg_parser.handle_alloc_chars ();
    3867                 :            : 
    3868                 :            :       /* The rest of the conversion specification is the length modifier
    3869                 :            :          (if any), and the conversion specifier, so this is where the
    3870                 :            :          type information starts.  If we need to issue a suggestion
    3871                 :            :          about a type mismatch, then we should preserve everything up
    3872                 :            :          to here. */
    3873                 :      39338 :       const char *type_start = format_chars;
    3874                 :            : 
    3875                 :            :       /* Read any length modifier, if this kind of format has them.  */
    3876                 :      39338 :       const length_modifier len_modifier
    3877                 :      39338 :         = arg_parser.read_any_length_modifier ();
    3878                 :            : 
    3879                 :            :       /* Read any modifier (strftime E/O).  */
    3880                 :      39338 :       arg_parser.read_any_other_modifier ();
    3881                 :            : 
    3882                 :      39338 :       char format_char = *format_chars;
    3883                 :      39338 :       if (format_char == 0
    3884                 :      39328 :           || (!(fki->flags & (int) FMT_FLAG_FANCY_PERCENT_OK)
    3885                 :      38514 :               && format_char == '%'))
    3886                 :            :         {
    3887                 :         42 :           format_warning_at_char (format_string_loc, format_string_cst,
    3888                 :         42 :                              format_chars - orig_format_chars,
    3889                 :            :                              OPT_Wformat_,
    3890                 :            :                              "conversion lacks type at end of format");
    3891                 :         42 :           continue;
    3892                 :            :         }
    3893                 :      39296 :       format_chars++;
    3894                 :            : 
    3895                 :      39296 :       const format_char_info * const fci
    3896                 :      39296 :         = arg_parser.find_format_char_info (format_char);
    3897                 :      39296 :       if (!fci)
    3898                 :        189 :         continue;
    3899                 :            : 
    3900                 :      39107 :       flag_chars.validate (fki, fci, flag_specs, format_chars,
    3901                 :            :                            format_string_cst,
    3902                 :            :                            format_string_loc, orig_format_chars, format_char,
    3903                 :      39107 :                            baltoks.quotdirs.length () > 0);
    3904                 :            : 
    3905                 :      39107 :       const int alloc_flag = flag_chars.get_alloc_flag (fki);
    3906                 :      39107 :       const bool suppressed = flag_chars.assignment_suppression_p (fki);
    3907                 :            : 
    3908                 :            :       /* Diagnose nested or unmatched quoting directives such as GCC's
    3909                 :            :          "%<...%<" and "%>...%>".  */
    3910                 :      39107 :       bool quot_begin_p = strchr (fci->flags2, '<');
    3911                 :      39107 :       bool quot_end_p = strchr (fci->flags2, '>');
    3912                 :            : 
    3913                 :      39107 :       if (quot_begin_p && !quot_end_p)
    3914                 :            :         {
    3915                 :        206 :           if (baltoks.quotdirs.length ())
    3916                 :          8 :             format_warning_at_char (format_string_loc, format_string_cst,
    3917                 :          8 :                                     format_chars - orig_format_chars,
    3918                 :            :                                     OPT_Wformat_,
    3919                 :            :                                     "nested quoting directive");
    3920                 :        206 :           baltoks.quotdirs.safe_push (format_chars);
    3921                 :            :         }
    3922                 :      38901 :       else if (!quot_begin_p && quot_end_p)
    3923                 :            :         {
    3924                 :        206 :           if (baltoks.quotdirs.length ())
    3925                 :        198 :             baltoks.quotdirs.pop ();
    3926                 :            :           else
    3927                 :          8 :             format_warning_at_char (format_string_loc, format_string_cst,
    3928                 :          8 :                                     format_chars - orig_format_chars,
    3929                 :            :                                     OPT_Wformat_,
    3930                 :            :                                     "unmatched quoting directive");
    3931                 :            :         }
    3932                 :            : 
    3933                 :      39107 :       bool color_begin_p = strchr (fci->flags2, '/');
    3934                 :      39107 :       if (color_begin_p)
    3935                 :            :         {
    3936                 :        102 :           color_begin = format_chars;
    3937                 :        102 :           color_end = NULL;
    3938                 :            :         }
    3939                 :      39005 :       else if (strchr (fci->flags2, '\\'))
    3940                 :            :         {
    3941                 :         74 :           if (color_end)
    3942                 :          0 :             format_warning_at_char (format_string_loc, format_string_cst,
    3943                 :          0 :                                     format_chars - orig_format_chars,
    3944                 :            :                                     OPT_Wformat_,
    3945                 :            :                                     "%qc directive redundant after prior "
    3946                 :            :                                     "occurence of the same", format_char);
    3947                 :         74 :           else if (!color_begin)
    3948                 :         20 :             format_warning_at_char (format_string_loc, format_string_cst,
    3949                 :         20 :                                     format_chars - orig_format_chars,
    3950                 :            :                                     OPT_Wformat_,
    3951                 :            :                                     "unmatched color reset directive");
    3952                 :         74 :           color_end = format_chars;
    3953                 :            :         }
    3954                 :            : 
    3955                 :            :       /* Diagnose directives that shouldn't appear in a quoted sequence.
    3956                 :            :          (They are denoted by a double quote in FLAGS2.)  */
    3957                 :      39107 :       if (baltoks.quotdirs.length ())
    3958                 :            :         {
    3959                 :        424 :           if (strchr (fci->flags2, '"'))
    3960                 :          8 :             format_warning_at_char (format_string_loc, format_string_cst,
    3961                 :          8 :                                     format_chars - orig_format_chars,
    3962                 :            :                                     OPT_Wformat_,
    3963                 :            :                                     "%qc conversion used within a quoted "
    3964                 :            :                                     "sequence",
    3965                 :            :                                     format_char);
    3966                 :            :         }
    3967                 :            : 
    3968                 :            :       /* Validate the pairs of flags used.  */
    3969                 :      39107 :       arg_parser.validate_flag_pairs (fci, format_char);
    3970                 :            : 
    3971                 :      39107 :       arg_parser.give_y2k_warnings (fci, format_char);
    3972                 :            : 
    3973                 :      39107 :       arg_parser.parse_any_scan_set (fci);
    3974                 :            : 
    3975                 :      39107 :       tree wanted_type = NULL;
    3976                 :      39107 :       const char *wanted_type_name = NULL;
    3977                 :            : 
    3978                 :      39107 :       if (!arg_parser.handle_conversions (fci, len_modifier,
    3979                 :            :                                           wanted_type, wanted_type_name,
    3980                 :            :                                           arg_num,
    3981                 :            :                                           params,
    3982                 :            :                                           format_char))
    3983                 :        566 :         continue;
    3984                 :            : 
    3985                 :      38541 :       arg_parser.main_wanted_type.next = NULL;
    3986                 :            : 
    3987                 :            :       /* Finally. . .check type of argument against desired type!  */
    3988                 :      38541 :       if (!arg_parser.check_argument_type (fci, len_modifier,
    3989                 :            :                                            wanted_type, wanted_type_name,
    3990                 :            :                                            suppressed,
    3991                 :            :                                            arg_num, params,
    3992                 :            :                                            alloc_flag,
    3993                 :            :                                            format_start, type_start,
    3994                 :            :                                            fmt_param_loc,
    3995                 :            :                                            format_char))
    3996                 :            :         return;
    3997                 :            :     }
    3998                 :            : 
    3999                 :      26658 :   if (format_chars - orig_format_chars != format_length)
    4000                 :         36 :     format_warning_at_char (format_string_loc, format_string_cst,
    4001                 :         36 :                             format_chars + 1 - orig_format_chars,
    4002                 :            :                             OPT_Wformat_contains_nul,
    4003                 :            :                             "embedded %<\\0%> in format");
    4004                 :      26658 :   if (info->first_arg_num != 0 && params != 0
    4005                 :        250 :       && has_operand_number <= 0)
    4006                 :            :     {
    4007                 :        213 :       res->number_other--;
    4008                 :        213 :       res->number_extra_args++;
    4009                 :            :     }
    4010                 :      26658 :   if (has_operand_number > 0)
    4011                 :         80 :     finish_dollar_format_checking (res, fki->flags & (int) FMT_FLAG_DOLLAR_GAP_POINTER_OK);
    4012                 :            : 
    4013                 :      26658 :   maybe_diag_unbalanced_tokens (format_string_loc, orig_format_chars,
    4014                 :            :                                 format_string_cst, baltoks);
    4015                 :            : 
    4016                 :      26658 :   if (color_begin && !color_end)
    4017                 :         28 :     format_warning_at_char (format_string_loc, format_string_cst,
    4018                 :         28 :                             color_begin - orig_format_chars,
    4019                 :            :                             OPT_Wformat_, "unterminated color directive");
    4020                 :            : }
    4021                 :            : 
    4022                 :            : /* Check the argument types from a single format conversion (possibly
    4023                 :            :    including width and precision arguments).
    4024                 :            : 
    4025                 :            :    FMT_LOC is the location of the format conversion.
    4026                 :            : 
    4027                 :            :    TYPES is a singly-linked list expressing the parts of the format
    4028                 :            :    conversion that expect argument types, and the arguments they
    4029                 :            :    correspond to.
    4030                 :            : 
    4031                 :            :    OFFSET_TO_TYPE_START is the offset within the execution-charset encoded
    4032                 :            :    format string to where type information begins for the conversion
    4033                 :            :    (the length modifier and conversion specifier).
    4034                 :            : 
    4035                 :            :    CONVERSION_CHAR is the user-provided conversion specifier.
    4036                 :            : 
    4037                 :            :    For example, given:
    4038                 :            : 
    4039                 :            :      sprintf (d, "before %-+*.*lld after", arg3, arg4, arg5);
    4040                 :            : 
    4041                 :            :    then FMT_LOC covers this range:
    4042                 :            : 
    4043                 :            :      sprintf (d, "before %-+*.*lld after", arg3, arg4, arg5);
    4044                 :            :                          ^^^^^^^^^
    4045                 :            : 
    4046                 :            :    and TYPES in this case is a three-entry singly-linked list consisting of:
    4047                 :            :    (1) the check for the field width here:
    4048                 :            :          sprintf (d, "before %-+*.*lld after", arg3, arg4, arg5);
    4049                 :            :                                 ^              ^^^^
    4050                 :            :        against arg3, and
    4051                 :            :    (2) the check for the field precision here:
    4052                 :            :          sprintf (d, "before %-+*.*lld after", arg3, arg4, arg5);
    4053                 :            :                                  ^^                  ^^^^
    4054                 :            :        against arg4, and
    4055                 :            :    (3) the check for the length modifier and conversion char here:
    4056                 :            :          sprintf (d, "before %-+*.*lld after", arg3, arg4, arg5);
    4057                 :            :                                    ^^^                     ^^^^
    4058                 :            :        against arg5.
    4059                 :            : 
    4060                 :            :    OFFSET_TO_TYPE_START is 13, the offset to the "lld" within the
    4061                 :            :    STRING_CST:
    4062                 :            : 
    4063                 :            :                   0000000000111111111122
    4064                 :            :                   0123456789012345678901
    4065                 :            :      sprintf (d, "before %-+*.*lld after", arg3, arg4, arg5);
    4066                 :            :                                ^ ^
    4067                 :            :                                | ` CONVERSION_CHAR: 'd'
    4068                 :            :                                type starts here.  */
    4069                 :            : 
    4070                 :            : static void
    4071                 :      36593 : check_format_types (const substring_loc &fmt_loc,
    4072                 :            :                     format_wanted_type *types, const format_kind_info *fki,
    4073                 :            :                     int offset_to_type_start,
    4074                 :            :                     char conversion_char,
    4075                 :            :                     vec<location_t> *arglocs)
    4076                 :            : {
    4077                 :      74681 :   for (; types != 0; types = types->next)
    4078                 :            :     {
    4079                 :      38088 :       tree cur_param;
    4080                 :      38088 :       tree cur_type;
    4081                 :      38088 :       tree orig_cur_type;
    4082                 :      38088 :       tree wanted_type;
    4083                 :      38088 :       int arg_num;
    4084                 :      38088 :       int i;
    4085                 :      38088 :       int char_type_flag;
    4086                 :            : 
    4087                 :      38088 :       wanted_type = types->wanted_type;
    4088                 :      38088 :       arg_num = types->arg_num;
    4089                 :            : 
    4090                 :            :       /* The following should not occur here.  */
    4091                 :      38088 :       gcc_assert (wanted_type);
    4092                 :      38088 :       gcc_assert (wanted_type != void_type_node || types->pointer_count);
    4093                 :            : 
    4094                 :      38088 :       if (types->pointer_count == 0)
    4095                 :      29918 :         wanted_type = lang_hooks.types.type_promotes_to (wanted_type);
    4096                 :            : 
    4097                 :      38088 :       wanted_type = TYPE_MAIN_VARIANT (wanted_type);
    4098                 :            : 
    4099                 :      38088 :       cur_param = types->param;
    4100                 :      38088 :       if (!cur_param)
    4101                 :            :         {
    4102                 :         63 :           format_type_warning (fmt_loc, UNKNOWN_LOCATION, types, wanted_type,
    4103                 :            :                                NULL, fki, offset_to_type_start,
    4104                 :            :                                conversion_char);
    4105                 :         63 :           continue;
    4106                 :            :         }
    4107                 :            : 
    4108                 :      38025 :       cur_type = TREE_TYPE (cur_param);
    4109                 :      38025 :       if (cur_type == error_mark_node)
    4110                 :          0 :         continue;
    4111                 :      38025 :       orig_cur_type = cur_type;
    4112                 :      38025 :       char_type_flag = 0;
    4113                 :            : 
    4114                 :      38025 :       location_t param_loc = UNKNOWN_LOCATION;
    4115                 :      38025 :       if (EXPR_HAS_LOCATION (cur_param))
    4116                 :      25613 :         param_loc = EXPR_LOCATION (cur_param);
    4117                 :      12412 :       else if (arglocs)
    4118                 :            :         {
    4119                 :            :           /* arg_num is 1-based.  */
    4120                 :      12398 :           gcc_assert (types->arg_num > 0);
    4121                 :      12398 :           param_loc = (*arglocs)[types->arg_num - 1];
    4122                 :            :         }
    4123                 :            : 
    4124                 :      38025 :       STRIP_NOPS (cur_param);
    4125                 :            : 
    4126                 :            :       /* Check the types of any additional pointer arguments
    4127                 :            :          that precede the "real" argument.  */
    4128                 :      46222 :       for (i = 0; i < types->pointer_count; ++i)
    4129                 :            :         {
    4130                 :       8292 :           if (TREE_CODE (cur_type) == POINTER_TYPE)
    4131                 :            :             {
    4132                 :       8197 :               cur_type = TREE_TYPE (cur_type);
    4133                 :       8197 :               if (cur_type == error_mark_node)
    4134                 :            :                 break;
    4135                 :            : 
    4136                 :            :               /* Check for writing through a NULL pointer.  */
    4137                 :       8197 :               if (types->writing_in_flag
    4138                 :       1404 :                   && i == 0
    4139                 :       1404 :                   && cur_param != 0
    4140                 :       9465 :                   && integer_zerop (cur_param))
    4141                 :          4 :                 warning (OPT_Wformat_, "writing through null pointer "
    4142                 :            :                          "(argument %d)", arg_num);
    4143                 :            : 
    4144                 :            :               /* Check for reading through a NULL pointer.  Ignore
    4145                 :            :                  printf-family of functions as they are checked for
    4146                 :            :                  null arguments by the middle-end.  */
    4147                 :       8197 :               if (fki->conversion_specs != print_char_table
    4148                 :       1769 :                   && types->reading_from_flag
    4149                 :        158 :                   && i == 0
    4150                 :        158 :                   && cur_param != 0
    4151                 :       8355 :                   && integer_zerop (cur_param))
    4152                 :          4 :                 warning (OPT_Wformat_, "reading through null pointer "
    4153                 :            :                          "(argument %d)", arg_num);
    4154                 :            : 
    4155                 :       8197 :               if (cur_param != 0 && TREE_CODE (cur_param) == ADDR_EXPR)
    4156                 :       2261 :                 cur_param = TREE_OPERAND (cur_param, 0);
    4157                 :            :               else
    4158                 :            :                 cur_param = 0;
    4159                 :            : 
    4160                 :            :               /* See if this is an attempt to write into a const type with
    4161                 :            :                  scanf or with printf "%n".  Note: the writing in happens
    4162                 :            :                  at the first indirection only, if for example
    4163                 :            :                  void * const * is passed to scanf %p; passing
    4164                 :            :                  const void ** is simply passing an incompatible type.  */
    4165                 :       8197 :               if (types->writing_in_flag
    4166                 :       1404 :                   && i == 0
    4167                 :       8197 :                   && (TYPE_READONLY (cur_type)
    4168                 :       1258 :                       || (cur_param != 0
    4169                 :         21 :                           && (CONSTANT_CLASS_P (cur_param)
    4170                 :         21 :                               || (DECL_P (cur_param)
    4171                 :       1289 :                                   && TREE_READONLY (cur_param))))))
    4172                 :         10 :                 warning (OPT_Wformat_, "writing into constant object "
    4173                 :            :                          "(argument %d)", arg_num);
    4174                 :            : 
    4175                 :            :               /* If there are extra type qualifiers beyond the first
    4176                 :            :                  indirection, then this makes the types technically
    4177                 :            :                  incompatible.  */
    4178                 :       8197 :               if (i > 0
    4179                 :        136 :                   && pedantic
    4180                 :       8197 :                   && (TYPE_READONLY (cur_type)
    4181                 :         40 :                       || TYPE_VOLATILE (cur_type)
    4182                 :         38 :                       || TYPE_ATOMIC (cur_type)
    4183                 :         38 :                       || TYPE_RESTRICT (cur_type)))
    4184                 :          2 :                 warning (OPT_Wformat_, "extra type qualifiers in format "
    4185                 :            :                          "argument (argument %d)",
    4186                 :            :                          arg_num);
    4187                 :            : 
    4188                 :            :             }
    4189                 :            :           else
    4190                 :            :             {
    4191                 :         95 :               format_type_warning (fmt_loc, param_loc,
    4192                 :            :                                    types, wanted_type, orig_cur_type, fki,
    4193                 :            :                                    offset_to_type_start, conversion_char);
    4194                 :         95 :               break;
    4195                 :            :             }
    4196                 :            :         }
    4197                 :            : 
    4198                 :      38025 :       if (i < types->pointer_count)
    4199                 :         95 :         continue;
    4200                 :            : 
    4201                 :      37930 :       cur_type = TYPE_MAIN_VARIANT (cur_type);
    4202                 :            : 
    4203                 :            :       /* Check whether the argument type is a character type.  This leniency
    4204                 :            :          only applies to certain formats, flagged with 'c'.  */
    4205                 :      37930 :       if (types->char_lenient_flag)
    4206                 :       6675 :         char_type_flag = (cur_type == char_type_node
    4207                 :        686 :                           || cur_type == signed_char_type_node
    4208                 :       7347 :                           || cur_type == unsigned_char_type_node);
    4209                 :            : 
    4210                 :            :       /* Check the type of the "real" argument, if there's a type we want.  */
    4211                 :      37930 :       if (lang_hooks.types_compatible_p (wanted_type, cur_type))
    4212                 :      36144 :         continue;
    4213                 :            :       /* If we want 'void *', allow any pointer type.
    4214                 :            :          (Anything else would already have got a warning.)
    4215                 :            :          With -Wpedantic, only allow pointers to void and to character
    4216                 :            :          types.  */
    4217                 :       1786 :       if (wanted_type == void_type_node
    4218                 :         64 :           && (!pedantic || (i == 1 && char_type_flag)))
    4219                 :         58 :         continue;
    4220                 :            :       /* Don't warn about differences merely in signedness, unless
    4221                 :            :          -Wpedantic.  With -Wpedantic, warn if the type is a pointer
    4222                 :            :          target and not a character type, and for character types at
    4223                 :            :          a second level of indirection.  */
    4224                 :       2666 :       if (TREE_CODE (wanted_type) == INTEGER_TYPE
    4225                 :       1476 :           && TREE_CODE (cur_type) == INTEGER_TYPE
    4226                 :       1312 :           && ((!pedantic && !warn_format_signedness)
    4227                 :       1312 :               || (i == 0 && !warn_format_signedness)
    4228                 :         92 :               || (i == 1 && char_type_flag))
    4229                 :       2369 :           && (TYPE_UNSIGNED (wanted_type)
    4230                 :       1238 :               ? wanted_type == c_common_unsigned_type (cur_type)
    4231                 :       1238 :               : wanted_type == c_common_signed_type (cur_type)))
    4232                 :        938 :         continue;
    4233                 :            :       /* Don't warn about differences merely in signedness if we know
    4234                 :            :          that the current type is integer-promoted and its original type
    4235                 :            :          was unsigned such as that it is in the range of WANTED_TYPE.  */
    4236                 :        790 :       if (TREE_CODE (wanted_type) == INTEGER_TYPE
    4237                 :        538 :           && TREE_CODE (cur_type) == INTEGER_TYPE
    4238                 :        374 :           && warn_format_signedness
    4239                 :         40 :           && TYPE_UNSIGNED (wanted_type)
    4240                 :         32 :           && cur_param != NULL_TREE
    4241                 :        821 :           && TREE_CODE (cur_param) == NOP_EXPR)
    4242                 :            :         {
    4243                 :         20 :           tree t = TREE_TYPE (TREE_OPERAND (cur_param, 0));
    4244                 :         20 :           if (TYPE_UNSIGNED (t)
    4245                 :         20 :               && cur_type == lang_hooks.types.type_promotes_to (t))
    4246                 :         10 :             continue;
    4247                 :            :         }
    4248                 :            :       /* Likewise, "signed char", "unsigned char" and "char" are
    4249                 :            :          equivalent but the above test won't consider them equivalent.  */
    4250                 :        780 :       if (wanted_type == char_type_node
    4251                 :         44 :           && (!pedantic || i < 2)
    4252                 :         44 :           && char_type_flag)
    4253                 :         18 :         continue;
    4254                 :        762 :       if (types->scalar_identity_flag
    4255                 :          0 :           && (TREE_CODE (cur_type) == TREE_CODE (wanted_type)
    4256                 :          0 :               || (INTEGRAL_TYPE_P (cur_type)
    4257                 :          0 :                   && INTEGRAL_TYPE_P (wanted_type)))
    4258                 :        762 :           && TYPE_PRECISION (cur_type) == TYPE_PRECISION (wanted_type))
    4259                 :          0 :         continue;
    4260                 :            :       /* Now we have a type mismatch.  */
    4261                 :        762 :       format_type_warning (fmt_loc, param_loc, types,
    4262                 :            :                            wanted_type, orig_cur_type, fki,
    4263                 :            :                            offset_to_type_start, conversion_char);
    4264                 :            :     }
    4265                 :      36593 : }
    4266                 :            : 
    4267                 :            : /* Given type TYPE, attempt to dereference the type N times
    4268                 :            :    (e.g. from ("int ***", 2) to "int *")
    4269                 :            : 
    4270                 :            :    Return the derefenced type, with any qualifiers
    4271                 :            :    such as "const" stripped from the result, or
    4272                 :            :    NULL if unsuccessful (e.g. TYPE is not a pointer type).  */
    4273                 :            : 
    4274                 :            : static tree
    4275                 :       2545 : deref_n_times (tree type, int n)
    4276                 :            : {
    4277                 :       2545 :   gcc_assert (type);
    4278                 :            : 
    4279                 :       3182 :   for (int i = n; i > 0; i--)
    4280                 :            :     {
    4281                 :        810 :       if (TREE_CODE (type) != POINTER_TYPE)
    4282                 :            :         return NULL_TREE;
    4283                 :        637 :       type = TREE_TYPE (type);
    4284                 :            :     }
    4285                 :            :   /* Strip off any "const" etc.  */
    4286                 :       2372 :   return build_qualified_type (type, 0);
    4287                 :            : }
    4288                 :            : 
    4289                 :            : /* Lookup the format code for FORMAT_LEN within FLI,
    4290                 :            :    returning the string code for expressing it, or NULL
    4291                 :            :    if it is not found.  */
    4292                 :            : 
    4293                 :            : static const char *
    4294                 :          0 : get_modifier_for_format_len (const format_length_info *fli,
    4295                 :            :                              enum format_lengths format_len)
    4296                 :            : {
    4297                 :       3252 :   for (; fli->name; fli++)
    4298                 :            :     {
    4299                 :       3252 :       if (fli->index == format_len)
    4300                 :          0 :         return fli->name;
    4301                 :       3010 :       if (fli->double_index == format_len)
    4302                 :        512 :         return fli->double_name;
    4303                 :            :     }
    4304                 :            :   return NULL;
    4305                 :            : }
    4306                 :            : 
    4307                 :            : #if CHECKING_P
    4308                 :            : 
    4309                 :            : namespace selftest {
    4310                 :            : 
    4311                 :            : static void
    4312                 :          2 : test_get_modifier_for_format_len ()
    4313                 :            : {
    4314                 :          2 :   ASSERT_STREQ ("h",
    4315                 :            :                 get_modifier_for_format_len (printf_length_specs, FMT_LEN_h));
    4316                 :          2 :   ASSERT_STREQ ("hh",
    4317                 :            :                 get_modifier_for_format_len (printf_length_specs, FMT_LEN_hh));
    4318                 :          4 :   ASSERT_STREQ ("L",
    4319                 :            :                 get_modifier_for_format_len (printf_length_specs, FMT_LEN_L));
    4320                 :          4 :   ASSERT_EQ (NULL,
    4321                 :            :              get_modifier_for_format_len (printf_length_specs, FMT_LEN_none));
    4322                 :          2 : }
    4323                 :            : 
    4324                 :            : } // namespace selftest
    4325                 :            : 
    4326                 :            : #endif /* CHECKING_P */
    4327                 :            : 
    4328                 :            : /* Determine if SPEC_TYPE and ARG_TYPE are sufficiently similar for a
    4329                 :            :    format_type_detail using SPEC_TYPE to be offered as a suggestion for
    4330                 :            :    Wformat type errors where the argument has type ARG_TYPE.  */
    4331                 :            : 
    4332                 :            : static bool
    4333                 :      11280 : matching_type_p (tree spec_type, tree arg_type)
    4334                 :            : {
    4335                 :      11280 :   gcc_assert (spec_type);
    4336                 :      11280 :   gcc_assert (arg_type);
    4337                 :            : 
    4338                 :            :   /* If any of the types requires structural equality, we can't compare
    4339                 :            :      their canonical types.  */
    4340                 :      11280 :   if (TYPE_STRUCTURAL_EQUALITY_P (spec_type)
    4341                 :      22560 :       || TYPE_STRUCTURAL_EQUALITY_P (arg_type))
    4342                 :            :     return false;
    4343                 :            : 
    4344                 :      10368 :   spec_type = TYPE_CANONICAL (spec_type);
    4345                 :      10368 :   arg_type = TYPE_CANONICAL (arg_type);
    4346                 :            : 
    4347                 :      10368 :   if (TREE_CODE (spec_type) == INTEGER_TYPE
    4348                 :       7125 :       && TREE_CODE (arg_type) == INTEGER_TYPE
    4349                 :      10782 :       && (TYPE_UNSIGNED (spec_type)
    4350                 :       1169 :           ? spec_type == c_common_unsigned_type (arg_type)
    4351                 :       1169 :           : spec_type == c_common_signed_type (arg_type)))
    4352                 :        411 :     return true;
    4353                 :            : 
    4354                 :       9957 :   return spec_type == arg_type;
    4355                 :            : }
    4356                 :            : 
    4357                 :            : /* Subroutine of get_format_for_type.
    4358                 :            : 
    4359                 :            :    Generate a string containing the length modifier and conversion specifier
    4360                 :            :    that should be used to format arguments of type ARG_TYPE within FKI
    4361                 :            :    (effectively the inverse of the checking code).
    4362                 :            : 
    4363                 :            :    If CONVERSION_CHAR is not zero (the first pass), the resulting suggestion
    4364                 :            :    is required to use it, for correcting bogus length modifiers.
    4365                 :            :    If CONVERSION_CHAR is zero (the second pass), then allow any suggestion
    4366                 :            :    that matches ARG_TYPE.
    4367                 :            : 
    4368                 :            :    If successful, returns a non-NULL string which should be freed
    4369                 :            :    by the caller.
    4370                 :            :    Otherwise, returns NULL.  */
    4371                 :            : 
    4372                 :            : static char *
    4373                 :       1106 : get_format_for_type_1 (const format_kind_info *fki, tree arg_type,
    4374                 :            :                        char conversion_char)
    4375                 :            : {
    4376                 :       1106 :   gcc_assert (arg_type);
    4377                 :            : 
    4378                 :       1106 :   const format_char_info *spec;
    4379                 :       8177 :   for (spec = &fki->conversion_specs[0];
    4380                 :       8177 :        spec->format_chars;
    4381                 :            :        spec++)
    4382                 :            :     {
    4383                 :       7821 :       if (conversion_char)
    4384                 :       6088 :         if (!strchr (spec->format_chars, conversion_char))
    4385                 :       5276 :           continue;
    4386                 :            : 
    4387                 :       5090 :       tree effective_arg_type = deref_n_times (arg_type,
    4388                 :       2545 :                                                spec->pointer_count);
    4389                 :       2545 :       if (!effective_arg_type)
    4390                 :        173 :         continue;
    4391                 :      25904 :       for (int i = 0; i < FMT_LEN_MAX; i++)
    4392                 :            :         {
    4393                 :      24282 :           const format_type_detail *ftd = &spec->types[i];
    4394                 :      24282 :           if (!ftd->type || *ftd->type == NULL_TREE)
    4395                 :      13002 :             continue;
    4396                 :      11280 :           if (matching_type_p (*ftd->type, effective_arg_type))
    4397                 :            :             {
    4398                 :        750 :               const char *len_modifier
    4399                 :        750 :                 = get_modifier_for_format_len (fki->length_char_specs,
    4400                 :            :                                                (enum format_lengths)i);
    4401                 :        750 :               if (!len_modifier)
    4402                 :        400 :                 len_modifier = "";
    4403                 :            : 
    4404                 :        750 :               if (conversion_char)
    4405                 :            :                 /* We found a match, using the given conversion char - the
    4406                 :            :                    length modifier was incorrect (or absent).
    4407                 :            :                    Provide a suggestion using the conversion char with the
    4408                 :            :                    correct length modifier for the type.  */
    4409                 :        518 :                 return xasprintf ("%s%c", len_modifier, conversion_char);
    4410                 :            :               else
    4411                 :            :                 /* 2nd pass: no match was possible using the user-provided
    4412                 :            :                    conversion char, but we do have a match without using it.
    4413                 :            :                    Provide a suggestion using the first conversion char
    4414                 :            :                    listed for the given type.  */
    4415                 :        232 :                 return xasprintf ("%s%c", len_modifier, spec->format_chars[0]);
    4416                 :            :             }
    4417                 :            :         }
    4418                 :            :    }
    4419                 :            : 
    4420                 :            :   return NULL;
    4421                 :            : }
    4422                 :            : 
    4423                 :            : /* Generate a string containing the length modifier and conversion specifier
    4424                 :            :    that should be used to format arguments of type ARG_TYPE within FKI
    4425                 :            :    (effectively the inverse of the checking code).
    4426                 :            : 
    4427                 :            :    If successful, returns a non-NULL string which should be freed
    4428                 :            :    by the caller.
    4429                 :            :    Otherwise, returns NULL.  */
    4430                 :            : 
    4431                 :            : static char *
    4432                 :        812 : get_format_for_type (const format_kind_info *fki, tree arg_type,
    4433                 :            :                      char conversion_char)
    4434                 :            : {
    4435                 :        812 :   gcc_assert (arg_type);
    4436                 :        812 :   gcc_assert (conversion_char);
    4437                 :            : 
    4438                 :            :   /* First pass: look for a format_char_info containing CONVERSION_CHAR
    4439                 :            :      If we find one, then presumably the length modifier was incorrect
    4440                 :            :      (or absent).  */
    4441                 :        812 :   char *result = get_format_for_type_1 (fki, arg_type, conversion_char);
    4442                 :        812 :   if (result)
    4443                 :            :     return result;
    4444                 :            : 
    4445                 :            :   /* Second pass: we didn't find a match for CONVERSION_CHAR, so try
    4446                 :            :      matching just on the type. */
    4447                 :        294 :   return get_format_for_type_1 (fki, arg_type, '\0');
    4448                 :            : }
    4449                 :            : 
    4450                 :            : /* Attempt to get a string for use as a replacement fix-it hint for the
    4451                 :            :    source range in FMT_LOC.
    4452                 :            : 
    4453                 :            :    Preserve all of the text within the range of FMT_LOC up to
    4454                 :            :    OFFSET_TO_TYPE_START, replacing the rest with an appropriate
    4455                 :            :    length modifier and conversion specifier for ARG_TYPE, attempting
    4456                 :            :    to keep the user-provided CONVERSION_CHAR if possible.
    4457                 :            : 
    4458                 :            :    For example, given a long vs long long mismatch for arg5 here:
    4459                 :            : 
    4460                 :            :     000000000111111111122222222223333333333|
    4461                 :            :     123456789012345678901234567890123456789` column numbers
    4462                 :            :                    0000000000111111111122|
    4463                 :            :                    0123456789012345678901` string offsets
    4464                 :            :                           V~~~~~~~~ : range of FMT_LOC, from cols 23-31
    4465                 :            :       sprintf (d, "before %-+*.*lld after", arg3, arg4, arg5);
    4466                 :            :                                 ^ ^
    4467                 :            :                                 | ` CONVERSION_CHAR: 'd'
    4468                 :            :                                 type starts here
    4469                 :            : 
    4470                 :            :    where OFFSET_TO_TYPE_START is 13 (the offset to the "lld" within the
    4471                 :            :    STRING_CST), where the user provided:
    4472                 :            :      %-+*.*lld
    4473                 :            :    the result (assuming "long" argument 5) should be:
    4474                 :            :      %-+*.*ld
    4475                 :            : 
    4476                 :            :    If successful, returns a non-NULL string which should be freed
    4477                 :            :    by the caller.
    4478                 :            :    Otherwise, returns NULL.  */
    4479                 :            : 
    4480                 :            : static char *
    4481                 :        920 : get_corrected_substring (const substring_loc &fmt_loc,
    4482                 :            :                          format_wanted_type *type, tree arg_type,
    4483                 :            :                          const format_kind_info *fki,
    4484                 :            :                          int offset_to_type_start, char conversion_char)
    4485                 :            : {
    4486                 :            :   /* Attempt to provide hints for argument types, but not for field widths
    4487                 :            :      and precisions.  */
    4488                 :        920 :   if (!arg_type)
    4489                 :            :     return NULL;
    4490                 :        857 :   if (type->kind != CF_KIND_FORMAT)
    4491                 :            :     return NULL;
    4492                 :            : 
    4493                 :            :   /* Locate the current code within the source range, rejecting
    4494                 :            :      any awkward cases where the format string occupies more than
    4495                 :            :      one line.
    4496                 :            :      Lookup the place where the type starts (including any length
    4497                 :            :      modifiers), getting it as the caret location.  */
    4498                 :        775 :   substring_loc type_loc (fmt_loc);
    4499                 :        775 :   type_loc.set_caret_index (offset_to_type_start);
    4500                 :            : 
    4501                 :        775 :   location_t fmt_substring_loc;
    4502                 :        775 :   const char *err = type_loc.get_location (&fmt_substring_loc);
    4503                 :        775 :   if (err)
    4504                 :            :     return NULL;
    4505                 :            : 
    4506                 :        751 :   source_range fmt_substring_range
    4507                 :        751 :     = get_range_from_loc (line_table, fmt_substring_loc);
    4508                 :            : 
    4509                 :        751 :   expanded_location caret
    4510                 :        751 :     = expand_location_to_spelling_point (fmt_substring_loc);
    4511                 :        751 :   expanded_location start
    4512                 :        751 :     = expand_location_to_spelling_point (fmt_substring_range.m_start);
    4513                 :        751 :   expanded_location finish
    4514                 :        751 :     = expand_location_to_spelling_point (fmt_substring_range.m_finish);
    4515                 :        751 :   if (caret.file != start.file)
    4516                 :            :     return NULL;
    4517                 :        748 :   if (start.file != finish.file)
    4518                 :            :     return NULL;
    4519                 :        748 :   if (caret.line != start.line)
    4520                 :            :     return NULL;
    4521                 :        740 :   if (start.line != finish.line)
    4522                 :            :     return NULL;
    4523                 :        740 :   if (start.column > caret.column)
    4524                 :            :     return NULL;
    4525                 :        740 :   if (start.column > finish.column)
    4526                 :            :     return NULL;
    4527                 :        740 :   if (caret.column > finish.column)
    4528                 :            :     return NULL;
    4529                 :            : 
    4530                 :        740 :   char_span line = location_get_source_line (start.file, start.line);
    4531                 :        740 :   if (!line)
    4532                 :            :     return NULL;
    4533                 :            : 
    4534                 :            :   /* If we got this far, then we have the line containing the
    4535                 :            :      existing conversion specification.
    4536                 :            : 
    4537                 :            :      Generate a trimmed copy, containing the prefix part of the conversion
    4538                 :            :      specification, up to the (but not including) the length modifier.
    4539                 :            :      In the above example, this would be "%-+*.*".  */
    4540                 :        740 :   int length_up_to_type = caret.column - start.column;
    4541                 :        740 :   char_span prefix_span = line.subspan (start.column - 1, length_up_to_type);
    4542                 :        740 :   char *prefix = prefix_span.xstrdup ();
    4543                 :            : 
    4544                 :            :   /* Now attempt to generate a suggestion for the rest of the specification
    4545                 :            :      (length modifier and conversion char), based on ARG_TYPE and
    4546                 :            :      CONVERSION_CHAR.
    4547                 :            :      In the above example, this would be "ld".  */
    4548                 :        740 :   char *format_for_type = get_format_for_type (fki, arg_type, conversion_char);
    4549                 :        740 :   if (!format_for_type)
    4550                 :            :     {
    4551                 :         62 :       free (prefix);
    4552                 :         62 :       return NULL;
    4553                 :            :     }
    4554                 :            : 
    4555                 :            :   /* Success.  Generate the resulting suggestion for the whole range of
    4556                 :            :      FMT_LOC by concatenating the two strings.
    4557                 :            :      In the above example, this would be "%-+*.*ld".  */
    4558                 :        678 :   char *result = concat (prefix, format_for_type, NULL);
    4559                 :        678 :   free (format_for_type);
    4560                 :        678 :   free (prefix);
    4561                 :        678 :   return result;
    4562                 :            : }
    4563                 :            : 
    4564                 :            : /* Helper class for adding zero or more trailing '*' to types.
    4565                 :            : 
    4566                 :            :    The format type and name exclude any '*' for pointers, so those
    4567                 :            :    must be formatted manually.  For all the types we currently have,
    4568                 :            :    this is adequate, but formats taking pointers to functions or
    4569                 :            :    arrays would require the full type to be built up in order to
    4570                 :            :    print it with %T.  */
    4571                 :            : 
    4572                 :            : class indirection_suffix
    4573                 :            : {
    4574                 :            :  public:
    4575                 :       1159 :   indirection_suffix (int pointer_count) : m_pointer_count (pointer_count) {}
    4576                 :            : 
    4577                 :            :   /* Determine the size of the buffer (including NUL-terminator).  */
    4578                 :            : 
    4579                 :       1159 :   size_t get_buffer_size () const
    4580                 :            :   {
    4581                 :       1159 :     return m_pointer_count + 2;
    4582                 :            :   }
    4583                 :            : 
    4584                 :            :   /* Write the '*' to DST and add a NUL-terminator.  */
    4585                 :            : 
    4586                 :       1159 :   void fill_buffer (char *dst) const
    4587                 :            :   {
    4588                 :       1159 :     if (m_pointer_count == 0)
    4589                 :        797 :       dst[0] = 0;
    4590                 :        362 :     else if (c_dialect_cxx ())
    4591                 :            :       {
    4592                 :         97 :         memset (dst, '*', m_pointer_count);
    4593                 :         97 :         dst[m_pointer_count] = 0;
    4594                 :            :       }
    4595                 :            :     else
    4596                 :            :       {
    4597                 :        265 :         dst[0] = ' ';
    4598                 :        265 :         memset (dst + 1, '*', m_pointer_count);
    4599                 :        265 :         dst[m_pointer_count + 1] = 0;
    4600                 :            :       }
    4601                 :       1159 :   }
    4602                 :            : 
    4603                 :            :  private:
    4604                 :            :   int m_pointer_count;
    4605                 :            : };
    4606                 :            : 
    4607                 :            : /* Subclass of range_label for labelling the range in the format string
    4608                 :            :    with the type in question, adding trailing '*' for pointer_count.  */
    4609                 :            : 
    4610                 :        922 : class range_label_for_format_type_mismatch
    4611                 :            :   : public range_label_for_type_mismatch
    4612                 :            : {
    4613                 :            :  public:
    4614                 :        922 :   range_label_for_format_type_mismatch (tree labelled_type, tree other_type,
    4615                 :            :                                         int pointer_count)
    4616                 :        922 :   : range_label_for_type_mismatch (labelled_type, other_type),
    4617                 :        922 :     m_pointer_count (pointer_count)
    4618                 :            :   {
    4619                 :            :   }
    4620                 :            : 
    4621                 :        239 :   label_text get_text (unsigned range_idx) const FINAL OVERRIDE
    4622                 :            :   {
    4623                 :        239 :     label_text text = range_label_for_type_mismatch::get_text (range_idx);
    4624                 :        239 :     if (text.m_buffer == NULL)
    4625                 :          0 :       return text;
    4626                 :            : 
    4627                 :        239 :     indirection_suffix suffix (m_pointer_count);
    4628                 :        239 :     char *p = (char *) alloca (suffix.get_buffer_size ());
    4629                 :        239 :     suffix.fill_buffer (p);
    4630                 :            : 
    4631                 :        239 :     char *result = concat (text.m_buffer, p, NULL);
    4632                 :        239 :     text.maybe_free ();
    4633                 :        239 :     return label_text::take (result);
    4634                 :            :   }
    4635                 :            : 
    4636                 :            :  private:
    4637                 :            :   int m_pointer_count;
    4638                 :            : };
    4639                 :            : 
    4640                 :            : /* Give a warning about a format argument of different type from that expected.
    4641                 :            :    The range of the diagnostic is taken from WHOLE_FMT_LOC; the caret location
    4642                 :            :    is based on the location of the char at TYPE->offset_loc.
    4643                 :            :    PARAM_LOC is the location of the relevant argument, or UNKNOWN_LOCATION
    4644                 :            :    if this is unavailable.
    4645                 :            :    WANTED_TYPE is the type the argument should have,
    4646                 :            :    possibly stripped of pointer dereferences.  The description (such as "field
    4647                 :            :    precision"), the placement in the format string, a possibly more
    4648                 :            :    friendly name of WANTED_TYPE, and the number of pointer dereferences
    4649                 :            :    are taken from TYPE.  ARG_TYPE is the type of the actual argument,
    4650                 :            :    or NULL if it is missing.
    4651                 :            : 
    4652                 :            :    OFFSET_TO_TYPE_START is the offset within the execution-charset encoded
    4653                 :            :    format string to where type information begins for the conversion
    4654                 :            :    (the length modifier and conversion specifier).
    4655                 :            :    CONVERSION_CHAR is the user-provided conversion specifier.
    4656                 :            : 
    4657                 :            :    For example, given a type mismatch for argument 5 here:
    4658                 :            : 
    4659                 :            :     00000000011111111112222222222333333333344444444445555555555|
    4660                 :            :     12345678901234567890123456789012345678901234567890123456789` column numbers
    4661                 :            :                    0000000000111111111122|
    4662                 :            :                    0123456789012345678901` offsets within STRING_CST
    4663                 :            :                           V~~~~~~~~ : range of WHOLE_FMT_LOC, from cols 23-31
    4664                 :            :       sprintf (d, "before %-+*.*lld after", int_expr, int_expr, long_expr);
    4665                 :            :                                 ^ ^                             ^~~~~~~~~
    4666                 :            :                                 | ` CONVERSION_CHAR: 'd'        PARAM_LOC
    4667                 :            :                                 type starts here
    4668                 :            : 
    4669                 :            :    OFFSET_TO_TYPE_START is 13, the offset to the "lld" within the
    4670                 :            :    STRING_CST.  */
    4671                 :            : 
    4672                 :            : static void
    4673                 :        920 : format_type_warning (const substring_loc &whole_fmt_loc,
    4674                 :            :                      location_t param_loc,
    4675                 :            :                      format_wanted_type *type,
    4676                 :            :                      tree wanted_type, tree arg_type,
    4677                 :            :                      const format_kind_info *fki,
    4678                 :            :                      int offset_to_type_start,
    4679                 :            :                      char conversion_char)
    4680                 :            : {
    4681                 :        920 :   enum format_specifier_kind kind = type->kind;
    4682                 :        920 :   const char *wanted_type_name = type->wanted_type_name;
    4683                 :        920 :   const char *format_start = type->format_start;
    4684                 :        920 :   int format_length = type->format_length;
    4685                 :        920 :   int pointer_count = type->pointer_count;
    4686                 :        920 :   int arg_num = type->arg_num;
    4687                 :            : 
    4688                 :            :   /* If ARG_TYPE is a typedef with a misleading name (for example,
    4689                 :            :      size_t but not the standard size_t expected by printf %zu), avoid
    4690                 :            :      printing the typedef name.  */
    4691                 :        920 :   if (wanted_type_name
    4692                 :        920 :       && arg_type
    4693                 :        208 :       && TYPE_NAME (arg_type)
    4694                 :        102 :       && TREE_CODE (TYPE_NAME (arg_type)) == TYPE_DECL
    4695                 :        102 :       && DECL_NAME (TYPE_NAME (arg_type))
    4696                 :       1022 :       && !strcmp (wanted_type_name,
    4697                 :        102 :                   lang_hooks.decl_printable_name (TYPE_NAME (arg_type), 2)))
    4698                 :          0 :     arg_type = TYPE_MAIN_VARIANT (arg_type);
    4699                 :            : 
    4700                 :        920 :   indirection_suffix suffix (pointer_count);
    4701                 :        920 :   char *p = (char *) alloca (suffix.get_buffer_size ());
    4702                 :        920 :   suffix.fill_buffer (p);
    4703                 :            : 
    4704                 :            :   /* WHOLE_FMT_LOC has the caret at the end of the range.
    4705                 :            :      Set the caret to be at the offset from TYPE.  Subtract one
    4706                 :            :      from the offset for the same reason as in format_warning_at_char.  */
    4707                 :        920 :   substring_loc fmt_loc (whole_fmt_loc);
    4708                 :        920 :   fmt_loc.set_caret_index (type->offset_loc - 1);
    4709                 :            : 
    4710                 :        920 :   range_label_for_format_type_mismatch fmt_label (wanted_type, arg_type,
    4711                 :       1840 :                                                   pointer_count);
    4712                 :       1840 :   range_label_for_type_mismatch param_label (arg_type, wanted_type);
    4713                 :            : 
    4714                 :            :   /* Get a string for use as a replacement fix-it hint for the range in
    4715                 :            :      fmt_loc, or NULL.  */
    4716                 :        920 :   char *corrected_substring
    4717                 :        920 :     = get_corrected_substring (fmt_loc, type, arg_type, fki,
    4718                 :            :                                offset_to_type_start, conversion_char);
    4719                 :        920 :   format_string_diagnostic_t diag (fmt_loc, &fmt_label, param_loc, &param_label,
    4720                 :        920 :                                    corrected_substring);
    4721                 :        920 :   if (wanted_type_name)
    4722                 :            :     {
    4723                 :        212 :       if (arg_type)
    4724                 :        208 :         diag.emit_warning
    4725                 :        208 :           (OPT_Wformat_,
    4726                 :            :            "%s %<%s%.*s%> expects argument of type %<%s%s%>, "
    4727                 :            :            "but argument %d has type %qT",
    4728                 :        208 :            gettext (kind_descriptions[kind]),
    4729                 :            :            (kind == CF_KIND_FORMAT ? "%" : ""),
    4730                 :            :            format_length, format_start,
    4731                 :            :            wanted_type_name, p, arg_num, arg_type);
    4732                 :            :       else
    4733                 :          4 :         diag.emit_warning
    4734                 :          4 :           (OPT_Wformat_,
    4735                 :            :            "%s %<%s%.*s%> expects a matching %<%s%s%> argument",
    4736                 :          4 :            gettext (kind_descriptions[kind]),
    4737                 :            :            (kind == CF_KIND_FORMAT ? "%" : ""),
    4738                 :            :            format_length, format_start, wanted_type_name, p);
    4739                 :            :     }
    4740                 :            :   else
    4741                 :            :     {
    4742                 :        708 :       if (arg_type)
    4743                 :        649 :         diag.emit_warning
    4744                 :        649 :           (OPT_Wformat_,
    4745                 :            :            "%s %<%s%.*s%> expects argument of type %<%T%s%>, "
    4746                 :            :            "but argument %d has type %qT",
    4747                 :        649 :            gettext (kind_descriptions[kind]),
    4748                 :            :            (kind == CF_KIND_FORMAT ? "%" : ""),
    4749                 :            :            format_length, format_start,
    4750                 :            :            wanted_type, p, arg_num, arg_type);
    4751                 :            :       else
    4752                 :         59 :         diag.emit_warning
    4753                 :         59 :           (OPT_Wformat_,
    4754                 :            :            "%s %<%s%.*s%> expects a matching %<%T%s%> argument",
    4755                 :         59 :            gettext (kind_descriptions[kind]),
    4756                 :            :            (kind == CF_KIND_FORMAT ? "%" : ""),
    4757                 :            :            format_length, format_start, wanted_type, p);
    4758                 :            :     }
    4759                 :            : 
    4760                 :        920 :   free (corrected_substring);
    4761                 :        920 : }
    4762                 :            : 
    4763                 :            : 
    4764                 :            : /* Given a format_char_info array FCI, and a character C, this function
    4765                 :            :    returns the index into the conversion_specs where that specifier's
    4766                 :            :    data is located.  The character must exist.  */
    4767                 :            : static unsigned int
    4768                 :          2 : find_char_info_specifier_index (const format_char_info *fci, int c)
    4769                 :            : {
    4770                 :          2 :   unsigned i;
    4771                 :            : 
    4772                 :         12 :   for (i = 0; fci->format_chars; i++, fci++)
    4773                 :         12 :     if (strchr (fci->format_chars, c))
    4774                 :          2 :       return i;
    4775                 :            : 
    4776                 :            :   /* We shouldn't be looking for a non-existent specifier.  */
    4777                 :          0 :   gcc_unreachable ();
    4778                 :            : }
    4779                 :            : 
    4780                 :            : /* Given a format_length_info array FLI, and a character C, this
    4781                 :            :    function returns the index into the conversion_specs where that
    4782                 :            :    modifier's data is located.  The character must exist.  */
    4783                 :            : static unsigned int
    4784                 :          8 : find_length_info_modifier_index (const format_length_info *fli, int c)
    4785                 :            : {
    4786                 :          8 :   unsigned i;
    4787                 :            : 
    4788                 :         16 :   for (i = 0; fli->name; i++, fli++)
    4789                 :         16 :     if (strchr (fli->name, c))
    4790                 :          8 :       return i;
    4791                 :            : 
    4792                 :            :   /* We shouldn't be looking for a non-existent modifier.  */
    4793                 :          0 :   gcc_unreachable ();
    4794                 :            : }
    4795                 :            : 
    4796                 :            : /* Determine the type of HOST_WIDE_INT in the code being compiled for
    4797                 :            :    use in GCC's __asm_fprintf__ custom format attribute.  You must
    4798                 :            :    have set dynamic_format_types before calling this function.  */
    4799                 :            : static void
    4800                 :         10 : init_dynamic_asm_fprintf_info (void)
    4801                 :            : {
    4802                 :         10 :   static tree hwi;
    4803                 :            : 
    4804                 :         10 :   if (!hwi)
    4805                 :            :     {
    4806                 :         10 :       format_length_info *new_asm_fprintf_length_specs;
    4807                 :         10 :       unsigned int i;
    4808                 :            : 
    4809                 :            :       /* Find the underlying type for HOST_WIDE_INT.  For the %w
    4810                 :            :          length modifier to work, one must have issued: "typedef
    4811                 :            :          HOST_WIDE_INT __gcc_host_wide_int__;" in one's source code
    4812                 :            :          prior to using that modifier.  */
    4813                 :         10 :       hwi = maybe_get_identifier ("__gcc_host_wide_int__");
    4814                 :         10 :       if (!hwi)
    4815                 :            :         {
    4816                 :          2 :           error ("%<__gcc_host_wide_int__%> is not defined as a type");
    4817                 :          2 :           return;
    4818                 :            :         }
    4819                 :          8 :       hwi = identifier_global_value (hwi);
    4820                 :          8 :       if (!hwi || TREE_CODE (hwi) != TYPE_DECL)
    4821                 :            :         {
    4822                 :          4 :           error ("%<__gcc_host_wide_int__%> is not defined as a type");
    4823                 :          4 :           return;
    4824                 :            :         }
    4825                 :          4 :       hwi = DECL_ORIGINAL_TYPE (hwi);
    4826                 :          4 :       gcc_assert (hwi);
    4827                 :          4 :       if (hwi != long_integer_type_node && hwi != long_long_integer_type_node)
    4828                 :            :         {
    4829                 :          2 :           error ("%<__gcc_host_wide_int__%> is not defined as %<long%>"
    4830                 :            :                  " or %<long long%>");
    4831                 :          2 :           return;
    4832                 :            :         }
    4833                 :            : 
    4834                 :            :       /* Create a new (writable) copy of asm_fprintf_length_specs.  */
    4835                 :          2 :       new_asm_fprintf_length_specs = (format_length_info *)
    4836                 :          2 :                                      xmemdup (asm_fprintf_length_specs,
    4837                 :            :                                               sizeof (asm_fprintf_length_specs),
    4838                 :            :                                               sizeof (asm_fprintf_length_specs));
    4839                 :            : 
    4840                 :            :       /* HOST_WIDE_INT must be one of 'long' or 'long long'.  */
    4841                 :          2 :       i = find_length_info_modifier_index (new_asm_fprintf_length_specs, 'w');
    4842                 :          2 :       if (hwi == long_integer_type_node)
    4843                 :          0 :         new_asm_fprintf_length_specs[i].index = FMT_LEN_l;
    4844                 :          2 :       else if (hwi == long_long_integer_type_node)
    4845                 :          2 :         new_asm_fprintf_length_specs[i].index = FMT_LEN_ll;
    4846                 :            :       else
    4847                 :          0 :         gcc_unreachable ();
    4848                 :            : 
    4849                 :            :       /* Assign the new data for use.  */
    4850                 :          2 :       dynamic_format_types[asm_fprintf_format_type].length_char_specs =
    4851                 :            :         new_asm_fprintf_length_specs;
    4852                 :            :     }
    4853                 :            : }
    4854                 :            : 
    4855                 :            : /* Determine the type of a "locus" in the code being compiled for use
    4856                 :            :    in GCC's __gcc_gfc__ custom format attribute.  You must have set
    4857                 :            :    dynamic_format_types before calling this function.  */
    4858                 :            : static void
    4859                 :          4 : init_dynamic_gfc_info (void)
    4860                 :            : {
    4861                 :          4 :   if (!locus)
    4862                 :            :     {
    4863                 :          4 :       static format_char_info *gfc_fci;
    4864                 :            : 
    4865                 :            :       /* For the GCC __gcc_gfc__ custom format specifier to work, one
    4866                 :            :          must have declared 'locus' prior to using this attribute.  If
    4867                 :            :          we haven't seen this declarations then you shouldn't use the
    4868                 :            :          specifier requiring that type.  */
    4869                 :          4 :       if ((locus = maybe_get_identifier ("locus")))
    4870                 :            :         {
    4871                 :          4 :           locus = identifier_global_value (locus);
    4872                 :          4 :           if (locus)
    4873                 :            :             {
    4874                 :          4 :               if (TREE_CODE (locus) != TYPE_DECL
    4875                 :          4 :                   || TREE_TYPE (locus) == error_mark_node)
    4876                 :            :                 {
    4877                 :          2 :                   error ("%<locus%> is not defined as a type");
    4878                 :          2 :                   locus = 0;
    4879                 :            :                 }
    4880                 :            :               else
    4881                 :          2 :                 locus = TREE_TYPE (locus);
    4882                 :            :             }
    4883                 :            :         }
    4884                 :            : 
    4885                 :            :       /* Assign the new data for use.  */
    4886                 :            : 
    4887                 :            :       /* Handle the __gcc_gfc__ format specifics.  */
    4888                 :          4 :       if (!gfc_fci)
    4889                 :          8 :         dynamic_format_types[gcc_gfc_format_type].conversion_specs =
    4890                 :          4 :           gfc_fci = (format_char_info *)
    4891                 :          4 :                      xmemdup (gcc_gfc_char_table,
    4892                 :            :                               sizeof (gcc_gfc_char_table),
    4893                 :            :                               sizeof (gcc_gfc_char_table));
    4894                 :          4 :       if (locus)
    4895                 :            :         {
    4896                 :          2 :           const unsigned i = find_char_info_specifier_index (gfc_fci, 'L');
    4897                 :          2 :           gfc_fci[i].types[0].type = &locus;
    4898                 :          2 :           gfc_fci[i].pointer_count = 1;
    4899                 :            :         }
    4900                 :            :     }
    4901                 :          4 : }
    4902                 :            : 
    4903                 :            : /* Lookup the type named NAME and return a NAME type if found.
    4904                 :            :    Otherwise, return void_type_node if NAME has not been used yet,
    4905                 :            :    or NULL_TREE if NAME is not a type (issuing an error).  */
    4906                 :            : 
    4907                 :            : static tree
    4908                 :        164 : get_named_type (const char *name)
    4909                 :            : {
    4910                 :        164 :   if (tree result = maybe_get_identifier (name))
    4911                 :            :     {
    4912                 :         24 :       result = identifier_global_tag (result);
    4913                 :         24 :       if (result)
    4914                 :            :         {
    4915                 :         19 :           if (TYPE_P (result))
    4916                 :            :             ;
    4917                 :          8 :           else if (TREE_CODE (result) == TYPE_DECL)
    4918                 :          8 :             result = TREE_TYPE (result);
    4919                 :            :           else
    4920                 :            :             {
    4921                 :          0 :               error ("%qs is not defined as a type", name);
    4922                 :          0 :               result = NULL_TREE;
    4923                 :            :             }
    4924                 :            :         }
    4925                 :         24 :       return result;
    4926                 :            :     }
    4927                 :            :   else
    4928                 :        140 :     return void_type_node;
    4929                 :            : }
    4930                 :            : 
    4931                 :            : /* Determine the types of "tree" and "location_t" in the code being
    4932                 :            :    compiled for use in GCC's diagnostic custom format attributes.  You
    4933                 :            :    must have set dynamic_format_types before calling this function.  */
    4934                 :            : static void
    4935                 :         72 : init_dynamic_diag_info (void)
    4936                 :            : {
    4937                 :            :   /* For the GCC-diagnostics custom format specifiers to work, one
    4938                 :            :      must have declared 'tree' and 'location_t' prior to using those
    4939                 :            :      attributes.  If we haven't seen these declarations then
    4940                 :            :      the specifiers requiring these types shouldn't be used.
    4941                 :            :      However we don't force a hard ICE because we may see only one
    4942                 :            :      or the other type.  */
    4943                 :         72 :   if (tree loc = maybe_get_identifier ("location_t"))
    4944                 :            :     {
    4945                 :         48 :       loc = identifier_global_value (loc);
    4946                 :         48 :       if (loc && TREE_CODE (loc) != TYPE_DECL)
    4947                 :          2 :         error ("%<location_t%> is not defined as a type");
    4948                 :            :     }
    4949                 :            : 
    4950                 :            :   /* Initialize the global tree node type local to this file.  */
    4951                 :         72 :   if (!local_tree_type_node
    4952                 :         30 :       || local_tree_type_node == void_type_node)
    4953                 :            :     {
    4954                 :            :       /* We need to grab the underlying 'union tree_node' so peek into
    4955                 :            :          an extra type level.  */
    4956                 :         42 :       if ((local_tree_type_node = maybe_get_identifier ("tree")))
    4957                 :            :         {
    4958                 :         17 :           local_tree_type_node
    4959                 :         17 :             = identifier_global_value (local_tree_type_node);
    4960                 :         17 :           if (local_tree_type_node)
    4961                 :            :             {
    4962                 :         15 :               if (TREE_CODE (local_tree_type_node) != TYPE_DECL)
    4963                 :            :                 {
    4964                 :          2 :                   error ("%<tree%> is not defined as a type");
    4965                 :          2 :                   local_tree_type_node = NULL_TREE;
    4966                 :            :                 }
    4967                 :         13 :               else if (TREE_CODE (TREE_TYPE (local_tree_type_node))
    4968                 :            :                        != POINTER_TYPE)
    4969                 :            :                 {
    4970                 :          2 :                   error ("%<tree%> is not defined as a pointer type");
    4971                 :          2 :                   local_tree_type_node = NULL_TREE;
    4972                 :            :                 }
    4973                 :            :               else
    4974                 :         11 :                 local_tree_type_node
    4975                 :         11 :                   = TREE_TYPE (TREE_TYPE (local_tree_type_node));
    4976                 :            :             }
    4977                 :            :         }
    4978                 :            :       else
    4979                 :         25 :         local_tree_type_node = void_type_node;
    4980                 :            :     }
    4981                 :            : 
    4982                 :            :   /* Similar to the above but for gimple*.  */
    4983                 :         72 :   if (!local_gimple_ptr_node
    4984                 :         30 :       || local_gimple_ptr_node == void_type_node)
    4985                 :         50 :     local_gimple_ptr_node = get_named_type ("gimple");
    4986                 :            : 
    4987                 :            :   /* Similar to the above but for cgraph_node*.  */
    4988                 :         72 :   if (!local_cgraph_node_ptr_node
    4989                 :         30 :       || local_cgraph_node_ptr_node == void_type_node)
    4990                 :         50 :     local_cgraph_node_ptr_node = get_named_type ("cgraph_node");
    4991                 :            : 
    4992                 :            :   /* Similar to the above but for diagnostic_event_id_t*.  */
    4993                 :         72 :   if (!local_event_ptr_node
    4994                 :         30 :       || local_event_ptr_node == void_type_node)
    4995                 :         64 :     local_event_ptr_node = get_named_type ("diagnostic_event_id_t");
    4996                 :            : 
    4997                 :         72 :   static tree hwi;
    4998                 :            : 
    4999                 :         72 :   if (!hwi)
    5000                 :            :     {
    5001                 :         42 :       static format_length_info *diag_ls;
    5002                 :         42 :       unsigned int i;
    5003                 :            : 
    5004                 :            :       /* Find the underlying type for HOST_WIDE_INT.  For the 'w'
    5005                 :            :          length modifier to work, one must have issued: "typedef
    5006                 :            :          HOST_WIDE_INT __gcc_host_wide_int__;" in one's source code
    5007                 :            :          prior to using that modifier.  */
    5008                 :         42 :       if ((hwi = maybe_get_identifier ("__gcc_host_wide_int__")))
    5009                 :            :         {
    5010                 :         12 :           hwi = identifier_global_value (hwi);
    5011                 :         12 :           if (hwi)
    5012                 :            :             {
    5013                 :         10 :               if (TREE_CODE (hwi) != TYPE_DECL)
    5014                 :            :                 {
    5015                 :          2 :                   error ("%<__gcc_host_wide_int__%> is not defined as a type");
    5016                 :          2 :                   hwi = 0;
    5017                 :            :                 }
    5018                 :            :               else
    5019                 :            :                 {
    5020                 :          8 :                   hwi = DECL_ORIGINAL_TYPE (hwi);
    5021                 :          8 :                   gcc_assert (hwi);
    5022                 :          8 :                   if (hwi != long_integer_type_node
    5023                 :          8 :                       && hwi != long_long_integer_type_node)
    5024                 :            :                     {
    5025                 :          2 :                       error ("%<__gcc_host_wide_int__%> is not defined"
    5026                 :            :                              " as %<long%> or %<long long%>");
    5027                 :          2 :                       hwi = 0;
    5028                 :            :                     }
    5029                 :            :                 }
    5030                 :            :             }
    5031                 :            :         }
    5032                 :            : 
    5033                 :            :       /* Assign the new data for use.  */
    5034                 :            : 
    5035                 :            :       /* All the GCC diag formats use the same length specs.  */
    5036                 :         42 :       if (!diag_ls)
    5037                 :         84 :         dynamic_format_types[gcc_diag_format_type].length_char_specs =
    5038                 :         42 :           dynamic_format_types[gcc_tdiag_format_type].length_char_specs =
    5039                 :         42 :           dynamic_format_types[gcc_cdiag_format_type].length_char_specs =
    5040                 :         42 :           dynamic_format_types[gcc_cxxdiag_format_type].length_char_specs =
    5041                 :         42 :           dynamic_format_types[gcc_dump_printf_format_type].length_char_specs =
    5042                 :         42 :           diag_ls = (format_length_info *)
    5043                 :         42 :                     xmemdup (gcc_diag_length_specs,
    5044                 :            :                              sizeof (gcc_diag_length_specs),
    5045                 :            :                              sizeof (gcc_diag_length_specs));
    5046                 :         42 :       if (hwi)
    5047                 :            :         {
    5048                 :            :           /* HOST_WIDE_INT must be one of 'long' or 'long long'.  */
    5049                 :          6 :           i = find_length_info_modifier_index (diag_ls, 'w');
    5050                 :          6 :           if (hwi == long_integer_type_node)
    5051                 :          0 :             diag_ls[i].index = FMT_LEN_l;
    5052                 :          6 :           else if (hwi == long_long_integer_type_node)
    5053                 :          6 :             diag_ls[i].index = FMT_LEN_ll;
    5054                 :            :           else
    5055                 :          0 :             gcc_unreachable ();
    5056                 :            :         }
    5057                 :            :     }
    5058                 :            : 
    5059                 :            :   /* It's safe to "re-initialize these to the same values.  */
    5060                 :         72 :   dynamic_format_types[gcc_diag_format_type].conversion_specs =
    5061                 :            :     gcc_diag_char_table;
    5062                 :         72 :   dynamic_format_types[gcc_tdiag_format_type].conversion_specs =
    5063                 :            :     gcc_tdiag_char_table;
    5064                 :         72 :   dynamic_format_types[gcc_cdiag_format_type].conversion_specs =
    5065                 :            :     gcc_cdiag_char_table;
    5066                 :         72 :   dynamic_format_types[gcc_cxxdiag_format_type].conversion_specs =
    5067                 :            :     gcc_cxxdiag_char_table;
    5068                 :         72 :   dynamic_format_types[gcc_dump_printf_format_type].conversion_specs =
    5069                 :            :     gcc_dump_printf_char_table;
    5070                 :         72 : }
    5071                 :            : 
    5072                 :            : #ifdef TARGET_FORMAT_TYPES
    5073                 :            : extern const format_kind_info TARGET_FORMAT_TYPES[];
    5074                 :            : #endif
    5075                 :            : 
    5076                 :            : #ifdef TARGET_OVERRIDES_FORMAT_ATTRIBUTES
    5077                 :            : extern const target_ovr_attr TARGET_OVERRIDES_FORMAT_ATTRIBUTES[];
    5078                 :            : #endif
    5079                 :            : #ifdef TARGET_OVERRIDES_FORMAT_INIT
    5080                 :            :   extern void TARGET_OVERRIDES_FORMAT_INIT (void);
    5081                 :            : #endif
    5082                 :            : 
    5083                 :            : /* Attributes such as "printf" are equivalent to those such as
    5084                 :            :    "gnu_printf" unless this is overridden by a target.  */
    5085                 :            : static const target_ovr_attr gnu_target_overrides_format_attributes[] =
    5086                 :            : {
    5087                 :            :   { "gnu_printf",   "printf" },
    5088                 :            :   { "gnu_scanf",    "scanf" },
    5089                 :            :   { "gnu_strftime", "strftime" },
    5090                 :            :   { "gnu_strfmon",  "strfmon" },
    5091                 :            :   { NULL,           NULL }
    5092                 :            : };
    5093                 :            : 
    5094                 :            : /* Translate to unified attribute name. This is used in decode_format_type and
    5095                 :            :    decode_format_attr. In attr_name the user specified argument is passed. It
    5096                 :            :    returns the unified format name from TARGET_OVERRIDES_FORMAT_ATTRIBUTES
    5097                 :            :    or the attr_name passed to this function, if there is no matching entry.  */
    5098                 :            : static const char *
    5099                 :    7833470 : convert_format_name_to_system_name (const char *attr_name)
    5100                 :            : {
    5101                 :    7833470 :   int i;
    5102                 :            : 
    5103                 :    7833470 :   if (attr_name == NULL || *attr_name == 0
    5104                 :    7833470 :       || strncmp (attr_name, "gcc_", 4) == 0)
    5105                 :            :     return attr_name;
    5106                 :            : #ifdef TARGET_OVERRIDES_FORMAT_INIT
    5107                 :            :   TARGET_OVERRIDES_FORMAT_INIT ();
    5108                 :            : #endif
    5109                 :            : 
    5110                 :            : #ifdef TARGET_OVERRIDES_FORMAT_ATTRIBUTES
    5111                 :            :   /* Check if format attribute is overridden by target.  */
    5112                 :            :   if (TARGET_OVERRIDES_FORMAT_ATTRIBUTES != NULL
    5113                 :            :       && TARGET_OVERRIDES_FORMAT_ATTRIBUTES_COUNT > 0)
    5114                 :            :     {
    5115                 :            :       for (i = 0; i < TARGET_OVERRIDES_FORMAT_ATTRIBUTES_COUNT; ++i)
    5116                 :            :         {
    5117                 :            :           if (cmp_attribs (TARGET_OVERRIDES_FORMAT_ATTRIBUTES[i].named_attr_src,
    5118                 :            :                            attr_name))
    5119                 :            :             return attr_name;
    5120                 :            :           if (cmp_attribs (TARGET_OVERRIDES_FORMAT_ATTRIBUTES[i].named_attr_dst,
    5121                 :            :                            attr_name))
    5122                 :            :             return TARGET_OVERRIDES_FORMAT_ATTRIBUTES[i].named_attr_src;
    5123                 :            :         }
    5124                 :            :     }
    5125                 :            : #endif
    5126                 :            :   /* Otherwise default to gnu format.  */
    5127                 :    3366890 :   for (i = 0;
    5128                 :   11199200 :        gnu_target_overrides_format_attributes[i].named_attr_src != NULL;
    5129                 :            :        ++i)
    5130                 :            :     {
    5131                 :   11199100 :       if (cmp_attribs (gnu_target_overrides_format_attributes[i].named_attr_src,
    5132                 :            :                        attr_name))
    5133                 :            :         return attr_name;
    5134                 :   11195700 :       if (cmp_attribs (gnu_target_overrides_format_attributes[i].named_attr_dst,
    5135                 :            :                        attr_name))
    5136                 :    7828850 :         return gnu_target_overrides_format_attributes[i].named_attr_src;
    5137                 :            :     }
    5138                 :            : 
    5139                 :            :   return attr_name;
    5140                 :            : }
    5141                 :            : 
    5142                 :            : /* Handle a "format" attribute; arguments as in
    5143                 :            :    struct attribute_spec.handler.  */
    5144                 :            : tree
    5145                 :    7801590 : handle_format_attribute (tree *node, tree atname, tree args,
    5146                 :            :                          int flags, bool *no_add_attrs)
    5147                 :            : {
    5148                 :    7801590 :   const_tree type = *node;
    5149                 :    7801590 :   function_format_info info;
    5150                 :            : 
    5151                 :            : #ifdef TARGET_FORMAT_TYPES
    5152                 :            :   /* If the target provides additional format types, we need to
    5153                 :            :      add them to FORMAT_TYPES at first use.  */
    5154                 :            :   if (TARGET_FORMAT_TYPES != NULL && !dynamic_format_types)
    5155                 :            :     {
    5156                 :            :       dynamic_format_types = XNEWVEC (format_kind_info,
    5157                 :            :                                       n_format_types + TARGET_N_FORMAT_TYPES);
    5158                 :            :       memcpy (dynamic_format_types, format_types_orig,
    5159                 :            :               sizeof (format_types_orig));
    5160                 :            :       memcpy (&dynamic_format_types[n_format_types], TARGET_FORMAT_TYPES,
    5161                 :            :               TARGET_N_FORMAT_TYPES * sizeof (dynamic_format_types[0]));
    5162                 :            : 
    5163                 :            :       format_types = dynamic_format_types;
    5164                 :            :       /* Provide a reference for the first potential external type.  */
    5165                 :            :       first_target_format_type = n_format_types;
    5166                 :            :       n_format_types += TARGET_N_FORMAT_TYPES;
    5167                 :            :     }
    5168                 :            : #endif
    5169                 :            : 
    5170                 :            :   /* Canonicalize name of format function.  */
    5171                 :    7801590 :   if (TREE_CODE (TREE_VALUE (args)) == IDENTIFIER_NODE)
    5172                 :    7801580 :     TREE_VALUE (args) = canonicalize_attr_name (TREE_VALUE (args));
    5173                 :            : 
    5174                 :    7801590 :   if (!decode_format_attr (type, atname, args, &info, /* validated_p = */false))
    5175                 :            :     {
    5176                 :         32 :       *no_add_attrs = true;
    5177                 :         32 :       return NULL_TREE;
    5178                 :            :     }
    5179                 :            : 
    5180                 :    7801560 :   if (prototype_p (type))
    5181                 :            :     {
    5182                 :    7801520 :       if (!check_format_string (type, info.format_num, flags,
    5183                 :    7801520 :                                 no_add_attrs, info.format_type))
    5184                 :            :         return NULL_TREE;
    5185                 :            : 
    5186                 :    7801520 :       if (info.first_arg_num != 0)
    5187                 :            :         {
    5188                 :    4138540 :           unsigned HOST_WIDE_INT arg_num = 1;
    5189                 :    4138540 :           function_args_iterator iter;
    5190                 :    4138540 :           tree arg_type;
    5191                 :            : 
    5192                 :            :           /* Verify that first_arg_num points to the last arg,
    5193                 :            :              the ...  */
    5194                 :   13723900 :           FOREACH_FUNCTION_ARGS (type, arg_type, iter)
    5195                 :    9585370 :             arg_num++;
    5196                 :            : 
    5197                 :    4138540 :           if (arg_num != info.first_arg_num)
    5198                 :            :             {
    5199                 :          2 :               if (!(flags & (int) ATTR_FLAG_BUILT_IN))
    5200                 :          2 :                 error ("argument to be formatted is not %<...%>");
    5201                 :          2 :               *no_add_attrs = true;
    5202                 :          2 :               return NULL_TREE;
    5203                 :            :             }
    5204                 :            :         }
    5205                 :            :     }
    5206                 :            : 
    5207                 :            :   /* Check if this is a strftime variant. Just for this variant
    5208                 :            :      FMT_FLAG_ARG_CONVERT is not set.  */
    5209                 :    7801550 :   if ((format_types[info.format_type].flags & (int) FMT_FLAG_ARG_CONVERT) == 0
    5210                 :     313011 :       && info.first_arg_num != 0)
    5211                 :            :     {
    5212                 :          2 :       error ("strftime formats cannot format arguments");
    5213                 :          2 :       *no_add_attrs = true;
    5214                 :          2 :       return NULL_TREE;
    5215                 :            :     }
    5216                 :            : 
    5217                 :            :   /* If this is a custom GCC-internal format type, we have to
    5218                 :            :      initialize certain bits at runtime.  */
    5219                 :    7801550 :   if (info.format_type == asm_fprintf_format_type
    5220                 :    7801550 :       || info.format_type == gcc_gfc_format_type
    5221                 :    7801540 :       || info.format_type == gcc_diag_format_type
    5222                 :    7801510 :       || info.format_type == gcc_tdiag_format_type
    5223                 :    7801480 :       || info.format_type == gcc_cdiag_format_type
    5224                 :    7801480 :       || info.format_type == gcc_cxxdiag_format_type
    5225                 :    7801470 :       || info.format_type == gcc_dump_printf_format_type)
    5226                 :            :     {
    5227                 :            :       /* Our first time through, we have to make sure that our
    5228                 :            :          format_type data is allocated dynamically and is modifiable.  */
    5229                 :         86 :       if (!dynamic_format_types)
    5230                 :         56 :         format_types = dynamic_format_types = (format_kind_info *)
    5231                 :         56 :           xmemdup (format_types_orig, sizeof (format_types_orig),
    5232                 :            :                    sizeof (format_types_orig));
    5233                 :            : 
    5234                 :            :       /* If this is format __asm_fprintf__, we have to initialize
    5235                 :            :          GCC's notion of HOST_WIDE_INT for checking %wd.  */
    5236                 :         86 :       if (info.format_type == asm_fprintf_format_type)
    5237                 :         10 :         init_dynamic_asm_fprintf_info ();
    5238                 :            :       /* If this is format __gcc_gfc__, we have to initialize GCC's
    5239                 :            :          notion of 'locus' at runtime for %L.  */
    5240                 :         76 :       else if (info.format_type == gcc_gfc_format_type)
    5241                 :          4 :         init_dynamic_gfc_info ();
    5242                 :            :       /* If this is one of the diagnostic attributes, then we have to
    5243                 :            :          initialize 'location_t' and 'tree' at runtime.  */
    5244                 :         72 :       else if (info.format_type == gcc_diag_format_type
    5245                 :            :                || info.format_type == gcc_tdiag_format_type
    5246                 :            :                || info.format_type == gcc_cdiag_format_type
    5247                 :         72 :                || info.format_type == gcc_cxxdiag_format_type
    5248                 :          4 :                || info.format_type == gcc_dump_printf_format_type)
    5249                 :         72 :         init_dynamic_diag_info ();
    5250                 :            :       else
    5251                 :          0 :         gcc_unreachable ();
    5252                 :            :     }
    5253                 :            : 
    5254                 :            :   return NULL_TREE;
    5255                 :            : }
    5256                 :            : 
    5257                 :            : #if CHECKING_P
    5258                 :            : 
    5259                 :            : namespace selftest {
    5260                 :            : 
    5261                 :            : /* Selftests of location handling.  */
    5262                 :            : 
    5263                 :            : /* Get the format_kind_info with the given name.  */
    5264                 :            : 
    5265                 :            : static const format_kind_info *
    5266                 :          4 : get_info (const char *name)
    5267                 :            : {
    5268                 :          4 :   int idx = decode_format_type (name);
    5269                 :          4 :   const format_kind_info *fki = &format_types[idx];
    5270                 :          4 :   ASSERT_STREQ (fki->name, name);
    5271                 :          4 :   return fki;
    5272                 :            : }
    5273                 :            : 
    5274                 :            : /* Verify that get_format_for_type (FKI, TYPE, CONVERSION_CHAR)
    5275                 :            :    is EXPECTED_FORMAT.  */
    5276                 :            : 
    5277                 :            : static void
    5278                 :         72 : assert_format_for_type_streq (const location &loc, const format_kind_info *fki,
    5279                 :            :                               const char *expected_format, tree type,
    5280                 :            :                               char conversion_char)
    5281                 :            : {
    5282                 :         72 :   gcc_assert (fki);
    5283                 :         72 :   gcc_assert (expected_format);
    5284                 :         72 :   gcc_assert (type);
    5285                 :            : 
    5286                 :         72 :   char *actual_format = get_format_for_type (fki, type, conversion_char);
    5287                 :         72 :   ASSERT_STREQ_AT (loc, expected_format, actual_format);
    5288                 :         72 :   free (actual_format);
    5289                 :         72 : }
    5290                 :            : 
    5291                 :            : /* Selftests for get_format_for_type.  */
    5292                 :            : 
    5293                 :            : #define ASSERT_FORMAT_FOR_TYPE_STREQ(EXPECTED_FORMAT, TYPE, CONVERSION_CHAR) \
    5294                 :            :   assert_format_for_type_streq (SELFTEST_LOCATION, (fki), (EXPECTED_FORMAT), \
    5295                 :            :                                 (TYPE), (CONVERSION_CHAR))
    5296                 :            : 
    5297                 :            : /* Selftest for get_format_for_type for "printf"-style functions.  */
    5298                 :            : 
    5299                 :            : static void
    5300                 :          2 : test_get_format_for_type_printf ()
    5301                 :            : {
    5302                 :          2 :   const format_kind_info *fki = get_info ("gnu_printf");
    5303                 :          2 :   ASSERT_NE (fki, NULL);
    5304                 :            : 
    5305                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("f", double_type_node, 'i');
    5306                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("Lf", long_double_type_node, 'i');
    5307                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("f", double_type_node, 'o');
    5308                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("Lf", long_double_type_node, 'o');
    5309                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("f", double_type_node, 'x');
    5310                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("Lf", long_double_type_node, 'x');
    5311                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("f", double_type_node, 'X');
    5312                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("Lf", long_double_type_node, 'X');
    5313                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("d", integer_type_node, 'd');
    5314                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("i", integer_type_node, 'i');
    5315                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("o", integer_type_node, 'o');
    5316                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("x", integer_type_node, 'x');
    5317                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("X", integer_type_node, 'X');
    5318                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("d", unsigned_type_node, 'd');
    5319                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("i", unsigned_type_node, 'i');
    5320                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("o", unsigned_type_node, 'o');
    5321                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("x", unsigned_type_node, 'x');
    5322                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("X", unsigned_type_node, 'X');
    5323                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("ld", long_integer_type_node, 'd');
    5324                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("li", long_integer_type_node, 'i');
    5325                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("lx", long_integer_type_node, 'x');
    5326                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("lo", long_unsigned_type_node, 'o');
    5327                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("lx", long_unsigned_type_node, 'x');
    5328                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("lld", long_long_integer_type_node, 'd');
    5329                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("lli", long_long_integer_type_node, 'i');
    5330                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("llo", long_long_unsigned_type_node, 'o');
    5331                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("llx", long_long_unsigned_type_node, 'x');
    5332                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("s", build_pointer_type (char_type_node), 'i');
    5333                 :          2 : }
    5334                 :            : 
    5335                 :            : /* Selftest for get_format_for_type for "scanf"-style functions.  */
    5336                 :            : 
    5337                 :            : static void
    5338                 :          2 : test_get_format_for_type_scanf ()
    5339                 :            : {
    5340                 :          2 :   const format_kind_info *fki = get_info ("gnu_scanf");
    5341                 :          2 :   ASSERT_NE (fki, NULL);
    5342                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("d", build_pointer_type (integer_type_node), 'd');
    5343                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("u", build_pointer_type (unsigned_type_node), 'u');
    5344                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("ld",
    5345                 :            :                                 build_pointer_type (long_integer_type_node), 'd');
    5346                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("lu",
    5347                 :            :                                 build_pointer_type (long_unsigned_type_node), 'u');
    5348                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ
    5349                 :            :     ("lld", build_pointer_type (long_long_integer_type_node), 'd');
    5350                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ
    5351                 :            :     ("llu", build_pointer_type (long_long_unsigned_type_node), 'u');
    5352                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("e", build_pointer_type (float_type_node), 'e');
    5353                 :          2 :   ASSERT_FORMAT_FOR_TYPE_STREQ ("le", build_pointer_type (double_type_node), 'e');
    5354                 :          2 : }
    5355                 :            : 
    5356                 :            : #undef ASSERT_FORMAT_FOR_TYPE_STREQ
    5357                 :            : 
    5358                 :            : /* Exercise the type-printing label code, to give some coverage
    5359                 :            :    under "make selftest-valgrind" (in particular, to ensure that
    5360                 :            :    the label-printing machinery doesn't leak).  */
    5361                 :            : 
    5362                 :            : static void
    5363                 :          2 : test_type_mismatch_range_labels ()
    5364                 :            : {
    5365                 :            :   /* Create a tempfile and write some text to it.
    5366                 :            :      ....................0000000001 11111111 12 22222222
    5367                 :            :      ....................1234567890 12345678 90 12345678.  */
    5368                 :          2 :   const char *content = "  printf (\"msg: %i\\n\", msg);\n";
    5369                 :          4 :   temp_source_file tmp (SELFTEST_LOCATION, ".c", content);
    5370                 :          4 :   line_table_test ltt;
    5371                 :            : 
    5372                 :          2 :   linemap_add (line_table, LC_ENTER, false, tmp.get_filename (), 1);
    5373                 :            : 
    5374                 :          2 :   location_t c17 = linemap_position_for_column (line_table, 17);
    5375                 :          2 :   ASSERT_EQ (LOCATION_COLUMN (c17), 17);
    5376                 :          2 :   location_t c18 = linemap_position_for_column (line_table, 18);
    5377                 :          2 :   location_t c24 = linemap_position_for_column (line_table, 24);
    5378                 :          2 :   location_t c26 = linemap_position_for_column (line_table, 26);
    5379                 :            : 
    5380                 :            :   /* Don't attempt to run the tests if column data might be unavailable.  */
    5381                 :          2 :   if (c26 > LINE_MAP_MAX_LOCATION_WITH_COLS)
    5382                 :          0 :     return;
    5383                 :            : 
    5384                 :          2 :   location_t fmt = make_location (c18, c17, c18);
    5385                 :          2 :   ASSERT_EQ (LOCATION_COLUMN (fmt), 18);
    5386                 :            : 
    5387                 :          2 :   location_t param = make_location (c24, c24, c26);
    5388                 :          2 :   ASSERT_EQ (LOCATION_COLUMN (param), 24);
    5389                 :            : 
    5390                 :          2 :   range_label_for_format_type_mismatch fmt_label (char_type_node,
    5391                 :          2 :                                                   integer_type_node, 1);
    5392                 :          2 :   range_label_for_type_mismatch param_label (integer_type_node,
    5393                 :          2 :                                              char_type_node);
    5394                 :          4 :   gcc_rich_location richloc (fmt, &fmt_label);
    5395                 :          2 :   richloc.add_range (param, SHOW_RANGE_WITHOUT_CARET, &param_label);
    5396                 :            : 
    5397                 :          4 :   test_diagnostic_context dc;
    5398                 :          2 :   diagnostic_show_locus (&dc, &richloc, DK_ERROR);
    5399                 :          2 :   if (c_dialect_cxx ())
    5400                 :            :     /* "char*", without a space.  */
    5401                 :          1 :     ASSERT_STREQ ("   printf (\"msg: %i\\n\", msg);\n"
    5402                 :            :                   "                 ~^     ~~~\n"
    5403                 :            :                   "                  |     |\n"
    5404                 :            :                   "                  char* int\n",
    5405                 :            :                   pp_formatted_text (dc.printer));
    5406                 :            :   else
    5407                 :            :     /* "char *", with a space.  */
    5408                 :          1 :     ASSERT_STREQ ("   printf (\"msg: %i\\n\", msg);\n"
    5409                 :            :                   "                 ~^     ~~~\n"
    5410                 :            :                   "                  |     |\n"
    5411                 :            :                   "                  |     int\n"
    5412                 :            :                   "                  char *\n",
    5413                 :            :                   pp_formatted_text (dc.printer));
    5414                 :            : }
    5415                 :            : 
    5416                 :            : /* Run all of the selftests within this file.  */
    5417                 :            : 
    5418                 :            : void
    5419                 :          2 : c_format_c_tests ()
    5420                 :            : {
    5421                 :          2 :   test_get_modifier_for_format_len ();
    5422                 :          2 :   test_get_format_for_type_printf ();
    5423                 :          2 :   test_get_format_for_type_scanf ();
    5424                 :          2 :   test_type_mismatch_range_labels ();
    5425                 :          2 : }
    5426                 :            : 
    5427                 :            : } // namespace selftest
    5428                 :            : 
    5429                 :            : #endif /* CHECKING_P */
    5430                 :            : 
    5431                 :            : #include "gt-c-family-c-format.h"

Generated by: LCOV version 1.0

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