Update the tcmalloc chromium branch to r144 (gperftools 2.0), and merge chromium-specific changes.

third_party/tcmalloc/chromium/src/heap-checker.cc

 // Copyright (c) 2005, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 34 matching lines @@
 #include <sys/mman.h>
 #endif
 #ifdef HAVE_PTHREAD
 #include <pthread.h>
 #endif
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <time.h>
 #include <assert.h>
 
-#ifdef HAVE_LINUX_PTRACE_H
+#if defined(HAVE_LINUX_PTRACE_H)
 #include <linux/ptrace.h>
 #endif
 #ifdef HAVE_SYS_SYSCALL_H
 #include <sys/syscall.h>
 #endif
 #if defined(_WIN32) || defined(__CYGWIN__) || defined(__CYGWIN32__) || defined(__MINGW32__)
 #include <wtypes.h>
 #include <winbase.h>
 #undef ERROR     // windows defines these as macros, which can cause trouble
 #undef max
 #undef min
 #endif
 
 #include <string>
 #include <vector>
 #include <map>
 #include <set>
 #include <algorithm>
 #include <functional>
 
-#include <google/heap-checker.h>
+#include <gperftools/heap-checker.h>
 
 #include "base/basictypes.h"
 #include "base/googleinit.h"
 #include "base/logging.h"
-#include <google/stacktrace.h>
+#include <gperftools/stacktrace.h>
 #include "base/commandlineflags.h"
 #include "base/elfcore.h"              // for i386_regs
 #include "base/thread_lister.h"
 #include "heap-profile-table.h"
 #include "base/low_level_alloc.h"
 #include "malloc_hook-inl.h"
-#include <google/malloc_hook.h>
-#include <google/malloc_extension.h>
+#include <gperftools/malloc_hook.h>
+#include <gperftools/malloc_extension.h>
 #include "maybe_threads.h"
 #include "memory_region_map.h"
 #include "base/spinlock.h"
 #include "base/sysinfo.h"
 #include "base/stl_allocator.h"
 
 using std::string;
 using std::basic_string;
 using std::pair;
 using std::map;
