Add __sanitizer_get_allocated_begin API and implementations

[thurston]

Summary

This function will return the start of the allocation, if given a pointer that lies within an allocation. Otherwise, it returns NULL.

It will be useful for detecting dynamic TLS allocations in glibc >=2.25, which
uses malloc (see https://github.com/google/sanitizers/issues/1409#issuecomment-1214244142).

[thurston]

Add test for freed (new int)

[kstoimenov]

compiler-rt/lib/hwasan/hwasan_allocator.cpp

667

Nit: no space after function name.

674

I think that beg will be an untagged pointer. Please take that into account when implementing the client code because there is a good chance the pointer in the client code will be tagged.

compiler-rt/test/msan/get_allocation_bounds.cpp

1 ↗

(On Diff #508810)

Can we try moving this to compiler-rt/test/sanitizer_common? I am working on enabling HWASAN for those so when it's done HWASAN will be covered as well. Currently "supported tools" are: set(SUPPORTED_TOOLS_INIT asan lsan msan tsan ubsan) in compiler-rt/test/sanitizer_common/CMakeLists.txt.

[thurston]

compiler-rt/test/msan/get_allocation_bounds.cpp

1 ↗

(On Diff #508810)

To put this in sanitizer_common tests, I would need to add __sanitizer_get_allocation_bounds to stand-alone ubsan, even though AFAICS it doesn't have its own memory allocator. Should I proceed with that?

[kstoimenov]

compiler-rt/test/msan/get_allocation_bounds.cpp

1 ↗

(On Diff #508810)

Main motivation is to have this test run with all applicable sanitizers. You could disabled UBSAN using the UNSUPPORTED keyword. Another option is to provide an implementation which would satisfy the test with the standard allocator. Please double-check with vitalybuka@ before going down that path.

[thurston]

Minor bug fix

[thurston]

Revert to diff 2 (+ whitespace changes)

[thurston]

Formatting and minor bug fixes

[thurston]

Add function to sanitizer_common_interface.inc

[thurston]

Change HWASan implementation of __sanitizer_get_allocation_bounds to return tagged pointer

Mark test as unsupported for UBSan

[thurston]

compiler-rt/lib/hwasan/hwasan_allocator.cpp

674

Thanks for pointing this out! I've changed the implementation to return a tagged pointer.

[thurston]

Test both the primary and secondary allocators, by trying many different allocation sizes

[vitalybuka]

Could you please add a patch into the stack where it's used?

compiler-rt/include/sanitizer/allocator_interface.h

40

This is public interface, if we don't have to, we should avoid exposing it here.
Do we have a reason to do so?

sanitizer_common/sanitizer_interface_internal.h probably more appropriate?

compiler-rt/test/sanitizer_common/TestCases/get_allocation_bounds.cpp

7 ↗

(On Diff #509789)

how long this takes with? Can you make sure that it does not get into the top of:
LIT_OPTS="--time-tests" ninja check-sanitizer

[thurston]

compiler-rt/include/sanitizer/allocator_interface.h

40

I'll try moving it there.

compiler-rt/test/sanitizer_common/TestCases/get_allocation_bounds.cpp

7 ↗

(On Diff #509789)

It's not among the slowest tests:

4.70s: SanitizerCommon-tsan-x86_64-Linux :: get_allocation_bounds.cpp
4.53s: SanitizerCommon-asan-i386-Linux :: get_allocation_bounds.cpp
4.17s: SanitizerCommon-asan-x86_64-Linux :: get_allocation_bounds.cpp
3.99s: SanitizerCommon-msan-x86_64-Linux :: get_allocation_bounds.cpp
3.45s: SanitizerCommon-lsan-i386-Linux :: get_allocation_bounds.cpp
3.29s: SanitizerCommon-lsan-x86_64-Linux :: get_allocation_bounds.cpp

Slowest Tests:
--------------------------------------------------------------------------
16.38s: SanitizerCommon-msan-x86_64-Linux :: Linux/soft_rss_limit_mb_test.cpp
14.82s: SanitizerCommon-asan-i386-Linux :: Linux/soft_rss_limit_mb_test.cpp
14.77s: SanitizerCommon-asan-x86_64-Linux :: Linux/soft_rss_limit_mb_test.cpp
14.42s: SanitizerCommon-ubsan-i386-Linux :: Posix/qsort.cpp
14.14s: SanitizerCommon-tsan-x86_64-Linux :: Linux/soft_rss_limit_mb_test.cpp
14.12s: SanitizerCommon-ubsan-x86_64-Linux :: Posix/qsort.cpp
14.06s: SanitizerCommon-lsan-i386-Linux :: Linux/soft_rss_limit_mb_test.cpp
13.83s: SanitizerCommon-lsan-x86_64-Linux :: Linux/soft_rss_limit_mb_test.cpp
11.52s: SanitizerCommon-msan-x86_64-Linux :: compress_stack_depot.cpp
11.18s: SanitizerCommon-asan-i386-Linux :: Posix/qsort.cpp
10.47s: SanitizerCommon-Unit :: ./Sanitizer-x86_64-Test/SanitizerCommon/CombinedAllocator32Compact
10.29s: SanitizerCommon-msan-x86_64-Linux :: Posix/qsort.cpp
10.24s: SanitizerCommon-asan-x86_64-Linux :: Posix/qsort.cpp
9.82s: SanitizerCommon-lsan-i386-Linux :: Posix/qsort.cpp
9.81s: SanitizerCommon-asan-i386-Linux :: get_allocation_bounds.cpp
9.57s: SanitizerCommon-lsan-x86_64-Linux :: Posix/qsort.cpp
9.52s: SanitizerCommon-asan-i386-Linux :: Linux/signal_segv_handler.cpp
9.48s: SanitizerCommon-tsan-x86_64-Linux :: Linux/resize_tls_dynamic.cpp
9.39s: SanitizerCommon-asan-i386-Linux :: compress_stack_depot.cpp
9.37s: SanitizerCommon-lsan-i386-Linux :: Linux/signal_segv_handler.cpp

[thurston]

Move __sanitizer_get_allocation_bounds to internal header, per Vitaly's suggestion.

Update test accordingly.

[thurston]

compiler-rt/lib/sanitizer_common/sanitizer_allocator_interface.h

42–44

I'll work on removing this too.

[vitalybuka]

compiler-rt/include/sanitizer/allocator_interface.h

40

Sorry, after looking into this more, seems original header was fine.

40

there is redundancy sanitizer_get_allocation_bounds sanitizer_get_allocated_size

sanitizer_get_allocated_size does half the work
would it be better to add:

void * __sanitizer_get_allocated_begin(const volatile void *p)

[vitalybuka]

compiler-rt/lib/hwasan/hwasan_allocator.cpp

665

I'd recommend to extract AllocationBegin() next to AllocationSize() and keep interface methods implementation short like __sanitizer_get_allocated_size.

Please do the same for all sanitizers

667

looks tool long, please

git clang-format -f --extensions=inc,cc,h,c,cpp,rst HEAD^

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

468

is this for malloc(0)? looks strange, but let's keep it consistent with __sanitizer_get_allocated_size

[vitalybuka]

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

468

is this for malloc(0)? looks strange, but let's keep it consistent with __sanitizer_get_allocated_size

strange that we return 1 to the user, I would expected the same value as passed into malloc.

[thurston]

Change sanitizer_get_allocation_bounds to sanitizer_get_allocated_begin,
per Vitaly's comment

[thurston]

In D147005#4237707, @vitalybuka wrote:

Could you please add a patch into the stack where it's used?

Coming soon (tm)

compiler-rt/include/sanitizer/allocator_interface.h

40

Sorry, after looking into this more, seems original header was fine.

I've moved it back to the original header

40

there is redundancy sanitizer_get_allocation_bounds sanitizer_get_allocated_size

sanitizer_get_allocated_size does half the work
would it be better to add:

void * __sanitizer_get_allocated_begin(const volatile void *p)

Done

compiler-rt/lib/hwasan/hwasan_allocator.cpp

665

I'd recommend to extract AllocationBegin() next to AllocationSize() and keep interface methods implementation short like __sanitizer_get_allocated_size.

Please do the same for all sanitizers

Done

667

looks tool long, please

git clang-format -f --extensions=inc,cc,h,c,cpp,rst HEAD^

Done

[thurston]

In D147005#4241093, @thurston wrote:

In D147005#4237707, @vitalybuka wrote:

Could you please add a patch into the stack where it's used?

Coming soon (tm)

This patch is useful for "Fix tls_get_addr handling for glibc >=2.25" (https://reviews.llvm.org/D147459)

[vitalybuka]

compiler-rt/lib/dfsan/dfsan_allocator.cpp

181

We use implicit pointer tests, please fix for entire patch

[vitalybuka]

compiler-rt/lib/lsan/lsan_allocator.cpp

382

why this one is SANITIZER_WEAK_ATTRIBUTE? It should not be

[thurston]

Use implicit pointer checks, per Vitaly's feedback

Also removed unnecessary weak annotation (though the
header still has it).

[thurston]

compiler-rt/lib/dfsan/dfsan_allocator.cpp

181

Done

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_allocator_interface.h

24

It was LGTM assuming you'll remove SANITIZER_WEAK_ATTRIBUTE

compiler-rt/include/sanitizer/allocator_interface.h

/* Returns the estimated number of bytes that will be reserved by allocator
      memory, returns the maximal possible allocation size, otherwise returns
      "size". */
   size_t __sanitizer_get_estimated_allocated_size(size_t size);
 
   /* Returns true if p was returned by the allocator and
      is not yet freed. */
   int __sanitizer_get_ownership(const volatile void *p);
 
+  /* If a pointer lies within an allocation, it will return the start address
+     of the allocation. Otherwise, it returns nullptr. */
+  void *__sanitizer_get_allocated_begin(const void *p);
+
   /* Returns the number of bytes reserved for the pointer p.
      Requires (get_ownership(p) == true) or (p == 0). */
   size_t __sanitizer_get_allocated_size(const volatile void *p);
 
   /* Number of bytes, allocated and not yet freed by the application. */
   size_t __sanitizer_get_current_allocated_bytes(void);
 
   /* Number of bytes, mmaped by the allocator to fulfill allocation requests.
      Generally, for request of X bytes, allocator can reserve and add to free
      lists a large number of chunks of size X to use them for future requests.
      All these chunks count toward the heap size. Currently, allocator never
      releases memory to OS (instead, it just puts freed chunks to free
      lists). */
   size_t __sanitizer_get_heap_size(void);
 
   /* Number of bytes, mmaped by the allocator, which can be used to fulfill

compiler-rt/lib/asan/asan_allocator.cpp

IgnoreObjectResult IgnoreObjectLocked(const void *p) {
   return kIgnoreObjectSuccess;
 }
 
 }  // namespace __lsan
 
 // ---------------------- Interface ---------------- {{{1
 using namespace __asan;
 
+void *AllocationBegin(const void *p) {
+  AsanChunk *m = __asan::instance.GetAsanChunkByAddr((uptr)p);
+  if (!m)
+    return nullptr;
+  if (atomic_load(&m->chunk_state, memory_order_acquire) != CHUNK_ALLOCATED)
+    return nullptr;
+  if (m->UsedSize() == 0)
+    return nullptr;
+  return (void *)(m->Beg());
+}
+
 // ASan allocator doesn't reserve extra bytes, so normally we would
 // just return "size". We don't want to expose our redzone sizes, etc here.
 uptr __sanitizer_get_estimated_allocated_size(uptr size) {
   return size;
 }
 
 int __sanitizer_get_ownership(const void *p) {
   uptr ptr = reinterpret_cast<uptr>(p);
   return instance.AllocationSize(ptr) > 0;
 }
 
 uptr __sanitizer_get_allocated_size(const void *p) {
   if (!p) return 0;
   uptr ptr = reinterpret_cast<uptr>(p);
   uptr allocated_size = instance.AllocationSize(ptr);
   // Die if p is not malloced or if it is already freed.
   if (allocated_size == 0) {
     GET_STACK_TRACE_FATAL_HERE;
     ReportSanitizerGetAllocatedSizeNotOwned(ptr, &stack);
   }
   return allocated_size;
 }
 
+void *__sanitizer_get_allocated_begin(const void *p) {
+  return AllocationBegin(p);
+}
+
 void __sanitizer_purge_allocator() {
   GET_STACK_TRACE_MALLOC;
   instance.Purge(&stack);
 }
 
 int __asan_update_allocation_context(void* addr) {
   GET_STACK_TRACE_MALLOC;
   return instance.UpdateAllocationStack((uptr)addr, &stack);
 }

compiler-rt/lib/dfsan/dfsan_allocator.cpp

if (UNLIKELY(CheckForCallocOverflow(size, nmemb))) {
     if (AllocatorMayReturnNull())
       return nullptr;
     BufferedStackTrace stack;
     ReportCallocOverflow(nmemb, size, &stack);
   }
   return DFsanAllocate(nmemb * size, sizeof(u64), true /*zeroise*/);
 }
 
+void *AllocationBegin(const void *p) {
+  if (!p)
+    return nullptr;
+  const void *beg = allocator.GetBlockBegin(p);
+  if (!beg)
+    return nullptr;
+  Metadata *b = (Metadata *)allocator.GetMetaData(beg);
+  if (!b)
+    return nullptr;
+  if (b->requested_size == 0)
+    return nullptr;
+  return (void *)beg;
+}
+
 static uptr AllocationSize(const void *p) {
   if (!p)
     return 0;
   const void *beg = allocator.GetBlockBegin(p);
   if (beg != p)
     return 0;
   Metadata *b = (Metadata *)allocator.GetMetaData(p);
   return b->requested_size;

 uptr __sanitizer_get_free_bytes() { return 1; }
 
 uptr __sanitizer_get_unmapped_bytes() { return 1; }
 
 uptr __sanitizer_get_estimated_allocated_size(uptr size) { return size; }
 
 int __sanitizer_get_ownership(const void *p) { return AllocationSize(p) != 0; }
 
+void *__sanitizer_get_allocated_begin(const void *p) {
+  return AllocationBegin(p);
+}
+
 uptr __sanitizer_get_allocated_size(const void *p) { return AllocationSize(p); }

compiler-rt/lib/hwasan/hwasan_allocator.cpp

HwasanChunkView FindHeapChunkByAddress(uptr address) {
   void *block = allocator.GetBlockBegin(reinterpret_cast<void*>(address));
   if (!block)
     return HwasanChunkView();
   Metadata *metadata =
       reinterpret_cast<Metadata*>(allocator.GetMetaData(block));
   return HwasanChunkView(reinterpret_cast<uptr>(block), metadata);
 }
 
+void *AllocationBegin(const void *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 (void *)AddTagToPointer((uptr)beg, tag);
+}
+
 static uptr AllocationSize(const void *tagged_ptr) {
   const void *untagged_ptr = UntagPtr(tagged_ptr);
   if (!untagged_ptr) return 0;
   const void *beg = allocator.GetBlockBegin(untagged_ptr);
   Metadata *b = (Metadata *)allocator.GetMetaData(untagged_ptr);
   if (beg != untagged_ptr) return 0;
   return b->GetRequestedSize();
 }

 uptr __sanitizer_get_free_bytes() { return 1; }
 
 uptr __sanitizer_get_unmapped_bytes() { return 1; }
 
 uptr __sanitizer_get_estimated_allocated_size(uptr size) { return size; }
 
 int __sanitizer_get_ownership(const void *p) { return AllocationSize(p) != 0; }
 
+void *__sanitizer_get_allocated_begin(const void *p) {
+  return AllocationBegin(p);
+}
+
 uptr __sanitizer_get_allocated_size(const void *p) { return AllocationSize(p); }

compiler-rt/lib/lsan/lsan_allocator.cpp

void *Reallocate(const StackTrace &stack, void *p, uptr new_size,
   return new_p;
 }
 
 void GetAllocatorCacheRange(uptr *begin, uptr *end) {
   *begin = (uptr)GetAllocatorCache();
   *end = *begin + sizeof(AllocatorCache);
 }
 
+void *GetMallocBegin(const void *p) {
+  if (!p)
+    return nullptr;
+  const void *beg = allocator.GetBlockBegin(p);
+  if (!beg)
+    return nullptr;
+  ChunkMetadata *m = Metadata(beg);
+  if (!m)
+    return nullptr;
+  if (!m->allocated)
+    return nullptr;
+  if (m->requested_size == 0)
+    return nullptr;
+  return (void *)beg;
+}
+
 uptr GetMallocUsableSize(const void *p) {
   if (!p)
     return 0;
   ChunkMetadata *m = Metadata(p);
   if (!m) return 0;
   return m->requested_size;
 }
 

 uptr __sanitizer_get_unmapped_bytes() { return 0; }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 uptr __sanitizer_get_estimated_allocated_size(uptr size) { return size; }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 int __sanitizer_get_ownership(const void *p) { return Metadata(p) != nullptr; }
 
 SANITIZER_INTERFACE_ATTRIBUTE
+void * __sanitizer_get_allocated_begin(const void *p) {
+  return GetMallocBegin(p);
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE
 uptr __sanitizer_get_allocated_size(const void *p) {
   return GetMallocUsableSize(p);
 }
 
 } // extern "C"

compiler-rt/lib/memprof/memprof_allocator.cpp

int memprof_posix_memalign(void **memptr, uptr alignment, uptr size,
   if (UNLIKELY(!ptr))
     // OOM error is already taken care of by Allocate.
     return errno_ENOMEM;
   CHECK(IsAligned((uptr)ptr, alignment));
   *memptr = ptr;
   return 0;
 }
 
+void *memprof_malloc_begin(const void *p) {
+  u64 user_requested_size;
+  MemprofChunk *m =
+      instance.GetMemprofChunkByAddr((uptr)p, user_requested_size);
+  if (!m)
+    return nullptr;
+  if (user_requested_size == 0)
+    return nullptr;
+
+  return (void *)m->Beg();
+}
+
 uptr memprof_malloc_usable_size(const void *ptr, uptr pc, uptr bp) {
   if (!ptr)
     return 0;
   uptr usable_size = instance.AllocationSize(reinterpret_cast<uptr>(ptr));
   return usable_size;
 }
 
 } // namespace __memprof
 
 // ---------------------- Interface ---------------- {{{1
 using namespace __memprof;
 
 uptr __sanitizer_get_estimated_allocated_size(uptr size) { return size; }
 
 int __sanitizer_get_ownership(const void *p) {
   return memprof_malloc_usable_size(p, 0, 0) != 0;
 }
 
+void *__sanitizer_get_allocated_begin(const void *p) {
+  return memprof_malloc_begin(p);
+}
+
 uptr __sanitizer_get_allocated_size(const void *p) {
   return memprof_malloc_usable_size(p, 0, 0);
 }
 
 int __memprof_profile_dump() {
   instance.FinishAndWrite();
   // In the future we may want to return non-zero if there are any errors
   // detected during the dumping process.
   return 0;
 }

compiler-rt/lib/msan/msan_allocator.cpp

static void *MsanCalloc(StackTrace *stack, uptr nmemb, uptr size) {
   if (UNLIKELY(CheckForCallocOverflow(size, nmemb))) {
     if (AllocatorMayReturnNull())
       return nullptr;
     ReportCallocOverflow(nmemb, size, stack);
   }
   return MsanAllocate(stack, nmemb * size, sizeof(u64), true);
 }
 
+void *AllocationBegin(const void *p) {
+  if (!p)
+    return nullptr;
+  const void *beg = allocator.GetBlockBegin(p);
+  if (!beg)
+    return nullptr;
+  Metadata *b = (Metadata *)allocator.GetMetaData(beg);
+  if (!b)
+    return nullptr;
+  if (b->requested_size == 0)
+    return nullptr;
+
+  return (void *)beg;
+}
+
 static uptr AllocationSize(const void *p) {
   if (!p) return 0;
   const void *beg = allocator.GetBlockBegin(p);
   if (beg != p) return 0;
   Metadata *b = (Metadata *)allocator.GetMetaData(p);
   return b->requested_size;
 }
 

 uptr __sanitizer_get_free_bytes() { return 1; }
 
 uptr __sanitizer_get_unmapped_bytes() { return 1; }
 
 uptr __sanitizer_get_estimated_allocated_size(uptr size) { return size; }
 
 int __sanitizer_get_ownership(const void *p) { return AllocationSize(p) != 0; }
 
+void *__sanitizer_get_allocated_begin(const void *p) {
+  return AllocationBegin(p);
+}
+
 uptr __sanitizer_get_allocated_size(const void *p) { return AllocationSize(p); }

compiler-rt/lib/sanitizer_common/sanitizer_allocator_interface.h

 #include "sanitizer_internal_defs.h"
 
 using __sanitizer::uptr;
 
 extern "C" {
 SANITIZER_INTERFACE_ATTRIBUTE
 uptr __sanitizer_get_estimated_allocated_size(uptr size);
 SANITIZER_INTERFACE_ATTRIBUTE int __sanitizer_get_ownership(const void *p);
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void *
+__sanitizer_get_allocated_begin(const void *p);
 SANITIZER_INTERFACE_ATTRIBUTE uptr
 __sanitizer_get_allocated_size(const void *p);
 SANITIZER_INTERFACE_ATTRIBUTE uptr __sanitizer_get_current_allocated_bytes();
 SANITIZER_INTERFACE_ATTRIBUTE uptr __sanitizer_get_heap_size();
 SANITIZER_INTERFACE_ATTRIBUTE uptr __sanitizer_get_free_bytes();
 SANITIZER_INTERFACE_ATTRIBUTE uptr __sanitizer_get_unmapped_bytes();
 
 SANITIZER_INTERFACE_ATTRIBUTE int __sanitizer_install_malloc_and_free_hooks(
     void (*malloc_hook)(const void *, uptr),
     void (*free_hook)(const void *));
 
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
     void __sanitizer_malloc_hook(void *ptr, uptr size);
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
     void __sanitizer_free_hook(void *ptr);
 
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void
 __sanitizer_purge_allocator();
 
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void
 __sanitizer_print_memory_profile(uptr top_percent, uptr max_number_of_contexts);
 }  // extern "C"
 
 #endif  // SANITIZER_ALLOCATOR_INTERFACE_H

compiler-rt/lib/sanitizer_common/sanitizer_allocator_internal.h

 void *InternalReallocArray(void *p, uptr count, uptr size,
                            InternalAllocatorCache *cache = nullptr);
 void *InternalCalloc(uptr count, uptr size,
                      InternalAllocatorCache *cache = nullptr);
 void InternalFree(void *p, InternalAllocatorCache *cache = nullptr);
 void InternalAllocatorLock();
 void InternalAllocatorUnlock();
 InternalAllocator *internal_allocator();
-
+int __sanitizer_get_allocation_bounds(const void *p, void **start,
+                                      unsigned long long *size);
 } // namespace __sanitizer
 
 #endif // SANITIZER_ALLOCATOR_INTERNAL_H

compiler-rt/lib/sanitizer_common/sanitizer_common_interface.inc

 INTERFACE_WEAK_FUNCTION(__sanitizer_weak_hook_strcmp)
 INTERFACE_WEAK_FUNCTION(__sanitizer_weak_hook_strncmp)
 INTERFACE_WEAK_FUNCTION(__sanitizer_weak_hook_strstr)
 // Stacktrace interface.
 INTERFACE_FUNCTION(__sanitizer_get_module_and_offset_for_pc)
 INTERFACE_FUNCTION(__sanitizer_symbolize_global)
 INTERFACE_FUNCTION(__sanitizer_symbolize_pc)
 // Allocator interface.
+INTERFACE_FUNCTION(__sanitizer_get_allocated_begin)
 INTERFACE_FUNCTION(__sanitizer_get_allocated_size)
 INTERFACE_FUNCTION(__sanitizer_get_current_allocated_bytes)
 INTERFACE_FUNCTION(__sanitizer_get_estimated_allocated_size)
 INTERFACE_FUNCTION(__sanitizer_get_free_bytes)
 INTERFACE_FUNCTION(__sanitizer_get_heap_size)
 INTERFACE_FUNCTION(__sanitizer_get_ownership)
 INTERFACE_FUNCTION(__sanitizer_get_unmapped_bytes)
 INTERFACE_FUNCTION(__sanitizer_install_malloc_and_free_hooks)
 INTERFACE_FUNCTION(__sanitizer_purge_allocator)
 INTERFACE_FUNCTION(__sanitizer_print_memory_profile)
 INTERFACE_WEAK_FUNCTION(__sanitizer_free_hook)
 INTERFACE_WEAK_FUNCTION(__sanitizer_malloc_hook)

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

if (UNLIKELY(CheckForPvallocOverflow(sz, PageSize))) {
     GET_STACK_TRACE_FATAL(thr, pc);
     ReportPvallocOverflow(sz, &stack);
   }
   // pvalloc(0) should allocate one page.
   sz = sz ? RoundUpTo(sz, PageSize) : PageSize;
   return SetErrnoOnNull(user_alloc_internal(thr, pc, sz, PageSize));
 }
 
+void *user_alloc_begin(const void *p) {
+  if (p == nullptr || !IsAppMem((uptr)p))
+    return nullptr;
+  const void *beg = allocator()->GetBlockBegin(p);
+  if (!beg)
+    return nullptr;
+
+  MBlock *b = ctx->metamap.GetBlock((uptr)beg);
+  if (!b)
+    return nullptr;  // Not a valid pointer.
+
+  return (void *)beg;
+}
+
 uptr user_alloc_usable_size(const void *p) {
   if (p == 0 || !IsAppMem((uptr)p))
     return 0;
   MBlock *b = ctx->metamap.GetBlock((uptr)p);
   if (!b)
     return 0;  // Not a valid pointer.
   if (b->siz == 0)
     return 1;  // Zero-sized allocations are actually 1 byte.

 uptr __sanitizer_get_estimated_allocated_size(uptr size) {
   return size;
 }
 
 int __sanitizer_get_ownership(const void *p) {
   return allocator()->GetBlockBegin(p) != 0;
 }
 
+void *__sanitizer_get_allocated_begin(const void *p) {
+  return user_alloc_begin(p);
+}
+
 uptr __sanitizer_get_allocated_size(const void *p) {
   return user_alloc_usable_size(p);
 }
 
 void __tsan_on_thread_idle() {
   ThreadState *thr = cur_thread();
   allocator()->SwallowCache(&thr->proc()->alloc_cache);
   internal_allocator()->SwallowCache(&thr->proc()->internal_alloc_cache);
   ctx->metamap.OnProcIdle(thr->proc());
 }
 }  // extern "C"

compiler-rt/test/sanitizer_common/TestCases/get_allocated_begin.cpp

+// RUN: %clangxx -O0 -g %s -o %t && %run %t
+
+// UBSan does not have its own allocator
+// UNSUPPORTED: ubsan
+
+#include <assert.h>
+#include <sanitizer/allocator_interface.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// Based on lib/msan/tests/msan_test.cpp::get_allocated_size_and_ownership
+int main(void) {
+  int sizes[] = {10, 100, 1000, 10000, 100000, 1000000};
+
+  for (int i = 0; i < sizeof(sizes) / sizeof(int); i++) {
+    printf("Testing size %d\n", sizes[i]);
+
+    char *array = reinterpret_cast<char *>(malloc(sizes[i]));
+    int *int_ptr = new int;
+    printf("array: %p\n", array);
+    printf("int_ptr: %p\n", int_ptr);
+
+    // Bogus value to unpoison start. Calling __sanitizer_get_allocated_begin
+    // does not unpoison it.
+    void *start = NULL;
+    for (int j = 0; j < sizes[i]; j++) {
+      printf("j: %d\n", j);
+
+      start = __sanitizer_get_allocated_begin(array + j);
+      printf("Start: %p (expected: %p)\n", start, array);
+      fflush(stdout);
+      assert(array == start);
+    }
+
+    start = __sanitizer_get_allocated_begin(int_ptr);
+    assert(int_ptr == start);
+
+    void *wild_addr = reinterpret_cast<void *>(4096 * 160);
+    assert(__sanitizer_get_allocated_begin(wild_addr) == NULL);
+
+    wild_addr = reinterpret_cast<void *>(0x1);
+    assert(__sanitizer_get_allocated_begin(wild_addr) == NULL);
+
+    // NULL is a valid argument for GetAllocatedSize but is not owned.
+    assert(__sanitizer_get_allocated_begin(NULL) == NULL);
+
+    free(array);
+    for (int j = 0; j < sizes[i]; j++) {
+      assert(__sanitizer_get_allocated_begin(array + j) == NULL);
+    }
+
+    delete int_ptr;
+    assert(__sanitizer_get_allocated_begin(int_ptr) == NULL);
+  }
+
+  return 0;
+}