Merge tcmalloc r111 (perftools v. 1.8) with the chromium/ branch.

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) && !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 917 matching lines @@
 // we can do everything in that main thread,
 // so that CPU profiler can collect all its samples.
 // Returns the number of threads in the process.
 static int IsOneThread(void* parameter, int num_threads,
                        pid_t* thread_pids, va_list ap) {
   if (num_threads != 1) {
     RAW_LOG(WARNING, "Have threads: Won't CPU-profile the bulk of leak "
                      "checking work happening in IgnoreLiveThreadsLocked!");
   }
   ResumeAllProcessThreads(num_threads, thread_pids);
+  RAW_LOG(INFO, "IsOneThread returning %d", num_threads);
   return num_threads;
 }
 
 // Dummy for IgnoreAllLiveObjectsLocked below.
 // Making it global helps with compiler warnings.
 static va_list dummy_ap;
 
 // static
 void HeapLeakChecker::IgnoreAllLiveObjectsLocked(const void* self_stack_top) {
   RAW_DCHECK(heap_checker_lock.IsHeld(), "");
@@ skipping 37 matching lines @@
     bool want_and_can_run_in_main_thread =
       ProfilingIsEnabledForAllThreads()  &&
       ListAllProcessThreads(NULL, IsOneThread) == 1;
     // When the normal path of ListAllProcessThreads below is taken,
     // we fully suspend the threads right here before any liveness checking
     // and keep them suspended for the whole time of liveness checking
     // inside of the IgnoreLiveThreadsLocked callback.
     // (The threads can't (de)allocate due to lock on the delete hook but
     //  if not suspended they could still mess with the pointer
     //  graph while we walk it).
+    RAW_LOG(INFO, "want_and_can_run_in_main_thread: %d", want_and_can_run_in_main_thread);
     int r = want_and_can_run_in_main_thread
             ? IgnoreLiveThreadsLocked(NULL, 1, &self_thread_pid, dummy_ap)
             : ListAllProcessThreads(NULL, IgnoreLiveThreadsLocked);
     need_to_ignore_non_thread_objects = r < 0;
     if (r < 0) {
       RAW_LOG(WARNING, "Thread finding failed with %d errno=%d", r, errno);
       if (thread_listing_status == CALLBACK_COMPLETED) {
         RAW_LOG(INFO, "Thread finding callback "
                       "finished ok; hopefully everything is fine");
         need_to_ignore_non_thread_objects = false;
@@ skipping 177 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];
 }