WTF_MAKE_TZONE_NON_HEAP_ALLOCATABLE(AssemblyHelpers);

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() LIFETIME_BOUND { return m_assembler; }

void prepareCallOperation(VM& vm)

{

UNUSED_PARAM(vm);

#if ASSERT_ENABLED

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

#endif

}

#if ENABLE(WEBASSEMBLY)

void NODELETE prepareWasmCallOperation(GPRReg instanceGPR);

#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

}

void store64FromReg(Reg src, Address dst)

{

if (src.isFPR())

storeDouble(src.fpr(), dst);

else

store64(src.gpr(), dst);

}

void store64FromReg(Reg src, BaseIndex dst)

{

if (src.isFPR())

storeDouble(src.fpr(), dst);

else

store64(src.gpr(), dst);

}

void store32FromReg(Reg src, Address dst)

{

if (src.isFPR())

storeFloat(src.fpr(), dst);

else

store32(src.gpr(), dst);

}

void store32FromReg(Reg src, BaseIndex dst)

{

if (src.isFPR())

storeFloat(src.fpr(), dst);

else

store32(src.gpr(), dst);

}

void storeReg(Reg src, Address dst)

{

store64FromReg(src, dst);

}

void load64ToReg(Address src, Reg dst)

{

if (dst.isFPR())

loadDouble(src, dst.fpr());

else

load64(src, dst.gpr());

}

void load32ToReg(Address src, Reg dst)

{

if (dst.isFPR())

loadFloat(src, dst.fpr());

else

load32(src, dst.gpr());

}

void loadReg(Address src, Reg dst)

{

load64ToReg(src, dst);

}

template<typename T, typename U>

void storeCell(T cell, U address)

{

store64(cell, address);

}

template<typename U>

void storeCell(GPRReg cell, U address)

{

store64(cell, address);

}

void storeCell(JSValueRegs regs, void* address)

{

store64(regs.gpr(), address);

}

void loadCell(Address address, GPRReg gpr)

{

load64(address, gpr);

}

void storeValue(JSValueRegs regs, Address address)

{

store64(regs.gpr(), address);

}

void storeValue(JSValueRegs regs, BaseIndex address)

{

store64(regs.gpr(), address);

}

void storeValue(JSValueRegs regs, void* address)

{

store64(regs.gpr(), address);

}

void loadValue(Address address, JSValueRegs regs)

{

load64(address, regs.gpr());

}

void loadValue(BaseIndex address, JSValueRegs regs)

{

load64(address, regs.gpr());

}

void loadValue(void* address, JSValueRegs regs)

{

load64(address, regs.gpr());

}

// Note that these clobber offset.

void loadProperty(GPRReg object, GPRReg offset, JSValueRegs result);

void storeProperty(JSValueRegs value, GPRReg object, GPRReg offset, GPRReg scratch);

JumpList loadMegamorphicProperty(VM&, GPRReg baseGPR, GPRReg uidGPR, UniquedStringImpl*, GPRReg resultGPR, GPRReg scratch1GPR, GPRReg scratch2GPR, GPRReg scratch3GPR);

JumpList loadMegamorphicGetterSetter(VM&, GPRReg baseGPR, GPRReg uidGPR, UniquedStringImpl*, GPRReg resultGPR, GPRReg scratch1GPR, GPRReg scratch2GPR, GPRReg scratch3GPR);

template<uint32_t primaryMask, ptrdiff_t primaryEntriesOffset, uint32_t secondaryMask, ptrdiff_t secondaryEntriesOffset>

JumpList findMegamorphicCacheEntry(VM&, GPRReg baseGPR, GPRReg uidGPR, UniquedStringImpl*, GPRReg scratch1GPR, GPRReg scratch2GPR, GPRReg scratch3GPR);

std::tuple<JumpList, JumpList> storeMegamorphicProperty(VM&, GPRReg baseGPR, GPRReg uidGPR, UniquedStringImpl*, GPRReg valueGPR, GPRReg scratch1GPR, GPRReg scratch2GPR, GPRReg scratch3GPR);

JumpList hasMegamorphicProperty(VM&, GPRReg baseGPR, GPRReg uidGPR, UniquedStringImpl*, GPRReg resultGPR, GPRReg scratch1GPR, GPRReg scratch2GPR, GPRReg scratch3GPR);

JumpList loadCacheableIdentifierImpl(GPRReg propertyGPR, GPRReg destGPR, bool propertyIsString, bool propertyIsSymbol, bool canBeRope = true);

