[Sema] -Wformat: support C23 format specifier %b %B

[MaskRay]

Summary

Close #56885: WG14 N2630 added %b to fprintf/fscanf and recommended %B for
fprintf. This patch teaches -Wformat %b for the printf/scanf family of functions
and %B for the printf family of functions.

glibc 2.35 and latest Android bionic added %b/%B printf support. From
https://www.openwall.com/lists/libc-coord/2022/07/ no scanf support is available
yet.

Like GCC, we don't test library support.

GCC 12 -Wformat -pedantic emits a warning:

warning: ISO C17 does not support the ‘%b’ gnu_printf format [-Wformat=]

The behavior is not ported.

Note: freebsd_kernel_printf uses %b differently.

[dim]

LGTM.

[dim]

GCC 12 -Wformat -pedantic emits a warning:

warning: ISO C17 does not support the ‘%b’ gnu_printf format [-Wformat=]

The behavior is not ported (and it's unclear to me how to implement it).

If you really want this, I think it can be implemented by looking at LangOpts::LangStd.

[enh]

thanks!

[aaron.ballman]

Thanks for working on this! Please also add a release note for it.

I think there are changes missing for ScanfFormatString.cpp to handle bArg and BArg that should be handled at the same time. WDYT?

[MaskRay]

In D131057#3697165, @aaron.ballman wrote:

Thanks for working on this! Please also add a release note for it.

Will add:)

I think there are changes missing for ScanfFormatString.cpp to handle bArg and BArg that should be handled at the same time. WDYT?

I noticed this: https://github.com/llvm/llvm-project/issues/56885#issuecomment-1203636181

I think making scanf in the same patch makes sense. Let me check existing tests...

[enh]

I think making scanf in the same patch makes sense. Let me check existing tests...

fwiw, most of the libcs seem to have been doing these separately because scanf is harder. i hope to have bionic's scanf done this week though.

