allocator: Fix function type mismatch in allocator function definitions.

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 <new>
 
@@ skipping 124 matching lines @@
 void RemoveAllocatorDispatchForTesting(AllocatorDispatch* dispatch) {
   DCHECK_EQ(GetChainHead(), dispatch);
   subtle::NoBarrier_Store(&g_chain_head,
                           reinterpret_cast<subtle::AtomicWord>(dispatch->next));
 }
 
 }  // namespace allocator
 }  // namespace base
 
 // The Shim* functions below are the entry-points into the shim-layer and
-// are supposed to be invoked / aliased by the allocator_shim_override_*
+// are supposed to be invoked by the allocator_shim_override_*
 // headers to route the malloc / new symbols through the shim layer.
+// They are defined as ALWAYS_INLINE in order to remove a level of indirection
+// between the system-defined entry points and the shim implementations.
 extern "C" {
 
 // The general pattern for allocations is:
 // - Try to allocate, if succeded return the pointer.
 // - If the allocation failed:
 //   - Call the std::new_handler if it was a C++ allocation.
 //   - Call the std::new_handler if it was a malloc() (or calloc() or similar)
 //     AND SetCallNewHandlerOnMallocFailure(true).
 //   - If the std::new_handler is NOT set just return nullptr.
 //   - 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) {
+ALWAYS_INLINE void* ShimCppNew(size_t size) {
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
   void* ptr;
   do {
     void* context = nullptr;
 #if defined(OS_MACOSX)
     context = malloc_default_zone();
 #endif
     ptr = chain_head->alloc_function(chain_head, size, context);
   } while (!ptr && CallNewHandler(size));
   return ptr;
 }
 
-void ShimCppDelete(void* address) {
+ALWAYS_INLINE void ShimCppDelete(void* address) {
   void* context = nullptr;
 #if defined(OS_MACOSX)
   context = malloc_default_zone();
 #endif
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
   return chain_head->free_function(chain_head, address, context);
 }
 
-void* ShimMalloc(size_t size, void* context) {
+ALWAYS_INLINE void* ShimMalloc(size_t size, void* context) {
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
   void* ptr;
   do {
     ptr = chain_head->alloc_function(chain_head, size, context);
   } while (!ptr && g_call_new_handler_on_malloc_failure &&
            CallNewHandler(size));
   return ptr;
 }
 
-void* ShimCalloc(size_t n, size_t size, void* context) {
+ALWAYS_INLINE void* ShimCalloc(size_t n, size_t size, void* context) {
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
   void* ptr;
   do {
     ptr = chain_head->alloc_zero_initialized_function(chain_head, n, size,
                                                       context);
   } while (!ptr && g_call_new_handler_on_malloc_failure &&
            CallNewHandler(size));
   return ptr;
 }
 
-void* ShimRealloc(void* address, size_t size, void* context) {
+ALWAYS_INLINE void* ShimRealloc(void* address, size_t size, void* context) {
   // 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, context);
   } while (!ptr && size && g_call_new_handler_on_malloc_failure &&
            CallNewHandler(size));
   return ptr;
 }
 
-void* ShimMemalign(size_t alignment, size_t size, void* context) {
+ALWAYS_INLINE void* ShimMemalign(size_t alignment, size_t size, void* context) {
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
   void* ptr;
   do {
     ptr = chain_head->alloc_aligned_function(chain_head, alignment, size,
                                              context);
   } while (!ptr && g_call_new_handler_on_malloc_failure &&
            CallNewHandler(size));
   return ptr;
 }
 
-int ShimPosixMemalign(void** res, size_t alignment, size_t size) {
+ALWAYS_INLINE 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;
   }
   void* ptr = ShimMemalign(alignment, size, nullptr);
   *res = ptr;
   return ptr ? 0 : ENOMEM;
 }
 
-void* ShimValloc(size_t size, void* context) {
+ALWAYS_INLINE void* ShimValloc(size_t size, void* context) {
   return ShimMemalign(GetCachedPageSize(), size, context);
 }
 
-void* ShimPvalloc(size_t size) {
+ALWAYS_INLINE void* ShimPvalloc(size_t size) {
   // pvalloc(0) should allocate one page, according to its man page.
   if (size == 0) {
     size = GetCachedPageSize();
   } else {
     size = (size + GetCachedPageSize() - 1) & ~(GetCachedPageSize() - 1);
   }
   // The third argument is nullptr because pvalloc is glibc only and does not
   // exist on OSX/BSD systems.
   return ShimMemalign(GetCachedPageSize(), size, nullptr);
 }
 
-void ShimFree(void* address, void* context) {
+ALWAYS_INLINE void ShimFree(void* address, void* context) {
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
   return chain_head->free_function(chain_head, address, context);
 }
 
-size_t ShimGetSizeEstimate(const void* address, void* context) {
+ALWAYS_INLINE size_t ShimGetSizeEstimate(const void* address, void* context) {
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
   return chain_head->get_size_estimate_function(
       chain_head, const_cast<void*>(address), context);
 }
 
-unsigned ShimBatchMalloc(size_t size,
-                         void** results,
-                         unsigned num_requested,
-                         void* context) {
+ALWAYS_INLINE unsigned ShimBatchMalloc(size_t size,
+                                       void** results,
+                                       unsigned num_requested,
+                                       void* context) {
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
   return chain_head->batch_malloc_function(chain_head, size, results,
                                            num_requested, context);
 }
 
-void ShimBatchFree(void** to_be_freed,
-                   unsigned num_to_be_freed,
-                   void* context) {
+ALWAYS_INLINE void ShimBatchFree(void** to_be_freed,
+                                 unsigned num_to_be_freed,
+                                 void* context) {
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
   return chain_head->batch_free_function(chain_head, to_be_freed,
                                          num_to_be_freed, context);
 }
 
-void ShimFreeDefiniteSize(void* ptr, size_t size, void* context) {
+ALWAYS_INLINE void ShimFreeDefiniteSize(void* ptr, size_t size, void* context) {
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
   return chain_head->free_definite_size_function(chain_head, ptr, size,
                                                  context);
 }
 
 }  // extern "C"
 
 #if !defined(OS_WIN) && !defined(OS_MACOSX)
 // Cpp symbols (new / delete) should always be routed through the shim layer
 // except on Windows and macOS where the malloc intercept is deep enough that it
@@ skipping 41 matching lines @@
 // 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