Hookup the generic heap intercept for Windows.

base/allocator/allocator_shim.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/allocator/allocator_shim.h"
 
 #include <errno.h>
-#include <unistd.h>
 
 #include <new>
 
 #include "base/atomicops.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/threading/platform_thread.h"
 #include "build/build_config.h"
 
+#if !defined(OS_WIN)
+#include <unistd.h>
+#else
+#include "base/allocator/allocator_impl_win.h"
+#endif
+
 // No calls to malloc / new in this file. They would would cause re-entrancy of
 // the shim, which is hard to deal with. Keep this code as simple as possible
 // and don't use any external C++ object here, not even //base ones. Even if
 // they are safe to use today, in future they might be refactored.
 
 namespace {
 
 using namespace base;
 
 subtle::AtomicWord g_chain_head = reinterpret_cast<subtle::AtomicWord>(
     &allocator::AllocatorDispatch::default_dispatch);
 
 bool g_call_new_handler_on_malloc_failure = false;
 subtle::Atomic32 g_new_handler_lock = 0;
 
 // In theory this should be just base::ThreadChecker. But we can't afford
 // the luxury of a LazyInstance<ThreadChecker> here as it would cause a new().
 bool CalledOnValidThread() {
   using subtle::Atomic32;
   const Atomic32 kInvalidTID = static_cast<Atomic32>(kInvalidThreadId);
   static Atomic32 g_tid = kInvalidTID;
   Atomic32 cur_tid = static_cast<Atomic32>(PlatformThread::CurrentId());
   Atomic32 prev_tid =
       subtle::NoBarrier_CompareAndSwap(&g_tid, kInvalidTID, cur_tid);
   return prev_tid == kInvalidTID || prev_tid == cur_tid;
 }
 
 inline size_t GetPageSize() {
+#if defined(OS_WIN)
+  return 4096;
+#else
   static size_t pagesize = 0;
   if (!pagesize)
     pagesize = sysconf(_SC_PAGESIZE);
   return pagesize;
+#endif
 }
 
 // Calls the std::new handler thread-safely. Returns true if a new_handler was
 // set and called, false if no new_handler was set.
-bool CallNewHandler() {
+bool CallNewHandler(size_t size) {
+#if defined(OS_WIN)
+  return base::allocator::WinCallNewHandler(size);
+#else
   // TODO(primiano): C++11 has introduced ::get_new_handler() which is supposed
   // to be thread safe and would avoid the spinlock boilerplate here. However
   // it doesn't seem to be available yet in the Linux chroot headers yet.
   std::new_handler nh;
   {
     while (subtle::Acquire_CompareAndSwap(&g_new_handler_lock, 0, 1))
       PlatformThread::YieldCurrentThread();
     nh = std::set_new_handler(0);
     ignore_result(std::set_new_handler(nh));
     subtle::Release_Store(&g_new_handler_lock, 0);
   }
   if (!nh)
     return false;
   (*nh)();
   // Assume the new_handler will abort if it fails. Exception are disabled and
   // we don't support the case of a new_handler throwing std::bad_balloc.
   return true;
+#endif
 }
 
 inline const allocator::AllocatorDispatch* GetChainHead() {
   // TODO(primiano): Just use NoBarrier_Load once crbug.com/593344 is fixed.
   // Unfortunately due to that bug NoBarrier_Load() is mistakenly fully
   // barriered on Linux+Clang, and that causes visible perf regressons.
   return reinterpret_cast<const allocator::AllocatorDispatch*>(
 #if defined(OS_LINUX) && defined(__clang__)
       *static_cast<const volatile subtle::AtomicWord*>(&g_chain_head)
 #else
@@ skipping 59 matching lines @@
 //   - If the std::new_handler is set:
 //     - Assume it will abort() if it fails (very likely the new_handler will
 //       just suicide priting a message).
 //     - Assume it did succeed if it returns, in which case reattempt the alloc.
 
 void* ShimCppNew(size_t size) {
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
   void* ptr;
   do {
     ptr = chain_head->alloc_function(chain_head, size);
-  } while (!ptr && CallNewHandler());
+  } while (!ptr && CallNewHandler(size));
   return ptr;
 }
 
 void ShimCppDelete(void* address) {
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
   return chain_head->free_function(chain_head, address);
 }
 
 void* ShimMalloc(size_t size) {
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
   void* ptr;
   do {
     ptr = chain_head->alloc_function(chain_head, size);
-  } while (!ptr && g_call_new_handler_on_malloc_failure && CallNewHandler());
+  } while (!ptr && g_call_new_handler_on_malloc_failure &&
+           CallNewHandler(size));
   return ptr;
 }
 
 void* ShimCalloc(size_t n, size_t size) {
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
   void* ptr;
   do {
     ptr = chain_head->alloc_zero_initialized_function(chain_head, n, size);
-  } while (!ptr && g_call_new_handler_on_malloc_failure && CallNewHandler());
+  } while (!ptr && g_call_new_handler_on_malloc_failure &&
+           CallNewHandler(size));
   return ptr;
 }
 
 void* ShimRealloc(void* address, size_t size) {
   // realloc(size == 0) means free() and might return a nullptr. We should
   // not call the std::new_handler in that case, though.
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
   void* ptr;
   do {
     ptr = chain_head->realloc_function(chain_head, address, size);
   } while (!ptr && size && g_call_new_handler_on_malloc_failure &&
-           CallNewHandler());
+           CallNewHandler(size));
   return ptr;
 }
 
 void* ShimMemalign(size_t alignment, size_t size) {
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
   void* ptr;
   do {
     ptr = chain_head->alloc_aligned_function(chain_head, alignment, size);
-  } while (!ptr && g_call_new_handler_on_malloc_failure && CallNewHandler());
+  } while (!ptr && g_call_new_handler_on_malloc_failure &&
+           CallNewHandler(size));
   return ptr;
 }
 
 int ShimPosixMemalign(void** res, size_t alignment, size_t size) {
   // posix_memalign is supposed to check the arguments. See tc_posix_memalign()
   // in tc_malloc.cc.
   if (((alignment % sizeof(void*)) != 0) ||
       ((alignment & (alignment - 1)) != 0) || (alignment == 0)) {
     return EINVAL;
   }
@@ skipping 14 matching lines @@
     size = (size + GetPageSize() - 1) & ~(GetPageSize() - 1);
   }
   return ShimMemalign(GetPageSize(), size);
 }
 
 void ShimFree(void* address) {
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
   return chain_head->free_function(chain_head, address);
 }
 
