Merge google-perftools r109 (the current contents of third_party/tcmalloc/vendor)

third_party/tcmalloc/chromium/src/windows/patch_functions.cc

 // Copyright (c) 2007, 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 104 matching lines @@
 // Without this, the linker will likely decide that libtcmalloc.dll
 // doesn't add anything to the executable (since it does all its work
 // through patching, which the linker can't see), and ignore it
 // entirely.  (The name 'tcmalloc' is already reserved for a
 // namespace.  I'd rather export a variable named "_tcmalloc", but I
 // couldn't figure out how to get that to work.  This function exports
 // the symbol "__tcmalloc".)
 extern "C" PERFTOOLS_DLL_DECL void _tcmalloc();
 void _tcmalloc() { }
 
+// This is the version needed for windows x64, which has a different
+// decoration scheme which doesn't auto-add a leading underscore.
+extern "C" PERFTOOLS_DLL_DECL void __tcmalloc();
+void __tcmalloc() { }
+
 namespace {    // most everything here is in an unnamed namespace
 
 typedef void (*GenericFnPtr)();
 
 using sidestep::PreamblePatcher;
 
 struct ModuleEntryCopy;   // defined below
 
 // These functions are how we override the memory allocation
 // functions, just like tcmalloc.cc and malloc_hook.cc do.
@@ skipping 33 matching lines @@
     memcpy(this->windows_fn_, that.windows_fn_, sizeof(windows_fn_));
     this->module_base_address_ = that.module_base_address_;
     this->module_base_size_ = that.module_base_size_;
   }
 
   enum {
     kMalloc, kFree, kRealloc, kCalloc,
     kNew, kNewArray, kDelete, kDeleteArray,
     kNewNothrow, kNewArrayNothrow, kDeleteNothrow, kDeleteArrayNothrow,
     // These are windows-only functions from malloc.h
-    k_Msize, k_Expand, k_Aligned_malloc, k_Aligned_free,
+    k_Msize, k_Expand,
     kNumFunctions
   };
 
   // I'd like to put these together in a struct (perhaps in the
   // subclass, so we can put in perftools_fn_ as well), but vc8 seems
   // to have a bug where it doesn't initialize the struct properly if
   // we try to take the address of a function that's not yet loaded
   // from a dll, as is the common case for static_fn_.  So we need
   // each to be in its own array. :-(
   static const char* const function_name_[kNumFunctions];
@@ skipping 78 matching lines @@
   static void* Perftools_new_nothrow(size_t size,
                                      const std::nothrow_t&) __THROW;
   static void* Perftools_newarray_nothrow(size_t size,
                                           const std::nothrow_t&) __THROW;
   static void Perftools_delete_nothrow(void *ptr,
                                        const std::nothrow_t&) __THROW;
   static void Perftools_deletearray_nothrow(void *ptr,
                                             const std::nothrow_t&) __THROW;
   static size_t Perftools__msize(void *ptr) __THROW;
   static void* Perftools__expand(void *ptr, size_t size) __THROW;
-  static void* Perftools__aligned_malloc(size_t size, size_t alignment) __THROW;
-  static void Perftools__aligned_free(void *ptr) __THROW;
   // malloc.h also defines these functions:
+  //   _aligned_malloc, _aligned_free,
   //   _recalloc, _aligned_offset_malloc, _aligned_realloc, _aligned_recalloc
   //   _aligned_offset_realloc, _aligned_offset_recalloc, _malloca, _freea
   // But they seem pretty obscure, and I'm fine not overriding them for now.
