Revert 126020 - Experiment for updating the tcmalloc chromium branch to r144 (gperftools 2.0).

third_party/tcmalloc/chromium/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)                \
   { 1, { reinterpret_cast<AtomicWord>(initial_value) } }
 
 // Explicit instantiation for malloc_hook_test.cc.  This ensures all the methods
 // are instantiated.
-template struct HookList<MallocHook::NewHook>;
+template class HookList<MallocHook::NewHook>;
 
 HookList<MallocHook::NewHook> new_hooks_ =
     INIT_HOOK_LIST_WITH_VALUE(&InitialNewHook);
 HookList<MallocHook::DeleteHook> delete_hooks_ = INIT_HOOK_LIST;
 HookList<MallocHook::PreMmapHook> premmap_hooks_ =
     INIT_HOOK_LIST_WITH_VALUE(&InitialPreMMapHook);
 HookList<MallocHook::MmapHook> mmap_hooks_ = INIT_HOOK_LIST;
 HookList<MallocHook::MunmapHook> munmap_hooks_ = INIT_HOOK_LIST;
 HookList<MallocHook::MremapHook> mremap_hooks_ = INIT_HOOK_LIST;
 HookList<MallocHook::PreSbrkHook> presbrk_hooks_ =
@@ skipping 394 matching lines @@
   }
   RAW_LOG(WARNING, "Hooked allocator frame not found, returning empty trace");
     // If this happens try increasing kMaxSkip
     // or else something must be wrong with InHookCaller,
     // e.g. for every section used in InHookCaller
     // all functions in that section must be inside the same library.
   return 0;
 #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).
+// On Linux/x86, we override mmap/munmap/mremap/sbrk
+// and provide support for calling the related hooks.
+//
+// We define mmap() and mmap64(), which somewhat reimplements libc's mmap
+// syscall stubs.  Unfortunately libc only exports the stubs via weak symbols
+// (which we're overriding with our mmap64() and mmap() wrappers) so we can't
+// just call through to them.
 
-#if defined(__linux)
-# include "malloc_hook_mmap_linux.h"
 
-#elif defined(__FreeBSD__)
-# include "malloc_hook_mmap_freebsd.h"
+#if defined(__linux) && \
+    (defined(__i386__) || defined(__x86_64__) || defined(__PPC__))
+#include <unistd.h>
+#include <syscall.h>
+#include <sys/mman.h>
+#include <errno.h>
+#include "base/linux_syscall_support.h"
 
