# Copyright (C) 2011-2025 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. AND ITS CONTRIBUTORS ``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 ITS 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.

# Crash course on the language that this is written in (which I just call

# "assembly" even though it's more than that):

#

# - Mostly gas-style operand ordering. The last operand tends to be the

# destination. So "a := b" is written as "mov b, a". But unlike gas,

# comparisons are in-order, so "if (a < b)" is written as

# "bilt a, b, ...".

#

# - "b" = byte, "h" = 16-bit word, "i" = 32-bit word, "q" = 64-bit word,

# "f" = float, "d" = double, "p" = pointer. For 32-bit, "i" and "p" are

# interchangeable except when an op supports one but not the other.

#

# - In general, valid operands for macro invocations and instructions are

# registers (eg "t0"), addresses (eg "4[t0]"), base-index addresses

# (eg "7[t0, t1, 2]"), absolute addresses (eg "0xa0000000[]"), or labels

# (eg "_foo" or ".foo"). Macro invocations can also take anonymous

# macros as operands. Instructions cannot take anonymous macros.

#

# - Labels must have names that begin with either "_" or ".". A "." label

# is local and gets renamed before code gen to minimize namespace

# pollution. A "_" label is an extern symbol (i.e. ".globl"). The "_"

# may or may not be removed during code gen depending on whether the asm

# conventions for C name mangling on the target platform mandate a "_"

# prefix.

#

# - A "macro" is a lambda expression, which may be either anonymous or

# named. But this has caveats. "macro" can take zero or more arguments,

# which may be macros or any valid operands, but it can only return

# code. But you can do Turing-complete things via continuation passing

# style: "macro foo (a, b) b(a, a) end foo(foo, foo)". Actually, don't do

# that, since you'll just crash the assembler.

#

# - An "if" is a conditional on settings. Any identifier supplied in the

# predicate of an "if" is assumed to be a #define that is available

# during code gen. So you can't use "if" for computation in a macro, but

# you can use it to select different pieces of code for different

# platforms.

#

# - Arguments to macros follow lexical scoping rather than dynamic scoping.

# Const's also follow lexical scoping and may override (hide) arguments

# or other consts. All variables (arguments and constants) can be bound

# to operands. Additionally, arguments (but not constants) can be bound

# to macros.

# The following general-purpose registers are available:

#

# - cfr and sp hold the call frame and (native) stack pointer respectively.

# They are callee-save registers, and guaranteed to be distinct from all other

# registers on all architectures.

#

# - lr is defined on non-X86 architectures (ARM64, ARM64E, ARMv7, and CLOOP)

# and holds the return PC

#

# - t0, t1, t2, t3, t4, t5, and optionally t6 and t7 are temporary registers that can get trashed on

# calls, and are pairwise distinct registers. t4 holds the JS program counter, so use

# with caution in opcodes (actually, don't use it in opcodes at all, except as PC).

#

# - r0 and r1 are the platform's customary return registers, and thus are

# two distinct registers

#

# - a0, a1, a2 and a3 are the platform's customary argument registers, and

# thus are pairwise distinct registers. Be mindful that:

#

# - The only registers guaranteed to be caller-saved are r0, r1, a0, a1 and a2, and

# you should be mindful of that in functions that are called directly from C.

# If you need more registers, you should push and pop them like a good

# assembly citizen, because any other register will be callee-saved on X86.

#

# You can additionally assume:

#

# - a3, t2, t3, t4 and t5 are never return registers; t0, t1, a0, a1 and a2

# can be return registers.

#

# - t3 can only be a3, t1 can only be a1; but t0 and t2 can be either a0 or a2.

#

# - There are callee-save registers named csr0, csr1, ... csrN.

# The last three csr registers are used used to store the PC base and

# two special tag values (on 64-bits only). Don't use them for anything else.

#

# Additional platform-specific details (you shouldn't rely on this remaining

# true):

#

# - For consistency with the baseline JIT, t0 is always r0 (and t1 is always

# r1 on 32 bits platforms). You should use the r version when you need return

# registers, and the t version otherwise: code using t0 (or t1) should still

# work if swapped with e.g. t3, while code using r0 (or r1) should not. There

# *may* be legacy code relying on this.

#

# - On all platforms, t0 can only be a0 and t2 can only be a2.

#

# - On all platforms other than X86_64, a2 is not a return register.

# a2 is r1 on X86_64 (because the ABI enforces it).

#

# The following floating-point registers are available:

#

# - ft0-ft5 are temporary floating-point registers that get trashed on calls,

# and are pairwise distinct.

#

# - fa0 and fa1 are the platform's customary floating-point argument

# registers, and are both distinct. On 64-bits platforms, fa2 and fa3 are

# additional floating-point argument registers.

#

# - fr is the platform's customary floating-point return register

#

# You can assume that ft1-ft5 or fa1-fa3 are never fr, and that ftX is never

# faY if X != Y.

# Do not put any code before this.

global _llintPCRangeStart

# This break instruction is needed so that the synthesized llintPCRangeStart# label

# doesn't point to the exact same location as vmEntryToJavaScript which comes after it.

# Otherwise, libunwind will report vmEntryToJavaScript as llintPCRangeStart in

# stack traces.

break

# Work-around for the fact that the toolchain's awareness of armv7k / armv7s

# results in a separate slab in the fat binary, yet the offlineasm doesn't know

# to expect it.

if ARMv7k

if ARMv7s

# First come the common protocols that both interpreters use. Note that each

# of these must have an ASSERT() in LLIntData.cpp

# These declarations must match interpreter/JSStack.h.

const PtrSize = constexpr (sizeof(void*))

const MachineRegisterSize = constexpr (sizeof(CPURegister))

const FPRRegisterSize = 8

const VectorRegisterSize = 16

const SlotSize = constexpr (sizeof(Register))

const SeenMultipleCalleeObjects = 1

if JSVALUE64

const CallFrameHeaderSlots = 5

const CallFrameHeaderSlots = 4

const CallFrameAlignSlots = 1

const JSLexicalEnvironment_variables = (sizeof JSLexicalEnvironment + SlotSize - 1) & ~(SlotSize - 1)

const DirectArguments_storage = (sizeof DirectArguments + SlotSize - 1) & ~(SlotSize - 1)

const JSInternalFieldObjectImpl_internalFields = JSInternalFieldObjectImpl::m_internalFields

const StackAlignment = constexpr (stackAlignmentBytes())

const StackAlignmentSlots = constexpr (stackAlignmentRegisters())

const StackAlignmentMask = StackAlignment - 1

const CallerFrameAndPCSize = constexpr (sizeof(CallerFrameAndPC))

const PrologueStackPointerDelta = constexpr (prologueStackPointerDelta())

const CallerFrame = 0

const ReturnPC = CallerFrame + MachineRegisterSize

const CodeBlock = ReturnPC + MachineRegisterSize

const Callee = CodeBlock + SlotSize

const ArgumentCountIncludingThis = Callee + SlotSize

const ThisArgumentOffset = ArgumentCountIncludingThis + SlotSize

const FirstArgumentOffset = ThisArgumentOffset + SlotSize

const CallFrameHeaderSize = ThisArgumentOffset

const MetadataOffsetTable16Offset = 0

const MetadataOffsetTable32Offset = constexpr UnlinkedMetadataTable::s_offset16TableSize

const NumberOfJSOpcodeIDs = constexpr numOpcodeIDs

# Some value representation constants.

if JSVALUE64

const TagOther = constexpr JSValue::OtherTag

const TagBool = constexpr JSValue::BoolTag

const TagUndefined = constexpr JSValue::UndefinedTag

const ValueEmpty = constexpr JSValue::ValueEmpty

const ValueFalse = constexpr JSValue::ValueFalse

const ValueTrue = constexpr JSValue::ValueTrue

const ValueUndefined = constexpr JSValue::ValueUndefined

const ValueNull = constexpr JSValue::ValueNull

const TagNumber = constexpr JSValue::NumberTag

const NotCellMask = constexpr JSValue::NotCellMask

if BIGINT32

const TagBigInt32 = constexpr JSValue::BigInt32Tag

const MaskBigInt32 = constexpr JSValue::BigInt32Mask

end

const LowestOfHighBits = constexpr JSValue::LowestOfHighBits

const Int32Tag = constexpr JSValue::Int32Tag

const BooleanTag = constexpr JSValue::BooleanTag

const NullTag = constexpr JSValue::NullTag

const UndefinedTag = constexpr JSValue::UndefinedTag

const CellTag = constexpr JSValue::CellTag

const EmptyValueTag = constexpr JSValue::EmptyValueTag

const DeletedValueTag = constexpr JSValue::DeletedValueTag

const InvalidTag = constexpr JSValue::InvalidTag

const LowestTag = constexpr JSValue::LowestTag