+  // It may be they all call into malloc/free anyway.
 };
 
 // This is a subset of MODDULEENTRY32, that we need for patching.
 struct ModuleEntryCopy {
   LPVOID  modBaseAddr;     // the same as hmodule
   DWORD   modBaseSize;
   // This is not part of MODDULEENTRY32, but is needed to avoid making
   // windows syscalls while we're holding patch_all_modules_lock (see
   // lock-inversion comments at patch_all_modules_lock definition, below).
   GenericFnPtr rgProcAddresses[LibcInfo::ctrgProcAddress];
 
   ModuleEntryCopy() {
     modBaseAddr = NULL;
     modBaseSize = 0;
     for (int i = 0; i < sizeof(rgProcAddresses)/sizeof(*rgProcAddresses); i++)
       rgProcAddresses[i] = LibcInfo::static_fn(i);
   }
   ModuleEntryCopy(const MODULEINFO& mi) {
     this->modBaseAddr = mi.lpBaseOfDll;
     this->modBaseSize = mi.SizeOfImage;
-    for (int i = 0; i < sizeof(rgProcAddresses)/sizeof(*rgProcAddresses); i++)
-      rgProcAddresses[i] = (GenericFnPtr)::GetProcAddress(
+    LPVOID modEndAddr = (char*)mi.lpBaseOfDll + mi.SizeOfImage;
+    for (int i = 0; i < sizeof(rgProcAddresses)/sizeof(*rgProcAddresses); i++) {
+      FARPROC target = ::GetProcAddress(
           reinterpret_cast<const HMODULE>(mi.lpBaseOfDll),
           LibcInfo::function_name(i));
+      // Sometimes a DLL forwards a function to a function in another
+      // DLL.  We don't want to patch those forwarded functions --
+      // they'll get patched when the other DLL is processed.
+      if (target >= modBaseAddr && target < modEndAddr)
+        rgProcAddresses[i] = (GenericFnPtr)target;
+      else
+        rgProcAddresses[i] = (GenericFnPtr)NULL;
+    }
   }
 };
 
 // This class is easier because there's only one of them.
 class WindowsInfo {
  public:
   void Patch();
   void Unpatch();
 
  private:
@@ skipping 66 matching lines @@
   "malloc", "free", "realloc", "calloc",
   kMangledNew, kMangledNewArray, kMangledDelete, kMangledDeleteArray,
   // Ideally we should patch the nothrow versions of new/delete, but
   // at least in msvcrt, nothrow-new machine-code is of a type we
   // can't patch.  Since these are relatively rare, I'm hoping it's ok
   // not to patch them.  (NULL name turns off patching.)
   NULL,  // kMangledNewNothrow,
   NULL,  // kMangledNewArrayNothrow,
   NULL,  // kMangledDeleteNothrow,
   NULL,  // kMangledDeleteArrayNothrow,
-  "_msize", "_expand", "_aligned_malloc", "_aligned_free",
+  "_msize", "_expand",
 };
 
 // For mingw, I can't patch the new/delete here, because the
 // instructions are too small to patch.  Luckily, they're so small
 // because all they do is call into malloc/free, so they still end up
 // calling tcmalloc routines, and we don't actually lose anything
 // (except maybe some stacktrace goodness) by not patching.
 const GenericFnPtr LibcInfo::static_fn_[] = {
   (GenericFnPtr)&::malloc,
   (GenericFnPtr)&::free,
@@ skipping 10 matching lines @@
   (void*(*)(size_t, struct std::nothrow_t const &))&::operator new,
   (GenericFnPtr)
   (void*(*)(size_t, struct std::nothrow_t const &))&::operator new[],
   (GenericFnPtr)
   (void(*)(void*, struct std::nothrow_t const &))&::operator delete,
   (GenericFnPtr)
   (void(*)(void*, struct std::nothrow_t const &))&::operator delete[],
 #endif
   (GenericFnPtr)&::_msize,
   (GenericFnPtr)&::_expand,
-#ifdef PERFTOOLS_NO_ALIGNED_MALLOC   // for older versions of mingw
-  // _aligned_malloc isn't always available in mingw, so don't try to patch.
-  (GenericFnPtr)NULL,
-  (GenericFnPtr)NULL,
-#else
-  (GenericFnPtr)&::_aligned_malloc,
-  (GenericFnPtr)&::_aligned_free,
-#endif
 };
 
 template<int T> GenericFnPtr LibcInfoWithPatchFunctions<T>::origstub_fn_[] = {
   // This will get filled in at run-time, as patching is done.
 };
 
 template<int T>
 const GenericFnPtr LibcInfoWithPatchFunctions<T>::perftools_fn_[] = {
   (GenericFnPtr)&Perftools_malloc,
   (GenericFnPtr)&Perftools_free,
   (GenericFnPtr)&Perftools_realloc,
   (GenericFnPtr)&Perftools_calloc,
   (GenericFnPtr)&Perftools_new,
   (GenericFnPtr)&Perftools_newarray,
   (GenericFnPtr)&Perftools_delete,
   (GenericFnPtr)&Perftools_deletearray,
   (GenericFnPtr)&Perftools_new_nothrow,
   (GenericFnPtr)&Perftools_newarray_nothrow,
   (GenericFnPtr)&Perftools_delete_nothrow,
   (GenericFnPtr)&Perftools_deletearray_nothrow,
   (GenericFnPtr)&Perftools__msize,
   (GenericFnPtr)&Perftools__expand,
-  (GenericFnPtr)&Perftools__aligned_malloc,
-  (GenericFnPtr)&Perftools__aligned_free,
 };
 
 /*static*/ WindowsInfo::FunctionInfo WindowsInfo::function_info_[] = {
   { "HeapAlloc", NULL, NULL, (GenericFnPtr)&Perftools_HeapAlloc },
   { "HeapFree", NULL, NULL, (GenericFnPtr)&Perftools_HeapFree },
   { "VirtualAllocEx", NULL, NULL, (GenericFnPtr)&Perftools_VirtualAllocEx },
   { "VirtualFreeEx", NULL, NULL, (GenericFnPtr)&Perftools_VirtualFreeEx },
   { "MapViewOfFileEx", NULL, NULL, (GenericFnPtr)&Perftools_MapViewOfFileEx },
   { "UnmapViewOfFile", NULL, NULL, (GenericFnPtr)&Perftools_UnmapViewOfFile },
   { "LoadLibraryExW", NULL, NULL, (GenericFnPtr)&Perftools_LoadLibraryExW },
@@ skipping 435 matching lines @@
 
 // We need to define this because internal windows functions like to
 // call into it(?).  _expand() is like realloc but doesn't move the
 // pointer.  We punt, which will cause callers to fall back on realloc.
 template<int T>
 void* LibcInfoWithPatchFunctions<T>::Perftools__expand(void *ptr,
                                                        size_t size) __THROW {
   return NULL;
 }
 
-template<int T>
-void* LibcInfoWithPatchFunctions<T>::Perftools__aligned_malloc(size_t size,
-                                                               size_t alignment)
-    __THROW {
-  void* result = do_memalign_or_cpp_memalign(alignment, size);
-  MallocHook::InvokeNewHook(result, size);
-  return result;
-}
-
-template<int T>
-void LibcInfoWithPatchFunctions<T>::Perftools__aligned_free(void *ptr) __THROW {
-  MallocHook::InvokeDeleteHook(ptr);
-  do_free_with_callback(ptr, (void (*)(void*))origstub_fn_[k_Aligned_free]);
-}
-
 LPVOID WINAPI WindowsInfo::Perftools_HeapAlloc(HANDLE hHeap, DWORD dwFlags,
                                                DWORD_PTR dwBytes) {
   LPVOID result = ((LPVOID (WINAPI *)(HANDLE, DWORD, DWORD_PTR))
                    function_info_[kHeapAlloc].origstub_fn)(
                        hHeap, dwFlags, dwBytes);
   MallocHook::InvokeNewHook(result, dwBytes);
   return result;
 }
 
 BOOL WINAPI WindowsInfo::Perftools_HeapFree(HANDLE hHeap, DWORD dwFlags,
@@ skipping 142 matching lines @@
   if (libc1.is_valid()) libc1.Unpatch();
   if (libc2.is_valid()) libc2.Unpatch();
   if (libc3.is_valid()) libc3.Unpatch();
   if (libc4.is_valid()) libc4.Unpatch();
   if (libc5.is_valid()) libc5.Unpatch();
   if (libc6.is_valid()) libc6.Unpatch();
   if (libc7.is_valid()) libc7.Unpatch();
   if (libc8.is_valid()) libc8.Unpatch();
 }
 #endif