1 /* Check calls to formatted I/O functions (-Wformat).
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004 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"
35 /* Set format warning options according to a -Wformat=n option. */
38 set_Wformat (int setting)
40 warn_format = setting;
41 warn_format_extra_args = setting;
42 warn_format_zero_length = setting;
45 warn_format_nonliteral = setting;
46 warn_format_security = setting;
47 warn_format_y2k = setting;
49 /* Make sure not to disable -Wnonnull if -Wformat=0 is specified. */
51 warn_nonnull = setting;
55 /* Handle attributes associated with format checking. */
57 /* This must be in the same order as format_types, except for
58 format_type_error. Target-specific format types do not have
59 matching enum values. */
60 enum format_type { printf_format_type, asm_fprintf_format_type,
61 gcc_diag_format_type, gcc_cdiag_format_type,
62 gcc_cxxdiag_format_type,
63 scanf_format_type, strftime_format_type,
64 strfmon_format_type, format_type_error = -1};
66 typedef struct function_format_info
68 int format_type; /* type of format (printf, scanf, etc.) */
69 unsigned HOST_WIDE_INT format_num; /* number of format argument */
70 unsigned HOST_WIDE_INT first_arg_num; /* number of first arg (zero for varargs) */
71 } function_format_info;
73 static bool decode_format_attr (tree, function_format_info *, int);
74 static int decode_format_type (const char *);
76 static bool check_format_string (tree argument,
77 unsigned HOST_WIDE_INT format_num,
78 int flags, bool *no_add_attrs);
79 static bool get_constant (tree expr, unsigned HOST_WIDE_INT *value,
83 /* Handle a "format_arg" attribute; arguments as in
84 struct attribute_spec.handler. */
86 handle_format_arg_attribute (tree *node, tree name ATTRIBUTE_UNUSED,
87 tree args, int flags, bool *no_add_attrs)
90 tree format_num_expr = TREE_VALUE (args);
91 unsigned HOST_WIDE_INT format_num = 0;
94 if (!get_constant (format_num_expr, &format_num, 0))
96 error ("format string has invalid operand number");
101 argument = TYPE_ARG_TYPES (type);
104 if (!check_format_string (argument, format_num, flags, no_add_attrs))
108 if (TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
109 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
112 if (!(flags & (int) ATTR_FLAG_BUILT_IN))
113 error ("function does not return string type");
114 *no_add_attrs = true;
121 /* Verify that the format_num argument is actually a string, in case
122 the format attribute is in error. */
124 check_format_string (tree argument, unsigned HOST_WIDE_INT format_num,
125 int flags, bool *no_add_attrs)
127 unsigned HOST_WIDE_INT i;
129 for (i = 1; i != format_num; i++)
133 argument = TREE_CHAIN (argument);
137 || TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE
138 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument)))
141 if (!(flags & (int) ATTR_FLAG_BUILT_IN))
142 error ("format string arg not a string type");
143 *no_add_attrs = true;
150 /* Strip any conversions from the expression, verify it is a constant,
151 and store its value. If validated_p is true, abort on errors.
152 Returns true on success, false otherwise. */
154 get_constant(tree expr, unsigned HOST_WIDE_INT *value, int validated_p)
156 while (TREE_CODE (expr) == NOP_EXPR
157 || TREE_CODE (expr) == CONVERT_EXPR
158 || TREE_CODE (expr) == NON_LVALUE_EXPR)
159 expr = TREE_OPERAND (expr, 0);
161 if (TREE_CODE (expr) != INTEGER_CST || TREE_INT_CST_HIGH (expr) != 0)
168 *value = TREE_INT_CST_LOW (expr);
173 /* Decode the arguments to a "format" attribute into a function_format_info
174 structure. It is already known that the list is of the right length.
175 If VALIDATED_P is true, then these attributes have already been validated
176 and this function will abort if they are erroneous; if false, it
177 will give an error message. Returns true if the attributes are
178 successfully decoded, false otherwise. */
181 decode_format_attr (tree args, function_format_info *info, int validated_p)
183 tree format_type_id = TREE_VALUE (args);
184 tree format_num_expr = TREE_VALUE (TREE_CHAIN (args));
185 tree first_arg_num_expr
186 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args)));
188 if (TREE_CODE (format_type_id) != IDENTIFIER_NODE)
192 error ("unrecognized format specifier");
197 const char *p = IDENTIFIER_POINTER (format_type_id);
199 info->format_type = decode_format_type (p);
201 if (info->format_type == format_type_error)
205 warning ("%qs is an unrecognized format function type", p);
210 if (!get_constant (format_num_expr, &info->format_num, validated_p))
212 error ("format string has invalid operand number");
216 if (!get_constant (first_arg_num_expr, &info->first_arg_num, validated_p))
218 error ("'...' has invalid operand number");
222 if (info->first_arg_num != 0 && info->first_arg_num <= info->format_num)
226 error ("format string arg follows the args to be formatted");
233 /* Check a call to a format function against a parameter list. */
235 /* The C standard version C++ is treated as equivalent to
236 or inheriting from, for the purpose of format features supported. */
237 #define CPLUSPLUS_STD_VER STD_C94
238 /* The C standard version we are checking formats against when pedantic. */
239 #define C_STD_VER ((int)(c_dialect_cxx () \
240 ? CPLUSPLUS_STD_VER \
243 : (flag_isoc94 ? STD_C94 : STD_C89))))
244 /* The name to give to the standard version we are warning about when
245 pedantic. FEATURE_VER is the version in which the feature warned out
246 appeared, which is higher than C_STD_VER. */
247 #define C_STD_NAME(FEATURE_VER) (c_dialect_cxx () \
249 : ((FEATURE_VER) == STD_EXT \
252 /* Adjust a C standard version, which may be STD_C9L, to account for
253 -Wno-long-long. Returns other standard versions unchanged. */
254 #define ADJ_STD(VER) ((int)((VER) == STD_C9L \
255 ? (warn_long_long ? STD_C99 : STD_C89) \
258 /* Structure describing details of a type expected in format checking,
259 and the type to check against it. */
260 typedef struct format_wanted_type
262 /* The type wanted. */
264 /* The name of this type to use in diagnostics. */
265 const char *wanted_type_name;
266 /* The level of indirection through pointers at which this type occurs. */
268 /* Whether, when pointer_count is 1, to allow any character type when
269 pedantic, rather than just the character or void type specified. */
270 int char_lenient_flag;
271 /* Whether the argument, dereferenced once, is written into and so the
272 argument must not be a pointer to a const-qualified type. */
274 /* Whether the argument, dereferenced once, is read from and so
275 must not be a NULL pointer. */
276 int reading_from_flag;
277 /* If warnings should be of the form "field precision should have
278 type 'int'", the name to use (in this case "field precision"),
279 otherwise NULL, for "format expects type 'long'" type
282 /* The actual parameter to check against the wanted type. */
284 /* The argument number of that parameter. */
286 /* The next type to check for this format conversion, or NULL if none. */
287 struct format_wanted_type *next;
288 } format_wanted_type;
291 static const format_length_info printf_length_specs[] =
293 { "h", FMT_LEN_h, STD_C89, "hh", FMT_LEN_hh, STD_C99 },
294 { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C9L },
295 { "q", FMT_LEN_ll, STD_EXT, NULL, 0, 0 },
296 { "L", FMT_LEN_L, STD_C89, NULL, 0, 0 },
297 { "z", FMT_LEN_z, STD_C99, NULL, 0, 0 },
298 { "Z", FMT_LEN_z, STD_EXT, NULL, 0, 0 },
299 { "t", FMT_LEN_t, STD_C99, NULL, 0, 0 },
300 { "j", FMT_LEN_j, STD_C99, NULL, 0, 0 },
301 { NULL, 0, 0, NULL, 0, 0 }
304 /* Length specifiers valid for asm_fprintf. */
305 static const format_length_info asm_fprintf_length_specs[] =
307 { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C89 },
308 { "w", FMT_LEN_none, STD_C89, NULL, 0, 0 },
309 { NULL, 0, 0, NULL, 0, 0 }
312 /* Length specifiers valid for GCC diagnostics. */
313 static const format_length_info gcc_diag_length_specs[] =
315 { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C89 },
316 { "w", FMT_LEN_none, STD_C89, NULL, 0, 0 },
317 { NULL, 0, 0, NULL, 0, 0 }
320 /* The custom diagnostics all accept the same length specifiers. */
321 #define gcc_cdiag_length_specs gcc_diag_length_specs
322 #define gcc_cxxdiag_length_specs gcc_diag_length_specs
324 /* This differs from printf_length_specs only in that "Z" is not accepted. */
325 static const format_length_info scanf_length_specs[] =
327 { "h", FMT_LEN_h, STD_C89, "hh", FMT_LEN_hh, STD_C99 },
328 { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C9L },
329 { "q", FMT_LEN_ll, STD_EXT, NULL, 0, 0 },
330 { "L", FMT_LEN_L, STD_C89, NULL, 0, 0 },
331 { "z", FMT_LEN_z, STD_C99, NULL, 0, 0 },
332 { "t", FMT_LEN_t, STD_C99, NULL, 0, 0 },
333 { "j", FMT_LEN_j, STD_C99, NULL, 0, 0 },
334 { NULL, 0, 0, NULL, 0, 0 }
338 /* All tables for strfmon use STD_C89 everywhere, since -pedantic warnings
339 make no sense for a format type not part of any C standard version. */
340 static const format_length_info strfmon_length_specs[] =
342 /* A GNU extension. */
343 { "L", FMT_LEN_L, STD_C89, NULL, 0, 0 },
344 { NULL, 0, 0, NULL, 0, 0 }
347 static const format_flag_spec printf_flag_specs[] =
349 { ' ', 0, 0, N_("` ' flag"), N_("the ` ' printf flag"), STD_C89 },
350 { '+', 0, 0, N_("`+' flag"), N_("the `+' printf flag"), STD_C89 },
351 { '#', 0, 0, N_("`#' flag"), N_("the `#' printf flag"), STD_C89 },
352 { '0', 0, 0, N_("`0' flag"), N_("the `0' printf flag"), STD_C89 },
353 { '-', 0, 0, N_("`-' flag"), N_("the `-' printf flag"), STD_C89 },
354 { '\'', 0, 0, N_("`'' flag"), N_("the `'' printf flag"), STD_EXT },
355 { 'I', 0, 0, N_("`I' flag"), N_("the `I' printf flag"), STD_EXT },
356 { 'w', 0, 0, N_("field width"), N_("field width in printf format"), STD_C89 },
357 { 'p', 0, 0, N_("precision"), N_("precision in printf format"), STD_C89 },
358 { 'L', 0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
359 { 0, 0, 0, NULL, NULL, 0 }
363 static const format_flag_pair printf_flag_pairs[] =
367 { '0', 'p', 1, 'i' },
371 static const format_flag_spec asm_fprintf_flag_specs[] =
373 { ' ', 0, 0, N_("` ' flag"), N_("the ` ' printf flag"), STD_C89 },
374 { '+', 0, 0, N_("`+' flag"), N_("the `+' printf flag"), STD_C89 },
375 { '#', 0, 0, N_("`#' flag"), N_("the `#' printf flag"), STD_C89 },
376 { '0', 0, 0, N_("`0' flag"), N_("the `0' printf flag"), STD_C89 },
377 { '-', 0, 0, N_("`-' flag"), N_("the `-' printf flag"), STD_C89 },
378 { 'w', 0, 0, N_("field width"), N_("field width in printf format"), STD_C89 },
379 { 'p', 0, 0, N_("precision"), N_("precision in printf format"), STD_C89 },
380 { 'L', 0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
381 { 0, 0, 0, NULL, NULL, 0 }
384 static const format_flag_pair asm_fprintf_flag_pairs[] =
388 { '0', 'p', 1, 'i' },
392 static const format_flag_pair gcc_diag_flag_pairs[] =
397 #define gcc_cdiag_flag_pairs gcc_diag_flag_pairs
398 #define gcc_cxxdiag_flag_pairs gcc_diag_flag_pairs
400 static const format_flag_spec gcc_diag_flag_specs[] =
402 { 'q', 0, 0, N_("`q' flag"), N_("the `q' diagnostic flag"), STD_C89 },
403 { 'p', 0, 0, N_("precision"), N_("precision in printf format"), STD_C89 },
404 { 'L', 0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
405 { 0, 0, 0, NULL, NULL, 0 }
408 #define gcc_cdiag_flag_specs gcc_diag_flag_specs
410 static const format_flag_spec gcc_cxxdiag_flag_specs[] =
412 { '+', 0, 0, N_("`+' flag"), N_("the `+' printf flag"), STD_C89 },
413 { '#', 0, 0, N_("`#' flag"), N_("the `#' printf flag"), STD_C89 },
414 { 'q', 0, 0, N_("`q' flag"), N_("the `q' diagnostic flag"), STD_C89 },
415 { 'p', 0, 0, N_("precision"), N_("precision in printf format"), STD_C89 },
416 { 'L', 0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
417 { 0, 0, 0, NULL, NULL, 0 }
420 static const format_flag_spec scanf_flag_specs[] =
422 { '*', 0, 0, N_("assignment suppression"), N_("the assignment suppression scanf feature"), STD_C89 },
423 { 'a', 0, 0, N_("`a' flag"), N_("the `a' scanf flag"), STD_EXT },
424 { 'w', 0, 0, N_("field width"), N_("field width in scanf format"), STD_C89 },
425 { 'L', 0, 0, N_("length modifier"), N_("length modifier in scanf format"), STD_C89 },
426 { '\'', 0, 0, N_("`'' flag"), N_("the `'' scanf flag"), STD_EXT },
427 { 'I', 0, 0, N_("`I' flag"), N_("the `I' scanf flag"), STD_EXT },
428 { 0, 0, 0, NULL, NULL, 0 }
432 static const format_flag_pair scanf_flag_pairs[] =
439 static const format_flag_spec strftime_flag_specs[] =
441 { '_', 0, 0, N_("`_' flag"), N_("the `_' strftime flag"), STD_EXT },
442 { '-', 0, 0, N_("`-' flag"), N_("the `-' strftime flag"), STD_EXT },
443 { '0', 0, 0, N_("`0' flag"), N_("the `0' strftime flag"), STD_EXT },
444 { '^', 0, 0, N_("`^' flag"), N_("the `^' strftime flag"), STD_EXT },
445 { '#', 0, 0, N_("`#' flag"), N_("the `#' strftime flag"), STD_EXT },
446 { 'w', 0, 0, N_("field width"), N_("field width in strftime format"), STD_EXT },
447 { 'E', 0, 0, N_("`E' modifier"), N_("the `E' strftime modifier"), STD_C99 },
448 { 'O', 0, 0, N_("`O' modifier"), N_("the `O' strftime modifier"), STD_C99 },
449 { 'O', 'o', 0, NULL, N_("the `O' modifier"), STD_EXT },
450 { 0, 0, 0, NULL, NULL, 0 }
454 static const format_flag_pair strftime_flag_pairs[] =
465 static const format_flag_spec strfmon_flag_specs[] =
467 { '=', 0, 1, N_("fill character"), N_("fill character in strfmon format"), STD_C89 },
468 { '^', 0, 0, N_("`^' flag"), N_("the `^' strfmon flag"), STD_C89 },
469 { '+', 0, 0, N_("`+' flag"), N_("the `+' strfmon flag"), STD_C89 },
470 { '(', 0, 0, N_("`(' flag"), N_("the `(' strfmon flag"), STD_C89 },
471 { '!', 0, 0, N_("`!' flag"), N_("the `!' strfmon flag"), STD_C89 },
472 { '-', 0, 0, N_("`-' flag"), N_("the `-' strfmon flag"), STD_C89 },
473 { 'w', 0, 0, N_("field width"), N_("field width in strfmon format"), STD_C89 },
474 { '#', 0, 0, N_("left precision"), N_("left precision in strfmon format"), STD_C89 },
475 { 'p', 0, 0, N_("right precision"), N_("right precision in strfmon format"), STD_C89 },
476 { 'L', 0, 0, N_("length modifier"), N_("length modifier in strfmon format"), STD_C89 },
477 { 0, 0, 0, NULL, NULL, 0 }
480 static const format_flag_pair strfmon_flag_pairs[] =
487 static const format_char_info print_char_table[] =
489 /* C89 conversion specifiers. */
490 { "di", 0, STD_C89, { T89_I, T99_SC, T89_S, T89_L, T9L_LL, TEX_LL, T99_SST, T99_PD, T99_IM }, "-wp0 +'I", "i", NULL },
491 { "oxX", 0, STD_C89, { T89_UI, T99_UC, T89_US, T89_UL, T9L_ULL, TEX_ULL, T99_ST, T99_UPD, T99_UIM }, "-wp0#", "i", NULL },
492 { "u", 0, STD_C89, { T89_UI, T99_UC, T89_US, T89_UL, T9L_ULL, TEX_ULL, T99_ST, T99_UPD, T99_UIM }, "-wp0'I", "i", NULL },
493 { "fgG", 0, STD_C89, { T89_D, BADLEN, BADLEN, T99_D, BADLEN, T89_LD, BADLEN, BADLEN, BADLEN }, "-wp0 +#'I", "", NULL },
494 { "eE", 0, STD_C89, { T89_D, BADLEN, BADLEN, T99_D, BADLEN, T89_LD, BADLEN, BADLEN, BADLEN }, "-wp0 +#I", "", NULL },
495 { "c", 0, STD_C89, { T89_I, BADLEN, BADLEN, T94_WI, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-w", "", NULL },
496 { "s", 1, STD_C89, { T89_C, BADLEN, BADLEN, T94_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "cR", NULL },
497 { "p", 1, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-w", "c", NULL },
498 { "n", 1, STD_C89, { T89_I, T99_SC, T89_S, T89_L, T9L_LL, BADLEN, T99_SST, T99_PD, T99_IM }, "", "W", NULL },
499 /* C99 conversion specifiers. */
500 { "F", 0, STD_C99, { T99_D, BADLEN, BADLEN, T99_D, BADLEN, T99_LD, BADLEN, BADLEN, BADLEN }, "-wp0 +#'I", "", NULL },
501 { "aA", 0, STD_C99, { T99_D, BADLEN, BADLEN, T99_D, BADLEN, T99_LD, BADLEN, BADLEN, BADLEN }, "-wp0 +#", "", NULL },
502 /* X/Open conversion specifiers. */
503 { "C", 0, STD_EXT, { TEX_WI, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-w", "", NULL },
504 { "S", 1, STD_EXT, { TEX_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "R", NULL },
505 /* GNU conversion specifiers. */
506 { "m", 0, STD_EXT, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "", NULL },
507 { NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
510 static const format_char_info asm_fprintf_char_table[] =
512 /* C89 conversion specifiers. */
513 { "di", 0, STD_C89, { T89_I, BADLEN, BADLEN, T89_L, T9L_LL, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp0 +", "i", NULL },
514 { "oxX", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp0#", "i", NULL },
515 { "u", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp0", "i", NULL },
516 { "c", 0, STD_C89, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-w", "", NULL },
517 { "s", 1, STD_C89, { T89_C, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "-wp", "cR", NULL },
519 /* asm_fprintf conversion specifiers. */
520 { "O", 0, STD_C89, NOARGUMENTS, "", "", NULL },
521 { "R", 0, STD_C89, NOARGUMENTS, "", "", NULL },
522 { "I", 0, STD_C89, NOARGUMENTS, "", "", NULL },
523 { "L", 0, STD_C89, NOARGUMENTS, "", "", NULL },
524 { "U", 0, STD_C89, NOARGUMENTS, "", "", NULL },
525 { "r", 0, STD_C89, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "", "", NULL },
526 { "@", 0, STD_C89, NOARGUMENTS, "", "", NULL },
527 { NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
530 static const format_char_info gcc_diag_char_table[] =
532 /* C89 conversion specifiers. */
533 { "di", 0, STD_C89, { T89_I, BADLEN, BADLEN, T89_L, T9L_LL, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
534 { "ox", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
535 { "u", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
536 { "c", 0, STD_C89, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
537 { "s", 1, STD_C89, { T89_C, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "pq", "cR", NULL },
538 { "p", 1, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "c", NULL },
540 /* Custom conversion specifiers. */
542 /* %H will require "location_t" at runtime. */
543 { "H", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
545 /* These will require a "tree" at runtime. */
546 { "J", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
548 { "<>'", 0, STD_C89, NOARGUMENTS, "", "", NULL },
549 { "m", 0, STD_C89, NOARGUMENTS, "q", "", NULL },
550 { NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
553 static const format_char_info gcc_cdiag_char_table[] =
555 /* C89 conversion specifiers. */
556 { "di", 0, STD_C89, { T89_I, BADLEN, BADLEN, T89_L, T9L_LL, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
557 { "ox", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
558 { "u", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
559 { "c", 0, STD_C89, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
560 { "s", 1, STD_C89, { T89_C, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "pq", "cR", NULL },
561 { "p", 1, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "c", NULL },
563 /* Custom conversion specifiers. */
565 /* %H will require "location_t" at runtime. */
566 { "H", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
568 /* These will require a "tree" at runtime. */
569 { "DEFJT", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
571 { "<>'", 0, STD_C89, NOARGUMENTS, "", "", NULL },
572 { "m", 0, STD_C89, NOARGUMENTS, "q", "", NULL },
573 { NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
576 static const format_char_info gcc_cxxdiag_char_table[] =
578 /* C89 conversion specifiers. */
579 { "di", 0, STD_C89, { T89_I, BADLEN, BADLEN, T89_L, T9L_LL, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
580 { "ox", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
581 { "u", 0, STD_C89, { T89_UI, BADLEN, BADLEN, T89_UL, T9L_ULL, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
582 { "c", 0, STD_C89, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
583 { "s", 1, STD_C89, { T89_C, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "pq", "cR", NULL },
584 { "p", 1, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "c", NULL },
586 /* Custom conversion specifiers. */
588 /* %H will require "location_t" at runtime. */
589 { "H", 0, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
591 /* These will require a "tree" at runtime. */
592 { "ADEFJTV",0,STD_C89,{ T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q+#", "", NULL },
594 /* These accept either an `int' or an `enum tree_code' (which is handled as an `int'.) */
595 { "CLOPQ",0,STD_C89, { T89_I, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "q", "", NULL },
597 { "<>'", 0, STD_C89, NOARGUMENTS, "", "", NULL },
598 { "m", 0, STD_C89, NOARGUMENTS, "q", "", NULL },
599 { NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
602 static const format_char_info scan_char_table[] =
604 /* C89 conversion specifiers. */
605 { "di", 1, STD_C89, { T89_I, T99_SC, T89_S, T89_L, T9L_LL, TEX_LL, T99_SST, T99_PD, T99_IM }, "*w'I", "W", NULL },
606 { "u", 1, STD_C89, { T89_UI, T99_UC, T89_US, T89_UL, T9L_ULL, TEX_ULL, T99_ST, T99_UPD, T99_UIM }, "*w'I", "W", NULL },
607 { "oxX", 1, STD_C89, { T89_UI, T99_UC, T89_US, T89_UL, T9L_ULL, TEX_ULL, T99_ST, T99_UPD, T99_UIM }, "*w", "W", NULL },
608 { "efgEG", 1, STD_C89, { T89_F, BADLEN, BADLEN, T89_D, BADLEN, T89_LD, BADLEN, BADLEN, BADLEN }, "*w'", "W", NULL },
609 { "c", 1, STD_C89, { T89_C, BADLEN, BADLEN, T94_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*w", "cW", NULL },
610 { "s", 1, STD_C89, { T89_C, BADLEN, BADLEN, T94_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*aw", "cW", NULL },
611 { "[", 1, STD_C89, { T89_C, BADLEN, BADLEN, T94_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*aw", "cW[", NULL },
612 { "p", 2, STD_C89, { T89_V, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*w", "W", NULL },
613 { "n", 1, STD_C89, { T89_I, T99_SC, T89_S, T89_L, T9L_LL, BADLEN, T99_SST, T99_PD, T99_IM }, "", "W", NULL },
614 /* C99 conversion specifiers. */
615 { "FaA", 1, STD_C99, { T99_F, BADLEN, BADLEN, T99_D, BADLEN, T99_LD, BADLEN, BADLEN, BADLEN }, "*w'", "W", NULL },
616 /* X/Open conversion specifiers. */
617 { "C", 1, STD_EXT, { TEX_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*w", "W", NULL },
618 { "S", 1, STD_EXT, { TEX_W, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }, "*aw", "W", NULL },
619 { NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
622 static const format_char_info time_char_table[] =
624 /* C89 conversion specifiers. */
625 { "ABZab", 0, STD_C89, NOLENGTHS, "^#", "", NULL },
626 { "cx", 0, STD_C89, NOLENGTHS, "E", "3", NULL },
627 { "HIMSUWdmw", 0, STD_C89, NOLENGTHS, "-_0Ow", "", NULL },
628 { "j", 0, STD_C89, NOLENGTHS, "-_0Ow", "o", NULL },
629 { "p", 0, STD_C89, NOLENGTHS, "#", "", NULL },
630 { "X", 0, STD_C89, NOLENGTHS, "E", "", NULL },
631 { "y", 0, STD_C89, NOLENGTHS, "EO-_0w", "4", NULL },
632 { "Y", 0, STD_C89, NOLENGTHS, "-_0EOw", "o", NULL },
633 { "%", 0, STD_C89, NOLENGTHS, "", "", NULL },
634 /* C99 conversion specifiers. */
635 { "C", 0, STD_C99, NOLENGTHS, "-_0EOw", "o", NULL },
636 { "D", 0, STD_C99, NOLENGTHS, "", "2", NULL },
637 { "eVu", 0, STD_C99, NOLENGTHS, "-_0Ow", "", NULL },
638 { "FRTnrt", 0, STD_C99, NOLENGTHS, "", "", NULL },
639 { "g", 0, STD_C99, NOLENGTHS, "O-_0w", "2o", NULL },
640 { "G", 0, STD_C99, NOLENGTHS, "-_0Ow", "o", NULL },
641 { "h", 0, STD_C99, NOLENGTHS, "^#", "", NULL },
642 { "z", 0, STD_C99, NOLENGTHS, "O", "o", NULL },
643 /* GNU conversion specifiers. */
644 { "kls", 0, STD_EXT, NOLENGTHS, "-_0Ow", "", NULL },
645 { "P", 0, STD_EXT, NOLENGTHS, "", "", NULL },
646 { NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
649 static const format_char_info monetary_char_table[] =
651 { "in", 0, STD_C89, { T89_D, BADLEN, BADLEN, BADLEN, BADLEN, T89_LD, BADLEN, BADLEN, BADLEN }, "=^+(!-w#p", "", NULL },
652 { NULL, 0, 0, NOLENGTHS, NULL, NULL, NULL }
655 /* This must be in the same order as enum format_type. */
656 static const format_kind_info format_types_orig[] =
658 { "printf", printf_length_specs, print_char_table, " +#0-'I", NULL,
659 printf_flag_specs, printf_flag_pairs,
660 FMT_FLAG_ARG_CONVERT|FMT_FLAG_DOLLAR_MULTIPLE|FMT_FLAG_USE_DOLLAR|FMT_FLAG_EMPTY_PREC_OK,
662 &integer_type_node, &integer_type_node
664 { "asm_fprintf", asm_fprintf_length_specs, asm_fprintf_char_table, " +#0-", NULL,
665 asm_fprintf_flag_specs, asm_fprintf_flag_pairs,
666 FMT_FLAG_ARG_CONVERT|FMT_FLAG_EMPTY_PREC_OK,
670 { "gcc_diag", gcc_diag_length_specs, gcc_diag_char_table, "q", NULL,
671 gcc_diag_flag_specs, gcc_diag_flag_pairs,
672 FMT_FLAG_ARG_CONVERT,
674 NULL, &integer_type_node
676 { "gcc_cdiag", gcc_cdiag_length_specs, gcc_cdiag_char_table, "q", NULL,
677 gcc_cdiag_flag_specs, gcc_cdiag_flag_pairs,
678 FMT_FLAG_ARG_CONVERT,
680 NULL, &integer_type_node
682 { "gcc_cxxdiag", gcc_cxxdiag_length_specs, gcc_cxxdiag_char_table, "q+#", NULL,
683 gcc_cxxdiag_flag_specs, gcc_cxxdiag_flag_pairs,
684 FMT_FLAG_ARG_CONVERT,
686 NULL, &integer_type_node
688 { "scanf", scanf_length_specs, scan_char_table, "*'I", NULL,
689 scanf_flag_specs, scanf_flag_pairs,
690 FMT_FLAG_ARG_CONVERT|FMT_FLAG_SCANF_A_KLUDGE|FMT_FLAG_USE_DOLLAR|FMT_FLAG_ZERO_WIDTH_BAD|FMT_FLAG_DOLLAR_GAP_POINTER_OK,
694 { "strftime", NULL, time_char_table, "_-0^#", "EO",
695 strftime_flag_specs, strftime_flag_pairs,
696 FMT_FLAG_FANCY_PERCENT_OK, 'w', 0, 0, 0, 0,
699 { "strfmon", strfmon_length_specs, monetary_char_table, "=^+(!-", NULL,
700 strfmon_flag_specs, strfmon_flag_pairs,
701 FMT_FLAG_ARG_CONVERT, 'w', '#', 'p', 0, 'L',
706 /* This layer of indirection allows GCC to reassign format_types with
707 new data if necessary, while still allowing the original data to be
709 static const format_kind_info *format_types = format_types_orig;
710 /* We can modify this one. We also add target-specific format types
711 to the end of the array. */
712 static format_kind_info *dynamic_format_types;
714 static int n_format_types = ARRAY_SIZE (format_types_orig);
716 /* Structure detailing the results of checking a format function call
717 where the format expression may be a conditional expression with
718 many leaves resulting from nested conditional expressions. */
721 /* Number of leaves of the format argument that could not be checked
722 as they were not string literals. */
723 int number_non_literal;
724 /* Number of leaves of the format argument that were null pointers or
725 string literals, but had extra format arguments. */
726 int number_extra_args;
727 /* Number of leaves of the format argument that were null pointers or
728 string literals, but had extra format arguments and used $ operand
730 int number_dollar_extra_args;
731 /* Number of leaves of the format argument that were wide string
734 /* Number of leaves of the format argument that were empty strings. */
736 /* Number of leaves of the format argument that were unterminated
738 int number_unterminated;
739 /* Number of leaves of the format argument that were not counted above. */
741 } format_check_results;
745 format_check_results *res;
746 function_format_info *info;
748 } format_check_context;
750 static void check_format_info (function_format_info *, tree);
751 static void check_format_arg (void *, tree, unsigned HOST_WIDE_INT);
752 static void check_format_info_main (format_check_results *,
753 function_format_info *,
754 const char *, int, tree,
755 unsigned HOST_WIDE_INT);
757 static void init_dollar_format_checking (int, tree);
758 static int maybe_read_dollar_number (const char **, int,
759 tree, tree *, const format_kind_info *);
760 static bool avoid_dollar_number (const char *);
761 static void finish_dollar_format_checking (format_check_results *, int);
763 static const format_flag_spec *get_flag_spec (const format_flag_spec *,
766 static void check_format_types (format_wanted_type *, const char *, int);
767 static void format_type_warning (const char *, const char *, int, tree,
768 int, const char *, tree, int);
770 /* Decode a format type from a string, returning the type, or
771 format_type_error if not valid, in which case the caller should print an
774 decode_format_type (const char *s)
779 for (i = 0; i < n_format_types; i++)
782 if (!strcmp (s, format_types[i].name))
784 alen = strlen (format_types[i].name);
785 if (slen == alen + 4 && s[0] == '_' && s[1] == '_'
786 && s[slen - 1] == '_' && s[slen - 2] == '_'
787 && !strncmp (s + 2, format_types[i].name, alen))
790 return format_type_error;
794 /* Check the argument list of a call to printf, scanf, etc.
795 ATTRS are the attributes on the function type.
796 PARAMS is the list of argument values. Also, if -Wmissing-format-attribute,
797 warn for calls to vprintf or vscanf in functions with no such format
798 attribute themselves. */
801 check_function_format (tree attrs, tree params)
805 /* See if this function has any format attributes. */
806 for (a = attrs; a; a = TREE_CHAIN (a))
808 if (is_attribute_p ("format", TREE_PURPOSE (a)))
811 function_format_info info;
812 decode_format_attr (TREE_VALUE (a), &info, 1);
813 check_format_info (&info, params);
814 if (warn_missing_format_attribute && info.first_arg_num == 0
815 && (format_types[info.format_type].flags
816 & (int) FMT_FLAG_ARG_CONVERT))
819 for (c = TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl));
822 if (is_attribute_p ("format", TREE_PURPOSE (c))
823 && (decode_format_type (IDENTIFIER_POINTER
824 (TREE_VALUE (TREE_VALUE (c))))
825 == info.format_type))
829 /* Check if the current function has a parameter to which
830 the format attribute could be attached; if not, it
831 can't be a candidate for a format attribute, despite
832 the vprintf-like or vscanf-like call. */
834 for (args = DECL_ARGUMENTS (current_function_decl);
836 args = TREE_CHAIN (args))
838 if (TREE_CODE (TREE_TYPE (args)) == POINTER_TYPE
839 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (args)))
844 warning ("function might be possible candidate for %qs format attribute",
845 format_types[info.format_type].name);
853 /* Variables used by the checking of $ operand number formats. */
854 static char *dollar_arguments_used = NULL;
855 static char *dollar_arguments_pointer_p = NULL;
856 static int dollar_arguments_alloc = 0;
857 static int dollar_arguments_count;
858 static int dollar_first_arg_num;
859 static int dollar_max_arg_used;
860 static int dollar_format_warned;
862 /* Initialize the checking for a format string that may contain $
863 parameter number specifications; we will need to keep track of whether
864 each parameter has been used. FIRST_ARG_NUM is the number of the first
865 argument that is a parameter to the format, or 0 for a vprintf-style
866 function; PARAMS is the list of arguments starting at this argument. */
869 init_dollar_format_checking (int first_arg_num, tree params)
871 tree oparams = params;
873 dollar_first_arg_num = first_arg_num;
874 dollar_arguments_count = 0;
875 dollar_max_arg_used = 0;
876 dollar_format_warned = 0;
877 if (first_arg_num > 0)
881 dollar_arguments_count++;
882 params = TREE_CHAIN (params);
885 if (dollar_arguments_alloc < dollar_arguments_count)
887 if (dollar_arguments_used)
888 free (dollar_arguments_used);
889 if (dollar_arguments_pointer_p)
890 free (dollar_arguments_pointer_p);
891 dollar_arguments_alloc = dollar_arguments_count;
892 dollar_arguments_used = xmalloc (dollar_arguments_alloc);
893 dollar_arguments_pointer_p = xmalloc (dollar_arguments_alloc);
895 if (dollar_arguments_alloc)
897 memset (dollar_arguments_used, 0, dollar_arguments_alloc);
898 if (first_arg_num > 0)
904 dollar_arguments_pointer_p[i] = (TREE_CODE (TREE_TYPE (TREE_VALUE (params)))
906 params = TREE_CHAIN (params);
914 /* Look for a decimal number followed by a $ in *FORMAT. If DOLLAR_NEEDED
915 is set, it is an error if one is not found; otherwise, it is OK. If
916 such a number is found, check whether it is within range and mark that
917 numbered operand as being used for later checking. Returns the operand
918 number if found and within range, zero if no such number was found and
919 this is OK, or -1 on error. PARAMS points to the first operand of the
920 format; PARAM_PTR is made to point to the parameter referred to. If
921 a $ format is found, *FORMAT is updated to point just after it. */
924 maybe_read_dollar_number (const char **format,
925 int dollar_needed, tree params, tree *param_ptr,
926 const format_kind_info *fki)
930 const char *fcp = *format;
931 if (! ISDIGIT (*fcp))
935 warning ("missing $ operand number in format");
943 while (ISDIGIT (*fcp))
946 nargnum = 10 * argnum + (*fcp - '0');
947 if (nargnum < 0 || nargnum / 10 != argnum)
956 warning ("missing $ operand number in format");
963 if (pedantic && !dollar_format_warned)
965 warning ("%s does not support %%n$ operand number formats",
966 C_STD_NAME (STD_EXT));
967 dollar_format_warned = 1;
969 if (overflow_flag || argnum == 0
970 || (dollar_first_arg_num && argnum > dollar_arguments_count))
972 warning ("operand number out of range in format");
975 if (argnum > dollar_max_arg_used)
976 dollar_max_arg_used = argnum;
977 /* For vprintf-style functions we may need to allocate more memory to
978 track which arguments are used. */
979 while (dollar_arguments_alloc < dollar_max_arg_used)
982 nalloc = 2 * dollar_arguments_alloc + 16;
983 dollar_arguments_used = xrealloc (dollar_arguments_used, nalloc);
984 dollar_arguments_pointer_p = xrealloc (dollar_arguments_pointer_p,
986 memset (dollar_arguments_used + dollar_arguments_alloc, 0,
987 nalloc - dollar_arguments_alloc);
988 dollar_arguments_alloc = nalloc;
990 if (!(fki->flags & (int) FMT_FLAG_DOLLAR_MULTIPLE)
991 && dollar_arguments_used[argnum - 1] == 1)
993 dollar_arguments_used[argnum - 1] = 2;
994 warning ("format argument %d used more than once in %s format",
998 dollar_arguments_used[argnum - 1] = 1;
999 if (dollar_first_arg_num)
1002 *param_ptr = params;
1003 for (i = 1; i < argnum && *param_ptr != 0; i++)
1004 *param_ptr = TREE_CHAIN (*param_ptr);
1006 if (*param_ptr == 0)
1008 /* This case shouldn't be caught here. */
1017 /* Ensure that FORMAT does not start with a decimal number followed by
1018 a $; give a diagnostic and return true if it does, false otherwise. */
1021 avoid_dollar_number (const char *format)
1023 if (!ISDIGIT (*format))
1025 while (ISDIGIT (*format))
1029 warning ("$ operand number used after format without operand number");
1036 /* Finish the checking for a format string that used $ operand number formats
1037 instead of non-$ formats. We check for unused operands before used ones
1038 (a serious error, since the implementation of the format function
1039 can't know what types to pass to va_arg to find the later arguments).
1040 and for unused operands at the end of the format (if we know how many
1041 arguments the format had, so not for vprintf). If there were operand
1042 numbers out of range on a non-vprintf-style format, we won't have reached
1043 here. If POINTER_GAP_OK, unused arguments are OK if all arguments are
1047 finish_dollar_format_checking (format_check_results *res, int pointer_gap_ok)
1050 bool found_pointer_gap = false;
1051 for (i = 0; i < dollar_max_arg_used; i++)
1053 if (!dollar_arguments_used[i])
1055 if (pointer_gap_ok && (dollar_first_arg_num == 0
1056 || dollar_arguments_pointer_p[i]))
1057 found_pointer_gap = true;
1059 warning ("format argument %d unused before used argument %d in $-style format",
1060 i + 1, dollar_max_arg_used);
1063 if (found_pointer_gap
1064 || (dollar_first_arg_num
1065 && dollar_max_arg_used < dollar_arguments_count))
1067 res->number_other--;
1068 res->number_dollar_extra_args++;
1073 /* Retrieve the specification for a format flag. SPEC contains the
1074 specifications for format flags for the applicable kind of format.
1075 FLAG is the flag in question. If PREDICATES is NULL, the basic
1076 spec for that flag must be retrieved and this function aborts if
1077 it cannot be found. If PREDICATES is not NULL, it is a string listing
1078 possible predicates for the spec entry; if an entry predicated on any
1079 of these is found, it is returned, otherwise NULL is returned. */
1081 static const format_flag_spec *
1082 get_flag_spec (const format_flag_spec *spec, int flag, const char *predicates)
1085 for (i = 0; spec[i].flag_char != 0; i++)
1087 if (spec[i].flag_char != flag)
1089 if (predicates != NULL)
1091 if (spec[i].predicate != 0
1092 && strchr (predicates, spec[i].predicate) != 0)
1095 else if (spec[i].predicate == 0)
1098 if (predicates == NULL)
1105 /* Check the argument list of a call to printf, scanf, etc.
1106 INFO points to the function_format_info structure.
1107 PARAMS is the list of argument values. */
1110 check_format_info (function_format_info *info, tree params)
1112 format_check_context format_ctx;
1113 unsigned HOST_WIDE_INT arg_num;
1115 format_check_results res;
1116 /* Skip to format argument. If the argument isn't available, there's
1117 no work for us to do; prototype checking will catch the problem. */
1118 for (arg_num = 1; ; ++arg_num)
1122 if (arg_num == info->format_num)
1124 params = TREE_CHAIN (params);
1126 format_tree = TREE_VALUE (params);
1127 params = TREE_CHAIN (params);
1128 if (format_tree == 0)
1131 res.number_non_literal = 0;
1132 res.number_extra_args = 0;
1133 res.number_dollar_extra_args = 0;
1134 res.number_wide = 0;
1135 res.number_empty = 0;
1136 res.number_unterminated = 0;
1137 res.number_other = 0;
1139 format_ctx.res = &res;
1140 format_ctx.info = info;
1141 format_ctx.params = params;
1143 check_function_arguments_recurse (check_format_arg, &format_ctx,
1144 format_tree, arg_num);
1146 if (res.number_non_literal > 0)
1148 /* Functions taking a va_list normally pass a non-literal format
1149 string. These functions typically are declared with
1150 first_arg_num == 0, so avoid warning in those cases. */
1151 if (!(format_types[info->format_type].flags & (int) FMT_FLAG_ARG_CONVERT))
1153 /* For strftime-like formats, warn for not checking the format
1154 string; but there are no arguments to check. */
1155 if (warn_format_nonliteral)
1156 warning ("format not a string literal, format string not checked");
1158 else if (info->first_arg_num != 0)
1160 /* If there are no arguments for the format at all, we may have
1161 printf (foo) which is likely to be a security hole. */
1162 while (arg_num + 1 < info->first_arg_num)
1166 params = TREE_CHAIN (params);
1169 if (params == 0 && (warn_format_nonliteral || warn_format_security))
1170 warning ("format not a string literal and no format arguments");
1171 else if (warn_format_nonliteral)
1172 warning ("format not a string literal, argument types not checked");
1176 /* If there were extra arguments to the format, normally warn. However,
1177 the standard does say extra arguments are ignored, so in the specific
1178 case where we have multiple leaves (conditional expressions or
1179 ngettext) allow extra arguments if at least one leaf didn't have extra
1180 arguments, but was otherwise OK (either non-literal or checked OK).
1181 If the format is an empty string, this should be counted similarly to the
1182 case of extra format arguments. */
1183 if (res.number_extra_args > 0 && res.number_non_literal == 0
1184 && res.number_other == 0 && warn_format_extra_args)
1185 warning ("too many arguments for format");
1186 if (res.number_dollar_extra_args > 0 && res.number_non_literal == 0
1187 && res.number_other == 0 && warn_format_extra_args)
1188 warning ("unused arguments in $-style format");
1189 if (res.number_empty > 0 && res.number_non_literal == 0
1190 && res.number_other == 0 && warn_format_zero_length)
1191 warning ("zero-length %s format string",
1192 format_types[info->format_type].name);
1194 if (res.number_wide > 0)
1195 warning ("format is a wide character string");
1197 if (res.number_unterminated > 0)
1198 warning ("unterminated format string");
1201 /* Callback from check_function_arguments_recurse to check a
1202 format string. FORMAT_TREE is the format parameter. ARG_NUM
1203 is the number of the format argument. CTX points to a
1204 format_check_context. */
1207 check_format_arg (void *ctx, tree format_tree,
1208 unsigned HOST_WIDE_INT arg_num)
1210 format_check_context *format_ctx = ctx;
1211 format_check_results *res = format_ctx->res;
1212 function_format_info *info = format_ctx->info;
1213 tree params = format_ctx->params;
1216 HOST_WIDE_INT offset;
1217 const char *format_chars;
1218 tree array_size = 0;
1221 if (integer_zerop (format_tree))
1223 /* Skip to first argument to check, so we can see if this format
1224 has any arguments (it shouldn't). */
1225 while (arg_num + 1 < info->first_arg_num)
1229 params = TREE_CHAIN (params);
1234 res->number_other++;
1236 res->number_extra_args++;
1242 if (TREE_CODE (format_tree) == PLUS_EXPR)
1246 arg0 = TREE_OPERAND (format_tree, 0);
1247 arg1 = TREE_OPERAND (format_tree, 1);
1250 if (TREE_CODE (arg1) == INTEGER_CST)
1252 else if (TREE_CODE (arg0) == INTEGER_CST)
1259 res->number_non_literal++;
1262 if (!host_integerp (arg1, 0)
1263 || (offset = tree_low_cst (arg1, 0)) < 0)
1265 res->number_non_literal++;
1269 if (TREE_CODE (format_tree) != ADDR_EXPR)
1271 res->number_non_literal++;
1274 format_tree = TREE_OPERAND (format_tree, 0);
1275 if (TREE_CODE (format_tree) == VAR_DECL
1276 && TREE_CODE (TREE_TYPE (format_tree)) == ARRAY_TYPE
1277 && (array_init = decl_constant_value (format_tree)) != format_tree
1278 && TREE_CODE (array_init) == STRING_CST)
1280 /* Extract the string constant initializer. Note that this may include
1281 a trailing NUL character that is not in the array (e.g.
1282 const char a[3] = "foo";). */
1283 array_size = DECL_SIZE_UNIT (format_tree);
1284 format_tree = array_init;
1286 if (TREE_CODE (format_tree) != STRING_CST)
1288 res->number_non_literal++;
1291 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (format_tree))) != char_type_node)
1296 format_chars = TREE_STRING_POINTER (format_tree);
1297 format_length = TREE_STRING_LENGTH (format_tree);
1298 if (array_size != 0)
1300 /* Variable length arrays can't be initialized. */
1301 if (TREE_CODE (array_size) != INTEGER_CST)
1303 if (host_integerp (array_size, 0))
1305 HOST_WIDE_INT array_size_value = TREE_INT_CST_LOW (array_size);
1306 if (array_size_value > 0
1307 && array_size_value == (int) array_size_value
1308 && format_length > array_size_value)
1309 format_length = array_size_value;
1314 if (offset >= format_length)
1316 res->number_non_literal++;
1319 format_chars += offset;
1320 format_length -= offset;
1322 if (format_length < 1)
1324 res->number_unterminated++;
1327 if (format_length == 1)
1329 res->number_empty++;
1332 if (format_chars[--format_length] != 0)
1334 res->number_unterminated++;
1338 /* Skip to first argument to check. */
1339 while (arg_num + 1 < info->first_arg_num)
1343 params = TREE_CHAIN (params);
1346 /* Provisionally increment res->number_other; check_format_info_main
1347 will decrement it if it finds there are extra arguments, but this way
1348 need not adjust it for every return. */
1349 res->number_other++;
1350 check_format_info_main (res, info, format_chars, format_length,
1355 /* Do the main part of checking a call to a format function. FORMAT_CHARS
1356 is the NUL-terminated format string (which at this point may contain
1357 internal NUL characters); FORMAT_LENGTH is its length (excluding the
1358 terminating NUL character). ARG_NUM is one less than the number of
1359 the first format argument to check; PARAMS points to that format
1360 argument in the list of arguments. */
1363 check_format_info_main (format_check_results *res,
1364 function_format_info *info, const char *format_chars,
1365 int format_length, tree params,
1366 unsigned HOST_WIDE_INT arg_num)
1368 const char *orig_format_chars = format_chars;
1369 tree first_fillin_param = params;
1371 const format_kind_info *fki = &format_types[info->format_type];
1372 const format_flag_spec *flag_specs = fki->flag_specs;
1373 const format_flag_pair *bad_flag_pairs = fki->bad_flag_pairs;
1375 /* -1 if no conversions taking an operand have been found; 0 if one has
1376 and it didn't use $; 1 if $ formats are in use. */
1377 int has_operand_number = -1;
1379 init_dollar_format_checking (info->first_arg_num, first_fillin_param);
1384 int suppressed = FALSE;
1385 const char *length_chars = NULL;
1386 enum format_lengths length_chars_val = FMT_LEN_none;
1387 enum format_std_version length_chars_std = STD_C89;
1391 int main_arg_num = 0;
1392 tree main_arg_params = 0;
1393 enum format_std_version wanted_type_std;
1394 const char *wanted_type_name;
1395 format_wanted_type width_wanted_type;
1396 format_wanted_type precision_wanted_type;
1397 format_wanted_type main_wanted_type;
1398 format_wanted_type *first_wanted_type = NULL;
1399 format_wanted_type *last_wanted_type = NULL;
1400 const format_length_info *fli = NULL;
1401 const format_char_info *fci = NULL;
1402 char flag_chars[256];
1404 const char *format_start = format_chars;
1405 if (*format_chars == 0)
1407 if (format_chars - orig_format_chars != format_length)
1408 warning ("embedded %<\\0%> in format");
1409 if (info->first_arg_num != 0 && params != 0
1410 && has_operand_number <= 0)
1412 res->number_other--;
1413 res->number_extra_args++;
1415 if (has_operand_number > 0)
1416 finish_dollar_format_checking (res, fki->flags & (int) FMT_FLAG_DOLLAR_GAP_POINTER_OK);
1419 if (*format_chars++ != '%')
1421 if (*format_chars == 0)
1423 warning ("spurious trailing %<%%%> in format");
1426 if (*format_chars == '%')
1433 if ((fki->flags & (int) FMT_FLAG_USE_DOLLAR) && has_operand_number != 0)
1435 /* Possibly read a $ operand number at the start of the format.
1436 If one was previously used, one is required here. If one
1437 is not used here, we can't immediately conclude this is a
1438 format without them, since it could be printf %m or scanf %*. */
1440 opnum = maybe_read_dollar_number (&format_chars, 0,
1442 &main_arg_params, fki);
1447 has_operand_number = 1;
1448 main_arg_num = opnum + info->first_arg_num - 1;
1451 else if (fki->flags & FMT_FLAG_USE_DOLLAR)
1453 if (avoid_dollar_number (format_chars))
1457 /* Read any format flags, but do not yet validate them beyond removing
1458 duplicates, since in general validation depends on the rest of
1460 while (*format_chars != 0
1461 && strchr (fki->flag_chars, *format_chars) != 0)
1463 const format_flag_spec *s = get_flag_spec (flag_specs,
1464 *format_chars, NULL);
1465 if (strchr (flag_chars, *format_chars) != 0)
1467 warning ("repeated %s in format", _(s->name));
1471 i = strlen (flag_chars);
1472 flag_chars[i++] = *format_chars;
1475 if (s->skip_next_char)
1478 if (*format_chars == 0)
1480 warning ("missing fill character at end of strfmon format");
1487 /* Read any format width, possibly * or *m$. */
1488 if (fki->width_char != 0)
1490 if (fki->width_type != NULL && *format_chars == '*')
1492 i = strlen (flag_chars);
1493 flag_chars[i++] = fki->width_char;
1495 /* "...a field width...may be indicated by an asterisk.
1496 In this case, an int argument supplies the field width..." */
1498 if (has_operand_number != 0)
1501 opnum = maybe_read_dollar_number (&format_chars,
1502 has_operand_number == 1,
1509 has_operand_number = 1;
1510 arg_num = opnum + info->first_arg_num - 1;
1513 has_operand_number = 0;
1517 if (avoid_dollar_number (format_chars))
1520 if (info->first_arg_num != 0)
1524 warning ("too few arguments for format");
1527 cur_param = TREE_VALUE (params);
1528 if (has_operand_number <= 0)
1530 params = TREE_CHAIN (params);
1533 width_wanted_type.wanted_type = *fki->width_type;
1534 width_wanted_type.wanted_type_name = NULL;
1535 width_wanted_type.pointer_count = 0;
1536 width_wanted_type.char_lenient_flag = 0;
1537 width_wanted_type.writing_in_flag = 0;
1538 width_wanted_type.reading_from_flag = 0;
1539 width_wanted_type.name = _("field width");
1540 width_wanted_type.param = cur_param;
1541 width_wanted_type.arg_num = arg_num;
1542 width_wanted_type.next = NULL;
1543 if (last_wanted_type != 0)
1544 last_wanted_type->next = &width_wanted_type;
1545 if (first_wanted_type == 0)
1546 first_wanted_type = &width_wanted_type;
1547 last_wanted_type = &width_wanted_type;
1552 /* Possibly read a numeric width. If the width is zero,
1553 we complain if appropriate. */
1554 int non_zero_width_char = FALSE;
1555 int found_width = FALSE;
1556 while (ISDIGIT (*format_chars))
1559 if (*format_chars != '0')
1560 non_zero_width_char = TRUE;
1563 if (found_width && !non_zero_width_char &&
1564 (fki->flags & (int) FMT_FLAG_ZERO_WIDTH_BAD))
1565 warning ("zero width in %s format", fki->name);
1568 i = strlen (flag_chars);
1569 flag_chars[i++] = fki->width_char;
1575 /* Read any format left precision (must be a number, not *). */
1576 if (fki->left_precision_char != 0 && *format_chars == '#')
1579 i = strlen (flag_chars);
1580 flag_chars[i++] = fki->left_precision_char;
1582 if (!ISDIGIT (*format_chars))
1583 warning ("empty left precision in %s format", fki->name);
1584 while (ISDIGIT (*format_chars))
1588 /* Read any format precision, possibly * or *m$. */
1589 if (fki->precision_char != 0 && *format_chars == '.')
1592 i = strlen (flag_chars);
1593 flag_chars[i++] = fki->precision_char;
1595 if (fki->precision_type != NULL && *format_chars == '*')
1597 /* "...a...precision...may be indicated by an asterisk.
1598 In this case, an int argument supplies the...precision." */
1600 if (has_operand_number != 0)
1603 opnum = maybe_read_dollar_number (&format_chars,
1604 has_operand_number == 1,
1611 has_operand_number = 1;
1612 arg_num = opnum + info->first_arg_num - 1;
1615 has_operand_number = 0;
1619 if (avoid_dollar_number (format_chars))
1622 if (info->first_arg_num != 0)
1626 warning ("too few arguments for format");
1629 cur_param = TREE_VALUE (params);
1630 if (has_operand_number <= 0)
1632 params = TREE_CHAIN (params);
1635 precision_wanted_type.wanted_type = *fki->precision_type;
1636 precision_wanted_type.wanted_type_name = NULL;
1637 precision_wanted_type.pointer_count = 0;
1638 precision_wanted_type.char_lenient_flag = 0;
1639 precision_wanted_type.writing_in_flag = 0;
1640 precision_wanted_type.reading_from_flag = 0;
1641 precision_wanted_type.name = _("field precision");
1642 precision_wanted_type.param = cur_param;
1643 precision_wanted_type.arg_num = arg_num;
1644 precision_wanted_type.next = NULL;
1645 if (last_wanted_type != 0)
1646 last_wanted_type->next = &precision_wanted_type;
1647 if (first_wanted_type == 0)
1648 first_wanted_type = &precision_wanted_type;
1649 last_wanted_type = &precision_wanted_type;
1654 if (!(fki->flags & (int) FMT_FLAG_EMPTY_PREC_OK)
1655 && !ISDIGIT (*format_chars))
1656 warning ("empty precision in %s format", fki->name);
1657 while (ISDIGIT (*format_chars))
1662 /* Read any length modifier, if this kind of format has them. */
1663 fli = fki->length_char_specs;
1664 length_chars = NULL;
1665 length_chars_val = FMT_LEN_none;
1666 length_chars_std = STD_C89;
1669 while (fli->name != 0 && fli->name[0] != *format_chars)
1674 if (fli->double_name != 0 && fli->name[0] == *format_chars)
1677 length_chars = fli->double_name;
1678 length_chars_val = fli->double_index;
1679 length_chars_std = fli->double_std;
1683 length_chars = fli->name;
1684 length_chars_val = fli->index;
1685 length_chars_std = fli->std;
1687 i = strlen (flag_chars);
1688 flag_chars[i++] = fki->length_code_char;
1693 /* Warn if the length modifier is non-standard. */
1694 if (ADJ_STD (length_chars_std) > C_STD_VER)
1695 warning ("%s does not support the %qs %s length modifier",
1696 C_STD_NAME (length_chars_std), length_chars,
1701 /* Read any modifier (strftime E/O). */
1702 if (fki->modifier_chars != NULL)
1704 while (*format_chars != 0
1705 && strchr (fki->modifier_chars, *format_chars) != 0)
1707 if (strchr (flag_chars, *format_chars) != 0)
1709 const format_flag_spec *s = get_flag_spec (flag_specs,
1710 *format_chars, NULL);
1711 warning ("repeated %s in format", _(s->name));
1715 i = strlen (flag_chars);
1716 flag_chars[i++] = *format_chars;
1723 /* Handle the scanf allocation kludge. */
1724 if (fki->flags & (int) FMT_FLAG_SCANF_A_KLUDGE)
1726 if (*format_chars == 'a' && !flag_isoc99)
1728 if (format_chars[1] == 's' || format_chars[1] == 'S'
1729 || format_chars[1] == '[')
1731 /* `a' is used as a flag. */
1732 i = strlen (flag_chars);
1733 flag_chars[i++] = 'a';
1740 format_char = *format_chars;
1741 if (format_char == 0
1742 || (!(fki->flags & (int) FMT_FLAG_FANCY_PERCENT_OK)
1743 && format_char == '%'))
1745 warning ("conversion lacks type at end of format");
1749 fci = fki->conversion_specs;
1750 while (fci->format_chars != 0
1751 && strchr (fci->format_chars, format_char) == 0)
1753 if (fci->format_chars == 0)
1755 if (ISGRAPH(format_char))
1756 warning ("unknown conversion type character %qc in format",
1759 warning ("unknown conversion type character 0x%x in format",
1765 if (ADJ_STD (fci->std) > C_STD_VER)
1766 warning ("%s does not support the %<%%%c%> %s format",
1767 C_STD_NAME (fci->std), format_char, fki->name);
1770 /* Validate the individual flags used, removing any that are invalid. */
1773 for (i = 0; flag_chars[i] != 0; i++)
1775 const format_flag_spec *s = get_flag_spec (flag_specs,
1776 flag_chars[i], NULL);
1777 flag_chars[i - d] = flag_chars[i];
1778 if (flag_chars[i] == fki->length_code_char)
1780 if (strchr (fci->flag_chars, flag_chars[i]) == 0)
1782 warning ("%s used with %<%%%c%> %s format",
1783 _(s->name), format_char, fki->name);
1789 const format_flag_spec *t;
1790 if (ADJ_STD (s->std) > C_STD_VER)
1791 warning ("%s does not support %s",
1792 C_STD_NAME (s->std), _(s->long_name));
1793 t = get_flag_spec (flag_specs, flag_chars[i], fci->flags2);
1794 if (t != NULL && ADJ_STD (t->std) > ADJ_STD (s->std))
1796 const char *long_name = (t->long_name != NULL
1799 if (ADJ_STD (t->std) > C_STD_VER)
1800 warning ("%s does not support %s with the %<%%%c%> %s format",
1801 C_STD_NAME (t->std), _(long_name),
1802 format_char, fki->name);
1806 flag_chars[i - d] = 0;
1809 if ((fki->flags & (int) FMT_FLAG_SCANF_A_KLUDGE)
1810 && strchr (flag_chars, 'a') != 0)
1813 if (fki->suppression_char
1814 && strchr (flag_chars, fki->suppression_char) != 0)
1817 /* Validate the pairs of flags used. */
1818 for (i = 0; bad_flag_pairs[i].flag_char1 != 0; i++)
1820 const format_flag_spec *s, *t;
1821 if (strchr (flag_chars, bad_flag_pairs[i].flag_char1) == 0)
1823 if (strchr (flag_chars, bad_flag_pairs[i].flag_char2) == 0)
1825 if (bad_flag_pairs[i].predicate != 0
1826 && strchr (fci->flags2, bad_flag_pairs[i].predicate) == 0)
1828 s = get_flag_spec (flag_specs, bad_flag_pairs[i].flag_char1, NULL);
1829 t = get_flag_spec (flag_specs, bad_flag_pairs[i].flag_char2, NULL);
1830 if (bad_flag_pairs[i].ignored)
1832 if (bad_flag_pairs[i].predicate != 0)
1833 warning ("%s ignored with %s and %<%%%c%> %s format",
1834 _(s->name), _(t->name), format_char,
1837 warning ("%s ignored with %s in %s format",
1838 _(s->name), _(t->name), fki->name);
1842 if (bad_flag_pairs[i].predicate != 0)
1843 warning ("use of %s and %s together with %<%%%c%> %s format",
1844 _(s->name), _(t->name), format_char,
1847 warning ("use of %s and %s together in %s format",
1848 _(s->name), _(t->name), fki->name);
1852 /* Give Y2K warnings. */
1853 if (warn_format_y2k)
1856 if (strchr (fci->flags2, '4') != 0)
1857 if (strchr (flag_chars, 'E') != 0)
1861 else if (strchr (fci->flags2, '3') != 0)
1863 else if (strchr (fci->flags2, '2') != 0)
1866 warning ("%<%%%c%> yields only last 2 digits of year in some locales",
1868 else if (y2k_level == 2)
1869 warning ("%<%%%c%> yields only last 2 digits of year", format_char);
1872 if (strchr (fci->flags2, '[') != 0)
1874 /* Skip over scan set, in case it happens to have '%' in it. */
1875 if (*format_chars == '^')
1877 /* Find closing bracket; if one is hit immediately, then
1878 it's part of the scan set rather than a terminator. */
1879 if (*format_chars == ']')
1881 while (*format_chars && *format_chars != ']')
1883 if (*format_chars != ']')
1884 /* The end of the format string was reached. */
1885 warning ("no closing %<]%> for %<%%[%> format");
1889 wanted_type_name = 0;
1890 if (fki->flags & (int) FMT_FLAG_ARG_CONVERT)
1892 wanted_type = (fci->types[length_chars_val].type
1893 ? *fci->types[length_chars_val].type : 0);
1894 wanted_type_name = fci->types[length_chars_val].name;
1895 wanted_type_std = fci->types[length_chars_val].std;
1896 if (wanted_type == 0)
1898 warning ("use of %qs length modifier with %qc type character",
1899 length_chars, format_char);
1900 /* Heuristic: skip one argument when an invalid length/type
1901 combination is encountered. */
1905 warning ("too few arguments for format");
1908 params = TREE_CHAIN (params);
1912 /* Warn if non-standard, provided it is more non-standard
1913 than the length and type characters that may already
1914 have been warned for. */
1915 && ADJ_STD (wanted_type_std) > ADJ_STD (length_chars_std)
1916 && ADJ_STD (wanted_type_std) > ADJ_STD (fci->std))
1918 if (ADJ_STD (wanted_type_std) > C_STD_VER)
1919 warning ("%s does not support the %<%%%s%c%> %s format",
1920 C_STD_NAME (wanted_type_std), length_chars,
1921 format_char, fki->name);
1925 main_wanted_type.next = NULL;
1927 /* Finally. . .check type of argument against desired type! */
1928 if (info->first_arg_num == 0)
1930 if ((fci->pointer_count == 0 && wanted_type == void_type_node)
1933 if (main_arg_num != 0)
1936 warning ("operand number specified with suppressed assignment");
1938 warning ("operand number specified for format taking no argument");
1943 format_wanted_type *wanted_type_ptr;
1945 if (main_arg_num != 0)
1947 arg_num = main_arg_num;
1948 params = main_arg_params;
1953 if (has_operand_number > 0)
1955 warning ("missing $ operand number in format");
1959 has_operand_number = 0;
1962 wanted_type_ptr = &main_wanted_type;
1967 warning ("too few arguments for format");
1971 cur_param = TREE_VALUE (params);
1972 params = TREE_CHAIN (params);
1974 wanted_type_ptr->wanted_type = wanted_type;
1975 wanted_type_ptr->wanted_type_name = wanted_type_name;
1976 wanted_type_ptr->pointer_count = fci->pointer_count + aflag;
1977 wanted_type_ptr->char_lenient_flag = 0;
1978 if (strchr (fci->flags2, 'c') != 0)
1979 wanted_type_ptr->char_lenient_flag = 1;
1980 wanted_type_ptr->writing_in_flag = 0;
1981 wanted_type_ptr->reading_from_flag = 0;
1983 wanted_type_ptr->writing_in_flag = 1;
1986 if (strchr (fci->flags2, 'W') != 0)
1987 wanted_type_ptr->writing_in_flag = 1;
1988 if (strchr (fci->flags2, 'R') != 0)
1989 wanted_type_ptr->reading_from_flag = 1;
1991 wanted_type_ptr->name = NULL;
1992 wanted_type_ptr->param = cur_param;
1993 wanted_type_ptr->arg_num = arg_num;
1994 wanted_type_ptr->next = NULL;
1995 if (last_wanted_type != 0)
1996 last_wanted_type->next = wanted_type_ptr;
1997 if (first_wanted_type == 0)
1998 first_wanted_type = wanted_type_ptr;
1999 last_wanted_type = wanted_type_ptr;
2004 wanted_type_ptr = ggc_alloc (sizeof (main_wanted_type));
2006 wanted_type = *fci->types[length_chars_val].type;
2007 wanted_type_name = fci->types[length_chars_val].name;
2012 if (first_wanted_type != 0)
2013 check_format_types (first_wanted_type, format_start,
2014 format_chars - format_start);
2016 if (main_wanted_type.next != NULL)
2018 format_wanted_type *wanted_type_ptr = main_wanted_type.next;
2019 while (wanted_type_ptr)
2021 format_wanted_type *next = wanted_type_ptr->next;
2022 ggc_free (wanted_type_ptr);
2023 wanted_type_ptr = next;
2030 /* Check the argument types from a single format conversion (possibly
2031 including width and precision arguments). */
2033 check_format_types (format_wanted_type *types, const char *format_start,
2036 for (; types != 0; types = types->next)
2045 cur_param = types->param;
2046 cur_type = TREE_TYPE (cur_param);
2047 if (cur_type == error_mark_node)
2049 orig_cur_type = cur_type;
2051 wanted_type = types->wanted_type;
2052 arg_num = types->arg_num;
2054 /* The following should not occur here. */
2055 if (wanted_type == 0)
2057 if (wanted_type == void_type_node && types->pointer_count == 0)
2060 if (types->pointer_count == 0)
2061 wanted_type = lang_hooks.types.type_promotes_to (wanted_type);
2063 wanted_type = TYPE_MAIN_VARIANT (wanted_type);
2065 STRIP_NOPS (cur_param);
2067 /* Check the types of any additional pointer arguments
2068 that precede the "real" argument. */
2069 for (i = 0; i < types->pointer_count; ++i)
2071 if (TREE_CODE (cur_type) == POINTER_TYPE)
2073 cur_type = TREE_TYPE (cur_type);
2074 if (cur_type == error_mark_node)
2077 /* Check for writing through a NULL pointer. */
2078 if (types->writing_in_flag
2081 && integer_zerop (cur_param))
2082 warning ("writing through null pointer (arg %d)",
2085 /* Check for reading through a NULL pointer. */
2086 if (types->reading_from_flag
2089 && integer_zerop (cur_param))
2090 warning ("reading through null pointer (arg %d)",
2093 if (cur_param != 0 && TREE_CODE (cur_param) == ADDR_EXPR)
2094 cur_param = TREE_OPERAND (cur_param, 0);
2098 /* See if this is an attempt to write into a const type with
2099 scanf or with printf "%n". Note: the writing in happens
2100 at the first indirection only, if for example
2101 void * const * is passed to scanf %p; passing
2102 const void ** is simply passing an incompatible type. */
2103 if (types->writing_in_flag
2105 && (TYPE_READONLY (cur_type)
2107 && (TREE_CODE_CLASS (TREE_CODE (cur_param)) == 'c'
2108 || (DECL_P (cur_param)
2109 && TREE_READONLY (cur_param))))))
2110 warning ("writing into constant object (arg %d)", arg_num);
2112 /* If there are extra type qualifiers beyond the first
2113 indirection, then this makes the types technically
2117 && (TYPE_READONLY (cur_type)
2118 || TYPE_VOLATILE (cur_type)
2119 || TYPE_RESTRICT (cur_type)))
2120 warning ("extra type qualifiers in format argument (arg %d)",
2126 format_type_warning (types->name, format_start, format_length,
2127 wanted_type, types->pointer_count,
2128 types->wanted_type_name, orig_cur_type,
2134 if (i < types->pointer_count)
2137 cur_type = TYPE_MAIN_VARIANT (cur_type);
2139 /* Check whether the argument type is a character type. This leniency
2140 only applies to certain formats, flagged with 'c'.
2142 if (types->char_lenient_flag)
2143 char_type_flag = (cur_type == char_type_node
2144 || cur_type == signed_char_type_node
2145 || cur_type == unsigned_char_type_node);
2147 /* Check the type of the "real" argument, if there's a type we want. */
2148 if (wanted_type == cur_type)
2150 /* If we want `void *', allow any pointer type.
2151 (Anything else would already have got a warning.)
2152 With -pedantic, only allow pointers to void and to character
2154 if (wanted_type == void_type_node
2155 && (!pedantic || (i == 1 && char_type_flag)))
2157 /* Don't warn about differences merely in signedness, unless
2158 -pedantic. With -pedantic, warn if the type is a pointer
2159 target and not a character type, and for character types at
2160 a second level of indirection. */
2161 if (TREE_CODE (wanted_type) == INTEGER_TYPE
2162 && TREE_CODE (cur_type) == INTEGER_TYPE
2163 && (! pedantic || i == 0 || (i == 1 && char_type_flag))
2164 && (TYPE_UNSIGNED (wanted_type)
2165 ? wanted_type == c_common_unsigned_type (cur_type)
2166 : wanted_type == c_common_signed_type (cur_type)))
2168 /* Likewise, "signed char", "unsigned char" and "char" are
2169 equivalent but the above test won't consider them equivalent. */
2170 if (wanted_type == char_type_node
2171 && (! pedantic || i < 2)
2174 /* Now we have a type mismatch. */
2175 format_type_warning (types->name, format_start, format_length,
2176 wanted_type, types->pointer_count,
2177 types->wanted_type_name, orig_cur_type, arg_num);
2182 /* Give a warning about a format argument of different type from that
2183 expected. DESCR is a description such as "field precision", or
2184 NULL for an ordinary format. For an ordinary format, FORMAT_START
2185 points to where the format starts in the format string and
2186 FORMAT_LENGTH is its length. WANTED_TYPE is the type the argument
2187 should have after POINTER_COUNT pointer dereferences.
2188 WANTED_NAME_NAME is a possibly more friendly name of WANTED_TYPE,
2189 or NULL if the ordinary name of the type should be used. ARG_TYPE
2190 is the type of the actual argument. ARG_NUM is the number of that
2193 format_type_warning (const char *descr, const char *format_start,
2194 int format_length, tree wanted_type, int pointer_count,
2195 const char *wanted_type_name, tree arg_type, int arg_num)
2198 /* If ARG_TYPE is a typedef with a misleading name (for example,
2199 size_t but not the standard size_t expected by printf %zu), avoid
2200 printing the typedef name. */
2201 if (wanted_type_name
2202 && TYPE_NAME (arg_type)
2203 && TREE_CODE (TYPE_NAME (arg_type)) == TYPE_DECL
2204 && DECL_NAME (TYPE_NAME (arg_type))
2205 && !strcmp (wanted_type_name,
2206 lang_hooks.decl_printable_name (TYPE_NAME (arg_type), 2)))
2207 arg_type = TYPE_MAIN_VARIANT (arg_type);
2208 /* The format type and name exclude any '*' for pointers, so those
2209 must be formatted manually. For all the types we currently have,
2210 this is adequate, but formats taking pointers to functions or
2211 arrays would require the full type to be built up in order to
2212 print it with %T. */
2213 p = alloca (pointer_count + 2);
2214 if (pointer_count == 0)
2216 else if (c_dialect_cxx ())
2218 memset (p, '*', pointer_count);
2219 p[pointer_count] = 0;
2224 memset (p + 1, '*', pointer_count);
2225 p[pointer_count + 1] = 0;
2227 if (wanted_type_name)
2230 warning ("%s should have type %<%s%s%>, but argument %d has type %qT",
2231 descr, wanted_type_name, p, arg_num, arg_type);
2233 warning ("format %q.*s expects type %<%s%s%>, but argument %d has type %qT",
2234 format_length, format_start, wanted_type_name, p,
2240 warning ("%s should have type %<%T%s%>, but argument %d has type %qT",
2241 descr, wanted_type, p, arg_num, arg_type);
2243 warning ("format %q.*s expects type %<%T%s%>, but argument %d has type %qT",
2244 format_length, format_start, wanted_type, p, arg_num, arg_type);
2249 /* Given a format_char_info array FCI, and a character C, this function
2250 returns the index into the conversion_specs where that specifier's
2251 data is located. If the character isn't found it aborts. */
2253 find_char_info_specifier_index (const format_char_info *fci, int c)
2257 while (fci->format_chars)
2259 if (strchr (fci->format_chars, c))
2264 /* We shouldn't be looking for a non-existent specifier. */
2268 /* Given a format_length_info array FLI, and a character C, this
2269 function returns the index into the conversion_specs where that
2270 modifier's data is located. If the character isn't found it
2273 find_length_info_modifier_index (const format_length_info *fli, int c)
2279 if (strchr (fli->name, c))
2284 /* We shouldn't be looking for a non-existent modifier. */
2288 /* Determine the type of HOST_WIDE_INT in the code being compiled for
2289 use in GCC's __asm_fprintf__ custom format attribute. You must
2290 have set dynamic_format_types before calling this function. */
2292 init_dynamic_asm_fprintf_info (void)
2298 format_length_info *new_asm_fprintf_length_specs;
2301 /* Find the underlying type for HOST_WIDE_INT. For the %w
2302 length modifier to work, one must have issued: "typedef
2303 HOST_WIDE_INT __gcc_host_wide_int__;" in one's source code
2304 prior to using that modifier. */
2305 if (!(hwi = maybe_get_identifier ("__gcc_host_wide_int__"))
2306 || !(hwi = DECL_ORIGINAL_TYPE (identifier_global_value (hwi))))
2309 /* Create a new (writable) copy of asm_fprintf_length_specs. */
2310 new_asm_fprintf_length_specs = xmemdup (asm_fprintf_length_specs,
2311 sizeof (asm_fprintf_length_specs),
2312 sizeof (asm_fprintf_length_specs));
2314 /* HOST_WIDE_INT must be one of 'long' or 'long long'. */
2315 i = find_length_info_modifier_index (new_asm_fprintf_length_specs, 'w');
2316 if (hwi == long_integer_type_node)
2317 new_asm_fprintf_length_specs[i].index = FMT_LEN_l;
2318 else if (hwi == long_long_integer_type_node)
2319 new_asm_fprintf_length_specs[i].index = FMT_LEN_ll;
2323 /* Assign the new data for use. */
2324 dynamic_format_types[asm_fprintf_format_type].length_char_specs =
2325 new_asm_fprintf_length_specs;
2329 /* Determine the types of "tree" and "location_t" in the code being
2330 compiled for use in GCC's diagnostic custom format attributes. You
2331 must have set dynamic_format_types before calling this function. */
2333 init_dynamic_diag_info (void)
2335 static tree t, loc, hwi;
2337 if (!loc || !t || !hwi)
2339 static format_char_info *diag_fci, *cdiag_fci, *cxxdiag_fci;
2340 static format_length_info *diag_ls;
2343 /* For the GCC-diagnostics custom format specifiers to work, one
2344 must have declared `tree' and/or `location_t' prior to using
2345 those attributes. If we haven't seen these declarations then
2346 you shouldn't use the specifiers requiring these types.
2347 However we don't force a hard ICE because we may see only one
2348 or the other type. */
2349 if ((loc = maybe_get_identifier ("location_t")))
2350 loc = TREE_TYPE (identifier_global_value (loc));
2352 /* We need to grab the underlying `union tree_node' so peek into
2353 an extra type level. */
2354 if ((t = maybe_get_identifier ("tree")))
2355 t = TREE_TYPE (TREE_TYPE (identifier_global_value (t)));
2357 /* Find the underlying type for HOST_WIDE_INT. For the %w
2358 length modifier to work, one must have issued: "typedef
2359 HOST_WIDE_INT __gcc_host_wide_int__;" in one's source code
2360 prior to using that modifier. */
2361 if ((hwi = maybe_get_identifier ("__gcc_host_wide_int__")))
2362 hwi = DECL_ORIGINAL_TYPE (identifier_global_value (hwi));
2364 /* Assign the new data for use. */
2366 /* All the GCC diag formats use the same length specs. */
2368 dynamic_format_types[gcc_diag_format_type].length_char_specs =
2369 dynamic_format_types[gcc_cdiag_format_type].length_char_specs =
2370 dynamic_format_types[gcc_cxxdiag_format_type].length_char_specs =
2371 diag_ls = xmemdup (gcc_diag_length_specs,
2372 sizeof (gcc_diag_length_specs),
2373 sizeof (gcc_diag_length_specs));
2376 /* HOST_WIDE_INT must be one of 'long' or 'long long'. */
2377 i = find_length_info_modifier_index (diag_ls, 'w');
2378 if (hwi == long_integer_type_node)
2379 diag_ls[i].index = FMT_LEN_l;
2380 else if (hwi == long_long_integer_type_node)
2381 diag_ls[i].index = FMT_LEN_ll;
2386 /* Handle the __gcc_diag__ format specifics. */
2388 dynamic_format_types[gcc_diag_format_type].conversion_specs =
2389 diag_fci = xmemdup (gcc_diag_char_table,
2390 sizeof(gcc_diag_char_table),
2391 sizeof(gcc_diag_char_table));
2394 i = find_char_info_specifier_index (diag_fci, 'H');
2395 diag_fci[i].types[0].type = &loc;
2396 diag_fci[i].pointer_count = 1;
2400 i = find_char_info_specifier_index (diag_fci, 'J');
2401 diag_fci[i].types[0].type = &t;
2402 diag_fci[i].pointer_count = 1;
2405 /* Handle the __gcc_cdiag__ format specifics. */
2407 dynamic_format_types[gcc_cdiag_format_type].conversion_specs =
2408 cdiag_fci = xmemdup (gcc_cdiag_char_table,
2409 sizeof(gcc_cdiag_char_table),
2410 sizeof(gcc_cdiag_char_table));
2413 i = find_char_info_specifier_index (cdiag_fci, 'H');
2414 cdiag_fci[i].types[0].type = &loc;
2415 cdiag_fci[i].pointer_count = 1;
2419 /* All specifiers taking a tree share the same struct. */
2420 i = find_char_info_specifier_index (cdiag_fci, 'D');
2421 cdiag_fci[i].types[0].type = &t;
2422 cdiag_fci[i].pointer_count = 1;
2423 i = find_char_info_specifier_index (cdiag_fci, 'J');
2424 cdiag_fci[i].types[0].type = &t;
2425 cdiag_fci[i].pointer_count = 1;
2428 /* Handle the __gcc_cxxdiag__ format specifics. */
2430 dynamic_format_types[gcc_cxxdiag_format_type].conversion_specs =
2431 cxxdiag_fci = xmemdup (gcc_cxxdiag_char_table,
2432 sizeof(gcc_cxxdiag_char_table),
2433 sizeof(gcc_cxxdiag_char_table));
2436 i = find_char_info_specifier_index (cxxdiag_fci, 'H');
2437 cxxdiag_fci[i].types[0].type = &loc;
2438 cxxdiag_fci[i].pointer_count = 1;
2442 /* All specifiers taking a tree share the same struct. */
2443 i = find_char_info_specifier_index (cxxdiag_fci, 'D');
2444 cxxdiag_fci[i].types[0].type = &t;
2445 cxxdiag_fci[i].pointer_count = 1;
2446 i = find_char_info_specifier_index (cxxdiag_fci, 'J');
2447 cxxdiag_fci[i].types[0].type = &t;
2448 cxxdiag_fci[i].pointer_count = 1;
2453 #ifdef TARGET_FORMAT_TYPES
2454 extern const format_kind_info TARGET_FORMAT_TYPES[];
2457 /* Handle a "format" attribute; arguments as in
2458 struct attribute_spec.handler. */
2460 handle_format_attribute (tree *node, tree name ATTRIBUTE_UNUSED, tree args,
2461 int flags, bool *no_add_attrs)
2464 function_format_info info;
2467 #ifdef TARGET_FORMAT_TYPES
2468 /* If the target provides additional format types, we need to
2469 add them to FORMAT_TYPES at first use. */
2470 if (TARGET_FORMAT_TYPES != NULL && !dynamic_format_types)
2472 dynamic_format_types = xmalloc ((n_format_types + TARGET_N_FORMAT_TYPES)
2473 * sizeof (dynamic_format_types[0]));
2474 memcpy (dynamic_format_types, format_types_orig,
2475 sizeof (format_types_orig));
2476 memcpy (&dynamic_format_types[n_format_types], TARGET_FORMAT_TYPES,
2477 TARGET_N_FORMAT_TYPES * sizeof (dynamic_format_types[0]));
2479 format_types = dynamic_format_types;
2480 n_format_types += TARGET_N_FORMAT_TYPES;
2484 if (!decode_format_attr (args, &info, 0))
2486 *no_add_attrs = true;
2490 argument = TYPE_ARG_TYPES (type);
2493 if (!check_format_string (argument, info.format_num, flags,
2497 if (info.first_arg_num != 0)
2499 unsigned HOST_WIDE_INT arg_num = 1;
2501 /* Verify that first_arg_num points to the last arg,
2504 arg_num++, argument = TREE_CHAIN (argument);
2506 if (arg_num != info.first_arg_num)
2508 if (!(flags & (int) ATTR_FLAG_BUILT_IN))
2509 error ("args to be formatted is not '...'");
2510 *no_add_attrs = true;
2516 if (info.format_type == strftime_format_type && info.first_arg_num != 0)
2518 error ("strftime formats cannot format arguments");
2519 *no_add_attrs = true;
2523 /* If this is a custom GCC-internal format type, we have to
2524 initialize certain bits a runtime. */
2525 if (info.format_type == asm_fprintf_format_type
2526 || info.format_type == gcc_diag_format_type
2527 || info.format_type == gcc_cdiag_format_type
2528 || info.format_type == gcc_cxxdiag_format_type)
2530 /* Our first time through, we have to make sure that our
2531 format_type data is allocated dynamically and is modifiable. */
2532 if (!dynamic_format_types)
2533 format_types = dynamic_format_types =
2534 xmemdup (format_types_orig, sizeof (format_types_orig),
2535 sizeof (format_types_orig));
2537 /* If this is format __asm_fprintf__, we have to initialize
2538 GCC's notion of HOST_WIDE_INT for checking %wd. */
2539 if (info.format_type == asm_fprintf_format_type)
2540 init_dynamic_asm_fprintf_info();
2541 /* If this is one of the diagnostic attributes, then we have to
2542 initialize `location_t' and `tree' at runtime. */
2543 else if (info.format_type == gcc_diag_format_type
2544 || info.format_type == gcc_cdiag_format_type
2545 || info.format_type == gcc_cxxdiag_format_type)
2546 init_dynamic_diag_info();