void moveValueRegs(JSValueRegs srcRegs, JSValueRegs destRegs)

{

move(srcRegs.gpr(), destRegs.gpr());

}

void moveValue(JSValue value, JSValueRegs regs)

{

move(Imm64(JSValue::encode(value)), regs.gpr());

}

void moveTrustedValue(JSValue value, JSValueRegs regs)

{

move(TrustedImm64(JSValue::encode(value)), regs.gpr());

}

void storeValue(JSValue value, Address address)

{

store64(Imm64(JSValue::encode(value)), address);

}

void storeTrustedValue(JSValue value, Address address)

{

store64(TrustedImm64(JSValue::encode(value)), address);

}

void storeTrustedValue(JSValue value, BaseIndex address)

{

store64(TrustedImm64(JSValue::encode(value)), address);

}

template<typename Op> class Spooler;

class LoadRegSpooler;

class StoreRegSpooler;

class CopySpooler;

Address addressFor(const RegisterAtOffset& entry)

{

return Address(GPRInfo::callFrameRegister, entry.offset());

}

void emitSave(const RegisterAtOffsetList&);

void emitRestore(const RegisterAtOffsetList&, GPRReg = GPRInfo::callFrameRegister);

void emitSaveCalleeSavesFor(const RegisterAtOffsetList* calleeSaves);

enum RestoreTagRegisterMode { UseExistingTagRegisterContents, CopyBaselineCalleeSavedRegistersFromBaseFrame };

void emitSaveOrCopyLLIntBaselineCalleeSavesFor(CodeBlock*, VirtualRegister offsetVirtualRegister, RestoreTagRegisterMode, GPRReg temp1, GPRReg temp2, GPRReg temp3);

void emitRestoreCalleeSavesFor(const RegisterAtOffsetList* calleeSaves);

void emitSaveThenMaterializeTagRegisters()

{

#if CPU(ARM64) || CPU(RISCV64)

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

#else

push(GPRInfo::numberTagRegister);

push(GPRInfo::notCellMaskRegister);

#endif

emitMaterializeTagCheckRegisters();

}

void emitRestoreSavedTagRegisters()

{

#if CPU(ARM64) || CPU(RISCV64)

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

#else

pop(GPRInfo::notCellMaskRegister);

pop(GPRInfo::numberTagRegister);

#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, GPRReg scratch)

{

#if NUMBER_OF_CALLEE_SAVES_REGISTERS > 0

loadPtr(&topEntryFrame, scratch);

copyCalleeSavesToEntryFrameCalleeSavesBufferImpl(scratch);

#else

UNUSED_PARAM(topEntryFrame);

UNUSED_PARAM(scratch);

#endif

}

void copyCalleeSavesToEntryFrameCalleeSavesBuffer(GPRReg topEntryFrame)

{

#if NUMBER_OF_CALLEE_SAVES_REGISTERS > 0

copyCalleeSavesToEntryFrameCalleeSavesBufferImpl(topEntryFrame);

#else

UNUSED_PARAM(topEntryFrame);

#endif

}

void restoreCalleeSavesFromEntryFrameCalleeSavesBuffer(EntryFrame*&);

void restoreCalleeSavesFromVMEntryFrameCalleeSavesBuffer(GPRReg vmGPR, GPRReg scratchGPR);

void restoreCalleeSavesFromVMEntryFrameCalleeSavesBufferImpl(GPRReg entryFrame, const RegisterSet& skipList);

void copyLLIntBaselineCalleeSavesFromFrameOrRegisterToEntryFrameCalleeSavesBuffer(EntryFrame*&, const RegisterSet& usedRegisters = RegisterSet::stubUnavailableRegisters());

void emitMaterializeTagCheckRegisters()

{

move(MacroAssembler::TrustedImm64(JSValue::NumberTag), GPRInfo::numberTagRegister);

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

}

#if CPU(X86_64)

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, std::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(ARM64)

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, std::optional<RegisterID> = { })

{

ASSERT(shift < 32);

ASSERT(base != index);

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

}

#endif // CPU(ARM64)

#endif

#if CPU(RISCV64)

void emitFunctionPrologue()