+#if defined(OS_WIN)
+
+void* (*malloc_unchecked)(size_t) = &base::allocator::UncheckedAlloc;

[Primiano Tucci (use gerrit), 2016/07/15 14:02:10]

To be honest I am not sure I understand all the black magic around
malloc_unchecked in memory_win.cc.
Is malloc_unchecked part of ucrt and we want to re-define it?
If not, can we do a cleaner solution  which is in memory_win.cc

bool UncheckedMalloc(size_t size, void** result) {
#if BUILDFLAG(USE_EXPERIMENTAL_ALLOCATOR_SHIM)
  *result = base::allocator::UncheckedAlloc(size)
#else
  *result = malloc_unchecked(size);
#
  return *result != NULL;
}

But I am really struggling to understand that linker magic there in
memory_win.cc

+
+namespace {
+
+int win_new_mode = 0;
+
+}  // namespace
+
+// This function behaves similarly to MSVC's _set_new_mode.

[Primiano Tucci (use gerrit), 2016/07/12 14:51:05]

I think this block is better placed in the impl.cc file right (and remove the
other copy in the old shim)? They seem identical. also will keep this file
cleaner

[Sigurður Ásgeirsson, 2016/07/14 19:04:27]

There is a small difference in that this one calls SetCallNewHandler. I could
ifdef this, I suppose.

[Primiano Tucci (use gerrit), 2016/07/15 14:02:10]

Oh I see. Ok now I follow it. In windows there is an "official" _set_new_mode,
so the entry point is that one.
SG keeping it separate.
Just at this point you can move all this section to
allocator_shim_override_ucrt_symbols_win.h. This is really defining the extra
windows-specific synmbols required to properly shim allocations on win, so it
feels like this entire section belongs to there.

In practice there should be no difference as that file is included few lines
below here.

+// If flag is 0 (default), calls to malloc will behave normally.
+// If flag is 1, calls to malloc will behave like calls to new,
+// and the std_new_handler will be invoked on failure.
+// Returns the previous mode.
+//
+// Replaces _set_new_mode in ucrt\heap\new_mode.cpp
+int _set_new_mode(int flag) {
+  // The MS CRT calls this function early on in startup, so this serves as a low
+  // overhead proof that the allocator shim is in place for this process.
+  base::allocator::g_is_win_shim_layer_initialized = true;
+  int old_mode = win_new_mode;
+  win_new_mode = flag;
+
+  base::allocator::SetCallNewHandlerOnMallocFailure(win_new_mode != 0);
+
+  return old_mode;
+}
+
+// Replaces _query_new_mode in ucrt\heap\new_mode.cpp
+int _query_new_mode() {
+  return win_new_mode;
+}
+
+#endif
+
 }  // extern "C"
 
+#if !defined(OS_WIN)

[Primiano Tucci (use gerrit), 2016/07/12 14:51:05]

maybe add a comment here explaining that on win the default impl already routes
them to malloc/free and there is no need to redefine them

[Sigurður Ásgeirsson, 2016/07/14 19:04:27]

Done.

 // Cpp symbols (new / delete) should always be routed through the shim layer.
 #include "base/allocator/allocator_shim_override_cpp_symbols.h"
+#endif
 
 // Android does not support symbol interposition. The way malloc symbols are
 // intercepted on Android is by using link-time -wrap flags.
 #if !defined(OS_ANDROID)
 // Ditto for plain malloc() / calloc() / free() etc. symbols.
 #include "base/allocator/allocator_shim_override_libc_symbols.h"
 #else
 #include "base/allocator/allocator_shim_override_linker_wrapped_symbols.h"
 #endif
 
 // In the case of tcmalloc we also want to plumb into the glibc hooks
 // to avoid that allocations made in glibc itself (e.g., strdup()) get
 // accidentally performed on the glibc heap instead of the tcmalloc one.
 #if defined(USE_TCMALLOC)
 #include "base/allocator/allocator_shim_override_glibc_weak_symbols.h"
 #endif
 
 // Cross-checks.
 
 #if defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
 #error The allocator shim should not be compiled when building for memory tools.
 #endif
 
 #if (defined(__GNUC__) && defined(__EXCEPTIONS)) || \
     (defined(_HAS_EXCEPTIONS) && _HAS_EXCEPTIONS)
 #error This code cannot be used when exceptions are turned on.
 #endif