# Copyright (C) 2011-2016 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.

# Utilities.

macro jumpToInstruction()

jmp [PB, PC, 8]

macro dispatch(advance)

addp advance, PC

jumpToInstruction()

macro dispatchInt(advance)

addi advance, PC

jumpToInstruction()

macro dispatchIntIndirect(offset)

dispatchInt(offset * 8[PB, PC, 8])

macro dispatchAfterCall()

loadi ArgumentCount + TagOffset[cfr], PC

loadp CodeBlock[cfr], PB

loadp CodeBlock::m_instructions[PB], PB

loadisFromInstruction(1, t1)

storeq r0, [cfr, t1, 8]

valueProfile(r0, (CallOpCodeSize - 1), t3)

dispatch(CallOpCodeSize)

macro cCall2(function)

checkStackPointerAlignment(t4, 0xbad0c002)

if X86_64 or ARM64

call function

elsif X86_64_WIN

# Note: this implementation is only correct if the return type size is > 8 bytes.

# See macro cCall2Void for an implementation when the return type <= 8 bytes.

# On Win64, when the return type is larger than 8 bytes, we need to allocate space on the stack for the return value.

# On entry rcx (a0), should contain a pointer to this stack space. The other parameters are shifted to the right,

# rdx (a1) should contain the first argument, and r8 (a2) should contain the second argument.

# On return, rax contains a pointer to this stack value, and we then need to copy the 16 byte return value into rax (r0) and rdx (r1)

# since the return value is expected to be split between the two.

# See http://msdn.microsoft.com/en-us/library/7572ztz4.aspx

move a1, a2

move a0, a1

subp 48, sp

move sp, a0

addp 32, a0

call function

addp 48, sp

move 8[r0], r1

move [r0], r0

elsif C_LOOP

cloopCallSlowPath function, a0, a1

else

error

end

macro cCall2Void(function)

if C_LOOP

cloopCallSlowPathVoid function, a0, a1

elsif X86_64_WIN

# Note: we cannot use the cCall2 macro for Win64 in this case,

# as the Win64 cCall2 implemenation is only correct when the return type size is > 8 bytes.

# On Win64, rcx and rdx are used for passing the first two parameters.

# We also need to make room on the stack for all four parameter registers.

# See http://msdn.microsoft.com/en-us/library/ms235286.aspx

subp 32, sp

call function

addp 32, sp

else

cCall2(function)

end

# This barely works. arg3 and arg4 should probably be immediates.

macro cCall4(function)

checkStackPointerAlignment(t4, 0xbad0c004)

if X86_64 or ARM64

call function

elsif X86_64_WIN

# On Win64, rcx, rdx, r8, and r9 are used for passing the first four parameters.

# We also need to make room on the stack for all four parameter registers.

# See http://msdn.microsoft.com/en-us/library/ms235286.aspx

subp 64, sp

call function

addp 64, sp

else

error

end

macro doVMEntry(makeCall)

functionPrologue()

pushCalleeSaves()

const entry = a0

const vm = a1

const protoCallFrame = a2

vmEntryRecord(cfr, sp)

checkStackPointerAlignment(t4, 0xbad0dc01)

storep vm, VMEntryRecord::m_vm[sp]

loadp VM::topCallFrame[vm], t4

storep t4, VMEntryRecord::m_prevTopCallFrame[sp]

loadp VM::topVMEntryFrame[vm], t4

storep t4, VMEntryRecord::m_prevTopVMEntryFrame[sp]

loadi ProtoCallFrame::paddedArgCount[protoCallFrame], t4

addp CallFrameHeaderSlots, t4, t4

lshiftp 3, t4

subp sp, t4, t3

# Ensure that we have enough additional stack capacity for the incoming args,

# and the frame for the JS code we're executing. We need to do this check

# before we start copying the args from the protoCallFrame below.

bpaeq t3, VM::m_jsStackLimit[vm], .stackHeightOK

if C_LOOP

move entry, t4

move vm, t5

cloopCallSlowPath _llint_stack_check_at_vm_entry, vm, t3

