maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/lib/Analysis/PrintfFormatString.cpp

763 lines
23 KiB
C++
Raw Normal View History

Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
//== PrintfFormatString.cpp - Analysis of printf format strings --*- C++ -*-==//
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Handling of format string in printf and friends. The structure of format
// strings for fprintf() are described in C99 7.19.6.1.
//
//===----------------------------------------------------------------------===//
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
#include "clang/Analysis/Analyses/FormatString.h"
#include "FormatStringParsing.h"
Sort all of Clang's files under 'lib', and fix up the broken headers uncovered. This required manually correcting all of the incorrect main-module headers I could find, and running the new llvm/utils/sort_includes.py script over the files. I also manually added quite a few missing headers that were uncovered by shuffling the order or moving headers up to be main-module-headers. llvm-svn: 169237
2012-12-04 17:13:33 +08:00
#include "clang/Basic/TargetInfo.h"
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
Rename analyze_format_string::ArgTypeResult to ArgType Also remove redundant constructors and unused member functions. llvm-svn: 161403
2012-08-07 16:11:26 +08:00
using clang::analyze_format_string::ArgType;
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
using clang::analyze_format_string::FormatStringHandler;
using clang::analyze_format_string::LengthModifier;
using clang::analyze_format_string::OptionalAmount;
Add 'ConversionSpecifier' root class in 'analyze_format_string' namespace and derived 'PrintfConversionSpecifier' from this class. We will do the same for 'ScanfConversionSpecifier'. llvm-svn: 108903
2010-07-21 04:04:27 +08:00
using clang::analyze_format_string::ConversionSpecifier;
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
using clang::analyze_printf::PrintfSpecifier;
For printf format string checking, add support for positional format strings. Along the way, coelesce some of the diagnostics. llvm-svn: 97297
2010-02-27 09:41:03 +08:00
Alternate format string checking: issue warnings for incomplete format specifiers. In addition, move ParseFormatString() and FormatStringHandler() from the clang::analyze_printf to the clang namespace. Hopefully this will resolve some link errors on Linux. llvm-svn: 94794
2010-01-29 11:16:21 +08:00
using namespace clang;
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
typedef clang::analyze_format_string::SpecifierResult<PrintfSpecifier>
PrintfSpecifierResult;
Refactor the logic for printf argument type-checking into analyze_printf::ArgTypeResult. Implement printf argument type checking for '%s'. Fixes <rdar://problem/3065808>. llvm-svn: 96310
2010-02-16 09:46:59 +08:00
//===----------------------------------------------------------------------===//
// Methods for parsing format strings.
//===----------------------------------------------------------------------===//
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
using analyze_format_string::ParseNonPositionAmount;
For printf format string checking, add support for positional format strings. Along the way, coelesce some of the diagnostics. llvm-svn: 97297
2010-02-27 09:41:03 +08:00
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
static bool ParsePrecision(FormatStringHandler &H, PrintfSpecifier &FS,
For printf format string checking, add support for positional format strings. Along the way, coelesce some of the diagnostics. llvm-svn: 97297
2010-02-27 09:41:03 +08:00
const char *Start, const char *&Beg, const char *E,
unsigned *argIndex) {
if (argIndex) {
FS.setPrecision(ParseNonPositionAmount(Beg, E, *argIndex));
Fix else style. No functionality change intended. llvm-svn: 137896
2011-08-18 07:08:45 +08:00
} else {
For printf format string checking, add support for positional format strings. Along the way, coelesce some of the diagnostics. llvm-svn: 97297
2010-02-27 09:41:03 +08:00
const OptionalAmount Amt = ParsePositionAmount(H, Start, Beg, E,
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
analyze_format_string::PrecisionPos);
For printf format string checking, add support for positional format strings. Along the way, coelesce some of the diagnostics. llvm-svn: 97297
2010-02-27 09:41:03 +08:00
if (Amt.isInvalid())
return true;
FS.setPrecision(Amt);
}
return false;
}
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
static PrintfSpecifierResult ParsePrintfSpecifier(FormatStringHandler &H,
Move ParseFormatString() and FormatStringHandler back into the analyze_printf namespace. llvm-svn: 95324
2010-02-05 04:46:58 +08:00
const char *&Beg,
For printf format string checking, move the tracking of the data argument index out of Sema and into analyze_printf::ParseFormatString(). Also use a bitvector to determine what arguments have been covered (instead of just checking to see if the last argument consumed is the max argument). This is prep. for support positional arguments (an IEEE extension). llvm-svn: 97248
2010-02-27 03:18:41 +08:00
const char *E,
Support the 'a' length modifier in scanf format strings as a C90 extension. This fixes gcc.dg/format/c90-scanf-3.c and ext-4.c (test for excess errors). llvm-svn: 146649
2011-12-15 18:25:47 +08:00
unsigned &argIndex,
Format strings: %D, %U, and %O are valid on Darwin (same as %d, %u, %o). These will warn under -Wformat-non-iso, and will still be rejected outright on other platforms. <rdar://problem/12061922> llvm-svn: 163771
2012-09-13 10:11:03 +08:00
const LangOptions &LO,
const TargetInfo &Target) {
Refactor the logic for printf argument type-checking into analyze_printf::ArgTypeResult. Implement printf argument type checking for '%s'. Fixes <rdar://problem/3065808>. llvm-svn: 96310
2010-02-16 09:46:59 +08:00
Add 'ConversionSpecifier' root class in 'analyze_format_string' namespace and derived 'PrintfConversionSpecifier' from this class. We will do the same for 'ScanfConversionSpecifier'. llvm-svn: 108903
2010-07-21 04:04:27 +08:00
using namespace clang::analyze_format_string;
Yet another attempt to make the Linux buildbots happy. Apparently there are differences on how nested namespaces are handled... llvm-svn: 94790
2010-01-29 10:13:53 +08:00
using namespace clang::analyze_printf;
Refactor the logic for printf argument type-checking into analyze_printf::ArgTypeResult. Implement printf argument type checking for '%s'. Fixes <rdar://problem/3065808>. llvm-svn: 96310
2010-02-16 09:46:59 +08:00
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
const char *I = Beg;
Add a few more conversion specifiers to ParseFormatSpecifier (these appear in SemaChecking). llvm-svn: 94704
2010-01-28 08:02:05 +08:00
const char *Start = 0;
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
UpdateOnReturn <const char*> UpdateBeg(Beg, I);
// Look for a '%' character that indicates the start of a format specifier.
Fix off-by-one error in ParseFormatSpecifier() when reporting the location of a null character. llvm-svn: 94762
2010-01-29 07:56:52 +08:00
for ( ; I != E ; ++I) {
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
char c = *I;
if (c == '\0') {
// Detect spurious null characters, which are likely errors.
H.HandleNullChar(I);
return true;
}
if (c == '%') {
Fix off-by-one error in ParseFormatSpecifier() when reporting the location of a null character. llvm-svn: 94762
2010-01-29 07:56:52 +08:00
Start = I++; // Record the start of the format specifier.
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
break;
}
}
Refactor the logic for printf argument type-checking into analyze_printf::ArgTypeResult. Implement printf argument type checking for '%s'. Fixes <rdar://problem/3065808>. llvm-svn: 96310
2010-02-16 09:46:59 +08:00
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
// No format specifier found?
if (!Start)
return false;
Refactor the logic for printf argument type-checking into analyze_printf::ArgTypeResult. Implement printf argument type checking for '%s'. Fixes <rdar://problem/3065808>. llvm-svn: 96310
2010-02-16 09:46:59 +08:00
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
if (I == E) {
// No more characters left?
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
H.HandleIncompleteSpecifier(Start, E - Start);
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
return true;
}
Refactor the logic for printf argument type-checking into analyze_printf::ArgTypeResult. Implement printf argument type checking for '%s'. Fixes <rdar://problem/3065808>. llvm-svn: 96310
2010-02-16 09:46:59 +08:00
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
PrintfSpecifier FS;
For printf format string checking, add support for positional format strings. Along the way, coelesce some of the diagnostics. llvm-svn: 97297
2010-02-27 09:41:03 +08:00
if (ParseArgPosition(H, FS, Start, I, E))
return true;
if (I == E) {
// No more characters left?
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
H.HandleIncompleteSpecifier(Start, E - Start);
For printf format string checking, add support for positional format strings. Along the way, coelesce some of the diagnostics. llvm-svn: 97297
2010-02-27 09:41:03 +08:00
return true;
}
Refactor the logic for printf argument type-checking into analyze_printf::ArgTypeResult. Implement printf argument type checking for '%s'. Fixes <rdar://problem/3065808>. llvm-svn: 96310
2010-02-16 09:46:59 +08:00
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
// Look for flags (if any).
bool hasMore = true;
for ( ; I != E; ++I) {
switch (*I) {
default: hasMore = false; break;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
case '\'':
Add printf format string parsing support for ' prefix to format conversions (POSIX extension). llvm-svn: 123054
2011-01-08 13:28:38 +08:00
// FIXME: POSIX specific. Always accept?
FS.setHasThousandsGrouping(I);
break;
Bug 7377: Fixed several bad printf format string bugs. - Added warning for undefined behavior when using field specifier - Added warning for undefined behavior when using length modifier - Fixed warnings for invalid flags - Added warning for ignored flags - Added fixits for the above warnings - Fixed accuracy of detecting several undefined behavior conditions - Receive normal warnings in addition to security warnings when using %n - Fix bug where '+' flag would remain on unsigned conversion suggestions Summary of changes: - Added expanded tests - Added/expanded warnings - Added position info to OptionalAmounts for fixits - Extracted optional flags to a wrapper class with position info for fixits - Added several methods to validate a FormatSpecifier by component, each checking for undefined behavior - Fixed conversion specifier checking to conform to C99 standard - Added hooks to detect the invalid states in CheckPrintfHandler::HandleFormatSpecifier Note: warnings involving the ' ' (space) flag are temporarily disabled until whitespace highlighting no longer triggers assertions. I will make a post about this on cfe-dev shortly. M test/Sema/format-strings.c M include/clang/Basic/DiagnosticSemaKinds.td M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 106233
2010-06-18 03:00:27 +08:00
case '-': FS.setIsLeftJustified(I); break;
case '+': FS.setHasPlusPrefix(I); break;
case ' ': FS.setHasSpacePrefix(I); break;
case '#': FS.setHasAlternativeForm(I); break;
case '0': FS.setHasLeadingZeros(I); break;
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
}
if (!hasMore)
break;
Refactor the logic for printf argument type-checking into analyze_printf::ArgTypeResult. Implement printf argument type checking for '%s'. Fixes <rdar://problem/3065808>. llvm-svn: 96310
2010-02-16 09:46:59 +08:00
}
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
if (I == E) {
// No more characters left?
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
H.HandleIncompleteSpecifier(Start, E - Start);
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
return true;
}
Refactor the logic for printf argument type-checking into analyze_printf::ArgTypeResult. Implement printf argument type checking for '%s'. Fixes <rdar://problem/3065808>. llvm-svn: 96310
2010-02-16 09:46:59 +08:00
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
// Look for the field width (if any).
For printf format string checking, add support for positional format strings. Along the way, coelesce some of the diagnostics. llvm-svn: 97297
2010-02-27 09:41:03 +08:00
if (ParseFieldWidth(H, FS, Start, I, E,
FS.usesPositionalArg() ? 0 : &argIndex))
return true;
Refactor the logic for printf argument type-checking into analyze_printf::ArgTypeResult. Implement printf argument type checking for '%s'. Fixes <rdar://problem/3065808>. llvm-svn: 96310
2010-02-16 09:46:59 +08:00
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
if (I == E) {
// No more characters left?
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
H.HandleIncompleteSpecifier(Start, E - Start);
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
return true;
Refactor the logic for printf argument type-checking into analyze_printf::ArgTypeResult. Implement printf argument type checking for '%s'. Fixes <rdar://problem/3065808>. llvm-svn: 96310
2010-02-16 09:46:59 +08:00
}
// Look for the precision (if any).
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
if (*I == '.') {
Alternate format string checking: issue warnings for incomplete format specifiers. In addition, move ParseFormatString() and FormatStringHandler() from the clang::analyze_printf to the clang namespace. Hopefully this will resolve some link errors on Linux. llvm-svn: 94794
2010-01-29 11:16:21 +08:00
++I;
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
if (I == E) {
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
H.HandleIncompleteSpecifier(Start, E - Start);
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
return true;
}
Refactor the logic for printf argument type-checking into analyze_printf::ArgTypeResult. Implement printf argument type checking for '%s'. Fixes <rdar://problem/3065808>. llvm-svn: 96310
2010-02-16 09:46:59 +08:00
For printf format string checking, add support for positional format strings. Along the way, coelesce some of the diagnostics. llvm-svn: 97297
2010-02-27 09:41:03 +08:00
if (ParsePrecision(H, FS, Start, I, E,
FS.usesPositionalArg() ? 0 : &argIndex))
return true;
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
if (I == E) {
// No more characters left?
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
H.HandleIncompleteSpecifier(Start, E - Start);
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
return true;
}
}
// Look for the length modifier.
Support the 'a' length modifier in scanf format strings as a C90 extension. This fixes gcc.dg/format/c90-scanf-3.c and ext-4.c (test for excess errors). llvm-svn: 146649
2011-12-15 18:25:47 +08:00
if (ParseLengthModifier(FS, I, E, LO) && I == E) {
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
// No more characters left?
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
H.HandleIncompleteSpecifier(Start, E - Start);
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
return true;
}
Convert tabs to spaces. llvm-svn: 95621
2010-02-09 08:04:09 +08:00
Enhancements to the alternate (WIP) format string checking: - Add ConversionSpecifier::consumesDataArgument() as a helper method to determine if a conversion specifier requires a matching argument. - Add support for glibc-specific '%m' conversion - Add an extra callback to HandleNull() for locations within the format specifier that have a null character llvm-svn: 94834
2010-01-30 04:29:53 +08:00
if (*I == '\0') {
Convert tabs to spaces. llvm-svn: 95621
2010-02-09 08:04:09 +08:00
// Detect spurious null characters, which are likely errors.
H.HandleNullChar(I);
return true;
Enhancements to the alternate (WIP) format string checking: - Add ConversionSpecifier::consumesDataArgument() as a helper method to determine if a conversion specifier requires a matching argument. - Add support for glibc-specific '%m' conversion - Add an extra callback to HandleNull() for locations within the format specifier that have a null character llvm-svn: 94834
2010-01-30 04:29:53 +08:00
}
Refactor the logic for printf argument type-checking into analyze_printf::ArgTypeResult. Implement printf argument type checking for '%s'. Fixes <rdar://problem/3065808>. llvm-svn: 96310
2010-02-16 09:46:59 +08:00
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
// Finally, look for the conversion specifier.
Add position of conversion specifier character to 'ConversionSpecifier'. llvm-svn: 94739
2010-01-28 10:46:17 +08:00
const char *conversionPosition = I++;
Alternate format string checking: issue a warning for invalid conversion specifiers. llvm-svn: 94792
2010-01-29 10:40:24 +08:00
ConversionSpecifier::Kind k = ConversionSpecifier::InvalidSpecifier;
Add position of conversion specifier character to 'ConversionSpecifier'. llvm-svn: 94739
2010-01-28 10:46:17 +08:00
switch (*conversionPosition) {
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
default:
Alternate format string checking: issue a warning for invalid conversion specifiers. llvm-svn: 94792
2010-01-29 10:40:24 +08:00
break;
Add '@' conversion specifier. llvm-svn: 94713
2010-01-28 08:55:28 +08:00
// C99: 7.19.6.1 (section 8).
Add support for '%C' and '%S' printf conversion specifiers. llvm-svn: 97005
2010-02-24 08:05:54 +08:00
case '%': k = ConversionSpecifier::PercentArg; break;
case 'A': k = ConversionSpecifier::AArg; break;
Add position of conversion specifier character to 'ConversionSpecifier'. llvm-svn: 94739
2010-01-28 10:46:17 +08:00
case 'E': k = ConversionSpecifier::EArg; break;
Add support for '%C' and '%S' printf conversion specifiers. llvm-svn: 97005
2010-02-24 08:05:54 +08:00
case 'F': k = ConversionSpecifier::FArg; break;
Add position of conversion specifier character to 'ConversionSpecifier'. llvm-svn: 94739
2010-01-28 10:46:17 +08:00
case 'G': k = ConversionSpecifier::GArg; break;
Add support for '%C' and '%S' printf conversion specifiers. llvm-svn: 97005
2010-02-24 08:05:54 +08:00
case 'X': k = ConversionSpecifier::XArg; break;
Add position of conversion specifier character to 'ConversionSpecifier'. llvm-svn: 94739
2010-01-28 10:46:17 +08:00
case 'a': k = ConversionSpecifier::aArg; break;
Rename analyze_printf::ConversionSpecifier::IntAsCharArg to 'cArg' to match analagous enum in analyze_scanf. This is prep for refactoring the logic for handling ConversionSpecifiers for both scanf and printf. llvm-svn: 108897
2010-07-21 04:03:49 +08:00
case 'c': k = ConversionSpecifier::cArg; break;
Add support for '%C' and '%S' printf conversion specifiers. llvm-svn: 97005
2010-02-24 08:05:54 +08:00
case 'd': k = ConversionSpecifier::dArg; break;
case 'e': k = ConversionSpecifier::eArg; break;
case 'f': k = ConversionSpecifier::fArg; break;
case 'g': k = ConversionSpecifier::gArg; break;
case 'i': k = ConversionSpecifier::iArg; break;
Rename 'ConsumedSoFarArg' -> 'nArg' and 'OutIntPtrArg' to 'nArg' (scanf and printf checking). llvm-svn: 108900
2010-07-21 04:04:10 +08:00
case 'n': k = ConversionSpecifier::nArg; break;
Add support for '%C' and '%S' printf conversion specifiers. llvm-svn: 97005
2010-02-24 08:05:54 +08:00
case 'o': k = ConversionSpecifier::oArg; break;
Rename 'VoidPtrArg' to 'pArg' in printf/scanf checking. llvm-svn: 108899
2010-07-21 04:04:04 +08:00
case 'p': k = ConversionSpecifier::pArg; break;
Rename 'CStrArg' to 'sArg' for printf checking to match with the analagous enum for scanf checking. llvm-svn: 108898
2010-07-21 04:03:58 +08:00
case 's': k = ConversionSpecifier::sArg; break;
Add support for '%C' and '%S' printf conversion specifiers. llvm-svn: 97005
2010-02-24 08:05:54 +08:00
case 'u': k = ConversionSpecifier::uArg; break;
case 'x': k = ConversionSpecifier::xArg; break;
Add printf format string parsing support for ' prefix to format conversions (POSIX extension). llvm-svn: 123054
2011-01-08 13:28:38 +08:00
// POSIX specific.
Add support for '%C' and '%S' printf conversion specifiers. llvm-svn: 97005
2010-02-24 08:05:54 +08:00
case 'C': k = ConversionSpecifier::CArg; break;
Rename 'UnicodeStrArg' to 'SArg'. llvm-svn: 108901
2010-07-21 04:04:15 +08:00
case 'S': k = ConversionSpecifier::SArg; break;
Add '@' conversion specifier. llvm-svn: 94713
2010-01-28 08:55:28 +08:00
// Objective-C.
Enhancements to the alternate (WIP) format string checking: - Add ConversionSpecifier::consumesDataArgument() as a helper method to determine if a conversion specifier requires a matching argument. - Add support for glibc-specific '%m' conversion - Add an extra callback to HandleNull() for locations within the format specifier that have a null character llvm-svn: 94834
2010-01-30 04:29:53 +08:00
case '@': k = ConversionSpecifier::ObjCObjArg; break;
Convert tabs to spaces. llvm-svn: 95621
2010-02-09 08:04:09 +08:00
// Glibc specific.
Enhancements to the alternate (WIP) format string checking: - Add ConversionSpecifier::consumesDataArgument() as a helper method to determine if a conversion specifier requires a matching argument. - Add support for glibc-specific '%m' conversion - Add an extra callback to HandleNull() for locations within the format specifier that have a null character llvm-svn: 94834
2010-01-30 04:29:53 +08:00
case 'm': k = ConversionSpecifier::PrintErrno; break;
Format strings: %D, %U, and %O are valid on Darwin (same as %d, %u, %o). These will warn under -Wformat-non-iso, and will still be rejected outright on other platforms. <rdar://problem/12061922> llvm-svn: 163771
2012-09-13 10:11:03 +08:00
// Apple-specific
case 'D':
if (Target.getTriple().isOSDarwin())
k = ConversionSpecifier::DArg;
break;
case 'O':
if (Target.getTriple().isOSDarwin())
k = ConversionSpecifier::OArg;
break;
case 'U':
if (Target.getTriple().isOSDarwin())
k = ConversionSpecifier::UArg;
break;
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
}
Add 'ConversionSpecifier' root class in 'analyze_format_string' namespace and derived 'PrintfConversionSpecifier' from this class. We will do the same for 'ScanfConversionSpecifier'. llvm-svn: 108903
2010-07-21 04:04:27 +08:00
PrintfConversionSpecifier CS(conversionPosition, k);
For printf format string checking, move the tracking of the data argument index out of Sema and into analyze_printf::ParseFormatString(). Also use a bitvector to determine what arguments have been covered (instead of just checking to see if the last argument consumed is the max argument). This is prep. for support positional arguments (an IEEE extension). llvm-svn: 97248
2010-02-27 03:18:41 +08:00
FS.setConversionSpecifier(CS);
For printf format string checking, add support for positional format strings. Along the way, coelesce some of the diagnostics. llvm-svn: 97297
2010-02-27 09:41:03 +08:00
if (CS.consumesDataArgument() && !FS.usesPositionalArg())
For printf format string checking, move the tracking of the data argument index out of Sema and into analyze_printf::ParseFormatString(). Also use a bitvector to determine what arguments have been covered (instead of just checking to see if the last argument consumed is the max argument). This is prep. for support positional arguments (an IEEE extension). llvm-svn: 97248
2010-02-27 03:18:41 +08:00
FS.setArgIndex(argIndex++);
Alternate format string checking: issue a warning for invalid conversion specifiers. llvm-svn: 94792
2010-01-29 10:40:24 +08:00
if (k == ConversionSpecifier::InvalidSpecifier) {
For printf format string checking, move the tracking of the data argument index out of Sema and into analyze_printf::ParseFormatString(). Also use a bitvector to determine what arguments have been covered (instead of just checking to see if the last argument consumed is the max argument). This is prep. for support positional arguments (an IEEE extension). llvm-svn: 97248
2010-02-27 03:18:41 +08:00
// Assume the conversion takes one argument.
Fix range in printf warnings for invalid conversion specifiers. llvm-svn: 120735
2010-12-03 04:57:51 +08:00
return !H.HandleInvalidPrintfConversionSpecifier(FS, Start, I - Start);
Alternate format string checking: issue a warning for invalid conversion specifiers. llvm-svn: 94792
2010-01-29 10:40:24 +08:00
}
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
return PrintfSpecifierResult(Start, FS);
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
}
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
bool clang::analyze_format_string::ParsePrintfString(FormatStringHandler &H,
const char *I,
Support the 'a' length modifier in scanf format strings as a C90 extension. This fixes gcc.dg/format/c90-scanf-3.c and ext-4.c (test for excess errors). llvm-svn: 146649
2011-12-15 18:25:47 +08:00
const char *E,
Format strings: %D, %U, and %O are valid on Darwin (same as %d, %u, %o). These will warn under -Wformat-non-iso, and will still be rejected outright on other platforms. <rdar://problem/12061922> llvm-svn: 163771
2012-09-13 10:11:03 +08:00
const LangOptions &LO,
const TargetInfo &Target) {
For printf format string checking, move the tracking of the data argument index out of Sema and into analyze_printf::ParseFormatString(). Also use a bitvector to determine what arguments have been covered (instead of just checking to see if the last argument consumed is the max argument). This is prep. for support positional arguments (an IEEE extension). llvm-svn: 97248
2010-02-27 03:18:41 +08:00
unsigned argIndex = 0;
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
// Keep looking for a format specifier until we have exhausted the string.
while (I != E) {
Support the 'a' length modifier in scanf format strings as a C90 extension. This fixes gcc.dg/format/c90-scanf-3.c and ext-4.c (test for excess errors). llvm-svn: 146649
2011-12-15 18:25:47 +08:00
const PrintfSpecifierResult &FSR = ParsePrintfSpecifier(H, I, E, argIndex,
Format strings: %D, %U, and %O are valid on Darwin (same as %d, %u, %o). These will warn under -Wformat-non-iso, and will still be rejected outright on other platforms. <rdar://problem/12061922> llvm-svn: 163771
2012-09-13 10:11:03 +08:00
LO, Target);
Alternate format string checking: issue a warning for invalid conversion specifiers. llvm-svn: 94792
2010-01-29 10:40:24 +08:00
// Did a fail-stop error of any kind occur when parsing the specifier?
// If so, don't do any more processing.
if (FSR.shouldStop())
Remove redundant semicolons which are null statements. llvm-svn: 163546
2012-09-11 05:20:09 +08:00
return true;
Alternate format string checking: issue a warning for invalid conversion specifiers. llvm-svn: 94792
2010-01-29 10:40:24 +08:00
// Did we exhaust the string or encounter an error that
// we can recover from?
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
if (!FSR.hasValue())
Alternate format string checking: issue a warning for invalid conversion specifiers. llvm-svn: 94792
2010-01-29 10:40:24 +08:00
continue;
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
// We have a format specifier. Pass it to the callback.
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
if (!H.HandlePrintfSpecifier(FSR.getValue(), FSR.getStart(),
Add position of conversion specifier character to 'ConversionSpecifier'. llvm-svn: 94739
2010-01-28 10:46:17 +08:00
I - FSR.getStart()))
Enhancements to the alternate (WIP) format string checking: - Add ConversionSpecifier::consumesDataArgument() as a helper method to determine if a conversion specifier requires a matching argument. - Add support for glibc-specific '%m' conversion - Add an extra callback to HandleNull() for locations within the format specifier that have a null character llvm-svn: 94834
2010-01-30 04:29:53 +08:00
return true;
Refactor the logic for printf argument type-checking into analyze_printf::ArgTypeResult. Implement printf argument type checking for '%s'. Fixes <rdar://problem/3065808>. llvm-svn: 96310
2010-02-16 09:46:59 +08:00
}
assert(I == E && "Format string not exhausted");
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702
2010-01-28 07:43:25 +08:00
return false;
}
Added FixIt support to printf format string checking. - Refactored LengthModifier to be a class. - Added toString methods in all member classes of FormatSpecifier. - FixIt suggestions keep user specified flags unless incorrect. Limitations: - The suggestions are not conversion specifier sensitive. For example, if we have a 'pad with zeroes' flag, and the correction is a string conversion specifier, we do not remove the flag. Clang will warn us on the next compilation. A test/Sema/format-strings-fixit.c M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 105680
2010-06-09 12:11:11 +08:00
//===----------------------------------------------------------------------===//
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
// Methods on PrintfSpecifier.
Per a suggestion from Cristian Draghici, add a method to FormatSpecifier that returns the expected type of the matching data argument. It isn't complete, but should handle several of the important cases. llvm-svn: 94851
2010-01-30 06:59:32 +08:00
//===----------------------------------------------------------------------===//
Rename analyze_format_string::ArgTypeResult to ArgType Also remove redundant constructors and unused member functions. llvm-svn: 161403
2012-08-07 16:11:26 +08:00
ArgType PrintfSpecifier::getArgType(ASTContext &Ctx,
bool IsObjCLiteral) const {
Add 'ConversionSpecifier' root class in 'analyze_format_string' namespace and derived 'PrintfConversionSpecifier' from this class. We will do the same for 'ScanfConversionSpecifier'. llvm-svn: 108903
2010-07-21 04:04:27 +08:00
const PrintfConversionSpecifier &CS = getConversionSpecifier();
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Per a suggestion from Cristian Draghici, add a method to FormatSpecifier that returns the expected type of the matching data argument. It isn't complete, but should handle several of the important cases. llvm-svn: 94851
2010-01-30 06:59:32 +08:00
if (!CS.consumesDataArgument())
Rename analyze_format_string::ArgTypeResult to ArgType Also remove redundant constructors and unused member functions. llvm-svn: 161403
2012-08-07 16:11:26 +08:00
return ArgType::Invalid();
Refactor the logic for printf argument type-checking into analyze_printf::ArgTypeResult. Implement printf argument type checking for '%s'. Fixes <rdar://problem/3065808>. llvm-svn: 96310
2010-02-16 09:46:59 +08:00
Fix printf format string checking for '%lc' (which expects a wint_t or compatible argument). Fixes PR 7981. llvm-svn: 111978
2010-08-25 06:24:51 +08:00
if (CS.getKind() == ConversionSpecifier::cArg)
switch (LM.getKind()) {
case LengthModifier::None: return Ctx.IntTy;
Make printf warnings refer to wint_t and wchar_t by name in addition to underlying type. llvm-svn: 146254
2011-12-09 20:22:12 +08:00
case LengthModifier::AsLong:
Rename analyze_format_string::ArgTypeResult to ArgType Also remove redundant constructors and unused member functions. llvm-svn: 161403
2012-08-07 16:11:26 +08:00
return ArgType(ArgType::WIntTy, "wint_t");
Fix printf format string checking for '%lc' (which expects a wint_t or compatible argument). Fixes PR 7981. llvm-svn: 111978
2010-08-25 06:24:51 +08:00
default:
Rename analyze_format_string::ArgTypeResult to ArgType Also remove redundant constructors and unused member functions. llvm-svn: 161403
2012-08-07 16:11:26 +08:00
return ArgType::Invalid();
Fix printf format string checking for '%lc' (which expects a wint_t or compatible argument). Fixes PR 7981. llvm-svn: 111978
2010-08-25 06:24:51 +08:00
}
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Per a suggestion from Cristian Draghici, add a method to FormatSpecifier that returns the expected type of the matching data argument. It isn't complete, but should handle several of the important cases. llvm-svn: 94851
2010-01-30 06:59:32 +08:00
if (CS.isIntArg())
Added FixIt support to printf format string checking. - Refactored LengthModifier to be a class. - Added toString methods in all member classes of FormatSpecifier. - FixIt suggestions keep user specified flags unless incorrect. Limitations: - The suggestions are not conversion specifier sensitive. For example, if we have a 'pad with zeroes' flag, and the correction is a string conversion specifier, we do not remove the flag. Clang will warn us on the next compilation. A test/Sema/format-strings-fixit.c M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 105680
2010-06-09 12:11:11 +08:00
switch (LM.getKind()) {
case LengthModifier::AsLongDouble:
Teach scanf/printf checking about '%Ld' and friends (a GNU extension). Fixes PR 9466. llvm-svn: 148859
2012-01-25 05:29:54 +08:00
// GNU extension.
return Ctx.LongLongTy;
Added FixIt support to printf format string checking. - Refactored LengthModifier to be a class. - Added toString methods in all member classes of FormatSpecifier. - FixIt suggestions keep user specified flags unless incorrect. Limitations: - The suggestions are not conversion specifier sensitive. For example, if we have a 'pad with zeroes' flag, and the correction is a string conversion specifier, we do not remove the flag. Clang will warn us on the next compilation. A test/Sema/format-strings-fixit.c M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 105680
2010-06-09 12:11:11 +08:00
case LengthModifier::None: return Ctx.IntTy;
Rename analyze_format_string::ArgTypeResult to ArgType Also remove redundant constructors and unused member functions. llvm-svn: 161403
2012-08-07 16:11:26 +08:00
case LengthModifier::AsChar: return ArgType::AnyCharTy;
Added FixIt support to printf format string checking. - Refactored LengthModifier to be a class. - Added toString methods in all member classes of FormatSpecifier. - FixIt suggestions keep user specified flags unless incorrect. Limitations: - The suggestions are not conversion specifier sensitive. For example, if we have a 'pad with zeroes' flag, and the correction is a string conversion specifier, we do not remove the flag. Clang will warn us on the next compilation. A test/Sema/format-strings-fixit.c M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 105680
2010-06-09 12:11:11 +08:00
case LengthModifier::AsShort: return Ctx.ShortTy;
case LengthModifier::AsLong: return Ctx.LongTy;
Format string analysis: give 'q' its own enumerator. This is in preparation for being able to warn about 'q' and other non-standard format string features. It also allows us to print its name correctly. llvm-svn: 150697
2012-02-17 00:34:54 +08:00
case LengthModifier::AsLongLong:
case LengthModifier::AsQuad:
return Ctx.LongLongTy;
Make printf warnings refer to intmax_t et al. by name in addition to underlying type. For example, the warning for printf("%zu", 42.0); changes from "conversion specifies type 'unsigned long'" to "conversion specifies type 'size_t' (aka 'unsigned long')" (This is a second attempt after r145697, which got reverted.) llvm-svn: 146032
2011-12-07 18:33:11 +08:00
case LengthModifier::AsIntMax:
Rename analyze_format_string::ArgTypeResult to ArgType Also remove redundant constructors and unused member functions. llvm-svn: 161403
2012-08-07 16:11:26 +08:00
return ArgType(Ctx.getIntMaxType(), "intmax_t");
Teach format string analysis that "%zu" means size_t. The code had it backwards, thinking size_t was signed, and using that for "%zd". Also let the analysis get the types for (u)intmax_t while we are at it. llvm-svn: 143099
2011-10-27 16:29:09 +08:00
case LengthModifier::AsSizeT:
// FIXME: How to get the corresponding signed version of size_t?
Rename analyze_format_string::ArgTypeResult to ArgType Also remove redundant constructors and unused member functions. llvm-svn: 161403
2012-08-07 16:11:26 +08:00
return ArgType();
Make printf warnings refer to intmax_t et al. by name in addition to underlying type. For example, the warning for printf("%zu", 42.0); changes from "conversion specifies type 'unsigned long'" to "conversion specifies type 'size_t' (aka 'unsigned long')" (This is a second attempt after r145697, which got reverted.) llvm-svn: 146032
2011-12-07 18:33:11 +08:00
case LengthModifier::AsPtrDiff:
Rename analyze_format_string::ArgTypeResult to ArgType Also remove redundant constructors and unused member functions. llvm-svn: 161403
2012-08-07 16:11:26 +08:00
return ArgType(Ctx.getPointerDiffType(), "ptrdiff_t");
Support the 'a' length modifier in scanf format strings as a C90 extension. This fixes gcc.dg/format/c90-scanf-3.c and ext-4.c (test for excess errors). llvm-svn: 146649
2011-12-15 18:25:47 +08:00
case LengthModifier::AsAllocate:
scanf: parse the 'm' length modifier, and check that the right arguments are used with that and the 'a' length modifier. llvm-svn: 148029
2012-01-13 01:11:12 +08:00
case LengthModifier::AsMAllocate:
Rename analyze_format_string::ArgTypeResult to ArgType Also remove redundant constructors and unused member functions. llvm-svn: 161403
2012-08-07 16:11:26 +08:00
return ArgType::Invalid();
Per a suggestion from Cristian Draghici, add a method to FormatSpecifier that returns the expected type of the matching data argument. It isn't complete, but should handle several of the important cases. llvm-svn: 94851
2010-01-30 06:59:32 +08:00
}
if (CS.isUIntArg())
Added FixIt support to printf format string checking. - Refactored LengthModifier to be a class. - Added toString methods in all member classes of FormatSpecifier. - FixIt suggestions keep user specified flags unless incorrect. Limitations: - The suggestions are not conversion specifier sensitive. For example, if we have a 'pad with zeroes' flag, and the correction is a string conversion specifier, we do not remove the flag. Clang will warn us on the next compilation. A test/Sema/format-strings-fixit.c M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 105680
2010-06-09 12:11:11 +08:00
switch (LM.getKind()) {
case LengthModifier::AsLongDouble:
Teach scanf/printf checking about '%Ld' and friends (a GNU extension). Fixes PR 9466. llvm-svn: 148859
2012-01-25 05:29:54 +08:00
// GNU extension.
return Ctx.UnsignedLongLongTy;
Added FixIt support to printf format string checking. - Refactored LengthModifier to be a class. - Added toString methods in all member classes of FormatSpecifier. - FixIt suggestions keep user specified flags unless incorrect. Limitations: - The suggestions are not conversion specifier sensitive. For example, if we have a 'pad with zeroes' flag, and the correction is a string conversion specifier, we do not remove the flag. Clang will warn us on the next compilation. A test/Sema/format-strings-fixit.c M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 105680
2010-06-09 12:11:11 +08:00
case LengthModifier::None: return Ctx.UnsignedIntTy;
case LengthModifier::AsChar: return Ctx.UnsignedCharTy;
case LengthModifier::AsShort: return Ctx.UnsignedShortTy;
case LengthModifier::AsLong: return Ctx.UnsignedLongTy;
Format string analysis: give 'q' its own enumerator. This is in preparation for being able to warn about 'q' and other non-standard format string features. It also allows us to print its name correctly. llvm-svn: 150697
2012-02-17 00:34:54 +08:00
case LengthModifier::AsLongLong:
case LengthModifier::AsQuad:
return Ctx.UnsignedLongLongTy;
Make printf warnings refer to intmax_t et al. by name in addition to underlying type. For example, the warning for printf("%zu", 42.0); changes from "conversion specifies type 'unsigned long'" to "conversion specifies type 'size_t' (aka 'unsigned long')" (This is a second attempt after r145697, which got reverted.) llvm-svn: 146032
2011-12-07 18:33:11 +08:00
case LengthModifier::AsIntMax:
Rename analyze_format_string::ArgTypeResult to ArgType Also remove redundant constructors and unused member functions. llvm-svn: 161403
2012-08-07 16:11:26 +08:00
return ArgType(Ctx.getUIntMaxType(), "uintmax_t");
Added FixIt support to printf format string checking. - Refactored LengthModifier to be a class. - Added toString methods in all member classes of FormatSpecifier. - FixIt suggestions keep user specified flags unless incorrect. Limitations: - The suggestions are not conversion specifier sensitive. For example, if we have a 'pad with zeroes' flag, and the correction is a string conversion specifier, we do not remove the flag. Clang will warn us on the next compilation. A test/Sema/format-strings-fixit.c M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 105680
2010-06-09 12:11:11 +08:00
case LengthModifier::AsSizeT:
Rename analyze_format_string::ArgTypeResult to ArgType Also remove redundant constructors and unused member functions. llvm-svn: 161403
2012-08-07 16:11:26 +08:00
return ArgType(Ctx.getSizeType(), "size_t");
Added FixIt support to printf format string checking. - Refactored LengthModifier to be a class. - Added toString methods in all member classes of FormatSpecifier. - FixIt suggestions keep user specified flags unless incorrect. Limitations: - The suggestions are not conversion specifier sensitive. For example, if we have a 'pad with zeroes' flag, and the correction is a string conversion specifier, we do not remove the flag. Clang will warn us on the next compilation. A test/Sema/format-strings-fixit.c M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 105680
2010-06-09 12:11:11 +08:00
case LengthModifier::AsPtrDiff:
Per a suggestion from Cristian Draghici, add a method to FormatSpecifier that returns the expected type of the matching data argument. It isn't complete, but should handle several of the important cases. llvm-svn: 94851
2010-01-30 06:59:32 +08:00
// FIXME: How to get the corresponding unsigned
// version of ptrdiff_t?
Rename analyze_format_string::ArgTypeResult to ArgType Also remove redundant constructors and unused member functions. llvm-svn: 161403
2012-08-07 16:11:26 +08:00
return ArgType();
Support the 'a' length modifier in scanf format strings as a C90 extension. This fixes gcc.dg/format/c90-scanf-3.c and ext-4.c (test for excess errors). llvm-svn: 146649
2011-12-15 18:25:47 +08:00
case LengthModifier::AsAllocate:
scanf: parse the 'm' length modifier, and check that the right arguments are used with that and the 'a' length modifier. llvm-svn: 148029
2012-01-13 01:11:12 +08:00
case LengthModifier::AsMAllocate:
Rename analyze_format_string::ArgTypeResult to ArgType Also remove redundant constructors and unused member functions. llvm-svn: 161403
2012-08-07 16:11:26 +08:00
return ArgType::Invalid();
Per a suggestion from Cristian Draghici, add a method to FormatSpecifier that returns the expected type of the matching data argument. It isn't complete, but should handle several of the important cases. llvm-svn: 94851
2010-01-30 06:59:32 +08:00
}
Refactor the logic for printf argument type-checking into analyze_printf::ArgTypeResult. Implement printf argument type checking for '%s'. Fixes <rdar://problem/3065808>. llvm-svn: 96310
2010-02-16 09:46:59 +08:00
Add format string type checking support for 'long double'. llvm-svn: 95026
2010-02-02 07:23:50 +08:00
if (CS.isDoubleArg()) {
Added FixIt support to printf format string checking. - Refactored LengthModifier to be a class. - Added toString methods in all member classes of FormatSpecifier. - FixIt suggestions keep user specified flags unless incorrect. Limitations: - The suggestions are not conversion specifier sensitive. For example, if we have a 'pad with zeroes' flag, and the correction is a string conversion specifier, we do not remove the flag. Clang will warn us on the next compilation. A test/Sema/format-strings-fixit.c M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 105680
2010-06-09 12:11:11 +08:00
if (LM.getKind() == LengthModifier::AsLongDouble)
Add format string type checking support for 'long double'. llvm-svn: 95026
2010-02-02 07:23:50 +08:00
return Ctx.LongDoubleTy;
Add format string checking of 'double' arguments. Fixes <rdar://problem/6931734>. llvm-svn: 94867
2010-01-30 09:02:18 +08:00
return Ctx.DoubleTy;
Add format string type checking support for 'long double'. llvm-svn: 95026
2010-02-02 07:23:50 +08:00
}
For printf format string checking, move the tracking of the data argument index out of Sema and into analyze_printf::ParseFormatString(). Also use a bitvector to determine what arguments have been covered (instead of just checking to see if the last argument consumed is the max argument). This is prep. for support positional arguments (an IEEE extension). llvm-svn: 97248
2010-02-27 03:18:41 +08:00
Properly check length modfiers for %n in format strings. llvm-svn: 161408
2012-08-07 17:13:19 +08:00
if (CS.getKind() == ConversionSpecifier::nArg) {
switch (LM.getKind()) {
case LengthModifier::None:
return ArgType::PtrTo(Ctx.IntTy);
case LengthModifier::AsChar:
return ArgType::PtrTo(Ctx.SignedCharTy);
case LengthModifier::AsShort:
return ArgType::PtrTo(Ctx.ShortTy);
case LengthModifier::AsLong:
return ArgType::PtrTo(Ctx.LongTy);
case LengthModifier::AsLongLong:
case LengthModifier::AsQuad:
return ArgType::PtrTo(Ctx.LongLongTy);
case LengthModifier::AsIntMax:
return ArgType::PtrTo(ArgType(Ctx.getIntMaxType(), "intmax_t"));
case LengthModifier::AsSizeT:
return ArgType(); // FIXME: ssize_t
case LengthModifier::AsPtrDiff:
return ArgType::PtrTo(ArgType(Ctx.getPointerDiffType(), "ptrdiff_t"));
case LengthModifier::AsLongDouble:
return ArgType(); // FIXME: Is this a known extension?
case LengthModifier::AsAllocate:
case LengthModifier::AsMAllocate:
return ArgType::Invalid();
}
}
Add support for '%C' and '%S' printf conversion specifiers. llvm-svn: 97005
2010-02-24 08:05:54 +08:00
switch (CS.getKind()) {
Remove unnecessary braces from my previous commit. llvm-svn: 146259
2011-12-09 23:57:33 +08:00
case ConversionSpecifier::sArg:
Let %S, %ls, %C match 16bit types in NSStrings. As discussed at http://lists.cs.uiuc.edu/pipermail/cfe-commits/Week-of-Mon-20120130/052200.html llvm-svn: 149325
2012-01-31 09:43:25 +08:00
if (LM.getKind() == LengthModifier::AsWideChar) {
if (IsObjCLiteral)
Format strings: offer a cast to 'unichar' for %C in Objective-C contexts. For most cases where a conversion specifier doesn't match an argument, we usually guess that the conversion specifier is wrong. However, if the argument is an integer type and the specifier is %C, it's likely the user really did mean to print the integer as a character. (This is more common than %c because there is no way to specify a unichar literal -- you have to write an integer literal, such as '0x2603', and then cast it to unichar.) This does not change the behavior of %S, since there are fewer cases where printing a literal Unicode *string* is necessary, but this could easily be changed in the future. <rdar://problem/11982013> llvm-svn: 169400
2012-12-06 02:44:49 +08:00
return ArgType(Ctx.getPointerType(Ctx.UnsignedShortTy.withConst()),
"const unichar *");
Rename analyze_format_string::ArgTypeResult to ArgType Also remove redundant constructors and unused member functions. llvm-svn: 161403
2012-08-07 16:11:26 +08:00
return ArgType(ArgType::WCStrTy, "wchar_t *");
Let %S, %ls, %C match 16bit types in NSStrings. As discussed at http://lists.cs.uiuc.edu/pipermail/cfe-commits/Week-of-Mon-20120130/052200.html llvm-svn: 149325
2012-01-31 09:43:25 +08:00
}
Rename analyze_format_string::ArgTypeResult to ArgType Also remove redundant constructors and unused member functions. llvm-svn: 161403
2012-08-07 16:11:26 +08:00
return ArgType::CStrTy;
Rename 'UnicodeStrArg' to 'SArg'. llvm-svn: 108901
2010-07-21 04:04:15 +08:00
case ConversionSpecifier::SArg:
Let %S, %ls, %C match 16bit types in NSStrings. As discussed at http://lists.cs.uiuc.edu/pipermail/cfe-commits/Week-of-Mon-20120130/052200.html llvm-svn: 149325
2012-01-31 09:43:25 +08:00
if (IsObjCLiteral)
Format strings: offer a cast to 'unichar' for %C in Objective-C contexts. For most cases where a conversion specifier doesn't match an argument, we usually guess that the conversion specifier is wrong. However, if the argument is an integer type and the specifier is %C, it's likely the user really did mean to print the integer as a character. (This is more common than %c because there is no way to specify a unichar literal -- you have to write an integer literal, such as '0x2603', and then cast it to unichar.) This does not change the behavior of %S, since there are fewer cases where printing a literal Unicode *string* is necessary, but this could easily be changed in the future. <rdar://problem/11982013> llvm-svn: 169400
2012-12-06 02:44:49 +08:00
return ArgType(Ctx.getPointerType(Ctx.UnsignedShortTy.withConst()),
"const unichar *");
Rename analyze_format_string::ArgTypeResult to ArgType Also remove redundant constructors and unused member functions. llvm-svn: 161403
2012-08-07 16:11:26 +08:00
return ArgType(ArgType::WCStrTy, "wchar_t *");
Add support for '%C' and '%S' printf conversion specifiers. llvm-svn: 97005
2010-02-24 08:05:54 +08:00
case ConversionSpecifier::CArg:
Let %S, %ls, %C match 16bit types in NSStrings. As discussed at http://lists.cs.uiuc.edu/pipermail/cfe-commits/Week-of-Mon-20120130/052200.html llvm-svn: 149325
2012-01-31 09:43:25 +08:00
if (IsObjCLiteral)
Format strings: offer a cast to 'unichar' for %C in Objective-C contexts. For most cases where a conversion specifier doesn't match an argument, we usually guess that the conversion specifier is wrong. However, if the argument is an integer type and the specifier is %C, it's likely the user really did mean to print the integer as a character. (This is more common than %c because there is no way to specify a unichar literal -- you have to write an integer literal, such as '0x2603', and then cast it to unichar.) This does not change the behavior of %S, since there are fewer cases where printing a literal Unicode *string* is necessary, but this could easily be changed in the future. <rdar://problem/11982013> llvm-svn: 169400
2012-12-06 02:44:49 +08:00
return ArgType(Ctx.UnsignedShortTy, "unichar");
Rename analyze_format_string::ArgTypeResult to ArgType Also remove redundant constructors and unused member functions. llvm-svn: 161403
2012-08-07 16:11:26 +08:00
return ArgType(Ctx.WCharTy, "wchar_t");
Rename 'VoidPtrArg' to 'pArg' in printf/scanf checking. llvm-svn: 108899
2010-07-21 04:04:04 +08:00
case ConversionSpecifier::pArg:
Rename analyze_format_string::ArgTypeResult to ArgType Also remove redundant constructors and unused member functions. llvm-svn: 161403
2012-08-07 16:11:26 +08:00
return ArgType::CPointerTy;
Fix NSLog format string checking for %@. llvm-svn: 148885
2012-01-25 08:04:09 +08:00
case ConversionSpecifier::ObjCObjArg:
Rename analyze_format_string::ArgTypeResult to ArgType Also remove redundant constructors and unused member functions. llvm-svn: 161403
2012-08-07 16:11:26 +08:00
return ArgType::ObjCPointerTy;
Add support for '%C' and '%S' printf conversion specifiers. llvm-svn: 97005
2010-02-24 08:05:54 +08:00
default:
break;
}
For printf format string checking, move the tracking of the data argument index out of Sema and into analyze_printf::ParseFormatString(). Also use a bitvector to determine what arguments have been covered (instead of just checking to see if the last argument consumed is the max argument). This is prep. for support positional arguments (an IEEE extension). llvm-svn: 97248
2010-02-27 03:18:41 +08:00
Per a suggestion from Cristian Draghici, add a method to FormatSpecifier that returns the expected type of the matching data argument. It isn't complete, but should handle several of the important cases. llvm-svn: 94851
2010-01-30 06:59:32 +08:00
// FIXME: Handle other cases.
Rename analyze_format_string::ArgTypeResult to ArgType Also remove redundant constructors and unused member functions. llvm-svn: 161403
2012-08-07 16:11:26 +08:00
return ArgType();
Per a suggestion from Cristian Draghici, add a method to FormatSpecifier that returns the expected type of the matching data argument. It isn't complete, but should handle several of the important cases. llvm-svn: 94851
2010-01-30 06:59:32 +08:00
}
Make -Wformat fix-its preserve original conversion specifiers. This commit makes PrintfSpecifier::fixType() and ScanfSpecifier::fixType() only fix a conversion specification enough that Clang wouldn't warn about it, as opposed to always changing it to use the "canonical" conversion specifier. (PR11975) This preserves the user's choice of conversion specifier in cases like: printf("%a", (long double)1); where we previously suggested "%Lf", we now suggest "%La" printf("%x", (long)1); where we previously suggested "%ld", we now suggest "%lx". llvm-svn: 150578
2012-02-15 17:59:46 +08:00
bool PrintfSpecifier::fixType(QualType QT, const LangOptions &LangOpt,
ASTContext &Ctx, bool IsObjCLiteral) {
Make -Wformat check the argument type for %n. This makes Clang check that the corresponding argument for "%n" in a format string is a pointer to int. llvm-svn: 160966
2012-07-31 01:11:32 +08:00
// %n is different from other conversion specifiers; don't try to fix it.
if (CS.getKind() == ConversionSpecifier::nArg)
return false;
Suggest '%@' for Objective-C objects in ObjC format strings. llvm-svn: 157716
2012-05-31 05:53:13 +08:00
// Handle Objective-C objects first. Note that while the '%@' specifier will
// not warn for structure pointer or void pointer arguments (because that's
// how CoreFoundation objects are implemented), we only show a fixit for '%@'
// if we know it's an object (block, id, class, or __attribute__((NSObject))).
if (QT->isObjCRetainableType()) {
if (!IsObjCLiteral)
return false;
CS.setKind(ConversionSpecifier::ObjCObjArg);
// Disable irrelevant flags
HasThousandsGrouping = false;
HasPlusPrefix = false;
HasSpacePrefix = false;
HasAlternativeForm = false;
HasLeadingZeroes = false;
Precision.setHowSpecified(OptionalAmount::NotSpecified);
LM.setKind(LengthModifier::None);
return true;
}
// Handle strings next (char *, wchar_t *)
Added FixIt support to printf format string checking. - Refactored LengthModifier to be a class. - Added toString methods in all member classes of FormatSpecifier. - FixIt suggestions keep user specified flags unless incorrect. Limitations: - The suggestions are not conversion specifier sensitive. For example, if we have a 'pad with zeroes' flag, and the correction is a string conversion specifier, we do not remove the flag. Clang will warn us on the next compilation. A test/Sema/format-strings-fixit.c M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 105680
2010-06-09 12:11:11 +08:00
if (QT->isPointerType() && (QT->getPointeeType()->isAnyCharacterType())) {
Rename 'CStrArg' to 'sArg' for printf checking to match with the analagous enum for scanf checking. llvm-svn: 108898
2010-07-21 04:03:58 +08:00
CS.setKind(ConversionSpecifier::sArg);
Added FixIt support to printf format string checking. - Refactored LengthModifier to be a class. - Added toString methods in all member classes of FormatSpecifier. - FixIt suggestions keep user specified flags unless incorrect. Limitations: - The suggestions are not conversion specifier sensitive. For example, if we have a 'pad with zeroes' flag, and the correction is a string conversion specifier, we do not remove the flag. Clang will warn us on the next compilation. A test/Sema/format-strings-fixit.c M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 105680
2010-06-09 12:11:11 +08:00
Small fixes regarding printf fix suggestions. - Added some handling of flags that become invalid when changing the conversion specifier. - Changed fixit behavior to remove unnecessary length modifiers. - Separated some tests out and added some comments. modified: lib/Analysis/PrintfFormatString.cpp test/Sema/format-strings-fixit.c llvm-svn: 105807
2010-06-11 12:22:02 +08:00
// Disable irrelevant flags
HasAlternativeForm = 0;
HasLeadingZeroes = 0;
Added FixIt support to printf format string checking. - Refactored LengthModifier to be a class. - Added toString methods in all member classes of FormatSpecifier. - FixIt suggestions keep user specified flags unless incorrect. Limitations: - The suggestions are not conversion specifier sensitive. For example, if we have a 'pad with zeroes' flag, and the correction is a string conversion specifier, we do not remove the flag. Clang will warn us on the next compilation. A test/Sema/format-strings-fixit.c M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 105680
2010-06-09 12:11:11 +08:00
// Set the long length modifier for wide characters
if (QT->getPointeeType()->isWideCharType())
LM.setKind(LengthModifier::AsWideChar);
fix format specifier fixit for printf("%ld", "foo"); It should reset the length modifier (unless it's a wchar_t string). llvm-svn: 146252
2011-12-09 18:51:29 +08:00
else
LM.setKind(LengthModifier::None);
Added FixIt support to printf format string checking. - Refactored LengthModifier to be a class. - Added toString methods in all member classes of FormatSpecifier. - FixIt suggestions keep user specified flags unless incorrect. Limitations: - The suggestions are not conversion specifier sensitive. For example, if we have a 'pad with zeroes' flag, and the correction is a string conversion specifier, we do not remove the flag. Clang will warn us on the next compilation. A test/Sema/format-strings-fixit.c M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 105680
2010-06-09 12:11:11 +08:00
return true;
}
Make suggestions for mismatched enum arguments to printf/scanf. llvm-svn: 157962
2012-06-05 06:49:02 +08:00
// If it's an enum, get its underlying type.
if (const EnumType *ETy = QT->getAs<EnumType>())
QT = ETy->getDecl()->getIntegerType();
Added FixIt support to printf format string checking. - Refactored LengthModifier to be a class. - Added toString methods in all member classes of FormatSpecifier. - FixIt suggestions keep user specified flags unless incorrect. Limitations: - The suggestions are not conversion specifier sensitive. For example, if we have a 'pad with zeroes' flag, and the correction is a string conversion specifier, we do not remove the flag. Clang will warn us on the next compilation. A test/Sema/format-strings-fixit.c M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 105680
2010-06-09 12:11:11 +08:00
// We can only work with builtin types.
const BuiltinType *BT = QT->getAs<BuiltinType>();
More metaprogramming with builtin types. llvm-svn: 142433
2011-10-19 06:28:37 +08:00
if (!BT)
return false;
Small fixes regarding printf fix suggestions. - Added some handling of flags that become invalid when changing the conversion specifier. - Changed fixit behavior to remove unnecessary length modifiers. - Separated some tests out and added some comments. modified: lib/Analysis/PrintfFormatString.cpp test/Sema/format-strings-fixit.c llvm-svn: 105807
2010-06-11 12:22:02 +08:00
Added FixIt support to printf format string checking. - Refactored LengthModifier to be a class. - Added toString methods in all member classes of FormatSpecifier. - FixIt suggestions keep user specified flags unless incorrect. Limitations: - The suggestions are not conversion specifier sensitive. For example, if we have a 'pad with zeroes' flag, and the correction is a string conversion specifier, we do not remove the flag. Clang will warn us on the next compilation. A test/Sema/format-strings-fixit.c M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 105680
2010-06-09 12:11:11 +08:00
// Set length modifier
switch (BT->getKind()) {
Don't print fixits for format specifiers in cases where the fixit does not actually fix the warning. PR8781. I'm not sure what the preferred way to write a test for whether a fixit is emitted. llvm-svn: 130335
2011-04-28 06:06:20 +08:00
case BuiltinType::Bool:
case BuiltinType::WChar_U:
case BuiltinType::WChar_S:
case BuiltinType::Char16:
case BuiltinType::Char32:
case BuiltinType::UInt128:
case BuiltinType::Int128:
Provide half floating point support as a storage only type. Lack of half FP was a regression compared to llvm-gcc. llvm-svn: 142016
2011-10-15 07:23:15 +08:00
case BuiltinType::Half:
More metaprogramming with builtin types. llvm-svn: 142433
2011-10-19 06:28:37 +08:00
// Various types which are non-trivial to correct.
Don't print fixits for format specifiers in cases where the fixit does not actually fix the warning. PR8781. I'm not sure what the preferred way to write a test for whether a fixit is emitted. llvm-svn: 130335
2011-04-28 06:06:20 +08:00
return false;
More metaprogramming with builtin types. llvm-svn: 142433
2011-10-19 06:28:37 +08:00
#define SIGNED_TYPE(Id, SingletonId)
#define UNSIGNED_TYPE(Id, SingletonId)
#define FLOATING_TYPE(Id, SingletonId)
#define BUILTIN_TYPE(Id, SingletonId) \
case BuiltinType::Id:
#include "clang/AST/BuiltinTypes.def"
Don't print fixits for format specifiers in cases where the fixit does not actually fix the warning. PR8781. I'm not sure what the preferred way to write a test for whether a fixit is emitted. llvm-svn: 130335
2011-04-28 06:06:20 +08:00
// Misc other stuff which doesn't make sense here.
return false;
case BuiltinType::UInt:
case BuiltinType::Int:
case BuiltinType::Float:
case BuiltinType::Double:
Small fixes regarding printf fix suggestions. - Added some handling of flags that become invalid when changing the conversion specifier. - Changed fixit behavior to remove unnecessary length modifiers. - Separated some tests out and added some comments. modified: lib/Analysis/PrintfFormatString.cpp test/Sema/format-strings-fixit.c llvm-svn: 105807
2010-06-11 12:22:02 +08:00
LM.setKind(LengthModifier::None);
Added FixIt support to printf format string checking. - Refactored LengthModifier to be a class. - Added toString methods in all member classes of FormatSpecifier. - FixIt suggestions keep user specified flags unless incorrect. Limitations: - The suggestions are not conversion specifier sensitive. For example, if we have a 'pad with zeroes' flag, and the correction is a string conversion specifier, we do not remove the flag. Clang will warn us on the next compilation. A test/Sema/format-strings-fixit.c M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 105680
2010-06-09 12:11:11 +08:00
break;
Small fixes regarding printf fix suggestions. - Added some handling of flags that become invalid when changing the conversion specifier. - Changed fixit behavior to remove unnecessary length modifiers. - Separated some tests out and added some comments. modified: lib/Analysis/PrintfFormatString.cpp test/Sema/format-strings-fixit.c llvm-svn: 105807
2010-06-11 12:22:02 +08:00
Previously, the printf warnings would say your arguments type was 'int' when it was really a 'char' or a 'short'. This fixes that and allows the hints to suggest 'h' modifiers for small ints. Patch by Justin Bogner! llvm-svn: 116996
2010-10-21 12:00:58 +08:00
case BuiltinType::Char_U:
case BuiltinType::UChar:
case BuiltinType::Char_S:
case BuiltinType::SChar:
LM.setKind(LengthModifier::AsChar);
break;
case BuiltinType::Short:
case BuiltinType::UShort:
LM.setKind(LengthModifier::AsShort);
break;
Added FixIt support to printf format string checking. - Refactored LengthModifier to be a class. - Added toString methods in all member classes of FormatSpecifier. - FixIt suggestions keep user specified flags unless incorrect. Limitations: - The suggestions are not conversion specifier sensitive. For example, if we have a 'pad with zeroes' flag, and the correction is a string conversion specifier, we do not remove the flag. Clang will warn us on the next compilation. A test/Sema/format-strings-fixit.c M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 105680
2010-06-09 12:11:11 +08:00
case BuiltinType::Long:
case BuiltinType::ULong:
LM.setKind(LengthModifier::AsLong);
break;
case BuiltinType::LongLong:
case BuiltinType::ULongLong:
LM.setKind(LengthModifier::AsLongLong);
break;
case BuiltinType::LongDouble:
LM.setKind(LengthModifier::AsLongDouble);
break;
}
Suggest %zu for size_t args to printf. For PR11152. Make PrintSpecifier::fixType() suggest "%zu" for size_t, etc. rather than looking at the underlying type and suggesting "%llu" or other platform-specific length modifiers. Applies to C99 and C++11. llvm-svn: 142342
2011-10-18 16:10:06 +08:00
// Handle size_t, ptrdiff_t, etc. that have dedicated length modifiers in C99.
s/CPlusPlus0x/CPlusPlus11/g llvm-svn: 171367
2013-01-02 19:42:31 +08:00
if (isa<TypedefType>(QT) && (LangOpt.C99 || LangOpt.CPlusPlus11))
Make -Wformat walk the typedef chain when looking for size_t, etc. Clang's -Wformat fix-its currently suggest using "%zu" for values of type size_t (in C99 or C++11 mode). However, for a type such as std::vector<T>::size_type, it does not notice that type is actually typedeffed to size_t, and instead suggests a format for the underlying type, such as "%lu" or "%u". This commit makes the format string fix mechanism walk the typedef chain so that it notices if the type is size_t, even if that isn't "at the top". llvm-svn: 160886
2012-07-28 03:17:46 +08:00
namedTypeToLengthModifier(QT, LM);
Suggest %zu for size_t args to printf. For PR11152. Make PrintSpecifier::fixType() suggest "%zu" for size_t, etc. rather than looking at the underlying type and suggesting "%llu" or other platform-specific length modifiers. Applies to C99 and C++11. llvm-svn: 142342
2011-10-18 16:10:06 +08:00
Format strings: correct signedness if already correcting width (%d,%u). It is valid to do this: printf("%u", (int)x); But if we see this: printf("%lu", (int)x); ...our fixit should suggest %d, not %u. llvm-svn: 172739
2013-01-18 02:47:16 +08:00
// If fixing the length modifier was enough, we might be done.
Format strings: %Ld isn't available on Darwin or Windows. This seems to be a GNU libc extension; we offer a fixit to %lld on these platforms. <rdar://problem/11518237> llvm-svn: 163452
2012-09-08 12:00:03 +08:00
if (hasValidLengthModifier(Ctx.getTargetInfo())) {
Format strings: correct signedness if already correcting width (%d,%u). It is valid to do this: printf("%u", (int)x); But if we see this: printf("%lu", (int)x); ...our fixit should suggest %d, not %u. llvm-svn: 172739
2013-01-18 02:47:16 +08:00
// If we're going to offer a fix anyway, make sure the sign matches.
switch (CS.getKind()) {
case ConversionSpecifier::uArg:
case ConversionSpecifier::UArg:
if (QT->isSignedIntegerType())
CS.setKind(clang::analyze_format_string::ConversionSpecifier::dArg);
break;
case ConversionSpecifier::dArg:
case ConversionSpecifier::DArg:
case ConversionSpecifier::iArg:
Format strings: don't ever convert %+d to %lu. Presumably, if the printf format has the sign explicitly requested, the user wants to treat the data as signed. This is a fix-up for r172739, and also includes several test changes that didn't make it into that commit. llvm-svn: 172762
2013-01-18 06:34:10 +08:00
if (QT->isUnsignedIntegerType() && !HasPlusPrefix)
Format strings: correct signedness if already correcting width (%d,%u). It is valid to do this: printf("%u", (int)x); But if we see this: printf("%lu", (int)x); ...our fixit should suggest %d, not %u. llvm-svn: 172739
2013-01-18 02:47:16 +08:00
CS.setKind(clang::analyze_format_string::ConversionSpecifier::uArg);
break;
default:
// Other specifiers do not have signed/unsigned variants.
break;
}
Format strings: %Ld isn't available on Darwin or Windows. This seems to be a GNU libc extension; we offer a fixit to %lld on these platforms. <rdar://problem/11518237> llvm-svn: 163452
2012-09-08 12:00:03 +08:00
const analyze_printf::ArgType &ATR = getArgType(Ctx, IsObjCLiteral);
if (ATR.isValid() && ATR.matchesType(Ctx, QT))
return true;
}
Make -Wformat fix-its preserve original conversion specifiers. This commit makes PrintfSpecifier::fixType() and ScanfSpecifier::fixType() only fix a conversion specification enough that Clang wouldn't warn about it, as opposed to always changing it to use the "canonical" conversion specifier. (PR11975) This preserves the user's choice of conversion specifier in cases like: printf("%a", (long double)1); where we previously suggested "%Lf", we now suggest "%La" printf("%x", (long)1); where we previously suggested "%ld", we now suggest "%lx". llvm-svn: 150578
2012-02-15 17:59:46 +08:00
Added FixIt support to printf format string checking. - Refactored LengthModifier to be a class. - Added toString methods in all member classes of FormatSpecifier. - FixIt suggestions keep user specified flags unless incorrect. Limitations: - The suggestions are not conversion specifier sensitive. For example, if we have a 'pad with zeroes' flag, and the correction is a string conversion specifier, we do not remove the flag. Clang will warn us on the next compilation. A test/Sema/format-strings-fixit.c M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 105680
2010-06-09 12:11:11 +08:00
// Set conversion specifier and disable any flags which do not apply to it.
Previously, the printf warnings would say your arguments type was 'int' when it was really a 'char' or a 'short'. This fixes that and allows the hints to suggest 'h' modifiers for small ints. Patch by Justin Bogner! llvm-svn: 116996
2010-10-21 12:00:58 +08:00
// Let typedefs to char fall through to int, as %c is silly for uint8_t.
Format strings: the correct conversion for 'char' is %c, not %d or %hhd. We tried to account for 'uint8_t' by saying that /typedefs/ of 'char' should be corrected as %hhd rather than %c, but the condition was wrong. llvm-svn: 169397
2012-12-06 02:44:37 +08:00
if (!isa<TypedefType>(QT) && QT->isCharType()) {
Rename analyze_printf::ConversionSpecifier::IntAsCharArg to 'cArg' to match analagous enum in analyze_scanf. This is prep for refactoring the logic for handling ConversionSpecifiers for both scanf and printf. llvm-svn: 108897
2010-07-21 04:03:49 +08:00
CS.setKind(ConversionSpecifier::cArg);
Previously, the printf warnings would say your arguments type was 'int' when it was really a 'char' or a 'short'. This fixes that and allows the hints to suggest 'h' modifiers for small ints. Patch by Justin Bogner! llvm-svn: 116996
2010-10-21 12:00:58 +08:00
LM.setKind(LengthModifier::None);
Added FixIt support to printf format string checking. - Refactored LengthModifier to be a class. - Added toString methods in all member classes of FormatSpecifier. - FixIt suggestions keep user specified flags unless incorrect. Limitations: - The suggestions are not conversion specifier sensitive. For example, if we have a 'pad with zeroes' flag, and the correction is a string conversion specifier, we do not remove the flag. Clang will warn us on the next compilation. A test/Sema/format-strings-fixit.c M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 105680
2010-06-09 12:11:11 +08:00
Precision.setHowSpecified(OptionalAmount::NotSpecified);
HasAlternativeForm = 0;
HasLeadingZeroes = 0;
Bug 7377: Fixed several bad printf format string bugs. - Added warning for undefined behavior when using field specifier - Added warning for undefined behavior when using length modifier - Fixed warnings for invalid flags - Added warning for ignored flags - Added fixits for the above warnings - Fixed accuracy of detecting several undefined behavior conditions - Receive normal warnings in addition to security warnings when using %n - Fix bug where '+' flag would remain on unsigned conversion suggestions Summary of changes: - Added expanded tests - Added/expanded warnings - Added position info to OptionalAmounts for fixits - Extracted optional flags to a wrapper class with position info for fixits - Added several methods to validate a FormatSpecifier by component, each checking for undefined behavior - Fixed conversion specifier checking to conform to C99 standard - Added hooks to detect the invalid states in CheckPrintfHandler::HandleFormatSpecifier Note: warnings involving the ' ' (space) flag are temporarily disabled until whitespace highlighting no longer triggers assertions. I will make a post about this on cfe-dev shortly. M test/Sema/format-strings.c M include/clang/Basic/DiagnosticSemaKinds.td M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 106233
2010-06-18 03:00:27 +08:00
HasPlusPrefix = 0;
Added FixIt support to printf format string checking. - Refactored LengthModifier to be a class. - Added toString methods in all member classes of FormatSpecifier. - FixIt suggestions keep user specified flags unless incorrect. Limitations: - The suggestions are not conversion specifier sensitive. For example, if we have a 'pad with zeroes' flag, and the correction is a string conversion specifier, we do not remove the flag. Clang will warn us on the next compilation. A test/Sema/format-strings-fixit.c M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 105680
2010-06-09 12:11:11 +08:00
}
// Test for Floating type first as LongDouble can pass isUnsignedIntegerType
Type Type::isRealFloatingType() that vectors are not floating-point types, updating callers of both isFloatingType() and isRealFloatingType() accordingly. Caught at least one issue where we allowed one to declare a vector of vectors (!), along with cleaning up the standard-conversion logic for C++. llvm-svn: 106595
2010-06-23 07:07:26 +08:00
else if (QT->isRealFloatingType()) {
Added FixIt support to printf format string checking. - Refactored LengthModifier to be a class. - Added toString methods in all member classes of FormatSpecifier. - FixIt suggestions keep user specified flags unless incorrect. Limitations: - The suggestions are not conversion specifier sensitive. For example, if we have a 'pad with zeroes' flag, and the correction is a string conversion specifier, we do not remove the flag. Clang will warn us on the next compilation. A test/Sema/format-strings-fixit.c M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 105680
2010-06-09 12:11:11 +08:00
CS.setKind(ConversionSpecifier::fArg);
}
else if (QT->isSignedIntegerType()) {
CS.setKind(ConversionSpecifier::dArg);
HasAlternativeForm = 0;
}
Fix a typo that breaks the GCC build. Turns out that Clang isn't diagnosing this code as an error when it should, so I've filed http://llvm.org/bugs/show_bug.cgi?id=7325. llvm-svn: 105683
2010-06-09 13:25:34 +08:00
else if (QT->isUnsignedIntegerType()) {
Make -Wformat fix-its preserve original conversion specifiers. This commit makes PrintfSpecifier::fixType() and ScanfSpecifier::fixType() only fix a conversion specification enough that Clang wouldn't warn about it, as opposed to always changing it to use the "canonical" conversion specifier. (PR11975) This preserves the user's choice of conversion specifier in cases like: printf("%a", (long double)1); where we previously suggested "%Lf", we now suggest "%La" printf("%x", (long)1); where we previously suggested "%ld", we now suggest "%lx". llvm-svn: 150578
2012-02-15 17:59:46 +08:00
CS.setKind(ConversionSpecifier::uArg);
Added FixIt support to printf format string checking. - Refactored LengthModifier to be a class. - Added toString methods in all member classes of FormatSpecifier. - FixIt suggestions keep user specified flags unless incorrect. Limitations: - The suggestions are not conversion specifier sensitive. For example, if we have a 'pad with zeroes' flag, and the correction is a string conversion specifier, we do not remove the flag. Clang will warn us on the next compilation. A test/Sema/format-strings-fixit.c M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 105680
2010-06-09 12:11:11 +08:00
HasAlternativeForm = 0;
Bug 7377: Fixed several bad printf format string bugs. - Added warning for undefined behavior when using field specifier - Added warning for undefined behavior when using length modifier - Fixed warnings for invalid flags - Added warning for ignored flags - Added fixits for the above warnings - Fixed accuracy of detecting several undefined behavior conditions - Receive normal warnings in addition to security warnings when using %n - Fix bug where '+' flag would remain on unsigned conversion suggestions Summary of changes: - Added expanded tests - Added/expanded warnings - Added position info to OptionalAmounts for fixits - Extracted optional flags to a wrapper class with position info for fixits - Added several methods to validate a FormatSpecifier by component, each checking for undefined behavior - Fixed conversion specifier checking to conform to C99 standard - Added hooks to detect the invalid states in CheckPrintfHandler::HandleFormatSpecifier Note: warnings involving the ' ' (space) flag are temporarily disabled until whitespace highlighting no longer triggers assertions. I will make a post about this on cfe-dev shortly. M test/Sema/format-strings.c M include/clang/Basic/DiagnosticSemaKinds.td M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 106233
2010-06-18 03:00:27 +08:00
HasPlusPrefix = 0;
Fix else style. No functionality change intended. llvm-svn: 137896
2011-08-18 07:08:45 +08:00
} else {
Switch assert(0/false) llvm_unreachable. llvm-svn: 140367
2011-09-23 13:06:16 +08:00
llvm_unreachable("Unexpected type");
Added FixIt support to printf format string checking. - Refactored LengthModifier to be a class. - Added toString methods in all member classes of FormatSpecifier. - FixIt suggestions keep user specified flags unless incorrect. Limitations: - The suggestions are not conversion specifier sensitive. For example, if we have a 'pad with zeroes' flag, and the correction is a string conversion specifier, we do not remove the flag. Clang will warn us on the next compilation. A test/Sema/format-strings-fixit.c M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 105680
2010-06-09 12:11:11 +08:00
}
return true;
}
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
void PrintfSpecifier::toString(raw_ostream &os) const {
Added FixIt support to printf format string checking. - Refactored LengthModifier to be a class. - Added toString methods in all member classes of FormatSpecifier. - FixIt suggestions keep user specified flags unless incorrect. Limitations: - The suggestions are not conversion specifier sensitive. For example, if we have a 'pad with zeroes' flag, and the correction is a string conversion specifier, we do not remove the flag. Clang will warn us on the next compilation. A test/Sema/format-strings-fixit.c M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 105680
2010-06-09 12:11:11 +08:00
// Whilst some features have no defined order, we are using the order
7bit-ize. llvm-svn: 124363
2011-01-27 15:09:49 +08:00
// appearing in the C99 standard (ISO/IEC 9899:1999 (E) 7.19.6.1)
Added FixIt support to printf format string checking. - Refactored LengthModifier to be a class. - Added toString methods in all member classes of FormatSpecifier. - FixIt suggestions keep user specified flags unless incorrect. Limitations: - The suggestions are not conversion specifier sensitive. For example, if we have a 'pad with zeroes' flag, and the correction is a string conversion specifier, we do not remove the flag. Clang will warn us on the next compilation. A test/Sema/format-strings-fixit.c M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 105680
2010-06-09 12:11:11 +08:00
os << "%";
// Positional args
if (usesPositionalArg()) {
os << getPositionalArgIndex() << "$";
}
// Conversion flags
if (IsLeftJustified) os << "-";
if (HasPlusPrefix) os << "+";
if (HasSpacePrefix) os << " ";
if (HasAlternativeForm) os << "#";
if (HasLeadingZeroes) os << "0";
// Minimum field width
FieldWidth.toString(os);
// Precision
Precision.toString(os);
// Length modifier
os << LM.toString();
// Conversion specifier
os << CS.toString();
}
Bug 7377: Fixed several bad printf format string bugs. - Added warning for undefined behavior when using field specifier - Added warning for undefined behavior when using length modifier - Fixed warnings for invalid flags - Added warning for ignored flags - Added fixits for the above warnings - Fixed accuracy of detecting several undefined behavior conditions - Receive normal warnings in addition to security warnings when using %n - Fix bug where '+' flag would remain on unsigned conversion suggestions Summary of changes: - Added expanded tests - Added/expanded warnings - Added position info to OptionalAmounts for fixits - Extracted optional flags to a wrapper class with position info for fixits - Added several methods to validate a FormatSpecifier by component, each checking for undefined behavior - Fixed conversion specifier checking to conform to C99 standard - Added hooks to detect the invalid states in CheckPrintfHandler::HandleFormatSpecifier Note: warnings involving the ' ' (space) flag are temporarily disabled until whitespace highlighting no longer triggers assertions. I will make a post about this on cfe-dev shortly. M test/Sema/format-strings.c M include/clang/Basic/DiagnosticSemaKinds.td M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 106233
2010-06-18 03:00:27 +08:00
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
bool PrintfSpecifier::hasValidPlusPrefix() const {
Bug 7377: Fixed several bad printf format string bugs. - Added warning for undefined behavior when using field specifier - Added warning for undefined behavior when using length modifier - Fixed warnings for invalid flags - Added warning for ignored flags - Added fixits for the above warnings - Fixed accuracy of detecting several undefined behavior conditions - Receive normal warnings in addition to security warnings when using %n - Fix bug where '+' flag would remain on unsigned conversion suggestions Summary of changes: - Added expanded tests - Added/expanded warnings - Added position info to OptionalAmounts for fixits - Extracted optional flags to a wrapper class with position info for fixits - Added several methods to validate a FormatSpecifier by component, each checking for undefined behavior - Fixed conversion specifier checking to conform to C99 standard - Added hooks to detect the invalid states in CheckPrintfHandler::HandleFormatSpecifier Note: warnings involving the ' ' (space) flag are temporarily disabled until whitespace highlighting no longer triggers assertions. I will make a post about this on cfe-dev shortly. M test/Sema/format-strings.c M include/clang/Basic/DiagnosticSemaKinds.td M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 106233
2010-06-18 03:00:27 +08:00
if (!HasPlusPrefix)
return true;
// The plus prefix only makes sense for signed conversions
switch (CS.getKind()) {
case ConversionSpecifier::dArg:
Format strings: %D, %U, and %O are valid on Darwin (same as %d, %u, %o). These will warn under -Wformat-non-iso, and will still be rejected outright on other platforms. <rdar://problem/12061922> llvm-svn: 163771
2012-09-13 10:11:03 +08:00
case ConversionSpecifier::DArg:
Bug 7377: Fixed several bad printf format string bugs. - Added warning for undefined behavior when using field specifier - Added warning for undefined behavior when using length modifier - Fixed warnings for invalid flags - Added warning for ignored flags - Added fixits for the above warnings - Fixed accuracy of detecting several undefined behavior conditions - Receive normal warnings in addition to security warnings when using %n - Fix bug where '+' flag would remain on unsigned conversion suggestions Summary of changes: - Added expanded tests - Added/expanded warnings - Added position info to OptionalAmounts for fixits - Extracted optional flags to a wrapper class with position info for fixits - Added several methods to validate a FormatSpecifier by component, each checking for undefined behavior - Fixed conversion specifier checking to conform to C99 standard - Added hooks to detect the invalid states in CheckPrintfHandler::HandleFormatSpecifier Note: warnings involving the ' ' (space) flag are temporarily disabled until whitespace highlighting no longer triggers assertions. I will make a post about this on cfe-dev shortly. M test/Sema/format-strings.c M include/clang/Basic/DiagnosticSemaKinds.td M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 106233
2010-06-18 03:00:27 +08:00
case ConversionSpecifier::iArg:
case ConversionSpecifier::fArg:
case ConversionSpecifier::FArg:
case ConversionSpecifier::eArg:
case ConversionSpecifier::EArg:
case ConversionSpecifier::gArg:
case ConversionSpecifier::GArg:
case ConversionSpecifier::aArg:
case ConversionSpecifier::AArg:
return true;
default:
return false;
}
}
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
bool PrintfSpecifier::hasValidAlternativeForm() const {
Bug 7377: Fixed several bad printf format string bugs. - Added warning for undefined behavior when using field specifier - Added warning for undefined behavior when using length modifier - Fixed warnings for invalid flags - Added warning for ignored flags - Added fixits for the above warnings - Fixed accuracy of detecting several undefined behavior conditions - Receive normal warnings in addition to security warnings when using %n - Fix bug where '+' flag would remain on unsigned conversion suggestions Summary of changes: - Added expanded tests - Added/expanded warnings - Added position info to OptionalAmounts for fixits - Extracted optional flags to a wrapper class with position info for fixits - Added several methods to validate a FormatSpecifier by component, each checking for undefined behavior - Fixed conversion specifier checking to conform to C99 standard - Added hooks to detect the invalid states in CheckPrintfHandler::HandleFormatSpecifier Note: warnings involving the ' ' (space) flag are temporarily disabled until whitespace highlighting no longer triggers assertions. I will make a post about this on cfe-dev shortly. M test/Sema/format-strings.c M include/clang/Basic/DiagnosticSemaKinds.td M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 106233
2010-06-18 03:00:27 +08:00
if (!HasAlternativeForm)
return true;
The 'X' printf type has a valid alternative form. Fixes PR8641. llvm-svn: 119946
2010-11-22 02:34:21 +08:00
// Alternate form flag only valid with the oxXaAeEfFgG conversions
Bug 7377: Fixed several bad printf format string bugs. - Added warning for undefined behavior when using field specifier - Added warning for undefined behavior when using length modifier - Fixed warnings for invalid flags - Added warning for ignored flags - Added fixits for the above warnings - Fixed accuracy of detecting several undefined behavior conditions - Receive normal warnings in addition to security warnings when using %n - Fix bug where '+' flag would remain on unsigned conversion suggestions Summary of changes: - Added expanded tests - Added/expanded warnings - Added position info to OptionalAmounts for fixits - Extracted optional flags to a wrapper class with position info for fixits - Added several methods to validate a FormatSpecifier by component, each checking for undefined behavior - Fixed conversion specifier checking to conform to C99 standard - Added hooks to detect the invalid states in CheckPrintfHandler::HandleFormatSpecifier Note: warnings involving the ' ' (space) flag are temporarily disabled until whitespace highlighting no longer triggers assertions. I will make a post about this on cfe-dev shortly. M test/Sema/format-strings.c M include/clang/Basic/DiagnosticSemaKinds.td M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 106233
2010-06-18 03:00:27 +08:00
switch (CS.getKind()) {
case ConversionSpecifier::oArg:
Format strings: %D, %U, and %O are valid on Darwin (same as %d, %u, %o). These will warn under -Wformat-non-iso, and will still be rejected outright on other platforms. <rdar://problem/12061922> llvm-svn: 163771
2012-09-13 10:11:03 +08:00
case ConversionSpecifier::OArg:
Bug 7377: Fixed several bad printf format string bugs. - Added warning for undefined behavior when using field specifier - Added warning for undefined behavior when using length modifier - Fixed warnings for invalid flags - Added warning for ignored flags - Added fixits for the above warnings - Fixed accuracy of detecting several undefined behavior conditions - Receive normal warnings in addition to security warnings when using %n - Fix bug where '+' flag would remain on unsigned conversion suggestions Summary of changes: - Added expanded tests - Added/expanded warnings - Added position info to OptionalAmounts for fixits - Extracted optional flags to a wrapper class with position info for fixits - Added several methods to validate a FormatSpecifier by component, each checking for undefined behavior - Fixed conversion specifier checking to conform to C99 standard - Added hooks to detect the invalid states in CheckPrintfHandler::HandleFormatSpecifier Note: warnings involving the ' ' (space) flag are temporarily disabled until whitespace highlighting no longer triggers assertions. I will make a post about this on cfe-dev shortly. M test/Sema/format-strings.c M include/clang/Basic/DiagnosticSemaKinds.td M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 106233
2010-06-18 03:00:27 +08:00
case ConversionSpecifier::xArg:
The 'X' printf type has a valid alternative form. Fixes PR8641. llvm-svn: 119946
2010-11-22 02:34:21 +08:00
case ConversionSpecifier::XArg:
Bug 7377: Fixed several bad printf format string bugs. - Added warning for undefined behavior when using field specifier - Added warning for undefined behavior when using length modifier - Fixed warnings for invalid flags - Added warning for ignored flags - Added fixits for the above warnings - Fixed accuracy of detecting several undefined behavior conditions - Receive normal warnings in addition to security warnings when using %n - Fix bug where '+' flag would remain on unsigned conversion suggestions Summary of changes: - Added expanded tests - Added/expanded warnings - Added position info to OptionalAmounts for fixits - Extracted optional flags to a wrapper class with position info for fixits - Added several methods to validate a FormatSpecifier by component, each checking for undefined behavior - Fixed conversion specifier checking to conform to C99 standard - Added hooks to detect the invalid states in CheckPrintfHandler::HandleFormatSpecifier Note: warnings involving the ' ' (space) flag are temporarily disabled until whitespace highlighting no longer triggers assertions. I will make a post about this on cfe-dev shortly. M test/Sema/format-strings.c M include/clang/Basic/DiagnosticSemaKinds.td M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 106233
2010-06-18 03:00:27 +08:00
case ConversionSpecifier::aArg:
case ConversionSpecifier::AArg:
case ConversionSpecifier::eArg:
case ConversionSpecifier::EArg:
case ConversionSpecifier::fArg:
case ConversionSpecifier::FArg:
case ConversionSpecifier::gArg:
case ConversionSpecifier::GArg:
return true;
default:
return false;
}
}
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
bool PrintfSpecifier::hasValidLeadingZeros() const {
Bug 7377: Fixed several bad printf format string bugs. - Added warning for undefined behavior when using field specifier - Added warning for undefined behavior when using length modifier - Fixed warnings for invalid flags - Added warning for ignored flags - Added fixits for the above warnings - Fixed accuracy of detecting several undefined behavior conditions - Receive normal warnings in addition to security warnings when using %n - Fix bug where '+' flag would remain on unsigned conversion suggestions Summary of changes: - Added expanded tests - Added/expanded warnings - Added position info to OptionalAmounts for fixits - Extracted optional flags to a wrapper class with position info for fixits - Added several methods to validate a FormatSpecifier by component, each checking for undefined behavior - Fixed conversion specifier checking to conform to C99 standard - Added hooks to detect the invalid states in CheckPrintfHandler::HandleFormatSpecifier Note: warnings involving the ' ' (space) flag are temporarily disabled until whitespace highlighting no longer triggers assertions. I will make a post about this on cfe-dev shortly. M test/Sema/format-strings.c M include/clang/Basic/DiagnosticSemaKinds.td M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 106233
2010-06-18 03:00:27 +08:00
if (!HasLeadingZeroes)
return true;
// Leading zeroes flag only valid with the diouxXaAeEfFgG conversions
switch (CS.getKind()) {
case ConversionSpecifier::dArg:
Format strings: %D, %U, and %O are valid on Darwin (same as %d, %u, %o). These will warn under -Wformat-non-iso, and will still be rejected outright on other platforms. <rdar://problem/12061922> llvm-svn: 163771
2012-09-13 10:11:03 +08:00
case ConversionSpecifier::DArg:
Bug 7377: Fixed several bad printf format string bugs. - Added warning for undefined behavior when using field specifier - Added warning for undefined behavior when using length modifier - Fixed warnings for invalid flags - Added warning for ignored flags - Added fixits for the above warnings - Fixed accuracy of detecting several undefined behavior conditions - Receive normal warnings in addition to security warnings when using %n - Fix bug where '+' flag would remain on unsigned conversion suggestions Summary of changes: - Added expanded tests - Added/expanded warnings - Added position info to OptionalAmounts for fixits - Extracted optional flags to a wrapper class with position info for fixits - Added several methods to validate a FormatSpecifier by component, each checking for undefined behavior - Fixed conversion specifier checking to conform to C99 standard - Added hooks to detect the invalid states in CheckPrintfHandler::HandleFormatSpecifier Note: warnings involving the ' ' (space) flag are temporarily disabled until whitespace highlighting no longer triggers assertions. I will make a post about this on cfe-dev shortly. M test/Sema/format-strings.c M include/clang/Basic/DiagnosticSemaKinds.td M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 106233
2010-06-18 03:00:27 +08:00
case ConversionSpecifier::iArg:
case ConversionSpecifier::oArg:
Format strings: %D, %U, and %O are valid on Darwin (same as %d, %u, %o). These will warn under -Wformat-non-iso, and will still be rejected outright on other platforms. <rdar://problem/12061922> llvm-svn: 163771
2012-09-13 10:11:03 +08:00
case ConversionSpecifier::OArg:
Bug 7377: Fixed several bad printf format string bugs. - Added warning for undefined behavior when using field specifier - Added warning for undefined behavior when using length modifier - Fixed warnings for invalid flags - Added warning for ignored flags - Added fixits for the above warnings - Fixed accuracy of detecting several undefined behavior conditions - Receive normal warnings in addition to security warnings when using %n - Fix bug where '+' flag would remain on unsigned conversion suggestions Summary of changes: - Added expanded tests - Added/expanded warnings - Added position info to OptionalAmounts for fixits - Extracted optional flags to a wrapper class with position info for fixits - Added several methods to validate a FormatSpecifier by component, each checking for undefined behavior - Fixed conversion specifier checking to conform to C99 standard - Added hooks to detect the invalid states in CheckPrintfHandler::HandleFormatSpecifier Note: warnings involving the ' ' (space) flag are temporarily disabled until whitespace highlighting no longer triggers assertions. I will make a post about this on cfe-dev shortly. M test/Sema/format-strings.c M include/clang/Basic/DiagnosticSemaKinds.td M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 106233
2010-06-18 03:00:27 +08:00
case ConversionSpecifier::uArg:
Format strings: %D, %U, and %O are valid on Darwin (same as %d, %u, %o). These will warn under -Wformat-non-iso, and will still be rejected outright on other platforms. <rdar://problem/12061922> llvm-svn: 163771
2012-09-13 10:11:03 +08:00
case ConversionSpecifier::UArg:
Bug 7377: Fixed several bad printf format string bugs. - Added warning for undefined behavior when using field specifier - Added warning for undefined behavior when using length modifier - Fixed warnings for invalid flags - Added warning for ignored flags - Added fixits for the above warnings - Fixed accuracy of detecting several undefined behavior conditions - Receive normal warnings in addition to security warnings when using %n - Fix bug where '+' flag would remain on unsigned conversion suggestions Summary of changes: - Added expanded tests - Added/expanded warnings - Added position info to OptionalAmounts for fixits - Extracted optional flags to a wrapper class with position info for fixits - Added several methods to validate a FormatSpecifier by component, each checking for undefined behavior - Fixed conversion specifier checking to conform to C99 standard - Added hooks to detect the invalid states in CheckPrintfHandler::HandleFormatSpecifier Note: warnings involving the ' ' (space) flag are temporarily disabled until whitespace highlighting no longer triggers assertions. I will make a post about this on cfe-dev shortly. M test/Sema/format-strings.c M include/clang/Basic/DiagnosticSemaKinds.td M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 106233
2010-06-18 03:00:27 +08:00
case ConversionSpecifier::xArg:
case ConversionSpecifier::XArg:
case ConversionSpecifier::aArg:
case ConversionSpecifier::AArg:
case ConversionSpecifier::eArg:
case ConversionSpecifier::EArg:
case ConversionSpecifier::fArg:
case ConversionSpecifier::FArg:
case ConversionSpecifier::gArg:
case ConversionSpecifier::GArg:
return true;
default:
return false;
}
}
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
bool PrintfSpecifier::hasValidSpacePrefix() const {
Bug 7377: Fixed several bad printf format string bugs. - Added warning for undefined behavior when using field specifier - Added warning for undefined behavior when using length modifier - Fixed warnings for invalid flags - Added warning for ignored flags - Added fixits for the above warnings - Fixed accuracy of detecting several undefined behavior conditions - Receive normal warnings in addition to security warnings when using %n - Fix bug where '+' flag would remain on unsigned conversion suggestions Summary of changes: - Added expanded tests - Added/expanded warnings - Added position info to OptionalAmounts for fixits - Extracted optional flags to a wrapper class with position info for fixits - Added several methods to validate a FormatSpecifier by component, each checking for undefined behavior - Fixed conversion specifier checking to conform to C99 standard - Added hooks to detect the invalid states in CheckPrintfHandler::HandleFormatSpecifier Note: warnings involving the ' ' (space) flag are temporarily disabled until whitespace highlighting no longer triggers assertions. I will make a post about this on cfe-dev shortly. M test/Sema/format-strings.c M include/clang/Basic/DiagnosticSemaKinds.td M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 106233
2010-06-18 03:00:27 +08:00
if (!HasSpacePrefix)
return true;
// The space prefix only makes sense for signed conversions
switch (CS.getKind()) {
case ConversionSpecifier::dArg:
Format strings: %D, %U, and %O are valid on Darwin (same as %d, %u, %o). These will warn under -Wformat-non-iso, and will still be rejected outright on other platforms. <rdar://problem/12061922> llvm-svn: 163771
2012-09-13 10:11:03 +08:00
case ConversionSpecifier::DArg:
Bug 7377: Fixed several bad printf format string bugs. - Added warning for undefined behavior when using field specifier - Added warning for undefined behavior when using length modifier - Fixed warnings for invalid flags - Added warning for ignored flags - Added fixits for the above warnings - Fixed accuracy of detecting several undefined behavior conditions - Receive normal warnings in addition to security warnings when using %n - Fix bug where '+' flag would remain on unsigned conversion suggestions Summary of changes: - Added expanded tests - Added/expanded warnings - Added position info to OptionalAmounts for fixits - Extracted optional flags to a wrapper class with position info for fixits - Added several methods to validate a FormatSpecifier by component, each checking for undefined behavior - Fixed conversion specifier checking to conform to C99 standard - Added hooks to detect the invalid states in CheckPrintfHandler::HandleFormatSpecifier Note: warnings involving the ' ' (space) flag are temporarily disabled until whitespace highlighting no longer triggers assertions. I will make a post about this on cfe-dev shortly. M test/Sema/format-strings.c M include/clang/Basic/DiagnosticSemaKinds.td M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 106233
2010-06-18 03:00:27 +08:00
case ConversionSpecifier::iArg:
case ConversionSpecifier::fArg:
case ConversionSpecifier::FArg:
case ConversionSpecifier::eArg:
case ConversionSpecifier::EArg:
case ConversionSpecifier::gArg:
case ConversionSpecifier::GArg:
case ConversionSpecifier::aArg:
case ConversionSpecifier::AArg:
return true;
default:
return false;
}
}
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
bool PrintfSpecifier::hasValidLeftJustified() const {
Bug 7377: Fixed several bad printf format string bugs. - Added warning for undefined behavior when using field specifier - Added warning for undefined behavior when using length modifier - Fixed warnings for invalid flags - Added warning for ignored flags - Added fixits for the above warnings - Fixed accuracy of detecting several undefined behavior conditions - Receive normal warnings in addition to security warnings when using %n - Fix bug where '+' flag would remain on unsigned conversion suggestions Summary of changes: - Added expanded tests - Added/expanded warnings - Added position info to OptionalAmounts for fixits - Extracted optional flags to a wrapper class with position info for fixits - Added several methods to validate a FormatSpecifier by component, each checking for undefined behavior - Fixed conversion specifier checking to conform to C99 standard - Added hooks to detect the invalid states in CheckPrintfHandler::HandleFormatSpecifier Note: warnings involving the ' ' (space) flag are temporarily disabled until whitespace highlighting no longer triggers assertions. I will make a post about this on cfe-dev shortly. M test/Sema/format-strings.c M include/clang/Basic/DiagnosticSemaKinds.td M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 106233
2010-06-18 03:00:27 +08:00
if (!IsLeftJustified)
return true;
// The left justified flag is valid for all conversions except n
switch (CS.getKind()) {
Rename 'ConsumedSoFarArg' -> 'nArg' and 'OutIntPtrArg' to 'nArg' (scanf and printf checking). llvm-svn: 108900
2010-07-21 04:04:10 +08:00
case ConversionSpecifier::nArg:
Bug 7377: Fixed several bad printf format string bugs. - Added warning for undefined behavior when using field specifier - Added warning for undefined behavior when using length modifier - Fixed warnings for invalid flags - Added warning for ignored flags - Added fixits for the above warnings - Fixed accuracy of detecting several undefined behavior conditions - Receive normal warnings in addition to security warnings when using %n - Fix bug where '+' flag would remain on unsigned conversion suggestions Summary of changes: - Added expanded tests - Added/expanded warnings - Added position info to OptionalAmounts for fixits - Extracted optional flags to a wrapper class with position info for fixits - Added several methods to validate a FormatSpecifier by component, each checking for undefined behavior - Fixed conversion specifier checking to conform to C99 standard - Added hooks to detect the invalid states in CheckPrintfHandler::HandleFormatSpecifier Note: warnings involving the ' ' (space) flag are temporarily disabled until whitespace highlighting no longer triggers assertions. I will make a post about this on cfe-dev shortly. M test/Sema/format-strings.c M include/clang/Basic/DiagnosticSemaKinds.td M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 106233
2010-06-18 03:00:27 +08:00
return false;
default:
return true;
}
}
Add semantic checking that the "thousands grouping" prefix in a printf format string is matched with the appropriate conversion specifier. llvm-svn: 123055
2011-01-08 13:28:46 +08:00
bool PrintfSpecifier::hasValidThousandsGroupingPrefix() const {
if (!HasThousandsGrouping)
return true;
Fix whitespace. llvm-svn: 124364
2011-01-27 15:10:08 +08:00
Add semantic checking that the "thousands grouping" prefix in a printf format string is matched with the appropriate conversion specifier. llvm-svn: 123055
2011-01-08 13:28:46 +08:00
switch (CS.getKind()) {
case ConversionSpecifier::dArg:
Format strings: %D, %U, and %O are valid on Darwin (same as %d, %u, %o). These will warn under -Wformat-non-iso, and will still be rejected outright on other platforms. <rdar://problem/12061922> llvm-svn: 163771
2012-09-13 10:11:03 +08:00
case ConversionSpecifier::DArg:
Add semantic checking that the "thousands grouping" prefix in a printf format string is matched with the appropriate conversion specifier. llvm-svn: 123055
2011-01-08 13:28:46 +08:00
case ConversionSpecifier::iArg:
case ConversionSpecifier::uArg:
Format strings: %D, %U, and %O are valid on Darwin (same as %d, %u, %o). These will warn under -Wformat-non-iso, and will still be rejected outright on other platforms. <rdar://problem/12061922> llvm-svn: 163771
2012-09-13 10:11:03 +08:00
case ConversionSpecifier::UArg:
Add semantic checking that the "thousands grouping" prefix in a printf format string is matched with the appropriate conversion specifier. llvm-svn: 123055
2011-01-08 13:28:46 +08:00
case ConversionSpecifier::fArg:
case ConversionSpecifier::FArg:
case ConversionSpecifier::gArg:
case ConversionSpecifier::GArg:
return true;
default:
return false;
}
}
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
bool PrintfSpecifier::hasValidPrecision() const {
Bug 7377: Fixed several bad printf format string bugs. - Added warning for undefined behavior when using field specifier - Added warning for undefined behavior when using length modifier - Fixed warnings for invalid flags - Added warning for ignored flags - Added fixits for the above warnings - Fixed accuracy of detecting several undefined behavior conditions - Receive normal warnings in addition to security warnings when using %n - Fix bug where '+' flag would remain on unsigned conversion suggestions Summary of changes: - Added expanded tests - Added/expanded warnings - Added position info to OptionalAmounts for fixits - Extracted optional flags to a wrapper class with position info for fixits - Added several methods to validate a FormatSpecifier by component, each checking for undefined behavior - Fixed conversion specifier checking to conform to C99 standard - Added hooks to detect the invalid states in CheckPrintfHandler::HandleFormatSpecifier Note: warnings involving the ' ' (space) flag are temporarily disabled until whitespace highlighting no longer triggers assertions. I will make a post about this on cfe-dev shortly. M test/Sema/format-strings.c M include/clang/Basic/DiagnosticSemaKinds.td M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 106233
2010-06-18 03:00:27 +08:00
if (Precision.getHowSpecified() == OptionalAmount::NotSpecified)
return true;
// Precision is only valid with the diouxXaAeEfFgGs conversions
switch (CS.getKind()) {
case ConversionSpecifier::dArg:
Format strings: %D, %U, and %O are valid on Darwin (same as %d, %u, %o). These will warn under -Wformat-non-iso, and will still be rejected outright on other platforms. <rdar://problem/12061922> llvm-svn: 163771
2012-09-13 10:11:03 +08:00
case ConversionSpecifier::DArg:
Bug 7377: Fixed several bad printf format string bugs. - Added warning for undefined behavior when using field specifier - Added warning for undefined behavior when using length modifier - Fixed warnings for invalid flags - Added warning for ignored flags - Added fixits for the above warnings - Fixed accuracy of detecting several undefined behavior conditions - Receive normal warnings in addition to security warnings when using %n - Fix bug where '+' flag would remain on unsigned conversion suggestions Summary of changes: - Added expanded tests - Added/expanded warnings - Added position info to OptionalAmounts for fixits - Extracted optional flags to a wrapper class with position info for fixits - Added several methods to validate a FormatSpecifier by component, each checking for undefined behavior - Fixed conversion specifier checking to conform to C99 standard - Added hooks to detect the invalid states in CheckPrintfHandler::HandleFormatSpecifier Note: warnings involving the ' ' (space) flag are temporarily disabled until whitespace highlighting no longer triggers assertions. I will make a post about this on cfe-dev shortly. M test/Sema/format-strings.c M include/clang/Basic/DiagnosticSemaKinds.td M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 106233
2010-06-18 03:00:27 +08:00
case ConversionSpecifier::iArg:
case ConversionSpecifier::oArg:
Format strings: %D, %U, and %O are valid on Darwin (same as %d, %u, %o). These will warn under -Wformat-non-iso, and will still be rejected outright on other platforms. <rdar://problem/12061922> llvm-svn: 163771
2012-09-13 10:11:03 +08:00
case ConversionSpecifier::OArg:
Bug 7377: Fixed several bad printf format string bugs. - Added warning for undefined behavior when using field specifier - Added warning for undefined behavior when using length modifier - Fixed warnings for invalid flags - Added warning for ignored flags - Added fixits for the above warnings - Fixed accuracy of detecting several undefined behavior conditions - Receive normal warnings in addition to security warnings when using %n - Fix bug where '+' flag would remain on unsigned conversion suggestions Summary of changes: - Added expanded tests - Added/expanded warnings - Added position info to OptionalAmounts for fixits - Extracted optional flags to a wrapper class with position info for fixits - Added several methods to validate a FormatSpecifier by component, each checking for undefined behavior - Fixed conversion specifier checking to conform to C99 standard - Added hooks to detect the invalid states in CheckPrintfHandler::HandleFormatSpecifier Note: warnings involving the ' ' (space) flag are temporarily disabled until whitespace highlighting no longer triggers assertions. I will make a post about this on cfe-dev shortly. M test/Sema/format-strings.c M include/clang/Basic/DiagnosticSemaKinds.td M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 106233
2010-06-18 03:00:27 +08:00
case ConversionSpecifier::uArg:
Format strings: %D, %U, and %O are valid on Darwin (same as %d, %u, %o). These will warn under -Wformat-non-iso, and will still be rejected outright on other platforms. <rdar://problem/12061922> llvm-svn: 163771
2012-09-13 10:11:03 +08:00
case ConversionSpecifier::UArg:
Bug 7377: Fixed several bad printf format string bugs. - Added warning for undefined behavior when using field specifier - Added warning for undefined behavior when using length modifier - Fixed warnings for invalid flags - Added warning for ignored flags - Added fixits for the above warnings - Fixed accuracy of detecting several undefined behavior conditions - Receive normal warnings in addition to security warnings when using %n - Fix bug where '+' flag would remain on unsigned conversion suggestions Summary of changes: - Added expanded tests - Added/expanded warnings - Added position info to OptionalAmounts for fixits - Extracted optional flags to a wrapper class with position info for fixits - Added several methods to validate a FormatSpecifier by component, each checking for undefined behavior - Fixed conversion specifier checking to conform to C99 standard - Added hooks to detect the invalid states in CheckPrintfHandler::HandleFormatSpecifier Note: warnings involving the ' ' (space) flag are temporarily disabled until whitespace highlighting no longer triggers assertions. I will make a post about this on cfe-dev shortly. M test/Sema/format-strings.c M include/clang/Basic/DiagnosticSemaKinds.td M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 106233
2010-06-18 03:00:27 +08:00
case ConversionSpecifier::xArg:
case ConversionSpecifier::XArg:
case ConversionSpecifier::aArg:
case ConversionSpecifier::AArg:
case ConversionSpecifier::eArg:
case ConversionSpecifier::EArg:
case ConversionSpecifier::fArg:
case ConversionSpecifier::FArg:
case ConversionSpecifier::gArg:
case ConversionSpecifier::GArg:
Rename 'CStrArg' to 'sArg' for printf checking to match with the analagous enum for scanf checking. llvm-svn: 108898
2010-07-21 04:03:58 +08:00
case ConversionSpecifier::sArg:
Bug 7377: Fixed several bad printf format string bugs. - Added warning for undefined behavior when using field specifier - Added warning for undefined behavior when using length modifier - Fixed warnings for invalid flags - Added warning for ignored flags - Added fixits for the above warnings - Fixed accuracy of detecting several undefined behavior conditions - Receive normal warnings in addition to security warnings when using %n - Fix bug where '+' flag would remain on unsigned conversion suggestions Summary of changes: - Added expanded tests - Added/expanded warnings - Added position info to OptionalAmounts for fixits - Extracted optional flags to a wrapper class with position info for fixits - Added several methods to validate a FormatSpecifier by component, each checking for undefined behavior - Fixed conversion specifier checking to conform to C99 standard - Added hooks to detect the invalid states in CheckPrintfHandler::HandleFormatSpecifier Note: warnings involving the ' ' (space) flag are temporarily disabled until whitespace highlighting no longer triggers assertions. I will make a post about this on cfe-dev shortly. M test/Sema/format-strings.c M include/clang/Basic/DiagnosticSemaKinds.td M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 106233
2010-06-18 03:00:27 +08:00
return true;
default:
return false;
}
}
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500
2010-07-16 10:11:22 +08:00
bool PrintfSpecifier::hasValidFieldWidth() const {
Bug 7377: Fixed several bad printf format string bugs. - Added warning for undefined behavior when using field specifier - Added warning for undefined behavior when using length modifier - Fixed warnings for invalid flags - Added warning for ignored flags - Added fixits for the above warnings - Fixed accuracy of detecting several undefined behavior conditions - Receive normal warnings in addition to security warnings when using %n - Fix bug where '+' flag would remain on unsigned conversion suggestions Summary of changes: - Added expanded tests - Added/expanded warnings - Added position info to OptionalAmounts for fixits - Extracted optional flags to a wrapper class with position info for fixits - Added several methods to validate a FormatSpecifier by component, each checking for undefined behavior - Fixed conversion specifier checking to conform to C99 standard - Added hooks to detect the invalid states in CheckPrintfHandler::HandleFormatSpecifier Note: warnings involving the ' ' (space) flag are temporarily disabled until whitespace highlighting no longer triggers assertions. I will make a post about this on cfe-dev shortly. M test/Sema/format-strings.c M include/clang/Basic/DiagnosticSemaKinds.td M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 106233
2010-06-18 03:00:27 +08:00
if (FieldWidth.getHowSpecified() == OptionalAmount::NotSpecified)
return true;
// The field width is valid for all conversions except n
switch (CS.getKind()) {
Rename 'ConsumedSoFarArg' -> 'nArg' and 'OutIntPtrArg' to 'nArg' (scanf and printf checking). llvm-svn: 108900
2010-07-21 04:04:10 +08:00
case ConversionSpecifier::nArg:
Bug 7377: Fixed several bad printf format string bugs. - Added warning for undefined behavior when using field specifier - Added warning for undefined behavior when using length modifier - Fixed warnings for invalid flags - Added warning for ignored flags - Added fixits for the above warnings - Fixed accuracy of detecting several undefined behavior conditions - Receive normal warnings in addition to security warnings when using %n - Fix bug where '+' flag would remain on unsigned conversion suggestions Summary of changes: - Added expanded tests - Added/expanded warnings - Added position info to OptionalAmounts for fixits - Extracted optional flags to a wrapper class with position info for fixits - Added several methods to validate a FormatSpecifier by component, each checking for undefined behavior - Fixed conversion specifier checking to conform to C99 standard - Added hooks to detect the invalid states in CheckPrintfHandler::HandleFormatSpecifier Note: warnings involving the ' ' (space) flag are temporarily disabled until whitespace highlighting no longer triggers assertions. I will make a post about this on cfe-dev shortly. M test/Sema/format-strings.c M include/clang/Basic/DiagnosticSemaKinds.td M include/clang/Analysis/Analyses/PrintfFormatString.h M lib/Analysis/PrintfFormatString.cpp M lib/Sema/SemaChecking.cpp llvm-svn: 106233
2010-06-18 03:00:27 +08:00
return false;
default:
return true;
}
}