if LARGE_TYPED_ARRAYS

const SmallTypedArrayMaxLength = constexpr ArrayProfile::s_smallTypedArrayMaxLength

const maxFrameExtentForSlowPathCall = constexpr maxFrameExtentForSlowPathCall

if X86_64 or ARM64 or ARM64E or RISCV64

const CalleeSaveSpaceAsVirtualRegisters = 4

elsif C_LOOP

const CalleeSaveSpaceAsVirtualRegisters = 1

elsif ARMv7

const CalleeSaveSpaceAsVirtualRegisters = 1

const CalleeSaveSpaceAsVirtualRegisters = 0

const CalleeSaveSpaceStackAligned = (CalleeSaveSpaceAsVirtualRegisters * SlotSize + StackAlignment - 1) & ~StackAlignmentMask

# Watchpoint states

const ClearWatchpoint = constexpr ClearWatchpoint

const IsWatched = constexpr IsWatched

const IsInvalidated = constexpr IsInvalidated

# ShadowChicken data

const ShadowChickenTailMarker = constexpr ShadowChicken::Packet::tailMarkerValue

# UnaryArithProfile data

const ArithProfileInt = constexpr (UnaryArithProfile::observedIntBits())

const ArithProfileNumber = constexpr (UnaryArithProfile::observedNumberBits())

# BinaryArithProfile data

const ArithProfileIntInt = constexpr (BinaryArithProfile::observedIntIntBits())

const ArithProfileNumberInt = constexpr (BinaryArithProfile::observedNumberIntBits())

const ArithProfileIntNumber = constexpr (BinaryArithProfile::observedIntNumberBits())

const ArithProfileNumberNumber = constexpr (BinaryArithProfile::observedNumberNumberBits())

# Pointer Tags

const AddressDiversified = 1

const BytecodePtrTag = constexpr BytecodePtrTag

const CustomAccessorPtrTag = constexpr CustomAccessorPtrTag

const JSEntryPtrTag = constexpr JSEntryPtrTag

const HostFunctionPtrTag = constexpr HostFunctionPtrTag

const JSEntrySlowPathPtrTag = constexpr JSEntrySlowPathPtrTag

const NativeToJITGatePtrTag = constexpr NativeToJITGatePtrTag

const VMEntryToJITGatePtrTag = constexpr VMEntryToJITGatePtrTag

const ExceptionHandlerPtrTag = constexpr ExceptionHandlerPtrTag

const YarrEntryPtrTag = constexpr YarrEntryPtrTag

const CSSSelectorPtrTag = constexpr CSSSelectorPtrTag

const LLIntToWasmEntryPtrTag = constexpr LLIntToWasmEntryPtrTag

const NoPtrTag = constexpr NoPtrTag

# VMTraps data

const VMTrapsAsyncEvents = constexpr VMTraps::AsyncEvents

# VM offsets

const VMTrapAwareSoftStackLimitOffset = VM::m_threadContext + VMThreadContext::m_traps + VMTraps::m_stack + StackManager::m_trapAwareSoftStackLimit

const VMCLoopStackLimitOffset = VM::m_threadContext + VMThreadContext::m_traps + VMTraps::m_stack + StackManager::m_cloopStackLimit

const VMSoftStackLimitOffset = VM::m_threadContext + VMThreadContext::m_traps + VMTraps::m_stack + StackManager::m_softStackLimit

# Registers

if ARMv7

const a0 = t0

const a1 = t1

const a2 = t2

const a3 = t3

const a4 = invalidGPR

const a5 = invalidGPR

const a6 = invalidGPR

const a7 = invalidGPR

const wa0 = a0

const wa1 = a1

const wa2 = a2

const wa3 = a3

const wa4 = invalidGPR

const wa5 = invalidGPR

const wa6 = invalidGPR

const wa7 = invalidGPR

const ws0 = t5 # ws0 must be a non-argument/non-return GPR

const ws1 = t6

const ws2 = csr0

const ws3 = csr1

const r0 = a0

const r1 = a1

const fa0 = ft0

const fa1 = ft1

const fa2 = ft2

const fa3 = ft3

const wfa0 = fa0

const wfa1 = fa1

const wfa2 = fa2

const wfa3 = fa3

const wfa4 = ft4

const wfa5 = ft5

const wfa6 = ft6

const wfa7 = ft7

const fr = fa0

elsif X86_64

const a0 = t6

const a1 = t1

const a2 = t2

