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

983 lines
31 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;
}
Parse 'technical term' format specifier. Objective-C format strings now support modifier flags that can be attached to a '@' conversion. Currently the only one supported, as of iOS 9 and OS X 10.11, is the new "technical term", denoted by the flag "tt", for example: %[tt]@ instead of just: %@ The 'tt' stands for "technical term", which is used by the string-localization facilities on Darwin to add the appropriate spacing or quotation depending the language locale. Implements <rdar://problem/20374720>. llvm-svn: 241243
2015-07-02 13:39:16 +08:00
static bool ParseObjCFlags(FormatStringHandler &H, PrintfSpecifier &FS,
const char *FlagBeg, const char *E, bool Warn) {
StringRef Flag(FlagBeg, E - FlagBeg);
// Currently there is only one flag.
if (Flag == "tt") {
FS.setHasObjCTechnicalTerm(FlagBeg);
return false;
}
// Handle either the case of no flag or an invalid flag.
if (Warn) {
if (Flag == "")
H.HandleEmptyObjCModifierFlag(FlagBeg, E - FlagBeg);
else
H.HandleInvalidObjCModifierFlag(FlagBeg, E - FlagBeg);
}
return true;
}
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,
Objective-C. Under a special flag, -Wcstring-format-directive, off by default, issue a warning if %s directive is used in certain CF/NS formatting APIs, to assist user in deprecating use of such %s in these APIs. rdar://18182443 llvm-svn: 217467
2014-09-10 07:10:54 +08:00
const TargetInfo &Target,
Add support for analyzing FreeBSD kernel printf extensions. This adds a new __freebsd_kprintf__ format string type, which enables checking when used in __attribute__((format(...))) attributes. It can check the FreeBSD kernel specific %b, %D, %r and %y specifiers, using existing diagnostic messages. Also adds test cases for all these specifiers. Differential Revision: http://reviews.llvm.org/D7154 llvm-svn: 229921
2015-02-20 06:32:33 +08:00
bool Warn,
bool isFreeBSDKPrintf) {
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;
[C++11] Use 'nullptr'. Analysis edition. llvm-svn: 209191
2014-05-20 12:30:07 +08:00
const char *Start = nullptr;
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?
Objective-C. Under a special flag, -Wcstring-format-directive, off by default, issue a warning if %s directive is used in certain CF/NS formatting APIs, to assist user in deprecating use of such %s in these APIs. rdar://18182443 llvm-svn: 217467
2014-09-10 07:10:54 +08:00
if (Warn)
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?
Objective-C. Under a special flag, -Wcstring-format-directive, off by default, issue a warning if %s directive is used in certain CF/NS formatting APIs, to assist user in deprecating use of such %s in these APIs. rdar://18182443 llvm-svn: 217467
2014-09-10 07:10:54 +08:00
if (Warn)
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 support for __builtin_os_log_format[_buffer_size] This reverts commit r285007 and reapply r284990, with a fix for the opencl test that I broke. Original commit message follows: These new builtins support a mechanism for logging OS events, using a printf-like format string to specify the layout of data in a buffer. The _buffer_size version of the builtin can be used to determine the size of the buffer to allocate to hold the data, and then __builtin_os_log_format can write data into that buffer. This implements format checking to report mismatches between the format string and the data arguments. Most of this code was written by Chris Willmore. Differential Revision: https://reviews.llvm.org/D25888 llvm-svn: 285019
2016-10-25 04:39:34 +08:00
const char *OSLogVisibilityFlagsStart = nullptr,
*OSLogVisibilityFlagsEnd = nullptr;
if (*I == '{') {
OSLogVisibilityFlagsStart = I++;
// Find the end of the modifier.
while (I != E && *I != '}') {
I++;
}
if (I == E) {
if (Warn)
H.HandleIncompleteSpecifier(Start, E - Start);
return true;
}
assert(*I == '}');
OSLogVisibilityFlagsEnd = I++;
// Just see if 'private' or 'public' is the first word. os_log itself will
// do any further parsing.
const char *P = OSLogVisibilityFlagsStart + 1;
while (P < OSLogVisibilityFlagsEnd && isspace(*P))
P++;
const char *WordStart = P;
while (P < OSLogVisibilityFlagsEnd && (isalnum(*P) || *P == '_'))
P++;
const char *WordEnd = P;
StringRef Word(WordStart, WordEnd - WordStart);
if (Word == "private") {
FS.setIsPrivate(WordStart);
} else if (Word == "public") {
FS.setIsPublic(WordStart);
}
}
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?
Objective-C. Under a special flag, -Wcstring-format-directive, off by default, issue a warning if %s directive is used in certain CF/NS formatting APIs, to assist user in deprecating use of such %s in these APIs. rdar://18182443 llvm-svn: 217467
2014-09-10 07:10:54 +08:00
if (Warn)
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,
[C++11] Use 'nullptr'. Analysis edition. llvm-svn: 209191
2014-05-20 12:30:07 +08:00
FS.usesPositionalArg() ? nullptr : &argIndex))
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
if (I == E) {
// No more characters left?
Objective-C. Under a special flag, -Wcstring-format-directive, off by default, issue a warning if %s directive is used in certain CF/NS formatting APIs, to assist user in deprecating use of such %s in these APIs. rdar://18182443 llvm-svn: 217467
2014-09-10 07:10:54 +08:00
if (Warn)
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) {
Objective-C. Under a special flag, -Wcstring-format-directive, off by default, issue a warning if %s directive is used in certain CF/NS formatting APIs, to assist user in deprecating use of such %s in these APIs. rdar://18182443 llvm-svn: 217467
2014-09-10 07:10:54 +08:00
if (Warn)
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,
[C++11] Use 'nullptr'. Analysis edition. llvm-svn: 209191
2014-05-20 12:30:07 +08:00
FS.usesPositionalArg() ? nullptr : &argIndex))
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;
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?
Objective-C. Under a special flag, -Wcstring-format-directive, off by default, issue a warning if %s directive is used in certain CF/NS formatting APIs, to assist user in deprecating use of such %s in these APIs. rdar://18182443 llvm-svn: 217467
2014-09-10 07:10:54 +08:00
if (Warn)
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?
Objective-C. Under a special flag, -Wcstring-format-directive, off by default, issue a warning if %s directive is used in certain CF/NS formatting APIs, to assist user in deprecating use of such %s in these APIs. rdar://18182443 llvm-svn: 217467
2014-09-10 07:10:54 +08:00
if (Warn)
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
Parse 'technical term' format specifier. Objective-C format strings now support modifier flags that can be attached to a '@' conversion. Currently the only one supported, as of iOS 9 and OS X 10.11, is the new "technical term", denoted by the flag "tt", for example: %[tt]@ instead of just: %@ The 'tt' stands for "technical term", which is used by the string-localization facilities on Darwin to add the appropriate spacing or quotation depending the language locale. Implements <rdar://problem/20374720>. llvm-svn: 241243
2015-07-02 13:39:16 +08:00
// Look for the Objective-C modifier flags, if any.
// We parse these here, even if they don't apply to
// the conversion specifier, and then emit an error
// later if the conversion specifier isn't '@'. This
// enables better recovery, and we don't know if
// these flags are applicable until later.
const char *ObjCModifierFlagsStart = nullptr,
*ObjCModifierFlagsEnd = nullptr;
if (*I == '[') {
ObjCModifierFlagsStart = I;
++I;
auto flagStart = I;
for (;; ++I) {
ObjCModifierFlagsEnd = I;
if (I == E) {
if (Warn)
H.HandleIncompleteSpecifier(Start, E - Start);
return true;
}
// Did we find the closing ']'?
if (*I == ']') {
if (ParseObjCFlags(H, FS, flagStart, I, Warn))
return true;
++I;
break;
}
// There are no separators defined yet for multiple
// Objective-C modifier flags. When those are
// defined, this is the place to check.
}
}
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;
Analysis: Add support for MS specific printf format specifiers Summary: Adds support for %I, %I32 and %I64. Reviewers: hans, jordan_rose, rnk, majnemer Reviewed By: majnemer CC: cfe-commits, cdavis5x Differential Revision: http://llvm-reviews.chandlerc.com/D1456 llvm-svn: 188937
2013-08-22 05:54:46 +08:00
case 'p': k = ConversionSpecifier::pArg; break;
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 support for __builtin_os_log_format[_buffer_size] This reverts commit r285007 and reapply r284990, with a fix for the opencl test that I broke. Original commit message follows: These new builtins support a mechanism for logging OS events, using a printf-like format string to specify the layout of data in a buffer. The _buffer_size version of the builtin can be used to determine the size of the buffer to allocate to hold the data, and then __builtin_os_log_format can write data into that buffer. This implements format checking to report mismatches between the format string and the data arguments. Most of this code was written by Chris Willmore. Differential Revision: https://reviews.llvm.org/D25888 llvm-svn: 285019
2016-10-25 04:39:34 +08:00
// Apple extension for os_log
case 'P':
k = ConversionSpecifier::PArg;
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;
Add support for analyzing FreeBSD kernel printf extensions. This adds a new __freebsd_kprintf__ format string type, which enables checking when used in __attribute__((format(...))) attributes. It can check the FreeBSD kernel specific %b, %D, %r and %y specifiers, using existing diagnostic messages. Also adds test cases for all these specifiers. Differential Revision: http://reviews.llvm.org/D7154 llvm-svn: 229921
2015-02-20 06:32:33 +08:00
// FreeBSD kernel specific.
case 'b':
if (isFreeBSDKPrintf)
k = ConversionSpecifier::FreeBSDbArg; // int followed by char *
break;
case 'r':
if (isFreeBSDKPrintf)
k = ConversionSpecifier::FreeBSDrArg; // int
break;
case 'y':
if (isFreeBSDKPrintf)
k = ConversionSpecifier::FreeBSDyArg; // int
break;
MS format strings: parse the 'Z' printf conversion specifier (PR20808) llvm-svn: 217326
2014-09-07 11:03:51 +08:00
// Apple-specific.
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 'D':
Add support for analyzing FreeBSD kernel printf extensions. This adds a new __freebsd_kprintf__ format string type, which enables checking when used in __attribute__((format(...))) attributes. It can check the FreeBSD kernel specific %b, %D, %r and %y specifiers, using existing diagnostic messages. Also adds test cases for all these specifiers. Differential Revision: http://reviews.llvm.org/D7154 llvm-svn: 229921
2015-02-20 06:32:33 +08:00
if (isFreeBSDKPrintf)
k = ConversionSpecifier::FreeBSDDArg; // void * followed by char *
else if (Target.getTriple().isOSDarwin())
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
k = ConversionSpecifier::DArg;
break;
case 'O':
if (Target.getTriple().isOSDarwin())
k = ConversionSpecifier::OArg;
break;
case 'U':
if (Target.getTriple().isOSDarwin())
k = ConversionSpecifier::UArg;
break;
MS format strings: parse the 'Z' printf conversion specifier (PR20808) llvm-svn: 217326
2014-09-07 11:03:51 +08:00
// MS specific.
case 'Z':
if (Target.getTriple().isOSMSVCRT())
k = ConversionSpecifier::ZArg;
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
}
Parse 'technical term' format specifier. Objective-C format strings now support modifier flags that can be attached to a '@' conversion. Currently the only one supported, as of iOS 9 and OS X 10.11, is the new "technical term", denoted by the flag "tt", for example: %[tt]@ instead of just: %@ The 'tt' stands for "technical term", which is used by the string-localization facilities on Darwin to add the appropriate spacing or quotation depending the language locale. Implements <rdar://problem/20374720>. llvm-svn: 241243
2015-07-02 13:39:16 +08:00
// Check to see if we used the Objective-C modifier flags with
// a conversion specifier other than '@'.
if (k != ConversionSpecifier::ObjCObjArg &&
k != ConversionSpecifier::InvalidSpecifier &&
ObjCModifierFlagsStart) {
H.HandleObjCFlagsWithNonObjCConversion(ObjCModifierFlagsStart,
ObjCModifierFlagsEnd + 1,
conversionPosition);
return true;
}
Add support for __builtin_os_log_format[_buffer_size] This reverts commit r285007 and reapply r284990, with a fix for the opencl test that I broke. Original commit message follows: These new builtins support a mechanism for logging OS events, using a printf-like format string to specify the layout of data in a buffer. The _buffer_size version of the builtin can be used to determine the size of the buffer to allocate to hold the data, and then __builtin_os_log_format can write data into that buffer. This implements format checking to report mismatches between the format string and the data arguments. Most of this code was written by Chris Willmore. Differential Revision: https://reviews.llvm.org/D25888 llvm-svn: 285019
2016-10-25 04:39:34 +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++);
Add support for analyzing FreeBSD kernel printf extensions. This adds a new __freebsd_kprintf__ format string type, which enables checking when used in __attribute__((format(...))) attributes. It can check the FreeBSD kernel specific %b, %D, %r and %y specifiers, using existing diagnostic messages. Also adds test cases for all these specifiers. Differential Revision: http://reviews.llvm.org/D7154 llvm-svn: 229921
2015-02-20 06:32:33 +08:00
// FreeBSD kernel specific.
if (k == ConversionSpecifier::FreeBSDbArg ||
k == ConversionSpecifier::FreeBSDDArg)
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) {
[Sema] Handle UTF-8 invalid format string specifiers Improve invalid format string specifier handling by printing out invalid specifiers characters with \x, \u and \U. Previously clang would print gargabe whenever the character is unprintable. Example, before: NSLog(@"%\u25B9"); => warning: invalid conversion specifier ' [-Wformat-invalid-specifier] after: NSLog(@"%\u25B9"); => warning: invalid conversion specifier '\u25b9' [-Wformat-invalid-specifier] Differential Revision: http://reviews.llvm.org/D18296 rdar://problem/24672159 llvm-svn: 264752
2016-03-30 01:35:02 +08:00
unsigned Len = I - Start;
if (ParseUTF8InvalidSpecifier(Start, E, Len)) {
CS.setEndScanList(Start + Len);
FS.setConversionSpecifier(CS);
}
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.
[Sema] Handle UTF-8 invalid format string specifiers Improve invalid format string specifier handling by printing out invalid specifiers characters with \x, \u and \U. Previously clang would print gargabe whenever the character is unprintable. Example, before: NSLog(@"%\u25B9"); => warning: invalid conversion specifier ' [-Wformat-invalid-specifier] after: NSLog(@"%\u25B9"); => warning: invalid conversion specifier '\u25b9' [-Wformat-invalid-specifier] Differential Revision: http://reviews.llvm.org/D18296 rdar://problem/24672159 llvm-svn: 264752
2016-03-30 01:35:02 +08:00
return !H.HandleInvalidPrintfConversionSpecifier(FS, Start, Len);
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,
Add support for analyzing FreeBSD kernel printf extensions. This adds a new __freebsd_kprintf__ format string type, which enables checking when used in __attribute__((format(...))) attributes. It can check the FreeBSD kernel specific %b, %D, %r and %y specifiers, using existing diagnostic messages. Also adds test cases for all these specifiers. Differential Revision: http://reviews.llvm.org/D7154 llvm-svn: 229921
2015-02-20 06:32:33 +08:00
const TargetInfo &Target,
bool isFreeBSDKPrintf) {
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,
Add support for analyzing FreeBSD kernel printf extensions. This adds a new __freebsd_kprintf__ format string type, which enables checking when used in __attribute__((format(...))) attributes. It can check the FreeBSD kernel specific %b, %D, %r and %y specifiers, using existing diagnostic messages. Also adds test cases for all these specifiers. Differential Revision: http://reviews.llvm.org/D7154 llvm-svn: 229921
2015-02-20 06:32:33 +08:00
LO, Target, true,
isFreeBSDKPrintf);
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;
}
Objective-C. Under a special flag, -Wcstring-format-directive, off by default, issue a warning if %s directive is used in certain CF/NS formatting APIs, to assist user in deprecating use of such %s in these APIs. rdar://18182443 llvm-svn: 217467
2014-09-10 07:10:54 +08:00
bool clang::analyze_format_string::ParseFormatStringHasSArg(const char *I,
const char *E,
const LangOptions &LO,
const TargetInfo &Target) {
unsigned argIndex = 0;
// Keep looking for a %s format specifier until we have exhausted the string.
FormatStringHandler H;
while (I != E) {
const PrintfSpecifierResult &FSR = ParsePrintfSpecifier(H, I, E, argIndex,
Add support for analyzing FreeBSD kernel printf extensions. This adds a new __freebsd_kprintf__ format string type, which enables checking when used in __attribute__((format(...))) attributes. It can check the FreeBSD kernel specific %b, %D, %r and %y specifiers, using existing diagnostic messages. Also adds test cases for all these specifiers. Differential Revision: http://reviews.llvm.org/D7154 llvm-svn: 229921
2015-02-20 06:32:33 +08:00
LO, Target, false,
false);
Objective-C. Under a special flag, -Wcstring-format-directive, off by default, issue a warning if %s directive is used in certain CF/NS formatting APIs, to assist user in deprecating use of such %s in these APIs. rdar://18182443 llvm-svn: 217467
2014-09-10 07:10:54 +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())
return false;
// Did we exhaust the string or encounter an error that
// we can recover from?
if (!FSR.hasValue())
continue;
const analyze_printf::PrintfSpecifier &FS = FSR.getValue();
// Return true if this a %s format specifier.
if (FS.getConversionSpecifier().getKind() == ConversionSpecifier::Kind::sArg)
return true;
}
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()) {
MS format strings: allow the 'h' length modifier with C, C, s and S (PR20808) llvm-svn: 217196
2014-09-05 05:39:52 +08:00
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:
MS format strings: support the 'w' length modifier (PR20808) llvm-svn: 217195
2014-09-05 05:39:46 +08:00
case LengthModifier::AsWide:
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");
MS format strings: allow the 'h' length modifier with C, C, s and S (PR20808) llvm-svn: 217196
2014-09-05 05:39:52 +08:00
case LengthModifier::AsShort:
if (Ctx.getTargetInfo().getTriple().isOSMSVCRT())
return Ctx.IntTy;
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;
Analysis: Add support for MS specific printf format specifiers Summary: Adds support for %I, %I32 and %I64. Reviewers: hans, jordan_rose, rnk, majnemer Reviewed By: majnemer CC: cfe-commits, cdavis5x Differential Revision: http://llvm-reviews.chandlerc.com/D1456 llvm-svn: 188937
2013-08-22 05:54:46 +08:00
case LengthModifier::None:
return Ctx.IntTy;
case LengthModifier::AsInt32:
return ArgType(Ctx.IntTy, "__int32");
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;
Analysis: Add support for MS specific printf format specifiers Summary: Adds support for %I, %I32 and %I64. Reviewers: hans, jordan_rose, rnk, majnemer Reviewed By: majnemer CC: cfe-commits, cdavis5x Differential Revision: http://llvm-reviews.chandlerc.com/D1456 llvm-svn: 188937
2013-08-22 05:54:46 +08:00
case LengthModifier::AsInt64:
return ArgType(Ctx.LongLongTy, "__int64");
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();
Analysis: Add support for MS specific printf format specifiers Summary: Adds support for %I, %I32 and %I64. Reviewers: hans, jordan_rose, rnk, majnemer Reviewed By: majnemer CC: cfe-commits, cdavis5x Differential Revision: http://llvm-reviews.chandlerc.com/D1456 llvm-svn: 188937
2013-08-22 05:54:46 +08:00
case LengthModifier::AsInt3264:
Analysis: Make %I in printf more reasonable, add more tests llvm-svn: 188992
2013-08-22 15:53:21 +08:00
return Ctx.getTargetInfo().getTriple().isArch64Bit()
? ArgType(Ctx.LongLongTy, "__int64")
: ArgType(Ctx.IntTy, "__int32");
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:
MS format strings: support the 'w' length modifier (PR20808) llvm-svn: 217195
2014-09-05 05:39:46 +08:00
case LengthModifier::AsWide:
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;
Analysis: Add support for MS specific printf format specifiers Summary: Adds support for %I, %I32 and %I64. Reviewers: hans, jordan_rose, rnk, majnemer Reviewed By: majnemer CC: cfe-commits, cdavis5x Differential Revision: http://llvm-reviews.chandlerc.com/D1456 llvm-svn: 188937
2013-08-22 05:54:46 +08:00
case LengthModifier::None:
return Ctx.UnsignedIntTy;
case LengthModifier::AsInt32:
return ArgType(Ctx.UnsignedIntTy, "unsigned __int32");
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::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;
Analysis: Add support for MS specific printf format specifiers Summary: Adds support for %I, %I32 and %I64. Reviewers: hans, jordan_rose, rnk, majnemer Reviewed By: majnemer CC: cfe-commits, cdavis5x Differential Revision: http://llvm-reviews.chandlerc.com/D1456 llvm-svn: 188937
2013-08-22 05:54:46 +08:00
case LengthModifier::AsInt64:
return ArgType(Ctx.UnsignedLongLongTy, "unsigned __int64");
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");
Analysis: Add support for MS specific printf format specifiers Summary: Adds support for %I, %I32 and %I64. Reviewers: hans, jordan_rose, rnk, majnemer Reviewed By: majnemer CC: cfe-commits, cdavis5x Differential Revision: http://llvm-reviews.chandlerc.com/D1456 llvm-svn: 188937
2013-08-22 05:54:46 +08:00
case LengthModifier::AsInt3264:
return Ctx.getTargetInfo().getTriple().isArch64Bit()
Analysis: Make %I in printf more reasonable, add more tests llvm-svn: 188992
2013-08-22 15:53:21 +08:00
? ArgType(Ctx.UnsignedLongLongTy, "unsigned __int64")
: ArgType(Ctx.UnsignedIntTy, "unsigned __int32");
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:
MS format strings: support the 'w' length modifier (PR20808) llvm-svn: 217195
2014-09-05 05:39:46 +08:00
case LengthModifier::AsWide:
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:
Analysis: Add support for MS specific printf format specifiers Summary: Adds support for %I, %I32 and %I64. Reviewers: hans, jordan_rose, rnk, majnemer Reviewed By: majnemer CC: cfe-commits, cdavis5x Differential Revision: http://llvm-reviews.chandlerc.com/D1456 llvm-svn: 188937
2013-08-22 05:54:46 +08:00
case LengthModifier::AsInt32:
case LengthModifier::AsInt3264:
case LengthModifier::AsInt64:
MS format strings: support the 'w' length modifier (PR20808) llvm-svn: 217195
2014-09-05 05:39:46 +08:00
case LengthModifier::AsWide:
Properly check length modfiers for %n in format strings. llvm-svn: 161408
2012-08-07 17:13:19 +08:00
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
}
MS format strings: support the 'w' length modifier (PR20808) llvm-svn: 217195
2014-09-05 05:39:46 +08:00
if (LM.getKind() == LengthModifier::AsWide)
return ArgType(ArgType::WCStrTy, "wchar_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::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 *");
MS format strings: allow the 'h' length modifier with C, C, s and S (PR20808) llvm-svn: 217196
2014-09-05 05:39:52 +08:00
if (Ctx.getTargetInfo().getTriple().isOSMSVCRT() &&
LM.getKind() == LengthModifier::AsShort)
return ArgType::CStrTy;
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");
MS format strings: allow the 'h' length modifier with C, C, s and S (PR20808) llvm-svn: 217196
2014-09-05 05:39:52 +08:00
if (Ctx.getTargetInfo().getTriple().isOSMSVCRT() &&
LM.getKind() == LengthModifier::AsShort)
return Ctx.IntTy;
Add support for __wchar_t in -fms-extensions mode. MSVC provides __wchar_t. This is the same as the built-in wchar_t type from C++, but it is also available with -fno-wchar and in C. The commit changes ASTContext to have two different types for this: - WCharTy is the built-in type used for wchar_t in C++ and __wchar_t. - WideCharTy is the type of a wide character literal. In C++ this is the same as WCharTy, and in C it is an integer type compatible with the type in <stddef.h>. This fixes PR15815. llvm-svn: 181587
2013-05-10 18:08:40 +08:00
return ArgType(Ctx.WideCharTy, "wchar_t");
Rename 'VoidPtrArg' to 'pArg' in printf/scanf checking. llvm-svn: 108899
2010-07-21 04:04:04 +08:00
case ConversionSpecifier::pArg:
Add support for __builtin_os_log_format[_buffer_size] This reverts commit r285007 and reapply r284990, with a fix for the opencl test that I broke. Original commit message follows: These new builtins support a mechanism for logging OS events, using a printf-like format string to specify the layout of data in a buffer. The _buffer_size version of the builtin can be used to determine the size of the buffer to allocate to hold the data, and then __builtin_os_log_format can write data into that buffer. This implements format checking to report mismatches between the format string and the data arguments. Most of this code was written by Chris Willmore. Differential Revision: https://reviews.llvm.org/D25888 llvm-svn: 285019
2016-10-25 04:39:34 +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:
Enable support for __float128 in Clang and enable it on pertinent platforms This patch corresponds to reviews: http://reviews.llvm.org/D15120 http://reviews.llvm.org/D19125 It adds support for the __float128 keyword, literals and target feature to enable it. Based on the latter of the two aforementioned reviews, this feature is enabled on Linux on i386/X86 as well as SystemZ. This is also the second attempt in commiting this feature. The first attempt did not enable it on required platforms which caused failures when compiling type_traits with -std=gnu++11. If you see failures with compiling this header on your platform after this commit, it is likely that your platform needs to have this feature enabled. llvm-svn: 268898
2016-05-09 16:52:33 +08:00
case BuiltinType::Float128:
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;
[OpenCL] Complete image types support. I. Current implementation of images is not conformant to spec in the following points: 1. It makes no distinction with respect to access qualifiers and therefore allows to use images with different access type interchangeably. The following code would compile just fine: void write_image(write_only image2d_t img); kernel void foo(read_only image2d_t img) { write_image(img); } // Accepted code which is disallowed according to s6.13.14. 2. It discards access qualifier on generated code, which leads to generated code for the above example: call void @write_image(%opencl.image2d_t* %img); In OpenCL2.0 however we can have different calls into write_image with read_only and wite_only images. Also generally following compiler steps have no easy way to take different path depending on the image access: linking to the right implementation of image types, performing IR opts and backend codegen differently. 3. Image types are language keywords and can't be redeclared s6.1.9, which can happen currently as they are just typedef names. 4. Default access qualifier read_only is to be added if not provided explicitly. II. This patch corrects the above points as follows: 1. All images are encapsulated into a separate .def file that is inserted in different points where image handling is required. This avoid a lot of code repetition as all images are handled the same way in the code with no distinction of their exact type. 2. The Cartesian product of image types and image access qualifiers is added to the builtin types. This simplifies a lot handling of access type mismatch as no operations are allowed by default on distinct Builtin types. Also spec intended access qualifier as special type qualifier that are combined with an image type to form a distinct type (see statement above - images can't be created w/o access qualifiers). 3. Improves testing of images in Clang. Author: Anastasia Stulova Reviewers: bader, mgrang. Subscribers: pxli168, pekka.jaaskelainen, yaxunl. Differential Revision: http://reviews.llvm.org/D17821 llvm-svn: 265783
2016-04-08 21:40:33 +08:00
#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
case BuiltinType::Id:
[OpenCL] Move OpenCLImageTypes.def from clangAST to clangBasic library. Putting OpenCLImageTypes.def to clangAST library violates layering requirement: "It's not OK for a Basic/ header to include an AST/ header". This fixes the modules build. Differential revision: http://reviews.llvm.org/D18954 Reviewers: Richard Smith, Vassil Vassilev. llvm-svn: 266180
2016-04-13 16:33:41 +08:00
#include "clang/Basic/OpenCLImageTypes.def"
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:
Add support for analyzing FreeBSD kernel printf extensions. This adds a new __freebsd_kprintf__ format string type, which enables checking when used in __attribute__((format(...))) attributes. It can check the FreeBSD kernel specific %b, %D, %r and %y specifiers, using existing diagnostic messages. Also adds test cases for all these specifiers. Differential Revision: http://reviews.llvm.org/D7154 llvm-svn: 229921
2015-02-20 06:32:33 +08:00
case ConversionSpecifier::FreeBSDrArg:
case ConversionSpecifier::FreeBSDyArg:
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::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:
Add support for analyzing FreeBSD kernel printf extensions. This adds a new __freebsd_kprintf__ format string type, which enables checking when used in __attribute__((format(...))) attributes. It can check the FreeBSD kernel specific %b, %D, %r and %y specifiers, using existing diagnostic messages. Also adds test cases for all these specifiers. Differential Revision: http://reviews.llvm.org/D7154 llvm-svn: 229921
2015-02-20 06:32:33 +08:00
case ConversionSpecifier::FreeBSDrArg:
case ConversionSpecifier::FreeBSDyArg:
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::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:
Add support for analyzing FreeBSD kernel printf extensions. This adds a new __freebsd_kprintf__ format string type, which enables checking when used in __attribute__((format(...))) attributes. It can check the FreeBSD kernel specific %b, %D, %r and %y specifiers, using existing diagnostic messages. Also adds test cases for all these specifiers. Differential Revision: http://reviews.llvm.org/D7154 llvm-svn: 229921
2015-02-20 06:32:33 +08:00
case ConversionSpecifier::FreeBSDrArg:
case ConversionSpecifier::FreeBSDyArg:
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::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:
Add support for analyzing FreeBSD kernel printf extensions. This adds a new __freebsd_kprintf__ format string type, which enables checking when used in __attribute__((format(...))) attributes. It can check the FreeBSD kernel specific %b, %D, %r and %y specifiers, using existing diagnostic messages. Also adds test cases for all these specifiers. Differential Revision: http://reviews.llvm.org/D7154 llvm-svn: 229921
2015-02-20 06:32:33 +08:00
case ConversionSpecifier::FreeBSDrArg:
case ConversionSpecifier::FreeBSDyArg:
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::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;
Add support for __builtin_os_log_format[_buffer_size] This reverts commit r285007 and reapply r284990, with a fix for the opencl test that I broke. Original commit message follows: These new builtins support a mechanism for logging OS events, using a printf-like format string to specify the layout of data in a buffer. The _buffer_size version of the builtin can be used to determine the size of the buffer to allocate to hold the data, and then __builtin_os_log_format can write data into that buffer. This implements format checking to report mismatches between the format string and the data arguments. Most of this code was written by Chris Willmore. Differential Revision: https://reviews.llvm.org/D25888 llvm-svn: 285019
2016-10-25 04:39:34 +08:00
// Precision is only valid with the diouxXaAeEfFgGsP 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::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:
Add support for analyzing FreeBSD kernel printf extensions. This adds a new __freebsd_kprintf__ format string type, which enables checking when used in __attribute__((format(...))) attributes. It can check the FreeBSD kernel specific %b, %D, %r and %y specifiers, using existing diagnostic messages. Also adds test cases for all these specifiers. Differential Revision: http://reviews.llvm.org/D7154 llvm-svn: 229921
2015-02-20 06:32:33 +08:00
case ConversionSpecifier::FreeBSDrArg:
case ConversionSpecifier::FreeBSDyArg:
Add support for __builtin_os_log_format[_buffer_size] This reverts commit r285007 and reapply r284990, with a fix for the opencl test that I broke. Original commit message follows: These new builtins support a mechanism for logging OS events, using a printf-like format string to specify the layout of data in a buffer. The _buffer_size version of the builtin can be used to determine the size of the buffer to allocate to hold the data, and then __builtin_os_log_format can write data into that buffer. This implements format checking to report mismatches between the format string and the data arguments. Most of this code was written by Chris Willmore. Differential Revision: https://reviews.llvm.org/D25888 llvm-svn: 285019
2016-10-25 04:39:34 +08:00
case ConversionSpecifier::PArg:
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;
}
}