Revert "sanitizer_common: support printing __m128i type"

[dvyukov]

Summary

This reverts commits
"sanitizer_common: support printing __m128i type"
and "[sanitizer] Fix VSNPrintf %V on Windows".

Unfortunately, custom "%V" is inherently incompatible with -Wformat,
it produces both:
warning: invalid conversion specifier 'V' [-Wformat-invalid-specifier]
warning: data argument not used by format string [-Wformat-extra-args]
If we disable both of these warnings we lose lots of useful warnings as well.

Depends on D107978.

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_printf.cpp

165

please don't revert these two vars?
it was an improvement.

[dvyukov]

compiler-rt/lib/sanitizer_common/sanitizer_printf.cpp

165

I've added a separate https://reviews.llvm.org/D108015 for this to not revert revert of an unrelated change in a revert :)

compiler-rt/lib/sanitizer_common/sanitizer_common.h

public:
   T *begin() { return begin_; }
   T *end() { return end_; }
 
  private:
   T *begin_ = nullptr;
   T *end_ = nullptr;
 };
 
-#define PRINTF_128(v)                                                         \
-  (*((u8 *)&v + 0)), (*((u8 *)&v + 1)), (*((u8 *)&v + 2)), (*((u8 *)&v + 3)), \
-      (*((u8 *)&v + 4)), (*((u8 *)&v + 5)), (*((u8 *)&v + 6)),                \
-      (*((u8 *)&v + 7)), (*((u8 *)&v + 8)), (*((u8 *)&v + 9)),                \
-      (*((u8 *)&v + 10)), (*((u8 *)&v + 11)), (*((u8 *)&v + 12)),             \
-      (*((u8 *)&v + 13)), (*((u8 *)&v + 14)), (*((u8 *)&v + 15))
-
 }  // namespace __sanitizer
 
 inline void *operator new(__sanitizer::operator_new_size_type size,
                           __sanitizer::LowLevelAllocator &alloc) {
   return alloc.Allocate(size);
 }
 
 #endif  // SANITIZER_COMMON_H

compiler-rt/lib/sanitizer_common/sanitizer_printf.cpp

 
 #include "sanitizer_common.h"
 #include "sanitizer_flags.h"
 #include "sanitizer_libc.h"
 
 #include <stdio.h>
 #include <stdarg.h>
 