{

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

void getArityPadding(VM&, unsigned numberOfParameters, GPRReg argumentCountIncludingThisGPR, GPRReg paddingOutputGPR, GPRReg scratchGPR0, GPRReg scratchGPR1, JumpList& stackOverflow);

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

{

ASSERT(entry.isHeader());

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

}

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 emitPutCellToCallFrameHeader(GPRReg from, VirtualRegister entry)

{

ASSERT(entry.isHeader());

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

}

void emitZeroToCallFrameHeader(VirtualRegister entry)

{

ASSERT(entry.isHeader());

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

}

JumpList branchIfNotEqual(JSValueRegs regs, JSValue value)

{

return branch64(NotEqual, regs.gpr(), TrustedImm64(JSValue::encode(value)));

}

Jump branchIfEqual(JSValueRegs regs, JSValue value)

{

return branch64(Equal, regs.gpr(), TrustedImm64(JSValue::encode(value)));

}

template<typename T>

Jump branchIfNotCell(T maybeCell, TagRegistersMode mode = HaveTagRegisters)

{

if (mode == HaveTagRegisters)

return branchTest64(NonZero, maybeCell, GPRInfo::notCellMaskRegister);

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

}

Jump branchIfNotCell(JSValueRegs regs, TagRegistersMode mode = HaveTagRegisters)

{

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

}

template<typename T>

Jump branchIfCell(T maybeCell, TagRegistersMode mode = HaveTagRegisters)

{

if (mode == HaveTagRegisters)

return branchTest64(Zero, maybeCell, GPRInfo::notCellMaskRegister);

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

}

Jump branchIfCell(JSValueRegs regs, TagRegistersMode mode = HaveTagRegisters)

{

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

}

Jump branchIfOther(JSValueRegs regs, GPRReg tempGPR)

{

and64(TrustedImm32(~JSValue::UndefinedTag), regs.gpr(), tempGPR);

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

}

Jump branchIfNotOther(JSValueRegs regs, GPRReg tempGPR)

{

and64(TrustedImm32(~JSValue::UndefinedTag), regs.gpr(), tempGPR);

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

}

Jump branchIfInt32(GPRReg gpr, TagRegistersMode mode = HaveTagRegisters)

{

if (mode == HaveTagRegisters)

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

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

}

Jump branchIfInt32(JSValueRegs regs, TagRegistersMode mode = HaveTagRegisters)

{

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

}

Jump branchIfNotInt32(GPRReg gpr, TagRegistersMode mode = HaveTagRegisters)

{

if (mode == HaveTagRegisters)

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

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

}

Jump branchIfNotInt32(JSValueRegs regs, TagRegistersMode mode = HaveTagRegisters)

{

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

}

Jump branchIfNumber(GPRReg gpr, TagRegistersMode mode = HaveTagRegisters)

{

if (mode == HaveTagRegisters)

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

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

}

Jump branchIfNumber(JSValueRegs regs, TagRegistersMode mode = HaveTagRegisters)

{

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

}

Jump branchIfNotNumber(GPRReg gpr, TagRegistersMode mode = HaveTagRegisters)

{

if (mode == HaveTagRegisters)

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

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

}

Jump branchIfNotNumber(JSValueRegs regs, TagRegistersMode mode = HaveTagRegisters)

{

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

}

Jump branchIfNotDoubleKnownNotInt32(JSValueRegs regs, TagRegistersMode mode = HaveTagRegisters)

{

if (mode == HaveTagRegisters)

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

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

}

Jump branchIfBoolean(GPRReg gpr, GPRReg tempGPR)

{

ASSERT(tempGPR != InvalidGPRReg);

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

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

}

Jump branchIfBoolean(JSValueRegs regs, GPRReg tempGPR)

{

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

}

Jump branchIfNotBoolean(GPRReg gpr, GPRReg tempGPR)

{

ASSERT(tempGPR != InvalidGPRReg);

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

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

}

Jump branchIfNotBoolean(JSValueRegs regs, GPRReg tempGPR)

{

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

}

#if USE(BIGINT32)

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

{

ASSERT(tempGPR != InvalidGPRReg);

if (mode == HaveTagRegisters && gpr != tempGPR) {

static_assert(JSValue::BigInt32Mask == JSValue::NumberTag + JSValue::BigInt32Tag);

add64(TrustedImm32(JSValue::BigInt32Tag), GPRInfo::numberTagRegister, tempGPR);

and64(gpr, tempGPR);

return branch64(Equal, tempGPR, TrustedImm32(JSValue::BigInt32Tag));

}

and64(TrustedImm64(JSValue::BigInt32Mask), gpr, tempGPR);

return branch64(Equal, tempGPR, TrustedImm32(JSValue::BigInt32Tag));

}

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

{

ASSERT(tempGPR != InvalidGPRReg);

if (mode == HaveTagRegisters && gpr != tempGPR) {

static_assert(JSValue::BigInt32Mask == JSValue::NumberTag + JSValue::BigInt32Tag);

add64(TrustedImm32(JSValue::BigInt32Tag), GPRInfo::numberTagRegister, tempGPR);

and64(gpr, tempGPR);

return branch64(NotEqual, tempGPR, TrustedImm32(JSValue::BigInt32Tag));

}

and64(TrustedImm64(JSValue::BigInt32Mask), gpr, tempGPR);

return branch64(NotEqual, tempGPR, TrustedImm32(JSValue::BigInt32Tag));

}

Jump branchIfBigInt32(JSValueRegs regs, GPRReg tempGPR, TagRegistersMode mode = HaveTagRegisters)

{

return branchIfBigInt32(regs.gpr(), tempGPR, mode);

}

Jump branchIfNotBigInt32(JSValueRegs regs, GPRReg tempGPR, TagRegistersMode mode = HaveTagRegisters)

{

return branchIfNotBigInt32(regs.gpr(), tempGPR, mode);

}

#endif // USE(BIGINT32)

// FIXME: rename these to make it clear that they require their input to be a cell.

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

}

