[HWASAN][NFC] Added implementation for the most of the allocator related functions from the LSAN interface.

compiler-rt/lib/hwasan/hwasan_allocator.h

HwasanChunkView(uptr block, Metadata *metadata)
       : block_(block), metadata_(metadata) {}
   bool IsAllocated() const;    // Checks if the memory is currently allocated
   uptr Beg() const;            // First byte of user memory
   uptr End() const;            // Last byte of user memory
   uptr UsedSize() const;       // Size requested by the user
   uptr ActualSize() const;     // Size allocated by the allocator.
   u32 GetAllocStackId() const;
   bool FromSmallHeap() const;
+  bool AddrIsInside(uptr addr) const;
+
  private:
   friend class __lsan::LsanMetadata;
   uptr block_;
   Metadata *const metadata_;
 };
 
 HwasanChunkView FindHeapChunkByAddress(uptr address);
 

compiler-rt/lib/hwasan/hwasan_allocator.cpp

 uptr HwasanChunkView::ActualSize() const {
   return allocator.GetActuallyAllocatedSize(reinterpret_cast<void *>(block_));
 }
 
 bool HwasanChunkView::FromSmallHeap() const {
   return allocator.FromPrimary(reinterpret_cast<void *>(block_));
 }
 
+bool HwasanChunkView::AddrIsInside(uptr addr) const {
+  return (addr >= Beg()) && (addr < Beg() + UsedSize());
+}
+
 inline void Metadata::SetAllocated(u32 stack, u64 size) {
   Thread *t = GetCurrentThread();
   u64 context = t ? t->unique_id() : kMainTid;
   context <<= 32;
   context += stack;
   requested_size_low = size & ((1ul << 32) - 1);
   requested_size_high = size >> 32;
   atomic_store(&alloc_context_id, context, memory_order_relaxed);
void hwasan_free(void *ptr, StackTrace *stack) {
   return HwasanDeallocate(stack, ptr);
 }
 
 }  // namespace __hwasan
 
 // --- Implementation of LSan-specific functions --- {{{1
 namespace __lsan {
 
+void LockAllocator() {
+  __hwasan::HwasanAllocatorLock();
+}
+
+void UnlockAllocator() {
+  __hwasan::HwasanAllocatorUnlock();
+}
+
+void GetAllocatorGlobalRange(uptr *begin, uptr *end) {
+  *begin = (uptr)&__hwasan::allocator;
+  *end = *begin + sizeof(__hwasan::allocator);
+}
+
+uptr PointsIntoChunk(void *p) {
+  uptr addr = reinterpret_cast<uptr>(p);
+  __hwasan::HwasanChunkView view = __hwasan::FindHeapChunkByAddress(addr);
+  if (!view.IsAllocated()) 
+    return 0;
+  uptr chunk = view.Beg();
+  if (view.AddrIsInside(addr))
+    return chunk;
+  if (IsSpecialCaseOfOperatorNew0(chunk, view.UsedSize(), addr))
+    return chunk;
+  return 0;
+}
+
+uptr GetUserBegin(uptr chunk) {
+  return __hwasan::FindHeapChunkByAddress(chunk).Beg();
+}
+
 LsanMetadata::LsanMetadata(uptr chunk) {
   metadata_ = chunk ? reinterpret_cast<__hwasan::Metadata *>(
                           chunk - __hwasan::kChunkHeaderSize)
                     : nullptr;
 }
 
 bool LsanMetadata::allocated() const {
   if (!metadata_)
uptr LsanMetadata::requested_size() const {
   return m->GetRequestedSize();
 }
 
 u32 LsanMetadata::stack_trace_id() const {
   __hwasan::Metadata *m = reinterpret_cast<__hwasan::Metadata *>(metadata_);
   return m->GetAllocStackId();
 }
 
+void ForEachChunk(ForEachChunkCallback callback, void *arg) {
+  __hwasan::allocator.ForEachChunk(callback, arg);
+}
+
 }  // namespace __lsan
 
 using namespace __hwasan;
 
 void __hwasan_enable_allocator_tagging() {
   atomic_store_relaxed(&hwasan_allocator_tagging_enabled, 1);
 }