[msan] Implement __sanitizer_get_current_allocated_bytes

[vitalybuka]

Summary

__sanitizer_get_current_allocated_bytes had as body, but allocator
caches were not registered to collect stats. It's done by
SizeClassAllocator64LocalCache::Init().

[vitalybuka]

update

[kstoimenov]

Could you please provide a little bit more context around the bug that this is fixing?

[vitalybuka]

In D151352#4369155, @kstoimenov wrote:

Could you please provide a little bit more context around the bug that this is fixing?

It fixes // XFAIL: msan

compiler-rt/lib/msan/msan_allocator.h

 
 #include "sanitizer_common/sanitizer_common.h"
 
 namespace __msan {
 
 struct MsanThreadLocalMallocStorage {
   // Allocator cache contains atomic_uint64_t which must be 8-byte aligned.
   ALIGNED(8) uptr allocator_cache[96 * (512 * 8 + 16)];  // Opaque.
+  void Init();
   void CommitBack();
 
  private:
   // These objects are allocated via mmap() and are zero-initialized.
   MsanThreadLocalMallocStorage() {}
 };
 
 } // namespace __msan
 #endif // MSAN_ALLOCATOR_H

compiler-rt/lib/msan/msan_allocator.cpp

 }
 
 AllocatorCache *GetAllocatorCache(MsanThreadLocalMallocStorage *ms) {
   CHECK(ms);
   CHECK_LE(sizeof(AllocatorCache), sizeof(ms->allocator_cache));
   return reinterpret_cast<AllocatorCache *>(ms->allocator_cache);
 }
 
+void MsanThreadLocalMallocStorage::Init() {
+  allocator.InitCache(GetAllocatorCache(this));
+}
+
 void MsanThreadLocalMallocStorage::CommitBack() {
   allocator.SwallowCache(GetAllocatorCache(this));
+  allocator.DestroyCache(GetAllocatorCache(this));
 }
 
 static void *MsanAllocate(StackTrace *stack, uptr size, uptr alignment,
                           bool zeroise) {
   if (size > max_malloc_size) {
     if (AllocatorMayReturnNull()) {
       Report("WARNING: MemorySanitizer failed to allocate 0x%zx bytes\n", size);
       return nullptr;

 
 int __sanitizer_get_ownership(const void *p) { return AllocationSize(p) != 0; }
 
 const void *__sanitizer_get_allocated_begin(const void *p) {
   return AllocationBegin(p);
 }
 
 uptr __sanitizer_get_allocated_size(const void *p) { return AllocationSize(p); }
+
+void __sanitizer_purge_allocator() { allocator.ForceReleaseToOS(); }

compiler-rt/lib/msan/msan_thread.cpp

void MsanThread::ClearShadowForThreadStackAndTLS() {
   });
 }
 
 void MsanThread::Init() {
   SetThreadStackAndTls();
   CHECK(MEM_IS_APP(stack_.bottom));
   CHECK(MEM_IS_APP(stack_.top - 1));
   ClearShadowForThreadStackAndTLS();
+  malloc_storage().Init();
 }
 
 void MsanThread::TSDDtor(void *tsd) {
   MsanThread *t = (MsanThread*)tsd;
   t->Destroy();
 }
 
 void MsanThread::Destroy() {

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

 // RUN: %clangxx %s -o %t && %run %t 1234
 // RUN: %clangxx %s -o %t && %run %t 5678910
 
 // No allocator.
 // UNSUPPORTED: ubsan
 
 // FIXME: implementation is incomplete.
-// XFAIL: msan, lsan, hwasan
+// XFAIL: lsan, hwasan
 
 #include <assert.h>
 #include <sanitizer/allocator_interface.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <thread>
 
 void Test(int size) {
int main(int argc, char **argv) {
   Test(size);
 
   // Check the thread local caches work as well.
   std::thread t(Test, size);
   t.join();
 
   return 0;
 }
 No newline at end of file