JSWebAssemblyMemory.cpp [plain text]
#include "config.h"
#include "JSWebAssemblyMemory.h"
#if ENABLE(WEBASSEMBLY)
#include "JSCInlines.h"
#include "ArrayBuffer.h"
#include "JSArrayBuffer.h"
namespace JSC {
const ClassInfo JSWebAssemblyMemory::s_info = { "WebAssembly.Memory", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSWebAssemblyMemory) };
JSWebAssemblyMemory* JSWebAssemblyMemory::create(ExecState* exec, VM& vm, Structure* structure)
{
auto throwScope = DECLARE_THROW_SCOPE(vm);
auto* globalObject = exec->lexicalGlobalObject();
auto exception = [&] (JSObject* error) {
throwException(exec, throwScope, error);
return nullptr;
};
if (!globalObject->webAssemblyEnabled())
return exception(createEvalError(exec, globalObject->webAssemblyDisabledErrorMessage()));
auto* memory = new (NotNull, allocateCell<JSWebAssemblyMemory>(vm.heap)) JSWebAssemblyMemory(vm, structure);
memory->finishCreation(vm);
return memory;
}
void JSWebAssemblyMemory::adopt(Ref<Wasm::Memory>&& memory)
{
m_memory.swap(memory);
ASSERT(m_memory->refCount() == 1);
m_memory->check();
}
Structure* JSWebAssemblyMemory::createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
{
return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info());
}
JSWebAssemblyMemory::JSWebAssemblyMemory(VM& vm, Structure* structure)
: Base(vm, structure)
, m_memory(Wasm::Memory::create().releaseNonNull())
{
}
JSArrayBuffer* JSWebAssemblyMemory::buffer(VM& vm, JSGlobalObject* globalObject)
{
if (m_bufferWrapper)
return m_bufferWrapper.get();
Ref<Wasm::Memory> protectedMemory = m_memory.get();
auto destructor = [protectedMemory = WTFMove(protectedMemory)] (void*) { };
m_buffer = ArrayBuffer::createFromBytes(memory().memory(), memory().size(), WTFMove(destructor));
m_buffer->makeWasmMemory();
m_bufferWrapper.set(vm, this, JSArrayBuffer::create(vm, globalObject->m_arrayBufferStructure.get(), m_buffer.get()));
RELEASE_ASSERT(m_bufferWrapper);
return m_bufferWrapper.get();
}
Wasm::PageCount JSWebAssemblyMemory::grow(VM& vm, ExecState* exec, uint32_t delta)
{
auto throwScope = DECLARE_THROW_SCOPE(vm);
auto grown = memory().grow(Wasm::PageCount(delta));
if (!grown) {
switch (grown.error()) {
case Wasm::Memory::GrowFailReason::InvalidDelta:
throwException(exec, throwScope, createRangeError(exec, ASCIILiteral("WebAssembly.Memory.grow expects the delta to be a valid page count")));
break;
case Wasm::Memory::GrowFailReason::InvalidGrowSize:
throwException(exec, throwScope, createRangeError(exec, ASCIILiteral("WebAssembly.Memory.grow expects the grown size to be a valid page count")));
break;
case Wasm::Memory::GrowFailReason::WouldExceedMaximum:
throwException(exec, throwScope, createRangeError(exec, ASCIILiteral("WebAssembly.Memory.grow would exceed the memory's declared maximum size")));
break;
case Wasm::Memory::GrowFailReason::OutOfMemory:
throwException(exec, throwScope, createOutOfMemoryError(exec));
break;
}
return Wasm::PageCount();
}
return grown.value();
}
void JSWebAssemblyMemory::growSuccessCallback(VM& vm, Wasm::PageCount oldPageCount, Wasm::PageCount newPageCount)
{
if (m_buffer) {
m_buffer->neuter(vm);
m_buffer = nullptr;
m_bufferWrapper.clear();
}
memory().check();
vm.heap.reportExtraMemoryAllocated(newPageCount.bytes() - oldPageCount.bytes());
}
void JSWebAssemblyMemory::finishCreation(VM& vm)
{
Base::finishCreation(vm);
ASSERT(inherits(vm, info()));
heap()->reportExtraMemoryAllocated(memory().size());
}
void JSWebAssemblyMemory::destroy(JSCell* cell)
{
auto memory = static_cast<JSWebAssemblyMemory*>(cell);
ASSERT(memory->classInfo() == info());
memory->JSWebAssemblyMemory::~JSWebAssemblyMemory();
}
void JSWebAssemblyMemory::visitChildren(JSCell* cell, SlotVisitor& visitor)
{
auto* thisObject = jsCast<JSWebAssemblyMemory*>(cell);
ASSERT_GC_OBJECT_INHERITS(thisObject, info());
Base::visitChildren(thisObject, visitor);
visitor.append(thisObject->m_bufferWrapper);
visitor.reportExtraMemoryVisited(thisObject->memory().size());
}
}
#endif // ENABLE(WEBASSEMBLY)