[ASan] Show memory rather than tag addresses in tag dump

[eugenis]

LGTM

Maybe add a few compile-time checks that mem->shadow->mem returns the original value? At least the sparc equations are complicated enough.

[eugenis]

Well compile-time may be hard. Hwasan does some runtime checks in InitShadow, that's ok too

[fmayer]

add static assert

[fmayer]

In D133391#3775336, @eugenis wrote:

LGTM

Maybe add a few compile-time checks that mem->shadow->mem returns the original value? At least the sparc equations are complicated enough.

Done. Cross-compiled compiler-rt for SPARC64 to verify the assertion doesn't fail (it fails at the link step, but compilation works fine).

compiler-rt/lib/asan/asan_errors.cpp

static void PrintLegend(InternalScopedString *str) {
   PrintShadowByte(str, "  Left alloca redzone:     ", kAsanAllocaLeftMagic);
   PrintShadowByte(str, "  Right alloca redzone:    ", kAsanAllocaRightMagic);
 }
 
 static void PrintShadowBytes(InternalScopedString *str, const char *before,
                              u8 *bytes, u8 *guilty, uptr n) {
   Decorator d;
   if (before)
-    str->append("%s%p:", before, (void *)bytes);
+    str->append("%s%p:", before,
+                (void *)ShadowToMem(reinterpret_cast<uptr>(bytes)));
   for (uptr i = 0; i < n; i++) {
     u8 *p = bytes + i;
     const char *before =
         p == guilty ? "[" : (p - 1 == guilty && i != 0) ? "" : " ";
     const char *after = p == guilty ? "]" : "";
     PrintShadowByte(str, before, *p, after);
   }
   str->append("\n");

compiler-rt/lib/asan/asan_mapping.h

 
 }  // namespace __asan
 
 #  if defined(__sparc__) && SANITIZER_WORDSIZE == 64
 #    include "asan_mapping_sparc64.h"
 #  else
 #    define MEM_TO_SHADOW(mem) \
       (((mem) >> ASAN_SHADOW_SCALE) + (ASAN_SHADOW_OFFSET))
+#    define SHADOW_TO_MEM(mem) \
+      (((mem) - (ASAN_SHADOW_OFFSET)) << (ASAN_SHADOW_SCALE))
 
 #    define kLowMemBeg 0
 #    define kLowMemEnd (ASAN_SHADOW_OFFSET ? ASAN_SHADOW_OFFSET - 1 : 0)
 
 #    define kLowShadowBeg ASAN_SHADOW_OFFSET
 #    define kLowShadowEnd MEM_TO_SHADOW(kLowMemEnd)
 
 #    define kHighMemBeg (MEM_TO_SHADOW(kHighMemEnd) + 1)
static inline uptr MemToShadow(uptr p) {
   return MEM_TO_SHADOW(p);
 }
 
 static inline bool AddrIsInShadow(uptr a) {
   PROFILE_ASAN_MAPPING();
   return AddrIsInLowShadow(a) || AddrIsInMidShadow(a) || AddrIsInHighShadow(a);
 }
 
+static inline uptr ShadowToMem(uptr p) {
+  PROFILE_ASAN_MAPPING();
+  CHECK(AddrIsInShadow(p));
+  return SHADOW_TO_MEM(p);
+}
+
 static inline bool AddrIsAlignedByGranularity(uptr a) {
   PROFILE_ASAN_MAPPING();
   return (a & (ASAN_SHADOW_GRANULARITY - 1)) == 0;
 }
 
 static inline bool AddressIsPoisoned(uptr a) {
   PROFILE_ASAN_MAPPING();
   const uptr kAccessSize = 1;

compiler-rt/lib/asan/asan_mapping_sparc64.h

 #define HIGH_BITS (64 - VMA_BITS)
 
 // The idea is to chop the high bits before doing the scaling, so the two
 // parts become contiguous again and the usual scheme can be applied.
 
 #define MEM_TO_SHADOW(mem)                                       \
   ((((mem) << HIGH_BITS) >> (HIGH_BITS + (ASAN_SHADOW_SCALE))) + \
    (ASAN_SHADOW_OFFSET))
+#define SHADOW_TO_MEM(ptr) (__asan::ShadowToMemSparc64(ptr))
 
 #define kLowMemBeg 0
 #define kLowMemEnd (ASAN_SHADOW_OFFSET - 1)
 
 #define kLowShadowBeg ASAN_SHADOW_OFFSET
 #define kLowShadowEnd MEM_TO_SHADOW(kLowMemEnd)
 
 // But of course there is the huge hole between the high shadow memory,
static inline bool AddrIsInHighShadow(uptr a) {
   return kHighMemBeg && a >= kHighShadowBeg && a <= kHighShadowEnd;
 }
 
 static inline bool AddrIsInShadowGap(uptr a) {
   PROFILE_ASAN_MAPPING();
   return a >= kShadowGapBeg && a <= kShadowGapEnd;
 }
 
+static inline constexpr uptr ShadowToMemSparc64(uptr p) {
+  PROFILE_ASAN_MAPPING();
+  p -= ASAN_SHADOW_OFFSET;
+  p <<= ASAN_SHADOW_SCALE;
+  if (p >= 0x8000000000000) {
+    p |= (~0ULL) << VMA_BITS;
+  }
+  return p;
+}
+
+static_assert(ShadowToMemSparc64(MEM_TO_SHADOW(0x0000000000000000)) ==
+              0x0000000000000000);
+static_assert(ShadowToMemSparc64(MEM_TO_SHADOW(0xfff8000000000000)) ==
+              0xfff8000000000000);
+// Gets aligned down.
+static_assert(ShadowToMemSparc64(MEM_TO_SHADOW(0x0007ffffffffffff)) ==
+              0x0007fffffffffff8);
+
 }  // namespace __asan
 
 #endif  // ASAN_MAPPING_SPARC64_H