Merged third_party/tcmalloc/vendor/src(google-perftools r87) into...

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 29 matching lines @@
 #include <errno.h>
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 #ifdef HAVE_MMAP
 #include <sys/mman.h>
 #endif
 #ifdef HAVE_PTHREAD
 #include <pthread.h>
 #endif
-#ifdef HAVE_POLL_H
-#include <poll.h>
-#endif
 #include <sys/stat.h>
 #include <sys/types.h>
+#include <time.h>
 #include <assert.h>
 
 #ifdef 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>
@@ skipping 1762 matching lines @@
 //
 // 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() {
   { SpinLockHolder l(&heap_checker_lock);
-    RAW_CHECK(!internal_init_start_has_run, "Only one call is expected");
+    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;
 
     if (FLAGS_heap_check.empty()) {
       // turns out we do not need checking in the end; can stop profiling
       TurnItselfOffLocked();
       return;
     }
   }
 
   // Changing this to false can be useful when debugging heap-checker itself:
@@ skipping 443 matching lines @@
 }
 
 // This function is executed after all global object destructors run.
 void HeapLeakChecker_AfterDestructors() {
   { SpinLockHolder l(&heap_checker_lock);
     // can get here (via forks?) with other pids
     if (heap_checker_pid != getpid()) return;
   }
   if (FLAGS_heap_check_after_destructors) {
     if (HeapLeakChecker::DoMainHeapCheck()) {
-      poll(0, 0, 500);
+      const struct timespec sleep_time = { 0, 500000000 };  // 500 ms
+      nanosleep(&sleep_time, NULL);
         // Need this hack to wait for other pthreads to exit.
         // Otherwise tcmalloc find errors
         // on a free() call from pthreads.
     }
   }
   SpinLockHolder l(&heap_checker_lock);
   RAW_CHECK(!do_main_heap_check, "should have done it");
 }
 
 //----------------------------------------------------------------------
@@ skipping 49 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];
 }