[msan] Optimize zeroing allocated memory

[vitalybuka]

update

compiler-rt/lib/msan/msan_allocator.cpp

if (UNLIKELY(!allocated)) {
     if (AllocatorMayReturnNull())
       return nullptr;
     ReportOutOfMemory(size, stack);
   }
   Metadata *meta =
       reinterpret_cast<Metadata *>(allocator.GetMetaData(allocated));
   meta->requested_size = size;
   if (zeroise) {
+    if (allocator.FromPrimary(allocated))
       __msan_clear_and_unpoison(allocated, size);
+    else
+      __msan_unpoison(allocated, size);  // Mem is already zeroed.
   } else if (flags()->poison_in_malloc) {
     __msan_poison(allocated, size);
     if (__msan_get_track_origins()) {
       stack->tag = StackTrace::TAG_ALLOC;
       Origin o = Origin::CreateHeapOrigin(stack);
       __msan_set_origin(allocated, size, o.raw_id());
     }
   }
   UnpoisonParam(2);
   RunMallocHooks(allocated, size);
   return allocated;
 }
 
 void MsanDeallocate(StackTrace *stack, void *p) {
   CHECK(p);
   UnpoisonParam(1);
   RunFreeHooks(p);
 
   Metadata *meta = reinterpret_cast<Metadata *>(allocator.GetMetaData(p));
   uptr size = meta->requested_size;
   meta->requested_size = 0;
   // This memory will not be reused by anyone else, so we are free to keep it
-  // poisoned.
-  if (flags()->poison_in_free) {
+  // poisoned. The secondary allocator will unmap and unpoison by
+  // MsanMapUnmapCallback, no need to poison it here.
+  if (flags()->poison_in_free && allocator.FromPrimary(p)) {
     __msan_poison(p, size);
     if (__msan_get_track_origins()) {
       stack->tag = StackTrace::TAG_DEALLOC;
       Origin o = Origin::CreateHeapOrigin(stack);
       __msan_set_origin(p, size, o.raw_id());
     }
   }
   MsanThread *t = GetCurrentThread();

compiler-rt/test/sanitizer_common/TestCases/Posix/huge_malloc.c

 // RUN: %clang -O0 %s -o %t && %env_tool_opts=allocator_may_return_null=1:hard_rss_limit_mb=50:quarantine_size_mb=1 %run %t
 
 #include <stdlib.h>
 #include <stdio.h>
 
 // https://github.com/google/sanitizers/issues/981
 // UNSUPPORTED: android-26
 
 // FIXME: Hangs.
 // UNSUPPORTED: tsan
 
-// FIXME: Make it work. Don't xfail to avoid excessive memory usage.
-// UNSUPPORTED: msan
-
 // Hwasan requires tagging of new allocations, so needs RSS for shadow.
 // UNSUPPORTED: hwasan
 
 void *p;
 
 int main(int argc, char **argv) {
   for (int i = 0; i < sizeof(void *) * 8; ++i) {
-    p = malloc(1ull << i);
-    fprintf(stderr, "%llu: %p\n", (1ull << i), p);
+    // Calloc avoids MSAN shadow poisoning.
+    p = calloc(1ull << i, 1);
+    fprintf(stderr, "%d %llu: %p\n", i, (1ull << i), p);
     free(p);
   }
   return 0;
 }