Macro out unused functions in memory_mac.mm

base/process/memory_mac.mm

 // Copyright (c) 2013 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/process/memory.h"
 
+// AddressSanitizer handles heap corruption, and on 64 bit Macs, the malloc
+// system automatically abort()s on heap corruption.
+#if !defined(ADDRESS_SANITIZER) && ARCH_CPU_32_BITS
+#define HANDLE_MEMORY_CORRUPTION_MANUALLY
+#endif
+
 #include <CoreFoundation/CoreFoundation.h>
 #include <errno.h>
 #include <mach/mach.h>
 #include <mach/mach_vm.h>
 #include <malloc/malloc.h>
 #import <objc/runtime.h>
 
 #include <new>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/mach_logging.h"
 #include "base/scoped_clear_errno.h"
 #include "third_party/apple_apsl/CFBase.h"
 #include "third_party/apple_apsl/malloc.h"
 
-#if ARCH_CPU_32_BITS
+#if defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
 #include <dlfcn.h>
 #include <mach-o/nlist.h>
 
 #include "base/threading/thread_local.h"
 #include "third_party/mach_override/mach_override.h"
-#endif  // ARCH_CPU_32_BITS
+#endif  // defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
 
 namespace base {
 
 // These are helpers for EnableTerminationOnHeapCorruption, which is a no-op
 // on 64 bit Macs.
-#if ARCH_CPU_32_BITS
+#if defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
 namespace {
 
 // Finds the library path for malloc() and thus the libC part of libSystem,
 // which in Lion is in a separate image.
 const char* LookUpLibCPath() {
   const void* addr = reinterpret_cast<void*>(&malloc);
 
   Dl_info info;
   if (dladdr(addr, &info))
     return info.dli_fname;
@@ skipping 108 matching lines @@
   // crash dump info (setting a breakpad key would re-enter the malloc
   // library).  Max documented errno in intro(2) is actually 102, but
   // it really just needs to be "small" to stay on the right vm page.
   const int kMaxErrno = 256;
   char* volatile death_ptr = NULL;
   death_ptr += std::min(errno, kMaxErrno);
   *death_ptr = '!';
 }
 
 }  // namespace
-#endif  // ARCH_CPU_32_BITS
+#endif  // defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
 
 void EnableTerminationOnHeapCorruption() {
-#if defined(ADDRESS_SANITIZER) || ARCH_CPU_64_BITS
-  // AddressSanitizer handles heap corruption, and on 64 bit Macs, the malloc
-  // system automatically abort()s on heap corruption.
-  return;
-#else
+#if defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
   // Only override once, otherwise CrMallocErrorBreak() will recurse
   // to itself.
   if (g_original_malloc_error_break)
     return;
 
   malloc_error_break_t malloc_error_break = LookUpMallocErrorBreak();
   if (!malloc_error_break) {
     DLOG(WARNING) << "Could not find malloc_error_break";
     return;
   }
 
   mach_error_t err = mach_override_ptr(
      (void*)malloc_error_break,
      (void*)&CrMallocErrorBreak,
      (void**)&g_original_malloc_error_break);
 
   if (err != err_none)
     DLOG(WARNING) << "Could not override malloc_error_break; error = " << err;
-#endif  // defined(ADDRESS_SANITIZER) || ARCH_CPU_64_BITS
+#endif  // defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
 }
 
 // ------------------------------------------------------------------------
 
 namespace {
 
 bool g_oom_killer_enabled;
 
+#if !defined(ADDRESS_SANITIZER)
+
 // Starting with Mac OS X 10.7, the zone allocators set up by the system are
 // read-only, to prevent them from being overwritten in an attack. However,
 // blindly unprotecting and reprotecting the zone allocators fails with
 // GuardMalloc because GuardMalloc sets up its zone allocator using a block of
 // memory in its bss. Explicit saving/restoring of the protection is required.
 //
 // This function takes a pointer to a malloc zone, de-protects it if necessary,
 // and returns (in the out parameters) a region of memory (if any) to be
 // re-protected when modifications are complete. This approach assumes that
 // there is no contention for the protection of this memory.
@@ skipping 72 matching lines @@
 
 malloc_type g_old_malloc_purgeable;
 calloc_type g_old_calloc_purgeable;
 valloc_type g_old_valloc_purgeable;
 free_type g_old_free_purgeable;
 realloc_type g_old_realloc_purgeable;
 memalign_type g_old_memalign_purgeable;
 
 void* oom_killer_malloc(struct _malloc_zone_t* zone,
                         size_t size) {
-#if ARCH_CPU_32_BITS
+#if defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
   ScopedClearErrno clear_errno;
-#endif  // ARCH_CPU_32_BITS
+#endif  // defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
   void* result = g_old_malloc(zone, size);
   if (!result && size)
     debug::BreakDebugger();
   return result;
 }
 
 void* oom_killer_calloc(struct _malloc_zone_t* zone,
                         size_t num_items,
                         size_t size) {
-#if ARCH_CPU_32_BITS
+#if defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
   ScopedClearErrno clear_errno;
-#endif  // ARCH_CPU_32_BITS
+#endif  // defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
   void* result = g_old_calloc(zone, num_items, size);
   if (!result && num_items && size)
     debug::BreakDebugger();
   return result;
 }
 
 void* oom_killer_valloc(struct _malloc_zone_t* zone,
                         size_t size) {
-#if ARCH_CPU_32_BITS
+#if defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
   ScopedClearErrno clear_errno;
-#endif  // ARCH_CPU_32_BITS
+#endif  // defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
   void* result = g_old_valloc(zone, size);
   if (!result && size)
     debug::BreakDebugger();
   return result;
 }
 
 void oom_killer_free(struct _malloc_zone_t* zone,
                      void* ptr) {
-#if ARCH_CPU_32_BITS
+#if defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
   ScopedClearErrno clear_errno;
-#endif  // ARCH_CPU_32_BITS
+#endif  // defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
   g_old_free(zone, ptr);
 }
 
 void* oom_killer_realloc(struct _malloc_zone_t* zone,
                          void* ptr,
                          size_t size) {
-#if ARCH_CPU_32_BITS
+#if defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
   ScopedClearErrno clear_errno;
-#endif  // ARCH_CPU_32_BITS
+#endif  // defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
   void* result = g_old_realloc(zone, ptr, size);
   if (!result && size)
     debug::BreakDebugger();
   return result;
 }
 
 void* oom_killer_memalign(struct _malloc_zone_t* zone,
                           size_t alignment,
                           size_t size) {
-#if ARCH_CPU_32_BITS
+#if defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
   ScopedClearErrno clear_errno;
-#endif  // ARCH_CPU_32_BITS
+#endif  // defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
   void* result = g_old_memalign(zone, alignment, size);
   // Only die if posix_memalign would have returned ENOMEM, since there are
   // other reasons why NULL might be returned (see
   // http://opensource.apple.com/source/Libc/Libc-583/gen/malloc.c ).
   if (!result && size && alignment >= sizeof(void*)
       && (alignment & (alignment - 1)) == 0) {
     debug::BreakDebugger();
   }
   return result;
 }
 
 void* oom_killer_malloc_purgeable(struct _malloc_zone_t* zone,
                                   size_t size) {
-#if ARCH_CPU_32_BITS
+#if defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
   ScopedClearErrno clear_errno;
-#endif  // ARCH_CPU_32_BITS
+#endif  // defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
   void* result = g_old_malloc_purgeable(zone, size);
   if (!result && size)
     debug::BreakDebugger();
   return result;
 }
 
 void* oom_killer_calloc_purgeable(struct _malloc_zone_t* zone,
                                   size_t num_items,
                                   size_t size) {
-#if ARCH_CPU_32_BITS
+#if defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
   ScopedClearErrno clear_errno;
-#endif  // ARCH_CPU_32_BITS
+#endif  // defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
   void* result = g_old_calloc_purgeable(zone, num_items, size);
   if (!result && num_items && size)
     debug::BreakDebugger();
   return result;
 }
 
 void* oom_killer_valloc_purgeable(struct _malloc_zone_t* zone,
                                   size_t size) {
-#if ARCH_CPU_32_BITS
+#if defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
   ScopedClearErrno clear_errno;
-#endif  // ARCH_CPU_32_BITS
+#endif  // defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
   void* result = g_old_valloc_purgeable(zone, size);
   if (!result && size)
     debug::BreakDebugger();
   return result;
 }
 
 void oom_killer_free_purgeable(struct _malloc_zone_t* zone,
                                void* ptr) {
-#if ARCH_CPU_32_BITS
+#if defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
   ScopedClearErrno clear_errno;
-#endif  // ARCH_CPU_32_BITS
+#endif  // defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
   g_old_free_purgeable(zone, ptr);
 }
 
 void* oom_killer_realloc_purgeable(struct _malloc_zone_t* zone,
                                    void* ptr,
                                    size_t size) {
-#if ARCH_CPU_32_BITS
+#if defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
   ScopedClearErrno clear_errno;
-#endif  // ARCH_CPU_32_BITS
+#endif  // defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
   void* result = g_old_realloc_purgeable(zone, ptr, size);
   if (!result && size)
     debug::BreakDebugger();
   return result;
 }
 
 void* oom_killer_memalign_purgeable(struct _malloc_zone_t* zone,
                                     size_t alignment,
                                     size_t size) {
-#if ARCH_CPU_32_BITS
+#if defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
   ScopedClearErrno clear_errno;
-#endif  // ARCH_CPU_32_BITS
+#endif  // defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
   void* result = g_old_memalign_purgeable(zone, alignment, size);
   // Only die if posix_memalign would have returned ENOMEM, since there are
   // other reasons why NULL might be returned (see
   // http://opensource.apple.com/source/Libc/Libc-583/gen/malloc.c ).
   if (!result && size && alignment >= sizeof(void*)
       && (alignment & (alignment - 1)) == 0) {
     debug::BreakDebugger();
   }
   return result;
 }
 
+#endif  // !defined(ADDRESS_SANITIZER)
+
 // === C++ operator new ===
 
 void oom_killer_new() {
   debug::BreakDebugger();
 }
 
+#if !defined(ADDRESS_SANITIZER)
+
 // === Core Foundation CFAllocators ===
 
 bool CanGetContextForCFAllocator() {
   return !base::mac::IsOSLaterThanYosemite_DontCallThis();
 }
 
 CFAllocatorContext* ContextForCFAllocator(CFAllocatorRef allocator) {
   if (base::mac::IsOSSnowLeopard()) {
     ChromeCFAllocatorLeopards* our_allocator =
         const_cast<ChromeCFAllocatorLeopards*>(
@@ skipping 36 matching lines @@
 
 void* oom_killer_cfallocator_malloc_zone(CFIndex alloc_size,
                                          CFOptionFlags hint,
                                          void* info) {
   void* result = g_old_cfallocator_malloc_zone(alloc_size, hint, info);
   if (!result)
     debug::BreakDebugger();
   return result;
 }
 
+#endif  // !defined(ADDRESS_SANITIZER)
+
 // === Cocoa NSObject allocation ===
 
 typedef id (*allocWithZone_t)(id, SEL, NSZone*);
 allocWithZone_t g_old_allocWithZone;
 
 id oom_killer_allocWithZone(id self, SEL _cmd, NSZone* zone)
 {
   id result = g_old_allocWithZone(self, _cmd, zone);
   if (!result)
     debug::BreakDebugger();
   return result;
 }
 
 }  // namespace
 
 bool UncheckedMalloc(size_t size, void** result) {
+#if defined(ADDRESS_SANITIZER)
+  *result = malloc(size);
+#else
   if (g_old_malloc) {
-#if ARCH_CPU_32_BITS
+#if defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
     ScopedClearErrno clear_errno;
     ThreadLocalBooleanAutoReset flag(g_unchecked_alloc.Pointer(), true);
-#endif  // ARCH_CPU_32_BITS
+#endif  // defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
     *result = g_old_malloc(malloc_default_zone(), size);
   } else {
     *result = malloc(size);
   }
+#endif  // defined(ADDRESS_SANITIZER)
 
   return *result != NULL;
 }
 
 bool UncheckedCalloc(size_t num_items, size_t size, void** result) {
+#if defined(ADDRESS_SANITIZER)
+  *result = calloc(num_items, size);
+#else
   if (g_old_calloc) {
-#if ARCH_CPU_32_BITS
+#if defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
     ScopedClearErrno clear_errno;
     ThreadLocalBooleanAutoReset flag(g_unchecked_alloc.Pointer(), true);
-#endif  // ARCH_CPU_32_BITS
+#endif  // defined(HANDLE_MEMORY_CORRUPTION_MANUALLY)
     *result = g_old_calloc(malloc_default_zone(), num_items, size);
   } else {
     *result = calloc(num_items, size);
   }
+#endif  // defined(ADDRESS_SANITIZER)
 
   return *result != NULL;
 }
 
 void* UncheckedMalloc(size_t size) {
   void* address;
   return UncheckedMalloc(size, &address) ? address : NULL;
 }
 
 void* UncheckedCalloc(size_t num_items, size_t size) {
   void* address;
   return UncheckedCalloc(num_items, size, &address) ? address : NULL;
 }
 
 void EnableTerminationOnOutOfMemory() {
   if (g_oom_killer_enabled)
     return;
 
   g_oom_killer_enabled = true;
 
   // === C malloc/calloc/valloc/realloc/posix_memalign ===
 
   // This approach is not perfect, as requests for amounts of memory larger than
   // MALLOC_ABSOLUTE_MAX_SIZE (currently SIZE_T_MAX - (2 * PAGE_SIZE)) will
   // still fail with a NULL rather than dying (see
   // http://opensource.apple.com/source/Libc/Libc-583/gen/malloc.c for details).
   // Unfortunately, it's the best we can do. Also note that this does not affect
   // allocations from non-default zones.
 
+#if !defined(ADDRESS_SANITIZER)
+  // Don't do anything special on OOM for the malloc zones replaced by
+  // AddressSanitizer, as modifying or protecting them may not work correctly.
+
   CHECK(!g_old_malloc && !g_old_calloc && !g_old_valloc && !g_old_realloc &&
         !g_old_memalign) << "Old allocators unexpectedly non-null";
 
   CHECK(!g_old_malloc_purgeable && !g_old_calloc_purgeable &&
         !g_old_valloc_purgeable && !g_old_realloc_purgeable &&
         !g_old_memalign_purgeable) << "Old allocators unexpectedly non-null";
 
-#if !defined(ADDRESS_SANITIZER)
-  // Don't do anything special on OOM for the malloc zones replaced by
-  // AddressSanitizer, as modifying or protecting them may not work correctly.
-
   ChromeMallocZone* default_zone =
       reinterpret_cast<ChromeMallocZone*>(malloc_default_zone());
   ChromeMallocZone* purgeable_zone =
       reinterpret_cast<ChromeMallocZone*>(malloc_default_purgeable_zone());
 
   mach_vm_address_t default_reprotection_start = 0;
   mach_vm_size_t default_reprotection_length = 0;
   vm_prot_t default_reprotection_value = VM_PROT_NONE;
   DeprotectMallocZone(default_zone,
                       &default_reprotection_start,
@@ skipping 159 matching lines @@
                                             @selector(allocWithZone:));
   g_old_allocWithZone = reinterpret_cast<allocWithZone_t>(
       method_getImplementation(orig_method));
   CHECK(g_old_allocWithZone)
       << "Failed to get allocWithZone allocation function.";
   method_setImplementation(orig_method,
                            reinterpret_cast<IMP>(oom_killer_allocWithZone));
 }
 
 }  // namespace base