blob: 20998e349ef11337b95b9cca703a4339bc3db50d [file] [log] [blame]
/*
* Copyright (C) 2011-2018 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#if ENABLE(JIT)
#include "CodeBlock.h"
#include "FPRInfo.h"
#include "GPRInfo.h"
#include "Heap.h"
#include "InlineCallFrame.h"
#include "JITAllocator.h"
#include "JITCode.h"
#include "MacroAssembler.h"
#include "MarkedSpace.h"
#include "RegisterAtOffsetList.h"
#include "RegisterSet.h"
#include "StackAlignment.h"
#include "TagRegistersMode.h"
#include "TypeofType.h"
#include "VM.h"
namespace JSC {
typedef void (*V_DebugOperation_EPP)(ExecState*, void*, void*);
class AssemblyHelpers : public MacroAssembler {
public:
AssemblyHelpers(CodeBlock* codeBlock)
: m_codeBlock(codeBlock)
, m_baselineCodeBlock(codeBlock ? codeBlock->baselineAlternative() : 0)
{
if (m_codeBlock) {
ASSERT(m_baselineCodeBlock);
ASSERT(!m_baselineCodeBlock->alternative());
ASSERT(m_baselineCodeBlock->jitType() == JITCode::None || JITCode::isBaselineCode(m_baselineCodeBlock->jitType()));
}
}
CodeBlock* codeBlock() { return m_codeBlock; }
VM& vm() { return *m_codeBlock->vm(); }
AssemblerType_T& assembler() { return m_assembler; }
void checkStackPointerAlignment()
{
// This check is both unneeded and harder to write correctly for ARM64
#if !defined(NDEBUG) && !CPU(ARM64)
Jump stackPointerAligned = branchTestPtr(Zero, stackPointerRegister, TrustedImm32(0xf));
abortWithReason(AHStackPointerMisaligned);
stackPointerAligned.link(this);
#endif
}
template<typename T>
void storeCell(T cell, Address address)
{
#if USE(JSVALUE64)
store64(cell, address);
#else
store32(cell, address.withOffset(PayloadOffset));
store32(TrustedImm32(JSValue::CellTag), address.withOffset(TagOffset));
#endif
}
void loadCell(Address address, GPRReg gpr)
{
#if USE(JSVALUE64)
load64(address, gpr);
#else
load32(address.withOffset(PayloadOffset), gpr);
#endif
}
void storeValue(JSValueRegs regs, Address address)
{
#if USE(JSVALUE64)
store64(regs.gpr(), address);
#else
store32(regs.payloadGPR(), address.withOffset(PayloadOffset));
store32(regs.tagGPR(), address.withOffset(TagOffset));
#endif
}
void storeValue(JSValueRegs regs, BaseIndex address)
{
#if USE(JSVALUE64)
store64(regs.gpr(), address);
#else
store32(regs.payloadGPR(), address.withOffset(PayloadOffset));
store32(regs.tagGPR(), address.withOffset(TagOffset));
#endif
}
void storeValue(JSValueRegs regs, void* address)
{
#if USE(JSVALUE64)
store64(regs.gpr(), address);
#else
store32(regs.payloadGPR(), bitwise_cast<void*>(bitwise_cast<uintptr_t>(address) + PayloadOffset));
store32(regs.tagGPR(), bitwise_cast<void*>(bitwise_cast<uintptr_t>(address) + TagOffset));
#endif
}
void loadValue(Address address, JSValueRegs regs)
{
#if USE(JSVALUE64)
load64(address, regs.gpr());
#else
if (address.base == regs.payloadGPR()) {
load32(address.withOffset(TagOffset), regs.tagGPR());
load32(address.withOffset(PayloadOffset), regs.payloadGPR());
} else {
load32(address.withOffset(PayloadOffset), regs.payloadGPR());
load32(address.withOffset(TagOffset), regs.tagGPR());
}
#endif
}
void loadValue(BaseIndex address, JSValueRegs regs)
{
#if USE(JSVALUE64)
load64(address, regs.gpr());
#else
if (address.base == regs.payloadGPR() || address.index == regs.payloadGPR()) {
// We actually could handle the case where the registers are aliased to both
// tag and payload, but we don't for now.
RELEASE_ASSERT(address.base != regs.tagGPR());
RELEASE_ASSERT(address.index != regs.tagGPR());
load32(address.withOffset(TagOffset), regs.tagGPR());
load32(address.withOffset(PayloadOffset), regs.payloadGPR());
} else {
load32(address.withOffset(PayloadOffset), regs.payloadGPR());
load32(address.withOffset(TagOffset), regs.tagGPR());
}
#endif
}
void loadValue(void* address, JSValueRegs regs)
{
#if USE(JSVALUE64)
load64(address, regs.gpr());
#else
move(TrustedImmPtr(address), regs.payloadGPR());
loadValue(Address(regs.payloadGPR()), regs);
#endif
}
// Note that this clobbers offset.
void loadProperty(GPRReg object, GPRReg offset, JSValueRegs result);
void moveValueRegs(JSValueRegs srcRegs, JSValueRegs destRegs)
{
#if USE(JSVALUE32_64)
if (destRegs.tagGPR() == srcRegs.payloadGPR()) {
if (destRegs.payloadGPR() == srcRegs.tagGPR()) {
swap(srcRegs.payloadGPR(), srcRegs.tagGPR());
return;
}
move(srcRegs.payloadGPR(), destRegs.payloadGPR());
move(srcRegs.tagGPR(), destRegs.tagGPR());
return;
}
move(srcRegs.tagGPR(), destRegs.tagGPR());
move(srcRegs.payloadGPR(), destRegs.payloadGPR());
#else
move(srcRegs.gpr(), destRegs.gpr());
#endif
}
void moveValue(JSValue value, JSValueRegs regs)
{
#if USE(JSVALUE64)
move(Imm64(JSValue::encode(value)), regs.gpr());
#else
move(Imm32(value.tag()), regs.tagGPR());
move(Imm32(value.payload()), regs.payloadGPR());
#endif
}
void moveTrustedValue(JSValue value, JSValueRegs regs)
{
#if USE(JSVALUE64)
move(TrustedImm64(JSValue::encode(value)), regs.gpr());
#else
move(TrustedImm32(value.tag()), regs.tagGPR());
move(TrustedImm32(value.payload()), regs.payloadGPR());
#endif
}
void storeTrustedValue(JSValue value, Address address)
{
#if USE(JSVALUE64)
store64(TrustedImm64(JSValue::encode(value)), address);
#else
store32(TrustedImm32(value.tag()), address.withOffset(TagOffset));
store32(TrustedImm32(value.payload()), address.withOffset(PayloadOffset));
#endif
}
void storeTrustedValue(JSValue value, BaseIndex address)
{
#if USE(JSVALUE64)
store64(TrustedImm64(JSValue::encode(value)), address);
#else
store32(TrustedImm32(value.tag()), address.withOffset(TagOffset));
store32(TrustedImm32(value.payload()), address.withOffset(PayloadOffset));
#endif
}
Address addressFor(const RegisterAtOffset& entry)
{
return Address(GPRInfo::callFrameRegister, entry.offset());
}
void emitSave(const RegisterAtOffsetList& list)
{
for (const RegisterAtOffset& entry : list) {
if (entry.reg().isGPR())
storePtr(entry.reg().gpr(), addressFor(entry));
else
storeDouble(entry.reg().fpr(), addressFor(entry));
}
}
void emitRestore(const RegisterAtOffsetList& list)
{
for (const RegisterAtOffset& entry : list) {
if (entry.reg().isGPR())
loadPtr(addressFor(entry), entry.reg().gpr());
else
loadDouble(addressFor(entry), entry.reg().fpr());
}
}
void emitSaveCalleeSavesFor(CodeBlock* codeBlock)
{
ASSERT(codeBlock);
RegisterAtOffsetList* calleeSaves = codeBlock->calleeSaveRegisters();
RegisterSet dontSaveRegisters = RegisterSet(RegisterSet::stackRegisters(), RegisterSet::allFPRs());
unsigned registerCount = calleeSaves->size();
for (unsigned i = 0; i < registerCount; i++) {
RegisterAtOffset entry = calleeSaves->at(i);
if (dontSaveRegisters.get(entry.reg()))
continue;
storePtr(entry.reg().gpr(), Address(framePointerRegister, entry.offset()));
}
}
enum RestoreTagRegisterMode { UseExistingTagRegisterContents, CopyBaselineCalleeSavedRegistersFromBaseFrame };
void emitSaveOrCopyCalleeSavesFor(CodeBlock* codeBlock, VirtualRegister offsetVirtualRegister, RestoreTagRegisterMode tagRegisterMode, GPRReg temp)
{
ASSERT(codeBlock);
RegisterAtOffsetList* calleeSaves = codeBlock->calleeSaveRegisters();
RegisterSet dontSaveRegisters = RegisterSet(RegisterSet::stackRegisters(), RegisterSet::allFPRs());
unsigned registerCount = calleeSaves->size();
#if USE(JSVALUE64)
RegisterSet baselineCalleeSaves = RegisterSet::llintBaselineCalleeSaveRegisters();
#endif
for (unsigned i = 0; i < registerCount; i++) {
RegisterAtOffset entry = calleeSaves->at(i);
if (dontSaveRegisters.get(entry.reg()))
continue;
GPRReg registerToWrite;
#if USE(JSVALUE32_64)
UNUSED_PARAM(tagRegisterMode);
UNUSED_PARAM(temp);
#else
if (tagRegisterMode == CopyBaselineCalleeSavedRegistersFromBaseFrame && baselineCalleeSaves.get(entry.reg())) {
registerToWrite = temp;
loadPtr(AssemblyHelpers::Address(GPRInfo::callFrameRegister, entry.offset()), registerToWrite);
} else
#endif
registerToWrite = entry.reg().gpr();
storePtr(registerToWrite, Address(framePointerRegister, offsetVirtualRegister.offsetInBytes() + entry.offset()));
}
}
void emitRestoreCalleeSavesFor(CodeBlock* codeBlock)
{
ASSERT(codeBlock);
RegisterAtOffsetList* calleeSaves = codeBlock->calleeSaveRegisters();
RegisterSet dontRestoreRegisters = RegisterSet(RegisterSet::stackRegisters(), RegisterSet::allFPRs());
unsigned registerCount = calleeSaves->size();
for (unsigned i = 0; i < registerCount; i++) {
RegisterAtOffset entry = calleeSaves->at(i);
if (dontRestoreRegisters.get(entry.reg()))
continue;
loadPtr(Address(framePointerRegister, entry.offset()), entry.reg().gpr());
}
}
void emitSaveCalleeSaves()
{
emitSaveCalleeSavesFor(codeBlock());
}
void emitSaveThenMaterializeTagRegisters()
{
#if USE(JSVALUE64)
#if CPU(ARM64)
pushPair(GPRInfo::tagTypeNumberRegister, GPRInfo::tagMaskRegister);
#else
push(GPRInfo::tagTypeNumberRegister);
push(GPRInfo::tagMaskRegister);
#endif
emitMaterializeTagCheckRegisters();
#endif
}
void emitRestoreCalleeSaves()
{
emitRestoreCalleeSavesFor(codeBlock());
}
void emitRestoreSavedTagRegisters()
{
#if USE(JSVALUE64)
#if CPU(ARM64)
popPair(GPRInfo::tagTypeNumberRegister, GPRInfo::tagMaskRegister);
#else
pop(GPRInfo::tagMaskRegister);
pop(GPRInfo::tagTypeNumberRegister);
#endif
#endif
}
// If you use this, be aware that vmGPR will get trashed.
void copyCalleeSavesToVMEntryFrameCalleeSavesBuffer(GPRReg vmGPR)
{
#if NUMBER_OF_CALLEE_SAVES_REGISTERS > 0
loadPtr(Address(vmGPR, VM::topEntryFrameOffset()), vmGPR);
copyCalleeSavesToEntryFrameCalleeSavesBufferImpl(vmGPR);
#else
UNUSED_PARAM(vmGPR);
#endif
}
void copyCalleeSavesToEntryFrameCalleeSavesBuffer(EntryFrame*& topEntryFrame)
{
#if NUMBER_OF_CALLEE_SAVES_REGISTERS > 0
const TempRegisterSet& usedRegisters = { RegisterSet::stubUnavailableRegisters() };
GPRReg temp1 = usedRegisters.getFreeGPR(0);
loadPtr(&topEntryFrame, temp1);
copyCalleeSavesToEntryFrameCalleeSavesBufferImpl(temp1);
#else
UNUSED_PARAM(topEntryFrame);
#endif
}
void copyCalleeSavesToEntryFrameCalleeSavesBuffer(GPRReg topEntryFrame)
{
#if NUMBER_OF_CALLEE_SAVES_REGISTERS > 0
copyCalleeSavesToEntryFrameCalleeSavesBufferImpl(topEntryFrame);
#else
UNUSED_PARAM(topEntryFrame);
#endif
}
void restoreCalleeSavesFromEntryFrameCalleeSavesBuffer(EntryFrame*&);
void copyCalleeSavesFromFrameOrRegisterToEntryFrameCalleeSavesBuffer(EntryFrame*& topEntryFrame, const TempRegisterSet& usedRegisters = { RegisterSet::stubUnavailableRegisters() })
{
#if NUMBER_OF_CALLEE_SAVES_REGISTERS > 0
GPRReg temp1 = usedRegisters.getFreeGPR(0);
GPRReg temp2 = usedRegisters.getFreeGPR(1);
FPRReg fpTemp = usedRegisters.getFreeFPR();
ASSERT(temp2 != InvalidGPRReg);
ASSERT(codeBlock());
// Copy saved calleeSaves on stack or unsaved calleeSaves in register to vm calleeSave buffer
loadPtr(&topEntryFrame, temp1);
addPtr(TrustedImm32(EntryFrame::calleeSaveRegistersBufferOffset()), temp1);
RegisterAtOffsetList* allCalleeSaves = RegisterSet::vmCalleeSaveRegisterOffsets();
RegisterAtOffsetList* currentCalleeSaves = codeBlock()->calleeSaveRegisters();
RegisterSet dontCopyRegisters = RegisterSet::stackRegisters();
unsigned registerCount = allCalleeSaves->size();
for (unsigned i = 0; i < registerCount; i++) {
RegisterAtOffset entry = allCalleeSaves->at(i);
if (dontCopyRegisters.get(entry.reg()))
continue;
RegisterAtOffset* currentFrameEntry = currentCalleeSaves->find(entry.reg());
if (entry.reg().isGPR()) {
GPRReg regToStore;
if (currentFrameEntry) {
// Load calleeSave from stack into temp register
regToStore = temp2;
loadPtr(Address(framePointerRegister, currentFrameEntry->offset()), regToStore);
} else
// Just store callee save directly
regToStore = entry.reg().gpr();
storePtr(regToStore, Address(temp1, entry.offset()));
} else {
FPRReg fpRegToStore;
if (currentFrameEntry) {
// Load calleeSave from stack into temp register
fpRegToStore = fpTemp;
loadDouble(Address(framePointerRegister, currentFrameEntry->offset()), fpRegToStore);
} else
// Just store callee save directly
fpRegToStore = entry.reg().fpr();
storeDouble(fpRegToStore, Address(temp1, entry.offset()));
}
}
#else
UNUSED_PARAM(topEntryFrame);
UNUSED_PARAM(usedRegisters);
#endif
}
void emitMaterializeTagCheckRegisters()
{
#if USE(JSVALUE64)
move(MacroAssembler::TrustedImm64(TagTypeNumber), GPRInfo::tagTypeNumberRegister);
orPtr(MacroAssembler::TrustedImm32(TagBitTypeOther), GPRInfo::tagTypeNumberRegister, GPRInfo::tagMaskRegister);
#endif
}
void clearStackFrame(GPRReg currentTop, GPRReg newTop, GPRReg temp, unsigned frameSize)
{
ASSERT(frameSize % stackAlignmentBytes() == 0);
if (frameSize <= 128) {
for (unsigned offset = 0; offset < frameSize; offset += sizeof(intptr_t))
storePtr(TrustedImm32(0), Address(currentTop, -8 - offset));
} else {
constexpr unsigned storeBytesPerIteration = stackAlignmentBytes();
constexpr unsigned storesPerIteration = storeBytesPerIteration / sizeof(intptr_t);
move(currentTop, temp);
Label zeroLoop = label();
subPtr(TrustedImm32(storeBytesPerIteration), temp);
#if CPU(ARM64)
static_assert(storesPerIteration == 2, "clearStackFrame() for ARM64 assumes stack is 16 byte aligned");
storePair64(ARM64Registers::zr, ARM64Registers::zr, temp);
#else
for (unsigned i = storesPerIteration; i-- != 0;)
storePtr(TrustedImm32(0), Address(temp, sizeof(intptr_t) * i));
#endif
branchPtr(NotEqual, temp, newTop).linkTo(zeroLoop, this);
}
}
#if CPU(X86_64) || CPU(X86)
static size_t prologueStackPointerDelta()
{
// Prologue only saves the framePointerRegister
return sizeof(void*);
}
void emitFunctionPrologue()
{
push(framePointerRegister);
move(stackPointerRegister, framePointerRegister);
}
void emitFunctionEpilogueWithEmptyFrame()
{
pop(framePointerRegister);
}
void emitFunctionEpilogue()
{
move(framePointerRegister, stackPointerRegister);
pop(framePointerRegister);
}
void preserveReturnAddressAfterCall(GPRReg reg)
{
pop(reg);
}
void restoreReturnAddressBeforeReturn(GPRReg reg)
{
push(reg);
}
void restoreReturnAddressBeforeReturn(Address address)
{
push(address);
}
#endif // CPU(X86_64) || CPU(X86)
#if CPU(ARM) || CPU(ARM64)
static size_t prologueStackPointerDelta()
{
// Prologue saves the framePointerRegister and linkRegister
return 2 * sizeof(void*);
}
void emitFunctionPrologue()
{
tagReturnAddress();
pushPair(framePointerRegister, linkRegister);
move(stackPointerRegister, framePointerRegister);
}
void emitFunctionEpilogueWithEmptyFrame()
{
popPair(framePointerRegister, linkRegister);
}
void emitFunctionEpilogue()
{
move(framePointerRegister, stackPointerRegister);
emitFunctionEpilogueWithEmptyFrame();
}
ALWAYS_INLINE void preserveReturnAddressAfterCall(RegisterID reg)
{
move(linkRegister, reg);
}
ALWAYS_INLINE void restoreReturnAddressBeforeReturn(RegisterID reg)
{
move(reg, linkRegister);
}
ALWAYS_INLINE void restoreReturnAddressBeforeReturn(Address address)
{
loadPtr(address, linkRegister);
}
#endif
#if CPU(MIPS)
static size_t prologueStackPointerDelta()
{
// Prologue saves the framePointerRegister and returnAddressRegister
return 2 * sizeof(void*);
}
void emitFunctionPrologue()
{
pushPair(framePointerRegister, returnAddressRegister);
move(stackPointerRegister, framePointerRegister);
}
void emitFunctionEpilogueWithEmptyFrame()
{
popPair(framePointerRegister, returnAddressRegister);
}
void emitFunctionEpilogue()
{
move(framePointerRegister, stackPointerRegister);
emitFunctionEpilogueWithEmptyFrame();
}
ALWAYS_INLINE void preserveReturnAddressAfterCall(RegisterID reg)
{
move(returnAddressRegister, reg);
}
ALWAYS_INLINE void restoreReturnAddressBeforeReturn(RegisterID reg)
{
move(reg, returnAddressRegister);
}
ALWAYS_INLINE void restoreReturnAddressBeforeReturn(Address address)
{
loadPtr(address, returnAddressRegister);
}
#endif
void emitGetFromCallFrameHeaderPtr(int entry, GPRReg to, GPRReg from = GPRInfo::callFrameRegister)
{
loadPtr(Address(from, entry * sizeof(Register)), to);
}
void emitGetFromCallFrameHeader32(int entry, GPRReg to, GPRReg from = GPRInfo::callFrameRegister)
{
load32(Address(from, entry * sizeof(Register)), to);
}
#if USE(JSVALUE64)
void emitGetFromCallFrameHeader64(int entry, GPRReg to, GPRReg from = GPRInfo::callFrameRegister)
{
load64(Address(from, entry * sizeof(Register)), to);
}
#endif // USE(JSVALUE64)
void emitPutToCallFrameHeader(GPRReg from, int entry)
{
storePtr(from, Address(GPRInfo::callFrameRegister, entry * sizeof(Register)));
}
void emitPutToCallFrameHeader(void* value, int entry)
{
storePtr(TrustedImmPtr(value), Address(GPRInfo::callFrameRegister, entry * sizeof(Register)));
}
void emitGetCallerFrameFromCallFrameHeaderPtr(RegisterID to)
{
loadPtr(Address(GPRInfo::callFrameRegister, CallFrame::callerFrameOffset()), to);
}
void emitPutCallerFrameToCallFrameHeader(RegisterID from)
{
storePtr(from, Address(GPRInfo::callFrameRegister, CallFrame::callerFrameOffset()));
}
void emitPutReturnPCToCallFrameHeader(RegisterID from)
{
storePtr(from, Address(GPRInfo::callFrameRegister, CallFrame::returnPCOffset()));
}
void emitPutReturnPCToCallFrameHeader(TrustedImmPtr from)
{
storePtr(from, Address(GPRInfo::callFrameRegister, CallFrame::returnPCOffset()));
}
// emitPutToCallFrameHeaderBeforePrologue() and related are used to access callee frame header
// fields before the code from emitFunctionPrologue() has executed.
// First, the access is via the stack pointer. Second, the address calculation must also take
// into account that the stack pointer may not have been adjusted down for the return PC and/or
// caller's frame pointer. On some platforms, the callee is responsible for pushing the
// "link register" containing the return address in the function prologue.
#if USE(JSVALUE64)
void emitPutToCallFrameHeaderBeforePrologue(GPRReg from, int entry)
{
storePtr(from, Address(stackPointerRegister, entry * static_cast<ptrdiff_t>(sizeof(Register)) - prologueStackPointerDelta()));
}
#else
void emitPutPayloadToCallFrameHeaderBeforePrologue(GPRReg from, int entry)
{
storePtr(from, Address(stackPointerRegister, entry * static_cast<ptrdiff_t>(sizeof(Register)) - prologueStackPointerDelta() + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload)));
}
void emitPutTagToCallFrameHeaderBeforePrologue(TrustedImm32 tag, int entry)
{
storePtr(tag, Address(stackPointerRegister, entry * static_cast<ptrdiff_t>(sizeof(Register)) - prologueStackPointerDelta() + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.tag)));
}
#endif
JumpList branchIfNotEqual(JSValueRegs regs, JSValue value)
{
#if USE(JSVALUE64)
return branch64(NotEqual, regs.gpr(), TrustedImm64(JSValue::encode(value)));
#else
JumpList result;
result.append(branch32(NotEqual, regs.tagGPR(), TrustedImm32(value.tag())));
if (value.isEmpty() || value.isUndefinedOrNull())
return result; // These don't have anything interesting in the payload.
result.append(branch32(NotEqual, regs.payloadGPR(), TrustedImm32(value.payload())));
return result;
#endif
}
Jump branchIfEqual(JSValueRegs regs, JSValue value)
{
#if USE(JSVALUE64)
return branch64(Equal, regs.gpr(), TrustedImm64(JSValue::encode(value)));
#else
Jump notEqual;
// These don't have anything interesting in the payload.
if (!value.isEmpty() && !value.isUndefinedOrNull())
notEqual = branch32(NotEqual, regs.payloadGPR(), TrustedImm32(value.payload()));
Jump result = branch32(Equal, regs.tagGPR(), TrustedImm32(value.tag()));
if (notEqual.isSet())
notEqual.link(this);
return result;
#endif
}
Jump branchIfNotCell(GPRReg reg, TagRegistersMode mode = HaveTagRegisters)
{
#if USE(JSVALUE64)
if (mode == HaveTagRegisters)
return branchTest64(NonZero, reg, GPRInfo::tagMaskRegister);
return branchTest64(NonZero, reg, TrustedImm64(TagMask));
#else
UNUSED_PARAM(mode);
return branch32(MacroAssembler::NotEqual, reg, TrustedImm32(JSValue::CellTag));
#endif
}
Jump branchIfNotCell(JSValueRegs regs, TagRegistersMode mode = HaveTagRegisters)
{
#if USE(JSVALUE64)
return branchIfNotCell(regs.gpr(), mode);
#else
return branchIfNotCell(regs.tagGPR(), mode);
#endif
}
Jump branchIfCell(GPRReg reg, TagRegistersMode mode = HaveTagRegisters)
{
#if USE(JSVALUE64)
if (mode == HaveTagRegisters)
return branchTest64(Zero, reg, GPRInfo::tagMaskRegister);
return branchTest64(Zero, reg, TrustedImm64(TagMask));
#else
UNUSED_PARAM(mode);
return branch32(MacroAssembler::Equal, reg, TrustedImm32(JSValue::CellTag));
#endif
}
Jump branchIfCell(JSValueRegs regs, TagRegistersMode mode = HaveTagRegisters)
{
#if USE(JSVALUE64)
return branchIfCell(regs.gpr(), mode);
#else
return branchIfCell(regs.tagGPR(), mode);
#endif
}
Jump branchIfOther(JSValueRegs regs, GPRReg tempGPR)
{
#if USE(JSVALUE64)
move(regs.gpr(), tempGPR);
and64(TrustedImm32(~TagBitUndefined), tempGPR);
return branch64(Equal, tempGPR, TrustedImm64(ValueNull));
#else
or32(TrustedImm32(1), regs.tagGPR(), tempGPR);
return branch32(Equal, tempGPR, TrustedImm32(JSValue::NullTag));
#endif
}
Jump branchIfNotOther(JSValueRegs regs, GPRReg tempGPR)
{
#if USE(JSVALUE64)
move(regs.gpr(), tempGPR);
and64(TrustedImm32(~TagBitUndefined), tempGPR);
return branch64(NotEqual, tempGPR, TrustedImm64(ValueNull));
#else
or32(TrustedImm32(1), regs.tagGPR(), tempGPR);
return branch32(NotEqual, tempGPR, TrustedImm32(JSValue::NullTag));
#endif
}
Jump branchIfInt32(JSValueRegs regs, TagRegistersMode mode = HaveTagRegisters)
{
#if USE(JSVALUE64)
if (mode == HaveTagRegisters)
return branch64(AboveOrEqual, regs.gpr(), GPRInfo::tagTypeNumberRegister);
return branch64(AboveOrEqual, regs.gpr(), TrustedImm64(TagTypeNumber));
#else
UNUSED_PARAM(mode);
return branch32(Equal, regs.tagGPR(), TrustedImm32(JSValue::Int32Tag));
#endif
}
#if USE(JSVALUE64)
Jump branchIfNotInt32(GPRReg gpr, TagRegistersMode mode = HaveTagRegisters)
{
if (mode == HaveTagRegisters)
return branch64(Below, gpr, GPRInfo::tagTypeNumberRegister);
return branch64(Below, gpr, TrustedImm64(TagTypeNumber));
}
#endif
Jump branchIfNotInt32(JSValueRegs regs, TagRegistersMode mode = HaveTagRegisters)
{
#if USE(JSVALUE64)
return branchIfNotInt32(regs.gpr(), mode);
#else
UNUSED_PARAM(mode);
return branch32(NotEqual, regs.tagGPR(), TrustedImm32(JSValue::Int32Tag));
#endif
}
// Note that the tempGPR is not used in 64-bit mode.
Jump branchIfNumber(JSValueRegs regs, GPRReg tempGPR, TagRegistersMode mode = HaveTagRegisters)
{
#if USE(JSVALUE64)
UNUSED_PARAM(tempGPR);
return branchIfNumber(regs.gpr(), mode);
#else
UNUSED_PARAM(mode);
add32(TrustedImm32(1), regs.tagGPR(), tempGPR);
return branch32(Below, tempGPR, TrustedImm32(JSValue::LowestTag + 1));
#endif
}
#if USE(JSVALUE64)
Jump branchIfNumber(GPRReg reg, TagRegistersMode mode = HaveTagRegisters)
{
if (mode == HaveTagRegisters)
return branchTest64(NonZero, reg, GPRInfo::tagTypeNumberRegister);
return branchTest64(NonZero, reg, TrustedImm64(TagTypeNumber));
}
#endif
// Note that the tempGPR is not used in 64-bit mode.
Jump branchIfNotNumber(JSValueRegs regs, GPRReg tempGPR, TagRegistersMode mode = HaveTagRegisters)
{
#if USE(JSVALUE64)
UNUSED_PARAM(tempGPR);
return branchIfNotNumber(regs.gpr(), mode);
#else
UNUSED_PARAM(mode);
add32(TrustedImm32(1), regs.tagGPR(), tempGPR);
return branch32(AboveOrEqual, tempGPR, TrustedImm32(JSValue::LowestTag + 1));
#endif
}
#if USE(JSVALUE64)
Jump branchIfNotNumber(GPRReg reg, TagRegistersMode mode = HaveTagRegisters)
{
if (mode == HaveTagRegisters)
return branchTest64(Zero, reg, GPRInfo::tagTypeNumberRegister);
return branchTest64(Zero, reg, TrustedImm64(TagTypeNumber));
}
#endif
Jump branchIfNotDoubleKnownNotInt32(JSValueRegs regs, TagRegistersMode mode = HaveTagRegisters)
{
#if USE(JSVALUE64)
if (mode == HaveTagRegisters)
return branchTest64(Zero, regs.gpr(), GPRInfo::tagTypeNumberRegister);
return branchTest64(Zero, regs.gpr(), TrustedImm64(TagTypeNumber));
#else
UNUSED_PARAM(mode);
return branch32(AboveOrEqual, regs.tagGPR(), TrustedImm32(JSValue::LowestTag));
#endif
}
// Note that the tempGPR is not used in 32-bit mode.
Jump branchIfBoolean(JSValueRegs regs, GPRReg tempGPR)
{
#if USE(JSVALUE64)
move(regs.gpr(), tempGPR);
xor64(TrustedImm32(static_cast<int32_t>(ValueFalse)), tempGPR);
return branchTest64(Zero, tempGPR, TrustedImm32(static_cast<int32_t>(~1)));
#else
UNUSED_PARAM(tempGPR);
return branch32(Equal, regs.tagGPR(), TrustedImm32(JSValue::BooleanTag));
#endif
}
// Note that the tempGPR is not used in 32-bit mode.
Jump branchIfNotBoolean(JSValueRegs regs, GPRReg tempGPR)
{
#if USE(JSVALUE64)
move(regs.gpr(), tempGPR);
xor64(TrustedImm32(static_cast<int32_t>(ValueFalse)), tempGPR);
return branchTest64(NonZero, tempGPR, TrustedImm32(static_cast<int32_t>(~1)));
#else
UNUSED_PARAM(tempGPR);
return branch32(NotEqual, regs.tagGPR(), TrustedImm32(JSValue::BooleanTag));
#endif
}
Jump branchIfObject(GPRReg cellGPR)
{
return branch8(
AboveOrEqual, Address(cellGPR, JSCell::typeInfoTypeOffset()), TrustedImm32(ObjectType));
}
Jump branchIfNotObject(GPRReg cellGPR)
{
return branch8(
Below, Address(cellGPR, JSCell::typeInfoTypeOffset()), TrustedImm32(ObjectType));
}
Jump branchIfType(GPRReg cellGPR, JSType type)
{
return branch8(Equal, Address(cellGPR, JSCell::typeInfoTypeOffset()), TrustedImm32(type));
}
Jump branchIfNotType(GPRReg cellGPR, JSType type)
{
return branch8(NotEqual, Address(cellGPR, JSCell::typeInfoTypeOffset()), TrustedImm32(type));
}
Jump branchIfString(GPRReg cellGPR) { return branchIfType(cellGPR, StringType); }
Jump branchIfNotString(GPRReg cellGPR) { return branchIfNotType(cellGPR, StringType); }
Jump branchIfSymbol(GPRReg cellGPR) { return branchIfType(cellGPR, SymbolType); }
Jump branchIfNotSymbol(GPRReg cellGPR) { return branchIfNotType(cellGPR, SymbolType); }
Jump branchIfBigInt(GPRReg cellGPR) { return branchIfType(cellGPR, BigIntType); }
Jump branchIfNotBigInt(GPRReg cellGPR) { return branchIfNotType(cellGPR, BigIntType); }
Jump branchIfFunction(GPRReg cellGPR) { return branchIfType(cellGPR, JSFunctionType); }
Jump branchIfNotFunction(GPRReg cellGPR) { return branchIfNotType(cellGPR, JSFunctionType); }
Jump branchIfEmpty(JSValueRegs regs)
{
#if USE(JSVALUE64)
return branchTest64(Zero, regs.gpr());
#else
return branch32(Equal, regs.tagGPR(), TrustedImm32(JSValue::EmptyValueTag));
#endif
}
// Note that this function does not respect MasqueradesAsUndefined.
Jump branchIfUndefined(JSValueRegs regs)
{
#if USE(JSVALUE64)
return branch64(Equal, regs.gpr(), TrustedImm64(JSValue::encode(jsUndefined())));
#else
return branch32(Equal, regs.tagGPR(), TrustedImm32(JSValue::UndefinedTag));
#endif
}
Jump branchIfNull(JSValueRegs regs)
{
#if USE(JSVALUE64)
return branch64(Equal, regs.gpr(), TrustedImm64(JSValue::encode(jsNull())));
#else
return branch32(Equal, regs.tagGPR(), TrustedImm32(JSValue::NullTag));
#endif
}
JumpList branchIfNotType(
JSValueRegs, GPRReg tempGPR, const InferredType::Descriptor&,
TagRegistersMode = HaveTagRegisters);
template<typename T>
Jump branchStructure(RelationalCondition condition, T leftHandSide, Structure* structure)
{
#if USE(JSVALUE64)
return branch32(condition, leftHandSide, TrustedImm32(structure->id()));
#else
return branchPtr(condition, leftHandSide, TrustedImmPtr(structure));
#endif
}
Jump branchIfFastTypedArray(GPRReg baseGPR);
Jump branchIfNotFastTypedArray(GPRReg baseGPR);
static Address addressForByteOffset(ptrdiff_t byteOffset)
{
return Address(GPRInfo::callFrameRegister, byteOffset);
}
static Address addressFor(VirtualRegister virtualRegister, GPRReg baseReg)
{
ASSERT(virtualRegister.isValid());
return Address(baseReg, virtualRegister.offset() * sizeof(Register));
}
static Address addressFor(VirtualRegister virtualRegister)
{
// NB. It's tempting on some architectures to sometimes use an offset from the stack
// register because for some offsets that will encode to a smaller instruction. But we
// cannot do this. We use this in places where the stack pointer has been moved to some
// unpredictable location.
ASSERT(virtualRegister.isValid());
return Address(GPRInfo::callFrameRegister, virtualRegister.offset() * sizeof(Register));
}
static Address addressFor(int operand)
{
return addressFor(static_cast<VirtualRegister>(operand));
}
static Address tagFor(VirtualRegister virtualRegister)
{
ASSERT(virtualRegister.isValid());
return Address(GPRInfo::callFrameRegister, virtualRegister.offset() * sizeof(Register) + TagOffset);
}
static Address tagFor(int operand)
{
return tagFor(static_cast<VirtualRegister>(operand));
}
static Address payloadFor(VirtualRegister virtualRegister)
{
ASSERT(virtualRegister.isValid());
return Address(GPRInfo::callFrameRegister, virtualRegister.offset() * sizeof(Register) + PayloadOffset);
}
static Address payloadFor(int operand)
{
return payloadFor(static_cast<VirtualRegister>(operand));
}
// Access to our fixed callee CallFrame.
static Address calleeFrameSlot(int slot)
{
ASSERT(slot >= CallerFrameAndPC::sizeInRegisters);
return Address(stackPointerRegister, sizeof(Register) * (slot - CallerFrameAndPC::sizeInRegisters));
}
// Access to our fixed callee CallFrame.
static Address calleeArgumentSlot(int argument)
{
return calleeFrameSlot(virtualRegisterForArgument(argument).offset());
}
static Address calleeFrameTagSlot(int slot)
{
return calleeFrameSlot(slot).withOffset(TagOffset);
}
static Address calleeFramePayloadSlot(int slot)
{
return calleeFrameSlot(slot).withOffset(PayloadOffset);
}
static Address calleeArgumentTagSlot(int argument)
{
return calleeArgumentSlot(argument).withOffset(TagOffset);
}
static Address calleeArgumentPayloadSlot(int argument)
{
return calleeArgumentSlot(argument).withOffset(PayloadOffset);
}
static Address calleeFrameCallerFrame()
{
return calleeFrameSlot(0).withOffset(CallFrame::callerFrameOffset());
}
static GPRReg selectScratchGPR(RegisterSet preserved)
{
GPRReg registers[] = {
GPRInfo::regT0,
GPRInfo::regT1,
GPRInfo::regT2,
GPRInfo::regT3,
GPRInfo::regT4,
GPRInfo::regT5,
};
for (GPRReg reg : registers) {
if (!preserved.contains(reg))
return reg;
}
RELEASE_ASSERT_NOT_REACHED();
return InvalidGPRReg;
}
template<typename... Regs>
static GPRReg selectScratchGPR(Regs... args)
{
RegisterSet set;
constructRegisterSet(set, args...);
return selectScratchGPR(set);
}
static void constructRegisterSet(RegisterSet&)
{
}
template<typename... Regs>
static void constructRegisterSet(RegisterSet& set, JSValueRegs regs, Regs... args)
{
if (regs.tagGPR() != InvalidGPRReg)
set.set(regs.tagGPR());
if (regs.payloadGPR() != InvalidGPRReg)
set.set(regs.payloadGPR());
constructRegisterSet(set, args...);
}
template<typename... Regs>
static void constructRegisterSet(RegisterSet& set, GPRReg reg, Regs... args)
{
if (reg != InvalidGPRReg)
set.set(reg);
constructRegisterSet(set, args...);
}
// Add a debug call. This call has no effect on JIT code execution state.
void debugCall(VM&, V_DebugOperation_EPP function, void* argument);
// These methods JIT generate dynamic, debug-only checks - akin to ASSERTs.
#if !ASSERT_DISABLED
void jitAssertIsInt32(GPRReg);
void jitAssertIsJSInt32(GPRReg);
void jitAssertIsJSNumber(GPRReg);
void jitAssertIsJSDouble(GPRReg);
void jitAssertIsCell(GPRReg);
void jitAssertHasValidCallFrame();
void jitAssertIsNull(GPRReg);
void jitAssertTagsInPlace();
void jitAssertArgumentCountSane();
#else
void jitAssertIsInt32(GPRReg) { }
void jitAssertIsJSInt32(GPRReg) { }
void jitAssertIsJSNumber(GPRReg) { }
void jitAssertIsJSDouble(GPRReg) { }
void jitAssertIsCell(GPRReg) { }
void jitAssertHasValidCallFrame() { }
void jitAssertIsNull(GPRReg) { }
void jitAssertTagsInPlace() { }
void jitAssertArgumentCountSane() { }
#endif
void jitReleaseAssertNoException(VM&);
void incrementSuperSamplerCount();
void decrementSuperSamplerCount();
void purifyNaN(FPRReg);
// These methods convert between doubles, and doubles boxed and JSValues.
#if USE(JSVALUE64)
GPRReg boxDouble(FPRReg fpr, GPRReg gpr)
{
moveDoubleTo64(fpr, gpr);
sub64(GPRInfo::tagTypeNumberRegister, gpr);
jitAssertIsJSDouble(gpr);
return gpr;
}
FPRReg unboxDoubleWithoutAssertions(GPRReg gpr, GPRReg resultGPR, FPRReg fpr)
{
add64(GPRInfo::tagTypeNumberRegister, gpr, resultGPR);
move64ToDouble(resultGPR, fpr);
return fpr;
}
FPRReg unboxDouble(GPRReg gpr, GPRReg resultGPR, FPRReg fpr)
{
jitAssertIsJSDouble(gpr);
return unboxDoubleWithoutAssertions(gpr, resultGPR, fpr);
}
void boxDouble(FPRReg fpr, JSValueRegs regs)
{
boxDouble(fpr, regs.gpr());
}
void unboxDoubleNonDestructive(JSValueRegs regs, FPRReg destFPR, GPRReg resultGPR, FPRReg)
{
unboxDouble(regs.payloadGPR(), resultGPR, destFPR);
}
// Here are possible arrangements of source, target, scratch:
// - source, target, scratch can all be separate registers.
// - source and target can be the same but scratch is separate.
// - target and scratch can be the same but source is separate.
void boxInt52(GPRReg source, GPRReg target, GPRReg scratch, FPRReg fpScratch)
{
// Is it an int32?
signExtend32ToPtr(source, scratch);
Jump isInt32 = branch64(Equal, source, scratch);
// Nope, it's not, but regT0 contains the int64 value.
convertInt64ToDouble(source, fpScratch);
boxDouble(fpScratch, target);
Jump done = jump();
isInt32.link(this);
zeroExtend32ToPtr(source, target);
or64(GPRInfo::tagTypeNumberRegister, target);
done.link(this);
}
#endif
#if USE(JSVALUE32_64)
void boxDouble(FPRReg fpr, GPRReg tagGPR, GPRReg payloadGPR)
{
moveDoubleToInts(fpr, payloadGPR, tagGPR);
}
void unboxDouble(GPRReg tagGPR, GPRReg payloadGPR, FPRReg fpr, FPRReg scratchFPR)
{
moveIntsToDouble(payloadGPR, tagGPR, fpr, scratchFPR);
}
void boxDouble(FPRReg fpr, JSValueRegs regs)
{
boxDouble(fpr, regs.tagGPR(), regs.payloadGPR());
}
void unboxDouble(JSValueRegs regs, FPRReg fpr, FPRReg scratchFPR)
{
unboxDouble(regs.tagGPR(), regs.payloadGPR(), fpr, scratchFPR);
}
void unboxDoubleNonDestructive(const JSValueRegs regs, FPRReg destFPR, GPRReg, FPRReg scratchFPR)
{
unboxDouble(regs, destFPR, scratchFPR);
}
#endif
void boxBooleanPayload(GPRReg boolGPR, GPRReg payloadGPR)
{
#if USE(JSVALUE64)
add32(TrustedImm32(ValueFalse), boolGPR, payloadGPR);
#else
move(boolGPR, payloadGPR);
#endif
}
void boxBooleanPayload(bool value, GPRReg payloadGPR)
{
#if USE(JSVALUE64)
move(TrustedImm32(ValueFalse + value), payloadGPR);
#else
move(TrustedImm32(value), payloadGPR);
#endif
}
void boxBoolean(GPRReg boolGPR, JSValueRegs boxedRegs)
{
boxBooleanPayload(boolGPR, boxedRegs.payloadGPR());
#if USE(JSVALUE32_64)
move(TrustedImm32(JSValue::BooleanTag), boxedRegs.tagGPR());
#endif
}
void boxInt32(GPRReg intGPR, JSValueRegs boxedRegs, TagRegistersMode mode = HaveTagRegisters)
{
#if USE(JSVALUE64)
if (mode == DoNotHaveTagRegisters) {
move(intGPR, boxedRegs.gpr());
or64(TrustedImm64(TagTypeNumber), boxedRegs.gpr());
} else
or64(GPRInfo::tagTypeNumberRegister, intGPR, boxedRegs.gpr());
#else
UNUSED_PARAM(mode);
move(intGPR, boxedRegs.payloadGPR());
move(TrustedImm32(JSValue::Int32Tag), boxedRegs.tagGPR());
#endif
}
void boxCell(GPRReg cellGPR, JSValueRegs boxedRegs)
{
#if USE(JSVALUE64)
move(cellGPR, boxedRegs.gpr());
#else
move(cellGPR, boxedRegs.payloadGPR());
move(TrustedImm32(JSValue::CellTag), boxedRegs.tagGPR());
#endif
}
void callExceptionFuzz(VM&);
enum ExceptionCheckKind { NormalExceptionCheck, InvertedExceptionCheck };
enum ExceptionJumpWidth { NormalJumpWidth, FarJumpWidth };
JS_EXPORT_PRIVATE Jump emitExceptionCheck(
VM&, ExceptionCheckKind = NormalExceptionCheck, ExceptionJumpWidth = NormalJumpWidth);
JS_EXPORT_PRIVATE Jump emitNonPatchableExceptionCheck(VM&);
Jump emitJumpIfException(VM&);
#if ENABLE(SAMPLING_COUNTERS)
static void emitCount(MacroAssembler& jit, AbstractSamplingCounter& counter, int32_t increment = 1)
{
jit.add64(TrustedImm32(increment), AbsoluteAddress(counter.addressOfCounter()));
}
void emitCount(AbstractSamplingCounter& counter, int32_t increment = 1)
{
add64(TrustedImm32(increment), AbsoluteAddress(counter.addressOfCounter()));
}
#endif
#if ENABLE(SAMPLING_FLAGS)
void setSamplingFlag(int32_t);
void clearSamplingFlag(int32_t flag);
#endif
JSGlobalObject* globalObjectFor(CodeOrigin codeOrigin)
{
return codeBlock()->globalObjectFor(codeOrigin);
}
bool isStrictModeFor(CodeOrigin codeOrigin)
{
if (!codeOrigin.inlineCallFrame)
return codeBlock()->isStrictMode();
return codeOrigin.inlineCallFrame->isStrictMode();
}
ECMAMode ecmaModeFor(CodeOrigin codeOrigin)
{
return isStrictModeFor(codeOrigin) ? StrictMode : NotStrictMode;
}
ExecutableBase* executableFor(const CodeOrigin& codeOrigin);
CodeBlock* baselineCodeBlockFor(const CodeOrigin& codeOrigin)
{
return baselineCodeBlockForOriginAndBaselineCodeBlock(codeOrigin, baselineCodeBlock());
}
CodeBlock* baselineCodeBlockFor(InlineCallFrame* inlineCallFrame)
{
if (!inlineCallFrame)
return baselineCodeBlock();
return baselineCodeBlockForInlineCallFrame(inlineCallFrame);
}
CodeBlock* baselineCodeBlock()
{
return m_baselineCodeBlock;
}
static VirtualRegister argumentsStart(InlineCallFrame* inlineCallFrame)
{
if (!inlineCallFrame)
return VirtualRegister(CallFrame::argumentOffset(0));
if (inlineCallFrame->argumentsWithFixup.size() <= 1)
return virtualRegisterForLocal(0);
ValueRecovery recovery = inlineCallFrame->argumentsWithFixup[1];
RELEASE_ASSERT(recovery.technique() == DisplacedInJSStack);
return recovery.virtualRegister();
}
static VirtualRegister argumentsStart(const CodeOrigin& codeOrigin)
{
return argumentsStart(codeOrigin.inlineCallFrame);
}
static VirtualRegister argumentCount(InlineCallFrame* inlineCallFrame)
{
ASSERT(!inlineCallFrame || inlineCallFrame->isVarargs());
if (!inlineCallFrame)
return VirtualRegister(CallFrameSlot::argumentCount);
return inlineCallFrame->argumentCountRegister;
}
static VirtualRegister argumentCount(const CodeOrigin& codeOrigin)
{
return argumentCount(codeOrigin.inlineCallFrame);
}
void emitLoadStructure(VM&, RegisterID source, RegisterID dest, RegisterID scratch);
void emitStoreStructureWithTypeInfo(TrustedImmPtr structure, RegisterID dest, RegisterID)
{
emitStoreStructureWithTypeInfo(*this, structure, dest);
}
void emitStoreStructureWithTypeInfo(RegisterID structure, RegisterID dest, RegisterID scratch)
{
#if USE(JSVALUE64)
load64(MacroAssembler::Address(structure, Structure::structureIDOffset()), scratch);
store64(scratch, MacroAssembler::Address(dest, JSCell::structureIDOffset()));
#else
// Store all the info flags using a single 32-bit wide load and store.
load32(MacroAssembler::Address(structure, Structure::indexingTypeIncludingHistoryOffset()), scratch);
store32(scratch, MacroAssembler::Address(dest, JSCell::indexingTypeAndMiscOffset()));
// Store the StructureID
storePtr(structure, MacroAssembler::Address(dest, JSCell::structureIDOffset()));
#endif
}
static void emitStoreStructureWithTypeInfo(AssemblyHelpers& jit, TrustedImmPtr structure, RegisterID dest);
Jump barrierBranchWithoutFence(GPRReg cell)
{
return branch8(Above, Address(cell, JSCell::cellStateOffset()), TrustedImm32(blackThreshold));
}
Jump barrierBranchWithoutFence(JSCell* cell)
{
uint8_t* address = reinterpret_cast<uint8_t*>(cell) + JSCell::cellStateOffset();
return branch8(Above, AbsoluteAddress(address), TrustedImm32(blackThreshold));
}
Jump barrierBranch(VM& vm, GPRReg cell, GPRReg scratchGPR)
{
load8(Address(cell, JSCell::cellStateOffset()), scratchGPR);
return branch32(Above, scratchGPR, AbsoluteAddress(vm.heap.addressOfBarrierThreshold()));
}
Jump barrierBranch(VM& vm, JSCell* cell, GPRReg scratchGPR)
{
uint8_t* address = reinterpret_cast<uint8_t*>(cell) + JSCell::cellStateOffset();
load8(address, scratchGPR);
return branch32(Above, scratchGPR, AbsoluteAddress(vm.heap.addressOfBarrierThreshold()));
}
void barrierStoreLoadFence(VM& vm)
{
if (!Options::useConcurrentBarriers())
return;
Jump ok = jumpIfMutatorFenceNotNeeded(vm);
memoryFence();
ok.link(this);
}
void mutatorFence(VM& vm)
{
if (isX86())
return;
Jump ok = jumpIfMutatorFenceNotNeeded(vm);
storeFence();
ok.link(this);
}
void cage(Gigacage::Kind kind, GPRReg storage)
{
#if GIGACAGE_ENABLED
if (!Gigacage::isEnabled(kind))
return;
andPtr(TrustedImmPtr(Gigacage::mask(kind)), storage);
addPtr(TrustedImmPtr(Gigacage::basePtr(kind)), storage);
#else
UNUSED_PARAM(kind);
UNUSED_PARAM(storage);
#endif
}
void cageConditionally(Gigacage::Kind kind, GPRReg storage, GPRReg scratch)
{
#if GIGACAGE_ENABLED
if (!Gigacage::isEnabled(kind))
return;
if (kind != Gigacage::Primitive || Gigacage::isDisablingPrimitiveGigacageDisabled())
return cage(kind, storage);
loadPtr(&Gigacage::basePtr(kind), scratch);
Jump done = branchTestPtr(Zero, scratch);
andPtr(TrustedImmPtr(Gigacage::mask(kind)), storage);
addPtr(scratch, storage);
done.link(this);
#else
UNUSED_PARAM(kind);
UNUSED_PARAM(storage);
UNUSED_PARAM(scratch);
#endif
}
void emitComputeButterflyIndexingMask(GPRReg vectorLengthGPR, GPRReg scratchGPR, GPRReg resultGPR)
{
ASSERT(scratchGPR != resultGPR);
Jump done;
if (isX86() && !isX86_64()) {
Jump nonZero = branchTest32(NonZero, vectorLengthGPR);
move(TrustedImm32(0), resultGPR);
done = jump();
nonZero.link(this);
}
// If vectorLength == 0 then clz will return 32 on both ARM and x86. On 64-bit systems, we can then do a 64-bit right shift on a 32-bit -1 to get a 0 mask for zero vectorLength. On 32-bit ARM, shift masks with 0xff, which means it will still create a 0 mask.
countLeadingZeros32(vectorLengthGPR, scratchGPR);
move(TrustedImm32(-1), resultGPR);
urshiftPtr(scratchGPR, resultGPR);
if (done.isSet())
done.link(this);
}
// If for whatever reason the butterfly is going to change vector length this function does NOT
// update the indexing mask.
void nukeStructureAndStoreButterfly(VM& vm, GPRReg butterfly, GPRReg object)
{
if (isX86()) {
or32(TrustedImm32(bitwise_cast<int32_t>(nukedStructureIDBit())), Address(object, JSCell::structureIDOffset()));
storePtr(butterfly, Address(object, JSObject::butterflyOffset()));
return;
}
Jump ok = jumpIfMutatorFenceNotNeeded(vm);
or32(TrustedImm32(bitwise_cast<int32_t>(nukedStructureIDBit())), Address(object, JSCell::structureIDOffset()));
storeFence();
storePtr(butterfly, Address(object, JSObject::butterflyOffset()));
storeFence();
Jump done = jump();
ok.link(this);
storePtr(butterfly, Address(object, JSObject::butterflyOffset()));
done.link(this);
}
Jump jumpIfMutatorFenceNotNeeded(VM& vm)
{
return branchTest8(Zero, AbsoluteAddress(vm.heap.addressOfMutatorShouldBeFenced()));
}
void sanitizeStackInline(VM&, GPRReg scratch);
// Emits the branch structure for typeof. The code emitted by this doesn't fall through. The
// functor is called at those points where we have pinpointed a type. One way to use this is to
// have the functor emit the code to put the type string into an appropriate register and then
// jump out. A secondary functor is used for the call trap and masquerades-as-undefined slow
// case. It is passed the unlinked jump to the slow case.
template<typename Functor, typename SlowPathFunctor>
void emitTypeOf(
JSValueRegs regs, GPRReg tempGPR, const Functor& functor,
const SlowPathFunctor& slowPathFunctor)
{
// Implements the following branching structure:
//
// if (is cell) {
// if (is object) {
// if (is function) {
// return function;
// } else if (doesn't have call trap and doesn't masquerade as undefined) {
// return object
// } else {
// return slowPath();
// }
// } else if (is string) {
// return string
// } else {
// return symbol
// }
// } else if (is number) {
// return number
// } else if (is null) {
// return object
// } else if (is boolean) {
// return boolean
// } else {
// return undefined
// }
Jump notCell = branchIfNotCell(regs);
GPRReg cellGPR = regs.payloadGPR();
Jump notObject = branchIfNotObject(cellGPR);
Jump notFunction = branchIfNotFunction(cellGPR);
functor(TypeofType::Function, false);
notFunction.link(this);
slowPathFunctor(
branchTest8(
NonZero,
Address(cellGPR, JSCell::typeInfoFlagsOffset()),
TrustedImm32(MasqueradesAsUndefined | TypeOfShouldCallGetCallData)));
functor(TypeofType::Object, false);
notObject.link(this);
Jump notString = branchIfNotString(cellGPR);
functor(TypeofType::String, false);
notString.link(this);
functor(TypeofType::Symbol, false);
notCell.link(this);
Jump notNumber = branchIfNotNumber(regs, tempGPR);
functor(TypeofType::Number, false);
notNumber.link(this);
JumpList notNull = branchIfNotEqual(regs, jsNull());
functor(TypeofType::Object, false);
notNull.link(this);
Jump notBoolean = branchIfNotBoolean(regs, tempGPR);
functor(TypeofType::Boolean, false);
notBoolean.link(this);
functor(TypeofType::Undefined, true);
}
void emitDumbVirtualCall(VM&, CallLinkInfo*);
void makeSpaceOnStackForCCall();
void reclaimSpaceOnStackForCCall();
#if USE(JSVALUE64)
void emitRandomThunk(JSGlobalObject*, GPRReg scratch0, GPRReg scratch1, GPRReg scratch2, FPRReg result);
void emitRandomThunk(VM&, GPRReg scratch0, GPRReg scratch1, GPRReg scratch2, GPRReg scratch3, FPRReg result);
#endif
// Call this if you know that the value held in allocatorGPR is non-null. This DOES NOT mean
// that allocator is non-null; allocator can be null as a signal that we don't know what the
// value of allocatorGPR is. Additionally, if the allocator is not null, then there is no need
// to populate allocatorGPR - this code will ignore the contents of allocatorGPR.
void emitAllocateWithNonNullAllocator(GPRReg resultGPR, const JITAllocator& allocator, GPRReg allocatorGPR, GPRReg scratchGPR, JumpList& slowPath);
void emitAllocate(GPRReg resultGPR, const JITAllocator& allocator, GPRReg allocatorGPR, GPRReg scratchGPR, JumpList& slowPath);
template<typename StructureType>
void emitAllocateJSCell(GPRReg resultGPR, const JITAllocator& allocator, GPRReg allocatorGPR, StructureType structure, GPRReg scratchGPR, JumpList& slowPath)
{
emitAllocate(resultGPR, allocator, allocatorGPR, scratchGPR, slowPath);
emitStoreStructureWithTypeInfo(structure, resultGPR, scratchGPR);
}
template<typename StructureType, typename StorageType>
void emitAllocateJSObject(GPRReg resultGPR, const JITAllocator& allocator, GPRReg allocatorGPR, StructureType structure, StorageType storage, GPRReg scratchGPR, JumpList& slowPath)
{
emitAllocateJSCell(resultGPR, allocator, allocatorGPR, structure, scratchGPR, slowPath);
storePtr(storage, Address(resultGPR, JSObject::butterflyOffset()));
}
template<typename ClassType, typename StructureType, typename StorageType>
void emitAllocateJSObjectWithKnownSize(
VM& vm, GPRReg resultGPR, StructureType structure, StorageType storage, GPRReg scratchGPR1,
GPRReg scratchGPR2, JumpList& slowPath, size_t size)
{
Allocator allocator = subspaceFor<ClassType>(vm)->allocatorForNonVirtual(size, AllocatorForMode::AllocatorIfExists);
emitAllocateJSObject(resultGPR, JITAllocator::constant(allocator), scratchGPR1, structure, storage, scratchGPR2, slowPath);
}
template<typename ClassType, typename StructureType, typename StorageType>
void emitAllocateJSObject(VM& vm, GPRReg resultGPR, StructureType structure, StorageType storage, GPRReg scratchGPR1, GPRReg scratchGPR2, JumpList& slowPath)
{
emitAllocateJSObjectWithKnownSize<ClassType>(vm, resultGPR, structure, storage, scratchGPR1, scratchGPR2, slowPath, ClassType::allocationSize(0));
}
// allocationSize can be aliased with any of the other input GPRs. If it's not aliased then it
// won't be clobbered.
void emitAllocateVariableSized(GPRReg resultGPR, CompleteSubspace& subspace, GPRReg allocationSize, GPRReg scratchGPR1, GPRReg scratchGPR2, JumpList& slowPath);
template<typename ClassType, typename StructureType>
void emitAllocateVariableSizedCell(VM& vm, GPRReg resultGPR, StructureType structure, GPRReg allocationSize, GPRReg scratchGPR1, GPRReg scratchGPR2, JumpList& slowPath)
{
CompleteSubspace& subspace = *subspaceFor<ClassType>(vm);
emitAllocateVariableSized(resultGPR, subspace, allocationSize, scratchGPR1, scratchGPR2, slowPath);
emitStoreStructureWithTypeInfo(structure, resultGPR, scratchGPR2);
}
template<typename ClassType, typename StructureType>
void emitAllocateVariableSizedJSObject(VM& vm, GPRReg resultGPR, StructureType structure, GPRReg allocationSize, GPRReg scratchGPR1, GPRReg scratchGPR2, JumpList& slowPath)
{
emitAllocateVariableSizedCell<ClassType>(vm, resultGPR, structure, allocationSize, scratchGPR1, scratchGPR2, slowPath);
storePtr(TrustedImmPtr(nullptr), Address(resultGPR, JSObject::butterflyOffset()));
}
void emitConvertValueToBoolean(VM&, JSValueRegs value, GPRReg result, GPRReg scratchIfShouldCheckMasqueradesAsUndefined, FPRReg, FPRReg, bool shouldCheckMasqueradesAsUndefined, JSGlobalObject*, bool negateResult = false);
template<typename ClassType>
void emitAllocateDestructibleObject(VM& vm, GPRReg resultGPR, Structure* structure, GPRReg scratchGPR1, GPRReg scratchGPR2, JumpList& slowPath)
{
auto butterfly = TrustedImmPtr(nullptr);
emitAllocateJSObject<ClassType>(vm, resultGPR, TrustedImmPtr(structure), butterfly, scratchGPR1, scratchGPR2, slowPath);
storePtr(TrustedImmPtr(PoisonedClassInfoPtr(structure->classInfo()).bits()), Address(resultGPR, JSDestructibleObject::classInfoOffset()));
}
void emitInitializeInlineStorage(GPRReg baseGPR, unsigned inlineCapacity)
{
for (unsigned i = 0; i < inlineCapacity; ++i)
storeTrustedValue(JSValue(), Address(baseGPR, JSObject::offsetOfInlineStorage() + i * sizeof(EncodedJSValue)));
}
void emitInitializeInlineStorage(GPRReg baseGPR, GPRReg inlineCapacity)
{
Jump empty = branchTest32(Zero, inlineCapacity);
Label loop = label();
sub32(TrustedImm32(1), inlineCapacity);
storeTrustedValue(JSValue(), BaseIndex(baseGPR, inlineCapacity, TimesEight, JSObject::offsetOfInlineStorage()));
branchTest32(NonZero, inlineCapacity).linkTo(loop, this);
empty.link(this);
}
void emitInitializeOutOfLineStorage(GPRReg butterflyGPR, unsigned outOfLineCapacity)
{
for (unsigned i = 0; i < outOfLineCapacity; ++i)
storeTrustedValue(JSValue(), Address(butterflyGPR, -sizeof(IndexingHeader) - (i + 1) * sizeof(EncodedJSValue)));
}
#if USE(JSVALUE64)
void wangsInt64Hash(GPRReg inputAndResult, GPRReg scratch);
#endif
// This assumes that index and length are 32-bit. This also assumes that they are already
// zero-extended. Also this does not clobber index, which is useful in the baseline JIT. This
// permits length and result to be in the same register.
void emitPreparePreciseIndexMask32(GPRReg index, GPRReg length, GPRReg result);
void emitDynamicPoison(GPRReg base, GPRReg poisonValue);
void emitDynamicPoisonOnLoadedType(GPRReg base, GPRReg actualType, JSType expectedType);
void emitDynamicPoisonOnType(GPRReg base, GPRReg scratch, JSType expectedType);
#if ENABLE(WEBASSEMBLY)
void loadWasmContextInstance(GPRReg dst);
void storeWasmContextInstance(GPRReg src);
static bool loadWasmContextInstanceNeedsMacroScratchRegister();
static bool storeWasmContextInstanceNeedsMacroScratchRegister();
#endif
protected:
void copyCalleeSavesToEntryFrameCalleeSavesBufferImpl(GPRReg calleeSavesBuffer);
CodeBlock* m_codeBlock;
CodeBlock* m_baselineCodeBlock;
};
} // namespace JSC
#endif // ENABLE(JIT)