[compiler-rt] Support glibc's non-standard I printf flag character

[sberg]

Summary

(see https://sourceware.org/git/?p=glibc.git;a=commit;h=4295702fe36902ad82587748b918d828ce62c446 "[...] stdio-common/vfprintf.c: Implement 'I' flag to print using locales' outdigits." for a source)

[sberg]

ping

[hubert.reinterpretcast]

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors_format.inc

410

Note that Clang favours the MSVCRT interpretation of printf("%I64d\n", 42LL);.

[sberg]

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors_format.inc

410

But then again all of this code is guarded by

#if SANITIZER_INTERCEPT_PRINTF

and the only place to define SANITIZER_INTERCEPT_PRINTF appears to be

# define SANITIZER_INTERCEPT_PRINTF SI_POSIX

in compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h, so it looks like this code is only used for Posix environments, at least for now?

But maybe it would be better to only include I in the above string literal conditionally on SI_POSIX (or SANITIZER_POSIX, which appears to be the same thing, cf. llvm-project/compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h)?

[hubert.reinterpretcast]

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors_format.inc

410

The more specific guarding here sounds like a good idea to me (but I have very little exposure to/experience in the sanitizer code). SI_POSIX would at least take out the Windows side of things in terms of considerations.

Would using __GLIBC_PREREQ make sense here? Or is that too specific?

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors_format.inc

 // and http://pubs.opengroup.org/onlinepubs/9699919799/functions/fprintf.html
 // with a few common GNU extensions.
 //
 //===----------------------------------------------------------------------===//
 
 #include <stdarg.h>
 
 static const char *parse_number(const char *p, int *out) {
   *out = internal_atoll(p);
   while (*p >= '0' && *p <= '9')
     ++p;
   return p;
 }
 
 static const char *maybe_parse_param_index(const char *p, int *out) {
   // n$
   if (*p >= '0' && *p <= '9') {
     int number;
     const char *q = parse_number(p, &number);
     CHECK(q);
     if (*q == '$') {
       *out = number;
       p = q + 1;
     }
   }
 
   // Otherwise, do not change p. This will be re-parsed later as the field
   // width.
   return p;
 }
 
 static bool char_is_one_of(char c, const char *s) {
   return !!internal_strchr(s, c);
 }
 
 static const char *maybe_parse_length_modifier(const char *p, char ll[2]) {
   if (char_is_one_of(*p, "jztLq")) {
     ll[0] = *p;
     ++p;
   } else if (*p == 'h') {
     ll[0] = 'h';
case 'h':
       return lengthModifier[1] == 'h' ? sizeof(char) : sizeof(short);
     case 'l':
       return lengthModifier[1] == 'l' ? sizeof(long long) : sizeof(long);
     case 'q':
       return sizeof(long long);
     case 'L':
       return sizeof(long long);
     case 'j':
       return sizeof(INTMAX_T);
     case 'z':
       return sizeof(SIZE_T);
     case 't':
       return sizeof(PTRDIFF_T);
     case 0:
       return sizeof(int);
     default:
       return FSS_INVALID;
     }
   }
 
   if (format_is_float_conv(convSpecifier)) {

 };
 
 // Parse scanf format string. If a valid directive in encountered, it is
 // returned in dir. This function returns the pointer to the first
 // unprocessed character, or 0 in case of error.
 // In case of the end-of-string, a pointer to the closing \0 is returned.
 static const char *scanf_parse_next(const char *p, bool allowGnuMalloc,
                                     ScanfDirective *dir) {
   internal_memset(dir, 0, sizeof(*dir));
   dir->argIdx = -1;
 
   while (*p) {
     if (*p != '%') {
       ++p;
       continue;
     }
     dir->begin = p;
     ++p;
     // %%
     if (*p == '%') {
       ++p;
       continue;
     }
     if (*p == '\0') {
       return nullptr;
     }
     // %n$
     p = maybe_parse_param_index(p, &dir->argIdx);
     CHECK(p);
     // *
     if (*p == '*') {
       dir->suppressed = true;
       ++p;
     }
     // Field width
     if (*p >= '0' && *p <= '9') {
       p = parse_number(p, &dir->fieldWidth);
       CHECK(p);
       if (dir->fieldWidth <= 0)  // Width if at all must be non-zero
         return nullptr;
     }
     // m
     if (*p == 'm') {
       dir->allocate = true;
       ++p;
     }
static int scanf_get_value_size(ScanfDirective *dir) {
   return format_get_value_size(dir->convSpecifier, dir->lengthModifier, false);
 }
 
 // Common part of *scanf interceptors.
 // Process format string and va_list, and report all store ranges.
 // Stops when "consuming" n_inputs input items.
 static void scanf_common(void *ctx, int n_inputs, bool allowGnuMalloc,
                          const char *format, va_list aq) {
   CHECK_GT(n_inputs, 0);
   const char *p = format;
 
   COMMON_INTERCEPTOR_READ_RANGE(ctx, format, internal_strlen(format) + 1);
 
   while (*p) {
     ScanfDirective dir;
     p = scanf_parse_next(p, allowGnuMalloc, &dir);
     if (!p)
       break;
     if (dir.convSpecifier == 0) {
       // This can only happen at the end of the format string.
       CHECK_EQ(*p, 0);
       break;
     }
     // Here the directive is valid. Do what it says.
     if (dir.argIdx != -1) {
       // Unsupported.
       break;
     }
     if (dir.suppressed)
       continue;
     int size = scanf_get_value_size(&dir);
     if (size == FSS_INVALID) {
       Report("%s: WARNING: unexpected format specifier in scanf interceptor: ",
              SanitizerToolName, "%.*s\n", dir.end - dir.begin, dir.begin);
       break;
     }
     void *argp = va_arg(aq, void *);
     if (dir.convSpecifier != 'n')
       --n_inputs;
     if (n_inputs < 0)
       break;
     if (size == FSS_STRLEN) {
       size = internal_strlen((const char *)argp) + 1;
     } else if (size == FSS_WCSLEN) {
       // FIXME: actually use wcslen() to calculate it.
       size = 0;
     }
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, argp, size);
     // For %ms/%mc, write the allocated output buffer as well.
     if (dir.allocate) {
       char *buf = *(char **)argp;
       if (buf)
         COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, internal_strlen(buf) + 1);
     }
   }
 }
 
 #if SANITIZER_INTERCEPT_PRINTF
 
 struct PrintfDirective {
   int fieldWidth;
while (*p) {
     }
     if (*p == '\0') {
       return nullptr;
     }
     // %n$
     p = maybe_parse_param_index(p, &dir->precisionIdx);
     CHECK(p);
     // Flags
-    while (char_is_one_of(*p, "'-+ #0")) {
+    while (char_is_one_of(*p, "'-+ #0I")) {
       ++p;
     }
     // Field width
     p = maybe_parse_number_or_star(p, &dir->fieldWidth,
                                    &dir->starredWidth);
     if (!p)
       return nullptr;
     // Precision