// Note that first and last are inclusive.

Jump branchIfType(GPRReg cellGPR, JSTypeRange range)

{

if (range.last == range.first)

return branch8(Equal, Address(cellGPR, JSCell::typeInfoTypeOffset()), TrustedImm32(range.first));

ASSERT(range.last > range.first);

GPRReg scratch = scratchRegister();

load8(Address(cellGPR, JSCell::typeInfoTypeOffset()), scratch);

sub32(TrustedImm32(range.first), scratch);

return branch32(BelowOrEqual, scratch, TrustedImm32(range.last - range.first));

}

Jump branchIfType(GPRReg cellGPR, JSType type)

{

return branchIfType(cellGPR, JSTypeRange { type, type });

}

Jump branchIfNotType(GPRReg cellGPR, JSTypeRange range)

{

if (range.last == range.first)

return branch8(NotEqual, Address(cellGPR, JSCell::typeInfoTypeOffset()), TrustedImm32(range.first));

ASSERT(range.last > range.first);

GPRReg scratch = scratchRegister();

load8(Address(cellGPR, JSCell::typeInfoTypeOffset()), scratch);

sub32(TrustedImm32(range.first), scratch);

return branch32(Above, scratch, TrustedImm32(range.last - range.first));

}

Jump branchIfNotType(GPRReg cellGPR, JSType type)

{

return branchIfNotType(cellGPR, JSTypeRange { type, type });

}

// FIXME: rename these to make it clear that they require their input to be a cell.

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 branchIfHeapBigInt(GPRReg cellGPR) { return branchIfType(cellGPR, HeapBigIntType); }

Jump branchIfNotHeapBigInt(GPRReg cellGPR) { return branchIfNotType(cellGPR, HeapBigIntType); }

Jump branchIfFunction(GPRReg cellGPR) { return branchIfType(cellGPR, JSFunctionType); }

Jump branchIfNotFunction(GPRReg cellGPR) { return branchIfNotType(cellGPR, JSFunctionType); }

Jump branchIfStructure(GPRReg cellGPR) { return branchIfType(cellGPR, StructureType); }

Jump branchIfNotStructure(GPRReg cellGPR) { return branchIfNotType(cellGPR, StructureType); }

void isEmpty(GPRReg gpr, GPRReg dst)

{

test64(Zero, gpr, gpr, dst);

}

void toBigInt64(GPRReg cellGPR, GPRReg destGPR)

{

ASSERT(noOverlap(cellGPR, destGPR));

load32(Address(cellGPR, JSBigInt::offsetOfLength()), destGPR);

JumpList doneCases;

doneCases.append(branchTest32(Zero, destGPR));

load64(Address(cellGPR, JSBigInt::offsetOfData()), destGPR);

doneCases.append(branchTest8(Zero, Address(cellGPR, JSCell::typeInfoFlagsOffset()), TrustedImm32(TypeInfoPerCellBit)));

neg64(destGPR);

doneCases.link(this);

}

void isNotEmpty(GPRReg gpr, GPRReg dst)

{

test64(NonZero, gpr, gpr, dst);

}

Jump branchIfEmpty(BaseIndex address)

{

return branchTest64(Zero, address);

}

