#ifndef WTF_FastMallocWinCE_h
#define WTF_FastMallocWinCE_h
#include <new.h>
#ifdef __cplusplus
#include <new>
#include "MemoryManager.h"
extern "C" {
#endif
void* fastMalloc(size_t n);
void* fastCalloc(size_t n_elements, size_t element_size);
void fastFree(void* p);
void* fastRealloc(void* p, size_t n);
void* fastZeroedMalloc(size_t n);
void* tryFastMalloc(size_t n);
void* tryFastZeroedMalloc(size_t n);
void* tryFastCalloc(size_t n_elements, size_t element_size);
void* tryFastRealloc(void* p, size_t n);
char* fastStrDup(const char*);
#ifndef NDEBUG
void fastMallocForbid();
void fastMallocAllow();
#endif
#if !defined(USE_SYSTEM_MALLOC) || !USE_SYSTEM_MALLOC
#define malloc(n) fastMalloc(n)
#define calloc(n_elements, element_size) fastCalloc(n_elements, element_size)
#define realloc(p, n) fastRealloc(p, n)
#define free(p) fastFree(p)
#define strdup(p) fastStrDup(p)
#else
#define strdup(p) _strdup(p)
#endif
#ifdef __cplusplus
}
#endif
#ifdef __cplusplus
#if !defined(USE_SYSTEM_MALLOC) || !USE_SYSTEM_MALLOC
static inline void* __cdecl operator new(size_t s) { return fastMalloc(s); }
static inline void __cdecl operator delete(void* p) { fastFree(p); }
static inline void* __cdecl operator new[](size_t s) { return fastMalloc(s); }
static inline void __cdecl operator delete[](void* p) { fastFree(p); }
static inline void* operator new(size_t s, const std::nothrow_t&) throw() { return fastMalloc(s); }
static inline void operator delete(void* p, const std::nothrow_t&) throw() { fastFree(p); }
static inline void* operator new[](size_t s, const std::nothrow_t&) throw() { return fastMalloc(s); }
static inline void operator delete[](void* p, const std::nothrow_t&) throw() { fastFree(p); }
#endif
namespace WTF {
typedef unsigned long long AllocAlignmentInteger;
namespace Internal {
enum AllocType { AllocTypeMalloc = 0x375d6750, AllocTypeClassNew, AllocTypeClassNewArray, AllocTypeFastNew, AllocTypeFastNewArray, AllocTypeNew, AllocTypeNewArray };
}
#if ENABLE(FAST_MALLOC_MATCH_VALIDATION)
namespace Internal {
inline AllocType fastMallocMatchValidationType(const void* p)
{
const AllocAlignmentInteger* type = static_cast<const AllocAlignmentInteger*>(p) - 1;
return static_cast<AllocType>(*type);
}
inline AllocAlignmentInteger* fastMallocMatchValidationValue(void* p)
{
return reinterpret_cast<AllocAlignmentInteger*>(static_cast<char*>(p) - sizeof(AllocAlignmentInteger));
}
inline void setFastMallocMatchValidationType(void* p, AllocType allocType)
{
AllocAlignmentInteger* type = static_cast<AllocAlignmentInteger*>(p) - 1;
*type = static_cast<AllocAlignmentInteger>(allocType);
}
void fastMallocMatchFailed(void* p);
}
inline void fastMallocMatchValidateMalloc(void* p, Internal::AllocType allocType)
{
if (!p)
return;
Internal::setFastMallocMatchValidationType(p, allocType);
}
inline void fastMallocMatchValidateFree(void* p, Internal::AllocType allocType)
{
if (!p)
return;
if (Internal::fastMallocMatchValidationType(p) != allocType)
Internal::fastMallocMatchFailed(p);
Internal::setFastMallocMatchValidationType(p, Internal::AllocTypeMalloc); }
#else
inline void fastMallocMatchValidateMalloc(void*, Internal::AllocType)
{
}
inline void fastMallocMatchValidateFree(void*, Internal::AllocType)
{
}
#endif
}
#endif
#endif // WTF_FastMallocWinCE_h