macOS: Shim all malloc zones.

base/allocator/allocator_shim_default_dispatch_to_mac_zoned_malloc.cc

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/allocator/allocator_shim_default_dispatch_to_mac_zoned_malloc.h"
 
 #include <utility>
 
 #include "base/allocator/allocator_interception_mac.h"
 #include "base/allocator/allocator_shim.h"
+#include "base/allocator/malloc_zone_functions_mac.h"
 #include "base/logging.h"
 
 namespace base {
 namespace allocator {
-
 namespace {
 
-// This is the zone that the allocator shim will call to actually perform heap
-// allocations. It should be populated with the original, unintercepted default
-// malloc zone.
-MallocZoneFunctions g_default_zone;
+MallocZoneFunctions& GetFunctionsForZone(void* zone) {

[Primiano Tucci (use gerrit), 2017/02/23 00:40:17]

IMHO it makes more sense for this to be an inline function in
/malloc_zone_functions_mac.h and hiding (i.e. un-externing) the g_malloc_zones.
This requires the awkard bit where here in this file you need to worry abound
and match the acquire/release semantic (see my comment about threading in
malloc_zone_functions_mac.h)

[erikchen, 2017/02/23 01:43:14]

inline function in malloc_zone_functions_mac.h doesn't allow us to un-extern
g_malloc_zones. Instead I've marked this function inline [which is really just a
compiler hint anyways, which is why I mostly avoid use of it]..

[Primiano Tucci (use gerrit), 2017/02/23 11:19:41]

sorry, I really meant "allow us to not have to access the extern g_malloc_zone
outside of that file"
Yup agree  about inline being pretty much useless. My suggestion was to define
this function in the malloc_zone_functions_mac.h, so that all the logic that
accesses g_malloc_zones stays there.

[erikchen, 2017/02/23 20:06:44]

Done.

+  for (unsigned int i = 0; i < arraysize(g_malloc_zones); ++i) {
+    if (g_malloc_zones[i].context == zone)
+      return g_malloc_zones[i];
+  }
+  IMMEDIATE_CRASH();

[Primiano Tucci (use gerrit), 2017/02/23 00:40:18]

out of curiosity, did you use this because the compiler is not smart enough to
realize that CHECK(false) is noreturn? (well actually it might not be on
non-official builds)

[erikchen, 2017/02/23 01:43:14]

yes

[Primiano Tucci (use gerrit), 2017/02/23 11:19:41]

got it, sg

+}
 
 void* MallocImpl(const AllocatorDispatch*, size_t size, void* context) {
-  return g_default_zone.malloc(
-      reinterpret_cast<struct _malloc_zone_t*>(context), size);
+  MallocZoneFunctions& functions = GetFunctionsForZone(context);
+  return functions.malloc(reinterpret_cast<struct _malloc_zone_t*>(context),
+                          size);
 }
 
 void* CallocImpl(const AllocatorDispatch*,
                  size_t n,
                  size_t size,
                  void* context) {
-  return g_default_zone.calloc(
-      reinterpret_cast<struct _malloc_zone_t*>(context), n, size);
+  MallocZoneFunctions& functions = GetFunctionsForZone(context);
+  return functions.calloc(reinterpret_cast<struct _malloc_zone_t*>(context), n,
+                          size);
 }
 
 void* MemalignImpl(const AllocatorDispatch*,
                    size_t alignment,
                    size_t size,
                    void* context) {
-  return g_default_zone.memalign(
-      reinterpret_cast<struct _malloc_zone_t*>(context), alignment, size);
+  MallocZoneFunctions& functions = GetFunctionsForZone(context);
+  return functions.memalign(reinterpret_cast<struct _malloc_zone_t*>(context),
+                            alignment, size);
 }
 
 void* ReallocImpl(const AllocatorDispatch*,
                   void* ptr,
                   size_t size,
                   void* context) {
-  return g_default_zone.realloc(
-      reinterpret_cast<struct _malloc_zone_t*>(context), ptr, size);
+  MallocZoneFunctions& functions = GetFunctionsForZone(context);
+  return functions.realloc(reinterpret_cast<struct _malloc_zone_t*>(context),
+                           ptr, size);
 }
 
 void FreeImpl(const AllocatorDispatch*, void* ptr, void* context) {
-  g_default_zone.free(reinterpret_cast<struct _malloc_zone_t*>(context), ptr);
+  MallocZoneFunctions& functions = GetFunctionsForZone(context);
+  functions.free(reinterpret_cast<struct _malloc_zone_t*>(context), ptr);
 }
 
 size_t GetSizeEstimateImpl(const AllocatorDispatch*, void* ptr, void* context) {
-  return g_default_zone.size(reinterpret_cast<struct _malloc_zone_t*>(context),
-                             ptr);
+  MallocZoneFunctions& functions = GetFunctionsForZone(context);
+  return functions.size(reinterpret_cast<struct _malloc_zone_t*>(context), ptr);
 }
 
 unsigned BatchMallocImpl(const AllocatorDispatch* self,
                          size_t size,
                          void** results,
                          unsigned num_requested,
                          void* context) {
-  return g_default_zone.batch_malloc(
+  MallocZoneFunctions& functions = GetFunctionsForZone(context);
+  return functions.batch_malloc(
       reinterpret_cast<struct _malloc_zone_t*>(context), size, results,
       num_requested);
 }
 
 void BatchFreeImpl(const AllocatorDispatch* self,
                    void** to_be_freed,
                    unsigned num_to_be_freed,
                    void* context) {
-  g_default_zone.batch_free(reinterpret_cast<struct _malloc_zone_t*>(context),
-                            to_be_freed, num_to_be_freed);
+  MallocZoneFunctions& functions = GetFunctionsForZone(context);
+  functions.batch_free(reinterpret_cast<struct _malloc_zone_t*>(context),
+                       to_be_freed, num_to_be_freed);
 }
 
 void FreeDefiniteSizeImpl(const AllocatorDispatch* self,
                           void* ptr,
                           size_t size,
                           void* context) {
-  g_default_zone.free_definite_size(
+  MallocZoneFunctions& functions = GetFunctionsForZone(context);
+  functions.free_definite_size(
       reinterpret_cast<struct _malloc_zone_t*>(context), ptr, size);
 }
 
 }  // namespace
 
 void InitializeDefaultDispatchToMacAllocator() {
-  StoreFunctionsForDefaultZone(&g_default_zone);
+  StoreFunctionsForAllZones();
 }
 
 const AllocatorDispatch AllocatorDispatch::default_dispatch = {
     &MallocImpl,           /* alloc_function */
     &CallocImpl,           /* alloc_zero_initialized_function */
     &MemalignImpl,         /* alloc_aligned_function */
     &ReallocImpl,          /* realloc_function */
     &FreeImpl,             /* free_function */
     &GetSizeEstimateImpl,  /* get_size_estimate_function */
     &BatchMallocImpl,      /* batch_malloc_function */
     &BatchFreeImpl,        /* batch_free_function */
     &FreeDefiniteSizeImpl, /* free_definite_size_function */
     nullptr,               /* next */
 };
 
 }  // namespace allocator
 }  // namespace base