Jump branchIfEmpty(GPRReg gpr)

{

return branchTest64(Zero, gpr);

}

Jump branchIfEmpty(JSValueRegs regs)

{

return branchIfEmpty(regs.gpr());

}

Jump branchIfNotEmpty(BaseIndex address)

{

return branchTest64(NonZero, address);

}

Jump branchIfNotEmpty(GPRReg gpr)

{

return branchTest64(NonZero, gpr);

}

Jump branchIfNotEmpty(JSValueRegs regs)

{

return branchIfNotEmpty(regs.gpr());

}

void isUndefined(JSValueRegs regs, GPRReg dst)

{

compare64(Equal, regs.payloadGPR(), TrustedImm32(JSValue::ValueUndefined), dst);

}

// Note that this function does not respect MasqueradesAsUndefined.

Jump branchIfUndefined(GPRReg gpr)

{

return branch64(Equal, gpr, TrustedImm64(JSValue::encode(jsUndefined())));

}

// Note that this function does not respect MasqueradesAsUndefined.

Jump branchIfUndefined(JSValueRegs regs)

{

return branchIfUndefined(regs.gpr());

}

// Note that this function does not respect MasqueradesAsUndefined.

Jump branchIfNotUndefined(GPRReg gpr)

{

return branch64(NotEqual, gpr, TrustedImm64(JSValue::encode(jsUndefined())));

}

// Note that this function does not respect MasqueradesAsUndefined.

Jump branchIfNotUndefined(JSValueRegs regs)

{

return branchIfNotUndefined(regs.gpr());

}

void isNull(JSValueRegs regs, GPRReg dst)

{

compare64(Equal, regs.payloadGPR(), TrustedImm32(JSValue::ValueNull), dst);

}

void isNotNull(JSValueRegs regs, GPRReg dst)

{

compare64(NotEqual, regs.payloadGPR(), TrustedImm32(JSValue::ValueNull), dst);

}

Jump branchIfNull(GPRReg gpr)

{

return branch64(Equal, gpr, TrustedImm64(JSValue::encode(jsNull())));

}

Jump branchIfNull(JSValueRegs regs)

{

return branchIfNull(regs.gpr());

}

Jump branchIfNotNull(GPRReg gpr)

{

return branch64(NotEqual, gpr, TrustedImm64(JSValue::encode(jsNull())));

}

Jump branchIfNotNull(JSValueRegs regs)

{

return branchIfNotNull(regs.gpr());

}

Jump branchIfTrue(GPRReg gpr)

{

return branch64(Equal, gpr, TrustedImm64(JSValue::encode(jsBoolean(true))));

}

Jump branchIfNotTrue(GPRReg gpr)

{

return branch64(NotEqual, gpr, TrustedImm64(JSValue::encode(jsBoolean(true))));

}

Jump branchIfFalse(GPRReg gpr)

{

return branch64(Equal, gpr, TrustedImm64(JSValue::encode(jsBoolean(false))));

}

Jump branchIfNotFalse(GPRReg gpr)

{

return branch64(NotEqual, gpr, TrustedImm64(JSValue::encode(jsBoolean(false))));

}

template<typename T>

Jump branchStructure(RelationalCondition condition, T leftHandSide, Structure* structure)

{

return branch32(condition, leftHandSide, TrustedImm32(structure->id().bits()));

}

Jump branchIfFastTypedArray(GPRReg baseGPR);

Jump branchIfNotFastTypedArray(GPRReg baseGPR);

Jump branchIfNaN(FPRReg fpr)

{

return branchDouble(DoubleNotEqualOrUnordered, fpr, fpr);

}

Jump branchIfNotNaN(FPRReg fpr)

{

return branchDouble(DoubleEqualAndOrdered, fpr, fpr);

}

Jump branchIfRopeStringImpl(GPRReg stringImplGPR)

{

return branchTestPtr(NonZero, stringImplGPR, TrustedImm32(JSString::isRopeInPointer));

}

Jump branchIfNotRopeStringImpl(GPRReg stringImplGPR)

{

return branchTestPtr(Zero, stringImplGPR, TrustedImm32(JSString::isRopeInPointer));

}

// Returns the cases where implGPR, already loaded from stringGPR, is not an AtomStringImpl. The

// per-cell bit lets both checks be skipped when it is set; a clear bit proves nothing, so the

// checks remain on the fall-through path. stringGPR must survive the impl load, so the two

// registers cannot be the same: the flags byte of a JSCell overlaps StringImpl::m_length.

