Modify allocator_shim to support _aligned_alloc(), _aligned_free().

base/allocator/allocator_shim.cc

 // Copyright (c) 2012 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 <config.h>
 #include "base/allocator/allocator_extension_thunks.h"
 #include "base/profiler/alternate_timer.h"
 #include "base/sysinfo.h"
@@ skipping 47 matching lines @@
 #include "tcmalloc.cc"
 #include "win_allocator.cc"
 
 // Forward declarations from jemalloc.
 extern "C" {
 void* je_malloc(size_t s);
 void* je_realloc(void* p, size_t s);
 void je_free(void* s);
 size_t je_msize(void* p);
 bool je_malloc_init_hard();
+void* je_memalign(size_t a, size_t s);
 }
 
 extern "C" {
 
 // Call the new handler, if one has been set.
 // Returns true on successfully calling the handler, false otherwise.
 inline bool call_new_handler(bool nothrow) {
   // Get the current new handler.  NB: this function is not
   // thread-safe.  We make a feeble stab at making it so here, but
   // this lock only protects against tcmalloc interfering with
@@ skipping 214 matching lines @@
 
 // The CRT heap cleanup stub.
 extern "C" void _heap_term() {}
 
 // We set this to 1 because part of the CRT uses a check of _crtheap != 0
 // to test whether the CRT has been initialized.  Once we've ripped out
 // the allocators from libcmt, we need to provide this definition so that
 // the rest of the CRT is still usable.
 extern "C" void* _crtheap = reinterpret_cast<void*>(1);
 
+// Provide support for aligned memory through Windows only _aligned_malloc().
+void* _aligned_malloc(size_t size, size_t alignment) {
+  void* ptr;
+  for (;;) {
+#ifdef ENABLE_DYNAMIC_ALLOCATOR_SWITCHING
+    switch (allocator) {
+      case JEMALLOC:
+        ptr = je_memalign(alignment, size);
+        break;
+      case WINHEAP:
+      case WINLFH:
+        ptr = win_heap_memalign(alignment, size);
+        break;
+      case TCMALLOC:
+      default:
+        ptr = tc_memalign(alignment, size);
+        break;
+    }
+#else
+    // TCMalloc case.
+    ptr = tc_memalign(alignment, size);
+#endif
+    if (ptr)
+      return ptr;
+
+    if (!new_mode || !call_new_handler(true))
+      break;
+  }
+  return ptr;
+}
+
+void _aligned_free(void* p) {
+#ifdef ENABLE_DYNAMIC_ALLOCATOR_SWITCHING
+  switch (allocator) {
+    case JEMALLOC:
+      je_free(p);
+      return;
+    case WINHEAP:
+    case WINLFH:
+      win_heap_memalign_free(p);
+      return;
+  }
+#endif
+  // TCMalloc case.
+  do_free(p);
+}
+
 #endif  // WIN32
 
 #include "generic_allocators.cc"
 
 }  // extern C
 
 namespace base {
 namespace allocator {
 
 void SetupSubprocessAllocator() {
@@ skipping 23 matching lines @@
 void TCMallocDoFreeForTest(void* ptr) {
   do_free(ptr);
 }
 
 size_t ExcludeSpaceForMarkForTest(size_t size) {
   return ExcludeSpaceForMark(size);
 }
 
 }  // namespace allocator.
 }  // namespace base.