OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [gcc/] [c-format.c] - Blame information for rev 859

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.