[msan] Dump shadow address

[vitalybuka]

Summary

before:
00 00 00 00 ff ff ff ff 00 00 00 00 00 00 00 00
now:
0x2f60d213ac10[0x7f60d213ac10] 00 00 00 00 ff ff ff ff 00 00 00 00 00 00 00 00

[vitalybuka]

test

[eugenis]

LGTM

You know that you can also use msan_print_shadow, which is better in every way? :)
Also, do you mind updating msan_print_shadow to show the memory address, in addition to the shadow address, in the header?

compiler-rt/lib/msan/msan.cpp

 
 void __msan_dump_shadow(const void *x, uptr size) {
   if (!MEM_IS_APP(x)) {
     Printf("Not a valid application address: %p\n", x);
     return;
   }
 
   unsigned char *s = (unsigned char*)MEM_TO_SHADOW(x);
+  Printf("%p[%p]  ", s, x);
   for (uptr i = 0; i < size; i++)
     Printf("%x%x ", s[i] >> 4, s[i] & 0xf);
   Printf("\n");
 }
 
 sptr __msan_test_shadow(const void *x, uptr size) {
   if (!MEM_IS_APP(x)) return -1;
   unsigned char *s = (unsigned char *)MEM_TO_SHADOW((uptr)x);

compiler-rt/lib/msan/msan_report.cpp

void DescribeMemoryRange(const void *x, uptr size) {
   uptr pos = 0;  // Offset from aligned start.
   bool with_origins = __msan_get_track_origins();
   // True if there is at least 1 poisoned bit in the last 4-byte group.
   bool last_quad_poisoned;
   int origin_ids[4];  // Single letter origin ids for the current line.
 
   Decorator d;
   Printf("%s", d.Warning());
-  Printf("Shadow map of [%p, %p), %zu bytes:\n",
+  uptr start_x = reinterpret_cast<uptr>(x);
+  Printf("Shadow map [%p, %p) of [%p, %p), %zu bytes:\n",
          reinterpret_cast<void *>(start), reinterpret_cast<void *>(end),
-         end - start);
+         reinterpret_cast<void *>(start_x),
+         reinterpret_cast<void *>(start_x + end - start), end - start);
   Printf("%s", d.Default());
   while (s < e) {
     // Line start.
     if (pos % 16 == 0) {
       for (int i = 0; i < 4; ++i) origin_ids[i] = -1;
-      Printf("%p:", reinterpret_cast<void *>(s));
+      Printf("%p[%p]:", reinterpret_cast<void *>(s),
+             reinterpret_cast<void *>(start_x - start + s));
     }
     // Group start.
     if (pos % 4 == 0) {
       Printf(" ");
       last_quad_poisoned = false;
     }
     // Print shadow byte.
     if (s < start || s >= end) {

compiler-rt/test/msan/msan_check_mem_is_initialized.cpp

int main(void) {
   char p[32] = {};
   __msan_poison(p + 10, 2);
 
   __msan_check_mem_is_initialized(p, 10);
   __msan_check_mem_is_initialized(p + 12, 30);
 #ifdef POSITIVE
   __msan_check_mem_is_initialized(p + 5, 20);
   // CHECK: Uninitialized bytes in __msan_check_mem_is_initialized at offset 5 inside [0x{{.*}}, 20)
-  // CHECK-VERBOSE: Shadow map of [0x{{.*}}, 0x{{.*}}), 20 bytes:
+  // CHECK-VERBOSE: Shadow map [0x{{.*}}, 0x{{.*}}) of [0x{{.*}}, 0x{{.*}}), 20 bytes:
   // CHECK-VERBOSE: 0x{{.*}}: ..000000 0000ffff 00000000 00000000
   // CHECK-VERBOSE: 0x{{.*}}: 00000000 00...... ........ ........
 
   // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
   // CHECK: #0 0x{{.*}}in main{{.*}}msan_check_mem_is_initialized.cpp:[[@LINE-7]]
 #endif
   return 0;
 }
 

compiler-rt/test/msan/msan_dump_shadow.cpp

int main(void) {
   char *p = new char[16];
   __msan_dump_shadow(p, 5);
   delete[] p;
   const char *q = "abc";
   __msan_dump_shadow(q, 3);
   return 0;
 }
 
-// CHECK: ff ff ff ff ff
-// CHECK: 00 00 00
+// CHECK: 0x{{[0-9a-f]+}}[0x{{[0-9a-f]+}}]  ff ff ff ff ff
+// CHECK: 0x{{[0-9a-f]+}}[0x{{[0-9a-f]+}}]  00 00 00

compiler-rt/test/msan/msan_print_shadow.cpp

int main(void) {
 
   p[19] = x;
 
   __msan_print_shadow(p+5, 297);
   delete[] p;
   return 0;
 }
 
-// CHECK: Shadow map of [{{.*}}), 297 bytes:
+// CHECK: Shadow map [0x{{.*}}, 0x{{.*}}) of [0x{{.*}}, 0x{{.*}}), 297 bytes:
 
 // CHECK-NO-ORIGINS: 0x{{.*}}: ..00ffff 00000000 ffffffff ffffffff
 // CHECK-NO-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff
 // CHECK-NO-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff
 // CHECK-NO-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff
 // CHECK-NO-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff
 // CHECK-NO-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff
 // CHECK-NO-ORIGINS: 0x{{.*}}: ffffffff ffffffff ffffffff ffffffff

compiler-rt/test/msan/msan_print_shadow2.cpp

int main(void) {
   __msan_print_shadow(p+15, 1);
   __msan_print_shadow(p, 0);
   delete[] p;
   int x = 0;
   __msan_print_shadow(&x, 3);
   return 0;
 }
 
-// CHECK: Shadow map of [0x{{.*}}, 0x{{.*}}), 1 bytes:
+// CHECK: Shadow map [0x{{.*}}, 0x{{.*}}) of [0x{{.*}}, 0x{{.*}}), 1 bytes:
 // CHECK-NO-ORIGINS:   0x{{.*}}: ff...... ........ ........ ........
 // CHECK-ORIGINS:   0x{{.*}}: ff...... ........ ........ ........  |A . . .|
 // CHECK-ORIGINS: Origin A (origin_id {{.*}}):
 
-// CHECK: Shadow map of [0x{{.*}}, 0x{{.*}}), 1 bytes:
+// CHECK: Shadow map [0x{{.*}}, 0x{{.*}}) of [0x{{.*}}, 0x{{.*}}), 1 bytes:
 // CHECK-NO-ORIGINS:   0x{{.*}}: ..ff.... ........ ........ ........
 // CHECK-ORIGINS:   0x{{.*}}: ..ff.... ........ ........ ........  |A . . .|
 // CHECK-ORIGINS: Origin A (origin_id {{.*}}):
 
-// CHECK: Shadow map of [0x{{.*}}, 0x{{.*}}), 1 bytes:
+// CHECK: Shadow map [0x{{.*}}, 0x{{.*}}) of [0x{{.*}}, 0x{{.*}}), 1 bytes:
 // CHECK-NO-ORIGINS:   0x{{.*}}: ......ff ........ ........ ........
 // CHECK-ORIGINS:   0x{{.*}}: ......ff ........ ........ ........  |A . . .|
 // CHECK-ORIGINS: Origin A (origin_id {{.*}}):
 
-// CHECK: Shadow map of [0x{{.*}}, 0x{{.*}}), 1 bytes:
+// CHECK: Shadow map [0x{{.*}}, 0x{{.*}}) of [0x{{.*}}, 0x{{.*}}), 1 bytes:
 // CHECK-NO-ORIGINS:   0x{{.*}}: ......ff ........ ........ ........
 // CHECK-ORIGINS:   0x{{.*}}: ......ff ........ ........ ........  |A . . .|
 // CHECK-ORIGINS: Origin A (origin_id {{.*}}):
 
-// CHECK: Shadow map of [0x{{.*}}, 0x{{.*}}), 0 bytes:
+// CHECK: Shadow map [0x{{.*}}, 0x{{.*}}) of [0x{{.*}}, 0x{{.*}}), 0 bytes:
 
-// CHECK: Shadow map of [0x{{.*}}, 0x{{.*}}), 3 bytes:
+// CHECK: Shadow map [0x{{.*}}, 0x{{.*}}) of [0x{{.*}}, 0x{{.*}}), 3 bytes:
 // CHECK-NO-ORIGINS:   0x{{.*}}: 000000.. ........ ........ ........
 // CHECK-ORIGINS:   0x{{.*}}: 000000.. ........ ........ ........  |. . . .|

compiler-rt/test/msan/msan_print_shadow3.cpp

 // RUN: %clangxx_msan -O0 -g %s -o %t && %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out
 
 #include <stdint.h>
 #include <sanitizer/msan_interface.h>
 
 int main(void) {
   unsigned long long x = 0; // For 8-byte alignment.
   char x_s[4] = {0x77, 0x65, 0x43, 0x21};
   __msan_partial_poison(&x, &x_s, sizeof(x_s));
   __msan_print_shadow(&x, sizeof(x_s));
   return 0;
 }
 
-// CHECK: Shadow map of [{{.*}}), 4 bytes:
+// CHECK: Shadow map [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}) of [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}), 4 bytes:
 // CHECK: 0x{{.*}}: 77654321 ........ ........ ........