contrib/gcc-8.0/gcc/c-family/c-format.c

   1 /* Check calls to formatted I/O functions (-Wformat).
   2    Copyright (C) 1992-2018 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #include "config.h"
  21 #include "system.h"
  22 #include "coretypes.h"
  23 #include "tm.h"
  24 #include "c-target.h"
  25 #include "c-common.h"
  26 #include "alloc-pool.h"
  27 #include "stringpool.h"
  28 #include "c-objc.h"
  29 #include "intl.h"
  30 #include "langhooks.h"
  31 #include "c-format.h"
  32 #include "diagnostic.h"
  33 #include "substring-locations.h"
  34 #include "selftest.h"
  35 #include "builtins.h"
  36 #include "attribs.h"
  37
  38 /* Handle attributes associated with format checking.  */
  39
  40 /* This must be in the same order as format_types, except for
  41    format_type_error.  Target-specific format types do not have
  42    matching enum values.  */
  43 enum format_type { printf_format_type, asm_fprintf_format_type,
  44                    gcc_diag_format_type, gcc_tdiag_format_type,
  45                    gcc_cdiag_format_type,
  46                    gcc_cxxdiag_format_type, gcc_gfc_format_type,
  47                    gcc_objc_string_format_type,
  48                    format_type_error = -1};
  49
  50 struct function_format_info
  51 {
  52   int format_type;                      /* type of format (printf, scanf, etc.) */
  53   unsigned HOST_WIDE_INT format_num;    /* number of format argument */
  54   unsigned HOST_WIDE_INT first_arg_num; /* number of first arg (zero for varargs) */
  55 };
  56
  57 /* Initialized in init_dynamic_diag_info.  */
  58 static GTY(()) tree local_tree_type_node;
  59 static GTY(()) tree local_gcall_ptr_node;
  60 static GTY(()) tree locus;
  61
  62 static bool decode_format_attr (tree, function_format_info *, int);
  63 static int decode_format_type (const char *);
  64
  65 static bool check_format_string (tree argument,
  66                                  unsigned HOST_WIDE_INT format_num,
  67                                  int flags, bool *no_add_attrs,
  68                                  int expected_format_type);
  69 static bool get_constant (tree expr, unsigned HOST_WIDE_INT *value,
  70                           int validated_p);
  71 static const char *convert_format_name_to_system_name (const char *attr_name);
  72
  73 static int first_target_format_type;
  74 static const char *format_name (int format_num);
  75 static int format_flags (int format_num);
  76
  77 /* Emit a warning as per format_warning_va, but construct the substring_loc
  78    for the character at offset (CHAR_IDX - 1) within a string constant
  79    FORMAT_STRING_CST at FMT_STRING_LOC.  */
  80
  81 ATTRIBUTE_GCC_DIAG (5,6)
  82 static bool
  83 format_warning_at_char (location_t fmt_string_loc, tree format_string_cst,
  84                         int char_idx, int opt, const char *gmsgid, ...)
  85 {
  86   va_list ap;
  87   va_start (ap, gmsgid);
  88   tree string_type = TREE_TYPE (format_string_cst);
  89
  90   /* The callers are of the form:
  91        format_warning (format_string_loc, format_string_cst,
  92                        format_chars - orig_format_chars,
  93       where format_chars has already been incremented, so that
  94       CHAR_IDX is one character beyond where the warning should
  95       be emitted.  Fix it.  */
  96   char_idx -= 1;
  97
  98   substring_loc fmt_loc (fmt_string_loc, string_type, char_idx, char_idx,
  99                          char_idx);
 100   bool warned = format_warning_va (fmt_loc, UNKNOWN_LOCATION, NULL, opt,
 101                                    gmsgid, &ap);
 102   va_end (ap);
 103
 104   return warned;
 105 }
 106
 107 /* Check that we have a pointer to a string suitable for use as a format.
 108    The default is to check for a char type.
 109    For objective-c dialects, this is extended to include references to string
 110    objects validated by objc_string_ref_type_p ().
 111    Targets may also provide a string object type that can be used within c and
 112    c++ and shared with their respective objective-c dialects. In this case the
 113    reference to a format string is checked for validity via a hook.
 114
 115    The function returns true if strref points to any string type valid for the
 116    language dialect and target.  */
 117
 118 static bool
 119 valid_stringptr_type_p (tree strref)
 120 {
 121   return (strref != NULL
 122           && TREE_CODE (strref) == POINTER_TYPE
 123           && (TYPE_MAIN_VARIANT (TREE_TYPE (strref)) == char_type_node
 124               || objc_string_ref_type_p (strref)
 125               || (*targetcm.string_object_ref_type_p) ((const_tree) strref)));
 126 }
 127
 128 /* Handle a "format_arg" attribute; arguments as in
 129    struct attribute_spec.handler.  */
 130 tree
 131 handle_format_arg_attribute (tree *node, tree ARG_UNUSED (name),
 132                              tree args, int flags, bool *no_add_attrs)
 133 {
 134   tree type = *node;
 135   tree format_num_expr = TREE_VALUE (args);
 136   unsigned HOST_WIDE_INT format_num = 0;
 137
 138   if (!get_constant (format_num_expr, &format_num, 0))
 139     {
 140       error ("format string has invalid operand number");
 141       *no_add_attrs = true;
 142       return NULL_TREE;
 143     }
 144
 145   if (prototype_p (type))
 146     {
 147       /* The format arg can be any string reference valid for the language and
 148         target.  We cannot be more specific in this case.  */
 149       if (!check_format_string (type, format_num, flags, no_add_attrs, -1))
 150         return NULL_TREE;
 151     }
 152
 153   if (!valid_stringptr_type_p (TREE_TYPE (type)))
 154     {
 155       if (!(flags & (int) ATTR_FLAG_BUILT_IN))
 156         error ("function does not return string type");
 157       *no_add_attrs = true;
 158       return NULL_TREE;
 159     }
 160
 161   return NULL_TREE;
 162 }
 163
 164 /* Verify that the format_num argument is actually a string reference suitable,
 165    for the language dialect and target (in case the format attribute is in
 166    error).  When we know the specific reference type expected, this is also
 167    checked.  */
 168 static bool
 169 check_format_string (tree fntype, unsigned HOST_WIDE_INT format_num,
 170                      int flags, bool *no_add_attrs, int expected_format_type)
 171 {
 172   unsigned HOST_WIDE_INT i;
 173   bool is_objc_sref, is_target_sref, is_char_ref;
 174   tree ref;
 175   int fmt_flags;
 176   function_args_iterator iter;
 177
 178   i = 1;
 179   FOREACH_FUNCTION_ARGS (fntype, ref, iter)
 180     {
 181       if (i == format_num)
 182         break;
 183       i++;
 184     }
 185
 186   if (!ref
 187       || !valid_stringptr_type_p (ref))
 188     {
 189       if (!(flags & (int) ATTR_FLAG_BUILT_IN))
 190         error ("format string argument is not a string type");
 191       *no_add_attrs = true;
 192       return false;
 193     }
 194
 195   /* We only know that we want a suitable string reference.  */
 196   if (expected_format_type < 0)
 197     return true;
 198
 199   /* Now check that the arg matches the expected type.  */
 200   is_char_ref =
 201     (TYPE_MAIN_VARIANT (TREE_TYPE (ref)) == char_type_node);
 202
 203   fmt_flags = format_flags (expected_format_type);
 204   is_objc_sref = is_target_sref = false;
 205   if (!is_char_ref)
 206     is_objc_sref = objc_string_ref_type_p (ref);
 207
 208   if (!(fmt_flags & FMT_FLAG_PARSE_ARG_CONVERT_EXTERNAL))
 209     {
 210       if (is_char_ref)
 211         return true; /* OK, we expected a char and found one.  */
 212       else
 213         {
 214           /* We expected a char but found an extended string type.  */
 215           if (is_objc_sref)
 216             error ("found a %qs reference but the format argument should"
 217                    " be a string", format_name (gcc_objc_string_format_type));
 218           else
 219             error ("found a %qT but the format argument should be a string",
 220                    ref);
 221           *no_add_attrs = true;
 222           return false;
 223         }
 224     }
 225
 226   /* We expect a string object type as the format arg.  */
 227   if (is_char_ref)
 228     {
 229       error ("format argument should be a %qs reference but"
 230              " a string was found", format_name (expected_format_type));
 231       *no_add_attrs = true;
 232       return false;
 233     }
 234
 235   /* We will assert that objective-c will support either its own string type
 236      or the target-supplied variant.  */
 237   if (!is_objc_sref)
 238     is_target_sref = (*targetcm.string_object_ref_type_p) ((const_tree) ref);
 239
 240   if (expected_format_type == (int) gcc_objc_string_format_type
 241       && (is_objc_sref || is_target_sref))
 242     return true;
 243
 244   /* We will allow a target string ref to match only itself.  */
 245   if (first_target_format_type
 246       && expected_format_type >= first_target_format_type
 247       && is_target_sref)
 248     return true;
 249   else
 250     {
 251       error ("format argument should be a %qs reference",
 252               format_name (expected_format_type));
 253       *no_add_attrs = true;
 254       return false;
 255     }
 256
 257   gcc_unreachable ();
 258 }
 259
 260 /* Verify EXPR is a constant, and store its value.
 261    If validated_p is true there should be no errors.
 262    Returns true on success, false otherwise.  */
 263 static bool
 264 get_constant (tree expr, unsigned HOST_WIDE_INT *value, int validated_p)
 265 {
 266   if (!tree_fits_uhwi_p (expr))
 267     {
 268       gcc_assert (!validated_p);
 269       return false;
 270     }
 271
 272   *value = TREE_INT_CST_LOW (expr);
 273
 274   return true;
 275 }
 276
 277 /* Decode the arguments to a "format" attribute into a
 278    function_format_info structure.  It is already known that the list
 279    is of the right length.  If VALIDATED_P is true, then these
 280    attributes have already been validated and must not be erroneous;
 281    if false, it will give an error message.  Returns true if the
 282    attributes are successfully decoded, false otherwise.  */
 283
 284 static bool
 285 decode_format_attr (tree args, function_format_info *info, int validated_p)
 286 {
 287   tree format_type_id = TREE_VALUE (args);
 288   tree format_num_expr = TREE_VALUE (TREE_CHAIN (args));
 289   tree first_arg_num_expr
 290     = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args)));
 291
 292   if (TREE_CODE (format_type_id) != IDENTIFIER_NODE)
 293     {
 294       gcc_assert (!validated_p);
 295       error ("unrecognized format specifier");
 296       return false;
 297     }
 298   else
 299     {
 300       const char *p = IDENTIFIER_POINTER (format_type_id);
 301
 302       p = convert_format_name_to_system_name (p);
 303
 304       info->format_type = decode_format_type (p);
 305
 306       if (!c_dialect_objc ()
 307            && info->format_type == gcc_objc_string_format_type)
 308         {
 309           gcc_assert (!validated_p);
 310           warning (OPT_Wformat_, "%qE is only allowed in Objective-C dialects",
 311                    format_type_id);
 312           info->format_type = format_type_error;
 313           return false;
 314         }
 315
 316       if (info->format_type == format_type_error)
 317         {
 318           gcc_assert (!validated_p);
 319           warning (OPT_Wformat_, "%qE is an unrecognized format function type",
 320                    format_type_id);
 321           return false;
 322         }
 323     }
 324
 325   if (!get_constant (format_num_expr, &info->format_num, validated_p))
 326     {
 327       error ("format string has invalid operand number");
 328       return false;
 329     }
 330
 331   if (!get_constant (first_arg_num_expr, &info->first_arg_num, validated_p))
 332     {
 333       error ("%<...%> has invalid operand number");
 334       return false;
 335     }
 336
 337   if (info->first_arg_num != 0 && info->first_arg_num <= info->format_num)
 338     {
 339       gcc_assert (!validated_p);
 340       error ("format string argument follows the args to be formatted");
 341       return false;
 342     }
 343
 344   return true;
 345 }
 346 \f
 347 /* Check a call to a format function against a parameter list.  */
 348
 349 /* The C standard version C++ is treated as equivalent to
 350    or inheriting from, for the purpose of format features supported.  */
 351 #define CPLUSPLUS_STD_VER       (cxx_dialect < cxx11 ? STD_C94 : STD_C99)
 352 /* The C standard version we are checking formats against when pedantic.  */
 353 #define C_STD_VER               ((int) (c_dialect_cxx ()                   \
 354                                  ? CPLUSPLUS_STD_VER                       \
 355                                  : (flag_isoc99                            \
 356                                     ? STD_C99                              \
 357                                     : (flag_isoc94 ? STD_C94 : STD_C89))))
 358 /* The name to give to the standard version we are warning about when
 359    pedantic.  FEATURE_VER is the version in which the feature warned out
 360    appeared, which is higher than C_STD_VER.  */
 361 #define C_STD_NAME(FEATURE_VER) (c_dialect_cxx ()               \
 362                                  ? (cxx_dialect < cxx11 ? "ISO C++98" \
 363                                     : "ISO C++11")              \
 364                                  : ((FEATURE_VER) == STD_EXT    \
 365                                     ? "ISO C"                   \
 366                                     : "ISO C90"))
 367 /* Adjust a C standard version, which may be STD_C9L, to account for
 368    -Wno-long-long.  Returns other standard versions unchanged.  */
 369 #define ADJ_STD(VER)            ((int) ((VER) == STD_C9L                      \
 370                                        ? (warn_long_long ? STD_C99 : STD_C89) \
 371                                        : (VER)))
 372
 373 /* Enum describing the kind of specifiers present in the format and
 374    requiring an argument.  */
 375 enum format_specifier_kind {
 376   CF_KIND_FORMAT,
 377   CF_KIND_FIELD_WIDTH,
 378   CF_KIND_FIELD_PRECISION
 379 };
 380
 381 static const char *kind_descriptions[] = {
 382   N_("format"),
 383   N_("field width specifier"),
 384   N_("field precision specifier")
 385 };
 386
 387 /* Structure describing details of a type expected in format checking,
 388    and the type to check against it.  */
 389 struct format_wanted_type
 390 {
 391   /* The type wanted.  */
 392   tree wanted_type;
 393   /* The name of this type to use in diagnostics.  */
 394   const char *wanted_type_name;
 395   /* Should be type checked just for scalar width identity.  */
 396   int scalar_identity_flag;
 397   /* The level of indirection through pointers at which this type occurs.  */
 398   int pointer_count;
 399   /* Whether, when pointer_count is 1, to allow any character type when
 400      pedantic, rather than just the character or void type specified.  */
 401   int char_lenient_flag;
 402   /* Whether the argument, dereferenced once, is written into and so the
 403      argument must not be a pointer to a const-qualified type.  */
 404   int writing_in_flag;
 405   /* Whether the argument, dereferenced once, is read from and so
 406      must not be a NULL pointer.  */
 407   int reading_from_flag;
 408   /* The kind of specifier that this type is used for.  */
 409   enum format_specifier_kind kind;
 410   /* The starting character of the specifier.  This never includes the
 411      initial percent sign.  */
 412   const char *format_start;
 413   /* The length of the specifier.  */
 414   int format_length;
 415   /* The actual parameter to check against the wanted type.  */
 416   tree param;
 417   /* The argument number of that parameter.  */
 418   int arg_num;
 419   /* The offset location of this argument with respect to the format
 420      string location.  */
 421   unsigned int offset_loc;
 422   /* The next type to check for this format conversion, or NULL if none.  */
 423   struct format_wanted_type *next;
 424 };
 425
 426 /* Convenience macro for format_length_info meaning unused.  */
 427 #define NO_FMT NULL, FMT_LEN_none, STD_C89
 428
 429 static const format_length_info printf_length_specs[] =
 430 {
 431   { "h", FMT_LEN_h, STD_C89, "hh", FMT_LEN_hh, STD_C99, 0 },
 432   { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C9L, 0 },
 433   { "q", FMT_LEN_ll, STD_EXT, NO_FMT, 0 },
 434   { "L", FMT_LEN_L, STD_C89, NO_FMT, 0 },
 435   { "z", FMT_LEN_z, STD_C99, NO_FMT, 0 },
 436   { "Z", FMT_LEN_z, STD_EXT, NO_FMT, 0 },
 437   { "t", FMT_LEN_t, STD_C99, NO_FMT, 0 },
 438   { "j", FMT_LEN_j, STD_C99, NO_FMT, 0 },
 439   { "H", FMT_LEN_H, STD_EXT, NO_FMT, 0 },
 440   { "D", FMT_LEN_D, STD_EXT, "DD", FMT_LEN_DD, STD_EXT, 0 },
 441   { NO_FMT, NO_FMT, 0 }
 442 };
 443
 444 /* Length specifiers valid for asm_fprintf.  */
 445 static const format_length_info asm_fprintf_length_specs[] =
 446 {
 447   { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C89, 0 },
 448   { "w", FMT_LEN_none, STD_C89, NO_FMT, 0 },
 449   { NO_FMT, NO_FMT, 0 }
 450 };
 451
 452 /* Length specifiers valid for GCC diagnostics.  */
 453 static const format_length_info gcc_diag_length_specs[] =
 454 {
 455   { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C89, 0 },
 456   { "w", FMT_LEN_none, STD_C89, NO_FMT, 0 },
 457   { NO_FMT, NO_FMT, 0 }
 458 };
 459
 460 /* The custom diagnostics all accept the same length specifiers.  */
 461 #define gcc_tdiag_length_specs gcc_diag_length_specs
 462 #define gcc_cdiag_length_specs gcc_diag_length_specs
 463 #define gcc_cxxdiag_length_specs gcc_diag_length_specs
 464
 465 /* This differs from printf_length_specs only in that "Z" is not accepted.  */
 466 static const format_length_info scanf_length_specs[] =
 467 {
 468   { "h", FMT_LEN_h, STD_C89, "hh", FMT_LEN_hh, STD_C99, 0 },
 469   { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C9L, 0 },
 470   { "q", FMT_LEN_ll, STD_EXT, NO_FMT, 0 },
 471   { "L", FMT_LEN_L, STD_C89, NO_FMT, 0 },
 472   { "z", FMT_LEN_z, STD_C99, NO_FMT, 0 },
 473   { "t", FMT_LEN_t, STD_C99, NO_FMT, 0 },
 474   { "j", FMT_LEN_j, STD_C99, NO_FMT, 0 },
 475   { "H", FMT_LEN_H, STD_EXT, NO_FMT, 0 },
 476   { "D", FMT_LEN_D, STD_EXT, "DD", FMT_LEN_DD, STD_EXT, 0 },
 477   { NO_FMT, NO_FMT, 0 }
 478 };
 479
 480
 481 /* All tables for strfmon use STD_C89 everywhere, since -pedantic warnings
 482    make no sense for a format type not part of any C standard version.  */
 483 static const format_length_info strfmon_length_specs[] =
 484 {
 485   /* A GNU extension.  */
 486   { "L", FMT_LEN_L, STD_C89, NO_FMT, 0 },
 487   { NO_FMT, NO_FMT, 0 }
 488 };
 489
 490
 491 /* For now, the Fortran front-end routines only use l as length modifier.  */
 492 static const format_length_info gcc_gfc_length_specs[] =
 493 {
 494   { "l", FMT_LEN_l, STD_C89, NO_FMT, 0 },
 495   { NO_FMT, NO_FMT, 0 }
 496 };
 497
 498
 499 static const format_flag_spec printf_flag_specs[] =
 500 {
 501   { ' ',  0, 0, 0, N_("' ' flag"),        N_("the ' ' printf flag"),              STD_C89 },
 502   { '+',  0, 0, 0, N_("'+' flag"),        N_("the '+' printf flag"),              STD_C89 },
 503   { '#',  0, 0, 0, N_("'#' flag"),        N_("the '#' printf flag"),              STD_C89 },
 504   { '0',  0, 0, 0, N_("'0' flag"),        N_("the '0' printf flag"),              STD_C89 },
 505   { '-',  0, 0, 0, N_("'-' flag"),        N_("the '-' printf flag"),              STD_C89 },
 506   { '\'', 0, 0, 0, N_("''' flag"),        N_("the ''' printf flag"),              STD_EXT },
 507   { 'I',  0, 0, 0, N_("'I' flag"),        N_("the 'I' printf flag"),              STD_EXT },
 508   { 'w',  0, 0, 0, N_("field width"),     N_("field width in printf format"),     STD_C89 },
 509   { 'p',  0, 0, 0, N_("precision"),       N_("precision in printf format"),       STD_C89 },
 510   { 'L',  0, 0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
 511   { 0, 0, 0, 0, NULL, NULL, STD_C89 }
 512 };
 513
 514
 515 static const format_flag_pair printf_flag_pairs[] =
 516 {
 517   { ' ', '+', 1, 0   },
 518   { '0', '-', 1, 0   },
 519   { '0', 'p', 1, 'i' },
 520   { 0, 0, 0, 0 }
 521 };
 522
 523 static const format_flag_spec asm_fprintf_flag_specs[] =
 524 {
 525   { ' ',  0, 0, 0, N_("' ' flag"),        N_("the ' ' printf flag"),              STD_C89 },
 526   { '+',  0, 0, 0, N_("'+' flag"),        N_("the '+' printf flag"),              STD_C89 },
 527   { '#',  0, 0, 0, N_("'#' flag"),        N_("the '#' printf flag"),              STD_C89 },
 528   { '0',  0, 0, 0, N_("'0' flag"),        N_("the '0' printf flag"),              STD_C89 },
 529   { '-',  0, 0, 0, N_("'-' flag"),        N_("the '-' printf flag"),              STD_C89 },
 530   { 'w',  0, 0, 0, N_("field width"),     N_("field width in printf format"),     STD_C89 },
 531   { 'p',  0, 0, 0, N_("precision"),       N_("precision in printf format"),       STD_C89 },
 532   { 'L',  0, 0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
 533   { 0, 0, 0, 0, NULL, NULL, STD_C89 }
 534 };
 535
 536 static const format_flag_pair asm_fprintf_flag_pairs[] =
 537 {
 538   { ' ', '+', 1, 0   },
 539   { '0', '-', 1, 0   },
 540   { '0', 'p', 1, 'i' },
 541   { 0, 0, 0, 0 }
 542 };
 543
 544 static const format_flag_pair gcc_diag_flag_pairs[] =
 545 {
 546   { 0, 0, 0, 0 }
 547 };
 548
 549 #define gcc_tdiag_flag_pairs gcc_diag_flag_pairs
 550 #define gcc_cdiag_flag_pairs gcc_diag_flag_pairs
 551 #define gcc_cxxdiag_flag_pairs gcc_diag_flag_pairs
 552 #define gcc_gfc_flag_pairs gcc_diag_flag_pairs
 553
 554 static const format_flag_spec gcc_diag_flag_specs[] =
 555 {
 556   { '+',  0, 0, 0, N_("'+' flag"),        N_("the '+' printf flag"),              STD_C89 },
 557   { '#',  0, 0, 0, N_("'#' flag"),        N_("the '#' printf flag"),              STD_C89 },
 558   { 'q',  0, 0, 1, N_("'q' flag"),        N_("the 'q' diagnostic flag"),          STD_C89 },
 559   { 'p',  0, 0, 0, N_("precision"),       N_("precision in printf format"),       STD_C89 },
 560   { 'L',  0, 0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
 561   { 0, 0, 0, 0, NULL, NULL, STD_C89 }
 562 };
 563
 564 #define gcc_tdiag_flag_specs gcc_diag_flag_specs
 565 #define gcc_cdiag_flag_specs gcc_diag_flag_specs
 566 #define gcc_cxxdiag_flag_specs gcc_diag_flag_specs
 567 #define gcc_gfc_flag_specs gcc_diag_flag_specs
 568
 569 static const format_flag_spec scanf_flag_specs[] =
 570 {
 571   { '*',  0, 0, 0, N_("assignment suppression"), N_("the assignment suppression scanf feature"), STD_C89 },
 572   { 'a',  0, 0, 0, N_("'a' flag"),               N_("the 'a' scanf flag"),                       STD_EXT },
 573   { 'm',  0, 0, 0, N_("'m' flag"),               N_("the 'm' scanf flag"),                       STD_EXT },
 574   { 'w',  0, 0, 0, N_("field width"),            N_("field width in scanf format"),              STD_C89 },
 575   { 'L',  0, 0, 0, N_("length modifier"),        N_("length modifier in scanf format"),          STD_C89 },
 576   { '\'', 0, 0, 0, N_("''' flag"),               N_("the ''' scanf flag"),                       STD_EXT },
 577   { 'I',  0, 0, 0, N_("'I' flag"),               N_("the 'I' scanf flag"),                       STD_EXT },
 578   { 0, 0, 0, 0, NULL, NULL, STD_C89 }
 579 };
 580
 581
 582 static const format_flag_pair scanf_flag_pairs[] =
 583 {
 584   { '*', 'L', 0, 0 },
 585   { 'a', 'm', 0, 0 },
 586   { 0, 0, 0, 0 }
 587 };
 588
 589
 590 static const format_flag_spec strftime_flag_specs[] =
 591 {
 592   { '_', 0,   0, 0, N_("'_' flag"),     N_("the '_' strftime flag"),          STD_EXT },
 593   { '-', 0,   0, 0, N_("'-' flag"),     N_("the '-' strftime flag"),          STD_EXT },
 594   { '0', 0,   0, 0, N_("'0' flag"),     N_("the '0' strftime flag"),          STD_EXT },
 595   { '^', 0,   0, 0, N_("'^' flag"),     N_("the '^' strftime flag"),          STD_EXT },
 596   { '#', 0,   0, 0, N_("'#' flag"),     N_("the '#' strftime flag"),          STD_EXT },
 597   { 'w', 0,   0, 0, N_("field width"),  N_("field width in strftime format"), STD_EXT },
 598   { 'E', 0,   0, 0, N_("'E' modifier"), N_("the 'E' strftime modifier"),      STD_C99 },
 599   { 'O', 0,   0, 0, N_("'O' modifier"), N_("the 'O' strftime modifier"),      STD_C99 },
 600   { 'O', 'o', 0, 0, NULL,               N_("the 'O' modifier"),               STD_EXT },
 601   { 0, 0, 0, 0, NULL, NULL, STD_C89 }
 602 };
 603
 604
 605 static const format_flag_pair strftime_flag_pairs[] =
 606 {
 607   { 'E', 'O', 0, 0 },
 608   { '_', '-', 0, 0 },
 609   { '_', '0', 0, 0 },
 610   { '-', '0', 0, 0 },
 611   { '^', '#', 0, 0 },
 612   { 0, 0, 0, 0 }
 613 };
 614
 615
 616 static const format_flag_spec strfmon_flag_specs[] =
 617 {
 618   { '=',  0, 1, 0, N_("fill character"),  N_("fill character in strfmon format"),  STD_C89 },
 619   { '^',  0, 0, 0, N_("'^' flag"),        N_("the '^' strfmon flag"),              STD_C89 },
 620   { '+',  0, 0, 0, N_("'+' flag"),        N_("the '+' strfmon flag"),              STD_C89 },
 621   { '(',  0, 0, 0, N_("'(' flag"),        N_("the '(' strfmon flag"),              STD_C89 },
 622   { '!',  0, 0, 0, N_("'!' flag"),        N_("the '!' strfmon flag"),              STD_C89 },
 623   { '-',  0, 0, 0, N_("'-' flag"),        N_("the '-' strfmon flag"),              STD_C89 },
 624   { 'w',  0, 0, 0, N_("field width"),     N_("field width in strfmon format"),     STD_C89 },
 625   { '#',  0, 0, 0, N_("left precision"),  N_("left precision in strfmon format"),  STD_C89 },
 626   { 'p',  0, 0, 0, N_("right precision"), N_("right precision in strfmon format"), STD_C89 },
 627   { 'L',  0, 0, 0, N_("length modifier"), N_("length modifier in strfmon format"), STD_C89 },
 628   { 0, 0, 0, 0, NULL, NULL, STD_C89 }
 629 };
 630
 631 static const format_flag_pair strfmon_flag_pairs[] =
 632 {
 633   { '+', '(', 0, 0 },
 634   { 0, 0, 0, 0 }
 635 };
 636
 637
 638 static const format_char_info print_char_table[] =
 639 {
 640   /* C89 conversion specifiers.  */
 641   { "di",  0, STD_C89, { T89_I,   T99_SC,  T89_S,   T89_L,   T9L_LL,  TEX_LL,  T99_SST, T99_PD,  T99_IM,  BADLEN,  BADLEN,  BADLEN  }, "-wp0 +'I",  "i",  NULL },
 642   { "oxX", 0, STD_C89, { T89_UI,  T99_UC,  T89_US,  T89_UL,  T9L_ULL, TEX_ULL, T99_ST,  T99_UPD, T99_UIM, BADLEN,  BADLEN,  BADLEN }, "-wp0#",     "i",  NULL },
 643   { "u",   0, STD_C89, { T89_UI,  T99_UC,  T89_US,  T89_UL,  T9L_ULL, TEX_ULL, T99_ST,  T99_UPD, T99_UIM, BADLEN,  BADLEN,  BADLEN }, "-wp0'I",    "i",  NULL },
 644   { "fgG", 0, STD_C89, { T89_D,   BADLEN,  BADLEN,  T99_D,   BADLEN,  T89_LD,  BADLEN,  BADLEN,  BADLEN,  TEX_D32, TEX_D64, TEX_D128 }, "-wp0 +#'I", "",   NULL },
 645   { "eE",  0, STD_C89, { T89_D,   BADLEN,  BADLEN,  T99_D,   BADLEN,  T89_LD,  BADLEN,  BADLEN,  BADLEN,  TEX_D32, TEX_D64, TEX_D128 }, "-wp0 +#I",  "",   NULL },
 646   { "c",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  T94_WI,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "-w",        "",   NULL },
 647   { "s",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  T94_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "-wp",       "cR", NULL },
 648   { "p",   1, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "-w",        "c",  NULL },
 649   { "n",   1, STD_C89, { T89_I,   T99_SC,  T89_S,   T89_L,   T9L_LL,  BADLEN,  T99_SST, T99_PD,  T99_IM,  BADLEN,  BADLEN,  BADLEN }, "",          "W",  NULL },
 650   /* C99 conversion specifiers.  */
 651   { "F",   0, STD_C99, { T99_D,   BADLEN,  BADLEN,  T99_D,   BADLEN,  T99_LD,  BADLEN,  BADLEN,  BADLEN,  TEX_D32, TEX_D64, TEX_D128 }, "-wp0 +#'I", "",   NULL },
 652   { "aA",  0, STD_C99, { T99_D,   BADLEN,  BADLEN,  T99_D,   BADLEN,  T99_LD,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "-wp0 +#",   "",   NULL },
 653   /* X/Open conversion specifiers.  */
 654   { "C",   0, STD_EXT, { TEX_WI,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "-w",        "",   NULL },
 655   { "S",   1, STD_EXT, { TEX_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "-wp",       "R",  NULL },
 656   /* GNU conversion specifiers.  */
 657   { "m",   0, STD_EXT, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "-wp",       "",   NULL },
 658   { NULL,  0, STD_C89, NOLENGTHS, NULL, NULL, NULL }
 659 };
 660
 661 static const format_char_info asm_fprintf_char_table[] =
 662 {
 663   /* C89 conversion specifiers.  */
 664   { "di",  0, STD_C89, { T89_I,   BADLEN,  BADLEN,  T89_L,   T9L_LL,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-wp0 +",  "i", NULL },
 665   { "oxX", 0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-wp0#",   "i", NULL },
 666   { "u",   0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-wp0",    "i", NULL },
 667   { "c",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-w",       "", NULL },
 668   { "s",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-wp",    "cR", NULL },
 669
 670   /* asm_fprintf conversion specifiers.  */
 671   { "O",   0, STD_C89, NOARGUMENTS, "",      "",   NULL },
 672   { "R",   0, STD_C89, NOARGUMENTS, "",      "",   NULL },
 673   { "I",   0, STD_C89, NOARGUMENTS, "",      "",   NULL },
 674   { "L",   0, STD_C89, NOARGUMENTS, "",      "",   NULL },
 675   { "U",   0, STD_C89, NOARGUMENTS, "",      "",   NULL },
 676   { "r",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "",  "", NULL },
 677   { "z",   0, STD_C89, NOARGUMENTS, "",      "",   NULL },
 678   { "@",   0, STD_C89, NOARGUMENTS, "",      "",   NULL },
 679   { NULL,  0, STD_C89, NOLENGTHS, NULL, NULL, NULL }
 680 };
 681
 682 static const format_char_info gcc_diag_char_table[] =
 683 {
 684   /* C89 conversion specifiers.  */
 685   { "di",  0, STD_C89, { T89_I,   BADLEN,  BADLEN,  T89_L,   T9L_LL,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 686   { "ox",  0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 687   { "u",   0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 688   { "c",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 689   { "s",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "pq", "cR", NULL },
 690   { "p",   1, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "c",  NULL },
 691
 692   /* Custom conversion specifiers.  */
 693
 694   /* G requires a "gcall*" argument at runtime.  */
 695   { "G",   1, STD_C89, { T89_G,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "",    "\"",   NULL },
 696   /* K requires a "tree" argument at runtime.  */
 697   { "K",   1, STD_C89, { T89_T,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "",    "\"",   NULL },
 698
 699   { "r",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "",    "//cR",   NULL },
 700   { "<",   0, STD_C89, NOARGUMENTS, "",      "<",   NULL },
 701   { ">",   0, STD_C89, NOARGUMENTS, "",      ">",   NULL },
 702   { "'" ,  0, STD_C89, NOARGUMENTS, "",      "",    NULL },
 703   { "R",   0, STD_C89, NOARGUMENTS, "",     "\\",   NULL },
 704   { "m",   0, STD_C89, NOARGUMENTS, "q",     "",   NULL },
 705   { NULL,  0, STD_C89, NOLENGTHS, NULL, NULL, NULL }
 706 };
 707
 708 static const format_char_info gcc_tdiag_char_table[] =
 709 {
 710   /* C89 conversion specifiers.  */
 711   { "di",  0, STD_C89, { T89_I,   BADLEN,  BADLEN,  T89_L,   T9L_LL,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 712   { "ox",  0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 713   { "u",   0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 714   { "c",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 715   { "s",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "pq", "cR", NULL },
 716   { "p",   1, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "c",  NULL },
 717
 718   /* Custom conversion specifiers.  */
 719
 720   /* These will require a "tree" at runtime.  */
 721   { "DFTV", 1, STD_C89, { T89_T,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q+", "'",   NULL },
 722   { "E", 1, STD_C89, { T89_T,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q+", "",   NULL },
 723   { "K", 1, STD_C89, { T89_T,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "", "\"",   NULL },
 724
 725   /* G requires a "gcall*" argument at runtime.  */
 726   { "G", 1, STD_C89, { T89_G,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "", "\"",   NULL },
 727
 728   { "v",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q#",  "",   NULL },
 729
 730   { "r",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "",    "/cR",   NULL },
 731   { "<",   0, STD_C89, NOARGUMENTS, "",      "<",   NULL },
 732   { ">",   0, STD_C89, NOARGUMENTS, "",      ">",   NULL },
 733   { "'",   0, STD_C89, NOARGUMENTS, "",      "",    NULL },
 734   { "R",   0, STD_C89, NOARGUMENTS, "",     "\\",   NULL },
 735   { "m",   0, STD_C89, NOARGUMENTS, "q",     "",   NULL },
 736   { "Z",   1, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "",    "", &gcc_tdiag_char_table[0] },
 737   { NULL,  0, STD_C89, NOLENGTHS, NULL, NULL, NULL }
 738 };
 739
 740 static const format_char_info gcc_cdiag_char_table[] =
 741 {
 742   /* C89 conversion specifiers.  */
 743   { "di",  0, STD_C89, { T89_I,   BADLEN,  BADLEN,  T89_L,   T9L_LL,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 744   { "ox",  0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 745   { "u",   0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 746   { "c",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 747   { "s",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "pq", "cR", NULL },
 748   { "p",   1, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "c",  NULL },
 749
 750   /* Custom conversion specifiers.  */
 751
 752   /* These will require a "tree" at runtime.  */
 753   { "DFTV", 1, STD_C89, { T89_T,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q+", "'",   NULL },
 754   { "E",   1, STD_C89, { T89_T,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q+", "",   NULL },
 755   { "K",   1, STD_C89, { T89_T,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "", "\"",   NULL },
 756
 757   /* G requires a "gcall*" argument at runtime.  */
 758   { "G",   1, STD_C89, { T89_G,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "", "\"",   NULL },
 759
 760   { "v",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q#",  "",   NULL },
 761
 762   { "r",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "",    "/cR",   NULL },
 763   { "<",   0, STD_C89, NOARGUMENTS, "",      "<",  NULL },
 764   { ">",   0, STD_C89, NOARGUMENTS, "",      ">",  NULL },
 765   { "'",   0, STD_C89, NOARGUMENTS, "",      "",   NULL },
 766   { "R",   0, STD_C89, NOARGUMENTS, "",     "\\",  NULL },
 767   { "m",   0, STD_C89, NOARGUMENTS, "q",     "",   NULL },
 768   { "Z",   1, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "",    "", &gcc_tdiag_char_table[0] },
 769   { NULL,  0, STD_C89, NOLENGTHS, NULL, NULL, NULL }
 770 };
 771
 772 static const format_char_info gcc_cxxdiag_char_table[] =
 773 {
 774   /* C89 conversion specifiers.  */
 775   { "di",  0, STD_C89, { T89_I,   BADLEN,  BADLEN,  T89_L,   T9L_LL,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 776   { "ox",  0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 777   { "u",   0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 778   { "c",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 779   { "s",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "pq", "cR", NULL },
 780   { "p",   1, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "c",  NULL },
 781
 782   /* Custom conversion specifiers.  */
 783
 784   /* These will require a "tree" at runtime.  */
 785   { "ADFHISTVX",1,STD_C89,{ T89_T,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q+#",   "'",   NULL },
 786   { "E", 1,STD_C89,{ T89_T,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q+#",   "",   NULL },
 787   { "K", 1, STD_C89,{ T89_T,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "",   "\"",   NULL },
 788   { "v", 0,STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q#",  "",   NULL },
 789
 790   /* G requires a "gcall*" argument at runtime.  */
 791   { "G", 1, STD_C89,{ T89_G,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "",   "\"",   NULL },
 792
 793   /* These accept either an 'int' or an 'enum tree_code' (which is handled as an 'int'.)  */
 794   { "CLOPQ",0,STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q",  "",   NULL },
 795
 796   { "r",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "",    "/cR",   NULL },
 797   { "<",   0, STD_C89, NOARGUMENTS, "",      "<",   NULL },
 798   { ">",   0, STD_C89, NOARGUMENTS, "",      ">",   NULL },
 799   { "'",   0, STD_C89, NOARGUMENTS, "",      "",    NULL },
 800   { "R",   0, STD_C89, NOARGUMENTS, "",      "\\",  NULL },
 801   { "m",   0, STD_C89, NOARGUMENTS, "q",     "",   NULL },
 802   { "Z",   1, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "",    "", &gcc_tdiag_char_table[0] },
 803   { NULL,  0, STD_C89, NOLENGTHS, NULL, NULL, NULL }
 804 };
 805
 806 static const format_char_info gcc_gfc_char_table[] =
 807 {
 808   /* C89 conversion specifiers.  */
 809   { "di",  0, STD_C89, { T89_I,   BADLEN,  BADLEN,  T89_L,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q", "", NULL },
 810   { "u",   0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q", "", NULL },
 811   { "c",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q", "", NULL },
 812   { "s",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "q", "cR", NULL },
 813
 814   /* gfc conversion specifiers.  */
 815
 816   { "C",   0, STD_C89, NOARGUMENTS, "",      "",   NULL },
 817
 818   /* This will require a "locus" at runtime.  */
 819   { "L",   0, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "", "R", NULL },
 820
 821   /* These will require nothing.  */
 822   { "<>",0, STD_C89, NOARGUMENTS, "",      "",   NULL },
 823   { NULL,  0, STD_C89, NOLENGTHS, NULL, NULL, NULL }
 824 };
 825
 826 static const format_char_info scan_char_table[] =
 827 {
 828   /* C89 conversion specifiers.  */
 829   { "di",    1, STD_C89, { T89_I,   T99_SC,  T89_S,   T89_L,   T9L_LL,  TEX_LL,  T99_SST, T99_PD,  T99_IM,  BADLEN,  BADLEN,  BADLEN }, "*w'I", "W",   NULL },
 830   { "u",     1, STD_C89, { T89_UI,  T99_UC,  T89_US,  T89_UL,  T9L_ULL, TEX_ULL, T99_ST,  T99_UPD, T99_UIM, BADLEN,  BADLEN,  BADLEN }, "*w'I", "W",   NULL },
 831   { "oxX",   1, STD_C89, { T89_UI,  T99_UC,  T89_US,  T89_UL,  T9L_ULL, TEX_ULL, T99_ST,  T99_UPD, T99_UIM, BADLEN,  BADLEN,  BADLEN }, "*w",   "W",   NULL },
 832   { "efgEG", 1, STD_C89, { T89_F,   BADLEN,  BADLEN,  T89_D,   BADLEN,  T89_LD,  BADLEN,  BADLEN,  BADLEN,  TEX_D32, TEX_D64, TEX_D128 }, "*w'",  "W",   NULL },
 833   { "c",     1, STD_C89, { T89_C,   BADLEN,  BADLEN,  T94_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "*mw",   "cW",  NULL },
 834   { "s",     1, STD_C89, { T89_C,   BADLEN,  BADLEN,  T94_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "*amw",  "cW",  NULL },
 835   { "[",     1, STD_C89, { T89_C,   BADLEN,  BADLEN,  T94_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "*amw",  "cW[", NULL },
 836   { "p",     2, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "*w",   "W",   NULL },
 837   { "n",     1, STD_C89, { T89_I,   T99_SC,  T89_S,   T89_L,   T9L_LL,  BADLEN,  T99_SST, T99_PD,  T99_IM,  BADLEN,  BADLEN,  BADLEN }, "",     "W",   NULL },
 838   /* C99 conversion specifiers.  */
 839   { "F",   1, STD_C99, { T99_F,   BADLEN,  BADLEN,  T99_D,   BADLEN,  T99_LD,  BADLEN,  BADLEN,  BADLEN,  TEX_D32, TEX_D64, TEX_D128 }, "*w'",  "W",   NULL },
 840   { "aA",   1, STD_C99, { T99_F,   BADLEN,  BADLEN,  T99_D,   BADLEN,  T99_LD,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "*w'",  "W",   NULL },
 841   /* X/Open conversion specifiers.  */
 842   { "C",     1, STD_EXT, { TEX_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "*mw",   "W",   NULL },
 843   { "S",     1, STD_EXT, { TEX_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN }, "*amw",  "W",   NULL },
 844   { NULL, 0, STD_C89, NOLENGTHS, NULL, NULL, NULL }
 845 };
 846
 847 static const format_char_info time_char_table[] =
 848 {
 849   /* C89 conversion specifiers.  */
 850   { "ABZab",            0, STD_C89, NOLENGTHS, "^#",     "",   NULL },
 851   { "cx",               0, STD_C89, NOLENGTHS, "E",      "3",  NULL },
 852   { "HIMSUWdmw",        0, STD_C89, NOLENGTHS, "-_0Ow",  "",   NULL },
 853   { "j",                0, STD_C89, NOLENGTHS, "-_0Ow",  "o",  NULL },
 854   { "p",                0, STD_C89, NOLENGTHS, "#",      "",   NULL },
 855   { "X",                0, STD_C89, NOLENGTHS, "E",      "",   NULL },
 856   { "y",                0, STD_C89, NOLENGTHS, "EO-_0w", "4",  NULL },
 857   { "Y",                0, STD_C89, NOLENGTHS, "-_0EOw", "o",  NULL },
 858   { "%",                0, STD_C89, NOLENGTHS, "",       "",   NULL },
 859   /* C99 conversion specifiers.  */
 860   { "C",                0, STD_C99, NOLENGTHS, "-_0EOw", "o",  NULL },
 861   { "D",                0, STD_C99, NOLENGTHS, "",       "2",  NULL },
 862   { "eVu",              0, STD_C99, NOLENGTHS, "-_0Ow",  "",   NULL },
 863   { "FRTnrt",           0, STD_C99, NOLENGTHS, "",       "",   NULL },
 864   { "g",                0, STD_C99, NOLENGTHS, "O-_0w",  "2o", NULL },
 865   { "G",                0, STD_C99, NOLENGTHS, "-_0Ow",  "o",  NULL },
 866   { "h",                0, STD_C99, NOLENGTHS, "^#",     "",   NULL },
 867   { "z",                0, STD_C99, NOLENGTHS, "O",      "o",  NULL },
 868   /* GNU conversion specifiers.  */
 869   { "kls",              0, STD_EXT, NOLENGTHS, "-_0Ow",  "",   NULL },
 870   { "P",                0, STD_EXT, NOLENGTHS, "",       "",   NULL },
 871   { NULL,               0, STD_C89, NOLENGTHS, NULL, NULL, NULL }
 872 };
 873
 874 static const format_char_info monetary_char_table[] =
 875 {
 876   { "in", 0, STD_C89, { T89_D, BADLEN, BADLEN, BADLEN, BADLEN, T89_LD, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "=^+(!-w#p", "", NULL },
 877   { NULL, 0, STD_C89, NOLENGTHS, NULL, NULL, NULL }
 878 };
 879
 880 /* This must be in the same order as enum format_type.  */
 881 static const format_kind_info format_types_orig[] =
 882 {
 883   { "gnu_printf",   printf_length_specs,  print_char_table, " +#0-'I", NULL,
 884     printf_flag_specs, printf_flag_pairs,
 885     FMT_FLAG_ARG_CONVERT|FMT_FLAG_DOLLAR_MULTIPLE|FMT_FLAG_USE_DOLLAR|FMT_FLAG_EMPTY_PREC_OK,
 886     'w', 0, 'p', 0, 'L', 0,
 887     &integer_type_node, &integer_type_node
 888   },
 889   { "asm_fprintf",   asm_fprintf_length_specs,  asm_fprintf_char_table, " +#0-", NULL,
 890     asm_fprintf_flag_specs, asm_fprintf_flag_pairs,
 891     FMT_FLAG_ARG_CONVERT|FMT_FLAG_EMPTY_PREC_OK,
 892     'w', 0, 'p', 0, 'L', 0,
 893     NULL, NULL
 894   },
 895   { "gcc_diag",   gcc_diag_length_specs,  gcc_diag_char_table, "q+#", NULL,
 896     gcc_diag_flag_specs, gcc_diag_flag_pairs,
 897     FMT_FLAG_ARG_CONVERT,
 898     0, 0, 'p', 0, 'L', 0,
 899     NULL, &integer_type_node
 900   },
 901   { "gcc_tdiag",   gcc_tdiag_length_specs,  gcc_tdiag_char_table, "q+#", NULL,
 902     gcc_tdiag_flag_specs, gcc_tdiag_flag_pairs,
 903     FMT_FLAG_ARG_CONVERT,
 904     0, 0, 'p', 0, 'L', 0,
 905     NULL, &integer_type_node
 906   },
 907   { "gcc_cdiag",   gcc_cdiag_length_specs,  gcc_cdiag_char_table, "q+#", NULL,
 908     gcc_cdiag_flag_specs, gcc_cdiag_flag_pairs,
 909     FMT_FLAG_ARG_CONVERT,
 910     0, 0, 'p', 0, 'L', 0,
 911     NULL, &integer_type_node
 912   },
 913   { "gcc_cxxdiag",   gcc_cxxdiag_length_specs,  gcc_cxxdiag_char_table, "q+#", NULL,
 914     gcc_cxxdiag_flag_specs, gcc_cxxdiag_flag_pairs,
 915     FMT_FLAG_ARG_CONVERT,
 916     0, 0, 'p', 0, 'L', 0,
 917     NULL, &integer_type_node
 918   },
 919   { "gcc_gfc", gcc_gfc_length_specs, gcc_gfc_char_table, "q+#", NULL,
 920     gcc_gfc_flag_specs, gcc_gfc_flag_pairs,
 921     FMT_FLAG_ARG_CONVERT,
 922     0, 0, 0, 0, 0, 0,
 923     NULL, NULL
 924   },
 925   { "NSString",   NULL,  NULL, NULL, NULL,
 926     NULL, NULL,
 927     FMT_FLAG_ARG_CONVERT|FMT_FLAG_PARSE_ARG_CONVERT_EXTERNAL, 0, 0, 0, 0, 0, 0,
 928     NULL, NULL
 929   },
 930   { "gnu_scanf",    scanf_length_specs,   scan_char_table,  "*'I", NULL,
 931     scanf_flag_specs, scanf_flag_pairs,
 932     FMT_FLAG_ARG_CONVERT|FMT_FLAG_SCANF_A_KLUDGE|FMT_FLAG_USE_DOLLAR|FMT_FLAG_ZERO_WIDTH_BAD|FMT_FLAG_DOLLAR_GAP_POINTER_OK,
 933     'w', 0, 0, '*', 'L', 'm',
 934     NULL, NULL
 935   },
 936   { "gnu_strftime", NULL,                 time_char_table,  "_-0^#", "EO",
 937     strftime_flag_specs, strftime_flag_pairs,
 938     FMT_FLAG_FANCY_PERCENT_OK, 'w', 0, 0, 0, 0, 0,
 939     NULL, NULL
 940   },
 941   { "gnu_strfmon",  strfmon_length_specs, monetary_char_table, "=^+(!-", NULL,
 942     strfmon_flag_specs, strfmon_flag_pairs,
 943     FMT_FLAG_ARG_CONVERT, 'w', '#', 'p', 0, 'L', 0,
 944     NULL, NULL
 945   }
 946 };
 947
 948 /* This layer of indirection allows GCC to reassign format_types with
 949    new data if necessary, while still allowing the original data to be
 950    const.  */
 951 static const format_kind_info *format_types = format_types_orig;
 952 /* We can modify this one.  We also add target-specific format types
 953    to the end of the array.  */
 954 static format_kind_info *dynamic_format_types;
 955
 956 static int n_format_types = ARRAY_SIZE (format_types_orig);
 957
 958 /* Structure detailing the results of checking a format function call
 959    where the format expression may be a conditional expression with
 960    many leaves resulting from nested conditional expressions.  */
 961 struct format_check_results
 962 {
 963   /* Number of leaves of the format argument that could not be checked
 964      as they were not string literals.  */
 965   int number_non_literal;
 966   /* Number of leaves of the format argument that were null pointers or
 967      string literals, but had extra format arguments.  */
 968   int number_extra_args;
 969   location_t extra_arg_loc;
 970   /* Number of leaves of the format argument that were null pointers or
 971      string literals, but had extra format arguments and used $ operand
 972      numbers.  */
 973   int number_dollar_extra_args;
 974   /* Number of leaves of the format argument that were wide string
 975      literals.  */
 976   int number_wide;
 977   /* Number of leaves of the format argument that were empty strings.  */
 978   int number_empty;
 979   /* Number of leaves of the format argument that were unterminated
 980      strings.  */
 981   int number_unterminated;
 982   /* Number of leaves of the format argument that were not counted above.  */
 983   int number_other;
 984   /* Location of the format string.  */
 985   location_t format_string_loc;
 986 };
 987
 988 struct format_check_context
 989 {
 990   format_check_results *res;
 991   function_format_info *info;
 992   tree params;
 993   vec<location_t> *arglocs;
 994 };
 995
 996 /* Return the format name (as specified in the original table) for the format
 997    type indicated by format_num.  */
 998 static const char *
 999 format_name (int format_num)
1000 {
1001   if (format_num >= 0 && format_num < n_format_types)
1002     return format_types[format_num].name;
1003   gcc_unreachable ();
1004 }
1005
1006 /* Return the format flags (as specified in the original table) for the format
1007    type indicated by format_num.  */
1008 static int
1009 format_flags (int format_num)
1010 {
1011   if (format_num >= 0 && format_num < n_format_types)
1012     return format_types[format_num].flags;
1013   gcc_unreachable ();
1014 }
1015
1016 static void check_format_info (function_format_info *, tree,
1017                                vec<location_t> *);
1018 static void check_format_arg (void *, tree, unsigned HOST_WIDE_INT);
1019 static void check_format_info_main (format_check_results *,
1020                                     function_format_info *, const char *,
1021                                     location_t, tree,
1022                                     int, tree,
1023                                     unsigned HOST_WIDE_INT,
1024                                     object_allocator<format_wanted_type> &,
1025                                     vec<location_t> *);
1026
1027 static void init_dollar_format_checking (int, tree);
1028 static int maybe_read_dollar_number (const char **, int,
1029                                      tree, tree *, const format_kind_info *);
1030 static bool avoid_dollar_number (const char *);
1031 static void finish_dollar_format_checking (format_check_results *, int);
1032
1033 static const format_flag_spec *get_flag_spec (const format_flag_spec *,
1034                                               int, const char *);
1035
1036 static void check_format_types (const substring_loc &fmt_loc,
1037                                 format_wanted_type *,
1038                                 const format_kind_info *fki,
1039                                 int offset_to_type_start,
1040                                 char conversion_char,
1041                                 vec<location_t> *arglocs);
1042 static void format_type_warning (const substring_loc &fmt_loc,
1043                                  location_t param_loc,
1044                                  format_wanted_type *, tree,
1045                                  tree,
1046                                  const format_kind_info *fki,
1047                                  int offset_to_type_start,
1048                                  char conversion_char);
1049
1050 /* Decode a format type from a string, returning the type, or
1051    format_type_error if not valid, in which case the caller should print an
1052    error message.  */
1053 static int
1054 decode_format_type (const char *s)
1055 {
1056   int i;
1057   int slen;
1058
1059   s = convert_format_name_to_system_name (s);
1060   slen = strlen (s);
1061   for (i = 0; i < n_format_types; i++)
1062     {
1063       int alen;
1064       if (!strcmp (s, format_types[i].name))
1065         return i;
1066       alen = strlen (format_types[i].name);
1067       if (slen == alen + 4 && s[0] == '_' && s[1] == '_'
1068           && s[slen - 1] == '_' && s[slen - 2] == '_'
1069           && !strncmp (s + 2, format_types[i].name, alen))
1070         return i;
1071     }
1072   return format_type_error;
1073 }
1074
1075 \f
1076 /* Check the argument list of a call to printf, scanf, etc.
1077    ATTRS are the attributes on the function type.  There are NARGS argument
1078    values in the array ARGARRAY.
1079    Also, if -Wsuggest-attribute=format,
1080    warn for calls to vprintf or vscanf in functions with no such format
1081    attribute themselves.  */
1082
1083 void
1084 check_function_format (tree attrs, int nargs, tree *argarray,
1085                        vec<location_t> *arglocs)
1086 {
1087   tree a;
1088
1089   /* See if this function has any format attributes.  */
1090   for (a = attrs; a; a = TREE_CHAIN (a))
1091     {
1092       if (is_attribute_p ("format", TREE_PURPOSE (a)))
1093         {
1094           /* Yup; check it.  */
1095           function_format_info info;
1096           decode_format_attr (TREE_VALUE (a), &info, /*validated=*/true);
1097           if (warn_format)
1098             {
1099               /* FIXME: Rewrite all the internal functions in this file
1100                  to use the ARGARRAY directly instead of constructing this
1101                  temporary list.  */
1102               tree params = NULL_TREE;
1103               int i;
1104               for (i = nargs - 1; i >= 0; i--)
1105                 params = tree_cons (NULL_TREE, argarray[i], params);
1106               check_format_info (&info, params, arglocs);
1107             }
1108
1109           /* Attempt to detect whether the current function might benefit
1110              from the format attribute if the called function is decorated
1111              with it.  Avoid using calls with string literal formats for
1112              guidance since those are unlikely to be viable candidates.  */
1113           if (warn_suggest_attribute_format
1114               && current_function_decl != NULL_TREE
1115               && info.first_arg_num == 0
1116               && (format_types[info.format_type].flags
1117                   & (int) FMT_FLAG_ARG_CONVERT)
1118               /* c_strlen will fail for a function parameter but succeed
1119                  for a literal or constant array.  */
1120               && !c_strlen (argarray[info.format_num - 1], 1))
1121             {
1122               tree c;
1123               for (c = TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl));
1124                    c;
1125                    c = TREE_CHAIN (c))
1126                 if (is_attribute_p ("format", TREE_PURPOSE (c))
1127                     && (decode_format_type (IDENTIFIER_POINTER
1128                                             (TREE_VALUE (TREE_VALUE (c))))
1129                         == info.format_type))
1130                   break;
1131               if (c == NULL_TREE)
1132                 {
1133                   /* Check if the current function has a parameter to which
1134                      the format attribute could be attached; if not, it
1135                      can't be a candidate for a format attribute, despite
1136                      the vprintf-like or vscanf-like call.  */
1137                   tree args;
1138                   for (args = DECL_ARGUMENTS (current_function_decl);
1139                        args != 0;
1140                        args = DECL_CHAIN (args))
1141                     {
1142                       if (TREE_CODE (TREE_TYPE (args)) == POINTER_TYPE
1143                           && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (args)))
1144                               == char_type_node))
1145                         break;
1146                     }
1147                   if (args != 0)
1148                     warning (OPT_Wsuggest_attribute_format, "function %qD "
1149                              "might be a candidate for %qs format attribute",
1150                              current_function_decl,
1151                              format_types[info.format_type].name);
1152                 }
1153             }
1154         }
1155     }
1156 }
1157
1158
1159 /* Variables used by the checking of $ operand number formats.  */
1160 static char *dollar_arguments_used = NULL;
1161 static char *dollar_arguments_pointer_p = NULL;
1162 static int dollar_arguments_alloc = 0;
1163 static int dollar_arguments_count;
1164 static int dollar_first_arg_num;
1165 static int dollar_max_arg_used;
1166 static int dollar_format_warned;
1167
1168 /* Initialize the checking for a format string that may contain $
1169    parameter number specifications; we will need to keep track of whether
1170    each parameter has been used.  FIRST_ARG_NUM is the number of the first
1171    argument that is a parameter to the format, or 0 for a vprintf-style
1172    function; PARAMS is the list of arguments starting at this argument.  */
1173
1174 static void
1175 init_dollar_format_checking (int first_arg_num, tree params)
1176 {
1177   tree oparams = params;
1178
1179   dollar_first_arg_num = first_arg_num;
1180   dollar_arguments_count = 0;
1181   dollar_max_arg_used = 0;
1182   dollar_format_warned = 0;
1183   if (first_arg_num > 0)
1184     {
1185       while (params)
1186         {
1187           dollar_arguments_count++;
1188           params = TREE_CHAIN (params);
1189         }
1190     }
1191   if (dollar_arguments_alloc < dollar_arguments_count)
1192     {
1193       free (dollar_arguments_used);
1194       free (dollar_arguments_pointer_p);
1195       dollar_arguments_alloc = dollar_arguments_count;
1196       dollar_arguments_used = XNEWVEC (char, dollar_arguments_alloc);
1197       dollar_arguments_pointer_p = XNEWVEC (char, dollar_arguments_alloc);
1198     }
1199   if (dollar_arguments_alloc)
1200     {
1201       memset (dollar_arguments_used, 0, dollar_arguments_alloc);
1202       if (first_arg_num > 0)
1203         {
1204           int i = 0;
1205           params = oparams;
1206           while (params)
1207             {
1208               dollar_arguments_pointer_p[i] = (TREE_CODE (TREE_TYPE (TREE_VALUE (params)))
1209                                                == POINTER_TYPE);
1210               params = TREE_CHAIN (params);
1211               i++;
1212             }
1213         }
1214     }
1215 }
1216
1217
1218 /* Look for a decimal number followed by a $ in *FORMAT.  If DOLLAR_NEEDED
1219    is set, it is an error if one is not found; otherwise, it is OK.  If
1220    such a number is found, check whether it is within range and mark that
1221    numbered operand as being used for later checking.  Returns the operand
1222    number if found and within range, zero if no such number was found and
1223    this is OK, or -1 on error.  PARAMS points to the first operand of the
1224    format; PARAM_PTR is made to point to the parameter referred to.  If
1225    a $ format is found, *FORMAT is updated to point just after it.  */
1226
1227 static int
1228 maybe_read_dollar_number (const char **format,
1229                           int dollar_needed, tree params, tree *param_ptr,
1230                           const format_kind_info *fki)
1231 {
1232   int argnum;
1233   int overflow_flag;
1234   const char *fcp = *format;
1235   if (!ISDIGIT (*fcp))
1236     {
1237       if (dollar_needed)
1238         {
1239           warning (OPT_Wformat_, "missing $ operand number in format");
1240           return -1;
1241         }
1242       else
1243         return 0;
1244     }
1245   argnum = 0;
1246   overflow_flag = 0;
1247   while (ISDIGIT (*fcp))
1248     {
1249       int nargnum;
1250       nargnum = 10 * argnum + (*fcp - '0');
1251       if (nargnum < 0 || nargnum / 10 != argnum)
1252         overflow_flag = 1;
1253       argnum = nargnum;
1254       fcp++;
1255     }
1256   if (*fcp != '$')
1257     {
1258       if (dollar_needed)
1259         {
1260           warning (OPT_Wformat_, "missing $ operand number in format");
1261           return -1;
1262         }
1263       else
1264         return 0;
1265     }
1266   *format = fcp + 1;
1267   if (pedantic && !dollar_format_warned)
1268     {
1269       warning (OPT_Wformat_, "%s does not support %%n$ operand number formats",
1270                C_STD_NAME (STD_EXT));
1271       dollar_format_warned = 1;
1272     }
1273   if (overflow_flag || argnum == 0
1274       || (dollar_first_arg_num && argnum > dollar_arguments_count))
1275     {
1276       warning (OPT_Wformat_, "operand number out of range in format");
1277       return -1;
1278     }
1279   if (argnum > dollar_max_arg_used)
1280     dollar_max_arg_used = argnum;
1281   /* For vprintf-style functions we may need to allocate more memory to
1282      track which arguments are used.  */
1283   while (dollar_arguments_alloc < dollar_max_arg_used)
1284     {
1285       int nalloc;
1286       nalloc = 2 * dollar_arguments_alloc + 16;
1287       dollar_arguments_used = XRESIZEVEC (char, dollar_arguments_used,
1288                                           nalloc);
1289       dollar_arguments_pointer_p = XRESIZEVEC (char, dollar_arguments_pointer_p,
1290                                                nalloc);
1291       memset (dollar_arguments_used + dollar_arguments_alloc, 0,
1292               nalloc - dollar_arguments_alloc);
1293       dollar_arguments_alloc = nalloc;
1294     }
1295   if (!(fki->flags & (int) FMT_FLAG_DOLLAR_MULTIPLE)
1296       && dollar_arguments_used[argnum - 1] == 1)
1297     {
1298       dollar_arguments_used[argnum - 1] = 2;
1299       warning (OPT_Wformat_, "format argument %d used more than once in %s format",
1300                argnum, fki->name);
1301     }
1302   else
1303     dollar_arguments_used[argnum - 1] = 1;
1304   if (dollar_first_arg_num)
1305     {
1306       int i;
1307       *param_ptr = params;
1308       for (i = 1; i < argnum && *param_ptr != 0; i++)
1309         *param_ptr = TREE_CHAIN (*param_ptr);
1310
1311       /* This case shouldn't be caught here.  */
1312       gcc_assert (*param_ptr);
1313     }
1314   else
1315     *param_ptr = 0;
1316   return argnum;
1317 }
1318
1319 /* Ensure that FORMAT does not start with a decimal number followed by
1320    a $; give a diagnostic and return true if it does, false otherwise.  */
1321
1322 static bool
1323 avoid_dollar_number (const char *format)
1324 {
1325   if (!ISDIGIT (*format))
1326     return false;
1327   while (ISDIGIT (*format))
1328     format++;
1329   if (*format == '$')
1330     {
1331       warning (OPT_Wformat_, "$ operand number used after format without operand number");
1332       return true;
1333     }
1334   return false;
1335 }
1336
1337
1338 /* Finish the checking for a format string that used $ operand number formats
1339    instead of non-$ formats.  We check for unused operands before used ones
1340    (a serious error, since the implementation of the format function
1341    can't know what types to pass to va_arg to find the later arguments).
1342    and for unused operands at the end of the format (if we know how many
1343    arguments the format had, so not for vprintf).  If there were operand
1344    numbers out of range on a non-vprintf-style format, we won't have reached
1345    here.  If POINTER_GAP_OK, unused arguments are OK if all arguments are
1346    pointers.  */
1347
1348 static void
1349 finish_dollar_format_checking (format_check_results *res, int pointer_gap_ok)
1350 {
1351   int i;
1352   bool found_pointer_gap = false;
1353   for (i = 0; i < dollar_max_arg_used; i++)
1354     {
1355       if (!dollar_arguments_used[i])
1356         {
1357           if (pointer_gap_ok && (dollar_first_arg_num == 0
1358                                  || dollar_arguments_pointer_p[i]))
1359             found_pointer_gap = true;
1360           else
1361             warning_at (res->format_string_loc, OPT_Wformat_,
1362                         "format argument %d unused before used argument %d in $-style format",
1363                         i + 1, dollar_max_arg_used);
1364         }
1365     }
1366   if (found_pointer_gap
1367       || (dollar_first_arg_num
1368           && dollar_max_arg_used < dollar_arguments_count))
1369     {
1370       res->number_other--;
1371       res->number_dollar_extra_args++;
1372     }
1373 }
1374
1375
1376 /* Retrieve the specification for a format flag.  SPEC contains the
1377    specifications for format flags for the applicable kind of format.
1378    FLAG is the flag in question.  If PREDICATES is NULL, the basic
1379    spec for that flag must be retrieved and must exist.  If
1380    PREDICATES is not NULL, it is a string listing possible predicates
1381    for the spec entry; if an entry predicated on any of these is
1382    found, it is returned, otherwise NULL is returned.  */
1383
1384 static const format_flag_spec *
1385 get_flag_spec (const format_flag_spec *spec, int flag, const char *predicates)
1386 {
1387   int i;
1388   for (i = 0; spec[i].flag_char != 0; i++)
1389     {
1390       if (spec[i].flag_char != flag)
1391         continue;
1392       if (predicates != NULL)
1393         {
1394           if (spec[i].predicate != 0
1395               && strchr (predicates, spec[i].predicate) != 0)
1396             return &spec[i];
1397         }
1398       else if (spec[i].predicate == 0)
1399         return &spec[i];
1400     }
1401   gcc_assert (predicates);
1402   return NULL;
1403 }
1404
1405
1406 /* Check the argument list of a call to printf, scanf, etc.
1407    INFO points to the function_format_info structure.
1408    PARAMS is the list of argument values.  */
1409
1410 static void
1411 check_format_info (function_format_info *info, tree params,
1412                    vec<location_t> *arglocs)
1413 {
1414   format_check_context format_ctx;
1415   unsigned HOST_WIDE_INT arg_num;
1416   tree format_tree;
1417   format_check_results res;
1418   /* Skip to format argument.  If the argument isn't available, there's
1419      no work for us to do; prototype checking will catch the problem.  */
1420   for (arg_num = 1; ; ++arg_num)
1421     {
1422       if (params == 0)
1423         return;
1424       if (arg_num == info->format_num)
1425         break;
1426       params = TREE_CHAIN (params);
1427     }
1428   format_tree = TREE_VALUE (params);
1429   params = TREE_CHAIN (params);
1430   if (format_tree == 0)
1431     return;
1432
1433   res.number_non_literal = 0;
1434   res.number_extra_args = 0;
1435   res.extra_arg_loc = UNKNOWN_LOCATION;
1436   res.number_dollar_extra_args = 0;
1437   res.number_wide = 0;
1438   res.number_empty = 0;
1439   res.number_unterminated = 0;
1440   res.number_other = 0;
1441   res.format_string_loc = input_location;
1442
1443   format_ctx.res = &res;
1444   format_ctx.info = info;
1445   format_ctx.params = params;
1446   format_ctx.arglocs = arglocs;
1447
1448   check_function_arguments_recurse (check_format_arg, &format_ctx,
1449                                     format_tree, arg_num);
1450
1451   location_t loc = format_ctx.res->format_string_loc;
1452
1453   if (res.number_non_literal > 0)
1454     {
1455       /* Functions taking a va_list normally pass a non-literal format
1456          string.  These functions typically are declared with
1457          first_arg_num == 0, so avoid warning in those cases.  */
1458       if (!(format_types[info->format_type].flags & (int) FMT_FLAG_ARG_CONVERT))
1459         {
1460           /* For strftime-like formats, warn for not checking the format
1461              string; but there are no arguments to check.  */
1462           warning_at (loc, OPT_Wformat_nonliteral,
1463                       "format not a string literal, format string not checked");
1464         }
1465       else if (info->first_arg_num != 0)
1466         {
1467           /* If there are no arguments for the format at all, we may have
1468              printf (foo) which is likely to be a security hole.  */
1469           while (arg_num + 1 < info->first_arg_num)
1470             {
1471               if (params == 0)
1472                 break;
1473               params = TREE_CHAIN (params);
1474               ++arg_num;
1475             }
1476           if (params == 0 && warn_format_security)
1477             warning_at (loc, OPT_Wformat_security,
1478                         "format not a string literal and no format arguments");
1479           else if (params == 0 && warn_format_nonliteral)
1480             warning_at (loc, OPT_Wformat_nonliteral,
1481                         "format not a string literal and no format arguments");
1482           else
1483             warning_at (loc, OPT_Wformat_nonliteral,
1484                         "format not a string literal, argument types not checked");
1485         }
1486     }
1487
1488   /* If there were extra arguments to the format, normally warn.  However,
1489      the standard does say extra arguments are ignored, so in the specific
1490      case where we have multiple leaves (conditional expressions or
1491      ngettext) allow extra arguments if at least one leaf didn't have extra
1492      arguments, but was otherwise OK (either non-literal or checked OK).
1493      If the format is an empty string, this should be counted similarly to the
1494      case of extra format arguments.  */
1495   if (res.number_extra_args > 0 && res.number_non_literal == 0
1496       && res.number_other == 0)
1497     {
1498       if (res.extra_arg_loc == UNKNOWN_LOCATION)
1499         res.extra_arg_loc = loc;
1500       warning_at (res.extra_arg_loc, OPT_Wformat_extra_args,
1501                   "too many arguments for format");
1502     }
1503   if (res.number_dollar_extra_args > 0 && res.number_non_literal == 0
1504       && res.number_other == 0)
1505     warning_at (loc, OPT_Wformat_extra_args, "unused arguments in $-style format");
1506   if (res.number_empty > 0 && res.number_non_literal == 0
1507       && res.number_other == 0)
1508     warning_at (loc, OPT_Wformat_zero_length, "zero-length %s format string",
1509              format_types[info->format_type].name);
1510
1511   if (res.number_wide > 0)
1512     warning_at (loc, OPT_Wformat_, "format is a wide character string");
1513
1514   if (res.number_unterminated > 0)
1515     warning_at (loc, OPT_Wformat_, "unterminated format string");
1516 }
1517
1518 /* Callback from check_function_arguments_recurse to check a
1519    format string.  FORMAT_TREE is the format parameter.  ARG_NUM
1520    is the number of the format argument.  CTX points to a
1521    format_check_context.  */
1522
1523 static void
1524 check_format_arg (void *ctx, tree format_tree,
1525                   unsigned HOST_WIDE_INT arg_num)
1526 {
1527   format_check_context *format_ctx = (format_check_context *) ctx;
1528   format_check_results *res = format_ctx->res;
1529   function_format_info *info = format_ctx->info;
1530   tree params = format_ctx->params;
1531   vec<location_t> *arglocs = format_ctx->arglocs;
1532
1533   int format_length;
1534   HOST_WIDE_INT offset;
1535   const char *format_chars;
1536   tree array_size = 0;
1537   tree array_init;
1538
1539   location_t fmt_param_loc = EXPR_LOC_OR_LOC (format_tree, input_location);
1540
1541   /* Pull out a constant value if the front end didn't, and handle location
1542      wrappers.  */
1543   format_tree = fold_for_warn (format_tree);
1544   STRIP_NOPS (format_tree);
1545
1546   if (integer_zerop (format_tree))
1547     {
1548       /* Skip to first argument to check, so we can see if this format
1549          has any arguments (it shouldn't).  */
1550       while (arg_num + 1 < info->first_arg_num)
1551         {
1552           if (params == 0)
1553             return;
1554           params = TREE_CHAIN (params);
1555           ++arg_num;
1556         }
1557
1558       if (params == 0)
1559         res->number_other++;
1560       else
1561         {
1562           if (res->number_extra_args == 0)
1563             res->extra_arg_loc = EXPR_LOC_OR_LOC (TREE_VALUE (params),
1564                                                   input_location);
1565           res->number_extra_args++;
1566         }
1567       return;
1568     }
1569
1570   offset = 0;
1571   if (TREE_CODE (format_tree) == POINTER_PLUS_EXPR)
1572     {
1573       tree arg0, arg1;
1574
1575       arg0 = TREE_OPERAND (format_tree, 0);
1576       arg1 = TREE_OPERAND (format_tree, 1);
1577       STRIP_NOPS (arg0);
1578       STRIP_NOPS (arg1);
1579       if (TREE_CODE (arg1) == INTEGER_CST)
1580         format_tree = arg0;
1581       else
1582         {
1583           res->number_non_literal++;
1584           return;
1585         }
1586       /* POINTER_PLUS_EXPR offsets are to be interpreted signed.  */
1587       if (!cst_and_fits_in_hwi (arg1))
1588         {
1589           res->number_non_literal++;
1590           return;
1591         }
1592       offset = int_cst_value (arg1);
1593     }
1594   if (TREE_CODE (format_tree) != ADDR_EXPR)
1595     {
1596       res->number_non_literal++;
1597       return;
1598     }
1599   res->format_string_loc = EXPR_LOC_OR_LOC (format_tree, input_location);
1600   format_tree = TREE_OPERAND (format_tree, 0);
1601   if (format_types[info->format_type].flags
1602       & (int) FMT_FLAG_PARSE_ARG_CONVERT_EXTERNAL)
1603     {
1604       bool objc_str = (info->format_type == gcc_objc_string_format_type);
1605       /* We cannot examine this string here - but we can check that it is
1606          a valid type.  */
1607       if (TREE_CODE (format_tree) != CONST_DECL
1608           || !((objc_str && objc_string_ref_type_p (TREE_TYPE (format_tree)))
1609                 || (*targetcm.string_object_ref_type_p)
1610                                      ((const_tree) TREE_TYPE (format_tree))))
1611         {
1612           res->number_non_literal++;
1613           return;
1614         }
1615       /* Skip to first argument to check.  */
1616       while (arg_num + 1 < info->first_arg_num)
1617         {
1618           if (params == 0)
1619             return;
1620           params = TREE_CHAIN (params);
1621           ++arg_num;
1622         }
1623       /* So, we have a valid literal string object and one or more params.
1624          We need to use an external helper to parse the string into format
1625          info.  For Objective-C variants we provide the resource within the
1626          objc tree, for target variants, via a hook.  */
1627       if (objc_str)
1628         objc_check_format_arg (format_tree, params);
1629       else if (targetcm.check_string_object_format_arg)
1630         (*targetcm.check_string_object_format_arg) (format_tree, params);
1631       /* Else we can't handle it and retire quietly.  */
1632       return;
1633     }
1634   if (TREE_CODE (format_tree) == ARRAY_REF
1635       && tree_fits_shwi_p (TREE_OPERAND (format_tree, 1))
1636       && (offset += tree_to_shwi (TREE_OPERAND (format_tree, 1))) >= 0)
1637     format_tree = TREE_OPERAND (format_tree, 0);
1638   if (offset < 0)
1639     {
1640       res->number_non_literal++;
1641       return;
1642     }
1643   if (VAR_P (format_tree)
1644       && TREE_CODE (TREE_TYPE (format_tree)) == ARRAY_TYPE
1645       && (array_init = decl_constant_value (format_tree)) != format_tree
1646       && TREE_CODE (array_init) == STRING_CST)
1647     {
1648       /* Extract the string constant initializer.  Note that this may include
1649          a trailing NUL character that is not in the array (e.g.
1650          const char a[3] = "foo";).  */
1651       array_size = DECL_SIZE_UNIT (format_tree);
1652       format_tree = array_init;
1653     }
1654   if (TREE_CODE (format_tree) != STRING_CST)
1655     {
1656       res->number_non_literal++;
1657       return;
1658     }
1659   if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (format_tree))) != char_type_node)
1660     {
1661       res->number_wide++;
1662       return;
1663     }
1664   format_chars = TREE_STRING_POINTER (format_tree);
1665   format_length = TREE_STRING_LENGTH (format_tree);
1666   if (array_size != 0)
1667     {
1668       /* Variable length arrays can't be initialized.  */
1669       gcc_assert (TREE_CODE (array_size) == INTEGER_CST);
1670
1671       if (tree_fits_shwi_p (array_size))
1672         {
1673           HOST_WIDE_INT array_size_value = tree_to_shwi (array_size);
1674           if (array_size_value > 0
1675               && array_size_value == (int) array_size_value
1676               && format_length > array_size_value)
1677             format_length = array_size_value;
1678         }
1679     }
1680   if (offset)
1681     {
1682       if (offset >= format_length)
1683         {
1684           res->number_non_literal++;
1685           return;
1686         }
1687       format_chars += offset;
1688       format_length -= offset;
1689     }
1690   if (format_length < 1 || format_chars[--format_length] != 0)
1691     {
1692       res->number_unterminated++;
1693       return;
1694     }
1695   if (format_length == 0)
1696     {
1697       res->number_empty++;
1698       return;
1699     }
1700
1701   /* Skip to first argument to check.  */
1702   while (arg_num + 1 < info->first_arg_num)
1703     {
1704       if (params == 0)
1705         return;
1706       params = TREE_CHAIN (params);
1707       ++arg_num;
1708     }
1709   /* Provisionally increment res->number_other; check_format_info_main
1710      will decrement it if it finds there are extra arguments, but this way
1711      need not adjust it for every return.  */
1712   res->number_other++;
1713   object_allocator <format_wanted_type> fwt_pool ("format_wanted_type pool");
1714   check_format_info_main (res, info, format_chars, fmt_param_loc, format_tree,
1715                           format_length, params, arg_num, fwt_pool, arglocs);
1716 }
1717
1718 /* Support class for argument_parser and check_format_info_main.
1719    Tracks any flag characters that have been applied to the
1720    current argument.  */
1721
1722 class flag_chars_t
1723 {
1724  public:
1725   flag_chars_t ();
1726   bool has_char_p (char ch) const;
1727   void add_char (char ch);
1728   void validate (const format_kind_info *fki,
1729                  const format_char_info *fci,
1730                  const format_flag_spec *flag_specs,
1731                  const char * const format_chars,
1732                  tree format_string_cst,
1733                  location_t format_string_loc,
1734                  const char * const orig_format_chars,
1735                  char format_char,
1736                  bool quoted);
1737   int get_alloc_flag (const format_kind_info *fki);
1738   int assignment_suppression_p (const format_kind_info *fki);
1739
1740  private:
1741   char m_flag_chars[256];
1742 };
1743
1744 /* Support struct for argument_parser and check_format_info_main.
1745    Encapsulates any length modifier applied to the current argument.  */
1746
1747 struct length_modifier
1748 {
1749   length_modifier ()
1750   : chars (NULL), val (FMT_LEN_none), std (STD_C89),
1751     scalar_identity_flag (0)
1752   {
1753   }
1754
1755   length_modifier (const char *chars_,
1756                    enum format_lengths val_,
1757                    enum format_std_version std_,
1758                    int scalar_identity_flag_)
1759   : chars (chars_), val (val_), std (std_),
1760     scalar_identity_flag (scalar_identity_flag_)
1761   {
1762   }
1763
1764   const char *chars;
1765   enum format_lengths val;
1766   enum format_std_version std;
1767   int scalar_identity_flag;
1768 };
1769
1770 /* Parsing one argument within a format string.  */
1771
1772 class argument_parser
1773 {
1774  public:
1775   argument_parser (function_format_info *info, const char *&format_chars,
1776                    tree format_string_cst,
1777                    const char * const orig_format_chars,
1778                    location_t format_string_loc, flag_chars_t &flag_chars,
1779                    int &has_operand_number, tree first_fillin_param,
1780                    object_allocator <format_wanted_type> &fwt_pool_,
1781                    vec<location_t> *arglocs);
1782
1783   bool read_any_dollar ();
1784
1785   bool read_format_flags ();
1786
1787   bool
1788   read_any_format_width (tree &params,
1789                          unsigned HOST_WIDE_INT &arg_num);
1790
1791   void
1792   read_any_format_left_precision ();
1793
1794   bool
1795   read_any_format_precision (tree &params,
1796                              unsigned HOST_WIDE_INT &arg_num);
1797
1798   void handle_alloc_chars ();
1799
1800   length_modifier read_any_length_modifier ();
1801
1802   void read_any_other_modifier ();
1803
1804   const format_char_info *find_format_char_info (char format_char);
1805
1806   void
1807   validate_flag_pairs (const format_char_info *fci,
1808                        char format_char);
1809
1810   void
1811   give_y2k_warnings (const format_char_info *fci,
1812                      char format_char);
1813
1814   void parse_any_scan_set (const format_char_info *fci);
1815
1816   bool handle_conversions (const format_char_info *fci,
1817                            const length_modifier &len_modifier,
1818                            tree &wanted_type,
1819                            const char *&wanted_type_name,
1820                            unsigned HOST_WIDE_INT &arg_num,
1821                            tree &params,
1822                            char format_char);
1823
1824   bool
1825   check_argument_type (const format_char_info *fci,
1826                        const length_modifier &len_modifier,
1827                        tree &wanted_type,
1828                        const char *&wanted_type_name,
1829                        const bool suppressed,
1830                        unsigned HOST_WIDE_INT &arg_num,
1831                        tree &params,
1832                        const int alloc_flag,
1833                        const char * const format_start,
1834                        const char * const type_start,
1835                        location_t fmt_param_loc,
1836                        char conversion_char);
1837
1838  private:
1839   const function_format_info *const info;
1840   const format_kind_info * const fki;
1841   const format_flag_spec * const flag_specs;
1842   const char *start_of_this_format;
1843   const char *&format_chars;
1844   const tree format_string_cst;
1845   const char * const orig_format_chars;
1846   const location_t format_string_loc;
1847   object_allocator <format_wanted_type> &fwt_pool;
1848   flag_chars_t &flag_chars;
1849   int main_arg_num;
1850   tree main_arg_params;
1851   int &has_operand_number;
1852   const tree first_fillin_param;
1853   format_wanted_type width_wanted_type;
1854   format_wanted_type precision_wanted_type;
1855  public:
1856   format_wanted_type main_wanted_type;
1857  private:
1858   format_wanted_type *first_wanted_type;
1859   format_wanted_type *last_wanted_type;
1860   vec<location_t> *arglocs;
1861 };
1862
1863 /* flag_chars_t's constructor.  */
1864
1865 flag_chars_t::flag_chars_t ()
1866 {
1867   m_flag_chars[0] = 0;
1868 }
1869
1870 /* Has CH been seen as a flag within the current argument?  */
1871
1872 bool
1873 flag_chars_t::has_char_p (char ch) const
1874 {
1875   return strchr (m_flag_chars, ch) != 0;
1876 }
1877
1878 /* Add CH to the flags seen within the current argument.  */
1879
1880 void
1881 flag_chars_t::add_char (char ch)
1882 {
1883   int i = strlen (m_flag_chars);
1884   m_flag_chars[i++] = ch;
1885   m_flag_chars[i] = 0;
1886 }
1887
1888 /* Validate the individual flags used, removing any that are invalid.  */
1889
1890 void
1891 flag_chars_t::validate (const format_kind_info *fki,
1892                         const format_char_info *fci,
1893                         const format_flag_spec *flag_specs,
1894                         const char * const format_chars,
1895                         tree format_string_cst,
1896                         location_t format_string_loc,
1897                         const char * const orig_format_chars,
1898                         char format_char,
1899                         bool quoted)
1900 {
1901   int i;
1902   int d = 0;
1903   bool quotflag = false;
1904
1905   for (i = 0; m_flag_chars[i] != 0; i++)
1906     {
1907       const format_flag_spec *s = get_flag_spec (flag_specs,
1908                                                  m_flag_chars[i], NULL);
1909       m_flag_chars[i - d] = m_flag_chars[i];
1910       if (m_flag_chars[i] == fki->length_code_char)
1911         continue;
1912
1913       /* Remember if a quoting flag is seen.  */
1914       quotflag |= s->quoting;
1915
1916       if (strchr (fci->flag_chars, m_flag_chars[i]) == 0)
1917         {
1918           format_warning_at_char (format_string_loc, format_string_cst,
1919                                   format_chars - orig_format_chars,
1920                                   OPT_Wformat_,
1921                                   "%s used with %<%%%c%> %s format",
1922                                   _(s->name), format_char, fki->name);
1923           d++;
1924           continue;
1925         }
1926       if (pedantic)
1927         {
1928           const format_flag_spec *t;
1929           if (ADJ_STD (s->std) > C_STD_VER)
1930             warning_at (format_string_loc, OPT_Wformat_,
1931                         "%s does not support %s",
1932                         C_STD_NAME (s->std), _(s->long_name));
1933           t = get_flag_spec (flag_specs, m_flag_chars[i], fci->flags2);
1934           if (t != NULL && ADJ_STD (t->std) > ADJ_STD (s->std))
1935             {
1936               const char *long_name = (t->long_name != NULL
1937                                        ? t->long_name
1938                                        : s->long_name);
1939               if (ADJ_STD (t->std) > C_STD_VER)
1940                 warning_at (format_string_loc, OPT_Wformat_,
1941                             "%s does not support %s with"
1942                             " the %<%%%c%> %s format",
1943                             C_STD_NAME (t->std), _(long_name),
1944                             format_char, fki->name);
1945             }
1946         }
1947
1948       /* Detect quoting directives used within a quoted sequence, such
1949          as GCC's "%<...%qE".  */
1950       if (quoted && s->quoting)
1951         {
1952           format_warning_at_char (format_string_loc, format_string_cst,
1953                                   format_chars - orig_format_chars - 1,
1954                                   OPT_Wformat_,
1955                                   "%s used within a quoted sequence",
1956                                   _(s->name));
1957         }
1958     }
1959   m_flag_chars[i - d] = 0;
1960
1961   if (!quoted
1962       && !quotflag
1963       && strchr (fci->flags2, '\''))
1964     {
1965       format_warning_at_char (format_string_loc, format_string_cst,
1966                               format_chars - orig_format_chars,
1967                               OPT_Wformat_,
1968                               "%qc conversion used unquoted",
1969                               format_char);
1970     }
1971 }
1972
1973 /* Determine if an assignment-allocation has been set, requiring
1974    an extra char ** for writing back a dynamically-allocated char *.
1975    This is for handling the optional 'm' character in scanf.  */
1976
1977 int
1978 flag_chars_t::get_alloc_flag (const format_kind_info *fki)
1979 {
1980   if ((fki->flags & (int) FMT_FLAG_SCANF_A_KLUDGE)
1981       && has_char_p ('a'))
1982     return 1;
1983   if (fki->alloc_char && has_char_p (fki->alloc_char))
1984     return 1;
1985   return 0;
1986 }
1987
1988 /* Determine if an assignment-suppression character was seen.
1989    ('*' in scanf, for discarding the converted input).  */
1990
1991 int
1992 flag_chars_t::assignment_suppression_p (const format_kind_info *fki)
1993 {
1994   if (fki->suppression_char
1995       && has_char_p (fki->suppression_char))
1996     return 1;
1997   return 0;
1998 }
1999
2000 /* Constructor for argument_parser.  Initialize for parsing one
2001    argument within a format string.  */
2002
2003 argument_parser::
2004 argument_parser (function_format_info *info_, const char *&format_chars_,
2005                  tree format_string_cst_,
2006                  const char * const orig_format_chars_,
2007                  location_t format_string_loc_,
2008                  flag_chars_t &flag_chars_,
2009                  int &has_operand_number_,
2010                  tree first_fillin_param_,
2011                  object_allocator <format_wanted_type> &fwt_pool_,
2012                  vec<location_t> *arglocs_)
2013 : info (info_),
2014   fki (&format_types[info->format_type]),
2015   flag_specs (fki->flag_specs),
2016   start_of_this_format (format_chars_),
2017   format_chars (format_chars_),
2018   format_string_cst (format_string_cst_),
2019   orig_format_chars (orig_format_chars_),
2020   format_string_loc (format_string_loc_),
2021   fwt_pool (fwt_pool_),
2022   flag_chars (flag_chars_),
2023   main_arg_num (0),
2024   main_arg_params (NULL),
2025   has_operand_number (has_operand_number_),
2026   first_fillin_param (first_fillin_param_),
2027   first_wanted_type (NULL),
2028   last_wanted_type (NULL),
2029   arglocs (arglocs_)
2030 {
2031 }
2032
2033 /* Handle dollars at the start of format arguments, setting up main_arg_params
2034    and main_arg_num.
2035
2036    Return true if format parsing is to continue, false otherwise.  */
2037
2038 bool
2039 argument_parser::read_any_dollar ()
2040 {
2041   if ((fki->flags & (int) FMT_FLAG_USE_DOLLAR) && has_operand_number != 0)
2042     {
2043       /* Possibly read a $ operand number at the start of the format.
2044          If one was previously used, one is required here.  If one
2045          is not used here, we can't immediately conclude this is a
2046          format without them, since it could be printf %m or scanf %*.  */
2047       int opnum;
2048       opnum = maybe_read_dollar_number (&format_chars, 0,
2049                                         first_fillin_param,
2050                                         &main_arg_params, fki);
2051       if (opnum == -1)
2052         return false;
2053       else if (opnum > 0)
2054         {
2055           has_operand_number = 1;
2056           main_arg_num = opnum + info->first_arg_num - 1;
2057         }
2058     }
2059   else if (fki->flags & FMT_FLAG_USE_DOLLAR)
2060     {
2061       if (avoid_dollar_number (format_chars))
2062         return false;
2063     }
2064   return true;
2065 }
2066
2067 /* Read any format flags, but do not yet validate them beyond removing
2068    duplicates, since in general validation depends on the rest of
2069    the format.
2070
2071    Return true if format parsing is to continue, false otherwise.  */
2072
2073 bool
2074 argument_parser::read_format_flags ()
2075 {
2076   while (*format_chars != 0
2077          && strchr (fki->flag_chars, *format_chars) != 0)
2078     {
2079       const format_flag_spec *s = get_flag_spec (flag_specs,
2080                                                  *format_chars, NULL);
2081       if (flag_chars.has_char_p (*format_chars))
2082         {
2083           format_warning_at_char (format_string_loc, format_string_cst,
2084                                   format_chars + 1 - orig_format_chars,
2085                                   OPT_Wformat_,
2086                                   "repeated %s in format", _(s->name));
2087         }
2088       else
2089         flag_chars.add_char (*format_chars);
2090
2091       if (s->skip_next_char)
2092         {
2093           ++format_chars;
2094           if (*format_chars == 0)
2095             {
2096               warning_at (format_string_loc, OPT_Wformat_,
2097                           "missing fill character at end of strfmon format");
2098               return false;
2099             }
2100         }
2101       ++format_chars;
2102     }
2103
2104   return true;
2105 }
2106
2107 /* Read any format width, possibly * or *m$.
2108
2109    Return true if format parsing is to continue, false otherwise.  */
2110
2111 bool
2112 argument_parser::
2113 read_any_format_width (tree &params,
2114                        unsigned HOST_WIDE_INT &arg_num)
2115 {
2116   if (!fki->width_char)
2117     return true;
2118
2119   if (fki->width_type != NULL && *format_chars == '*')
2120     {
2121       flag_chars.add_char (fki->width_char);
2122       /* "...a field width...may be indicated by an asterisk.
2123          In this case, an int argument supplies the field width..."  */
2124       ++format_chars;
2125       if (has_operand_number != 0)
2126         {
2127           int opnum;
2128           opnum = maybe_read_dollar_number (&format_chars,
2129                                             has_operand_number == 1,
2130                                             first_fillin_param,
2131                                             &params, fki);
2132           if (opnum == -1)
2133             return false;
2134           else if (opnum > 0)
2135             {
2136               has_operand_number = 1;
2137               arg_num = opnum + info->first_arg_num - 1;
2138             }
2139           else
2140             has_operand_number = 0;
2141         }
2142       else
2143         {
2144           if (avoid_dollar_number (format_chars))
2145             return false;
2146         }
2147       if (info->first_arg_num != 0)
2148         {
2149           tree cur_param;
2150           if (params == 0)
2151             cur_param = NULL;
2152           else
2153             {
2154               cur_param = TREE_VALUE (params);
2155               if (has_operand_number <= 0)
2156                 {
2157                   params = TREE_CHAIN (params);
2158                   ++arg_num;
2159                 }
2160             }
2161           width_wanted_type.wanted_type = *fki->width_type;
2162           width_wanted_type.wanted_type_name = NULL;
2163           width_wanted_type.pointer_count = 0;
2164           width_wanted_type.char_lenient_flag = 0;
2165           width_wanted_type.scalar_identity_flag = 0;
2166           width_wanted_type.writing_in_flag = 0;
2167           width_wanted_type.reading_from_flag = 0;
2168           width_wanted_type.kind = CF_KIND_FIELD_WIDTH;
2169           width_wanted_type.format_start = format_chars - 1;
2170           width_wanted_type.format_length = 1;
2171           width_wanted_type.param = cur_param;
2172           width_wanted_type.arg_num = arg_num;
2173           width_wanted_type.offset_loc =
2174             format_chars - orig_format_chars;
2175           width_wanted_type.next = NULL;
2176           if (last_wanted_type != 0)
2177             last_wanted_type->next = &width_wanted_type;
2178           if (first_wanted_type == 0)
2179             first_wanted_type = &width_wanted_type;
2180           last_wanted_type = &width_wanted_type;
2181         }
2182     }
2183   else
2184     {
2185       /* Possibly read a numeric width.  If the width is zero,
2186          we complain if appropriate.  */
2187       int non_zero_width_char = FALSE;
2188       int found_width = FALSE;
2189       while (ISDIGIT (*format_chars))
2190         {
2191           found_width = TRUE;
2192           if (*format_chars != '0')
2193             non_zero_width_char = TRUE;
2194           ++format_chars;
2195         }
2196       if (found_width && !non_zero_width_char &&
2197           (fki->flags & (int) FMT_FLAG_ZERO_WIDTH_BAD))
2198         warning_at (format_string_loc, OPT_Wformat_,
2199                     "zero width in %s format", fki->name);
2200       if (found_width)
2201         flag_chars.add_char (fki->width_char);
2202     }
2203
2204   return true;
2205 }
2206
2207 /* Read any format left precision (must be a number, not *).  */
2208 void
2209 argument_parser::read_any_format_left_precision ()
2210 {
2211   if (fki->left_precision_char == 0)
2212     return;
2213   if (*format_chars != '#')
2214     return;
2215
2216   ++format_chars;
2217   flag_chars.add_char (fki->left_precision_char);
2218   if (!ISDIGIT (*format_chars))
2219     format_warning_at_char (format_string_loc, format_string_cst,
2220                             format_chars - orig_format_chars,
2221                             OPT_Wformat_,
2222                             "empty left precision in %s format", fki->name);
2223   while (ISDIGIT (*format_chars))
2224     ++format_chars;
2225 }
2226
2227 /* Read any format precision, possibly * or *m$.
2228
2229    Return true if format parsing is to continue, false otherwise.  */
2230
2231 bool
2232 argument_parser::
2233 read_any_format_precision (tree &params,
2234                            unsigned HOST_WIDE_INT &arg_num)
2235 {
2236   if (fki->precision_char == 0)
2237     return true;
2238   if (*format_chars != '.')
2239     return true;
2240
2241   ++format_chars;
2242   flag_chars.add_char (fki->precision_char);
2243   if (fki->precision_type != NULL && *format_chars == '*')
2244     {
2245       /* "...a...precision...may be indicated by an asterisk.
2246          In this case, an int argument supplies the...precision."  */
2247       ++format_chars;
2248       if (has_operand_number != 0)
2249         {
2250           int opnum;
2251           opnum = maybe_read_dollar_number (&format_chars,
2252                                             has_operand_number == 1,
2253                                             first_fillin_param,
2254                                             &params, fki);
2255           if (opnum == -1)
2256             return false;
2257           else if (opnum > 0)
2258             {
2259               has_operand_number = 1;
2260               arg_num = opnum + info->first_arg_num - 1;
2261             }
2262           else
2263             has_operand_number = 0;
2264         }
2265       else
2266         {
2267           if (avoid_dollar_number (format_chars))
2268             return false;
2269         }
2270       if (info->first_arg_num != 0)
2271         {
2272           tree cur_param;
2273           if (params == 0)
2274             cur_param = NULL;
2275           else
2276             {
2277               cur_param = TREE_VALUE (params);
2278               if (has_operand_number <= 0)
2279                 {
2280                   params = TREE_CHAIN (params);
2281                   ++arg_num;
2282                 }
2283             }
2284           precision_wanted_type.wanted_type = *fki->precision_type;
2285           precision_wanted_type.wanted_type_name = NULL;
2286           precision_wanted_type.pointer_count = 0;
2287           precision_wanted_type.char_lenient_flag = 0;
2288           precision_wanted_type.scalar_identity_flag = 0;
2289           precision_wanted_type.writing_in_flag = 0;
2290           precision_wanted_type.reading_from_flag = 0;
2291           precision_wanted_type.kind = CF_KIND_FIELD_PRECISION;
2292           precision_wanted_type.param = cur_param;
2293           precision_wanted_type.format_start = format_chars - 2;
2294           precision_wanted_type.format_length = 2;
2295           precision_wanted_type.arg_num = arg_num;
2296           precision_wanted_type.offset_loc =
2297             format_chars - orig_format_chars;
2298           precision_wanted_type.next = NULL;
2299           if (last_wanted_type != 0)
2300             last_wanted_type->next = &precision_wanted_type;
2301           if (first_wanted_type == 0)
2302             first_wanted_type = &precision_wanted_type;
2303           last_wanted_type = &precision_wanted_type;
2304         }
2305     }
2306   else
2307     {
2308       if (!(fki->flags & (int) FMT_FLAG_EMPTY_PREC_OK)
2309           && !ISDIGIT (*format_chars))
2310         format_warning_at_char (format_string_loc, format_string_cst,
2311                                 format_chars - orig_format_chars,
2312                                 OPT_Wformat_,
2313                                 "empty precision in %s format", fki->name);
2314       while (ISDIGIT (*format_chars))
2315         ++format_chars;
2316     }
2317
2318   return true;
2319 }
2320
2321 /* Parse any assignment-allocation flags, which request an extra
2322    char ** for writing back a dynamically-allocated char *.
2323    This is for handling the optional 'm' character in scanf,
2324    and, before C99, 'a' (for compatibility with a non-standard
2325    GNU libc extension).  */
2326
2327 void
2328 argument_parser::handle_alloc_chars ()
2329 {
2330   if (fki->alloc_char && fki->alloc_char == *format_chars)
2331     {
2332       flag_chars.add_char (fki->alloc_char);
2333       format_chars++;
2334     }
2335
2336   /* Handle the scanf allocation kludge.  */
2337   if (fki->flags & (int) FMT_FLAG_SCANF_A_KLUDGE)
2338     {
2339       if (*format_chars == 'a' && !flag_isoc99)
2340         {
2341           if (format_chars[1] == 's' || format_chars[1] == 'S'
2342               || format_chars[1] == '[')
2343             {
2344               /* 'a' is used as a flag.  */
2345               flag_chars.add_char ('a');
2346               format_chars++;
2347             }
2348         }
2349     }
2350 }
2351
2352 /* Look for length modifiers within the current format argument,
2353    returning a length_modifier instance describing it (or the
2354    default if one is not found).
2355
2356    Issue warnings about non-standard modifiers.  */
2357
2358 length_modifier
2359 argument_parser::read_any_length_modifier ()
2360 {
2361   length_modifier result;
2362
2363   const format_length_info *fli = fki->length_char_specs;
2364   if (!fli)
2365     return result;
2366
2367   while (fli->name != 0
2368          && strncmp (fli->name, format_chars, strlen (fli->name)))
2369     fli++;
2370   if (fli->name != 0)
2371     {
2372       format_chars += strlen (fli->name);
2373       if (fli->double_name != 0 && fli->name[0] == *format_chars)
2374         {
2375           format_chars++;
2376           result = length_modifier (fli->double_name, fli->double_index,
2377                                     fli->double_std, 0);
2378         }
2379       else
2380         {
2381           result = length_modifier (fli->name, fli->index, fli->std,
2382                                     fli->scalar_identity_flag);
2383         }
2384       flag_chars.add_char (fki->length_code_char);
2385     }
2386   if (pedantic)
2387     {
2388       /* Warn if the length modifier is non-standard.  */
2389       if (ADJ_STD (result.std) > C_STD_VER)
2390         warning_at (format_string_loc, OPT_Wformat_,
2391                     "%s does not support the %qs %s length modifier",
2392                     C_STD_NAME (result.std), result.chars,
2393                     fki->name);
2394     }
2395
2396   return result;
2397 }
2398
2399 /* Read any other modifier (strftime E/O).  */
2400
2401 void
2402 argument_parser::read_any_other_modifier ()
2403 {
2404   if (fki->modifier_chars == NULL)
2405     return;
2406
2407   while (*format_chars != 0
2408          && strchr (fki->modifier_chars, *format_chars) != 0)
2409     {
2410       if (flag_chars.has_char_p (*format_chars))
2411         {
2412           const format_flag_spec *s = get_flag_spec (flag_specs,
2413                                                      *format_chars, NULL);
2414           format_warning_at_char (format_string_loc, format_string_cst,
2415                                   format_chars - orig_format_chars,
2416                                   OPT_Wformat_,
2417                                   "repeated %s in format", _(s->name));
2418         }
2419       else
2420         flag_chars.add_char (*format_chars);
2421       ++format_chars;
2422     }
2423 }
2424
2425 /* Return the format_char_info corresponding to FORMAT_CHAR,
2426    potentially issuing a warning if the format char is
2427    not supported in the C standard version we are checking
2428    against.
2429
2430    Issue a warning and return NULL if it is not found.
2431
2432    Issue warnings about non-standard modifiers.  */
2433
2434 const format_char_info *
2435 argument_parser::find_format_char_info (char format_char)
2436 {
2437   const format_char_info *fci = fki->conversion_specs;
2438
2439   while (fci->format_chars != 0
2440          && strchr (fci->format_chars, format_char) == 0)
2441     ++fci;
2442   if (fci->format_chars == 0)
2443     {
2444       format_warning_at_char (format_string_loc, format_string_cst,
2445                               format_chars - orig_format_chars,
2446                               OPT_Wformat_,
2447                               "unknown conversion type character"
2448                               " %qc in format",
2449                               format_char);
2450       return NULL;
2451     }
2452
2453   if (pedantic)
2454     {
2455       if (ADJ_STD (fci->std) > C_STD_VER)
2456         format_warning_at_char (format_string_loc, format_string_cst,
2457                                 format_chars - orig_format_chars,
2458                                 OPT_Wformat_,
2459                                 "%s does not support the %<%%%c%> %s format",
2460                                 C_STD_NAME (fci->std), format_char, fki->name);
2461     }
2462
2463   return fci;
2464 }
2465
2466 /* Validate the pairs of flags used.
2467    Issue warnings about incompatible combinations of flags.  */
2468
2469 void
2470 argument_parser::validate_flag_pairs (const format_char_info *fci,
2471                                       char format_char)
2472 {
2473   const format_flag_pair * const bad_flag_pairs = fki->bad_flag_pairs;
2474
2475   for (int i = 0; bad_flag_pairs[i].flag_char1 != 0; i++)
2476     {
2477       const format_flag_spec *s, *t;
2478       if (!flag_chars.has_char_p (bad_flag_pairs[i].flag_char1))
2479         continue;
2480       if (!flag_chars.has_char_p (bad_flag_pairs[i].flag_char2))
2481         continue;
2482       if (bad_flag_pairs[i].predicate != 0
2483           && strchr (fci->flags2, bad_flag_pairs[i].predicate) == 0)
2484         continue;
2485       s = get_flag_spec (flag_specs, bad_flag_pairs[i].flag_char1, NULL);
2486       t = get_flag_spec (flag_specs, bad_flag_pairs[i].flag_char2, NULL);
2487       if (bad_flag_pairs[i].ignored)
2488         {
2489           if (bad_flag_pairs[i].predicate != 0)
2490             warning_at (format_string_loc, OPT_Wformat_,
2491                         "%s ignored with %s and %<%%%c%> %s format",
2492                         _(s->name), _(t->name), format_char,
2493                         fki->name);
2494           else
2495             warning_at (format_string_loc, OPT_Wformat_,
2496                         "%s ignored with %s in %s format",
2497                         _(s->name), _(t->name), fki->name);
2498         }
2499       else
2500         {
2501           if (bad_flag_pairs[i].predicate != 0)
2502             warning_at (format_string_loc, OPT_Wformat_,
2503                         "use of %s and %s together with %<%%%c%> %s format",
2504                         _(s->name), _(t->name), format_char,
2505                         fki->name);
2506           else
2507             warning_at (format_string_loc, OPT_Wformat_,
2508                         "use of %s and %s together in %s format",
2509                         _(s->name), _(t->name), fki->name);
2510         }
2511     }
2512 }
2513
2514 /* Give Y2K warnings.  */
2515
2516 void
2517 argument_parser::give_y2k_warnings (const format_char_info *fci,
2518                                     char format_char)
2519 {
2520   if (!warn_format_y2k)
2521     return;
2522
2523   int y2k_level = 0;
2524   if (strchr (fci->flags2, '4') != 0)
2525     if (flag_chars.has_char_p ('E'))
2526       y2k_level = 3;
2527     else
2528       y2k_level = 2;
2529   else if (strchr (fci->flags2, '3') != 0)
2530     y2k_level = 3;
2531   else if (strchr (fci->flags2, '2') != 0)
2532     y2k_level = 2;
2533   if (y2k_level == 3)
2534     warning_at (format_string_loc, OPT_Wformat_y2k,
2535                 "%<%%%c%> yields only last 2 digits of "
2536                 "year in some locales", format_char);
2537   else if (y2k_level == 2)
2538     warning_at (format_string_loc, OPT_Wformat_y2k,
2539                 "%<%%%c%> yields only last 2 digits of year",
2540                 format_char);
2541 }
2542
2543 /* Parse any "scan sets" enclosed in square brackets, e.g.
2544    for scanf-style calls.  */
2545
2546 void
2547 argument_parser::parse_any_scan_set (const format_char_info *fci)
2548 {
2549   if (strchr (fci->flags2, '[') == NULL)
2550     return;
2551
2552   /* Skip over scan set, in case it happens to have '%' in it.  */
2553   if (*format_chars == '^')
2554     ++format_chars;
2555   /* Find closing bracket; if one is hit immediately, then
2556      it's part of the scan set rather than a terminator.  */
2557   if (*format_chars == ']')
2558     ++format_chars;
2559   while (*format_chars && *format_chars != ']')
2560     ++format_chars;
2561   if (*format_chars != ']')
2562     /* The end of the format string was reached.  */
2563     format_warning_at_char (format_string_loc, format_string_cst,
2564                             format_chars - orig_format_chars,
2565                             OPT_Wformat_,
2566                             "no closing %<]%> for %<%%[%> format");
2567 }
2568
2569 /* Return true if this argument is to be continued to be parsed,
2570    false to skip to next argument.  */
2571
2572 bool
2573 argument_parser::handle_conversions (const format_char_info *fci,
2574                                      const length_modifier &len_modifier,
2575                                      tree &wanted_type,
2576                                      const char *&wanted_type_name,
2577                                      unsigned HOST_WIDE_INT &arg_num,
2578                                      tree &params,
2579                                      char format_char)
2580 {
2581   enum format_std_version wanted_type_std;
2582
2583   if (!(fki->flags & (int) FMT_FLAG_ARG_CONVERT))
2584     return true;
2585
2586   wanted_type = (fci->types[len_modifier.val].type
2587                  ? *fci->types[len_modifier.val].type : 0);
2588   wanted_type_name = fci->types[len_modifier.val].name;
2589   wanted_type_std = fci->types[len_modifier.val].std;
2590   if (wanted_type == 0)
2591     {
2592       format_warning_at_char (format_string_loc, format_string_cst,
2593                               format_chars - orig_format_chars,
2594                               OPT_Wformat_,
2595                               "use of %qs length modifier with %qc type"
2596                               " character has either no effect"
2597                               " or undefined behavior",
2598                               len_modifier.chars, format_char);
2599       /* Heuristic: skip one argument when an invalid length/type
2600          combination is encountered.  */
2601       arg_num++;
2602       if (params != 0)
2603         params = TREE_CHAIN (params);
2604       return false;
2605     }
2606   else if (pedantic
2607            /* Warn if non-standard, provided it is more non-standard
2608               than the length and type characters that may already
2609               have been warned for.  */
2610            && ADJ_STD (wanted_type_std) > ADJ_STD (len_modifier.std)
2611            && ADJ_STD (wanted_type_std) > ADJ_STD (fci->std))
2612     {
2613       if (ADJ_STD (wanted_type_std) > C_STD_VER)
2614         format_warning_at_char (format_string_loc, format_string_cst,
2615                                 format_chars - orig_format_chars,
2616                                 OPT_Wformat_,
2617                                 "%s does not support the %<%%%s%c%> %s format",
2618                                 C_STD_NAME (wanted_type_std),
2619                                 len_modifier.chars,
2620                                 format_char, fki->name);
2621     }
2622
2623   return true;
2624 }
2625
2626 /* Check type of argument against desired type.
2627
2628    Return true if format parsing is to continue, false otherwise.  */
2629
2630 bool
2631 argument_parser::
2632 check_argument_type (const format_char_info *fci,
2633                      const length_modifier &len_modifier,
2634                      tree &wanted_type,
2635                      const char *&wanted_type_name,
2636                      const bool suppressed,
2637                      unsigned HOST_WIDE_INT &arg_num,
2638                      tree &params,
2639                      const int alloc_flag,
2640                      const char * const format_start,
2641                      const char * const type_start,
2642                      location_t fmt_param_loc,
2643                      char conversion_char)
2644 {
2645   if (info->first_arg_num == 0)
2646     return true;
2647
2648   if ((fci->pointer_count == 0 && wanted_type == void_type_node)
2649       || suppressed)
2650     {
2651       if (main_arg_num != 0)
2652         {
2653           if (suppressed)
2654             warning_at (format_string_loc, OPT_Wformat_,
2655                         "operand number specified with "
2656                         "suppressed assignment");
2657           else
2658             warning_at (format_string_loc, OPT_Wformat_,
2659                         "operand number specified for format "
2660                         "taking no argument");
2661         }
2662     }
2663   else
2664     {
2665       format_wanted_type *wanted_type_ptr;
2666
2667       if (main_arg_num != 0)
2668         {
2669           arg_num = main_arg_num;
2670           params = main_arg_params;
2671         }
2672       else
2673         {
2674           ++arg_num;
2675           if (has_operand_number > 0)
2676             {
2677               warning_at (format_string_loc, OPT_Wformat_,
2678                           "missing $ operand number in format");
2679               return false;
2680             }
2681           else
2682             has_operand_number = 0;
2683         }
2684
2685       wanted_type_ptr = &main_wanted_type;
2686       while (fci)
2687         {
2688           tree cur_param;
2689           if (params == 0)
2690             cur_param = NULL;
2691           else
2692             {
2693               cur_param = TREE_VALUE (params);
2694               params = TREE_CHAIN (params);
2695             }
2696
2697           wanted_type_ptr->wanted_type = wanted_type;
2698           wanted_type_ptr->wanted_type_name = wanted_type_name;
2699           wanted_type_ptr->pointer_count = fci->pointer_count + alloc_flag;
2700           wanted_type_ptr->char_lenient_flag = 0;
2701           if (strchr (fci->flags2, 'c') != 0)
2702             wanted_type_ptr->char_lenient_flag = 1;
2703           wanted_type_ptr->scalar_identity_flag = 0;
2704           if (len_modifier.scalar_identity_flag)
2705             wanted_type_ptr->scalar_identity_flag = 1;
2706           wanted_type_ptr->writing_in_flag = 0;
2707           wanted_type_ptr->reading_from_flag = 0;
2708           if (alloc_flag)
2709             wanted_type_ptr->writing_in_flag = 1;
2710           else
2711             {
2712               if (strchr (fci->flags2, 'W') != 0)
2713                 wanted_type_ptr->writing_in_flag = 1;
2714               if (strchr (fci->flags2, 'R') != 0)
2715                 wanted_type_ptr->reading_from_flag = 1;
2716             }
2717           wanted_type_ptr->kind = CF_KIND_FORMAT;
2718           wanted_type_ptr->param = cur_param;
2719           wanted_type_ptr->arg_num = arg_num;
2720           wanted_type_ptr->format_start = format_start;
2721           wanted_type_ptr->format_length = format_chars - format_start;
2722           wanted_type_ptr->offset_loc = format_chars - orig_format_chars;
2723           wanted_type_ptr->next = NULL;
2724           if (last_wanted_type != 0)
2725             last_wanted_type->next = wanted_type_ptr;
2726           if (first_wanted_type == 0)
2727             first_wanted_type = wanted_type_ptr;
2728           last_wanted_type = wanted_type_ptr;
2729
2730           fci = fci->chain;
2731           if (fci)
2732             {
2733               wanted_type_ptr = fwt_pool.allocate ();
2734               arg_num++;
2735               wanted_type = *fci->types[len_modifier.val].type;
2736               wanted_type_name = fci->types[len_modifier.val].name;
2737             }
2738         }
2739     }
2740
2741   if (first_wanted_type != 0)
2742     {
2743       ptrdiff_t offset_to_format_start = (start_of_this_format - 1) - orig_format_chars;
2744       ptrdiff_t offset_to_format_end = (format_chars - 1) - orig_format_chars;
2745       /* By default, use the end of the range for the caret location.  */
2746       substring_loc fmt_loc (fmt_param_loc, TREE_TYPE (format_string_cst),
2747                              offset_to_format_end,
2748                              offset_to_format_start, offset_to_format_end);
2749       ptrdiff_t offset_to_type_start = type_start - orig_format_chars;
2750       check_format_types (fmt_loc, first_wanted_type, fki,
2751                           offset_to_type_start,
2752                           conversion_char, arglocs);
2753     }
2754
2755   return true;
2756 }
2757
2758 /* Do the main part of checking a call to a format function.  FORMAT_CHARS
2759    is the NUL-terminated format string (which at this point may contain
2760    internal NUL characters); FORMAT_LENGTH is its length (excluding the
2761    terminating NUL character).  ARG_NUM is one less than the number of
2762    the first format argument to check; PARAMS points to that format
2763    argument in the list of arguments.  */
2764
2765 static void
2766 check_format_info_main (format_check_results *res,
2767                         function_format_info *info, const char *format_chars,
2768                         location_t fmt_param_loc, tree format_string_cst,
2769                         int format_length, tree params,
2770                         unsigned HOST_WIDE_INT arg_num,
2771                         object_allocator <format_wanted_type> &fwt_pool,
2772                         vec<location_t> *arglocs)
2773 {
2774   const char * const orig_format_chars = format_chars;
2775   const tree first_fillin_param = params;
2776
2777   const format_kind_info * const fki = &format_types[info->format_type];
2778   const format_flag_spec * const flag_specs = fki->flag_specs;
2779   const location_t format_string_loc = res->format_string_loc;
2780
2781   /* -1 if no conversions taking an operand have been found; 0 if one has
2782      and it didn't use $; 1 if $ formats are in use.  */
2783   int has_operand_number = -1;
2784
2785   /* Vector of pointers to opening quoting directives (like GCC "%<").  */
2786   auto_vec<const char*> quotdirs;
2787
2788   /* Pointers to the most recent color directives (like GCC's "%r or %R").
2789      A starting color directive much be terminated before the end of
2790      the format string.  A terminating directive makes no sense without
2791      a prior starting directive.  */
2792   const char *color_begin = NULL;
2793   const char *color_end = NULL;
2794
2795   init_dollar_format_checking (info->first_arg_num, first_fillin_param);
2796
2797   while (*format_chars != 0)
2798     {
2799       if (*format_chars++ != '%')
2800         continue;
2801       if (*format_chars == 0)
2802         {
2803           format_warning_at_char (format_string_loc, format_string_cst,
2804                                   format_chars - orig_format_chars,
2805                                   OPT_Wformat_,
2806                                   "spurious trailing %<%%%> in format");
2807           continue;
2808         }
2809       if (*format_chars == '%')
2810         {
2811           ++format_chars;
2812           continue;
2813         }
2814
2815       flag_chars_t flag_chars;
2816       argument_parser arg_parser (info, format_chars, format_string_cst,
2817                                   orig_format_chars, format_string_loc,
2818                                   flag_chars, has_operand_number,
2819                                   first_fillin_param, fwt_pool, arglocs);
2820
2821       if (!arg_parser.read_any_dollar ())
2822         return;
2823
2824       if (!arg_parser.read_format_flags ())
2825         return;
2826
2827       /* Read any format width, possibly * or *m$.  */
2828       if (!arg_parser.read_any_format_width (params, arg_num))
2829         return;
2830
2831       /* Read any format left precision (must be a number, not *).  */
2832       arg_parser.read_any_format_left_precision ();
2833
2834       /* Read any format precision, possibly * or *m$.  */
2835       if (!arg_parser.read_any_format_precision (params, arg_num))
2836         return;
2837
2838       const char *format_start = format_chars;
2839
2840       arg_parser.handle_alloc_chars ();
2841
2842       /* The rest of the conversion specification is the length modifier
2843          (if any), and the conversion specifier, so this is where the
2844          type information starts.  If we need to issue a suggestion
2845          about a type mismatch, then we should preserve everything up
2846          to here. */
2847       const char *type_start = format_chars;
2848
2849       /* Read any length modifier, if this kind of format has them.  */
2850       const length_modifier len_modifier
2851         = arg_parser.read_any_length_modifier ();
2852
2853       /* Read any modifier (strftime E/O).  */
2854       arg_parser.read_any_other_modifier ();
2855
2856       char format_char = *format_chars;
2857       if (format_char == 0
2858           || (!(fki->flags & (int) FMT_FLAG_FANCY_PERCENT_OK)
2859               && format_char == '%'))
2860         {
2861           format_warning_at_char (format_string_loc, format_string_cst,
2862                              format_chars - orig_format_chars,
2863                              OPT_Wformat_,
2864                              "conversion lacks type at end of format");
2865           continue;
2866         }
2867       format_chars++;
2868
2869       const format_char_info * const fci
2870         = arg_parser.find_format_char_info (format_char);
2871       if (!fci)
2872         continue;
2873
2874       flag_chars.validate (fki, fci, flag_specs, format_chars,
2875                            format_string_cst,
2876                            format_string_loc, orig_format_chars, format_char,
2877                            quotdirs.length () > 0);
2878
2879       const int alloc_flag = flag_chars.get_alloc_flag (fki);
2880       const bool suppressed = flag_chars.assignment_suppression_p (fki);
2881
2882       /* Diagnose nested or unmatched quoting directives such as GCC's
2883          "%<...%<" and "%>...%>".  */
2884       bool quot_begin_p = strchr (fci->flags2, '<');
2885       bool quot_end_p = strchr (fci->flags2, '>');
2886
2887       if (quot_begin_p && !quot_end_p)
2888         {
2889           if (quotdirs.length ())
2890             format_warning_at_char (format_string_loc, format_string_cst,
2891                                     format_chars - orig_format_chars,
2892                                     OPT_Wformat_,
2893                                     "nested quoting directive");
2894           quotdirs.safe_push (format_chars);
2895         }
2896       else if (!quot_begin_p && quot_end_p)
2897         {
2898           if (quotdirs.length ())
2899             quotdirs.pop ();
2900           else
2901             format_warning_at_char (format_string_loc, format_string_cst,
2902                                     format_chars - orig_format_chars,
2903                                     OPT_Wformat_,
2904                                     "unmatched quoting directive");
2905         }
2906
2907       bool color_begin_p = strchr (fci->flags2, '/');
2908       if (color_begin_p)
2909         {
2910           color_begin = format_chars;
2911           color_end = NULL;
2912         }
2913       else if (strchr (fci->flags2, '\\'))
2914         {
2915           if (color_end)
2916             format_warning_at_char (format_string_loc, format_string_cst,
2917                                     format_chars - orig_format_chars,
2918                                     OPT_Wformat_,
2919                                     "%qc directive redundant after prior "
2920                                     "occurence of the same", format_char);
2921           else if (!color_begin)
2922             format_warning_at_char (format_string_loc, format_string_cst,
2923                                     format_chars - orig_format_chars,
2924                                     OPT_Wformat_,
2925                                     "unmatched color reset directive");
2926           color_end = format_chars;
2927         }
2928
2929       /* Diagnose directives that shouldn't appear in a quoted sequence.
2930          (They are denoted by a double quote in FLAGS2.)  */
2931       if (quotdirs.length ())
2932         {
2933           if (strchr (fci->flags2, '"'))
2934             format_warning_at_char (format_string_loc, format_string_cst,
2935                                     format_chars - orig_format_chars,
2936                                     OPT_Wformat_,
2937                                     "%qc conversion used within a quoted "
2938                                     "sequence",
2939                                     format_char);
2940         }
2941
2942       /* Validate the pairs of flags used.  */
2943       arg_parser.validate_flag_pairs (fci, format_char);
2944
2945       arg_parser.give_y2k_warnings (fci, format_char);
2946
2947       arg_parser.parse_any_scan_set (fci);
2948
2949       tree wanted_type = NULL;
2950       const char *wanted_type_name = NULL;
2951
2952       if (!arg_parser.handle_conversions (fci, len_modifier,
2953                                           wanted_type, wanted_type_name,
2954                                           arg_num,
2955                                           params,
2956                                           format_char))
2957         continue;
2958
2959       arg_parser.main_wanted_type.next = NULL;
2960
2961       /* Finally. . .check type of argument against desired type!  */
2962       if (!arg_parser.check_argument_type (fci, len_modifier,
2963                                            wanted_type, wanted_type_name,
2964                                            suppressed,
2965                                            arg_num, params,
2966                                            alloc_flag,
2967                                            format_start, type_start,
2968                                            fmt_param_loc,
2969                                            format_char))
2970         return;
2971     }
2972
2973   if (format_chars - orig_format_chars != format_length)
2974     format_warning_at_char (format_string_loc, format_string_cst,
2975                             format_chars + 1 - orig_format_chars,
2976                             OPT_Wformat_contains_nul,
2977                             "embedded %<\\0%> in format");
2978   if (info->first_arg_num != 0 && params != 0
2979       && has_operand_number <= 0)
2980     {
2981       res->number_other--;
2982       res->number_extra_args++;
2983     }
2984   if (has_operand_number > 0)
2985     finish_dollar_format_checking (res, fki->flags & (int) FMT_FLAG_DOLLAR_GAP_POINTER_OK);
2986
2987   if (quotdirs.length ())
2988     format_warning_at_char (format_string_loc, format_string_cst,
2989                             quotdirs.pop () - orig_format_chars,
2990                             OPT_Wformat_, "unterminated quoting directive");
2991   if (color_begin && !color_end)
2992     format_warning_at_char (format_string_loc, format_string_cst,
2993                             color_begin - orig_format_chars,
2994                             OPT_Wformat_, "unterminated color directive");
2995 }
2996
2997 /* Check the argument types from a single format conversion (possibly
2998    including width and precision arguments).
2999
3000    FMT_LOC is the location of the format conversion.
3001
3002    TYPES is a singly-linked list expressing the parts of the format
3003    conversion that expect argument types, and the arguments they
3004    correspond to.
3005
3006    OFFSET_TO_TYPE_START is the offset within the execution-charset encoded
3007    format string to where type information begins for the conversion
3008    (the length modifier and conversion specifier).
3009
3010    CONVERSION_CHAR is the user-provided conversion specifier.
3011
3012    For example, given:
3013
3014      sprintf (d, "before %-+*.*lld after", arg3, arg4, arg5);
3015
3016    then FMT_LOC covers this range:
3017
3018      sprintf (d, "before %-+*.*lld after", arg3, arg4, arg5);
3019                          ^^^^^^^^^
3020
3021    and TYPES in this case is a three-entry singly-linked list consisting of:
3022    (1) the check for the field width here:
3023          sprintf (d, "before %-+*.*lld after", arg3, arg4, arg5);
3024                                 ^              ^^^^
3025        against arg3, and
3026    (2) the check for the field precision here:
3027          sprintf (d, "before %-+*.*lld after", arg3, arg4, arg5);
3028                                  ^^                  ^^^^
3029        against arg4, and
3030    (3) the check for the length modifier and conversion char here:
3031          sprintf (d, "before %-+*.*lld after", arg3, arg4, arg5);
3032                                    ^^^                     ^^^^
3033        against arg5.
3034
3035    OFFSET_TO_TYPE_START is 13, the offset to the "lld" within the
3036    STRING_CST:
3037
3038                   0000000000111111111122
3039                   0123456789012345678901
3040      sprintf (d, "before %-+*.*lld after", arg3, arg4, arg5);
3041                                ^ ^
3042                                | ` CONVERSION_CHAR: 'd'
3043                                type starts here.  */
3044
3045 static void
3046 check_format_types (const substring_loc &fmt_loc,
3047                     format_wanted_type *types, const format_kind_info *fki,
3048                     int offset_to_type_start,
3049                     char conversion_char,
3050                     vec<location_t> *arglocs)
3051 {
3052   for (; types != 0; types = types->next)
3053     {
3054       tree cur_param;
3055       tree cur_type;
3056       tree orig_cur_type;
3057       tree wanted_type;
3058       int arg_num;
3059       int i;
3060       int char_type_flag;
3061
3062       wanted_type = types->wanted_type;
3063       arg_num = types->arg_num;
3064
3065       /* The following should not occur here.  */
3066       gcc_assert (wanted_type);
3067       gcc_assert (wanted_type != void_type_node || types->pointer_count);
3068
3069       if (types->pointer_count == 0)
3070         wanted_type = lang_hooks.types.type_promotes_to (wanted_type);
3071
3072       wanted_type = TYPE_MAIN_VARIANT (wanted_type);
3073
3074       cur_param = types->param;
3075       if (!cur_param)
3076         {
3077           format_type_warning (fmt_loc, UNKNOWN_LOCATION, types, wanted_type,
3078                                NULL, fki, offset_to_type_start,
3079                                conversion_char);
3080           continue;
3081         }
3082
3083       cur_type = TREE_TYPE (cur_param);
3084       if (cur_type == error_mark_node)
3085         continue;
3086       orig_cur_type = cur_type;
3087       char_type_flag = 0;
3088
3089       location_t param_loc = UNKNOWN_LOCATION;
3090       if (EXPR_HAS_LOCATION (cur_param))
3091         param_loc = EXPR_LOCATION (cur_param);
3092       else if (arglocs)
3093         {
3094           /* arg_num is 1-based.  */
3095           gcc_assert (types->arg_num > 0);
3096           param_loc = (*arglocs)[types->arg_num - 1];
3097         }
3098
3099       STRIP_NOPS (cur_param);
3100
3101       /* Check the types of any additional pointer arguments
3102          that precede the "real" argument.  */
3103       for (i = 0; i < types->pointer_count; ++i)
3104         {
3105           if (TREE_CODE (cur_type) == POINTER_TYPE)
3106             {
3107               cur_type = TREE_TYPE (cur_type);
3108               if (cur_type == error_mark_node)
3109                 break;
3110
3111               /* Check for writing through a NULL pointer.  */
3112               if (types->writing_in_flag
3113                   && i == 0
3114                   && cur_param != 0
3115                   && integer_zerop (cur_param))
3116                 warning (OPT_Wformat_, "writing through null pointer "
3117                          "(argument %d)", arg_num);
3118
3119               /* Check for reading through a NULL pointer.  */
3120               if (types->reading_from_flag
3121                   && i == 0
3122                   && cur_param != 0
3123                   && integer_zerop (cur_param))
3124                 warning (OPT_Wformat_, "reading through null pointer "
3125                          "(argument %d)", arg_num);
3126
3127               if (cur_param != 0 && TREE_CODE (cur_param) == ADDR_EXPR)
3128                 cur_param = TREE_OPERAND (cur_param, 0);
3129               else
3130                 cur_param = 0;
3131
3132               /* See if this is an attempt to write into a const type with
3133                  scanf or with printf "%n".  Note: the writing in happens
3134                  at the first indirection only, if for example
3135                  void * const * is passed to scanf %p; passing
3136                  const void ** is simply passing an incompatible type.  */
3137               if (types->writing_in_flag
3138                   && i == 0
3139                   && (TYPE_READONLY (cur_type)
3140                       || (cur_param != 0
3141                           && (CONSTANT_CLASS_P (cur_param)
3142                               || (DECL_P (cur_param)
3143                                   && TREE_READONLY (cur_param))))))
3144                 warning (OPT_Wformat_, "writing into constant object "
3145                          "(argument %d)", arg_num);
3146
3147               /* If there are extra type qualifiers beyond the first
3148                  indirection, then this makes the types technically
3149                  incompatible.  */
3150               if (i > 0
3151                   && pedantic
3152                   && (TYPE_READONLY (cur_type)
3153                       || TYPE_VOLATILE (cur_type)
3154                       || TYPE_ATOMIC (cur_type)
3155                       || TYPE_RESTRICT (cur_type)))
3156                 warning (OPT_Wformat_, "extra type qualifiers in format "
3157                          "argument (argument %d)",
3158                          arg_num);
3159
3160             }
3161           else
3162             {
3163               format_type_warning (fmt_loc, param_loc,
3164                                    types, wanted_type, orig_cur_type, fki,
3165                                    offset_to_type_start, conversion_char);
3166               break;
3167             }
3168         }
3169
3170       if (i < types->pointer_count)
3171         continue;
3172
3173       cur_type = TYPE_MAIN_VARIANT (cur_type);
3174
3175       /* Check whether the argument type is a character type.  This leniency
3176          only applies to certain formats, flagged with 'c'.  */
3177       if (types->char_lenient_flag)
3178         char_type_flag = (cur_type == char_type_node
3179                           || cur_type == signed_char_type_node
3180                           || cur_type == unsigned_char_type_node);
3181
3182       /* Check the type of the "real" argument, if there's a type we want.  */
3183       if (lang_hooks.types_compatible_p (wanted_type, cur_type))
3184         continue;
3185       /* If we want 'void *', allow any pointer type.
3186          (Anything else would already have got a warning.)
3187          With -Wpedantic, only allow pointers to void and to character
3188          types.  */
3189       if (wanted_type == void_type_node
3190           && (!pedantic || (i == 1 && char_type_flag)))
3191         continue;
3192       /* Don't warn about differences merely in signedness, unless
3193          -Wpedantic.  With -Wpedantic, warn if the type is a pointer
3194          target and not a character type, and for character types at
3195          a second level of indirection.  */
3196       if (TREE_CODE (wanted_type) == INTEGER_TYPE
3197           && TREE_CODE (cur_type) == INTEGER_TYPE
3198           && ((!pedantic && !warn_format_signedness)
3199               || (i == 0 && !warn_format_signedness)
3200               || (i == 1 && char_type_flag))
3201           && (TYPE_UNSIGNED (wanted_type)
3202               ? wanted_type == c_common_unsigned_type (cur_type)
3203               : wanted_type == c_common_signed_type (cur_type)))
3204         continue;
3205       /* Don't warn about differences merely in signedness if we know
3206          that the current type is integer-promoted and its original type
3207          was unsigned such as that it is in the range of WANTED_TYPE.  */
3208       if (TREE_CODE (wanted_type) == INTEGER_TYPE
3209           && TREE_CODE (cur_type) == INTEGER_TYPE
3210           && warn_format_signedness
3211           && TYPE_UNSIGNED (wanted_type)
3212           && cur_param != NULL_TREE
3213           && TREE_CODE (cur_param) == NOP_EXPR)
3214         {
3215           tree t = TREE_TYPE (TREE_OPERAND (cur_param, 0));
3216           if (TYPE_UNSIGNED (t)
3217               && cur_type == lang_hooks.types.type_promotes_to (t))
3218             continue;
3219         }
3220       /* Likewise, "signed char", "unsigned char" and "char" are
3221          equivalent but the above test won't consider them equivalent.  */
3222       if (wanted_type == char_type_node
3223           && (!pedantic || i < 2)
3224           && char_type_flag)
3225         continue;
3226       if (types->scalar_identity_flag
3227           && (TREE_CODE (cur_type) == TREE_CODE (wanted_type)
3228               || (INTEGRAL_TYPE_P (cur_type)
3229                   && INTEGRAL_TYPE_P (wanted_type)))
3230           && TYPE_PRECISION (cur_type) == TYPE_PRECISION (wanted_type))
3231         continue;
3232       /* Now we have a type mismatch.  */
3233       format_type_warning (fmt_loc, param_loc, types,
3234                            wanted_type, orig_cur_type, fki,
3235                            offset_to_type_start, conversion_char);
3236     }
3237 }
3238
3239 /* Given type TYPE, attempt to dereference the type N times
3240    (e.g. from ("int ***", 2) to "int *")
3241
3242    Return the derefenced type, with any qualifiers
3243    such as "const" stripped from the result, or
3244    NULL if unsuccessful (e.g. TYPE is not a pointer type).  */
3245
3246 static tree
3247 deref_n_times (tree type, int n)
3248 {
3249   gcc_assert (type);
3250
3251   for (int i = n; i > 0; i--)
3252     {
3253       if (TREE_CODE (type) != POINTER_TYPE)
3254         return NULL_TREE;
3255       type = TREE_TYPE (type);
3256     }
3257   /* Strip off any "const" etc.  */
3258   return build_qualified_type (type, 0);
3259 }
3260
3261 /* Lookup the format code for FORMAT_LEN within FLI,
3262    returning the string code for expressing it, or NULL
3263    if it is not found.  */
3264
3265 static const char *
3266 get_modifier_for_format_len (const format_length_info *fli,
3267                              enum format_lengths format_len)
3268 {
3269   for (; fli->name; fli++)
3270     {
3271       if (fli->index == format_len)
3272         return fli->name;
3273       if (fli->double_index == format_len)
3274         return fli->double_name;
3275     }
3276   return NULL;
3277 }
3278
3279 #if CHECKING_P
3280
3281 namespace selftest {
3282
3283 static void
3284 test_get_modifier_for_format_len ()
3285 {
3286   ASSERT_STREQ ("h",
3287                 get_modifier_for_format_len (printf_length_specs, FMT_LEN_h));
3288   ASSERT_STREQ ("hh",
3289                 get_modifier_for_format_len (printf_length_specs, FMT_LEN_hh));
3290   ASSERT_STREQ ("L",
3291                 get_modifier_for_format_len (printf_length_specs, FMT_LEN_L));
3292   ASSERT_EQ (NULL,
3293              get_modifier_for_format_len (printf_length_specs, FMT_LEN_none));
3294 }
3295
3296 } // namespace selftest
3297
3298 #endif /* CHECKING_P */
3299
3300 /* Determine if SPEC_TYPE and ARG_TYPE are sufficiently similar for a
3301    format_type_detail using SPEC_TYPE to be offered as a suggestion for
3302    Wformat type errors where the argument has type ARG_TYPE.  */
3303
3304 static bool
3305 matching_type_p (tree spec_type, tree arg_type)
3306 {
3307   gcc_assert (spec_type);
3308   gcc_assert (arg_type);
3309
3310   /* If any of the types requires structural equality, we can't compare
3311      their canonical types.  */
3312   if (TYPE_STRUCTURAL_EQUALITY_P (spec_type)
3313       || TYPE_STRUCTURAL_EQUALITY_P (arg_type))
3314     return false;
3315
3316   spec_type = TYPE_CANONICAL (spec_type);
3317   arg_type = TYPE_CANONICAL (arg_type);
3318
3319   if (TREE_CODE (spec_type) == INTEGER_TYPE
3320       && TREE_CODE (arg_type) == INTEGER_TYPE
3321       && (TYPE_UNSIGNED (spec_type)
3322           ? spec_type == c_common_unsigned_type (arg_type)
3323           : spec_type == c_common_signed_type (arg_type)))
3324     return true;
3325
3326   return spec_type == arg_type;
3327 }
3328
3329 /* Subroutine of get_format_for_type.
3330
3331    Generate a string containing the length modifier and conversion specifier
3332    that should be used to format arguments of type ARG_TYPE within FKI
3333    (effectively the inverse of the checking code).
3334
3335    If CONVERSION_CHAR is not zero (the first pass), the resulting suggestion
3336    is required to use it, for correcting bogus length modifiers.
3337    If CONVERSION_CHAR is zero (the second pass), then allow any suggestion
3338    that matches ARG_TYPE.
3339
3340    If successful, returns a non-NULL string which should be freed
3341    by the caller.
3342    Otherwise, returns NULL.  */
3343
3344 static char *
3345 get_format_for_type_1 (const format_kind_info *fki, tree arg_type,
3346                        char conversion_char)
3347 {
3348   gcc_assert (arg_type);
3349
3350   const format_char_info *spec;
3351   for (spec = &fki->conversion_specs[0];
3352        spec->format_chars;
3353        spec++)
3354     {
3355       if (conversion_char)
3356         if (!strchr (spec->format_chars, conversion_char))
3357           continue;
3358
3359       tree effective_arg_type = deref_n_times (arg_type,
3360                                                spec->pointer_count);
3361       if (!effective_arg_type)
3362         continue;
3363       for (int i = 0; i < FMT_LEN_MAX; i++)
3364         {
3365           const format_type_detail *ftd = &spec->types[i];
3366           if (!ftd->type)
3367             continue;
3368           if (matching_type_p (*ftd->type, effective_arg_type))
3369             {
3370               const char *len_modifier
3371                 = get_modifier_for_format_len (fki->length_char_specs,
3372                                                (enum format_lengths)i);
3373               if (!len_modifier)
3374                 len_modifier = "";
3375
3376               if (conversion_char)
3377                 /* We found a match, using the given conversion char - the
3378                    length modifier was incorrect (or absent).
3379                    Provide a suggestion using the conversion char with the
3380                    correct length modifier for the type.  */
3381                 return xasprintf ("%s%c", len_modifier, conversion_char);
3382               else
3383                 /* 2nd pass: no match was possible using the user-provided
3384                    conversion char, but we do have a match without using it.
3385                    Provide a suggestion using the first conversion char
3386                    listed for the given type.  */
3387                 return xasprintf ("%s%c", len_modifier, spec->format_chars[0]);
3388             }
3389         }
3390    }
3391
3392   return NULL;
3393 }
3394
3395 /* Generate a string containing the length modifier and conversion specifier
3396    that should be used to format arguments of type ARG_TYPE within FKI
3397    (effectively the inverse of the checking code).
3398
3399    If successful, returns a non-NULL string which should be freed
3400    by the caller.
3401    Otherwise, returns NULL.  */
3402
3403 static char *
3404 get_format_for_type (const format_kind_info *fki, tree arg_type,
3405                      char conversion_char)
3406 {
3407   gcc_assert (arg_type);
3408   gcc_assert (conversion_char);
3409
3410   /* First pass: look for a format_char_info containing CONVERSION_CHAR
3411      If we find one, then presumably the length modifier was incorrect
3412      (or absent).  */
3413   char *result = get_format_for_type_1 (fki, arg_type, conversion_char);
3414   if (result)
3415     return result;
3416
3417   /* Second pass: we didn't find a match for CONVERSION_CHAR, so try
3418      matching just on the type. */
3419   return get_format_for_type_1 (fki, arg_type, '\0');
3420 }
3421
3422 /* Attempt to get a string for use as a replacement fix-it hint for the
3423    source range in FMT_LOC.
3424
3425    Preserve all of the text within the range of FMT_LOC up to
3426    OFFSET_TO_TYPE_START, replacing the rest with an appropriate
3427    length modifier and conversion specifier for ARG_TYPE, attempting
3428    to keep the user-provided CONVERSION_CHAR if possible.
3429
3430    For example, given a long vs long long mismatch for arg5 here:
3431
3432     000000000111111111122222222223333333333|
3433     123456789012345678901234567890123456789` column numbers
3434                    0000000000111111111122|
3435                    0123456789012345678901` string offsets
3436                           V~~~~~~~~ : range of FMT_LOC, from cols 23-31
3437       sprintf (d, "before %-+*.*lld after", arg3, arg4, arg5);
3438                                 ^ ^
3439                                 | ` CONVERSION_CHAR: 'd'
3440                                 type starts here
3441
3442    where OFFSET_TO_TYPE_START is 13 (the offset to the "lld" within the
3443    STRING_CST), where the user provided:
3444      %-+*.*lld
3445    the result (assuming "long" argument 5) should be:
3446      %-+*.*ld
3447
3448    If successful, returns a non-NULL string which should be freed
3449    by the caller.
3450    Otherwise, returns NULL.  */
3451
3452 static char *
3453 get_corrected_substring (const substring_loc &fmt_loc,
3454                          format_wanted_type *type, tree arg_type,
3455                          const format_kind_info *fki,
3456                          int offset_to_type_start, char conversion_char)
3457 {
3458   /* Attempt to provide hints for argument types, but not for field widths
3459      and precisions.  */
3460   if (!arg_type)
3461     return NULL;
3462   if (type->kind != CF_KIND_FORMAT)
3463     return NULL;
3464
3465   /* Locate the current code within the source range, rejecting
3466      any awkward cases where the format string occupies more than
3467      one line.
3468      Lookup the place where the type starts (including any length
3469      modifiers), getting it as the caret location.  */
3470   substring_loc type_loc (fmt_loc);
3471   type_loc.set_caret_index (offset_to_type_start);
3472
3473   location_t fmt_substring_loc;
3474   const char *err = type_loc.get_location (&fmt_substring_loc);
3475   if (err)
3476     return NULL;
3477
3478   source_range fmt_substring_range
3479     = get_range_from_loc (line_table, fmt_substring_loc);
3480
3481   expanded_location caret
3482     = expand_location_to_spelling_point (fmt_substring_loc);
3483   expanded_location start
3484     = expand_location_to_spelling_point (fmt_substring_range.m_start);
3485   expanded_location finish
3486     = expand_location_to_spelling_point (fmt_substring_range.m_finish);
3487   if (caret.file != start.file)
3488     return NULL;
3489   if (start.file != finish.file)
3490     return NULL;
3491   if (caret.line != start.line)
3492     return NULL;
3493   if (start.line != finish.line)
3494     return NULL;
3495   if (start.column > caret.column)
3496     return NULL;
3497   if (start.column > finish.column)
3498     return NULL;
3499   if (caret.column > finish.column)
3500     return NULL;
3501
3502   int line_width;
3503   const char *line = location_get_source_line (start.file, start.line,
3504                                                &line_width);
3505   if (line == NULL)
3506     return NULL;
3507
3508   /* If we got this far, then we have the line containing the
3509      existing conversion specification.
3510
3511      Generate a trimmed copy, containing the prefix part of the conversion
3512      specification, up to the (but not including) the length modifier.
3513      In the above example, this would be "%-+*.*".  */
3514   const char *current_content = line + start.column - 1;
3515   int length_up_to_type = caret.column - start.column;
3516   char *prefix = xstrndup (current_content, length_up_to_type);
3517
3518   /* Now attempt to generate a suggestion for the rest of the specification
3519      (length modifier and conversion char), based on ARG_TYPE and
3520      CONVERSION_CHAR.
3521      In the above example, this would be "ld".  */
3522   char *format_for_type = get_format_for_type (fki, arg_type, conversion_char);
3523   if (!format_for_type)
3524     {
3525       free (prefix);
3526       return NULL;
3527     }
3528
3529   /* Success.  Generate the resulting suggestion for the whole range of
3530      FMT_LOC by concatenating the two strings.
3531      In the above example, this would be "%-+*.*ld".  */
3532   char *result = concat (prefix, format_for_type, NULL);
3533   free (format_for_type);
3534   free (prefix);
3535   return result;
3536 }
3537
3538 /* Give a warning about a format argument of different type from that expected.
3539    The range of the diagnostic is taken from WHOLE_FMT_LOC; the caret location
3540    is based on the location of the char at TYPE->offset_loc.
3541    PARAM_LOC is the location of the relevant argument, or UNKNOWN_LOCATION
3542    if this is unavailable.
3543    WANTED_TYPE is the type the argument should have,
3544    possibly stripped of pointer dereferences.  The description (such as "field
3545    precision"), the placement in the format string, a possibly more
3546    friendly name of WANTED_TYPE, and the number of pointer dereferences
3547    are taken from TYPE.  ARG_TYPE is the type of the actual argument,
3548    or NULL if it is missing.
3549
3550    OFFSET_TO_TYPE_START is the offset within the execution-charset encoded
3551    format string to where type information begins for the conversion
3552    (the length modifier and conversion specifier).
3553    CONVERSION_CHAR is the user-provided conversion specifier.
3554
3555    For example, given a type mismatch for argument 5 here:
3556
3557     00000000011111111112222222222333333333344444444445555555555|
3558     12345678901234567890123456789012345678901234567890123456789` column numbers
3559                    0000000000111111111122|
3560                    0123456789012345678901` offsets within STRING_CST
3561                           V~~~~~~~~ : range of WHOLE_FMT_LOC, from cols 23-31
3562       sprintf (d, "before %-+*.*lld after", int_expr, int_expr, long_expr);
3563                                 ^ ^                             ^~~~~~~~~
3564                                 | ` CONVERSION_CHAR: 'd'        PARAM_LOC
3565                                 type starts here
3566
3567    OFFSET_TO_TYPE_START is 13, the offset to the "lld" within the
3568    STRING_CST.  */
3569
3570 static void
3571 format_type_warning (const substring_loc &whole_fmt_loc,
3572                      location_t param_loc,
3573                      format_wanted_type *type,
3574                      tree wanted_type, tree arg_type,
3575                      const format_kind_info *fki,
3576                      int offset_to_type_start,
3577                      char conversion_char)
3578 {
3579   enum format_specifier_kind kind = type->kind;
3580   const char *wanted_type_name = type->wanted_type_name;
3581   const char *format_start = type->format_start;
3582   int format_length = type->format_length;
3583   int pointer_count = type->pointer_count;
3584   int arg_num = type->arg_num;
3585
3586   char *p;
3587   /* If ARG_TYPE is a typedef with a misleading name (for example,
3588      size_t but not the standard size_t expected by printf %zu), avoid
3589      printing the typedef name.  */
3590   if (wanted_type_name
3591       && arg_type
3592       && TYPE_NAME (arg_type)
3593       && TREE_CODE (TYPE_NAME (arg_type)) == TYPE_DECL
3594       && DECL_NAME (TYPE_NAME (arg_type))
3595       && !strcmp (wanted_type_name,
3596                   lang_hooks.decl_printable_name (TYPE_NAME (arg_type), 2)))
3597     arg_type = TYPE_MAIN_VARIANT (arg_type);
3598   /* The format type and name exclude any '*' for pointers, so those
3599      must be formatted manually.  For all the types we currently have,
3600      this is adequate, but formats taking pointers to functions or
3601      arrays would require the full type to be built up in order to
3602      print it with %T.  */
3603   p = (char *) alloca (pointer_count + 2);
3604   if (pointer_count == 0)
3605     p[0] = 0;
3606   else if (c_dialect_cxx ())
3607     {
3608       memset (p, '*', pointer_count);
3609       p[pointer_count] = 0;
3610     }
3611   else
3612     {
3613       p[0] = ' ';
3614       memset (p + 1, '*', pointer_count);
3615       p[pointer_count + 1] = 0;
3616     }
3617
3618   /* WHOLE_FMT_LOC has the caret at the end of the range.
3619      Set the caret to be at the offset from TYPE.  Subtract one
3620      from the offset for the same reason as in format_warning_at_char.  */
3621   substring_loc fmt_loc (whole_fmt_loc);
3622   fmt_loc.set_caret_index (type->offset_loc - 1);
3623
3624   /* Get a string for use as a replacement fix-it hint for the range in
3625      fmt_loc, or NULL.  */
3626   char *corrected_substring
3627     = get_corrected_substring (fmt_loc, type, arg_type, fki,
3628                                offset_to_type_start, conversion_char);
3629
3630   if (wanted_type_name)
3631     {
3632       if (arg_type)
3633         format_warning_at_substring
3634           (fmt_loc, param_loc,
3635            corrected_substring, OPT_Wformat_,
3636            "%s %<%s%.*s%> expects argument of type %<%s%s%>, "
3637            "but argument %d has type %qT",
3638            gettext (kind_descriptions[kind]),
3639            (kind == CF_KIND_FORMAT ? "%" : ""),
3640            format_length, format_start,
3641            wanted_type_name, p, arg_num, arg_type);
3642       else
3643         format_warning_at_substring
3644           (fmt_loc, param_loc,
3645            corrected_substring, OPT_Wformat_,
3646            "%s %<%s%.*s%> expects a matching %<%s%s%> argument",
3647            gettext (kind_descriptions[kind]),
3648            (kind == CF_KIND_FORMAT ? "%" : ""),
3649            format_length, format_start, wanted_type_name, p);
3650     }
3651   else
3652     {
3653       if (arg_type)
3654         format_warning_at_substring
3655           (fmt_loc, param_loc,
3656            corrected_substring, OPT_Wformat_,
3657            "%s %<%s%.*s%> expects argument of type %<%T%s%>, "
3658            "but argument %d has type %qT",
3659            gettext (kind_descriptions[kind]),
3660            (kind == CF_KIND_FORMAT ? "%" : ""),
3661            format_length, format_start,
3662            wanted_type, p, arg_num, arg_type);
3663       else
3664         format_warning_at_substring
3665           (fmt_loc, param_loc,
3666            corrected_substring, OPT_Wformat_,
3667            "%s %<%s%.*s%> expects a matching %<%T%s%> argument",
3668            gettext (kind_descriptions[kind]),
3669            (kind == CF_KIND_FORMAT ? "%" : ""),
3670            format_length, format_start, wanted_type, p);
3671     }
3672
3673   free (corrected_substring);
3674 }
3675
3676
3677 /* Given a format_char_info array FCI, and a character C, this function
3678    returns the index into the conversion_specs where that specifier's
3679    data is located.  The character must exist.  */
3680 static unsigned int
3681 find_char_info_specifier_index (const format_char_info *fci, int c)
3682 {
3683   unsigned i;
3684
3685   for (i = 0; fci->format_chars; i++, fci++)
3686     if (strchr (fci->format_chars, c))
3687       return i;
3688
3689   /* We shouldn't be looking for a non-existent specifier.  */
3690   gcc_unreachable ();
3691 }
3692
3693 /* Given a format_length_info array FLI, and a character C, this
3694    function returns the index into the conversion_specs where that
3695    modifier's data is located.  The character must exist.  */
3696 static unsigned int
3697 find_length_info_modifier_index (const format_length_info *fli, int c)
3698 {
3699   unsigned i;
3700
3701   for (i = 0; fli->name; i++, fli++)
3702     if (strchr (fli->name, c))
3703       return i;
3704
3705   /* We shouldn't be looking for a non-existent modifier.  */
3706   gcc_unreachable ();
3707 }
3708
3709 /* Determine the type of HOST_WIDE_INT in the code being compiled for
3710    use in GCC's __asm_fprintf__ custom format attribute.  You must
3711    have set dynamic_format_types before calling this function.  */
3712 static void
3713 init_dynamic_asm_fprintf_info (void)
3714 {
3715   static tree hwi;
3716
3717   if (!hwi)
3718     {
3719       format_length_info *new_asm_fprintf_length_specs;
3720       unsigned int i;
3721
3722       /* Find the underlying type for HOST_WIDE_INT.  For the %w
3723          length modifier to work, one must have issued: "typedef
3724          HOST_WIDE_INT __gcc_host_wide_int__;" in one's source code
3725          prior to using that modifier.  */
3726       hwi = maybe_get_identifier ("__gcc_host_wide_int__");
3727       if (!hwi)
3728         {
3729           error ("%<__gcc_host_wide_int__%> is not defined as a type");
3730           return;
3731         }
3732       hwi = identifier_global_value (hwi);
3733       if (!hwi || TREE_CODE (hwi) != TYPE_DECL)
3734         {
3735           error ("%<__gcc_host_wide_int__%> is not defined as a type");
3736           return;
3737         }
3738       hwi = DECL_ORIGINAL_TYPE (hwi);
3739       gcc_assert (hwi);
3740       if (hwi != long_integer_type_node && hwi != long_long_integer_type_node)
3741         {
3742           error ("%<__gcc_host_wide_int__%> is not defined as %<long%>"
3743                  " or %<long long%>");
3744           return;
3745         }
3746
3747       /* Create a new (writable) copy of asm_fprintf_length_specs.  */
3748       new_asm_fprintf_length_specs = (format_length_info *)
3749                                      xmemdup (asm_fprintf_length_specs,
3750                                               sizeof (asm_fprintf_length_specs),
3751                                               sizeof (asm_fprintf_length_specs));
3752
3753       /* HOST_WIDE_INT must be one of 'long' or 'long long'.  */
3754       i = find_length_info_modifier_index (new_asm_fprintf_length_specs, 'w');
3755       if (hwi == long_integer_type_node)
3756         new_asm_fprintf_length_specs[i].index = FMT_LEN_l;
3757       else if (hwi == long_long_integer_type_node)
3758         new_asm_fprintf_length_specs[i].index = FMT_LEN_ll;
3759       else
3760         gcc_unreachable ();
3761
3762       /* Assign the new data for use.  */
3763       dynamic_format_types[asm_fprintf_format_type].length_char_specs =
3764         new_asm_fprintf_length_specs;
3765     }
3766 }
3767
3768 /* Determine the type of a "locus" in the code being compiled for use
3769    in GCC's __gcc_gfc__ custom format attribute.  You must have set
3770    dynamic_format_types before calling this function.  */
3771 static void
3772 init_dynamic_gfc_info (void)
3773 {
3774   if (!locus)
3775     {
3776       static format_char_info *gfc_fci;
3777
3778       /* For the GCC __gcc_gfc__ custom format specifier to work, one
3779          must have declared 'locus' prior to using this attribute.  If
3780          we haven't seen this declarations then you shouldn't use the
3781          specifier requiring that type.  */
3782       if ((locus = maybe_get_identifier ("locus")))
3783         {
3784           locus = identifier_global_value (locus);
3785           if (locus)
3786             {
3787               if (TREE_CODE (locus) != TYPE_DECL
3788                   || TREE_TYPE (locus) == error_mark_node)
3789                 {
3790                   error ("%<locus%> is not defined as a type");
3791                   locus = 0;
3792                 }
3793               else
3794                 locus = TREE_TYPE (locus);
3795             }
3796         }
3797
3798       /* Assign the new data for use.  */
3799
3800       /* Handle the __gcc_gfc__ format specifics.  */
3801       if (!gfc_fci)
3802         dynamic_format_types[gcc_gfc_format_type].conversion_specs =
3803           gfc_fci = (format_char_info *)
3804                      xmemdup (gcc_gfc_char_table,
3805                               sizeof (gcc_gfc_char_table),
3806                               sizeof (gcc_gfc_char_table));
3807       if (locus)
3808         {
3809           const unsigned i = find_char_info_specifier_index (gfc_fci, 'L');
3810           gfc_fci[i].types[0].type = &locus;
3811           gfc_fci[i].pointer_count = 1;
3812         }
3813     }
3814 }
3815
3816 /* Determine the types of "tree" and "location_t" in the code being
3817    compiled for use in GCC's diagnostic custom format attributes.  You
3818    must have set dynamic_format_types before calling this function.  */
3819 static void
3820 init_dynamic_diag_info (void)
3821 {
3822   /* For the GCC-diagnostics custom format specifiers to work, one
3823      must have declared 'tree' and 'location_t' prior to using those
3824      attributes.  If we haven't seen these declarations then
3825      the specifiers requiring these types shouldn't be used.
3826      However we don't force a hard ICE because we may see only one
3827      or the other type.  */
3828   if (tree loc = maybe_get_identifier ("location_t"))
3829     {
3830       loc = identifier_global_value (loc);
3831       if (loc && TREE_CODE (loc) != TYPE_DECL)
3832         error ("%<location_t%> is not defined as a type");
3833     }
3834
3835   /* Initialize the global tree node type local to this file.  */
3836   if (!local_tree_type_node
3837       || local_tree_type_node == void_type_node)
3838     {
3839       /* We need to grab the underlying 'union tree_node' so peek into
3840          an extra type level.  */
3841       if ((local_tree_type_node = maybe_get_identifier ("tree")))
3842         {
3843           local_tree_type_node = identifier_global_value (local_tree_type_node);
3844           if (local_tree_type_node)
3845             {
3846               if (TREE_CODE (local_tree_type_node) != TYPE_DECL)
3847                 {
3848                   error ("%<tree%> is not defined as a type");
3849                   local_tree_type_node = 0;
3850                 }
3851               else if (TREE_CODE (TREE_TYPE (local_tree_type_node))
3852                        != POINTER_TYPE)
3853                 {
3854                   error ("%<tree%> is not defined as a pointer type");
3855                   local_tree_type_node = 0;
3856                 }
3857               else
3858                 local_tree_type_node =
3859                   TREE_TYPE (TREE_TYPE (local_tree_type_node));
3860             }
3861         }
3862       else
3863         local_tree_type_node = void_type_node;
3864     }
3865
3866   /* Similar to the above but for gcall*.  */
3867   if (!local_gcall_ptr_node
3868       || local_gcall_ptr_node == void_type_node)
3869     {
3870       if ((local_gcall_ptr_node = maybe_get_identifier ("gcall")))
3871         {
3872           local_gcall_ptr_node
3873             = identifier_global_value (local_gcall_ptr_node);
3874           if (local_gcall_ptr_node)
3875             {
3876               if (TREE_CODE (local_gcall_ptr_node) != TYPE_DECL)
3877                 {
3878                   error ("%<gcall%> is not defined as a type");
3879                   local_gcall_ptr_node = 0;
3880                 }
3881               else
3882                 local_gcall_ptr_node = TREE_TYPE (local_gcall_ptr_node);
3883             }
3884         }
3885       else
3886         local_gcall_ptr_node = void_type_node;
3887     }
3888
3889   static tree hwi;
3890
3891   if (!hwi)
3892     {
3893       static format_length_info *diag_ls;
3894       unsigned int i;
3895
3896       /* Find the underlying type for HOST_WIDE_INT.  For the 'w'
3897          length modifier to work, one must have issued: "typedef
3898          HOST_WIDE_INT __gcc_host_wide_int__;" in one's source code
3899          prior to using that modifier.  */
3900       if ((hwi = maybe_get_identifier ("__gcc_host_wide_int__")))
3901         {
3902           hwi = identifier_global_value (hwi);
3903           if (hwi)
3904             {
3905               if (TREE_CODE (hwi) != TYPE_DECL)
3906                 {
3907                   error ("%<__gcc_host_wide_int__%> is not defined as a type");
3908                   hwi = 0;
3909                 }
3910               else
3911                 {
3912                   hwi = DECL_ORIGINAL_TYPE (hwi);
3913                   gcc_assert (hwi);
3914                   if (hwi != long_integer_type_node
3915                       && hwi != long_long_integer_type_node)
3916                     {
3917                       error ("%<__gcc_host_wide_int__%> is not defined"
3918                              " as %<long%> or %<long long%>");
3919                       hwi = 0;
3920                     }
3921                 }
3922             }
3923         }
3924
3925       /* Assign the new data for use.  */
3926
3927       /* All the GCC diag formats use the same length specs.  */
3928       if (!diag_ls)
3929         dynamic_format_types[gcc_diag_format_type].length_char_specs =
3930           dynamic_format_types[gcc_tdiag_format_type].length_char_specs =
3931           dynamic_format_types[gcc_cdiag_format_type].length_char_specs =
3932           dynamic_format_types[gcc_cxxdiag_format_type].length_char_specs =
3933           diag_ls = (format_length_info *)
3934                     xmemdup (gcc_diag_length_specs,
3935                              sizeof (gcc_diag_length_specs),
3936                              sizeof (gcc_diag_length_specs));
3937       if (hwi)
3938         {
3939           /* HOST_WIDE_INT must be one of 'long' or 'long long'.  */
3940           i = find_length_info_modifier_index (diag_ls, 'w');
3941           if (hwi == long_integer_type_node)
3942             diag_ls[i].index = FMT_LEN_l;
3943           else if (hwi == long_long_integer_type_node)
3944             diag_ls[i].index = FMT_LEN_ll;
3945           else
3946             gcc_unreachable ();
3947         }
3948     }
3949
3950   /* It's safe to "re-initialize these to the same values.  */
3951   dynamic_format_types[gcc_diag_format_type].conversion_specs =
3952     gcc_diag_char_table;
3953   dynamic_format_types[gcc_tdiag_format_type].conversion_specs =
3954     gcc_tdiag_char_table;
3955   dynamic_format_types[gcc_cdiag_format_type].conversion_specs =
3956     gcc_cdiag_char_table;
3957   dynamic_format_types[gcc_cxxdiag_format_type].conversion_specs =
3958     gcc_cxxdiag_char_table;
3959 }
3960
3961 #ifdef TARGET_FORMAT_TYPES
3962 extern const format_kind_info TARGET_FORMAT_TYPES[];
3963 #endif
3964
3965 #ifdef TARGET_OVERRIDES_FORMAT_ATTRIBUTES
3966 extern const target_ovr_attr TARGET_OVERRIDES_FORMAT_ATTRIBUTES[];
3967 #endif
3968 #ifdef TARGET_OVERRIDES_FORMAT_INIT
3969   extern void TARGET_OVERRIDES_FORMAT_INIT (void);
3970 #endif
3971
3972 /* Attributes such as "printf" are equivalent to those such as
3973    "gnu_printf" unless this is overridden by a target.  */
3974 static const target_ovr_attr gnu_target_overrides_format_attributes[] =
3975 {
3976   { "gnu_printf",   "printf" },
3977   { "gnu_scanf",    "scanf" },
3978   { "gnu_strftime", "strftime" },
3979   { "gnu_strfmon",  "strfmon" },
3980   { NULL,           NULL }
3981 };
3982
3983 /* Translate to unified attribute name. This is used in decode_format_type and
3984    decode_format_attr. In attr_name the user specified argument is passed. It
3985    returns the unified format name from TARGET_OVERRIDES_FORMAT_ATTRIBUTES
3986    or the attr_name passed to this function, if there is no matching entry.  */
3987 static const char *
3988 convert_format_name_to_system_name (const char *attr_name)
3989 {
3990   int i;
3991
3992   if (attr_name == NULL || *attr_name == 0
3993       || strncmp (attr_name, "gcc_", 4) == 0)
3994     return attr_name;
3995 #ifdef TARGET_OVERRIDES_FORMAT_INIT
3996   TARGET_OVERRIDES_FORMAT_INIT ();
3997 #endif
3998
3999 #ifdef TARGET_OVERRIDES_FORMAT_ATTRIBUTES
4000   /* Check if format attribute is overridden by target.  */
4001   if (TARGET_OVERRIDES_FORMAT_ATTRIBUTES != NULL
4002       && TARGET_OVERRIDES_FORMAT_ATTRIBUTES_COUNT > 0)
4003     {
4004       for (i = 0; i < TARGET_OVERRIDES_FORMAT_ATTRIBUTES_COUNT; ++i)
4005         {
4006           if (cmp_attribs (TARGET_OVERRIDES_FORMAT_ATTRIBUTES[i].named_attr_src,
4007                            attr_name))
4008             return attr_name;
4009           if (cmp_attribs (TARGET_OVERRIDES_FORMAT_ATTRIBUTES[i].named_attr_dst,
4010                            attr_name))
4011             return TARGET_OVERRIDES_FORMAT_ATTRIBUTES[i].named_attr_src;
4012         }
4013     }
4014 #endif
4015   /* Otherwise default to gnu format.  */
4016   for (i = 0;
4017        gnu_target_overrides_format_attributes[i].named_attr_src != NULL;
4018        ++i)
4019     {
4020       if (cmp_attribs (gnu_target_overrides_format_attributes[i].named_attr_src,
4021                        attr_name))
4022         return attr_name;
4023       if (cmp_attribs (gnu_target_overrides_format_attributes[i].named_attr_dst,
4024                        attr_name))
4025         return gnu_target_overrides_format_attributes[i].named_attr_src;
4026     }
4027
4028   return attr_name;
4029 }
4030
4031 /* Handle a "format" attribute; arguments as in
4032    struct attribute_spec.handler.  */
4033 tree
4034 handle_format_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4035                          int flags, bool *no_add_attrs)
4036 {
4037   tree type = *node;
4038   function_format_info info;
4039
4040 #ifdef TARGET_FORMAT_TYPES
4041   /* If the target provides additional format types, we need to
4042      add them to FORMAT_TYPES at first use.  */
4043   if (TARGET_FORMAT_TYPES != NULL && !dynamic_format_types)
4044     {
4045       dynamic_format_types = XNEWVEC (format_kind_info,
4046                                       n_format_types + TARGET_N_FORMAT_TYPES);
4047       memcpy (dynamic_format_types, format_types_orig,
4048               sizeof (format_types_orig));
4049       memcpy (&dynamic_format_types[n_format_types], TARGET_FORMAT_TYPES,
4050               TARGET_N_FORMAT_TYPES * sizeof (dynamic_format_types[0]));
4051
4052       format_types = dynamic_format_types;
4053       /* Provide a reference for the first potential external type.  */
4054       first_target_format_type = n_format_types;
4055       n_format_types += TARGET_N_FORMAT_TYPES;
4056     }
4057 #endif
4058
4059   /* Canonicalize name of format function.  */
4060   if (TREE_CODE (TREE_VALUE (args)) == IDENTIFIER_NODE)
4061     TREE_VALUE (args) = canonicalize_attr_name (TREE_VALUE (args));
4062
4063   if (!decode_format_attr (args, &info, 0))
4064     {
4065       *no_add_attrs = true;
4066       return NULL_TREE;
4067     }
4068
4069   if (prototype_p (type))
4070     {
4071       if (!check_format_string (type, info.format_num, flags,
4072                                 no_add_attrs, info.format_type))
4073         return NULL_TREE;
4074
4075       if (info.first_arg_num != 0)
4076         {
4077           unsigned HOST_WIDE_INT arg_num = 1;
4078           function_args_iterator iter;
4079           tree arg_type;
4080
4081           /* Verify that first_arg_num points to the last arg,
4082              the ...  */
4083           FOREACH_FUNCTION_ARGS (type, arg_type, iter)
4084             arg_num++;
4085
4086           if (arg_num != info.first_arg_num)
4087             {
4088               if (!(flags & (int) ATTR_FLAG_BUILT_IN))
4089                 error ("args to be formatted is not %<...%>");
4090               *no_add_attrs = true;
4091               return NULL_TREE;
4092             }
4093         }
4094     }
4095
4096   /* Check if this is a strftime variant. Just for this variant
4097      FMT_FLAG_ARG_CONVERT is not set.  */
4098   if ((format_types[info.format_type].flags & (int) FMT_FLAG_ARG_CONVERT) == 0
4099       && info.first_arg_num != 0)
4100     {
4101       error ("strftime formats cannot format arguments");
4102       *no_add_attrs = true;
4103       return NULL_TREE;
4104     }
4105
4106   /* If this is a custom GCC-internal format type, we have to
4107      initialize certain bits at runtime.  */
4108   if (info.format_type == asm_fprintf_format_type
4109       || info.format_type == gcc_gfc_format_type
4110       || info.format_type == gcc_diag_format_type
4111       || info.format_type == gcc_tdiag_format_type
4112       || info.format_type == gcc_cdiag_format_type
4113       || info.format_type == gcc_cxxdiag_format_type)
4114     {
4115       /* Our first time through, we have to make sure that our
4116          format_type data is allocated dynamically and is modifiable.  */
4117       if (!dynamic_format_types)
4118         format_types = dynamic_format_types = (format_kind_info *)
4119           xmemdup (format_types_orig, sizeof (format_types_orig),
4120                    sizeof (format_types_orig));
4121
4122       /* If this is format __asm_fprintf__, we have to initialize
4123          GCC's notion of HOST_WIDE_INT for checking %wd.  */
4124       if (info.format_type == asm_fprintf_format_type)
4125         init_dynamic_asm_fprintf_info ();
4126       /* If this is format __gcc_gfc__, we have to initialize GCC's
4127          notion of 'locus' at runtime for %L.  */
4128       else if (info.format_type == gcc_gfc_format_type)
4129         init_dynamic_gfc_info ();
4130       /* If this is one of the diagnostic attributes, then we have to
4131          initialize 'location_t' and 'tree' at runtime.  */
4132       else if (info.format_type == gcc_diag_format_type
4133                || info.format_type == gcc_tdiag_format_type
4134                || info.format_type == gcc_cdiag_format_type
4135                || info.format_type == gcc_cxxdiag_format_type)
4136         init_dynamic_diag_info ();
4137       else
4138         gcc_unreachable ();
4139     }
4140
4141   return NULL_TREE;
4142 }
4143
4144 #if CHECKING_P
4145
4146 namespace selftest {
4147
4148 /* Selftests of location handling.  */
4149
4150 /* Get the format_kind_info with the given name.  */
4151
4152 static const format_kind_info *
4153 get_info (const char *name)
4154 {
4155   int idx = decode_format_type (name);
4156   const format_kind_info *fki = &format_types[idx];
4157   ASSERT_STREQ (fki->name, name);
4158   return fki;
4159 }
4160
4161 /* Verify that get_format_for_type (FKI, TYPE, CONVERSION_CHAR)
4162    is EXPECTED_FORMAT.  */
4163
4164 static void
4165 assert_format_for_type_streq (const location &loc, const format_kind_info *fki,
4166                               const char *expected_format, tree type,
4167                               char conversion_char)
4168 {
4169   gcc_assert (fki);
4170   gcc_assert (expected_format);
4171   gcc_assert (type);
4172
4173   char *actual_format = get_format_for_type (fki, type, conversion_char);
4174   ASSERT_STREQ_AT (loc, expected_format, actual_format);
4175   free (actual_format);
4176 }
4177
4178 /* Selftests for get_format_for_type.  */
4179
4180 #define ASSERT_FORMAT_FOR_TYPE_STREQ(EXPECTED_FORMAT, TYPE, CONVERSION_CHAR) \
4181   assert_format_for_type_streq (SELFTEST_LOCATION, (fki), (EXPECTED_FORMAT), \
4182                                 (TYPE), (CONVERSION_CHAR))
4183
4184 /* Selftest for get_format_for_type for "printf"-style functions.  */
4185
4186 static void
4187 test_get_format_for_type_printf ()
4188 {
4189   const format_kind_info *fki = get_info ("gnu_printf");
4190   ASSERT_NE (fki, NULL);
4191
4192   ASSERT_FORMAT_FOR_TYPE_STREQ ("f", double_type_node, 'i');
4193   ASSERT_FORMAT_FOR_TYPE_STREQ ("Lf", long_double_type_node, 'i');
4194   ASSERT_FORMAT_FOR_TYPE_STREQ ("f", double_type_node, 'o');
4195   ASSERT_FORMAT_FOR_TYPE_STREQ ("Lf", long_double_type_node, 'o');
4196   ASSERT_FORMAT_FOR_TYPE_STREQ ("f", double_type_node, 'x');
4197   ASSERT_FORMAT_FOR_TYPE_STREQ ("Lf", long_double_type_node, 'x');
4198   ASSERT_FORMAT_FOR_TYPE_STREQ ("f", double_type_node, 'X');
4199   ASSERT_FORMAT_FOR_TYPE_STREQ ("Lf", long_double_type_node, 'X');
4200   ASSERT_FORMAT_FOR_TYPE_STREQ ("d", integer_type_node, 'd');
4201   ASSERT_FORMAT_FOR_TYPE_STREQ ("i", integer_type_node, 'i');
4202   ASSERT_FORMAT_FOR_TYPE_STREQ ("o", integer_type_node, 'o');
4203   ASSERT_FORMAT_FOR_TYPE_STREQ ("x", integer_type_node, 'x');
4204   ASSERT_FORMAT_FOR_TYPE_STREQ ("X", integer_type_node, 'X');
4205   ASSERT_FORMAT_FOR_TYPE_STREQ ("d", unsigned_type_node, 'd');
4206   ASSERT_FORMAT_FOR_TYPE_STREQ ("i", unsigned_type_node, 'i');
4207   ASSERT_FORMAT_FOR_TYPE_STREQ ("o", unsigned_type_node, 'o');
4208   ASSERT_FORMAT_FOR_TYPE_STREQ ("x", unsigned_type_node, 'x');
4209   ASSERT_FORMAT_FOR_TYPE_STREQ ("X", unsigned_type_node, 'X');
4210   ASSERT_FORMAT_FOR_TYPE_STREQ ("ld", long_integer_type_node, 'd');
4211   ASSERT_FORMAT_FOR_TYPE_STREQ ("li", long_integer_type_node, 'i');
4212   ASSERT_FORMAT_FOR_TYPE_STREQ ("lx", long_integer_type_node, 'x');
4213   ASSERT_FORMAT_FOR_TYPE_STREQ ("lo", long_unsigned_type_node, 'o');
4214   ASSERT_FORMAT_FOR_TYPE_STREQ ("lx", long_unsigned_type_node, 'x');
4215   ASSERT_FORMAT_FOR_TYPE_STREQ ("lld", long_long_integer_type_node, 'd');
4216   ASSERT_FORMAT_FOR_TYPE_STREQ ("lli", long_long_integer_type_node, 'i');
4217   ASSERT_FORMAT_FOR_TYPE_STREQ ("llo", long_long_unsigned_type_node, 'o');
4218   ASSERT_FORMAT_FOR_TYPE_STREQ ("llx", long_long_unsigned_type_node, 'x');
4219   ASSERT_FORMAT_FOR_TYPE_STREQ ("s", build_pointer_type (char_type_node), 'i');
4220 }
4221
4222 /* Selftest for get_format_for_type for "scanf"-style functions.  */
4223
4224 static void
4225 test_get_format_for_type_scanf ()
4226 {
4227   const format_kind_info *fki = get_info ("gnu_scanf");
4228   ASSERT_NE (fki, NULL);
4229   ASSERT_FORMAT_FOR_TYPE_STREQ ("d", build_pointer_type (integer_type_node), 'd');
4230   ASSERT_FORMAT_FOR_TYPE_STREQ ("u", build_pointer_type (unsigned_type_node), 'u');
4231   ASSERT_FORMAT_FOR_TYPE_STREQ ("ld",
4232                                 build_pointer_type (long_integer_type_node), 'd');
4233   ASSERT_FORMAT_FOR_TYPE_STREQ ("lu",
4234                                 build_pointer_type (long_unsigned_type_node), 'u');
4235   ASSERT_FORMAT_FOR_TYPE_STREQ
4236     ("lld", build_pointer_type (long_long_integer_type_node), 'd');
4237   ASSERT_FORMAT_FOR_TYPE_STREQ
4238     ("llu", build_pointer_type (long_long_unsigned_type_node), 'u');
4239   ASSERT_FORMAT_FOR_TYPE_STREQ ("e", build_pointer_type (float_type_node), 'e');
4240   ASSERT_FORMAT_FOR_TYPE_STREQ ("le", build_pointer_type (double_type_node), 'e');
4241 }
4242
4243 #undef ASSERT_FORMAT_FOR_TYPE_STREQ
4244
4245 /* Run all of the selftests within this file.  */
4246
4247 void
4248 c_format_c_tests ()
4249 {
4250   test_get_modifier_for_format_len ();
4251   test_get_format_for_type_printf ();
4252   test_get_format_for_type_scanf ();
4253 }
4254
4255 } // namespace selftest
4256
4257 #endif /* CHECKING_P */
4258
4259 #include "gt-c-family-c-format.h"