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