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