AssemblyHelpers(CodeBlock* codeBlock)

: m_codeBlock(codeBlock)

, m_baselineCodeBlock(codeBlock ? codeBlock->baselineAlternative() : nullptr)

{

if (m_codeBlock) {

ASSERT(m_baselineCodeBlock);

ASSERT(!m_baselineCodeBlock->alternative());

ASSERT(m_baselineCodeBlock->jitType() == JITType::None || JITCode::isBaselineCode(m_baselineCodeBlock->jitType()));

}

}

CodeBlock* codeBlock() { return m_codeBlock; }

VM& vm() { return m_codeBlock->vm(); }

AssemblerType_T& assembler() { return m_assembler; }

void prepareCallOperation(VM& vm)

{

UNUSED_PARAM(vm);

#if !USE(BUILTIN_FRAME_ADDRESS) || ASSERT_ENABLED

storePtr(GPRInfo::callFrameRegister, &vm.topCallFrame);

#endif

}

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

}

#if USE(JSVALUE64)

void store64FromReg(Reg src, Address dst)

{

if (src.isFPR())

storeDouble(src.fpr(), dst);

else

store64(src.gpr(), dst);

}

#endif

void store32FromReg(Reg src, Address dst)

{

if (src.isFPR())

storeFloat(src.fpr(), dst);

else

store32(src.gpr(), dst);

}

void storeReg(Reg src, Address dst)

{

#if USE(JSVALUE64)

store64FromReg(src, dst);

#else

store32FromReg(src, dst);

#endif

}

#if USE(JSVALUE64)

void load64ToReg(Address src, Reg dst)

{

if (dst.isFPR())

loadDouble(src, dst.fpr());

else

load64(src, dst.gpr());

}

#endif

void load32ToReg(Address src, Reg dst)

{

if (dst.isFPR())

loadFloat(src, dst.fpr());

else

load32(src, dst.gpr());

}

void loadReg(Address src, Reg dst)

{

#if USE(JSVALUE64)

load64ToReg(src, dst);

#else

load32ToReg(src, dst);

#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);

const 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);

const 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);

const 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::numberTagRegister, GPRInfo::notCellMaskRegister);

#else

push(GPRInfo::numberTagRegister);

push(GPRInfo::notCellMaskRegister);

#endif

emitMaterializeTagCheckRegisters();

#endif

}

void emitRestoreCalleeSaves()

{

emitRestoreCalleeSavesFor(codeBlock());

}

void emitRestoreSavedTagRegisters()

{

#if USE(JSVALUE64)

#if CPU(ARM64)

popPair(GPRInfo::numberTagRegister, GPRInfo::notCellMaskRegister);

#else

pop(GPRInfo::notCellMaskRegister);

pop(GPRInfo::numberTagRegister);

#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();

const 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(JSValue::NumberTag), GPRInfo::numberTagRegister);

or64(MacroAssembler::TrustedImm32(JSValue::OtherTag), GPRInfo::numberTagRegister, GPRInfo::notCellMaskRegister);

#endif

}

#if CPU(X86_64)

static constexpr 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);

}

// dest = base + index << shift.

void shiftAndAdd(RegisterID base, RegisterID index, uint8_t shift, RegisterID dest, Optional<RegisterID> optionalScratch = { })

{

ASSERT(shift < 32);

if (shift <= 3) {

x86Lea64(BaseIndex(base, index, static_cast<Scale>(shift)), dest);

return;

}

RegisterID scratch = dest;

bool needToPreserveIndexRegister = false;

if (base == dest) {

scratch = optionalScratch ? optionalScratch.value() : scratchRegister();

if (base == scratch) {

scratch = index;

needToPreserveIndexRegister = true;

} else if (index == scratch)

needToPreserveIndexRegister = true;

if (needToPreserveIndexRegister)

push(index);

}

move(index, scratch);

lshift64(TrustedImm32(shift), scratch);

m_assembler.leaq_mr(0, base, scratch, 0, dest);

if (needToPreserveIndexRegister)

pop(index);

}

#endif // CPU(X86_64)

#if CPU(ARM_THUMB2) || CPU(ARM64)