const a3 = t3

const a4 = t4

const a5 = t7

const a6 = invalidGPR

const a7 = invalidGPR

const wa0 = a0

const wa1 = a1

const wa2 = a2

const wa3 = a3

const wa4 = a4

const wa5 = a5

const wa6 = a6

const wa7 = a7

const ws0 = t0

const ws1 = t5

const ws2 = invalidGPR

const ws3 = invalidGPR

const r0 = t0

const r1 = t2

const fa0 = ft0

const fa1 = ft1

const fa2 = ft2

const fa3 = ft3

const wfa0 = fa0

const wfa1 = fa1

const wfa2 = fa2

const wfa3 = fa3

const wfa4 = ft4

const wfa5 = ft5

const wfa6 = ft6

const wfa7 = ft7

const fr = fa0

const a0 = t0

const a1 = t1

const a2 = t2

const a3 = t3

const a4 = t4

const a5 = t5

const a6 = t6

const a7 = t7

const wa0 = a0

const wa1 = a1

const wa2 = a2

const wa3 = a3

const wa4 = a4

const wa5 = a5

const wa6 = a6

const wa7 = a7

const ws0 = t9 # ws0 must be a non-argument/non-return GPR

const ws1 = t10

const ws2 = t11

const ws3 = t12

const r0 = a0

const r1 = a1

const fa0 = ft0

const fa1 = ft1

const fa2 = ft2

const fa3 = ft3

const wfa0 = fa0

const wfa1 = fa1

const wfa2 = fa2

const wfa3 = fa3

const wfa4 = ft4

const wfa5 = ft5

const wfa6 = ft6

const wfa7 = ft7

const fr = fa0

# Some register conventions.

# - We use a pair of registers to represent the PC: one register for the

# base of the bytecodes, and one register for the index.

# - The PC base (or PB for short) must be stored in a callee-save register.

# - The metadata (PM / pointer to metadata) must be stored in a callee-save register.

# - C calls are still given the Instruction* rather than the PC index.

# This requires an add before the call, and a sub after.

if JSVALUE64

const PC = t4 # When changing this, make sure LLIntPC is up to date in LLIntPCRanges.h

if ARM64 or ARM64E or RISCV64

const metadataTable = csr6

const PB = csr7

const numberTag = csr8

const notCellMask = csr9

elsif X86_64

const metadataTable = csr1

const PB = csr2

const numberTag = csr3

const notCellMask = csr4

elsif C_LOOP

const PB = csr0

const numberTag = csr1

const notCellMask = csr2

const metadataTable = csr3

end

const PC = t4 # When changing this, make sure LLIntPC is up to date in LLIntPCRanges.h

if C_LOOP

const PB = csr0

const metadataTable = csr3

elsif ARMv7

const metadataTable = csr0

const PB = csr1

else

error

end

if GIGACAGE_ENABLED

const GigacagePrimitiveBasePtrOffset = constexpr Gigacage::offsetOfPrimitiveGigacageBasePtr

# Opcode offsets

const OpcodeIDNarrowSize = 1 # OpcodeID

const OpcodeIDWide16SizeJS = 2 # Wide16 Prefix + OpcodeID

const OpcodeIDWide32SizeJS = 2 # Wide32 Prefix + OpcodeID

const OpcodeIDWide16SizeWasm = 2 # Wide16 Prefix + OpcodeID(1 byte)

const OpcodeIDWide32SizeWasm = 2 # Wide32 Prefix + OpcodeID(1 byte)

const WTFConfig = _g_config + constexpr WTF::startOffsetOfWTFConfig

const GigacageConfig = _g_config + constexpr Gigacage::startOffsetOfGigacageConfig

const ExecutableAllocatorConfigOffset = constexpr WebConfig::startOffsetOfExecutableAllocatorConfig

const JSCConfigOffset = constexpr WTF::offsetOfWTFConfigExtension

const JSCConfigGateMapOffset = JSCConfigOffset + constexpr JSC::offsetOfJSCConfigGateMap

macro loadBoolJSCOption(name, reg)

leap _g_config, reg

loadb JSCConfigOffset + JSC::Config::options + OptionsStorage::%name%[reg], reg

macro validateOpcodeConfig(scratchReg)

if ARM64E

leap _os_script_config_storage, scratchReg

loadp [scratchReg], scratchReg

end

macro nextInstruction()

loadb [PB, PC, 1], t0

leap _os_script_config_storage, t1

