#pragma once
#include <wtf/FastMalloc.h>
#if defined(USE_SYSTEM_MALLOC) && USE_SYSTEM_MALLOC
#define GIGACAGE_ENABLED 0
#define PRIMITIVE_GIGACAGE_MASK 0
#define JSVALUE_GIGACAGE_MASK 0
#define GIGACAGE_BASE_PTRS_SIZE 8192
extern "C" {
alignas(void*) extern WTF_EXPORT_PRIVATE char g_gigacageBasePtrs[GIGACAGE_BASE_PTRS_SIZE];
}
namespace Gigacage {
struct BasePtrs {
void* primitive;
void* jsValue;
};
enum Kind {
Primitive,
JSValue,
};
inline void ensureGigacage() { }
inline void disablePrimitiveGigacage() { }
inline bool shouldBeEnabled() { return false; }
inline void addPrimitiveDisableCallback(void (*)(void*), void*) { }
inline void removePrimitiveDisableCallback(void (*)(void*), void*) { }
inline void disableDisablingPrimitiveGigacageIfShouldBeEnabled() { }
inline bool isDisablingPrimitiveGigacageDisabled() { return false; }
inline bool isPrimitiveGigacagePermanentlyEnabled() { return false; }
inline bool canPrimitiveGigacageBeDisabled() { return true; }
ALWAYS_INLINE const char* name(Kind kind)
{
switch (kind) {
case Primitive:
return "Primitive";
case JSValue:
return "JSValue";
}
RELEASE_ASSERT_NOT_REACHED();
return nullptr;
}
ALWAYS_INLINE void*& basePtr(BasePtrs& basePtrs, Kind kind)
{
switch (kind) {
case Primitive:
return basePtrs.primitive;
case JSValue:
return basePtrs.jsValue;
}
RELEASE_ASSERT_NOT_REACHED();
return basePtrs.primitive;
}
ALWAYS_INLINE BasePtrs& basePtrs()
{
return *reinterpret_cast<BasePtrs*>(reinterpret_cast<void*>(g_gigacageBasePtrs));
}
ALWAYS_INLINE void*& basePtr(Kind kind)
{
return basePtr(basePtrs(), kind);
}
ALWAYS_INLINE bool isEnabled(Kind kind)
{
return !!basePtr(kind);
}
ALWAYS_INLINE size_t mask(Kind) { return 0; }
template<typename T>
inline T* caged(Kind, T* ptr) { return ptr; }
inline bool isCaged(Kind, const void*) { return false; }
inline void* tryAlignedMalloc(Kind, size_t alignment, size_t size) { return tryFastAlignedMalloc(alignment, size); }
inline void alignedFree(Kind, void* p) { fastAlignedFree(p); }
WTF_EXPORT_PRIVATE void* tryMalloc(Kind, size_t size);
inline void free(Kind, void* p) { fastFree(p); }
WTF_EXPORT_PRIVATE void* tryAllocateZeroedVirtualPages(Kind, size_t size);
WTF_EXPORT_PRIVATE void freeVirtualPages(Kind, void* basePtr, size_t size);
} #else
#include <bmalloc/Gigacage.h>
namespace Gigacage {
WTF_EXPORT_PRIVATE void* tryAlignedMalloc(Kind, size_t alignment, size_t size);
WTF_EXPORT_PRIVATE void alignedFree(Kind, void*);
WTF_EXPORT_PRIVATE void* tryMalloc(Kind, size_t);
WTF_EXPORT_PRIVATE void free(Kind, void*);
WTF_EXPORT_PRIVATE void* tryAllocateZeroedVirtualPages(Kind, size_t size);
WTF_EXPORT_PRIVATE void freeVirtualPages(Kind, void* basePtr, size_t size);
} #endif
namespace Gigacage {
WTF_EXPORT_PRIVATE void* tryMallocArray(Kind, size_t numElements, size_t elementSize);
WTF_EXPORT_PRIVATE void* malloc(Kind, size_t);
WTF_EXPORT_PRIVATE void* mallocArray(Kind, size_t numElements, size_t elementSize);
}