static constexpr 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);

}

#if CPU(ARM64)

// dest = base + index << shift.

void shiftAndAdd(RegisterID base, RegisterID index, uint8_t shift, RegisterID dest, Optional<RegisterID> = { })

{

ASSERT(shift < 32);

ASSERT(base != index);

getEffectiveAddress(BaseIndex(base, index, static_cast<Scale>(shift)), dest);

}

#endif // CPU(ARM64)

#endif

#if CPU(MIPS)

static constexpr 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(VirtualRegister entry, GPRReg to, GPRReg from = GPRInfo::callFrameRegister)

{

ASSERT(entry.isHeader());

loadPtr(Address(from, entry.offset() * sizeof(Register)), to);

}

void emitGetFromCallFrameHeader32(VirtualRegister entry, GPRReg to, GPRReg from = GPRInfo::callFrameRegister)

{

ASSERT(entry.isHeader());

load32(Address(from, entry.offset() * sizeof(Register)), to);

}

#if USE(JSVALUE64)

void emitGetFromCallFrameHeader64(VirtualRegister entry, GPRReg to, GPRReg from = GPRInfo::callFrameRegister)

{

ASSERT(entry.isHeader());

load64(Address(from, entry.offset() * sizeof(Register)), to);

}

#endif // USE(JSVALUE64)

void emitPutToCallFrameHeader(GPRReg from, VirtualRegister entry)

{

ASSERT(entry.isHeader());

storePtr(from, Address(GPRInfo::callFrameRegister, entry.offset() * sizeof(Register)));

}

void emitPutToCallFrameHeader(void* value, VirtualRegister entry)

