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

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 54 matching lines @@
 #ifndef _WIN32
 # error You should only be including windows/patch_functions.cc in a windows environment!
 #endif
 
 #include <config.h>
 
 #ifdef WIN32_OVERRIDE_ALLOCATORS
 #error This file is intended for patching allocators - use override_functions.cc instead.
 #endif
 
+// We use psapi.  Non-MSVC systems will have to link this in themselves.
+#ifdef _MSC_VER
+#pragma comment(lib, "Psapi.lib")
+#endif
+
+// Make sure we always use the 'old' names of the psapi functions.
+#ifndef PSAPI_VERSION
+#define PSAPI_VERSION 1
+#endif
+
 #include <windows.h>
 #include <malloc.h>       // for _msize and _expand
-#include <tlhelp32.h>     // for CreateToolhelp32Snapshot()
+#include <Psapi.h>        // for EnumProcessModules, GetModuleInformation, etc.
+#include <set>
+#include <map>
 #include <vector>
 #include <base/logging.h>
 #include "base/spinlock.h"
 #include "google/malloc_hook.h"
 #include "malloc_hook-inl.h"
 #include "preamble_patcher.h"
 
-// MinGW doesn't seem to define this, perhaps some windowsen don't either.
-#ifndef TH32CS_SNAPMODULE32
-#define TH32CS_SNAPMODULE32  0
-#endif
+// The maximum number of modules we allow to be in one executable
+const int kMaxModules = 8182;
+// The maximum size of a module's basename
+const int kMaxModuleNameSize = 256;
 
 // These are hard-coded, unfortunately. :-( They are also probably
 // compiler specific.  See get_mangled_names.cc, in this directory,
 // for instructions on how to update these names for your compiler.
 const char kMangledNew[] = "??2@YAPAXI@Z";
 const char kMangledNewArray[] = "??_U@YAPAXI@Z";
 const char kMangledDelete[] = "??3@YAXPAX@Z";
 const char kMangledDeleteArray[] = "??_V@YAXPAX@Z";
 const char kMangledNewNothrow[] = "??2@YAPAXIABUnothrow_t@std@@@Z";
 const char kMangledNewArrayNothrow[] = "??_U@YAPAXIABUnothrow_t@std@@@Z";
@@ skipping 11 matching lines @@
 // the symbol "__tcmalloc".)
 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.
 
 // This is information about the routines we're patching, for a given
 // module that implements libc memory routines.  A single executable
 // can have several libc implementations running about (in different
 // .dll's), and we need to patch/unpatch them all.  This defines
 // everything except the new functions we're patching in, which
 // are defined in LibcFunctions, below.
 class LibcInfo {
  public:
   LibcInfo() {
     memset(this, 0, sizeof(*this));  // easiest way to initialize the array
   }
-  bool SameAs(const LibcInfo& that) const {
-    return (is_valid() &&
-            module_base_address_ == that.module_base_address_ &&
-            module_base_size_ == that.module_base_size_);
-  }
-  bool SameAsME32(const MODULEENTRY32& me32) const {
-    return (is_valid() &&
-            module_base_address_ == me32.modBaseAddr &&
-            module_base_size_ == me32.modBaseSize);
-  }
+  bool SameAs(const LibcInfo& that) const;
+  bool SameAsModuleEntry(const ModuleEntryCopy& module_entry) const;
+
   bool patched() const { return is_valid() && module_name_[0] != '\0'; }
   const char* module_name() const { return is_valid() ? module_name_ : ""; }
 
   void set_is_valid(bool b) { is_valid_ = b; }
 
-  // These shouldn't have to be public, since only subclasses of
-  // LibcInfo need it, but they do.  Maybe something to do with
-  // templates.  Shrug.
-  bool is_valid() const { return is_valid_; }
-  GenericFnPtr windows_fn(int ifunction) const {
-    return windows_fn_[ifunction];
-  }
-
   // Populates all the windows_fn_[] vars based on our module info.
   // Returns false if windows_fn_ is all NULL's, because there's
-  // nothing to patch.  Also populates the me32 info.
-  bool PopulateWindowsFn(const MODULEENTRY32& me32);
+  // nothing to patch.  Also populates the rest of the module_entry
+  // info, such as the module's name.
+  bool PopulateWindowsFn(const ModuleEntryCopy& module_entry);
 
  protected:
   void CopyFrom(const LibcInfo& that) {
     if (this == &that)
       return;
     this->is_valid_ = that.is_valid_;
     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_;
     memcpy(this->module_name_, that.module_name_, sizeof(module_name_));
@@ skipping 29 matching lines @@
   // patch-specific subclasses, below.
   GenericFnPtr windows_fn_[kNumFunctions];
 
   // This is set to true when this structure is initialized (because
   // we're patching a new library) and set to false when it's
   // uninitialized (because we've freed that library).
   bool is_valid_;
 
   const void *module_base_address_;
   size_t module_base_size_;
-  char module_name_[MAX_MODULE_NAME32 + 1];
+  char module_name_[kMaxModuleNameSize];
+
+ public:
+  // These shouldn't have to be public, since only subclasses of
+  // LibcInfo need it, but they do.  Maybe something to do with
+  // templates.  Shrug.  I hide them down here so users won't see
+  // them. :-)  (OK, I also need to define ctrgProcAddress late.)
+  bool is_valid() const { return is_valid_; }
+  GenericFnPtr windows_fn(int ifunction) const {
+    return windows_fn_[ifunction];
+  }
+  // These three are needed by ModuleEntryCopy.
+  static const int ctrgProcAddress = kNumFunctions;
+  static GenericFnPtr static_fn(int ifunction) {
+    return static_fn_[ifunction];
+  }
+  static const char* const function_name(int ifunction) {
+    return function_name_[ifunction];
+  }
 };
 
 // Template trickiness: logically, a LibcInfo would include
 // Windows_malloc_, origstub_malloc_, and Perftools_malloc_: for a
 // given module, these three go together.  And in fact,
 // Perftools_malloc_ may need to call origstub_malloc_, which means we
 // either need to change Perftools_malloc_ to take origstub_malloc_ as
 // an arugment -- unfortunately impossible since it needs to keep the
 // same API as normal malloc -- or we need to write a different
 // version of Perftools_malloc_ for each LibcInfo instance we create.
@@ skipping 37 matching lines @@
   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:
   //   _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.
 };
 