JumpList branchIfNotAtomStringImpl(GPRReg stringGPR, GPRReg implGPR, bool canBeRope = true)

{

ASSERT(noOverlap(stringGPR, implGPR));

JumpList notAtomCases;

Jump knownAtom = branchTest8(NonZero, Address(stringGPR, JSCell::typeInfoFlagsOffset()), TrustedImm32(TypeInfoPerCellBit));

if (canBeRope)

notAtomCases.append(branchIfRopeStringImpl(implGPR));

notAtomCases.append(branchTest32(Zero, Address(implGPR, StringImpl::flagsOffset()), TrustedImm32(StringImpl::flagIsAtom())));

knownAtom.link(this);

return notAtomCases;

}

JumpList branchIfInlineWatchpointSetIsStillValid(GPRReg setThenScratchGPR)

{

JumpList result;

loadPtr(Address(setThenScratchGPR, InlineWatchpointSet::offsetOfData()), setThenScratchGPR);

auto isThinInvalidated = branchPtr(Equal, setThenScratchGPR, TrustedImmPtr(InlineWatchpointSet::encodeState(IsInvalidated)));

result.append(branchTestPtr(NonZero, setThenScratchGPR, TrustedImm32(InlineWatchpointSet::IsThinFlag)));

result.append(branch8(NotEqual, Address(setThenScratchGPR, WatchpointSet::offsetOfState()), TrustedImm32(IsInvalidated)));

isThinInvalidated.link(this);

return result;

}

JumpList branchIfInlineWatchpointSetIsStillValid(InlineWatchpointSet& set, GPRReg scratchGPR)

{

if (RefPtr inflatedSet = set.inflatedSetConcurrently()) {

move(TrustedImmPtr(inflatedSet.get()), scratchGPR);

return JumpList { branch8(NotEqual, Address(scratchGPR, WatchpointSet::offsetOfState()), TrustedImm32(IsInvalidated)) };

}

move(TrustedImmPtr(&set), scratchGPR);

return branchIfInlineWatchpointSetIsStillValid(scratchGPR);

}

JumpList branchIfResizableOrGrowableSharedTypedArrayIsOutOfBounds(GPRReg baseGPR, GPRReg scratchGPR, GPRReg scratch2GPR, std::optional<TypedArrayType>);

void loadTypedArrayByteLength(GPRReg baseGPR, GPRReg valueGPR, GPRReg scratchGPR, GPRReg scratch2GPR, TypedArrayType);

std::tuple<Jump, JumpList> loadDataViewByteLength(GPRReg baseGPR, GPRReg valueGPR, GPRReg scratchGPR, GPRReg scratch2GPR, TypedArrayType);

void loadTypedArrayLength(GPRReg baseGPR, GPRReg valueGPR, GPRReg scratchGPR, GPRReg scratch2GPR, std::optional<TypedArrayType>);

void emitTurnUndefinedIntoNull(JSValueRegs regs)

{

static_assert((JSValue::ValueUndefined & ~JSValue::UndefinedTag) == JSValue::ValueNull);

and64(TrustedImm32(~JSValue::UndefinedTag), regs.payloadGPR());

}

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(Operand operand)

{

ASSERT(!operand.isTmp());

return addressFor(operand.virtualRegister());

}

static Address highWordFor(VirtualRegister virtualRegister, GPRReg baseGPR)

{

ASSERT(virtualRegister.isValid());

return Address(baseGPR, virtualRegister.offset() * sizeof(Register) + HighWordOffset);

}

static Address highWordFor(VirtualRegister virtualRegister)

{

ASSERT(virtualRegister.isValid());

return Address(GPRInfo::callFrameRegister, virtualRegister.offset() * sizeof(Register) + HighWordOffset);

}

static Address highWordFor(Operand operand)

{

ASSERT(!operand.isTmp());

return highWordFor(operand.virtualRegister());

}

static Address lowWordFor(VirtualRegister virtualRegister, GPRReg baseGPR)

{

ASSERT(virtualRegister.isValid());

return Address(baseGPR, virtualRegister.offset() * sizeof(Register) + LowWordOffset);

}

static Address lowWordFor(VirtualRegister virtualRegister)

{

ASSERT(virtualRegister.isValid());

return Address(GPRInfo::callFrameRegister, virtualRegister.offset() * sizeof(Register) + LowWordOffset);

}

static Address lowWordFor(Operand operand)

{

ASSERT(!operand.isTmp());