@@ skipping 37 matching lines @@
 //----------------------------------------------------------------------
 // Flags that control heap-checking
 //----------------------------------------------------------------------
 
 DEFINE_string(heap_check,
               EnvToString("HEAPCHECK", ""),
               "The heap leak checking to be done over the whole executable: "
               "\"minimal\", \"normal\", \"strict\", "
               "\"draconian\", \"as-is\", and \"local\" "
               " or the empty string are the supported choices. "
-              "(See HeapLeakChecker::InternalInitStart for details.)");
+              "(See HeapLeakChecker_InternalInitStart for details.)");
 
 DEFINE_bool(heap_check_report, true, "Obsolete");
 
 DEFINE_bool(heap_check_before_constructors,
             true,
             "deprecated; pretty much always true now");
 
 DEFINE_bool(heap_check_after_destructors,
             EnvToBool("HEAP_CHECK_AFTER_DESTRUCTORS", false),
             "If overall heap check is to end after global destructors "
@@ skipping 117 matching lines @@
 static pid_t heap_checker_pid = 0;
 
 // If we did heap profiling during global constructors execution
 static bool constructor_heap_profiling = false;
 
 // RAW_VLOG level we dump key INFO messages at.  If you want to turn
 // off these messages, set the environment variable PERFTOOLS_VERBOSE=-1.
 static const int heap_checker_info_level = 0;
 
 //----------------------------------------------------------------------
-// Cancel our InitialMallocHook_* if present.
-static void CancelInitialMallocHooks();  // defined below
-
-//----------------------------------------------------------------------
 // HeapLeakChecker's own memory allocator that is
 // independent of the normal program allocator.
 //----------------------------------------------------------------------
 
 // Wrapper of LowLevelAlloc for STL_Allocator and direct use.
 // We always access this class under held heap_checker_lock,
 // this allows us to in particular protect the period when threads are stopped
 // at random spots with ListAllProcessThreads by heap_checker_lock,
 // w/o worrying about the lock in LowLevelAlloc::Arena.
 // We rely on the fact that we use an own arena with an own lock here.
@@ skipping 247 matching lines @@
 template<typename T>
 inline static const void* AsPtr(T addr) {
   return reinterpret_cast<void*>(addr);
 }
 inline static uintptr_t AsInt(const void* ptr) {
   return reinterpret_cast<uintptr_t>(ptr);
 }
 
 //----------------------------------------------------------------------
 
+// We've seen reports that strstr causes heap-checker crashes in some
+// libc's (?):
+//    http://code.google.com/p/gperftools/issues/detail?id=263
+// It's simple enough to use our own.  This is not in time-critical code.
+static const char* hc_strstr(const char* s1, const char* s2) {
+  const size_t len = strlen(s2);
+  RAW_CHECK(len > 0, "Unexpected empty string passed to strstr()");
+  for (const char* p = strchr(s1, *s2); p != NULL; p = strchr(p+1, *s2)) {
+    if (strncmp(p, s2, len) == 0) {
+      return p;
+    }
+  }
+  return NULL;
+}
+
+//----------------------------------------------------------------------
+
 // Our hooks for MallocHook
 static void NewHook(const void* ptr, size_t size) {
   if (ptr != NULL) {
     const int counter = get_thread_disable_counter();
     const bool ignore = (counter > 0);
     RAW_VLOG(16, "Recording Alloc: %p of %"PRIuS "; %d", ptr, size,
              int(counter));
+
+    // Fetch the caller's stack trace before acquiring heap_checker_lock.
+    void* stack[HeapProfileTable::kMaxStackDepth];
+    int depth = HeapProfileTable::GetCallerStackTrace(0, stack);
+
     { SpinLockHolder l(&heap_checker_lock);
       if (size > max_heap_object_size) max_heap_object_size = size;
       uintptr_t addr = AsInt(ptr);
       if (addr < min_heap_address) min_heap_address = addr;
       addr += size;
       if (addr > max_heap_address) max_heap_address = addr;
       if (heap_checker_on) {
-        heap_profile->RecordAlloc(ptr, size, 0);
+        heap_profile->RecordAlloc(ptr, size, depth, stack);
         if (ignore) {
           heap_profile->MarkAsIgnored(ptr);
         }
       }
     }
     RAW_VLOG(17, "Alloc Recorded: %p of %"PRIuS"", ptr, size);
   }
 }
 
 static void DeleteHook(const void* ptr) {
@@ skipping 182 matching lines @@
         return;
       }
     }
     RAW_VLOG(11, "%s-disabling %"PRIuS" bytes at %p",
                 (stack_disable ? "Stack" : "Range"), info.object_size, ptr);
     live_objects->push_back(AllocObject(ptr, info.object_size,
                                         MUST_BE_ON_HEAP));
   }
 }
 
+static const char kUnnamedProcSelfMapEntry[] = "UNNAMED";
+
 // This function takes some fields from a /proc/self/maps line:
 //
 //   start_address  start address of a memory region.
 //   end_address    end address of a memory region
 //   permissions    rwx + private/shared bit
 //   filename       filename of the mapped file
 //
 // If the region is not writeable, then it cannot have any heap
 // pointers in it, otherwise we record it as a candidate live region
 // to get filtered later.
 static void RecordGlobalDataLocked(uintptr_t start_address,
                                    uintptr_t end_address,
                                    const char* permissions,
                                    const char* filename) {
   RAW_DCHECK(heap_checker_lock.IsHeld(), "");
   // Ignore non-writeable regions.
   if (strchr(permissions, 'w') == NULL) return;
-  if (filename == NULL  ||  *filename == '\0')  filename = "UNNAMED";
+  if (filename == NULL  ||  *filename == '\0') {
+    filename = kUnnamedProcSelfMapEntry;
+  }
   RAW_VLOG(11, "Looking into %s: 0x%" PRIxPTR "..0x%" PRIxPTR,
               filename, start_address, end_address);
   (*library_live_objects)[filename].
     push_back(AllocObject(AsPtr(start_address),
                           end_address - start_address,
                           MAYBE_LIVE));
 }
 
 // See if 'library' from /proc/self/maps has base name 'library_base'
 // i.e. contains it and has '.' or '-' after it.
 static bool IsLibraryNamed(const char* library, const char* library_base) {
-  const char* p = strstr(library, library_base);
+  const char* p = hc_strstr(library, library_base);
   size_t sz = strlen(library_base);
   return p != NULL  &&  (p[sz] == '.'  ||  p[sz] == '-');
 }
 
 // static
 void HeapLeakChecker::DisableLibraryAllocsLocked(const char* library,
                                                  uintptr_t start_address,
                                                  uintptr_t end_address) {
   RAW_DCHECK(heap_checker_lock.IsHeld(), "");
   int depth = 0;
@@ skipping 91 matching lines @@
       continue;
     }
     // Determine if any shared libraries are present (this is the same
     // list of extensions as is found in pprof).  We want to ignore
     // 'fake' libraries with inode 0 when determining.  However, some
     // systems don't share inodes via /proc, so we turn off this check
     // if we don't see any evidence that we're getting inode info.
     if (inode != 0) {
       saw_nonzero_inode = true;
     }
