Internalize AllocationBegin functions after D147005

[MaskRay]

update tsan

[thurston]

lsan and memprof also had analogous functions added in D147005

[MaskRay]

update lsan and memprof

compiler-rt/lib/asan/asan_allocator.cpp

IgnoreObjectResult IgnoreObject(const void *p) {
   return kIgnoreObjectSuccess;
 }
 
 }  // namespace __lsan
 
 // ---------------------- Interface ---------------- {{{1
 using namespace __asan;
 
-const void *AllocationBegin(const void *p) {
+static const 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 (const void *)(m->Beg());

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*/);
 }
 
-const void *AllocationBegin(const void *p) {
+static const void *AllocationBegin(const void *p) {
   if (!p)
     return nullptr;
   void *beg = allocator.GetBlockBegin(p);
   if (!beg)
     return nullptr;
   Metadata *b = (Metadata *)allocator.GetMetaData(beg);
   if (!b)
     return nullptr;

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);
 }
 
-const void *AllocationBegin(const void *p) {
+static const 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;
 

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);
 }
 
-const void *GetMallocBegin(const void *p) {
+static const void *GetMallocBegin(const void *p) {
   if (!p)
     return nullptr;
   void *beg = allocator.GetBlockBegin(p);
   if (!beg)
     return nullptr;
   ChunkMetadata *m = Metadata(beg);
   if (!m)
     return nullptr;

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;
 }
 
-const void *memprof_malloc_begin(const void *p) {
+static const 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;
 

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);
 }
 
-const void *AllocationBegin(const void *p) {
+static const void *AllocationBegin(const void *p) {
   if (!p)
     return nullptr;
   void *beg = allocator.GetBlockBegin(p);
   if (!beg)
     return nullptr;
   Metadata *b = (Metadata *)allocator.GetMetaData(beg);
   if (!b)
     return nullptr;

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));
 }
 
-const void *user_alloc_begin(const void *p) {
+static const void *user_alloc_begin(const void *p) {
   if (p == nullptr || !IsAppMem((uptr)p))
     return nullptr;
   void *beg = allocator()->GetBlockBegin(p);
   if (!beg)
     return nullptr;
 
   MBlock *b = ctx->metamap.GetBlock((uptr)beg);
   if (!b)