#pragma once
#include <wtf/ExportMacros.h>
#include <wtf/Platform.h>
#if ENABLE(MALLOC_HEAP_BREAKDOWN)
#include <mutex>
#if OS(DARWIN)
#include <malloc/malloc.h>
#endif
#endif
namespace WTF {
#if ENABLE(MALLOC_HEAP_BREAKDOWN)
class DebugHeap {
public:
WTF_EXPORT_PRIVATE DebugHeap(const char* heapName);
WTF_EXPORT_PRIVATE void* malloc(size_t);
WTF_EXPORT_PRIVATE void* calloc(size_t numElements, size_t elementSize);
WTF_EXPORT_PRIVATE void* memalign(size_t alignment, size_t, bool crashOnFailure);
WTF_EXPORT_PRIVATE void* realloc(void*, size_t);
WTF_EXPORT_PRIVATE void free(void*);
private:
#if OS(DARWIN)
malloc_zone_t* m_zone;
#endif
};
#define DECLARE_ALLOCATOR_WITH_HEAP_IDENTIFIER(Type) \
struct Type##Malloc { \
static WTF_EXPORT_PRIVATE WTF::DebugHeap& debugHeap(); \
\
static void* malloc(size_t size) { return debugHeap().malloc(size); } \
\
static void* tryMalloc(size_t size) { return debugHeap().malloc(size); } \
\
static void* zeroedMalloc(size_t size) { return debugHeap().calloc(1, size); } \
\
static void* tryZeroedMalloc(size_t size) { return debugHeap().calloc(1, size); } \
\
static void* realloc(void* p, size_t size) { return debugHeap().realloc(p, size); } \
\
static void* tryRealloc(void* p, size_t size) { return debugHeap().realloc(p, size); } \
\
static void free(void* p) { debugHeap().free(p); } \
}
#define DEFINE_ALLOCATOR_WITH_HEAP_IDENTIFIER(Type) \
WTF::DebugHeap& Type##Malloc::debugHeap() \
{ \
static LazyNeverDestroyed<WTF::DebugHeap> heap; \
static std::once_flag onceKey; \
std::call_once(onceKey, [&] { \
heap.construct(#Type); \
}); \
return heap; \
} \
struct MakeDebugHeapMallocedImplMacroSemicolonifier##Type { }
#else // ENABLE(MALLOC_HEAP_BREAKDOWN)
#define DECLARE_ALLOCATOR_WITH_HEAP_IDENTIFIER(Type) \
using Type##Malloc = FastMalloc
#define DEFINE_ALLOCATOR_WITH_HEAP_IDENTIFIER(Type) \
struct MakeDebugHeapMallocedImplMacroSemicolonifier##Type { }
#endif
}