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