[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