1 /* Check calls to formatted I/O functions (-Wformat).
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
24 #include "coretypes.h"
31 #include "diagnostic.h"
32 #include "langhooks.h"
34 /* Set format warning options according to a -Wformat=n option. */
37 set_Wformat (int setting)
39 warn_format = setting;
40 warn_format_y2k = setting;
41 warn_format_extra_args = setting;
42 warn_format_zero_length = setting;
45 warn_format_nonliteral = setting;
46 warn_format_security = setting;
48 /* Make sure not to disable -Wnonnull if -Wformat=0 is specified. */
50 warn_nonnull = setting;
54 /* Handle attributes associated with format checking. */
56 /* This must be in the same order as format_types, with format_type_error
58 enum format_type { printf_format_type, asm_fprintf_format_type,
59 scanf_format_type, strftime_format_type,
60 strfmon_format_type, format_type_error };
62 typedef struct function_format_info
64 enum format_type format_type; /* type of format (printf, scanf, etc.) */
65 unsigned HOST_WIDE_INT format_num; /* number of format argument */
66 unsigned HOST_WIDE_INT first_arg_num; /* number of first arg (zero for varargs) */
67 } function_format_info;
69 static bool decode_format_attr (tree, function_format_info *, int);
70 static enum format_type decode_format_type (const char *);
72 static bool check_format_string (tree argument,
73 unsigned HOST_WIDE_INT format_num,
74 int flags, bool *no_add_attrs);
75 static bool get_constant (tree expr, unsigned HOST_WIDE_INT *value,
79 /* Handle a "format_arg" attribute; arguments as in
80 struct attribute_spec.handler. */
82 handle_format_arg_attribute (tree *node, tree name ATTRIBUTE_UNUSED,
83 tree args, int flags, bool *no_add_attrs)
86 tree format_num_expr = TREE_VALUE (args);
87 unsigned HOST_WIDE_INT format_num;
90 if (!get_constant (format_num_expr, &format_num, 0))
92 error ("format string has invalid operand number");
97 argument = TYPE_ARG_TYPES (type);
100 if (!check_format_string (argument, format_num, flags, no_add_attrs))
104 if (TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
105 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
108 if (!(flags & (int) ATTR_FLAG_BUILT_IN))
109 error ("function does not return string type");
110 *no_add_attrs = true;
117 /* Verify that the format_num argument is actually a string, in case
118 the format attribute is in error. */
120 check_format_string (tree argument, unsigned HOST_WIDE_INT format_num,
121 int flags, bool *no_add_attrs)
123 unsigned HOST_WIDE_INT i;
125 for (i = 1; i != format_num; i++)
129 argument = TREE_CHAIN (argument);
133 || TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE
134 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument)))
137 if (!(flags & (int) ATTR_FLAG_BUILT_IN))
138 error ("format string arg not a string type");
139 *no_add_attrs = true;
146 /* Strip any conversions from the expression, verify it is a constant,
147 and store its value. If validated_p is true, abort on errors.
148 Returns true on success, false otherwise. */
150 get_constant(tree expr, unsigned HOST_WIDE_INT *value, int validated_p)
152 while (TREE_CODE (expr) == NOP_EXPR
153 || TREE_CODE (expr) == CONVERT_EXPR
154 || TREE_CODE (expr) == NON_LVALUE_EXPR)
155 expr = TREE_OPERAND (expr, 0);
157 if (TREE_CODE (expr) != INTEGER_CST || TREE_INT_CST_HIGH (expr) != 0)
164 *value = TREE_INT_CST_LOW (expr);
169 /* Decode the arguments to a "format" attribute into a function_format_info
170 structure. It is already known that the list is of the right length.
171 If VALIDATED_P is true, then these attributes have already been validated
172 and this function will abort if they are erroneous; if false, it
173 will give an error message. Returns true if the attributes are
174 successfully decoded, false otherwise. */
177 decode_format_attr (tree args, function_format_info *info, int validated_p)
179 tree format_type_id = TREE_VALUE (args);
180 tree format_num_expr = TREE_VALUE (TREE_CHAIN (args));
181 tree first_arg_num_expr
182 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args)));
184 if (TREE_CODE (format_type_id) != IDENTIFIER_NODE)
188 error ("unrecognized format specifier");
193 const char *p = IDENTIFIER_POINTER (format_type_id);
195 info->format_type = decode_format_type (p);
197 if (info->format_type == format_type_error)
201 warning ("`%s' is an unrecognized format function type", p);
206 if (!get_constant (format_num_expr, &info->format_num, validated_p))
208 error ("format string has invalid operand number");
212 if (!get_constant (first_arg_num_expr, &info->first_arg_num, validated_p))
214 error ("'...' has invalid operand number");
218 if (info->first_arg_num != 0 && info->first_arg_num <= info->format_num)
222 error ("format string arg follows the args to be formatted");
229 /* Check a call to a format function against a parameter list. */
231 /* The meaningfully distinct length modifiers for format checking recognized
248 /* The standard versions in which various format features appeared. */
249 enum format_std_version
253 STD_C9L, /* C99, but treat as C89 if -Wno-long-long. */
258 /* The C standard version C++ is treated as equivalent to
259 or inheriting from, for the purpose of format features supported. */
260 #define CPLUSPLUS_STD_VER STD_C94
261 /* The C standard version we are checking formats against when pedantic. */
262 #define C_STD_VER ((int)(c_language == clk_cplusplus \
263 ? CPLUSPLUS_STD_VER \
266 : (flag_isoc94 ? STD_C94 : STD_C89))))
267 /* The name to give to the standard version we are warning about when
268 pedantic. FEATURE_VER is the version in which the feature warned out
269 appeared, which is higher than C_STD_VER. */
270 #define C_STD_NAME(FEATURE_VER) (c_language == clk_cplusplus \
272 : ((FEATURE_VER) == STD_EXT \
275 /* Adjust a C standard version, which may be STD_C9L, to account for
276 -Wno-long-long. Returns other standard versions unchanged. */
277 #define ADJ_STD(VER) ((int)((VER) == STD_C9L \
278 ? (warn_long_long ? STD_C99 : STD_C89) \
281 /* Flags that may apply to a particular kind of format checked by GCC. */
284 /* This format converts arguments of types determined by the
286 FMT_FLAG_ARG_CONVERT = 1,
287 /* The scanf allocation 'a' kludge applies to this format kind. */
288 FMT_FLAG_SCANF_A_KLUDGE = 2,
289 /* A % during parsing a specifier is allowed to be a modified % rather
290 that indicating the format is broken and we are out-of-sync. */
291 FMT_FLAG_FANCY_PERCENT_OK = 4,
292 /* With $ operand numbers, it is OK to reference the same argument more
294 FMT_FLAG_DOLLAR_MULTIPLE = 8,
295 /* This format type uses $ operand numbers (strfmon doesn't). */
296 FMT_FLAG_USE_DOLLAR = 16,
297 /* Zero width is bad in this type of format (scanf). */
298 FMT_FLAG_ZERO_WIDTH_BAD = 32,
299 /* Empty precision specification is OK in this type of format (printf). */
300 FMT_FLAG_EMPTY_PREC_OK = 64,
301 /* Gaps are allowed in the arguments with $ operand numbers if all
302 arguments are pointers (scanf). */
303 FMT_FLAG_DOLLAR_GAP_POINTER_OK = 128
304 /* Not included here: details of whether width or precision may occur
305 (controlled by width_char and precision_char); details of whether
306 '*' can be used for these (width_type and precision_type); details
307 of whether length modifiers can occur (length_char_specs). */
311 /* Structure describing a length modifier supported in format checking, and
312 possibly a doubled version such as "hh". */
315 /* Name of the single-character length modifier. */
317 /* Index into a format_char_info.types array. */
318 enum format_lengths index;
319 /* Standard version this length appears in. */
320 enum format_std_version std;
321 /* Same, if the modifier can be repeated, or NULL if it can't. */
322 const char *double_name;
323 enum format_lengths double_index;
324 enum format_std_version double_std;
325 } format_length_info;
328 /* Structure describing the combination of a conversion specifier
329 (or a set of specifiers which act identically) and a length modifier. */
332 /* The standard version this combination of length and type appeared in.
333 This is only relevant if greater than those for length and type
334 individually; otherwise it is ignored. */
335 enum format_std_version std;
336 /* The name to use for the type, if different from that generated internally
337 (e.g., "signed size_t"). */
339 /* The type itself. */
341 } format_type_detail;
344 /* Macros to fill out tables of these. */
345 #define NOARGUMENTS { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }
346 #define BADLEN { 0, NULL, NULL }
347 #define NOLENGTHS { BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }
350 /* Structure describing a format conversion specifier (or a set of specifiers
351 which act identically), and the length modifiers used with it. */
354 const char *format_chars;
356 enum format_std_version std;
357 /* Types accepted for each length modifier. */
358 format_type_detail types[FMT_LEN_MAX];
359 /* List of other modifier characters allowed with these specifiers.
360 This lists flags, and additionally "w" for width, "p" for precision
361 (right precision, for strfmon), "#" for left precision (strfmon),
362 "a" for scanf "a" allocation extension (not applicable in C99 mode),
363 "*" for scanf suppression, and "E" and "O" for those strftime
365 const char *flag_chars;
366 /* List of additional flags describing these conversion specifiers.
367 "c" for generic character pointers being allowed, "2" for strftime
368 two digit year formats, "3" for strftime formats giving two digit
369 years in some locales, "4" for "2" which becomes "3" with an "E" modifier,
370 "o" if use of strftime "O" is a GNU extension beyond C99,
371 "W" if the argument is a pointer which is dereferenced and written into,
372 "R" if the argument is a pointer which is dereferenced and read from,
373 "i" for printf integer formats where the '0' flag is ignored with
374 precision, and "[" for the starting character of a scanf scanset. */
379 /* Structure describing a flag accepted by some kind of format. */
382 /* The flag character in question (0 for end of array). */
384 /* Zero if this entry describes the flag character in general, or a
385 nonzero character that may be found in flags2 if it describes the
386 flag when used with certain formats only. If the latter, only
387 the first such entry found that applies to the current conversion
388 specifier is used; the values of `name' and `long_name' it supplies
389 will be used, if non-NULL and the standard version is higher than
390 the unpredicated one, for any pedantic warning. For example, 'o'
391 for strftime formats (meaning 'O' is an extension over C99). */
393 /* Nonzero if the next character after this flag in the format should
394 be skipped ('=' in strfmon), zero otherwise. */
396 /* The name to use for this flag in diagnostic messages. For example,
397 N_("`0' flag"), N_("field width"). */
399 /* Long name for this flag in diagnostic messages; currently only used for
400 "ISO C does not support ...". For example, N_("the `I' printf flag"). */
401 const char *long_name;
402 /* The standard version in which it appeared. */
403 enum format_std_version std;
407 /* Structure describing a combination of flags that is bad for some kind
411 /* The first flag character in question (0 for end of array). */
413 /* The second flag character. */
415 /* Nonzero if the message should say that the first flag is ignored with
416 the second, zero if the combination should simply be objected to. */
418 /* Zero if this entry applies whenever this flag combination occurs,
419 a nonzero character from flags2 if it only applies in some
420 circumstances (e.g. 'i' for printf formats ignoring 0 with precision). */
425 /* Structure describing a particular kind of format processed by GCC. */
428 /* The name of this kind of format, for use in diagnostics. Also
429 the name of the attribute (without preceding and following __). */
431 /* Specifications of the length modifiers accepted; possibly NULL. */
432 const format_length_info *length_char_specs;
433 /* Details of the conversion specification characters accepted. */
434 const format_char_info *conversion_specs;
435 /* String listing the flag characters that are accepted. */
436 const char *flag_chars;
437 /* String listing modifier characters (strftime) accepted. May be NULL. */
438 const char *modifier_chars;
439 /* Details of the flag characters, including pseudo-flags. */
440 const format_flag_spec *flag_specs;
441 /* Details of bad combinations of flags. */
442 const format_flag_pair *bad_flag_pairs;
443 /* Flags applicable to this kind of format. */
445 /* Flag character to treat a width as, or 0 if width not used. */
447 /* Flag character to treat a left precision (strfmon) as,
448 or 0 if left precision not used. */
449 int left_precision_char;
450 /* Flag character to treat a precision (for strfmon, right precision) as,
451 or 0 if precision not used. */
453 /* If a flag character has the effect of suppressing the conversion of
454 an argument ('*' in scanf), that flag character, otherwise 0. */
455 int suppression_char;
456 /* Flag character to treat a length modifier as (ignored if length
457 modifiers not used). Need not be placed in flag_chars for conversion
458 specifiers, but is used to check for bad combinations such as length
459 modifier with assignment suppression in scanf. */
460 int length_code_char;
461 /* Pointer to type of argument expected if '*' is used for a width,
462 or NULL if '*' not used for widths. */
464 /* Pointer to type of argument expected if '*' is used for a precision,
465 or NULL if '*' not used for precisions. */
466 tree *precision_type;
470 /* Structure describing details of a type expected in format checking,
471 and the type to check against it. */
472 typedef struct format_wanted_type
474 /* The type wanted. */
476 /* The name of this type to use in diagnostics. */
477 const char *wanted_type_name;
478 /* The level of indirection through pointers at which this type occurs. */
480 /* Whether, when pointer_count is 1, to allow any character type when
481 pedantic, rather than just the character or void type specified. */
482 int char_lenient_flag;
483 /* Whether the argument, dereferenced once, is written into and so the
484 argument must not be a pointer to a const-qualified type. */
486 /* Whether the argument, dereferenced once, is read from and so
487 must not be a NULL pointer. */
488 int reading_from_flag;
489 /* If warnings should be of the form "field precision is not type int",
490 the name to use (in this case "field precision"), otherwise NULL,
491 for "%s format, %s arg" type messages. If (in an extension), this
492 is a pointer type, wanted_type_name should be set to include the
493 terminating '*' characters of the type name to give a correct
496 /* The actual parameter to check against the wanted type. */
498 /* The argument number of that parameter. */
500 /* The next type to check for this format conversion, or NULL if none. */
501 struct format_wanted_type *next;
502 } format_wanted_type;
505 static const format_length_info printf_length_specs[] =
507 { "h", FMT_LEN_h, STD_C89, "hh", FMT_LEN_hh, STD_C99 },
508 { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C9L },
509 { "q", FMT_LEN_ll, STD_EXT, NULL, 0, 0 },
510 { "L", FMT_LEN_L, STD_C89, NULL, 0, 0 },
511 { "z", FMT_LEN_z, STD_C99, NULL, 0, 0 },
512 { "Z", FMT_LEN_z, STD_EXT, NULL, 0, 0 },
513 { "t", FMT_LEN_t, STD_C99, NULL, 0, 0 },
514 { "j", FMT_LEN_j, STD_C99, NULL, 0, 0 },
515 { NULL, 0, 0, NULL, 0, 0 }
518 /* Length specifiers valid for asm_fprintf. */
519 static const format_length_info asm_fprintf_length_specs[] =
521 { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C89 },
522 { "w", FMT_LEN_none, STD_C89, NULL, 0, 0 },
523 { NULL, 0, 0, NULL, 0, 0 }
526 /* This differs from printf_length_specs only in that "Z" is not accepted. */
527 static const format_length_info scanf_length_specs[] =
529 { "h", FMT_LEN_h, STD_C89, "hh", FMT_LEN_hh, STD_C99 },
530 { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C9L },
531 { "q", FMT_LEN_ll, STD_EXT, NULL, 0, 0 },
532 { "L", FMT_LEN_L, STD_C89, NULL, 0, 0 },
533 { "z", FMT_LEN_z, STD_C99, NULL, 0, 0 },
534 { "t", FMT_LEN_t, STD_C99, NULL, 0, 0 },
535 { "j", FMT_LEN_j, STD_C99, NULL, 0, 0 },
536 { NULL, 0, 0, NULL, 0, 0 }
540 /* All tables for strfmon use STD_C89 everywhere, since -pedantic warnings
541 make no sense for a format type not part of any C standard version. */
542 static const format_length_info strfmon_length_specs[] =
544 /* A GNU extension. */
545 { "L", FMT_LEN_L, STD_C89, NULL, 0, 0 },
546 { NULL, 0, 0, NULL, 0, 0 }
549 static const format_flag_spec printf_flag_specs[] =
551 { ' ', 0, 0, N_("` ' flag"), N_("the ` ' printf flag"), STD_C89 },
552 { '+', 0, 0, N_("`+' flag"), N_("the `+' printf flag"), STD_C89 },
553 { '#', 0, 0, N_("`#' flag"), N_("the `#' printf flag"), STD_C89 },
554 { '0', 0, 0, N_("`0' flag"), N_("the `0' printf flag"), STD_C89 },
555 { '-', 0, 0, N_("`-' flag"), N_("the `-' printf flag"), STD_C89 },
556 { '\'', 0, 0, N_("`'' flag"), N_("the `'' printf flag"), STD_EXT },
557 { 'I', 0, 0, N_("`I' flag"), N_("the `I' printf flag"), STD_EXT },
558 { 'w', 0, 0, N_("field width"), N_("field width in printf format"), STD_C89 },
559 { 'p', 0, 0, N_("precision"), N_("precision in printf format"), STD_C89 },
560 { 'L', 0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
561 { 0, 0, 0, NULL, NULL, 0 }
565 static const format_flag_pair printf_flag_pairs[] =
569 { '0', 'p', 1, 'i' },
573 static const format_flag_spec asm_fprintf_flag_specs[] =
575 { ' ', 0, 0, N_("` ' flag"), N_("the ` ' printf flag"), STD_C89 },
576 { '+', 0, 0, N_("`+' flag"), N_("the `+' printf flag"), STD_C89 },
577 { '#', 0, 0, N_("`#' flag"), N_("the `#' printf flag"), STD_C89 },
578 { '0', 0, 0, N_("`0' flag"), N_("the `0' printf flag"), STD_C89 },
579 { '-', 0, 0, N_("`-' flag"), N_("the `-' printf flag"), STD_C89 },
580 { 'w', 0, 0, N_("field width"), N_("field width in printf format"), STD_C89 },
581 { 'p', 0, 0, N_("precision"), N_("precision in printf format"), STD_C89 },
582 { 'L', 0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
583 { 0, 0, 0, NULL, NULL, 0 }
586 static const format_flag_pair asm_fprintf_flag_pairs[] =
590 { '0', 'p', 1, 'i' },
594 static const format_flag_spec scanf_flag_specs[] =
596 { '*', 0, 0, N_("assignment suppression"), N_("the assignment suppression scanf feature"), STD_C89 },
597 { 'a', 0, 0, N_("`a' flag"), N_("the `a' scanf flag"), STD_EXT },
598 { 'w', 0, 0, N_("field width"), N_("field width in scanf format"), STD_C89 },
599 { 'L', 0, 0, N_("length modifier"), N_("length modifier in scanf format"), STD_C89 },
600 { '\'', 0, 0, N_("`'' flag"), N_("the `'' scanf flag"), STD_EXT },
601 { 'I', 0, 0, N_("`I' flag"), N_("the `I' scanf flag"), STD_EXT },
602 { 0, 0, 0, NULL, NULL, 0 }
606 static const format_flag_pair scanf_flag_pairs[] =
613 static const format_flag_spec strftime_flag_specs[] =
615 { '_', 0, 0, N_("`_' flag"), N_("the `_' strftime flag"), STD_EXT },
616 { '-', 0, 0, N_("`-' flag"), N_("the `-' strftime flag"), STD_EXT },
617 { '0', 0, 0, N_("`0' flag"), N_("the `0' strftime flag"), STD_EXT },
618 { '^', 0, 0, N_("`^' flag"), N_("the `^' strftime flag"), STD_EXT },
619 { '#', 0, 0, N_("`#' flag"), N_("the `#' strftime flag"), STD_EXT },
620 { 'w', 0, 0, N_("field width"), N_("field width in strftime format"), STD_EXT },
621 { 'E', 0, 0, N_("`E' modifier"), N_("the `E' strftime modifier"), STD_C99 },
622 { 'O', 0, 0, N_("`O' modifier"), N_("the `O' strftime modifier"), STD_C99 },
623 { 'O', 'o', 0, NULL, N_("the `O' modifier"), STD_EXT },
624 { 0, 0, 0, NULL, NULL, 0 }
628 static const format_flag_pair strftime_flag_pairs[] =
639 static const format_flag_spec strfmon_flag_specs[] =
641 { '=', 0, 1, N_("fill character"), N_("fill character in strfmon format"), STD_C89 },
642 { '^', 0, 0, N_("`^' flag"), N_("the `^' strfmon flag"), STD_C89 },
643 { '+', 0, 0, N_("`+' flag"), N_("the `+' strfmon flag"), STD_C89 },
644 { '(', 0, 0, N_("`(' flag"), N_("the `(' strfmon flag"), STD_C89 },
645 { '!', 0, 0, N_("`!' flag"), N_("the `!' strfmon flag"), STD_C89 },
646 { '-', 0, 0, N_("`-' flag"), N_("the `-' strfmon flag"), STD_C89 },
647 { 'w', 0, 0, N_("field width"), N_("field width in strfmon format"), STD_C89 },
648 { '#', 0, 0, N_("left precision"), N_("left precision in strfmon format"), STD_C89 },
649 { 'p', 0, 0, N_("right precision"), N_("right precision in strfmon format"), STD_C89 },
650 { 'L', 0, 0, N_("length modifier"), N_("length modifier in strfmon format"), STD_C89 },
651 { 0, 0, 0, NULL, NULL, 0 }
654 static const format_flag_pair strfmon_flag_pairs[] =
661 #define T_I &integer_type_node
662 #define T89_I { STD_C89, NULL, T_I }
663 #define T_L &long_integer_type_node
664 #define T89_L { STD_C89, NULL, T_L }
665 #define T_LL &long_long_integer_type_node
666 #define T9L_LL { STD_C9L, NULL, T_LL }
667 #define TEX_LL { STD_EXT, NULL, T_LL }
668 #define T_S &short_integer_type_node
669 #define T89_S { STD_C89, NULL, T_S }
670 #define T_UI &unsigned_type_node
671 #define T89_UI { STD_C89, NULL, T_UI }
672 #define T_UL &long_unsigned_type_node
673 #define T89_UL { STD_C89, NULL, T_UL }
674 #define T_ULL &long_long_unsigned_type_node
675 #define T9L_ULL { STD_C9L, NULL, T_ULL }
676 #define TEX_ULL { STD_EXT, NULL, T_ULL }
677 #define T_US &short_unsigned_type_node
678 #define T89_US { STD_C89, NULL, T_US }
679 #define T_F &float_type_node
680 #define T89_F { STD_C89, NULL, T_F }
681 #define T99_F { STD_C99, NULL, T_F }
682 #define T_D &double_type_node
683 #define T89_D { STD_C89, NULL, T_D }
684 #define T99_D { STD_C99, NULL, T_D }
685 #define T_LD &long_double_type_node
686 #define T89_LD { STD_C89, NULL, T_LD }
687 #define T99_LD { STD_C99, NULL, T_LD }
688 #define T_C &char_type_node
689 #define T89_C { STD_C89, NULL, T_C }
690 #define T_SC &signed_char_type_node
691 #define T99_SC { STD_C99, NULL, T_SC }
692 #define T_UC &unsigned_char_type_node
693 #define T99_UC { STD_C99, NULL, T_UC }
694 #define T_V &void_type_node
695 #define T89_V { STD_C89, NULL, T_V }
696 #define T_W &wchar_type_node
697 #define T94_W { STD_C94, "wchar_t", T_W }
698 #define TEX_W { STD_EXT, "wchar_t", T_W }
699 #define T_WI &wint_type_node
700 #define T94_WI { STD_C94, "wint_t", T_WI }
701 #define TEX_WI { STD_EXT, "wint_t", T_WI }
702 #define T_ST &size_type_node
703 #define T99_ST { STD_C99, "size_t", T_ST }
704 #define T_SST &signed_size_type_node
705 #define T99_SST { STD_C99, "signed size_t", T_SST }
706 #define T_PD &ptrdiff_type_node
707 #define T99_PD { STD_C99, "ptrdiff_t", T_PD }
708 #define T_UPD &unsigned_ptrdiff_type_node
709 #define T99_UPD { STD_C99, "unsigned ptrdiff_t", T_UPD }
710 #define T_IM &intmax_type_node
711 #define T99_IM { STD_C99, "intmax_t", T_IM }
712 #define T_UIM &uintmax_type_node
713 #define T99_UIM { STD_C99, "uintmax_t", T_UIM }
715 static const format_char_info print_char_table[] =
717 /* C89 conversion specifiers. */
718 { "di", 0, STD_C89, { T89_I, T99_SC, T89_S, T89_L, T9L_LL, TEX_LL, T99_SST, T99_PD, T99_IM }, "-wp0 +'I", "i" },
719 { "oxX", 0, STD_C89, { T89_UI, T99_UC, T89_US, T89_UL, T9L_ULL, TEX_ULL, T99_ST, T99_UPD, T99_UIM }, "-wp0#", "i" },
720 { "u", 0, STD_C89, { T89_UI, T99_UC, T89_US, T89_UL, T9L_ULL, TEX_ULL, T99_ST, T99_UPD, T99_UIM }, "-wp0'I", "i" },
721 { "fgG", 0, STD_C89, { T89_D, BADLEN, BADLEN, T99_D, BADLEN, T89_LD, BADLEN, BADLEN, BADLEN }, "-wp0 +#'", "" },
722 { "eE", 0, STD_C89, { T89_D, BADLEN, BADLEN, T99_D, BADLEN, T89_LD, BADLEN, BADLEN, BADLEN }, "-wp0 +#", "" },
723 { "c", 0, STD_C89, { T89_I, BADLEN, BADLEN, T94_WI, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-w", "" },
724 { "s", 1, STD_C89, { T89_C, BADLEN, BADLEN, T94_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "cR" },
725 { "p", 1, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-w", "c" },
726 { "n", 1, STD_C89, { T89_I, T99_SC, T89_S, T89_L, T9L_LL, BADLEN, T99_SST, T99_PD, T99_IM }, "", "W" },
727 /* C99 conversion specifiers. */
728 { "F", 0, STD_C99, { T99_D, BADLEN, BADLEN, T99_D, BADLEN, T99_LD, BADLEN, BADLEN, BADLEN }, "-wp0 +#'", "" },
729 { "aA", 0, STD_C99, { T99_D, BADLEN, BADLEN, T99_D, BADLEN, T99_LD, BADLEN, BADLEN, BADLEN }, "-wp0 +#", "" },
730 /* X/Open conversion specifiers. */
731 { "C", 0, STD_EXT, { TEX_WI, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-w", "" },
732 { "S", 1, STD_EXT, { TEX_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "R" },
733 /* GNU conversion specifiers. */
734 { "m", 0, STD_EXT, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "" },
735 { NULL, 0, 0, NOLENGTHS, NULL, NULL }
738 static const format_char_info asm_fprintf_char_table[] =
740 /* C89 conversion specifiers. */
741 { "di", 0, STD_C89, { T89_I, BADLEN, BADLEN, T89_L, T9L_LL, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp0 +", "i" },
742 { "oxX", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp0#", "i" },
743 { "u", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp0", "i" },
744 { "c", 0, STD_C89, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-w", "" },
745 { "s", 1, STD_C89, { T89_C, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "cR" },
747 /* asm_fprintf conversion specifiers. */
748 { "O", 0, STD_C89, NOARGUMENTS, "", "" },
749 { "R", 0, STD_C89, NOARGUMENTS, "", "" },
750 { "I", 0, STD_C89, NOARGUMENTS, "", "" },
751 { "L", 0, STD_C89, NOARGUMENTS, "", "" },
752 { "U", 0, STD_C89, NOARGUMENTS, "", "" },
753 { "r", 0, STD_C89, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "", "" },
754 { "@", 0, STD_C89, NOARGUMENTS, "", "" },
755 { NULL, 0, 0, NOLENGTHS, NULL, NULL }
758 static const format_char_info scan_char_table[] =
760 /* C89 conversion specifiers. */
761 { "di", 1, STD_C89, { T89_I, T99_SC, T89_S, T89_L, T9L_LL, TEX_LL, T99_SST, T99_PD, T99_IM }, "*w'I", "W" },
762 { "u", 1, STD_C89, { T89_UI, T99_UC, T89_US, T89_UL, T9L_ULL, TEX_ULL, T99_ST, T99_UPD, T99_UIM }, "*w'I", "W" },
763 { "oxX", 1, STD_C89, { T89_UI, T99_UC, T89_US, T89_UL, T9L_ULL, TEX_ULL, T99_ST, T99_UPD, T99_UIM }, "*w", "W" },
764 { "efgEG", 1, STD_C89, { T89_F, BADLEN, BADLEN, T89_D, BADLEN, T89_LD, BADLEN, BADLEN, BADLEN }, "*w'", "W" },
765 { "c", 1, STD_C89, { T89_C, BADLEN, BADLEN, T94_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*w", "cW" },
766 { "s", 1, STD_C89, { T89_C, BADLEN, BADLEN, T94_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*aw", "cW" },
767 { "[", 1, STD_C89, { T89_C, BADLEN, BADLEN, T94_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*aw", "cW[" },
768 { "p", 2, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*w", "W" },
769 { "n", 1, STD_C89, { T89_I, T99_SC, T89_S, T89_L, T9L_LL, BADLEN, T99_SST, T99_PD, T99_IM }, "", "W" },
770 /* C99 conversion specifiers. */
771 { "FaA", 1, STD_C99, { T99_F, BADLEN, BADLEN, T99_D, BADLEN, T99_LD, BADLEN, BADLEN, BADLEN }, "*w'", "W" },
772 /* X/Open conversion specifiers. */
773 { "C", 1, STD_EXT, { TEX_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*w", "W" },
774 { "S", 1, STD_EXT, { TEX_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*aw", "W" },
775 { NULL, 0, 0, NOLENGTHS, NULL, NULL }
778 static const format_char_info time_char_table[] =
780 /* C89 conversion specifiers. */
781 { "ABZab", 0, STD_C89, NOLENGTHS, "^#", "" },
782 { "cx", 0, STD_C89, NOLENGTHS, "E", "3" },
783 { "HIMSUWdmw", 0, STD_C89, NOLENGTHS, "-_0Ow", "" },
784 { "j", 0, STD_C89, NOLENGTHS, "-_0Ow", "o" },
785 { "p", 0, STD_C89, NOLENGTHS, "#", "" },
786 { "X", 0, STD_C89, NOLENGTHS, "E", "" },
787 { "y", 0, STD_C89, NOLENGTHS, "EO-_0w", "4" },
788 { "Y", 0, STD_C89, NOLENGTHS, "-_0EOw", "o" },
789 { "%", 0, STD_C89, NOLENGTHS, "", "" },
790 /* C99 conversion specifiers. */
791 { "C", 0, STD_C99, NOLENGTHS, "-_0EOw", "o" },
792 { "D", 0, STD_C99, NOLENGTHS, "", "2" },
793 { "eVu", 0, STD_C99, NOLENGTHS, "-_0Ow", "" },
794 { "FRTnrt", 0, STD_C99, NOLENGTHS, "", "" },
795 { "g", 0, STD_C99, NOLENGTHS, "O-_0w", "2o" },
796 { "G", 0, STD_C99, NOLENGTHS, "-_0Ow", "o" },
797 { "h", 0, STD_C99, NOLENGTHS, "^#", "" },
798 { "z", 0, STD_C99, NOLENGTHS, "O", "o" },
799 /* GNU conversion specifiers. */
800 { "kls", 0, STD_EXT, NOLENGTHS, "-_0Ow", "" },
801 { "P", 0, STD_EXT, NOLENGTHS, "", "" },
802 { NULL, 0, 0, NOLENGTHS, NULL, NULL }
805 static const format_char_info monetary_char_table[] =
807 { "in", 0, STD_C89, { T89_D, BADLEN, BADLEN, BADLEN, BADLEN, T89_LD, BADLEN, BADLEN, BADLEN }, "=^+(!-w#p", "" },
808 { NULL, 0, 0, NOLENGTHS, NULL, NULL }
812 /* This must be in the same order as enum format_type. */
813 static const format_kind_info format_types_orig[] =
815 { "printf", printf_length_specs, print_char_table, " +#0-'I", NULL,
816 printf_flag_specs, printf_flag_pairs,
817 FMT_FLAG_ARG_CONVERT|FMT_FLAG_DOLLAR_MULTIPLE|FMT_FLAG_USE_DOLLAR|FMT_FLAG_EMPTY_PREC_OK,
819 &integer_type_node, &integer_type_node
821 { "asm_fprintf", asm_fprintf_length_specs, asm_fprintf_char_table, " +#0-", NULL,
822 asm_fprintf_flag_specs, asm_fprintf_flag_pairs,
823 FMT_FLAG_ARG_CONVERT|FMT_FLAG_EMPTY_PREC_OK,
827 { "scanf", scanf_length_specs, scan_char_table, "*'I", NULL,
828 scanf_flag_specs, scanf_flag_pairs,
829 FMT_FLAG_ARG_CONVERT|FMT_FLAG_SCANF_A_KLUDGE|FMT_FLAG_USE_DOLLAR|FMT_FLAG_ZERO_WIDTH_BAD|FMT_FLAG_DOLLAR_GAP_POINTER_OK,
833 { "strftime", NULL, time_char_table, "_-0^#", "EO",
834 strftime_flag_specs, strftime_flag_pairs,
835 FMT_FLAG_FANCY_PERCENT_OK, 'w', 0, 0, 0, 0,
838 { "strfmon", strfmon_length_specs, monetary_char_table, "=^+(!-", NULL,
839 strfmon_flag_specs, strfmon_flag_pairs,
840 FMT_FLAG_ARG_CONVERT, 'w', '#', 'p', 0, 'L',
845 /* This layer of indirection allows GCC to reassign format_types with
846 new data if necessary, while still allowing the original data to be
848 static const format_kind_info *format_types = format_types_orig;
849 /* We can modify this one. */
850 static format_kind_info *dynamic_format_types;
852 /* Structure detailing the results of checking a format function call
853 where the format expression may be a conditional expression with
854 many leaves resulting from nested conditional expressions. */
857 /* Number of leaves of the format argument that could not be checked
858 as they were not string literals. */
859 int number_non_literal;
860 /* Number of leaves of the format argument that were null pointers or
861 string literals, but had extra format arguments. */
862 int number_extra_args;
863 /* Number of leaves of the format argument that were null pointers or
864 string literals, but had extra format arguments and used $ operand
866 int number_dollar_extra_args;
867 /* Number of leaves of the format argument that were wide string
870 /* Number of leaves of the format argument that were empty strings. */
872 /* Number of leaves of the format argument that were unterminated
874 int number_unterminated;
875 /* Number of leaves of the format argument that were not counted above. */
877 } format_check_results;
881 format_check_results *res;
882 function_format_info *info;
885 } format_check_context;
887 static void check_format_info (int *, function_format_info *, tree);
888 static void check_format_arg (void *, tree, unsigned HOST_WIDE_INT);
889 static void check_format_info_main (int *, format_check_results *,
890 function_format_info *,
891 const char *, int, tree,
892 unsigned HOST_WIDE_INT);
893 static void status_warning (int *, const char *, ...)
896 static void init_dollar_format_checking (int, tree);
897 static int maybe_read_dollar_number (int *, const char **, int,
898 tree, tree *, const format_kind_info *);
899 static void finish_dollar_format_checking (int *, format_check_results *, int);
901 static const format_flag_spec *get_flag_spec (const format_flag_spec *,
904 static void check_format_types (int *, format_wanted_type *);
906 /* Decode a format type from a string, returning the type, or
907 format_type_error if not valid, in which case the caller should print an
909 static enum format_type
910 decode_format_type (const char *s)
915 for (i = 0; i < (int) format_type_error; i++)
918 if (!strcmp (s, format_types[i].name))
920 alen = strlen (format_types[i].name);
921 if (slen == alen + 4 && s[0] == '_' && s[1] == '_'
922 && s[slen - 1] == '_' && s[slen - 2] == '_'
923 && !strncmp (s + 2, format_types[i].name, alen))
926 return ((enum format_type) i);
930 /* Check the argument list of a call to printf, scanf, etc.
931 ATTRS are the attributes on the function type.
932 PARAMS is the list of argument values. Also, if -Wmissing-format-attribute,
933 warn for calls to vprintf or vscanf in functions with no such format
934 attribute themselves. */
937 check_function_format (int *status, tree attrs, tree params)
941 /* See if this function has any format attributes. */
942 for (a = attrs; a; a = TREE_CHAIN (a))
944 if (is_attribute_p ("format", TREE_PURPOSE (a)))
947 function_format_info info;
948 decode_format_attr (TREE_VALUE (a), &info, 1);
949 check_format_info (status, &info, params);
950 if (warn_missing_format_attribute && info.first_arg_num == 0
951 && (format_types[info.format_type].flags
952 & (int) FMT_FLAG_ARG_CONVERT))
955 for (c = TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl));
958 if (is_attribute_p ("format", TREE_PURPOSE (c))
959 && (decode_format_type (IDENTIFIER_POINTER
960 (TREE_VALUE (TREE_VALUE (c))))
961 == info.format_type))
965 /* Check if the current function has a parameter to which
966 the format attribute could be attached; if not, it
967 can't be a candidate for a format attribute, despite
968 the vprintf-like or vscanf-like call. */
970 for (args = DECL_ARGUMENTS (current_function_decl);
972 args = TREE_CHAIN (args))
974 if (TREE_CODE (TREE_TYPE (args)) == POINTER_TYPE
975 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (args)))
980 warning ("function might be possible candidate for `%s' format attribute",
981 format_types[info.format_type].name);
988 /* This function replaces `warning' inside the printf format checking
989 functions. If the `status' parameter is non-NULL, then it is
990 dereferenced and set to 1 whenever a warning is caught. Otherwise
991 it warns as usual by replicating the innards of the warning
992 function from diagnostic.c. */
994 status_warning (int *status, const char *msgid, ...)
996 diagnostic_info diagnostic ;
999 va_start (ap, msgid);
1005 /* This duplicates the warning function behavior. */
1006 diagnostic_set_info (&diagnostic, _(msgid), &ap,
1007 input_filename, input_line, DK_WARNING);
1008 report_diagnostic (&diagnostic);
1014 /* Variables used by the checking of $ operand number formats. */
1015 static char *dollar_arguments_used = NULL;
1016 static char *dollar_arguments_pointer_p = NULL;
1017 static int dollar_arguments_alloc = 0;
1018 static int dollar_arguments_count;
1019 static int dollar_first_arg_num;
1020 static int dollar_max_arg_used;
1021 static int dollar_format_warned;
1023 /* Initialize the checking for a format string that may contain $
1024 parameter number specifications; we will need to keep track of whether
1025 each parameter has been used. FIRST_ARG_NUM is the number of the first
1026 argument that is a parameter to the format, or 0 for a vprintf-style
1027 function; PARAMS is the list of arguments starting at this argument. */
1030 init_dollar_format_checking (int first_arg_num, tree params)
1032 tree oparams = params;
1034 dollar_first_arg_num = first_arg_num;
1035 dollar_arguments_count = 0;
1036 dollar_max_arg_used = 0;
1037 dollar_format_warned = 0;
1038 if (first_arg_num > 0)
1042 dollar_arguments_count++;
1043 params = TREE_CHAIN (params);
1046 if (dollar_arguments_alloc < dollar_arguments_count)
1048 if (dollar_arguments_used)
1049 free (dollar_arguments_used);
1050 if (dollar_arguments_pointer_p)
1051 free (dollar_arguments_pointer_p);
1052 dollar_arguments_alloc = dollar_arguments_count;
1053 dollar_arguments_used = xmalloc (dollar_arguments_alloc);
1054 dollar_arguments_pointer_p = xmalloc (dollar_arguments_alloc);
1056 if (dollar_arguments_alloc)
1058 memset (dollar_arguments_used, 0, dollar_arguments_alloc);
1059 if (first_arg_num > 0)
1065 dollar_arguments_pointer_p[i] = (TREE_CODE (TREE_TYPE (TREE_VALUE (params)))
1067 params = TREE_CHAIN (params);
1075 /* Look for a decimal number followed by a $ in *FORMAT. If DOLLAR_NEEDED
1076 is set, it is an error if one is not found; otherwise, it is OK. If
1077 such a number is found, check whether it is within range and mark that
1078 numbered operand as being used for later checking. Returns the operand
1079 number if found and within range, zero if no such number was found and
1080 this is OK, or -1 on error. PARAMS points to the first operand of the
1081 format; PARAM_PTR is made to point to the parameter referred to. If
1082 a $ format is found, *FORMAT is updated to point just after it. */
1085 maybe_read_dollar_number (int *status, const char **format,
1086 int dollar_needed, tree params, tree *param_ptr,
1087 const format_kind_info *fki)
1091 const char *fcp = *format;
1092 if (! ISDIGIT (*fcp))
1096 status_warning (status, "missing $ operand number in format");
1104 while (ISDIGIT (*fcp))
1107 nargnum = 10 * argnum + (*fcp - '0');
1108 if (nargnum < 0 || nargnum / 10 != argnum)
1117 status_warning (status, "missing $ operand number in format");
1124 if (pedantic && !dollar_format_warned)
1126 status_warning (status,
1127 "%s does not support %%n$ operand number formats",
1128 C_STD_NAME (STD_EXT));
1129 dollar_format_warned = 1;
1131 if (overflow_flag || argnum == 0
1132 || (dollar_first_arg_num && argnum > dollar_arguments_count))
1134 status_warning (status, "operand number out of range in format");
1137 if (argnum > dollar_max_arg_used)
1138 dollar_max_arg_used = argnum;
1139 /* For vprintf-style functions we may need to allocate more memory to
1140 track which arguments are used. */
1141 while (dollar_arguments_alloc < dollar_max_arg_used)
1144 nalloc = 2 * dollar_arguments_alloc + 16;
1145 dollar_arguments_used = xrealloc (dollar_arguments_used, nalloc);
1146 dollar_arguments_pointer_p = xrealloc (dollar_arguments_pointer_p,
1148 memset (dollar_arguments_used + dollar_arguments_alloc, 0,
1149 nalloc - dollar_arguments_alloc);
1150 dollar_arguments_alloc = nalloc;
1152 if (!(fki->flags & (int) FMT_FLAG_DOLLAR_MULTIPLE)
1153 && dollar_arguments_used[argnum - 1] == 1)
1155 dollar_arguments_used[argnum - 1] = 2;
1156 status_warning (status,
1157 "format argument %d used more than once in %s format",
1161 dollar_arguments_used[argnum - 1] = 1;
1162 if (dollar_first_arg_num)
1165 *param_ptr = params;
1166 for (i = 1; i < argnum && *param_ptr != 0; i++)
1167 *param_ptr = TREE_CHAIN (*param_ptr);
1169 if (*param_ptr == 0)
1171 /* This case shouldn't be caught here. */
1181 /* Finish the checking for a format string that used $ operand number formats
1182 instead of non-$ formats. We check for unused operands before used ones
1183 (a serious error, since the implementation of the format function
1184 can't know what types to pass to va_arg to find the later arguments).
1185 and for unused operands at the end of the format (if we know how many
1186 arguments the format had, so not for vprintf). If there were operand
1187 numbers out of range on a non-vprintf-style format, we won't have reached
1188 here. If POINTER_GAP_OK, unused arguments are OK if all arguments are
1192 finish_dollar_format_checking (int *status, format_check_results *res, int pointer_gap_ok)
1195 bool found_pointer_gap = false;
1196 for (i = 0; i < dollar_max_arg_used; i++)
1198 if (!dollar_arguments_used[i])
1200 if (pointer_gap_ok && (dollar_first_arg_num == 0
1201 || dollar_arguments_pointer_p[i]))
1202 found_pointer_gap = true;
1204 status_warning (status, "format argument %d unused before used argument %d in $-style format",
1205 i + 1, dollar_max_arg_used);
1208 if (found_pointer_gap
1209 || (dollar_first_arg_num
1210 && dollar_max_arg_used < dollar_arguments_count))
1212 res->number_other--;
1213 res->number_dollar_extra_args++;
1218 /* Retrieve the specification for a format flag. SPEC contains the
1219 specifications for format flags for the applicable kind of format.
1220 FLAG is the flag in question. If PREDICATES is NULL, the basic
1221 spec for that flag must be retrieved and this function aborts if
1222 it cannot be found. If PREDICATES is not NULL, it is a string listing
1223 possible predicates for the spec entry; if an entry predicated on any
1224 of these is found, it is returned, otherwise NULL is returned. */
1226 static const format_flag_spec *
1227 get_flag_spec (const format_flag_spec *spec, int flag, const char *predicates)
1230 for (i = 0; spec[i].flag_char != 0; i++)
1232 if (spec[i].flag_char != flag)
1234 if (predicates != NULL)
1236 if (spec[i].predicate != 0
1237 && strchr (predicates, spec[i].predicate) != 0)
1240 else if (spec[i].predicate == 0)
1243 if (predicates == NULL)
1250 /* Check the argument list of a call to printf, scanf, etc.
1251 INFO points to the function_format_info structure.
1252 PARAMS is the list of argument values. */
1255 check_format_info (int *status, function_format_info *info, tree params)
1257 format_check_context format_ctx;
1258 unsigned HOST_WIDE_INT arg_num;
1260 format_check_results res;
1261 /* Skip to format argument. If the argument isn't available, there's
1262 no work for us to do; prototype checking will catch the problem. */
1263 for (arg_num = 1; ; ++arg_num)
1267 if (arg_num == info->format_num)
1269 params = TREE_CHAIN (params);
1271 format_tree = TREE_VALUE (params);
1272 params = TREE_CHAIN (params);
1273 if (format_tree == 0)
1276 res.number_non_literal = 0;
1277 res.number_extra_args = 0;
1278 res.number_dollar_extra_args = 0;
1279 res.number_wide = 0;
1280 res.number_empty = 0;
1281 res.number_unterminated = 0;
1282 res.number_other = 0;
1284 format_ctx.res = &res;
1285 format_ctx.info = info;
1286 format_ctx.params = params;
1287 format_ctx.status = status;
1289 check_function_arguments_recurse (check_format_arg, &format_ctx,
1290 format_tree, arg_num);
1292 if (res.number_non_literal > 0)
1294 /* Functions taking a va_list normally pass a non-literal format
1295 string. These functions typically are declared with
1296 first_arg_num == 0, so avoid warning in those cases. */
1297 if (!(format_types[info->format_type].flags & (int) FMT_FLAG_ARG_CONVERT))
1299 /* For strftime-like formats, warn for not checking the format
1300 string; but there are no arguments to check. */
1301 if (warn_format_nonliteral)
1302 status_warning (status, "format not a string literal, format string not checked");
1304 else if (info->first_arg_num != 0)
1306 /* If there are no arguments for the format at all, we may have
1307 printf (foo) which is likely to be a security hole. */
1308 while (arg_num + 1 < info->first_arg_num)
1312 params = TREE_CHAIN (params);
1315 if (params == 0 && (warn_format_nonliteral || warn_format_security))
1316 status_warning (status, "format not a string literal and no format arguments");
1317 else if (warn_format_nonliteral)
1318 status_warning (status, "format not a string literal, argument types not checked");
1322 /* If there were extra arguments to the format, normally warn. However,
1323 the standard does say extra arguments are ignored, so in the specific
1324 case where we have multiple leaves (conditional expressions or
1325 ngettext) allow extra arguments if at least one leaf didn't have extra
1326 arguments, but was otherwise OK (either non-literal or checked OK).
1327 If the format is an empty string, this should be counted similarly to the
1328 case of extra format arguments. */
1329 if (res.number_extra_args > 0 && res.number_non_literal == 0
1330 && res.number_other == 0 && warn_format_extra_args)
1331 status_warning (status, "too many arguments for format");
1332 if (res.number_dollar_extra_args > 0 && res.number_non_literal == 0
1333 && res.number_other == 0 && warn_format_extra_args)
1334 status_warning (status, "unused arguments in $-style format");
1335 if (res.number_empty > 0 && res.number_non_literal == 0
1336 && res.number_other == 0 && warn_format_zero_length)
1337 status_warning (status, "zero-length %s format string",
1338 format_types[info->format_type].name);
1340 if (res.number_wide > 0)
1341 status_warning (status, "format is a wide character string");
1343 if (res.number_unterminated > 0)
1344 status_warning (status, "unterminated format string");
1347 /* Callback from check_function_arguments_recurse to check a
1348 format string. FORMAT_TREE is the format parameter. ARG_NUM
1349 is the number of the format argument. CTX points to a
1350 format_check_context. */
1353 check_format_arg (void *ctx, tree format_tree,
1354 unsigned HOST_WIDE_INT arg_num)
1356 format_check_context *format_ctx = ctx;
1357 format_check_results *res = format_ctx->res;
1358 function_format_info *info = format_ctx->info;
1359 tree params = format_ctx->params;
1360 int *status = format_ctx->status;
1363 HOST_WIDE_INT offset;
1364 const char *format_chars;
1365 tree array_size = 0;
1368 if (integer_zerop (format_tree))
1370 /* Skip to first argument to check, so we can see if this format
1371 has any arguments (it shouldn't). */
1372 while (arg_num + 1 < info->first_arg_num)
1376 params = TREE_CHAIN (params);
1381 res->number_other++;
1383 res->number_extra_args++;
1389 if (TREE_CODE (format_tree) == PLUS_EXPR)
1393 arg0 = TREE_OPERAND (format_tree, 0);
1394 arg1 = TREE_OPERAND (format_tree, 1);
1397 if (TREE_CODE (arg1) == INTEGER_CST)
1399 else if (TREE_CODE (arg0) == INTEGER_CST)
1406 res->number_non_literal++;
1409 if (!host_integerp (arg1, 0)
1410 || (offset = tree_low_cst (arg1, 0)) < 0)
1412 res->number_non_literal++;
1416 if (TREE_CODE (format_tree) != ADDR_EXPR)
1418 res->number_non_literal++;
1421 format_tree = TREE_OPERAND (format_tree, 0);
1422 if (TREE_CODE (format_tree) == VAR_DECL
1423 && TREE_CODE (TREE_TYPE (format_tree)) == ARRAY_TYPE
1424 && (array_init = decl_constant_value (format_tree)) != format_tree
1425 && TREE_CODE (array_init) == STRING_CST)
1427 /* Extract the string constant initializer. Note that this may include
1428 a trailing NUL character that is not in the array (e.g.
1429 const char a[3] = "foo";). */
1430 array_size = DECL_SIZE_UNIT (format_tree);
1431 format_tree = array_init;
1433 if (TREE_CODE (format_tree) != STRING_CST)
1435 res->number_non_literal++;
1438 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (format_tree))) != char_type_node)
1443 format_chars = TREE_STRING_POINTER (format_tree);
1444 format_length = TREE_STRING_LENGTH (format_tree);
1445 if (array_size != 0)
1447 /* Variable length arrays can't be initialized. */
1448 if (TREE_CODE (array_size) != INTEGER_CST)
1450 if (host_integerp (array_size, 0))
1452 HOST_WIDE_INT array_size_value = TREE_INT_CST_LOW (array_size);
1453 if (array_size_value > 0
1454 && array_size_value == (int) array_size_value
1455 && format_length > array_size_value)
1456 format_length = array_size_value;
1461 if (offset >= format_length)
1463 res->number_non_literal++;
1466 format_chars += offset;
1467 format_length -= offset;
1469 if (format_length < 1)
1471 res->number_unterminated++;
1474 if (format_length == 1)
1476 res->number_empty++;
1479 if (format_chars[--format_length] != 0)
1481 res->number_unterminated++;
1485 /* Skip to first argument to check. */
1486 while (arg_num + 1 < info->first_arg_num)
1490 params = TREE_CHAIN (params);
1493 /* Provisionally increment res->number_other; check_format_info_main
1494 will decrement it if it finds there are extra arguments, but this way
1495 need not adjust it for every return. */
1496 res->number_other++;
1497 check_format_info_main (status, res, info, format_chars, format_length,
1502 /* Do the main part of checking a call to a format function. FORMAT_CHARS
1503 is the NUL-terminated format string (which at this point may contain
1504 internal NUL characters); FORMAT_LENGTH is its length (excluding the
1505 terminating NUL character). ARG_NUM is one less than the number of
1506 the first format argument to check; PARAMS points to that format
1507 argument in the list of arguments. */
1510 check_format_info_main (int *status, format_check_results *res,
1511 function_format_info *info, const char *format_chars,
1512 int format_length, tree params,
1513 unsigned HOST_WIDE_INT arg_num)
1515 const char *orig_format_chars = format_chars;
1516 tree first_fillin_param = params;
1518 const format_kind_info *fki = &format_types[info->format_type];
1519 const format_flag_spec *flag_specs = fki->flag_specs;
1520 const format_flag_pair *bad_flag_pairs = fki->bad_flag_pairs;
1522 /* -1 if no conversions taking an operand have been found; 0 if one has
1523 and it didn't use $; 1 if $ formats are in use. */
1524 int has_operand_number = -1;
1526 init_dollar_format_checking (info->first_arg_num, first_fillin_param);
1531 int suppressed = FALSE;
1532 const char *length_chars = NULL;
1533 enum format_lengths length_chars_val = FMT_LEN_none;
1534 enum format_std_version length_chars_std = STD_C89;
1538 int main_arg_num = 0;
1539 tree main_arg_params = 0;
1540 enum format_std_version wanted_type_std;
1541 const char *wanted_type_name;
1542 format_wanted_type width_wanted_type;
1543 format_wanted_type precision_wanted_type;
1544 format_wanted_type main_wanted_type;
1545 format_wanted_type *first_wanted_type = NULL;
1546 format_wanted_type *last_wanted_type = NULL;
1547 const format_length_info *fli = NULL;
1548 const format_char_info *fci = NULL;
1549 char flag_chars[256];
1551 if (*format_chars == 0)
1553 if (format_chars - orig_format_chars != format_length)
1554 status_warning (status, "embedded `\\0' in format");
1555 if (info->first_arg_num != 0 && params != 0
1556 && has_operand_number <= 0)
1558 res->number_other--;
1559 res->number_extra_args++;
1561 if (has_operand_number > 0)
1562 finish_dollar_format_checking (status, res, fki->flags & (int) FMT_FLAG_DOLLAR_GAP_POINTER_OK);
1565 if (*format_chars++ != '%')
1567 if (*format_chars == 0)
1569 status_warning (status, "spurious trailing `%%' in format");
1572 if (*format_chars == '%')
1579 if ((fki->flags & (int) FMT_FLAG_USE_DOLLAR) && has_operand_number != 0)
1581 /* Possibly read a $ operand number at the start of the format.
1582 If one was previously used, one is required here. If one
1583 is not used here, we can't immediately conclude this is a
1584 format without them, since it could be printf %m or scanf %*. */
1586 opnum = maybe_read_dollar_number (status, &format_chars, 0,
1588 &main_arg_params, fki);
1593 has_operand_number = 1;
1594 main_arg_num = opnum + info->first_arg_num - 1;
1598 /* Read any format flags, but do not yet validate them beyond removing
1599 duplicates, since in general validation depends on the rest of
1601 while (*format_chars != 0
1602 && strchr (fki->flag_chars, *format_chars) != 0)
1604 const format_flag_spec *s = get_flag_spec (flag_specs,
1605 *format_chars, NULL);
1606 if (strchr (flag_chars, *format_chars) != 0)
1608 status_warning (status, "repeated %s in format", _(s->name));
1612 i = strlen (flag_chars);
1613 flag_chars[i++] = *format_chars;
1616 if (s->skip_next_char)
1619 if (*format_chars == 0)
1621 status_warning (status, "missing fill character at end of strfmon format");
1628 /* Read any format width, possibly * or *m$. */
1629 if (fki->width_char != 0)
1631 if (fki->width_type != NULL && *format_chars == '*')
1633 i = strlen (flag_chars);
1634 flag_chars[i++] = fki->width_char;
1636 /* "...a field width...may be indicated by an asterisk.
1637 In this case, an int argument supplies the field width..." */
1639 if (has_operand_number != 0)
1642 opnum = maybe_read_dollar_number (status, &format_chars,
1643 has_operand_number == 1,
1650 has_operand_number = 1;
1651 arg_num = opnum + info->first_arg_num - 1;
1654 has_operand_number = 0;
1656 if (info->first_arg_num != 0)
1660 status_warning (status, "too few arguments for format");
1663 cur_param = TREE_VALUE (params);
1664 if (has_operand_number <= 0)
1666 params = TREE_CHAIN (params);
1669 width_wanted_type.wanted_type = *fki->width_type;
1670 width_wanted_type.wanted_type_name = NULL;
1671 width_wanted_type.pointer_count = 0;
1672 width_wanted_type.char_lenient_flag = 0;
1673 width_wanted_type.writing_in_flag = 0;
1674 width_wanted_type.reading_from_flag = 0;
1675 width_wanted_type.name = _("field width");
1676 width_wanted_type.param = cur_param;
1677 width_wanted_type.arg_num = arg_num;
1678 width_wanted_type.next = NULL;
1679 if (last_wanted_type != 0)
1680 last_wanted_type->next = &width_wanted_type;
1681 if (first_wanted_type == 0)
1682 first_wanted_type = &width_wanted_type;
1683 last_wanted_type = &width_wanted_type;
1688 /* Possibly read a numeric width. If the width is zero,
1689 we complain if appropriate. */
1690 int non_zero_width_char = FALSE;
1691 int found_width = FALSE;
1692 while (ISDIGIT (*format_chars))
1695 if (*format_chars != '0')
1696 non_zero_width_char = TRUE;
1699 if (found_width && !non_zero_width_char &&
1700 (fki->flags & (int) FMT_FLAG_ZERO_WIDTH_BAD))
1701 status_warning (status, "zero width in %s format",
1705 i = strlen (flag_chars);
1706 flag_chars[i++] = fki->width_char;
1712 /* Read any format left precision (must be a number, not *). */
1713 if (fki->left_precision_char != 0 && *format_chars == '#')
1716 i = strlen (flag_chars);
1717 flag_chars[i++] = fki->left_precision_char;
1719 if (!ISDIGIT (*format_chars))
1720 status_warning (status, "empty left precision in %s format",
1722 while (ISDIGIT (*format_chars))
1726 /* Read any format precision, possibly * or *m$. */
1727 if (fki->precision_char != 0 && *format_chars == '.')
1730 i = strlen (flag_chars);
1731 flag_chars[i++] = fki->precision_char;
1733 if (fki->precision_type != NULL && *format_chars == '*')
1735 /* "...a...precision...may be indicated by an asterisk.
1736 In this case, an int argument supplies the...precision." */
1738 if (has_operand_number != 0)
1741 opnum = maybe_read_dollar_number (status, &format_chars,
1742 has_operand_number == 1,
1749 has_operand_number = 1;
1750 arg_num = opnum + info->first_arg_num - 1;
1753 has_operand_number = 0;
1755 if (info->first_arg_num != 0)
1759 status_warning (status, "too few arguments for format");
1762 cur_param = TREE_VALUE (params);
1763 if (has_operand_number <= 0)
1765 params = TREE_CHAIN (params);
1768 precision_wanted_type.wanted_type = *fki->precision_type;
1769 precision_wanted_type.wanted_type_name = NULL;
1770 precision_wanted_type.pointer_count = 0;
1771 precision_wanted_type.char_lenient_flag = 0;
1772 precision_wanted_type.writing_in_flag = 0;
1773 precision_wanted_type.reading_from_flag = 0;
1774 precision_wanted_type.name = _("field precision");
1775 precision_wanted_type.param = cur_param;
1776 precision_wanted_type.arg_num = arg_num;
1777 precision_wanted_type.next = NULL;
1778 if (last_wanted_type != 0)
1779 last_wanted_type->next = &precision_wanted_type;
1780 if (first_wanted_type == 0)
1781 first_wanted_type = &precision_wanted_type;
1782 last_wanted_type = &precision_wanted_type;
1787 if (!(fki->flags & (int) FMT_FLAG_EMPTY_PREC_OK)
1788 && !ISDIGIT (*format_chars))
1789 status_warning (status, "empty precision in %s format",
1791 while (ISDIGIT (*format_chars))
1796 /* Read any length modifier, if this kind of format has them. */
1797 fli = fki->length_char_specs;
1798 length_chars = NULL;
1799 length_chars_val = FMT_LEN_none;
1800 length_chars_std = STD_C89;
1803 while (fli->name != 0 && fli->name[0] != *format_chars)
1808 if (fli->double_name != 0 && fli->name[0] == *format_chars)
1811 length_chars = fli->double_name;
1812 length_chars_val = fli->double_index;
1813 length_chars_std = fli->double_std;
1817 length_chars = fli->name;
1818 length_chars_val = fli->index;
1819 length_chars_std = fli->std;
1821 i = strlen (flag_chars);
1822 flag_chars[i++] = fki->length_code_char;
1827 /* Warn if the length modifier is non-standard. */
1828 if (ADJ_STD (length_chars_std) > C_STD_VER)
1829 status_warning (status, "%s does not support the `%s' %s length modifier",
1830 C_STD_NAME (length_chars_std), length_chars,
1835 /* Read any modifier (strftime E/O). */
1836 if (fki->modifier_chars != NULL)
1838 while (*format_chars != 0
1839 && strchr (fki->modifier_chars, *format_chars) != 0)
1841 if (strchr (flag_chars, *format_chars) != 0)
1843 const format_flag_spec *s = get_flag_spec (flag_specs,
1844 *format_chars, NULL);
1845 status_warning (status, "repeated %s in format", _(s->name));
1849 i = strlen (flag_chars);
1850 flag_chars[i++] = *format_chars;
1857 /* Handle the scanf allocation kludge. */
1858 if (fki->flags & (int) FMT_FLAG_SCANF_A_KLUDGE)
1860 if (*format_chars == 'a' && !flag_isoc99)
1862 if (format_chars[1] == 's' || format_chars[1] == 'S'
1863 || format_chars[1] == '[')
1865 /* `a' is used as a flag. */
1866 i = strlen (flag_chars);
1867 flag_chars[i++] = 'a';
1874 format_char = *format_chars;
1875 if (format_char == 0
1876 || (!(fki->flags & (int) FMT_FLAG_FANCY_PERCENT_OK)
1877 && format_char == '%'))
1879 status_warning (status, "conversion lacks type at end of format");
1883 fci = fki->conversion_specs;
1884 while (fci->format_chars != 0
1885 && strchr (fci->format_chars, format_char) == 0)
1887 if (fci->format_chars == 0)
1889 if (ISGRAPH(format_char))
1890 status_warning (status, "unknown conversion type character `%c' in format",
1893 status_warning (status, "unknown conversion type character 0x%x in format",
1899 if (ADJ_STD (fci->std) > C_STD_VER)
1900 status_warning (status, "%s does not support the `%%%c' %s format",
1901 C_STD_NAME (fci->std), format_char, fki->name);
1904 /* Validate the individual flags used, removing any that are invalid. */
1907 for (i = 0; flag_chars[i] != 0; i++)
1909 const format_flag_spec *s = get_flag_spec (flag_specs,
1910 flag_chars[i], NULL);
1911 flag_chars[i - d] = flag_chars[i];
1912 if (flag_chars[i] == fki->length_code_char)
1914 if (strchr (fci->flag_chars, flag_chars[i]) == 0)
1916 status_warning (status, "%s used with `%%%c' %s format",
1917 _(s->name), format_char, fki->name);
1923 const format_flag_spec *t;
1924 if (ADJ_STD (s->std) > C_STD_VER)
1925 status_warning (status, "%s does not support %s",
1926 C_STD_NAME (s->std), _(s->long_name));
1927 t = get_flag_spec (flag_specs, flag_chars[i], fci->flags2);
1928 if (t != NULL && ADJ_STD (t->std) > ADJ_STD (s->std))
1930 const char *long_name = (t->long_name != NULL
1933 if (ADJ_STD (t->std) > C_STD_VER)
1934 status_warning (status, "%s does not support %s with the `%%%c' %s format",
1935 C_STD_NAME (t->std), _(long_name),
1936 format_char, fki->name);
1940 flag_chars[i - d] = 0;
1943 if ((fki->flags & (int) FMT_FLAG_SCANF_A_KLUDGE)
1944 && strchr (flag_chars, 'a') != 0)
1947 if (fki->suppression_char
1948 && strchr (flag_chars, fki->suppression_char) != 0)
1951 /* Validate the pairs of flags used. */
1952 for (i = 0; bad_flag_pairs[i].flag_char1 != 0; i++)
1954 const format_flag_spec *s, *t;
1955 if (strchr (flag_chars, bad_flag_pairs[i].flag_char1) == 0)
1957 if (strchr (flag_chars, bad_flag_pairs[i].flag_char2) == 0)
1959 if (bad_flag_pairs[i].predicate != 0
1960 && strchr (fci->flags2, bad_flag_pairs[i].predicate) == 0)
1962 s = get_flag_spec (flag_specs, bad_flag_pairs[i].flag_char1, NULL);
1963 t = get_flag_spec (flag_specs, bad_flag_pairs[i].flag_char2, NULL);
1964 if (bad_flag_pairs[i].ignored)
1966 if (bad_flag_pairs[i].predicate != 0)
1967 status_warning (status, "%s ignored with %s and `%%%c' %s format",
1968 _(s->name), _(t->name), format_char,
1971 status_warning (status, "%s ignored with %s in %s format",
1972 _(s->name), _(t->name), fki->name);
1976 if (bad_flag_pairs[i].predicate != 0)
1977 status_warning (status, "use of %s and %s together with `%%%c' %s format",
1978 _(s->name), _(t->name), format_char,
1981 status_warning (status, "use of %s and %s together in %s format",
1982 _(s->name), _(t->name), fki->name);
1986 /* Give Y2K warnings. */
1987 if (warn_format_y2k)
1990 if (strchr (fci->flags2, '4') != 0)
1991 if (strchr (flag_chars, 'E') != 0)
1995 else if (strchr (fci->flags2, '3') != 0)
1997 else if (strchr (fci->flags2, '2') != 0)
2000 status_warning (status, "`%%%c' yields only last 2 digits of year in some locales",
2002 else if (y2k_level == 2)
2003 status_warning (status, "`%%%c' yields only last 2 digits of year", format_char);
2006 if (strchr (fci->flags2, '[') != 0)
2008 /* Skip over scan set, in case it happens to have '%' in it. */
2009 if (*format_chars == '^')
2011 /* Find closing bracket; if one is hit immediately, then
2012 it's part of the scan set rather than a terminator. */
2013 if (*format_chars == ']')
2015 while (*format_chars && *format_chars != ']')
2017 if (*format_chars != ']')
2018 /* The end of the format string was reached. */
2019 status_warning (status, "no closing `]' for `%%[' format");
2023 wanted_type_name = 0;
2024 if (fki->flags & (int) FMT_FLAG_ARG_CONVERT)
2026 wanted_type = (fci->types[length_chars_val].type
2027 ? *fci->types[length_chars_val].type : 0);
2028 wanted_type_name = fci->types[length_chars_val].name;
2029 wanted_type_std = fci->types[length_chars_val].std;
2030 if (wanted_type == 0)
2032 status_warning (status, "use of `%s' length modifier with `%c' type character",
2033 length_chars, format_char);
2034 /* Heuristic: skip one argument when an invalid length/type
2035 combination is encountered. */
2039 status_warning (status, "too few arguments for format");
2042 params = TREE_CHAIN (params);
2046 /* Warn if non-standard, provided it is more non-standard
2047 than the length and type characters that may already
2048 have been warned for. */
2049 && ADJ_STD (wanted_type_std) > ADJ_STD (length_chars_std)
2050 && ADJ_STD (wanted_type_std) > ADJ_STD (fci->std))
2052 if (ADJ_STD (wanted_type_std) > C_STD_VER)
2053 status_warning (status, "%s does not support the `%%%s%c' %s format",
2054 C_STD_NAME (wanted_type_std), length_chars,
2055 format_char, fki->name);
2059 /* Finally. . .check type of argument against desired type! */
2060 if (info->first_arg_num == 0)
2062 if ((fci->pointer_count == 0 && wanted_type == void_type_node)
2065 if (main_arg_num != 0)
2068 status_warning (status, "operand number specified with suppressed assignment");
2070 status_warning (status, "operand number specified for format taking no argument");
2075 if (main_arg_num != 0)
2077 arg_num = main_arg_num;
2078 params = main_arg_params;
2083 if (has_operand_number > 0)
2085 status_warning (status, "missing $ operand number in format");
2089 has_operand_number = 0;
2092 status_warning (status, "too few arguments for format");
2096 cur_param = TREE_VALUE (params);
2097 params = TREE_CHAIN (params);
2098 main_wanted_type.wanted_type = wanted_type;
2099 main_wanted_type.wanted_type_name = wanted_type_name;
2100 main_wanted_type.pointer_count = fci->pointer_count + aflag;
2101 main_wanted_type.char_lenient_flag = 0;
2102 if (strchr (fci->flags2, 'c') != 0)
2103 main_wanted_type.char_lenient_flag = 1;
2104 main_wanted_type.writing_in_flag = 0;
2105 main_wanted_type.reading_from_flag = 0;
2107 main_wanted_type.writing_in_flag = 1;
2110 if (strchr (fci->flags2, 'W') != 0)
2111 main_wanted_type.writing_in_flag = 1;
2112 if (strchr (fci->flags2, 'R') != 0)
2113 main_wanted_type.reading_from_flag = 1;
2115 main_wanted_type.name = NULL;
2116 main_wanted_type.param = cur_param;
2117 main_wanted_type.arg_num = arg_num;
2118 main_wanted_type.next = NULL;
2119 if (last_wanted_type != 0)
2120 last_wanted_type->next = &main_wanted_type;
2121 if (first_wanted_type == 0)
2122 first_wanted_type = &main_wanted_type;
2123 last_wanted_type = &main_wanted_type;
2126 if (first_wanted_type != 0)
2127 check_format_types (status, first_wanted_type);
2133 /* Check the argument types from a single format conversion (possibly
2134 including width and precision arguments). */
2136 check_format_types (int *status, format_wanted_type *types)
2138 for (; types != 0; types = types->next)
2147 cur_param = types->param;
2148 cur_type = TREE_TYPE (cur_param);
2149 if (cur_type == error_mark_node)
2152 wanted_type = types->wanted_type;
2153 arg_num = types->arg_num;
2155 /* The following should not occur here. */
2156 if (wanted_type == 0)
2158 if (wanted_type == void_type_node && types->pointer_count == 0)
2161 if (types->pointer_count == 0)
2162 wanted_type = (*lang_hooks.types.type_promotes_to) (wanted_type);
2164 STRIP_NOPS (cur_param);
2166 /* Check the types of any additional pointer arguments
2167 that precede the "real" argument. */
2168 for (i = 0; i < types->pointer_count; ++i)
2170 if (TREE_CODE (cur_type) == POINTER_TYPE)
2172 cur_type = TREE_TYPE (cur_type);
2173 if (cur_type == error_mark_node)
2176 /* Check for writing through a NULL pointer. */
2177 if (types->writing_in_flag
2180 && integer_zerop (cur_param))
2181 status_warning (status,
2182 "writing through null pointer (arg %d)",
2185 /* Check for reading through a NULL pointer. */
2186 if (types->reading_from_flag
2189 && integer_zerop (cur_param))
2190 status_warning (status,
2191 "reading through null pointer (arg %d)",
2194 if (cur_param != 0 && TREE_CODE (cur_param) == ADDR_EXPR)
2195 cur_param = TREE_OPERAND (cur_param, 0);
2199 /* See if this is an attempt to write into a const type with
2200 scanf or with printf "%n". Note: the writing in happens
2201 at the first indirection only, if for example
2202 void * const * is passed to scanf %p; passing
2203 const void ** is simply passing an incompatible type. */
2204 if (types->writing_in_flag
2206 && (TYPE_READONLY (cur_type)
2208 && (TREE_CODE_CLASS (TREE_CODE (cur_param)) == 'c'
2209 || (DECL_P (cur_param)
2210 && TREE_READONLY (cur_param))))))
2211 status_warning (status, "writing into constant object (arg %d)", arg_num);
2213 /* If there are extra type qualifiers beyond the first
2214 indirection, then this makes the types technically
2218 && (TYPE_READONLY (cur_type)
2219 || TYPE_VOLATILE (cur_type)
2220 || TYPE_RESTRICT (cur_type)))
2221 status_warning (status, "extra type qualifiers in format argument (arg %d)",
2227 if (types->pointer_count == 1)
2228 status_warning (status, "format argument is not a pointer (arg %d)", arg_num);
2230 status_warning (status, "format argument is not a pointer to a pointer (arg %d)", arg_num);
2235 if (i < types->pointer_count)
2238 orig_cur_type = cur_type;
2239 cur_type = TYPE_MAIN_VARIANT (cur_type);
2241 /* Check whether the argument type is a character type. This leniency
2242 only applies to certain formats, flagged with 'c'.
2244 if (types->char_lenient_flag)
2245 char_type_flag = (cur_type == char_type_node
2246 || cur_type == signed_char_type_node
2247 || cur_type == unsigned_char_type_node);
2249 /* Check the type of the "real" argument, if there's a type we want. */
2250 if (wanted_type == cur_type)
2252 /* If we want `void *', allow any pointer type.
2253 (Anything else would already have got a warning.)
2254 With -pedantic, only allow pointers to void and to character
2256 if (wanted_type == void_type_node
2257 && (!pedantic || (i == 1 && char_type_flag)))
2259 /* Don't warn about differences merely in signedness, unless
2260 -pedantic. With -pedantic, warn if the type is a pointer
2261 target and not a character type, and for character types at
2262 a second level of indirection. */
2263 if (TREE_CODE (wanted_type) == INTEGER_TYPE
2264 && TREE_CODE (cur_type) == INTEGER_TYPE
2265 && (! pedantic || i == 0 || (i == 1 && char_type_flag))
2266 && (TREE_UNSIGNED (wanted_type)
2267 ? wanted_type == c_common_unsigned_type (cur_type)
2268 : wanted_type == c_common_signed_type (cur_type)))
2270 /* Likewise, "signed char", "unsigned char" and "char" are
2271 equivalent but the above test won't consider them equivalent. */
2272 if (wanted_type == char_type_node
2273 && (! pedantic || i < 2)
2276 /* Now we have a type mismatch. */
2281 this = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (wanted_type)));
2283 if (TYPE_NAME (orig_cur_type) != 0
2284 && TREE_CODE (orig_cur_type) != INTEGER_TYPE
2285 && !(TREE_CODE (orig_cur_type) == POINTER_TYPE
2286 && TREE_CODE (TREE_TYPE (orig_cur_type)) == INTEGER_TYPE))
2288 if (TREE_CODE (TYPE_NAME (orig_cur_type)) == TYPE_DECL
2289 && DECL_NAME (TYPE_NAME (orig_cur_type)) != 0)
2290 that = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (orig_cur_type)));
2292 that = IDENTIFIER_POINTER (TYPE_NAME (orig_cur_type));
2295 /* A nameless type can't possibly match what the format wants.
2296 So there will be a warning for it.
2297 Make up a string to describe vaguely what it is. */
2300 if (TREE_CODE (orig_cur_type) == POINTER_TYPE)
2301 that = _("pointer");
2303 that = _("different type");
2306 /* Make the warning better in case of mismatch of int vs long. */
2307 if (TREE_CODE (orig_cur_type) == INTEGER_TYPE
2308 && TREE_CODE (wanted_type) == INTEGER_TYPE
2309 && TYPE_PRECISION (orig_cur_type) == TYPE_PRECISION (wanted_type)
2310 && TYPE_NAME (orig_cur_type) != 0
2311 && TREE_CODE (TYPE_NAME (orig_cur_type)) == TYPE_DECL)
2312 that = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (orig_cur_type)));
2314 if (strcmp (this, that) != 0)
2316 /* There may be a better name for the format, e.g. size_t,
2317 but we should allow for programs with a perverse typedef
2318 making size_t something other than what the compiler
2320 if (types->wanted_type_name != 0
2321 && strcmp (types->wanted_type_name, that) != 0)
2322 this = types->wanted_type_name;
2323 if (types->name != 0)
2324 status_warning (status, "%s is not type %s (arg %d)", types->name, this,
2327 status_warning (status, "%s format, %s arg (arg %d)", this, that, arg_num);
2333 /* Given a format_length_info array FLI, and a character C, this
2334 function returns the index into the conversion_specs where that
2335 modifier's data is located. If the character isn't found it
2338 find_length_info_modifier_index (const format_length_info *fli, int c)
2344 if (strchr (fli->name, c))
2349 /* We shouldn't be looking for a non-existent modifier. */
2353 /* Determine the type of HOST_WIDE_INT in the code being compiled for
2354 use in GCC's __asm_fprintf__ custom format attribute. You must
2355 have set dynamic_format_types before calling this function. */
2357 init_dynamic_asm_fprintf_info (void)
2363 format_length_info *new_asm_fprintf_length_specs;
2366 /* Find the underlying type for HOST_WIDE_INT. For the %w
2367 length modifier to work, one must have issued: "typedef
2368 HOST_WIDE_INT __gcc_host_wide_int__;" in one's source code
2369 prior to using that modifier. */
2370 if (!(hwi = maybe_get_identifier ("__gcc_host_wide_int__"))
2371 || !(hwi = DECL_ORIGINAL_TYPE (identifier_global_value (hwi))))
2374 /* Create a new (writable) copy of asm_fprintf_length_specs. */
2375 new_asm_fprintf_length_specs = xmemdup (asm_fprintf_length_specs,
2376 sizeof (asm_fprintf_length_specs),
2377 sizeof (asm_fprintf_length_specs));
2379 /* HOST_WIDE_INT must be one of 'long' or 'long long'. */
2380 i = find_length_info_modifier_index (new_asm_fprintf_length_specs, 'w');
2381 if (hwi == long_integer_type_node)
2382 new_asm_fprintf_length_specs[i].index = FMT_LEN_l;
2383 else if (hwi == long_long_integer_type_node)
2384 new_asm_fprintf_length_specs[i].index = FMT_LEN_ll;
2388 /* Assign the new data for use. */
2389 dynamic_format_types[asm_fprintf_format_type].length_char_specs =
2390 new_asm_fprintf_length_specs;
2394 /* Handle a "format" attribute; arguments as in
2395 struct attribute_spec.handler. */
2397 handle_format_attribute (tree *node, tree name ATTRIBUTE_UNUSED, tree args,
2398 int flags, bool *no_add_attrs)
2401 function_format_info info;
2404 if (!decode_format_attr (args, &info, 0))
2406 *no_add_attrs = true;
2410 argument = TYPE_ARG_TYPES (type);
2413 if (!check_format_string (argument, info.format_num, flags,
2417 if (info.first_arg_num != 0)
2419 unsigned HOST_WIDE_INT arg_num = 1;
2421 /* Verify that first_arg_num points to the last arg,
2424 arg_num++, argument = TREE_CHAIN (argument);
2426 if (arg_num != info.first_arg_num)
2428 if (!(flags & (int) ATTR_FLAG_BUILT_IN))
2429 error ("args to be formatted is not '...'");
2430 *no_add_attrs = true;
2436 if (info.format_type == strftime_format_type && info.first_arg_num != 0)
2438 error ("strftime formats cannot format arguments");
2439 *no_add_attrs = true;
2443 /* If this is format type __asm_fprintf__, we have to initialize
2444 GCC's notion of HOST_WIDE_INT for checking %wd. */
2445 if (info.format_type == asm_fprintf_format_type)
2447 /* Our first time through, we have to make sure that our
2448 format_type data is allocated dynamically and is modifiable. */
2449 if (!dynamic_format_types)
2450 format_types = dynamic_format_types =
2451 xmemdup (format_types_orig, sizeof (format_types_orig),
2452 sizeof (format_types_orig));
2454 init_dynamic_asm_fprintf_info();