{

ASSERT(entry.isHeader());

storePtr(TrustedImmPtr(value), Address(GPRInfo::callFrameRegister, entry.offset() * 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, VirtualRegister entry)

{

storePtr(from, Address(stackPointerRegister, entry.offset() * static_cast<ptrdiff_t>(sizeof(Register)) - prologueStackPointerDelta()));

}

#else

void emitPutPayloadToCallFrameHeaderBeforePrologue(GPRReg from, VirtualRegister entry)

{

storePtr(from, Address(stackPointerRegister, entry.offset() * static_cast<ptrdiff_t>(sizeof(Register)) - prologueStackPointerDelta() + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload)));

}

void emitPutTagToCallFrameHeaderBeforePrologue(TrustedImm32 tag, VirtualRegister entry)

{

storePtr(tag, Address(stackPointerRegister, entry.offset() * 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::notCellMaskRegister);

return branchTest64(NonZero, reg, TrustedImm64(JSValue::NotCellMask));

#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::notCellMaskRegister);

return branchTest64(Zero, reg, TrustedImm64(JSValue::NotCellMask));

#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(~JSValue::UndefinedTag), tempGPR);

return branch64(Equal, tempGPR, TrustedImm64(JSValue::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(~JSValue::UndefinedTag), tempGPR);

return branch64(NotEqual, tempGPR, TrustedImm64(JSValue::ValueNull));

#else

or32(TrustedImm32(1), regs.tagGPR(), tempGPR);

return branch32(NotEqual, tempGPR, TrustedImm32(JSValue::NullTag));

#endif

}

Jump branchIfInt32(GPRReg gpr, TagRegistersMode mode = HaveTagRegisters)

{

#if USE(JSVALUE64)

if (mode == HaveTagRegisters)

return branch64(AboveOrEqual, gpr, GPRInfo::numberTagRegister);

return branch64(AboveOrEqual, gpr, TrustedImm64(JSValue::NumberTag));

#else

UNUSED_PARAM(mode);

return branch32(Equal, gpr, TrustedImm32(JSValue::Int32Tag));

#endif

}

Jump branchIfInt32(JSValueRegs regs, TagRegistersMode mode = HaveTagRegisters)

{

#if USE(JSVALUE64)

return branchIfInt32(regs.gpr(), mode);

#else

return branchIfInt32(regs.tagGPR(), mode);

#endif

}

Jump branchIfNotInt32(GPRReg gpr, TagRegistersMode mode = HaveTagRegisters)

{

#if USE(JSVALUE64)

if (mode == HaveTagRegisters)

return branch64(Below, gpr, GPRInfo::numberTagRegister);

return branch64(Below, gpr, TrustedImm64(JSValue::NumberTag));

#else

UNUSED_PARAM(mode);

return branch32(NotEqual, gpr, TrustedImm32(JSValue::Int32Tag));

#endif

}

Jump branchIfNotInt32(JSValueRegs regs, TagRegistersMode mode = HaveTagRegisters)

{

#if USE(JSVALUE64)

return branchIfNotInt32(regs.gpr(), mode);

#else

return branchIfNotInt32(regs.tagGPR(), mode);

#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);

ASSERT(tempGPR != InvalidGPRReg);

add32(TrustedImm32(1), regs.tagGPR(), tempGPR);

return branch32(Below, tempGPR, TrustedImm32(JSValue::LowestTag + 1));

#endif

}

#if USE(JSVALUE64)

Jump branchIfNumber(GPRReg gpr, TagRegistersMode mode = HaveTagRegisters)

{

if (mode == HaveTagRegisters)

return branchTest64(NonZero, gpr, GPRInfo::numberTagRegister);

return branchTest64(NonZero, gpr, TrustedImm64(JSValue::NumberTag));

}

#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 gpr, TagRegistersMode mode = HaveTagRegisters)

{

if (mode == HaveTagRegisters)

return branchTest64(Zero, gpr, GPRInfo::numberTagRegister);

return branchTest64(Zero, gpr, TrustedImm64(JSValue::NumberTag));

}

#endif

Jump branchIfNotDoubleKnownNotInt32(JSValueRegs regs, TagRegistersMode mode = HaveTagRegisters)

{

#if USE(JSVALUE64)

if (mode == HaveTagRegisters)

return branchTest64(Zero, regs.gpr(), GPRInfo::numberTagRegister);

return branchTest64(Zero, regs.gpr(), TrustedImm64(JSValue::NumberTag));

#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(GPRReg gpr, GPRReg tempGPR)

{

#if USE(JSVALUE64)

ASSERT(tempGPR != InvalidGPRReg);

move(gpr, tempGPR);

xor64(TrustedImm32(JSValue::ValueFalse), tempGPR);

return branchTest64(Zero, tempGPR, TrustedImm32(static_cast<int32_t>(~1)));

#else

UNUSED_PARAM(tempGPR);

return branch32(Equal, gpr, TrustedImm32(JSValue::BooleanTag));

#endif

}

// Note that the tempGPR is not used in 32-bit mode.

Jump branchIfBoolean(JSValueRegs regs, GPRReg tempGPR)

{

#if USE(JSVALUE64)

return branchIfBoolean(regs.gpr(), tempGPR);

#else

return branchIfBoolean(regs.tagGPR(), tempGPR);

#endif

}

// Note that the tempGPR is not used in 32-bit mode.

Jump branchIfNotBoolean(GPRReg gpr, GPRReg tempGPR)

{

#if USE(JSVALUE64)

ASSERT(tempGPR != InvalidGPRReg);

move(gpr, tempGPR);

xor64(TrustedImm32(JSValue::ValueFalse), tempGPR);

return branchTest64(NonZero, tempGPR, TrustedImm32(static_cast<int32_t>(~1)));

#else

UNUSED_PARAM(tempGPR);

return branch32(NotEqual, gpr, TrustedImm32(JSValue::BooleanTag));

#endif

}

// Note that the tempGPR is not used in 32-bit mode.

Jump branchIfNotBoolean(JSValueRegs regs, GPRReg tempGPR)

{

#if USE(JSVALUE64)

return branchIfNotBoolean(regs.gpr(), tempGPR);

#else

return branchIfNotBoolean(regs.tagGPR(), tempGPR);

#endif

}

#if USE(BIGINT32)

Jump branchIfBigInt32(GPRReg gpr, GPRReg tempGPR, TagRegistersMode mode = HaveTagRegisters)

{

ASSERT(tempGPR != InvalidGPRReg);