+// This is a subset of MODDULEENTRY32, that we need for patching.
+struct ModuleEntryCopy {
+  LPVOID  modBaseAddr;
+  DWORD   modBaseSize;
+  HMODULE hModule;
+  TCHAR   szModule[kMaxModuleNameSize];
+  // 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;
+    hModule = NULL;
+    strcpy(szModule, "<executable>");
+    for (int i = 0; i < sizeof(rgProcAddresses)/sizeof(*rgProcAddresses); i++)
+      rgProcAddresses[i] = LibcInfo::static_fn(i);
+  }
+  ModuleEntryCopy(HANDLE hprocess, HMODULE hmodule, const MODULEINFO& mi) {
+    this->modBaseAddr = mi.lpBaseOfDll;
+    this->modBaseSize = mi.SizeOfImage;
+    this->hModule = hmodule;
+    // TODO(csilvers): we could make more efficient by calling these
+    // lazily (not until the vars are needed, which is often never).
+    // However, there's tricky business with calling windows functions
+    // inside the patch_all_modules_lock (see the lock inversion
+    // comments with the patch_all_modules_lock definition, below), so
+    // it's safest to do it all here, where no lock is needed.
+    ::GetModuleBaseNameA(hprocess, hmodule,
+                         this->szModule, sizeof(this->szModule));
+    for (int i = 0; i < sizeof(rgProcAddresses)/sizeof(*rgProcAddresses); i++)
+      rgProcAddresses[i] =
+          (GenericFnPtr)::GetProcAddress(hModule, LibcInfo::function_name(i));
+  }
+};
+
 // This class is easier because there's only one of them.
 class WindowsInfo {
  public:
   void Patch();
   void Unpatch();
 
  private:
   // TODO(csilvers): should we be patching GlobalAlloc/LocalAlloc instead,
   //                 for pre-XP systems?
   enum {
@@ skipping 33 matching lines @@
   // We don't need the other 3 variants because they all call this one. */
   static HMODULE WINAPI Perftools_LoadLibraryExW(LPCWSTR lpFileName,
                                                  HANDLE hFile,
                                                  DWORD dwFlags);
   static BOOL WINAPI Perftools_FreeLibrary(HMODULE hLibModule);
 };
 
 // If you run out, just add a few more to the array.  You'll also need
 // to update the switch statement in PatchOneModule(), and the list in
 // UnpatchWindowsFunctions().
+// main_executable and main_executable_windows are two windows into
+// the same executable.  One is responsible for patching the libc
+// routines that live in the main executable (if any) to use tcmalloc;
+// the other is responsible for patching the windows routines like
+// HeapAlloc/etc to use tcmalloc.
 static LibcInfoWithPatchFunctions<0> main_executable;
 static LibcInfoWithPatchFunctions<1> libc1;
 static LibcInfoWithPatchFunctions<2> libc2;
 static LibcInfoWithPatchFunctions<3> libc3;
 static LibcInfoWithPatchFunctions<4> libc4;
 static LibcInfoWithPatchFunctions<5> libc5;
 static LibcInfoWithPatchFunctions<6> libc6;
 static LibcInfoWithPatchFunctions<7> libc7;
 static LibcInfoWithPatchFunctions<8> libc8;
-static LibcInfo* module_libcs[] = {
+static LibcInfo* g_module_libcs[] = {
   &libc1, &libc2, &libc3, &libc4, &libc5, &libc6, &libc7, &libc8
 };
 static WindowsInfo main_executable_windows;
 
 const char* const LibcInfo::function_name_[] = {
   "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
@@ skipping 71 matching lines @@
   { "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 },
   { "FreeLibrary", NULL, NULL, (GenericFnPtr)&Perftools_FreeLibrary },
 };
 
-bool LibcInfo::PopulateWindowsFn(const MODULEENTRY32& me32) {
-  module_base_address_ = me32.modBaseAddr;
-  module_base_size_ = me32.modBaseSize;
-  strcpy(module_name_, me32.szModule);
+bool LibcInfo::SameAs(const LibcInfo& that) const {
+  return (is_valid() &&
+          module_base_address_ == that.module_base_address_ &&
+          module_base_size_ == that.module_base_size_);
+}
 
+bool LibcInfo::SameAsModuleEntry(const ModuleEntryCopy& module_entry) const {
+  return (is_valid() &&
+          module_base_address_ == module_entry.modBaseAddr &&
+          module_base_size_ == module_entry.modBaseSize);
+}
+
+bool LibcInfo::PopulateWindowsFn(const ModuleEntryCopy& module_entry) {
   // First, store the location of the function to patch before
   // patching it.  If none of these functions are found in the module,
   // then this module has no libc in it, and we just return false.
   for (int i = 0; i < kNumFunctions; i++) {
     if (!function_name_[i])     // we can turn off patching by unsetting name
       continue;
-    GenericFnPtr fn = NULL;
-    if (me32.hModule == NULL) { // used for the main executable
-      // This is used only for a statically-linked-in libc.
-      fn = static_fn_[i];
-    } else {
-      fn = (GenericFnPtr)::GetProcAddress(me32.hModule, function_name_[i]);
-    }
+    // The ::GetProcAddress calls were done in the ModuleEntryCopy
+    // constructor, so we don't have to make any windows calls here.
+    const GenericFnPtr fn = module_entry.rgProcAddresses[i];
     if (fn) {
       windows_fn_[i] = PreamblePatcher::ResolveTarget(fn);
     }
   }
 
   // Some modules use the same function pointer for new and new[].  If
   // we find that, set one of the pointers to NULL so we don't double-
   // patch.  Same may happen with new and nothrow-new, or even new[]
   // and nothrow-new.  It's easiest just to check each fn-ptr against
   // every other.
   for (int i = 0; i < kNumFunctions; i++) {
     for (int j = i+1; j < kNumFunctions; j++) {
       if (windows_fn_[i] == windows_fn_[j]) {
         // We NULL the later one (j), so as to minimize the chances we
         // NULL kFree and kRealloc.  See comments below.  This is fragile!
         windows_fn_[j] = NULL;
       }
     }
   }
 
   // There's always a chance that our module uses the same function
   // as another module that we've already loaded.  In that case, we
   // need to set our windows_fn to NULL, to avoid double-patching.
   for (int ifn = 0; ifn < kNumFunctions; ifn++) {
     for (int imod = 0;
-         imod < sizeof(module_libcs)/sizeof(*module_libcs);  imod++) {
-      if (module_libcs[imod]->is_valid() &&
-          this->windows_fn(ifn) == module_libcs[imod]->windows_fn(ifn)) {
+         imod < sizeof(g_module_libcs)/sizeof(*g_module_libcs);  imod++) {
+      if (g_module_libcs[imod]->is_valid() &&
+          this->windows_fn(ifn) == g_module_libcs[imod]->windows_fn(ifn)) {
         windows_fn_[ifn] = NULL;
       }
     }
   }
 
   bool found_non_null = false;
   for (int i = 0; i < kNumFunctions; i++) {
     if (windows_fn_[i])
       found_non_null = true;
   }
   if (!found_non_null)
     return false;
 
   // It's important we didn't NULL out windows_fn_[kFree] or [kRealloc].
   // The reason is, if those are NULL-ed out, we'll never patch them
   // and thus never get an origstub_fn_ value for them, and when we
   // try to call origstub_fn_[kFree/kRealloc] in Perftools_free and
   // Perftools_realloc, below, it will fail.  We could work around
   // that by adding a pointer from one patch-unit to the other, but we
   // haven't needed to yet.
   CHECK(windows_fn_[kFree]);
   CHECK(windows_fn_[kRealloc]);
+
+  // OK, we successfully patched.  Let's store our member information.
+  module_base_address_ = module_entry.modBaseAddr;
+  module_base_size_ = module_entry.modBaseSize;
+  strcpy(module_name_, module_entry.szModule);
   return true;
 }
 
 template<int T>
 bool LibcInfoWithPatchFunctions<T>::Patch(const LibcInfo& me_info) {
-  CopyFrom(me_info);   // copies the me32 and the windows_fn_ array
+  CopyFrom(me_info);   // copies the module_entry and the windows_fn_ array
   for (int i = 0; i < kNumFunctions; i++) {
-    if (windows_fn_[i] && windows_fn_[i] != perftools_fn_[i])
+    if (windows_fn_[i] && windows_fn_[i] != perftools_fn_[i]) {
+      // if origstub_fn_ is not NULL, it's left around from a previous
+      // patch.  We need to set it to NULL for the new Patch call.
+      // Since we've patched Unpatch() not to delete origstub_fn_ (it
+      // causes problems in some contexts, though obviously not this
+      // one), we should delete it now, before setting it to NULL.
+      // NOTE: casting from a function to a pointer is contra the C++
+      //       spec.  It's not safe on IA64, but is on i386.  We use
+      //       a C-style cast here to emphasize this is not legal C++.
+      delete[] (char*)(origstub_fn_[i]);
+      origstub_fn_[i] = NULL;   // Patch() will fill this in
       CHECK_EQ(sidestep::SIDESTEP_SUCCESS,
                PreamblePatcher::Patch(windows_fn_[i], perftools_fn_[i],
                                       &origstub_fn_[i]));
+    }
   }
   set_is_valid(true);
   return true;
 }
 
 template<int T>
 void LibcInfoWithPatchFunctions<T>::Unpatch() {
   // We have to cast our GenericFnPtrs to void* for unpatch.  This is
   // contra the C++ spec; we use C-style casts to empahsize that.
   for (int i = 0; i < kNumFunctions; i++) {
     if (windows_fn_[i])
       CHECK_EQ(sidestep::SIDESTEP_SUCCESS,
                PreamblePatcher::Unpatch((void*)windows_fn_[i],
                                         (void*)perftools_fn_[i],
                                         (void*)origstub_fn_[i]));
   }
   set_is_valid(false);
 }
 
 void WindowsInfo::Patch() {
   HMODULE hkernel32 = ::GetModuleHandleA("kernel32");
   CHECK_NE(hkernel32, NULL);
 
   // Unlike for libc, we know these exist in our module, so we can get
   // and patch at the same time.
   for (int i = 0; i < kNumFunctions; i++) {
     function_info_[i].windows_fn = (GenericFnPtr)
         ::GetProcAddress(hkernel32, function_info_[i].name);
+    // If origstub_fn is not NULL, it's left around from a previous
+    // patch.  We need to set it to NULL for the new Patch call.
+    // Since we've patched Unpatch() not to delete origstub_fn_ (it
+    // causes problems in some contexts, though obviously not this
+    // one), we should delete it now, before setting it to NULL.
+    // NOTE: casting from a function to a pointer is contra the C++
+    //       spec.  It's not safe on IA64, but is on i386.  We use
+    //       a C-style cast here to emphasize this is not legal C++.
+    delete[] (char*)(function_info_[i].origstub_fn);
+    function_info_[i].origstub_fn = NULL;  // Patch() will fill this in
     CHECK_EQ(sidestep::SIDESTEP_SUCCESS,
              PreamblePatcher::Patch(function_info_[i].windows_fn,
                                     function_info_[i].perftools_fn,
                                     &function_info_[i].origstub_fn));
   }
 }
 
 void WindowsInfo::Unpatch() {
   // We have to cast our GenericFnPtrs to void* for unpatch.  This is
   // contra the C++ spec; we use C-style casts to empahsize that.
   for (int i = 0; i < kNumFunctions; i++) {
     CHECK_EQ(sidestep::SIDESTEP_SUCCESS,
              PreamblePatcher::Unpatch((void*)function_info_[i].windows_fn,
                                       (void*)function_info_[i].perftools_fn,
                                       (void*)function_info_[i].origstub_fn));
   }
 }
 
 // You should hold the patch_all_modules_lock when calling this.
 void PatchOneModuleLocked(const LibcInfo& me_info) {
   // Double-check we haven't seen this module before.
-  for (int i = 0; i < sizeof(module_libcs)/sizeof(*module_libcs); i++) {
-    if (module_libcs[i]->SameAs(me_info)) {
-      fprintf(stderr, "%s:%d: FATAL ERROR: %s double-patched somehow.\n",
-              __FILE__, __LINE__, module_libcs[i]->module_name());
+  for (int i = 0; i < sizeof(g_module_libcs)/sizeof(*g_module_libcs); i++) {
+    if (g_module_libcs[i]->SameAs(me_info)) {
+      fprintf(stderr, "%s:%d: FATAL PERFTOOLS ERROR: %s double-patched somehow.\n",
+              __FILE__, __LINE__, g_module_libcs[i]->module_name());
       CHECK(false);
     }
   }
   // If we don't already have info on this module, let's add it.  This
   // is where we're sad that each libcX has a different type, so we
   // can't use an array; instead, we have to use a switch statement.
   // Patch() returns false if there were no libc functions in the module.
-  for (int i = 0; i < sizeof(module_libcs)/sizeof(*module_libcs); i++) {
-    if (!module_libcs[i]->is_valid()) {   // found an empty spot to add!
+  for (int i = 0; i < sizeof(g_module_libcs)/sizeof(*g_module_libcs); i++) {
+    if (!g_module_libcs[i]->is_valid()) {   // found an empty spot to add!
       switch (i) {
         case 0: libc1.Patch(me_info); return;
         case 1: libc2.Patch(me_info); return;
         case 2: libc3.Patch(me_info); return;
         case 3: libc4.Patch(me_info); return;
         case 4: libc5.Patch(me_info); return;
         case 5: libc6.Patch(me_info); return;
         case 6: libc7.Patch(me_info); return;
         case 7: libc8.Patch(me_info); return;
       }
     }
   }
-  printf("ERROR: Too many modules containing libc in this executable\n");
+  printf("PERFTOOLS ERROR: Too many modules containing libc in this executable\n");
 }
 
 void PatchMainExecutableLocked() {
   if (main_executable.patched())
     return;    // main executable has already been patched
-  MODULEENTRY32 fake_me32;   // we make a fake one to pass into Patch()
-  fake_me32.modBaseAddr = NULL;
-  fake_me32.modBaseSize = 0;
-  strcpy(fake_me32.szModule, "<executable>");
-  fake_me32.hModule = NULL;
-  main_executable.PopulateWindowsFn(fake_me32);
+  ModuleEntryCopy fake_module_entry;   // make a fake one to pass into Patch()
+  // No need to call PopulateModuleEntryProcAddresses on the main executable.
+  main_executable.PopulateWindowsFn(fake_module_entry);
   main_executable.Patch(main_executable);
 }
 
+// This lock is subject to a subtle and annoying lock inversion
+// problem: it may interact badly with unknown internal windows locks.
+// In particular, windows may be holding a lock when it calls
+// LoadLibraryExW and FreeLibrary, which we've patched.  We have those
+// routines call PatchAllModules, which acquires this lock.  If we
+// make windows system calls while holding this lock, those system
+// calls may need the internal windows locks that are being held in
+// the call to LoadLibraryExW, resulting in deadlock.  The solution is
+// to be very careful not to call *any* windows routines while holding
+// patch_all_modules_lock, inside PatchAllModules().
 static SpinLock patch_all_modules_lock(SpinLock::LINKER_INITIALIZED);
 
 // Iterates over all the modules currently loaded by the executable,
 // and makes sure they're all patched.  For ones that aren't, we patch
 // them in.  We also check that every module we had patched in the
 // past is still loaded, and update internal data structures if so.
-void PatchAllModules() {
-  std::vector<LibcInfo*> modules;
-  bool still_loaded[sizeof(module_libcs)/sizeof(*module_libcs)] = {};
+// We return true if this PatchAllModules did any work, false else.
+bool PatchAllModules() {
+  std::vector<ModuleEntryCopy> modules;
+  bool made_changes = false;
 
-  HANDLE hModuleSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE |
-                                                TH32CS_SNAPMODULE32,
-                                                GetCurrentProcessId());
-  if (hModuleSnap != INVALID_HANDLE_VALUE) {
-    MODULEENTRY32 me32;
-    me32.dwSize = sizeof(me32);
-    if (Module32First(hModuleSnap, &me32)) {
-      do {
-        bool module_already_loaded = false;
-        for (int i = 0; i < sizeof(module_libcs)/sizeof(*module_libcs); i++) {
-          if (module_libcs[i]->SameAsME32(me32)) {
-            still_loaded[i] = true;
-            module_already_loaded = true;
-            break;
-          }
-        }
-        if (!module_already_loaded) {
-          LibcInfo* libc_info = new LibcInfo;
-          if (libc_info->PopulateWindowsFn(me32))
-            modules.push_back(libc_info);
-          else                   // means module has no libc routines
-            delete libc_info;
-        }
-      } while (Module32Next(hModuleSnap, &me32));
+  const HANDLE hCurrentProcess = GetCurrentProcess();
+  MODULEINFO mi;
+  DWORD cbNeeded = 0;
+  HMODULE hModules[kMaxModules];  // max # of modules we support in one process
+  if (::EnumProcessModules(hCurrentProcess, hModules, sizeof(hModules),
+                           &cbNeeded)) {
+    for (int i = 0; i < cbNeeded / sizeof(*hModules); ++i) {
+      if (i >= kMaxModules) {
+        printf("PERFTOOLS ERROR: Too many modules in this executable to try"
+               " to patch them all (if you need to, raise kMaxModules in"
+               " patch_functions.cc).\n");
+        break;
+      }
+      if (::GetModuleInformation(hCurrentProcess, hModules[i], &mi, sizeof(mi)))
+        modules.push_back(ModuleEntryCopy(hCurrentProcess, hModules[i], mi));
     }
-    CloseHandle(hModuleSnap);
   }
 
-  // Now do the actual patching.
+  // Now do the actual patching and unpatching.
   {
     SpinLockHolder h(&patch_all_modules_lock);
-    // First, delete the modules that are no longer loaded.  (We go first
-    // so we can try to open up space for the new modules we need to load.)
-    for (int i = 0; i < sizeof(module_libcs)/sizeof(*module_libcs); i++) {
-      if (!still_loaded[i]) {
+    for (int i = 0; i < sizeof(g_module_libcs)/sizeof(*g_module_libcs); i++) {
+      if (!g_module_libcs[i]->is_valid())
+        continue;
+      bool still_loaded = false;
+      for (std::vector<ModuleEntryCopy>::iterator it = modules.begin();
+           it != modules.end(); ++it) {
+        if (g_module_libcs[i]->SameAsModuleEntry(*it)) {
+          // Both g_module_libcs[i] and it are still valid.  Mark it by
+          // removing it from the vector; mark g_module_libcs[i] by
+          // setting a bool.
+          modules.erase(it);
+          still_loaded = true;
+          break;
+        }
+      }
+      if (!still_loaded) {
+        // Means g_module_libcs[i] is no longer loaded (no me32 matched).
         // We could call Unpatch() here, but why bother?  The module
         // has gone away, so nobody is going to call into it anyway.
-        module_libcs[i]->set_is_valid(false);
+        g_module_libcs[i]->set_is_valid(false);
+        made_changes = true;
       }
     }
 
-    // Now, add in new modules that we need to load.
-    for (std::vector<LibcInfo*>::iterator it = modules.begin();
-         it != modules.end();  ++it) {
-      PatchOneModuleLocked(**it);  // updates num_patched_modules
+    // We've handled all the g_module_libcs.  Now let's handle the rest
+    // of the module-entries: those that haven't already been loaded.
+    for (std::vector<ModuleEntryCopy>::const_iterator it = modules.begin();
+         it != modules.end(); ++it) {
+      LibcInfo libc_info;
+      if (libc_info.PopulateWindowsFn(*it)) { // true==module has libc routines
+        PatchOneModuleLocked(libc_info);      // updates num_patched_modules
+        made_changes = true;
+      }
     }
 
     // Now that we've dealt with the modules (dlls), update the main
     // executable.  We do this last because PatchMainExecutableLocked
     // wants to look at how other modules were patched.
-    PatchMainExecutableLocked();
+    if (!main_executable.patched()) {
+      PatchMainExecutableLocked();
+      made_changes = true;
+    }
   }
-
-  for (std::vector<LibcInfo*>::iterator it = modules.begin();
-       it != modules.end();  ++it) {
-    delete *it;
-  }
+  return made_changes;
 }
 
 
 }  // end unnamed namespace
 
 // ---------------------------------------------------------------------
 // PatchWindowsFunctions()
 //    This is the function that is exposed to the outside world.
+//    It should be called before the program becomes multi-threaded,
+//    since main_executable_windows.Patch() is not thread-safe.
 // ---------------------------------------------------------------------
 
 void PatchWindowsFunctions() {
   // This does the libc patching in every module, and the main executable.
   PatchAllModules();
   main_executable_windows.Patch();
 }
 
 #if 0
 // It's possible to unpatch all the functions when we are exiting.
@@ skipping 44 matching lines @@
 // functions here, using tcmalloc internals, without polluting
 // tcmalloc.cc.
 // -------------------------------------------------------------------
 
 // TODO(csilvers): refactor tcmalloc.cc into two files, so I can link
 // against the file with do_malloc, and ignore the one with malloc.
 #include "tcmalloc.cc"
 
 template<int T>
 void* LibcInfoWithPatchFunctions<T>::Perftools_malloc(size_t size) __THROW {
-  void* result = do_malloc(size);
+  void* result = do_malloc_or_cpp_alloc(size);
   MallocHook::InvokeNewHook(result, size);
   return result;
 }
 
 template<int T>
 void LibcInfoWithPatchFunctions<T>::Perftools_free(void* ptr) __THROW {
   MallocHook::InvokeDeleteHook(ptr);
   // This calls the windows free if do_free decides ptr was not
   // allocated by tcmalloc.  Note it calls the origstub_free from
   // *this* templatized instance of LibcInfo.  See "template
   // trickiness" above.
   do_free_with_callback(ptr, (void (*)(void*))origstub_fn_[kFree]);
 }
 
 template<int T>
 void* LibcInfoWithPatchFunctions<T>::Perftools_realloc(
     void* old_ptr, size_t new_size) __THROW {
   if (old_ptr == NULL) {
-    void* result = do_malloc(new_size);
+    void* result = do_malloc_or_cpp_alloc(new_size);
     MallocHook::InvokeNewHook(result, new_size);
     return result;
   }
   if (new_size == 0) {
     MallocHook::InvokeDeleteHook(old_ptr);
     do_free_with_callback(old_ptr,
                           (void (*)(void*))origstub_fn_[kFree]);
     return NULL;
   }
   return do_realloc_with_callback(
@@ skipping 86 matching lines @@
 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(alignment, size);
+  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]);
 }
 
@@ skipping 54 matching lines @@
           function_info_[kUnmapViewOfFile].origstub_fn)(
               lpBaseAddress);
 }
 
 HMODULE WINAPI WindowsInfo::Perftools_LoadLibraryExW(LPCWSTR lpFileName,
                                                      HANDLE hFile,
                                                      DWORD dwFlags) {
   HMODULE rv = ((HMODULE (WINAPI *)(LPCWSTR, HANDLE, DWORD))
                 function_info_[kLoadLibraryExW].origstub_fn)(
                     lpFileName, hFile, dwFlags);
-  PatchAllModules();   // this will patch any newly loaded libraries
+  PatchAllModules();
   return rv;
 }
 
 BOOL WINAPI WindowsInfo::Perftools_FreeLibrary(HMODULE hLibModule) {
   BOOL rv = ((BOOL (WINAPI *)(HMODULE))
              function_info_[kFreeLibrary].origstub_fn)(hLibModule);
   PatchAllModules();    // this will fix up the list of patched libraries
   return rv;
 }