Update the tcmalloc vendor branch to r111 (perftools version 1.8)

third_party/tcmalloc/vendor/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) && !defined(__native_client__)
 #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
@@ skipping 205 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 1171 matching lines @@
   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 802 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];
 }