[HWASAN] Use InTaggableRegion in basic tagging functions

[vitalybuka]

Summary

For primary use-case when !HWASAN_ALIASING_MODE the function is constant
true and should be eliminated by optimizations.

In case HWASAN_ALIASING_MODE all new calls to the functions were missing
in the first place. We just not use this mode for anything but tests, so
we didn't noticed.

Addressing @thurston comment on D149293

compiler-rt/lib/hwasan/hwasan.h

#if defined(HWASAN_ALIASING_MODE)
   // base.
   return (addr >> kTaggableRegionCheckShift) ==
          (__hwasan::GetShadowOffset() >> kTaggableRegionCheckShift);
 #endif
   return true;
 }
 
 static inline tag_t GetTagFromPointer(uptr p) {
-  return (p >> kAddressTagShift) & kTagMask;
+  return InTaggableRegion(p) ? ((p >> kAddressTagShift) & kTagMask) : 0;
 }
 
 static inline uptr UntagAddr(uptr tagged_addr) {
-  return tagged_addr & ~kAddressTagMask;
+  return InTaggableRegion(tagged_addr) ? (tagged_addr & ~kAddressTagMask)
+                                       : tagged_addr;
 }
 
 static inline void *UntagPtr(const void *tagged_ptr) {
   return reinterpret_cast<void *>(
       UntagAddr(reinterpret_cast<uptr>(tagged_ptr)));
 }
 
 static inline uptr AddTagToPointer(uptr p, tag_t tag) {
-  return (p & ~kAddressTagMask) | ((uptr)tag << kAddressTagShift);
+  return InTaggableRegion(p)
+             ? ((p & ~kAddressTagMask) | ((uptr)tag << kAddressTagShift))
+             : p;
 }
 
 namespace __hwasan {
 
 extern int hwasan_inited;
 extern bool hwasan_init_is_running;
 extern int hwasan_report_count;
 

compiler-rt/lib/hwasan/hwasan_allocator.cpp

static bool CheckInvalidFree(StackTrace *stack, void *untagged_ptr,
   }
   return false;
 }
 
 static void HwasanDeallocate(StackTrace *stack, void *tagged_ptr) {
   CHECK(tagged_ptr);
   RunFreeHooks(tagged_ptr);
 
-  bool in_taggable_region =
-      InTaggableRegion(reinterpret_cast<uptr>(tagged_ptr));
-  void *untagged_ptr = in_taggable_region ? UntagPtr(tagged_ptr) : tagged_ptr;
+  void *untagged_ptr = UntagPtr(tagged_ptr);
 
   if (CheckInvalidFree(stack, untagged_ptr, tagged_ptr))
     return;
 
   void *aligned_ptr = reinterpret_cast<void *>(
       RoundDownTo(reinterpret_cast<uptr>(untagged_ptr), kShadowAlignment));
   tag_t pointer_tag = GetTagFromPointer(reinterpret_cast<uptr>(tagged_ptr));
   Metadata *meta =
       reinterpret_cast<Metadata *>(allocator.GetMetaData(aligned_ptr));
   if (!meta) {
     ReportInvalidFree(stack, reinterpret_cast<uptr>(tagged_ptr));
     return;
   }
   uptr orig_size = meta->GetRequestedSize();
   u32 free_context_id = StackDepotPut(*stack);
   u32 alloc_context_id = meta->GetAllocStackId();
   u32 alloc_thread_id = meta->GetAllocThreadId();
 
+  bool in_taggable_region =
+      InTaggableRegion(reinterpret_cast<uptr>(tagged_ptr));
+
   // Check tail magic.
   uptr tagged_size = TaggedSize(orig_size);
   if (flags()->free_checks_tail_magic && orig_size &&
       tagged_size != orig_size) {
     uptr tail_size = tagged_size - orig_size - 1;
     CHECK_LT(tail_size, kShadowAlignment);
     void *tail_beg = reinterpret_cast<void *>(
         reinterpret_cast<uptr>(aligned_ptr) + orig_size);
if (t) {
     SpinMutexLock l(&fallback_mutex);
     AllocatorCache *cache = &fallback_allocator_cache;
     allocator.Deallocate(cache, aligned_ptr);
   }
 }
 
 static void *HwasanReallocate(StackTrace *stack, void *tagged_ptr_old,
                               uptr new_size, uptr alignment) {
-  void *untagged_ptr_old =
-      InTaggableRegion(reinterpret_cast<uptr>(tagged_ptr_old))
-          ? UntagPtr(tagged_ptr_old)
-          : tagged_ptr_old;
+  void *untagged_ptr_old = UntagPtr(tagged_ptr_old);
   if (CheckInvalidFree(stack, untagged_ptr_old, tagged_ptr_old))
     return nullptr;
   void *tagged_ptr_new =
       HwasanAllocate(stack, new_size, alignment, false /*zeroise*/);
   if (tagged_ptr_old && tagged_ptr_new) {
     Metadata *meta =
         reinterpret_cast<Metadata *>(allocator.GetMetaData(untagged_ptr_old));
-    void *untagged_ptr_new =
-        InTaggableRegion(reinterpret_cast<uptr>(tagged_ptr_new))
-            ? UntagPtr(tagged_ptr_new)
-            : tagged_ptr_new;
+    void *untagged_ptr_new = UntagPtr(tagged_ptr_new);
     internal_memcpy(untagged_ptr_new, untagged_ptr_old,
                     Min(new_size, static_cast<uptr>(meta->GetRequestedSize())));
     HwasanDeallocate(stack, tagged_ptr_old);
   }
   return tagged_ptr_new;
 }
 
 static void *HwasanCalloc(StackTrace *stack, uptr nmemb, uptr size) {
HwasanChunkView FindHeapChunkByAddress(uptr address) {
   if (!block)
     return HwasanChunkView();
   Metadata *metadata =
       reinterpret_cast<Metadata*>(allocator.GetMetaData(block));
   return HwasanChunkView(reinterpret_cast<uptr>(block), metadata);
 }
 
 static const void *AllocationBegin(const void *p) {
-  const void *untagged_ptr =
-      InTaggableRegion(reinterpret_cast<uptr>(p)) ? UntagPtr(p) : p;
+  const void *untagged_ptr = UntagPtr(p);
   if (!untagged_ptr)
     return nullptr;
 
   const void *beg = allocator.GetBlockBegin(untagged_ptr);
   if (!beg)
     return nullptr;
 
   Metadata *b = (Metadata *)allocator.GetMetaData(beg);
   if (b->GetRequestedSize() == 0)
     return nullptr;
 
   tag_t tag = GetTagFromPointer((uptr)p);
   return (const void *)AddTagToPointer((uptr)beg, tag);
 }
 
 static uptr AllocationSize(const void *p) {
-  const void *untagged_ptr =
-      InTaggableRegion(reinterpret_cast<uptr>(p)) ? UntagPtr(p) : p;
+  const void *untagged_ptr = UntagPtr(p);
   if (!untagged_ptr) return 0;
   const void *beg = allocator.GetBlockBegin(untagged_ptr);
   if (!beg)
     return 0;
   Metadata *b = (Metadata *)allocator.GetMetaData(beg);
   return b->GetRequestedSize();
 }
 

 }
 
 void GetAllocatorGlobalRange(uptr *begin, uptr *end) {
   *begin = (uptr)&__hwasan::allocator;
   *end = *begin + sizeof(__hwasan::allocator);
 }
 
 uptr PointsIntoChunk(void *p) {
-  p = InTaggableRegion(reinterpret_cast<uptr>(p)) ? UntagPtr(p) : p;
+  p = UntagPtr(p);
   uptr addr = reinterpret_cast<uptr>(p);
   uptr chunk =
       reinterpret_cast<uptr>(__hwasan::allocator.GetBlockBeginFastLocked(p));
   if (!chunk)
     return 0;
   __hwasan::Metadata *metadata = reinterpret_cast<__hwasan::Metadata *>(
       __hwasan::allocator.GetMetaData(reinterpret_cast<void *>(chunk)));
   if (!metadata || !metadata->IsAllocated())
     return 0;
   if (addr < chunk + metadata->GetRequestedSize())
     return chunk;
   if (IsSpecialCaseOfOperatorNew0(chunk, metadata->GetRequestedSize(), addr))
     return chunk;
   return 0;
 }
 
 uptr GetUserBegin(uptr chunk) {
-  if (InTaggableRegion(chunk))
-    CHECK_EQ(UntagAddr(chunk), chunk);
   void *block = __hwasan::allocator.GetBlockBeginFastLocked(
       reinterpret_cast<void *>(chunk));
   if (!block)
     return 0;
   __hwasan::Metadata *metadata = reinterpret_cast<__hwasan::Metadata *>(
       __hwasan::allocator.GetMetaData(block));
   if (!metadata || !metadata->IsAllocated())
     return 0;
 
   return reinterpret_cast<uptr>(block);
 }
 
 uptr GetUserAddr(uptr chunk) {
-  tag_t mem_tag = *(tag_t *)__hwasan::MemToShadow(chunk);
   if (!InTaggableRegion(chunk))
     return chunk;
+  tag_t mem_tag = *(tag_t *)__hwasan::MemToShadow(chunk);
   return AddTagToPointer(chunk, mem_tag);
 }
 
 LsanMetadata::LsanMetadata(uptr chunk) {
-  if (InTaggableRegion(chunk))
-    CHECK_EQ(UntagAddr(chunk), chunk);
   metadata_ =
       chunk ? __hwasan::allocator.GetMetaData(reinterpret_cast<void *>(chunk))
             : nullptr;
 }
 
 bool LsanMetadata::allocated() const {
   if (!metadata_)
     return false;
u32 LsanMetadata::stack_trace_id() const {
   return m->GetAllocStackId();
 }
 
 void ForEachChunk(ForEachChunkCallback callback, void *arg) {
   __hwasan::allocator.ForEachChunk(callback, arg);
 }
 
 IgnoreObjectResult IgnoreObject(const void *p) {
-  p = InTaggableRegion(reinterpret_cast<uptr>(p)) ? UntagPtr(p) : p;
+  p = UntagPtr(p);
   uptr addr = reinterpret_cast<uptr>(p);
   uptr chunk = reinterpret_cast<uptr>(__hwasan::allocator.GetBlockBegin(p));
   if (!chunk)
     return kIgnoreObjectInvalid;
   __hwasan::Metadata *metadata = reinterpret_cast<__hwasan::Metadata *>(
       __hwasan::allocator.GetMetaData(reinterpret_cast<void *>(chunk)));
   if (!metadata || !metadata->IsAllocated())
     return kIgnoreObjectInvalid;