macOS: Shim all malloc zones.

base/allocator/malloc_zone_aggregator_mac.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/malloc_zone_aggregator_mac.h"
+
+#include "base/atomicops.h"
+
+namespace base {
+namespace allocator {
+
+MallocZoneFunctions::MallocZoneFunctions() {}
+
+void StoreZoneFunctions(ChromeMallocZone* zone,
+                        MallocZoneFunctions* functions) {
+  functions->malloc = zone->malloc;
+  functions->calloc = zone->calloc;
+  functions->valloc = zone->valloc;
+  functions->free = zone->free;
+  functions->realloc = zone->realloc;
+  functions->size = zone->size;
+  CHECK(functions->malloc && functions->calloc && functions->valloc &&
+        functions->free && functions->realloc && functions->size);
+
+  // These functions might be nullptr.
+  functions->batch_malloc = zone->batch_malloc;
+  functions->batch_free = zone->batch_free;
+
+  if (zone->version >= 5) {
+    // Not all custom malloc zones have a memalign.
+    functions->memalign = zone->memalign;
+  }
+  if (zone->version >= 6) {
+    // This may be nullptr.
+    functions->free_definite_size = zone->free_definite_size;
+  }
+
+  functions->context = zone;
+}
+
+// static
+MallocZoneAggregator* MallocZoneAggregator::GetMallocZoneAggregator() {
+  static MallocZoneAggregator* malloc_zone_aggregator =
+      new MallocZoneAggregator();
+  return malloc_zone_aggregator;
+}
+
+MallocZoneAggregator::MallocZoneAggregator() {
+  memset(zones_, 0, sizeof(zones_));

[Primiano Tucci (use gerrit), 2017/02/22 12:25:39]

can you add a static_assert(is_pod(zones_[0])) ?

[erikchen, 2017/02/22 21:03:09]

MallocZoneFunctions has a non-default constructor, because it's "weight" exceeds
10. I think the static_assert doesn't provide additional clarity, especially
since the default constructor can use non-0 values [header initialization]
[compared to the alternative of suppressing the default-constructor warning].

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

I just realized now about that that default constructor. By not initializing the
pod fields explicitly, that CTOR will prevent the struct from being
zero-initialized, both in the case where you define as a temporary variable on
the stack or as a global variable.
It should be possible to define a pure struct which has as many fields as you
want as long as they are all pod. that is the only way to avoid a static
initializer AFAIK.
Is not just about clarity, is about avoiding a static initializer.
See discussion on
https://groups.google.com/a/chromium.org/d/msg/chromium-dev/688aPLsA5jU/lwJm7...
The TL;DR is that: the only way to have a solid guarantee that a struct/class
won't cause a static initializer is:
- not having any constructors
- checking that is_pod
See my other comment on this. I think the safest and cleanest way here is to not
having a constructor at all and initialize this:
- as a globlal variable: this will be implicitly zero-initialized
- as a local variable: just do MallocZone x = {};
I think this is the only choice here to really prevent a static initializer.
better to ask this to thakis@

+}
+MallocZoneAggregator::~MallocZoneAggregator() {}
+
+void* MallocZoneAggregator::DispatchMallocToZone(void* zone, size_t size) {
+  MallocZoneFunctions& functions = GetFunctionsForZone(zone);
+  return functions.malloc(reinterpret_cast<struct _malloc_zone_t*>(zone), size);
+}
+
+void* MallocZoneAggregator::DispatchCallocToZone(void* zone,
+                                                 size_t num_items,
+                                                 size_t size) {
+  MallocZoneFunctions& functions = GetFunctionsForZone(zone);
+  return functions.calloc(reinterpret_cast<struct _malloc_zone_t*>(zone),
+                          num_items, size);
+}
+void* MallocZoneAggregator::DispatchVallocToZone(void* zone, size_t size) {
+  MallocZoneFunctions& functions = GetFunctionsForZone(zone);
+  return functions.valloc(reinterpret_cast<struct _malloc_zone_t*>(zone), size);
+}
+
+void MallocZoneAggregator::DispatchFreeToZone(void* zone, void* ptr) {
+  MallocZoneFunctions& functions = GetFunctionsForZone(zone);
+  functions.free(reinterpret_cast<struct _malloc_zone_t*>(zone), ptr);
+}
+
+void* MallocZoneAggregator::DispatchReallocToZone(void* zone,
+                                                  void* ptr,
+                                                  size_t size) {
+  MallocZoneFunctions& functions = GetFunctionsForZone(zone);
+  return functions.realloc(reinterpret_cast<struct _malloc_zone_t*>(zone), ptr,
+                           size);
+}
+
+void* MallocZoneAggregator::DispatchMemalignToZone(void* zone,
+                                                   size_t alignment,
+                                                   size_t size) {
+  MallocZoneFunctions& functions = GetFunctionsForZone(zone);
+  return functions.memalign(reinterpret_cast<struct _malloc_zone_t*>(zone),
+                            alignment, size);
+}
+
+unsigned MallocZoneAggregator::DispatchBatchMallocToZone(
+    void* zone,
+    size_t size,
+    void** results,
+    unsigned num_requested) {
+  MallocZoneFunctions& functions = GetFunctionsForZone(zone);
+  return functions.batch_malloc(reinterpret_cast<struct _malloc_zone_t*>(zone),
+                                size, results, num_requested);
+}
+
+void MallocZoneAggregator::DispatchBatchFreeToZone(void* zone,
+                                                   void** to_be_freed,
+                                                   unsigned num_to_be_freed) {
+  MallocZoneFunctions& functions = GetFunctionsForZone(zone);
+  functions.batch_free(reinterpret_cast<struct _malloc_zone_t*>(zone),
+                       to_be_freed, num_to_be_freed);
+}
+
+void MallocZoneAggregator::DispatchFreeDefiniteSizeToZone(void* zone,
+                                                          void* ptr,
+                                                          size_t size) {
+  MallocZoneFunctions& functions = GetFunctionsForZone(zone);
+  functions.free_definite_size(reinterpret_cast<struct _malloc_zone_t*>(zone),
+                               ptr, size);
+}
+
+size_t MallocZoneAggregator::DispatchGetSizeEstimateToZone(void* zone,
+                                                           void* ptr) {
+  MallocZoneFunctions& functions = GetFunctionsForZone(zone);
+  return functions.size(reinterpret_cast<struct _malloc_zone_t*>(zone), ptr);
+}
+
+void MallocZoneAggregator::StoreZone(ChromeMallocZone* zone) {
+  base::AutoLock l(lock_);
+  if (IsZoneAlreadyStoredLockAcquired(zone))
+    return;
+
+  if (zone_count_ == kMaxZoneCount)
+    return;
+
+  StoreZoneFunctions(zone, &zones_[zone_count_]);
+  ++zone_count_;
+  base::subtle::MemoryBarrier();
+}
+
+bool MallocZoneAggregator::IsZoneAlreadyStored(ChromeMallocZone* zone) {
+  base::AutoLock l(lock_);
+  return IsZoneAlreadyStoredLockAcquired(zone);
+}
+
+int MallocZoneAggregator::GetZoneCount() {
+  base::AutoLock l(lock_);
+  return zone_count_;
+}
+
+bool MallocZoneAggregator::IsZoneAlreadyStoredLockAcquired(
+    ChromeMallocZone* zone) {
+  lock_.AssertAcquired();
+  for (int i = 0; i < zone_count_; ++i) {
+    if (zones_[i].context == reinterpret_cast<void*>(zone))
+      return true;
+  }
+  return false;
+}
+
+MallocZoneFunctions& MallocZoneAggregator::GetFunctionsForZone(void* zone) {
+  for (unsigned int i = 0; i < arraysize(zones_); ++i) {
+    if (zones_[i].context == zone)
+      return zones_[i];
+  }
+  CHECK(false);
+  __builtin_unreachable();

[Primiano Tucci (use gerrit), 2017/02/22 12:25:39]

this seems redundant, CHECK(false) will already expand to __builtin_unreachable.
Also using __builtin_unreachable seems unprecedented in the codebase % logging.h
where we use it in CHECK.

[erikchen, 2017/02/22 21:03:09]

Switched to IMMEDIATE_CRASH();

+}
+
+}  // namespace allocator
+}  // namespace base