jmp JSC::LLInt::OpcodeConfig::opcodeMap[t1, t0, PtrSize]

macro nextInstructionWide16()

loadb OpcodeIDNarrowSize[PB, PC, 1], t0

leap _os_script_config_storage, t1

jmp JSC::LLInt::OpcodeConfig::opcodeMapWide16[t1, t0, PtrSize]

macro nextInstructionWide32()

loadb OpcodeIDNarrowSize[PB, PC, 1], t0

leap _os_script_config_storage, t1

jmp JSC::LLInt::OpcodeConfig::opcodeMapWide32[t1, t0, PtrSize]

macro dispatch(advanceReg)

addp advanceReg, PC

nextInstruction()

macro dispatchIndirect(offsetReg)

dispatch(offsetReg)

macro genericDispatchOpJS(dispatch, size, opcodeName)

macro dispatchNarrow()

dispatch((constexpr %opcodeName%_length) * 1 + OpcodeIDNarrowSize)

end

macro dispatchWide16()

dispatch((constexpr %opcodeName%_length) * 2 + OpcodeIDWide16SizeJS)

end

macro dispatchWide32()

dispatch((constexpr %opcodeName%_length) * 4 + OpcodeIDWide32SizeJS)

end

size(dispatchNarrow, dispatchWide16, dispatchWide32, macro (dispatch) dispatch() end)

macro genericDispatchOpWasm(dispatch, size, opcodeName)

macro dispatchNarrow()

dispatch((constexpr %opcodeName%_length) * 1 + OpcodeIDNarrowSize)

end

macro dispatchWide16()

dispatch((constexpr %opcodeName%_length) * 2 + OpcodeIDWide16SizeWasm)

end

macro dispatchWide32()

dispatch((constexpr %opcodeName%_length) * 4 + OpcodeIDWide32SizeWasm)

end

size(dispatchNarrow, dispatchWide16, dispatchWide32, macro (dispatch) dispatch() end)

macro dispatchOp(size, opcodeName)

genericDispatchOpJS(dispatch, size, opcodeName)

macro superSamplerBegin(scratch)

leap _g_superSamplerCount, scratch

addi 1, [scratch]

macro superSamplerEnd(scratch)

leap _g_superSamplerCount, scratch

subi 1, [scratch]

macro getu(size, opcodeStruct, fieldName, dst)

size(getuOperandNarrow, getuOperandWide16JS, getuOperandWide32JS, macro (getu)

getu(opcodeStruct, fieldName, dst)

end)

macro get(size, opcodeStruct, fieldName, dst)

size(getOperandNarrow, getOperandWide16JS, getOperandWide32JS, macro (get)

get(opcodeStruct, fieldName, dst)

end)

macro narrow(narrowFn, wide16Fn, wide32Fn, k)

k(narrowFn)

macro wide16(narrowFn, wide16Fn, wide32Fn, k)

k(wide16Fn)

macro wide32(narrowFn, wide16Fn, wide32Fn, k)

k(wide32Fn)

macro metadata(size, opcode, dst, scratch)

loadh (constexpr %opcode%::opcodeID * 2 + MetadataOffsetTable16Offset)[metadataTable], dst # offset = metadataTable<uint16_t*>[opcodeID]

btinz dst, .setUpOffset

loadi (constexpr %opcode%::opcodeID * 4 + MetadataOffsetTable32Offset)[metadataTable], dst # offset = metadataTable<uint32_t*>[opcodeID]

getu(size, opcode, m_metadataID, scratch) # scratch = bytecode.m_metadataID

muli sizeof %opcode%::Metadata, scratch # scratch *= sizeof(Op::Metadata)

addi scratch, dst # offset += scratch

addp metadataTable, dst # return &metadataTable[offset]

# roundUpToMultipleOf(alignof(Metadata), dst)

const adder = (constexpr (alignof(%opcode%::Metadata))) - 1

const mask = ~adder

addp adder, dst

andp mask, dst

macro jumpImpl(dispatchIndirect, targetOffsetReg)

btiz targetOffsetReg, .outOfLineJumpTarget

dispatchIndirect(targetOffsetReg)

callSlowPath(_llint_slow_path_out_of_line_jump_target)

nextInstruction()

macro commonOp(label, prologue, fn)

_%label%:

prologue()

fn(narrow)

if ASSERT_ENABLED

break

break

end

_%label%_wide16:

prologue()

fn(wide16)

if ASSERT_ENABLED

break

break

end

