#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 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();
jit.jump(GPRInfo::returnValueGPR);
jit.breakpoint();
ThrowWasmException throwWasmException = Thunks::singleton().throwWasmException();
RELEASE_ASSERT(throwWasmException);
LinkBuffer linkBuffer(jit, GLOBAL_THUNK_ID);
linkBuffer.link(call, FunctionPtr(throwWasmException));
return FINALIZE_CODE(linkBuffer, ("Throw exception from Wasm"));
}
MacroAssemblerCodeRef 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(Thunks::singleton().stub(locker, throwExceptionFromWasmThunkGenerator).code()));
return FINALIZE_CODE(linkBuffer, ("Throw stack overflow from Wasm"));
}
MacroAssemblerCodeRef triggerOMGTierUpThunkGenerator(const AbstractLocker&)
{
CCallHelpers jit;
const unsigned extraPaddingBytes = 0;
RegisterSet registersToSpill = RegisterSet::allRegisters();
registersToSpill.exclude(RegisterSet::registersToNotSaveForCCall());
#if CPU(ARM64)
registersToSpill.set(ARM64Registers::x30);
#endif
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(reinterpret_cast<void*>(run)), GPRInfo::argumentGPR2);
jit.call(GPRInfo::argumentGPR2);
ScratchRegisterAllocator::restoreRegistersFromStackForCall(jit, registersToSpill, RegisterSet(), numberOfStackBytesUsedForRegisterPreservation, extraPaddingBytes);
jit.ret();
LinkBuffer linkBuffer(jit, GLOBAL_THUNK_ID);
return FINALIZE_CODE(linkBuffer, ("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 Thunks::stub(ThunkGenerator generator)
{
auto locker = holdLock(m_lock);
return stub(locker, generator);
}
MacroAssemblerCodeRef Thunks::stub(const AbstractLocker& locker, ThunkGenerator generator)
{
ASSERT(!!generator);
{
auto addResult = m_stubs.add(generator, MacroAssemblerCodeRef());
if (!addResult.isNewEntry)
return addResult.iterator->value;
}
MacroAssemblerCodeRef code = generator(locker);
m_stubs.set(generator, code);
return code;
}
MacroAssemblerCodeRef 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();
}
} }
#endif // ENABLE(WEBASSEMBLY)