#include "config.h"
#include "WasmThunks.h"
#if ENABLE(WEBASSEMBLY)
#include "CCallHelpers.h"
#include "HeapCellInlines.h"
#include "JITExceptions.h"
#include "LinkBuffer.h"
#include "ScratchRegisterAllocator.h"
#include "WasmContext.h"
#include "WasmExceptionType.h"
#include "WasmInstance.h"
#include "WasmOMGPlan.h"
namespace JSC { namespace Wasm {
MacroAssemblerCodeRef<JITThunkPtrTag> throwExceptionFromWasmThunkGenerator(const AbstractLocker&)
{
CCallHelpers jit;
jit.loadWasmContextInstance(GPRInfo::argumentGPR2);
jit.loadPtr(CCallHelpers::Address(GPRInfo::argumentGPR2, Instance::offsetOfPointerToTopEntryFrame()), GPRInfo::argumentGPR0);
jit.loadPtr(CCallHelpers::Address(GPRInfo::argumentGPR0), GPRInfo::argumentGPR0);
jit.copyCalleeSavesToEntryFrameCalleeSavesBuffer(GPRInfo::argumentGPR0);
jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
CCallHelpers::Call call = jit.call(OperationPtrTag);
jit.jump(GPRInfo::returnValueGPR, ExceptionHandlerPtrTag);
jit.breakpoint();
ThrowWasmException throwWasmException = Thunks::singleton().throwWasmException();
RELEASE_ASSERT(throwWasmException);
LinkBuffer linkBuffer(jit, GLOBAL_THUNK_ID);
linkBuffer.link(call, FunctionPtr<OperationPtrTag>(throwWasmException));
return FINALIZE_CODE(linkBuffer, JITThunkPtrTag, "Throw exception from Wasm");
}
MacroAssemblerCodeRef<JITThunkPtrTag> throwStackOverflowFromWasmThunkGenerator(const AbstractLocker& locker)
{
CCallHelpers jit;
int32_t stackSpace = WTF::roundUpToMultipleOf(stackAlignmentBytes(), RegisterSet::calleeSaveRegisters().numberOfSetRegisters() * sizeof(Register));
ASSERT(static_cast<unsigned>(stackSpace) < Options::softReservedZoneSize());
jit.addPtr(CCallHelpers::TrustedImm32(-stackSpace), GPRInfo::callFrameRegister, MacroAssembler::stackPointerRegister);
jit.move(CCallHelpers::TrustedImm32(static_cast<uint32_t>(ExceptionType::StackOverflow)), GPRInfo::argumentGPR1);
auto jumpToExceptionHandler = jit.jump();
LinkBuffer linkBuffer(jit, GLOBAL_THUNK_ID);
linkBuffer.link(jumpToExceptionHandler, CodeLocationLabel<JITThunkPtrTag>(Thunks::singleton().stub(locker, throwExceptionFromWasmThunkGenerator).code()));
return FINALIZE_CODE(linkBuffer, JITThunkPtrTag, "Throw stack overflow from Wasm");
}
MacroAssemblerCodeRef<JITThunkPtrTag> triggerOMGTierUpThunkGenerator(const AbstractLocker&)
{
CCallHelpers jit;
jit.emitFunctionPrologue();
const unsigned extraPaddingBytes = 0;
RegisterSet registersToSpill = RegisterSet::allRegisters();
registersToSpill.exclude(RegisterSet::registersToNotSaveForCCall());
unsigned numberOfStackBytesUsedForRegisterPreservation = ScratchRegisterAllocator::preserveRegistersToStackForCall(jit, registersToSpill, extraPaddingBytes);
jit.loadWasmContextInstance(GPRInfo::argumentGPR0);
typedef void (*Run)(Instance*, uint32_t);
Run run = OMGPlan::runForIndex;
jit.move(MacroAssembler::TrustedImmPtr(tagCFunctionPtr<OperationPtrTag>(run)), GPRInfo::argumentGPR2);
jit.call(GPRInfo::argumentGPR2, OperationPtrTag);
ScratchRegisterAllocator::restoreRegistersFromStackForCall(jit, registersToSpill, RegisterSet(), numberOfStackBytesUsedForRegisterPreservation, extraPaddingBytes);
jit.emitFunctionEpilogue();
jit.ret();
LinkBuffer linkBuffer(jit, GLOBAL_THUNK_ID);
return FINALIZE_CODE(linkBuffer, JITThunkPtrTag, "Trigger OMG tier up");
}
static Thunks* thunks;
void Thunks::initialize()
{
thunks = new Thunks;
}
Thunks& Thunks::singleton()
{
ASSERT(thunks);
return *thunks;
}
void Thunks::setThrowWasmException(ThrowWasmException throwWasmException)
{
auto locker = holdLock(m_lock);
RELEASE_ASSERT(!m_throwWasmException || m_throwWasmException == throwWasmException);
m_throwWasmException = throwWasmException;
}
ThrowWasmException Thunks::throwWasmException()
{
return m_throwWasmException;
}
MacroAssemblerCodeRef<JITThunkPtrTag> Thunks::stub(ThunkGenerator generator)
{
auto locker = holdLock(m_lock);
return stub(locker, generator);
}
MacroAssemblerCodeRef<JITThunkPtrTag> Thunks::stub(const AbstractLocker& locker, ThunkGenerator generator)
{
ASSERT(!!generator);
{
auto addResult = m_stubs.add(generator, MacroAssemblerCodeRef<JITThunkPtrTag>());
if (!addResult.isNewEntry)
return addResult.iterator->value;
}
MacroAssemblerCodeRef<JITThunkPtrTag> code = generator(locker);
m_stubs.set(generator, code);
return code;
}
MacroAssemblerCodeRef<JITThunkPtrTag> Thunks::existingStub(ThunkGenerator generator)
{
auto locker = holdLock(m_lock);
auto iter = m_stubs.find(generator);
if (iter != m_stubs.end())
return iter->value;
return MacroAssemblerCodeRef<JITThunkPtrTag>();
}
} }
#endif // ENABLE(WEBASSEMBLY)