[HWASan] Print short tags in __hwasan_print_shadow.

[morehouse]

• Undo accidental change.

[eugenis]

LGTM w/ nit

compiler-rt/lib/hwasan/hwasan.cpp

398

mem_tag < kShadowAlignment this check is not covered by the test case

[morehouse]

• Test case where tag >= kShadowAlignment.

compiler-rt/lib/hwasan/hwasan.cpp

 // HWAddressSanitizer runtime.
 //===----------------------------------------------------------------------===//
 
 #include "hwasan.h"
 
 #include "hwasan_checks.h"
 #include "hwasan_dynamic_shadow.h"
 #include "hwasan_globals.h"
+#include "hwasan_mapping.h"
 #include "hwasan_poisoning.h"
 #include "hwasan_report.h"
 #include "hwasan_thread.h"
 #include "hwasan_thread_list.h"
 #include "sanitizer_common/sanitizer_atomic.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_flag_parser.h"
 #include "sanitizer_common/sanitizer_flags.h"

 }
 
 void __hwasan_print_shadow(const void *p, uptr sz) {
   uptr ptr_raw = UntagAddr(reinterpret_cast<uptr>(p));
   uptr shadow_first = MemToShadow(ptr_raw);
   uptr shadow_last = MemToShadow(ptr_raw + sz - 1);
   Printf("HWASan shadow map for %zx .. %zx (pointer tag %x)\n", ptr_raw,
          ptr_raw + sz, GetTagFromPointer((uptr)p));
-  for (uptr s = shadow_first; s <= shadow_last; ++s)
-    Printf("  %zx: %x\n", ShadowToMem(s), *(tag_t *)s);
+  for (uptr s = shadow_first; s <= shadow_last; ++s) {
+    tag_t mem_tag = *reinterpret_cast<tag_t *>(s);
+    uptr granule_addr = ShadowToMem(s);
+    if (mem_tag && mem_tag < kShadowAlignment)
+      Printf("  %zx: %02x(%02x)\n", granule_addr, mem_tag,
+             *reinterpret_cast<tag_t *>(granule_addr + kShadowAlignment - 1));
+    else
+      Printf("  %zx: %02x\n", granule_addr, mem_tag);
+  }
 }
 
 sptr __hwasan_test_shadow(const void *p, uptr sz) {
   if (sz == 0)
     return -1;
   tag_t ptr_tag = GetTagFromPointer((uptr)p);
   uptr ptr_raw = UntagAddr(reinterpret_cast<uptr>(p));
   uptr shadow_first = MemToShadow(ptr_raw);

compiler-rt/test/hwasan/TestCases/hwasan-print-shadow.cpp

 // RUN: %clangxx_hwasan -DSIZE=16 -O0 %s -o %t && %run %t 2>&1 | FileCheck %s
 
 // REQUIRES: stable-runtime
 
 #include <assert.h>
 #include <stdlib.h>
 #include <sys/mman.h>
 #include <sanitizer/hwasan_interface.h>
 
 int main() {
-  void *alloc = malloc(4096);
+  char *alloc = (char *)malloc(4096);
+
+  // Simulate short granule tags.
+  alloc[15] = 0x00;
+  alloc[31] = 0xbb;
+  alloc[47] = 0xcc;
+  alloc[63] = 0xdd;
+  alloc[79] = 0xee;
+  alloc[95] = 0xff;
 
   // __hwasan_tag_memory expects untagged pointers.
   char *p = (char *)__hwasan_tag_pointer(alloc, 0);
   assert(p);
 
+  // Write tags to shadow.
   __hwasan_tag_memory(p, 1, 32);
-  __hwasan_tag_memory(p + 32, 3, 16);
+  __hwasan_tag_memory(p + 32, 16, 16);
   __hwasan_tag_memory(p + 48, 0, 32);
   __hwasan_tag_memory(p + 80, 4, 16);
 
   char *q = (char *)__hwasan_tag_pointer(p, 7);
   __hwasan_print_shadow(q + 5, 89 - 5);
   // CHECK:      HWASan shadow map for {{.*}}5 .. {{.*}}9 (pointer tag 7)
-  // CHECK-NEXT:   {{.*}}0: 1
-  // CHECK-NEXT:   {{.*}}0: 1
-  // CHECK-NEXT:   {{.*}}0: 3
-  // CHECK-NEXT:   {{.*}}0: 0
-  // CHECK-NEXT:   {{.*}}0: 0
-  // CHECK-NEXT:   {{.*}}0: 4
+  // CHECK-NEXT:   {{.*}}0: 01(00)
+  // CHECK-NEXT:   {{.*}}0: 01(bb)
+  // CHECK-NEXT:   {{.*}}0: 10
+  // CHECK-NEXT:   {{.*}}0: 00
+  // CHECK-NEXT:   {{.*}}0: 00
+  // CHECK-NEXT:   {{.*}}0: 04(ff)
 
   free(alloc);
 }