Revert 126715 - Update the tcmalloc vendor branch to r144 (gperftools 2.0).

third_party/tcmalloc/vendor/src/malloc_hook.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 28 matching lines @@
 # define mremap glibc_mremap
 # include <sys/mman.h>
 # undef mremap
 #endif
 
 #include <stddef.h>
 #ifdef HAVE_STDINT_H
 #include <stdint.h>
 #endif
 #include <algorithm>
+#include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/spinlock.h"
 #include "maybe_threads.h"
 #include "malloc_hook-inl.h"
-#include <gperftools/malloc_hook.h>
+#include <google/malloc_hook.h>
 
 // This #ifdef should almost never be set.  Set NO_TCMALLOC_SAMPLES if
 // you're porting to a system where you really can't get a stacktrace.
 #ifdef NO_TCMALLOC_SAMPLES
   // We use #define so code compiles even if you #include stacktrace.h somehow.
 # define GetStackTrace(stack, depth, skip)  (0)
 #else
-# include <gperftools/stacktrace.h>
+# include <google/stacktrace.h>
 #endif
 
 // __THROW is defined in glibc systems.  It means, counter-intuitively,
 // "This function will never throw an exception."  It's an optional
 // optimization tool, but we may need to use it to match glibc prototypes.
 #ifndef __THROW    // I guess we're not on a glibc system
 # define __THROW   // __THROW is just an optimization, so ok to make it ""
 #endif
 
 using std::copy;
@@ skipping 124 matching lines @@
 // End of DEPRECATED code section.
 
 // This lock is shared between all implementations of HookList::Add & Remove.
 // The potential for contention is very small.  This needs to be a SpinLock and
 // not a Mutex since it's possible for Mutex locking to allocate memory (e.g.,
 // per-thread allocation in debug builds), which could cause infinite recursion.
 static SpinLock hooklist_spinlock(base::LINKER_INITIALIZED);
 
 template <typename T>
 bool HookList<T>::Add(T value_as_t) {
-  AtomicWord value = bit_cast<AtomicWord>(value_as_t);
+  // Note: we need to check this _before_ reinterpret_cast, since
+  // reinterpret_cast may include random junk from memory.
+  if (value_as_t == 0) {
+    return false;
+  }
+  AtomicWord value = reinterpret_cast<const AtomicWord&>(value_as_t);
   if (value == 0) {
+    // This should not actually happen, but just to be sure...
     return false;
   }
   SpinLockHolder l(&hooklist_spinlock);
   // Find the first slot in data that is 0.
   int index = 0;
   while ((index < kHookListMaxValues) &&
          (base::subtle::NoBarrier_Load(&priv_data[index]) != 0)) {
     ++index;
   }
   if (index == kHookListMaxValues) {
     return false;
   }
   AtomicWord prev_num_hooks = base::subtle::Acquire_Load(&priv_end);
   base::subtle::Release_Store(&priv_data[index], value);
   if (prev_num_hooks <= index) {
     base::subtle::Release_Store(&priv_end, index + 1);
   }
   return true;
 }
 
 template <typename T>
 bool HookList<T>::Remove(T value_as_t) {
   if (value_as_t == 0) {
     return false;
   }
   SpinLockHolder l(&hooklist_spinlock);
   AtomicWord hooks_end = base::subtle::Acquire_Load(&priv_end);
   int index = 0;
-  while (index < hooks_end && value_as_t != bit_cast<T>(
+  // Note: we need to cast back to T since T may be smaller than AtomicWord.
+  while (index < hooks_end && value_as_t != reinterpret_cast<T>(
              base::subtle::Acquire_Load(&priv_data[index]))) {
     ++index;
   }
   if (index == hooks_end) {
     return false;
   }
   base::subtle::Release_Store(&priv_data[index], 0);
   if (hooks_end == index + 1) {
     // Adjust hooks_end down to the lowest possible value.
     hooks_end = index;
     while ((hooks_end > 0) &&
            (base::subtle::Acquire_Load(&priv_data[hooks_end - 1]) == 0)) {
       --hooks_end;
     }
     base::subtle::Release_Store(&priv_end, hooks_end);
   }
   return true;
 }
 
 template <typename T>
 int HookList<T>::Traverse(T* output_array, int n) const {
   AtomicWord hooks_end = base::subtle::Acquire_Load(&priv_end);
   int actual_hooks_end = 0;
   for (int i = 0; i < hooks_end && n > 0; ++i) {
     AtomicWord data = base::subtle::Acquire_Load(&priv_data[i]);
     if (data != 0) {
-      *output_array++ = bit_cast<T>(data);
+      *output_array++ = reinterpret_cast<const T&>(data);
       ++actual_hooks_end;
       --n;
     }
   }
   return actual_hooks_end;
 }
 
 // Initialize a HookList (optionally with the given initial_value in index 0).
 #define INIT_HOOK_LIST { 0 }
 #define INIT_HOOK_LIST_WITH_VALUE(initial_value)                \
@@ skipping 416 matching lines @@
 #endif
 }
 
 // On systems where we know how, we override mmap/munmap/mremap/sbrk
 // to provide support for calling the related hooks (in addition,
 // of course, to doing what these functions normally do).
 
 #if defined(__linux)
 # include "malloc_hook_mmap_linux.h"
 
-#elif defined(__FreeBSD__)
+// This code doesn't even compile on my freebsd 8.1 (x86_64) system,
+// so comment it out for now.  TODO(csilvers): fix this!
+#elif 0 && defined(__FreeBSD__)
 # include "malloc_hook_mmap_freebsd.h"
 
 #else
 
 /*static*/void* MallocHook::UnhookedMMap(void *start, size_t length, int prot,
                                          int flags, int fd, off_t offset) {
   void* result;
   if (!MallocHook::InvokeMmapReplacement(
           start, length, prot, flags, fd, offset, &result)) {
     result = mmap(start, length, prot, flags, fd, offset);
   }
   return result;
 }
 
 /*static*/int MallocHook::UnhookedMUnmap(void *start, size_t length) {
   int result;
   if (!MallocHook::InvokeMunmapReplacement(start, length, &result)) {
     result = munmap(start, length);
   }
   return result;
 }
 
 #endif