-#else
+// The x86-32 case and the x86-64 case differ:
+// 32b has a mmap2() syscall, 64b does not.
+// 64b and 32b have different calling conventions for mmap().
+#if defined(__x86_64__) || defined(__PPC64__)
+
+static inline void* do_mmap64(void *start, size_t length,
+                              int prot, int flags,
+                              int fd, __off64_t offset) __THROW {
+  return (void *)syscall(SYS_mmap, start, length, prot, flags, fd, offset);
+}
+
+#elif defined(__i386__) || defined(__PPC__)
+
+static inline void* do_mmap64(void *start, size_t length,
+                              int prot, int flags,
+                              int fd, __off64_t offset) __THROW {
+  void *result;
+
+  // Try mmap2() unless it's not supported
+  static bool have_mmap2 = true;
+  if (have_mmap2) {
+    static int pagesize = 0;
+    if (!pagesize) pagesize = getpagesize();
+
+    // Check that the offset is page aligned
+    if (offset & (pagesize - 1)) {
+      result = MAP_FAILED;
+      errno = EINVAL;
+      goto out;
+    }
+
+    result = (void *)syscall(SYS_mmap2, 
+                       start, length, prot, flags, fd,
+                       (off_t) (offset / pagesize));
+    if (result != MAP_FAILED || errno != ENOSYS)  goto out;
+
+    // We don't have mmap2() after all - don't bother trying it in future
+    have_mmap2 = false;
+  }
+
+  if (((off_t)offset) != offset) {
+    // If we're trying to map a 64-bit offset, fail now since we don't
+    // have 64-bit mmap() support.
+    result = MAP_FAILED;
+    errno = EINVAL;
+    goto out;
+  }
+
+  {
+    // Fall back to old 32-bit offset mmap() call
+    // Old syscall interface cannot handle six args, so pass in an array
+    int32 args[6] = { (int32) start, length, prot, flags, fd, (off_t) offset };
+    result = (void *)syscall(SYS_mmap, args);
+  }
+ out:
+  return result;
+}
+
+# endif  // defined(__x86_64__)
+
+// We use do_mmap64 abstraction to put MallocHook::InvokeMmapHook
+// calls right into mmap and mmap64, so that the stack frames in the caller's
+// stack are at the same offsets for all the calls of memory allocating
+// functions.
+
+// Put all callers of MallocHook::Invoke* in this module into
+// malloc_hook section,
+// so that MallocHook::GetCallerStackTrace can function accurately:
+
+// Make sure mmap doesn't get #define'd away by <sys/mman.h>
+#undef mmap
+
+extern "C" {
+  void* mmap64(void *start, size_t length, int prot, int flags,
+               int fd, __off64_t offset  ) __THROW
+    ATTRIBUTE_SECTION(malloc_hook);
+  void* mmap(void *start, size_t length,int prot, int flags,
+             int fd, off_t offset) __THROW
+    ATTRIBUTE_SECTION(malloc_hook);
+  int munmap(void* start, size_t length) __THROW
+    ATTRIBUTE_SECTION(malloc_hook);
+  void* mremap(void* old_addr, size_t old_size, size_t new_size,
+               int flags, ...) __THROW
+    ATTRIBUTE_SECTION(malloc_hook);
+  void* sbrk(std::ptrdiff_t increment) __THROW
+    ATTRIBUTE_SECTION(malloc_hook);
+}
+
+extern "C" void* mmap64(void *start, size_t length, int prot, int flags,
+                        int fd, __off64_t offset) __THROW {
+  MallocHook::InvokePreMmapHook(start, length, prot, flags, fd, offset);
+  void *result;
+  if (!MallocHook::InvokeMmapReplacement(
+          start, length, prot, flags, fd, offset, &result)) {
+    result = do_mmap64(start, length, prot, flags, fd, offset);
+  }
+  MallocHook::InvokeMmapHook(result, start, length, prot, flags, fd, offset);
+  return result;
+}
+
+#if !defined(__USE_FILE_OFFSET64) || !defined(__REDIRECT_NTH)
+
+extern "C" void* mmap(void *start, size_t length, int prot, int flags,
+                      int fd, off_t offset) __THROW {
+  MallocHook::InvokePreMmapHook(start, length, prot, flags, fd, offset);
+  void *result;
+  if (!MallocHook::InvokeMmapReplacement(
+          start, length, prot, flags, fd, offset, &result)) {
+    result = do_mmap64(start, length, prot, flags, fd,
+                       static_cast<size_t>(offset)); // avoid sign extension
+  }
+  MallocHook::InvokeMmapHook(result, start, length, prot, flags, fd, offset);
+  return result;
+}
+
+#endif  // !defined(__USE_FILE_OFFSET64) || !defined(__REDIRECT_NTH)
+
+extern "C" int munmap(void* start, size_t length) __THROW {
+  MallocHook::InvokeMunmapHook(start, length);
+  int result;
+  if (!MallocHook::InvokeMunmapReplacement(start, length, &result)) {
+    result = syscall(SYS_munmap, start, length);
+  }
+  return result;
+}
+
+extern "C" void* mremap(void* old_addr, size_t old_size, size_t new_size,
+                        int flags, ...) __THROW {
+  va_list ap;
+  va_start(ap, flags);
+  void *new_address = va_arg(ap, void *);
+  va_end(ap);
+  void* result = sys_mremap(old_addr, old_size, new_size, flags, new_address);
+  MallocHook::InvokeMremapHook(result, old_addr, old_size, new_size, flags,
+                               new_address);
+  return result;
+}
+
+// libc's version:
+extern "C" void* __sbrk(std::ptrdiff_t increment);
+
+extern "C" void* sbrk(std::ptrdiff_t increment) __THROW {
+  MallocHook::InvokePreSbrkHook(increment);
+  void *result = __sbrk(increment);
+  MallocHook::InvokeSbrkHook(result, increment);
+  return result;
+}
+
+/*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 = do_mmap64(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 = sys_munmap(start, length);
+  }
+  return result;
+}
+
+#else   // defined(__linux) &&
+        // (defined(__i386__) || defined(__x86_64__) || defined(__PPC__))
 
 /*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
+#endif  // defined(__linux) &&
+        // (defined(__i386__) || defined(__x86_64__) || defined(__PPC__))