[llvm-branch-commits] [clang] [llvm] Add format string handling (PR #196568)
Abhina Sree via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Fri Nov 20 11:48:03 PST 2026
https://github.com/abhina-sree updated https://github.com/llvm/llvm-project/pull/196568
>From 479f35b5f8dc926b717d47f92eba54e136c9ec03 Mon Sep 17 00:00:00 2001
From: Abhina Sreeskantharajan <Abhina.Sreeskantharajan at ibm.com>
Date: Fri, 8 May 2026 12:19:11 -0400
Subject: [PATCH 1/2] Add format string handling
---
clang/lib/AST/FormatString.cpp | 56 +++++-----
clang/lib/AST/FormatStringParsing.h | 18 +++-
clang/lib/AST/PrintfFormatString.cpp | 126 +++++++++++++----------
clang/lib/AST/ScanfFormatString.cpp | 61 ++++++-----
clang/lib/Sema/SemaChecking.cpp | 27 +++--
clang/lib/Sema/SemaStmtAsm.cpp | 1 +
llvm/include/llvm/Support/TextEncoding.h | 10 ++
7 files changed, 175 insertions(+), 124 deletions(-)
diff --git a/clang/lib/AST/FormatString.cpp b/clang/lib/AST/FormatString.cpp
index 100758e5ebf43..4c86d3a9a24f2 100644
--- a/clang/lib/AST/FormatString.cpp
+++ b/clang/lib/AST/FormatString.cpp
@@ -44,10 +44,10 @@ OptionalAmount FormatStringParser::parseAmount(const char *&Beg,
bool hasDigits = false;
for (; I != E; ++I) {
- char c = *I;
- if (c >= '0' && c <= '9') {
+ char c = FormatStrConverter.convertBasicChar(*I);
+ if (c >= u8'0' && c <= u8'9') {
hasDigits = true;
- accumulator = (accumulator * 10) + (c - '0');
+ accumulator = (accumulator * 10) + (c - u8'0');
continue;
}
@@ -80,7 +80,7 @@ bool FormatStringParser::parseWidthModifier(const char *&I, const char *E,
OptionalAmount
FormatStringParser::parseNonPositionAmount(const char *&Beg, const char *E,
unsigned &argIndex) const {
- if (*Beg == '*') {
+ if (FormatStrConverter.convertBasicChar(*Beg) == u8'*') {
++Beg;
return OptionalAmount(OptionalAmount::Arg, argIndex++, Beg, 0, false);
}
@@ -92,7 +92,7 @@ OptionalAmount
FormatStringParser::parsePositionAmount(const char *Start, const char *&Beg,
const char *E,
PositionContext p) const {
- if (*Beg == '*') {
+ if (FormatStrConverter.convertBasicChar(*Beg) == u8'*') {
const char *I = Beg + 1;
const OptionalAmount &Amt = parseAmount(I, E);
@@ -109,7 +109,7 @@ FormatStringParser::parsePositionAmount(const char *Start, const char *&Beg,
assert(Amt.getHowSpecified() == OptionalAmount::Constant);
- if (*I == '$') {
+ if (FormatStrConverter.convertBasicChar(*I) == u8'$') {
// Handle positional arguments
// Special case: '*0$', since this is an easy mistake.
@@ -162,7 +162,8 @@ bool FormatStringParser::parseArgPosition(FormatSpecifier &FS,
return true;
}
- if (Amt.getHowSpecified() == OptionalAmount::Constant && *(I++) == '$') {
+ if (Amt.getHowSpecified() == OptionalAmount::Constant &&
+ FormatStrConverter.convertBasicChar(*(I++)) == u8'$') {
// Warn that positional arguments are non-standard.
H.HandlePosition(Start, I - Start);
@@ -190,7 +191,7 @@ bool FormatStringParser::parseVectorModifier(FormatSpecifier &FS,
return false;
const char *Start = I;
- if (*I == 'v') {
+ if (FormatStrConverter.convertBasicChar(*I) == u8'v') {
++I;
if (I == E) {
@@ -215,64 +216,67 @@ bool FormatStringParser::parseLengthModifier(FormatSpecifier &FS,
const char *E) const {
LengthModifier::Kind lmKind = LengthModifier::None;
const char *lmPosition = I;
- switch (*I) {
+ switch (FormatStrConverter.convertBasicChar(*I)) {
default:
return false;
- case 'h':
+ case u8'h':
++I;
- if (I != E && *I == 'h') {
+ if (I != E && FormatStrConverter.convertBasicChar(*I) == u8'h') {
++I;
lmKind = LengthModifier::AsChar;
- } else if (I != E && *I == 'l' && LO.OpenCL) {
+ } else if (I != E && FormatStrConverter.convertBasicChar(*I) == u8'l' &&
+ LO.OpenCL) {
++I;
lmKind = LengthModifier::AsShortLong;
} else {
lmKind = LengthModifier::AsShort;
}
break;
- case 'l':
+ case u8'l':
++I;
- if (I != E && *I == 'l') {
+ if (I != E && FormatStrConverter.convertBasicChar(*I) == u8'l') {
++I;
lmKind = LengthModifier::AsLongLong;
} else {
lmKind = LengthModifier::AsLong;
}
break;
- case 'j':
+ case u8'j':
lmKind = LengthModifier::AsIntMax;
++I;
break;
- case 'z':
+ case u8'z':
lmKind = LengthModifier::AsSizeT;
++I;
break;
- case 't':
+ case u8't':
lmKind = LengthModifier::AsPtrDiff;
++I;
break;
- case 'L':
+ case u8'L':
lmKind = LengthModifier::AsLongDouble;
++I;
break;
- case 'q':
+ case u8'q':
lmKind = LengthModifier::AsQuad;
++I;
break;
- case 'a':
+ case u8'a':
if (IsScanf && !LO.C99 && !LO.CPlusPlus11) {
// 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 == '[')) {
+ if (I != E && (FormatStrConverter.convertBasicChar(*I) == u8's' ||
+ FormatStrConverter.convertBasicChar(*I) == u8'S' ||
+ FormatStrConverter.convertBasicChar(*I) == u8'[')) {
lmKind = LengthModifier::AsAllocate;
break;
}
--I;
}
return false;
- case 'm':
+ case u8'm':
if (IsScanf) {
lmKind = LengthModifier::AsMAllocate;
++I;
@@ -281,9 +285,10 @@ bool FormatStringParser::parseLengthModifier(FormatSpecifier &FS,
return false;
// printf: AsInt64, AsInt32, AsInt3264
// scanf: AsInt64
- case 'I':
+ case u8'I':
if (I + 1 != E && I + 2 != E) {
- if (I[1] == '6' && I[2] == '4') {
+ if (FormatStrConverter.convertBasicChar(I[1]) == u8'6' &&
+ FormatStrConverter.convertBasicChar(I[2]) == u8'4') {
I += 3;
lmKind = LengthModifier::AsInt64;
break;
@@ -291,7 +296,8 @@ bool FormatStringParser::parseLengthModifier(FormatSpecifier &FS,
if (IsScanf)
return false;
- if (I[1] == '3' && I[2] == '2') {
+ if (FormatStrConverter.convertBasicChar(I[1]) == u8'3' &&
+ FormatStrConverter.convertBasicChar(I[2]) == u8'2') {
I += 3;
lmKind = LengthModifier::AsInt32;
break;
diff --git a/clang/lib/AST/FormatStringParsing.h b/clang/lib/AST/FormatStringParsing.h
index 0a4169c5577af..4bc2ff4626070 100644
--- a/clang/lib/AST/FormatStringParsing.h
+++ b/clang/lib/AST/FormatStringParsing.h
@@ -17,19 +17,27 @@
#include "clang/AST/ASTContext.h"
#include "clang/AST/FormatString.h"
#include "clang/AST/Type.h"
+#include "clang/Basic/TargetInfo.h"
#include "llvm/Support/TextEncoding.h"
namespace clang {
class LangOptions;
-/// Creates the TextEncodingConverter used for format string character
-/// comparisons. Currently this is always a no-op converter.
+/// Creates a TextEncodingConverter for format string character comparisons.
+/// On z/OS format strings are IBM-1047 encoded, so each byte must be converted
+/// to UTF-8 before comparing against ASCII specifier characters.
+/// On all other targets a no-op converter is returned.
+/// Create this once per format string parse and pass it through.
inline llvm::TextEncodingConverter
makeFormatStrConverter(const TargetInfo &Target) {
- auto Converter = llvm::TextEncodingConverter::createNoopConverter();
- assert(Converter && "Failed to create format string converter");
- return std::move(*Converter);
+ auto MaybeConverter =
+ Target.getTriple().isOSzOS()
+ ? llvm::TextEncodingConverter::create(llvm::TextEncoding::IBM1047,
+ llvm::TextEncoding::UTF8)
+ : llvm::TextEncodingConverter::createNoopConverter();
+ assert(MaybeConverter && "Failed to create format string converter");
+ return std::move(*MaybeConverter);
}
template <typename T> class UpdateOnReturn {
diff --git a/clang/lib/AST/PrintfFormatString.cpp b/clang/lib/AST/PrintfFormatString.cpp
index b4eefceaa7c35..130ab295c0074 100644
--- a/clang/lib/AST/PrintfFormatString.cpp
+++ b/clang/lib/AST/PrintfFormatString.cpp
@@ -16,6 +16,7 @@
#include "clang/AST/OSLog.h"
#include "clang/Basic/TargetInfo.h"
#include "llvm/Support/Regex.h"
+#include "llvm/Support/TextEncoding.h"
using clang::analyze_format_string::ArgType;
using clang::analyze_format_string::ConversionSpecifier;
@@ -77,7 +78,9 @@ bool PrintfFormatStringParser::parseObjCFlags(PrintfSpecifier &FS,
const char *E) const {
StringRef Flag(FlagBeg, E - FlagBeg);
// Currently there is only one flag.
- if (Flag == "tt") {
+ if (Flag.size() == 2 &&
+ FormatStrConverter.convertBasicChar(FlagBeg[0]) == u8't' &&
+ FormatStrConverter.convertBasicChar(FlagBeg[1]) == u8't') {
FS.setHasObjCTechnicalTerm(FlagBeg);
return false;
}
@@ -109,7 +112,7 @@ PrintfFormatStringParser::parseSpecifier(const char *&Beg, const char *E,
H.HandleNullChar(I);
return true;
}
- if (c == '%') {
+ if (FormatStrConverter.convertBasicChar(c) == u8'%') {
Start = I++; // Record the start of the format specifier.
break;
}
@@ -137,13 +140,17 @@ PrintfFormatStringParser::parseSpecifier(const char *&Beg, const char *E,
return true;
}
- if (*I == '{') {
+ if (FormatStrConverter.convertBasicChar(*I) == u8'{') {
++I;
unsigned char PrivacyFlags = 0;
StringRef MatchedStr;
do {
- StringRef Str(I, E - I);
+ const char *II;
+ std::string S(I, E - I);
+ for (unsigned long i = 0; i < S.length(); ++i)
+ S[i] = FormatStrConverter.convertBasicChar(S[i]);
+ StringRef Str(S);
std::string Match = "^[[:space:]]*"
"(private|public|sensitive|mask\\.[^[:space:],}]*)"
"[[:space:]]*(,|})";
@@ -152,25 +159,38 @@ PrintfFormatStringParser::parseSpecifier(const char *&Beg, const char *E,
if (R.match(Str, &Matches)) {
MatchedStr = Matches[1];
+ II = I;
I += Matches[0].size();
+ while (FormatStrConverter.convertBasicChar(*II) == u8' ')
+ ++II;
+
// Set the privacy flag if the privacy annotation in the
// comma-delimited segment is at least as strict as the privacy
// annotations in previous comma-delimited segments.
if (MatchedStr.starts_with("mask")) {
- StringRef MaskType = MatchedStr.substr(sizeof("mask.") - 1);
+ StringRef MaskType(II + sizeof("mask.") - 1,
+ MatchedStr.size() - sizeof("mask.") + 1);
unsigned Size = MaskType.size();
+
if (Warn && (Size == 0 || Size > 8))
H.handleInvalidMaskType(MaskType);
FS.setMaskType(MaskType);
- } else if (MatchedStr == "sensitive")
+ } else if (MatchedStr == "sensitive") {
+ StringRef ProxyMatchedStr(II, sizeof("sensitive") - 1);
+ MatchedStr = ProxyMatchedStr;
PrivacyFlags = clang::analyze_os_log::OSLogBufferItem::IsSensitive;
- else if (PrivacyFlags !=
- clang::analyze_os_log::OSLogBufferItem::IsSensitive &&
- MatchedStr == "private")
+ } else if (PrivacyFlags !=
+ clang::analyze_os_log::OSLogBufferItem::IsSensitive &&
+ MatchedStr == "private") {
+ StringRef ProxyMatchedStr(II, sizeof("private") - 1);
+ MatchedStr = ProxyMatchedStr;
PrivacyFlags = clang::analyze_os_log::OSLogBufferItem::IsPrivate;
- else if (PrivacyFlags == 0 && MatchedStr == "public")
+ } else if (PrivacyFlags == 0 && MatchedStr == "public") {
+ StringRef ProxyMatchedStr(II, sizeof("public") - 1);
+ MatchedStr = ProxyMatchedStr;
PrivacyFlags = clang::analyze_os_log::OSLogBufferItem::IsPublic;
+ }
} else {
size_t CommaOrBracePos =
Str.find_if([](char c) { return c == ',' || c == '}'; });
@@ -185,7 +205,7 @@ PrintfFormatStringParser::parseSpecifier(const char *&Beg, const char *E,
I += CommaOrBracePos + 1;
}
// Continue until the closing brace is found.
- } while (*(I - 1) == ',');
+ } while (FormatStrConverter.convertBasicChar(*(I - 1)) == u8',');
// Set the privacy flag.
switch (PrivacyFlags) {
@@ -208,7 +228,7 @@ PrintfFormatStringParser::parseSpecifier(const char *&Beg, const char *E,
// Look for flags (if any).
bool hasMore = true;
for (; I != E; ++I) {
- switch (*I) {
+ switch (FormatStrConverter.convertBasicChar(*I)) {
default:
hasMore = false;
break;
@@ -256,7 +276,7 @@ PrintfFormatStringParser::parseSpecifier(const char *&Beg, const char *E,
}
// Look for the precision (if any).
- if (*I == '.') {
+ if (FormatStrConverter.convertBasicChar(*I) == u8'.') {
++I;
if (I == E) {
if (Warn)
@@ -294,7 +314,7 @@ PrintfFormatStringParser::parseSpecifier(const char *&Beg, const char *E,
// enables better recovery, and we don't know if
// these flags are applicable until later.
const char *ObjCModifierFlagsStart = nullptr, *ObjCModifierFlagsEnd = nullptr;
- if (*I == '[') {
+ if (FormatStrConverter.convertBasicChar(*I) == u8'[') {
ObjCModifierFlagsStart = I;
++I;
auto flagStart = I;
@@ -306,7 +326,7 @@ PrintfFormatStringParser::parseSpecifier(const char *&Beg, const char *E,
return true;
}
// Did we find the closing ']'?
- if (*I == ']') {
+ if (FormatStrConverter.convertBasicChar(*I) == u8']') {
if (parseObjCFlags(FS, flagStart, I))
return true;
++I;
@@ -327,139 +347,139 @@ PrintfFormatStringParser::parseSpecifier(const char *&Beg, const char *E,
// Finally, look for the conversion specifier.
const char *conversionPosition = I++;
ConversionSpecifier::Kind k = ConversionSpecifier::InvalidSpecifier;
- switch (*conversionPosition) {
+ switch (FormatStrConverter.convertBasicChar(*conversionPosition)) {
default:
break;
// C99: 7.19.6.1 (section 8).
- case '%':
+ case u8'%':
k = ConversionSpecifier::PercentArg;
break;
- case 'A':
+ case u8'A':
k = ConversionSpecifier::AArg;
break;
- case 'E':
+ case u8'E':
k = ConversionSpecifier::EArg;
break;
- case 'F':
+ case u8'F':
k = ConversionSpecifier::FArg;
break;
- case 'G':
+ case u8'G':
k = ConversionSpecifier::GArg;
break;
- case 'X':
+ case u8'X':
k = ConversionSpecifier::XArg;
break;
- case 'a':
+ case u8'a':
k = ConversionSpecifier::aArg;
break;
- case 'c':
+ case u8'c':
k = ConversionSpecifier::cArg;
break;
- case 'd':
+ case u8'd':
k = ConversionSpecifier::dArg;
break;
- case 'e':
+ case u8'e':
k = ConversionSpecifier::eArg;
break;
- case 'f':
+ case u8'f':
k = ConversionSpecifier::fArg;
break;
- case 'g':
+ case u8'g':
k = ConversionSpecifier::gArg;
break;
- case 'i':
+ case u8'i':
k = ConversionSpecifier::iArg;
break;
- case 'n':
+ case u8'n':
// Not handled, but reserved in OpenCL.
if (!LO.OpenCL)
k = ConversionSpecifier::nArg;
break;
- case 'o':
+ case u8'o':
k = ConversionSpecifier::oArg;
break;
- case 'p':
+ case u8'p':
k = ConversionSpecifier::pArg;
break;
- case 's':
+ case u8's':
k = ConversionSpecifier::sArg;
break;
- case 'u':
+ case u8'u':
k = ConversionSpecifier::uArg;
break;
- case 'x':
+ case u8'x':
k = ConversionSpecifier::xArg;
break;
// C23.
- case 'b':
+ case u8'b':
if (IsFreeBSDKPrintf)
k = ConversionSpecifier::FreeBSDbArg; // int followed by char *
else
k = ConversionSpecifier::bArg;
break;
- case 'B':
+ case u8'B':
k = ConversionSpecifier::BArg;
break;
// POSIX specific.
- case 'C':
+ case u8'C':
k = ConversionSpecifier::CArg;
break;
- case 'S':
+ case u8'S':
k = ConversionSpecifier::SArg;
break;
// Apple extension for os_log
- case 'P':
+ case u8'P':
k = ConversionSpecifier::PArg;
break;
// Objective-C.
- case '@':
+ case u8'@':
k = ConversionSpecifier::ObjCObjArg;
break;
// Glibc specific.
- case 'm':
+ case u8'm':
k = ConversionSpecifier::PrintErrno;
break;
- case 'r':
+ case u8'r':
if (IsFreeBSDKPrintf)
k = ConversionSpecifier::FreeBSDrArg; // int
else if (LO.FixedPoint)
k = ConversionSpecifier::rArg;
break;
- case 'y':
+ case u8'y':
if (IsFreeBSDKPrintf)
k = ConversionSpecifier::FreeBSDyArg; // int
break;
// Apple-specific.
- case 'D':
+ case u8'D':
if (IsFreeBSDKPrintf)
k = ConversionSpecifier::FreeBSDDArg; // void * followed by char *
else if (Target.getTriple().isOSDarwin())
k = ConversionSpecifier::DArg;
break;
- case 'O':
+ case u8'O':
if (Target.getTriple().isOSDarwin())
k = ConversionSpecifier::OArg;
break;
- case 'U':
+ case u8'U':
if (Target.getTriple().isOSDarwin())
k = ConversionSpecifier::UArg;
break;
// MS specific.
- case 'Z':
+ case u8'Z':
if (Target.getTriple().isOSMSVCRT())
k = ConversionSpecifier::ZArg;
break;
// ISO/IEC TR 18037 (fixed-point) specific.
// NOTE: 'r' is handled up above since FreeBSD also supports %r.
- case 'k':
+ case u8'k':
if (LO.FixedPoint)
k = ConversionSpecifier::kArg;
break;
- case 'K':
+ case u8'K':
if (LO.FixedPoint)
k = ConversionSpecifier::KArg;
break;
- case 'R':
+ case u8'R':
if (LO.FixedPoint)
k = ConversionSpecifier::RArg;
break;
@@ -501,9 +521,8 @@ bool clang::analyze_format_string::ParsePrintfString(
const TargetInfo &Target, bool isFreeBSDKPrintf) {
unsigned argIndex = 0;
-
- // Keep looking for a format specifier until we have exhausted the string.
llvm::TextEncodingConverter Conv = makeFormatStrConverter(Target);
+ // Keep looking for a format specifier until we have exhausted the string.
PrintfFormatStringParser P(H, LO, Target, /*Warn=*/true, isFreeBSDKPrintf,
Conv);
while (I != E) {
@@ -530,7 +549,6 @@ bool clang::analyze_format_string::ParseFormatStringHasSArg(
const TargetInfo &Target) {
unsigned argIndex = 0;
-
// Keep looking for a %s format specifier until we have exhausted the string.
FormatStringHandler H;
llvm::TextEncodingConverter Conv = makeFormatStrConverter(Target);
diff --git a/clang/lib/AST/ScanfFormatString.cpp b/clang/lib/AST/ScanfFormatString.cpp
index e36588b317146..ae3ccd63d3f0c 100644
--- a/clang/lib/AST/ScanfFormatString.cpp
+++ b/clang/lib/AST/ScanfFormatString.cpp
@@ -13,7 +13,6 @@
#include "FormatStringParsing.h"
#include "clang/AST/FormatString.h"
-#include "clang/Basic/TargetInfo.h"
using clang::UpdateOnReturn;
using clang::analyze_format_string::ArgType;
@@ -99,7 +98,6 @@ ScanfFormatStringParser::parseSpecifier(const char *&Beg, const char *E,
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;
@@ -108,7 +106,7 @@ ScanfFormatStringParser::parseSpecifier(const char *&Beg, const char *E,
H.HandleNullChar(I);
return true;
}
- if (c == '%') {
+ if (FormatStrConverter.convertBasicChar(c) == u8'%') {
Start = I++; // Record the start of the format specifier.
break;
}
@@ -135,7 +133,7 @@ ScanfFormatStringParser::parseSpecifier(const char *&Beg, const char *E,
}
// Look for '*' flag if it is present.
- if (*I == '*') {
+ if (FormatStrConverter.convertBasicChar(*I) == u8'*') {
FS.setSuppressAssignment(I);
if (++I == E) {
H.HandleIncompleteSpecifier(Start, E - Start);
@@ -173,89 +171,89 @@ ScanfFormatStringParser::parseSpecifier(const char *&Beg, const char *E,
// Finally, look for the conversion specifier.
const char *conversionPosition = I++;
ScanfConversionSpecifier::Kind k = ScanfConversionSpecifier::InvalidSpecifier;
- switch (*conversionPosition) {
+ switch (FormatStrConverter.convertBasicChar(*conversionPosition)) {
default:
break;
- case '%':
+ case u8'%':
k = ConversionSpecifier::PercentArg;
break;
- case 'b':
+ case u8'b':
k = ConversionSpecifier::bArg;
break;
- case 'A':
+ case u8'A':
k = ConversionSpecifier::AArg;
break;
- case 'E':
+ case u8'E':
k = ConversionSpecifier::EArg;
break;
- case 'F':
+ case u8'F':
k = ConversionSpecifier::FArg;
break;
- case 'G':
+ case u8'G':
k = ConversionSpecifier::GArg;
break;
- case 'X':
+ case u8'X':
k = ConversionSpecifier::XArg;
break;
- case 'a':
+ case u8'a':
k = ConversionSpecifier::aArg;
break;
- case 'd':
+ case u8'd':
k = ConversionSpecifier::dArg;
break;
- case 'e':
+ case u8'e':
k = ConversionSpecifier::eArg;
break;
- case 'f':
+ case u8'f':
k = ConversionSpecifier::fArg;
break;
- case 'g':
+ case u8'g':
k = ConversionSpecifier::gArg;
break;
- case 'i':
+ case u8'i':
k = ConversionSpecifier::iArg;
break;
- case 'n':
+ case u8'n':
k = ConversionSpecifier::nArg;
break;
- case 'c':
+ case u8'c':
k = ConversionSpecifier::cArg;
break;
- case 'C':
+ case u8'C':
k = ConversionSpecifier::CArg;
break;
- case 'S':
+ case u8'S':
k = ConversionSpecifier::SArg;
break;
- case '[':
+ case u8'[':
k = ConversionSpecifier::ScanListArg;
break;
- case 'u':
+ case u8'u':
k = ConversionSpecifier::uArg;
break;
- case 'x':
+ case u8'x':
k = ConversionSpecifier::xArg;
break;
- case 'o':
+ case u8'o':
k = ConversionSpecifier::oArg;
break;
- case 's':
+ case u8's':
k = ConversionSpecifier::sArg;
break;
- case 'p':
+ case u8'p':
k = ConversionSpecifier::pArg;
break;
// Apple extensions
// Apple-specific
- case 'D':
+ case u8'D':
if (Target.getTriple().isOSDarwin())
k = ConversionSpecifier::DArg;
break;
- case 'O':
+ case u8'O':
if (Target.getTriple().isOSDarwin())
k = ConversionSpecifier::OArg;
break;
- case 'U':
+ case u8'U':
if (Target.getTriple().isOSDarwin())
k = ConversionSpecifier::UArg;
break;
@@ -633,7 +631,6 @@ bool clang::analyze_format_string::ParseScanfString(FormatStringHandler &H,
const char *E,
const LangOptions &LO,
const TargetInfo &Target) {
-
unsigned argIndex = 0;
// Keep looking for a format specifier until we have exhausted the string.
diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
index 080c08419aef8..ba834ce1e6e20 100644
--- a/clang/lib/Sema/SemaChecking.cpp
+++ b/clang/lib/Sema/SemaChecking.cpp
@@ -104,6 +104,7 @@
#include "llvm/Support/Locale.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/SaveAndRestore.h"
+#include "llvm/Support/TextEncoding.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/TargetParser/RISCVTargetParser.h"
#include "llvm/TargetParser/Triple.h"
@@ -8353,10 +8354,11 @@ class CheckFormatHandler : public analyze_format_string::FormatStringHandler {
ArrayRef<FixItHint> Fixit = {});
protected:
- bool HandleInvalidConversionSpecifier(unsigned argIndex, SourceLocation Loc,
- const char *startSpec,
- unsigned specifierLen,
- const char *csStart, unsigned csLen);
+ bool
+ HandleInvalidConversionSpecifier(unsigned argIndex, SourceLocation Loc,
+ const char *startSpec, unsigned specifierLen,
+ const char *csStart, unsigned csLen,
+ const llvm::TextEncodingConverter &Conv);
void HandlePositionalNonpositionalArgs(SourceLocation Loc,
const char *startSpec,
@@ -8603,7 +8605,8 @@ void UncoveredArgHandler::Diagnose(Sema &S, bool IsFunctionCall,
bool CheckFormatHandler::HandleInvalidConversionSpecifier(
unsigned argIndex, SourceLocation Loc, const char *startSpec,
- unsigned specifierLen, const char *csStart, unsigned csLen) {
+ unsigned specifierLen, const char *csStart, unsigned csLen,
+ const llvm::TextEncodingConverter &Conv) {
bool keepGoing = true;
if (argIndex < NumDataArgs) {
// Consider the argument coverered, even though the specifier doesn't
@@ -8618,7 +8621,15 @@ bool CheckFormatHandler::HandleInvalidConversionSpecifier(
keepGoing = false;
}
- StringRef Specifier(csStart, csLen);
+ // The csStart points to a character that has already been converted to the
+ // exec charset, so we have to reverse the conversion to allow diagnostic
+ // message to match an expected value when using -verify option,
+ SmallString<4> RS;
+ auto EC = Conv.convert(StringRef(csStart, csLen), RS);
+ if (EC) {
+ keepGoing = false;
+ }
+ llvm::StringRef Specifier(RS);
// If the specifier in non-printable, it could be the first byte of a UTF-8
// sequence. In that case, print the UTF-8 code point. If not, print the byte
@@ -8920,7 +8931,7 @@ bool CheckPrintfHandler::HandleInvalidPrintfConversionSpecifier(
return HandleInvalidConversionSpecifier(
FS.getArgIndex(), getLocationOfByte(CS.getStart()), startSpecifier,
- specifierLen, CS.getStart(), CS.getLength());
+ specifierLen, CS.getStart(), CS.getLength(), Conv);
}
void CheckPrintfHandler::handleInvalidMaskType(StringRef MaskType) {
@@ -10158,7 +10169,7 @@ bool CheckScanfHandler::HandleInvalidScanfConversionSpecifier(
return HandleInvalidConversionSpecifier(
FS.getArgIndex(), getLocationOfByte(CS.getStart()), startSpecifier,
- specifierLen, CS.getStart(), CS.getLength());
+ specifierLen, CS.getStart(), CS.getLength(), Conv);
}
bool CheckScanfHandler::HandleScanfSpecifier(
diff --git a/clang/lib/Sema/SemaStmtAsm.cpp b/clang/lib/Sema/SemaStmtAsm.cpp
index cfb537eba8034..fa41283ed0a44 100644
--- a/clang/lib/Sema/SemaStmtAsm.cpp
+++ b/clang/lib/Sema/SemaStmtAsm.cpp
@@ -267,6 +267,7 @@ ExprResult Sema::ActOnGCCAsmStmtString(Expr *Expr, bool ForAsmLabel,
}
return SL;
}
+
if (DiagnoseUnexpandedParameterPack(Expr))
return ExprError();
if (Expr->getDependence() != ExprDependence::None)
diff --git a/llvm/include/llvm/Support/TextEncoding.h b/llvm/include/llvm/Support/TextEncoding.h
index a994a98e57355..53f57bfdeea5a 100644
--- a/llvm/include/llvm/Support/TextEncoding.h
+++ b/llvm/include/llvm/Support/TextEncoding.h
@@ -138,6 +138,16 @@ class TextEncodingConverter {
return std::string(Result);
return EC;
}
+
+ // This method is used in format string handling and is only intended
+ // to support basic charsets, not multibyte characters.
+ char convertBasicChar(char SingleChar) const {
+ SmallString<1> Result;
+ auto EC = Converter->convert(StringRef(&SingleChar, 1), Result);
+ if (!EC)
+ return Result[0];
+ return '\0';
+ }
};
} // namespace llvm
>From dbdc71d500b5ad0a2960b942967178c17beefa58 Mon Sep 17 00:00:00 2001
From: Abhina Sreeskantharajan <Abhina.Sreeskantharajan at ibm.com>
Date: Wed, 18 Nov 2026 11:45:37 -0500
Subject: [PATCH 2/2] address comments
---
clang/lib/AST/FormatString.cpp | 22 +++++++--------
clang/lib/AST/PrintfFormatString.cpp | 42 +++++++++++-----------------
clang/lib/AST/ScanfFormatString.cpp | 7 +++--
clang/lib/Sema/SemaStmtAsm.cpp | 1 -
4 files changed, 31 insertions(+), 41 deletions(-)
diff --git a/clang/lib/AST/FormatString.cpp b/clang/lib/AST/FormatString.cpp
index 4c86d3a9a24f2..d44d4a59d15fd 100644
--- a/clang/lib/AST/FormatString.cpp
+++ b/clang/lib/AST/FormatString.cpp
@@ -64,16 +64,15 @@ OptionalAmount FormatStringParser::parseAmount(const char *&Beg,
bool FormatStringParser::parseWidthModifier(const char *&I, const char *E,
unsigned &BitWidth,
unsigned &ModifierLength) const {
- StringRef W = StringRef(I, E - I).take_while(llvm::isDigit);
- if (W.empty() || W.front() == '0')
+ if (I == E || FormatStrConverter.convertBasicChar(*I) == u8'0')
return false;
- if (W.getAsInteger(10, BitWidth))
+ OptionalAmount Amt = parseAmount(I, E);
+ if (Amt.getHowSpecified() != OptionalAmount::Constant)
return false;
- I = W.end();
- ModifierLength += W.size();
-
+ BitWidth = Amt.getConstantAmount();
+ ModifierLength += Amt.getConstantLength();
return true;
}
@@ -306,17 +305,17 @@ bool FormatStringParser::parseLengthModifier(FormatSpecifier &FS,
++I;
lmKind = LengthModifier::AsInt3264;
break;
- case 'H':
+ case u8'H':
if (LO.C23) {
lmKind = LengthModifier::AsDecimal32;
++I;
break;
}
return false;
- case 'D':
+ case u8'D':
if (LO.C23) {
++I;
- if (I != E && *I == 'D') {
+ if (I != E && FormatStrConverter.convertBasicChar(*I) == u8'D') {
++I;
lmKind = LengthModifier::AsDecimal128;
} else {
@@ -325,14 +324,15 @@ bool FormatStringParser::parseLengthModifier(FormatSpecifier &FS,
break;
}
return false;
- case 'w':
+ case u8'w':
if (LO.C23) {
const char *WidthModifier = I + 1;
unsigned BitWidth = 0;
unsigned ModifierLength = 1;
LengthModifier::Kind WidthKind = LengthModifier::AsIntN;
- if (WidthModifier != E && *WidthModifier == 'f') {
+ if (WidthModifier != E &&
+ FormatStrConverter.convertBasicChar(*WidthModifier) == u8'f') {
WidthModifier = I + 2;
ModifierLength = 2;
WidthKind = LengthModifier::AsFastIntN;
diff --git a/clang/lib/AST/PrintfFormatString.cpp b/clang/lib/AST/PrintfFormatString.cpp
index 130ab295c0074..7ef054d264571 100644
--- a/clang/lib/AST/PrintfFormatString.cpp
+++ b/clang/lib/AST/PrintfFormatString.cpp
@@ -86,7 +86,7 @@ bool PrintfFormatStringParser::parseObjCFlags(PrintfSpecifier &FS,
}
// Handle either the case of no flag or an invalid flag.
if (Warn) {
- if (Flag == "")
+ if (Flag.empty())
H.HandleEmptyObjCModifierFlag(FlagBeg, E - FlagBeg);
else
H.HandleInvalidObjCModifierFlag(FlagBeg, E - FlagBeg);
@@ -146,9 +146,8 @@ PrintfFormatStringParser::parseSpecifier(const char *&Beg, const char *E,
StringRef MatchedStr;
do {
- const char *II;
std::string S(I, E - I);
- for (unsigned long i = 0; i < S.length(); ++i)
+ for (size_t i = 0; i < S.length(); ++i)
S[i] = FormatStrConverter.convertBasicChar(S[i]);
StringRef Str(S);
std::string Match = "^[[:space:]]*"
@@ -158,37 +157,28 @@ PrintfFormatStringParser::parseSpecifier(const char *&Beg, const char *E,
SmallVector<StringRef, 2> Matches;
if (R.match(Str, &Matches)) {
- MatchedStr = Matches[1];
- II = I;
+ StringRef MatchedStrUTF8 = Matches[1];
+ MatchedStr =
+ StringRef(I + (Matches[1].data() - Str.data()), Matches[1].size());
I += Matches[0].size();
- while (FormatStrConverter.convertBasicChar(*II) == u8' ')
- ++II;
-
// Set the privacy flag if the privacy annotation in the
// comma-delimited segment is at least as strict as the privacy
// annotations in previous comma-delimited segments.
- if (MatchedStr.starts_with("mask")) {
- StringRef MaskType(II + sizeof("mask.") - 1,
- MatchedStr.size() - sizeof("mask.") + 1);
+ if (MatchedStrUTF8.starts_with("mask")) {
+ StringRef MaskType = MatchedStr.substr(sizeof("mask.") - 1);
unsigned Size = MaskType.size();
if (Warn && (Size == 0 || Size > 8))
H.handleInvalidMaskType(MaskType);
FS.setMaskType(MaskType);
- } else if (MatchedStr == "sensitive") {
- StringRef ProxyMatchedStr(II, sizeof("sensitive") - 1);
- MatchedStr = ProxyMatchedStr;
+ } else if (MatchedStrUTF8 == "sensitive") {
PrivacyFlags = clang::analyze_os_log::OSLogBufferItem::IsSensitive;
} else if (PrivacyFlags !=
clang::analyze_os_log::OSLogBufferItem::IsSensitive &&
- MatchedStr == "private") {
- StringRef ProxyMatchedStr(II, sizeof("private") - 1);
- MatchedStr = ProxyMatchedStr;
+ MatchedStrUTF8 == "private") {
PrivacyFlags = clang::analyze_os_log::OSLogBufferItem::IsPrivate;
- } else if (PrivacyFlags == 0 && MatchedStr == "public") {
- StringRef ProxyMatchedStr(II, sizeof("public") - 1);
- MatchedStr = ProxyMatchedStr;
+ } else if (PrivacyFlags == 0 && MatchedStrUTF8 == "public") {
PrivacyFlags = clang::analyze_os_log::OSLogBufferItem::IsPublic;
}
} else {
@@ -232,23 +222,23 @@ PrintfFormatStringParser::parseSpecifier(const char *&Beg, const char *E,
default:
hasMore = false;
break;
- case '\'':
+ case u8'\'':
// FIXME: POSIX specific. Always accept?
FS.setHasThousandsGrouping(I);
break;
- case '-':
+ case u8'-':
FS.setIsLeftJustified(I);
break;
- case '+':
+ case u8'+':
FS.setHasPlusPrefix(I);
break;
- case ' ':
+ case u8' ':
FS.setHasSpacePrefix(I);
break;
- case '#':
+ case u8'#':
FS.setHasAlternativeForm(I);
break;
- case '0':
+ case u8'0':
FS.setHasLeadingZeros(I);
break;
}
diff --git a/clang/lib/AST/ScanfFormatString.cpp b/clang/lib/AST/ScanfFormatString.cpp
index ae3ccd63d3f0c..7391f545a49c3 100644
--- a/clang/lib/AST/ScanfFormatString.cpp
+++ b/clang/lib/AST/ScanfFormatString.cpp
@@ -60,7 +60,7 @@ bool ScanfFormatStringParser::parseScanList(ScanfConversionSpecifier &CS,
}
// Special case: ']' is the first character.
- if (*I == ']') {
+ if (FormatStrConverter.convertBasicChar(*I) == u8']') {
if (++I == E) {
H.HandleIncompleteScanList(start, I - 1);
return true;
@@ -68,7 +68,8 @@ bool ScanfFormatStringParser::parseScanList(ScanfConversionSpecifier &CS,
}
// Special case: "^]" are the first characters.
- if (I + 1 != E && I[0] == '^' && I[1] == ']') {
+ if (I + 1 != E && FormatStrConverter.convertBasicChar(I[0]) == u8'^' &&
+ FormatStrConverter.convertBasicChar(I[1]) == u8']') {
I += 2;
if (I == E) {
H.HandleIncompleteScanList(start, I - 1);
@@ -77,7 +78,7 @@ bool ScanfFormatStringParser::parseScanList(ScanfConversionSpecifier &CS,
}
// Look for a ']' character which denotes the end of the scan list.
- while (*I != ']') {
+ while (FormatStrConverter.convertBasicChar(*I) != u8']') {
if (++I == E) {
H.HandleIncompleteScanList(start, I - 1);
return true;
diff --git a/clang/lib/Sema/SemaStmtAsm.cpp b/clang/lib/Sema/SemaStmtAsm.cpp
index fa41283ed0a44..cfb537eba8034 100644
--- a/clang/lib/Sema/SemaStmtAsm.cpp
+++ b/clang/lib/Sema/SemaStmtAsm.cpp
@@ -267,7 +267,6 @@ ExprResult Sema::ActOnGCCAsmStmtString(Expr *Expr, bool ForAsmLabel,
}
return SL;
}
-
if (DiagnoseUnexpandedParameterPack(Expr))
return ExprError();
if (Expr->getDependence() != ExprDependence::None)
More information about the llvm-branch-commits
mailing list