Index: third_party/tcmalloc/chromium/src/gperftools/malloc_hook.h |
=================================================================== |
--- third_party/tcmalloc/chromium/src/gperftools/malloc_hook.h (revision 124832) |
+++ third_party/tcmalloc/chromium/src/gperftools/malloc_hook.h (working copy) |
@@ -1,358 +0,0 @@ |
-// Copyright (c) 2005, 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 |
-// copyright notice, this list of conditions and the following disclaimer |
-// in the documentation and/or other materials provided with the |
-// distribution. |
-// * Neither the name of Google Inc. nor the names of its |
-// contributors may be used to endorse or promote products derived from |
-// this software without specific prior written permission. |
-// |
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
- |
-// --- |
-// Author: Sanjay Ghemawat |
-// |
-// Some of our malloc implementations can invoke the following hooks whenever |
-// memory is allocated or deallocated. MallocHook is thread-safe, and things |
-// you do before calling AddFooHook(MyHook) are visible to any resulting calls |
-// to MyHook. Hooks must be thread-safe. If you write: |
-// |
-// CHECK(MallocHook::AddNewHook(&MyNewHook)); |
-// |
-// MyNewHook will be invoked in subsequent calls in the current thread, but |
-// there are no guarantees on when it might be invoked in other threads. |
-// |
-// There are a limited number of slots available for each hook type. Add*Hook |
-// will return false if there are no slots available. Remove*Hook will return |
-// false if the given hook was not already installed. |
-// |
-// The order in which individual hooks are called in Invoke*Hook is undefined. |
-// |
-// It is safe for a hook to remove itself within Invoke*Hook and add other |
-// hooks. Any hooks added inside a hook invocation (for the same hook type) |
-// will not be invoked for the current invocation. |
-// |
-// One important user of these hooks is the heap profiler. |
-// |
-// CAVEAT: If you add new MallocHook::Invoke* calls then those calls must be |
-// directly in the code of the (de)allocation function that is provided to the |
-// user and that function must have an ATTRIBUTE_SECTION(malloc_hook) attribute. |
-// |
-// Note: the Invoke*Hook() functions are defined in malloc_hook-inl.h. If you |
-// need to invoke a hook (which you shouldn't unless you're part of tcmalloc), |
-// be sure to #include malloc_hook-inl.h in addition to malloc_hook.h. |
-// |
-// NOTE FOR C USERS: If you want to use malloc_hook functionality from |
-// a C program, #include malloc_hook_c.h instead of this file. |
- |
-#ifndef _MALLOC_HOOK_H_ |
-#define _MALLOC_HOOK_H_ |
- |
-#include <stddef.h> |
-#include <sys/types.h> |
-extern "C" { |
-#include <gperftools/malloc_hook_c.h> // a C version of the malloc_hook interface |
-} |
- |
-// Annoying stuff for windows -- makes sure clients can import these functions |
-#ifndef PERFTOOLS_DLL_DECL |
-# ifdef _WIN32 |
-# define PERFTOOLS_DLL_DECL __declspec(dllimport) |
-# else |
-# define PERFTOOLS_DLL_DECL |
-# endif |
-#endif |
- |
-// The C++ methods below call the C version (MallocHook_*), and thus |
-// convert between an int and a bool. Windows complains about this |
-// (a "performance warning") which we don't care about, so we suppress. |
-#ifdef _MSC_VER |
-#pragma warning(push) |
-#pragma warning(disable:4800) |
-#endif |
- |
-// Note: malloc_hook_c.h defines MallocHook_*Hook and |
-// MallocHook_{Add,Remove}*Hook. The version of these inside the MallocHook |
-// class are defined in terms of the malloc_hook_c version. See malloc_hook_c.h |
-// for details of these types/functions. |
- |
-class PERFTOOLS_DLL_DECL MallocHook { |
- public: |
- // The NewHook is invoked whenever an object is allocated. |
- // It may be passed NULL if the allocator returned NULL. |
- typedef MallocHook_NewHook NewHook; |
- inline static bool AddNewHook(NewHook hook) { |
- return MallocHook_AddNewHook(hook); |
- } |
- inline static bool RemoveNewHook(NewHook hook) { |
- return MallocHook_RemoveNewHook(hook); |
- } |
- inline static void InvokeNewHook(const void* p, size_t s); |
- |
- // The DeleteHook is invoked whenever an object is deallocated. |
- // It may be passed NULL if the caller is trying to delete NULL. |
- typedef MallocHook_DeleteHook DeleteHook; |
- inline static bool AddDeleteHook(DeleteHook hook) { |
- return MallocHook_AddDeleteHook(hook); |
- } |
- inline static bool RemoveDeleteHook(DeleteHook hook) { |
- return MallocHook_RemoveDeleteHook(hook); |
- } |
- inline static void InvokeDeleteHook(const void* p); |
- |
- // The PreMmapHook is invoked with mmap or mmap64 arguments just |
- // before the call is actually made. Such a hook may be useful |
- // in memory limited contexts, to catch allocations that will exceed |
- // a memory limit, and take outside actions to increase that limit. |
- typedef MallocHook_PreMmapHook PreMmapHook; |
- inline static bool AddPreMmapHook(PreMmapHook hook) { |
- return MallocHook_AddPreMmapHook(hook); |
- } |
- inline static bool RemovePreMmapHook(PreMmapHook hook) { |
- return MallocHook_RemovePreMmapHook(hook); |
- } |
- inline static void InvokePreMmapHook(const void* start, |
- size_t size, |
- int protection, |
- int flags, |
- int fd, |
- off_t offset); |
- |
- // The MmapReplacement is invoked after the PreMmapHook but before |
- // the call is actually made. The MmapReplacement should return true |
- // if it handled the call, or false if it is still necessary to |
- // call mmap/mmap64. |
- // This should be used only by experts, and users must be be |
- // extremely careful to avoid recursive calls to mmap. The replacement |
- // should be async signal safe. |
- // Only one MmapReplacement is supported. After setting an MmapReplacement |
- // you must call RemoveMmapReplacement before calling SetMmapReplacement |
- // again. |
- typedef MallocHook_MmapReplacement MmapReplacement; |
- inline static bool SetMmapReplacement(MmapReplacement hook) { |
- return MallocHook_SetMmapReplacement(hook); |
- } |
- inline static bool RemoveMmapReplacement(MmapReplacement hook) { |
- return MallocHook_RemoveMmapReplacement(hook); |
- } |
- inline static bool InvokeMmapReplacement(const void* start, |
- size_t size, |
- int protection, |
- int flags, |
- int fd, |
- off_t offset, |
- void** result); |
- |
- |
- // The MmapHook is invoked whenever a region of memory is mapped. |
- // It may be passed MAP_FAILED if the mmap failed. |
- typedef MallocHook_MmapHook MmapHook; |
- inline static bool AddMmapHook(MmapHook hook) { |
- return MallocHook_AddMmapHook(hook); |
- } |
- inline static bool RemoveMmapHook(MmapHook hook) { |
- return MallocHook_RemoveMmapHook(hook); |
- } |
- inline static void InvokeMmapHook(const void* result, |
- const void* start, |
- size_t size, |
- int protection, |
- int flags, |
- int fd, |
- off_t offset); |
- |
- // The MunmapReplacement is invoked with munmap arguments just before |
- // the call is actually made. The MunmapReplacement should return true |
- // if it handled the call, or false if it is still necessary to |
- // call munmap. |
- // This should be used only by experts. The replacement should be |
- // async signal safe. |
- // Only one MunmapReplacement is supported. After setting an |
- // MunmapReplacement you must call RemoveMunmapReplacement before |
- // calling SetMunmapReplacement again. |
- typedef MallocHook_MunmapReplacement MunmapReplacement; |
- inline static bool SetMunmapReplacement(MunmapReplacement hook) { |
- return MallocHook_SetMunmapReplacement(hook); |
- } |
- inline static bool RemoveMunmapReplacement(MunmapReplacement hook) { |
- return MallocHook_RemoveMunmapReplacement(hook); |
- } |
- inline static bool InvokeMunmapReplacement(const void* p, |
- size_t size, |
- int* result); |
- |
- // The MunmapHook is invoked whenever a region of memory is unmapped. |
- typedef MallocHook_MunmapHook MunmapHook; |
- inline static bool AddMunmapHook(MunmapHook hook) { |
- return MallocHook_AddMunmapHook(hook); |
- } |
- inline static bool RemoveMunmapHook(MunmapHook hook) { |
- return MallocHook_RemoveMunmapHook(hook); |
- } |
- inline static void InvokeMunmapHook(const void* p, size_t size); |
- |
- // The MremapHook is invoked whenever a region of memory is remapped. |
- typedef MallocHook_MremapHook MremapHook; |
- inline static bool AddMremapHook(MremapHook hook) { |
- return MallocHook_AddMremapHook(hook); |
- } |
- inline static bool RemoveMremapHook(MremapHook hook) { |
- return MallocHook_RemoveMremapHook(hook); |
- } |
- inline static void InvokeMremapHook(const void* result, |
- const void* old_addr, |
- size_t old_size, |
- size_t new_size, |
- int flags, |
- const void* new_addr); |
- |
- // The PreSbrkHook is invoked just before sbrk is called -- except when |
- // the increment is 0. This is because sbrk(0) is often called |
- // to get the top of the memory stack, and is not actually a |
- // memory-allocation call. It may be useful in memory-limited contexts, |
- // to catch allocations that will exceed the limit and take outside |
- // actions to increase such a limit. |
- typedef MallocHook_PreSbrkHook PreSbrkHook; |
- inline static bool AddPreSbrkHook(PreSbrkHook hook) { |
- return MallocHook_AddPreSbrkHook(hook); |
- } |
- inline static bool RemovePreSbrkHook(PreSbrkHook hook) { |
- return MallocHook_RemovePreSbrkHook(hook); |
- } |
- inline static void InvokePreSbrkHook(std::ptrdiff_t increment); |
- |
- // The SbrkHook is invoked whenever sbrk is called -- except when |
- // the increment is 0. This is because sbrk(0) is often called |
- // to get the top of the memory stack, and is not actually a |
- // memory-allocation call. |
- typedef MallocHook_SbrkHook SbrkHook; |
- inline static bool AddSbrkHook(SbrkHook hook) { |
- return MallocHook_AddSbrkHook(hook); |
- } |
- inline static bool RemoveSbrkHook(SbrkHook hook) { |
- return MallocHook_RemoveSbrkHook(hook); |
- } |
- inline static void InvokeSbrkHook(const void* result, std::ptrdiff_t increment); |
- |
- // Get the current stack trace. Try to skip all routines up to and |
- // and including the caller of MallocHook::Invoke*. |
- // Use "skip_count" (similarly to GetStackTrace from stacktrace.h) |
- // as a hint about how many routines to skip if better information |
- // is not available. |
- inline static int GetCallerStackTrace(void** result, int max_depth, |
- int skip_count) { |
- return MallocHook_GetCallerStackTrace(result, max_depth, skip_count); |
- } |
- |
- // Unhooked versions of mmap() and munmap(). These should be used |
- // only by experts, since they bypass heapchecking, etc. |
- // Note: These do not run hooks, but they still use the MmapReplacement |
- // and MunmapReplacement. |
- static void* UnhookedMMap(void *start, size_t length, int prot, int flags, |
- int fd, off_t offset); |
- static int UnhookedMUnmap(void *start, size_t length); |
- |
- // The following are DEPRECATED. |
- inline static NewHook GetNewHook(); |
- inline static NewHook SetNewHook(NewHook hook) { |
- return MallocHook_SetNewHook(hook); |
- } |
- |
- inline static DeleteHook GetDeleteHook(); |
- inline static DeleteHook SetDeleteHook(DeleteHook hook) { |
- return MallocHook_SetDeleteHook(hook); |
- } |
- |
- inline static PreMmapHook GetPreMmapHook(); |
- inline static PreMmapHook SetPreMmapHook(PreMmapHook hook) { |
- return MallocHook_SetPreMmapHook(hook); |
- } |
- |
- inline static MmapHook GetMmapHook(); |
- inline static MmapHook SetMmapHook(MmapHook hook) { |
- return MallocHook_SetMmapHook(hook); |
- } |
- |
- inline static MunmapHook GetMunmapHook(); |
- inline static MunmapHook SetMunmapHook(MunmapHook hook) { |
- return MallocHook_SetMunmapHook(hook); |
- } |
- |
- inline static MremapHook GetMremapHook(); |
- inline static MremapHook SetMremapHook(MremapHook hook) { |
- return MallocHook_SetMremapHook(hook); |
- } |
- |
- inline static PreSbrkHook GetPreSbrkHook(); |
- inline static PreSbrkHook SetPreSbrkHook(PreSbrkHook hook) { |
- return MallocHook_SetPreSbrkHook(hook); |
- } |
- |
- inline static SbrkHook GetSbrkHook(); |
- inline static SbrkHook SetSbrkHook(SbrkHook hook) { |
- return MallocHook_SetSbrkHook(hook); |
- } |
- // End of DEPRECATED methods. |
- |
- private: |
- // Slow path versions of Invoke*Hook. |
- static void InvokeNewHookSlow(const void* p, size_t s); |
- static void InvokeDeleteHookSlow(const void* p); |
- static void InvokePreMmapHookSlow(const void* start, |
- size_t size, |
- int protection, |
- int flags, |
- int fd, |
- off_t offset); |
- static void InvokeMmapHookSlow(const void* result, |
- const void* start, |
- size_t size, |
- int protection, |
- int flags, |
- int fd, |
- off_t offset); |
- static bool InvokeMmapReplacementSlow(const void* start, |
- size_t size, |
- int protection, |
- int flags, |
- int fd, |
- off_t offset, |
- void** result); |
- static void InvokeMunmapHookSlow(const void* p, size_t size); |
- static bool InvokeMunmapReplacementSlow(const void* p, |
- size_t size, |
- int* result); |
- static void InvokeMremapHookSlow(const void* result, |
- const void* old_addr, |
- size_t old_size, |
- size_t new_size, |
- int flags, |
- const void* new_addr); |
- static void InvokePreSbrkHookSlow(std::ptrdiff_t increment); |
- static void InvokeSbrkHookSlow(const void* result, std::ptrdiff_t increment); |
-}; |
- |
-#ifdef _MSC_VER |
-#pragma warning(pop) |
-#endif |
- |
- |
-#endif /* _MALLOC_HOOK_H_ */ |