bpeq t0, 0, .stackCheckFailed

move t4, entry

move t5, vm

jmp .stackHeightOK

move t4, entry

move t5, vm

end

move vm, a0

move protoCallFrame, a1

cCall2(_llint_throw_stack_overflow_error)

vmEntryRecord(cfr, t4)

loadp VMEntryRecord::m_vm[t4], vm

loadp VMEntryRecord::m_prevTopCallFrame[t4], extraTempReg

storep extraTempReg, VM::topCallFrame[vm]

loadp VMEntryRecord::m_prevTopVMEntryFrame[t4], extraTempReg

storep extraTempReg, VM::topVMEntryFrame[vm]

subp cfr, CalleeRegisterSaveSize, sp

popCalleeSaves()

functionEpilogue()

ret

move t3, sp

move 4, t3

subi 1, t3

loadq [protoCallFrame, t3, 8], extraTempReg

storeq extraTempReg, CodeBlock[sp, t3, 8]

btinz t3, .copyHeaderLoop

loadi PayloadOffset + ProtoCallFrame::argCountAndCodeOriginValue[protoCallFrame], t4

subi 1, t4

loadi ProtoCallFrame::paddedArgCount[protoCallFrame], extraTempReg

subi 1, extraTempReg

bieq t4, extraTempReg, .copyArgs

move ValueUndefined, t3

subi 1, extraTempReg

storeq t3, ThisArgumentOffset + 8[sp, extraTempReg, 8]

bineq t4, extraTempReg, .fillExtraArgsLoop

loadp ProtoCallFrame::args[protoCallFrame], t3

btiz t4, .copyArgsDone

subi 1, t4

loadq [t3, t4, 8], extraTempReg

storeq extraTempReg, ThisArgumentOffset + 8[sp, t4, 8]

jmp .copyArgsLoop

if ARM64

move sp, t4

storep t4, VM::topCallFrame[vm]

else

storep sp, VM::topCallFrame[vm]

end

storep cfr, VM::topVMEntryFrame[vm]

checkStackPointerAlignment(extraTempReg, 0xbad0dc02)

makeCall(entry, t3)

# We may have just made a call into a JS function, so we can't rely on sp

# for anything but the fact that our own locals (ie the VMEntryRecord) are

# not below it. It also still has to be aligned, though.

checkStackPointerAlignment(t2, 0xbad0dc03)

vmEntryRecord(cfr, t4)

loadp VMEntryRecord::m_vm[t4], vm

loadp VMEntryRecord::m_prevTopCallFrame[t4], t2

storep t2, VM::topCallFrame[vm]

loadp VMEntryRecord::m_prevTopVMEntryFrame[t4], t2

storep t2, VM::topVMEntryFrame[vm]

subp cfr, CalleeRegisterSaveSize, sp

popCalleeSaves()

functionEpilogue()

ret

macro makeJavaScriptCall(entry, temp)

addp 16, sp

if C_LOOP

cloopCallJSFunction entry

else

call entry

end

subp 16, sp

macro makeHostFunctionCall(entry, temp)

move entry, temp

storep cfr, [sp]

move sp, a0

if C_LOOP

storep lr, 8[sp]

cloopCallNative temp

elsif X86_64_WIN

# We need to allocate 32 bytes on the stack for the shadow space.

subp 32, sp

call temp

addp 32, sp

else

call temp

end

loadp Callee[cfr], t3

andp MarkedBlockMask, t3

loadp MarkedBlock::m_weakSet + WeakSet::m_vm[t3], t3

restoreCalleeSavesFromVMCalleeSavesBuffer(t3, t0)

loadp VM::callFrameForCatch[t3], cfr

storep 0, VM::callFrameForCatch[t3]

loadp CallerFrame[cfr], cfr

vmEntryRecord(cfr, t2)

loadp VMEntryRecord::m_vm[t2], t3

loadp VMEntryRecord::m_prevTopCallFrame[t2], extraTempReg

storep extraTempReg, VM::topCallFrame[t3]

loadp VMEntryRecord::m_prevTopVMEntryFrame[t2], extraTempReg