_%label%_wide32:

prologue()

fn(wide32)

if ASSERT_ENABLED

break

break

end

macro op(l, fn)

commonOp(l, macro () end, macro (size)

size(fn, macro() break end, macro() break end, macro(gen) gen() end)

end)

macro llintOp(opcodeName, opcodeStruct, fn)

commonOp(llint_%opcodeName%, traceExecution, macro(size)

macro getImpl(fieldName, dst)

get(size, opcodeStruct, fieldName, dst)

end

macro dispatchImpl()

dispatchOp(size, opcodeName)

end

fn(size, getImpl, dispatchImpl)

end)

macro llintOpWithReturn(opcodeName, opcodeStruct, fn)

llintOp(opcodeName, opcodeStruct, macro(size, get, dispatch)

makeReturn(get, dispatch, macro (return)

fn(size, get, dispatch, return)

end)

end)

macro llintOpWithMetadata(opcodeName, opcodeStruct, fn)

llintOpWithReturn(opcodeName, opcodeStruct, macro (size, get, dispatch, return)

macro meta(dst, scratch)

metadata(size, opcodeStruct, dst, scratch)

end

fn(size, get, dispatch, meta, return)

end)

macro llintOpWithJump(opcodeName, opcodeStruct, impl)

llintOpWithMetadata(opcodeName, opcodeStruct, macro(size, get, dispatch, metadata, return)

macro jump(fieldName)

get(fieldName, t0)

jumpImpl(dispatchIndirect, t0)

end

impl(size, get, jump, dispatch)

end)

macro llintOpWithProfile(opcodeName, opcodeStruct, fn)

llintOpWithMetadata(opcodeName, opcodeStruct, macro(size, get, dispatch, metadata, return)

makeReturnProfiled(size, opcodeStruct, get, metadata, dispatch, macro (returnProfiled)

fn(size, get, dispatch, returnProfiled)

end)

end)

# Constants for reasoning about value representation.

const TagOffset = constexpr TagOffset

const PayloadOffset = constexpr PayloadOffset

# Constant for reasoning about butterflies.

const IsArray = constexpr IsArray

const IndexingShapeMask = constexpr IndexingShapeMask

const IndexingTypeMask = constexpr IndexingTypeMask

const NoIndexingShape = constexpr NoIndexingShape

const Int32Shape = constexpr Int32Shape

const DoubleShape = constexpr DoubleShape

const ContiguousShape = constexpr ContiguousShape

const ArrayStorageShape = constexpr ArrayStorageShape

const SlowPutArrayStorageShape = constexpr SlowPutArrayStorageShape

const CopyOnWrite = constexpr CopyOnWrite

const ArrayWithUndecided = constexpr ArrayWithUndecided

# Type constants.

const StructureType = constexpr StructureType

const StringType = constexpr StringType

const SymbolType = constexpr SymbolType

const ObjectType = constexpr ObjectType

const FinalObjectType = constexpr FinalObjectType

const JSFunctionType = constexpr JSFunctionType

const InternalFunctionType = constexpr InternalFunctionType

const ArrayType = constexpr ArrayType

const DerivedArrayType = constexpr DerivedArrayType

const ProxyObjectType = constexpr ProxyObjectType

const HeapBigIntType = constexpr HeapBigIntType

const FunctionExecutableType = constexpr FunctionExecutableType

# The typed array types need to be numbered in a particular order because of the manually written

# switch statement in get_by_val and put_by_val.

const Int8ArrayType = constexpr Int8ArrayType

const Uint8ArrayType = constexpr Uint8ArrayType

const Uint8ClampedArrayType = constexpr Uint8ClampedArrayType

const Int16ArrayType = constexpr Int16ArrayType

const Uint16ArrayType = constexpr Uint16ArrayType

const Int32ArrayType = constexpr Int32ArrayType

const Uint32ArrayType = constexpr Uint32ArrayType

const Float16ArrayType = constexpr Float16ArrayType

const Float32ArrayType = constexpr Float32ArrayType

const Float64ArrayType = constexpr Float64ArrayType

const FirstTypedArrayType = constexpr FirstTypedArrayType

const NumberOfTypedArrayTypesExcludingDataView = constexpr NumberOfTypedArrayTypesExcludingDataView

const NumberOfTypedArrayTypesExcludingBigIntArraysAndDataView = constexpr NumberOfTypedArrayTypesExcludingBigIntArraysAndDataView

# Type flags constants.