-    if ((strstr(filename, "lib") && strstr(filename, ".so")) ||
-        strstr(filename, ".dll") ||
+    if ((hc_strstr(filename, "lib") && hc_strstr(filename, ".so")) ||
+        hc_strstr(filename, ".dll") ||
         // not all .dylib filenames start with lib. .dylib is big enough
         // that we are unlikely to get false matches just checking that.
-        strstr(filename, ".dylib") || strstr(filename, ".bundle")) {
+        hc_strstr(filename, ".dylib") || hc_strstr(filename, ".bundle")) {
       saw_shared_lib = true;
       if (inode != 0) {
         saw_shared_lib_with_nonzero_inode = true;
       }
     }
 
     switch (proc_maps_task) {
       case DISABLE_LIBRARY_ALLOCS:
         // All lines starting like
         // "401dc000-4030f000 r??p 00132000 03:01 13991972  lib/bin"
@@ skipping 455 matching lines @@
     const size_t remainder = AsInt(object) % pointer_source_alignment;
     if (remainder) {
       object += pointer_source_alignment - remainder;
       if (size >= pointer_source_alignment - remainder) {
         size -= pointer_source_alignment - remainder;
       } else {
         size = 0;
       }
     }
     if (size < sizeof(void*)) continue;
+
+#ifdef NO_FRAME_POINTER
+    // Frame pointer omission requires us to use libunwind, which uses direct
+    // mmap and munmap system calls, and that needs special handling.
+    if (name2 == kUnnamedProcSelfMapEntry) {
+      static const uintptr_t page_mask = ~(getpagesize() - 1);
+      const uintptr_t addr = reinterpret_cast<uintptr_t>(object);
+      if ((addr & page_mask) == 0 && (size & page_mask) == 0) {
+        // This is an object we slurped from /proc/self/maps.
+        // It may or may not be readable at this point.
+        //
+        // In case all the above conditions made a mistake, and the object is
+        // not related to libunwind, we also verify that it's not readable
+        // before ignoring it.
+        if (msync(const_cast<char*>(object), size, MS_ASYNC) != 0) {
+          // Skip unreadable object, so we don't crash trying to sweep it.
+          RAW_VLOG(0, "Ignoring inaccessible object [%p, %p) "
+                   "(msync error %d (%s))",
+                   object, object + size, errno, strerror(errno));
+          continue;
+        }
+      }
+    }
+#endif
+
     const char* const max_object = object + size - sizeof(void*);
     while (object <= max_object) {
       // potentially unaligned load:
       const uintptr_t addr = *reinterpret_cast<const uintptr_t*>(object);
       // Do fast check before the more expensive HaveOnHeapLocked lookup:
       // this code runs for all memory words that are potentially pointers:
       const bool can_be_on_heap =
         // Order tests by the likelyhood of the test failing in 64/32 bit modes.
         // Yes, this matters: we either lose 5..6% speed in 32 bit mode
         // (which is already slower) or by a factor of 1.5..1.91 in 64 bit mode.
@@ skipping 52 matching lines @@
 //----------------------------------------------------------------------
 // HeapLeakChecker leak check disabling components
 //----------------------------------------------------------------------
 
 // static
 void HeapLeakChecker::DisableChecksIn(const char* pattern) {
   RAW_LOG(WARNING, "DisableChecksIn(%s) is ignored", pattern);
 }
 
 // static
-void HeapLeakChecker::IgnoreObject(const void* ptr) {
+void HeapLeakChecker::DoIgnoreObject(const void* ptr) {
   SpinLockHolder l(&heap_checker_lock);
   if (!heap_checker_on) return;
   size_t object_size;
   if (!HaveOnHeapLocked(&ptr, &object_size)) {
     RAW_LOG(ERROR, "No live heap object at %p to ignore", ptr);
   } else {
     RAW_VLOG(10, "Going to ignore live object at %p of %"PRIuS" bytes",
                 ptr, object_size);
     if (ignored_objects == NULL)  {
       ignored_objects = new(Allocator::Allocate(sizeof(IgnoredObjectsMap)))
                           IgnoredObjectsMap;
     }
     if (!ignored_objects->insert(make_pair(AsInt(ptr), object_size)).second) {
-      RAW_LOG(FATAL, "Object at %p is already being ignored", ptr);
+      RAW_LOG(WARNING, "Object at %p is already being ignored", ptr);
     }
   }
 }
 
 // static
 void HeapLeakChecker::UnIgnoreObject(const void* ptr) {
   SpinLockHolder l(&heap_checker_lock);
   if (!heap_checker_on) return;
   size_t object_size;
   if (!HaveOnHeapLocked(&ptr, &object_size)) {
@@ skipping 369 matching lines @@
   if (!heap_cleanups_)
     return;
   for (int i = 0; i < heap_cleanups_->size(); i++) {
     void (*f)(void) = (*heap_cleanups_)[i];
     f();
   }
   delete heap_cleanups_;
   heap_cleanups_ = NULL;
 }
 
-// Program exit heap cleanup registered with atexit().
+// Program exit heap cleanup registered as a module object destructor.
 // Will not get executed when we crash on a signal.
 //
-/*static*/ void HeapLeakChecker::RunHeapCleanups() {
+void HeapLeakChecker_RunHeapCleanups() {
+  if (FLAGS_heap_check == "local")   // don't check heap in this mode
+    return;
   { SpinLockHolder l(&heap_checker_lock);
     // can get here (via forks?) with other pids
     if (heap_checker_pid != getpid()) return;
   }
   HeapCleaner::RunHeapCleanups();
-  if (!FLAGS_heap_check_after_destructors) DoMainHeapCheck();
+  if (!FLAGS_heap_check_after_destructors) HeapLeakChecker::DoMainHeapCheck();
 }
 
 static bool internal_init_start_has_run = false;
 
 // Called exactly once, before main() (but hopefully just before).
 // This picks a good unique name for the dumped leak checking heap profiles.
 //
 // Because we crash when InternalInitStart is called more than once,
 // it's fine that we hold heap_checker_lock only around pieces of
 // this function: this is still enough for thread-safety w.r.t. other functions
 // of this module.
 // We can't hold heap_checker_lock throughout because it would deadlock
 // on a memory allocation since our new/delete hooks can be on.
 //
-/*static*/ void HeapLeakChecker::InternalInitStart() {
+void HeapLeakChecker_InternalInitStart() {
   { SpinLockHolder l(&heap_checker_lock);
     RAW_CHECK(!internal_init_start_has_run,
               "Heap-check constructor called twice.  Perhaps you both linked"
               " in the heap checker, and also used LD_PRELOAD to load it?");
     internal_init_start_has_run = true;
 
+#ifdef ADDRESS_SANITIZER
+    // AddressSanitizer's custom malloc conflicts with HeapChecker.
+    FLAGS_heap_check = "";
+#endif
+
     if (FLAGS_heap_check.empty()) {
       // turns out we do not need checking in the end; can stop profiling
-      TurnItselfOffLocked();
+      HeapLeakChecker::TurnItselfOffLocked();
       return;
     } else if (RunningOnValgrind()) {
       // There is no point in trying -- we'll just fail.
       RAW_LOG(WARNING, "Can't run under Valgrind; will turn itself off");
-      TurnItselfOffLocked();
+      HeapLeakChecker::TurnItselfOffLocked();
       return;
     }
   }
 
   // Changing this to false can be useful when debugging heap-checker itself:
   if (!FLAGS_heap_check_run_under_gdb && IsDebuggerAttached()) {
     RAW_LOG(WARNING, "Someone is ptrace()ing us; will turn itself off");
     SpinLockHolder l(&heap_checker_lock);
-    TurnItselfOffLocked();
+    HeapLeakChecker::TurnItselfOffLocked();
     return;
   }
 
   { SpinLockHolder l(&heap_checker_lock);
     if (!constructor_heap_profiling) {
       RAW_LOG(FATAL, "Can not start so late. You have to enable heap checking "
                      "with HEAPCHECK=<mode>.");
     }
   }
 
@@ skipping 30 matching lines @@
     FLAGS_heap_check_ignore_thread_live = false;  // no live flood (stricter)
     FLAGS_heap_check_ignore_global_live = false;  // no live flood (stricter)
   } else if (FLAGS_heap_check == "as-is") {
     // do nothing: use other flags as is
   } else if (FLAGS_heap_check == "local") {
     // do nothing
   } else {
     RAW_LOG(FATAL, "Unsupported heap_check flag: %s",
                    FLAGS_heap_check.c_str());
   }
+  // FreeBSD doesn't seem to honor atexit execution order:
+  //    http://code.google.com/p/gperftools/issues/detail?id=375
+  // Since heap-checking before destructors depends on atexit running
+  // at the right time, on FreeBSD we always check after, even in the
+  // less strict modes.  This just means FreeBSD is always a bit
+  // stricter in its checking than other OSes.
+#ifdef __FreeBSD__
+  FLAGS_heap_check_after_destructors = true;
+#endif
+
   { SpinLockHolder l(&heap_checker_lock);
     RAW_DCHECK(heap_checker_pid == getpid(), "");
     heap_checker_on = true;
     RAW_DCHECK(heap_profile, "");
-    ProcMapsResult pm_result = UseProcMapsLocked(DISABLE_LIBRARY_ALLOCS);
+    HeapLeakChecker::ProcMapsResult pm_result = HeapLeakChecker::UseProcMapsLocked(HeapLeakChecker::DISABLE_LIBRARY_ALLOCS);
       // might neeed to do this more than once
       // if one later dynamically loads libraries that we want disabled
-    if (pm_result != PROC_MAPS_USED) {  // can't function
-      TurnItselfOffLocked();
+    if (pm_result != HeapLeakChecker::PROC_MAPS_USED) {  // can't function
+      HeapLeakChecker::TurnItselfOffLocked();
       return;
     }
   }
 
   // make a good place and name for heap profile leak dumps
   string* profile_prefix =
     new string(FLAGS_heap_check_dump_directory + "/" + invocation_name());
 
   // Finalize prefix for dumping leak checking profiles.
   const int32 our_pid = getpid();   // safest to call getpid() outside lock
@@ skipping 33 matching lines @@
   // "nm <this_binary> | grep new" will show that tcmalloc's new/delete
   // implementation did not get linked-in into this binary
   // (i.e. nm will list __builtin_new and __builtin_vec_new as undefined).
   // If this happens, it is a BUILD bug to be fixed.
 
   RAW_VLOG(heap_checker_info_level,
            "WARNING: Perftools heap leak checker is active "
            "-- Performance may suffer");
 
   if (FLAGS_heap_check != "local") {
-    // Schedule registered heap cleanup
-    atexit(RunHeapCleanups);
     HeapLeakChecker* main_hc = new HeapLeakChecker();
     SpinLockHolder l(&heap_checker_lock);
     RAW_DCHECK(main_heap_checker == NULL,
                "Repeated creation of main_heap_checker");
     main_heap_checker = main_hc;
     do_main_heap_check = true;
   }
 
   { SpinLockHolder l(&heap_checker_lock);
     RAW_CHECK(heap_checker_on  &&  constructor_heap_profiling,
@@ skipping 12 matching lines @@
   // TODO(csilvers): support this in some manner.
 #if 0
   SetCommandLineOptionWithMode("max_free_queue_size", "104857600",  // 100M
                                SET_FLAG_IF_DEFAULT);
 #endif
 }
 
 // We want this to run early as well, but not so early as
 // ::BeforeConstructors (we want flag assignments to have already
 // happened, for instance).  Initializer-registration does the trick.
-REGISTER_MODULE_INITIALIZER(init_start, HeapLeakChecker::InternalInitStart());
+REGISTER_MODULE_INITIALIZER(init_start, HeapLeakChecker_InternalInitStart());
+REGISTER_MODULE_DESTRUCTOR(init_start, HeapLeakChecker_RunHeapCleanups());
+
+// static
+bool HeapLeakChecker::NoGlobalLeaksMaybeSymbolize(
+    ShouldSymbolize should_symbolize) {
+  // we never delete or change main_heap_checker once it's set:
+  HeapLeakChecker* main_hc = GlobalChecker();
+  if (main_hc) {
+    RAW_VLOG(10, "Checking for whole-program memory leaks");
+    return main_hc->DoNoLeaks(should_symbolize);
+  }
+  return true;
+}
 
 // static
 bool HeapLeakChecker::DoMainHeapCheck() {
   if (FLAGS_heap_check_delay_seconds > 0) {
     sleep(FLAGS_heap_check_delay_seconds);
   }
   { SpinLockHolder l(&heap_checker_lock);
     if (!do_main_heap_check) return false;
     RAW_DCHECK(heap_checker_pid == getpid(), "");
     do_main_heap_check = false;  // will do it now; no need to do it more
   }
 
-  if (!NoGlobalLeaks()) {
+  // The program is over, so it's safe to symbolize addresses (which
+  // requires a fork) because no serious work is expected to be done
+  // after this.  Symbolizing is really useful -- knowing what
+  // function has a leak is better than knowing just an address --
+  // and while we can only safely symbolize once in a program run,
+  // now is the time (after all, there's no "later" that would be better).
+  if (!NoGlobalLeaksMaybeSymbolize(SYMBOLIZE)) {
     if (FLAGS_heap_check_identify_leaks) {
       RAW_LOG(FATAL, "Whole-program memory leaks found.");
     }
     RAW_LOG(ERROR, "Exiting with error code (instead of crashing) "
                    "because of whole-program memory leaks");
     // We don't want to call atexit() routines!
     _exit(FLAGS_heap_check_error_exit_code);
   }
   return true;
 }
 
 // static
 HeapLeakChecker* HeapLeakChecker::GlobalChecker() {
   SpinLockHolder l(&heap_checker_lock);
   return main_heap_checker;
 }
 
 // static
 bool HeapLeakChecker::NoGlobalLeaks() {
-  // we never delete or change main_heap_checker once it's set:
-  HeapLeakChecker* main_hc = GlobalChecker();
-  if (main_hc) {
-    RAW_VLOG(10, "Checking for whole-program memory leaks");
-    // The program is over, so it's safe to symbolize addresses (which
-    // requires a fork) because no serious work is expected to be done
-    // after this.  Symbolizing is really useful -- knowing what
-    // function has a leak is better than knowing just an address --
-    // and while we can only safely symbolize once in a program run,
-    // now is the time (after all, there's no "later" that would be better).
-    return main_hc->DoNoLeaks(SYMBOLIZE);
-  }
-  return true;
+  // symbolizing requires a fork, which isn't safe to do in general.
+  return NoGlobalLeaksMaybeSymbolize(DO_NOT_SYMBOLIZE);
 }
 
 // static
 void HeapLeakChecker::CancelGlobalCheck() {
   SpinLockHolder l(&heap_checker_lock);
   if (do_main_heap_check) {
     RAW_VLOG(heap_checker_info_level,
              "Canceling the automatic at-exit whole-program memory leak check");
     do_main_heap_check = false;
   }
 }
 
 // static
 void HeapLeakChecker::BeforeConstructorsLocked() {
   RAW_DCHECK(heap_checker_lock.IsHeld(), "");
   RAW_CHECK(!constructor_heap_profiling,
             "BeforeConstructorsLocked called multiple times");
+#ifdef ADDRESS_SANITIZER
+  // AddressSanitizer's custom malloc conflicts with HeapChecker.
+  return;
+#endif
   // Set hooks early to crash if 'new' gets called before we make heap_profile,
   // and make sure no other hooks existed:
   RAW_CHECK(MallocHook::AddNewHook(&NewHook), "");
   RAW_CHECK(MallocHook::AddDeleteHook(&DeleteHook), "");
   constructor_heap_profiling = true;
   MemoryRegionMap::Init(1);
     // Set up MemoryRegionMap with (at least) one caller stack frame to record
     // (important that it's done before HeapProfileTable creation below).
   Allocator::Init();
   RAW_CHECK(heap_profile == NULL, "");
@@ skipping 157 matching lines @@
 // static
 const void* HeapLeakChecker::GetAllocCaller(void* ptr) {
   // this is used only in the unittest, so the heavy checks are fine
   HeapProfileTable::AllocInfo info;
   { SpinLockHolder l(&heap_checker_lock);
     RAW_CHECK(heap_profile->FindAllocDetails(ptr, &info), "");
   }
   RAW_CHECK(info.stack_depth >= 1, "");
   return info.call_stack[0];
 }