storep extraTempReg, VM::topVMEntryFrame[t3]

subp cfr, CalleeRegisterSaveSize, sp

popCalleeSaves()

functionEpilogue()

ret

macro prepareStateForCCall()

leap [PB, PC, 8], PC

macro restoreStateAfterCCall()

move r0, PC

subp PB, PC

rshiftp 3, PC

macro callSlowPath(slowPath)

prepareStateForCCall()

move cfr, a0

move PC, a1

cCall2(slowPath)

restoreStateAfterCCall()

macro traceOperand(fromWhere, operand)

prepareStateForCCall()

move fromWhere, a2

move operand, a3

move cfr, a0

move PC, a1

cCall4(_llint_trace_operand)

restoreStateAfterCCall()

macro traceValue(fromWhere, operand)

prepareStateForCCall()

move fromWhere, a2

move operand, a3

move cfr, a0

move PC, a1

cCall4(_llint_trace_value)

restoreStateAfterCCall()

# Call a slow path for call call opcodes.

macro callCallSlowPath(slowPath, action)

storei PC, ArgumentCount + TagOffset[cfr]

prepareStateForCCall()

move cfr, a0

move PC, a1

cCall2(slowPath)

action(r0, r1)

macro callWatchdogTimerHandler(throwHandler)

storei PC, ArgumentCount + TagOffset[cfr]

prepareStateForCCall()

move cfr, a0

move PC, a1

cCall2(_llint_slow_path_handle_watchdog_timer)

btpnz r0, throwHandler

loadi ArgumentCount + TagOffset[cfr], PC

macro checkSwitchToJITForLoop()

checkSwitchToJIT(

1,

macro()

storei PC, ArgumentCount + TagOffset[cfr]

prepareStateForCCall()

move cfr, a0

move PC, a1

cCall2(_llint_loop_osr)

btpz r0, .recover

move r1, sp

jmp r0

.recover:

loadi ArgumentCount + TagOffset[cfr], PC

end)

macro loadVariable(operand, value)

loadisFromInstruction(operand, value)

loadq [cfr, value, 8], value

# Index and value must be different registers. Index may be clobbered.

macro loadConstantOrVariable(index, value)

bpgteq index, FirstConstantRegisterIndex, .constant

loadq [cfr, index, 8], value

jmp .done

loadp CodeBlock[cfr], value

loadp CodeBlock::m_constantRegisters + VectorBufferOffset[value], value

subp FirstConstantRegisterIndex, index

loadq [value, index, 8], value

macro loadConstantOrVariableInt32(index, value, slow)

loadConstantOrVariable(index, value)

bqb value, tagTypeNumber, slow

macro loadConstantOrVariableCell(index, value, slow)

loadConstantOrVariable(index, value)

btqnz value, tagMask, slow

macro writeBarrierOnOperand(cellOperand)

loadisFromInstruction(cellOperand, t1)

loadConstantOrVariableCell(t1, t2, .writeBarrierDone)

skipIfIsRememberedOrInEden(t2, t1, t3,

macro(cellState)

btbnz cellState, .writeBarrierDone

push PB, PC

move t2, a1 # t2 can be a0 (not on 64 bits, but better safe than sorry)

move cfr, a0

cCall2Void(_llint_write_barrier_slow)

pop PC, PB

end

)

macro writeBarrierOnOperands(cellOperand, valueOperand)

loadisFromInstruction(valueOperand, t1)

loadConstantOrVariableCell(t1, t0, .writeBarrierDone)

btpz t0, .writeBarrierDone

writeBarrierOnOperand(cellOperand)

macro writeBarrierOnGlobal(valueOperand, loadHelper)

loadisFromInstruction(valueOperand, t1)

loadConstantOrVariableCell(t1, t0, .writeBarrierDone)

btpz t0, .writeBarrierDone

loadHelper(t3)

skipIfIsRememberedOrInEden(t3, t1, t2,

macro(gcData)

btbnz gcData, .writeBarrierDone

push PB, PC

move cfr, a0

move t3, a1

cCall2Void(_llint_write_barrier_slow)

pop PC, PB

end

)