const MasqueradesAsUndefined = constexpr MasqueradesAsUndefined

const ImplementsDefaultHasInstance = constexpr ImplementsDefaultHasInstance

const OverridesGetPrototype = constexpr OverridesGetPrototype

# Bytecode operand constants.

const FirstConstantRegisterIndexNarrow = constexpr FirstConstantRegisterIndex8

const FirstConstantRegisterIndexWide16 = constexpr FirstConstantRegisterIndex16

const FirstConstantRegisterIndexWide32 = constexpr FirstConstantRegisterIndex

# Code type constants.

const GlobalCode = constexpr GlobalCode

const EvalCode = constexpr EvalCode

const FunctionCode = constexpr FunctionCode

const ModuleCode = constexpr ModuleCode

# The interpreter steals the tag word of the argument count.

const CallSiteIndex = ArgumentCountIncludingThis + TagOffset

# String flags.

const isRopeInPointer = constexpr JSString::isRopeInPointer

const HashFlags8BitBuffer = constexpr StringImpl::s_hashFlag8BitBuffer

# Copied from PropertyOffset.h

const firstOutOfLineOffset = constexpr firstOutOfLineOffset

const knownPolyProtoOffset = constexpr knownPolyProtoOffset

# ResolveType

const GlobalProperty = constexpr GlobalProperty

const GlobalVar = constexpr GlobalVar

const GlobalLexicalVar = constexpr GlobalLexicalVar

const ClosureVar = constexpr ClosureVar

const ResolvedClosureVar = constexpr ResolvedClosureVar

const ModuleVar = constexpr ModuleVar

const GlobalPropertyWithVarInjectionChecks = constexpr GlobalPropertyWithVarInjectionChecks

const GlobalVarWithVarInjectionChecks = constexpr GlobalVarWithVarInjectionChecks

const GlobalLexicalVarWithVarInjectionChecks = constexpr GlobalLexicalVarWithVarInjectionChecks

const ClosureVarWithVarInjectionChecks = constexpr ClosureVarWithVarInjectionChecks

const ResolveTypeMask = constexpr GetPutInfo::typeBits

const InitializationModeMask = constexpr GetPutInfo::initializationBits

const InitializationModeShift = constexpr GetPutInfo::initializationShift

const NotInitialization = constexpr InitializationMode::NotInitialization

const MarkedBlockSize = constexpr MarkedBlock::blockSize

const MarkedBlockMask = ~(MarkedBlockSize - 1)

const MarkedBlockHeaderOffset = constexpr MarkedBlock::offsetOfHeader

const PreciseAllocationHeaderSize = constexpr (PreciseAllocation::headerSize())

const PreciseAllocationVMOffset = (PreciseAllocation::m_weakSet + WeakSet::m_vm - PreciseAllocationHeaderSize)

const BlackThreshold = constexpr blackThreshold

const VectorBufferOffset = Vector::m_buffer

const VectorSizeOffset = Vector::m_size

# Some common utilities.

macro crash()

if C_LOOP

cloopCrash

else

call _llint_crash

end

macro assert(assertion)

if ASSERT_ENABLED

assertion(.ok)

crash()

.ok:

end

macro assert_with(assertion, crash)

if ASSERT_ENABLED

assertion(.ok)

crash()

.ok:

end

# The probe macro can be used to insert some debugging code without perturbing scalar

# registers. Presently, the probe macro only preserves scalar registers. Hence, the

# C probe callback function should not trash floating point registers.

#

# The macro you pass to probe() can pass whatever registers you like to your probe

# callback function. However, you need to be mindful of which of the registers are

# also used as argument registers, and ensure that you don't trash the register value

# before storing it in the probe callback argument register that you desire.

#

# Here's an example of how it's used:

#

# probe(

# macro()

# move cfr, a0 # pass the CallFrame* as arg0.

# move t0, a1 # pass the value of register t0 as arg1.

# call _cProbeCallbackFunction # to do whatever you want.

# end

# )

#

# LLIntSlowPaths.h

# extern "C" __attribute__((__used__)) __attribute__((visibility("hidden"))) void cProbeCallbackFunction(uint64_t i);

# LLIntSlowPaths.cpp:

# extern "C" void cProbeCallbackFunction(uint64_t i) {}

#

if X86_64 or ARM64 or ARM64E or ARMv7

macro probe(action)

# save all the registers that the LLInt may use.

if ARM64 or ARM64E or ARMv7

push cfr, lr

end

push a0, a1

