91cdd35008
This is a major change on how we represent nested name qualifications in the AST. * The nested name specifier itself and how it's stored is changed. The prefixes for types are handled within the type hierarchy, which makes canonicalization for them super cheap, no memory allocation required. Also translating a type into nested name specifier form becomes a no-op. An identifier is stored as a DependentNameType. The nested name specifier gains a lightweight handle class, to be used instead of passing around pointers, which is similar to what is implemented for TemplateName. There is still one free bit available, and this handle can be used within a PointerUnion and PointerIntPair, which should keep bit-packing aficionados happy. * The ElaboratedType node is removed, all type nodes in which it could previously apply to can now store the elaborated keyword and name qualifier, tail allocating when present. * TagTypes can now point to the exact declaration found when producing these, as opposed to the previous situation of there only existing one TagType per entity. This increases the amount of type sugar retained, and can have several applications, for example in tracking module ownership, and other tools which care about source file origins, such as IWYU. These TagTypes are lazily allocated, in order to limit the increase in AST size. This patch offers a great performance benefit. It greatly improves compilation time for [stdexec](https://github.com/NVIDIA/stdexec). For one datapoint, for `test_on2.cpp` in that project, which is the slowest compiling test, this patch improves `-c` compilation time by about 7.2%, with the `-fsyntax-only` improvement being at ~12%. This has great results on compile-time-tracker as well:  This patch also further enables other optimziations in the future, and will reduce the performance impact of template specialization resugaring when that lands. It has some other miscelaneous drive-by fixes. About the review: Yes the patch is huge, sorry about that. Part of the reason is that I started by the nested name specifier part, before the ElaboratedType part, but that had a huge performance downside, as ElaboratedType is a big performance hog. I didn't have the steam to go back and change the patch after the fact. There is also a lot of internal API changes, and it made sense to remove ElaboratedType in one go, versus removing it from one type at a time, as that would present much more churn to the users. Also, the nested name specifier having a different API avoids missing changes related to how prefixes work now, which could make existing code compile but not work. How to review: The important changes are all in `clang/include/clang/AST` and `clang/lib/AST`, with also important changes in `clang/lib/Sema/TreeTransform.h`. The rest and bulk of the changes are mostly consequences of the changes in API. PS: TagType::getDecl is renamed to `getOriginalDecl` in this patch, just for easier to rebasing. I plan to rename it back after this lands. Fixes #136624 Fixes https://github.com/llvm/llvm-project/issues/43179 Fixes https://github.com/llvm/llvm-project/issues/68670 Fixes https://github.com/llvm/llvm-project/issues/92757
574 lines
19 KiB
C++
574 lines
19 KiB
C++
//= ScanfFormatString.cpp - Analysis of printf format strings --*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Handling of format string in scanf and friends. The structure of format
|
|
// strings for fscanf() are described in C99 7.19.6.2.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/AST/FormatString.h"
|
|
#include "FormatStringParsing.h"
|
|
#include "clang/Basic/TargetInfo.h"
|
|
|
|
using clang::analyze_format_string::ArgType;
|
|
using clang::analyze_format_string::FormatStringHandler;
|
|
using clang::analyze_format_string::LengthModifier;
|
|
using clang::analyze_format_string::OptionalAmount;
|
|
using clang::analyze_format_string::ConversionSpecifier;
|
|
using clang::analyze_scanf::ScanfConversionSpecifier;
|
|
using clang::analyze_scanf::ScanfSpecifier;
|
|
using clang::UpdateOnReturn;
|
|
using namespace clang;
|
|
|
|
typedef clang::analyze_format_string::SpecifierResult<ScanfSpecifier>
|
|
ScanfSpecifierResult;
|
|
|
|
static bool ParseScanList(FormatStringHandler &H,
|
|
ScanfConversionSpecifier &CS,
|
|
const char *&Beg, const char *E) {
|
|
const char *I = Beg;
|
|
const char *start = I - 1;
|
|
UpdateOnReturn <const char*> UpdateBeg(Beg, I);
|
|
|
|
// No more characters?
|
|
if (I == E) {
|
|
H.HandleIncompleteScanList(start, I);
|
|
return true;
|
|
}
|
|
|
|
// Special case: ']' is the first character.
|
|
if (*I == ']') {
|
|
if (++I == E) {
|
|
H.HandleIncompleteScanList(start, I - 1);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Special case: "^]" are the first characters.
|
|
if (I + 1 != E && I[0] == '^' && I[1] == ']') {
|
|
I += 2;
|
|
if (I == E) {
|
|
H.HandleIncompleteScanList(start, I - 1);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Look for a ']' character which denotes the end of the scan list.
|
|
while (*I != ']') {
|
|
if (++I == E) {
|
|
H.HandleIncompleteScanList(start, I - 1);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
CS.setEndScanList(I);
|
|
return false;
|
|
}
|
|
|
|
// FIXME: Much of this is copy-paste from ParsePrintfSpecifier.
|
|
// We can possibly refactor.
|
|
static ScanfSpecifierResult ParseScanfSpecifier(FormatStringHandler &H,
|
|
const char *&Beg,
|
|
const char *E,
|
|
unsigned &argIndex,
|
|
const LangOptions &LO,
|
|
const TargetInfo &Target) {
|
|
using namespace clang::analyze_format_string;
|
|
using namespace clang::analyze_scanf;
|
|
const char *I = Beg;
|
|
const char *Start = nullptr;
|
|
UpdateOnReturn <const char*> UpdateBeg(Beg, I);
|
|
|
|
// Look for a '%' character that indicates the start of a format specifier.
|
|
for ( ; I != E ; ++I) {
|
|
char c = *I;
|
|
if (c == '\0') {
|
|
// Detect spurious null characters, which are likely errors.
|
|
H.HandleNullChar(I);
|
|
return true;
|
|
}
|
|
if (c == '%') {
|
|
Start = I++; // Record the start of the format specifier.
|
|
break;
|
|
}
|
|
}
|
|
|
|
// No format specifier found?
|
|
if (!Start)
|
|
return false;
|
|
|
|
if (I == E) {
|
|
// No more characters left?
|
|
H.HandleIncompleteSpecifier(Start, E - Start);
|
|
return true;
|
|
}
|
|
|
|
ScanfSpecifier FS;
|
|
if (ParseArgPosition(H, FS, Start, I, E))
|
|
return true;
|
|
|
|
if (I == E) {
|
|
// No more characters left?
|
|
H.HandleIncompleteSpecifier(Start, E - Start);
|
|
return true;
|
|
}
|
|
|
|
// Look for '*' flag if it is present.
|
|
if (*I == '*') {
|
|
FS.setSuppressAssignment(I);
|
|
if (++I == E) {
|
|
H.HandleIncompleteSpecifier(Start, E - Start);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Look for the field width (if any). Unlike printf, this is either
|
|
// a fixed integer or isn't present.
|
|
const OptionalAmount &Amt = clang::analyze_format_string::ParseAmount(I, E);
|
|
if (Amt.getHowSpecified() != OptionalAmount::NotSpecified) {
|
|
assert(Amt.getHowSpecified() == OptionalAmount::Constant);
|
|
FS.setFieldWidth(Amt);
|
|
|
|
if (I == E) {
|
|
// No more characters left?
|
|
H.HandleIncompleteSpecifier(Start, E - Start);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Look for the length modifier.
|
|
if (ParseLengthModifier(FS, I, E, LO, /*IsScanf=*/true) && I == E) {
|
|
// No more characters left?
|
|
H.HandleIncompleteSpecifier(Start, E - Start);
|
|
return true;
|
|
}
|
|
|
|
// Detect spurious null characters, which are likely errors.
|
|
if (*I == '\0') {
|
|
H.HandleNullChar(I);
|
|
return true;
|
|
}
|
|
|
|
// Finally, look for the conversion specifier.
|
|
const char *conversionPosition = I++;
|
|
ScanfConversionSpecifier::Kind k = ScanfConversionSpecifier::InvalidSpecifier;
|
|
switch (*conversionPosition) {
|
|
default:
|
|
break;
|
|
case '%': k = ConversionSpecifier::PercentArg; break;
|
|
case 'b': k = ConversionSpecifier::bArg; break;
|
|
case 'A': k = ConversionSpecifier::AArg; break;
|
|
case 'E': k = ConversionSpecifier::EArg; break;
|
|
case 'F': k = ConversionSpecifier::FArg; break;
|
|
case 'G': k = ConversionSpecifier::GArg; break;
|
|
case 'X': k = ConversionSpecifier::XArg; break;
|
|
case 'a': k = ConversionSpecifier::aArg; break;
|
|
case 'd': k = ConversionSpecifier::dArg; break;
|
|
case 'e': k = ConversionSpecifier::eArg; break;
|
|
case 'f': k = ConversionSpecifier::fArg; break;
|
|
case 'g': k = ConversionSpecifier::gArg; break;
|
|
case 'i': k = ConversionSpecifier::iArg; break;
|
|
case 'n': k = ConversionSpecifier::nArg; break;
|
|
case 'c': k = ConversionSpecifier::cArg; break;
|
|
case 'C': k = ConversionSpecifier::CArg; break;
|
|
case 'S': k = ConversionSpecifier::SArg; break;
|
|
case '[': k = ConversionSpecifier::ScanListArg; break;
|
|
case 'u': k = ConversionSpecifier::uArg; break;
|
|
case 'x': k = ConversionSpecifier::xArg; break;
|
|
case 'o': k = ConversionSpecifier::oArg; break;
|
|
case 's': k = ConversionSpecifier::sArg; break;
|
|
case 'p': k = ConversionSpecifier::pArg; break;
|
|
// Apple extensions
|
|
// Apple-specific
|
|
case 'D':
|
|
if (Target.getTriple().isOSDarwin())
|
|
k = ConversionSpecifier::DArg;
|
|
break;
|
|
case 'O':
|
|
if (Target.getTriple().isOSDarwin())
|
|
k = ConversionSpecifier::OArg;
|
|
break;
|
|
case 'U':
|
|
if (Target.getTriple().isOSDarwin())
|
|
k = ConversionSpecifier::UArg;
|
|
break;
|
|
}
|
|
ScanfConversionSpecifier CS(conversionPosition, k);
|
|
if (k == ScanfConversionSpecifier::ScanListArg) {
|
|
if (ParseScanList(H, CS, I, E))
|
|
return true;
|
|
}
|
|
FS.setConversionSpecifier(CS);
|
|
if (CS.consumesDataArgument() && !FS.getSuppressAssignment()
|
|
&& !FS.usesPositionalArg())
|
|
FS.setArgIndex(argIndex++);
|
|
|
|
// FIXME: '%' and '*' doesn't make sense. Issue a warning.
|
|
// FIXME: 'ConsumedSoFar' and '*' doesn't make sense.
|
|
|
|
if (k == ScanfConversionSpecifier::InvalidSpecifier) {
|
|
unsigned Len = I - Beg;
|
|
if (ParseUTF8InvalidSpecifier(Beg, E, Len)) {
|
|
CS.setEndScanList(Beg + Len);
|
|
FS.setConversionSpecifier(CS);
|
|
}
|
|
// Assume the conversion takes one argument.
|
|
return !H.HandleInvalidScanfConversionSpecifier(FS, Beg, Len);
|
|
}
|
|
return ScanfSpecifierResult(Start, FS);
|
|
}
|
|
|
|
ArgType ScanfSpecifier::getArgType(ASTContext &Ctx) const {
|
|
const ScanfConversionSpecifier &CS = getConversionSpecifier();
|
|
|
|
if (!CS.consumesDataArgument())
|
|
return ArgType::Invalid();
|
|
|
|
switch(CS.getKind()) {
|
|
// Signed int.
|
|
case ConversionSpecifier::dArg:
|
|
case ConversionSpecifier::DArg:
|
|
case ConversionSpecifier::iArg:
|
|
switch (LM.getKind()) {
|
|
case LengthModifier::None:
|
|
return ArgType::PtrTo(Ctx.IntTy);
|
|
case LengthModifier::AsChar:
|
|
return ArgType::PtrTo(ArgType::AnyCharTy);
|
|
case LengthModifier::AsShort:
|
|
return ArgType::PtrTo(Ctx.ShortTy);
|
|
case LengthModifier::AsLong:
|
|
return ArgType::PtrTo(Ctx.LongTy);
|
|
case LengthModifier::AsLongLong:
|
|
case LengthModifier::AsQuad:
|
|
return ArgType::PtrTo(Ctx.LongLongTy);
|
|
case LengthModifier::AsInt64:
|
|
return ArgType::PtrTo(ArgType(Ctx.LongLongTy, "__int64"));
|
|
case LengthModifier::AsIntMax:
|
|
return ArgType::PtrTo(ArgType(Ctx.getIntMaxType(), "intmax_t"));
|
|
case LengthModifier::AsSizeT:
|
|
return ArgType::PtrTo(ArgType::makeSizeT(
|
|
ArgType(Ctx.getSignedSizeType(), "signed size_t")));
|
|
case LengthModifier::AsPtrDiff:
|
|
return ArgType::PtrTo(ArgType::makePtrdiffT(
|
|
ArgType(Ctx.getPointerDiffType(), "ptrdiff_t")));
|
|
case LengthModifier::AsLongDouble:
|
|
// GNU extension.
|
|
return ArgType::PtrTo(Ctx.LongLongTy);
|
|
case LengthModifier::AsAllocate:
|
|
case LengthModifier::AsMAllocate:
|
|
case LengthModifier::AsInt32:
|
|
case LengthModifier::AsInt3264:
|
|
case LengthModifier::AsWide:
|
|
case LengthModifier::AsShortLong:
|
|
return ArgType::Invalid();
|
|
}
|
|
llvm_unreachable("Unsupported LengthModifier Type");
|
|
|
|
// Unsigned int.
|
|
case ConversionSpecifier::bArg:
|
|
case ConversionSpecifier::oArg:
|
|
case ConversionSpecifier::OArg:
|
|
case ConversionSpecifier::uArg:
|
|
case ConversionSpecifier::UArg:
|
|
case ConversionSpecifier::xArg:
|
|
case ConversionSpecifier::XArg:
|
|
switch (LM.getKind()) {
|
|
case LengthModifier::None:
|
|
return ArgType::PtrTo(Ctx.UnsignedIntTy);
|
|
case LengthModifier::AsChar:
|
|
return ArgType::PtrTo(Ctx.UnsignedCharTy);
|
|
case LengthModifier::AsShort:
|
|
return ArgType::PtrTo(Ctx.UnsignedShortTy);
|
|
case LengthModifier::AsLong:
|
|
return ArgType::PtrTo(Ctx.UnsignedLongTy);
|
|
case LengthModifier::AsLongLong:
|
|
case LengthModifier::AsQuad:
|
|
return ArgType::PtrTo(Ctx.UnsignedLongLongTy);
|
|
case LengthModifier::AsInt64:
|
|
return ArgType::PtrTo(ArgType(Ctx.UnsignedLongLongTy, "unsigned __int64"));
|
|
case LengthModifier::AsIntMax:
|
|
return ArgType::PtrTo(ArgType(Ctx.getUIntMaxType(), "uintmax_t"));
|
|
case LengthModifier::AsSizeT:
|
|
return ArgType::PtrTo(
|
|
ArgType::makeSizeT(ArgType(Ctx.getSizeType(), "size_t")));
|
|
case LengthModifier::AsPtrDiff:
|
|
return ArgType::PtrTo(ArgType::makePtrdiffT(
|
|
ArgType(Ctx.getUnsignedPointerDiffType(), "unsigned ptrdiff_t")));
|
|
case LengthModifier::AsLongDouble:
|
|
// GNU extension.
|
|
return ArgType::PtrTo(Ctx.UnsignedLongLongTy);
|
|
case LengthModifier::AsAllocate:
|
|
case LengthModifier::AsMAllocate:
|
|
case LengthModifier::AsInt32:
|
|
case LengthModifier::AsInt3264:
|
|
case LengthModifier::AsWide:
|
|
case LengthModifier::AsShortLong:
|
|
return ArgType::Invalid();
|
|
}
|
|
llvm_unreachable("Unsupported LengthModifier Type");
|
|
|
|
// Float.
|
|
case ConversionSpecifier::aArg:
|
|
case ConversionSpecifier::AArg:
|
|
case ConversionSpecifier::eArg:
|
|
case ConversionSpecifier::EArg:
|
|
case ConversionSpecifier::fArg:
|
|
case ConversionSpecifier::FArg:
|
|
case ConversionSpecifier::gArg:
|
|
case ConversionSpecifier::GArg:
|
|
switch (LM.getKind()) {
|
|
case LengthModifier::None:
|
|
return ArgType::PtrTo(Ctx.FloatTy);
|
|
case LengthModifier::AsLong:
|
|
return ArgType::PtrTo(Ctx.DoubleTy);
|
|
case LengthModifier::AsLongDouble:
|
|
return ArgType::PtrTo(Ctx.LongDoubleTy);
|
|
default:
|
|
return ArgType::Invalid();
|
|
}
|
|
|
|
// Char, string and scanlist.
|
|
case ConversionSpecifier::cArg:
|
|
case ConversionSpecifier::sArg:
|
|
case ConversionSpecifier::ScanListArg:
|
|
switch (LM.getKind()) {
|
|
case LengthModifier::None:
|
|
return ArgType::PtrTo(ArgType::AnyCharTy);
|
|
case LengthModifier::AsLong:
|
|
case LengthModifier::AsWide:
|
|
return ArgType::PtrTo(ArgType(Ctx.getWideCharType(), "wchar_t"));
|
|
case LengthModifier::AsAllocate:
|
|
case LengthModifier::AsMAllocate:
|
|
return ArgType::PtrTo(ArgType::CStrTy);
|
|
case LengthModifier::AsShort:
|
|
if (Ctx.getTargetInfo().getTriple().isOSMSVCRT())
|
|
return ArgType::PtrTo(ArgType::AnyCharTy);
|
|
[[fallthrough]];
|
|
default:
|
|
return ArgType::Invalid();
|
|
}
|
|
case ConversionSpecifier::CArg:
|
|
case ConversionSpecifier::SArg:
|
|
// FIXME: Mac OS X specific?
|
|
switch (LM.getKind()) {
|
|
case LengthModifier::None:
|
|
case LengthModifier::AsWide:
|
|
return ArgType::PtrTo(ArgType(Ctx.getWideCharType(), "wchar_t"));
|
|
case LengthModifier::AsAllocate:
|
|
case LengthModifier::AsMAllocate:
|
|
return ArgType::PtrTo(ArgType(ArgType::WCStrTy, "wchar_t *"));
|
|
case LengthModifier::AsShort:
|
|
if (Ctx.getTargetInfo().getTriple().isOSMSVCRT())
|
|
return ArgType::PtrTo(ArgType::AnyCharTy);
|
|
[[fallthrough]];
|
|
default:
|
|
return ArgType::Invalid();
|
|
}
|
|
|
|
// Pointer.
|
|
case ConversionSpecifier::pArg:
|
|
return ArgType::PtrTo(ArgType::CPointerTy);
|
|
|
|
// Write-back.
|
|
case ConversionSpecifier::nArg:
|
|
switch (LM.getKind()) {
|
|
case LengthModifier::None:
|
|
return ArgType::PtrTo(Ctx.IntTy);
|
|
case LengthModifier::AsChar:
|
|
return ArgType::PtrTo(Ctx.SignedCharTy);
|
|
case LengthModifier::AsShort:
|
|
return ArgType::PtrTo(Ctx.ShortTy);
|
|
case LengthModifier::AsLong:
|
|
return ArgType::PtrTo(Ctx.LongTy);
|
|
case LengthModifier::AsLongLong:
|
|
case LengthModifier::AsQuad:
|
|
return ArgType::PtrTo(Ctx.LongLongTy);
|
|
case LengthModifier::AsInt64:
|
|
return ArgType::PtrTo(ArgType(Ctx.LongLongTy, "__int64"));
|
|
case LengthModifier::AsIntMax:
|
|
return ArgType::PtrTo(ArgType(Ctx.getIntMaxType(), "intmax_t"));
|
|
case LengthModifier::AsSizeT:
|
|
return ArgType::PtrTo(ArgType::makeSizeT(
|
|
ArgType(Ctx.getSignedSizeType(), "signed size_t")));
|
|
case LengthModifier::AsPtrDiff:
|
|
return ArgType::PtrTo(ArgType::makePtrdiffT(
|
|
ArgType(Ctx.getPointerDiffType(), "ptrdiff_t")));
|
|
case LengthModifier::AsLongDouble:
|
|
return ArgType(); // FIXME: Is this a known extension?
|
|
case LengthModifier::AsAllocate:
|
|
case LengthModifier::AsMAllocate:
|
|
case LengthModifier::AsInt32:
|
|
case LengthModifier::AsInt3264:
|
|
case LengthModifier::AsWide:
|
|
case LengthModifier::AsShortLong:
|
|
return ArgType::Invalid();
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ArgType();
|
|
}
|
|
|
|
bool ScanfSpecifier::fixType(QualType QT, QualType RawQT,
|
|
const LangOptions &LangOpt,
|
|
ASTContext &Ctx) {
|
|
|
|
// %n is different from other conversion specifiers; don't try to fix it.
|
|
if (CS.getKind() == ConversionSpecifier::nArg)
|
|
return false;
|
|
|
|
if (!QT->isPointerType())
|
|
return false;
|
|
|
|
QualType PT = QT->getPointeeType();
|
|
|
|
// If it's an enum, get its underlying type.
|
|
if (const EnumType *ETy = PT->getAs<EnumType>()) {
|
|
// Don't try to fix incomplete enums.
|
|
const EnumDecl *ED = ETy->getOriginalDecl()->getDefinitionOrSelf();
|
|
if (!ED->isComplete())
|
|
return false;
|
|
PT = ED->getIntegerType();
|
|
}
|
|
|
|
const BuiltinType *BT = PT->getAs<BuiltinType>();
|
|
if (!BT)
|
|
return false;
|
|
|
|
// Pointer to a character.
|
|
if (PT->isAnyCharacterType()) {
|
|
CS.setKind(ConversionSpecifier::sArg);
|
|
if (PT->isWideCharType())
|
|
LM.setKind(LengthModifier::AsWideChar);
|
|
else
|
|
LM.setKind(LengthModifier::None);
|
|
|
|
// If we know the target array length, we can use it as a field width.
|
|
if (const ConstantArrayType *CAT = Ctx.getAsConstantArrayType(RawQT)) {
|
|
if (CAT->getSizeModifier() == ArraySizeModifier::Normal)
|
|
FieldWidth = OptionalAmount(OptionalAmount::Constant,
|
|
CAT->getZExtSize() - 1, "", 0, false);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Figure out the length modifier.
|
|
switch (BT->getKind()) {
|
|
// no modifier
|
|
case BuiltinType::UInt:
|
|
case BuiltinType::Int:
|
|
case BuiltinType::Float:
|
|
LM.setKind(LengthModifier::None);
|
|
break;
|
|
|
|
// hh
|
|
case BuiltinType::Char_U:
|
|
case BuiltinType::UChar:
|
|
case BuiltinType::Char_S:
|
|
case BuiltinType::SChar:
|
|
LM.setKind(LengthModifier::AsChar);
|
|
break;
|
|
|
|
// h
|
|
case BuiltinType::Short:
|
|
case BuiltinType::UShort:
|
|
LM.setKind(LengthModifier::AsShort);
|
|
break;
|
|
|
|
// l
|
|
case BuiltinType::Long:
|
|
case BuiltinType::ULong:
|
|
case BuiltinType::Double:
|
|
LM.setKind(LengthModifier::AsLong);
|
|
break;
|
|
|
|
// ll
|
|
case BuiltinType::LongLong:
|
|
case BuiltinType::ULongLong:
|
|
LM.setKind(LengthModifier::AsLongLong);
|
|
break;
|
|
|
|
// L
|
|
case BuiltinType::LongDouble:
|
|
LM.setKind(LengthModifier::AsLongDouble);
|
|
break;
|
|
|
|
// Don't know.
|
|
default:
|
|
return false;
|
|
}
|
|
|
|
// Handle size_t, ptrdiff_t, etc. that have dedicated length modifiers in C99.
|
|
if (LangOpt.C99 || LangOpt.CPlusPlus11)
|
|
namedTypeToLengthModifier(Ctx, PT, LM);
|
|
|
|
// If fixing the length modifier was enough, we are done.
|
|
if (hasValidLengthModifier(Ctx.getTargetInfo(), LangOpt)) {
|
|
const analyze_scanf::ArgType &AT = getArgType(Ctx);
|
|
if (AT.isValid() && AT.matchesType(Ctx, QT))
|
|
return true;
|
|
}
|
|
|
|
// Figure out the conversion specifier.
|
|
if (PT->isRealFloatingType())
|
|
CS.setKind(ConversionSpecifier::fArg);
|
|
else if (PT->isSignedIntegerType())
|
|
CS.setKind(ConversionSpecifier::dArg);
|
|
else if (PT->isUnsignedIntegerType())
|
|
CS.setKind(ConversionSpecifier::uArg);
|
|
else
|
|
llvm_unreachable("Unexpected type");
|
|
|
|
return true;
|
|
}
|
|
|
|
void ScanfSpecifier::toString(raw_ostream &os) const {
|
|
os << "%";
|
|
|
|
if (usesPositionalArg())
|
|
os << getPositionalArgIndex() << "$";
|
|
if (SuppressAssignment)
|
|
os << "*";
|
|
|
|
FieldWidth.toString(os);
|
|
os << LM.toString();
|
|
os << CS.toString();
|
|
}
|
|
|
|
bool clang::analyze_format_string::ParseScanfString(FormatStringHandler &H,
|
|
const char *I,
|
|
const char *E,
|
|
const LangOptions &LO,
|
|
const TargetInfo &Target) {
|
|
|
|
unsigned argIndex = 0;
|
|
|
|
// Keep looking for a format specifier until we have exhausted the string.
|
|
while (I != E) {
|
|
const ScanfSpecifierResult &FSR = ParseScanfSpecifier(H, I, E, argIndex,
|
|
LO, Target);
|
|
// Did a fail-stop error of any kind occur when parsing the specifier?
|
|
// If so, don't do any more processing.
|
|
if (FSR.shouldStop())
|
|
return true;
|
|
// Did we exhaust the string or encounter an error that
|
|
// we can recover from?
|
|
if (!FSR.hasValue())
|
|
continue;
|
|
// We have a format specifier. Pass it to the callback.
|
|
if (!H.HandleScanfSpecifier(FSR.getValue(), FSR.getStart(),
|
|
I - FSR.getStart())) {
|
|
return true;
|
|
}
|
|
}
|
|
assert(I == E && "Format string not exhausted");
|
|
return false;
|
|
}
|