macro writeBarrierOnGlobalObject(valueOperand)

writeBarrierOnGlobal(valueOperand,

macro(registerToStoreGlobal)

loadp CodeBlock[cfr], registerToStoreGlobal

loadp CodeBlock::m_globalObject[registerToStoreGlobal], registerToStoreGlobal

end)

macro writeBarrierOnGlobalLexicalEnvironment(valueOperand)

writeBarrierOnGlobal(valueOperand,

macro(registerToStoreGlobal)

loadp CodeBlock[cfr], registerToStoreGlobal

loadp CodeBlock::m_globalObject[registerToStoreGlobal], registerToStoreGlobal

loadp JSGlobalObject::m_globalLexicalEnvironment[registerToStoreGlobal], registerToStoreGlobal

end)

macro valueProfile(value, operand, scratch)

loadpFromInstruction(operand, scratch)

storeq value, ValueProfile::m_buckets[scratch]

macro structureIDToStructureWithScratch(structureIDThenStructure, scratch)

loadp CodeBlock[cfr], scratch

loadp CodeBlock::m_vm[scratch], scratch

loadp VM::heap + Heap::m_structureIDTable + StructureIDTable::m_table[scratch], scratch

loadp [scratch, structureIDThenStructure, 8], structureIDThenStructure

macro loadStructureWithScratch(cell, structure, scratch)

loadi JSCell::m_structureID[cell], structure

structureIDToStructureWithScratch(structure, scratch)

macro loadStructureAndClobberFirstArg(cell, structure)

loadi JSCell::m_structureID[cell], structure

loadp CodeBlock[cfr], cell

loadp CodeBlock::m_vm[cell], cell

loadp VM::heap + Heap::m_structureIDTable + StructureIDTable::m_table[cell], cell

loadp [cell, structure, 8], structure

macro storeStructureWithTypeInfo(cell, structure, scratch)

loadq Structure::m_blob + StructureIDBlob::u.doubleWord[structure], scratch

storeq scratch, JSCell::m_structureID[cell]

# Entrypoints into the interpreter.

# Expects that CodeBlock is in t1, which is what prologue() leaves behind.

macro functionArityCheck(doneLabel, slowPath)

loadi PayloadOffset + ArgumentCount[cfr], t0

biaeq t0, CodeBlock::m_numParameters[t1], doneLabel

prepareStateForCCall()

move cfr, a0

move PC, a1

cCall2(slowPath) # This slowPath has the protocol: r0 = 0 => no error, r0 != 0 => error

btiz r0, .noError

move r1, cfr # r1 contains caller frame

jmp _llint_throw_from_slow_path_trampoline

loadi CommonSlowPaths::ArityCheckData::paddedStackSpace[r1], t1

btiz t1, .continue

loadi PayloadOffset + ArgumentCount[cfr], t2

addi CallFrameHeaderSlots, t2

// Check if there are some unaligned slots we can use

move t1, t3

andi StackAlignmentSlots - 1, t3

btiz t3, .noExtraSlot

move ValueUndefined, t0

storeq t0, [cfr, t2, 8]

addi 1, t2

bsubinz 1, t3, .fillExtraSlots

andi ~(StackAlignmentSlots - 1), t1

btiz t1, .continue

// Move frame up t1 slots

negq t1

move cfr, t3

subp CalleeSaveSpaceAsVirtualRegisters * 8, t3

addi CalleeSaveSpaceAsVirtualRegisters, t2

loadq [t3], t0

storeq t0, [t3, t1, 8]

addp 8, t3

bsubinz 1, t2, .copyLoop

// Fill new slots with JSUndefined

move t1, t2

move ValueUndefined, t0

storeq t0, [t3, t1, 8]

addp 8, t3

baddinz 1, t2, .fillLoop

lshiftp 3, t1

addp t1, cfr

addp t1, sp

# Reload CodeBlock and reset PC, since the slow_path clobbered them.

loadp CodeBlock[cfr], t1