push a2, a3

push t0, t1

push t2, t3

push t4, t5

push t6, t7

push ws0, ws1

if ARM64 or ARM64E

push csr0, csr1

push csr2, csr3

push csr4, csr5

push csr6, csr7

push csr8, csr9

elsif ARMv7

push csr0, csr1

end

action()

# restore all the registers we saved previously.

if ARM64 or ARM64E

pop csr9, csr8

pop csr7, csr6

pop csr5, csr4

pop csr3, csr2

pop csr1, csr0

elsif ARMv7

pop csr1, csr0

end

pop ws1, ws0

pop t7, t6

pop t5, t4

pop t3, t2

pop t1, t0

pop a3, a2

pop a1, a0

if ARM64 or ARM64E or ARMv7

pop lr, cfr

end

end

macro probe(action)

end

macro checkStackPointerAlignment(tempReg, location)

if ASSERT_ENABLED

if ARM64 or ARM64E or C_LOOP

# ARM64 and ARM64E will check for us!

# C_LOOP does not need the alignment, and can use a little perf

# improvement from avoiding useless work.

else

if ARMv7

# ARM can't do logical ops with the sp as a source

move sp, tempReg

andp StackAlignmentMask, tempReg

else

andp sp, StackAlignmentMask, tempReg

end

btpz tempReg, .stackPointerOkay

move location, tempReg

break

.stackPointerOkay:

end

end

if C_LOOP or ARM64 or ARM64E or X86_64 or RISCV64

const CalleeSaveRegisterCount = 0

elsif ARMv7

const CalleeSaveRegisterCount = 5 + 2 * 2 // 5 32-bit GPRs + 2 64-bit FPRs

const CalleeRegisterSaveSize = CalleeSaveRegisterCount * MachineRegisterSize

# VMEntryTotalFrameSize includes the space for struct VMEntryRecord and the

# callee save registers rounded up to keep the stack aligned

const VMEntryTotalFrameSize = (CalleeRegisterSaveSize + sizeof VMEntryRecord + StackAlignment - 1) & ~StackAlignmentMask

macro pushCalleeSaves()

# Note: Only registers that are in RegisterSet::calleeSaveRegisters(),

# but are not in RegisterSet::vmCalleeSaveRegisters() need to be saved here,

# i.e.: only those registers that are callee save in the C ABI, but are not

# callee save in the JIT ABI.

if C_LOOP or ARM64 or ARM64E or X86_64 or RISCV64

elsif ARMv7

emit "vpush.64 {d14, d15}"

emit "push {r4-r6, r8-r9}"

end

macro popCalleeSaves()

if C_LOOP or ARM64 or ARM64E or X86_64 or RISCV64

elsif ARMv7

emit "pop {r4-r6, r8-r9}"

emit "vpop.64 {d14, d15}"

end

macro preserveCallerPCAndCFR()

if C_LOOP or ARMv7

push lr

push cfr

elsif X86_64

push cfr

elsif ARM64 or ARM64E or RISCV64

push cfr, lr

else

error

end

move sp, cfr

macro restoreCallerPCAndCFR()

move cfr, sp

if C_LOOP or ARMv7

pop cfr

pop lr

elsif X86_64

pop cfr

elsif ARM64 or ARM64E or RISCV64

pop lr, cfr

end

macro preserveCalleeSavesUsedByLLInt()

subp CalleeSaveSpaceStackAligned, sp

if C_LOOP

storep metadataTable, -PtrSize[cfr]

elsif ARMv7

storep PB, -4[cfr]

storep metadataTable, -8[cfr]

elsif ARM64 or ARM64E

storepairq csr8, csr9, -16[cfr]

storepairq csr6, csr7, -32[cfr]

elsif X86_64

storep csr4, -8[cfr]

storep csr3, -16[cfr]

storep csr2, -24[cfr]

storep csr1, -32[cfr]

elsif RISCV64

storep csr9, -8[cfr]

storep csr8, -16[cfr]

storep csr7, -24[cfr]

storep csr6, -32[cfr]

end

macro restoreCalleeSavesUsedByLLInt()

if C_LOOP

loadp -PtrSize[cfr], metadataTable

elsif ARMv7

loadp -4[cfr], PB

loadp -8[cfr], metadataTable

elsif ARM64 or ARM64E

loadpairq -32[cfr], csr6, csr7

loadpairq -16[cfr], csr8, csr9

elsif X86_64

loadp -32[cfr], csr1