(note in case you haven't already that there is no %B for scanf, just %b...)

[aaron.ballman]

In D131057#3697265, @enh wrote:

I think making scanf in the same patch makes sense. Let me check existing tests...

fwiw, most of the libcs seem to have been doing these separately because scanf is harder. i hope to have bionic's scanf done this week though.

(note in case you haven't already that there is no %B for scanf, just %b...)

Whoops, you're right, that recommended practice I saw nearby was for fwprintf and not fscanf.

[MaskRay]

add scanf support

[MaskRay]

In D131057#3697265, @enh wrote:

I think making scanf in the same patch makes sense. Let me check existing tests...

fwiw, most of the libcs seem to have been doing these separately because scanf is harder. i hope to have bionic's scanf done this week though.

(note in case you haven't already that there is no %B for scanf, just %b...)

Thanks for the reminder:) I subscribed to https://www.openwall.com/lists/libc-coord/2022/08/ but working on this issue led me to read the discussion:)

scanf("%B", i); // expected-warning{{invalid conversion specifier 'B'}} tests this.

In D131057#3697095, @dim wrote:

GCC 12 -Wformat -pedantic emits a warning:

warning: ISO C17 does not support the ‘%b’ gnu_printf format [-Wformat=]

The behavior is not ported (and it's unclear to me how to implement it).

If you really want this, I think it can be implemented by looking at LangOpts::LangStd.

Something like !getLangOpts().C2X I suppose, but I do not find how to check both -Wformat and -Wpedantic.
Also, for the nature of the diagnostic, I think something in TableGen like def ext_... InGroup<C2x> would make sense but using a C23/C2x related -W option would deviate from the GCC behavior.
ISTM adding the diagnostic (even if we do) is not so necessary in this patch.

[aaron.ballman]

In D131057#3697392, @MaskRay wrote:

ISTM adding the diagnostic (even if we do) is not so necessary in this patch.

I tend to agree. I think we'll want such a diagnostic at some point, and I think it's fine to deviate from the warning group GCC uses. We already have diagnostic grouping patterns for this sort of thing and we should use those consistently.

LGTM with some minor corrections to the release note. Thanks for this!

clang/docs/ReleaseNotes.rst

70–71

[MaskRay]

Thanks for quick reviews!
Updated ReleaseNotes.rst

[enh]

In D131057#3697392, @MaskRay wrote:

In D131057#3697095, @dim wrote:

GCC 12 -Wformat -pedantic emits a warning:

warning: ISO C17 does not support the ‘%b’ gnu_printf format [-Wformat=]

The behavior is not ported (and it's unclear to me how to implement it).

If you really want this, I think it can be implemented by looking at LangOpts::LangStd.

Something like !getLangOpts().C2X I suppose, but I do not find how to check both -Wformat and -Wpedantic.
Also, for the nature of the diagnostic, I think something in TableGen like def ext_... InGroup<C2x> would make sense but using a C23/C2x related -W option would deviate from the GCC behavior.
ISTM adding the diagnostic (even if we do) is not so necessary in this patch.

note that that's not even what we'd want for Android anyway ... availability and behavior on Android is always[1] predicated on the API level, not the C standard. app developers can't avoid dealing with the API level, so we've avoided having an orthogonal versioning concern for them. (this is true in the headers too, not just behavior: on Android you always get the API-level-appropriate _library_ no matter what version of the language you select.)

and, like i said elsewhere, no-one's ever noticed that clang just assumes %m is always available. even though _i've_ wanted %b since i was a kid[2], i'm not actually expecting %b will be heavily used in practice. (tbh, i doubt %b will ever be used in scanf() outside of tests. as far as i'm concerned only the printf() side is actually useful...)

---

1. the removal of gets() is the only exception that springs to mind.
2. even though i know that for weird-ass machines like the PDP series, octal was more useful than it is to the rest of us, i still can't believe %b wasn't in B, let alone C!

clang/docs/ReleaseNotes.rst

- No longer assert/miscompile when trying to make a vectorized ``_BitInt`` type
   already properly diagnosing this case).
 
 Improvements to Clang's diagnostics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 - Clang will now correctly diagnose as ill-formed a constant expression where an
   enum without a fixed underlying type is set to a value outside the range of
   the enumeration's values. Fixes
   `Issue 50055: <https://github.com/llvm/llvm-project/issues/50055>`_.
 - Clang will now check compile-time determinable string literals as format strings.
   This fixes `Issue 55805: <https://github.com/llvm/llvm-project/issues/55805>`_.
+- ``-Wformat`` now recognizes ``%b`` for the ``printf``/``scanf`` family of
+  functions and ``%B`` for the ``printf`` family of functions. Fixes
+  `Issue 56885: <https://github.com/llvm/llvm-project/issues/56885>`_.
 
 Non-comprehensive list of changes in this release
 -------------------------------------------------
 
 New Compiler Flags
 ------------------
 
 Deprecated Compiler Flags

clang/include/clang/AST/FormatString.h

 public:
   enum Kind {
     InvalidSpecifier = 0,
     // C99 conversion specifiers.
     cArg,
     dArg,
     DArg, // Apple extension
     iArg,
+    // C23 conversion specifiers.
+    bArg,
+    BArg,
+
     IntArgBeg = dArg,
-    IntArgEnd = iArg,
+    IntArgEnd = BArg,
 
     oArg,
     OArg, // Apple extension
     uArg,
     UArg, // Apple extension
     xArg,
     XArg,
     UIntArgBeg = oArg,

clang/lib/AST/FormatString.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // Methods on ConversionSpecifier.
 //===----------------------------------------------------------------------===//
 
 const char *ConversionSpecifier::toString() const {
   switch (kind) {
+  case bArg: return "b";
+  case BArg: return "B";
   case dArg: return "d";
   case DArg: return "D";
   case iArg: return "i";
   case oArg: return "o";
   case OArg: return "O";
   case uArg: return "u";
   case UArg: return "U";
   case xArg: return "x";
case LengthModifier::AsShort:
       LLVM_FALLTHROUGH;
     case LengthModifier::AsChar:
     case LengthModifier::AsLongLong:
     case LengthModifier::AsQuad:
     case LengthModifier::AsIntMax:
     case LengthModifier::AsSizeT:
     case LengthModifier::AsPtrDiff:
       switch (CS.getKind()) {
+        case ConversionSpecifier::bArg:
+        case ConversionSpecifier::BArg:
         case ConversionSpecifier::dArg:
         case ConversionSpecifier::DArg:
         case ConversionSpecifier::iArg:
         case ConversionSpecifier::oArg:
         case ConversionSpecifier::OArg:
         case ConversionSpecifier::uArg:
         case ConversionSpecifier::UArg:
         case ConversionSpecifier::xArg:
case LengthModifier::AsShortLong: // ???
       return false;
   }
   llvm_unreachable("Invalid LengthModifier Kind!");
 }
 
 bool FormatSpecifier::hasStandardConversionSpecifier(
     const LangOptions &LangOpt) const {
   switch (CS.getKind()) {
+    case ConversionSpecifier::bArg:
+    case ConversionSpecifier::BArg:
     case ConversionSpecifier::cArg:
     case ConversionSpecifier::dArg:
     case ConversionSpecifier::iArg:
     case ConversionSpecifier::oArg:
     case ConversionSpecifier::uArg:
     case ConversionSpecifier::xArg:
     case ConversionSpecifier::XArg:
     case ConversionSpecifier::fArg:

clang/lib/AST/PrintfFormatString.cpp

case 'n':
       if (!LO.OpenCL)
         k = ConversionSpecifier::nArg;
       break;
     case 'o': k = ConversionSpecifier::oArg; break;
     case 'p': k = ConversionSpecifier::pArg; break;
     case 's': k = ConversionSpecifier::sArg; break;
     case 'u': k = ConversionSpecifier::uArg; break;
     case 'x': k = ConversionSpecifier::xArg; break;
+    // C23.
+    case 'b':
+      if (isFreeBSDKPrintf)
+        k = ConversionSpecifier::FreeBSDbArg; // int followed by char *
+      else
+        k = ConversionSpecifier::bArg;
+      break;
+    case 'B': k = ConversionSpecifier::BArg; break;
     // POSIX specific.
     case 'C': k = ConversionSpecifier::CArg; break;
     case 'S': k = ConversionSpecifier::SArg; break;
     // Apple extension for os_log
     case 'P':
       k = ConversionSpecifier::PArg;
       break;
     // Objective-C.
     case '@': k = ConversionSpecifier::ObjCObjArg; break;
     // Glibc specific.
     case 'm': k = ConversionSpecifier::PrintErrno; break;
-    // FreeBSD kernel specific.
-    case 'b':
-      if (isFreeBSDKPrintf)
-        k = ConversionSpecifier::FreeBSDbArg; // int followed by char *
-      break;
     case 'r':
       if (isFreeBSDKPrintf)
         k = ConversionSpecifier::FreeBSDrArg; // int
       break;
     case 'y':
       if (isFreeBSDKPrintf)
         k = ConversionSpecifier::FreeBSDyArg; // int
       break;
default:
     return false;
   }
 }
 
 bool PrintfSpecifier::hasValidAlternativeForm() const {
   if (!HasAlternativeForm)
     return true;
 
-  // Alternate form flag only valid with the oxXaAeEfFgG conversions
+  // Alternate form flag only valid with the bBoxXaAeEfFgG conversions
   switch (CS.getKind()) {
+  case ConversionSpecifier::bArg:
+  case ConversionSpecifier::BArg:
   case ConversionSpecifier::oArg:
   case ConversionSpecifier::OArg:
   case ConversionSpecifier::xArg:
   case ConversionSpecifier::XArg:
   case ConversionSpecifier::aArg:
   case ConversionSpecifier::AArg:
   case ConversionSpecifier::eArg:
   case ConversionSpecifier::EArg:
default:
     return false;
   }
 }
 
 bool PrintfSpecifier::hasValidLeadingZeros() const {
   if (!HasLeadingZeroes)
     return true;
 
-  // Leading zeroes flag only valid with the diouxXaAeEfFgG conversions
+  // Leading zeroes flag only valid with the bBdiouxXaAeEfFgG conversions
   switch (CS.getKind()) {
+  case ConversionSpecifier::bArg:
+  case ConversionSpecifier::BArg:
   case ConversionSpecifier::dArg:
   case ConversionSpecifier::DArg:
   case ConversionSpecifier::iArg:
   case ConversionSpecifier::oArg:
   case ConversionSpecifier::OArg:
   case ConversionSpecifier::uArg:
   case ConversionSpecifier::UArg:
   case ConversionSpecifier::xArg:
default:
       return false;
   }
 }
 
 bool PrintfSpecifier::hasValidPrecision() const {
   if (Precision.getHowSpecified() == OptionalAmount::NotSpecified)
     return true;
 
-  // Precision is only valid with the diouxXaAeEfFgGsP conversions
+  // Precision is only valid with the bBdiouxXaAeEfFgGsP conversions
   switch (CS.getKind()) {
+  case ConversionSpecifier::bArg:
+  case ConversionSpecifier::BArg:
   case ConversionSpecifier::dArg:
   case ConversionSpecifier::DArg:
   case ConversionSpecifier::iArg:
   case ConversionSpecifier::oArg:
   case ConversionSpecifier::OArg:
   case ConversionSpecifier::uArg:
   case ConversionSpecifier::UArg:
   case ConversionSpecifier::xArg:

clang/lib/AST/ScanfFormatString.cpp

static ScanfSpecifierResult ParseScanfSpecifier(FormatStringHandler &H,
 
   // 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 ConversionSpecifier::iArg:
         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:

clang/test/Sema/format-strings-fixit.c

 typedef __PTRDIFF_TYPE__ ptrdiff_t;
 typedef __WCHAR_TYPE__ wchar_t;
 
 void test(void) {
   // Basic types
   printf("%s", (int) 123);
   printf("abc%0f", "testing testing 123");
   printf("%u", (long) -12);
+  printf("%b", (long) -13);
   printf("%p", 123);
   printf("%c\n", "x");
   printf("%c\n", 1.23);
 
   // Larger types
   printf("%+.2d", (unsigned long long) 123456);
   printf("%1d", (long double) 1.23);
 
void test2(int intSAParm[static 2]) {
   typedef int my_int_type;
   scanf("%f", (my_size_type*)&sizeVar);
   scanf("%f", (my_intmax_type*)&intmaxVar);
   scanf("%f", (my_uintmax_type*)&uIntmaxVar);
   scanf("%f", (my_ptrdiff_type*)&ptrdiffVar);
   scanf("%f", (my_int_type*)&intVar);
 
   // Preserve the original formatting.
+  scanf("%b", &longVar);
   scanf("%o", &longVar);
   scanf("%u", &longVar);
   scanf("%x", &longVar);
   scanf("%X", &longVar);
   scanf("%i", &uLongVar);
   scanf("%d", &uLongVar);
   scanf("%F", &longDoubleVar);
   scanf("%e", &longDoubleVar);
   scanf("%E", &longDoubleVar);
   scanf("%g", &longDoubleVar);
   scanf("%G", &longDoubleVar);
   scanf("%a", &longDoubleVar);
   scanf("%A", &longDoubleVar);
 }
 
 // Validate the fixes.
 // CHECK: printf("%d", (int) 123);
 // CHECK: printf("abc%s", "testing testing 123");
 // CHECK: printf("%ld", (long) -12);
+// CHECK: printf("%ld", (long) -13);
 // CHECK: printf("%d", 123);
 // CHECK: printf("%s\n", "x");
 // CHECK: printf("%f\n", 1.23);
 // CHECK: printf("%+.2lld", (unsigned long long) 123456);
 // CHECK: printf("%1Lf", (long double) 1.23);
 // CHECK: printf("%0u", (unsigned) 31337);
 // CHECK: printf("%p", (void *) 0);
 // CHECK: printf("%+f", 1.23);

 // CHECK: scanf("%jd", &intmaxVar);
 // CHECK: scanf("%ju", &uIntmaxVar);
 // CHECK: scanf("%td", &ptrdiffVar);
 // CHECK: scanf("%zu", (my_size_type*)&sizeVar);
 // CHECK: scanf("%jd", (my_intmax_type*)&intmaxVar);
 // CHECK: scanf("%ju", (my_uintmax_type*)&uIntmaxVar);
 // CHECK: scanf("%td", (my_ptrdiff_type*)&ptrdiffVar);
 // CHECK: scanf("%d", (my_int_type*)&intVar);
+// CHECK: scanf("%ld", &longVar);
 // CHECK: scanf("%lo", &longVar);
 // CHECK: scanf("%lu", &longVar);
 // CHECK: scanf("%lx", &longVar);
 // CHECK: scanf("%lX", &longVar);
 // CHECK: scanf("%li", &uLongVar);
 // CHECK: scanf("%ld", &uLongVar);
 // CHECK: scanf("%LF", &longDoubleVar);
 // CHECK: scanf("%Le", &longDoubleVar);
 // CHECK: scanf("%LE", &longDoubleVar);
 // CHECK: scanf("%Lg", &longDoubleVar);
 // CHECK: scanf("%LG", &longDoubleVar);
 // CHECK: scanf("%La", &longDoubleVar);
 // CHECK: scanf("%LA", &longDoubleVar);

clang/test/Sema/format-strings-scanf.c

 int vfscanf(FILE * restrict, const char * restrict, va_list);
 int vsscanf(const char * restrict, const char * restrict, va_list);
 
 void test(const char *s, int *i) {
   scanf(s, i); // expected-warning{{format string is not a string literal}}
   scanf("%0d", i); // expected-warning{{zero field width in scanf format string is unused}}
   scanf("%00d", i); // expected-warning{{zero field width in scanf format string is unused}}
   scanf("%d%[asdfasdfd", i, s); // expected-warning{{no closing ']' for '%[' in scanf format string}}
+  scanf("%B", i); // expected-warning{{invalid conversion specifier 'B'}}
 
   unsigned short s_x;
   scanf ("%" "hu" "\n", &s_x); // no-warning
+  scanf("%hb", &s_x);
   scanf("%y", i); // expected-warning{{invalid conversion specifier 'y'}}
   scanf("%%"); // no-warning
   scanf("%%%1$d", i); // no-warning
   scanf("%1$d%%", i); // no-warning
   scanf("%d", i, i); // expected-warning{{data argument not used by format string}}
   scanf("%*d", i); // // expected-warning{{data argument not used by format string}}
   scanf("%*d", i); // // expected-warning{{data argument not used by format string}}
   scanf("%*d%1$d", i); // no-warning
 
   scanf("%s", (char*)0); // no-warning
   scanf("%s", (volatile char*)0); // no-warning
   scanf("%s", (signed char*)0); // no-warning
   scanf("%s", (unsigned char*)0); // no-warning
   scanf("%hhu", (signed char*)0); // no-warning
+  scanf("%hhb", (signed char*)0); // no-warning
 }
 
 void bad_length_modifiers(char *s, void *p, wchar_t *ws, long double *ld) {
   scanf("%hhs", "foo"); // expected-warning{{length modifier 'hh' results in undefined behavior or no effect with 's' conversion specifier}}
   scanf("%1$zp", &p); // expected-warning{{length modifier 'z' results in undefined behavior or no effect with 'p' conversion specifier}}
   scanf("%ls", ws); // no-warning
   scanf("%#.2Lf", ld); // expected-warning{{invalid conversion specifier '#'}}
 }
void test_qualifiers(const int *cip, volatile int* vip,
   typedef const int* cip_t;
   scanf("%d", (ip_t)0); // No warning.
   scanf("%d", (cip_t)0); // expected-warning{{format specifies type 'int *' but the argument has type 'cip_t' (aka 'const int *')}}
 }
 
 void test_size_types(void) {
   size_t s = 0;
   scanf("%zu", &s); // No warning.
+  scanf("%zb", &s);
 
   double d1 = 0.;
   scanf("%zu", &d1); // expected-warning-re{{format specifies type 'size_t *' (aka '{{.+}}') but the argument has type 'double *'}}
 
   ssize_t ss = 0;
   scanf("%zd", &s); // No warning.
 
   double d2 = 0.;
   scanf("%zd", &d2); // expected-warning-re{{format specifies type 'ssize_t *' (aka '{{.+}}') but the argument has type 'double *'}}
 
   ssize_t sn = 0;
   scanf("%zn", &sn); // No warning.
 
   double d3 = 0.;
   scanf("%zn", &d3); // expected-warning-re{{format specifies type 'ssize_t *' (aka '{{.+}}') but the argument has type 'double *'}}
 }
 
 void test_ptrdiff_t_types(void) {
   __UNSIGNED_PTRDIFF_TYPE__ p1 = 0;
   scanf("%tu", &p1); // No warning.
+  scanf("%tb", &p1);
 
   double d1 = 0.;
   scanf("%tu", &d1); // expected-warning-re{{format specifies type 'unsigned ptrdiff_t *' (aka '{{.+}}') but the argument has type 'double *'}}
 
   ptrdiff_t p2 = 0;
   scanf("%td", &p2); // No warning.
   
   double d2 = 0.;

clang/test/Sema/format-strings.c

void check_writeback_specifier(void)
   printf("%qn", (long long*)0); // expected-warning{{'%n' specifier not supported on this platform}}
   printf("%qn", (unsigned long long*)0); // expected-warning{{'%n' specifier not supported on this platform}}
 }
 
 #endif // !defined(__ANDROID__) && !defined(__Fuchsia__)
 
 void check_invalid_specifier(FILE* fp, char *buf)
 {
-  printf("%s%lb%d","unix",10,20); // expected-warning {{invalid conversion specifier 'b'}} expected-warning {{data argument not used by format string}}
+  printf("%s%lv%d","unix",10,20); // expected-warning {{invalid conversion specifier 'v'}} expected-warning {{data argument not used by format string}}
   fprintf(fp,"%%%l"); // expected-warning {{incomplete format specifier}}
   sprintf(buf,"%%%%%ld%d%d", 1, 2, 3); // expected-warning{{format specifies type 'long' but the argument has type 'int'}}
   snprintf(buf, 2, "%%%%%ld%;%d", 1, 2, 3); // expected-warning{{format specifies type 'long' but the argument has type 'int'}} expected-warning {{invalid conversion specifier ';'}} expected-warning {{data argument not used by format string}}
 }
 
 void check_null_char_string(char* b)
 {
   printf("\0this is bogus%d",1); // expected-warning {{string contains '\0'}}
void test10(int x, float f, int i, long long lli) {
   printf("%.d", x); // no-warning
   printf("%.", x);  // expected-warning{{incomplete format specifier}}
   printf("%f", 4); // expected-warning{{format specifies type 'double' but the argument has type 'int'}}
   printf("%qd", lli); // no-warning
   printf("%qd", x); // expected-warning{{format specifies type 'long long' but the argument has type 'int'}}
   printf("%qp", (void *)0); // expected-warning{{length modifier 'q' results in undefined behavior or no effect with 'p' conversion specifier}}
   printf("hhX %hhX", (unsigned char)10); // no-warning
   printf("llX %llX", (long long) 10); // no-warning
+  printf("%llb %llB", (long long) 10, (long long) 10); // no-warning
   // This is fine, because there is an implicit conversion to an int.
   printf("%d", (unsigned char) 10); // no-warning
   printf("%d", (long long) 10); // expected-warning{{format specifies type 'int' but the argument has type 'long long'}}
   printf("%Lf\n", (long double) 1.0); // no-warning
   printf("%f\n", (long double) 1.0); // expected-warning{{format specifies type 'double' but the argument has type 'long double'}}
   // The man page says that a zero precision is okay.
   printf("%.0Lf", (long double) 1.0); // no-warning
   printf("%c\n", "x"); // expected-warning{{format specifies type 'int' but the argument has type 'char *'}}
void bug7377_bad_length_mod_usage(void) {
   printf("%hhs", "foo"); // expected-warning{{length modifier 'hh' results in undefined behavior or no effect with 's' conversion specifier}}
   printf("%1$zp", (void *)0); // expected-warning{{length modifier 'z' results in undefined behavior or no effect with 'p' conversion specifier}}
   printf("%ls", L"foo"); // no-warning
   printf("%#.2Lf", (long double)1.234); // no-warning
 
   // Bad flag usage
   printf("%#p", (void *) 0); // expected-warning{{flag '#' results in undefined behavior with 'p' conversion specifier}}
   printf("%0d", -1); // no-warning
+  printf("%0b%0B", -1u, -1u); // no-warning
   printf("%-p", (void *) 0); // no-warning
 #if !defined(__ANDROID__) && !defined(__Fuchsia__)
   printf("%#n", (int *) 0); // expected-warning{{flag '#' results in undefined behavior with 'n' conversion specifier}}
   printf("%-n", (int *) 0); // expected-warning{{flag '-' results in undefined behavior with 'n' conversion specifier}}
 #else
   printf("%#n", (int *) 0); // expected-warning{{flag '#' results in undefined behavior with 'n' conversion specifier}}
   // expected-warning@-1 {{'%n' specifier not supported on this platform}}
   printf("%-n", (int *) 0); // expected-warning{{flag '-' results in undefined behavior with 'n' conversion specifier}}

 void rdar8332221(va_list ap, int *x, long *y) {
   rdar8332221_vprintf_scanf("%", ap, "%d", x); // expected-warning{{incomplete format specifier}}
 }
 
 // PR8641
 void pr8641(void) {
   printf("%#x\n", 10);
   printf("%#X\n", 10);
+  printf("%#b %#15.8B\n", 10, 10u);
 }
 
 void posix_extensions(void) {
   // Test %'d, "thousands grouping".
   // <rdar://problem/8816343>
   printf("%'d\n", 123456789); // no-warning
   printf("%'i\n", 123456789); // no-warning
   printf("%'f\n", (float) 1.0); // no-warning
   printf("%'p\n", (void*) 0); // expected-warning{{results in undefined behavior with 'p' conversion specifier}}
+  printf("%'b\n", 123456789); // expected-warning{{results in undefined behavior with 'b' conversion specifier}}
+  printf("%'B\n", 123456789); // expected-warning{{results in undefined behavior with 'B' conversion specifier}}
 }
 
 // PR8486
 //
 // Test what happens when -Wformat is on, but -Wformat-security is off.
 #pragma GCC diagnostic warning "-Wformat"
 #pragma GCC diagnostic ignored "-Wformat-security"
 

 
 void check_char(unsigned char x, signed char y) {
   printf("%c", y); // no-warning
   printf("%hhu", x); // no-warning
   printf("%hhi", y); // no-warning
   printf("%hhi", x); // no-warning
   printf("%c", x); // no-warning
   printf("%hhu", y); // no-warning
+  printf("%hhb %hhB", x, x); // no-warning
 }
 
 // Test suppression of individual warnings.
 
 void test_suppress_invalid_specifier(void) {
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wformat-invalid-specifier"
   printf("%@", 12); // no-warning

clang/test/SemaObjC/format-strings-objc.m

 int printf(const char * restrict, ...) ;
 
 //===----------------------------------------------------------------------===//
 // Test cases.
 //===----------------------------------------------------------------------===//
 
 void check_nslog(unsigned k) {
   NSLog(@"%d%%", k); // no-warning
-  NSLog(@"%s%lb%d", "unix", 10, 20); // expected-warning {{invalid conversion specifier 'b'}} expected-warning {{data argument not used by format string}}
+  NSLog(@"%s%lv%d", "unix", 10, 20); // expected-warning {{invalid conversion specifier 'v'}} expected-warning {{data argument not used by format string}}
 }
 
 // Check type validation
 extern void NSLog2(int format, ...) __attribute__((format(__NSString__, 1, 2))); // expected-error {{format argument not a string type}}
 extern void CFStringCreateWithFormat2(int *format, ...) __attribute__((format(CFString, 1, 2))); // expected-error {{format argument not a string type}}
 
 // Check interoperability of strings
 extern void NSLog3(const char *, ...) __attribute__((format(__NSString__, 1, 2)));