loadp CodeBlock::m_instructions[t1], PB

move 0, PC

jmp doneLabel

macro branchIfException(label)

loadp Callee[cfr], t3

andp MarkedBlockMask, t3

loadp MarkedBlock::m_weakSet + WeakSet::m_vm[t3], t3

btqz VM::m_exception[t3], .noException

jmp label

# Instruction implementations

traceExecution()

checkStackPointerAlignment(t2, 0xdead00e1)

loadp CodeBlock[cfr], t2 // t2<CodeBlock> = cfr.CodeBlock

loadi CodeBlock::m_numVars[t2], t2 // t2<size_t> = t2<CodeBlock>.m_numVars

subq CalleeSaveSpaceAsVirtualRegisters, t2

move cfr, t1

subq CalleeSaveSpaceAsVirtualRegisters * 8, t1

btiz t2, .opEnterDone

move ValueUndefined, t0

negi t2

sxi2q t2, t2

storeq t0, [t1, t2, 8]

addq 1, t2

btqnz t2, .opEnterLoop

callSlowPath(_slow_path_enter)

dispatch(1)

traceExecution()

loadp Callee[cfr], t0

loadp JSCallee::m_scope[t0], t0

loadisFromInstruction(1, t1)

storeq t0, [cfr, t1, 8]

dispatch(2)

traceExecution()

loadisFromInstruction(2, t0)

loadp [cfr, t0, 8], t0

loadp JSFunction::m_rareData[t0], t3

btpz t3, .opCreateThisSlow

loadp FunctionRareData::m_objectAllocationProfile + ObjectAllocationProfile::m_allocator[t3], t1

loadp FunctionRareData::m_objectAllocationProfile + ObjectAllocationProfile::m_structure[t3], t2

btpz t1, .opCreateThisSlow

loadpFromInstruction(4, t3)

bpeq t3, 1, .hasSeenMultipleCallee

bpneq t3, t0, .opCreateThisSlow

allocateJSObject(t1, t2, t0, t3, .opCreateThisSlow)

loadisFromInstruction(1, t1)

storeq t0, [cfr, t1, 8]

dispatch(5)

callSlowPath(_slow_path_create_this)

dispatch(5)

traceExecution()

loadisFromInstruction(1, t0)

loadq [cfr, t0, 8], t0

btqnz t0, tagMask, .opToThisSlow

bbneq JSCell::m_type[t0], FinalObjectType, .opToThisSlow

loadStructureWithScratch(t0, t1, t2)

loadpFromInstruction(2, t2)

bpneq t1, t2, .opToThisSlow

dispatch(4)

callSlowPath(_slow_path_to_this)

dispatch(4)

traceExecution()

loadpFromInstruction(3, t0)

loadp ObjectAllocationProfile::m_allocator[t0], t1

loadp ObjectAllocationProfile::m_structure[t0], t2

allocateJSObject(t1, t2, t0, t3, .opNewObjectSlow)

loadisFromInstruction(1, t1)

storeq t0, [cfr, t1, 8]

dispatch(4)

callSlowPath(_llint_slow_path_new_object)

dispatch(4)

traceExecution()

loadisFromInstruction(1, t0)

loadConstantOrVariable(t0, t1)

bqneq t1, ValueEmpty, .opNotTDZ

callSlowPath(_slow_path_throw_tdz_error)

dispatch(2)

traceExecution()

loadisFromInstruction(2, t1)

loadisFromInstruction(1, t0)

loadConstantOrVariable(t1, t2)

storeq t2, [cfr, t0, 8]

dispatch(3)

traceExecution()

loadisFromInstruction(2, t0)

loadisFromInstruction(1, t1)

loadConstantOrVariable(t0, t2)

xorq ValueFalse, t2

btqnz t2, ~1, .opNotSlow

xorq ValueTrue, t2

storeq t2, [cfr, t1, 8]

dispatch(3)

callSlowPath(_slow_path_not)

dispatch(3)

macro equalityComparison(integerComparison, slowPath)

traceExecution()

loadisFromInstruction(3, t0)

loadisFromInstruction(2, t2)

