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/FormatString.cpp

951 lines
28 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
// FormatString.cpp - Common stuff for handling printf/scanf formats -*- C++ -*-
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Shared details for processing format strings of printf and scanf
// (and friends).
//
//===----------------------------------------------------------------------===//
#include "FormatStringParsing.h"
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
#include "clang/Basic/LangOptions.h"
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
#include "clang/Basic/TargetInfo.h"
[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
#include "llvm/Support/ConvertUTF.h"
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
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::FormatSpecifier;
using clang::analyze_format_string::LengthModifier;
using clang::analyze_format_string::OptionalAmount;
using clang::analyze_format_string::PositionContext;
Move 'hasValidLengthModifier' from PrintfFormatSpecifier to FormatSpecifier. llvm-svn: 108906
2010-07-21 04:04:42 +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 namespace clang;
// Key function to FormatStringHandler.
Roll-back r250822. Summary: It breaks the build for the ASTMatchers Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D13893 llvm-svn: 250827
2015-10-20 21:23:58 +08:00
FormatStringHandler::~FormatStringHandler() {}
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
//===----------------------------------------------------------------------===//
// Functions for parsing format strings components in both printf and
// scanf format strings.
//===----------------------------------------------------------------------===//
OptionalAmount
clang::analyze_format_string::ParseAmount(const char *&Beg, const char *E) {
const char *I = Beg;
UpdateOnReturn <const char*> UpdateBeg(Beg, I);
unsigned accumulator = 0;
bool hasDigits = false;
for ( ; I != E; ++I) {
char c = *I;
if (c >= '0' && c <= '9') {
hasDigits = true;
accumulator = (accumulator * 10) + (c - '0');
continue;
}
if (hasDigits)
return OptionalAmount(OptionalAmount::Constant, accumulator, Beg, I - Beg,
false);
break;
}
return OptionalAmount();
}
OptionalAmount
clang::analyze_format_string::ParseNonPositionAmount(const char *&Beg,
const char *E,
unsigned &argIndex) {
if (*Beg == '*') {
++Beg;
return OptionalAmount(OptionalAmount::Arg, argIndex++, Beg, 0, false);
}
return ParseAmount(Beg, E);
}
OptionalAmount
clang::analyze_format_string::ParsePositionAmount(FormatStringHandler &H,
const char *Start,
const char *&Beg,
const char *E,
PositionContext p) {
if (*Beg == '*') {
const char *I = Beg + 1;
const OptionalAmount &Amt = ParseAmount(I, E);
if (Amt.getHowSpecified() == OptionalAmount::NotSpecified) {
H.HandleInvalidPosition(Beg, I - Beg, p);
return OptionalAmount(false);
}
if (I == E) {
// No more characters left?
H.HandleIncompleteSpecifier(Start, E - Start);
return OptionalAmount(false);
}
assert(Amt.getHowSpecified() == OptionalAmount::Constant);
if (*I == '$') {
// Handle positional arguments
// Special case: '*0$', since this is an easy mistake.
if (Amt.getConstantAmount() == 0) {
H.HandleZeroPosition(Beg, I - Beg + 1);
return OptionalAmount(false);
}
const char *Tmp = Beg;
Beg = ++I;
return OptionalAmount(OptionalAmount::Arg, Amt.getConstantAmount() - 1,
Tmp, 0, true);
}
H.HandleInvalidPosition(Beg, I - Beg, p);
return OptionalAmount(false);
}
return ParseAmount(Beg, E);
}
bool
clang::analyze_format_string::ParseFieldWidth(FormatStringHandler &H,
FormatSpecifier &CS,
const char *Start,
const char *&Beg, const char *E,
unsigned *argIndex) {
// FIXME: Support negative field widths.
if (argIndex) {
CS.setFieldWidth(ParseNonPositionAmount(Beg, E, *argIndex));
}
else {
const OptionalAmount Amt =
ParsePositionAmount(H, Start, Beg, E,
analyze_format_string::FieldWidthPos);
if (Amt.isInvalid())
return true;
CS.setFieldWidth(Amt);
}
return false;
}
bool
clang::analyze_format_string::ParseArgPosition(FormatStringHandler &H,
FormatSpecifier &FS,
const char *Start,
const char *&Beg,
const char *E) {
const char *I = Beg;
const OptionalAmount &Amt = ParseAmount(I, E);
if (I == E) {
// No more characters left?
H.HandleIncompleteSpecifier(Start, E - Start);
return true;
}
if (Amt.getHowSpecified() == OptionalAmount::Constant && *(I++) == '$') {
-Wformat-non-iso: warn about positional arguments (pr12017) This renames the -Wformat-non-standard flag to -Wformat-non-iso, rewords the current warnings a bit (pointing out that a format string is not supported by ISO C rather than being "non standard"), and adds a warning about positional arguments. llvm-svn: 152403
2012-03-09 18:10:54 +08:00
// Warn that positional arguments are non-standard.
H.HandlePosition(Start, I - Start);
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
// Special case: '%0$', since this is an easy mistake.
if (Amt.getConstantAmount() == 0) {
H.HandleZeroPosition(Start, I - Start);
return true;
}
FS.setArgIndex(Amt.getConstantAmount() - 1);
FS.setUsesPositionalArg();
// Update the caller's pointer if we decided to consume
// these characters.
Beg = I;
return false;
}
return false;
}
bool
clang::analyze_format_string::ParseLengthModifier(FormatSpecifier &FS,
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,
const LangOptions &LO,
bool IsScanf) {
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
LengthModifier::Kind lmKind = LengthModifier::None;
const char *lmPosition = I;
switch (*I) {
default:
return false;
case 'h':
++I;
Remove use of builtin comma operator. Cleanup for upcoming Clang warning -Wcomma. No functionality change intended. llvm-svn: 261271
2016-02-19 06:34:54 +08:00
if (I != E && *I == 'h') {
++I;
lmKind = LengthModifier::AsChar;
} else {
lmKind = LengthModifier::AsShort;
}
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
break;
case 'l':
++I;
Remove use of builtin comma operator. Cleanup for upcoming Clang warning -Wcomma. No functionality change intended. llvm-svn: 261271
2016-02-19 06:34:54 +08:00
if (I != E && *I == 'l') {
++I;
lmKind = LengthModifier::AsLongLong;
} else {
lmKind = LengthModifier::AsLong;
}
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
break;
case 'j': lmKind = LengthModifier::AsIntMax; ++I; break;
case 'z': lmKind = LengthModifier::AsSizeT; ++I; break;
case 't': lmKind = LengthModifier::AsPtrDiff; ++I; break;
case 'L': lmKind = LengthModifier::AsLongDouble; ++I; break;
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 'q': lmKind = LengthModifier::AsQuad; ++I; break;
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 'a':
s/CPlusPlus0x/CPlusPlus11/g llvm-svn: 171367
2013-01-02 19:42:31 +08:00
if (IsScanf && !LO.C99 && !LO.CPlusPlus11) {
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
// For scanf in C90, look at the next character to see if this should
// be parsed as the GNU extension 'a' length modifier. If not, this
// will be parsed as a conversion specifier.
++I;
if (I != E && (*I == 's' || *I == 'S' || *I == '[')) {
lmKind = LengthModifier::AsAllocate;
break;
}
--I;
}
return false;
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 'm':
if (IsScanf) {
lmKind = LengthModifier::AsMAllocate;
++I;
break;
}
return false;
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
// printf: AsInt64, AsInt32, AsInt3264
// scanf: AsInt64
case 'I':
if (I + 1 != E && I + 2 != E) {
if (I[1] == '6' && I[2] == '4') {
I += 3;
lmKind = LengthModifier::AsInt64;
break;
}
if (IsScanf)
return false;
if (I[1] == '3' && I[2] == '2') {
I += 3;
lmKind = LengthModifier::AsInt32;
break;
}
}
++I;
lmKind = LengthModifier::AsInt3264;
break;
MS format strings: support the 'w' length modifier (PR20808) llvm-svn: 217195
2014-09-05 05:39:46 +08:00
case 'w':
lmKind = LengthModifier::AsWide; ++I; break;
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
}
LengthModifier lm(lmPosition, lmKind);
FS.setLengthModifier(lm);
return true;
}
[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
bool clang::analyze_format_string::ParseUTF8InvalidSpecifier(
const char *SpecifierBegin, const char *FmtStrEnd, unsigned &Len) {
if (SpecifierBegin + 1 >= FmtStrEnd)
return false;
Move UTF functions into namespace llvm. Summary: This lets people link against LLVM and their own version of the UTF library. I determined this only affects llvm, clang, lld, and lldb by running $ git grep -wl 'UTF[0-9]\+\|\bConvertUTF\bisLegalUTF\|getNumBytesFor' | cut -f 1 -d '/' | sort | uniq clang lld lldb llvm Tested with ninja lldb ninja check-clang check-llvm check-lld (ninja check-lldb doesn't complete for me with or without this patch.) Reviewers: rnk Subscribers: klimek, beanz, mgorny, llvm-commits Differential Revision: https://reviews.llvm.org/D24996 llvm-svn: 282822
2016-09-30 08:38:45 +08:00
const llvm::UTF8 *SB =
reinterpret_cast<const llvm::UTF8 *>(SpecifierBegin + 1);
const llvm::UTF8 *SE = reinterpret_cast<const llvm::UTF8 *>(FmtStrEnd);
[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
const char FirstByte = *SB;
// If the invalid specifier is a multibyte UTF-8 string, return the
// total length accordingly so that the conversion specifier can be
// properly updated to reflect a complete UTF-8 specifier.
Move UTF functions into namespace llvm. Summary: This lets people link against LLVM and their own version of the UTF library. I determined this only affects llvm, clang, lld, and lldb by running $ git grep -wl 'UTF[0-9]\+\|\bConvertUTF\bisLegalUTF\|getNumBytesFor' | cut -f 1 -d '/' | sort | uniq clang lld lldb llvm Tested with ninja lldb ninja check-clang check-llvm check-lld (ninja check-lldb doesn't complete for me with or without this patch.) Reviewers: rnk Subscribers: klimek, beanz, mgorny, llvm-commits Differential Revision: https://reviews.llvm.org/D24996 llvm-svn: 282822
2016-09-30 08:38:45 +08:00
unsigned NumBytes = llvm::getNumBytesForUTF8(FirstByte);
[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
if (NumBytes == 1)
return false;
if (SB + NumBytes > SE)
return false;
Len = NumBytes + 1;
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
//===----------------------------------------------------------------------===//
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
// Methods on 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
//===----------------------------------------------------------------------===//
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
clang::analyze_format_string::ArgType::MatchKind
ArgType::matchesType(ASTContext &C, QualType argTy) const {
Remove ScanfArgType and bake that logic into ArgType. This is useful for example for %n in printf, which expects a pointer to int with the same logic for checking as %d would have in scanf. llvm-svn: 161407
2012-08-07 16:59:46 +08:00
if (Ptr) {
// It has to be a pointer.
const PointerType *PT = argTy->getAs<PointerType>();
if (!PT)
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
return NoMatch;
Remove ScanfArgType and bake that logic into ArgType. This is useful for example for %n in printf, which expects a pointer to int with the same logic for checking as %d would have in scanf. llvm-svn: 161407
2012-08-07 16:59:46 +08:00
// We cannot write through a const qualified pointer.
if (PT->getPointeeType().isConstQualified())
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
return NoMatch;
Remove ScanfArgType and bake that logic into ArgType. This is useful for example for %n in printf, which expects a pointer to int with the same logic for checking as %d would have in scanf. llvm-svn: 161407
2012-08-07 16:59:46 +08:00
argTy = PT->getPointeeType();
}
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
switch (K) {
case InvalidTy:
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
llvm_unreachable("ArgType must be valid");
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
case UnknownTy:
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
return Match;
Tweak printf format string parsing to accept 'hh' conversion specifier to accept any char, not just signed char. Fixes <rdar://problem/10303638>. llvm-svn: 142908
2011-10-25 12:20:41 +08:00
case AnyCharTy: {
[Sema] Don't crash on scanf on forward-declared enums. This is valid in GNU C, which allows pointers to incomplete enums. GCC just pretends that the underlying type is 'int' in those cases, follow that behavior. llvm-svn: 279374
2016-08-21 00:51:33 +08:00
if (const EnumType *ETy = argTy->getAs<EnumType>()) {
// If the enum is incomplete we know nothing about the underlying type.
// Assume that it's 'int'.
if (!ETy->getDecl()->isComplete())
return NoMatch;
Teach printf/scanf about enums with fixed underlying types. llvm-svn: 157961
2012-06-05 06:48:57 +08:00
argTy = ETy->getDecl()->getIntegerType();
[Sema] Don't crash on scanf on forward-declared enums. This is valid in GNU C, which allows pointers to incomplete enums. GCC just pretends that the underlying type is 'int' in those cases, follow that behavior. llvm-svn: 279374
2016-08-21 00:51:33 +08:00
}
Teach printf/scanf about enums with fixed underlying types. llvm-svn: 157961
2012-06-05 06:48:57 +08:00
Tweak printf format string parsing to accept 'hh' conversion specifier to accept any char, not just signed char. Fixes <rdar://problem/10303638>. llvm-svn: 142908
2011-10-25 12:20:41 +08:00
if (const BuiltinType *BT = argTy->getAs<BuiltinType>())
switch (BT->getKind()) {
default:
break;
case BuiltinType::Char_S:
case BuiltinType::SChar:
case BuiltinType::UChar:
case BuiltinType::Char_U:
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
return Match;
Tweak printf format string parsing to accept 'hh' conversion specifier to accept any char, not just signed char. Fixes <rdar://problem/10303638>. llvm-svn: 142908
2011-10-25 12:20:41 +08:00
}
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
return NoMatch;
Tweak printf format string parsing to accept 'hh' conversion specifier to accept any char, not just signed char. Fixes <rdar://problem/10303638>. llvm-svn: 142908
2011-10-25 12:20:41 +08:00
}
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +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
case SpecificTy: {
[Sema] Don't crash on scanf on forward-declared enums. This is valid in GNU C, which allows pointers to incomplete enums. GCC just pretends that the underlying type is 'int' in those cases, follow that behavior. llvm-svn: 279374
2016-08-21 00:51:33 +08:00
if (const EnumType *ETy = argTy->getAs<EnumType>()) {
// If the enum is incomplete we know nothing about the underlying type.
// Assume that it's 'int'.
if (!ETy->getDecl()->isComplete())
argTy = C.IntTy;
else
argTy = ETy->getDecl()->getIntegerType();
}
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
argTy = C.getCanonicalType(argTy).getUnqualifiedType();
Teach printf/scanf about enums with fixed underlying types. llvm-svn: 157961
2012-06-05 06:48:57 +08:00
Revert r145697 and dependent patch r145702. It added a dependency from lib/Analysis to lib/Sema which is cyclical. llvm-svn: 145724
2011-12-03 07:21:43 +08:00
if (T == argTy)
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
return Match;
Re-relax conversion specifier checking for printf format strings and conversion specifiers. My recent change was a mistake. llvm-svn: 135048
2011-07-14 01:35:14 +08:00
// Check for "compatible types".
Revert r135147 and r135075. The consensus was that this wasn't the right thing to do. llvm-svn: 135152
2011-07-15 01:05:32 +08:00
if (const BuiltinType *BT = argTy->getAs<BuiltinType>())
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
switch (BT->getKind()) {
default:
break;
case BuiltinType::Char_S:
case BuiltinType::SChar:
Re-relax conversion specifier checking for printf format strings and conversion specifiers. My recent change was a mistake. llvm-svn: 135048
2011-07-14 01:35:14 +08:00
case BuiltinType::Char_U:
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
case BuiltinType::UChar:
return T == C.UnsignedCharTy || T == C.SignedCharTy ? Match
: NoMatch;
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
case BuiltinType::Short:
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
return T == C.UnsignedShortTy ? Match : NoMatch;
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
case BuiltinType::UShort:
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
return T == C.ShortTy ? Match : NoMatch;
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
case BuiltinType::Int:
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
return T == C.UnsignedIntTy ? Match : NoMatch;
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
case BuiltinType::UInt:
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
return T == C.IntTy ? Match : NoMatch;
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
case BuiltinType::Long:
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
return T == C.UnsignedLongTy ? Match : NoMatch;
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
case BuiltinType::ULong:
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
return T == C.LongTy ? Match : NoMatch;
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
case BuiltinType::LongLong:
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
return T == C.UnsignedLongLongTy ? Match : NoMatch;
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
case BuiltinType::ULongLong:
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
return T == C.LongLongTy ? Match : NoMatch;
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
}
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
return NoMatch;
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
}
case CStrTy: {
const PointerType *PT = argTy->getAs<PointerType>();
if (!PT)
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
return NoMatch;
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
QualType pointeeTy = PT->getPointeeType();
if (const BuiltinType *BT = pointeeTy->getAs<BuiltinType>())
switch (BT->getKind()) {
case BuiltinType::Void:
case BuiltinType::Char_U:
case BuiltinType::UChar:
case BuiltinType::Char_S:
case BuiltinType::SChar:
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
return Match;
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
default:
break;
}
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
return NoMatch;
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
}
case WCStrTy: {
const PointerType *PT = argTy->getAs<PointerType>();
if (!PT)
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
return NoMatch;
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
QualType pointeeTy =
C.getCanonicalType(PT->getPointeeType()).getUnqualifiedType();
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
return pointeeTy == C.getWideCharType() ? Match : NoMatch;
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
}
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +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
case WIntTy: {
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +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
QualType PromoArg =
argTy->isPromotableIntegerType()
? C.getPromotedIntegerType(argTy) : argTy;
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
Fix handling of wint_t - we can't assume wint_t is purely an integer promotion of wchar_t - they may differ in signedness. Teach ASTContext about WIntType, and have it taken from TargetInfo like WCharType. Should fix test/Sema/format-strings.c for ARM, with the exception of one subtest which will fail if wint_t and wchar_t are the same size and wint_t is signed, wchar_t is unsigned. There'll be a followup commit to fix that. Reviewed by Chandler and Hans at http://llvm.org/reviews/r/8 llvm-svn: 156165
2012-05-04 18:55:22 +08:00
QualType WInt = C.getCanonicalType(C.getWIntType()).getUnqualifiedType();
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
PromoArg = C.getCanonicalType(PromoArg).getUnqualifiedType();
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
Fix handling of wint_t - we can't assume wint_t is purely an integer promotion of wchar_t - they may differ in signedness. Teach ASTContext about WIntType, and have it taken from TargetInfo like WCharType. Should fix test/Sema/format-strings.c for ARM, with the exception of one subtest which will fail if wint_t and wchar_t are the same size and wint_t is signed, wchar_t is unsigned. There'll be a followup commit to fix that. Reviewed by Chandler and Hans at http://llvm.org/reviews/r/8 llvm-svn: 156165
2012-05-04 18:55:22 +08:00
// If the promoted argument is the corresponding signed type of the
// wint_t type, then it should match.
if (PromoArg->hasSignedIntegerRepresentation() &&
C.getCorrespondingUnsignedType(PromoArg) == WInt)
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
return Match;
Fix handling of wint_t - we can't assume wint_t is purely an integer promotion of wchar_t - they may differ in signedness. Teach ASTContext about WIntType, and have it taken from TargetInfo like WCharType. Should fix test/Sema/format-strings.c for ARM, with the exception of one subtest which will fail if wint_t and wchar_t are the same size and wint_t is signed, wchar_t is unsigned. There'll be a followup commit to fix that. Reviewed by Chandler and Hans at http://llvm.org/reviews/r/8 llvm-svn: 156165
2012-05-04 18:55:22 +08:00
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
return WInt == PromoArg ? Match : NoMatch;
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
}
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
case CPointerTy:
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
if (argTy->isVoidPointerType()) {
return Match;
} if (argTy->isPointerType() || argTy->isObjCObjectPointerType() ||
argTy->isBlockPointerType() || argTy->isNullPtrType()) {
return NoMatchPedantic;
} else {
return NoMatch;
}
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
Tweak format string checking to work with %@ and ObjC toll-free bridging. <rdar://problem/10814120> llvm-svn: 149907
2012-02-07 05:45:29 +08:00
case ObjCPointerTy: {
if (argTy->getAs<ObjCObjectPointerType>() ||
argTy->getAs<BlockPointerType>())
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
return Match;
Tweak format string checking to work with %@ and ObjC toll-free bridging. <rdar://problem/10814120> llvm-svn: 149907
2012-02-07 05:45:29 +08:00
// Handle implicit toll-free bridging.
if (const PointerType *PT = argTy->getAs<PointerType>()) {
// Things such as CFTypeRef are really just opaque pointers
// to C structs representing CF types that can often be bridged
// to Objective-C objects. Since the compiler doesn't know which
// structs can be toll-free bridged, we just accept them all.
QualType pointee = PT->getPointeeType();
if (pointee->getAsStructureType() || pointee->isVoidType())
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
return Match;
Tweak format string checking to work with %@ and ObjC toll-free bridging. <rdar://problem/10814120> llvm-svn: 149907
2012-02-07 05:45:29 +08:00
}
Add a format warning for "%p" with non-void* args GCC -pedantic produces a format warning when the "%p" specifier is used with arguments that are not void*. It's useful for portability to be able to catch such warnings with clang as well. The warning is off by default in both gcc and with this patch. This patch enables it either when extensions are disabled with -pedantic, or with the specific flag -Wformat-pedantic. The C99 and C11 specs do appear to require arguments corresponding to 'p' specifiers to be void*: "If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined." [7.19.6.1 p9], and of the 'p' format specifier "The argument shall be a pointer to void." [7.19.6.1 p8] Both printf and scanf format checking are covered. llvm-svn: 231211
2015-03-04 11:12:10 +08:00
return NoMatch;
Tweak format string checking to work with %@ and ObjC toll-free bridging. <rdar://problem/10814120> llvm-svn: 149907
2012-02-07 05:45:29 +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
}
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
llvm_unreachable("Invalid ArgType Kind!");
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
}
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
QualType ArgType::getRepresentativeType(ASTContext &C) const {
Remove ScanfArgType and bake that logic into ArgType. This is useful for example for %n in printf, which expects a pointer to int with the same logic for checking as %d would have in scanf. llvm-svn: 161407
2012-08-07 16:59:46 +08:00
QualType Res;
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
switch (K) {
case InvalidTy:
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
llvm_unreachable("No representative type for Invalid 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
case UnknownTy:
Remove ScanfArgType and bake that logic into ArgType. This is useful for example for %n in printf, which expects a pointer to int with the same logic for checking as %d would have in scanf. llvm-svn: 161407
2012-08-07 16:59:46 +08:00
llvm_unreachable("No representative type for Unknown ArgType");
Tweak printf format string parsing to accept 'hh' conversion specifier to accept any char, not just signed char. Fixes <rdar://problem/10303638>. llvm-svn: 142908
2011-10-25 12:20:41 +08:00
case AnyCharTy:
Remove ScanfArgType and bake that logic into ArgType. This is useful for example for %n in printf, which expects a pointer to int with the same logic for checking as %d would have in scanf. llvm-svn: 161407
2012-08-07 16:59:46 +08:00
Res = C.CharTy;
break;
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
case SpecificTy:
Remove ScanfArgType and bake that logic into ArgType. This is useful for example for %n in printf, which expects a pointer to int with the same logic for checking as %d would have in scanf. llvm-svn: 161407
2012-08-07 16:59:46 +08:00
Res = T;
break;
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
case CStrTy:
Remove ScanfArgType and bake that logic into ArgType. This is useful for example for %n in printf, which expects a pointer to int with the same logic for checking as %d would have in scanf. llvm-svn: 161407
2012-08-07 16:59:46 +08:00
Res = C.getPointerType(C.CharTy);
break;
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
case WCStrTy:
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
Res = C.getPointerType(C.getWideCharType());
Remove ScanfArgType and bake that logic into ArgType. This is useful for example for %n in printf, which expects a pointer to int with the same logic for checking as %d would have in scanf. llvm-svn: 161407
2012-08-07 16:59:46 +08:00
break;
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
case ObjCPointerTy:
Remove ScanfArgType and bake that logic into ArgType. This is useful for example for %n in printf, which expects a pointer to int with the same logic for checking as %d would have in scanf. llvm-svn: 161407
2012-08-07 16:59:46 +08:00
Res = C.ObjCBuiltinIdTy;
break;
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
case CPointerTy:
Remove ScanfArgType and bake that logic into ArgType. This is useful for example for %n in printf, which expects a pointer to int with the same logic for checking as %d would have in scanf. llvm-svn: 161407
2012-08-07 16:59:46 +08:00
Res = C.VoidPtrTy;
break;
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
case WIntTy: {
Remove ScanfArgType and bake that logic into ArgType. This is useful for example for %n in printf, which expects a pointer to int with the same logic for checking as %d would have in scanf. llvm-svn: 161407
2012-08-07 16:59:46 +08:00
Res = C.getWIntType();
break;
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
}
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
}
Remove ScanfArgType and bake that logic into ArgType. This is useful for example for %n in printf, which expects a pointer to int with the same logic for checking as %d would have in scanf. llvm-svn: 161407
2012-08-07 16:59:46 +08:00
if (Ptr)
Res = C.getPointerType(Res);
return Res;
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
}
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
std::string ArgType::getRepresentativeTypeName(ASTContext &C) const {
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
std::string S = getRepresentativeType(C).getAsString();
Remove ScanfArgType and bake that logic into ArgType. This is useful for example for %n in printf, which expects a pointer to int with the same logic for checking as %d would have in scanf. llvm-svn: 161407
2012-08-07 16:59:46 +08:00
std::string Alias;
if (Name) {
// Use a specific name for this type, e.g. "size_t".
Alias = Name;
if (Ptr) {
// If ArgType is actually a pointer to T, append an asterisk.
Alias += (Alias[Alias.size()-1] == '*') ? "*" : " *";
}
// If Alias is the same as the underlying type, e.g. wchar_t, then drop it.
if (S == Alias)
Alias.clear();
}
if (!Alias.empty())
return std::string("'") + Alias + "' (aka '" + S + "')";
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
return std::string("'") + S + "'";
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
}
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 OptionalAmount.
//===----------------------------------------------------------------------===//
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
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::OptionalAmount::getArgType(ASTContext &Ctx) const {
return Ctx.IntTy;
}
//===----------------------------------------------------------------------===//
// Methods on LengthModifier.
//===----------------------------------------------------------------------===//
const char *
analyze_format_string::LengthModifier::toString() const {
switch (kind) {
case AsChar:
return "hh";
case AsShort:
return "h";
case AsLong: // or AsWideChar
return "l";
case AsLongLong:
return "ll";
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 AsQuad:
return "q";
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
case AsIntMax:
return "j";
case AsSizeT:
return "z";
case AsPtrDiff:
return "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 AsInt32:
return "I32";
case AsInt3264:
return "I";
case AsInt64:
return "I64";
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
case AsLongDouble:
return "L";
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 AsAllocate:
return "a";
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 AsMAllocate:
return "m";
MS format strings: support the 'w' length modifier (PR20808) llvm-svn: 217195
2014-09-05 05:39:46 +08:00
case AsWide:
return "w";
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
case None:
return "";
}
[C++11] Use 'nullptr'. Analysis edition. llvm-svn: 209191
2014-05-20 12:30:07 +08:00
return nullptr;
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
}
Move definition of ConversionSpecifier::toString() to FormatString.cpp It's declared in FormatString.h, so it shouldn't be defined in PrintfFormatString.cpp. llvm-svn: 146253
2011-12-09 19:11:07 +08:00
//===----------------------------------------------------------------------===//
// Methods on ConversionSpecifier.
//===----------------------------------------------------------------------===//
const char *ConversionSpecifier::toString() const {
switch (kind) {
case dArg: return "d";
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 DArg: return "D";
Move definition of ConversionSpecifier::toString() to FormatString.cpp It's declared in FormatString.h, so it shouldn't be defined in PrintfFormatString.cpp. llvm-svn: 146253
2011-12-09 19:11:07 +08:00
case iArg: return "i";
case oArg: return "o";
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 OArg: return "O";
Move definition of ConversionSpecifier::toString() to FormatString.cpp It's declared in FormatString.h, so it shouldn't be defined in PrintfFormatString.cpp. llvm-svn: 146253
2011-12-09 19:11:07 +08:00
case uArg: return "u";
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 UArg: return "U";
Move definition of ConversionSpecifier::toString() to FormatString.cpp It's declared in FormatString.h, so it shouldn't be defined in PrintfFormatString.cpp. llvm-svn: 146253
2011-12-09 19:11:07 +08:00
case xArg: return "x";
case XArg: return "X";
case fArg: return "f";
case FArg: return "F";
case eArg: return "e";
case EArg: return "E";
case gArg: return "g";
case GArg: return "G";
case aArg: return "a";
case AArg: return "A";
case cArg: return "c";
case sArg: return "s";
case pArg: return "p";
case nArg: return "n";
case PercentArg: return "%";
case ScanListArg: return "[";
[C++11] Use 'nullptr'. Analysis edition. llvm-svn: 209191
2014-05-20 12:30:07 +08:00
case InvalidSpecifier: return nullptr;
Move definition of ConversionSpecifier::toString() to FormatString.cpp It's declared in FormatString.h, so it shouldn't be defined in PrintfFormatString.cpp. llvm-svn: 146253
2011-12-09 19:11:07 +08:00
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
// POSIX unicode extensions.
Move definition of ConversionSpecifier::toString() to FormatString.cpp It's declared in FormatString.h, so it shouldn't be defined in PrintfFormatString.cpp. llvm-svn: 146253
2011-12-09 19:11:07 +08:00
case CArg: return "C";
case SArg: return "S";
// Objective-C specific specifiers.
case ObjCObjArg: return "@";
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 specifiers.
case FreeBSDbArg: return "b";
case FreeBSDDArg: return "D";
case FreeBSDrArg: return "r";
case FreeBSDyArg: return "y";
Move definition of ConversionSpecifier::toString() to FormatString.cpp It's declared in FormatString.h, so it shouldn't be defined in PrintfFormatString.cpp. llvm-svn: 146253
2011-12-09 19:11:07 +08:00
// GlibC specific specifiers.
case PrintErrno: return "m";
MS format strings: parse the 'Z' printf conversion specifier (PR20808) llvm-svn: 217326
2014-09-07 11:03:51 +08:00
// MS specific specifiers.
case ZArg: return "Z";
Move definition of ConversionSpecifier::toString() to FormatString.cpp It's declared in FormatString.h, so it shouldn't be defined in PrintfFormatString.cpp. llvm-svn: 146253
2011-12-09 19:11:07 +08:00
}
[C++11] Use 'nullptr'. Analysis edition. llvm-svn: 209191
2014-05-20 12:30:07 +08:00
return nullptr;
Move definition of ConversionSpecifier::toString() to FormatString.cpp It's declared in FormatString.h, so it shouldn't be defined in PrintfFormatString.cpp. llvm-svn: 146253
2011-12-09 19:11:07 +08:00
}
Include llvm::Optional in clang/Basic/LLVM.h Post-commit CR feedback from Jordan Rose regarding r175594. llvm-svn: 175679
2013-02-21 06:23:23 +08:00
Optional<ConversionSpecifier>
Format strings: offer a fixit for Darwin's %D/%U/%O to ISO %d/%u/%o. <rdar://problem/12061922> llvm-svn: 163772
2012-09-13 10:11:15 +08:00
ConversionSpecifier::getStandardSpecifier() const {
ConversionSpecifier::Kind NewKind;
switch (getKind()) {
default:
Use None rather than Optional<T>() where possible. llvm-svn: 175705
2013-02-21 09:47:18 +08:00
return None;
Format strings: offer a fixit for Darwin's %D/%U/%O to ISO %d/%u/%o. <rdar://problem/12061922> llvm-svn: 163772
2012-09-13 10:11:15 +08:00
case DArg:
NewKind = dArg;
break;
case UArg:
NewKind = uArg;
break;
case OArg:
NewKind = oArg;
break;
}
ConversionSpecifier FixedCS(*this);
FixedCS.setKind(NewKind);
return FixedCS;
}
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 OptionalAmount.
//===----------------------------------------------------------------------===//
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 OptionalAmount::toString(raw_ostream &os) const {
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
switch (hs) {
case Invalid:
case NotSpecified:
return;
case Arg:
if (UsesDotPrefix)
os << ".";
if (usesPositionalArg())
os << "*" << getPositionalArgIndex() << "$";
else
os << "*";
break;
case Constant:
if (UsesDotPrefix)
os << ".";
os << amt;
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
bool FormatSpecifier::hasValidLengthModifier(const TargetInfo &Target) const {
Move 'hasValidLengthModifier' from PrintfFormatSpecifier to FormatSpecifier. llvm-svn: 108906
2010-07-21 04:04:42 +08:00
switch (LM.getKind()) {
case LengthModifier::None:
return true;
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
// Handle most integer flags
Move 'hasValidLengthModifier' from PrintfFormatSpecifier to FormatSpecifier. llvm-svn: 108906
2010-07-21 04:04:42 +08:00
case LengthModifier::AsShort:
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 (Target.getTriple().isOSMSVCRT()) {
switch (CS.getKind()) {
case ConversionSpecifier::cArg:
case ConversionSpecifier::CArg:
case ConversionSpecifier::sArg:
case ConversionSpecifier::SArg:
MS format strings: parse the 'Z' printf conversion specifier (PR20808) llvm-svn: 217326
2014-09-07 11:03:51 +08:00
case ConversionSpecifier::ZArg:
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
return true;
default:
break;
}
}
// Fall through.
case LengthModifier::AsChar:
Move 'hasValidLengthModifier' from PrintfFormatSpecifier to FormatSpecifier. llvm-svn: 108906
2010-07-21 04:04:42 +08:00
case LengthModifier::AsLongLong:
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::AsQuad:
Move 'hasValidLengthModifier' from PrintfFormatSpecifier to FormatSpecifier. llvm-svn: 108906
2010-07-21 04:04:42 +08:00
case LengthModifier::AsIntMax:
case LengthModifier::AsSizeT:
case LengthModifier::AsPtrDiff:
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:
Move 'hasValidLengthModifier' from PrintfFormatSpecifier to FormatSpecifier. llvm-svn: 108906
2010-07-21 04:04:42 +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:
Move 'hasValidLengthModifier' from PrintfFormatSpecifier to FormatSpecifier. llvm-svn: 108906
2010-07-21 04:04:42 +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:
Move 'hasValidLengthModifier' from PrintfFormatSpecifier to FormatSpecifier. llvm-svn: 108906
2010-07-21 04:04:42 +08:00
case ConversionSpecifier::xArg:
case ConversionSpecifier::XArg:
case ConversionSpecifier::nArg:
return true;
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:
Check 'r' and 'y specifiers of freebsd_kernel_printf format strings on PS4 This is an addendum to r229921. llvm-svn: 267625
2016-04-27 07:19:00 +08:00
return Target.getTriple().isOSFreeBSD() || Target.getTriple().isPS4();
Move 'hasValidLengthModifier' from PrintfFormatSpecifier to FormatSpecifier. llvm-svn: 108906
2010-07-21 04:04:42 +08:00
default:
return false;
}
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
// Handle 'l' flag
Add a comment, no functional change. llvm-svn: 216777
2014-08-30 05:05:44 +08:00
case LengthModifier::AsLong: // or AsWideChar
Move 'hasValidLengthModifier' from PrintfFormatSpecifier to FormatSpecifier. llvm-svn: 108906
2010-07-21 04:04:42 +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:
Move 'hasValidLengthModifier' from PrintfFormatSpecifier to FormatSpecifier. llvm-svn: 108906
2010-07-21 04:04:42 +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:
Move 'hasValidLengthModifier' from PrintfFormatSpecifier to FormatSpecifier. llvm-svn: 108906
2010-07-21 04:04:42 +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:
Move 'hasValidLengthModifier' from PrintfFormatSpecifier to FormatSpecifier. llvm-svn: 108906
2010-07-21 04:04:42 +08:00
case ConversionSpecifier::xArg:
case ConversionSpecifier::XArg:
case ConversionSpecifier::aArg:
case ConversionSpecifier::AArg:
case ConversionSpecifier::fArg:
case ConversionSpecifier::FArg:
case ConversionSpecifier::eArg:
case ConversionSpecifier::EArg:
case ConversionSpecifier::gArg:
case ConversionSpecifier::GArg:
case ConversionSpecifier::nArg:
case ConversionSpecifier::cArg:
case ConversionSpecifier::sArg:
The 'l' length modifier makes sense with the scanlist conversion specifier. llvm-svn: 148586
2012-01-21 06:11:52 +08:00
case ConversionSpecifier::ScanListArg:
MS format strings: parse the 'Z' printf conversion specifier (PR20808) llvm-svn: 217326
2014-09-07 11:03:51 +08:00
case ConversionSpecifier::ZArg:
Move 'hasValidLengthModifier' from PrintfFormatSpecifier to FormatSpecifier. llvm-svn: 108906
2010-07-21 04:04:42 +08:00
return true;
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:
Check 'r' and 'y specifiers of freebsd_kernel_printf format strings on PS4 This is an addendum to r229921. llvm-svn: 267625
2016-04-27 07:19:00 +08:00
return Target.getTriple().isOSFreeBSD() || Target.getTriple().isPS4();
Move 'hasValidLengthModifier' from PrintfFormatSpecifier to FormatSpecifier. llvm-svn: 108906
2010-07-21 04:04:42 +08:00
default:
return false;
}
case LengthModifier::AsLongDouble:
switch (CS.getKind()) {
case ConversionSpecifier::aArg:
case ConversionSpecifier::AArg:
case ConversionSpecifier::fArg:
case ConversionSpecifier::FArg:
case ConversionSpecifier::eArg:
case ConversionSpecifier::EArg:
case ConversionSpecifier::gArg:
case ConversionSpecifier::GArg:
return true;
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
// GNU libc extension.
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
case ConversionSpecifier::dArg:
case ConversionSpecifier::iArg:
case ConversionSpecifier::oArg:
case ConversionSpecifier::uArg:
case ConversionSpecifier::xArg:
case ConversionSpecifier::XArg:
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
return !Target.getTriple().isOSDarwin() &&
!Target.getTriple().isOSWindows();
Move 'hasValidLengthModifier' from PrintfFormatSpecifier to FormatSpecifier. llvm-svn: 108906
2010-07-21 04:04:42 +08:00
default:
return false;
}
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:
switch (CS.getKind()) {
case ConversionSpecifier::sArg:
case ConversionSpecifier::SArg:
scanf analysis: the 'a' length modifier is valid with a scanlist Before r148025 we (accidentally) didn't check whether a length modifier is appropriate for a scanlist, but now we do. llvm-svn: 148026
2012-01-12 23:07:16 +08:00
case ConversionSpecifier::ScanListArg:
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
return true;
default:
return false;
}
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:
switch (CS.getKind()) {
case ConversionSpecifier::cArg:
case ConversionSpecifier::CArg:
case ConversionSpecifier::sArg:
case ConversionSpecifier::SArg:
case ConversionSpecifier::ScanListArg:
return true;
default:
return false;
}
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:
switch (CS.getKind()) {
case ConversionSpecifier::dArg:
case ConversionSpecifier::iArg:
case ConversionSpecifier::oArg:
case ConversionSpecifier::uArg:
case ConversionSpecifier::xArg:
case ConversionSpecifier::XArg:
return Target.getTriple().isOSMSVCRT();
default:
return false;
}
MS format strings: support the 'w' length modifier (PR20808) llvm-svn: 217195
2014-09-05 05:39:46 +08:00
case LengthModifier::AsWide:
switch (CS.getKind()) {
case ConversionSpecifier::cArg:
case ConversionSpecifier::CArg:
case ConversionSpecifier::sArg:
MS format strings: parse the 'Z' printf conversion specifier (PR20808) llvm-svn: 217326
2014-09-07 11:03:51 +08:00
case ConversionSpecifier::SArg:
case ConversionSpecifier::ZArg:
MS format strings: support the 'w' length modifier (PR20808) llvm-svn: 217195
2014-09-05 05:39:46 +08:00
return Target.getTriple().isOSMSVCRT();
default:
return false;
}
Move 'hasValidLengthModifier' from PrintfFormatSpecifier to FormatSpecifier. llvm-svn: 108906
2010-07-21 04:04:42 +08:00
}
More dead code removal (using -Wunreachable-code) llvm-svn: 148577
2012-01-21 05:50:17 +08:00
llvm_unreachable("Invalid LengthModifier Kind!");
Move 'hasValidLengthModifier' from PrintfFormatSpecifier to FormatSpecifier. llvm-svn: 108906
2010-07-21 04:04:42 +08:00
}
Warn about non-standard format strings (pr12017) This adds the -Wformat-non-standard flag (off by default, enabled by -pedantic), which warns about non-standard things in format strings (such as the 'q' length modifier, the 'S' conversion specifier, etc.) llvm-svn: 151154
2012-02-22 18:17:01 +08:00
bool FormatSpecifier::hasStandardLengthModifier() const {
switch (LM.getKind()) {
case LengthModifier::None:
case LengthModifier::AsChar:
case LengthModifier::AsShort:
case LengthModifier::AsLong:
case LengthModifier::AsLongLong:
case LengthModifier::AsIntMax:
case LengthModifier::AsSizeT:
case LengthModifier::AsPtrDiff:
case LengthModifier::AsLongDouble:
return true;
case LengthModifier::AsAllocate:
case LengthModifier::AsMAllocate:
case LengthModifier::AsQuad:
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:
Warn about non-standard format strings (pr12017) This adds the -Wformat-non-standard flag (off by default, enabled by -pedantic), which warns about non-standard things in format strings (such as the 'q' length modifier, the 'S' conversion specifier, etc.) llvm-svn: 151154
2012-02-22 18:17:01 +08:00
return false;
}
llvm_unreachable("Invalid LengthModifier Kind!");
}
Wrap to 80 columns. No behavior change. llvm-svn: 237549
2015-05-18 10:41:17 +08:00
bool FormatSpecifier::hasStandardConversionSpecifier(
const LangOptions &LangOpt) const {
Warn about non-standard format strings (pr12017) This adds the -Wformat-non-standard flag (off by default, enabled by -pedantic), which warns about non-standard things in format strings (such as the 'q' length modifier, the 'S' conversion specifier, etc.) llvm-svn: 151154
2012-02-22 18:17:01 +08:00
switch (CS.getKind()) {
case ConversionSpecifier::cArg:
case ConversionSpecifier::dArg:
case ConversionSpecifier::iArg:
case ConversionSpecifier::oArg:
case ConversionSpecifier::uArg:
case ConversionSpecifier::xArg:
case ConversionSpecifier::XArg:
case ConversionSpecifier::fArg:
case ConversionSpecifier::FArg:
case ConversionSpecifier::eArg:
case ConversionSpecifier::EArg:
case ConversionSpecifier::gArg:
case ConversionSpecifier::GArg:
case ConversionSpecifier::aArg:
case ConversionSpecifier::AArg:
case ConversionSpecifier::sArg:
case ConversionSpecifier::pArg:
case ConversionSpecifier::nArg:
case ConversionSpecifier::ObjCObjArg:
case ConversionSpecifier::ScanListArg:
case ConversionSpecifier::PercentArg:
return true;
case ConversionSpecifier::CArg:
case ConversionSpecifier::SArg:
return LangOpt.ObjC1 || LangOpt.ObjC2;
case ConversionSpecifier::InvalidSpecifier:
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::FreeBSDbArg:
case ConversionSpecifier::FreeBSDDArg:
case ConversionSpecifier::FreeBSDrArg:
case ConversionSpecifier::FreeBSDyArg:
Warn about non-standard format strings (pr12017) This adds the -Wformat-non-standard flag (off by default, enabled by -pedantic), which warns about non-standard things in format strings (such as the 'q' length modifier, the 'S' conversion specifier, etc.) llvm-svn: 151154
2012-02-22 18:17:01 +08:00
case ConversionSpecifier::PrintErrno:
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:
case ConversionSpecifier::OArg:
case ConversionSpecifier::UArg:
MS format strings: parse the 'Z' printf conversion specifier (PR20808) llvm-svn: 217326
2014-09-07 11:03:51 +08:00
case ConversionSpecifier::ZArg:
Warn about non-standard format strings (pr12017) This adds the -Wformat-non-standard flag (off by default, enabled by -pedantic), which warns about non-standard things in format strings (such as the 'q' length modifier, the 'S' conversion specifier, etc.) llvm-svn: 151154
2012-02-22 18:17:01 +08:00
return false;
}
llvm_unreachable("Invalid ConversionSpecifier Kind!");
}
bool FormatSpecifier::hasStandardLengthConversionCombination() const {
if (LM.getKind() == LengthModifier::AsLongDouble) {
switch(CS.getKind()) {
case ConversionSpecifier::dArg:
case ConversionSpecifier::iArg:
case ConversionSpecifier::oArg:
case ConversionSpecifier::uArg:
case ConversionSpecifier::xArg:
case ConversionSpecifier::XArg:
return false;
default:
return true;
}
}
return true;
}
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
Include llvm::Optional in clang/Basic/LLVM.h Post-commit CR feedback from Jordan Rose regarding r175594. llvm-svn: 175679
2013-02-21 06:23:23 +08:00
Optional<LengthModifier> FormatSpecifier::getCorrectedLengthModifier() const {
Format strings: suggest %lld instead of %qd and %Ld with -Wformat-non-iso. As a corollary to the previous commit, even when an extension is available, we can still offer a fixit to the standard modifier. llvm-svn: 163453
2012-09-08 12:00:12 +08:00
if (CS.isAnyIntArg() || CS.getKind() == ConversionSpecifier::nArg) {
if (LM.getKind() == LengthModifier::AsLongDouble ||
LM.getKind() == LengthModifier::AsQuad) {
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
LengthModifier FixedLM(LM);
FixedLM.setKind(LengthModifier::AsLongLong);
return FixedLM;
}
}
Use None rather than Optional<T>() where possible. llvm-svn: 175705
2013-02-21 09:47:18 +08:00
return None;
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
}
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
bool FormatSpecifier::namedTypeToLengthModifier(QualType QT,
LengthModifier &LM) {
assert(isa<TypedefType>(QT) && "Expected a TypedefType");
const TypedefNameDecl *Typedef = cast<TypedefType>(QT)->getDecl();
for (;;) {
const IdentifierInfo *Identifier = Typedef->getIdentifier();
if (Identifier->getName() == "size_t") {
LM.setKind(LengthModifier::AsSizeT);
return true;
} else if (Identifier->getName() == "ssize_t") {
// Not C99, but common in Unix.
LM.setKind(LengthModifier::AsSizeT);
return true;
} else if (Identifier->getName() == "intmax_t") {
LM.setKind(LengthModifier::AsIntMax);
return true;
} else if (Identifier->getName() == "uintmax_t") {
LM.setKind(LengthModifier::AsIntMax);
return true;
} else if (Identifier->getName() == "ptrdiff_t") {
LM.setKind(LengthModifier::AsPtrDiff);
return true;
}
QualType T = Typedef->getUnderlyingType();
if (!isa<TypedefType>(T))
break;
Typedef = cast<TypedefType>(T)->getDecl();
}
return false;
}