tsan: make IsMetaMem accept u32*

[dvyukov]

Summary

MemToMeta returns u32*, so it's reasonable for IsMetaMem
to accept u32* as well.
Changing the argument type just removes few type casts.

[vitalybuka]

compiler-rt/lib/tsan/rtl/tsan_rtl.cpp

331

is this const for text alignment or it actually affects some optimization?

[dvyukov]

compiler-rt/lib/tsan/rtl/tsan_rtl.cpp

331

It's just to make it constant (prevent accidental changes, make readers to be able to assume that the value is not changing). Currently we use "const uptr", so I just kept the const.

compiler-rt/lib/tsan/rtl/tsan_debugging.cpp

 const char *__tsan_locate_address(uptr addr, char *name, uptr name_size,
                                   uptr *region_address_ptr,
                                   uptr *region_size_ptr) {
   uptr region_address = 0;
   uptr region_size = 0;
   const char *region_kind = nullptr;
   if (name && name_size > 0) name[0] = 0;
 
-  if (IsMetaMem(addr)) {
+  if (IsMetaMem(reinterpret_cast<u32 *>(addr))) {
     region_kind = "meta shadow";
   } else if (IsShadowMem(addr)) {
     region_kind = "shadow";
   } else {
     bool is_stack = false;
     MBlock *b = 0;
     Allocator *a = allocator();
     if (a->PointerIsMine((void *)addr)) {

compiler-rt/lib/tsan/rtl/tsan_platform.h

 
 
 template<typename Mapping>
 bool IsMetaMemImpl(uptr mem) {
   return mem >= Mapping::kMetaShadowBeg && mem <= Mapping::kMetaShadowEnd;
 }
 
 ALWAYS_INLINE
-bool IsMetaMem(uptr mem) {
+bool IsMetaMem(const u32 *p) {
+  uptr mem = reinterpret_cast<uptr>(p);
 #if defined(__aarch64__) && !defined(__APPLE__) && !SANITIZER_GO
   switch (vmaSize) {
     case 39: return IsMetaMemImpl<Mapping39>(mem);
     case 42: return IsMetaMemImpl<Mapping42>(mem);
     case 48: return IsMetaMemImpl<Mapping48>(mem);
   }
   DCHECK(0);
   return false;
#endif
   }
   DCHECK(0);
   return false;
 #else
   return IsMetaMemImpl<Mapping>(mem);
 #endif
 }
 
-
 template<typename Mapping>
 uptr MemToShadowImpl(uptr x) {
   DCHECK(IsAppMem(x));
 #if !SANITIZER_GO
   return (((x) & ~(Mapping::kAppMemMsk | (kShadowCell - 1)))
       ^ Mapping::kAppMemXor) * kShadowCnt;
 #else
 # ifndef SANITIZER_WINDOWS

compiler-rt/lib/tsan/rtl/tsan_rtl.cpp

for (int i = 0; GetUserRegion(i, &beg, &end); i++) {
     VPrintf(3, "checking shadow region %p-%p\n", beg, end);
     uptr prev = 0;
     for (uptr p0 = beg; p0 <= end; p0 += (end - beg) / 4) {
       for (int x = -(int)kShadowCell; x <= (int)kShadowCell; x += kShadowCell) {
         const uptr p = RoundDown(p0 + x, kShadowCell);
         if (p < beg || p >= end)
           continue;
         const uptr s = MemToShadow(p);
-        const uptr m = (uptr)MemToMeta(p);
+        u32 *const m = MemToMeta(p);
         VPrintf(3, "  checking pointer %p: shadow=%p meta=%p\n", p, s, m);
         CHECK(IsAppMem(p));
         CHECK(IsShadowMem(s));
         CHECK_EQ(p, ShadowToMem(s));
         CHECK(IsMetaMem(m));
         if (prev) {
           // Ensure that shadow and meta mappings are linear within a single
           // user range. Lots of code that processes memory ranges assumes it.
           const uptr prev_s = MemToShadow(prev);
-          const uptr prev_m = (uptr)MemToMeta(prev);
+          u32 *const prev_m = MemToMeta(prev);
           CHECK_EQ(s - prev_s, (p - prev) * kShadowMultiplier);
-          CHECK_EQ((m - prev_m) / kMetaShadowSize,
-                   (p - prev) / kMetaShadowCell);
+          CHECK_EQ(m - prev_m, (p - prev) / kMetaShadowCell);
         }
         prev = p;
       }
     }
   }
 }
 
 #if !SANITIZER_GO