-#if defined(__x86_64__)
-#  include <emmintrin.h>
-#endif
-
 #if SANITIZER_WINDOWS && defined(_MSC_VER) && _MSC_VER < 1800 &&               \
       !defined(va_copy)
 # define va_copy(dst, src) ((dst) = (src))
 #endif
 
 namespace __sanitizer {
 
 static int AppendChar(char **buff, const char *buff_end, char c) {
result += AppendUnsigned(buff, buff_end, ptr_value, 16,
                            SANITIZER_POINTER_FORMAT_LENGTH,
                            true /* pad_with_zero */, false /* uppercase */);
   return result;
 }
 
 int VSNPrintf(char *buff, int buff_length,
               const char *format, va_list args) {
   static const char *kPrintfFormatsHelp =
-      "Supported Printf formats: %([0-9]*)?(z|ll)?{d,u,x,X,V}; %p; "
+      "Supported Printf formats: %([0-9]*)?(z|ll)?{d,u,x,X}; %p; "
       "%[-]([0-9]*)?(\\.\\*)?s; %c\n";
   RAW_CHECK(format);
   RAW_CHECK(buff_length > 0);
   const char *buff_end = &buff[buff_length - 1];
   const char *cur = format;
   int result = 0;
   for (; *cur; cur++) {
     if (*cur != '%') {
for (; *cur; cur++) {
     if (have_precision) {
       cur += 2;
       precision = va_arg(args, int);
     }
     bool have_z = (*cur == 'z');
     cur += have_z;
     bool have_ll = !have_z && (cur[0] == 'l' && cur[1] == 'l');
     cur += have_ll * 2;
+    s64 dval;
+    u64 uval;
     const bool have_length = have_z || have_ll;
     const bool have_flags = have_width || have_length;
     // At the moment only %s supports precision and left-justification.
     CHECK(!((precision >= 0 || left_justified) && *cur != 's'));
     switch (*cur) {
       case 'd': {
-        s64 dval = have_ll  ? va_arg(args, s64)
-                   : have_z ? va_arg(args, sptr)
-                            : va_arg(args, int);
+        dval = have_ll  ? va_arg(args, s64)
         result += AppendSignedDecimal(&buff, buff_end, dval, width,
                                       pad_with_zero);
         break;
       }
       case 'u':
       case 'x':
       case 'X': {
-        u64 uval = have_ll  ? va_arg(args, u64)
-                   : have_z ? va_arg(args, uptr)
-                            : va_arg(args, unsigned);
+        uval = have_ll  ? va_arg(args, u64)
         bool uppercase = (*cur == 'X');
         result += AppendUnsigned(&buff, buff_end, uval, (*cur == 'u') ? 10 : 16,
                                  width, pad_with_zero, uppercase);
         break;
       }
-      case 'V': {
-        for (uptr i = 0; i < 16; i++) {
-          unsigned x = va_arg(args, unsigned);
-          result += AppendUnsigned(&buff, buff_end, x, 16, 2, true, false);
-        }
-        break;
-      }
       case 'p': {
         RAW_CHECK_MSG(!have_flags, kPrintfFormatsHelp);
         result += AppendPointer(&buff, buff_end, va_arg(args, uptr));
         break;
       }
       case 's': {
         RAW_CHECK_MSG(!have_length, kPrintfFormatsHelp);
         // Only left-justified width is supported.

compiler-rt/lib/sanitizer_common/tests/sanitizer_printf_test.cpp

 //===----------------------------------------------------------------------===//
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_libc.h"
 #include "gtest/gtest.h"
 
 #include <string.h>
 #include <limits.h>
 
-#ifdef __x86_64__
-#  include <emmintrin.h>
-#endif
-
 namespace __sanitizer {
 
 TEST(Printf, Basic) {
   char buf[1024];
   uptr len = internal_snprintf(
       buf, sizeof(buf), "a%db%zdc%ue%zuf%xh%zxq%pe%sr", (int)-1, (uptr)-2,
       (unsigned)-4, (uptr)5, (unsigned)10, (uptr)11, (void *)0x123, "_string_");
   EXPECT_EQ(len, strlen(buf));
TEST(Printf, Precision) {
   EXPECT_STREQ("12345 ", buf);
   // Check that width does not overflow the smaller buffer, although
   // 10 chars is requested, it stops at the buffer size, 8.
   len = internal_snprintf(buf, 8, "%-10s", "12345");
   EXPECT_EQ(10U, len);  // The required size reported.
   EXPECT_STREQ("12345  ", buf);
 }
 
-#ifdef __x86_64__
-TEST(Printf, M128) {
-  __m128i v = _mm_set_epi32(0x12345678, 0x0a0a0a0a, 0xb0b0b0b0, 0xaabbccdd);
-  char buf[128];
-  internal_snprintf(buf, sizeof(buf), "%V", PRINTF_128(v));
-  EXPECT_STREQ("ddccbbaab0b0b0b00a0a0a0a78563412", buf);
-  v = _mm_cvtsi32_si128(0x12345678);
-  internal_snprintf(buf, sizeof(buf), "%V", PRINTF_128(v));
-  EXPECT_STREQ("78563412000000000000000000000000", buf);
-  internal_snprintf(buf, sizeof(buf), "%d %V", 0, PRINTF_128(v));
-  EXPECT_STREQ("0 78563412000000000000000000000000", buf);
-}
-#endif
-
 }  // namespace __sanitizer