sanitizer_common: support printing __m128i type

[dvyukov]

Summary

__m128i is vector SSE type used in tsan.
It's handy to be able to print it for debugging.

[dvyukov]

compiler-rt/lib/sanitizer_common/sanitizer_printf.cpp

175–177

Humm... I run arc lint... the lines below are changed by it, I did not change them. And arc lint does not produce any more warnings/changes....

[vitalybuka]

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

165

this unusual format
if it's just few places maybe just continue to type printf("%lx%016lx", (u64)(n >> 64), (u64)n) ?

[dvyukov]

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

165

It's not this simple because __m128i is not an integer, it's some implementation-defined type, may be a struct, may have some implementation-specific attributes.

We could do something along the lines of the following helpers:

u64 m128part(__m128i v, bool lo) {
  u64 x[2];
  internal_memcpy(&x, &v, sizeof(x));
  return lo ? x[0] : x[1];
}

#define M128FMT "%016llx%016llx"

And use them as:

Printf("value: " M128FMT "\n", m128part(v, true), m128part(v, false));

... but on second though this won't work as well because printing u64 will revert bytes (high byte goes first), this is generally confusing for a vector. It may contain 2 u64s, or 4 u32s, or 8 u16s, so there is even no common way to revert it back while reading the log.

Or we could add a helper function that prints a single value only:

void PrintVec(const char* prefix, __m128i v);

And then add DPrintVec/DPrintVec2 defines on top.

Currently I do:

DPrintf2("  MOP: shadow=%V access=%V\n", shadow, access);

Your call.

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) {
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': {
-        dval = have_ll ? va_arg(args, s64)
+        s64 dval = have_ll  ? va_arg(args, s64)
                    : have_z ? va_arg(args, sptr)
                             : va_arg(args, int);
         result += AppendSignedDecimal(&buff, buff_end, dval, width,
                                       pad_with_zero);
         break;
       }
       case 'u':
       case 'x':
       case 'X': {
-        uval = have_ll ? va_arg(args, u64)
+        u64 uval = have_ll  ? va_arg(args, u64)
                    : have_z ? va_arg(args, uptr)
                             : va_arg(args, unsigned);
         bool uppercase = (*cur == 'X');
         result += AppendUnsigned(&buff, buff_end, uval, (*cur == 'u') ? 10 : 16,
                                  width, pad_with_zero, uppercase);
         break;
       }
+#if defined(__x86_64__)
+      case 'V': {
+        __m128i v = va_arg(args, __m128i);
+        u8 x[sizeof(v)];
+        internal_memcpy(x, &v, sizeof(x));
+        for (uptr i = 0; i < sizeof(x); i++)
+          result += AppendUnsigned(&buff, buff_end, x[i], 16, 2, true, false);
+        break;
+      }
+#endif
       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");  // NOLINT
   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", v);
+  EXPECT_STREQ("ddccbbaab0b0b0b00a0a0a0a78563412", buf);
+  v = _mm_cvtsi32_si128(0x12345678);
+  internal_snprintf(buf, sizeof(buf), "%V", v);
+  EXPECT_STREQ("78563412000000000000000000000000", buf);
+  internal_snprintf(buf, sizeof(buf), "%d %V", 0, v);
+  EXPECT_STREQ("0 78563412000000000000000000000000", buf);
+}
+#endif
+
 }  // namespace __sanitizer