loadisFromInstruction(1, t3)

loadConstantOrVariableInt32(t0, t1, .slow)

loadConstantOrVariableInt32(t2, t0, .slow)

integerComparison(t0, t1, t0)

orq ValueFalse, t0

storeq t0, [cfr, t3, 8]

dispatch(4)

callSlowPath(slowPath)

dispatch(4)

equalityComparison(

macro (left, right, result) cieq left, right, result end,

_slow_path_eq)

equalityComparison(

macro (left, right, result) cineq left, right, result end,

_slow_path_neq)

macro equalNullComparison()

loadisFromInstruction(2, t0)

loadq [cfr, t0, 8], t0

btqnz t0, tagMask, .immediate

btbnz JSCell::m_flags[t0], MasqueradesAsUndefined, .masqueradesAsUndefined

move 0, t0

jmp .done

loadStructureWithScratch(t0, t2, t1)

loadp CodeBlock[cfr], t0

loadp CodeBlock::m_globalObject[t0], t0

cpeq Structure::m_globalObject[t2], t0, t0

jmp .done

andq ~TagBitUndefined, t0

cqeq t0, ValueNull, t0

traceExecution()

equalNullComparison()

loadisFromInstruction(1, t1)

orq ValueFalse, t0

storeq t0, [cfr, t1, 8]

dispatch(3)

traceExecution()

equalNullComparison()

loadisFromInstruction(1, t1)

xorq ValueTrue, t0

storeq t0, [cfr, t1, 8]

dispatch(3)

macro strictEq(equalityOperation, slowPath)

traceExecution()

loadisFromInstruction(3, t0)

loadisFromInstruction(2, t2)

loadConstantOrVariable(t0, t1)

loadConstantOrVariable(t2, t0)

move t0, t2

orq t1, t2

btqz t2, tagMask, .slow

bqaeq t0, tagTypeNumber, .leftOK

btqnz t0, tagTypeNumber, .slow

bqaeq t1, tagTypeNumber, .rightOK

btqnz t1, tagTypeNumber, .slow

equalityOperation(t0, t1, t0)

loadisFromInstruction(1, t1)

orq ValueFalse, t0

storeq t0, [cfr, t1, 8]

dispatch(4)

callSlowPath(slowPath)

dispatch(4)

strictEq(

macro (left, right, result) cqeq left, right, result end,

_slow_path_stricteq)

strictEq(

macro (left, right, result) cqneq left, right, result end,

_slow_path_nstricteq)

macro preOp(arithmeticOperation, slowPath)

traceExecution()

loadisFromInstruction(1, t0)

loadq [cfr, t0, 8], t1

bqb t1, tagTypeNumber, .slow

arithmeticOperation(t1, .slow)

orq tagTypeNumber, t1

storeq t1, [cfr, t0, 8]

dispatch(2)

callSlowPath(slowPath)

dispatch(2)

preOp(

macro (value, slow) baddio 1, value, slow end,

_slow_path_inc)

preOp(

macro (value, slow) bsubio 1, value, slow end,

_slow_path_dec)

traceExecution()

loadisFromInstruction(2, t0)

loadisFromInstruction(1, t1)

loadConstantOrVariable(t0, t2)

bqaeq t2, tagTypeNumber, .opToNumberIsImmediate

btqz t2, tagTypeNumber, .opToNumberSlow

storeq t2, [cfr, t1, 8]

dispatch(3)

callSlowPath(_slow_path_to_number)

dispatch(3)

traceExecution()

loadisFromInstruction(2, t1)

loadisFromInstruction(1, t2)

loadConstantOrVariable(t1, t0)

btqnz t0, tagMask, .opToStringSlow

bbneq JSCell::m_type[t0], StringType, .opToStringSlow

storeq t0, [cfr, t2, 8]

dispatch(3)

callSlowPath(_slow_path_to_string)

dispatch(3)

traceExecution()

loadisFromInstruction(2, t0)

loadisFromInstruction(1, t1)

loadConstantOrVariable(t0, t2)

