gcc/c-format.c

   1 /* Check calls to formatted I/O functions (-Wformat).
   2    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "tree.h"
  27 #include "flags.h"
  28 #include "toplev.h"
  29 #include "c-common.h"
  30 #include "intl.h"
  31 #include "diagnostic.h"
  32 #include "langhooks.h"
  33 #include "c-format.h"
  34 \f
  35 /* Set format warning options according to a -Wformat=n option.  */
  36
  37 void
  38 set_Wformat (int setting)
  39 {
  40   warn_format = setting;
  41   warn_format_extra_args = setting;
  42   warn_format_zero_length = setting;
  43   if (setting != 1)
  44     {
  45       warn_format_nonliteral = setting;
  46       warn_format_security = setting;
  47       warn_format_y2k = setting;
  48     }
  49   /* Make sure not to disable -Wnonnull if -Wformat=0 is specified.  */
  50   if (setting)
  51     warn_nonnull = setting;
  52 }
  53
  54 \f
  55 /* Handle attributes associated with format checking.  */
  56
  57 /* This must be in the same order as format_types, except for
  58    format_type_error.  Target-specific format types do not have
  59    matching enum values.  */
  60 enum format_type { printf_format_type, asm_fprintf_format_type,
  61                    gcc_diag_format_type, gcc_cdiag_format_type,
  62                    gcc_cxxdiag_format_type,
  63                    scanf_format_type, strftime_format_type,
  64                    strfmon_format_type, format_type_error = -1};
  65
  66 typedef struct function_format_info
  67 {
  68   int format_type;                      /* type of format (printf, scanf, etc.) */
  69   unsigned HOST_WIDE_INT format_num;    /* number of format argument */
  70   unsigned HOST_WIDE_INT first_arg_num; /* number of first arg (zero for varargs) */
  71 } function_format_info;
  72
  73 static bool decode_format_attr (tree, function_format_info *, int);
  74 static int decode_format_type (const char *);
  75
  76 static bool check_format_string (tree argument,
  77                                  unsigned HOST_WIDE_INT format_num,
  78                                  int flags, bool *no_add_attrs);
  79 static bool get_constant (tree expr, unsigned HOST_WIDE_INT *value,
  80                           int validated_p);
  81
  82
  83 /* Handle a "format_arg" attribute; arguments as in
  84    struct attribute_spec.handler.  */
  85 tree
  86 handle_format_arg_attribute (tree *node, tree ARG_UNUSED (name),
  87                              tree args, int flags, bool *no_add_attrs)
  88 {
  89   tree type = *node;
  90   tree format_num_expr = TREE_VALUE (args);
  91   unsigned HOST_WIDE_INT format_num = 0;
  92   tree argument;
  93
  94   if (!get_constant (format_num_expr, &format_num, 0))
  95     {
  96       error ("format string has invalid operand number");
  97       *no_add_attrs = true;
  98       return NULL_TREE;
  99     }
 100
 101   argument = TYPE_ARG_TYPES (type);
 102   if (argument)
 103     {
 104       if (!check_format_string (argument, format_num, flags, no_add_attrs))
 105         return NULL_TREE;
 106     }
 107
 108   if (TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
 109       || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
 110           != char_type_node))
 111     {
 112       if (!(flags & (int) ATTR_FLAG_BUILT_IN))
 113         error ("function does not return string type");
 114       *no_add_attrs = true;
 115       return NULL_TREE;
 116     }
 117
 118   return NULL_TREE;
 119 }
 120
 121 /* Verify that the format_num argument is actually a string, in case
 122    the format attribute is in error.  */
 123 static bool
 124 check_format_string (tree argument, unsigned HOST_WIDE_INT format_num,
 125                      int flags, bool *no_add_attrs)
 126 {
 127   unsigned HOST_WIDE_INT i;
 128
 129   for (i = 1; i != format_num; i++)
 130     {
 131       if (argument == 0)
 132         break;
 133       argument = TREE_CHAIN (argument);
 134     }
 135
 136   if (!argument
 137       || TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE
 138       || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument)))
 139           != char_type_node))
 140     {
 141       if (!(flags & (int) ATTR_FLAG_BUILT_IN))
 142         error ("format string argument not a string type");
 143       *no_add_attrs = true;
 144       return false;
 145     }
 146
 147   return true;
 148 }
 149
 150 /* Verify EXPR is a constant, and store its value.
 151    If validated_p is true there should be no errors.
 152    Returns true on success, false otherwise.  */
 153 static bool
 154 get_constant (tree expr, unsigned HOST_WIDE_INT *value, int validated_p)
 155 {
 156   if (TREE_CODE (expr) != INTEGER_CST || TREE_INT_CST_HIGH (expr) != 0)
 157     {
 158       gcc_assert (!validated_p);
 159       return false;
 160     }
 161
 162   *value = TREE_INT_CST_LOW (expr);
 163
 164   return true;
 165 }
 166
 167 /* Decode the arguments to a "format" attribute into a
 168    function_format_info structure.  It is already known that the list
 169    is of the right length.  If VALIDATED_P is true, then these
 170    attributes have already been validated and must not be erroneous;
 171    if false, it will give an error message.  Returns true if the
 172    attributes are successfully decoded, false otherwise.  */
 173
 174 static bool
 175 decode_format_attr (tree args, function_format_info *info, int validated_p)
 176 {
 177   tree format_type_id = TREE_VALUE (args);
 178   tree format_num_expr = TREE_VALUE (TREE_CHAIN (args));
 179   tree first_arg_num_expr
 180     = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args)));
 181
 182   if (TREE_CODE (format_type_id) != IDENTIFIER_NODE)
 183     {
 184       gcc_assert (!validated_p);
 185       error ("unrecognized format specifier");
 186       return false;
 187     }
 188   else
 189     {
 190       const char *p = IDENTIFIER_POINTER (format_type_id);
 191
 192       info->format_type = decode_format_type (p);
 193
 194       if (info->format_type == format_type_error)
 195         {
 196           gcc_assert (!validated_p);
 197           warning (0, "%qE is an unrecognized format function type",
 198                    format_type_id);
 199           return false;
 200         }
 201     }
 202
 203   if (!get_constant (format_num_expr, &info->format_num, validated_p))
 204     {
 205       error ("format string has invalid operand number");
 206       return false;
 207     }
 208
 209   if (!get_constant (first_arg_num_expr, &info->first_arg_num, validated_p))
 210     {
 211       error ("%<...%> has invalid operand number");
 212       return false;
 213     }
 214
 215   if (info->first_arg_num != 0 && info->first_arg_num <= info->format_num)
 216     {
 217       gcc_assert (!validated_p);
 218       error ("format string argument follows the args to be formatted");
 219       return false;
 220     }
 221
 222   return true;
 223 }
 224 \f
 225 /* Check a call to a format function against a parameter list.  */
 226
 227 /* The C standard version C++ is treated as equivalent to
 228    or inheriting from, for the purpose of format features supported.  */
 229 #define CPLUSPLUS_STD_VER       STD_C94
 230 /* The C standard version we are checking formats against when pedantic.  */
 231 #define C_STD_VER               ((int) (c_dialect_cxx ()                   \
 232                                  ? CPLUSPLUS_STD_VER                       \
 233                                  : (flag_isoc99                            \
 234                                     ? STD_C99                              \
 235                                     : (flag_isoc94 ? STD_C94 : STD_C89))))
 236 /* The name to give to the standard version we are warning about when
 237    pedantic.  FEATURE_VER is the version in which the feature warned out
 238    appeared, which is higher than C_STD_VER.  */
 239 #define C_STD_NAME(FEATURE_VER) (c_dialect_cxx ()               \
 240                                  ? "ISO C++"                    \
 241                                  : ((FEATURE_VER) == STD_EXT    \
 242                                     ? "ISO C"                   \
 243                                     : "ISO C90"))
 244 /* Adjust a C standard version, which may be STD_C9L, to account for
 245    -Wno-long-long.  Returns other standard versions unchanged.  */
 246 #define ADJ_STD(VER)            ((int) ((VER) == STD_C9L                      \
 247                                        ? (warn_long_long ? STD_C99 : STD_C89) \
 248                                        : (VER)))
 249
 250 /* Structure describing details of a type expected in format checking,
 251    and the type to check against it.  */
 252 typedef struct format_wanted_type
 253 {
 254   /* The type wanted.  */
 255   tree wanted_type;
 256   /* The name of this type to use in diagnostics.  */
 257   const char *wanted_type_name;
 258   /* The level of indirection through pointers at which this type occurs.  */
 259   int pointer_count;
 260   /* Whether, when pointer_count is 1, to allow any character type when
 261      pedantic, rather than just the character or void type specified.  */
 262   int char_lenient_flag;
 263   /* Whether the argument, dereferenced once, is written into and so the
 264      argument must not be a pointer to a const-qualified type.  */
 265   int writing_in_flag;
 266   /* Whether the argument, dereferenced once, is read from and so
 267      must not be a NULL pointer.  */
 268   int reading_from_flag;
 269   /* If warnings should be of the form "field precision should have
 270      type 'int'", the name to use (in this case "field precision"),
 271      otherwise NULL, for "format expects type 'long'" type
 272      messages.  */
 273   const char *name;
 274   /* The actual parameter to check against the wanted type.  */
 275   tree param;
 276   /* The argument number of that parameter.  */
 277   int arg_num;
 278   /* The next type to check for this format conversion, or NULL if none.  */
 279   struct format_wanted_type *next;
 280 } format_wanted_type;
 281
 282
 283 static const format_length_info printf_length_specs[] =
 284 {
 285   { "h", FMT_LEN_h, STD_C89, "hh", FMT_LEN_hh, STD_C99 },
 286   { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C9L },
 287   { "q", FMT_LEN_ll, STD_EXT, NULL, 0, 0 },
 288   { "L", FMT_LEN_L, STD_C89, NULL, 0, 0 },
 289   { "z", FMT_LEN_z, STD_C99, NULL, 0, 0 },
 290   { "Z", FMT_LEN_z, STD_EXT, NULL, 0, 0 },
 291   { "t", FMT_LEN_t, STD_C99, NULL, 0, 0 },
 292   { "j", FMT_LEN_j, STD_C99, NULL, 0, 0 },
 293   { NULL, 0, 0, NULL, 0, 0 }
 294 };
 295
 296 /* Length specifiers valid for asm_fprintf.  */
 297 static const format_length_info asm_fprintf_length_specs[] =
 298 {
 299   { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C89 },
 300   { "w", FMT_LEN_none, STD_C89, NULL, 0, 0 },
 301   { NULL, 0, 0, NULL, 0, 0 }
 302 };
 303
 304 /* Length specifiers valid for GCC diagnostics.  */
 305 static const format_length_info gcc_diag_length_specs[] =
 306 {
 307   { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C89 },
 308   { "w", FMT_LEN_none, STD_C89, NULL, 0, 0 },
 309   { NULL, 0, 0, NULL, 0, 0 }
 310 };
 311
 312 /* The custom diagnostics all accept the same length specifiers.  */
 313 #define gcc_cdiag_length_specs gcc_diag_length_specs
 314 #define gcc_cxxdiag_length_specs gcc_diag_length_specs
 315
 316 /* This differs from printf_length_specs only in that "Z" is not accepted.  */
 317 static const format_length_info scanf_length_specs[] =
 318 {
 319   { "h", FMT_LEN_h, STD_C89, "hh", FMT_LEN_hh, STD_C99 },
 320   { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C9L },
 321   { "q", FMT_LEN_ll, STD_EXT, NULL, 0, 0 },
 322   { "L", FMT_LEN_L, STD_C89, NULL, 0, 0 },
 323   { "z", FMT_LEN_z, STD_C99, NULL, 0, 0 },
 324   { "t", FMT_LEN_t, STD_C99, NULL, 0, 0 },
 325   { "j", FMT_LEN_j, STD_C99, NULL, 0, 0 },
 326   { NULL, 0, 0, NULL, 0, 0 }
 327 };
 328
 329
 330 /* All tables for strfmon use STD_C89 everywhere, since -pedantic warnings
 331    make no sense for a format type not part of any C standard version.  */
 332 static const format_length_info strfmon_length_specs[] =
 333 {
 334   /* A GNU extension.  */
 335   { "L", FMT_LEN_L, STD_C89, NULL, 0, 0 },
 336   { NULL, 0, 0, NULL, 0, 0 }
 337 };
 338
 339 static const format_flag_spec printf_flag_specs[] =
 340 {
 341   { ' ',  0, 0, N_("' ' flag"),        N_("the ' ' printf flag"),              STD_C89 },
 342   { '+',  0, 0, N_("'+' flag"),        N_("the '+' printf flag"),              STD_C89 },
 343   { '#',  0, 0, N_("'#' flag"),        N_("the '#' printf flag"),              STD_C89 },
 344   { '0',  0, 0, N_("'0' flag"),        N_("the '0' printf flag"),              STD_C89 },
 345   { '-',  0, 0, N_("'-' flag"),        N_("the '-' printf flag"),              STD_C89 },
 346   { '\'', 0, 0, N_("''' flag"),        N_("the ''' printf flag"),              STD_EXT },
 347   { 'I',  0, 0, N_("'I' flag"),        N_("the 'I' printf flag"),              STD_EXT },
 348   { 'w',  0, 0, N_("field width"),     N_("field width in printf format"),     STD_C89 },
 349   { 'p',  0, 0, N_("precision"),       N_("precision in printf format"),       STD_C89 },
 350   { 'L',  0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
 351   { 0, 0, 0, NULL, NULL, 0 }
 352 };
 353
 354
 355 static const format_flag_pair printf_flag_pairs[] =
 356 {
 357   { ' ', '+', 1, 0   },
 358   { '0', '-', 1, 0   },
 359   { '0', 'p', 1, 'i' },
 360   { 0, 0, 0, 0 }
 361 };
 362
 363 static const format_flag_spec asm_fprintf_flag_specs[] =
 364 {
 365   { ' ',  0, 0, N_("' ' flag"),        N_("the ' ' printf flag"),              STD_C89 },
 366   { '+',  0, 0, N_("'+' flag"),        N_("the '+' printf flag"),              STD_C89 },
 367   { '#',  0, 0, N_("'#' flag"),        N_("the '#' printf flag"),              STD_C89 },
 368   { '0',  0, 0, N_("'0' flag"),        N_("the '0' printf flag"),              STD_C89 },
 369   { '-',  0, 0, N_("'-' flag"),        N_("the '-' printf flag"),              STD_C89 },
 370   { 'w',  0, 0, N_("field width"),     N_("field width in printf format"),     STD_C89 },
 371   { 'p',  0, 0, N_("precision"),       N_("precision in printf format"),       STD_C89 },
 372   { 'L',  0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
 373   { 0, 0, 0, NULL, NULL, 0 }
 374 };
 375
 376 static const format_flag_pair asm_fprintf_flag_pairs[] =
 377 {
 378   { ' ', '+', 1, 0   },
 379   { '0', '-', 1, 0   },
 380   { '0', 'p', 1, 'i' },
 381   { 0, 0, 0, 0 }
 382 };
 383
 384 static const format_flag_pair gcc_diag_flag_pairs[] =
 385 {
 386   { 0, 0, 0, 0 }
 387 };
 388
 389 #define gcc_cdiag_flag_pairs gcc_diag_flag_pairs
 390 #define gcc_cxxdiag_flag_pairs gcc_diag_flag_pairs
 391
 392 static const format_flag_spec gcc_diag_flag_specs[] =
 393 {
 394   { 'q',  0, 0, N_("'q' flag"),        N_("the 'q' diagnostic flag"),          STD_C89 },
 395   { 'p',  0, 0, N_("precision"),       N_("precision in printf format"),       STD_C89 },
 396   { 'L',  0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
 397   { 0, 0, 0, NULL, NULL, 0 }
 398 };
 399
 400 #define gcc_cdiag_flag_specs gcc_diag_flag_specs
 401
 402 static const format_flag_spec gcc_cxxdiag_flag_specs[] =
 403 {
 404   { '+',  0, 0, N_("'+' flag"),        N_("the '+' printf flag"),              STD_C89 },
 405   { '#',  0, 0, N_("'#' flag"),        N_("the '#' printf flag"),              STD_C89 },
 406   { 'q',  0, 0, N_("'q' flag"),        N_("the 'q' diagnostic flag"),          STD_C89 },
 407   { 'p',  0, 0, N_("precision"),       N_("precision in printf format"),       STD_C89 },
 408   { 'L',  0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
 409   { 0, 0, 0, NULL, NULL, 0 }
 410 };
 411
 412 static const format_flag_spec scanf_flag_specs[] =
 413 {
 414   { '*',  0, 0, N_("assignment suppression"), N_("the assignment suppression scanf feature"), STD_C89 },
 415   { 'a',  0, 0, N_("'a' flag"),               N_("the 'a' scanf flag"),                       STD_EXT },
 416   { 'w',  0, 0, N_("field width"),            N_("field width in scanf format"),              STD_C89 },
 417   { 'L',  0, 0, N_("length modifier"),        N_("length modifier in scanf format"),          STD_C89 },
 418   { '\'', 0, 0, N_("''' flag"),               N_("the ''' scanf flag"),                       STD_EXT },
 419   { 'I',  0, 0, N_("'I' flag"),               N_("the 'I' scanf flag"),                       STD_EXT },
 420   { 0, 0, 0, NULL, NULL, 0 }
 421 };
 422
 423
 424 static const format_flag_pair scanf_flag_pairs[] =
 425 {
 426   { '*', 'L', 0, 0 },
 427   { 0, 0, 0, 0 }
 428 };
 429
 430
 431 static const format_flag_spec strftime_flag_specs[] =
 432 {
 433   { '_', 0,   0, N_("'_' flag"),     N_("the '_' strftime flag"),          STD_EXT },
 434   { '-', 0,   0, N_("'-' flag"),     N_("the '-' strftime flag"),          STD_EXT },
 435   { '0', 0,   0, N_("'0' flag"),     N_("the '0' strftime flag"),          STD_EXT },
 436   { '^', 0,   0, N_("'^' flag"),     N_("the '^' strftime flag"),          STD_EXT },
 437   { '#', 0,   0, N_("'#' flag"),     N_("the '#' strftime flag"),          STD_EXT },
 438   { 'w', 0,   0, N_("field width"),  N_("field width in strftime format"), STD_EXT },
 439   { 'E', 0,   0, N_("'E' modifier"), N_("the 'E' strftime modifier"),      STD_C99 },
 440   { 'O', 0,   0, N_("'O' modifier"), N_("the 'O' strftime modifier"),      STD_C99 },
 441   { 'O', 'o', 0, NULL,               N_("the 'O' modifier"),               STD_EXT },
 442   { 0, 0, 0, NULL, NULL, 0 }
 443 };
 444
 445
 446 static const format_flag_pair strftime_flag_pairs[] =
 447 {
 448   { 'E', 'O', 0, 0 },
 449   { '_', '-', 0, 0 },
 450   { '_', '0', 0, 0 },
 451   { '-', '0', 0, 0 },
 452   { '^', '#', 0, 0 },
 453   { 0, 0, 0, 0 }
 454 };
 455
 456
 457 static const format_flag_spec strfmon_flag_specs[] =
 458 {
 459   { '=',  0, 1, N_("fill character"),  N_("fill character in strfmon format"),  STD_C89 },
 460   { '^',  0, 0, N_("'^' flag"),        N_("the '^' strfmon flag"),              STD_C89 },
 461   { '+',  0, 0, N_("'+' flag"),        N_("the '+' strfmon flag"),              STD_C89 },
 462   { '(',  0, 0, N_("'(' flag"),        N_("the '(' strfmon flag"),              STD_C89 },
 463   { '!',  0, 0, N_("'!' flag"),        N_("the '!' strfmon flag"),              STD_C89 },
 464   { '-',  0, 0, N_("'-' flag"),        N_("the '-' strfmon flag"),              STD_C89 },
 465   { 'w',  0, 0, N_("field width"),     N_("field width in strfmon format"),     STD_C89 },
 466   { '#',  0, 0, N_("left precision"),  N_("left precision in strfmon format"),  STD_C89 },
 467   { 'p',  0, 0, N_("right precision"), N_("right precision in strfmon format"), STD_C89 },
 468   { 'L',  0, 0, N_("length modifier"), N_("length modifier in strfmon format"), STD_C89 },
 469   { 0, 0, 0, NULL, NULL, 0 }
 470 };
 471
 472 static const format_flag_pair strfmon_flag_pairs[] =
 473 {
 474   { '+', '(', 0, 0 },
 475   { 0, 0, 0, 0 }
 476 };
 477
 478
 479 static const format_char_info print_char_table[] =
 480 {
 481   /* C89 conversion specifiers.  */
 482   { "di",  0, STD_C89, { T89_I,   T99_SC,  T89_S,   T89_L,   T9L_LL,  TEX_LL,  T99_SST, T99_PD,  T99_IM  }, "-wp0 +'I",  "i",  NULL },
 483   { "oxX", 0, STD_C89, { T89_UI,  T99_UC,  T89_US,  T89_UL,  T9L_ULL, TEX_ULL, T99_ST,  T99_UPD, T99_UIM }, "-wp0#",     "i",  NULL },
 484   { "u",   0, STD_C89, { T89_UI,  T99_UC,  T89_US,  T89_UL,  T9L_ULL, TEX_ULL, T99_ST,  T99_UPD, T99_UIM }, "-wp0'I",    "i",  NULL },
 485   { "fgG", 0, STD_C89, { T89_D,   BADLEN,  BADLEN,  T99_D,   BADLEN,  T89_LD,  BADLEN,  BADLEN,  BADLEN  }, "-wp0 +#'I", "",   NULL },
 486   { "eE",  0, STD_C89, { T89_D,   BADLEN,  BADLEN,  T99_D,   BADLEN,  T89_LD,  BADLEN,  BADLEN,  BADLEN  }, "-wp0 +#I",  "",   NULL },
 487   { "c",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  T94_WI,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-w",        "",   NULL },
 488   { "s",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  T94_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-wp",       "cR", NULL },
 489   { "p",   1, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-w",        "c",  NULL },
 490   { "n",   1, STD_C89, { T89_I,   T99_SC,  T89_S,   T89_L,   T9L_LL,  BADLEN,  T99_SST, T99_PD,  T99_IM  }, "",          "W",  NULL },
 491   /* C99 conversion specifiers.  */
 492   { "F",   0, STD_C99, { T99_D,   BADLEN,  BADLEN,  T99_D,   BADLEN,  T99_LD,  BADLEN,  BADLEN,  BADLEN  }, "-wp0 +#'I", "",   NULL },
 493   { "aA",  0, STD_C99, { T99_D,   BADLEN,  BADLEN,  T99_D,   BADLEN,  T99_LD,  BADLEN,  BADLEN,  BADLEN  }, "-wp0 +#",   "",   NULL },
 494   /* X/Open conversion specifiers.  */
 495   { "C",   0, STD_EXT, { TEX_WI,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-w",        "",   NULL },
 496   { "S",   1, STD_EXT, { TEX_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-wp",       "R",  NULL },
 497   /* GNU conversion specifiers.  */
 498   { "m",   0, STD_EXT, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-wp",       "",   NULL },
 499   { NULL,  0, 0, NOLENGTHS, NULL, NULL, NULL }
 500 };
 501
 502 static const format_char_info asm_fprintf_char_table[] =
 503 {
 504   /* C89 conversion specifiers.  */
 505   { "di",  0, STD_C89, { T89_I,   BADLEN,  BADLEN,  T89_L,   T9L_LL,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-wp0 +",  "i", NULL },
 506   { "oxX", 0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-wp0#",   "i", NULL },
 507   { "u",   0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-wp0",    "i", NULL },
 508   { "c",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-w",       "", NULL },
 509   { "s",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-wp",    "cR", NULL },
 510
 511   /* asm_fprintf conversion specifiers.  */
 512   { "O",   0, STD_C89, NOARGUMENTS, "",      "",   NULL },
 513   { "R",   0, STD_C89, NOARGUMENTS, "",      "",   NULL },
 514   { "I",   0, STD_C89, NOARGUMENTS, "",      "",   NULL },
 515   { "L",   0, STD_C89, NOARGUMENTS, "",      "",   NULL },
 516   { "U",   0, STD_C89, NOARGUMENTS, "",      "",   NULL },
 517   { "r",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "",  "", NULL },
 518   { "@",   0, STD_C89, NOARGUMENTS, "",      "",   NULL },
 519   { NULL,  0, 0, NOLENGTHS, NULL, NULL, NULL }
 520 };
 521
 522 static const format_char_info gcc_diag_char_table[] =
 523 {
 524   /* C89 conversion specifiers.  */
 525   { "di",  0, STD_C89, { T89_I,   BADLEN,  BADLEN,  T89_L,   T9L_LL,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 526   { "ox",  0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 527   { "u",   0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 528   { "c",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 529   { "s",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "pq", "cR", NULL },
 530   { "p",   1, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "c",  NULL },
 531
 532   /* Custom conversion specifiers.  */
 533
 534   /* %H will require "location_t" at runtime.  */
 535   { "H",   0, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 536
 537   /* These will require a "tree" at runtime.  */
 538   { "J", 0, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",    "",   NULL },
 539
 540   { "<>'", 0, STD_C89, NOARGUMENTS, "",      "",   NULL },
 541   { "m",   0, STD_C89, NOARGUMENTS, "q",     "",   NULL },
 542   { NULL,  0, 0, NOLENGTHS, NULL, NULL, NULL }
 543 };
 544
 545 static const format_char_info gcc_cdiag_char_table[] =
 546 {
 547   /* C89 conversion specifiers.  */
 548   { "di",  0, STD_C89, { T89_I,   BADLEN,  BADLEN,  T89_L,   T9L_LL,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 549   { "ox",  0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 550   { "u",   0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 551   { "c",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 552   { "s",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "pq", "cR", NULL },
 553   { "p",   1, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "c",  NULL },
 554
 555   /* Custom conversion specifiers.  */
 556
 557   /* %H will require "location_t" at runtime.  */
 558   { "H",   0, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 559
 560   /* These will require a "tree" at runtime.  */
 561   { "DEFJT", 0, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q", "",   NULL },
 562
 563   { "<>'", 0, STD_C89, NOARGUMENTS, "",      "",   NULL },
 564   { "m",   0, STD_C89, NOARGUMENTS, "q",     "",   NULL },
 565   { NULL,  0, 0, NOLENGTHS, NULL, NULL, NULL }
 566 };
 567
 568 static const format_char_info gcc_cxxdiag_char_table[] =
 569 {
 570   /* C89 conversion specifiers.  */
 571   { "di",  0, STD_C89, { T89_I,   BADLEN,  BADLEN,  T89_L,   T9L_LL,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 572   { "ox",  0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 573   { "u",   0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 574   { "c",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 575   { "s",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "pq", "cR", NULL },
 576   { "p",   1, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "c",  NULL },
 577
 578   /* Custom conversion specifiers.  */
 579
 580   /* %H will require "location_t" at runtime.  */
 581   { "H",   0, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 582
 583   /* These will require a "tree" at runtime.  */
 584   { "ADEFJTV",0,STD_C89,{ T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q+#",   "",   NULL },
 585
 586   /* These accept either an 'int' or an 'enum tree_code' (which is handled as an 'int'.)  */
 587   { "CLOPQ",0,STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 588
 589   { "<>'", 0, STD_C89, NOARGUMENTS, "",      "",   NULL },
 590   { "m",   0, STD_C89, NOARGUMENTS, "q",     "",   NULL },
 591   { NULL,  0, 0, NOLENGTHS, NULL, NULL, NULL }
 592 };
 593
 594 static const format_char_info scan_char_table[] =
 595 {
 596   /* C89 conversion specifiers.  */
 597   { "di",    1, STD_C89, { T89_I,   T99_SC,  T89_S,   T89_L,   T9L_LL,  TEX_LL,  T99_SST, T99_PD,  T99_IM  }, "*w'I", "W",   NULL },
 598   { "u",     1, STD_C89, { T89_UI,  T99_UC,  T89_US,  T89_UL,  T9L_ULL, TEX_ULL, T99_ST,  T99_UPD, T99_UIM }, "*w'I", "W",   NULL },
 599   { "oxX",   1, STD_C89, { T89_UI,  T99_UC,  T89_US,  T89_UL,  T9L_ULL, TEX_ULL, T99_ST,  T99_UPD, T99_UIM }, "*w",   "W",   NULL },
 600   { "efgEG", 1, STD_C89, { T89_F,   BADLEN,  BADLEN,  T89_D,   BADLEN,  T89_LD,  BADLEN,  BADLEN,  BADLEN  }, "*w'",  "W",   NULL },
 601   { "c",     1, STD_C89, { T89_C,   BADLEN,  BADLEN,  T94_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "*w",   "cW",  NULL },
 602   { "s",     1, STD_C89, { T89_C,   BADLEN,  BADLEN,  T94_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "*aw",  "cW",  NULL },
 603   { "[",     1, STD_C89, { T89_C,   BADLEN,  BADLEN,  T94_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "*aw",  "cW[", NULL },
 604   { "p",     2, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "*w",   "W",   NULL },
 605   { "n",     1, STD_C89, { T89_I,   T99_SC,  T89_S,   T89_L,   T9L_LL,  BADLEN,  T99_SST, T99_PD,  T99_IM  }, "",     "W",   NULL },
 606   /* C99 conversion specifiers.  */
 607   { "FaA",   1, STD_C99, { T99_F,   BADLEN,  BADLEN,  T99_D,   BADLEN,  T99_LD,  BADLEN,  BADLEN,  BADLEN  }, "*w'",  "W",   NULL },
 608   /* X/Open conversion specifiers.  */
 609   { "C",     1, STD_EXT, { TEX_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "*w",   "W",   NULL },
 610   { "S",     1, STD_EXT, { TEX_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "*aw",  "W",   NULL },
 611   { NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
 612 };
 613
 614 static const format_char_info time_char_table[] =
 615 {
 616   /* C89 conversion specifiers.  */
 617   { "ABZab",            0, STD_C89, NOLENGTHS, "^#",     "",   NULL },
 618   { "cx",               0, STD_C89, NOLENGTHS, "E",      "3",  NULL },
 619   { "HIMSUWdmw",        0, STD_C89, NOLENGTHS, "-_0Ow",  "",   NULL },
 620   { "j",                0, STD_C89, NOLENGTHS, "-_0Ow",  "o",  NULL },
 621   { "p",                0, STD_C89, NOLENGTHS, "#",      "",   NULL },
 622   { "X",                0, STD_C89, NOLENGTHS, "E",      "",   NULL },
 623   { "y",                0, STD_C89, NOLENGTHS, "EO-_0w", "4",  NULL },
 624   { "Y",                0, STD_C89, NOLENGTHS, "-_0EOw", "o",  NULL },
 625   { "%",                0, STD_C89, NOLENGTHS, "",       "",   NULL },
 626   /* C99 conversion specifiers.  */
 627   { "C",                0, STD_C99, NOLENGTHS, "-_0EOw", "o",  NULL },
 628   { "D",                0, STD_C99, NOLENGTHS, "",       "2",  NULL },
 629   { "eVu",              0, STD_C99, NOLENGTHS, "-_0Ow",  "",   NULL },
 630   { "FRTnrt",           0, STD_C99, NOLENGTHS, "",       "",   NULL },
 631   { "g",                0, STD_C99, NOLENGTHS, "O-_0w",  "2o", NULL },
 632   { "G",                0, STD_C99, NOLENGTHS, "-_0Ow",  "o",  NULL },
 633   { "h",                0, STD_C99, NOLENGTHS, "^#",     "",   NULL },
 634   { "z",                0, STD_C99, NOLENGTHS, "O",      "o",  NULL },
 635   /* GNU conversion specifiers.  */
 636   { "kls",              0, STD_EXT, NOLENGTHS, "-_0Ow",  "",   NULL },
 637   { "P",                0, STD_EXT, NOLENGTHS, "",       "",   NULL },
 638   { NULL,               0, 0, NOLENGTHS, NULL, NULL, NULL }
 639 };
 640
 641 static const format_char_info monetary_char_table[] =
 642 {
 643   { "in", 0, STD_C89, { T89_D, BADLEN, BADLEN, BADLEN, BADLEN, T89_LD, BADLEN, BADLEN, BADLEN }, "=^+(!-w#p", "", NULL },
 644   { NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
 645 };
 646
 647 /* This must be in the same order as enum format_type.  */
 648 static const format_kind_info format_types_orig[] =
 649 {
 650   { "printf",   printf_length_specs,  print_char_table, " +#0-'I", NULL,
 651     printf_flag_specs, printf_flag_pairs,
 652     FMT_FLAG_ARG_CONVERT|FMT_FLAG_DOLLAR_MULTIPLE|FMT_FLAG_USE_DOLLAR|FMT_FLAG_EMPTY_PREC_OK,
 653     'w', 0, 'p', 0, 'L',
 654     &integer_type_node, &integer_type_node
 655   },
 656   { "asm_fprintf",   asm_fprintf_length_specs,  asm_fprintf_char_table, " +#0-", NULL,
 657     asm_fprintf_flag_specs, asm_fprintf_flag_pairs,
 658     FMT_FLAG_ARG_CONVERT|FMT_FLAG_EMPTY_PREC_OK,
 659     'w', 0, 'p', 0, 'L',
 660     NULL, NULL
 661   },
 662   { "gcc_diag",   gcc_diag_length_specs,  gcc_diag_char_table, "q", NULL,
 663     gcc_diag_flag_specs, gcc_diag_flag_pairs,
 664     FMT_FLAG_ARG_CONVERT,
 665     0, 0, 'p', 0, 'L',
 666     NULL, &integer_type_node
 667   },
 668   { "gcc_cdiag",   gcc_cdiag_length_specs,  gcc_cdiag_char_table, "q", NULL,
 669     gcc_cdiag_flag_specs, gcc_cdiag_flag_pairs,
 670     FMT_FLAG_ARG_CONVERT,
 671     0, 0, 'p', 0, 'L',
 672     NULL, &integer_type_node
 673   },
 674   { "gcc_cxxdiag",   gcc_cxxdiag_length_specs,  gcc_cxxdiag_char_table, "q+#", NULL,
 675     gcc_cxxdiag_flag_specs, gcc_cxxdiag_flag_pairs,
 676     FMT_FLAG_ARG_CONVERT,
 677     0, 0, 'p', 0, 'L',
 678     NULL, &integer_type_node
 679   },
 680   { "scanf",    scanf_length_specs,   scan_char_table,  "*'I", NULL,
 681     scanf_flag_specs, scanf_flag_pairs,
 682     FMT_FLAG_ARG_CONVERT|FMT_FLAG_SCANF_A_KLUDGE|FMT_FLAG_USE_DOLLAR|FMT_FLAG_ZERO_WIDTH_BAD|FMT_FLAG_DOLLAR_GAP_POINTER_OK,
 683     'w', 0, 0, '*', 'L',
 684     NULL, NULL
 685   },
 686   { "strftime", NULL,                 time_char_table,  "_-0^#", "EO",
 687     strftime_flag_specs, strftime_flag_pairs,
 688     FMT_FLAG_FANCY_PERCENT_OK, 'w', 0, 0, 0, 0,
 689     NULL, NULL
 690   },
 691   { "strfmon",  strfmon_length_specs, monetary_char_table, "=^+(!-", NULL,
 692     strfmon_flag_specs, strfmon_flag_pairs,
 693     FMT_FLAG_ARG_CONVERT, 'w', '#', 'p', 0, 'L',
 694     NULL, NULL
 695   }
 696 };
 697
 698 /* This layer of indirection allows GCC to reassign format_types with
 699    new data if necessary, while still allowing the original data to be
 700    const.  */
 701 static const format_kind_info *format_types = format_types_orig;
 702 /* We can modify this one.  We also add target-specific format types
 703    to the end of the array.  */
 704 static format_kind_info *dynamic_format_types;
 705
 706 static int n_format_types = ARRAY_SIZE (format_types_orig);
 707
 708 /* Structure detailing the results of checking a format function call
 709    where the format expression may be a conditional expression with
 710    many leaves resulting from nested conditional expressions.  */
 711 typedef struct
 712 {
 713   /* Number of leaves of the format argument that could not be checked
 714      as they were not string literals.  */
 715   int number_non_literal;
 716   /* Number of leaves of the format argument that were null pointers or
 717      string literals, but had extra format arguments.  */
 718   int number_extra_args;
 719   /* Number of leaves of the format argument that were null pointers or
 720      string literals, but had extra format arguments and used $ operand
 721      numbers.  */
 722   int number_dollar_extra_args;
 723   /* Number of leaves of the format argument that were wide string
 724      literals.  */
 725   int number_wide;
 726   /* Number of leaves of the format argument that were empty strings.  */
 727   int number_empty;
 728   /* Number of leaves of the format argument that were unterminated
 729      strings.  */
 730   int number_unterminated;
 731   /* Number of leaves of the format argument that were not counted above.  */
 732   int number_other;
 733 } format_check_results;
 734
 735 typedef struct
 736 {
 737   format_check_results *res;
 738   function_format_info *info;
 739   tree params;
 740 } format_check_context;
 741
 742 static void check_format_info (function_format_info *, tree);
 743 static void check_format_arg (void *, tree, unsigned HOST_WIDE_INT);
 744 static void check_format_info_main (format_check_results *,
 745                                     function_format_info *,
 746                                     const char *, int, tree,
 747                                     unsigned HOST_WIDE_INT);
 748
 749 static void init_dollar_format_checking (int, tree);
 750 static int maybe_read_dollar_number (const char **, int,
 751                                      tree, tree *, const format_kind_info *);
 752 static bool avoid_dollar_number (const char *);
 753 static void finish_dollar_format_checking (format_check_results *, int);
 754
 755 static const format_flag_spec *get_flag_spec (const format_flag_spec *,
 756                                               int, const char *);
 757
 758 static void check_format_types (format_wanted_type *, const char *, int);
 759 static void format_type_warning (const char *, const char *, int, tree,
 760                                  int, const char *, tree, int);
 761
 762 /* Decode a format type from a string, returning the type, or
 763    format_type_error if not valid, in which case the caller should print an
 764    error message.  */
 765 static int
 766 decode_format_type (const char *s)
 767 {
 768   int i;
 769   int slen;
 770   slen = strlen (s);
 771   for (i = 0; i < n_format_types; i++)
 772     {
 773       int alen;
 774       if (!strcmp (s, format_types[i].name))
 775         return i;
 776       alen = strlen (format_types[i].name);
 777       if (slen == alen + 4 && s[0] == '_' && s[1] == '_'
 778           && s[slen - 1] == '_' && s[slen - 2] == '_'
 779           && !strncmp (s + 2, format_types[i].name, alen))
 780         return i;
 781     }
 782   return format_type_error;
 783 }
 784
 785 \f
 786 /* Check the argument list of a call to printf, scanf, etc.
 787    ATTRS are the attributes on the function type.
 788    PARAMS is the list of argument values.  Also, if -Wmissing-format-attribute,
 789    warn for calls to vprintf or vscanf in functions with no such format
 790    attribute themselves.  */
 791
 792 void
 793 check_function_format (tree attrs, tree params)
 794 {
 795   tree a;
 796
 797   /* See if this function has any format attributes.  */
 798   for (a = attrs; a; a = TREE_CHAIN (a))
 799     {
 800       if (is_attribute_p ("format", TREE_PURPOSE (a)))
 801         {
 802           /* Yup; check it.  */
 803           function_format_info info;
 804           decode_format_attr (TREE_VALUE (a), &info, 1);
 805           check_format_info (&info, params);
 806           if (warn_missing_format_attribute && info.first_arg_num == 0
 807               && (format_types[info.format_type].flags
 808                   & (int) FMT_FLAG_ARG_CONVERT))
 809             {
 810               tree c;
 811               for (c = TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl));
 812                    c;
 813                    c = TREE_CHAIN (c))
 814                 if (is_attribute_p ("format", TREE_PURPOSE (c))
 815                     && (decode_format_type (IDENTIFIER_POINTER
 816                                             (TREE_VALUE (TREE_VALUE (c))))
 817                         == info.format_type))
 818                   break;
 819               if (c == NULL_TREE)
 820                 {
 821                   /* Check if the current function has a parameter to which
 822                      the format attribute could be attached; if not, it
 823                      can't be a candidate for a format attribute, despite
 824                      the vprintf-like or vscanf-like call.  */
 825                   tree args;
 826                   for (args = DECL_ARGUMENTS (current_function_decl);
 827                        args != 0;
 828                        args = TREE_CHAIN (args))
 829                     {
 830                       if (TREE_CODE (TREE_TYPE (args)) == POINTER_TYPE
 831                           && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (args)))
 832                               == char_type_node))
 833                         break;
 834                     }
 835                   if (args != 0)
 836                     warning (0, "function might be possible candidate for %qs format attribute",
 837                              format_types[info.format_type].name);
 838                 }
 839             }
 840         }
 841     }
 842 }
 843
 844
 845 /* Variables used by the checking of $ operand number formats.  */
 846 static char *dollar_arguments_used = NULL;
 847 static char *dollar_arguments_pointer_p = NULL;
 848 static int dollar_arguments_alloc = 0;
 849 static int dollar_arguments_count;
 850 static int dollar_first_arg_num;
 851 static int dollar_max_arg_used;
 852 static int dollar_format_warned;
 853
 854 /* Initialize the checking for a format string that may contain $
 855    parameter number specifications; we will need to keep track of whether
 856    each parameter has been used.  FIRST_ARG_NUM is the number of the first
 857    argument that is a parameter to the format, or 0 for a vprintf-style
 858    function; PARAMS is the list of arguments starting at this argument.  */
 859
 860 static void
 861 init_dollar_format_checking (int first_arg_num, tree params)
 862 {
 863   tree oparams = params;
 864
 865   dollar_first_arg_num = first_arg_num;
 866   dollar_arguments_count = 0;
 867   dollar_max_arg_used = 0;
 868   dollar_format_warned = 0;
 869   if (first_arg_num > 0)
 870     {
 871       while (params)
 872         {
 873           dollar_arguments_count++;
 874           params = TREE_CHAIN (params);
 875         }
 876     }
 877   if (dollar_arguments_alloc < dollar_arguments_count)
 878     {
 879       if (dollar_arguments_used)
 880         free (dollar_arguments_used);
 881       if (dollar_arguments_pointer_p)
 882         free (dollar_arguments_pointer_p);
 883       dollar_arguments_alloc = dollar_arguments_count;
 884       dollar_arguments_used = XNEWVEC (char, dollar_arguments_alloc);
 885       dollar_arguments_pointer_p = XNEWVEC (char, dollar_arguments_alloc);
 886     }
 887   if (dollar_arguments_alloc)
 888     {
 889       memset (dollar_arguments_used, 0, dollar_arguments_alloc);
 890       if (first_arg_num > 0)
 891         {
 892           int i = 0;
 893           params = oparams;
 894           while (params)
 895             {
 896               dollar_arguments_pointer_p[i] = (TREE_CODE (TREE_TYPE (TREE_VALUE (params)))
 897                                                == POINTER_TYPE);
 898               params = TREE_CHAIN (params);
 899               i++;
 900             }
 901         }
 902     }
 903 }
 904
 905
 906 /* Look for a decimal number followed by a $ in *FORMAT.  If DOLLAR_NEEDED
 907    is set, it is an error if one is not found; otherwise, it is OK.  If
 908    such a number is found, check whether it is within range and mark that
 909    numbered operand as being used for later checking.  Returns the operand
 910    number if found and within range, zero if no such number was found and
 911    this is OK, or -1 on error.  PARAMS points to the first operand of the
 912    format; PARAM_PTR is made to point to the parameter referred to.  If
 913    a $ format is found, *FORMAT is updated to point just after it.  */
 914
 915 static int
 916 maybe_read_dollar_number (const char **format,
 917                           int dollar_needed, tree params, tree *param_ptr,
 918                           const format_kind_info *fki)
 919 {
 920   int argnum;
 921   int overflow_flag;
 922   const char *fcp = *format;
 923   if (!ISDIGIT (*fcp))
 924     {
 925       if (dollar_needed)
 926         {
 927           warning (0, "missing $ operand number in format");
 928           return -1;
 929         }
 930       else
 931         return 0;
 932     }
 933   argnum = 0;
 934   overflow_flag = 0;
 935   while (ISDIGIT (*fcp))
 936     {
 937       int nargnum;
 938       nargnum = 10 * argnum + (*fcp - '0');
 939       if (nargnum < 0 || nargnum / 10 != argnum)
 940         overflow_flag = 1;
 941       argnum = nargnum;
 942       fcp++;
 943     }
 944   if (*fcp != '$')
 945     {
 946       if (dollar_needed)
 947         {
 948           warning (0, "missing $ operand number in format");
 949           return -1;
 950         }
 951       else
 952         return 0;
 953     }
 954   *format = fcp + 1;
 955   if (pedantic && !dollar_format_warned)
 956     {
 957       warning (0, "%s does not support %%n$ operand number formats",
 958                C_STD_NAME (STD_EXT));
 959       dollar_format_warned = 1;
 960     }
 961   if (overflow_flag || argnum == 0
 962       || (dollar_first_arg_num && argnum > dollar_arguments_count))
 963     {
 964       warning (0, "operand number out of range in format");
 965       return -1;
 966     }
 967   if (argnum > dollar_max_arg_used)
 968     dollar_max_arg_used = argnum;
 969   /* For vprintf-style functions we may need to allocate more memory to
 970      track which arguments are used.  */
 971   while (dollar_arguments_alloc < dollar_max_arg_used)
 972     {
 973       int nalloc;
 974       nalloc = 2 * dollar_arguments_alloc + 16;
 975       dollar_arguments_used = XRESIZEVEC (char, dollar_arguments_used,
 976                                           nalloc);
 977       dollar_arguments_pointer_p = XRESIZEVEC (char, dollar_arguments_pointer_p,
 978                                                nalloc);
 979       memset (dollar_arguments_used + dollar_arguments_alloc, 0,
 980               nalloc - dollar_arguments_alloc);
 981       dollar_arguments_alloc = nalloc;
 982     }
 983   if (!(fki->flags & (int) FMT_FLAG_DOLLAR_MULTIPLE)
 984       && dollar_arguments_used[argnum - 1] == 1)
 985     {
 986       dollar_arguments_used[argnum - 1] = 2;
 987       warning (0, "format argument %d used more than once in %s format",
 988                argnum, fki->name);
 989     }
 990   else
 991     dollar_arguments_used[argnum - 1] = 1;
 992   if (dollar_first_arg_num)
 993     {
 994       int i;
 995       *param_ptr = params;
 996       for (i = 1; i < argnum && *param_ptr != 0; i++)
 997         *param_ptr = TREE_CHAIN (*param_ptr);
 998
 999       /* This case shouldn't be caught here.  */
1000       gcc_assert (*param_ptr);
1001     }
1002   else
1003     *param_ptr = 0;
1004   return argnum;
1005 }
1006
1007 /* Ensure that FORMAT does not start with a decimal number followed by
1008    a $; give a diagnostic and return true if it does, false otherwise.  */
1009
1010 static bool
1011 avoid_dollar_number (const char *format)
1012 {
1013   if (!ISDIGIT (*format))
1014     return false;
1015   while (ISDIGIT (*format))
1016     format++;
1017   if (*format == '$')
1018     {
1019       warning (0, "$ operand number used after format without operand number");
1020       return true;
1021     }
1022   return false;
1023 }
1024
1025
1026 /* Finish the checking for a format string that used $ operand number formats
1027    instead of non-$ formats.  We check for unused operands before used ones
1028    (a serious error, since the implementation of the format function
1029    can't know what types to pass to va_arg to find the later arguments).
1030    and for unused operands at the end of the format (if we know how many
1031    arguments the format had, so not for vprintf).  If there were operand
1032    numbers out of range on a non-vprintf-style format, we won't have reached
1033    here.  If POINTER_GAP_OK, unused arguments are OK if all arguments are
1034    pointers.  */
1035
1036 static void
1037 finish_dollar_format_checking (format_check_results *res, int pointer_gap_ok)
1038 {
1039   int i;
1040   bool found_pointer_gap = false;
1041   for (i = 0; i < dollar_max_arg_used; i++)
1042     {
1043       if (!dollar_arguments_used[i])
1044         {
1045           if (pointer_gap_ok && (dollar_first_arg_num == 0
1046                                  || dollar_arguments_pointer_p[i]))
1047             found_pointer_gap = true;
1048           else
1049             warning (0, "format argument %d unused before used argument %d in $-style format",
1050                      i + 1, dollar_max_arg_used);
1051         }
1052     }
1053   if (found_pointer_gap
1054       || (dollar_first_arg_num
1055           && dollar_max_arg_used < dollar_arguments_count))
1056     {
1057       res->number_other--;
1058       res->number_dollar_extra_args++;
1059     }
1060 }
1061
1062
1063 /* Retrieve the specification for a format flag.  SPEC contains the
1064    specifications for format flags for the applicable kind of format.
1065    FLAG is the flag in question.  If PREDICATES is NULL, the basic
1066    spec for that flag must be retrieved and must exist.  If
1067    PREDICATES is not NULL, it is a string listing possible predicates
1068    for the spec entry; if an entry predicated on any of these is
1069    found, it is returned, otherwise NULL is returned.  */
1070
1071 static const format_flag_spec *
1072 get_flag_spec (const format_flag_spec *spec, int flag, const char *predicates)
1073 {
1074   int i;
1075   for (i = 0; spec[i].flag_char != 0; i++)
1076     {
1077       if (spec[i].flag_char != flag)
1078         continue;
1079       if (predicates != NULL)
1080         {
1081           if (spec[i].predicate != 0
1082               && strchr (predicates, spec[i].predicate) != 0)
1083             return &spec[i];
1084         }
1085       else if (spec[i].predicate == 0)
1086         return &spec[i];
1087     }
1088   gcc_assert (predicates);
1089   return NULL;
1090 }
1091
1092
1093 /* Check the argument list of a call to printf, scanf, etc.
1094    INFO points to the function_format_info structure.
1095    PARAMS is the list of argument values.  */
1096
1097 static void
1098 check_format_info (function_format_info *info, tree params)
1099 {
1100   format_check_context format_ctx;
1101   unsigned HOST_WIDE_INT arg_num;
1102   tree format_tree;
1103   format_check_results res;
1104   /* Skip to format argument.  If the argument isn't available, there's
1105      no work for us to do; prototype checking will catch the problem.  */
1106   for (arg_num = 1; ; ++arg_num)
1107     {
1108       if (params == 0)
1109         return;
1110       if (arg_num == info->format_num)
1111         break;
1112       params = TREE_CHAIN (params);
1113     }
1114   format_tree = TREE_VALUE (params);
1115   params = TREE_CHAIN (params);
1116   if (format_tree == 0)
1117     return;
1118
1119   res.number_non_literal = 0;
1120   res.number_extra_args = 0;
1121   res.number_dollar_extra_args = 0;
1122   res.number_wide = 0;
1123   res.number_empty = 0;
1124   res.number_unterminated = 0;
1125   res.number_other = 0;
1126
1127   format_ctx.res = &res;
1128   format_ctx.info = info;
1129   format_ctx.params = params;
1130
1131   check_function_arguments_recurse (check_format_arg, &format_ctx,
1132                                     format_tree, arg_num);
1133
1134   if (res.number_non_literal > 0)
1135     {
1136       /* Functions taking a va_list normally pass a non-literal format
1137          string.  These functions typically are declared with
1138          first_arg_num == 0, so avoid warning in those cases.  */
1139       if (!(format_types[info->format_type].flags & (int) FMT_FLAG_ARG_CONVERT))
1140         {
1141           /* For strftime-like formats, warn for not checking the format
1142              string; but there are no arguments to check.  */
1143           if (warn_format_nonliteral)
1144             warning (0, "format not a string literal, format string not checked");
1145         }
1146       else if (info->first_arg_num != 0)
1147         {
1148           /* If there are no arguments for the format at all, we may have
1149              printf (foo) which is likely to be a security hole.  */
1150           while (arg_num + 1 < info->first_arg_num)
1151             {
1152               if (params == 0)
1153                 break;
1154               params = TREE_CHAIN (params);
1155               ++arg_num;
1156             }
1157           if (params == 0 && (warn_format_nonliteral || warn_format_security))
1158             warning (0, "format not a string literal and no format arguments");
1159           else if (warn_format_nonliteral)
1160             warning (0, "format not a string literal, argument types not checked");
1161         }
1162     }
1163
1164   /* If there were extra arguments to the format, normally warn.  However,
1165      the standard does say extra arguments are ignored, so in the specific
1166      case where we have multiple leaves (conditional expressions or
1167      ngettext) allow extra arguments if at least one leaf didn't have extra
1168      arguments, but was otherwise OK (either non-literal or checked OK).
1169      If the format is an empty string, this should be counted similarly to the
1170      case of extra format arguments.  */
1171   if (res.number_extra_args > 0 && res.number_non_literal == 0
1172       && res.number_other == 0 && warn_format_extra_args)
1173     warning (0, "too many arguments for format");
1174   if (res.number_dollar_extra_args > 0 && res.number_non_literal == 0
1175       && res.number_other == 0 && warn_format_extra_args)
1176     warning (0, "unused arguments in $-style format");
1177   if (res.number_empty > 0 && res.number_non_literal == 0
1178       && res.number_other == 0 && warn_format_zero_length)
1179     warning (0, "zero-length %s format string",
1180              format_types[info->format_type].name);
1181
1182   if (res.number_wide > 0)
1183     warning (0, "format is a wide character string");
1184
1185   if (res.number_unterminated > 0)
1186     warning (0, "unterminated format string");
1187 }
1188
1189 /* Callback from check_function_arguments_recurse to check a
1190    format string.  FORMAT_TREE is the format parameter.  ARG_NUM
1191    is the number of the format argument.  CTX points to a
1192    format_check_context.  */
1193
1194 static void
1195 check_format_arg (void *ctx, tree format_tree,
1196                   unsigned HOST_WIDE_INT arg_num)
1197 {
1198   format_check_context *format_ctx = (format_check_context *) ctx;
1199   format_check_results *res = format_ctx->res;
1200   function_format_info *info = format_ctx->info;
1201   tree params = format_ctx->params;
1202
1203   int format_length;
1204   HOST_WIDE_INT offset;
1205   const char *format_chars;
1206   tree array_size = 0;
1207   tree array_init;
1208
1209   if (integer_zerop (format_tree))
1210     {
1211       /* Skip to first argument to check, so we can see if this format
1212          has any arguments (it shouldn't).  */
1213       while (arg_num + 1 < info->first_arg_num)
1214         {
1215           if (params == 0)
1216             return;
1217           params = TREE_CHAIN (params);
1218           ++arg_num;
1219         }
1220
1221       if (params == 0)
1222         res->number_other++;
1223       else
1224         res->number_extra_args++;
1225
1226       return;
1227     }
1228
1229   offset = 0;
1230   if (TREE_CODE (format_tree) == PLUS_EXPR)
1231     {
1232       tree arg0, arg1;
1233
1234       arg0 = TREE_OPERAND (format_tree, 0);
1235       arg1 = TREE_OPERAND (format_tree, 1);
1236       STRIP_NOPS (arg0);
1237       STRIP_NOPS (arg1);
1238       if (TREE_CODE (arg1) == INTEGER_CST)
1239         format_tree = arg0;
1240       else if (TREE_CODE (arg0) == INTEGER_CST)
1241         {
1242           format_tree = arg1;
1243           arg1 = arg0;
1244         }
1245       else
1246         {
1247           res->number_non_literal++;
1248           return;
1249         }
1250       if (!host_integerp (arg1, 0)
1251           || (offset = tree_low_cst (arg1, 0)) < 0)
1252         {
1253           res->number_non_literal++;
1254           return;
1255         }
1256     }
1257   if (TREE_CODE (format_tree) != ADDR_EXPR)
1258     {
1259       res->number_non_literal++;
1260       return;
1261     }
1262   format_tree = TREE_OPERAND (format_tree, 0);
1263   if (TREE_CODE (format_tree) == ARRAY_REF
1264       && host_integerp (TREE_OPERAND (format_tree, 1), 0)
1265       && (offset += tree_low_cst (TREE_OPERAND (format_tree, 1), 0)) >= 0)
1266     format_tree = TREE_OPERAND (format_tree, 0);
1267   if (TREE_CODE (format_tree) == VAR_DECL
1268       && TREE_CODE (TREE_TYPE (format_tree)) == ARRAY_TYPE
1269       && (array_init = decl_constant_value (format_tree)) != format_tree
1270       && TREE_CODE (array_init) == STRING_CST)
1271     {
1272       /* Extract the string constant initializer.  Note that this may include
1273          a trailing NUL character that is not in the array (e.g.
1274          const char a[3] = "foo";).  */
1275       array_size = DECL_SIZE_UNIT (format_tree);
1276       format_tree = array_init;
1277     }
1278   if (TREE_CODE (format_tree) != STRING_CST)
1279     {
1280       res->number_non_literal++;
1281       return;
1282     }
1283   if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (format_tree))) != char_type_node)
1284     {
1285       res->number_wide++;
1286       return;
1287     }
1288   format_chars = TREE_STRING_POINTER (format_tree);
1289   format_length = TREE_STRING_LENGTH (format_tree);
1290   if (array_size != 0)
1291     {
1292       /* Variable length arrays can't be initialized.  */
1293       gcc_assert (TREE_CODE (array_size) == INTEGER_CST);
1294
1295       if (host_integerp (array_size, 0))
1296         {
1297           HOST_WIDE_INT array_size_value = TREE_INT_CST_LOW (array_size);
1298           if (array_size_value > 0
1299               && array_size_value == (int) array_size_value
1300               && format_length > array_size_value)
1301             format_length = array_size_value;
1302         }
1303     }
1304   if (offset)
1305     {
1306       if (offset >= format_length)
1307         {
1308           res->number_non_literal++;
1309           return;
1310         }
1311       format_chars += offset;
1312       format_length -= offset;
1313     }
1314   if (format_length < 1)
1315     {
1316       res->number_unterminated++;
1317       return;
1318     }
1319   if (format_length == 1)
1320     {
1321       res->number_empty++;
1322       return;
1323     }
1324   if (format_chars[--format_length] != 0)
1325     {
1326       res->number_unterminated++;
1327       return;
1328     }
1329
1330   /* Skip to first argument to check.  */
1331   while (arg_num + 1 < info->first_arg_num)
1332     {
1333       if (params == 0)
1334         return;
1335       params = TREE_CHAIN (params);
1336       ++arg_num;
1337     }
1338   /* Provisionally increment res->number_other; check_format_info_main
1339      will decrement it if it finds there are extra arguments, but this way
1340      need not adjust it for every return.  */
1341   res->number_other++;
1342   check_format_info_main (res, info, format_chars, format_length,
1343                           params, arg_num);
1344 }
1345
1346
1347 /* Do the main part of checking a call to a format function.  FORMAT_CHARS
1348    is the NUL-terminated format string (which at this point may contain
1349    internal NUL characters); FORMAT_LENGTH is its length (excluding the
1350    terminating NUL character).  ARG_NUM is one less than the number of
1351    the first format argument to check; PARAMS points to that format
1352    argument in the list of arguments.  */
1353
1354 static void
1355 check_format_info_main (format_check_results *res,
1356                         function_format_info *info, const char *format_chars,
1357                         int format_length, tree params,
1358                         unsigned HOST_WIDE_INT arg_num)
1359 {
1360   const char *orig_format_chars = format_chars;
1361   tree first_fillin_param = params;
1362
1363   const format_kind_info *fki = &format_types[info->format_type];
1364   const format_flag_spec *flag_specs = fki->flag_specs;
1365   const format_flag_pair *bad_flag_pairs = fki->bad_flag_pairs;
1366
1367   /* -1 if no conversions taking an operand have been found; 0 if one has
1368      and it didn't use $; 1 if $ formats are in use.  */
1369   int has_operand_number = -1;
1370
1371   init_dollar_format_checking (info->first_arg_num, first_fillin_param);
1372
1373   while (1)
1374     {
1375       int i;
1376       int suppressed = FALSE;
1377       const char *length_chars = NULL;
1378       enum format_lengths length_chars_val = FMT_LEN_none;
1379       enum format_std_version length_chars_std = STD_C89;
1380       int format_char;
1381       tree cur_param;
1382       tree wanted_type;
1383       int main_arg_num = 0;
1384       tree main_arg_params = 0;
1385       enum format_std_version wanted_type_std;
1386       const char *wanted_type_name;
1387       format_wanted_type width_wanted_type;
1388       format_wanted_type precision_wanted_type;
1389       format_wanted_type main_wanted_type;
1390       format_wanted_type *first_wanted_type = NULL;
1391       format_wanted_type *last_wanted_type = NULL;
1392       const format_length_info *fli = NULL;
1393       const format_char_info *fci = NULL;
1394       char flag_chars[256];
1395       int aflag = 0;
1396       const char *format_start = format_chars;
1397       if (*format_chars == 0)
1398         {
1399           if (format_chars - orig_format_chars != format_length)
1400             warning (0, "embedded %<\\0%> in format");
1401           if (info->first_arg_num != 0 && params != 0
1402               && has_operand_number <= 0)
1403             {
1404               res->number_other--;
1405               res->number_extra_args++;
1406             }
1407           if (has_operand_number > 0)
1408             finish_dollar_format_checking (res, fki->flags & (int) FMT_FLAG_DOLLAR_GAP_POINTER_OK);
1409           return;
1410         }
1411       if (*format_chars++ != '%')
1412         continue;
1413       if (*format_chars == 0)
1414         {
1415           warning (0, "spurious trailing %<%%%> in format");
1416           continue;
1417         }
1418       if (*format_chars == '%')
1419         {
1420           ++format_chars;
1421           continue;
1422         }
1423       flag_chars[0] = 0;
1424
1425       if ((fki->flags & (int) FMT_FLAG_USE_DOLLAR) && has_operand_number != 0)
1426         {
1427           /* Possibly read a $ operand number at the start of the format.
1428              If one was previously used, one is required here.  If one
1429              is not used here, we can't immediately conclude this is a
1430              format without them, since it could be printf %m or scanf %*.  */
1431           int opnum;
1432           opnum = maybe_read_dollar_number (&format_chars, 0,
1433                                             first_fillin_param,
1434                                             &main_arg_params, fki);
1435           if (opnum == -1)
1436             return;
1437           else if (opnum > 0)
1438             {
1439               has_operand_number = 1;
1440               main_arg_num = opnum + info->first_arg_num - 1;
1441             }
1442         }
1443       else if (fki->flags & FMT_FLAG_USE_DOLLAR)
1444         {
1445           if (avoid_dollar_number (format_chars))
1446             return;
1447         }
1448
1449       /* Read any format flags, but do not yet validate them beyond removing
1450          duplicates, since in general validation depends on the rest of
1451          the format.  */
1452       while (*format_chars != 0
1453              && strchr (fki->flag_chars, *format_chars) != 0)
1454         {
1455           const format_flag_spec *s = get_flag_spec (flag_specs,
1456                                                      *format_chars, NULL);
1457           if (strchr (flag_chars, *format_chars) != 0)
1458             {
1459               warning (0, "repeated %s in format", _(s->name));
1460             }
1461           else
1462             {
1463               i = strlen (flag_chars);
1464               flag_chars[i++] = *format_chars;
1465               flag_chars[i] = 0;
1466             }
1467           if (s->skip_next_char)
1468             {
1469               ++format_chars;
1470               if (*format_chars == 0)
1471                 {
1472                   warning (0, "missing fill character at end of strfmon format");
1473                   return;
1474                 }
1475             }
1476           ++format_chars;
1477         }
1478
1479       /* Read any format width, possibly * or *m$.  */
1480       if (fki->width_char != 0)
1481         {
1482           if (fki->width_type != NULL && *format_chars == '*')
1483             {
1484               i = strlen (flag_chars);
1485               flag_chars[i++] = fki->width_char;
1486               flag_chars[i] = 0;
1487               /* "...a field width...may be indicated by an asterisk.
1488                  In this case, an int argument supplies the field width..."  */
1489               ++format_chars;
1490               if (has_operand_number != 0)
1491                 {
1492                   int opnum;
1493                   opnum = maybe_read_dollar_number (&format_chars,
1494                                                     has_operand_number == 1,
1495                                                     first_fillin_param,
1496                                                     &params, fki);
1497                   if (opnum == -1)
1498                     return;
1499                   else if (opnum > 0)
1500                     {
1501                       has_operand_number = 1;
1502                       arg_num = opnum + info->first_arg_num - 1;
1503                     }
1504                   else
1505                     has_operand_number = 0;
1506                 }
1507               else
1508                 {
1509                   if (avoid_dollar_number (format_chars))
1510                     return;
1511                 }
1512               if (info->first_arg_num != 0)
1513                 {
1514                   if (params == 0)
1515                     {
1516                       warning (0, "too few arguments for format");
1517                       return;
1518                     }
1519                   cur_param = TREE_VALUE (params);
1520                   if (has_operand_number <= 0)
1521                     {
1522                       params = TREE_CHAIN (params);
1523                       ++arg_num;
1524                     }
1525                   width_wanted_type.wanted_type = *fki->width_type;
1526                   width_wanted_type.wanted_type_name = NULL;
1527                   width_wanted_type.pointer_count = 0;
1528                   width_wanted_type.char_lenient_flag = 0;
1529                   width_wanted_type.writing_in_flag = 0;
1530                   width_wanted_type.reading_from_flag = 0;
1531                   width_wanted_type.name = _("field width");
1532                   width_wanted_type.param = cur_param;
1533                   width_wanted_type.arg_num = arg_num;
1534                   width_wanted_type.next = NULL;
1535                   if (last_wanted_type != 0)
1536                     last_wanted_type->next = &width_wanted_type;
1537                   if (first_wanted_type == 0)
1538                     first_wanted_type = &width_wanted_type;
1539                   last_wanted_type = &width_wanted_type;
1540                 }
1541             }
1542           else
1543             {
1544               /* Possibly read a numeric width.  If the width is zero,
1545                  we complain if appropriate.  */
1546               int non_zero_width_char = FALSE;
1547               int found_width = FALSE;
1548               while (ISDIGIT (*format_chars))
1549                 {
1550                   found_width = TRUE;
1551                   if (*format_chars != '0')
1552                     non_zero_width_char = TRUE;
1553                   ++format_chars;
1554                 }
1555               if (found_width && !non_zero_width_char &&
1556                   (fki->flags & (int) FMT_FLAG_ZERO_WIDTH_BAD))
1557                 warning (0, "zero width in %s format", fki->name);
1558               if (found_width)
1559                 {
1560                   i = strlen (flag_chars);
1561                   flag_chars[i++] = fki->width_char;
1562                   flag_chars[i] = 0;
1563                 }
1564             }
1565         }
1566
1567       /* Read any format left precision (must be a number, not *).  */
1568       if (fki->left_precision_char != 0 && *format_chars == '#')
1569         {
1570           ++format_chars;
1571           i = strlen (flag_chars);
1572           flag_chars[i++] = fki->left_precision_char;
1573           flag_chars[i] = 0;
1574           if (!ISDIGIT (*format_chars))
1575             warning (0, "empty left precision in %s format", fki->name);
1576           while (ISDIGIT (*format_chars))
1577             ++format_chars;
1578         }
1579
1580       /* Read any format precision, possibly * or *m$.  */
1581       if (fki->precision_char != 0 && *format_chars == '.')
1582         {
1583           ++format_chars;
1584           i = strlen (flag_chars);
1585           flag_chars[i++] = fki->precision_char;
1586           flag_chars[i] = 0;
1587           if (fki->precision_type != NULL && *format_chars == '*')
1588             {
1589               /* "...a...precision...may be indicated by an asterisk.
1590                  In this case, an int argument supplies the...precision."  */
1591               ++format_chars;
1592               if (has_operand_number != 0)
1593                 {
1594                   int opnum;
1595                   opnum = maybe_read_dollar_number (&format_chars,
1596                                                     has_operand_number == 1,
1597                                                     first_fillin_param,
1598                                                     &params, fki);
1599                   if (opnum == -1)
1600                     return;
1601                   else if (opnum > 0)
1602                     {
1603                       has_operand_number = 1;
1604                       arg_num = opnum + info->first_arg_num - 1;
1605                     }
1606                   else
1607                     has_operand_number = 0;
1608                 }
1609               else
1610                 {
1611                   if (avoid_dollar_number (format_chars))
1612                     return;
1613                 }
1614               if (info->first_arg_num != 0)
1615                 {
1616                   if (params == 0)
1617                     {
1618                       warning (0, "too few arguments for format");
1619                       return;
1620                     }
1621                   cur_param = TREE_VALUE (params);
1622                   if (has_operand_number <= 0)
1623                     {
1624                       params = TREE_CHAIN (params);
1625                       ++arg_num;
1626                     }
1627                   precision_wanted_type.wanted_type = *fki->precision_type;
1628                   precision_wanted_type.wanted_type_name = NULL;
1629                   precision_wanted_type.pointer_count = 0;
1630                   precision_wanted_type.char_lenient_flag = 0;
1631                   precision_wanted_type.writing_in_flag = 0;
1632                   precision_wanted_type.reading_from_flag = 0;
1633                   precision_wanted_type.name = _("field precision");
1634                   precision_wanted_type.param = cur_param;
1635                   precision_wanted_type.arg_num = arg_num;
1636                   precision_wanted_type.next = NULL;
1637                   if (last_wanted_type != 0)
1638                     last_wanted_type->next = &precision_wanted_type;
1639                   if (first_wanted_type == 0)
1640                     first_wanted_type = &precision_wanted_type;
1641                   last_wanted_type = &precision_wanted_type;
1642                 }
1643             }
1644           else
1645             {
1646               if (!(fki->flags & (int) FMT_FLAG_EMPTY_PREC_OK)
1647                   && !ISDIGIT (*format_chars))
1648                 warning (0, "empty precision in %s format", fki->name);
1649               while (ISDIGIT (*format_chars))
1650                 ++format_chars;
1651             }
1652         }
1653
1654       /* Read any length modifier, if this kind of format has them.  */
1655       fli = fki->length_char_specs;
1656       length_chars = NULL;
1657       length_chars_val = FMT_LEN_none;
1658       length_chars_std = STD_C89;
1659       if (fli)
1660         {
1661           while (fli->name != 0 && fli->name[0] != *format_chars)
1662             fli++;
1663           if (fli->name != 0)
1664             {
1665               format_chars++;
1666               if (fli->double_name != 0 && fli->name[0] == *format_chars)
1667                 {
1668                   format_chars++;
1669                   length_chars = fli->double_name;
1670                   length_chars_val = fli->double_index;
1671                   length_chars_std = fli->double_std;
1672                 }
1673               else
1674                 {
1675                   length_chars = fli->name;
1676                   length_chars_val = fli->index;
1677                   length_chars_std = fli->std;
1678                 }
1679               i = strlen (flag_chars);
1680               flag_chars[i++] = fki->length_code_char;
1681               flag_chars[i] = 0;
1682             }
1683           if (pedantic)
1684             {
1685               /* Warn if the length modifier is non-standard.  */
1686               if (ADJ_STD (length_chars_std) > C_STD_VER)
1687                 warning (0, "%s does not support the %qs %s length modifier",
1688                          C_STD_NAME (length_chars_std), length_chars,
1689                          fki->name);
1690             }
1691         }
1692
1693       /* Read any modifier (strftime E/O).  */
1694       if (fki->modifier_chars != NULL)
1695         {
1696           while (*format_chars != 0
1697                  && strchr (fki->modifier_chars, *format_chars) != 0)
1698             {
1699               if (strchr (flag_chars, *format_chars) != 0)
1700                 {
1701                   const format_flag_spec *s = get_flag_spec (flag_specs,
1702                                                              *format_chars, NULL);
1703                   warning (0, "repeated %s in format", _(s->name));
1704                 }
1705               else
1706                 {
1707                   i = strlen (flag_chars);
1708                   flag_chars[i++] = *format_chars;
1709                   flag_chars[i] = 0;
1710                 }
1711               ++format_chars;
1712             }
1713         }
1714
1715       /* Handle the scanf allocation kludge.  */
1716       if (fki->flags & (int) FMT_FLAG_SCANF_A_KLUDGE)
1717         {
1718           if (*format_chars == 'a' && !flag_isoc99)
1719             {
1720               if (format_chars[1] == 's' || format_chars[1] == 'S'
1721                   || format_chars[1] == '[')
1722                 {
1723                   /* 'a' is used as a flag.  */
1724                   i = strlen (flag_chars);
1725                   flag_chars[i++] = 'a';
1726                   flag_chars[i] = 0;
1727                   format_chars++;
1728                 }
1729             }
1730         }
1731
1732       format_char = *format_chars;
1733       if (format_char == 0
1734           || (!(fki->flags & (int) FMT_FLAG_FANCY_PERCENT_OK)
1735               && format_char == '%'))
1736         {
1737           warning (0, "conversion lacks type at end of format");
1738           continue;
1739         }
1740       format_chars++;
1741       fci = fki->conversion_specs;
1742       while (fci->format_chars != 0
1743              && strchr (fci->format_chars, format_char) == 0)
1744           ++fci;
1745       if (fci->format_chars == 0)
1746         {
1747           if (ISGRAPH (format_char))
1748             warning (0, "unknown conversion type character %qc in format",
1749                      format_char);
1750           else
1751             warning (0, "unknown conversion type character 0x%x in format",
1752                      format_char);
1753           continue;
1754         }
1755       if (pedantic)
1756         {
1757           if (ADJ_STD (fci->std) > C_STD_VER)
1758             warning (0, "%s does not support the %<%%%c%> %s format",
1759                      C_STD_NAME (fci->std), format_char, fki->name);
1760         }
1761
1762       /* Validate the individual flags used, removing any that are invalid.  */
1763       {
1764         int d = 0;
1765         for (i = 0; flag_chars[i] != 0; i++)
1766           {
1767             const format_flag_spec *s = get_flag_spec (flag_specs,
1768                                                        flag_chars[i], NULL);
1769             flag_chars[i - d] = flag_chars[i];
1770             if (flag_chars[i] == fki->length_code_char)
1771               continue;
1772             if (strchr (fci->flag_chars, flag_chars[i]) == 0)
1773               {
1774                 warning (0, "%s used with %<%%%c%> %s format",
1775                          _(s->name), format_char, fki->name);
1776                 d++;
1777                 continue;
1778               }
1779             if (pedantic)
1780               {
1781                 const format_flag_spec *t;
1782                 if (ADJ_STD (s->std) > C_STD_VER)
1783                   warning (0, "%s does not support %s",
1784                            C_STD_NAME (s->std), _(s->long_name));
1785                 t = get_flag_spec (flag_specs, flag_chars[i], fci->flags2);
1786                 if (t != NULL && ADJ_STD (t->std) > ADJ_STD (s->std))
1787                   {
1788                     const char *long_name = (t->long_name != NULL
1789                                              ? t->long_name
1790                                              : s->long_name);
1791                     if (ADJ_STD (t->std) > C_STD_VER)
1792                       warning (0, "%s does not support %s with the %<%%%c%> %s format",
1793                                C_STD_NAME (t->std), _(long_name),
1794                                format_char, fki->name);
1795                   }
1796               }
1797           }
1798         flag_chars[i - d] = 0;
1799       }
1800
1801       if ((fki->flags & (int) FMT_FLAG_SCANF_A_KLUDGE)
1802           && strchr (flag_chars, 'a') != 0)
1803         aflag = 1;
1804
1805       if (fki->suppression_char
1806           && strchr (flag_chars, fki->suppression_char) != 0)
1807         suppressed = 1;
1808
1809       /* Validate the pairs of flags used.  */
1810       for (i = 0; bad_flag_pairs[i].flag_char1 != 0; i++)
1811         {
1812           const format_flag_spec *s, *t;
1813           if (strchr (flag_chars, bad_flag_pairs[i].flag_char1) == 0)
1814             continue;
1815           if (strchr (flag_chars, bad_flag_pairs[i].flag_char2) == 0)
1816             continue;
1817           if (bad_flag_pairs[i].predicate != 0
1818               && strchr (fci->flags2, bad_flag_pairs[i].predicate) == 0)
1819             continue;
1820           s = get_flag_spec (flag_specs, bad_flag_pairs[i].flag_char1, NULL);
1821           t = get_flag_spec (flag_specs, bad_flag_pairs[i].flag_char2, NULL);
1822           if (bad_flag_pairs[i].ignored)
1823             {
1824               if (bad_flag_pairs[i].predicate != 0)
1825                 warning (0, "%s ignored with %s and %<%%%c%> %s format",
1826                          _(s->name), _(t->name), format_char,
1827                          fki->name);
1828               else
1829                 warning (0, "%s ignored with %s in %s format",
1830                          _(s->name), _(t->name), fki->name);
1831             }
1832           else
1833             {
1834               if (bad_flag_pairs[i].predicate != 0)
1835                 warning (0, "use of %s and %s together with %<%%%c%> %s format",
1836                          _(s->name), _(t->name), format_char,
1837                          fki->name);
1838               else
1839                 warning (0, "use of %s and %s together in %s format",
1840                          _(s->name), _(t->name), fki->name);
1841             }
1842         }
1843
1844       /* Give Y2K warnings.  */
1845       if (warn_format_y2k)
1846         {
1847           int y2k_level = 0;
1848           if (strchr (fci->flags2, '4') != 0)
1849             if (strchr (flag_chars, 'E') != 0)
1850               y2k_level = 3;
1851             else
1852               y2k_level = 2;
1853           else if (strchr (fci->flags2, '3') != 0)
1854             y2k_level = 3;
1855           else if (strchr (fci->flags2, '2') != 0)
1856             y2k_level = 2;
1857           if (y2k_level == 3)
1858             warning (0, "%<%%%c%> yields only last 2 digits of year in some locales",
1859                      format_char);
1860           else if (y2k_level == 2)
1861             warning (0, "%<%%%c%> yields only last 2 digits of year", format_char);
1862         }
1863
1864       if (strchr (fci->flags2, '[') != 0)
1865         {
1866           /* Skip over scan set, in case it happens to have '%' in it.  */
1867           if (*format_chars == '^')
1868             ++format_chars;
1869           /* Find closing bracket; if one is hit immediately, then
1870              it's part of the scan set rather than a terminator.  */
1871           if (*format_chars == ']')
1872             ++format_chars;
1873           while (*format_chars && *format_chars != ']')
1874             ++format_chars;
1875           if (*format_chars != ']')
1876             /* The end of the format string was reached.  */
1877             warning (0, "no closing %<]%> for %<%%[%> format");
1878         }
1879
1880       wanted_type = 0;
1881       wanted_type_name = 0;
1882       if (fki->flags & (int) FMT_FLAG_ARG_CONVERT)
1883         {
1884           wanted_type = (fci->types[length_chars_val].type
1885                          ? *fci->types[length_chars_val].type : 0);
1886           wanted_type_name = fci->types[length_chars_val].name;
1887           wanted_type_std = fci->types[length_chars_val].std;
1888           if (wanted_type == 0)
1889             {
1890               warning (0, "use of %qs length modifier with %qc type character",
1891                        length_chars, format_char);
1892               /* Heuristic: skip one argument when an invalid length/type
1893                  combination is encountered.  */
1894               arg_num++;
1895               if (params == 0)
1896                 {
1897                   warning (0, "too few arguments for format");
1898                   return;
1899                 }
1900               params = TREE_CHAIN (params);
1901               continue;
1902             }
1903           else if (pedantic
1904                    /* Warn if non-standard, provided it is more non-standard
1905                       than the length and type characters that may already
1906                       have been warned for.  */
1907                    && ADJ_STD (wanted_type_std) > ADJ_STD (length_chars_std)
1908                    && ADJ_STD (wanted_type_std) > ADJ_STD (fci->std))
1909             {
1910               if (ADJ_STD (wanted_type_std) > C_STD_VER)
1911                 warning (0, "%s does not support the %<%%%s%c%> %s format",
1912                          C_STD_NAME (wanted_type_std), length_chars,
1913                          format_char, fki->name);
1914             }
1915         }
1916
1917       main_wanted_type.next = NULL;
1918
1919       /* Finally. . .check type of argument against desired type!  */
1920       if (info->first_arg_num == 0)
1921         continue;
1922       if ((fci->pointer_count == 0 && wanted_type == void_type_node)
1923           || suppressed)
1924         {
1925           if (main_arg_num != 0)
1926             {
1927               if (suppressed)
1928                 warning (0, "operand number specified with suppressed assignment");
1929               else
1930                 warning (0, "operand number specified for format taking no argument");
1931             }
1932         }
1933       else
1934         {
1935           format_wanted_type *wanted_type_ptr;
1936
1937           if (main_arg_num != 0)
1938             {
1939               arg_num = main_arg_num;
1940               params = main_arg_params;
1941             }
1942           else
1943             {
1944               ++arg_num;
1945               if (has_operand_number > 0)
1946                 {
1947                   warning (0, "missing $ operand number in format");
1948                   return;
1949                 }
1950               else
1951                 has_operand_number = 0;
1952             }
1953
1954           wanted_type_ptr = &main_wanted_type;
1955           while (fci)
1956             {
1957               if (params == 0)
1958                 {
1959                   warning (0, "too few arguments for format");
1960                   return;
1961                 }
1962
1963               cur_param = TREE_VALUE (params);
1964               params = TREE_CHAIN (params);
1965
1966               wanted_type_ptr->wanted_type = wanted_type;
1967               wanted_type_ptr->wanted_type_name = wanted_type_name;
1968               wanted_type_ptr->pointer_count = fci->pointer_count + aflag;
1969               wanted_type_ptr->char_lenient_flag = 0;
1970               if (strchr (fci->flags2, 'c') != 0)
1971                 wanted_type_ptr->char_lenient_flag = 1;
1972               wanted_type_ptr->writing_in_flag = 0;
1973               wanted_type_ptr->reading_from_flag = 0;
1974               if (aflag)
1975                 wanted_type_ptr->writing_in_flag = 1;
1976               else
1977                 {
1978                   if (strchr (fci->flags2, 'W') != 0)
1979                     wanted_type_ptr->writing_in_flag = 1;
1980                   if (strchr (fci->flags2, 'R') != 0)
1981                     wanted_type_ptr->reading_from_flag = 1;
1982                 }
1983               wanted_type_ptr->name = NULL;
1984               wanted_type_ptr->param = cur_param;
1985               wanted_type_ptr->arg_num = arg_num;
1986               wanted_type_ptr->next = NULL;
1987               if (last_wanted_type != 0)
1988                 last_wanted_type->next = wanted_type_ptr;
1989               if (first_wanted_type == 0)
1990                 first_wanted_type = wanted_type_ptr;
1991               last_wanted_type = wanted_type_ptr;
1992
1993               fci = fci->chain;
1994               if (fci)
1995                 {
1996                   wanted_type_ptr = ggc_alloc (sizeof (main_wanted_type));
1997                   arg_num++;
1998                   wanted_type = *fci->types[length_chars_val].type;
1999                   wanted_type_name = fci->types[length_chars_val].name;
2000                 }
2001             }
2002         }
2003
2004       if (first_wanted_type != 0)
2005         check_format_types (first_wanted_type, format_start,
2006                             format_chars - format_start);
2007
2008       if (main_wanted_type.next != NULL)
2009         {
2010           format_wanted_type *wanted_type_ptr = main_wanted_type.next;
2011           while (wanted_type_ptr)
2012             {
2013               format_wanted_type *next = wanted_type_ptr->next;
2014               ggc_free (wanted_type_ptr);
2015               wanted_type_ptr = next;
2016             }
2017         }
2018     }
2019 }
2020
2021
2022 /* Check the argument types from a single format conversion (possibly
2023    including width and precision arguments).  */
2024 static void
2025 check_format_types (format_wanted_type *types, const char *format_start,
2026                     int format_length)
2027 {
2028   for (; types != 0; types = types->next)
2029     {
2030       tree cur_param;
2031       tree cur_type;
2032       tree orig_cur_type;
2033       tree wanted_type;
2034       int arg_num;
2035       int i;
2036       int char_type_flag;
2037       cur_param = types->param;
2038       cur_type = TREE_TYPE (cur_param);
2039       if (cur_type == error_mark_node)
2040         continue;
2041       orig_cur_type = cur_type;
2042       char_type_flag = 0;
2043       wanted_type = types->wanted_type;
2044       arg_num = types->arg_num;
2045
2046       /* The following should not occur here.  */
2047       gcc_assert (wanted_type);
2048       gcc_assert (wanted_type != void_type_node || types->pointer_count);
2049
2050       if (types->pointer_count == 0)
2051         wanted_type = lang_hooks.types.type_promotes_to (wanted_type);
2052
2053       wanted_type = TYPE_MAIN_VARIANT (wanted_type);
2054
2055       STRIP_NOPS (cur_param);
2056
2057       /* Check the types of any additional pointer arguments
2058          that precede the "real" argument.  */
2059       for (i = 0; i < types->pointer_count; ++i)
2060         {
2061           if (TREE_CODE (cur_type) == POINTER_TYPE)
2062             {
2063               cur_type = TREE_TYPE (cur_type);
2064               if (cur_type == error_mark_node)
2065                 break;
2066
2067               /* Check for writing through a NULL pointer.  */
2068               if (types->writing_in_flag
2069                   && i == 0
2070                   && cur_param != 0
2071                   && integer_zerop (cur_param))
2072                 warning (0, "writing through null pointer (argument %d)",
2073                          arg_num);
2074
2075               /* Check for reading through a NULL pointer.  */
2076               if (types->reading_from_flag
2077                   && i == 0
2078                   && cur_param != 0
2079                   && integer_zerop (cur_param))
2080                 warning (0, "reading through null pointer (argument %d)",
2081                          arg_num);
2082
2083               if (cur_param != 0 && TREE_CODE (cur_param) == ADDR_EXPR)
2084                 cur_param = TREE_OPERAND (cur_param, 0);
2085               else
2086                 cur_param = 0;
2087
2088               /* See if this is an attempt to write into a const type with
2089                  scanf or with printf "%n".  Note: the writing in happens
2090                  at the first indirection only, if for example
2091                  void * const * is passed to scanf %p; passing
2092                  const void ** is simply passing an incompatible type.  */
2093               if (types->writing_in_flag
2094                   && i == 0
2095                   && (TYPE_READONLY (cur_type)
2096                       || (cur_param != 0
2097                           && (CONSTANT_CLASS_P (cur_param)
2098                               || (DECL_P (cur_param)
2099                                   && TREE_READONLY (cur_param))))))
2100                 warning (0, "writing into constant object (argument %d)",
2101                          arg_num);
2102
2103               /* If there are extra type qualifiers beyond the first
2104                  indirection, then this makes the types technically
2105                  incompatible.  */
2106               if (i > 0
2107                   && pedantic
2108                   && (TYPE_READONLY (cur_type)
2109                       || TYPE_VOLATILE (cur_type)
2110                       || TYPE_RESTRICT (cur_type)))
2111                 warning (0, "extra type qualifiers in format argument "
2112                          "(argument %d)",
2113                          arg_num);
2114
2115             }
2116           else
2117             {
2118               format_type_warning (types->name, format_start, format_length,
2119                                    wanted_type, types->pointer_count,
2120                                    types->wanted_type_name, orig_cur_type,
2121                                    arg_num);
2122               break;
2123             }
2124         }
2125
2126       if (i < types->pointer_count)
2127         continue;
2128
2129       cur_type = TYPE_MAIN_VARIANT (cur_type);
2130
2131       /* Check whether the argument type is a character type.  This leniency
2132          only applies to certain formats, flagged with 'c'.
2133       */
2134       if (types->char_lenient_flag)
2135         char_type_flag = (cur_type == char_type_node
2136                           || cur_type == signed_char_type_node
2137                           || cur_type == unsigned_char_type_node);
2138
2139       /* Check the type of the "real" argument, if there's a type we want.  */
2140       if (wanted_type == cur_type)
2141         continue;
2142       /* If we want 'void *', allow any pointer type.
2143          (Anything else would already have got a warning.)
2144          With -pedantic, only allow pointers to void and to character
2145          types.  */
2146       if (wanted_type == void_type_node
2147           && (!pedantic || (i == 1 && char_type_flag)))
2148         continue;
2149       /* Don't warn about differences merely in signedness, unless
2150          -pedantic.  With -pedantic, warn if the type is a pointer
2151          target and not a character type, and for character types at
2152          a second level of indirection.  */
2153       if (TREE_CODE (wanted_type) == INTEGER_TYPE
2154           && TREE_CODE (cur_type) == INTEGER_TYPE
2155           && (!pedantic || i == 0 || (i == 1 && char_type_flag))
2156           && (TYPE_UNSIGNED (wanted_type)
2157               ? wanted_type == c_common_unsigned_type (cur_type)
2158               : wanted_type == c_common_signed_type (cur_type)))
2159         continue;
2160       /* Likewise, "signed char", "unsigned char" and "char" are
2161          equivalent but the above test won't consider them equivalent.  */
2162       if (wanted_type == char_type_node
2163           && (!pedantic || i < 2)
2164           && char_type_flag)
2165         continue;
2166       /* Now we have a type mismatch.  */
2167       format_type_warning (types->name, format_start, format_length,
2168                            wanted_type, types->pointer_count,
2169                            types->wanted_type_name, orig_cur_type, arg_num);
2170     }
2171 }
2172
2173
2174 /* Give a warning about a format argument of different type from that
2175    expected.  DESCR is a description such as "field precision", or
2176    NULL for an ordinary format.  For an ordinary format, FORMAT_START
2177    points to where the format starts in the format string and
2178    FORMAT_LENGTH is its length.  WANTED_TYPE is the type the argument
2179    should have after POINTER_COUNT pointer dereferences.
2180    WANTED_NAME_NAME is a possibly more friendly name of WANTED_TYPE,
2181    or NULL if the ordinary name of the type should be used.  ARG_TYPE
2182    is the type of the actual argument.  ARG_NUM is the number of that
2183    argument.  */
2184 static void
2185 format_type_warning (const char *descr, const char *format_start,
2186                      int format_length, tree wanted_type, int pointer_count,
2187                      const char *wanted_type_name, tree arg_type, int arg_num)
2188 {
2189   char *p;
2190   /* If ARG_TYPE is a typedef with a misleading name (for example,
2191      size_t but not the standard size_t expected by printf %zu), avoid
2192      printing the typedef name.  */
2193   if (wanted_type_name
2194       && TYPE_NAME (arg_type)
2195       && TREE_CODE (TYPE_NAME (arg_type)) == TYPE_DECL
2196       && DECL_NAME (TYPE_NAME (arg_type))
2197       && !strcmp (wanted_type_name,
2198                   lang_hooks.decl_printable_name (TYPE_NAME (arg_type), 2)))
2199     arg_type = TYPE_MAIN_VARIANT (arg_type);
2200   /* The format type and name exclude any '*' for pointers, so those
2201      must be formatted manually.  For all the types we currently have,
2202      this is adequate, but formats taking pointers to functions or
2203      arrays would require the full type to be built up in order to
2204      print it with %T.  */
2205   p = alloca (pointer_count + 2);
2206   if (pointer_count == 0)
2207     p[0] = 0;
2208   else if (c_dialect_cxx ())
2209     {
2210       memset (p, '*', pointer_count);
2211       p[pointer_count] = 0;
2212     }
2213   else
2214     {
2215       p[0] = ' ';
2216       memset (p + 1, '*', pointer_count);
2217       p[pointer_count + 1] = 0;
2218     }
2219   if (wanted_type_name)
2220     {
2221       if (descr)
2222         warning (0, "%s should have type %<%s%s%>, but argument %d has type %qT",
2223                  descr, wanted_type_name, p, arg_num, arg_type);
2224       else
2225         warning (0, "format %q.*s expects type %<%s%s%>, but argument %d has type %qT",
2226                  format_length, format_start, wanted_type_name, p,
2227                  arg_num, arg_type);
2228     }
2229   else
2230     {
2231       if (descr)
2232         warning (0, "%s should have type %<%T%s%>, but argument %d has type %qT",
2233                  descr, wanted_type, p, arg_num, arg_type);
2234       else
2235         warning (0, "format %q.*s expects type %<%T%s%>, but argument %d has type %qT",
2236                  format_length, format_start, wanted_type, p, arg_num, arg_type);
2237     }
2238 }
2239
2240
2241 /* Given a format_char_info array FCI, and a character C, this function
2242    returns the index into the conversion_specs where that specifier's
2243    data is located.  The character must exist.  */
2244 static unsigned int
2245 find_char_info_specifier_index (const format_char_info *fci, int c)
2246 {
2247   unsigned i;
2248
2249   for (i = 0; fci->format_chars; i++, fci++)
2250     if (strchr (fci->format_chars, c))
2251       return i;
2252
2253   /* We shouldn't be looking for a non-existent specifier.  */
2254   gcc_unreachable ();
2255 }
2256
2257 /* Given a format_length_info array FLI, and a character C, this
2258    function returns the index into the conversion_specs where that
2259    modifier's data is located.  The character must exist.  */
2260 static unsigned int
2261 find_length_info_modifier_index (const format_length_info *fli, int c)
2262 {
2263   unsigned i;
2264
2265   for (i = 0; fli->name; i++, fli++)
2266     if (strchr (fli->name, c))
2267       return i;
2268
2269   /* We shouldn't be looking for a non-existent modifier.  */
2270   gcc_unreachable ();
2271 }
2272
2273 /* Determine the type of HOST_WIDE_INT in the code being compiled for
2274    use in GCC's __asm_fprintf__ custom format attribute.  You must
2275    have set dynamic_format_types before calling this function.  */
2276 static void
2277 init_dynamic_asm_fprintf_info (void)
2278 {
2279   static tree hwi;
2280
2281   if (!hwi)
2282     {
2283       format_length_info *new_asm_fprintf_length_specs;
2284       unsigned int i;
2285
2286       /* Find the underlying type for HOST_WIDE_INT.  For the %w
2287          length modifier to work, one must have issued: "typedef
2288          HOST_WIDE_INT __gcc_host_wide_int__;" in one's source code
2289          prior to using that modifier.  */
2290       hwi = maybe_get_identifier ("__gcc_host_wide_int__");
2291       if (!hwi)
2292         {
2293           error ("%<__gcc_host_wide_int__%> is not defined as a type");
2294           return;
2295         }
2296       hwi = identifier_global_value (hwi);
2297       if (!hwi || TREE_CODE (hwi) != TYPE_DECL)
2298         {
2299           error ("%<__gcc_host_wide_int__%> is not defined as a type");
2300           return;
2301         }
2302       hwi = DECL_ORIGINAL_TYPE (hwi);
2303       gcc_assert (hwi);
2304       if (hwi != long_integer_type_node && hwi != long_long_integer_type_node)
2305         {
2306           error ("%<__gcc_host_wide_int__%> is not defined as %<long%>"
2307                  " or %<long long%>");
2308           return;
2309         }
2310
2311       /* Create a new (writable) copy of asm_fprintf_length_specs.  */
2312       new_asm_fprintf_length_specs = (format_length_info *)
2313                                      xmemdup (asm_fprintf_length_specs,
2314                                               sizeof (asm_fprintf_length_specs),
2315                                               sizeof (asm_fprintf_length_specs));
2316
2317       /* HOST_WIDE_INT must be one of 'long' or 'long long'.  */
2318       i = find_length_info_modifier_index (new_asm_fprintf_length_specs, 'w');
2319       if (hwi == long_integer_type_node)
2320         new_asm_fprintf_length_specs[i].index = FMT_LEN_l;
2321       else if (hwi == long_long_integer_type_node)
2322         new_asm_fprintf_length_specs[i].index = FMT_LEN_ll;
2323       else
2324         gcc_unreachable ();
2325
2326       /* Assign the new data for use.  */
2327       dynamic_format_types[asm_fprintf_format_type].length_char_specs =
2328         new_asm_fprintf_length_specs;
2329     }
2330 }
2331
2332 /* Determine the types of "tree" and "location_t" in the code being
2333    compiled for use in GCC's diagnostic custom format attributes.  You
2334    must have set dynamic_format_types before calling this function.  */
2335 static void
2336 init_dynamic_diag_info (void)
2337 {
2338   static tree t, loc, hwi;
2339
2340   if (!loc || !t || !hwi)
2341     {
2342       static format_char_info *diag_fci, *cdiag_fci, *cxxdiag_fci;
2343       static format_length_info *diag_ls;
2344       unsigned int i;
2345
2346       /* For the GCC-diagnostics custom format specifiers to work, one
2347          must have declared 'tree' and/or 'location_t' prior to using
2348          those attributes.  If we haven't seen these declarations then
2349          you shouldn't use the specifiers requiring these types.
2350          However we don't force a hard ICE because we may see only one
2351          or the other type.  */
2352       if ((loc = maybe_get_identifier ("location_t")))
2353         {
2354           loc = identifier_global_value (loc);
2355           if (loc)
2356             {
2357               if (TREE_CODE (loc) != TYPE_DECL)
2358                 {
2359                   error ("%<location_t%> is not defined as a type");
2360                   loc = 0;
2361                 }
2362               else
2363                 loc = TREE_TYPE (loc);
2364             }
2365         }
2366
2367       /* We need to grab the underlying 'union tree_node' so peek into
2368          an extra type level.  */
2369       if ((t = maybe_get_identifier ("tree")))
2370         {
2371           t = identifier_global_value (t);
2372           if (t)
2373             {
2374               if (TREE_CODE (t) != TYPE_DECL)
2375                 {
2376                   error ("%<tree%> is not defined as a type");
2377                   t = 0;
2378                 }
2379               else if (TREE_CODE (TREE_TYPE (t)) != POINTER_TYPE)
2380                 {
2381                   error ("%<tree%> is not defined as a pointer type");
2382                   t = 0;
2383                 }
2384               else
2385                 t = TREE_TYPE (TREE_TYPE (t));
2386             }
2387         }
2388
2389       /* Find the underlying type for HOST_WIDE_INT.  For the %w
2390          length modifier to work, one must have issued: "typedef
2391          HOST_WIDE_INT __gcc_host_wide_int__;" in one's source code
2392          prior to using that modifier.  */
2393       if ((hwi = maybe_get_identifier ("__gcc_host_wide_int__")))
2394         {
2395           hwi = identifier_global_value (hwi);
2396           if (hwi)
2397             {
2398               if (TREE_CODE (hwi) != TYPE_DECL)
2399                 {
2400                   error ("%<__gcc_host_wide_int__%> is not defined as a type");
2401                   hwi = 0;
2402                 }
2403               else
2404                 {
2405                   hwi = DECL_ORIGINAL_TYPE (hwi);
2406                   gcc_assert (hwi);
2407                   if (hwi != long_integer_type_node
2408                       && hwi != long_long_integer_type_node)
2409                     {
2410                       error ("%<__gcc_host_wide_int__%> is not defined"
2411                              " as %<long%> or %<long long%>");
2412                       hwi = 0;
2413                     }
2414                 }
2415             }
2416         }
2417
2418       /* Assign the new data for use.  */
2419
2420       /* All the GCC diag formats use the same length specs.  */
2421       if (!diag_ls)
2422         dynamic_format_types[gcc_diag_format_type].length_char_specs =
2423           dynamic_format_types[gcc_cdiag_format_type].length_char_specs =
2424           dynamic_format_types[gcc_cxxdiag_format_type].length_char_specs =
2425           diag_ls = (format_length_info *)
2426                     xmemdup (gcc_diag_length_specs,
2427                              sizeof (gcc_diag_length_specs),
2428                              sizeof (gcc_diag_length_specs));
2429       if (hwi)
2430         {
2431           /* HOST_WIDE_INT must be one of 'long' or 'long long'.  */
2432           i = find_length_info_modifier_index (diag_ls, 'w');
2433           if (hwi == long_integer_type_node)
2434             diag_ls[i].index = FMT_LEN_l;
2435           else if (hwi == long_long_integer_type_node)
2436             diag_ls[i].index = FMT_LEN_ll;
2437           else
2438             gcc_unreachable ();
2439         }
2440
2441       /* Handle the __gcc_diag__ format specifics.  */
2442       if (!diag_fci)
2443         dynamic_format_types[gcc_diag_format_type].conversion_specs =
2444           diag_fci = (format_char_info *)
2445                      xmemdup (gcc_diag_char_table,
2446                               sizeof (gcc_diag_char_table),
2447                               sizeof (gcc_diag_char_table));
2448       if (loc)
2449         {
2450           i = find_char_info_specifier_index (diag_fci, 'H');
2451           diag_fci[i].types[0].type = &loc;
2452           diag_fci[i].pointer_count = 1;
2453         }
2454       if (t)
2455         {
2456           i = find_char_info_specifier_index (diag_fci, 'J');
2457           diag_fci[i].types[0].type = &t;
2458           diag_fci[i].pointer_count = 1;
2459         }
2460
2461       /* Handle the __gcc_cdiag__ format specifics.  */
2462       if (!cdiag_fci)
2463         dynamic_format_types[gcc_cdiag_format_type].conversion_specs =
2464           cdiag_fci = (format_char_info *)
2465                       xmemdup (gcc_cdiag_char_table,
2466                                sizeof (gcc_cdiag_char_table),
2467                                sizeof (gcc_cdiag_char_table));
2468       if (loc)
2469         {
2470           i = find_char_info_specifier_index (cdiag_fci, 'H');
2471           cdiag_fci[i].types[0].type = &loc;
2472           cdiag_fci[i].pointer_count = 1;
2473         }
2474       if (t)
2475         {
2476           /* All specifiers taking a tree share the same struct.  */
2477           i = find_char_info_specifier_index (cdiag_fci, 'D');
2478           cdiag_fci[i].types[0].type = &t;
2479           cdiag_fci[i].pointer_count = 1;
2480           i = find_char_info_specifier_index (cdiag_fci, 'J');
2481           cdiag_fci[i].types[0].type = &t;
2482           cdiag_fci[i].pointer_count = 1;
2483         }
2484
2485       /* Handle the __gcc_cxxdiag__ format specifics.  */
2486       if (!cxxdiag_fci)
2487         dynamic_format_types[gcc_cxxdiag_format_type].conversion_specs =
2488           cxxdiag_fci = (format_char_info *)
2489                         xmemdup (gcc_cxxdiag_char_table,
2490                                  sizeof (gcc_cxxdiag_char_table),
2491                                  sizeof (gcc_cxxdiag_char_table));
2492       if (loc)
2493         {
2494           i = find_char_info_specifier_index (cxxdiag_fci, 'H');
2495           cxxdiag_fci[i].types[0].type = &loc;
2496           cxxdiag_fci[i].pointer_count = 1;
2497         }
2498       if (t)
2499         {
2500           /* All specifiers taking a tree share the same struct.  */
2501           i = find_char_info_specifier_index (cxxdiag_fci, 'D');
2502           cxxdiag_fci[i].types[0].type = &t;
2503           cxxdiag_fci[i].pointer_count = 1;
2504           i = find_char_info_specifier_index (cxxdiag_fci, 'J');
2505           cxxdiag_fci[i].types[0].type = &t;
2506           cxxdiag_fci[i].pointer_count = 1;
2507         }
2508     }
2509 }
2510
2511 #ifdef TARGET_FORMAT_TYPES
2512 extern const format_kind_info TARGET_FORMAT_TYPES[];
2513 #endif
2514
2515 /* Handle a "format" attribute; arguments as in
2516    struct attribute_spec.handler.  */
2517 tree
2518 handle_format_attribute (tree *node, tree ARG_UNUSED (name), tree args,
2519                          int flags, bool *no_add_attrs)
2520 {
2521   tree type = *node;
2522   function_format_info info;
2523   tree argument;
2524
2525 #ifdef TARGET_FORMAT_TYPES
2526   /* If the target provides additional format types, we need to
2527      add them to FORMAT_TYPES at first use.  */
2528   if (TARGET_FORMAT_TYPES != NULL && !dynamic_format_types)
2529     {
2530       dynamic_format_types = xmalloc ((n_format_types + TARGET_N_FORMAT_TYPES)
2531                                       * sizeof (dynamic_format_types[0]));
2532       memcpy (dynamic_format_types, format_types_orig,
2533               sizeof (format_types_orig));
2534       memcpy (&dynamic_format_types[n_format_types], TARGET_FORMAT_TYPES,
2535               TARGET_N_FORMAT_TYPES * sizeof (dynamic_format_types[0]));
2536
2537       format_types = dynamic_format_types;
2538       n_format_types += TARGET_N_FORMAT_TYPES;
2539     }
2540 #endif
2541
2542   if (!decode_format_attr (args, &info, 0))
2543     {
2544       *no_add_attrs = true;
2545       return NULL_TREE;
2546     }
2547
2548   argument = TYPE_ARG_TYPES (type);
2549   if (argument)
2550     {
2551       if (!check_format_string (argument, info.format_num, flags,
2552                                 no_add_attrs))
2553         return NULL_TREE;
2554
2555       if (info.first_arg_num != 0)
2556         {
2557           unsigned HOST_WIDE_INT arg_num = 1;
2558
2559           /* Verify that first_arg_num points to the last arg,
2560              the ...  */
2561           while (argument)
2562             arg_num++, argument = TREE_CHAIN (argument);
2563
2564           if (arg_num != info.first_arg_num)
2565             {
2566               if (!(flags & (int) ATTR_FLAG_BUILT_IN))
2567                 error ("args to be formatted is not %<...%>");
2568               *no_add_attrs = true;
2569               return NULL_TREE;
2570             }
2571         }
2572     }
2573
2574   if (info.format_type == strftime_format_type && info.first_arg_num != 0)
2575     {
2576       error ("strftime formats cannot format arguments");
2577       *no_add_attrs = true;
2578       return NULL_TREE;
2579     }
2580
2581   /* If this is a custom GCC-internal format type, we have to
2582      initialize certain bits a runtime.  */
2583   if (info.format_type == asm_fprintf_format_type
2584       || info.format_type == gcc_diag_format_type
2585       || info.format_type == gcc_cdiag_format_type
2586       || info.format_type == gcc_cxxdiag_format_type)
2587     {
2588       /* Our first time through, we have to make sure that our
2589          format_type data is allocated dynamically and is modifiable.  */
2590       if (!dynamic_format_types)
2591         format_types = dynamic_format_types = (format_kind_info *)
2592           xmemdup (format_types_orig, sizeof (format_types_orig),
2593                    sizeof (format_types_orig));
2594
2595       /* If this is format __asm_fprintf__, we have to initialize
2596          GCC's notion of HOST_WIDE_INT for checking %wd.  */
2597       if (info.format_type == asm_fprintf_format_type)
2598         init_dynamic_asm_fprintf_info ();
2599       /* If this is one of the diagnostic attributes, then we have to
2600          initialize 'location_t' and 'tree' at runtime.  */
2601       else if (info.format_type == gcc_diag_format_type
2602                || info.format_type == gcc_cdiag_format_type
2603                || info.format_type == gcc_cxxdiag_format_type)
2604         init_dynamic_diag_info ();
2605       else
2606         gcc_unreachable ();
2607     }
2608
2609   return NULL_TREE;
2610 }