bqb t2, tagTypeNumber, .opNegateNotInt

btiz t2, 0x7fffffff, .opNegateSlow

negi t2

orq tagTypeNumber, t2

storeq t2, [cfr, t1, 8]

dispatch(3)

btqz t2, tagTypeNumber, .opNegateSlow

xorq 0x8000000000000000, t2

storeq t2, [cfr, t1, 8]

dispatch(3)

callSlowPath(_slow_path_negate)

dispatch(3)

macro binaryOpCustomStore(integerOperationAndStore, doubleOperation, slowPath)

loadisFromInstruction(3, t0)

loadisFromInstruction(2, t2)

loadConstantOrVariable(t0, t1)

loadConstantOrVariable(t2, t0)

bqb t0, tagTypeNumber, .op1NotInt

bqb t1, tagTypeNumber, .op2NotInt

loadisFromInstruction(1, t2)

integerOperationAndStore(t1, t0, .slow, t2)

dispatch(5)

# First operand is definitely not an int, the second operand could be anything.

btqz t0, tagTypeNumber, .slow

bqaeq t1, tagTypeNumber, .op1NotIntOp2Int

btqz t1, tagTypeNumber, .slow

addq tagTypeNumber, t1

fq2d t1, ft1

jmp .op1NotIntReady

ci2d t1, ft1

loadisFromInstruction(1, t2)

addq tagTypeNumber, t0

fq2d t0, ft0

doubleOperation(ft1, ft0)

fd2q ft0, t0

subq tagTypeNumber, t0

storeq t0, [cfr, t2, 8]

dispatch(5)

# First operand is definitely an int, the second is definitely not.

loadisFromInstruction(1, t2)

btqz t1, tagTypeNumber, .slow

ci2d t0, ft0

addq tagTypeNumber, t1

fq2d t1, ft1

doubleOperation(ft1, ft0)

fd2q ft0, t0

subq tagTypeNumber, t0

storeq t0, [cfr, t2, 8]

dispatch(5)

callSlowPath(slowPath)

dispatch(5)

macro binaryOp(integerOperation, doubleOperation, slowPath)

binaryOpCustomStore(

macro (left, right, slow, index)

integerOperation(left, right, slow)

orq tagTypeNumber, right

storeq right, [cfr, index, 8]

end,

doubleOperation, slowPath)

traceExecution()

binaryOp(

macro (left, right, slow) baddio left, right, slow end,

macro (left, right) addd left, right end,

_slow_path_add)

traceExecution()

binaryOpCustomStore(

macro (left, right, slow, index)

# Assume t3 is scratchable.

move right, t3

bmulio left, t3, slow

btinz t3, .done

bilt left, 0, slow

bilt right, 0, slow

.done:

orq tagTypeNumber, t3

storeq t3, [cfr, index, 8]

end,

macro (left, right) muld left, right end,

_slow_path_mul)

traceExecution()

binaryOp(

macro (left, right, slow) bsubio left, right, slow end,

macro (left, right) subd left, right end,

_slow_path_sub)

traceExecution()

if X86_64 or X86_64_WIN

binaryOpCustomStore(

macro (left, right, slow, index)

# Assume t3 is scratchable.

btiz left, slow

bineq left, -1, .notNeg2TwoThe31DivByNeg1

bieq right, -2147483648, .slow

.notNeg2TwoThe31DivByNeg1:

btinz right, .intOK

bilt left, 0, slow

.intOK:

move left, t3

move right, t0

cdqi

idivi t3

btinz t1, slow

orq tagTypeNumber, t0

storeq t0, [cfr, index, 8]

end,

macro (left, right) divd left, right end,

_slow_path_div)

else

callSlowPath(_slow_path_div)

dispatch(5)

end

macro bitOp(operation, slowPath, advance)

loadisFromInstruction(3, t0)

loadisFromInstruction(2, t2)

loadisFromInstruction(1, t3)

loadConstantOrVariable(t0, t1)

loadConstantOrVariable(t2, t0)

bqb t0, tagTypeNumber, .slow

bqb t1, tagTypeNumber, .slow